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