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 <sal/config.h>
21 :
22 : #include <cstdlib>
23 :
24 : #include <tools/debug.hxx>
25 :
26 : #include <vcl/layout.hxx>
27 : #include <vcl/settings.hxx>
28 : #include <vcl/svapp.hxx>
29 : #include <vcl/menu.hxx>
30 : #include <vcl/event.hxx>
31 : #include <vcl/syswin.hxx>
32 : #include <vcl/taskpanelist.hxx>
33 : #include <vcl/unowrap.hxx>
34 :
35 : #include <rtl/strbuf.hxx>
36 :
37 : #include <salframe.hxx>
38 : #include <svdata.hxx>
39 : #include <brdwin.hxx>
40 : #include <window.h>
41 :
42 : using namespace ::com::sun::star::uno;
43 : using namespace ::com::sun::star::lang;
44 :
45 : class SystemWindow::ImplData
46 : {
47 : public:
48 : ImplData();
49 : ~ImplData();
50 :
51 : TaskPaneList* mpTaskPaneList;
52 : Size maMaxOutSize;
53 : OUString maRepresentedURL;
54 : Link<> maCloseHdl;
55 : };
56 :
57 6933 : SystemWindow::ImplData::ImplData()
58 : {
59 6933 : mpTaskPaneList = NULL;
60 6933 : maMaxOutSize = Size( SHRT_MAX, SHRT_MAX );
61 6933 : }
62 :
63 13830 : SystemWindow::ImplData::~ImplData()
64 : {
65 6915 : delete mpTaskPaneList;
66 6915 : }
67 :
68 6933 : void SystemWindow::Init()
69 : {
70 6933 : mpImplData = new ImplData;
71 6933 : mpWindowImpl->mbSysWin = true;
72 6933 : mpWindowImpl->mnActivateMode = ActivateModeFlags::GrabFocus;
73 :
74 6933 : mpMenuBar = NULL;
75 6933 : mbPinned = false;
76 6933 : mbRollUp = false;
77 6933 : mbRollFunc = false;
78 6933 : mbDockBtn = false;
79 6933 : mbHideBtn = false;
80 6933 : mbSysChild = false;
81 6933 : mbIsCalculatingInitialLayoutSize = false;
82 6933 : mbInitialLayoutDone = false;
83 6933 : mnMenuBarMode = MenuBarMode::Normal;
84 6933 : mnIcon = 0;
85 6933 : mpDialogParent = NULL;
86 :
87 : //To-Do, reuse maResizeTimer
88 6933 : maLayoutIdle.SetPriority(SchedulerPriority::RESIZE);
89 6933 : maLayoutIdle.SetIdleHdl( LINK( this, SystemWindow, ImplHandleLayoutTimerHdl ) );
90 6933 : }
91 :
92 6933 : SystemWindow::SystemWindow(WindowType nType)
93 : : Window(nType)
94 6933 : , mbIsDefferedInit(false)
95 : {
96 6933 : Init();
97 6933 : }
98 :
99 3 : void SystemWindow::loadUI(vcl::Window* pParent, const OString& rID, const OUString& rUIXMLDescription,
100 : const css::uno::Reference<css::frame::XFrame> &rFrame)
101 : {
102 3 : mbIsDefferedInit = true;
103 3 : mpDialogParent = pParent; //should be unset in doDeferredInit
104 6 : m_pUIBuilder = new VclBuilder(this, getUIRootDir(), rUIXMLDescription, rID, rFrame);
105 0 : }
106 :
107 13830 : SystemWindow::~SystemWindow()
108 : {
109 6915 : disposeOnce();
110 6915 : }
111 :
112 6915 : void SystemWindow::dispose()
113 : {
114 6915 : maLayoutIdle.Stop();
115 6915 : delete mpImplData;
116 6915 : mpImplData = NULL;
117 :
118 : // Hack to make sure code called from base ~Window does not interpret this
119 : // as a SystemWindow (which it no longer is by then):
120 6915 : mpWindowImpl->mbSysWin = false;
121 6915 : disposeBuilder();
122 6915 : mpDialogParent.clear();
123 6915 : Window::dispose();
124 6915 : }
125 :
126 70346 : bool SystemWindow::Notify( NotifyEvent& rNEvt )
127 : {
128 : // capture KeyEvents for menu handling
129 70346 : if ( rNEvt.GetType() == MouseNotifyEvent::KEYINPUT )
130 : {
131 0 : MenuBar* pMBar = mpMenuBar;
132 0 : if ( !pMBar && ( GetType() == WINDOW_FLOATINGWINDOW ) )
133 : {
134 0 : vcl::Window* pWin = ImplGetFrameWindow()->ImplGetWindow();
135 0 : if( pWin && pWin->IsSystemWindow() )
136 0 : pMBar = static_cast<SystemWindow*>(pWin)->GetMenuBar();
137 : }
138 0 : if ( pMBar && pMBar->ImplHandleKeyEvent( *rNEvt.GetKeyEvent(), false ) )
139 0 : return true;
140 : }
141 :
142 70346 : return Window::Notify( rNEvt );
143 : }
144 :
145 32682 : bool SystemWindow::PreNotify( NotifyEvent& rNEvt )
146 : {
147 : // capture KeyEvents for taskpane cycling
148 32682 : if ( rNEvt.GetType() == MouseNotifyEvent::KEYINPUT )
149 : {
150 0 : if( rNEvt.GetKeyEvent()->GetKeyCode().GetCode() == KEY_F6 &&
151 0 : rNEvt.GetKeyEvent()->GetKeyCode().IsMod1() &&
152 0 : !rNEvt.GetKeyEvent()->GetKeyCode().IsShift() )
153 : {
154 : // Ctrl-F6 goes directly to the document
155 0 : GrabFocusToDocument();
156 0 : return true;
157 : }
158 : else
159 : {
160 0 : TaskPaneList *pTList = mpImplData->mpTaskPaneList;
161 0 : if( !pTList && ( GetType() == WINDOW_FLOATINGWINDOW ) )
162 : {
163 0 : vcl::Window* pWin = ImplGetFrameWindow()->ImplGetWindow();
164 0 : if( pWin && pWin->IsSystemWindow() )
165 0 : pTList = static_cast<SystemWindow*>(pWin)->mpImplData->mpTaskPaneList;
166 : }
167 0 : if( !pTList )
168 : {
169 : // search topmost system window which is the one to handle dialog/toolbar cycling
170 0 : SystemWindow *pSysWin = this;
171 0 : vcl::Window *pWin = this;
172 0 : while( pWin )
173 : {
174 0 : pWin = pWin->GetParent();
175 0 : if( pWin && pWin->IsSystemWindow() )
176 0 : pSysWin = static_cast<SystemWindow*>(pWin);
177 : }
178 0 : pTList = pSysWin->mpImplData->mpTaskPaneList;
179 : }
180 0 : if( pTList && pTList->HandleKeyEvent( *rNEvt.GetKeyEvent() ) )
181 0 : return true;
182 : }
183 : }
184 32682 : return Window::PreNotify( rNEvt );
185 : }
186 :
187 33949 : TaskPaneList* SystemWindow::GetTaskPaneList()
188 : {
189 33949 : if( !mpImplData )
190 0 : return NULL;
191 33949 : if( mpImplData->mpTaskPaneList )
192 30683 : return mpImplData->mpTaskPaneList ;
193 : else
194 : {
195 3266 : mpImplData->mpTaskPaneList = new TaskPaneList();
196 3266 : MenuBar* pMBar = mpMenuBar;
197 3266 : if ( !pMBar && ( GetType() == WINDOW_FLOATINGWINDOW ) )
198 : {
199 0 : vcl::Window* pWin = ImplGetFrameWindow()->ImplGetWindow();
200 0 : if ( pWin && pWin->IsSystemWindow() )
201 0 : pMBar = static_cast<SystemWindow*>(pWin)->GetMenuBar();
202 : }
203 3266 : if( pMBar )
204 121 : mpImplData->mpTaskPaneList->AddWindow( pMBar->ImplGetWindow() );
205 3266 : return mpImplData->mpTaskPaneList;
206 : }
207 : }
208 :
209 0 : bool SystemWindow::Close()
210 : {
211 0 : ImplDelData aDelData;
212 0 : ImplAddDel( &aDelData );
213 0 : CallEventListeners( VCLEVENT_WINDOW_CLOSE );
214 0 : if ( aDelData.IsDead() )
215 0 : return false;
216 0 : ImplRemoveDel( &aDelData );
217 :
218 0 : if ( mpWindowImpl->mxWindowPeer.is() && IsCreatedWithToolkit() )
219 0 : return false;
220 :
221 : // Is Window not closeable, ignore close
222 0 : vcl::Window* pBorderWin = ImplGetBorderWindow();
223 : WinBits nStyle;
224 0 : if ( pBorderWin )
225 0 : nStyle = pBorderWin->GetStyle();
226 : else
227 0 : nStyle = GetStyle();
228 0 : if ( !(nStyle & WB_CLOSEABLE) )
229 0 : return false;
230 :
231 0 : Hide();
232 :
233 0 : return true;
234 : }
235 :
236 0 : void SystemWindow::TitleButtonClick( TitleButton )
237 : {
238 0 : }
239 :
240 0 : void SystemWindow::Pin()
241 : {
242 0 : }
243 :
244 0 : void SystemWindow::Roll()
245 : {
246 0 : }
247 :
248 0 : void SystemWindow::Resizing( Size& )
249 : {
250 0 : }
251 :
252 6639 : void SystemWindow::SetRepresentedURL( const OUString& i_rURL )
253 : {
254 6639 : bool bChanged = (i_rURL != mpImplData->maRepresentedURL);
255 6639 : mpImplData->maRepresentedURL = i_rURL;
256 6639 : if ( !mbSysChild && bChanged )
257 : {
258 2486 : const vcl::Window* pWindow = this;
259 7458 : while ( pWindow->mpWindowImpl->mpBorderWindow )
260 2486 : pWindow = pWindow->mpWindowImpl->mpBorderWindow;
261 :
262 2486 : if ( pWindow->mpWindowImpl->mbFrame )
263 2486 : pWindow->mpWindowImpl->mpFrame->SetRepresentedURL( i_rURL );
264 : }
265 6639 : }
266 :
267 9928 : void SystemWindow::SetIcon( sal_uInt16 nIcon )
268 : {
269 9928 : if ( mnIcon == nIcon )
270 16566 : return;
271 :
272 3290 : mnIcon = nIcon;
273 :
274 3290 : if ( !mbSysChild )
275 : {
276 3290 : const vcl::Window* pWindow = this;
277 9870 : while ( pWindow->mpWindowImpl->mpBorderWindow )
278 3290 : pWindow = pWindow->mpWindowImpl->mpBorderWindow;
279 :
280 3290 : if ( pWindow->mpWindowImpl->mbFrame )
281 3290 : pWindow->mpWindowImpl->mpFrame->SetIcon( nIcon );
282 : }
283 : }
284 :
285 3314 : void SystemWindow::EnableSaveBackground(bool bSave)
286 : {
287 3314 : if( ImplGetSVData()->maWinData.mbNoSaveBackground )
288 0 : bSave = false;
289 :
290 3314 : vcl::Window* pWindow = this;
291 9942 : while (pWindow->mpWindowImpl->mpBorderWindow)
292 3314 : pWindow = pWindow->mpWindowImpl->mpBorderWindow;
293 3314 : if (pWindow->mpWindowImpl->mbOverlapWin && !pWindow->mpWindowImpl->mbFrame)
294 : {
295 0 : pWindow->mpWindowImpl->mpOverlapData->mbSaveBack = bSave;
296 0 : if (!bSave)
297 0 : pWindow->ImplDeleteOverlapBackground();
298 : }
299 3314 : }
300 :
301 12 : bool SystemWindow::IsSaveBackgroundEnabled() const
302 : {
303 12 : const vcl::Window* pWindow = this;
304 36 : while ( pWindow->mpWindowImpl->mpBorderWindow )
305 12 : pWindow = pWindow->mpWindowImpl->mpBorderWindow;
306 12 : if ( pWindow->mpWindowImpl->mpOverlapData )
307 12 : return pWindow->mpWindowImpl->mpOverlapData->mbSaveBack;
308 : else
309 0 : return false;
310 : }
311 :
312 0 : void SystemWindow::ShowTitleButton( TitleButton nButton, bool bVisible )
313 : {
314 0 : if ( nButton == TitleButton::Docking )
315 : {
316 0 : if ( mbDockBtn != bVisible )
317 : {
318 0 : mbDockBtn = bVisible;
319 0 : if ( mpWindowImpl->mpBorderWindow )
320 0 : static_cast<ImplBorderWindow*>(mpWindowImpl->mpBorderWindow.get())->SetDockButton( bVisible );
321 : }
322 : }
323 0 : else if ( nButton == TitleButton::Hide )
324 : {
325 0 : if ( mbHideBtn != bVisible )
326 : {
327 0 : mbHideBtn = bVisible;
328 0 : if ( mpWindowImpl->mpBorderWindow )
329 0 : static_cast<ImplBorderWindow*>(mpWindowImpl->mpBorderWindow.get())->SetHideButton( bVisible );
330 : }
331 : }
332 0 : else if ( nButton == TitleButton::Menu )
333 : {
334 0 : if ( mpWindowImpl->mpBorderWindow )
335 0 : static_cast<ImplBorderWindow*>(mpWindowImpl->mpBorderWindow.get())->SetMenuButton( bVisible );
336 : }
337 : else
338 0 : return;
339 : }
340 :
341 0 : bool SystemWindow::IsTitleButtonVisible( TitleButton nButton ) const
342 : {
343 0 : if ( nButton == TitleButton::Docking )
344 0 : return mbDockBtn;
345 : else /* if ( nButton == TitleButton::Hide ) */
346 0 : return mbHideBtn;
347 : }
348 :
349 0 : void SystemWindow::SetPin( bool bPin )
350 : {
351 0 : if ( bPin != mbPinned )
352 : {
353 0 : mbPinned = bPin;
354 0 : if ( mpWindowImpl->mpBorderWindow )
355 0 : static_cast<ImplBorderWindow*>(mpWindowImpl->mpBorderWindow.get())->SetPin( bPin );
356 : }
357 0 : }
358 :
359 0 : void SystemWindow::RollUp()
360 : {
361 0 : if ( !mbRollUp )
362 : {
363 0 : maOrgSize = GetOutputSizePixel();
364 0 : mbRollFunc = true;
365 0 : Size aSize = maRollUpOutSize;
366 0 : if ( !aSize.Width() )
367 0 : aSize.Width() = GetOutputSizePixel().Width();
368 0 : mbRollUp = true;
369 0 : if ( mpWindowImpl->mpBorderWindow )
370 0 : static_cast<ImplBorderWindow*>(mpWindowImpl->mpBorderWindow.get())->SetRollUp( true, aSize );
371 : else
372 0 : SetOutputSizePixel( aSize );
373 0 : mbRollFunc = false;
374 : }
375 0 : }
376 :
377 0 : void SystemWindow::RollDown()
378 : {
379 0 : if ( mbRollUp )
380 : {
381 0 : mbRollUp = false;
382 0 : if ( mpWindowImpl->mpBorderWindow )
383 0 : static_cast<ImplBorderWindow*>(mpWindowImpl->mpBorderWindow.get())->SetRollUp( false, maOrgSize );
384 : else
385 0 : SetOutputSizePixel( maOrgSize );
386 : }
387 0 : }
388 :
389 2 : void SystemWindow::SetMinOutputSizePixel( const Size& rSize )
390 : {
391 2 : maMinOutSize = rSize;
392 2 : if ( mpWindowImpl->mpBorderWindow )
393 : {
394 1 : static_cast<ImplBorderWindow*>(mpWindowImpl->mpBorderWindow.get())->SetMinOutputSize( rSize.Width(), rSize.Height() );
395 1 : if ( mpWindowImpl->mpBorderWindow->mpWindowImpl->mbFrame )
396 1 : mpWindowImpl->mpBorderWindow->mpWindowImpl->mpFrame->SetMinClientSize( rSize.Width(), rSize.Height() );
397 : }
398 1 : else if ( mpWindowImpl->mbFrame )
399 1 : mpWindowImpl->mpFrame->SetMinClientSize( rSize.Width(), rSize.Height() );
400 2 : }
401 :
402 0 : void SystemWindow::SetMaxOutputSizePixel( const Size& rSize )
403 : {
404 0 : Size aSize( rSize );
405 0 : if( aSize.Width() > SHRT_MAX || aSize.Width() <= 0 )
406 0 : aSize.Width() = SHRT_MAX;
407 0 : if( aSize.Height() > SHRT_MAX || aSize.Height() <= 0 )
408 0 : aSize.Height() = SHRT_MAX;
409 :
410 0 : mpImplData->maMaxOutSize = aSize;
411 0 : if ( mpWindowImpl->mpBorderWindow )
412 : {
413 0 : static_cast<ImplBorderWindow*>(mpWindowImpl->mpBorderWindow.get())->SetMaxOutputSize( aSize.Width(), aSize.Height() );
414 0 : if ( mpWindowImpl->mpBorderWindow->mpWindowImpl->mbFrame )
415 0 : mpWindowImpl->mpBorderWindow->mpWindowImpl->mpFrame->SetMaxClientSize( aSize.Width(), aSize.Height() );
416 : }
417 0 : else if ( mpWindowImpl->mbFrame )
418 0 : mpWindowImpl->mpFrame->SetMaxClientSize( aSize.Width(), aSize.Height() );
419 0 : }
420 :
421 13 : const Size& SystemWindow::GetMaxOutputSizePixel() const
422 : {
423 13 : return mpImplData->maMaxOutSize;
424 : }
425 :
426 3220 : static void ImplWindowStateFromStr(WindowStateData& rData,
427 : const OString& rStr)
428 : {
429 3220 : sal_uLong nValidMask = 0;
430 3220 : sal_Int32 nIndex = 0;
431 3220 : OString aTokenStr;
432 :
433 3220 : aTokenStr = rStr.getToken(0, ',', nIndex);
434 3220 : if (!aTokenStr.isEmpty())
435 : {
436 3101 : rData.SetX(aTokenStr.toInt32());
437 3101 : if( rData.GetX() > -16384 && rData.GetX() < 16384 )
438 3101 : nValidMask |= WINDOWSTATE_MASK_X;
439 : else
440 0 : rData.SetX( 0 );
441 : }
442 : else
443 119 : rData.SetX( 0 );
444 3220 : aTokenStr = rStr.getToken(0, ',', nIndex);
445 3220 : if (!aTokenStr.isEmpty())
446 : {
447 3101 : rData.SetY(aTokenStr.toInt32());
448 3101 : if( rData.GetY() > -16384 && rData.GetY() < 16384 )
449 3101 : nValidMask |= WINDOWSTATE_MASK_Y;
450 : else
451 0 : rData.SetY( 0 );
452 : }
453 : else
454 119 : rData.SetY( 0 );
455 3220 : aTokenStr = rStr.getToken(0, ',', nIndex);
456 3220 : if (!aTokenStr.isEmpty())
457 : {
458 3101 : rData.SetWidth(aTokenStr.toInt32());
459 3101 : if( rData.GetWidth() > 0 && rData.GetWidth() < 16384 )
460 3101 : nValidMask |= WINDOWSTATE_MASK_WIDTH;
461 : else
462 0 : rData.SetWidth( 0 );
463 : }
464 : else
465 119 : rData.SetWidth( 0 );
466 3220 : aTokenStr = rStr.getToken(0, ';', nIndex);
467 3220 : if (!aTokenStr.isEmpty())
468 : {
469 3101 : rData.SetHeight(aTokenStr.toInt32());
470 3101 : if( rData.GetHeight() > 0 && rData.GetHeight() < 16384 )
471 3101 : nValidMask |= WINDOWSTATE_MASK_HEIGHT;
472 : else
473 0 : rData.SetHeight( 0 );
474 : }
475 : else
476 119 : rData.SetHeight( 0 );
477 3220 : aTokenStr = rStr.getToken(0, ';', nIndex);
478 3220 : if (!aTokenStr.isEmpty())
479 : {
480 : // #94144# allow Minimize again, should be masked out when read from configuration
481 : // 91625 - ignore Minimize
482 3220 : sal_uInt32 nState = (sal_uInt32)aTokenStr.toInt32();
483 : //nState &= ~(WINDOWSTATE_STATE_MINIMIZED);
484 3220 : rData.SetState( nState );
485 3220 : nValidMask |= WINDOWSTATE_MASK_STATE;
486 : }
487 : else
488 0 : rData.SetState( 0 );
489 :
490 : // read maximized pos/size
491 3220 : aTokenStr = rStr.getToken(0, ',', nIndex);
492 3220 : if (!aTokenStr.isEmpty())
493 : {
494 3101 : rData.SetMaximizedX(aTokenStr.toInt32());
495 3101 : if( rData.GetMaximizedX() > -16384 && rData.GetMaximizedX() < 16384 )
496 3101 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_X;
497 : else
498 0 : rData.SetMaximizedX( 0 );
499 : }
500 : else
501 119 : rData.SetMaximizedX( 0 );
502 3220 : aTokenStr = rStr.getToken(0, ',', nIndex);
503 3220 : if (!aTokenStr.isEmpty())
504 : {
505 3101 : rData.SetMaximizedY(aTokenStr.toInt32());
506 3101 : if( rData.GetMaximizedY() > -16384 && rData.GetMaximizedY() < 16384 )
507 3101 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_Y;
508 : else
509 0 : rData.SetMaximizedY( 0 );
510 : }
511 : else
512 119 : rData.SetMaximizedY( 0 );
513 3220 : aTokenStr = rStr.getToken(0, ',', nIndex);
514 3220 : if (!aTokenStr.isEmpty())
515 : {
516 3101 : rData.SetMaximizedWidth(aTokenStr.toInt32());
517 3101 : if( rData.GetMaximizedWidth() > 0 && rData.GetMaximizedWidth() < 16384 )
518 0 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_WIDTH;
519 : else
520 3101 : rData.SetMaximizedWidth( 0 );
521 : }
522 : else
523 119 : rData.SetMaximizedWidth( 0 );
524 3220 : aTokenStr = rStr.getToken(0, ';', nIndex);
525 3220 : if (!aTokenStr.isEmpty())
526 : {
527 3101 : rData.SetMaximizedHeight(aTokenStr.toInt32());
528 3101 : if( rData.GetMaximizedHeight() > 0 && rData.GetMaximizedHeight() < 16384 )
529 0 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_HEIGHT;
530 : else
531 3101 : rData.SetMaximizedHeight( 0 );
532 : }
533 : else
534 119 : rData.SetMaximizedHeight( 0 );
535 :
536 : // mark valid fields
537 3220 : rData.SetMask( nValidMask );
538 3220 : }
539 :
540 6455 : static OString ImplWindowStateToStr(const WindowStateData& rData)
541 : {
542 6455 : sal_uLong nValidMask = rData.GetMask();
543 6455 : if ( !nValidMask )
544 0 : return OString();
545 :
546 6455 : OStringBuffer rStrBuf;
547 :
548 6455 : if ( nValidMask & WINDOWSTATE_MASK_X )
549 6455 : rStrBuf.append(static_cast<sal_Int32>(rData.GetX()));
550 6455 : rStrBuf.append(',');
551 6455 : if ( nValidMask & WINDOWSTATE_MASK_Y )
552 6455 : rStrBuf.append(static_cast<sal_Int32>(rData.GetY()));
553 6455 : rStrBuf.append(',');
554 6455 : if ( nValidMask & WINDOWSTATE_MASK_WIDTH )
555 6455 : rStrBuf.append(static_cast<sal_Int32>(rData.GetWidth()));
556 6455 : rStrBuf.append(',');
557 6455 : if ( nValidMask & WINDOWSTATE_MASK_HEIGHT )
558 6455 : rStrBuf.append(static_cast<sal_Int32>(rData.GetHeight()));
559 6455 : rStrBuf.append( ';' );
560 6455 : if ( nValidMask & WINDOWSTATE_MASK_STATE )
561 : {
562 : // #94144# allow Minimize again, should be masked out when read from configuration
563 : // 91625 - ignore Minimize
564 6455 : sal_uInt32 nState = rData.GetState();
565 6455 : rStrBuf.append(static_cast<sal_Int32>(nState));
566 : }
567 6455 : rStrBuf.append(';');
568 6455 : if ( nValidMask & WINDOWSTATE_MASK_MAXIMIZED_X )
569 6455 : rStrBuf.append(static_cast<sal_Int32>(rData.GetMaximizedX()));
570 6455 : rStrBuf.append(',');
571 6455 : if ( nValidMask & WINDOWSTATE_MASK_MAXIMIZED_Y )
572 6455 : rStrBuf.append(static_cast<sal_Int32>(rData.GetMaximizedY()));
573 6455 : rStrBuf.append( ',' );
574 6455 : if ( nValidMask & WINDOWSTATE_MASK_MAXIMIZED_WIDTH )
575 6455 : rStrBuf.append(static_cast<sal_Int32>(rData.GetMaximizedWidth()));
576 6455 : rStrBuf.append(',');
577 6455 : if ( nValidMask & WINDOWSTATE_MASK_MAXIMIZED_HEIGHT )
578 6455 : rStrBuf.append(static_cast<sal_Int32>(rData.GetMaximizedHeight()));
579 6455 : rStrBuf.append(';');
580 :
581 6455 : return rStrBuf.makeStringAndClear();
582 : }
583 :
584 6440 : void SystemWindow::ImplMoveToScreen( long& io_rX, long& io_rY, long i_nWidth, long i_nHeight, vcl::Window* i_pConfigureWin )
585 : {
586 6440 : Rectangle aScreenRect;
587 6440 : if( !Application::IsUnifiedDisplay() )
588 0 : aScreenRect = Application::GetScreenPosSizePixel( GetScreenNumber() );
589 : else
590 : {
591 6440 : aScreenRect = Application::GetScreenPosSizePixel( 0 );
592 6440 : for( unsigned int i = 1; i < Application::GetScreenCount(); i++ )
593 0 : aScreenRect.Union( Application::GetScreenPosSizePixel( i ) );
594 : }
595 : // unfortunately most of the time width and height are not really known
596 6440 : if( i_nWidth < 1 )
597 3339 : i_nWidth = 50;
598 6440 : if( i_nHeight < 1 )
599 3339 : i_nHeight = 50;
600 :
601 : // check left border
602 6440 : bool bMove = false;
603 6440 : if( io_rX + i_nWidth < aScreenRect.Left() )
604 : {
605 0 : bMove = true;
606 0 : io_rX = aScreenRect.Left();
607 : }
608 : // check right border
609 6440 : if( io_rX > aScreenRect.Right() - i_nWidth )
610 : {
611 0 : bMove = true;
612 0 : io_rX = aScreenRect.Right() - i_nWidth;
613 : }
614 : // check top border
615 6440 : if( io_rY + i_nHeight < aScreenRect.Top() )
616 : {
617 0 : bMove = true;
618 0 : io_rY = aScreenRect.Top();
619 : }
620 : // check bottom border
621 6440 : if( io_rY > aScreenRect.Bottom() - i_nHeight )
622 : {
623 0 : bMove = true;
624 0 : io_rY = aScreenRect.Bottom() - i_nHeight;
625 : }
626 6440 : vcl::Window* pParent = i_pConfigureWin->GetParent();
627 6440 : if( bMove && pParent )
628 : {
629 : // calculate absolute screen pos here, since that is what is contained in WindowState
630 0 : Point aParentAbsPos( pParent->OutputToAbsoluteScreenPixel( Point(0,0) ) );
631 0 : Size aParentSizePixel( pParent->GetOutputSizePixel() );
632 0 : Point aPos( (aParentSizePixel.Width() - i_nWidth) / 2,
633 0 : (aParentSizePixel.Height() - i_nHeight) / 2 );
634 0 : io_rX = aParentAbsPos.X() + aPos.X();
635 0 : io_rY = aParentAbsPos.Y() + aPos.Y();
636 : }
637 6440 : }
638 :
639 3220 : void SystemWindow::SetWindowStateData( const WindowStateData& rData )
640 : {
641 3220 : sal_uLong nValidMask = rData.GetMask();
642 3220 : if ( !nValidMask )
643 0 : return;
644 :
645 3220 : if ( mbSysChild )
646 0 : return;
647 :
648 3220 : vcl::Window* pWindow = this;
649 9660 : while ( pWindow->mpWindowImpl->mpBorderWindow )
650 3220 : pWindow = pWindow->mpWindowImpl->mpBorderWindow;
651 :
652 3220 : if ( pWindow->mpWindowImpl->mbFrame )
653 : {
654 3220 : sal_uLong nState = rData.GetState();
655 : SalFrameState aState;
656 3220 : aState.mnMask = rData.GetMask();
657 3220 : aState.mnX = rData.GetX();
658 3220 : aState.mnY = rData.GetY();
659 3220 : aState.mnWidth = rData.GetWidth();
660 3220 : aState.mnHeight = rData.GetHeight();
661 :
662 3220 : if( rData.GetMask() & (WINDOWSTATE_MASK_WIDTH|WINDOWSTATE_MASK_HEIGHT) )
663 : {
664 : // #i43799# adjust window state sizes if a minimial output size was set
665 : // otherwise the frame and the client might get different sizes
666 3101 : if( maMinOutSize.Width() > aState.mnWidth )
667 0 : aState.mnWidth = maMinOutSize.Width();
668 3101 : if( maMinOutSize.Height() > aState.mnHeight )
669 0 : aState.mnHeight = maMinOutSize.Height();
670 : }
671 :
672 3220 : aState.mnMaximizedX = rData.GetMaximizedX();
673 3220 : aState.mnMaximizedY = rData.GetMaximizedY();
674 3220 : aState.mnMaximizedWidth = rData.GetMaximizedWidth();
675 3220 : aState.mnMaximizedHeight = rData.GetMaximizedHeight();
676 : // #94144# allow Minimize again, should be masked out when read from configuration
677 : // 91625 - ignore Minimize
678 : //nState &= ~(WINDOWSTATE_STATE_MINIMIZED);
679 3220 : aState.mnState = nState & WINDOWSTATE_STATE_SYSTEMMASK;
680 :
681 : // normalize window positions onto screen
682 3220 : ImplMoveToScreen( aState.mnX, aState.mnY, aState.mnWidth, aState.mnHeight, pWindow );
683 3220 : ImplMoveToScreen( aState.mnMaximizedX, aState.mnMaximizedY, aState.mnMaximizedWidth, aState.mnMaximizedHeight, pWindow );
684 :
685 : // #96568# avoid having multiple frames at the same screen location
686 : // do the check only if not maximized
687 3220 : if( !((rData.GetMask() & WINDOWSTATE_MASK_STATE) && (nState & WINDOWSTATE_STATE_MAXIMIZED)) )
688 3101 : if( rData.GetMask() & (WINDOWSTATE_MASK_POS|WINDOWSTATE_MASK_WIDTH|WINDOWSTATE_MASK_HEIGHT) )
689 : {
690 3101 : Rectangle aDesktop = GetDesktopRectPixel();
691 3101 : ImplSVData *pSVData = ImplGetSVData();
692 3101 : vcl::Window *pWin = pSVData->maWinData.mpFirstFrame;
693 3101 : bool bWrapped = false;
694 13231 : while( pWin )
695 : {
696 21910 : if( !pWin->ImplIsRealParentPath( this ) && ( pWin != this ) &&
697 14881 : pWin->ImplGetWindow()->IsTopWindow() && pWin->mpWindowImpl->mbReallyVisible )
698 : {
699 148 : SalFrameGeometry g = pWin->mpWindowImpl->mpFrame->GetGeometry();
700 148 : if( std::abs(g.nX-aState.mnX) < 2 && std::abs(g.nY-aState.mnY) < 5 )
701 : {
702 60 : long displacement = g.nTopDecoration ? g.nTopDecoration : 20;
703 120 : if( (unsigned long) (aState.mnX + displacement + aState.mnWidth + g.nRightDecoration) > (unsigned long) aDesktop.Right() ||
704 60 : (unsigned long) (aState.mnY + displacement + aState.mnHeight + g.nBottomDecoration) > (unsigned long) aDesktop.Bottom() )
705 : {
706 : // displacing would leave screen
707 0 : aState.mnX = g.nLeftDecoration ? g.nLeftDecoration : 10; // should result in (0,0)
708 0 : aState.mnY = displacement;
709 0 : if( bWrapped ||
710 0 : (unsigned long) (aState.mnX + displacement + aState.mnWidth + g.nRightDecoration) > (unsigned long) aDesktop.Right() ||
711 0 : (unsigned long) (aState.mnY + displacement + aState.mnHeight + g.nBottomDecoration) > (unsigned long) aDesktop.Bottom() )
712 0 : break; // further displacement not possible -> break
713 : // avoid endless testing
714 0 : bWrapped = true;
715 : }
716 : else
717 : {
718 : // displace
719 60 : aState.mnX += displacement;
720 60 : aState.mnY += displacement;
721 : }
722 60 : pWin = pSVData->maWinData.mpFirstFrame; // check new pos again
723 : }
724 : }
725 7029 : pWin = pWin->mpWindowImpl->mpFrameData->mpNextFrame;
726 : }
727 : }
728 :
729 3220 : mpWindowImpl->mpFrame->SetWindowState( &aState );
730 :
731 : // do a synchronous resize for layout reasons
732 : // but use rData only when the window is not to be maximized (#i38089#)
733 : // otherwise we have no useful size information
734 3220 : if( (rData.GetMask() & WINDOWSTATE_MASK_STATE) && (nState & WINDOWSTATE_STATE_MAXIMIZED) )
735 : {
736 : // query maximized size from frame
737 119 : SalFrameGeometry aGeometry = mpWindowImpl->mpFrame->GetGeometry();
738 :
739 : // but use it only if it is different from the restore size (rData)
740 : // as currently only on windows the exact size of a maximized window
741 : // can be computed without actually showing the window
742 119 : if( aGeometry.nWidth != rData.GetWidth() || aGeometry.nHeight != rData.GetHeight() )
743 119 : ImplHandleResize( pWindow, aGeometry.nWidth, aGeometry.nHeight );
744 : }
745 : else
746 3101 : if( rData.GetMask() & (WINDOWSTATE_MASK_WIDTH|WINDOWSTATE_MASK_HEIGHT) )
747 3101 : ImplHandleResize( pWindow, aState.mnWidth, aState.mnHeight ); // #i43799# use aState and not rData, see above
748 : }
749 : else
750 : {
751 0 : PosSizeFlags nPosSize = PosSizeFlags::NONE;
752 0 : if ( nValidMask & WINDOWSTATE_MASK_X )
753 0 : nPosSize |= PosSizeFlags::X;
754 0 : if ( nValidMask & WINDOWSTATE_MASK_Y )
755 0 : nPosSize |= PosSizeFlags::Y;
756 0 : if ( nValidMask & WINDOWSTATE_MASK_WIDTH )
757 0 : nPosSize |= PosSizeFlags::Width;
758 0 : if ( nValidMask & WINDOWSTATE_MASK_HEIGHT )
759 0 : nPosSize |= PosSizeFlags::Height;
760 :
761 0 : if( IsRollUp() )
762 0 : RollDown();
763 :
764 0 : long nX = rData.GetX();
765 0 : long nY = rData.GetY();
766 0 : long nWidth = rData.GetWidth();
767 0 : long nHeight = rData.GetHeight();
768 0 : const SalFrameGeometry& rGeom = pWindow->mpWindowImpl->mpFrame->GetGeometry();
769 0 : if( nX < 0 )
770 0 : nX = 0;
771 0 : if( nX + nWidth > (long) rGeom.nWidth )
772 0 : nX = rGeom.nWidth - nWidth;
773 0 : if( nY < 0 )
774 0 : nY = 0;
775 0 : if( nY + nHeight > (long) rGeom.nHeight )
776 0 : nY = rGeom.nHeight - nHeight;
777 0 : setPosSizePixel( nX, nY, nWidth, nHeight, nPosSize );
778 0 : maOrgSize = Size( nWidth, nHeight );
779 :
780 : // 91625 - ignore Minimize
781 0 : if ( nValidMask & WINDOWSTATE_MASK_STATE )
782 : {
783 0 : sal_uLong nState = rData.GetState();
784 0 : if ( nState & WINDOWSTATE_STATE_ROLLUP )
785 0 : RollUp();
786 : else
787 0 : RollDown();
788 : }
789 : }
790 : }
791 :
792 6455 : void SystemWindow::GetWindowStateData( WindowStateData& rData ) const
793 : {
794 6455 : sal_uLong nValidMask = rData.GetMask();
795 6455 : if ( !nValidMask )
796 0 : return;
797 :
798 6455 : if ( mbSysChild )
799 0 : return;
800 :
801 6455 : const vcl::Window* pWindow = this;
802 19365 : while ( pWindow->mpWindowImpl->mpBorderWindow )
803 6455 : pWindow = pWindow->mpWindowImpl->mpBorderWindow;
804 :
805 6455 : if ( pWindow->mpWindowImpl->mbFrame )
806 : {
807 : SalFrameState aState;
808 6455 : aState.mnMask = 0xFFFFFFFF;
809 6455 : if ( mpWindowImpl->mpFrame->GetWindowState( &aState ) )
810 : {
811 6455 : if ( nValidMask & WINDOWSTATE_MASK_X )
812 6455 : rData.SetX( aState.mnX );
813 6455 : if ( nValidMask & WINDOWSTATE_MASK_Y )
814 6455 : rData.SetY( aState.mnY );
815 6455 : if ( nValidMask & WINDOWSTATE_MASK_WIDTH )
816 6455 : rData.SetWidth( aState.mnWidth );
817 6455 : if ( nValidMask & WINDOWSTATE_MASK_HEIGHT )
818 6455 : rData.SetHeight( aState.mnHeight );
819 6455 : if ( aState.mnMask & WINDOWSTATE_MASK_MAXIMIZED_X )
820 : {
821 0 : rData.SetMaximizedX( aState.mnMaximizedX );
822 0 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_X;
823 : }
824 6455 : if ( aState.mnMask & WINDOWSTATE_MASK_MAXIMIZED_Y )
825 : {
826 0 : rData.SetMaximizedY( aState.mnMaximizedY );
827 0 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_Y;
828 : }
829 6455 : if ( aState.mnMask & WINDOWSTATE_MASK_MAXIMIZED_WIDTH )
830 : {
831 0 : rData.SetMaximizedWidth( aState.mnMaximizedWidth );
832 0 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_WIDTH;
833 : }
834 6455 : if ( aState.mnMask & WINDOWSTATE_MASK_MAXIMIZED_HEIGHT )
835 : {
836 0 : rData.SetMaximizedHeight( aState.mnMaximizedHeight );
837 0 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_HEIGHT;
838 : }
839 6455 : if ( nValidMask & WINDOWSTATE_MASK_STATE )
840 : {
841 : // #94144# allow Minimize again, should be masked out when read from configuration
842 : // 91625 - ignore Minimize
843 6455 : if ( !(nValidMask&WINDOWSTATE_MASK_MINIMIZED) )
844 3264 : aState.mnState &= ~(WINDOWSTATE_STATE_MINIMIZED);
845 6455 : rData.SetState( aState.mnState );
846 : }
847 6455 : rData.SetMask( nValidMask );
848 : }
849 : else
850 0 : rData.SetMask( 0 );
851 : }
852 : else
853 : {
854 0 : Point aPos = GetPosPixel();
855 0 : Size aSize = GetSizePixel();
856 0 : sal_uLong nState = 0;
857 :
858 0 : if ( IsRollUp() )
859 : {
860 0 : aSize.Height() += maOrgSize.Height();
861 0 : nState |= WINDOWSTATE_STATE_ROLLUP;
862 : }
863 :
864 0 : if ( nValidMask & WINDOWSTATE_MASK_X )
865 0 : rData.SetX( aPos.X() );
866 0 : if ( nValidMask & WINDOWSTATE_MASK_Y )
867 0 : rData.SetY( aPos.Y() );
868 0 : if ( nValidMask & WINDOWSTATE_MASK_WIDTH )
869 0 : rData.SetWidth( aSize.Width() );
870 0 : if ( nValidMask & WINDOWSTATE_MASK_HEIGHT )
871 0 : rData.SetHeight( aSize.Height() );
872 0 : if ( nValidMask & WINDOWSTATE_MASK_STATE )
873 0 : rData.SetState( nState );
874 : }
875 : }
876 :
877 3220 : void SystemWindow::SetWindowState(const OString& rStr)
878 : {
879 3220 : if (rStr.isEmpty())
880 3220 : return;
881 :
882 3220 : WindowStateData aData;
883 3220 : ImplWindowStateFromStr( aData, rStr );
884 3220 : SetWindowStateData( aData );
885 : }
886 :
887 6455 : OString SystemWindow::GetWindowState( sal_uLong nMask ) const
888 : {
889 6455 : WindowStateData aData;
890 6455 : aData.SetMask( nMask );
891 6455 : GetWindowStateData( aData );
892 :
893 6455 : return ImplWindowStateToStr(aData);
894 : }
895 :
896 10569 : void SystemWindow::SetMenuBar(MenuBar* pMenuBar, const css::uno::Reference<css::frame::XFrame>& rFrame)
897 : {
898 10569 : if ( mpMenuBar != pMenuBar )
899 : {
900 6393 : MenuBar* pOldMenuBar = mpMenuBar;
901 6393 : vcl::Window* pOldWindow = NULL;
902 6393 : vcl::Window* pNewWindow=NULL;
903 6393 : mpMenuBar = pMenuBar;
904 :
905 6393 : if ( mpWindowImpl->mpBorderWindow && (mpWindowImpl->mpBorderWindow->GetType() == WINDOW_BORDERWINDOW) )
906 : {
907 6393 : if ( pOldMenuBar )
908 3194 : pOldWindow = pOldMenuBar->ImplGetWindow();
909 : else
910 3199 : pOldWindow = NULL;
911 6393 : if ( pOldWindow )
912 : {
913 3194 : CallEventListeners( VCLEVENT_WINDOW_MENUBARREMOVED, static_cast<void*>(pOldMenuBar) );
914 3194 : pOldWindow->SetAccessible( ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible >() );
915 : }
916 6393 : if ( pMenuBar )
917 : {
918 : DBG_ASSERT( !pMenuBar->pWindow, "SystemWindow::SetMenuBar() - MenuBars can only set in one SystemWindow at time" );
919 3200 : static_cast<ImplBorderWindow*>(mpWindowImpl->mpBorderWindow.get())->SetMenuBarWindow( pNewWindow = MenuBar::ImplCreate( mpWindowImpl->mpBorderWindow, pOldWindow, pMenuBar, rFrame));
920 3200 : CallEventListeners( VCLEVENT_WINDOW_MENUBARADDED, static_cast<void*>(pMenuBar) );
921 : }
922 : else
923 3193 : static_cast<ImplBorderWindow*>(mpWindowImpl->mpBorderWindow.get())->SetMenuBarWindow( NULL );
924 6393 : ImplToBottomChild();
925 6393 : if ( pOldMenuBar )
926 : {
927 3194 : bool bDelete = (pMenuBar == 0);
928 3194 : if( bDelete && pOldWindow )
929 : {
930 3193 : if( mpImplData->mpTaskPaneList )
931 3193 : mpImplData->mpTaskPaneList->RemoveWindow( pOldWindow );
932 : }
933 3194 : MenuBar::ImplDestroy( pOldMenuBar, bDelete );
934 3194 : if( bDelete )
935 3193 : pOldWindow = NULL; // will be deleted in MenuBar::ImplDestroy,
936 : }
937 :
938 : }
939 : else
940 : {
941 0 : if( pMenuBar )
942 0 : pNewWindow = pMenuBar->ImplGetWindow();
943 0 : if( pOldMenuBar )
944 0 : pOldWindow = pOldMenuBar->ImplGetWindow();
945 : }
946 :
947 : // update taskpane list to make menubar accessible
948 6393 : if( mpImplData->mpTaskPaneList )
949 : {
950 6272 : if( pOldWindow )
951 1 : mpImplData->mpTaskPaneList->RemoveWindow( pOldWindow );
952 6272 : if( pNewWindow )
953 3079 : mpImplData->mpTaskPaneList->AddWindow( pNewWindow );
954 : }
955 : }
956 10569 : }
957 :
958 0 : void SystemWindow::SetMenuBarMode( MenuBarMode nMode )
959 : {
960 0 : if ( mnMenuBarMode != nMode )
961 : {
962 0 : mnMenuBarMode = nMode;
963 0 : if ( mpWindowImpl->mpBorderWindow && (mpWindowImpl->mpBorderWindow->GetType() == WINDOW_BORDERWINDOW) )
964 : {
965 0 : if ( nMode == MenuBarMode::Hide )
966 0 : static_cast<ImplBorderWindow*>(mpWindowImpl->mpBorderWindow.get())->SetMenuBarMode( true );
967 : else
968 0 : static_cast<ImplBorderWindow*>(mpWindowImpl->mpBorderWindow.get())->SetMenuBarMode( false );
969 : }
970 : }
971 0 : }
972 :
973 28880 : bool SystemWindow::ImplIsInTaskPaneList( vcl::Window* pWin )
974 : {
975 28880 : if( mpImplData && mpImplData->mpTaskPaneList )
976 21158 : return mpImplData->mpTaskPaneList->IsInList( pWin );
977 7722 : return false;
978 : }
979 :
980 0 : unsigned int SystemWindow::GetScreenNumber() const
981 : {
982 0 : return mpWindowImpl->mpFrame->maGeometry.nDisplayScreenNumber;
983 : }
984 :
985 0 : void SystemWindow::SetScreenNumber(unsigned int nDisplayScreen)
986 : {
987 0 : mpWindowImpl->mpFrame->SetScreenNumber( nDisplayScreen );
988 0 : }
989 :
990 9908 : void SystemWindow::SetApplicationID(const OUString &rApplicationID)
991 : {
992 9908 : mpWindowImpl->mpFrame->SetApplicationID( rApplicationID );
993 9908 : }
994 :
995 16 : void SystemWindow::SetCloseHdl(const Link<>& rLink)
996 : {
997 16 : mpImplData->maCloseHdl = rLink;
998 16 : }
999 :
1000 2 : const Link<>& SystemWindow::GetCloseHdl() const
1001 : {
1002 2 : return mpImplData->maCloseHdl;
1003 : }
1004 :
1005 401314 : void SystemWindow::queue_resize(StateChangedType /*eReason*/)
1006 : {
1007 401314 : if (hasPendingLayout() || isCalculatingInitialLayoutSize())
1008 5 : return;
1009 401309 : if (!isLayoutEnabled())
1010 401307 : return;
1011 2 : InvalidateSizeCache();
1012 2 : maLayoutIdle.Start();
1013 : }
1014 :
1015 11084 : void SystemWindow::Resize()
1016 : {
1017 11084 : queue_resize();
1018 11084 : }
1019 :
1020 401328 : bool SystemWindow::isLayoutEnabled() const
1021 : {
1022 : //pre dtor called, and single child is a container => we're layout enabled
1023 401328 : return mpImplData && ::isLayoutEnabled(this);
1024 : }
1025 :
1026 1 : Size SystemWindow::GetOptimalSize() const
1027 : {
1028 1 : if (!isLayoutEnabled())
1029 0 : return Window::GetOptimalSize();
1030 :
1031 1 : Size aSize = VclContainer::getLayoutRequisition(*GetWindow(GetWindowType::FirstChild));
1032 :
1033 1 : sal_Int32 nBorderWidth = get_border_width();
1034 :
1035 2 : aSize.Height() += mpWindowImpl->mnLeftBorder + mpWindowImpl->mnRightBorder
1036 2 : + 2*nBorderWidth;
1037 2 : aSize.Width() += mpWindowImpl->mnTopBorder + mpWindowImpl->mnBottomBorder
1038 2 : + 2*nBorderWidth;
1039 :
1040 1 : return Window::CalcWindowSize(aSize);
1041 : }
1042 :
1043 1 : void SystemWindow::setPosSizeOnContainee(Size aSize, Window &rBox)
1044 : {
1045 1 : sal_Int32 nBorderWidth = get_border_width();
1046 :
1047 1 : aSize.Width() -= 2 * nBorderWidth;
1048 1 : aSize.Height() -= 2 * nBorderWidth;
1049 :
1050 1 : Point aPos(nBorderWidth, nBorderWidth);
1051 1 : VclContainer::setLayoutAllocation(rBox, aPos, aSize);
1052 1 : }
1053 :
1054 0 : IMPL_LINK_NOARG_TYPED( SystemWindow, ImplHandleLayoutTimerHdl, Idle*, void )
1055 : {
1056 0 : if (!isLayoutEnabled())
1057 : {
1058 : SAL_WARN("vcl.layout", "SystemWindow has become non-layout because extra children have been added directly to it.");
1059 0 : return;
1060 : }
1061 :
1062 0 : Window *pBox = GetWindow(GetWindowType::FirstChild);
1063 : assert(pBox);
1064 0 : setPosSizeOnContainee(GetSizePixel(), *pBox);
1065 : }
1066 :
1067 10125 : void SystemWindow::SetText(const OUString& rStr)
1068 : {
1069 10125 : setDeferredProperties();
1070 10125 : Window::SetText(rStr);
1071 10125 : }
1072 :
1073 257 : OUString SystemWindow::GetText() const
1074 : {
1075 257 : const_cast<SystemWindow*>(this)->setDeferredProperties();
1076 257 : return Window::GetText();
1077 : }
1078 :
1079 0 : void SystemWindow::settingOptimalLayoutSize(Window* /*pBox*/)
1080 : {
1081 0 : }
1082 :
1083 1 : void SystemWindow::setOptimalLayoutSize()
1084 : {
1085 1 : maLayoutIdle.Stop();
1086 :
1087 : //resize SystemWindow to fit requisition on initial show
1088 1 : Window *pBox = GetWindow(GetWindowType::FirstChild);
1089 :
1090 1 : settingOptimalLayoutSize(pBox);
1091 :
1092 1 : Size aSize = get_preferred_size();
1093 :
1094 1 : Size aMax(bestmaxFrameSizeForScreenSize(GetDesktopRectPixel().GetSize()));
1095 :
1096 1 : aSize.Width() = std::min(aMax.Width(), aSize.Width());
1097 1 : aSize.Height() = std::min(aMax.Height(), aSize.Height());
1098 :
1099 1 : SetMinOutputSizePixel(aSize);
1100 1 : SetSizePixel(aSize);
1101 1 : setPosSizeOnContainee(aSize, *pBox);
1102 1 : }
1103 :
1104 17 : void SystemWindow::DoInitialLayout()
1105 : {
1106 17 : if ( GetSettings().GetStyleSettings().GetAutoMnemonic() )
1107 17 : ImplWindowAutoMnemonic( this );
1108 :
1109 17 : if (isLayoutEnabled())
1110 : {
1111 1 : mbIsCalculatingInitialLayoutSize = true;
1112 1 : setDeferredProperties();
1113 1 : setOptimalLayoutSize();
1114 1 : mbIsCalculatingInitialLayoutSize = false;
1115 1 : mbInitialLayoutDone = true;
1116 : }
1117 17 : }
1118 :
1119 0 : void SystemWindow::doDeferredInit(WinBits /*nBits*/)
1120 : {
1121 : SAL_WARN("vcl.layout", "SystemWindow in layout without doDeferredInit impl");
1122 801 : }
1123 :
1124 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
