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