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