shell/source/win32/shlxthandler/prophdl/propertyhdl.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "internal/global.hxx"
  21 #include "internal/propertyhdl.hxx"
  22 #include "internal/fileextensions.hxx"
  23 #include "internal/metainforeader.hxx"
  24 #include "internal/utilities.hxx"
  25 #include "internal/config.hxx"
  26
  27 #include <propkey.h>
  28 #include <propvarutil.h>
  29 #include <sal/macros.h>
  30
  31 #include <malloc.h>
  32 #include <strsafe.h>
  33
  34 #include "internal/stream_helper.hxx"
  35
  36
  37 // Module global
  38
  39 long g_DllRefCnt = 0;
  40 HINSTANCE g_hModule = NULL;
  41
  42 // Map of property keys to the locations of their value(s) in the .??? XML schema
  43 struct PROPERTYMAP
  44 {
  45     PROPERTYKEY key;
  46     PCWSTR pszXPathParent;
  47     PCWSTR pszValueNodeName;
  48 };
  49
  50 PROPERTYMAP g_rgPROPERTYMAP[] =
  51 {
  52     { PKEY_Title,          L"LibreOffice",          L"Title" },
  53     { PKEY_Author,         L"LibreOffice",          L"Author" },
  54     { PKEY_Subject,        L"LibreOffice",          L"Subject" },
  55     { PKEY_Keywords,       L"LibreOffice",          L"Keyword" },
  56     { PKEY_Comment,        L"LibreOffice",          L"Comments" },
  57 };
  58
  59 size_t gPropertyMapTableSize = sizeof(g_rgPROPERTYMAP)/sizeof(g_rgPROPERTYMAP[0]);
  60
  61
  62
  63 CPropertyHdl::CPropertyHdl( long nRefCnt ) :
  64     m_RefCnt( nRefCnt ),
  65     m_pCache( NULL )
  66 {
  67     OutputDebugStringFormat( "CPropertyHdl: CTOR\n" );
  68     InterlockedIncrement( &g_DllRefCnt );
  69 }
  70
  71
  72
  73 CPropertyHdl::~CPropertyHdl()
  74 {
  75     if ( m_pCache )
  76     {
  77         m_pCache->Release();
  78         m_pCache = NULL;
  79     }
  80     InterlockedDecrement( &g_DllRefCnt );
  81 }
  82
  83
  84 // IUnknown methods
  85
  86 HRESULT STDMETHODCALLTYPE CPropertyHdl::QueryInterface(REFIID riid, void __RPC_FAR *__RPC_FAR *ppvObject)
  87 {
  88     *ppvObject = 0;
  89
  90     if (IID_IUnknown == riid || IID_IPropertyStore == riid)
  91     {
  92         OutputDebugStringFormat( "CPropertyHdl: QueryInterface (IID_IPropertyStore)\n" );
  93         IUnknown* pUnk = static_cast<IPropertyStore*>(this);
  94         pUnk->AddRef();
  95         *ppvObject = pUnk;
  96         return S_OK;
  97     }
  98     else if (IID_IPropertyStoreCapabilities == riid)
  99     {
 100         OutputDebugStringFormat( "CPropertyHdl: QueryInterface (IID_IPropertyStoreCapabilities)\n" );
 101         IUnknown* pUnk = static_cast<IPropertyStore*>(this);
 102         pUnk->AddRef();
 103         *ppvObject = pUnk;
 104         return S_OK;
 105     }
 106     else if (IID_IInitializeWithStream == riid)
 107     {
 108         OutputDebugStringFormat( "CPropertyHdl: QueryInterface (IID_IInitializeWithStream)\n" );
 109         IUnknown* pUnk = static_cast<IInitializeWithStream*>(this);
 110         pUnk->AddRef();
 111         *ppvObject = pUnk;
 112         return S_OK;
 113     }
 114     OutputDebugStringFormat( "CPropertyHdl: QueryInterface (something different)\n" );
 115
 116     return E_NOINTERFACE;
 117 }
 118
 119
 120 ULONG STDMETHODCALLTYPE CPropertyHdl::AddRef()
 121 {
 122     return InterlockedIncrement( &m_RefCnt );
 123 }
 124
 125
 126 ULONG STDMETHODCALLTYPE CPropertyHdl::Release()
 127 {
 128     long refcnt = InterlockedDecrement( &m_RefCnt );
 129
 130     if ( 0 == m_RefCnt )
 131         delete this;
 132
 133     return refcnt;
 134 }
 135
 136
 137 // IPropertyStore
 138
 139 HRESULT STDMETHODCALLTYPE CPropertyHdl::GetCount( DWORD *pcProps )
 140 {
 141     HRESULT hr = E_UNEXPECTED;
 142     if ( m_pCache && pcProps )
 143     {
 144         hr = m_pCache->GetCount( pcProps );
 145     }
 146
 147     return hr;
 148 }
 149
 150
 151 HRESULT STDMETHODCALLTYPE CPropertyHdl::GetAt( DWORD iProp, PROPERTYKEY *pKey )
 152 {
 153     HRESULT hr = E_UNEXPECTED;
 154     if ( m_pCache )
 155     {
 156         hr = m_pCache->GetAt( iProp, pKey );
 157     }
 158
 159     return hr;
 160 }
 161
 162
 163 HRESULT STDMETHODCALLTYPE CPropertyHdl::GetValue( REFPROPERTYKEY key, PROPVARIANT *pPropVar )
 164 {
 165     HRESULT hr = E_UNEXPECTED;
 166     if ( m_pCache )
 167     {
 168         hr = m_pCache->GetValue( key, pPropVar );
 169     }
 170
 171     return hr;
 172 }
 173
 174
 175 HRESULT STDMETHODCALLTYPE
 176 CPropertyHdl::SetValue(REFPROPERTYKEY /*key*/, REFPROPVARIANT /*propVar*/)
 177 {
 178     HRESULT hr = E_UNEXPECTED;
 179     if ( m_pCache )
 180     {
 181         hr = STG_E_ACCESSDENIED;
 182     }
 183     return hr;
 184 }
 185
 186
 187 HRESULT STDMETHODCALLTYPE CPropertyHdl::Commit()
 188 {
 189     return S_OK;
 190 }
 191
 192
 193 // IPropertyStore
 194
 195 HRESULT STDMETHODCALLTYPE
 196 CPropertyHdl::IsPropertyWritable(REFPROPERTYKEY /*key*/)
 197 {
 198     // We start with read only properties only
 199     return S_FALSE;
 200 }
 201
 202
 203 // IInitializeWithStream
 204
 205 HRESULT STDMETHODCALLTYPE CPropertyHdl::Initialize( IStream *pStream, DWORD grfMode )
 206 {
 207     if ( grfMode & STGM_READWRITE )
 208         return STG_E_ACCESSDENIED;
 209
 210     if ( !m_pCache )
 211     {
 212 #ifdef __MINGW32__
 213         if ( FAILED( PSCreateMemoryPropertyStore( IID_IPropertyStoreCache, reinterpret_cast<void**>(&m_pCache) ) ) )
 214 #else
 215         if ( FAILED( PSCreateMemoryPropertyStore( IID_PPV_ARGS( &m_pCache ) ) ) )
 216 #endif
 217             OutputDebugStringFormat( "CPropertyHdl::Initialize: PSCreateMemoryPropertyStore failed" );
 218
 219         BufferStream tmpStream(pStream);
 220
 221         CMetaInfoReader *pMetaInfoReader = NULL;
 222
 223         try
 224         {
 225             pMetaInfoReader = new CMetaInfoReader( &tmpStream );
 226             LoadProperties( pMetaInfoReader );
 227             delete pMetaInfoReader;
 228         }
 229         catch (const std::exception& e)
 230         {
 231             OutputDebugStringFormat( "CPropertyHdl::Initialize: Caught exception [%s]", e.what() );
 232             return E_FAIL;
 233         }
 234     }
 235
 236     return S_OK;
 237 }
 238
 239
 240 void CPropertyHdl::LoadProperties( CMetaInfoReader *pMetaInfoReader )
 241 {
 242     OutputDebugStringFormat( "CPropertyHdl: LoadProperties\n" );
 243     PROPVARIANT propvarValues;
 244
 245     for ( UINT i = 0; i < (UINT)gPropertyMapTableSize; ++i )
 246     {
 247         PropVariantClear( &propvarValues );
 248         HRESULT hr = GetItemData( pMetaInfoReader, i, &propvarValues);
 249         if (hr == S_OK)
 250         {
 251             // coerce the value(s) to the appropriate type for the property key
 252             hr = PSCoerceToCanonicalValue( g_rgPROPERTYMAP[i].key, &propvarValues );
 253             if (SUCCEEDED(hr))
 254             {
 255                 // cache the value(s) loaded
 256                 hr = m_pCache->SetValueAndState( g_rgPROPERTYMAP[i].key, &propvarValues, PSC_NORMAL );
 257             }
 258         }
 259     }
 260 }
 261
 262
 263 HRESULT CPropertyHdl::GetItemData( CMetaInfoReader *pMetaInfoReader, UINT nIndex, PROPVARIANT *pVarData )
 264 {
 265     switch (nIndex) {
 266     case 0: {
 267             pVarData->vt = VT_BSTR;
 268             pVarData->bstrVal = SysAllocString( pMetaInfoReader->getTagData( META_INFO_TITLE ).c_str() );
 269             OutputDebugStringFormat( "CPropertyHdl::GetItemData: Title=%S.\n", pMetaInfoReader->getTagData( META_INFO_TITLE ).c_str() );
 270             return S_OK;
 271     }
 272     case 1: {
 273             pVarData->vt = VT_BSTR;
 274             pVarData->bstrVal = SysAllocString( pMetaInfoReader->getTagData( META_INFO_AUTHOR ).c_str() );
 275             OutputDebugStringFormat( "CPropertyHdl::GetItemData: Author=%S.\n", pMetaInfoReader->getTagData( META_INFO_AUTHOR ).c_str() );
 276             return S_OK;
 277     }
 278     case 2: {
 279             pVarData->vt = VT_BSTR;
 280             pVarData->bstrVal = SysAllocString( pMetaInfoReader->getTagData( META_INFO_SUBJECT ).c_str() );
 281             OutputDebugStringFormat( "CPropertyHdl::GetItemData: Subject=%S.\n", pMetaInfoReader->getTagData( META_INFO_SUBJECT ).c_str() );
 282             return S_OK;
 283     }
 284     case 3: {
 285             pVarData->vt = VT_BSTR;
 286             pVarData->bstrVal = SysAllocString( pMetaInfoReader->getTagData( META_INFO_KEYWORDS ).c_str() );
 287             OutputDebugStringFormat( "CPropertyHdl::GetItemData: Keywords=%S.\n", pMetaInfoReader->getTagData( META_INFO_KEYWORDS ).c_str() );
 288             return S_OK;
 289     }
 290     case 4: {
 291             pVarData->vt = VT_BSTR;
 292             pVarData->bstrVal = SysAllocString( pMetaInfoReader->getTagData( META_INFO_DESCRIPTION ).c_str() );
 293             OutputDebugStringFormat( "CPropertyHdl::GetItemData: Description=%S.\n", pMetaInfoReader->getTagData( META_INFO_DESCRIPTION ).c_str() );
 294             return S_OK;
 295     }
 296     case 5: {
 297             pVarData->vt = VT_BSTR;
 298             pVarData->bstrVal = SysAllocString( pMetaInfoReader->getTagAttribute( META_INFO_DOCUMENT_STATISTIC, META_INFO_PAGES ).c_str() );
 299             OutputDebugStringFormat( "CPropertyHdl::GetItemData: Pages=%S.\n", pMetaInfoReader->getTagAttribute( META_INFO_DOCUMENT_STATISTIC, META_INFO_PAGES ).c_str() );
 300             return S_OK;
 301     }
 302     }
 303
 304     return S_FALSE;
 305 }
 306
 307
 308 //                              CClassFactory
 309
 310
 311 long CClassFactory::s_ServerLocks = 0;
 312
 313
 314 CClassFactory::CClassFactory( const CLSID& clsid ) :
 315     m_RefCnt(1),
 316     m_Clsid(clsid)
 317 {
 318     InterlockedIncrement( &g_DllRefCnt );
 319 }
 320
 321
 322 CClassFactory::~CClassFactory()
 323 {
 324     InterlockedDecrement( &g_DllRefCnt );
 325 }
 326
 327
 328 //                              IUnknown methods
 329
 330 HRESULT STDMETHODCALLTYPE CClassFactory::QueryInterface( REFIID riid, void __RPC_FAR *__RPC_FAR *ppvObject )
 331 {
 332     *ppvObject = 0;
 333
 334     if ( IID_IUnknown == riid || IID_IClassFactory == riid )
 335     {
 336         IUnknown* pUnk = this;
 337         pUnk->AddRef();
 338         *ppvObject = pUnk;
 339         return S_OK;
 340     }
 341
 342     return E_NOINTERFACE;
 343 }
 344
 345
 346 ULONG STDMETHODCALLTYPE CClassFactory::AddRef()
 347 {
 348     return InterlockedIncrement( &m_RefCnt );
 349 }
 350
 351
 352 ULONG STDMETHODCALLTYPE CClassFactory::Release()
 353 {
 354     long refcnt = InterlockedDecrement( &m_RefCnt );
 355
 356     if (0 == refcnt)
 357         delete this;
 358
 359     return refcnt;
 360 }
 361
 362
 363 //                          IClassFactory methods
 364
 365 HRESULT STDMETHODCALLTYPE CClassFactory::CreateInstance(
 366             IUnknown __RPC_FAR *pUnkOuter,
 367             REFIID riid,
 368             void __RPC_FAR *__RPC_FAR *ppvObject)
 369 {
 370     if ( pUnkOuter != NULL )
 371         return CLASS_E_NOAGGREGATION;
 372
 373     IUnknown* pUnk = 0;
 374
 375     if ( CLSID_PROPERTY_HANDLER == m_Clsid )
 376         pUnk = static_cast<IPropertyStore*>( new CPropertyHdl() );
 377
 378     if (0 == pUnk)
 379     {
 380         return E_OUTOFMEMORY;
 381     }
 382
 383     HRESULT hr = pUnk->QueryInterface( riid, ppvObject );
 384
 385     // if QueryInterface failed the component will destroy itself
 386     pUnk->Release();
 387
 388     return hr;
 389 }
 390
 391
 392 HRESULT STDMETHODCALLTYPE CClassFactory::LockServer( BOOL fLock )
 393 {
 394     if ( fLock )
 395         InterlockedIncrement( &s_ServerLocks );
 396     else
 397         InterlockedDecrement( &s_ServerLocks );
 398
 399     return S_OK;
 400 }
 401
 402
 403 bool CClassFactory::IsLocked()
 404 {
 405     return ( s_ServerLocks > 0 );
 406 }
 407
 408
 409 extern "C" STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void** ppv)
 410 {
 411     OutputDebugStringFormat( "DllGetClassObject.\n" );
 412     *ppv = 0;
 413
 414     if ( rclsid != CLSID_PROPERTY_HANDLER )
 415         return CLASS_E_CLASSNOTAVAILABLE;
 416
 417     if ( (riid != IID_IUnknown) && (riid != IID_IClassFactory) )
 418         return E_NOINTERFACE;
 419
 420     IUnknown* pUnk = new CClassFactory( rclsid );
 421     *ppv = pUnk;
 422     return S_OK;
 423 }
 424
 425
 426 extern "C" STDAPI DllCanUnloadNow()
 427 {
 428     OutputDebugStringFormat( "DllCanUnloadNow.\n" );
 429     if (CClassFactory::IsLocked() || g_DllRefCnt > 0)
 430         return S_FALSE;
 431
 432     return S_OK;
 433 }
 434
 435
 436 BOOL WINAPI DllMain( HINSTANCE hInst, ULONG /*ul_reason_for_call*/, LPVOID /*lpReserved*/ )
 437 {
 438     OutputDebugStringFormat( "DllMain.\n" );
 439     g_hModule = hInst;
 440     return TRUE;
 441 }
 442
 443 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */