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