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