vcl/source/app/svapp.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 "comphelper/processfactory.hxx"
  21
  22 #include "osl/module.h"
  23 #include "osl/file.hxx"
  24 #include "osl/thread.h"
  25
  26 #include "rtl/tencinfo.h"
  27 #include "rtl/instance.hxx"
  28 #include "rtl/process.h"
  29
  30 #include "tools/tools.h"
  31 #include "tools/debug.hxx"
  32 #include "tools/time.hxx"
  33
  34 #include "i18nlangtag/mslangid.hxx"
  35
  36 #include "unotools/syslocaleoptions.hxx"
  37
  38 #include "vcl/settings.hxx"
  39 #include "vcl/keycod.hxx"
  40 #include "vcl/event.hxx"
  41 #include "vcl/vclevent.hxx"
  42 #include "vcl/virdev.hxx"
  43 #include "vcl/wrkwin.hxx"
  44 #include "vcl/svapp.hxx"
  45 #include "vcl/cvtgrf.hxx"
  46 #include "vcl/unowrap.hxx"
  47 #include "vcl/timer.hxx"
  48 #include "vcl/unohelp.hxx"
  49 #include "vcl/lazydelete.hxx"
  50
  51 #include "salinst.hxx"
  52 #include "salframe.hxx"
  53 #include "salsys.hxx"
  54 #include "svdata.hxx"
  55 #include "salimestatus.hxx"
  56 #include "xconnection.hxx"
  57 #include "window.h"
  58 #include "accmgr.hxx"
  59 #include "idlemgr.hxx"
  60 #include "svids.hrc"
  61
  62 #include "com/sun/star/uno/Reference.h"
  63 #include "com/sun/star/awt/XToolkit.hpp"
  64 #include "com/sun/star/uno/XNamingService.hpp"
  65 #include "com/sun/star/lang/XMultiServiceFactory.hpp"
  66 #include "comphelper/solarmutex.hxx"
  67 #include "osl/process.h"
  68
  69 #include <utility>
  70
  71 using namespace ::com::sun::star;
  72 using namespace ::com::sun::star::uno;
  73
  74 // keycodes handled internally by VCL
  75 class ImplReservedKey
  76 {
  77 public:
  78     ImplReservedKey( KeyCode aKeyCode, sal_uInt16 nResId ) :
  79       mKeyCode(aKeyCode), mnResId( nResId)
  80      {}
  81
  82     KeyCode mKeyCode;
  83     sal_uInt16  mnResId;
  84 };
  85
  86 typedef std::pair<ImplReservedKey*, size_t> ReservedKeys;
  87 namespace
  88 {
  89     struct ImplReservedKeysImpl
  90     {
  91         ReservedKeys* operator()()
  92         {
  93             static ImplReservedKey ImplReservedKeys[] =
  94             {
  95                 ImplReservedKey(KeyCode(KEY_F1,0),                  SV_SHORTCUT_HELP),
  96                 ImplReservedKey(KeyCode(KEY_F1,KEY_SHIFT),          SV_SHORTCUT_ACTIVEHELP),
  97                 ImplReservedKey(KeyCode(KEY_F1,KEY_MOD1),           SV_SHORTCUT_CONTEXTHELP),
  98                 ImplReservedKey(KeyCode(KEY_F2,KEY_SHIFT),          SV_SHORTCUT_CONTEXTHELP),
  99                 ImplReservedKey(KeyCode(KEY_F4,KEY_MOD1),           SV_SHORTCUT_DOCKUNDOCK),
 100                 ImplReservedKey(KeyCode(KEY_F4,KEY_MOD2),           SV_SHORTCUT_DOCKUNDOCK),
 101                 ImplReservedKey(KeyCode(KEY_F4,KEY_MOD1|KEY_MOD2),  SV_SHORTCUT_DOCKUNDOCK),
 102                 ImplReservedKey(KeyCode(KEY_F6,0),                  SV_SHORTCUT_NEXTSUBWINDOW),
 103                 ImplReservedKey(KeyCode(KEY_F6,KEY_MOD1),           SV_SHORTCUT_TODOCUMENT),
 104                 ImplReservedKey(KeyCode(KEY_F6,KEY_SHIFT),          SV_SHORTCUT_PREVSUBWINDOW),
 105                 ImplReservedKey(KeyCode(KEY_F6,KEY_MOD1|KEY_SHIFT), SV_SHORTCUT_SPLITTER),
 106                 ImplReservedKey(KeyCode(KEY_F10,0),                 SV_SHORTCUT_MENUBAR)
 107 #ifdef UNX
 108                 ,
 109                 ImplReservedKey(KeyCode(KEY_1,KEY_SHIFT|KEY_MOD1), 0),
 110                 ImplReservedKey(KeyCode(KEY_2,KEY_SHIFT|KEY_MOD1), 0),
 111                 ImplReservedKey(KeyCode(KEY_3,KEY_SHIFT|KEY_MOD1), 0),
 112                 ImplReservedKey(KeyCode(KEY_4,KEY_SHIFT|KEY_MOD1), 0),
 113                 ImplReservedKey(KeyCode(KEY_5,KEY_SHIFT|KEY_MOD1), 0),
 114                 ImplReservedKey(KeyCode(KEY_6,KEY_SHIFT|KEY_MOD1), 0),
 115                 ImplReservedKey(KeyCode(KEY_7,KEY_SHIFT|KEY_MOD1), 0),
 116                 ImplReservedKey(KeyCode(KEY_8,KEY_SHIFT|KEY_MOD1), 0),
 117                 ImplReservedKey(KeyCode(KEY_9,KEY_SHIFT|KEY_MOD1), 0),
 118                 ImplReservedKey(KeyCode(KEY_0,KEY_SHIFT|KEY_MOD1), 0),
 119                 ImplReservedKey(KeyCode(KEY_ADD,KEY_SHIFT|KEY_MOD1), 0)
 120 #endif
 121             };
 122             static ReservedKeys aKeys
 123             (
 124                 &ImplReservedKeys[0],
 125                 sizeof(ImplReservedKeys) / sizeof(ImplReservedKey)
 126             );
 127             return &aKeys;
 128         }
 129     };
 130
 131     struct ImplReservedKeys
 132         : public rtl::StaticAggregate<ReservedKeys, ImplReservedKeysImpl> {};
 133 }
 134
 135 extern "C" {
 136     typedef UnoWrapperBase* (SAL_CALL *FN_TkCreateUnoWrapper)();
 137 }
 138
 139 struct ImplHotKey
 140 {
 141     ImplHotKey*             mpNext;
 142     void*                   mpUserData;
 143     KeyCode                 maKeyCode;
 144     Link                    maLink;
 145 };
 146
 147 struct ImplEventHook
 148 {
 149     ImplEventHook*          mpNext;
 150     void*                   mpUserData;
 151     VCLEventHookProc        mpProc;
 152 };
 153
 154 struct ImplPostEventData
 155 {
 156     sal_uLong           mnEvent;
 157     const Window*   mpWin;
 158     sal_uLong           mnEventId;
 159     KeyEvent        maKeyEvent;
 160     MouseEvent      maMouseEvent;
 161     ZoomEvent       maZoomEvent;
 162     ScrollEvent     maScrollEvent;
 163
 164        ImplPostEventData( sal_uLong nEvent, const Window* pWin, const KeyEvent& rKeyEvent ) :
 165         mnEvent( nEvent ), mpWin( pWin ), mnEventId( 0 ), maKeyEvent( rKeyEvent ) {}
 166        ImplPostEventData( sal_uLong nEvent, const Window* pWin, const MouseEvent& rMouseEvent ) :
 167         mnEvent( nEvent ), mpWin( pWin ), mnEventId( 0 ), maMouseEvent( rMouseEvent ) {}
 168        ImplPostEventData( sal_uLong nEvent, const Window* pWin, const ZoomEvent& rZoomEvent ) :
 169         mnEvent( nEvent ), mpWin( pWin ), mnEventId( 0 ), maZoomEvent( rZoomEvent ) {}
 170        ImplPostEventData( sal_uLong nEvent, const Window* pWin, const ScrollEvent& rScrollEvent ) :
 171         mnEvent( nEvent ), mpWin( pWin ), mnEventId( 0 ), maScrollEvent( rScrollEvent ) {}
 172
 173     ~ImplPostEventData() {}
 174 };
 175
 176 typedef ::std::pair< Window*, ImplPostEventData* > ImplPostEventPair;
 177
 178 static ::std::list< ImplPostEventPair > aPostedEventList;
 179
 180 Application* GetpApp()
 181 {
 182     ImplSVData* pSVData = ImplGetSVData();
 183     if ( !pSVData )
 184         return NULL;
 185     return pSVData->mpApp;
 186 }
 187
 188 Application::Application()
 189 {
 190     // useful for themes at least, perhaps extensions too
 191     OUString aVar("LIBO_VERSION"), aValue(LIBO_VERSION_DOTTED);
 192     osl_setEnvironment(aVar.pData, aValue.pData);
 193
 194     if( ! ImplGetSVData() )
 195         ImplInitSVData();
 196     ImplGetSVData()->mpApp = this;
 197     InitSalData();
 198 }
 199
 200 Application::~Application()
 201 {
 202     ImplDeInitSVData();
 203     DeInitSalData();
 204     ImplGetSVData()->mpApp = NULL;
 205     ImplDestroySVData();
 206     GlobalDeInitTools();
 207 }
 208
 209 sal_Bool Application::QueryExit()
 210 {
 211     WorkWindow* pAppWin = ImplGetSVData()->maWinData.mpAppWin;
 212
 213     // call the close handler of the application window
 214     if ( pAppWin )
 215         return pAppWin->Close();
 216     else
 217         return sal_True;
 218 }
 219
 220 void Application::UserEvent( sal_uLong, void* )
 221 {
 222 }
 223
 224 void Application::FocusChanged()
 225 {
 226 }
 227
 228 void Application::DataChanged( const DataChangedEvent& )
 229 {
 230 }
 231
 232 void Application::Init()
 233 {
 234 }
 235
 236 void Application::InitFinished()
 237 {
 238 }
 239
 240 void Application::DeInit()
 241 {
 242 }
 243
 244 sal_uInt16 Application::GetCommandLineParamCount()
 245 {
 246     return (sal_uInt16)osl_getCommandArgCount();
 247 }
 248
 249 OUString Application::GetCommandLineParam( sal_uInt16 nParam )
 250 {
 251     OUString aParam;
 252     osl_getCommandArg( nParam, &aParam.pData );
 253     return aParam;
 254 }
 255
 256 OUString Application::GetAppFileName()
 257 {
 258     ImplSVData* pSVData = ImplGetSVData();
 259     DBG_ASSERT( pSVData->maAppData.mpAppFileName, "AppFileName should be set to something after SVMain!" );
 260     if ( pSVData->maAppData.mpAppFileName )
 261         return *pSVData->maAppData.mpAppFileName;
 262
 263     /*
 264      *  provide a fallback for people without initialized vcl here (like setup
 265      *  in responsefile mode)
 266      */
 267     OUString aAppFileName;
 268     OUString aExeFileName;
 269     osl_getExecutableFile(&aExeFileName.pData);
 270
 271     // convert path to native file format
 272     osl::FileBase::getSystemPathFromFileURL(aExeFileName, aAppFileName);
 273
 274     return aAppFileName;
 275 }
 276
 277 sal_uInt16 Application::Exception( sal_uInt16 nError )
 278 {
 279     switch ( nError & EXC_MAJORTYPE )
 280     {
 281         // System has precedence (so do nothing)
 282         case EXC_SYSTEM:
 283             return 0;
 284
 285         case EXC_DISPLAY:
 286         case EXC_REMOTE:
 287             return 0;
 288
 289 #ifdef DBG_UTIL
 290         case EXC_RSCNOTLOADED:
 291             Abort(OUString("Resource not loaded"));
 292             break;
 293         case EXC_SYSOBJNOTCREATED:
 294             Abort(OUString("System Object not created"));
 295             break;
 296         default:
 297             Abort(OUString("Unknown Error"));
 298             break;
 299 #else
 300         default:
 301             Abort(OUString());
 302             break;
 303 #endif
 304     }
 305
 306     return 0;
 307 }
 308
 309 void Application::Abort( const OUString& rErrorText )
 310 {
 311     //HACK: Dump core iff --norestore command line argument is given (assuming
 312     // this process is run by developers who are interested in cores, vs. end
 313     // users who are not):
 314     bool dumpCore = false;
 315     sal_uInt16 n = GetCommandLineParamCount();
 316     for (sal_uInt16 i = 0; i != n; ++i) {
 317         if (GetCommandLineParam(i).equals("--norestore")) {
 318             dumpCore = true;
 319             break;
 320         }
 321     }
 322
 323     SalAbort( rErrorText, dumpCore );
 324 }
 325
 326 sal_uLong   Application::GetReservedKeyCodeCount()
 327 {
 328     return ImplReservedKeys::get()->second;
 329 }
 330
 331 const KeyCode*  Application::GetReservedKeyCode( sal_uLong i )
 332 {
 333     if( i >= GetReservedKeyCodeCount() )
 334         return NULL;
 335     else
 336         return &ImplReservedKeys::get()->first[i].mKeyCode;
 337 }
 338
 339 void Application::Execute()
 340 {
 341     ImplSVData* pSVData = ImplGetSVData();
 342     pSVData->maAppData.mbInAppExecute = sal_True;
 343
 344     while ( !pSVData->maAppData.mbAppQuit )
 345         Application::Yield();
 346
 347     pSVData->maAppData.mbInAppExecute = sal_False;
 348 }
 349
 350 inline void ImplYield( bool i_bWait, bool i_bAllEvents )
 351 {
 352     ImplSVData* pSVData = ImplGetSVData();
 353
 354     // run timers that have timed out
 355     if ( !pSVData->mbNoCallTimer )
 356         while ( pSVData->mbNotAllTimerCalled )
 357             Timer::ImplTimerCallbackProc();
 358
 359     pSVData->maAppData.mnDispatchLevel++;
 360     // do not wait for events if application was already quit; in that
 361     // case only dispatch events already available
 362     // do not wait for events either if the app decided that it is too busy for timers
 363     // (feature added for the slideshow)
 364     pSVData->mpDefInst->Yield( i_bWait && !pSVData->maAppData.mbAppQuit && !pSVData->maAppData.mbNoYield, i_bAllEvents );
 365     pSVData->maAppData.mnDispatchLevel--;
 366
 367     DBG_TESTSOLARMUTEX(); // must be locked on return from Yield
 368
 369     // flush lazy deleted objects
 370     if( pSVData->maAppData.mnDispatchLevel == 0 )
 371         vcl::LazyDelete::flush();
 372
 373     // the system timer events will not necessarily come in in non waiting mode
 374     // e.g. on aqua; need to trigger timer checks manually
 375     if( pSVData->maAppData.mbNoYield && !pSVData->mbNoCallTimer )
 376     {
 377         do
 378         {
 379             Timer::ImplTimerCallbackProc();
 380         }
 381         while( pSVData->mbNotAllTimerCalled );
 382     }
 383
 384     // call post yield listeners
 385     if( pSVData->maAppData.mpPostYieldListeners )
 386         pSVData->maAppData.mpPostYieldListeners->callListeners( NULL );
 387 }
 388
 389 void Application::Reschedule( bool i_bAllEvents )
 390 {
 391     ImplYield( false, i_bAllEvents );
 392 }
 393
 394 void Application::Yield()
 395 {
 396     ImplYield( true, false );
 397 }
 398
 399 IMPL_STATIC_LINK_NOINSTANCE( ImplSVAppData, ImplQuitMsg, void*, EMPTYARG )
 400 {
 401     ImplGetSVData()->maAppData.mbAppQuit = sal_True;
 402     return 0;
 403 }
 404
 405 void Application::Quit()
 406 {
 407     Application::PostUserEvent( STATIC_LINK( NULL, ImplSVAppData, ImplQuitMsg ) );
 408 }
 409
 410 comphelper::SolarMutex& Application::GetSolarMutex()
 411 {
 412     ImplSVData* pSVData = ImplGetSVData();
 413     return *(pSVData->mpDefInst->GetYieldMutex());
 414 }
 415
 416 oslThreadIdentifier Application::GetMainThreadIdentifier()
 417 {
 418     return ImplGetSVData()->mnMainThreadId;
 419 }
 420
 421 sal_uLong Application::ReleaseSolarMutex()
 422 {
 423     ImplSVData* pSVData = ImplGetSVData();
 424     return pSVData->mpDefInst->ReleaseYieldMutex();
 425 }
 426
 427 void Application::AcquireSolarMutex( sal_uLong nCount )
 428 {
 429     ImplSVData* pSVData = ImplGetSVData();
 430     pSVData->mpDefInst->AcquireYieldMutex( nCount );
 431 }
 432
 433 sal_Bool Application::IsInMain()
 434 {
 435     return ImplGetSVData()->maAppData.mbInAppMain;
 436 }
 437
 438 sal_Bool Application::IsInExecute()
 439 {
 440     return ImplGetSVData()->maAppData.mbInAppExecute;
 441 }
 442
 443 sal_Bool Application::IsInModalMode()
 444 {
 445     return (ImplGetSVData()->maAppData.mnModalMode != 0);
 446 }
 447
 448 sal_uInt16 Application::GetDispatchLevel()
 449 {
 450     return ImplGetSVData()->maAppData.mnDispatchLevel;
 451 }
 452
 453 bool Application::AnyInput( sal_uInt16 nType )
 454 {
 455     return ImplGetSVData()->mpDefInst->AnyInput( nType );
 456 }
 457
 458 sal_uLong Application::GetLastInputInterval()
 459 {
 460     return (Time::GetSystemTicks()-ImplGetSVData()->maAppData.mnLastInputTime);
 461 }
 462
 463 extern int nImplSysDialog;
 464
 465 sal_Bool Application::IsUICaptured()
 466 {
 467     ImplSVData* pSVData = ImplGetSVData();
 468
 469     // If mouse was captured, or if in tracking- or in select-mode of a floatingwindow (e.g. menus
 470     // or pulldown toolboxes) another window should be created
 471     // D&D active !!!
 472     if ( pSVData->maWinData.mpCaptureWin || pSVData->maWinData.mpTrackWin ||
 473          pSVData->maWinData.mpFirstFloat || nImplSysDialog )
 474         return sal_True;
 475     else
 476         return sal_False;
 477 }
 478
 479 void Application::SystemSettingsChanging( AllSettings& /*rSettings*/,
 480                                           Window* /*pFrame*/ )
 481 {
 482 }
 483
 484 void Application::MergeSystemSettings( AllSettings& rSettings )
 485 {
 486     Window* pWindow = ImplGetSVData()->maWinData.mpFirstFrame;
 487     if( ! pWindow )
 488         pWindow = ImplGetDefaultWindow();
 489     if( pWindow )
 490     {
 491         ImplSVData* pSVData = ImplGetSVData();
 492         if ( !pSVData->maAppData.mbSettingsInit )
 493         {
 494             // side effect: ImplUpdateGlobalSettings does an ImplGetFrame()->UpdateSettings
 495             pWindow->ImplUpdateGlobalSettings( *pSVData->maAppData.mpSettings );
 496             pSVData->maAppData.mbSettingsInit = sal_True;
 497         }
 498         // side effect: ImplUpdateGlobalSettings does an ImplGetFrame()->UpdateSettings
 499         pWindow->ImplUpdateGlobalSettings( rSettings, sal_False );
 500     }
 501 }
 502
 503 bool Application::ValidateSystemFont()
 504 {
 505     Window* pWindow = ImplGetSVData()->maWinData.mpFirstFrame;
 506     if( ! pWindow )
 507         pWindow = ImplGetDefaultWindow();
 508
 509     if( pWindow )
 510     {
 511         AllSettings aSettings;
 512         pWindow->ImplGetFrame()->UpdateSettings( aSettings );
 513         return pWindow->ImplCheckUIFont( aSettings.GetStyleSettings().GetAppFont() );
 514     }
 515     return false;
 516 }
 517
 518 void Application::SetSettings( const AllSettings& rSettings )
 519 {
 520     ImplSVData* pSVData = ImplGetSVData();
 521     if ( !pSVData->maAppData.mpSettings )
 522     {
 523         GetSettings();
 524         *pSVData->maAppData.mpSettings = rSettings;
 525         ResMgr::SetDefaultLocale( rSettings.GetUILanguageTag() );
 526     }
 527     else
 528     {
 529         AllSettings aOldSettings = *pSVData->maAppData.mpSettings;
 530         if( aOldSettings.GetUILanguageTag().getLanguageType() != rSettings.GetUILanguageTag().getLanguageType() &&
 531                 pSVData->mpResMgr )
 532         {
 533             delete pSVData->mpResMgr;
 534             pSVData->mpResMgr = NULL;
 535         }
 536         ResMgr::SetDefaultLocale( rSettings.GetUILanguageTag() );
 537         *pSVData->maAppData.mpSettings = rSettings;
 538         sal_uLong nChangeFlags = aOldSettings.GetChangeFlags( *pSVData->maAppData.mpSettings );
 539         if ( nChangeFlags )
 540         {
 541             DataChangedEvent aDCEvt( DATACHANGED_SETTINGS, &aOldSettings, nChangeFlags );
 542             GetpApp()->DataChanged( aDCEvt );
 543
 544             // notify data change handler
 545             ImplCallEventListeners( VCLEVENT_APPLICATION_DATACHANGED, NULL, &aDCEvt);
 546
 547             // Update all windows
 548             Window* pFirstFrame = pSVData->maWinData.mpFirstFrame;
 549             // Reset data that needs to be re-calculated
 550             long nOldDPIX = 0;
 551             long nOldDPIY = 0;
 552             if ( pFirstFrame )
 553             {
 554                 nOldDPIX = pFirstFrame->mnDPIX;
 555                 nOldDPIY = pFirstFrame->mnDPIY;
 556                 pSVData->maGDIData.mnAppFontX = 0;
 557             }
 558             Window* pFrame = pFirstFrame;
 559             while ( pFrame )
 560             {
 561                 // restore AppFont cache data
 562                 pFrame->mpWindowImpl->mpFrameData->meMapUnit = MAP_PIXEL;
 563
 564                 // call UpdateSettings from ClientWindow in order to prevent updating data twice
 565                 Window* pClientWin = pFrame;
 566                 while ( pClientWin->ImplGetClientWindow() )
 567                     pClientWin = pClientWin->ImplGetClientWindow();
 568                 pClientWin->UpdateSettings( rSettings, sal_True );
 569
 570                 Window* pTempWin = pFrame->mpWindowImpl->mpFrameData->mpFirstOverlap;
 571                 while ( pTempWin )
 572                 {
 573                     // call UpdateSettings from ClientWindow in order to prevent updating data twice
 574                     pClientWin = pTempWin;
 575                     while ( pClientWin->ImplGetClientWindow() )
 576                         pClientWin = pClientWin->ImplGetClientWindow();
 577                     pClientWin->UpdateSettings( rSettings, sal_True );
 578                     pTempWin = pTempWin->mpWindowImpl->mpNextOverlap;
 579                 }
 580
 581                 pFrame = pFrame->mpWindowImpl->mpFrameData->mpNextFrame;
 582             }
 583
 584             // if DPI resolution for screen output was changed set the new resolution for all
 585             // screen compatible VirDev's
 586             pFirstFrame = pSVData->maWinData.mpFirstFrame;
 587             if ( pFirstFrame )
 588             {
 589                 if ( (pFirstFrame->mnDPIX != nOldDPIX) ||
 590                      (pFirstFrame->mnDPIY != nOldDPIY) )
 591                 {
 592                     VirtualDevice* pVirDev = pSVData->maGDIData.mpFirstVirDev;
 593                     while ( pVirDev )
 594                     {
 595                         if ( pVirDev->mbScreenComp &&
 596                              (pVirDev->mnDPIX == nOldDPIX) &&
 597                              (pVirDev->mnDPIY == nOldDPIY) )
 598                         {
 599                             pVirDev->mnDPIX = pFirstFrame->mnDPIX;
 600                             pVirDev->mnDPIY = pFirstFrame->mnDPIY;
 601                             if ( pVirDev->IsMapMode() )
 602                             {
 603                                 MapMode aMapMode = pVirDev->GetMapMode();
 604                                 pVirDev->SetMapMode();
 605                                 pVirDev->SetMapMode( aMapMode );
 606                             }
 607                         }
 608
 609                         pVirDev = pVirDev->mpNext;
 610                     }
 611                 }
 612             }
 613         }
 614     }
 615 }
 616
 617 const AllSettings& Application::GetSettings()
 618 {
 619     ImplSVData* pSVData = ImplGetSVData();
 620     if ( !pSVData->maAppData.mpSettings )
 621     {
 622         pSVData->maAppData.mpCfgListener = new LocaleConfigurationListener;
 623         pSVData->maAppData.mpSettings = new AllSettings();
 624         pSVData->maAppData.mpSettings->GetSysLocale().GetOptions().AddListener( pSVData->maAppData.mpCfgListener );
 625     }
 626
 627     return *(pSVData->maAppData.mpSettings);
 628 }
 629
 630 void Application::NotifyAllWindows( DataChangedEvent& rDCEvt )
 631 {
 632     ImplSVData* pSVData = ImplGetSVData();
 633     Window*     pFrame = pSVData->maWinData.mpFirstFrame;
 634     while ( pFrame )
 635     {
 636         pFrame->NotifyAllChildren( rDCEvt );
 637
 638         Window* pSysWin = pFrame->mpWindowImpl->mpFrameData->mpFirstOverlap;
 639         while ( pSysWin )
 640         {
 641             pSysWin->NotifyAllChildren( rDCEvt );
 642             pSysWin = pSysWin->mpWindowImpl->mpNextOverlap;
 643         }
 644
 645         pFrame = pFrame->mpWindowImpl->mpFrameData->mpNextFrame;
 646     }
 647 }
 648
 649 void Application::ImplCallEventListeners( sal_uLong nEvent, Window *pWin, void* pData )
 650 {
 651     ImplSVData* pSVData = ImplGetSVData();
 652     VclWindowEvent aEvent( pWin, nEvent, pData );
 653
 654     if ( pSVData->maAppData.mpEventListeners )
 655         pSVData->maAppData.mpEventListeners->Call( &aEvent );
 656 }
 657
 658 void Application::ImplCallEventListeners( VclSimpleEvent* pEvent )
 659 {
 660     ImplSVData* pSVData = ImplGetSVData();
 661
 662     if ( pSVData->maAppData.mpEventListeners )
 663         pSVData->maAppData.mpEventListeners->Call( pEvent );
 664 }
 665
 666 void Application::AddEventListener( const Link& rEventListener )
 667 {
 668     ImplSVData* pSVData = ImplGetSVData();
 669     if( !pSVData->maAppData.mpEventListeners )
 670         pSVData->maAppData.mpEventListeners = new VclEventListeners;
 671     pSVData->maAppData.mpEventListeners->addListener( rEventListener );
 672 }
 673
 674 void Application::RemoveEventListener( const Link& rEventListener )
 675 {
 676     ImplSVData* pSVData = ImplGetSVData();
 677     if( pSVData->maAppData.mpEventListeners )
 678         pSVData->maAppData.mpEventListeners->removeListener( rEventListener );
 679 }
 680
 681 void Application::AddKeyListener( const Link& rKeyListener )
 682 {
 683     ImplSVData* pSVData = ImplGetSVData();
 684     if( !pSVData->maAppData.mpKeyListeners )
 685         pSVData->maAppData.mpKeyListeners = new VclEventListeners;
 686     pSVData->maAppData.mpKeyListeners->addListener( rKeyListener );
 687 }
 688
 689 void Application::RemoveKeyListener( const Link& rKeyListener )
 690 {
 691     ImplSVData* pSVData = ImplGetSVData();
 692     if( pSVData->maAppData.mpKeyListeners )
 693         pSVData->maAppData.mpKeyListeners->removeListener( rKeyListener );
 694 }
 695
 696 sal_Bool Application::HandleKey( sal_uLong nEvent, Window *pWin, KeyEvent* pKeyEvent )
 697 {
 698     // let listeners process the key event
 699     VclWindowEvent aEvent( pWin, nEvent, (void *) pKeyEvent );
 700
 701     ImplSVData* pSVData = ImplGetSVData();
 702     sal_Bool bProcessed = sal_False;
 703
 704     if ( pSVData->maAppData.mpKeyListeners )
 705         bProcessed = pSVData->maAppData.mpKeyListeners->Process( &aEvent );
 706
 707     return bProcessed;
 708 }
 709
 710 sal_uLong Application::PostKeyEvent( sal_uLong nEvent, Window *pWin, KeyEvent* pKeyEvent )
 711 {
 712     const SolarMutexGuard aGuard;
 713     sal_uLong               nEventId = 0;
 714
 715     if( pWin && pKeyEvent )
 716     {
 717         ImplPostEventData* pPostEventData = new ImplPostEventData( nEvent, pWin, *pKeyEvent );
 718
 719         PostUserEvent( nEventId,
 720                        STATIC_LINK( NULL, Application, PostEventHandler ),
 721                        pPostEventData );
 722
 723         if( nEventId )
 724         {
 725             pPostEventData->mnEventId = nEventId;
 726             aPostedEventList.push_back( ImplPostEventPair( pWin, pPostEventData ) );
 727         }
 728         else
 729             delete pPostEventData;
 730     }
 731
 732     return nEventId;
 733 }
 734
 735 sal_uLong Application::PostMouseEvent( sal_uLong nEvent, Window *pWin, MouseEvent* pMouseEvent )
 736 {
 737     const SolarMutexGuard aGuard;
 738     sal_uLong               nEventId = 0;
 739
 740     if( pWin && pMouseEvent )
 741     {
 742         Point aTransformedPos( pMouseEvent->GetPosPixel() );
 743
 744         aTransformedPos.X() += pWin->mnOutOffX;
 745         aTransformedPos.Y() += pWin->mnOutOffY;
 746
 747         const MouseEvent aTransformedEvent( aTransformedPos, pMouseEvent->GetClicks(), pMouseEvent->GetMode(),
 748                                             pMouseEvent->GetButtons(), pMouseEvent->GetModifier() );
 749
 750         ImplPostEventData* pPostEventData = new ImplPostEventData( nEvent, pWin, aTransformedEvent );
 751
 752         PostUserEvent( nEventId,
 753                        STATIC_LINK( NULL, Application, PostEventHandler ),
 754                        pPostEventData );
 755
 756         if( nEventId )
 757         {
 758             pPostEventData->mnEventId = nEventId;
 759             aPostedEventList.push_back( ImplPostEventPair( pWin, pPostEventData ) );
 760         }
 761         else
 762             delete pPostEventData;
 763     }
 764
 765     return nEventId;
 766 }
 767
 768 #if !HAVE_FEATURE_DESKTOP
 769
 770 sal_uLong Application::PostZoomEvent( sal_uLong nEvent, Window *pWin, ZoomEvent* pZoomEvent )
 771 {
 772     const SolarMutexGuard aGuard;
 773     sal_uLong               nEventId = 0;
 774
 775     if( pWin && pZoomEvent )
 776     {
 777         Point aTransformedPos( pZoomEvent->GetCenter() );
 778
 779         aTransformedPos.X() += pWin->mnOutOffX;
 780         aTransformedPos.Y() += pWin->mnOutOffY;
 781
 782         const ZoomEvent aTransformedEvent( aTransformedPos, pZoomEvent->GetScale() );
 783
 784         ImplPostEventData* pPostEventData = new ImplPostEventData( nEvent, pWin, aTransformedEvent );
 785
 786         PostUserEvent( nEventId,
 787                        STATIC_LINK( NULL, Application, PostEventHandler ),
 788                        pPostEventData );
 789
 790         if( nEventId )
 791         {
 792             pPostEventData->mnEventId = nEventId;
 793             aPostedEventList.push_back( ImplPostEventPair( pWin, pPostEventData ) );
 794         }
 795         else
 796             delete pPostEventData;
 797     }
 798
 799     return nEventId;
 800 }
 801
 802 sal_uLong Application::PostScrollEvent( sal_uLong nEvent, Window *pWin, ScrollEvent* pScrollEvent )
 803 {
 804     const SolarMutexGuard aGuard;
 805     sal_uLong               nEventId = 0;
 806
 807     if( pWin && pScrollEvent )
 808     {
 809         ImplPostEventData* pPostEventData = new ImplPostEventData( nEvent, pWin, *pScrollEvent );
 810
 811         PostUserEvent( nEventId,
 812                        STATIC_LINK( NULL, Application, PostEventHandler ),
 813                        pPostEventData );
 814
 815         if( nEventId )
 816         {
 817             pPostEventData->mnEventId = nEventId;
 818             aPostedEventList.push_back( ImplPostEventPair( pWin, pPostEventData ) );
 819         }
 820         else
 821             delete pPostEventData;
 822     }
 823
 824     return nEventId;
 825 }
 826
 827 #endif // !HAVE_FEATURE_DESKTOP
 828
 829 IMPL_STATIC_LINK_NOINSTANCE( Application, PostEventHandler, void*, pCallData )
 830 {
 831     const SolarMutexGuard aGuard;
 832     ImplPostEventData*  pData = static_cast< ImplPostEventData * >( pCallData );
 833     const void*         pEventData;
 834     sal_uLong               nEvent;
 835     const sal_uLong         nEventId = pData->mnEventId;
 836
 837     switch( pData->mnEvent )
 838     {
 839         case VCLEVENT_WINDOW_MOUSEMOVE:
 840             nEvent = SALEVENT_EXTERNALMOUSEMOVE;
 841             pEventData = &pData->maMouseEvent;
 842         break;
 843
 844         case VCLEVENT_WINDOW_MOUSEBUTTONDOWN:
 845             nEvent = SALEVENT_EXTERNALMOUSEBUTTONDOWN;
 846             pEventData = &pData->maMouseEvent;
 847         break;
 848
 849         case VCLEVENT_WINDOW_MOUSEBUTTONUP:
 850             nEvent = SALEVENT_EXTERNALMOUSEBUTTONUP;
 851             pEventData = &pData->maMouseEvent;
 852         break;
 853
 854         case VCLEVENT_WINDOW_KEYINPUT:
 855             nEvent = SALEVENT_EXTERNALKEYINPUT;
 856             pEventData = &pData->maKeyEvent;
 857         break;
 858
 859         case VCLEVENT_WINDOW_KEYUP:
 860             nEvent = SALEVENT_EXTERNALKEYUP;
 861             pEventData = &pData->maKeyEvent;
 862         break;
 863
 864         case VCLEVENT_WINDOW_ZOOM:
 865             nEvent = SALEVENT_EXTERNALZOOM;
 866             pEventData = &pData->maZoomEvent;
 867         break;
 868
 869         case VCLEVENT_WINDOW_SCROLL:
 870             nEvent = SALEVENT_EXTERNALSCROLL;
 871             pEventData = &pData->maScrollEvent;
 872         break;
 873
 874         default:
 875             nEvent = 0;
 876             pEventData = NULL;
 877         break;
 878     };
 879
 880     if( pData->mpWin && pData->mpWin->mpWindowImpl->mpFrameWindow && pEventData )
 881         ImplWindowFrameProc( pData->mpWin->mpWindowImpl->mpFrameWindow, NULL, (sal_uInt16) nEvent, pEventData );
 882
 883     // remove this event from list of posted events, watch for destruction of internal data
 884     ::std::list< ImplPostEventPair >::iterator aIter( aPostedEventList.begin() );
 885
 886     while( aIter != aPostedEventList.end() )
 887     {
 888         if( nEventId == (*aIter).second->mnEventId )
 889         {
 890             delete (*aIter).second;
 891             aIter = aPostedEventList.erase( aIter );
 892         }
 893         else
 894             ++aIter;
 895     }
 896
 897     return 0;
 898 }
 899
 900 void Application::RemoveMouseAndKeyEvents( Window* pWin )
 901 {
 902     const SolarMutexGuard aGuard;
 903
 904     // remove all events for specific window, watch for destruction of internal data
 905     ::std::list< ImplPostEventPair >::iterator aIter( aPostedEventList.begin() );
 906
 907     while( aIter != aPostedEventList.end() )
 908     {
 909         if( pWin == (*aIter).first )
 910         {
 911             if( (*aIter).second->mnEventId )
 912                 RemoveUserEvent( (*aIter).second->mnEventId );
 913
 914             delete (*aIter).second;
 915             aIter = aPostedEventList.erase( aIter );
 916         }
 917         else
 918             ++aIter;
 919     }
 920 }
 921
 922 sal_uLong Application::PostUserEvent( const Link& rLink, void* pCaller )
 923 {
 924     sal_uLong nEventId;
 925     PostUserEvent( nEventId, rLink, pCaller );
 926     return nEventId;
 927 }
 928
 929 sal_Bool Application::PostUserEvent( sal_uLong& rEventId, const Link& rLink, void* pCaller )
 930 {
 931     ImplSVEvent* pSVEvent = new ImplSVEvent;
 932     pSVEvent->mnEvent   = 0;
 933     pSVEvent->mpData    = pCaller;
 934     pSVEvent->mpLink    = new Link( rLink );
 935     pSVEvent->mpWindow  = NULL;
 936     pSVEvent->mbCall    = sal_True;
 937     rEventId = (sal_uLong)pSVEvent;
 938     Window* pDefWindow = ImplGetDefaultWindow();
 939     if ( pDefWindow && pDefWindow->ImplGetFrame()->PostEvent( pSVEvent ) )
 940         return sal_True;
 941     else
 942     {
 943         rEventId = 0;
 944         delete pSVEvent;
 945         return sal_False;
 946     }
 947 }
 948
 949 void Application::RemoveUserEvent( sal_uLong nUserEvent )
 950 {
 951     if(nUserEvent)
 952     {
 953         ImplSVEvent* pSVEvent = (ImplSVEvent*)nUserEvent;
 954
 955         DBG_ASSERT( !pSVEvent->mpWindow,
 956                     "Application::RemoveUserEvent(): Event is send to a window" );
 957         DBG_ASSERT( pSVEvent->mbCall,
 958                     "Application::RemoveUserEvent(): Event is already removed" );
 959
 960         if ( pSVEvent->mpWindow )
 961         {
 962             if( ! pSVEvent->maDelData.IsDead() )
 963                 pSVEvent->mpWindow->ImplRemoveDel( &(pSVEvent->maDelData) );
 964             pSVEvent->mpWindow = NULL;
 965         }
 966
 967         pSVEvent->mbCall = sal_False;
 968     }
 969 }
 970
 971 sal_Bool Application::InsertIdleHdl( const Link& rLink, sal_uInt16 nPrio )
 972 {
 973     ImplSVData* pSVData = ImplGetSVData();
 974
 975     // create if does not exist
 976     if ( !pSVData->maAppData.mpIdleMgr )
 977         pSVData->maAppData.mpIdleMgr = new ImplIdleMgr;
 978
 979     return pSVData->maAppData.mpIdleMgr->InsertIdleHdl( rLink, nPrio );
 980 }
 981
 982 void Application::RemoveIdleHdl( const Link& rLink )
 983 {
 984     ImplSVData* pSVData = ImplGetSVData();
 985
 986     if ( pSVData->maAppData.mpIdleMgr )
 987         pSVData->maAppData.mpIdleMgr->RemoveIdleHdl( rLink );
 988 }
 989
 990 void Application::EnableNoYieldMode( bool i_bNoYield )
 991 {
 992     ImplSVData* pSVData = ImplGetSVData();
 993     pSVData->maAppData.mbNoYield = i_bNoYield;
 994 }
 995
 996 void Application::AddPostYieldListener( const Link& i_rListener )
 997 {
 998     ImplSVData* pSVData = ImplGetSVData();
 999     if( ! pSVData->maAppData.mpPostYieldListeners )
1000         pSVData->maAppData.mpPostYieldListeners = new VclEventListeners2();
1001     pSVData->maAppData.mpPostYieldListeners->addListener( i_rListener );
1002 }
1003
1004 void Application::RemovePostYieldListener( const Link& i_rListener )
1005 {
1006     ImplSVData* pSVData = ImplGetSVData();
1007     if( pSVData->maAppData.mpPostYieldListeners )
1008         pSVData->maAppData.mpPostYieldListeners->removeListener( i_rListener );
1009 }
1010
1011 WorkWindow* Application::GetAppWindow()
1012 {
1013     return ImplGetSVData()->maWinData.mpAppWin;
1014 }
1015
1016 Window* Application::GetFocusWindow()
1017 {
1018     return ImplGetSVData()->maWinData.mpFocusWin;
1019 }
1020
1021 OutputDevice* Application::GetDefaultDevice()
1022 {
1023     return ImplGetDefaultWindow();
1024 }
1025
1026 Window* Application::GetFirstTopLevelWindow()
1027 {
1028     ImplSVData* pSVData = ImplGetSVData();
1029     return pSVData->maWinData.mpFirstFrame;
1030 }
1031
1032 Window* Application::GetNextTopLevelWindow( Window* pWindow )
1033 {
1034     return pWindow->mpWindowImpl->mpFrameData->mpNextFrame;
1035 }
1036
1037 long    Application::GetTopWindowCount()
1038 {
1039     long nRet = 0;
1040     ImplSVData* pSVData = ImplGetSVData();
1041     Window *pWin = pSVData ? pSVData->maWinData.mpFirstFrame : NULL;
1042     while( pWin )
1043     {
1044         if( pWin->ImplGetWindow()->IsTopWindow() )
1045             nRet++;
1046         pWin = pWin->mpWindowImpl->mpFrameData->mpNextFrame;
1047     }
1048     return nRet;
1049 }
1050
1051 Window* Application::GetTopWindow( long nIndex )
1052 {
1053     long nIdx = 0;
1054     ImplSVData* pSVData = ImplGetSVData();
1055     Window *pWin = pSVData ? pSVData->maWinData.mpFirstFrame : NULL;
1056     while( pWin )
1057     {
1058         if( pWin->ImplGetWindow()->IsTopWindow() )
1059         {
1060             if( nIdx == nIndex )
1061                 return pWin->ImplGetWindow();
1062             else
1063                 nIdx++;
1064         }
1065         pWin = pWin->mpWindowImpl->mpFrameData->mpNextFrame;
1066     }
1067     return NULL;
1068 }
1069
1070 Window* Application::GetActiveTopWindow()
1071 {
1072     Window *pWin = ImplGetSVData()->maWinData.mpFocusWin;
1073     while( pWin )
1074     {
1075         if( pWin->IsTopWindow() )
1076             return pWin;
1077         pWin = pWin->mpWindowImpl->mpParent;
1078     }
1079     return NULL;
1080 }
1081
1082 void Application::SetAppName( const OUString& rUniqueName )
1083 {
1084     ImplSVData* pSVData = ImplGetSVData();
1085
1086     // create if does not exist
1087     if ( !pSVData->maAppData.mpAppName )
1088         pSVData->maAppData.mpAppName = new OUString( rUniqueName );
1089     else
1090         *(pSVData->maAppData.mpAppName) = rUniqueName;
1091 }
1092
1093 OUString Application::GetAppName()
1094 {
1095     ImplSVData* pSVData = ImplGetSVData();
1096     if ( pSVData->maAppData.mpAppName )
1097         return *(pSVData->maAppData.mpAppName);
1098     else
1099         return OUString();
1100 }
1101
1102 void Application::SetDisplayName( const OUString& rName )
1103 {
1104     ImplSVData* pSVData = ImplGetSVData();
1105
1106     // create if does not exist
1107     if ( !pSVData->maAppData.mpDisplayName )
1108         pSVData->maAppData.mpDisplayName = new OUString( rName );
1109     else
1110         *(pSVData->maAppData.mpDisplayName) = rName;
1111 }
1112
1113 OUString Application::GetDisplayName()
1114 {
1115     ImplSVData* pSVData = ImplGetSVData();
1116     if ( pSVData->maAppData.mpDisplayName )
1117         return *(pSVData->maAppData.mpDisplayName);
1118     else if ( pSVData->maWinData.mpAppWin )
1119         return pSVData->maWinData.mpAppWin->GetText();
1120     else
1121         return OUString("");
1122 }
1123
1124 unsigned int Application::GetScreenCount()
1125 {
1126     SalSystem* pSys = ImplGetSalSystem();
1127     return pSys ? pSys->GetDisplayScreenCount() : 0;
1128 }
1129
1130 bool Application::IsUnifiedDisplay()
1131 {
1132     SalSystem* pSys = ImplGetSalSystem();
1133     return pSys ? pSys->IsUnifiedDisplay() : true;
1134 }
1135
1136 unsigned int Application::GetDisplayBuiltInScreen()
1137 {
1138     SalSystem* pSys = ImplGetSalSystem();
1139     return pSys ? pSys->GetDisplayBuiltInScreen() : 0;
1140 }
1141
1142 unsigned int Application::GetDisplayExternalScreen()
1143 {
1144     // This is really unpleasant, in theory we could have multiple
1145     // external displays etc.
1146     int nExternal(0);
1147     switch (GetDisplayBuiltInScreen())
1148     {
1149     case 0:
1150         nExternal = 1;
1151         break;
1152     case 1:
1153         nExternal = 0;
1154         break;
1155     default:
1156         // When the built-in display is neither 0 nor 1
1157         // then place the full-screen presentation on the
1158         // first available screen.
1159         nExternal = 0;
1160         break;
1161     }
1162     return nExternal;
1163 }
1164
1165 Rectangle Application::GetScreenPosSizePixel( unsigned int nScreen )
1166 {
1167     SalSystem* pSys = ImplGetSalSystem();
1168     return pSys ? pSys->GetDisplayScreenPosSizePixel( nScreen ) : Rectangle();
1169 }
1170
1171 namespace {
1172 unsigned long calcDistSquare( const Point& i_rPoint, const Rectangle& i_rRect )
1173 {
1174     const Point aRectCenter( (i_rRect.Left() + i_rRect.Right())/2,
1175                        (i_rRect.Top() + i_rRect.Bottom())/ 2 );
1176     const long nDX = aRectCenter.X() - i_rPoint.X();
1177     const long nDY = aRectCenter.Y() - i_rPoint.Y();
1178     return nDX*nDX + nDY*nDY;
1179 }
1180 }
1181
1182 unsigned int Application::GetBestScreen( const Rectangle& i_rRect )
1183 {
1184     if( !IsUnifiedDisplay() )
1185         return GetDisplayBuiltInScreen();
1186
1187     const unsigned int nScreens = GetScreenCount();
1188     unsigned int nBestMatchScreen = 0;
1189     unsigned long nOverlap = 0;
1190     for( unsigned int i = 0; i < nScreens; i++ )
1191     {
1192         const Rectangle aCurScreenRect( GetScreenPosSizePixel( i ) );
1193         // if a screen contains the rectangle completely it is obviously the best screen
1194         if( aCurScreenRect.IsInside( i_rRect ) )
1195             return i;
1196         // next the screen which contains most of the area of the rect is the best
1197         Rectangle aIntersection( aCurScreenRect.GetIntersection( i_rRect ) );
1198         if( ! aIntersection.IsEmpty() )
1199         {
1200             const unsigned long nCurOverlap( aIntersection.GetWidth() * aIntersection.GetHeight() );
1201             if( nCurOverlap > nOverlap )
1202             {
1203                 nOverlap = nCurOverlap;
1204                 nBestMatchScreen = i;
1205             }
1206         }
1207     }
1208     if( nOverlap > 0 )
1209         return nBestMatchScreen;
1210
1211     // finally the screen which center is nearest to the rect is the best
1212     const Point aCenter( (i_rRect.Left() + i_rRect.Right())/2,
1213                          (i_rRect.Top() + i_rRect.Bottom())/2 );
1214     unsigned long nDist = ULONG_MAX;
1215     for( unsigned int i = 0; i < nScreens; i++ )
1216     {
1217         const Rectangle aCurScreenRect( GetScreenPosSizePixel( i ) );
1218         const unsigned long nCurDist( calcDistSquare( aCenter, aCurScreenRect ) );
1219         if( nCurDist < nDist )
1220         {
1221             nBestMatchScreen = i;
1222             nDist = nCurDist;
1223         }
1224     }
1225     return nBestMatchScreen;
1226 }
1227
1228 sal_Bool Application::InsertAccel( Accelerator* pAccel )
1229 {
1230     ImplSVData* pSVData = ImplGetSVData();
1231
1232     if ( !pSVData->maAppData.mpAccelMgr )
1233         pSVData->maAppData.mpAccelMgr = new ImplAccelManager();
1234     return pSVData->maAppData.mpAccelMgr->InsertAccel( pAccel );
1235 }
1236
1237 void Application::RemoveAccel( Accelerator* pAccel )
1238 {
1239     ImplSVData* pSVData = ImplGetSVData();
1240
1241     if ( pSVData->maAppData.mpAccelMgr )
1242         pSVData->maAppData.mpAccelMgr->RemoveAccel( pAccel );
1243 }
1244
1245 void Application::SetHelp( Help* pHelp )
1246 {
1247     ImplGetSVData()->maAppData.mpHelp = pHelp;
1248 }
1249
1250 Help* Application::GetHelp()
1251 {
1252     return ImplGetSVData()->maAppData.mpHelp;
1253 }
1254
1255 void Application::EnableAutoHelpId( sal_Bool bEnabled )
1256 {
1257     ImplGetSVData()->maHelpData.mbAutoHelpId = bEnabled;
1258 }
1259
1260 sal_Bool Application::IsAutoHelpIdEnabled()
1261 {
1262     return ImplGetSVData()->maHelpData.mbAutoHelpId;
1263 }
1264
1265 void Application::EnableAutoMnemonic( sal_Bool bEnabled )
1266 {
1267     AllSettings aSettings = GetSettings();
1268     StyleSettings aStyle = aSettings.GetStyleSettings();
1269     aStyle.SetAutoMnemonic( bEnabled );
1270     aSettings.SetStyleSettings( aStyle );
1271     SetSettings( aSettings );
1272 }
1273
1274 sal_Bool Application::IsAutoMnemonicEnabled()
1275 {
1276     return GetSettings().GetStyleSettings().GetAutoMnemonic();
1277 }
1278
1279 void Application::SetDialogScaleX( short nScale )
1280 {
1281     ImplSVData* pSVData = ImplGetSVData();
1282     pSVData->maAppData.mnDialogScaleX = nScale;
1283     pSVData->maGDIData.mnAppFontX = pSVData->maGDIData.mnRealAppFontX;
1284     if ( nScale )
1285         pSVData->maGDIData.mnAppFontX += (pSVData->maGDIData.mnAppFontX*nScale)/100;
1286 }
1287
1288 void Application::SetDefDialogParent( Window* pWindow )
1289 {
1290     ImplGetSVData()->maWinData.mpDefDialogParent = pWindow;
1291 }
1292
1293 Window* Application::GetDefDialogParent()
1294 {
1295     ImplSVData* pSVData = ImplGetSVData();
1296     // #103442# find some useful dialog parent if there
1297     // was no default set
1298     // NOTE: currently even the default is not used
1299     if( sal_False && pSVData->maWinData.mpDefDialogParent != NULL )
1300         return pSVData->maWinData.mpDefDialogParent;
1301     else
1302     {
1303         // always use the topmost parent of the candidate
1304         // window to avoid using dialogs or floaters
1305         // as DefDialogParent
1306
1307         // current focus frame
1308         Window *pWin = NULL;
1309         if( (pWin = pSVData->maWinData.mpFocusWin) != NULL )
1310         {
1311             while( pWin->mpWindowImpl && pWin->mpWindowImpl->mpParent )
1312                 pWin = pWin->mpWindowImpl->mpParent;
1313
1314             if( (pWin->mpWindowImpl->mnStyle & WB_INTROWIN) == 0 )
1315             {
1316                 // check for corrupted window hierarchy, #122232#, may be we now crash somewhere else
1317                 if( !pWin->mpWindowImpl )
1318                 {
1319                     OSL_FAIL( "Window hierarchy corrupted!" );
1320                     pSVData->maWinData.mpFocusWin = NULL;   // avoid further access
1321                     return NULL;
1322                 }
1323
1324                 return pWin->mpWindowImpl->mpFrameWindow->ImplGetWindow();
1325             }
1326         }
1327         // last active application frame
1328         if( NULL != (pWin = pSVData->maWinData.mpActiveApplicationFrame) )
1329         {
1330             return pWin->mpWindowImpl->mpFrameWindow->ImplGetWindow();
1331         }
1332         else
1333         {
1334             // first visible top window (may be totally wrong....)
1335             pWin = pSVData->maWinData.mpFirstFrame;
1336             while( pWin )
1337             {
1338                 if( pWin->ImplGetWindow()->IsTopWindow() &&
1339                     pWin->mpWindowImpl->mbReallyVisible &&
1340                     (pWin->mpWindowImpl->mnStyle & WB_INTROWIN) == 0
1341                 )
1342                 {
1343                     while( pWin->mpWindowImpl->mpParent )
1344                         pWin = pWin->mpWindowImpl->mpParent;
1345                     return pWin->mpWindowImpl->mpFrameWindow->ImplGetWindow();
1346                 }
1347                 pWin = pWin->mpWindowImpl->mpFrameData->mpNextFrame;
1348             }
1349             // use the desktop
1350             return NULL;
1351         }
1352     }
1353 }
1354
1355 Application::DialogCancelMode Application::GetDialogCancelMode()
1356 {
1357     return ImplGetSVData()->maAppData.meDialogCancel;
1358 }
1359
1360 void Application::SetDialogCancelMode( DialogCancelMode mode )
1361 {
1362     ImplGetSVData()->maAppData.meDialogCancel = mode;
1363 }
1364
1365 sal_Bool Application::IsDialogCancelEnabled()
1366 {
1367     return ImplGetSVData()->maAppData.meDialogCancel != DIALOG_CANCEL_OFF;
1368 }
1369
1370 void Application::SetSystemWindowMode( sal_uInt16 nMode )
1371 {
1372     ImplGetSVData()->maAppData.mnSysWinMode = nMode;
1373 }
1374
1375 sal_uInt16 Application::GetSystemWindowMode()
1376 {
1377     return ImplGetSVData()->maAppData.mnSysWinMode;
1378 }
1379
1380 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XToolkit > Application::GetVCLToolkit()
1381 {
1382     ::com::sun::star::uno::Reference< ::com::sun::star::awt::XToolkit > xT;
1383     UnoWrapperBase* pWrapper = Application::GetUnoWrapper( sal_True );
1384     if ( pWrapper )
1385         xT = pWrapper->GetVCLToolkit();
1386     return xT;
1387 }
1388
1389 #ifdef DISABLE_DYNLOADING
1390
1391 extern "C" { UnoWrapperBase* CreateUnoWrapper(); }
1392
1393 #else
1394
1395 extern "C" { static void SAL_CALL thisModule() {} }
1396
1397 #endif
1398
1399 UnoWrapperBase* Application::GetUnoWrapper( sal_Bool bCreateIfNotExist )
1400 {
1401     ImplSVData* pSVData = ImplGetSVData();
1402     static bool bAlreadyTriedToCreate = false;
1403     if ( !pSVData->mpUnoWrapper && bCreateIfNotExist && !bAlreadyTriedToCreate )
1404     {
1405 #ifndef DISABLE_DYNLOADING
1406         OUString aLibName = ::vcl::unohelper::CreateLibraryName(
1407 #ifdef LIBO_MERGELIBS
1408                                                                        "merged",
1409 #else
1410                                                                        "tk",
1411 #endif
1412                                                                        sal_True );
1413         oslModule hTkLib = osl_loadModuleRelative(
1414             &thisModule, aLibName.pData, SAL_LOADMODULE_DEFAULT );
1415         if ( hTkLib )
1416         {
1417             OUString aFunctionName( "CreateUnoWrapper" );
1418             FN_TkCreateUnoWrapper fnCreateWrapper = (FN_TkCreateUnoWrapper)osl_getFunctionSymbol( hTkLib, aFunctionName.pData );
1419             if ( fnCreateWrapper )
1420             {
1421                 pSVData->mpUnoWrapper = fnCreateWrapper();
1422             }
1423         }
1424         DBG_ASSERT( pSVData->mpUnoWrapper, "UnoWrapper could not be created!" );
1425 #else
1426         pSVData->mpUnoWrapper = CreateUnoWrapper();
1427 #endif
1428         bAlreadyTriedToCreate = true;
1429     }
1430     return pSVData->mpUnoWrapper;
1431 }
1432
1433 void Application::SetUnoWrapper( UnoWrapperBase* pWrapper )
1434 {
1435     ImplSVData* pSVData = ImplGetSVData();
1436     DBG_ASSERT( !pSVData->mpUnoWrapper, "SetUnoWrapper: Wrapper already exists" );
1437     pSVData->mpUnoWrapper = pWrapper;
1438 }
1439
1440 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XDisplayConnection > Application::GetDisplayConnection()
1441 {
1442     ImplSVData* pSVData = ImplGetSVData();
1443
1444     if( !pSVData->mxDisplayConnection.is() )
1445     {
1446         pSVData->mxDisplayConnection.set( new ::vcl::DisplayConnection );
1447         pSVData->mxDisplayConnection->start();
1448     }
1449
1450     return pSVData->mxDisplayConnection.get();
1451 }
1452
1453 void Application::SetFilterHdl( const Link& rLink )
1454 {
1455     ImplGetSVData()->maGDIData.mpGrfConverter->SetFilterHdl( rLink );
1456 }
1457
1458 bool ImplCallHotKey( const KeyCode& rKeyCode )
1459 {
1460     ImplSVData*     pSVData = ImplGetSVData();
1461     ImplHotKey*     pHotKeyData = pSVData->maAppData.mpFirstHotKey;
1462     while ( pHotKeyData )
1463     {
1464         if ( pHotKeyData->maKeyCode.IsDefinedKeyCodeEqual( rKeyCode ) )
1465         {
1466             pHotKeyData->maLink.Call( pHotKeyData->mpUserData );
1467             return true;
1468         }
1469
1470         pHotKeyData = pHotKeyData->mpNext;
1471     }
1472
1473     return false;
1474 }
1475
1476 void ImplFreeHotKeyData()
1477 {
1478     ImplSVData*     pSVData = ImplGetSVData();
1479     ImplHotKey*     pTempHotKeyData;
1480     ImplHotKey*     pHotKeyData = pSVData->maAppData.mpFirstHotKey;
1481     while ( pHotKeyData )
1482     {
1483         pTempHotKeyData = pHotKeyData->mpNext;
1484         delete pHotKeyData;
1485         pHotKeyData = pTempHotKeyData;
1486     }
1487
1488     pSVData->maAppData.mpFirstHotKey = NULL;
1489 }
1490
1491 void ImplFreeEventHookData()
1492 {
1493     ImplSVData*     pSVData = ImplGetSVData();
1494     ImplEventHook*  pTempEventHookData;
1495     ImplEventHook*  pEventHookData = pSVData->maAppData.mpFirstEventHook;
1496     while ( pEventHookData )
1497     {
1498         pTempEventHookData = pEventHookData->mpNext;
1499         delete pEventHookData;
1500         pEventHookData = pTempEventHookData;
1501     }
1502
1503     pSVData->maAppData.mpFirstEventHook = NULL;
1504 }
1505
1506 long Application::CallEventHooks( NotifyEvent& rEvt )
1507 {
1508     ImplSVData*     pSVData = ImplGetSVData();
1509     long            nRet = 0;
1510     ImplEventHook*  pTempEventHookData;
1511     ImplEventHook*  pEventHookData = pSVData->maAppData.mpFirstEventHook;
1512     while ( pEventHookData )
1513     {
1514         pTempEventHookData = pEventHookData->mpNext;
1515         nRet = pEventHookData->mpProc( rEvt, pEventHookData->mpUserData );
1516         if ( nRet )
1517             break;
1518         pEventHookData = pTempEventHookData;
1519     }
1520
1521     return nRet;
1522 }
1523
1524 const LocaleDataWrapper& Application::GetAppLocaleDataWrapper()
1525 {
1526     return GetSettings().GetLocaleDataWrapper();
1527 }
1528
1529 void Application::EnableHeadlessMode( bool dialogsAreFatal )
1530 {
1531     SetDialogCancelMode(
1532         dialogsAreFatal ? DIALOG_CANCEL_FATAL : DIALOG_CANCEL_SILENT );
1533 }
1534
1535 sal_Bool Application::IsHeadlessModeEnabled()
1536 {
1537     return IsDialogCancelEnabled();
1538 }
1539
1540 bool Application::IsHeadlessModeRequested()
1541 {
1542     sal_uInt32 n = rtl_getAppCommandArgCount();
1543     for (sal_uInt32 i = 0; i < n; ++i) {
1544         OUString arg;
1545         rtl_getAppCommandArg(i, &arg.pData);
1546         if ( arg == "--headless" || arg == "-headless" ) {
1547             return true;
1548         }
1549     }
1550     return false;
1551 }
1552
1553 static bool bConsoleOnly = false;
1554
1555 bool Application::IsConsoleOnly()
1556 {
1557     return bConsoleOnly;
1558 }
1559
1560 void Application::EnableConsoleOnly()
1561 {
1562     bConsoleOnly = true;
1563 }
1564
1565 void Application::ShowNativeErrorBox(const OUString& sTitle  ,
1566                                      const OUString& sMessage)
1567 {
1568     int btn = ImplGetSalSystem()->ShowNativeMessageBox (
1569             sTitle,
1570             sMessage,
1571             SALSYSTEM_SHOWNATIVEMSGBOX_BTNCOMBI_OK,
1572             SALSYSTEM_SHOWNATIVEMSGBOX_BTN_OK, false);
1573     if (btn != SALSYSTEM_SHOWNATIVEMSGBOX_BTN_OK) {
1574         OSL_TRACE("ShowNativeMessageBox returned %d", btn);
1575     }
1576 }
1577
1578 bool Application::CanToggleImeStatusWindow()
1579 {
1580     ImplSVData* pSVData = ImplGetSVData();
1581     if( ! pSVData->mpImeStatus )
1582         pSVData->mpImeStatus  = pSVData->mpDefInst->CreateI18NImeStatus();
1583     return pSVData->mpImeStatus->canToggle();
1584 }
1585
1586 void Application::ShowImeStatusWindow(bool bShow)
1587 {
1588     ImplGetSVData()->maAppData.meShowImeStatusWindow = bShow
1589         ? ImplSVAppData::ImeStatusWindowMode_SHOW
1590         : ImplSVAppData::ImeStatusWindowMode_HIDE;
1591
1592     ImplSVData* pSVData = ImplGetSVData();
1593     if( ! pSVData->mpImeStatus )
1594         pSVData->mpImeStatus  = pSVData->mpDefInst->CreateI18NImeStatus();
1595     pSVData->mpImeStatus->toggle();
1596 }
1597
1598 bool Application::GetShowImeStatusWindowDefault()
1599 {
1600     rtl_TextEncodingInfo aInfo;
1601     aInfo.StructSize = sizeof aInfo;
1602     return rtl_getTextEncodingInfo(osl_getThreadTextEncoding(), &aInfo)
1603         && aInfo.MaximumCharSize > 1;
1604 }
1605
1606 const OUString& Application::GetDesktopEnvironment()
1607 {
1608     return SalGetDesktopEnvironment();
1609 }
1610
1611 void Application::AddToRecentDocumentList(const OUString& rFileUrl, const OUString& rMimeType, const OUString& rDocumentService)
1612 {
1613     ImplSVData* pSVData = ImplGetSVData();
1614     pSVData->mpDefInst->AddToRecentDocumentList(rFileUrl, rMimeType, rDocumentService);
1615 }
1616
1617 bool InitAccessBridge( bool bShowCancel, bool &rCancelled )
1618 {
1619 // Disable Java bridge on UNIX
1620 #if defined UNX
1621     (void) bShowCancel; // unused
1622     (void) rCancelled; // unused
1623     return true;
1624 #else
1625     bool bRet = ImplInitAccessBridge( bShowCancel, rCancelled );
1626
1627     if( !bRet && bShowCancel && !rCancelled )
1628     {
1629         // disable accessibility if the user chooses to continue
1630         AllSettings aSettings = Application::GetSettings();
1631         MiscSettings aMisc = aSettings.GetMiscSettings();
1632         aMisc.SetEnableATToolSupport( sal_False );
1633         aSettings.SetMiscSettings( aMisc );
1634         Application::SetSettings( aSettings );
1635     }
1636     return bRet;
1637 #endif // !UNX
1638 }
1639
1640 // MT: AppEvent was in oldsv.cxx, but is still needed...
1641 void Application::AppEvent( const ApplicationEvent& /*rAppEvent*/ )
1642 {
1643 }
1644
1645 bool Application::hasNativeFileSelection()
1646 {
1647     ImplSVData* pSVData = ImplGetSVData();
1648     return pSVData->mpDefInst->hasNativeFileSelection();
1649 }
1650
1651 Reference< ui::dialogs::XFilePicker2 >
1652 Application::createFilePicker( const Reference< uno::XComponentContext >& xSM )
1653 {
1654     ImplSVData* pSVData = ImplGetSVData();
1655     return pSVData->mpDefInst->createFilePicker( xSM );
1656 }
1657
1658 Reference< ui::dialogs::XFolderPicker2 >
1659 Application::createFolderPicker( const Reference< uno::XComponentContext >& xSM )
1660 {
1661     ImplSVData* pSVData = ImplGetSVData();
1662     return pSVData->mpDefInst->createFolderPicker( xSM );
1663 }
1664
1665 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */