vcl/source/app/svapp.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: svapp.cxx,v $
  10  * $Revision: 1.84 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_vcl.hxx"
  33
  34 #ifndef _SV_SVSYS_HXX
  35 #include <svsys.h>
  36 #endif
  37 #include <vcl/salinst.hxx>
  38 #include <vcl/salframe.hxx>
  39 #include <vcl/salsys.hxx>
  40 #ifndef _VOS_PROCESS_HXX
  41 #include <vos/process.hxx>
  42 #endif
  43 #ifndef _VOS_MUTEX_HXX
  44 #include <vos/mutex.hxx>
  45 #endif
  46 #include <tools/tools.h>
  47 #include <tools/debug.hxx>
  48 #include <tools/time.hxx>
  49 #include <i18npool/mslangid.hxx>
  50 #include <vcl/svdata.hxx>
  51 #include <vcl/settings.hxx>
  52 #ifndef _ACCMGR_HXX
  53 #include <vcl/accmgr.hxx>
  54 #endif
  55 #ifndef _SV_KEYCOD_HXX
  56 #include <vcl/keycod.hxx>
  57 #endif
  58 #include <vcl/event.hxx>
  59 #include <vcl/virdev.hxx>
  60 #include <vcl/windata.hxx>
  61 #include <vcl/window.h>
  62 #include <vcl/wrkwin.hxx>
  63 #include <vcl/idlemgr.hxx>
  64 #include <vcl/svapp.hxx>
  65 #include <vcl/cvtgrf.hxx>
  66 #include <vcl/unowrap.hxx>
  67 #include <vcl/xconnection.hxx>
  68 #ifndef _SV_SVIDS_HRC
  69 #include <vcl/svids.hrc>
  70 #endif
  71 #include <vcl/timer.hxx>
  72
  73 #include <vcl/unohelp.hxx>
  74
  75 #include <com/sun/star/uno/Reference.h>
  76 #include <com/sun/star/awt/XToolkit.hpp>
  77 #include <com/sun/star/uno/XNamingService.hpp>
  78 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  79 #include <comphelper/processfactory.hxx>
  80
  81 #include <osl/module.h>
  82 #include <osl/file.hxx>
  83
  84 #include "osl/thread.h"
  85 #include "rtl/tencinfo.h"
  86 #include <rtl/instance.hxx>
  87 #include <vcl/salimestatus.hxx>
  88
  89 #include <utility>
  90 #include <vcl/lazydelete.hxx>
  91
  92 using namespace ::com::sun::star::uno;
  93
  94 // keycodes handled internally by VCL
  95 class ImplReservedKey
  96 {
  97 public:
  98     ImplReservedKey( KeyCode aKeyCode, USHORT nResId ) :
  99       mKeyCode(aKeyCode), mnResId( nResId)
 100      {}
 101
 102     KeyCode mKeyCode;
 103     USHORT  mnResId;
 104 };
 105
 106 typedef std::pair<ImplReservedKey*, size_t> ReservedKeys;
 107 namespace
 108 {
 109     struct ImplReservedKeysImpl
 110     {
 111         ReservedKeys* operator()()
 112         {
 113             static ImplReservedKey ImplReservedKeys[] =
 114             {
 115                 ImplReservedKey(KeyCode(KEY_F1,0),                  SV_SHORTCUT_HELP),
 116                 ImplReservedKey(KeyCode(KEY_F1,KEY_SHIFT),          SV_SHORTCUT_ACTIVEHELP),
 117                 ImplReservedKey(KeyCode(KEY_F1,KEY_MOD1),           SV_SHORTCUT_CONTEXTHELP),
 118                 ImplReservedKey(KeyCode(KEY_F2,KEY_SHIFT),          SV_SHORTCUT_CONTEXTHELP),
 119                 ImplReservedKey(KeyCode(KEY_F4,KEY_MOD1),           SV_SHORTCUT_DOCKUNDOCK),
 120                 ImplReservedKey(KeyCode(KEY_F4,KEY_MOD2),           SV_SHORTCUT_DOCKUNDOCK),
 121                 ImplReservedKey(KeyCode(KEY_F4,KEY_MOD1|KEY_MOD2),  SV_SHORTCUT_DOCKUNDOCK),
 122                 ImplReservedKey(KeyCode(KEY_F6,0),                  SV_SHORTCUT_NEXTSUBWINDOW),
 123                 ImplReservedKey(KeyCode(KEY_F6,KEY_MOD1),           SV_SHORTCUT_TODOCUMENT),
 124                 ImplReservedKey(KeyCode(KEY_F6,KEY_SHIFT),          SV_SHORTCUT_PREVSUBWINDOW),
 125                 ImplReservedKey(KeyCode(KEY_F6,KEY_MOD1|KEY_SHIFT), SV_SHORTCUT_SPLITTER),
 126                 ImplReservedKey(KeyCode(KEY_F10,0),                 SV_SHORTCUT_MENUBAR)
 127 #ifdef UNX
 128                 ,
 129                 ImplReservedKey(KeyCode(KEY_1,KEY_SHIFT|KEY_MOD1), 0),
 130                 ImplReservedKey(KeyCode(KEY_2,KEY_SHIFT|KEY_MOD1), 0),
 131                 ImplReservedKey(KeyCode(KEY_3,KEY_SHIFT|KEY_MOD1), 0),
 132                 ImplReservedKey(KeyCode(KEY_4,KEY_SHIFT|KEY_MOD1), 0),
 133                 ImplReservedKey(KeyCode(KEY_5,KEY_SHIFT|KEY_MOD1), 0),
 134                 ImplReservedKey(KeyCode(KEY_6,KEY_SHIFT|KEY_MOD1), 0),
 135                 ImplReservedKey(KeyCode(KEY_7,KEY_SHIFT|KEY_MOD1), 0),
 136                 ImplReservedKey(KeyCode(KEY_8,KEY_SHIFT|KEY_MOD1), 0),
 137                 ImplReservedKey(KeyCode(KEY_9,KEY_SHIFT|KEY_MOD1), 0),
 138                 ImplReservedKey(KeyCode(KEY_0,KEY_SHIFT|KEY_MOD1), 0),
 139                 ImplReservedKey(KeyCode(KEY_ADD,KEY_SHIFT|KEY_MOD1), 0)
 140 #endif
 141             };
 142             static ReservedKeys aKeys
 143             (
 144                 &ImplReservedKeys[0],
 145                 sizeof(ImplReservedKeys) / sizeof(ImplReservedKey)
 146             );
 147             return &aKeys;
 148         }
 149     };
 150
 151     struct ImplReservedKeys
 152         : public rtl::StaticAggregate<ReservedKeys, ImplReservedKeysImpl> {};
 153 }
 154
 155
 156 // #include <usr/refl.hxx>
 157 class Reflection;
 158
 159
 160
 161 extern "C" {
 162     typedef UnoWrapperBase* (SAL_CALL *FN_TkCreateUnoWrapper)();
 163 }
 164
 165 // =======================================================================
 166
 167 // --------------
 168 // - ImplHotKey -
 169 // --------------
 170
 171 struct ImplHotKey
 172 {
 173     ImplHotKey*             mpNext;
 174     void*                   mpUserData;
 175     KeyCode                 maKeyCode;
 176     Link                    maLink;
 177 };
 178
 179 // =======================================================================
 180
 181 // -----------------
 182 // - ImplEventHook -
 183 // -----------------
 184
 185 struct ImplEventHook
 186 {
 187     ImplEventHook*          mpNext;
 188     void*                   mpUserData;
 189     VCLEventHookProc        mpProc;
 190 };
 191
 192 // =======================================================================
 193
 194 // ---------------------
 195 // - ImplPostEventData -
 196 // ---------------------
 197
 198 struct ImplPostEventData
 199 {
 200     ULONG                       mnEvent;
 201     const Window*       mpWin;
 202     ULONG                       mnEventId;
 203     KeyEvent            maKeyEvent;
 204     MouseEvent          maMouseEvent;
 205
 206
 207        ImplPostEventData( ULONG nEvent, const Window* pWin, const KeyEvent& rKeyEvent ) :
 208         mnEvent( nEvent ), mpWin( pWin ), mnEventId( 0 ), maKeyEvent( rKeyEvent ) {}
 209        ImplPostEventData( ULONG nEvent, const Window* pWin, const MouseEvent& rMouseEvent ) :
 210         mnEvent( nEvent ), mpWin( pWin ), mnEventId( 0 ), maMouseEvent( rMouseEvent ) {}
 211
 212     ~ImplPostEventData() {}
 213 };
 214
 215 typedef ::std::pair< Window*, ImplPostEventData* > ImplPostEventPair;
 216
 217 static ::std::list< ImplPostEventPair > aPostedEventList;
 218
 219 // =======================================================================
 220
 221 Application* GetpApp()
 222 {
 223     ImplSVData* pSVData = ImplGetSVData();
 224     if ( !pSVData )
 225         return NULL;
 226     return pSVData->mpApp;
 227 }
 228
 229 // -----------------------------------------------------------------------
 230
 231 Application::Application()
 232 {
 233     if( ! ImplGetSVData() )
 234         ImplInitSVData();
 235     ImplGetSVData()->mpApp = this;
 236     InitSalData();
 237 }
 238
 239 // -----------------------------------------------------------------------
 240
 241 Application::~Application()
 242 {
 243     ImplDeInitSVData();
 244     DeInitSalData();
 245     ImplGetSVData()->mpApp = NULL;
 246     ImplDestroySVData();
 247     GlobalDeInitTools();
 248 }
 249
 250 // -----------------------------------------------------------------------
 251
 252 void Application::InitAppRes( const ResId& )
 253 {
 254 }
 255
 256 // -----------------------------------------------------------------------
 257
 258 BOOL Application::QueryExit()
 259 {
 260     WorkWindow* pAppWin = ImplGetSVData()->maWinData.mpAppWin;
 261
 262     // Aufruf des Close-Handlers des Applikationsfensters
 263     if ( pAppWin )
 264         return pAppWin->Close();
 265     else
 266         return TRUE;
 267 }
 268
 269 // -----------------------------------------------------------------------
 270
 271 void Application::UserEvent( ULONG, void* )
 272 {
 273 }
 274
 275 // -----------------------------------------------------------------------
 276
 277 void Application::ShowStatusText( const XubString& )
 278 {
 279 }
 280
 281 // -----------------------------------------------------------------------
 282
 283 void Application::ShowHelpStatusText( const XubString& )
 284 {
 285 }
 286
 287 // -----------------------------------------------------------------------
 288
 289 void Application::ActivateExtHelp()
 290 {
 291 }
 292
 293 // -----------------------------------------------------------------------
 294
 295 void Application::DeactivateExtHelp()
 296 {
 297 }
 298
 299 // -----------------------------------------------------------------------
 300
 301 void Application::HideStatusText()
 302 {
 303 }
 304
 305 // -----------------------------------------------------------------------
 306
 307 void Application::HideHelpStatusText()
 308 {
 309 }
 310
 311 // -----------------------------------------------------------------------
 312
 313 void Application::FocusChanged()
 314 {
 315 }
 316
 317 // -----------------------------------------------------------------------
 318
 319 void Application::DataChanged( const DataChangedEvent& )
 320 {
 321 }
 322
 323 // -----------------------------------------------------------------------
 324 void Application::Init()
 325 {
 326 }
 327
 328 // -----------------------------------------------------------------------
 329 void Application::InitFinished()
 330 {
 331 }
 332
 333 // -----------------------------------------------------------------------
 334
 335 void Application::DeInit()
 336 {
 337 }
 338
 339 // -----------------------------------------------------------------------
 340
 341 USHORT Application::GetCommandLineParamCount()
 342 {
 343     vos::OStartupInfo aStartInfo;
 344     return (USHORT)aStartInfo.getCommandArgCount();
 345 }
 346
 347 // -----------------------------------------------------------------------
 348
 349 XubString Application::GetCommandLineParam( USHORT nParam )
 350 {
 351     vos::OStartupInfo   aStartInfo;
 352     rtl::OUString       aParam;
 353     aStartInfo.getCommandArg( nParam, aParam );
 354     return XubString( aParam );
 355 }
 356
 357 // -----------------------------------------------------------------------
 358
 359 const XubString& Application::GetAppFileName()
 360 {
 361     ImplSVData* pSVData = ImplGetSVData();
 362     DBG_ASSERT( pSVData->maAppData.mpAppFileName, "AppFileName vor SVMain ?!" );
 363     if ( pSVData->maAppData.mpAppFileName )
 364         return *pSVData->maAppData.mpAppFileName;
 365
 366     /*
 367      *  #91147# provide a fallback for people without initialized
 368      *  vcl here (like setup in responsefile mode)
 369      */
 370     static String aAppFileName;
 371     if( !aAppFileName.Len() )
 372     {
 373         vos::OStartupInfo   aStartInfo;
 374         ::rtl::OUString         aExeFileName;
 375
 376         aStartInfo.getExecutableFile( aExeFileName );
 377
 378         // convert path to native file format
 379         rtl::OUString aNativeFileName;
 380         osl::FileBase::getSystemPathFromFileURL( aExeFileName, aNativeFileName );
 381         aAppFileName = aNativeFileName;
 382     }
 383
 384     return aAppFileName;
 385 }
 386
 387 // -----------------------------------------------------------------------
 388
 389 USHORT Application::Exception( USHORT nError )
 390 {
 391     switch ( nError & EXC_MAJORTYPE )
 392     {
 393         // Bei System machen wir nichts und lassen dem System den
 394         // vortritt
 395         case EXC_SYSTEM:
 396             return 0;
 397
 398         case EXC_DISPLAY:
 399         case EXC_REMOTE:
 400             return 0;
 401
 402 #ifdef DBG_UTIL
 403         case EXC_RSCNOTLOADED:
 404             Abort( XubString( RTL_CONSTASCII_USTRINGPARAM( "Resource not loaded" ) ) );
 405             break;
 406         case EXC_SYSOBJNOTCREATED:
 407             Abort( XubString( RTL_CONSTASCII_USTRINGPARAM( "System Object not created" ) ) );
 408             break;
 409         default:
 410             Abort( XubString( RTL_CONSTASCII_USTRINGPARAM( "Unknown Error" ) ) );
 411             break;
 412 #else
 413         default:
 414             Abort( ImplGetSVEmptyStr() );
 415             break;
 416 #endif
 417     }
 418
 419     return 0;
 420 }
 421
 422 // -----------------------------------------------------------------------
 423
 424 void Application::Abort( const XubString& rErrorText )
 425 {
 426     SalAbort( rErrorText );
 427 }
 428
 429 // -----------------------------------------------------------------------
 430
 431 ULONG   Application::GetReservedKeyCodeCount()
 432 {
 433     return ImplReservedKeys::get()->second;
 434 }
 435
 436 const KeyCode*  Application::GetReservedKeyCode( ULONG i )
 437 {
 438     if( i >= GetReservedKeyCodeCount() )
 439         return NULL;
 440     else
 441         return &ImplReservedKeys::get()->first[i].mKeyCode;
 442 }
 443
 444 String Application::GetReservedKeyCodeDescription( ULONG i )
 445 {
 446     ResMgr* pResMgr = ImplGetResMgr();
 447     if( ! pResMgr )
 448         return String();
 449     ImplReservedKey *pImplReservedKeys = ImplReservedKeys::get()->first;
 450     if( i >= GetReservedKeyCodeCount() || ! pImplReservedKeys[i].mnResId )
 451         return String();
 452     else
 453         return String( ResId( pImplReservedKeys[i].mnResId, *pResMgr ) );
 454 }
 455
 456 // -----------------------------------------------------------------------
 457
 458 void Application::Execute()
 459 {
 460     DBG_STARTAPPEXECUTE();
 461
 462     ImplSVData* pSVData = ImplGetSVData();
 463     pSVData->maAppData.mbInAppExecute = TRUE;
 464
 465     while ( !pSVData->maAppData.mbAppQuit )
 466         Application::Yield();
 467
 468     pSVData->maAppData.mbInAppExecute = FALSE;
 469
 470     DBG_ENDAPPEXECUTE();
 471 }
 472
 473 // -----------------------------------------------------------------------
 474
 475 void Application::Reschedule( bool bAllEvents )
 476 {
 477     ImplSVData* pSVData = ImplGetSVData();
 478
 479     // run timers that have timed out
 480     if ( !pSVData->mbNoCallTimer )
 481         while ( pSVData->mbNotAllTimerCalled )
 482             Timer::ImplTimerCallbackProc();
 483
 484     pSVData->maAppData.mnDispatchLevel++;
 485     pSVData->mpDefInst->Yield( false, bAllEvents );
 486     pSVData->maAppData.mnDispatchLevel--;
 487
 488     // flush lazy deleted objects
 489     if( pSVData->maAppData.mnDispatchLevel == 0 )
 490         vcl::LazyDelete::flush();
 491 }
 492
 493 // -----------------------------------------------------------------------
 494
 495 void Application::Yield( bool bAllEvents )
 496 {
 497     ImplSVData* pSVData = ImplGetSVData();
 498
 499     // run timers that have timed out
 500     if ( !pSVData->mbNoCallTimer )
 501         while ( pSVData->mbNotAllTimerCalled )
 502             Timer::ImplTimerCallbackProc();
 503
 504     // do not wait for events if application was already quit; in that
 505     // case only dispatch events already available
 506     pSVData->maAppData.mnDispatchLevel++;
 507     pSVData->mpDefInst->Yield( !pSVData->maAppData.mbAppQuit, bAllEvents );
 508     pSVData->maAppData.mnDispatchLevel--;
 509
 510     // flush lazy deleted objects
 511     if( pSVData->maAppData.mnDispatchLevel == 0 )
 512         vcl::LazyDelete::flush();
 513 }
 514
 515 // -----------------------------------------------------------------------
 516
 517 IMPL_STATIC_LINK_NOINSTANCE( ImplSVAppData, ImplQuitMsg, void*, EMPTYARG )
 518 {
 519     ImplGetSVData()->maAppData.mbAppQuit = TRUE;
 520     return 0;
 521 }
 522
 523 // -----------------------------------------------------------------------
 524
 525 void Application::Quit()
 526 {
 527     Application::PostUserEvent( STATIC_LINK( NULL, ImplSVAppData, ImplQuitMsg ) );
 528 }
 529
 530 // -----------------------------------------------------------------------
 531
 532 vos::IMutex& Application::GetSolarMutex()
 533 {
 534     ImplSVData* pSVData = ImplGetSVData();
 535     return *(pSVData->mpDefInst->GetYieldMutex());
 536 }
 537
 538 // -----------------------------------------------------------------------
 539
 540 vos::OThread::TThreadIdentifier Application::GetMainThreadIdentifier()
 541 {
 542     return ImplGetSVData()->mnMainThreadId;
 543 }
 544
 545 // -----------------------------------------------------------------------
 546
 547 ULONG Application::ReleaseSolarMutex()
 548 {
 549     ImplSVData* pSVData = ImplGetSVData();
 550     return pSVData->mpDefInst->ReleaseYieldMutex();
 551 }
 552
 553 // -----------------------------------------------------------------------
 554
 555 void Application::AcquireSolarMutex( ULONG nCount )
 556 {
 557     ImplSVData* pSVData = ImplGetSVData();
 558     pSVData->mpDefInst->AcquireYieldMutex( nCount );
 559 }
 560
 561 // -----------------------------------------------------------------------
 562
 563 BOOL Application::IsInMain()
 564 {
 565     return ImplGetSVData()->maAppData.mbInAppMain;
 566 }
 567
 568 // -----------------------------------------------------------------------
 569
 570 BOOL Application::IsInExecute()
 571 {
 572     return ImplGetSVData()->maAppData.mbInAppExecute;
 573 }
 574
 575 // -----------------------------------------------------------------------
 576
 577 BOOL Application::IsShutDown()
 578 {
 579     return ImplGetSVData()->maAppData.mbAppQuit;
 580 }
 581
 582 // -----------------------------------------------------------------------
 583
 584 BOOL Application::IsInModalMode()
 585 {
 586     return (ImplGetSVData()->maAppData.mnModalMode != 0);
 587 }
 588
 589 // -----------------------------------------------------------------------
 590
 591 USHORT Application::GetModalModeCount()
 592 {
 593     return ImplGetSVData()->maAppData.mnModalMode;
 594 }
 595
 596 // -----------------------------------------------------------------------
 597
 598 USHORT Application::GetDispatchLevel()
 599 {
 600     return ImplGetSVData()->maAppData.mnDispatchLevel;
 601 }
 602
 603 // -----------------------------------------------------------------------
 604
 605 BOOL Application::AnyInput( USHORT nType )
 606 {
 607     return (BOOL)ImplGetSVData()->mpDefInst->AnyInput( nType );
 608 }
 609
 610 // -----------------------------------------------------------------------
 611
 612 ULONG Application::GetLastInputInterval()
 613 {
 614     return (Time::GetSystemTicks()-ImplGetSVData()->maAppData.mnLastInputTime);
 615 }
 616
 617 // -----------------------------------------------------------------------
 618
 619 extern int nImplSysDialog;
 620
 621 BOOL Application::IsUICaptured()
 622 {
 623     ImplSVData* pSVData = ImplGetSVData();
 624     // Wenn Mouse gecaptured, oder im TrackingModus oder im Auswahlmodus
 625     // eines FloatingWindows (wie Menus, Aufklapp-ToolBoxen) soll kein
 626     // weiteres Fenster aufgezogen werden
 627     // D&D aktive !!!
 628     if ( pSVData->maWinData.mpCaptureWin || pSVData->maWinData.mpTrackWin ||
 629          pSVData->maWinData.mpFirstFloat || nImplSysDialog )
 630         return TRUE;
 631     else
 632         return FALSE;
 633 }
 634
 635 // -----------------------------------------------------------------------
 636
 637 BOOL Application::IsUserActive( USHORT nTest )
 638 {
 639     if ( nTest & (USERACTIVE_MOUSEDRAG | USERACTIVE_INPUT) )
 640     {
 641         if ( IsUICaptured() )
 642             return TRUE;
 643     }
 644
 645     if ( nTest & USERACTIVE_INPUT )
 646     {
 647         if ( GetLastInputInterval() < 500 )
 648             return TRUE;
 649
 650         if ( AnyInput( INPUT_KEYBOARD ) )
 651             return TRUE;
 652     }
 653
 654     if ( nTest & USERACTIVE_MODALDIALOG )
 655     {
 656         if ( ImplGetSVData()->maAppData.mnModalDialog )
 657             return TRUE;
 658     }
 659
 660     return FALSE;
 661 }
 662
 663 // -----------------------------------------------------------------------
 664
 665 void Application::SystemSettingsChanging( AllSettings& /*rSettings*/,
 666                                           Window* /*pFrame*/ )
 667 {
 668 }
 669
 670 // -----------------------------------------------------------------------
 671
 672 void Application::MergeSystemSettings( AllSettings& rSettings )
 673 {
 674     Window* pWindow = ImplGetSVData()->maWinData.mpFirstFrame;
 675     if( ! pWindow )
 676         pWindow = ImplGetDefaultWindow();
 677     if( pWindow )
 678     {
 679         ImplSVData* pSVData = ImplGetSVData();
 680         if ( !pSVData->maAppData.mbSettingsInit )
 681         {
 682             // side effect: ImplUpdateGlobalSettings does an ImplGetFrame()->UpdateSettings
 683             pWindow->ImplUpdateGlobalSettings( *pSVData->maAppData.mpSettings );
 684             pSVData->maAppData.mbSettingsInit = TRUE;
 685         }
 686         // side effect: ImplUpdateGlobalSettings does an ImplGetFrame()->UpdateSettings
 687         pWindow->ImplUpdateGlobalSettings( rSettings, FALSE );
 688     }
 689 }
 690
 691 // -----------------------------------------------------------------------
 692
 693 bool Application::ValidateSystemFont()
 694 {
 695     Window* pWindow = ImplGetSVData()->maWinData.mpFirstFrame;
 696     if( ! pWindow )
 697         pWindow = ImplGetDefaultWindow();
 698
 699     if( pWindow )
 700     {
 701         AllSettings aSettings;
 702         pWindow->ImplGetFrame()->UpdateSettings( aSettings );
 703         return pWindow->ImplCheckUIFont( aSettings.GetStyleSettings().GetAppFont() );
 704     }
 705     return false;
 706 }
 707
 708 // -----------------------------------------------------------------------
 709
 710 void Application::SetSettings( const AllSettings& rSettings )
 711 {
 712     MsLangId::setConfiguredSystemLanguage( rSettings.GetLanguage());
 713     MsLangId::setConfiguredSystemUILanguage( rSettings.GetUILanguage());
 714     ImplSVData* pSVData = ImplGetSVData();
 715     if ( !pSVData->maAppData.mpSettings )
 716     {
 717         pSVData->maAppData.mpSettings = new AllSettings();
 718         *pSVData->maAppData.mpSettings = rSettings;
 719         ResMgr::SetDefaultLocale( rSettings.GetUILocale() );
 720     }
 721     else
 722     {
 723         AllSettings aOldSettings = *pSVData->maAppData.mpSettings;
 724         if( aOldSettings.GetUILanguage() != rSettings.GetUILanguage() && pSVData->mpResMgr )
 725         {
 726             delete pSVData->mpResMgr;
 727             pSVData->mpResMgr = NULL;
 728         }
 729         ResMgr::SetDefaultLocale( rSettings.GetUILocale() );
 730         *pSVData->maAppData.mpSettings = rSettings;
 731         ULONG nChangeFlags = aOldSettings.GetChangeFlags( *pSVData->maAppData.mpSettings );
 732         if ( nChangeFlags )
 733         {
 734             DataChangedEvent aDCEvt( DATACHANGED_SETTINGS, &aOldSettings, nChangeFlags );
 735             GetpApp()->DataChanged( aDCEvt );
 736
 737             // notify data change handler
 738             ImplCallEventListeners( VCLEVENT_APPLICATION_DATACHANGED, NULL, &aDCEvt);
 739
 740             // Update all windows
 741             Window* pFirstFrame = pSVData->maWinData.mpFirstFrame;
 742             // Daten, die neu berechnet werden muessen, zuruecksetzen
 743             long nOldDPIX = 0;
 744             long nOldDPIY = 0;
 745             if ( pFirstFrame )
 746             {
 747                 nOldDPIX = pFirstFrame->mnDPIX;
 748                 nOldDPIY = pFirstFrame->mnDPIY;
 749                 pSVData->maGDIData.mnAppFontX = 0;
 750             }
 751             Window* pFrame = pFirstFrame;
 752             while ( pFrame )
 753             {
 754                 // AppFont-Cache-Daten zuruecksetzen
 755                 pFrame->mpWindowImpl->mpFrameData->meMapUnit = MAP_PIXEL;
 756
 757                 // UpdateSettings am ClientWindow aufrufen, damit
 758                 // die Daten nicht doppelt geupdatet werden
 759                 Window* pClientWin = pFrame;
 760                 while ( pClientWin->ImplGetClientWindow() )
 761                     pClientWin = pClientWin->ImplGetClientWindow();
 762                 pClientWin->UpdateSettings( rSettings, TRUE );
 763
 764                 Window* pTempWin = pFrame->mpWindowImpl->mpFrameData->mpFirstOverlap;
 765                 while ( pTempWin )
 766                 {
 767                     // UpdateSettings am ClientWindow aufrufen, damit
 768                     // die Daten nicht doppelt geupdatet werden
 769                     pClientWin = pTempWin;
 770                     while ( pClientWin->ImplGetClientWindow() )
 771                         pClientWin = pClientWin->ImplGetClientWindow();
 772                     pClientWin->UpdateSettings( rSettings, TRUE );
 773                     pTempWin = pTempWin->mpWindowImpl->mpNextOverlap;
 774                 }
 775
 776                 pFrame = pFrame->mpWindowImpl->mpFrameData->mpNextFrame;
 777             }
 778
 779             // Wenn sich die DPI-Aufloesung fuer Screen-Ausgaben
 780             // geaendert hat, setzen wir auch bei allen
 781             // Screen-Kompatiblen VirDev's die neue Aufloesung
 782             pFirstFrame = pSVData->maWinData.mpFirstFrame;
 783             if ( pFirstFrame )
 784             {
 785                 if ( (pFirstFrame->mnDPIX != nOldDPIX) ||
 786                      (pFirstFrame->mnDPIY != nOldDPIY) )
 787                 {
 788                     VirtualDevice* pVirDev = pSVData->maGDIData.mpFirstVirDev;
 789                     while ( pVirDev )
 790                     {
 791                         if ( pVirDev->mbScreenComp &&
 792                              (pVirDev->mnDPIX == nOldDPIX) &&
 793                              (pVirDev->mnDPIY == nOldDPIY) )
 794                         {
 795                             pVirDev->mnDPIX = pFirstFrame->mnDPIX;
 796                             pVirDev->mnDPIY = pFirstFrame->mnDPIY;
 797                             if ( pVirDev->IsMapMode() )
 798                             {
 799                                 MapMode aMapMode = pVirDev->GetMapMode();
 800                                 pVirDev->SetMapMode();
 801                                 pVirDev->SetMapMode( aMapMode );
 802                             }
 803                         }
 804
 805                         pVirDev = pVirDev->mpNext;
 806                     }
 807                 }
 808             }
 809         }
 810     }
 811 }
 812
 813 // -----------------------------------------------------------------------
 814
 815 const AllSettings& Application::GetSettings()
 816 {
 817     ImplSVData* pSVData = ImplGetSVData();
 818     if ( !pSVData->maAppData.mpSettings )
 819         pSVData->maAppData.mpSettings = new AllSettings();
 820     return *(pSVData->maAppData.mpSettings);
 821 }
 822
 823 // -----------------------------------------------------------------------
 824
 825 void Application::NotifyAllWindows( DataChangedEvent& rDCEvt )
 826 {
 827     ImplSVData* pSVData = ImplGetSVData();
 828     Window*     pFrame = pSVData->maWinData.mpFirstFrame;
 829     while ( pFrame )
 830     {
 831         pFrame->NotifyAllChilds( rDCEvt );
 832
 833         Window* pSysWin = pFrame->mpWindowImpl->mpFrameData->mpFirstOverlap;
 834         while ( pSysWin )
 835         {
 836             pSysWin->NotifyAllChilds( rDCEvt );
 837             pSysWin = pSysWin->mpWindowImpl->mpNextOverlap;
 838         }
 839
 840         pFrame = pFrame->mpWindowImpl->mpFrameData->mpNextFrame;
 841     }
 842 }
 843
 844 // -----------------------------------------------------------------------
 845
 846 void Application::ImplCallEventListeners( ULONG nEvent, Window *pWin, void* pData )
 847 {
 848     ImplSVData* pSVData = ImplGetSVData();
 849     VclWindowEvent aEvent( pWin, nEvent, pData );
 850
 851     if ( pSVData->maAppData.mpEventListeners )
 852         if ( !pSVData->maAppData.mpEventListeners->empty() )
 853             pSVData->maAppData.mpEventListeners->Call( &aEvent );
 854 }
 855
 856 // -----------------------------------------------------------------------
 857
 858 void Application::ImplCallEventListeners( VclSimpleEvent* pEvent )
 859 {
 860     ImplSVData* pSVData = ImplGetSVData();
 861
 862     if ( pSVData->maAppData.mpEventListeners )
 863         if ( !pSVData->maAppData.mpEventListeners->empty() )
 864             pSVData->maAppData.mpEventListeners->Call( pEvent );
 865 }
 866
 867 // -----------------------------------------------------------------------
 868
 869 void Application::AddEventListener( const Link& rEventListener )
 870 {
 871     ImplSVData* pSVData = ImplGetSVData();
 872     if( !pSVData->maAppData.mpEventListeners )
 873         pSVData->maAppData.mpEventListeners = new VclEventListeners;
 874     pSVData->maAppData.mpEventListeners->push_back( rEventListener );
 875 }
 876
 877 // -----------------------------------------------------------------------
 878
 879 void Application::RemoveEventListener( const Link& rEventListener )
 880 {
 881     ImplSVData* pSVData = ImplGetSVData();
 882     if( pSVData->maAppData.mpEventListeners )
 883         pSVData->maAppData.mpEventListeners->remove( rEventListener );
 884 }
 885
 886 // -----------------------------------------------------------------------
 887 void Application::AddKeyListener( const Link& rKeyListener )
 888 {
 889     ImplSVData* pSVData = ImplGetSVData();
 890     if( !pSVData->maAppData.mpKeyListeners )
 891         pSVData->maAppData.mpKeyListeners = new VclEventListeners;
 892     pSVData->maAppData.mpKeyListeners->push_back( rKeyListener );
 893 }
 894
 895 // -----------------------------------------------------------------------
 896
 897 void Application::RemoveKeyListener( const Link& rKeyListener )
 898 {
 899     ImplSVData* pSVData = ImplGetSVData();
 900     if( pSVData->maAppData.mpKeyListeners )
 901         pSVData->maAppData.mpKeyListeners->remove( rKeyListener );
 902 }
 903
 904 // -----------------------------------------------------------------------
 905
 906 BOOL Application::HandleKey( ULONG nEvent, Window *pWin, KeyEvent* pKeyEvent )
 907 {
 908     // let listeners process the key event
 909     VclWindowEvent aEvent( pWin, nEvent, (void *) pKeyEvent );
 910
 911     ImplSVData* pSVData = ImplGetSVData();
 912     BOOL bProcessed = FALSE;
 913
 914     if ( pSVData->maAppData.mpKeyListeners )
 915         if ( !pSVData->maAppData.mpKeyListeners->empty() )
 916             bProcessed = pSVData->maAppData.mpKeyListeners->Process( &aEvent );
 917
 918     return bProcessed;
 919 }
 920
 921 // -----------------------------------------------------------------------------
 922
 923 ULONG Application::PostKeyEvent( ULONG nEvent, Window *pWin, KeyEvent* pKeyEvent )
 924 {
 925     const ::vos::OGuard aGuard( GetSolarMutex() );
 926     ULONG                               nEventId = 0;
 927
 928     if( pWin && pKeyEvent )
 929     {
 930         ImplPostEventData* pPostEventData = new ImplPostEventData( nEvent, pWin, *pKeyEvent );
 931
 932         PostUserEvent( nEventId,
 933                        STATIC_LINK( NULL, Application, PostEventHandler ),
 934                        pPostEventData );
 935
 936         if( nEventId )
 937         {
 938             pPostEventData->mnEventId = nEventId;
 939             aPostedEventList.push_back( ImplPostEventPair( pWin, pPostEventData ) );
 940         }
 941         else
 942             delete pPostEventData;
 943     }
 944
 945     return nEventId;
 946 }
 947
 948 // -----------------------------------------------------------------------------
 949
 950 ULONG Application::PostMouseEvent( ULONG nEvent, Window *pWin, MouseEvent* pMouseEvent )
 951 {
 952     const ::vos::OGuard aGuard( GetSolarMutex() );
 953     ULONG                               nEventId = 0;
 954
 955     if( pWin && pMouseEvent )
 956     {
 957         Point aTransformedPos( pMouseEvent->GetPosPixel() );
 958
 959         aTransformedPos.X() += pWin->mnOutOffX;
 960         aTransformedPos.Y() += pWin->mnOutOffY;
 961
 962         const MouseEvent aTransformedEvent( aTransformedPos, pMouseEvent->GetClicks(), pMouseEvent->GetMode(),
 963                                             pMouseEvent->GetButtons(), pMouseEvent->GetModifier() );
 964
 965         ImplPostEventData* pPostEventData = new ImplPostEventData( nEvent, pWin, aTransformedEvent );
 966
 967         PostUserEvent( nEventId,
 968                        STATIC_LINK( NULL, Application, PostEventHandler ),
 969                        pPostEventData );
 970
 971         if( nEventId )
 972         {
 973             pPostEventData->mnEventId = nEventId;
 974             aPostedEventList.push_back( ImplPostEventPair( pWin, pPostEventData ) );
 975         }
 976         else
 977             delete pPostEventData;
 978     }
 979
 980     return nEventId;
 981 }
 982
 983 // -----------------------------------------------------------------------------
 984
 985 IMPL_STATIC_LINK_NOINSTANCE( Application, PostEventHandler, void*, pCallData )
 986 {
 987     const ::vos::OGuard aGuard( GetSolarMutex() );
 988     ImplPostEventData*  pData = static_cast< ImplPostEventData * >( pCallData );
 989     const void*                 pEventData;
 990     ULONG               nEvent;
 991     const ULONG                 nEventId = pData->mnEventId;
 992
 993     switch( pData->mnEvent )
 994     {
 995         case VCLEVENT_WINDOW_MOUSEMOVE:
 996             nEvent = SALEVENT_EXTERNALMOUSEMOVE;
 997             pEventData = &pData->maMouseEvent;
 998         break;
 999
1000         case VCLEVENT_WINDOW_MOUSEBUTTONDOWN:
1001             nEvent = SALEVENT_EXTERNALMOUSEBUTTONDOWN;
1002             pEventData = &pData->maMouseEvent;
1003         break;
1004
1005         case VCLEVENT_WINDOW_MOUSEBUTTONUP:
1006             nEvent = SALEVENT_EXTERNALMOUSEBUTTONUP;
1007             pEventData = &pData->maMouseEvent;
1008         break;
1009
1010         case VCLEVENT_WINDOW_KEYINPUT:
1011             nEvent = SALEVENT_EXTERNALKEYINPUT;
1012             pEventData = &pData->maKeyEvent;
1013         break;
1014
1015         case VCLEVENT_WINDOW_KEYUP:
1016             nEvent = SALEVENT_EXTERNALKEYUP;
1017             pEventData = &pData->maKeyEvent;
1018         break;
1019
1020         default:
1021             nEvent = 0;
1022             pEventData = NULL;
1023         break;
1024     };
1025
1026     if( pData->mpWin && pData->mpWin->mpWindowImpl->mpFrameWindow && pEventData )
1027         ImplWindowFrameProc( pData->mpWin->mpWindowImpl->mpFrameWindow, NULL, (USHORT) nEvent, pEventData );
1028
1029     // remove this event from list of posted events, watch for destruction of internal data
1030     ::std::list< ImplPostEventPair >::iterator aIter( aPostedEventList.begin() );
1031
1032     while( aIter != aPostedEventList.end() )
1033     {
1034         if( nEventId == (*aIter).second->mnEventId )
1035         {
1036             delete (*aIter).second;
1037             aIter = aPostedEventList.erase( aIter );
1038         }
1039         else
1040             ++aIter;
1041     }
1042
1043     return 0;
1044 }
1045
1046 // -----------------------------------------------------------------------
1047
1048 void Application::RemoveMouseAndKeyEvents( Window* pWin )
1049 {
1050     const ::vos::OGuard aGuard( GetSolarMutex() );
1051
1052     // remove all events for specific window, watch for destruction of internal data
1053     ::std::list< ImplPostEventPair >::iterator aIter( aPostedEventList.begin() );
1054
1055     while( aIter != aPostedEventList.end() )
1056     {
1057         if( pWin == (*aIter).first )
1058         {
1059             if( (*aIter).second->mnEventId )
1060                 RemoveUserEvent( (*aIter).second->mnEventId );
1061
1062             delete (*aIter).second;
1063             aIter = aPostedEventList.erase( aIter );
1064         }
1065         else
1066             ++aIter;
1067     }
1068 }
1069
1070 // -----------------------------------------------------------------------
1071
1072 BOOL Application::IsProcessedMouseOrKeyEvent( ULONG nEventId )
1073 {
1074     const ::vos::OGuard aGuard( GetSolarMutex() );
1075
1076     // find event
1077     ::std::list< ImplPostEventPair >::iterator aIter( aPostedEventList.begin() );
1078
1079     while( aIter != aPostedEventList.end() )
1080     {
1081         if( (*aIter).second->mnEventId == nEventId )
1082             return FALSE;
1083
1084         else
1085             ++aIter;
1086     }
1087     return TRUE;
1088 }
1089
1090 // -----------------------------------------------------------------------
1091
1092 ULONG Application::PostUserEvent( ULONG nEvent, void* pEventData )
1093 {
1094     ULONG nEventId;
1095     PostUserEvent( nEventId, nEvent, pEventData );
1096     return nEventId;
1097 }
1098
1099 // -----------------------------------------------------------------------
1100
1101 ULONG Application::PostUserEvent( const Link& rLink, void* pCaller )
1102 {
1103     ULONG nEventId;
1104     PostUserEvent( nEventId, rLink, pCaller );
1105     return nEventId;
1106 }
1107
1108 // -----------------------------------------------------------------------
1109
1110 BOOL Application::PostUserEvent( ULONG& rEventId, ULONG nEvent, void* pEventData )
1111 {
1112     ImplSVEvent* pSVEvent = new ImplSVEvent;
1113     pSVEvent->mnEvent   = nEvent;
1114     pSVEvent->mpData    = pEventData;
1115     pSVEvent->mpLink    = NULL;
1116     pSVEvent->mpWindow  = NULL;
1117     pSVEvent->mbCall    = TRUE;
1118     rEventId = (ULONG)pSVEvent;
1119     Window* pDefWindow = ImplGetDefaultWindow();
1120     if ( pDefWindow && pDefWindow->ImplGetFrame()->PostEvent( pSVEvent ) )
1121         return TRUE;
1122     else
1123     {
1124         rEventId = 0;
1125         delete pSVEvent;
1126         return FALSE;
1127     }
1128 }
1129
1130 // -----------------------------------------------------------------------
1131
1132 BOOL Application::PostUserEvent( ULONG& rEventId, const Link& rLink, void* pCaller )
1133 {
1134     ImplSVEvent* pSVEvent = new ImplSVEvent;
1135     pSVEvent->mnEvent   = 0;
1136     pSVEvent->mpData    = pCaller;
1137     pSVEvent->mpLink    = new Link( rLink );
1138     pSVEvent->mpWindow  = NULL;
1139     pSVEvent->mbCall    = TRUE;
1140     rEventId = (ULONG)pSVEvent;
1141     Window* pDefWindow = ImplGetDefaultWindow();
1142     if ( pDefWindow && pDefWindow->ImplGetFrame()->PostEvent( pSVEvent ) )
1143         return TRUE;
1144     else
1145     {
1146         rEventId = 0;
1147         delete pSVEvent;
1148         return FALSE;
1149     }
1150 }
1151
1152 // -----------------------------------------------------------------------
1153
1154 void Application::RemoveUserEvent( ULONG nUserEvent )
1155 {
1156     if(nUserEvent)
1157     {
1158         ImplSVEvent* pSVEvent = (ImplSVEvent*)nUserEvent;
1159
1160         DBG_ASSERT( !pSVEvent->mpWindow,
1161                     "Application::RemoveUserEvent(): Event is send to a window" );
1162         DBG_ASSERT( pSVEvent->mbCall,
1163                     "Application::RemoveUserEvent(): Event is already removed" );
1164
1165         if ( pSVEvent->mpWindow )
1166         {
1167             if( ! pSVEvent->maDelData.IsDelete() )
1168                 pSVEvent->mpWindow->ImplRemoveDel( &(pSVEvent->maDelData) );
1169             pSVEvent->mpWindow = NULL;
1170         }
1171
1172         pSVEvent->mbCall = FALSE;
1173     }
1174 }
1175
1176 // -----------------------------------------------------------------------
1177
1178 BOOL Application::InsertIdleHdl( const Link& rLink, USHORT nPrio )
1179 {
1180     ImplSVData* pSVData = ImplGetSVData();
1181
1182     // Falls er noch nicht existiert, dann anlegen
1183     if ( !pSVData->maAppData.mpIdleMgr )
1184         pSVData->maAppData.mpIdleMgr = new ImplIdleMgr;
1185
1186     return pSVData->maAppData.mpIdleMgr->InsertIdleHdl( rLink, nPrio );
1187 }
1188
1189 // -----------------------------------------------------------------------
1190
1191 void Application::RemoveIdleHdl( const Link& rLink )
1192 {
1193     ImplSVData* pSVData = ImplGetSVData();
1194
1195     if ( pSVData->maAppData.mpIdleMgr )
1196         pSVData->maAppData.mpIdleMgr->RemoveIdleHdl( rLink );
1197 }
1198
1199 // -----------------------------------------------------------------------
1200
1201 WorkWindow* Application::GetAppWindow()
1202 {
1203     return ImplGetSVData()->maWinData.mpAppWin;
1204 }
1205
1206 // -----------------------------------------------------------------------
1207
1208 Window* Application::GetFocusWindow()
1209 {
1210     return ImplGetSVData()->maWinData.mpFocusWin;
1211 }
1212
1213 // -----------------------------------------------------------------------
1214
1215 OutputDevice* Application::GetDefaultDevice()
1216 {
1217     return ImplGetDefaultWindow();
1218 }
1219
1220 // -----------------------------------------------------------------------
1221
1222 Window* Application::GetFirstTopLevelWindow()
1223 {
1224     ImplSVData* pSVData = ImplGetSVData();
1225     return pSVData->maWinData.mpFirstFrame;
1226 }
1227
1228 // -----------------------------------------------------------------------
1229
1230 Window* Application::GetNextTopLevelWindow( Window* pWindow )
1231 {
1232     return pWindow->mpWindowImpl->mpFrameData->mpNextFrame;
1233 }
1234
1235 // -----------------------------------------------------------------------
1236
1237 long    Application::GetTopWindowCount()
1238 {
1239     long nRet = 0;
1240     ImplSVData* pSVData = ImplGetSVData();
1241     Window *pWin = pSVData ? pSVData->maWinData.mpFirstFrame : NULL;
1242     while( pWin )
1243     {
1244         if( pWin->ImplGetWindow()->IsTopWindow() )
1245             nRet++;
1246         pWin = pWin->mpWindowImpl->mpFrameData->mpNextFrame;
1247     }
1248     return nRet;
1249 }
1250
1251 // -----------------------------------------------------------------------
1252
1253 Window* Application::GetTopWindow( long nIndex )
1254 {
1255     long nIdx = 0;
1256     ImplSVData* pSVData = ImplGetSVData();
1257     Window *pWin = pSVData ? pSVData->maWinData.mpFirstFrame : NULL;
1258     while( pWin )
1259     {
1260         if( pWin->ImplGetWindow()->IsTopWindow() )
1261         {
1262             if( nIdx == nIndex )
1263                 return pWin->ImplGetWindow();
1264             else
1265                 nIdx++;
1266         }
1267         pWin = pWin->mpWindowImpl->mpFrameData->mpNextFrame;
1268     }
1269     return NULL;
1270 }
1271
1272 // -----------------------------------------------------------------------
1273
1274 Window* Application::GetActiveTopWindow()
1275 {
1276     Window *pWin = ImplGetSVData()->maWinData.mpFocusWin;
1277     while( pWin )
1278     {
1279         if( pWin->IsTopWindow() )
1280             return pWin;
1281         pWin = pWin->mpWindowImpl->mpParent;
1282     }
1283     return NULL;
1284 }
1285
1286 // -----------------------------------------------------------------------
1287
1288 void Application::SetAppName( const XubString& rUniqueName )
1289 {
1290     ImplSVData* pSVData = ImplGetSVData();
1291
1292     // Falls er noch nicht existiert, dann anlegen
1293     if ( !pSVData->maAppData.mpAppName )
1294         pSVData->maAppData.mpAppName = new XubString( rUniqueName );
1295     else
1296         *(pSVData->maAppData.mpAppName) = rUniqueName;
1297 }
1298
1299 // -----------------------------------------------------------------------
1300
1301 XubString Application::GetAppName()
1302 {
1303     ImplSVData* pSVData = ImplGetSVData();
1304     if ( pSVData->maAppData.mpAppName )
1305         return *(pSVData->maAppData.mpAppName);
1306     else
1307         return ImplGetSVEmptyStr();
1308 }
1309
1310 // -----------------------------------------------------------------------
1311
1312 void Application::SetDisplayName( const UniString& rName )
1313 {
1314     ImplSVData* pSVData = ImplGetSVData();
1315
1316     // Falls er noch nicht existiert, dann anlegen
1317     if ( !pSVData->maAppData.mpDisplayName )
1318         pSVData->maAppData.mpDisplayName = new UniString( rName );
1319     else
1320         *(pSVData->maAppData.mpDisplayName) = rName;
1321 }
1322
1323 // -----------------------------------------------------------------------
1324
1325 UniString Application::GetDisplayName()
1326 {
1327     ImplSVData* pSVData = ImplGetSVData();
1328     if ( pSVData->maAppData.mpDisplayName )
1329         return *(pSVData->maAppData.mpDisplayName);
1330     else if ( pSVData->maWinData.mpAppWin )
1331         return pSVData->maWinData.mpAppWin->GetText();
1332     else
1333         return ImplGetSVEmptyStr();
1334 }
1335
1336 // -----------------------------------------------------------------------
1337
1338 unsigned int Application::GetScreenCount()
1339 {
1340     SalSystem* pSys = ImplGetSalSystem();
1341     return pSys ? pSys->GetDisplayScreenCount() : 0;
1342 }
1343
1344 rtl::OUString Application::GetScreenName( unsigned int nScreen )
1345 {
1346     SalSystem* pSys = ImplGetSalSystem();
1347     return pSys ? pSys->GetScreenName( nScreen ) : rtl::OUString();
1348 }
1349
1350 bool Application::IsMultiDisplay()
1351 {
1352     SalSystem* pSys = ImplGetSalSystem();
1353     return pSys ? pSys->IsMultiDisplay() : false;
1354 }
1355
1356 unsigned int Application::GetDefaultDisplayNumber()
1357 {
1358     SalSystem* pSys = ImplGetSalSystem();
1359     return pSys ? pSys->GetDefaultDisplayNumber() : 0;
1360 }
1361
1362 Rectangle Application::GetScreenPosSizePixel( unsigned int nScreen )
1363 {
1364     SalSystem* pSys = ImplGetSalSystem();
1365     return pSys ? pSys->GetDisplayScreenPosSizePixel( nScreen ) : Rectangle();
1366 }
1367
1368 Rectangle Application::GetWorkAreaPosSizePixel( unsigned int nScreen )
1369 {
1370     SalSystem* pSys = ImplGetSalSystem();
1371     return pSys ? pSys->GetDisplayWorkAreaPosSizePixel( nScreen ) : Rectangle();
1372 }
1373
1374 namespace {
1375 unsigned long calcDistSquare( const Point& i_rPoint, const Rectangle& i_rRect )
1376 {
1377     const Point aRectCenter( (i_rRect.Left() + i_rRect.Right())/2,
1378                        (i_rRect.Top() + i_rRect.Bottom())/ 2 );
1379     const long nDX = aRectCenter.X() - i_rPoint.X();
1380     const long nDY = aRectCenter.Y() - i_rPoint.Y();
1381     return nDX*nDX + nDY*nDY;
1382 }
1383 }
1384
1385 unsigned int Application::GetBestScreen( const Rectangle& i_rRect )
1386 {
1387     if( IsMultiDisplay() )
1388         return GetDefaultDisplayNumber();
1389
1390     const unsigned int nScreens = GetScreenCount();
1391     unsigned int nBestMatchScreen = 0;
1392     unsigned long nOverlap = 0;
1393     for( unsigned int i = 0; i < nScreens; i++ )
1394     {
1395         const Rectangle aCurScreenRect( GetScreenPosSizePixel( i ) );
1396         // if a screen contains the rectangle completely it is obviously the best screen
1397         if( aCurScreenRect.IsInside( i_rRect ) )
1398             return i;
1399         // next the screen which contains most of the area of the rect is the best
1400         Rectangle aIntersection( aCurScreenRect.GetIntersection( i_rRect ) );
1401         if( ! aIntersection.IsEmpty() )
1402         {
1403             const unsigned long nCurOverlap( aIntersection.GetWidth() * aIntersection.GetHeight() );
1404             if( nCurOverlap > nOverlap )
1405             {
1406                 nOverlap = nCurOverlap;
1407                 nBestMatchScreen = i;
1408             }
1409         }
1410     }
1411     if( nOverlap > 0 )
1412         return nBestMatchScreen;
1413
1414     // finally the screen which center is nearest to the rect is the best
1415     const Point aCenter( (i_rRect.Left() + i_rRect.Right())/2,
1416                          (i_rRect.Top() + i_rRect.Bottom())/2 );
1417     unsigned long nDist = ULONG_MAX;
1418     for( unsigned int i = 0; i < nScreens; i++ )
1419     {
1420         const Rectangle aCurScreenRect( GetScreenPosSizePixel( i ) );
1421         const unsigned long nCurDist( calcDistSquare( aCenter, aCurScreenRect ) );
1422         if( nCurDist < nDist )
1423         {
1424             nBestMatchScreen = i;
1425             nDist = nCurDist;
1426         }
1427     }
1428     return nBestMatchScreen;
1429 }
1430
1431 // -----------------------------------------------------------------------
1432
1433 BOOL Application::InsertAccel( Accelerator* pAccel )
1434 {
1435     ImplSVData* pSVData = ImplGetSVData();
1436
1437     if ( !pSVData->maAppData.mpAccelMgr )
1438         pSVData->maAppData.mpAccelMgr = new ImplAccelManager();
1439     return pSVData->maAppData.mpAccelMgr->InsertAccel( pAccel );
1440 }
1441
1442 // -----------------------------------------------------------------------
1443
1444 void Application::RemoveAccel( Accelerator* pAccel )
1445 {
1446     ImplSVData* pSVData = ImplGetSVData();
1447
1448     if ( pSVData->maAppData.mpAccelMgr )
1449         pSVData->maAppData.mpAccelMgr->RemoveAccel( pAccel );
1450 }
1451
1452 // -----------------------------------------------------------------------
1453
1454 void Application::FlushAccel()
1455 {
1456     ImplSVData* pSVData = ImplGetSVData();
1457
1458     if ( pSVData->maAppData.mpAccelMgr )
1459         pSVData->maAppData.mpAccelMgr->FlushAccel();
1460 }
1461
1462 // -----------------------------------------------------------------------
1463
1464 BOOL Application::CallAccel( const KeyCode& rKeyCode, USHORT nRepeat )
1465 {
1466     ImplSVData* pSVData = ImplGetSVData();
1467
1468     if ( pSVData->maAppData.mpAccelMgr )
1469     {
1470         if ( pSVData->maAppData.mpAccelMgr->IsAccelKey( rKeyCode, nRepeat ) )
1471             return TRUE;
1472     }
1473
1474     return FALSE;
1475 }
1476
1477 // -----------------------------------------------------------------------
1478
1479 void Application::SetHelp( Help* pHelp )
1480 {
1481     ImplGetSVData()->maAppData.mpHelp = pHelp;
1482 }
1483
1484 // -----------------------------------------------------------------------
1485
1486 Help* Application::GetHelp()
1487 {
1488     return ImplGetSVData()->maAppData.mpHelp;
1489 }
1490
1491 // -----------------------------------------------------------------------
1492
1493 void Application::EnableAutoHelpId( BOOL bEnabled )
1494 {
1495     ImplGetSVData()->maHelpData.mbAutoHelpId = bEnabled;
1496 }
1497
1498 // -----------------------------------------------------------------------
1499
1500 BOOL Application::IsAutoHelpIdEnabled()
1501 {
1502     return ImplGetSVData()->maHelpData.mbAutoHelpId;
1503 }
1504
1505 // -----------------------------------------------------------------------
1506
1507 void Application::EnableAutoMnemonic( BOOL bEnabled )
1508 {
1509     AllSettings aSettings = GetSettings();
1510     StyleSettings aStyle = aSettings.GetStyleSettings();
1511     aStyle.SetAutoMnemonic( bEnabled );
1512     aSettings.SetStyleSettings( aStyle );
1513     SetSettings( aSettings );
1514 }
1515
1516 // -----------------------------------------------------------------------
1517
1518 BOOL Application::IsAutoMnemonicEnabled()
1519 {
1520     return GetSettings().GetStyleSettings().GetAutoMnemonic();
1521 }
1522
1523 // -----------------------------------------------------------------------
1524
1525 void Application::SetDialogScaleX( short nScale )
1526 {
1527     ImplSVData* pSVData = ImplGetSVData();
1528     pSVData->maAppData.mnDialogScaleX = nScale;
1529     pSVData->maGDIData.mnAppFontX = pSVData->maGDIData.mnRealAppFontX;
1530     if ( nScale )
1531         pSVData->maGDIData.mnAppFontX += (pSVData->maGDIData.mnAppFontX*nScale)/100;
1532 }
1533
1534 // -----------------------------------------------------------------------
1535
1536 short Application::GetDialogScaleX()
1537 {
1538     return ImplGetSVData()->maAppData.mnDialogScaleX;
1539 }
1540
1541 // -----------------------------------------------------------------------
1542
1543 void Application::SetDefDialogParent( Window* pWindow )
1544 {
1545     ImplGetSVData()->maWinData.mpDefDialogParent = pWindow;
1546 }
1547
1548 // -----------------------------------------------------------------------
1549
1550 Window* Application::GetDefDialogParent()
1551 {
1552     ImplSVData* pSVData = ImplGetSVData();
1553     // #103442# find some useful dialog parent if there
1554     // was no default set
1555     // NOTE: currently even the default is not used
1556     if( FALSE && pSVData->maWinData.mpDefDialogParent != NULL )
1557         return pSVData->maWinData.mpDefDialogParent;
1558     else
1559     {
1560         // always use the topmost parent of the candidate
1561         // window to avoid using dialogs or floaters
1562         // as DefDialogParent
1563
1564         // current focus frame
1565         Window *pWin = NULL;
1566         if( (pWin = pSVData->maWinData.mpFocusWin) != NULL )
1567         {
1568             while( pWin->mpWindowImpl && pWin->mpWindowImpl->mpParent )
1569                 pWin = pWin->mpWindowImpl->mpParent;
1570
1571             if( (pWin->mpWindowImpl->mnStyle & WB_INTROWIN) == 0 )
1572             {
1573                 // check for corrupted window hierarchy, #122232#, may be we now crash somewhere else
1574                 if( !pWin->mpWindowImpl )
1575                 {
1576                     DBG_ERROR( "Window hierarchy corrupted!" );
1577                     pSVData->maWinData.mpFocusWin = NULL;   // avoid further access
1578                     return NULL;
1579                 }
1580
1581                 // MAV: before the implementation has used only decorated windows,
1582                 //      but it is not true in case of ActiveX or plugin scenario,
1583                 //      so this check is commented out
1584                 // if( pWin->mpWindowImpl->mpFrameWindow->GetStyle() & (WB_MOVEABLE | WB_SIZEABLE) )
1585                     return pWin->mpWindowImpl->mpFrameWindow->ImplGetWindow();
1586                 // else
1587                 //    return NULL;
1588             }
1589         }
1590         // last active application frame
1591         if( NULL != (pWin = pSVData->maWinData.mpActiveApplicationFrame) )
1592         {
1593             return pWin->mpWindowImpl->mpFrameWindow->ImplGetWindow();
1594         }
1595         else
1596         {
1597             // first visible top window (may be totally wrong....)
1598             pWin = pSVData->maWinData.mpFirstFrame;
1599             while( pWin )
1600             {
1601                 if( pWin->ImplGetWindow()->IsTopWindow() &&
1602                     pWin->mpWindowImpl->mbReallyVisible &&
1603                     (pWin->mpWindowImpl->mnStyle & WB_INTROWIN) == 0
1604                 )
1605                 {
1606                     while( pWin->mpWindowImpl->mpParent )
1607                         pWin = pWin->mpWindowImpl->mpParent;
1608                     return pWin->mpWindowImpl->mpFrameWindow->ImplGetWindow();
1609                 }
1610                 pWin = pWin->mpWindowImpl->mpFrameData->mpNextFrame;
1611             }
1612             // use the desktop
1613             return NULL;
1614         }
1615     }
1616 }
1617
1618 // -----------------------------------------------------------------------
1619
1620 void Application::EnableDialogCancel( BOOL bDialogCancel )
1621 {
1622     ImplGetSVData()->maAppData.mbDialogCancel = bDialogCancel;
1623 }
1624
1625 // -----------------------------------------------------------------------
1626
1627 BOOL Application::IsDialogCancelEnabled()
1628 {
1629     return ImplGetSVData()->maAppData.mbDialogCancel;
1630 }
1631
1632 // -----------------------------------------------------------------------
1633
1634 void Application::SetSystemWindowMode( USHORT nMode )
1635 {
1636     ImplGetSVData()->maAppData.mnSysWinMode = nMode;
1637 }
1638
1639 // -----------------------------------------------------------------------
1640
1641 USHORT Application::GetSystemWindowMode()
1642 {
1643     return ImplGetSVData()->maAppData.mnSysWinMode;
1644 }
1645
1646 // -----------------------------------------------------------------------
1647
1648 const String& Application::GetFontPath()
1649 {
1650     ImplSVData* pSVData = ImplGetSVData();
1651     if( !pSVData->maAppData.mpFontPath )
1652     {
1653         if( const char* pFontPath = ::getenv( "SAL_FONTPATH_PRIVATE" ) )
1654             pSVData->maAppData.mpFontPath = new String( String::CreateFromAscii( pFontPath ) );
1655     }
1656
1657     if( pSVData->maAppData.mpFontPath )
1658         return *(pSVData->maAppData.mpFontPath);
1659     return ImplGetSVEmptyStr();
1660 }
1661
1662 // -----------------------------------------------------------------------
1663
1664 void Application::SetFontPath( const String& rPath )
1665 {
1666     ImplSVData* pSVData = ImplGetSVData();
1667
1668     // if it doesn't exist create a new one
1669     if( !pSVData->maAppData.mpFontPath )
1670         pSVData->maAppData.mpFontPath = new String( rPath );
1671     else
1672         *(pSVData->maAppData.mpFontPath) = rPath;
1673 }
1674
1675 // -----------------------------------------------------------------------
1676
1677 UniqueItemId Application::CreateUniqueId()
1678 {
1679     ImplSVData* pSVData = ImplGetSVData();
1680
1681     if ( !pSVData->maAppData.mpUniqueIdCont )
1682         pSVData->maAppData.mpUniqueIdCont = new UniqueIdContainer( UNIQUEID_SV_BEGIN );
1683     return pSVData->maAppData.mpUniqueIdCont->CreateId();
1684 }
1685
1686 // -----------------------------------------------------------------------
1687
1688 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XToolkit > Application::GetVCLToolkit()
1689 {
1690     ::com::sun::star::uno::Reference< ::com::sun::star::awt::XToolkit > xT;
1691     UnoWrapperBase* pWrapper = Application::GetUnoWrapper( TRUE );
1692     if ( pWrapper )
1693         xT = pWrapper->GetVCLToolkit();
1694     return xT;
1695 }
1696
1697 // -----------------------------------------------------------------------
1698
1699 extern "C" { static void SAL_CALL thisModule() {} }
1700
1701 UnoWrapperBase* Application::GetUnoWrapper( BOOL bCreateIfNotExist )
1702 {
1703     ImplSVData* pSVData = ImplGetSVData();
1704     static BOOL bAlreadyTriedToCreate = FALSE;
1705     if ( !pSVData->mpUnoWrapper && bCreateIfNotExist && !bAlreadyTriedToCreate )
1706     {
1707         ::rtl::OUString aLibName = ::vcl::unohelper::CreateLibraryName( "tk", TRUE );
1708         oslModule hTkLib = osl_loadModuleRelative(
1709             &thisModule, aLibName.pData, SAL_LOADMODULE_DEFAULT );
1710         if ( hTkLib )
1711         {
1712             ::rtl::OUString aFunctionName( RTL_CONSTASCII_USTRINGPARAM( "CreateUnoWrapper" ) );
1713             FN_TkCreateUnoWrapper fnCreateWrapper = (FN_TkCreateUnoWrapper)osl_getFunctionSymbol( hTkLib, aFunctionName.pData );
1714             if ( fnCreateWrapper )
1715             {
1716                 pSVData->mpUnoWrapper = fnCreateWrapper();
1717             }
1718         }
1719         DBG_ASSERT( pSVData->mpUnoWrapper, "UnoWrapper could not be created!" );
1720         bAlreadyTriedToCreate = TRUE;
1721     }
1722     return pSVData->mpUnoWrapper;
1723 }
1724
1725 // -----------------------------------------------------------------------
1726
1727 void Application::SetUnoWrapper( UnoWrapperBase* pWrapper )
1728 {
1729     ImplSVData* pSVData = ImplGetSVData();
1730     DBG_ASSERT( !pSVData->mpUnoWrapper, "SetUnoWrapper: Wrapper allready exists" );
1731     pSVData->mpUnoWrapper = pWrapper;
1732 }
1733
1734 // -----------------------------------------------------------------------
1735
1736 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XDisplayConnection > Application::GetDisplayConnection()
1737 {
1738     ImplSVData* pSVData = ImplGetSVData();
1739
1740     if( !pSVData->mxDisplayConnection.is() )
1741         pSVData->mxDisplayConnection.set( new ::vcl::DisplayConnection );
1742
1743     return pSVData->mxDisplayConnection;
1744 }
1745
1746 // -----------------------------------------------------------------------
1747
1748 void Application::SetFilterHdl( const Link& rLink )
1749 {
1750     ImplGetSVData()->maGDIData.mpGrfConverter->SetFilterHdl( rLink );
1751 }
1752
1753 // -----------------------------------------------------------------------
1754
1755 const Link& Application::GetFilterHdl()
1756 {
1757     return ImplGetSVData()->maGDIData.mpGrfConverter->GetFilterHdl();
1758 }
1759
1760 // -----------------------------------------------------------------------
1761
1762 BOOL ImplCallHotKey( const KeyCode& rKeyCode )
1763 {
1764     ImplSVData*     pSVData = ImplGetSVData();
1765     ImplHotKey*     pHotKeyData = pSVData->maAppData.mpFirstHotKey;
1766     while ( pHotKeyData )
1767     {
1768         if ( pHotKeyData->maKeyCode.IsDefinedKeyCodeEqual( rKeyCode ) )
1769         {
1770             pHotKeyData->maLink.Call( pHotKeyData->mpUserData );
1771             return TRUE;
1772         }
1773
1774         pHotKeyData = pHotKeyData->mpNext;
1775     }
1776
1777     return FALSE;
1778 }
1779
1780 // -----------------------------------------------------------------------
1781
1782 void ImplFreeHotKeyData()
1783 {
1784     ImplSVData*     pSVData = ImplGetSVData();
1785     ImplHotKey*     pTempHotKeyData;
1786     ImplHotKey*     pHotKeyData = pSVData->maAppData.mpFirstHotKey;
1787     while ( pHotKeyData )
1788     {
1789         pTempHotKeyData = pHotKeyData->mpNext;
1790         delete pHotKeyData;
1791         pHotKeyData = pTempHotKeyData;
1792     }
1793
1794     pSVData->maAppData.mpFirstHotKey = NULL;
1795 }
1796
1797 // -----------------------------------------------------------------------
1798
1799 ULONG Application::AddHotKey( const KeyCode& rKeyCode, const Link& rLink, void* pData )
1800 {
1801     ImplSVData*     pSVData = ImplGetSVData();
1802     ImplHotKey*     pHotKeyData = new ImplHotKey;
1803     pHotKeyData->mpUserData = pData;
1804     pHotKeyData->maKeyCode  = rKeyCode;
1805     pHotKeyData->maLink     = rLink;
1806     pHotKeyData->mpNext     = pSVData->maAppData.mpFirstHotKey;
1807     pSVData->maAppData.mpFirstHotKey = pHotKeyData;
1808     return (ULONG)pHotKeyData;
1809 }
1810
1811 // -----------------------------------------------------------------------
1812
1813 void Application::RemoveHotKey( ULONG nId )
1814 {
1815     ImplSVData*     pSVData = ImplGetSVData();
1816     ImplHotKey*     pFindHotKeyData = (ImplHotKey*)nId;
1817     ImplHotKey*     pPrevHotKeyData = NULL;
1818     ImplHotKey*     pHotKeyData = pSVData->maAppData.mpFirstHotKey;
1819     while ( pHotKeyData )
1820     {
1821         if ( pHotKeyData == pFindHotKeyData )
1822         {
1823             if ( pPrevHotKeyData )
1824                 pPrevHotKeyData->mpNext = pFindHotKeyData->mpNext;
1825             else
1826                 pSVData->maAppData.mpFirstHotKey = pFindHotKeyData->mpNext;
1827             delete pFindHotKeyData;
1828             break;
1829         }
1830
1831         pPrevHotKeyData = pHotKeyData;
1832         pHotKeyData = pHotKeyData->mpNext;
1833     }
1834
1835     DBG_ASSERT( pHotKeyData, "Application::RemoveHotKey() - HotKey is not added" );
1836 }
1837
1838 // -----------------------------------------------------------------------
1839
1840 void ImplFreeEventHookData()
1841 {
1842     ImplSVData*     pSVData = ImplGetSVData();
1843     ImplEventHook*  pTempEventHookData;
1844     ImplEventHook*  pEventHookData = pSVData->maAppData.mpFirstEventHook;
1845     while ( pEventHookData )
1846     {
1847         pTempEventHookData = pEventHookData->mpNext;
1848         delete pEventHookData;
1849         pEventHookData = pTempEventHookData;
1850     }
1851
1852     pSVData->maAppData.mpFirstEventHook = NULL;
1853 }
1854
1855 // -----------------------------------------------------------------------
1856
1857 ULONG Application::AddEventHook( VCLEventHookProc pProc, void* pData )
1858 {
1859     ImplSVData*     pSVData = ImplGetSVData();
1860     ImplEventHook*  pEventHookData = new ImplEventHook;
1861     pEventHookData->mpUserData = pData;
1862     pEventHookData->mpProc     = pProc;
1863     pEventHookData->mpNext     = pSVData->maAppData.mpFirstEventHook;
1864     pSVData->maAppData.mpFirstEventHook = pEventHookData;
1865     return (ULONG)pEventHookData;
1866 }
1867
1868 // -----------------------------------------------------------------------
1869
1870 void Application::RemoveEventHook( ULONG nId )
1871 {
1872     ImplSVData*     pSVData = ImplGetSVData();
1873     ImplEventHook*  pFindEventHookData = (ImplEventHook*)nId;
1874     ImplEventHook*  pPrevEventHookData = NULL;
1875     ImplEventHook*  pEventHookData = pSVData->maAppData.mpFirstEventHook;
1876     while ( pEventHookData )
1877     {
1878         if ( pEventHookData == pFindEventHookData )
1879         {
1880             if ( pPrevEventHookData )
1881                 pPrevEventHookData->mpNext = pFindEventHookData->mpNext;
1882             else
1883                 pSVData->maAppData.mpFirstEventHook = pFindEventHookData->mpNext;
1884             delete pFindEventHookData;
1885             break;
1886         }
1887
1888         pPrevEventHookData = pEventHookData;
1889         pEventHookData = pEventHookData->mpNext;
1890     }
1891
1892     DBG_ASSERT( pEventHookData, "Application::RemoveEventHook() - EventHook is not added" );
1893 }
1894
1895 // -----------------------------------------------------------------------
1896
1897 long Application::CallEventHooks( NotifyEvent& rEvt )
1898 {
1899     ImplSVData*     pSVData = ImplGetSVData();
1900     long            nRet = 0;
1901     ImplEventHook*  pTempEventHookData;
1902     ImplEventHook*  pEventHookData = pSVData->maAppData.mpFirstEventHook;
1903     while ( pEventHookData )
1904     {
1905         pTempEventHookData = pEventHookData->mpNext;
1906         nRet = pEventHookData->mpProc( rEvt, pEventHookData->mpUserData );
1907         if ( nRet )
1908             break;
1909         pEventHookData = pTempEventHookData;
1910     }
1911
1912     return nRet;
1913 }
1914
1915 // -----------------------------------------------------------------------
1916
1917 long Application::CallPreNotify( NotifyEvent& rEvt )
1918 {
1919     return ImplCallPreNotify( rEvt );
1920 }
1921
1922 // -----------------------------------------------------------------------
1923
1924 long Application::CallEvent( NotifyEvent& rEvt )
1925 {
1926     return ImplCallEvent( rEvt );
1927 }
1928
1929 // -----------------------------------------------------------------------
1930
1931 const LocaleDataWrapper& Application::GetAppLocaleDataWrapper()
1932 {
1933     return GetSettings().GetLocaleDataWrapper();
1934 }
1935
1936 // -----------------------------------------------------------------------
1937
1938 void Application::EnableHeadlessMode( BOOL bEnable )
1939 {
1940     EnableDialogCancel( bEnable );
1941 }
1942
1943 // -----------------------------------------------------------------------
1944
1945 BOOL Application::IsHeadlessModeEnabled()
1946 {
1947     return IsDialogCancelEnabled();
1948 }
1949
1950 // -----------------------------------------------------------------------
1951
1952 void Application::ShowNativeErrorBox(const String& sTitle  ,
1953                                      const String& sMessage)
1954 {
1955     ImplGetSalSystem()->ShowNativeMessageBox (
1956             sTitle,
1957             sMessage,
1958             SALSYSTEM_SHOWNATIVEMSGBOX_BTNCOMBI_OK,
1959             SALSYSTEM_SHOWNATIVEMSGBOX_BTN_OK);
1960 }
1961
1962 // -----------------------------------------------------------------------
1963
1964 bool Application::CanToggleImeStatusWindow()
1965 {
1966     ImplSVData* pSVData = ImplGetSVData();
1967     if( ! pSVData->mpImeStatus )
1968         pSVData->mpImeStatus  = pSVData->mpDefInst->CreateI18NImeStatus();
1969     return pSVData->mpImeStatus->canToggle();
1970 }
1971
1972 void Application::ShowImeStatusWindow(bool bShow)
1973 {
1974     ImplGetSVData()->maAppData.meShowImeStatusWindow = bShow
1975         ? ImplSVAppData::ImeStatusWindowMode_SHOW
1976         : ImplSVAppData::ImeStatusWindowMode_HIDE;
1977
1978     ImplSVData* pSVData = ImplGetSVData();
1979     if( ! pSVData->mpImeStatus )
1980         pSVData->mpImeStatus  = pSVData->mpDefInst->CreateI18NImeStatus();
1981     pSVData->mpImeStatus->toggle();
1982 }
1983
1984 bool Application::GetShowImeStatusWindowDefault()
1985 {
1986     rtl_TextEncodingInfo aInfo;
1987     aInfo.StructSize = sizeof aInfo;
1988     return rtl_getTextEncodingInfo(osl_getThreadTextEncoding(), &aInfo)
1989         && aInfo.MaximumCharSize > 1;
1990 }
1991
1992 const ::rtl::OUString& Application::GetDesktopEnvironment()
1993 {
1994     return SalGetDesktopEnvironment();
1995 }
1996
1997 void Application::AddToRecentDocumentList(const rtl::OUString& rFileUrl, const rtl::OUString& rMimeType)
1998 {
1999     ImplSVData* pSVData = ImplGetSVData();
2000     pSVData->mpDefInst->AddToRecentDocumentList(rFileUrl, rMimeType);
2001 }
2002
2003 BOOL Application::IsAccessibilityEnabled()
2004 {
2005     return FALSE;
2006 }
2007
2008 BOOL InitAccessBridge( BOOL bShowCancel, BOOL &rCancelled )
2009 {
2010     BOOL bRet = true;
2011
2012 // Disable Java bridge on UNIX
2013 #if defined UNX
2014     (void) bShowCancel; // unsued
2015     (void) rCancelled; // unused
2016 #else
2017     bRet = ImplInitAccessBridge( bShowCancel, rCancelled );
2018
2019     if( !bRet && bShowCancel && !rCancelled )
2020     {
2021         // disable accessibility if the user chooses to continue
2022         AllSettings aSettings = Application::GetSettings();
2023         MiscSettings aMisc = aSettings.GetMiscSettings();
2024         aMisc.SetEnableATToolSupport( FALSE );
2025         aSettings.SetMiscSettings( aMisc );
2026         Application::SetSettings( aSettings );
2027     }
2028 #endif // !UNX
2029
2030     return bRet;
2031 }
2032
2033 // MT: AppProperty, AppEvent was in oldsv.cxx, but is still needed...
2034 // ------------------------------------------------------------------------
2035
2036 TYPEINIT0(ApplicationProperty)
2037
2038 // ------------------------------------------------------------------------
2039
2040 static PropertyHandler* pHandler=NULL;
2041
2042 void Application::Property( ApplicationProperty& rProp )
2043 {
2044     if ( pHandler )
2045         pHandler->Property( rProp );
2046 }
2047
2048 void Application::SetPropertyHandler( PropertyHandler* p )
2049 {
2050     if ( pHandler )
2051         delete pHandler;
2052     pHandler = p;
2053 }
2054
2055
2056
2057 void Application::AppEvent( const ApplicationEvent& /*rAppEvent*/ )
2058 {
2059 }