fpicker/source/win32/folderpicker/MtaFop.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: MtaFop.cxx,v $
  10  * $Revision: 1.17 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_fpicker.hxx"
  33 #include <osl/diagnose.h>
  34 #include <osl/conditn.hxx>
  35
  36 #include "MtaFop.hxx"
  37 #include <wchar.h>
  38 #include <process.h>
  39 #include "..\misc\resourceprovider.hxx"
  40
  41 #include <systools/win32/comtools.hxx>
  42
  43 using rtl::OUString;
  44 using osl::Condition;
  45
  46 const sal_uInt32 MSG_BROWSEFORFOLDER = WM_USER + 1;
  47 const sal_uInt32 MSG_SHUTDOWN        = WM_USER + 2;
  48
  49 const sal_uInt32 MAX_WAITTIME            = 2000; // msec
  50
  51 const sal_Bool MANUAL_RESET     = sal_True;
  52 const sal_Bool AUTO_RESET       = sal_False;
  53 const sal_Bool INIT_NONSIGNALED = sal_False;
  54
  55 typedef sal::systools::COMReference<IMalloc> IMallocPtr;
  56 typedef sal::systools::COMReference<IShellFolder> IShellFolderPtr;
  57
  58 namespace
  59 {
  60     const char* FOLDERPICKER_SRV_DLL_NAME = "fop.dll";
  61     const char g_szWndClsName[]                   = "FopStaReqWnd###";
  62     const char* CURRENT_INSTANCE          = "CurrInst";
  63
  64     typedef struct _RequestContext
  65     {
  66         HANDLE   hEvent;
  67         sal_Bool bRet;
  68     } RequestContext;
  69
  70     inline sal_Bool InitializeRequestContext( RequestContext* aRequestContext )
  71     {
  72         OSL_ASSERT( aRequestContext );
  73
  74         aRequestContext->hEvent = CreateEventA(
  75             0, AUTO_RESET, INIT_NONSIGNALED, NULL );
  76
  77         aRequestContext->bRet = sal_False;
  78
  79         return ( 0 != aRequestContext->hEvent );
  80     }
  81
  82     inline void DeinitializeRequestContext( RequestContext* aRequestContext )
  83     {
  84         OSL_ASSERT( aRequestContext && aRequestContext->hEvent );
  85         CloseHandle( aRequestContext->hEvent );
  86     }
  87
  88     //-------------------------------
  89     // Determine if current thread is
  90     // an MTA or STA thread
  91     //-------------------------------
  92     bool IsMTA()
  93     {
  94         HRESULT hr = CoInitialize(NULL);
  95
  96         if (RPC_E_CHANGED_MODE == hr)
  97             return true;
  98
  99         if(SUCCEEDED(hr))
 100             CoUninitialize();
 101
 102         return false;
 103     }
 104 }
 105
 106 //----------------------------------------------------------------
 107 //      static member initialization
 108 //----------------------------------------------------------------
 109
 110 ATOM CMtaFolderPicker::s_ClassAtom = 0;
 111 osl::Mutex CMtaFolderPicker::s_Mutex;
 112 sal_Int32 CMtaFolderPicker::s_StaRequestWndRegisterCount = 0;
 113
 114 //--------------------------------------------------------------------
 115 // ctor
 116 //--------------------------------------------------------------------
 117
 118 CMtaFolderPicker::CMtaFolderPicker( sal_uInt32 Flags ) :
 119     m_hStaThread( NULL ),
 120     m_uStaThreadId( 0 ),
 121     m_hEvtThrdReady( NULL ),
 122     m_hwndStaRequestWnd( NULL )
 123 {
 124     m_hInstance = GetModuleHandleA( FOLDERPICKER_SRV_DLL_NAME );
 125     OSL_ENSURE( m_hInstance, "The name of the FolderPicker service dll must have changed" );
 126
 127     ZeroMemory( &m_bi, sizeof( m_bi ) );
 128
 129     // !!!!!!!!!!!!!!!!!  IMPORTANT !!!!!!!!!!!!!!!!!!!
 130     //
 131     // Remember: This HACK prevents you from stepping
 132     // through your code in the debugger because if you
 133     // set a break point in the ctor here the debugger
 134     // may become the owner of the FolderBrowse dialog
 135     // and so it seems that the Visual Studio and the
 136     // office are hanging
 137     m_bi.hwndOwner = GetForegroundWindow( );
 138
 139     /*
 140         Flag                            Available
 141         --------------------------------
 142         BIF_EDITBOX                     Version 4.71
 143         BIF_NEWDIALOGSTYLE      Version 5.0
 144         BIF_SHAREABLE           Version 5.0
 145         BIF_VALIDATE            Version 4.71
 146
 147         Version 4.71 - Internet Explorer 4.0
 148         Version 5.0      - Internet Explorer 5.0
 149                        Windows 2000
 150     */
 151     m_bi.ulFlags = Flags;
 152
 153     m_bi.lpfn    = CMtaFolderPicker::FolderPickerCallback;
 154     m_bi.lParam  = reinterpret_cast< LPARAM >( this );
 155
 156     //---------------------------------------
 157     // read the default strings for title and
 158     // description from a resource file
 159
 160     CResourceProvider ResProvider;
 161
 162     m_dialogTitle = ResProvider.getResString( 500 );
 163     m_Description = ResProvider.getResString( 501 );
 164
 165     // signals that the thread was successfully set up
 166     m_hEvtThrdReady  = CreateEventA(
 167         0,
 168         MANUAL_RESET,
 169         INIT_NONSIGNALED,
 170         NULL );
 171
 172     if ( m_hEvtThrdReady )
 173     {
 174         // setup the sta thread
 175         m_hStaThread = (HANDLE)_beginthreadex(
 176             NULL,
 177             0,
 178             CMtaFolderPicker::StaThreadProc,
 179             this,
 180             0,
 181             &m_uStaThreadId );
 182
 183         OSL_ASSERT( m_hStaThread );
 184     }
 185
 186     OSL_ASSERT( m_hEvtThrdReady );
 187 }
 188
 189 //--------------------------------------------------------------------
 190 // dtor
 191 //--------------------------------------------------------------------
 192
 193 CMtaFolderPicker::~CMtaFolderPicker( )
 194 {
 195     // only if the is a valid event handle
 196     // there may also be a thread a hidden
 197     // target request window and so on
 198     // see ctor
 199     if ( m_hEvtThrdReady )
 200     {
 201         // block calling threads because we
 202         // are about to shutdown
 203         ResetEvent( m_hEvtThrdReady );
 204
 205         // force the destruction of the sta thread request window
 206         // and the end of the thread
 207         // remeber: DestroyWindow may only be called from within
 208         // the thread that created the window
 209         if ( IsWindow( m_hwndStaRequestWnd ) )
 210         {
 211             SendMessageA( m_hwndStaRequestWnd, MSG_SHUTDOWN, 0, 0 );
 212
 213             // we place unregister class here because
 214             // if we have a valid window we must have
 215             // sucessfully registered a window class
 216             // if the creation of the window itself
 217             // failed after registering the window
 218             // class we have unregistered it immediately
 219             // in createStaRequestWindow below
 220             UnregisterStaRequestWindowClass( );
 221         }
 222
 223         if ( m_hStaThread )
 224         {
 225             // wait for thread shutdown
 226             sal_uInt32 dwResult = WaitForSingleObject( m_hStaThread, MAX_WAITTIME );
 227             OSL_ENSURE( dwResult == WAIT_OBJECT_0, "sta thread could not terminate" );
 228
 229             // terminate the thread if it
 230             // doesn't shutdown itself
 231             if ( WAIT_OBJECT_0 != dwResult )
 232                 TerminateThread(
 233                     m_hStaThread, sal::static_int_cast< DWORD >(-1) );
 234
 235             CloseHandle( m_hStaThread );
 236         }
 237
 238         CloseHandle( m_hEvtThrdReady );
 239     }
 240 }
 241
 242 //--------------------------------------------------------------------
 243 //
 244 //--------------------------------------------------------------------
 245
 246 sal_Bool CMtaFolderPicker::browseForFolder( )
 247 {
 248     sal_Bool bRet = sal_False;
 249
 250     if (IsMTA())
 251     {
 252
 253         OSL_ASSERT( m_hEvtThrdReady );
 254
 255         if ( WaitForSingleObject( m_hEvtThrdReady, MAX_WAITTIME ) != WAIT_OBJECT_0 )
 256         {
 257             OSL_ENSURE( sal_False, "sta thread not ready" );
 258             return sal_False;
 259         }
 260
 261         RequestContext aReqCtx;
 262
 263         if ( !InitializeRequestContext( &aReqCtx ) )
 264         {
 265             OSL_ASSERT( sal_False );
 266             return sal_False;
 267         }
 268
 269         // marshall request into the sta thread
 270         PostMessageA(
 271             m_hwndStaRequestWnd,
 272             MSG_BROWSEFORFOLDER,
 273             0,
 274             reinterpret_cast< LPARAM >( &aReqCtx ) );
 275
 276         // waiting for the event to be signaled or
 277         // window messages so that we don't block
 278         // our parent window
 279
 280         sal_Bool bContinue = sal_True;
 281
 282         while ( bContinue )
 283         {
 284             DWORD dwResult = MsgWaitForMultipleObjects(
 285                 1, &aReqCtx.hEvent, FALSE, INFINITE, QS_ALLEVENTS );
 286
 287             switch ( dwResult )
 288             {
 289             // the request context event is signaled
 290             case WAIT_OBJECT_0:
 291                 bContinue = sal_False;
 292                 break;
 293
 294             // a window message has arrived
 295             case WAIT_OBJECT_0 + 1:
 296                 {
 297                     // dispatching all messages but we expect to
 298                     // receive only paint or timer messages that's
 299                     // why we don't need to call TranslateMessage or
 300                     // TranslateAccelerator, because keybord or
 301                     // mouse messages are for the FolderPicker which
 302                     // is in the foreground and should not arrive here
 303                     MSG msg;
 304                     while ( PeekMessageA( &msg, NULL, 0, 0, PM_REMOVE ) )
 305                         DispatchMessageA(&msg);
 306                 }
 307                 break;
 308
 309             // should not happen
 310             default:
 311                 OSL_ASSERT( sal_False );
 312             }
 313         }
 314
 315         /*sal_Bool*/ bRet = aReqCtx.bRet;
 316         DeinitializeRequestContext( &aReqCtx );
 317     }
 318     else
 319     {
 320         bRet = onBrowseForFolder();
 321     }
 322
 323     return bRet;
 324 }
 325
 326 //--------------------------------------------------------------------
 327 //
 328 //--------------------------------------------------------------------
 329
 330 void SAL_CALL CMtaFolderPicker::setDisplayDirectory( const OUString& aDirectory )
 331 {
 332     m_displayDir = aDirectory;
 333 }
 334
 335 //--------------------------------------------------------------------
 336 //
 337 //--------------------------------------------------------------------
 338
 339 OUString SAL_CALL CMtaFolderPicker::getDisplayDirectory( )
 340 {
 341     return m_displayDir;
 342 }
 343
 344 //--------------------------------------------------------------------
 345 //
 346 //--------------------------------------------------------------------
 347
 348 OUString SAL_CALL CMtaFolderPicker::getDirectory( )
 349 {
 350     return m_SelectedDir;
 351 }
 352
 353 //--------------------------------------------------------------------
 354 //
 355 //--------------------------------------------------------------------
 356
 357 void SAL_CALL CMtaFolderPicker::setDescription( const rtl::OUString& aDescription )
 358 {
 359     m_Description = aDescription;
 360 }
 361
 362 //--------------------------------------------------------------------
 363 //
 364 //--------------------------------------------------------------------
 365
 366 void SAL_CALL CMtaFolderPicker::setTitle( const OUString& aTitle )
 367 {
 368     m_dialogTitle = aTitle;
 369 }
 370
 371 //--------------------------------------------------------------------
 372 //
 373 //--------------------------------------------------------------------
 374
 375 OUString SAL_CALL CMtaFolderPicker::getTitle( )
 376 {
 377     return m_dialogTitle;
 378 }
 379
 380 //-----------------------------------------------------
 381 // XCancellable
 382 //-----------------------------------------------------
 383
 384 void SAL_CALL CMtaFolderPicker::cancel( )
 385 {
 386     if ( IsWindow( m_hwnd ) )
 387     {
 388         // simulate a mouse click to the
 389         // cancel button
 390         PostMessageA(
 391             m_hwnd,
 392             WM_COMMAND,
 393             MAKEWPARAM( IDCANCEL, BN_CLICKED ),
 394             (LPARAM)GetDlgItem( m_hwnd, IDCANCEL ) );
 395     }
 396 }
 397
 398 //--------------------------------------------------------------------
 399 //
 400 //--------------------------------------------------------------------
 401
 402 sal_Bool SAL_CALL CMtaFolderPicker::onBrowseForFolder( )
 403 {
 404     sal_Bool     bRet;
 405     LPITEMIDLIST lpiid;
 406
 407     // pre SHBrowseFroFolder
 408
 409     m_bi.pidlRoot       = 0;
 410     m_bi.pszDisplayName = reinterpret_cast<LPWSTR>(m_pathBuff.get());
 411
 412     if ( m_Description.getLength( ) )
 413         m_bi.lpszTitle = reinterpret_cast<LPCWSTR>(m_Description.getStr( ));
 414
 415     lpiid = SHBrowseForFolderW( &m_bi );
 416     bRet = ( NULL != lpiid );
 417
 418     // post SHBrowseForFolder
 419
 420     m_SelectedDir = getPathFromItemIdList( lpiid );
 421     releaseItemIdList( lpiid );
 422
 423     return bRet;
 424 }
 425
 426 //--------------------------------------------------------------------
 427 //
 428 //--------------------------------------------------------------------
 429
 430 void SAL_CALL CMtaFolderPicker::releaseItemIdList( LPITEMIDLIST lpItemIdList )
 431 {
 432     IMallocPtr pIMalloc;
 433     SHGetMalloc(&pIMalloc);
 434     if (pIMalloc.is())
 435     {
 436         pIMalloc->Free(lpItemIdList);
 437         lpItemIdList = NULL;
 438     }
 439 }
 440
 441 //--------------------------------------------------------------------
 442 //
 443 //--------------------------------------------------------------------
 444
 445 LPITEMIDLIST SAL_CALL CMtaFolderPicker::getItemIdListFromPath( const rtl::OUString& aDirectory )
 446 {
 447     // parameter checking
 448     if ( !aDirectory.getLength( ) )
 449         return NULL;
 450
 451     LPITEMIDLIST lpItemIdList(NULL);
 452
 453     IShellFolderPtr pIShellFolder;
 454     SHGetDesktopFolder(&pIShellFolder);
 455
 456     if (pIShellFolder.is())
 457     {
 458         pIShellFolder->ParseDisplayName(
 459             NULL,
 460             NULL,
 461             reinterpret_cast<LPWSTR>(const_cast< sal_Unicode* >( aDirectory.getStr( ) )),
 462             NULL,
 463             &lpItemIdList,
 464             NULL );
 465     }
 466
 467     return lpItemIdList;
 468 }
 469
 470 //--------------------------------------------------------------------
 471 //
 472 //--------------------------------------------------------------------
 473
 474 OUString SAL_CALL CMtaFolderPicker::getPathFromItemIdList( LPCITEMIDLIST lpItemIdList )
 475 {
 476     OUString path;
 477
 478     if ( lpItemIdList )
 479     {
 480         bool bRet = SHGetPathFromIDListW( lpItemIdList, reinterpret_cast<LPWSTR>(m_pathBuff.get()) );
 481         if ( bRet )
 482             path = m_pathBuff.get( );
 483     }
 484
 485     return path;
 486 }
 487
 488 //--------------------------------------------------------------------
 489 //
 490 //--------------------------------------------------------------------
 491
 492 void SAL_CALL CMtaFolderPicker::enableOk( sal_Bool bEnable )
 493 {
 494     OSL_ASSERT( IsWindow( m_hwnd ) );
 495
 496     SendMessageW(
 497         m_hwnd,
 498         BFFM_ENABLEOK,
 499         static_cast< WPARAM >( 0 ),
 500         static_cast< LPARAM >( bEnable ) );
 501 }
 502
 503 //--------------------------------------------------------------------
 504 //
 505 //--------------------------------------------------------------------
 506
 507 void SAL_CALL CMtaFolderPicker::setSelection( const rtl::OUString& aDirectory )
 508 {
 509     OSL_ASSERT( IsWindow( m_hwnd ) );
 510
 511 #ifdef _MSC_VER
 512 #pragma message( "#######################################" )
 513 #pragma message( "SendMessageW wrapper has to be extended" )
 514 #pragma message( "#######################################" )
 515 #endif
 516
 517     SendMessageW(
 518         m_hwnd,
 519         BFFM_SETSELECTIONW,
 520         static_cast< WPARAM >( sal_True ),
 521         reinterpret_cast< LPARAM >( aDirectory.getStr( ) ) );
 522 }
 523
 524 //--------------------------------------------------------------------
 525 //
 526 //--------------------------------------------------------------------
 527
 528 void SAL_CALL CMtaFolderPicker::setStatusText( const rtl::OUString& aStatusText )
 529 {
 530     OSL_ASSERT( IsWindow( m_hwnd ) );
 531
 532     SendMessageW(
 533         m_hwnd,
 534         BFFM_SETSTATUSTEXTW,
 535         static_cast< WPARAM >( 0 ),
 536         reinterpret_cast< LPARAM >( aStatusText.getStr( ) ) );
 537 }
 538
 539 //--------------------------------------------------------------------
 540 //
 541 //--------------------------------------------------------------------
 542
 543 void SAL_CALL CMtaFolderPicker::onInitialized( )
 544 {
 545     LPITEMIDLIST lpiidDisplayDir = getItemIdListFromPath( m_displayDir );
 546
 547     if ( lpiidDisplayDir )
 548     {
 549         SendMessageA(
 550             m_hwnd,
 551             BFFM_SETSELECTION,
 552             (WPARAM)FALSE,
 553             (LPARAM) lpiidDisplayDir );
 554
 555         releaseItemIdList( lpiidDisplayDir );
 556     }
 557 }
 558
 559 //--------------------------------------------------------------------
 560 //
 561 //--------------------------------------------------------------------
 562
 563 sal_uInt32 CMtaFolderPicker::onValidateFailed()
 564 {
 565     // to be overwritten by subclasses
 566     return 1;
 567 }
 568
 569 //--------------------------------------------------------------------
 570 //
 571 //--------------------------------------------------------------------
 572
 573 int CALLBACK CMtaFolderPicker::FolderPickerCallback( HWND hwnd, UINT uMsg, LPARAM lParam, LPARAM lpData )
 574 {
 575     CMtaFolderPicker* pImpl = reinterpret_cast< CMtaFolderPicker* >( lpData );
 576     OSL_ASSERT( pImpl );
 577
 578     int nRC = 0;
 579
 580     switch( uMsg )
 581     {
 582         case BFFM_INITIALIZED:
 583             pImpl->m_hwnd = hwnd;
 584             pImpl->onInitialized( );
 585             SetWindowTextW( hwnd, reinterpret_cast<LPCWSTR>(pImpl->m_dialogTitle.getStr()) );
 586         break;
 587
 588         case BFFM_SELCHANGED:
 589             pImpl->m_hwnd = hwnd;
 590             pImpl->onSelChanged(
 591                 pImpl->getPathFromItemIdList(
 592                     reinterpret_cast< LPITEMIDLIST >( lParam ) ) );
 593         break;
 594
 595         case BFFM_VALIDATEFAILEDW:
 596             nRC = pImpl->onValidateFailed();
 597             break;
 598
 599         default:
 600             OSL_ASSERT( sal_False );
 601     }
 602
 603     return nRC;
 604 }
 605
 606 //--------------------------------------------------------------------
 607 // the window proc
 608 //--------------------------------------------------------------------
 609
 610 LRESULT CALLBACK CMtaFolderPicker::StaWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
 611 {
 612     LRESULT           lResult = 0;
 613     CMtaFolderPicker* pImpl   = NULL;
 614
 615     /*
 616         we connect to the belonging class instance of this
 617         window using SetProp, GetProp etc.
 618         this may fail if somehow the class instance destroyed
 619         before the window
 620     */
 621
 622     switch( uMsg )
 623     {
 624         case WM_CREATE:
 625             {
 626                 LPCREATESTRUCT lpcs =
 627                     reinterpret_cast< LPCREATESTRUCT >( lParam );
 628
 629                 OSL_ASSERT( lpcs->lpCreateParams );
 630
 631                 // connect the instance handle to the window
 632                 SetPropA( hWnd, CURRENT_INSTANCE, lpcs->lpCreateParams );
 633             }
 634             break;
 635
 636         case WM_NCDESTROY:
 637                 // RemoveProp returns the saved value on success
 638                 pImpl = reinterpret_cast< CMtaFolderPicker* >(
 639                     RemovePropA( hWnd, CURRENT_INSTANCE ) );
 640
 641                 OSL_ASSERT( pImpl && !IsBadReadPtr( pImpl, sizeof( CMtaFolderPicker ) ) );
 642             break;
 643
 644         case MSG_BROWSEFORFOLDER:
 645             {
 646                 RequestContext* aReqCtx = reinterpret_cast< RequestContext* >( lParam );
 647                 OSL_ASSERT( aReqCtx );
 648
 649                 pImpl = reinterpret_cast< CMtaFolderPicker* >(
 650                     GetPropA( hWnd, CURRENT_INSTANCE ) );
 651
 652                 OSL_ASSERT( pImpl && !IsBadReadPtr( pImpl, sizeof( CMtaFolderPicker ) ) );
 653
 654                 aReqCtx->bRet = pImpl->onBrowseForFolder( );
 655                 SetEvent( aReqCtx->hEvent );
 656             }
 657             break;
 658
 659         case MSG_SHUTDOWN:
 660             pImpl = reinterpret_cast< CMtaFolderPicker* >(
 661                 GetPropA( hWnd, CURRENT_INSTANCE ) );
 662
 663             OSL_ASSERT( pImpl && !IsBadReadPtr( pImpl, sizeof( CMtaFolderPicker ) ) );
 664
 665             DestroyWindow( pImpl->m_hwndStaRequestWnd );
 666             break;
 667
 668         case WM_DESTROY:
 669             PostQuitMessage( 0 );
 670             break;
 671
 672         default:
 673             lResult = DefWindowProcA( hWnd, uMsg, wParam, lParam );
 674             break;
 675     }
 676
 677     return lResult;
 678 }
 679
 680 //--------------------------------------------------------------------
 681 //
 682 //--------------------------------------------------------------------
 683
 684 sal_Bool SAL_CALL CMtaFolderPicker::createStaRequestWindow( )
 685 {
 686     bool bIsWnd = false;
 687
 688     if ( RegisterStaRequestWindowClass( ) )
 689     {
 690         m_hwndStaRequestWnd = CreateWindowA(
 691             g_szWndClsName, NULL,
 692             0, 0, 0, 0, 0,
 693             NULL, NULL, m_hInstance,
 694             (LPVOID)this // provide the instance of the class
 695         );
 696
 697         bIsWnd = IsWindow( m_hwndStaRequestWnd );
 698
 699         // we do immediately unregister the window class
 700         // if the creation of the window fails because we
 701         // don't want to spoil the register class counter
 702         if ( !bIsWnd )
 703             UnregisterStaRequestWindowClass( );
 704
 705         OSL_ENSURE( bIsWnd, "sta request window creation failed" );
 706     }
 707
 708     return bIsWnd;
 709 }
 710
 711 //--------------------------------------------------------------------
 712 //
 713 //--------------------------------------------------------------------
 714
 715 unsigned int CMtaFolderPicker::run( )
 716 {
 717     OSL_ASSERT( m_hEvtThrdReady );
 718
 719     // setup an sta environment
 720     HRESULT hr = CoInitialize( NULL );
 721
 722     // if we can't setup an sta environment
 723     // we stop here and return
 724     if ( FAILED( hr ) )
 725     {
 726         OSL_ENSURE( sal_False, "CoInitialize failed" );
 727         return sal::static_int_cast< unsigned int >(-1);
 728     }
 729
 730     unsigned int nRet;
 731
 732     if ( createStaRequestWindow( ) )
 733     {
 734         SetEvent( m_hEvtThrdReady );
 735
 736         // pumping messages
 737         MSG msg;
 738         while( GetMessageA( &msg, NULL, 0, 0 ) )
 739             DispatchMessageA( &msg );
 740
 741         nRet = 0;
 742     }
 743     else
 744     {
 745         OSL_ENSURE( sal_False, "failed to create sta thread" );
 746         nRet = sal::static_int_cast< unsigned int >(-1);
 747     }
 748
 749     // shutdown sta environment
 750     CoUninitialize( );
 751
 752     return nRet;
 753 }
 754
 755 //--------------------------------------------------------------------
 756 //
 757 //--------------------------------------------------------------------
 758
 759 unsigned int WINAPI CMtaFolderPicker::StaThreadProc( LPVOID pParam )
 760 {
 761     CMtaFolderPicker* pInst =
 762         reinterpret_cast<CMtaFolderPicker*>( pParam );
 763
 764     OSL_ASSERT( pInst );
 765
 766     HRESULT     hr = OleInitialize( NULL );
 767
 768     unsigned int        result = pInst->run( );
 769
 770     if ( SUCCEEDED( hr ) )
 771         OleUninitialize();
 772
 773     return result;
 774 }
 775
 776 //---------------------------------------------------
 777 //
 778 //---------------------------------------------------
 779
 780 ATOM SAL_CALL CMtaFolderPicker::RegisterStaRequestWindowClass( )
 781 {
 782     osl::MutexGuard aGuard( s_Mutex );
 783
 784     if ( 0 == s_ClassAtom )
 785     {
 786         WNDCLASSEXA  wcex;
 787
 788         ZeroMemory( &wcex, sizeof( WNDCLASSEXA ) );
 789
 790         wcex.cbSize                     = sizeof(WNDCLASSEXA);
 791         wcex.style                      = 0;
 792         wcex.lpfnWndProc        = static_cast< WNDPROC >( CMtaFolderPicker::StaWndProc );
 793         wcex.cbClsExtra         = 0;
 794         wcex.cbWndExtra         = 0;
 795         wcex.hInstance          = m_hInstance;
 796         wcex.hIcon                      = NULL;
 797         wcex.hCursor            = NULL;
 798         wcex.hbrBackground      = NULL;
 799         wcex.lpszMenuName       = NULL;
 800         wcex.lpszClassName      = g_szWndClsName;
 801         wcex.hIconSm            = NULL;
 802
 803         s_ClassAtom = RegisterClassExA( &wcex );
 804         OSL_ASSERT( s_ClassAtom );
 805     }
 806
 807     // increment the register class counter
 808     // so that we keep track of the number
 809     // of class registrations
 810     if ( 0 != s_ClassAtom )
 811         s_StaRequestWndRegisterCount++;
 812
 813     return s_ClassAtom;
 814 }
 815
 816 //---------------------------------------------------
 817 //
 818 //---------------------------------------------------
 819
 820 void SAL_CALL CMtaFolderPicker::UnregisterStaRequestWindowClass( )
 821 {
 822     osl::MutexGuard aGuard( s_Mutex );
 823
 824     OSL_ASSERT( 0 != s_ClassAtom );
 825
 826     // update the register class counter
 827     // and unregister the window class if
 828     // counter drops to zero
 829     if ( 0 != s_ClassAtom )
 830     {
 831         s_StaRequestWndRegisterCount--;
 832         OSL_ASSERT( s_StaRequestWndRegisterCount >= 0 );
 833     }
 834
 835     if ( 0 == s_StaRequestWndRegisterCount )
 836     {
 837         UnregisterClass(
 838             (LPCTSTR)MAKELONG( s_ClassAtom, 0 ), m_hInstance );
 839
 840         s_ClassAtom = 0;
 841     }
 842 }