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