1 files changed, 432 insertions, 0 deletions
diff --git a/shell/source/win32/shlxthandler/prophdl/propertyhdl.cxx b/shell/source/win32/shlxthandler/prophdl/propertyhdl.cxx
new file mode 100644
index 000000000..49a8b8d06
--- /dev/null
+++ b/shell/source/win32/shlxthandler/prophdl/propertyhdl.cxx
@@ -0,0 +1,432 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <global.hxx>
+#include <propertyhdl.hxx>
+#include <fileextensions.hxx>
+#include <metainforeader.hxx>
+#include <utilities.hxx>
+#include <config.hxx>
+
+#include <propkey.h>
+#include <propvarutil.h>
+#include <sal/macros.h>
+
+#include <malloc.h>
+#include <strsafe.h>
+
+#include <stream_helper.hxx>
+
+
+// Module global
+
+LONG g_DllRefCnt = 0;
+static HINSTANCE g_hModule = nullptr;
+
+const PROPERTYKEY g_rgPROPERTIES[] =
+{
+    PKEY_Title,
+    PKEY_Author,
+    PKEY_Subject,
+    PKEY_Keywords,
+    PKEY_Comment
+};
+
+size_t const gPropertyTableSize = SAL_N_ELEMENTS(g_rgPROPERTIES);
+
+
+CPropertyHdl::CPropertyHdl( LONG nRefCnt ) :
+    m_RefCnt( nRefCnt ),
+    m_pCache( nullptr )
+{
+    OutputDebugStringFormatW( L"CPropertyHdl: CTOR\n" );
+    InterlockedIncrement( &g_DllRefCnt );
+}
+
+
+CPropertyHdl::~CPropertyHdl()
+{
+    if ( m_pCache )
+    {
+        m_pCache->Release();
+        m_pCache = nullptr;
+    }
+    InterlockedDecrement( &g_DllRefCnt );
+}
+
+
+// IUnknown methods
+
+HRESULT STDMETHODCALLTYPE CPropertyHdl::QueryInterface(REFIID riid, void __RPC_FAR *__RPC_FAR *ppvObject)
+{
+    *ppvObject = nullptr;
+
+    if (IID_IUnknown == riid || IID_IPropertyStore == riid)
+    {
+        OutputDebugStringFormatW( L"CPropertyHdl: QueryInterface (IID_IPropertyStore)\n" );
+        IUnknown* pUnk = static_cast<IPropertyStore*>(this);
+        pUnk->AddRef();
+        *ppvObject = pUnk;
+        return S_OK;
+    }
+    else if (IID_IPropertyStoreCapabilities == riid)
+    {
+        OutputDebugStringFormatW( L"CPropertyHdl: QueryInterface (IID_IPropertyStoreCapabilities)\n" );
+        IUnknown* pUnk = static_cast<IPropertyStore*>(this);
+        pUnk->AddRef();
+        *ppvObject = pUnk;
+        return S_OK;
+    }
+    else if (IID_IInitializeWithStream == riid)
+    {
+        OutputDebugStringFormatW( L"CPropertyHdl: QueryInterface (IID_IInitializeWithStream)\n" );
+        IUnknown* pUnk = static_cast<IInitializeWithStream*>(this);
+        pUnk->AddRef();
+        *ppvObject = pUnk;
+        return S_OK;
+    }
+    OutputDebugStringFormatW( L"CPropertyHdl: QueryInterface (something different)\n" );
+
+    return E_NOINTERFACE;
+}
+
+
+ULONG STDMETHODCALLTYPE CPropertyHdl::AddRef()
+{
+    return InterlockedIncrement( &m_RefCnt );
+}
+
+
+ULONG STDMETHODCALLTYPE CPropertyHdl::Release()
+{
+    LONG refcnt = InterlockedDecrement( &m_RefCnt );
+
+    if ( 0 == m_RefCnt )
+        delete this;
+
+    return refcnt;
+}
+
+
+// IPropertyStore
+
+HRESULT STDMETHODCALLTYPE CPropertyHdl::GetCount( DWORD *pcProps )
+{
+    HRESULT hr = E_UNEXPECTED;
+    if ( m_pCache && pcProps )
+    {
+        hr = m_pCache->GetCount( pcProps );
+    }
+
+    return hr;
+}
+
+
+HRESULT STDMETHODCALLTYPE CPropertyHdl::GetAt( DWORD iProp, PROPERTYKEY *pKey )
+{
+    HRESULT hr = E_UNEXPECTED;
+    if ( m_pCache )
+    {
+        hr = m_pCache->GetAt( iProp, pKey );
+    }
+
+    return hr;
+}
+
+
+HRESULT STDMETHODCALLTYPE CPropertyHdl::GetValue( REFPROPERTYKEY key, PROPVARIANT *pPropVar )
+{
+    HRESULT hr = E_UNEXPECTED;
+    if ( m_pCache )
+    {
+        hr = m_pCache->GetValue( key, pPropVar );
+    }
+
+    return hr;
+}
+
+
+HRESULT STDMETHODCALLTYPE
+CPropertyHdl::SetValue(REFPROPERTYKEY /*key*/, REFPROPVARIANT /*propVar*/)
+{
+    HRESULT hr = E_UNEXPECTED;
+    if ( m_pCache )
+    {
+        hr = STG_E_ACCESSDENIED;
+    }
+    return hr;
+}
+
+
+HRESULT STDMETHODCALLTYPE CPropertyHdl::Commit()
+{
+    return S_OK;
+}
+
+
+// IPropertyStore
+
+HRESULT STDMETHODCALLTYPE
+CPropertyHdl::IsPropertyWritable(REFPROPERTYKEY /*key*/)
+{
+    // We start with read only properties only
+    return S_FALSE;
+}
+
+
+// IInitializeWithStream
+
+HRESULT STDMETHODCALLTYPE CPropertyHdl::Initialize( IStream *pStream, DWORD grfMode )
+{
+    if ( grfMode & STGM_READWRITE )
+        return STG_E_ACCESSDENIED;
+
+    if ( !m_pCache )
+    {
+        if ( FAILED( PSCreateMemoryPropertyStore( IID_PPV_ARGS( &m_pCache ) ) ) )
+            OutputDebugStringFormatW( L"CPropertyHdl::Initialize: PSCreateMemoryPropertyStore failed" );
+
+        BufferStream tmpStream(pStream);
+
+        CMetaInfoReader *pMetaInfoReader = nullptr;
+
+        try
+        {
+            pMetaInfoReader = new CMetaInfoReader( &tmpStream );
+            LoadProperties( pMetaInfoReader );
+            delete pMetaInfoReader;
+        }
+        catch (const std::exception& e)
+        {
+            // To output 8-bit string using unicode version of formatting functions, use capital %S type
+            // see https://msdn.microsoft.com/en-us/library/hf4y5e3w
+            OutputDebugStringFormatW( L"CPropertyHdl::Initialize: Caught exception [%S]", e.what() );
+            return E_FAIL;
+        }
+    }
+
+    return S_OK;
+}
+
+namespace {
+
+HRESULT GetItemData( CMetaInfoReader *pMetaInfoReader, UINT nIndex, PROPVARIANT *pVarData )
+{
+    switch (nIndex) {
+    case 0: {
+            pVarData->vt = VT_BSTR;
+            pVarData->bstrVal = SysAllocString( pMetaInfoReader->getTagData( META_INFO_TITLE ).c_str() );
+            OutputDebugStringFormatW( L"CPropertyHdl::GetItemData: Title=%s.\n", pMetaInfoReader->getTagData( META_INFO_TITLE ).c_str() );
+            return S_OK;
+    }
+    case 1: {
+            pVarData->vt = VT_BSTR;
+            pVarData->bstrVal = SysAllocString( pMetaInfoReader->getTagData( META_INFO_AUTHOR ).c_str() );
+            OutputDebugStringFormatW( L"CPropertyHdl::GetItemData: Author=%s.\n", pMetaInfoReader->getTagData( META_INFO_AUTHOR ).c_str() );
+            return S_OK;
+    }
+    case 2: {
+            pVarData->vt = VT_BSTR;
+            pVarData->bstrVal = SysAllocString( pMetaInfoReader->getTagData( META_INFO_SUBJECT ).c_str() );
+            OutputDebugStringFormatW( L"CPropertyHdl::GetItemData: Subject=%s.\n", pMetaInfoReader->getTagData( META_INFO_SUBJECT ).c_str() );
+            return S_OK;
+    }
+    case 3: {
+            pVarData->vt = VT_BSTR;
+            pVarData->bstrVal = SysAllocString( pMetaInfoReader->getTagData( META_INFO_KEYWORDS ).c_str() );
+            OutputDebugStringFormatW( L"CPropertyHdl::GetItemData: Keywords=%s.\n", pMetaInfoReader->getTagData( META_INFO_KEYWORDS ).c_str() );
+            return S_OK;
+    }
+    case 4: {
+            pVarData->vt = VT_BSTR;
+            pVarData->bstrVal = SysAllocString( pMetaInfoReader->getTagData( META_INFO_DESCRIPTION ).c_str() );
+            OutputDebugStringFormatW( L"CPropertyHdl::GetItemData: Description=%s.\n", pMetaInfoReader->getTagData( META_INFO_DESCRIPTION ).c_str() );
+            return S_OK;
+    }
+    case 5: {
+            pVarData->vt = VT_BSTR;
+            pVarData->bstrVal = SysAllocString( pMetaInfoReader->getTagAttribute( META_INFO_DOCUMENT_STATISTIC, META_INFO_PAGES ).c_str() );
+            OutputDebugStringFormatW( L"CPropertyHdl::GetItemData: Pages=%s.\n", pMetaInfoReader->getTagAttribute( META_INFO_DOCUMENT_STATISTIC, META_INFO_PAGES ).c_str() );
+            return S_OK;
+    }
+    }
+
+    return S_FALSE;
+}
+
+}
+
+void CPropertyHdl::LoadProperties( CMetaInfoReader *pMetaInfoReader )
+{
+    OutputDebugStringFormatW( L"CPropertyHdl: LoadProperties\n" );
+    PROPVARIANT propvarValues;
+
+    for ( UINT i = 0; i < UINT(gPropertyTableSize); ++i )
+    {
+        PropVariantClear( &propvarValues );
+        HRESULT hr = GetItemData( pMetaInfoReader, i, &propvarValues);
+        if (hr == S_OK)
+        {
+            // coerce the value(s) to the appropriate type for the property key
+            hr = PSCoerceToCanonicalValue( g_rgPROPERTIES[i], &propvarValues );
+            if (SUCCEEDED(hr))
+            {
+                // cache the value(s) loaded
+                hr = m_pCache->SetValueAndState( g_rgPROPERTIES[i], &propvarValues, PSC_NORMAL );
+            }
+        }
+    }
+}
+
+//                              CClassFactory
+
+
+LONG CClassFactory::s_ServerLocks = 0;
+
+
+CClassFactory::CClassFactory( const CLSID& clsid ) :
+    m_RefCnt(1),
+    m_Clsid(clsid)
+{
+    InterlockedIncrement( &g_DllRefCnt );
+}
+
+
+CClassFactory::~CClassFactory()
+{
+    InterlockedDecrement( &g_DllRefCnt );
+}
+
+
+//                              IUnknown methods
+
+HRESULT STDMETHODCALLTYPE CClassFactory::QueryInterface( REFIID riid, void __RPC_FAR *__RPC_FAR *ppvObject )
+{
+    *ppvObject = nullptr;
+
+    if ( IID_IUnknown == riid || IID_IClassFactory == riid )
+    {
+        IUnknown* pUnk = this;
+        pUnk->AddRef();
+        *ppvObject = pUnk;
+        return S_OK;
+    }
+
+    return E_NOINTERFACE;
+}
+
+
+ULONG STDMETHODCALLTYPE CClassFactory::AddRef()
+{
+    return InterlockedIncrement( &m_RefCnt );
+}
+
+
+ULONG STDMETHODCALLTYPE CClassFactory::Release()
+{
+    LONG refcnt = InterlockedDecrement( &m_RefCnt );
+
+    if (0 == refcnt)
+        delete this;
+
+    return refcnt;
+}
+
+
+//                          IClassFactory methods
+
+HRESULT STDMETHODCALLTYPE CClassFactory::CreateInstance(
+            IUnknown __RPC_FAR *pUnkOuter,
+            REFIID riid,
+            void __RPC_FAR *__RPC_FAR *ppvObject)
+{
+    if ( pUnkOuter != nullptr )
+        return CLASS_E_NOAGGREGATION;
+
+    IUnknown* pUnk = nullptr;
+
+    if ( CLSID_PROPERTY_HANDLER == m_Clsid )
+        pUnk = static_cast<IPropertyStore*>( new CPropertyHdl() );
+
+    if (nullptr == pUnk)
+    {
+        return E_OUTOFMEMORY;
+    }
+
+    HRESULT hr = pUnk->QueryInterface( riid, ppvObject );
+
+    // if QueryInterface failed the component will destroy itself
+    pUnk->Release();
+
+    return hr;
+}
+
+
+HRESULT STDMETHODCALLTYPE CClassFactory::LockServer( BOOL fLock )
+{
+    if ( fLock )
+        InterlockedIncrement( &s_ServerLocks );
+    else
+        InterlockedDecrement( &s_ServerLocks );
+
+    return S_OK;
+}
+
+
+bool CClassFactory::IsLocked()
+{
+    return ( s_ServerLocks > 0 );
+}
+
+
+STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv)
+{
+    OutputDebugStringFormatW( L"DllGetClassObject.\n" );
+    *ppv = nullptr;
+
+    if ( rclsid != CLSID_PROPERTY_HANDLER )
+        return CLASS_E_CLASSNOTAVAILABLE;
+
+    if ( (riid != IID_IUnknown) && (riid != IID_IClassFactory) )
+        return E_NOINTERFACE;
+
+    IUnknown* pUnk = new CClassFactory( rclsid );
+    *ppv = pUnk;
+    return S_OK;
+}
+
+
+STDAPI DllCanUnloadNow()
+{
+    OutputDebugStringFormatW( L"DllCanUnloadNow.\n" );
+    if (CClassFactory::IsLocked() || g_DllRefCnt > 0)
+        return S_FALSE;
+
+    return S_OK;
+}
+
+
+BOOL WINAPI DllMain( HINSTANCE hInst, ULONG /*ul_reason_for_call*/, LPVOID /*lpReserved*/ )
+{
+    OutputDebugStringFormatW( L"DllMain.\n" );
+    g_hModule = hInst;
+    return TRUE;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */