vcl/source/app/svmain.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
  21 #include "rtl/logfile.hxx"
  22
  23 #include <osl/file.hxx>
  24 #include <osl/signal.h>
  25
  26 #include "tools/tools.h"
  27 #include "tools/debug.hxx"
  28 #include "tools/resmgr.hxx"
  29
  30 #include "comphelper/processfactory.hxx"
  31
  32 #include "unotools/syslocaleoptions.hxx"
  33 #include "unotools/fontcfg.hxx"
  34
  35 #include "vcl/svapp.hxx"
  36 #include "vcl/wrkwin.hxx"
  37 #include "vcl/cvtgrf.hxx"
  38 #include "vcl/image.hxx"
  39 #include "vcl/settings.hxx"
  40 #include "vcl/unowrap.hxx"
  41 #include "vcl/configsettings.hxx"
  42 #include "vcl/lazydelete.hxx"
  43 #include "vcl/embeddedfontshelper.hxx"
  44
  45 #ifdef WNT
  46 #include <svsys.h>
  47 #include <process.h>
  48 #include <ole2.h>
  49 #endif
  50
  51 #ifdef ANDROID
  52 #include <cppuhelper/bootstrap.hxx>
  53 #include <jni.h>
  54 #endif
  55
  56 #include "salinst.hxx"
  57 #include "salwtype.hxx"
  58 #include "svdata.hxx"
  59 #include "dbggui.hxx"
  60 #include "accmgr.hxx"
  61 #include "idlemgr.hxx"
  62 #include "outdev.h"
  63 #include "outfont.hxx"
  64 #include "print.h"
  65 #include "salsys.hxx"
  66 #include "saltimer.hxx"
  67 #include "salimestatus.hxx"
  68 #include "impimagetree.hxx"
  69 #include "xconnection.hxx"
  70
  71 #include "osl/process.h"
  72 #include "com/sun/star/lang/XMultiServiceFactory.hpp"
  73 #include "com/sun/star/lang/XComponent.hpp"
  74 #include "com/sun/star/frame/Desktop.hpp"
  75
  76 #include "cppuhelper/implbase1.hxx"
  77 #include "uno/current_context.hxx"
  78
  79 #if OSL_DEBUG_LEVEL > 0
  80 #include <typeinfo>
  81 #include "rtl/strbuf.hxx"
  82 #endif
  83
  84 using namespace ::com::sun::star;
  85
  86 // =======================================================================
  87
  88 oslSignalAction SAL_CALL VCLExceptionSignal_impl( void* /*pData*/, oslSignalInfo* pInfo)
  89 {
  90     static bool bIn = false;
  91
  92     // if we crash again, bail out immediately
  93     if ( !bIn )
  94     {
  95         sal_uInt16 nVCLException = 0;
  96
  97         // UAE
  98         if ( (pInfo->Signal == osl_Signal_AccessViolation)     ||
  99              (pInfo->Signal == osl_Signal_IntegerDivideByZero) ||
 100              (pInfo->Signal == osl_Signal_FloatDivideByZero)   ||
 101              (pInfo->Signal == osl_Signal_DebugBreak) )
 102             nVCLException = EXC_SYSTEM;
 103
 104         // RC
 105         if ((pInfo->Signal == osl_Signal_User) &&
 106             (pInfo->UserSignal == OSL_SIGNAL_USER_RESOURCEFAILURE) )
 107             nVCLException = EXC_RSCNOTLOADED;
 108
 109         // DISPLAY-Unix
 110         if ((pInfo->Signal == osl_Signal_User) &&
 111             (pInfo->UserSignal == OSL_SIGNAL_USER_X11SUBSYSTEMERROR) )
 112             nVCLException = EXC_DISPLAY;
 113
 114         // Remote-Client
 115         if ((pInfo->Signal == osl_Signal_User) &&
 116             (pInfo->UserSignal == OSL_SIGNAL_USER_RVPCONNECTIONERROR) )
 117             nVCLException = EXC_REMOTE;
 118
 119         if ( nVCLException )
 120         {
 121             bIn = true;
 122
 123             SolarMutexGuard aLock;
 124
 125             // do not stop timer because otherwise the UAE-Box will not be painted as well
 126             ImplSVData* pSVData = ImplGetSVData();
 127             if ( pSVData->mpApp )
 128             {
 129                 sal_uInt16 nOldMode = Application::GetSystemWindowMode();
 130                 Application::SetSystemWindowMode( nOldMode & ~SYSTEMWINDOW_MODE_NOAUTOMODE );
 131                 pSVData->mpApp->Exception( nVCLException );
 132                 Application::SetSystemWindowMode( nOldMode );
 133             }
 134             bIn = false;
 135
 136             return osl_Signal_ActCallNextHdl;
 137         }
 138     }
 139
 140     return osl_Signal_ActCallNextHdl;
 141
 142 }
 143
 144 // =======================================================================
 145 int ImplSVMain()
 146 {
 147     // The 'real' SVMain()
 148     SAL_INFO( "vcl.app", "vcl (ss112471) ::SVMain" );
 149
 150     ImplSVData* pSVData = ImplGetSVData();
 151
 152     DBG_ASSERT( pSVData->mpApp, "no instance of class Application" );
 153
 154     int nReturn = EXIT_FAILURE;
 155
 156     bool bInit = InitVCL();
 157
 158     if( bInit )
 159     {
 160         // call application main
 161         pSVData->maAppData.mbInAppMain = sal_True;
 162         nReturn = pSVData->mpApp->Main();
 163         pSVData->maAppData.mbInAppMain = sal_False;
 164     }
 165
 166     if( pSVData->mxDisplayConnection.is() )
 167     {
 168         pSVData->mxDisplayConnection->terminate();
 169         pSVData->mxDisplayConnection.clear();
 170     }
 171
 172     // This is a hack to work around the problem of the asynchronous nature
 173     // of bridging accessibility through Java: on shutdown there might still
 174     // be some events in the AWT EventQueue, which need the SolarMutex which
 175     // - on the other hand - is destroyed in DeInitVCL(). So empty the queue
 176     // here ..
 177     if( pSVData->mxAccessBridge.is() )
 178     {
 179       sal_uLong nCount = Application::ReleaseSolarMutex();
 180       pSVData->mxAccessBridge->dispose();
 181       Application::AcquireSolarMutex(nCount);
 182       pSVData->mxAccessBridge.clear();
 183     }
 184
 185     DeInitVCL();
 186     return nReturn;
 187 }
 188
 189 int SVMain()
 190 {
 191     // #i47888# allow for alternative initialization as required for e.g. MacOSX
 192     extern sal_Bool ImplSVMainHook( int* );
 193
 194     int nRet;
 195     if( !Application::IsConsoleOnly() && ImplSVMainHook( &nRet ) )
 196         return nRet;
 197     else
 198         return ImplSVMain();
 199 }
 200 // This variable is set, when no Application object is instantiated
 201 // before SVInit is called
 202 static Application *        pOwnSvApp = NULL;
 203 // Exception handler. pExceptionHandler != NULL => VCL already inited
 204 oslSignalHandler   pExceptionHandler = NULL;
 205
 206 class Application_Impl : public Application
 207 {
 208 public:
 209     int                Main() { return EXIT_SUCCESS; };
 210 };
 211
 212 class DesktopEnvironmentContext: public cppu::WeakImplHelper1< com::sun::star::uno::XCurrentContext >
 213 {
 214 public:
 215     DesktopEnvironmentContext( const com::sun::star::uno::Reference< com::sun::star::uno::XCurrentContext > & ctx)
 216         : m_xNextContext( ctx ) {}
 217
 218     // XCurrentContext
 219     virtual com::sun::star::uno::Any SAL_CALL getValueByName( const OUString& Name )
 220             throw (com::sun::star::uno::RuntimeException);
 221
 222 private:
 223     com::sun::star::uno::Reference< com::sun::star::uno::XCurrentContext > m_xNextContext;
 224 };
 225
 226 uno::Any SAL_CALL DesktopEnvironmentContext::getValueByName( const OUString& Name) throw (uno::RuntimeException)
 227 {
 228     uno::Any retVal;
 229
 230     if ( Name == "system.desktop-environment" )
 231     {
 232         retVal = uno::makeAny( Application::GetDesktopEnvironment() );
 233     }
 234     else if( m_xNextContext.is() )
 235     {
 236         // Call next context in chain if found
 237         retVal = m_xNextContext->getValueByName( Name );
 238     }
 239     return retVal;
 240 }
 241
 242 bool InitVCL()
 243 {
 244     SAL_INFO( "vcl.app", "vcl (ss112471) ::InitVCL" );
 245
 246     if( pExceptionHandler != NULL )
 247         return false;
 248
 249     EmbeddedFontsHelper::clearTemporaryFontFiles();
 250
 251     if( ! ImplGetSVData() )
 252         ImplInitSVData();
 253
 254     if( !ImplGetSVData()->mpApp )
 255     {
 256         pOwnSvApp = new Application_Impl();
 257     }
 258     InitSalMain();
 259
 260     ImplSVData* pSVData = ImplGetSVData();
 261
 262     // register with tools
 263     InitTools();
 264
 265     // remember Main-Thread-Id
 266     pSVData->mnMainThreadId = ::osl::Thread::getCurrentIdentifier();
 267
 268     // Initialize Sal
 269     SAL_INFO( "vcl.app", "{ ::CreateSalInstance" );
 270     pSVData->mpDefInst = CreateSalInstance();
 271     if ( !pSVData->mpDefInst )
 272         return false;
 273     SAL_INFO( "vcl.app", "} ::CreateSalInstance" );
 274
 275     // Desktop Environment context (to be able to get value of "system.desktop-environment" as soon as possible)
 276     com::sun::star::uno::setCurrentContext(
 277         new DesktopEnvironmentContext( com::sun::star::uno::getCurrentContext() ) );
 278
 279     // Initialize application instance (should be done after initialization of VCL SAL part)
 280     if( pSVData->mpApp )
 281         // call init to initialize application class
 282         // soffice/sfx implementation creates the global service manager
 283         pSVData->mpApp->Init();
 284
 285     pSVData->mpDefInst->AfterAppInit();
 286
 287     // Fetch AppFileName and make it absolute before the workdir changes...
 288     OUString aExeFileName;
 289     osl_getExecutableFile( &aExeFileName.pData );
 290
 291     // convert path to native file format
 292     OUString aNativeFileName;
 293     osl::FileBase::getSystemPathFromFileURL( aExeFileName, aNativeFileName );
 294     pSVData->maAppData.mpAppFileName = new OUString( aNativeFileName );
 295
 296     // Initialize global data
 297     pSVData->maGDIData.mpScreenFontList     = new ImplDevFontList;
 298     pSVData->maGDIData.mpScreenFontCache    = new ImplFontCache( sal_False );
 299     pSVData->maGDIData.mpGrfConverter       = new GraphicConverter;
 300
 301     // Set exception handler
 302     pExceptionHandler = osl_addSignalHandler(VCLExceptionSignal_impl, NULL);
 303
 304     // initialise debug data
 305     DBGGUI_INIT();
 306
 307     return true;
 308 }
 309
 310 #ifdef ANDROID
 311
 312 extern "C" __attribute__ ((visibility("default"))) void
 313 InitVCLWrapper()
 314 {
 315     uno::Reference<uno::XComponentContext> xContext( cppu::defaultBootstrap_InitialComponentContext() );
 316     uno::Reference<lang::XMultiComponentFactory> xFactory( xContext->getServiceManager() );
 317
 318     uno::Reference<lang::XMultiServiceFactory> xSM( xFactory, uno::UNO_QUERY_THROW );
 319
 320     comphelper::setProcessServiceFactory( xSM );
 321
 322     InitVCL();
 323 }
 324
 325 #endif
 326
 327 namespace
 328 {
 329
 330 /** Serves for destroying the VCL UNO wrapper as late as possible. This avoids
 331   crash at exit in some special cases when a11y is enabled (e.g., when
 332   a bundled extension is registered/deregistered during startup, forcing exit
 333   while the app is still in splash screen.)
 334  */
 335 class VCLUnoWrapperDeleter : public cppu::WeakImplHelper1<com::sun::star::lang::XEventListener>
 336 {
 337     virtual void SAL_CALL disposing(lang::EventObject const& rSource) throw(uno::RuntimeException);
 338 };
 339
 340 void
 341 VCLUnoWrapperDeleter::disposing(lang::EventObject const& /* rSource */)
 342     throw(uno::RuntimeException)
 343 {
 344     ImplSVData* const pSVData = ImplGetSVData();
 345     if (pSVData && pSVData->mpUnoWrapper)
 346     {
 347         pSVData->mpUnoWrapper->Destroy();
 348         pSVData->mpUnoWrapper = NULL;
 349     }
 350 }
 351
 352 }
 353
 354 void DeInitVCL()
 355 {
 356     ImplSVData* pSVData = ImplGetSVData();
 357     pSVData->mbDeInit = sal_True;
 358
 359     vcl::DeleteOnDeinitBase::ImplDeleteOnDeInit();
 360
 361     // give ime status a chance to destroy its own windows
 362     delete pSVData->mpImeStatus;
 363     pSVData->mpImeStatus = NULL;
 364
 365     #if OSL_DEBUG_LEVEL > 0
 366     OStringBuffer aBuf( 256 );
 367     aBuf.append( "DeInitVCL: some top Windows are still alive\n" );
 368     long nTopWindowCount = Application::GetTopWindowCount();
 369     long nBadTopWindows = nTopWindowCount;
 370     for( long i = 0; i < nTopWindowCount; i++ )
 371     {
 372         Window* pWin = Application::GetTopWindow( i );
 373         // default window will be destroyed further down
 374         // but may still be useful during deinit up to that point
 375         if( pWin == pSVData->mpDefaultWin )
 376             nBadTopWindows--;
 377         else
 378         {
 379             aBuf.append( "text = \"" );
 380             aBuf.append( OUStringToOString( pWin->GetText(), osl_getThreadTextEncoding() ) );
 381             aBuf.append( "\" type = \"" );
 382             aBuf.append( typeid(*pWin).name() );
 383             aBuf.append( "\", ptr = 0x" );
 384             aBuf.append( sal_Int64( pWin ), 16 );
 385             aBuf.append( "\n" );
 386         }
 387     }
 388     DBG_ASSERT( nBadTopWindows==0, aBuf.getStr() );
 389     #endif
 390
 391     ImplImageTreeSingletonRef()->shutDown();
 392
 393     osl_removeSignalHandler( pExceptionHandler);
 394     pExceptionHandler = NULL;
 395
 396     // Debug Daten zuruecksetzen
 397     DBGGUI_DEINIT();
 398
 399     // free global data
 400     delete pSVData->maGDIData.mpGrfConverter;
 401
 402     if( pSVData->mpSettingsConfigItem )
 403         delete pSVData->mpSettingsConfigItem, pSVData->mpSettingsConfigItem = NULL;
 404     if( pSVData->maGDIData.mpDefaultFontConfiguration )
 405         delete pSVData->maGDIData.mpDefaultFontConfiguration, pSVData->maGDIData.mpDefaultFontConfiguration = NULL;
 406     if( pSVData->maGDIData.mpFontSubstConfiguration )
 407         delete pSVData->maGDIData.mpFontSubstConfiguration, pSVData->maGDIData.mpFontSubstConfiguration = NULL;
 408
 409     if ( pSVData->maAppData.mpIdleMgr )
 410         delete pSVData->maAppData.mpIdleMgr;
 411     Timer::ImplDeInitTimer();
 412
 413     if ( pSVData->maWinData.mpMsgBoxImgList )
 414     {
 415         delete pSVData->maWinData.mpMsgBoxImgList;
 416         pSVData->maWinData.mpMsgBoxImgList = NULL;
 417     }
 418     if ( pSVData->maCtrlData.mpCheckImgList )
 419     {
 420         delete pSVData->maCtrlData.mpCheckImgList;
 421         pSVData->maCtrlData.mpCheckImgList = NULL;
 422     }
 423     if ( pSVData->maCtrlData.mpRadioImgList )
 424     {
 425         delete pSVData->maCtrlData.mpRadioImgList;
 426         pSVData->maCtrlData.mpRadioImgList = NULL;
 427     }
 428     if ( pSVData->maCtrlData.mpPinImgList )
 429     {
 430         delete pSVData->maCtrlData.mpPinImgList;
 431         pSVData->maCtrlData.mpPinImgList = NULL;
 432     }
 433     if ( pSVData->maCtrlData.mpSplitHPinImgList )
 434     {
 435         delete pSVData->maCtrlData.mpSplitHPinImgList;
 436         pSVData->maCtrlData.mpSplitHPinImgList = NULL;
 437     }
 438     if ( pSVData->maCtrlData.mpSplitVPinImgList )
 439     {
 440         delete pSVData->maCtrlData.mpSplitVPinImgList;
 441         pSVData->maCtrlData.mpSplitVPinImgList = NULL;
 442     }
 443     if ( pSVData->maCtrlData.mpSplitHArwImgList )
 444     {
 445         delete pSVData->maCtrlData.mpSplitHArwImgList;
 446         pSVData->maCtrlData.mpSplitHArwImgList = NULL;
 447     }
 448     if ( pSVData->maCtrlData.mpSplitVArwImgList )
 449     {
 450         delete pSVData->maCtrlData.mpSplitVArwImgList;
 451         pSVData->maCtrlData.mpSplitVArwImgList = NULL;
 452     }
 453     if ( pSVData->maCtrlData.mpDisclosurePlus )
 454     {
 455         delete pSVData->maCtrlData.mpDisclosurePlus;
 456         pSVData->maCtrlData.mpDisclosurePlus = NULL;
 457     }
 458     if ( pSVData->maCtrlData.mpDisclosureMinus )
 459     {
 460         delete pSVData->maCtrlData.mpDisclosureMinus;
 461         pSVData->maCtrlData.mpDisclosureMinus = NULL;
 462     }
 463     if ( pSVData->mpDefaultWin )
 464     {
 465         delete pSVData->mpDefaultWin;
 466         pSVData->mpDefaultWin = NULL;
 467     }
 468
 469     if ( pSVData->mpUnoWrapper )
 470     {
 471         try
 472         {
 473             uno::Reference<frame::XDesktop2> const xDesktop = frame::Desktop::create(
 474                     comphelper::getProcessComponentContext() );
 475             xDesktop->addEventListener(new VCLUnoWrapperDeleter());
 476         }
 477         catch (uno::Exception const&)
 478         {
 479             // ignore
 480         }
 481     }
 482
 483     if( pSVData->mpApp )
 484     {
 485         sal_uLong nCount = Application::ReleaseSolarMutex();
 486         // call deinit to deinitialize application class
 487         // soffice/sfx implementation disposes the global service manager
 488         // Warning: After this call you can't call uno services
 489         pSVData->mpApp->DeInit();
 490         Application::AcquireSolarMutex(nCount);
 491     }
 492
 493     if ( pSVData->maAppData.mpSettings )
 494     {
 495         if ( pSVData->maAppData.mpCfgListener )
 496         {
 497             pSVData->maAppData.mpSettings->GetSysLocale().GetOptions().RemoveListener( pSVData->maAppData.mpCfgListener );
 498             delete pSVData->maAppData.mpCfgListener;
 499         }
 500
 501         delete pSVData->maAppData.mpSettings;
 502         pSVData->maAppData.mpSettings = NULL;
 503     }
 504     if ( pSVData->maAppData.mpAccelMgr )
 505     {
 506         delete pSVData->maAppData.mpAccelMgr;
 507         pSVData->maAppData.mpAccelMgr = NULL;
 508     }
 509     if ( pSVData->maAppData.mpAppFileName )
 510     {
 511         delete pSVData->maAppData.mpAppFileName;
 512         pSVData->maAppData.mpAppFileName = NULL;
 513     }
 514     if ( pSVData->maAppData.mpAppName )
 515     {
 516         delete pSVData->maAppData.mpAppName;
 517         pSVData->maAppData.mpAppName = NULL;
 518     }
 519     if ( pSVData->maAppData.mpDisplayName )
 520     {
 521         delete pSVData->maAppData.mpDisplayName;
 522         pSVData->maAppData.mpDisplayName = NULL;
 523     }
 524     if ( pSVData->maAppData.mpEventListeners )
 525     {
 526         delete pSVData->maAppData.mpEventListeners;
 527         pSVData->maAppData.mpEventListeners = NULL;
 528     }
 529     if ( pSVData->maAppData.mpKeyListeners )
 530     {
 531         delete pSVData->maAppData.mpKeyListeners;
 532         pSVData->maAppData.mpKeyListeners = NULL;
 533     }
 534     if ( pSVData->maAppData.mpPostYieldListeners )
 535     {
 536         delete pSVData->maAppData.mpPostYieldListeners;
 537         pSVData->maAppData.mpPostYieldListeners = NULL;
 538     }
 539
 540     if ( pSVData->maAppData.mpFirstHotKey )
 541         ImplFreeHotKeyData();
 542     if ( pSVData->maAppData.mpFirstEventHook )
 543         ImplFreeEventHookData();
 544
 545     if (pSVData->mpBlendFrameCache)
 546         delete pSVData->mpBlendFrameCache, pSVData->mpBlendFrameCache = NULL;
 547
 548     ImplDeletePrnQueueList();
 549     delete pSVData->maGDIData.mpScreenFontList;
 550     pSVData->maGDIData.mpScreenFontList = NULL;
 551     delete pSVData->maGDIData.mpScreenFontCache;
 552     pSVData->maGDIData.mpScreenFontCache = NULL;
 553
 554     if ( pSVData->mpResMgr )
 555     {
 556         delete pSVData->mpResMgr;
 557         pSVData->mpResMgr = NULL;
 558     }
 559
 560     ResMgr::DestroyAllResMgr();
 561
 562     // destroy all Sal interfaces before destorying the instance
 563     // and thereby unloading the plugin
 564     delete pSVData->mpSalSystem;
 565     pSVData->mpSalSystem = NULL;
 566     delete pSVData->mpSalTimer;
 567     pSVData->mpSalTimer = NULL;
 568
 569     // Deinit Sal
 570     DestroySalInstance( pSVData->mpDefInst );
 571
 572     DeInitTools();
 573
 574     if( pOwnSvApp )
 575     {
 576         delete pOwnSvApp;
 577         pOwnSvApp = NULL;
 578     }
 579
 580     EmbeddedFontsHelper::clearTemporaryFontFiles();
 581 }
 582
 583 // only one call is allowed
 584 struct WorkerThreadData
 585 {
 586     oslWorkerFunction   pWorker;
 587     void *              pThreadData;
 588     WorkerThreadData( oslWorkerFunction pWorker_, void * pThreadData_ )
 589         : pWorker( pWorker_ )
 590         , pThreadData( pThreadData_ )
 591     {
 592     }
 593 };
 594
 595 #ifdef WNT
 596 static HANDLE hThreadID = 0;
 597 static unsigned __stdcall _threadmain( void *pArgs )
 598 {
 599     OleInitialize( NULL );
 600     ((WorkerThreadData*)pArgs)->pWorker( ((WorkerThreadData*)pArgs)->pThreadData );
 601     delete (WorkerThreadData*)pArgs;
 602     OleUninitialize();
 603     hThreadID = 0;
 604     return 0;
 605 }
 606 #else
 607 static oslThread hThreadID = 0;
 608 extern "C"
 609 {
 610 static void SAL_CALL MainWorkerFunction( void* pArgs )
 611 {
 612     ((WorkerThreadData*)pArgs)->pWorker( ((WorkerThreadData*)pArgs)->pThreadData );
 613     delete (WorkerThreadData*)pArgs;
 614     hThreadID = 0;
 615 }
 616 } // extern "C"
 617 #endif
 618
 619 void CreateMainLoopThread( oslWorkerFunction pWorker, void * pThreadData )
 620 {
 621 #ifdef WNT
 622     // sal thread always call CoInitializeEx, so a sysdepen implementation is necessary
 623
 624     unsigned uThreadID;
 625     hThreadID = (HANDLE)_beginthreadex(
 626         NULL,       // no security handle
 627         0,          // stacksize 0 means default
 628         _threadmain,    // thread worker function
 629         new WorkerThreadData( pWorker, pThreadData ),       // arguments for worker function
 630         0,          // 0 means: create immediately otherwise use CREATE_SUSPENDED
 631         &uThreadID );   // thread id to fill
 632 #else
 633     hThreadID = osl_createThread( MainWorkerFunction, new WorkerThreadData( pWorker, pThreadData ) );
 634 #endif
 635 }
 636
 637 void JoinMainLoopThread()
 638 {
 639     if( hThreadID )
 640     {
 641 #ifdef WNT
 642         WaitForSingleObject(hThreadID, INFINITE);
 643 #else
 644         osl_joinWithThread(hThreadID);
 645         osl_destroyThread( hThreadID );
 646 #endif
 647     }
 648 }
 649
 650 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */