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