Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*************************************************************************
3 : : *
4 : : * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 : : *
6 : : * Copyright 2000, 2010 Oracle and/or its affiliates.
7 : : *
8 : : * OpenOffice.org - a multi-platform office productivity suite
9 : : *
10 : : * This file is part of OpenOffice.org.
11 : : *
12 : : * OpenOffice.org is free software: you can redistribute it and/or modify
13 : : * it under the terms of the GNU Lesser General Public License version 3
14 : : * only, as published by the Free Software Foundation.
15 : : *
16 : : * OpenOffice.org is distributed in the hope that it will be useful,
17 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 : : * GNU Lesser General Public License version 3 for more details
20 : : * (a copy is included in the LICENSE file that accompanied this code).
21 : : *
22 : : * You should have received a copy of the GNU Lesser General Public License
23 : : * version 3 along with OpenOffice.org. If not, see
24 : : * <http://www.openoffice.org/license.html>
25 : : * for a copy of the LGPLv3 License.
26 : : *
27 : : ************************************************************************/
28 : :
29 : : #include <tools/debug.hxx>
30 : :
31 : : #include <vcl/svapp.hxx>
32 : : #include <vcl/menu.hxx>
33 : : #include <vcl/svapp.hxx>
34 : : #include <vcl/event.hxx>
35 : : #include <vcl/syswin.hxx>
36 : : #include <vcl/taskpanelist.hxx>
37 : : #include <vcl/unowrap.hxx>
38 : :
39 : : #include <rtl/strbuf.hxx>
40 : :
41 : : #include <salframe.hxx>
42 : : #include <svdata.hxx>
43 : : #include <brdwin.hxx>
44 : : #include <window.h>
45 : :
46 : : using namespace ::com::sun::star::uno;
47 : : using namespace ::com::sun::star::lang;
48 : :
49 : : // =======================================================================
50 : : class SystemWindow::ImplData
51 : : {
52 : : public:
53 : : ImplData();
54 : : ~ImplData();
55 : :
56 : : TaskPaneList* mpTaskPaneList;
57 : : Size maMaxOutSize;
58 : : rtl::OUString maRepresentedURL;
59 : : Link maCloseHdl;
60 : : };
61 : :
62 [ + - ]: 5988 : SystemWindow::ImplData::ImplData()
63 : : {
64 : 5988 : mpTaskPaneList = NULL;
65 : 5988 : maMaxOutSize = Size( SHRT_MAX, SHRT_MAX );
66 : 5988 : }
67 : :
68 : 5802 : SystemWindow::ImplData::~ImplData()
69 : : {
70 [ + + ]: 5802 : if( mpTaskPaneList )
71 [ + - ][ + - ]: 1632 : delete mpTaskPaneList;
72 : 5802 : }
73 : :
74 : : // =======================================================================
75 : :
76 : 5988 : SystemWindow::SystemWindow( WindowType nType ) :
77 : 5988 : Window( nType )
78 : : {
79 [ + - ][ + - ]: 5988 : mpImplData = new ImplData;
80 : 5988 : mpWindowImpl->mbSysWin = sal_True;
81 : 5988 : mpWindowImpl->mnActivateMode = ACTIVATE_MODE_GRABFOCUS;
82 : :
83 : 5988 : mpMenuBar = NULL;
84 : 5988 : mbPined = sal_False;
85 : 5988 : mbRollUp = sal_False;
86 : 5988 : mbRollFunc = sal_False;
87 : 5988 : mbDockBtn = sal_False;
88 : 5988 : mbHideBtn = sal_False;
89 : 5988 : mbSysChild = sal_False;
90 : 5988 : mnMenuBarMode = MENUBAR_MODE_NORMAL;
91 : 5988 : mnIcon = 0;
92 : 5988 : }
93 : :
94 : 5802 : SystemWindow::~SystemWindow()
95 : : {
96 [ + - ][ + - ]: 5802 : delete mpImplData;
97 : 5802 : mpImplData = NULL;
98 [ - + ]: 5802 : }
99 : :
100 : : // -----------------------------------------------------------------------
101 : :
102 : 56132 : long SystemWindow::Notify( NotifyEvent& rNEvt )
103 : : {
104 : : // capture KeyEvents for menu handling
105 [ - + ]: 56132 : if ( rNEvt.GetType() == EVENT_KEYINPUT )
106 : : {
107 : 0 : MenuBar* pMBar = mpMenuBar;
108 [ # # ][ # # ]: 0 : if ( !pMBar && ( GetType() == WINDOW_FLOATINGWINDOW ) )
[ # # ]
109 : : {
110 : 0 : Window* pWin = ImplGetFrameWindow()->ImplGetWindow();
111 [ # # ][ # # ]: 0 : if( pWin && pWin->IsSystemWindow() )
[ # # ]
112 : 0 : pMBar = ((SystemWindow*)pWin)->GetMenuBar();
113 : : }
114 [ # # ][ # # ]: 0 : if ( pMBar && pMBar->ImplHandleKeyEvent( *rNEvt.GetKeyEvent(), sal_False ) )
[ # # ]
115 : 0 : return sal_True;
116 : : }
117 : :
118 : 56132 : return Window::Notify( rNEvt );
119 : : }
120 : :
121 : : // -----------------------------------------------------------------------
122 : :
123 : 15945 : long SystemWindow::PreNotify( NotifyEvent& rNEvt )
124 : : {
125 : : // capture KeyEvents for taskpane cycling
126 [ - + ]: 15945 : if ( rNEvt.GetType() == EVENT_KEYINPUT )
127 : : {
128 [ # # # # : 0 : if( rNEvt.GetKeyEvent()->GetKeyCode().GetCode() == KEY_F6 &&
# # ][ # # ]
129 : 0 : rNEvt.GetKeyEvent()->GetKeyCode().IsMod1() &&
130 : 0 : !rNEvt.GetKeyEvent()->GetKeyCode().IsShift() )
131 : : {
132 : : // Ctrl-F6 goes directly to the document
133 : 0 : GrabFocusToDocument();
134 : 0 : return sal_True;
135 : : }
136 : : else
137 : : {
138 : 0 : TaskPaneList *pTList = mpImplData->mpTaskPaneList;
139 [ # # ][ # # ]: 0 : if( !pTList && ( GetType() == WINDOW_FLOATINGWINDOW ) )
[ # # ]
140 : : {
141 : 0 : Window* pWin = ImplGetFrameWindow()->ImplGetWindow();
142 [ # # ][ # # ]: 0 : if( pWin && pWin->IsSystemWindow() )
[ # # ]
143 : 0 : pTList = ((SystemWindow*)pWin)->mpImplData->mpTaskPaneList;
144 : : }
145 [ # # ]: 0 : if( !pTList )
146 : : {
147 : : // search topmost system window which is the one to handle dialog/toolbar cycling
148 : 0 : SystemWindow *pSysWin = this;
149 : 0 : Window *pWin = this;
150 [ # # ]: 0 : while( pWin )
151 : : {
152 : 0 : pWin = pWin->GetParent();
153 [ # # ][ # # ]: 0 : if( pWin && pWin->IsSystemWindow() )
[ # # ]
154 : 0 : pSysWin = (SystemWindow*) pWin;
155 : : }
156 : 0 : pTList = pSysWin->mpImplData->mpTaskPaneList;
157 : : }
158 [ # # ][ # # ]: 0 : if( pTList && pTList->HandleKeyEvent( *rNEvt.GetKeyEvent() ) )
[ # # ][ # # ]
[ # # ][ # # ]
[ # # # # ]
159 : 0 : return sal_True;
160 : : }
161 : : }
162 : 15945 : return Window::PreNotify( rNEvt );
163 : : }
164 : :
165 : : // -----------------------------------------------------------------------
166 : :
167 : 9298 : TaskPaneList* SystemWindow::GetTaskPaneList()
168 : : {
169 [ + + ]: 9298 : if( mpImplData->mpTaskPaneList )
170 : 7575 : return mpImplData->mpTaskPaneList ;
171 : : else
172 : : {
173 [ + - ]: 1723 : mpImplData->mpTaskPaneList = new TaskPaneList();
174 : 1723 : MenuBar* pMBar = mpMenuBar;
175 [ + + ][ - + ]: 1723 : if ( !pMBar && ( GetType() == WINDOW_FLOATINGWINDOW ) )
[ - + ]
176 : : {
177 : 0 : Window* pWin = ImplGetFrameWindow()->ImplGetWindow();
178 [ # # ][ # # ]: 0 : if ( pWin && pWin->IsSystemWindow() )
[ # # ]
179 : 0 : pMBar = ((SystemWindow*)pWin)->GetMenuBar();
180 : : }
181 [ + + ]: 1723 : if( pMBar )
182 : 1428 : mpImplData->mpTaskPaneList->AddWindow( pMBar->ImplGetWindow() );
183 : 9298 : return mpImplData->mpTaskPaneList;
184 : : }
185 : : }
186 : :
187 : : // -----------------------------------------------------------------------
188 : :
189 : 0 : sal_Bool SystemWindow::Close()
190 : : {
191 [ # # ]: 0 : ImplDelData aDelData;
192 [ # # ]: 0 : ImplAddDel( &aDelData );
193 [ # # ]: 0 : ImplCallEventListeners( VCLEVENT_WINDOW_CLOSE );
194 [ # # ]: 0 : if ( aDelData.IsDead() )
195 : 0 : return sal_False;
196 [ # # ]: 0 : ImplRemoveDel( &aDelData );
197 : :
198 [ # # ][ # # ]: 0 : if ( mpWindowImpl->mxWindowPeer.is() && IsCreatedWithToolkit() )
[ # # ][ # # ]
199 : 0 : return sal_False;
200 : :
201 : : // Is Window not closeable, ignore close
202 [ # # ]: 0 : Window* pBorderWin = ImplGetBorderWindow();
203 : : WinBits nStyle;
204 [ # # ]: 0 : if ( pBorderWin )
205 [ # # ]: 0 : nStyle = pBorderWin->GetStyle();
206 : : else
207 [ # # ]: 0 : nStyle = GetStyle();
208 [ # # ]: 0 : if ( !(nStyle & WB_CLOSEABLE) )
209 : 0 : return sal_False;
210 : :
211 [ # # ]: 0 : Hide();
212 : :
213 [ # # ]: 0 : return sal_True;
214 : : }
215 : :
216 : : // -----------------------------------------------------------------------
217 : :
218 : 0 : void SystemWindow::TitleButtonClick( sal_uInt16 )
219 : : {
220 : 0 : }
221 : :
222 : : // -----------------------------------------------------------------------
223 : :
224 : 0 : void SystemWindow::Pin()
225 : : {
226 : 0 : }
227 : :
228 : : // -----------------------------------------------------------------------
229 : :
230 : 0 : void SystemWindow::Roll()
231 : : {
232 : 0 : }
233 : :
234 : : // -----------------------------------------------------------------------
235 : :
236 : 0 : void SystemWindow::Resizing( Size& )
237 : : {
238 : 0 : }
239 : :
240 : : // -----------------------------------------------------------------------
241 : :
242 : 3501 : void SystemWindow::SetRepresentedURL( const rtl::OUString& i_rURL )
243 : : {
244 : 3501 : bool bChanged = (i_rURL != mpImplData->maRepresentedURL);
245 : 3501 : mpImplData->maRepresentedURL = i_rURL;
246 [ + + ][ + - ]: 3501 : if ( !mbSysChild && bChanged )
247 : : {
248 : 687 : const Window* pWindow = this;
249 [ + + ]: 1374 : while ( pWindow->mpWindowImpl->mpBorderWindow )
250 : 687 : pWindow = pWindow->mpWindowImpl->mpBorderWindow;
251 : :
252 [ + - ]: 687 : if ( pWindow->mpWindowImpl->mbFrame )
253 : 687 : pWindow->mpWindowImpl->mpFrame->SetRepresentedURL( i_rURL );
254 : : }
255 : 3501 : }
256 : :
257 : : // -----------------------------------------------------------------------
258 : :
259 : 5262 : void SystemWindow::SetIcon( sal_uInt16 nIcon )
260 : : {
261 [ + + ]: 5262 : if ( mnIcon == nIcon )
262 : 5262 : return;
263 : :
264 : 1777 : mnIcon = nIcon;
265 : :
266 [ + - ]: 1777 : if ( !mbSysChild )
267 : : {
268 : 1777 : const Window* pWindow = this;
269 [ + + ]: 3554 : while ( pWindow->mpWindowImpl->mpBorderWindow )
270 : 1777 : pWindow = pWindow->mpWindowImpl->mpBorderWindow;
271 : :
272 [ + - ]: 1777 : if ( pWindow->mpWindowImpl->mbFrame )
273 : 1777 : pWindow->mpWindowImpl->mpFrame->SetIcon( nIcon );
274 : : }
275 : : }
276 : :
277 : : // -----------------------------------------------------------------------
278 : :
279 : 3870 : void SystemWindow::EnableSaveBackground( sal_Bool bSave )
280 : : {
281 [ - + ]: 3870 : if( ImplGetSVData()->maWinData.mbNoSaveBackground )
282 : 0 : bSave = false;
283 : :
284 : 3870 : Window* pWindow = this;
285 [ + + ]: 7740 : while ( pWindow->mpWindowImpl->mpBorderWindow )
286 : 3870 : pWindow = pWindow->mpWindowImpl->mpBorderWindow;
287 [ + - ][ - + ]: 3870 : if ( pWindow->mpWindowImpl->mbOverlapWin && !pWindow->mpWindowImpl->mbFrame )
288 : : {
289 : 0 : pWindow->mpWindowImpl->mpOverlapData->mbSaveBack = bSave;
290 [ # # ]: 0 : if ( !bSave )
291 : 0 : pWindow->ImplDeleteOverlapBackground();
292 : : }
293 : 3870 : }
294 : :
295 : : // -----------------------------------------------------------------------
296 : :
297 : 24 : sal_Bool SystemWindow::IsSaveBackgroundEnabled() const
298 : : {
299 : 24 : const Window* pWindow = this;
300 [ + + ]: 48 : while ( pWindow->mpWindowImpl->mpBorderWindow )
301 : 24 : pWindow = pWindow->mpWindowImpl->mpBorderWindow;
302 [ + - ]: 24 : if ( pWindow->mpWindowImpl->mpOverlapData )
303 : 24 : return pWindow->mpWindowImpl->mpOverlapData->mbSaveBack;
304 : : else
305 : 24 : return sal_False;
306 : : }
307 : :
308 : : // -----------------------------------------------------------------------
309 : :
310 : 0 : void SystemWindow::ShowTitleButton( sal_uInt16 nButton, sal_Bool bVisible )
311 : : {
312 [ # # ]: 0 : if ( nButton == TITLE_BUTTON_DOCKING )
313 : : {
314 [ # # ]: 0 : if ( mbDockBtn != bVisible )
315 : : {
316 : 0 : mbDockBtn = bVisible;
317 [ # # ]: 0 : if ( mpWindowImpl->mpBorderWindow )
318 : 0 : ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetDockButton( bVisible );
319 : : }
320 : : }
321 [ # # ]: 0 : else if ( nButton == TITLE_BUTTON_HIDE )
322 : : {
323 [ # # ]: 0 : if ( mbHideBtn != bVisible )
324 : : {
325 : 0 : mbHideBtn = bVisible;
326 [ # # ]: 0 : if ( mpWindowImpl->mpBorderWindow )
327 : 0 : ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetHideButton( bVisible );
328 : : }
329 : : }
330 [ # # ]: 0 : else if ( nButton == TITLE_BUTTON_MENU )
331 : : {
332 [ # # ]: 0 : if ( mpWindowImpl->mpBorderWindow )
333 : 0 : ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMenuButton( bVisible );
334 : : }
335 : : else
336 : 0 : return;
337 : : }
338 : :
339 : : // -----------------------------------------------------------------------
340 : :
341 : 0 : sal_Bool SystemWindow::IsTitleButtonVisible( sal_uInt16 nButton ) const
342 : : {
343 [ # # ]: 0 : if ( nButton == TITLE_BUTTON_DOCKING )
344 : 0 : return mbDockBtn;
345 : : else /* if ( nButton == TITLE_BUTTON_HIDE ) */
346 : 0 : return mbHideBtn;
347 : : }
348 : :
349 : : // -----------------------------------------------------------------------
350 : :
351 : 0 : void SystemWindow::SetPin( sal_Bool bPin )
352 : : {
353 [ # # ]: 0 : if ( bPin != mbPined )
354 : : {
355 : 0 : mbPined = bPin;
356 [ # # ]: 0 : if ( mpWindowImpl->mpBorderWindow )
357 : 0 : ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetPin( bPin );
358 : : }
359 : 0 : }
360 : :
361 : : // -----------------------------------------------------------------------
362 : :
363 : 0 : void SystemWindow::RollUp()
364 : : {
365 [ # # ]: 0 : if ( !mbRollUp )
366 : : {
367 : 0 : maOrgSize = GetOutputSizePixel();
368 : 0 : mbRollFunc = sal_True;
369 : 0 : Size aSize = maRollUpOutSize;
370 [ # # ]: 0 : if ( !aSize.Width() )
371 : 0 : aSize.Width() = GetOutputSizePixel().Width();
372 : 0 : mbRollUp = sal_True;
373 [ # # ]: 0 : if ( mpWindowImpl->mpBorderWindow )
374 [ # # ]: 0 : ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetRollUp( sal_True, aSize );
375 : : else
376 [ # # ]: 0 : SetOutputSizePixel( aSize );
377 : 0 : mbRollFunc = sal_False;
378 : : }
379 : 0 : }
380 : :
381 : : // -----------------------------------------------------------------------
382 : :
383 : 0 : void SystemWindow::RollDown()
384 : : {
385 [ # # ]: 0 : if ( mbRollUp )
386 : : {
387 : 0 : mbRollUp = sal_False;
388 [ # # ]: 0 : if ( mpWindowImpl->mpBorderWindow )
389 : 0 : ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetRollUp( sal_False, maOrgSize );
390 : : else
391 : 0 : SetOutputSizePixel( maOrgSize );
392 : : }
393 : 0 : }
394 : :
395 : : // -----------------------------------------------------------------------
396 : :
397 : 0 : void SystemWindow::SetMinOutputSizePixel( const Size& rSize )
398 : : {
399 : 0 : maMinOutSize = rSize;
400 [ # # ]: 0 : if ( mpWindowImpl->mpBorderWindow )
401 : : {
402 : 0 : ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMinOutputSize( rSize.Width(), rSize.Height() );
403 [ # # ]: 0 : if ( mpWindowImpl->mpBorderWindow->mpWindowImpl->mbFrame )
404 : 0 : mpWindowImpl->mpBorderWindow->mpWindowImpl->mpFrame->SetMinClientSize( rSize.Width(), rSize.Height() );
405 : : }
406 [ # # ]: 0 : else if ( mpWindowImpl->mbFrame )
407 : 0 : mpWindowImpl->mpFrame->SetMinClientSize( rSize.Width(), rSize.Height() );
408 : 0 : }
409 : :
410 : : // -----------------------------------------------------------------------
411 : :
412 : 0 : void SystemWindow::SetMaxOutputSizePixel( const Size& rSize )
413 : : {
414 : 0 : Size aSize( rSize );
415 [ # # ][ # # ]: 0 : if( aSize.Width() > SHRT_MAX || aSize.Width() <= 0 )
[ # # ]
416 : 0 : aSize.Width() = SHRT_MAX;
417 [ # # ][ # # ]: 0 : if( aSize.Height() > SHRT_MAX || aSize.Height() <= 0 )
[ # # ]
418 : 0 : aSize.Height() = SHRT_MAX;
419 : :
420 : 0 : mpImplData->maMaxOutSize = aSize;
421 [ # # ]: 0 : if ( mpWindowImpl->mpBorderWindow )
422 : : {
423 : 0 : ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMaxOutputSize( aSize.Width(), aSize.Height() );
424 [ # # ]: 0 : if ( mpWindowImpl->mpBorderWindow->mpWindowImpl->mbFrame )
425 [ # # ]: 0 : mpWindowImpl->mpBorderWindow->mpWindowImpl->mpFrame->SetMaxClientSize( aSize.Width(), aSize.Height() );
426 : : }
427 [ # # ]: 0 : else if ( mpWindowImpl->mbFrame )
428 [ # # ]: 0 : mpWindowImpl->mpFrame->SetMaxClientSize( aSize.Width(), aSize.Height() );
429 : 0 : }
430 : :
431 : 176 : const Size& SystemWindow::GetMaxOutputSizePixel() const
432 : : {
433 : 176 : return mpImplData->maMaxOutSize;
434 : : }
435 : : // -----------------------------------------------------------------------
436 : :
437 : 0 : Size SystemWindow::GetResizeOutputSizePixel() const
438 : : {
439 : 0 : Size aSize = GetOutputSizePixel();
440 [ # # ]: 0 : if ( aSize.Width() < maMinOutSize.Width() )
441 : 0 : aSize.Width() = maMinOutSize.Width();
442 [ # # ]: 0 : if ( aSize.Height() < maMinOutSize.Height() )
443 : 0 : aSize.Height() = maMinOutSize.Height();
444 : 0 : return aSize;
445 : : }
446 : :
447 : : // -----------------------------------------------------------------------
448 : :
449 : 1871 : static void ImplWindowStateFromStr(WindowStateData& rData,
450 : : const rtl::OString& rStr)
451 : : {
452 : 1871 : sal_uLong nValidMask = 0;
453 : 1871 : sal_Int32 nIndex = 0;
454 : 1871 : rtl::OString aTokenStr;
455 : :
456 : 1871 : aTokenStr = rStr.getToken(0, ',', nIndex);
457 [ + + ]: 1871 : if (!aTokenStr.isEmpty())
458 : : {
459 : 1743 : rData.SetX(aTokenStr.toInt32());
460 [ + - ][ + - ]: 1743 : if( rData.GetX() > -16384 && rData.GetX() < 16384 )
[ + - ]
461 : 1743 : nValidMask |= WINDOWSTATE_MASK_X;
462 : : else
463 : 0 : rData.SetX( 0 );
464 : : }
465 : : else
466 : 128 : rData.SetX( 0 );
467 : 1871 : aTokenStr = rStr.getToken(0, ',', nIndex);
468 [ + + ]: 1871 : if (!aTokenStr.isEmpty())
469 : : {
470 : 1743 : rData.SetY(aTokenStr.toInt32());
471 [ + - ][ + - ]: 1743 : if( rData.GetY() > -16384 && rData.GetY() < 16384 )
[ + - ]
472 : 1743 : nValidMask |= WINDOWSTATE_MASK_Y;
473 : : else
474 : 0 : rData.SetY( 0 );
475 : : }
476 : : else
477 : 128 : rData.SetY( 0 );
478 : 1871 : aTokenStr = rStr.getToken(0, ',', nIndex);
479 [ + + ]: 1871 : if (!aTokenStr.isEmpty())
480 : : {
481 : 1683 : rData.SetWidth(aTokenStr.toInt32());
482 [ + - ][ + - ]: 1683 : if( rData.GetWidth() > 0 && rData.GetWidth() < 16384 )
[ + - ]
483 : 1683 : nValidMask |= WINDOWSTATE_MASK_WIDTH;
484 : : else
485 : 0 : rData.SetWidth( 0 );
486 : : }
487 : : else
488 : 188 : rData.SetWidth( 0 );
489 : 1871 : aTokenStr = rStr.getToken(0, ';', nIndex);
490 [ + + ]: 1871 : if (!aTokenStr.isEmpty())
491 : : {
492 : 1683 : rData.SetHeight(aTokenStr.toInt32());
493 [ + - ][ + - ]: 1683 : if( rData.GetHeight() > 0 && rData.GetHeight() < 16384 )
[ + - ]
494 : 1683 : nValidMask |= WINDOWSTATE_MASK_HEIGHT;
495 : : else
496 : 0 : rData.SetHeight( 0 );
497 : : }
498 : : else
499 : 188 : rData.SetHeight( 0 );
500 : 1871 : aTokenStr = rStr.getToken(0, ';', nIndex);
501 [ + - ]: 1871 : if (!aTokenStr.isEmpty())
502 : : {
503 : : // #94144# allow Minimize again, should be masked out when read from configuration
504 : : // 91625 - ignore Minimize
505 : 1871 : sal_uInt32 nState = (sal_uInt32)aTokenStr.toInt32();
506 : : //nState &= ~(WINDOWSTATE_STATE_MINIMIZED);
507 : 1871 : rData.SetState( nState );
508 : 1871 : nValidMask |= WINDOWSTATE_MASK_STATE;
509 : : }
510 : : else
511 : 0 : rData.SetState( 0 );
512 : :
513 : : // read maximized pos/size
514 : 1871 : aTokenStr = rStr.getToken(0, ',', nIndex);
515 [ + + ]: 1871 : if (!aTokenStr.isEmpty())
516 : : {
517 : 1683 : rData.SetMaximizedX(aTokenStr.toInt32());
518 [ + - ][ + - ]: 1683 : if( rData.GetMaximizedX() > -16384 && rData.GetMaximizedX() < 16384 )
[ + - ]
519 : 1683 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_X;
520 : : else
521 : 0 : rData.SetMaximizedX( 0 );
522 : : }
523 : : else
524 : 188 : rData.SetMaximizedX( 0 );
525 : 1871 : aTokenStr = rStr.getToken(0, ',', nIndex);
526 [ + + ]: 1871 : if (!aTokenStr.isEmpty())
527 : : {
528 : 1683 : rData.SetMaximizedY(aTokenStr.toInt32());
529 [ + - ][ + - ]: 1683 : if( rData.GetMaximizedY() > -16384 && rData.GetMaximizedY() < 16384 )
[ + - ]
530 : 1683 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_Y;
531 : : else
532 : 0 : rData.SetMaximizedY( 0 );
533 : : }
534 : : else
535 : 188 : rData.SetMaximizedY( 0 );
536 : 1871 : aTokenStr = rStr.getToken(0, ',', nIndex);
537 [ + + ]: 1871 : if (!aTokenStr.isEmpty())
538 : : {
539 : 1683 : rData.SetMaximizedWidth(aTokenStr.toInt32());
540 [ # # ][ - + ]: 1683 : if( rData.GetMaximizedWidth() > 0 && rData.GetMaximizedWidth() < 16384 )
[ - + ]
541 : 0 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_WIDTH;
542 : : else
543 : 1683 : rData.SetMaximizedWidth( 0 );
544 : : }
545 : : else
546 : 188 : rData.SetMaximizedWidth( 0 );
547 : 1871 : aTokenStr = rStr.getToken(0, ';', nIndex);
548 [ + + ]: 1871 : if (!aTokenStr.isEmpty())
549 : : {
550 : 1683 : rData.SetMaximizedHeight(aTokenStr.toInt32());
551 [ # # ][ - + ]: 1683 : if( rData.GetMaximizedHeight() > 0 && rData.GetMaximizedHeight() < 16384 )
[ - + ]
552 : 0 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_HEIGHT;
553 : : else
554 : 1683 : rData.SetMaximizedHeight( 0 );
555 : : }
556 : : else
557 : 188 : rData.SetMaximizedHeight( 0 );
558 : :
559 : : // mark valid fields
560 : 1871 : rData.SetMask( nValidMask );
561 : 1871 : }
562 : :
563 : : // -----------------------------------------------------------------------
564 : :
565 : 3362 : static rtl::OString ImplWindowStateToStr(const WindowStateData& rData)
566 : : {
567 : 3362 : sal_uLong nValidMask = rData.GetMask();
568 [ - + ]: 3362 : if ( !nValidMask )
569 : 0 : return rtl::OString();
570 : :
571 : 3362 : rtl::OStringBuffer rStrBuf;
572 : :
573 [ + - ]: 3362 : if ( nValidMask & WINDOWSTATE_MASK_X )
574 [ + - ]: 3362 : rStrBuf.append(static_cast<sal_Int32>(rData.GetX()));
575 [ + - ]: 3362 : rStrBuf.append(',');
576 [ + - ]: 3362 : if ( nValidMask & WINDOWSTATE_MASK_Y )
577 [ + - ]: 3362 : rStrBuf.append(static_cast<sal_Int32>(rData.GetY()));
578 [ + - ]: 3362 : rStrBuf.append(',');
579 [ + + ]: 3362 : if ( nValidMask & WINDOWSTATE_MASK_WIDTH )
580 [ + - ]: 3288 : rStrBuf.append(static_cast<sal_Int32>(rData.GetWidth()));
581 [ + - ]: 3362 : rStrBuf.append(',');
582 [ + + ]: 3362 : if ( nValidMask & WINDOWSTATE_MASK_HEIGHT )
583 [ + - ]: 3288 : rStrBuf.append(static_cast<sal_Int32>(rData.GetHeight()));
584 [ + - ]: 3362 : rStrBuf.append( ';' );
585 [ + - ]: 3362 : if ( nValidMask & WINDOWSTATE_MASK_STATE )
586 : : {
587 : : // #94144# allow Minimize again, should be masked out when read from configuration
588 : : // 91625 - ignore Minimize
589 : 3362 : sal_uInt32 nState = rData.GetState();
590 [ + - ]: 3362 : rStrBuf.append(static_cast<sal_Int32>(nState));
591 : : }
592 [ + - ]: 3362 : rStrBuf.append(';');
593 [ + + ]: 3362 : if ( nValidMask & WINDOWSTATE_MASK_MAXIMIZED_X )
594 [ + - ]: 3288 : rStrBuf.append(static_cast<sal_Int32>(rData.GetMaximizedX()));
595 [ + - ]: 3362 : rStrBuf.append(',');
596 [ + + ]: 3362 : if ( nValidMask & WINDOWSTATE_MASK_MAXIMIZED_Y )
597 [ + - ]: 3288 : rStrBuf.append(static_cast<sal_Int32>(rData.GetMaximizedY()));
598 [ + - ]: 3362 : rStrBuf.append( ',' );
599 [ + + ]: 3362 : if ( nValidMask & WINDOWSTATE_MASK_MAXIMIZED_WIDTH )
600 [ + - ]: 3288 : rStrBuf.append(static_cast<sal_Int32>(rData.GetMaximizedWidth()));
601 [ + - ]: 3362 : rStrBuf.append(',');
602 [ + + ]: 3362 : if ( nValidMask & WINDOWSTATE_MASK_MAXIMIZED_HEIGHT )
603 [ + - ]: 3288 : rStrBuf.append(static_cast<sal_Int32>(rData.GetMaximizedHeight()));
604 [ + - ]: 3362 : rStrBuf.append(';');
605 : :
606 : 3362 : return rStrBuf.makeStringAndClear();
607 : : }
608 : :
609 : : // -----------------------------------------------------------------------
610 : :
611 : 3742 : void SystemWindow::ImplMoveToScreen( long& io_rX, long& io_rY, long i_nWidth, long i_nHeight, Window* i_pConfigureWin )
612 : : {
613 [ + - ]: 3742 : Rectangle aScreenRect;
614 [ + - ][ - + ]: 3742 : if( !Application::IsUnifiedDisplay() )
615 [ # # ][ # # ]: 0 : aScreenRect = Application::GetScreenPosSizePixel( GetScreenNumber() );
616 : : else
617 : : {
618 [ + - ]: 3742 : aScreenRect = Application::GetScreenPosSizePixel( 0 );
619 [ + - ][ - + ]: 3742 : for( unsigned int i = 1; i < Application::GetScreenCount(); i++ )
620 [ # # ][ # # ]: 0 : aScreenRect.Union( Application::GetScreenPosSizePixel( i ) );
621 : : }
622 : : // unfortunately most of the time width and height are not really known
623 [ + + ]: 3742 : if( i_nWidth < 1 )
624 : 2059 : i_nWidth = 50;
625 [ + + ]: 3742 : if( i_nHeight < 1 )
626 : 2059 : i_nHeight = 50;
627 : :
628 : : // check left border
629 : 3742 : bool bMove = false;
630 [ - + ]: 3742 : if( io_rX + i_nWidth < aScreenRect.Left() )
631 : : {
632 : 0 : bMove = true;
633 : 0 : io_rX = aScreenRect.Left();
634 : : }
635 : : // check right border
636 [ - + ]: 3742 : if( io_rX > aScreenRect.Right() - i_nWidth )
637 : : {
638 : 0 : bMove = true;
639 : 0 : io_rX = aScreenRect.Right() - i_nWidth;
640 : : }
641 : : // check top border
642 [ - + ]: 3742 : if( io_rY + i_nHeight < aScreenRect.Top() )
643 : : {
644 : 0 : bMove = true;
645 : 0 : io_rY = aScreenRect.Top();
646 : : }
647 : : // check bottom border
648 [ - + ]: 3742 : if( io_rY > aScreenRect.Bottom() - i_nHeight )
649 : : {
650 : 0 : bMove = true;
651 : 0 : io_rY = aScreenRect.Bottom() - i_nHeight;
652 : : }
653 [ + - ]: 3742 : Window* pParent = i_pConfigureWin->GetParent();
654 [ - + ][ # # ]: 3742 : if( bMove && pParent )
655 : : {
656 : : // calculate absolute screen pos here, since that is what is contained in WindowState
657 [ # # ]: 0 : Point aParentAbsPos( pParent->OutputToAbsoluteScreenPixel( Point(0,0) ) );
658 : 0 : Size aParentSizePixel( pParent->GetOutputSizePixel() );
659 : 0 : Point aPos( (aParentSizePixel.Width() - i_nWidth) / 2,
660 : 0 : (aParentSizePixel.Height() - i_nHeight) / 2 );
661 : 0 : io_rX = aParentAbsPos.X() + aPos.X();
662 : 0 : io_rY = aParentAbsPos.Y() + aPos.Y();
663 : : }
664 : 3742 : }
665 : :
666 : 1871 : void SystemWindow::SetWindowStateData( const WindowStateData& rData )
667 : : {
668 : 1871 : sal_uLong nValidMask = rData.GetMask();
669 [ - + ]: 1871 : if ( !nValidMask )
670 : 0 : return;
671 : :
672 [ - + ]: 1871 : if ( mbSysChild )
673 : 0 : return;
674 : :
675 : 1871 : Window* pWindow = this;
676 [ + + ]: 3682 : while ( pWindow->mpWindowImpl->mpBorderWindow )
677 : 1811 : pWindow = pWindow->mpWindowImpl->mpBorderWindow;
678 : :
679 [ + - ]: 1871 : if ( pWindow->mpWindowImpl->mbFrame )
680 : : {
681 : 1871 : sal_uLong nState = rData.GetState();
682 : : SalFrameState aState;
683 : 1871 : aState.mnMask = rData.GetMask();
684 : 1871 : aState.mnX = rData.GetX();
685 : 1871 : aState.mnY = rData.GetY();
686 : 1871 : aState.mnWidth = rData.GetWidth();
687 : 1871 : aState.mnHeight = rData.GetHeight();
688 : :
689 [ + + ]: 1871 : if( rData.GetMask() & (WINDOWSTATE_MASK_WIDTH|WINDOWSTATE_MASK_HEIGHT) )
690 : : {
691 : : // #i43799# adjust window state sizes if a minimial output size was set
692 : : // otherwise the frame and the client might get different sizes
693 [ - + ]: 1683 : if( maMinOutSize.Width() > aState.mnWidth )
694 : 0 : aState.mnWidth = maMinOutSize.Width();
695 [ - + ]: 1683 : if( maMinOutSize.Height() > aState.mnHeight )
696 : 0 : aState.mnHeight = maMinOutSize.Height();
697 : : }
698 : :
699 : 1871 : aState.mnMaximizedX = rData.GetMaximizedX();
700 : 1871 : aState.mnMaximizedY = rData.GetMaximizedY();
701 : 1871 : aState.mnMaximizedWidth = rData.GetMaximizedWidth();
702 : 1871 : aState.mnMaximizedHeight = rData.GetMaximizedHeight();
703 : : // #94144# allow Minimize again, should be masked out when read from configuration
704 : : // 91625 - ignore Minimize
705 : : //nState &= ~(WINDOWSTATE_STATE_MINIMIZED);
706 : 1871 : aState.mnState = nState & SAL_FRAMESTATE_SYSTEMMASK;
707 : :
708 : : // normalize window positions onto screen
709 [ + - ]: 1871 : ImplMoveToScreen( aState.mnX, aState.mnY, aState.mnWidth, aState.mnHeight, pWindow );
710 [ + - ]: 1871 : ImplMoveToScreen( aState.mnMaximizedX, aState.mnMaximizedY, aState.mnMaximizedWidth, aState.mnMaximizedHeight, pWindow );
711 : :
712 : : // #96568# avoid having multiple frames at the same screen location
713 : : // do the check only if not maximized
714 [ + - ][ + + ]: 1871 : if( !((rData.GetMask() & WINDOWSTATE_MASK_STATE) && (nState & WINDOWSTATE_STATE_MAXIMIZED)) )
[ + + ]
715 [ + - ]: 1743 : if( rData.GetMask() & (WINDOWSTATE_MASK_POS|WINDOWSTATE_MASK_WIDTH|WINDOWSTATE_MASK_HEIGHT) )
716 : : {
717 [ + - ]: 1743 : Rectangle aDesktop = GetDesktopRectPixel();
718 [ + - ]: 1743 : ImplSVData *pSVData = ImplGetSVData();
719 : 1743 : Window *pWin = pSVData->maWinData.mpFirstFrame;
720 : 1743 : sal_Bool bWrapped = sal_False;
721 [ + + ]: 14224 : while( pWin )
722 : : {
723 [ + - ][ + + ]: 23155 : if( !pWin->ImplIsRealParentPath( this ) && ( pWin != this ) &&
[ + + ][ + - ]
[ + + ][ + + ]
724 [ + - ][ + - ]: 10674 : pWin->ImplGetWindow()->IsTopWindow() && pWin->mpWindowImpl->mbReallyVisible )
725 : : {
726 [ + - ]: 8371 : SalFrameGeometry g = pWin->mpWindowImpl->mpFrame->GetGeometry();
727 [ + + ][ + + ]: 8371 : if( abs(g.nX-aState.mnX) < 2 && abs(g.nY-aState.mnY) < 5 )
[ + - ][ + - ]
728 : : {
729 [ - + ]: 1122 : long displacement = g.nTopDecoration ? g.nTopDecoration : 20;
730 [ + - ][ + + ]: 1122 : if( (unsigned long) (aState.mnX + displacement + aState.mnWidth + g.nRightDecoration) > (unsigned long) aDesktop.nRight ||
731 : : (unsigned long) (aState.mnY + displacement + aState.mnHeight + g.nBottomDecoration) > (unsigned long) aDesktop.nBottom )
732 : : {
733 : : // displacing would leave screen
734 [ - + ]: 126 : aState.mnX = g.nLeftDecoration ? g.nLeftDecoration : 10; // should result in (0,0)
735 : 126 : aState.mnY = displacement;
736 [ + + ][ + - ]: 126 : if( bWrapped ||
[ + - ]
737 : : (unsigned long) (aState.mnX + displacement + aState.mnWidth + g.nRightDecoration) > (unsigned long) aDesktop.nRight ||
738 : : (unsigned long) (aState.mnY + displacement + aState.mnHeight + g.nBottomDecoration) > (unsigned long) aDesktop.nBottom )
739 : : break; // further displacement not possible -> break
740 : : // avoid endless testing
741 : 66 : bWrapped = sal_True;
742 : : }
743 : : else
744 : : {
745 : : // displace
746 : 996 : aState.mnX += displacement;
747 : 996 : aState.mnY += displacement;
748 : : }
749 : 8371 : pWin = pSVData->maWinData.mpFirstFrame; // check new pos again
750 : : }
751 : : }
752 : 12421 : pWin = pWin->mpWindowImpl->mpFrameData->mpNextFrame;
753 : : }
754 : : }
755 : :
756 [ + - ]: 1871 : mpWindowImpl->mpFrame->SetWindowState( &aState );
757 : :
758 : : // do a synchronous resize for layout reasons
759 : : // but use rData only when the window is not to be maximized (#i38089#)
760 : : // otherwise we have no useful size information
761 [ + - ][ + + ]: 1871 : if( (rData.GetMask() & WINDOWSTATE_MASK_STATE) && (nState & WINDOWSTATE_STATE_MAXIMIZED) )
[ + + ]
762 : : {
763 : : // query maximized size from frame
764 [ + - ]: 128 : SalFrameGeometry aGeometry = mpWindowImpl->mpFrame->GetGeometry();
765 : :
766 : : // but use it only if it is different from the restore size (rData)
767 : : // as currently only on windows the exact size of a maximized window
768 : : // can be computed without actually showing the window
769 [ - + ][ # # ]: 128 : if( aGeometry.nWidth != rData.GetWidth() || aGeometry.nHeight != rData.GetHeight() )
[ + - ]
770 [ + - ]: 128 : ImplHandleResize( pWindow, aGeometry.nWidth, aGeometry.nHeight );
771 : : }
772 : : else
773 [ + + ]: 1743 : if( rData.GetMask() & (WINDOWSTATE_MASK_WIDTH|WINDOWSTATE_MASK_HEIGHT) )
774 [ + - ]: 1871 : ImplHandleResize( pWindow, aState.mnWidth, aState.mnHeight ); // #i43799# use aState and not rData, see above
775 : : }
776 : : else
777 : : {
778 : 0 : sal_uInt16 nPosSize = 0;
779 [ # # ]: 0 : if ( nValidMask & WINDOWSTATE_MASK_X )
780 : 0 : nPosSize |= WINDOW_POSSIZE_X;
781 [ # # ]: 0 : if ( nValidMask & WINDOWSTATE_MASK_Y )
782 : 0 : nPosSize |= WINDOW_POSSIZE_Y;
783 [ # # ]: 0 : if ( nValidMask & WINDOWSTATE_MASK_WIDTH )
784 : 0 : nPosSize |= WINDOW_POSSIZE_WIDTH;
785 [ # # ]: 0 : if ( nValidMask & WINDOWSTATE_MASK_HEIGHT )
786 : 0 : nPosSize |= WINDOW_POSSIZE_HEIGHT;
787 : :
788 [ # # ]: 0 : if( IsRollUp() )
789 : 0 : RollDown();
790 : :
791 : 0 : long nX = rData.GetX();
792 : 0 : long nY = rData.GetY();
793 : 0 : long nWidth = rData.GetWidth();
794 : 0 : long nHeight = rData.GetHeight();
795 : 0 : const SalFrameGeometry& rGeom = pWindow->mpWindowImpl->mpFrame->GetGeometry();
796 [ # # ]: 0 : if( nX < 0 )
797 : 0 : nX = 0;
798 [ # # ]: 0 : if( nX + nWidth > (long) rGeom.nWidth )
799 : 0 : nX = rGeom.nWidth - nWidth;
800 [ # # ]: 0 : if( nY < 0 )
801 : 0 : nY = 0;
802 [ # # ]: 0 : if( nY + nHeight > (long) rGeom.nHeight )
803 : 0 : nY = rGeom.nHeight - nHeight;
804 : 0 : SetPosSizePixel( nX, nY, nWidth, nHeight, nPosSize );
805 : 0 : maOrgSize = Size( nWidth, nHeight );
806 : :
807 : : // 91625 - ignore Minimize
808 [ # # ]: 0 : if ( nValidMask & WINDOWSTATE_MASK_STATE )
809 : : {
810 : 0 : sal_uLong nState = rData.GetState();
811 [ # # ]: 0 : if ( nState & WINDOWSTATE_STATE_ROLLUP )
812 : 0 : RollUp();
813 : : else
814 : 1871 : RollDown();
815 : : }
816 : : }
817 : : }
818 : :
819 : : // -----------------------------------------------------------------------
820 : :
821 : 3362 : void SystemWindow::GetWindowStateData( WindowStateData& rData ) const
822 : : {
823 : 3362 : sal_uLong nValidMask = rData.GetMask();
824 [ - + ]: 3362 : if ( !nValidMask )
825 : 0 : return;
826 : :
827 [ - + ]: 3362 : if ( mbSysChild )
828 : 0 : return;
829 : :
830 : 3362 : const Window* pWindow = this;
831 [ + + ]: 6650 : while ( pWindow->mpWindowImpl->mpBorderWindow )
832 : 3288 : pWindow = pWindow->mpWindowImpl->mpBorderWindow;
833 : :
834 [ + - ]: 3362 : if ( pWindow->mpWindowImpl->mbFrame )
835 : : {
836 : : SalFrameState aState;
837 : 3362 : aState.mnMask = 0xFFFFFFFF;
838 [ + - ][ + - ]: 3362 : if ( mpWindowImpl->mpFrame->GetWindowState( &aState ) )
839 : : {
840 [ + - ]: 3362 : if ( nValidMask & WINDOWSTATE_MASK_X )
841 : 3362 : rData.SetX( aState.mnX );
842 [ + - ]: 3362 : if ( nValidMask & WINDOWSTATE_MASK_Y )
843 : 3362 : rData.SetY( aState.mnY );
844 [ + + ]: 3362 : if ( nValidMask & WINDOWSTATE_MASK_WIDTH )
845 : 3288 : rData.SetWidth( aState.mnWidth );
846 [ + + ]: 3362 : if ( nValidMask & WINDOWSTATE_MASK_HEIGHT )
847 : 3288 : rData.SetHeight( aState.mnHeight );
848 [ - + ]: 3362 : if ( aState.mnMask & SAL_FRAMESTATE_MASK_MAXIMIZED_X )
849 : : {
850 : 0 : rData.SetMaximizedX( aState.mnMaximizedX );
851 : 0 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_X;
852 : : }
853 [ - + ]: 3362 : if ( aState.mnMask & SAL_FRAMESTATE_MASK_MAXIMIZED_Y )
854 : : {
855 : 0 : rData.SetMaximizedY( aState.mnMaximizedY );
856 : 0 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_Y;
857 : : }
858 [ - + ]: 3362 : if ( aState.mnMask & SAL_FRAMESTATE_MASK_MAXIMIZED_WIDTH )
859 : : {
860 : 0 : rData.SetMaximizedWidth( aState.mnMaximizedWidth );
861 : 0 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_WIDTH;
862 : : }
863 [ - + ]: 3362 : if ( aState.mnMask & SAL_FRAMESTATE_MASK_MAXIMIZED_HEIGHT )
864 : : {
865 : 0 : rData.SetMaximizedHeight( aState.mnMaximizedHeight );
866 : 0 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_HEIGHT;
867 : : }
868 [ + - ]: 3362 : if ( nValidMask & WINDOWSTATE_MASK_STATE )
869 : : {
870 : : // #94144# allow Minimize again, should be masked out when read from configuration
871 : : // 91625 - ignore Minimize
872 [ + + ]: 3362 : if ( !(nValidMask&WINDOWSTATE_MASK_MINIMIZED) )
873 : 1712 : aState.mnState &= ~(WINDOWSTATE_STATE_MINIMIZED);
874 : 3362 : rData.SetState( aState.mnState );
875 : : }
876 : 3362 : rData.SetMask( nValidMask );
877 : : }
878 : : else
879 : 3362 : rData.SetMask( 0 );
880 : : }
881 : : else
882 : : {
883 [ # # ]: 0 : Point aPos = GetPosPixel();
884 [ # # ]: 0 : Size aSize = GetSizePixel();
885 : 0 : sal_uLong nState = 0;
886 : :
887 [ # # ]: 0 : if ( IsRollUp() )
888 : : {
889 : 0 : aSize.Height() += maOrgSize.Height();
890 : 0 : nState |= WINDOWSTATE_STATE_ROLLUP;
891 : : }
892 : :
893 [ # # ]: 0 : if ( nValidMask & WINDOWSTATE_MASK_X )
894 : 0 : rData.SetX( aPos.X() );
895 [ # # ]: 0 : if ( nValidMask & WINDOWSTATE_MASK_Y )
896 : 0 : rData.SetY( aPos.Y() );
897 [ # # ]: 0 : if ( nValidMask & WINDOWSTATE_MASK_WIDTH )
898 : 0 : rData.SetWidth( aSize.Width() );
899 [ # # ]: 0 : if ( nValidMask & WINDOWSTATE_MASK_HEIGHT )
900 : 0 : rData.SetHeight( aSize.Height() );
901 [ # # ]: 0 : if ( nValidMask & WINDOWSTATE_MASK_STATE )
902 : 3362 : rData.SetState( nState );
903 : : }
904 : : }
905 : :
906 : : // -----------------------------------------------------------------------
907 : :
908 : 1871 : void SystemWindow::SetWindowState(const rtl::OString& rStr)
909 : : {
910 [ + - ]: 1871 : if (rStr.isEmpty())
911 : 1871 : return;
912 : :
913 : 1871 : WindowStateData aData;
914 : 1871 : ImplWindowStateFromStr( aData, rStr );
915 [ + - ]: 1871 : SetWindowStateData( aData );
916 : : }
917 : :
918 : : // -----------------------------------------------------------------------
919 : :
920 : 3362 : rtl::OString SystemWindow::GetWindowState( sal_uLong nMask ) const
921 : : {
922 : 3362 : WindowStateData aData;
923 : 3362 : aData.SetMask( nMask );
924 [ + - ]: 3362 : GetWindowStateData( aData );
925 : :
926 [ + - ]: 3362 : return ImplWindowStateToStr(aData);
927 : : }
928 : :
929 : : // -----------------------------------------------------------------------
930 : :
931 : 6331 : void SystemWindow::SetMenuBar( MenuBar* pMenuBar )
932 : : {
933 [ + + ]: 6331 : if ( mpMenuBar != pMenuBar )
934 : : {
935 : 3329 : MenuBar* pOldMenuBar = mpMenuBar;
936 : 3329 : Window* pOldWindow = NULL;
937 : 3329 : Window* pNewWindow=NULL;
938 : 3329 : mpMenuBar = pMenuBar;
939 : :
940 [ + - ][ + - ]: 3329 : if ( mpWindowImpl->mpBorderWindow && (mpWindowImpl->mpBorderWindow->GetType() == WINDOW_BORDERWINDOW) )
[ + - ]
941 : : {
942 [ + + ]: 3329 : if ( pOldMenuBar )
943 : 1620 : pOldWindow = pOldMenuBar->ImplGetWindow();
944 : : else
945 : 1709 : pOldWindow = NULL;
946 [ + + ]: 3329 : if ( pOldWindow )
947 : : {
948 : 1620 : ImplCallEventListeners( VCLEVENT_WINDOW_MENUBARREMOVED, (void*) pOldMenuBar );
949 [ + - ]: 1620 : pOldWindow->SetAccessible( ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible >() );
950 : : }
951 [ + + ]: 3329 : if ( pMenuBar )
952 : : {
953 : : DBG_ASSERT( !pMenuBar->pWindow, "SystemWindow::SetMenuBar() - MenuBars can only set in one SystemWindow at time" );
954 : 1711 : ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMenuBarWindow( pNewWindow = MenuBar::ImplCreate( mpWindowImpl->mpBorderWindow, pOldWindow, pMenuBar ) );
955 : 1711 : ImplCallEventListeners( VCLEVENT_WINDOW_MENUBARADDED, (void*) pMenuBar );
956 : : }
957 : : else
958 : 1618 : ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMenuBarWindow( NULL );
959 : 3329 : ImplToBottomChild();
960 [ + + ]: 3329 : if ( pOldMenuBar )
961 : : {
962 [ + + ]: 1620 : sal_Bool bDelete = (pMenuBar == 0) ? sal_True : sal_False;
963 [ + + ][ + - ]: 1620 : if( bDelete && pOldWindow )
964 : : {
965 [ + - ]: 1618 : if( mpImplData->mpTaskPaneList )
966 : 1618 : mpImplData->mpTaskPaneList->RemoveWindow( pOldWindow );
967 : : }
968 : 1620 : MenuBar::ImplDestroy( pOldMenuBar, bDelete );
969 [ + + ]: 1620 : if( bDelete )
970 : 1618 : pOldWindow = NULL; // will be deleted in MenuBar::ImplDestroy,
971 : : }
972 : :
973 : : }
974 : : else
975 : : {
976 [ # # ]: 0 : if( pMenuBar )
977 : 0 : pNewWindow = pMenuBar->ImplGetWindow();
978 [ # # ]: 0 : if( pOldMenuBar )
979 : 0 : pOldWindow = pOldMenuBar->ImplGetWindow();
980 : : }
981 : :
982 : : // update taskpane list to make menubar accessible
983 [ + + ]: 3329 : if( mpImplData->mpTaskPaneList )
984 : : {
985 [ + + ]: 1901 : if( pOldWindow )
986 : 2 : mpImplData->mpTaskPaneList->RemoveWindow( pOldWindow );
987 [ + + ]: 1901 : if( pNewWindow )
988 : 283 : mpImplData->mpTaskPaneList->AddWindow( pNewWindow );
989 : : }
990 : : }
991 : 6331 : }
992 : :
993 : : // -----------------------------------------------------------------------
994 : :
995 : 0 : void SystemWindow::SetMenuBarMode( sal_uInt16 nMode )
996 : : {
997 [ # # ]: 0 : if ( mnMenuBarMode != nMode )
998 : : {
999 : 0 : mnMenuBarMode = nMode;
1000 [ # # ][ # # ]: 0 : if ( mpWindowImpl->mpBorderWindow && (mpWindowImpl->mpBorderWindow->GetType() == WINDOW_BORDERWINDOW) )
[ # # ]
1001 : : {
1002 [ # # ]: 0 : if ( nMode == MENUBAR_MODE_HIDE )
1003 : 0 : ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMenuBarMode( sal_True );
1004 : : else
1005 : 0 : ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMenuBarMode( sal_False );
1006 : : }
1007 : : }
1008 : 0 : }
1009 : :
1010 : : // -----------------------------------------------------------------------
1011 : :
1012 : 18548 : sal_Bool SystemWindow::ImplIsInTaskPaneList( Window* pWin )
1013 : : {
1014 [ + - ][ + + ]: 18548 : if( mpImplData && mpImplData->mpTaskPaneList )
1015 : 11691 : return mpImplData->mpTaskPaneList->IsInList( pWin );
1016 : 18548 : return sal_False;
1017 : : }
1018 : :
1019 : 0 : unsigned int SystemWindow::GetScreenNumber() const
1020 : : {
1021 : 0 : return mpWindowImpl->mpFrame->maGeometry.nDisplayScreenNumber;
1022 : : }
1023 : :
1024 : 0 : void SystemWindow::SetScreenNumber(unsigned int nDisplayScreen)
1025 : : {
1026 : 0 : mpWindowImpl->mpFrame->SetScreenNumber( nDisplayScreen );
1027 : 0 : }
1028 : :
1029 : 5153 : void SystemWindow::SetApplicationID(const rtl::OUString &rApplicationID)
1030 : : {
1031 : 5153 : mpWindowImpl->mpFrame->SetApplicationID( rApplicationID );
1032 : 5153 : }
1033 : :
1034 : 32 : void SystemWindow::SetCloseHdl(const Link& rLink)
1035 : : {
1036 : 32 : mpImplData->maCloseHdl = rLink;
1037 : 32 : }
1038 : :
1039 : 2 : const Link& SystemWindow::GetCloseHdl() const
1040 : : {
1041 : 2 : return mpImplData->maCloseHdl;
1042 : : }
1043 : :
1044 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
