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 263 : SystemWindow::ImplData::ImplData()
54 : {
55 263 : mpTaskPaneList = NULL;
56 263 : maMaxOutSize = Size( SHRT_MAX, SHRT_MAX );
57 263 : }
58 :
59 126 : SystemWindow::ImplData::~ImplData()
60 : {
61 63 : if( mpTaskPaneList )
62 63 : delete mpTaskPaneList;
63 63 : }
64 :
65 : // =======================================================================
66 :
67 263 : SystemWindow::SystemWindow( WindowType nType ) :
68 263 : Window( nType )
69 : {
70 263 : mpImplData = new ImplData;
71 263 : mpWindowImpl->mbSysWin = sal_True;
72 263 : mpWindowImpl->mnActivateMode = ACTIVATE_MODE_GRABFOCUS;
73 :
74 263 : mpMenuBar = NULL;
75 263 : mbPined = sal_False;
76 263 : mbRollUp = sal_False;
77 263 : mbRollFunc = sal_False;
78 263 : mbDockBtn = sal_False;
79 263 : mbHideBtn = sal_False;
80 263 : mbSysChild = sal_False;
81 263 : mnMenuBarMode = MENUBAR_MODE_NORMAL;
82 263 : mnIcon = 0;
83 263 : }
84 :
85 126 : SystemWindow::~SystemWindow()
86 : {
87 63 : delete mpImplData;
88 63 : mpImplData = NULL;
89 63 : }
90 :
91 : // -----------------------------------------------------------------------
92 :
93 1165 : long SystemWindow::Notify( NotifyEvent& rNEvt )
94 : {
95 : // capture KeyEvents for menu handling
96 1165 : 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 1165 : return Window::Notify( rNEvt );
110 : }
111 :
112 : // -----------------------------------------------------------------------
113 :
114 1052 : long SystemWindow::PreNotify( NotifyEvent& rNEvt )
115 : {
116 : // capture KeyEvents for taskpane cycling
117 1052 : 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 1052 : return Window::PreNotify( rNEvt );
154 : }
155 :
156 : // -----------------------------------------------------------------------
157 :
158 1220 : TaskPaneList* SystemWindow::GetTaskPaneList()
159 : {
160 1220 : if( mpImplData->mpTaskPaneList )
161 984 : return mpImplData->mpTaskPaneList ;
162 : else
163 : {
164 236 : mpImplData->mpTaskPaneList = new TaskPaneList();
165 236 : MenuBar* pMBar = mpMenuBar;
166 236 : 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 236 : if( pMBar )
173 0 : mpImplData->mpTaskPaneList->AddWindow( pMBar->ImplGetWindow() );
174 236 : 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 303 : void SystemWindow::SetRepresentedURL( const rtl::OUString& i_rURL )
234 : {
235 303 : bool bChanged = (i_rURL != mpImplData->maRepresentedURL);
236 303 : mpImplData->maRepresentedURL = i_rURL;
237 303 : if ( !mbSysChild && bChanged )
238 : {
239 259 : const Window* pWindow = this;
240 777 : while ( pWindow->mpWindowImpl->mpBorderWindow )
241 259 : pWindow = pWindow->mpWindowImpl->mpBorderWindow;
242 :
243 259 : if ( pWindow->mpWindowImpl->mbFrame )
244 259 : pWindow->mpWindowImpl->mpFrame->SetRepresentedURL( i_rURL );
245 : }
246 303 : }
247 :
248 : // -----------------------------------------------------------------------
249 :
250 543 : void SystemWindow::SetIcon( sal_uInt16 nIcon )
251 : {
252 543 : if ( mnIcon == nIcon )
253 850 : return;
254 :
255 236 : mnIcon = nIcon;
256 :
257 236 : if ( !mbSysChild )
258 : {
259 236 : const Window* pWindow = this;
260 708 : while ( pWindow->mpWindowImpl->mpBorderWindow )
261 236 : pWindow = pWindow->mpWindowImpl->mpBorderWindow;
262 :
263 236 : if ( pWindow->mpWindowImpl->mbFrame )
264 236 : pWindow->mpWindowImpl->mpFrame->SetIcon( nIcon );
265 : }
266 : }
267 :
268 : // -----------------------------------------------------------------------
269 :
270 0 : void SystemWindow::EnableSaveBackground( sal_Bool bSave )
271 : {
272 0 : if( ImplGetSVData()->maWinData.mbNoSaveBackground )
273 0 : bSave = false;
274 :
275 0 : Window* pWindow = this;
276 0 : while ( pWindow->mpWindowImpl->mpBorderWindow )
277 0 : pWindow = pWindow->mpWindowImpl->mpBorderWindow;
278 0 : 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 0 : }
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 142 : static void ImplWindowStateFromStr(WindowStateData& rData,
441 : const rtl::OString& rStr)
442 : {
443 142 : sal_uLong nValidMask = 0;
444 142 : sal_Int32 nIndex = 0;
445 142 : rtl::OString aTokenStr;
446 :
447 142 : aTokenStr = rStr.getToken(0, ',', nIndex);
448 142 : if (!aTokenStr.isEmpty())
449 : {
450 142 : rData.SetX(aTokenStr.toInt32());
451 142 : if( rData.GetX() > -16384 && rData.GetX() < 16384 )
452 142 : nValidMask |= WINDOWSTATE_MASK_X;
453 : else
454 0 : rData.SetX( 0 );
455 : }
456 : else
457 0 : rData.SetX( 0 );
458 142 : aTokenStr = rStr.getToken(0, ',', nIndex);
459 142 : if (!aTokenStr.isEmpty())
460 : {
461 142 : rData.SetY(aTokenStr.toInt32());
462 142 : if( rData.GetY() > -16384 && rData.GetY() < 16384 )
463 142 : nValidMask |= WINDOWSTATE_MASK_Y;
464 : else
465 0 : rData.SetY( 0 );
466 : }
467 : else
468 0 : rData.SetY( 0 );
469 142 : aTokenStr = rStr.getToken(0, ',', nIndex);
470 142 : if (!aTokenStr.isEmpty())
471 : {
472 142 : rData.SetWidth(aTokenStr.toInt32());
473 142 : if( rData.GetWidth() > 0 && rData.GetWidth() < 16384 )
474 142 : nValidMask |= WINDOWSTATE_MASK_WIDTH;
475 : else
476 0 : rData.SetWidth( 0 );
477 : }
478 : else
479 0 : rData.SetWidth( 0 );
480 142 : aTokenStr = rStr.getToken(0, ';', nIndex);
481 142 : if (!aTokenStr.isEmpty())
482 : {
483 142 : rData.SetHeight(aTokenStr.toInt32());
484 142 : if( rData.GetHeight() > 0 && rData.GetHeight() < 16384 )
485 142 : nValidMask |= WINDOWSTATE_MASK_HEIGHT;
486 : else
487 0 : rData.SetHeight( 0 );
488 : }
489 : else
490 0 : rData.SetHeight( 0 );
491 142 : aTokenStr = rStr.getToken(0, ';', nIndex);
492 142 : if (!aTokenStr.isEmpty())
493 : {
494 : // #94144# allow Minimize again, should be masked out when read from configuration
495 : // 91625 - ignore Minimize
496 142 : sal_uInt32 nState = (sal_uInt32)aTokenStr.toInt32();
497 : //nState &= ~(WINDOWSTATE_STATE_MINIMIZED);
498 142 : rData.SetState( nState );
499 142 : nValidMask |= WINDOWSTATE_MASK_STATE;
500 : }
501 : else
502 0 : rData.SetState( 0 );
503 :
504 : // read maximized pos/size
505 142 : aTokenStr = rStr.getToken(0, ',', nIndex);
506 142 : if (!aTokenStr.isEmpty())
507 : {
508 142 : rData.SetMaximizedX(aTokenStr.toInt32());
509 142 : if( rData.GetMaximizedX() > -16384 && rData.GetMaximizedX() < 16384 )
510 142 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_X;
511 : else
512 0 : rData.SetMaximizedX( 0 );
513 : }
514 : else
515 0 : rData.SetMaximizedX( 0 );
516 142 : aTokenStr = rStr.getToken(0, ',', nIndex);
517 142 : if (!aTokenStr.isEmpty())
518 : {
519 142 : rData.SetMaximizedY(aTokenStr.toInt32());
520 142 : if( rData.GetMaximizedY() > -16384 && rData.GetMaximizedY() < 16384 )
521 142 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_Y;
522 : else
523 0 : rData.SetMaximizedY( 0 );
524 : }
525 : else
526 0 : rData.SetMaximizedY( 0 );
527 142 : aTokenStr = rStr.getToken(0, ',', nIndex);
528 142 : if (!aTokenStr.isEmpty())
529 : {
530 142 : rData.SetMaximizedWidth(aTokenStr.toInt32());
531 142 : if( rData.GetMaximizedWidth() > 0 && rData.GetMaximizedWidth() < 16384 )
532 0 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_WIDTH;
533 : else
534 142 : rData.SetMaximizedWidth( 0 );
535 : }
536 : else
537 0 : rData.SetMaximizedWidth( 0 );
538 142 : aTokenStr = rStr.getToken(0, ';', nIndex);
539 142 : if (!aTokenStr.isEmpty())
540 : {
541 142 : rData.SetMaximizedHeight(aTokenStr.toInt32());
542 142 : if( rData.GetMaximizedHeight() > 0 && rData.GetMaximizedHeight() < 16384 )
543 0 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_HEIGHT;
544 : else
545 142 : rData.SetMaximizedHeight( 0 );
546 : }
547 : else
548 0 : rData.SetMaximizedHeight( 0 );
549 :
550 : // mark valid fields
551 142 : rData.SetMask( nValidMask );
552 142 : }
553 :
554 : // -----------------------------------------------------------------------
555 :
556 170 : static rtl::OString ImplWindowStateToStr(const WindowStateData& rData)
557 : {
558 170 : sal_uLong nValidMask = rData.GetMask();
559 170 : if ( !nValidMask )
560 0 : return rtl::OString();
561 :
562 170 : rtl::OStringBuffer rStrBuf;
563 :
564 170 : if ( nValidMask & WINDOWSTATE_MASK_X )
565 170 : rStrBuf.append(static_cast<sal_Int32>(rData.GetX()));
566 170 : rStrBuf.append(',');
567 170 : if ( nValidMask & WINDOWSTATE_MASK_Y )
568 170 : rStrBuf.append(static_cast<sal_Int32>(rData.GetY()));
569 170 : rStrBuf.append(',');
570 170 : if ( nValidMask & WINDOWSTATE_MASK_WIDTH )
571 170 : rStrBuf.append(static_cast<sal_Int32>(rData.GetWidth()));
572 170 : rStrBuf.append(',');
573 170 : if ( nValidMask & WINDOWSTATE_MASK_HEIGHT )
574 170 : rStrBuf.append(static_cast<sal_Int32>(rData.GetHeight()));
575 170 : rStrBuf.append( ';' );
576 170 : if ( nValidMask & WINDOWSTATE_MASK_STATE )
577 : {
578 : // #94144# allow Minimize again, should be masked out when read from configuration
579 : // 91625 - ignore Minimize
580 170 : sal_uInt32 nState = rData.GetState();
581 170 : rStrBuf.append(static_cast<sal_Int32>(nState));
582 : }
583 170 : rStrBuf.append(';');
584 170 : if ( nValidMask & WINDOWSTATE_MASK_MAXIMIZED_X )
585 170 : rStrBuf.append(static_cast<sal_Int32>(rData.GetMaximizedX()));
586 170 : rStrBuf.append(',');
587 170 : if ( nValidMask & WINDOWSTATE_MASK_MAXIMIZED_Y )
588 170 : rStrBuf.append(static_cast<sal_Int32>(rData.GetMaximizedY()));
589 170 : rStrBuf.append( ',' );
590 170 : if ( nValidMask & WINDOWSTATE_MASK_MAXIMIZED_WIDTH )
591 170 : rStrBuf.append(static_cast<sal_Int32>(rData.GetMaximizedWidth()));
592 170 : rStrBuf.append(',');
593 170 : if ( nValidMask & WINDOWSTATE_MASK_MAXIMIZED_HEIGHT )
594 170 : rStrBuf.append(static_cast<sal_Int32>(rData.GetMaximizedHeight()));
595 170 : rStrBuf.append(';');
596 :
597 170 : return rStrBuf.makeStringAndClear();
598 : }
599 :
600 : // -----------------------------------------------------------------------
601 :
602 284 : void SystemWindow::ImplMoveToScreen( long& io_rX, long& io_rY, long i_nWidth, long i_nHeight, Window* i_pConfigureWin )
603 : {
604 284 : Rectangle aScreenRect;
605 284 : if( !Application::IsUnifiedDisplay() )
606 0 : aScreenRect = Application::GetScreenPosSizePixel( GetScreenNumber() );
607 : else
608 : {
609 284 : aScreenRect = Application::GetScreenPosSizePixel( 0 );
610 284 : 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 284 : if( i_nWidth < 1 )
615 142 : i_nWidth = 50;
616 284 : if( i_nHeight < 1 )
617 142 : i_nHeight = 50;
618 :
619 : // check left border
620 284 : bool bMove = false;
621 284 : if( io_rX + i_nWidth < aScreenRect.Left() )
622 : {
623 0 : bMove = true;
624 0 : io_rX = aScreenRect.Left();
625 : }
626 : // check right border
627 284 : 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 284 : if( io_rY + i_nHeight < aScreenRect.Top() )
634 : {
635 0 : bMove = true;
636 0 : io_rY = aScreenRect.Top();
637 : }
638 : // check bottom border
639 284 : if( io_rY > aScreenRect.Bottom() - i_nHeight )
640 : {
641 0 : bMove = true;
642 0 : io_rY = aScreenRect.Bottom() - i_nHeight;
643 : }
644 284 : Window* pParent = i_pConfigureWin->GetParent();
645 284 : 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 284 : }
656 :
657 142 : void SystemWindow::SetWindowStateData( const WindowStateData& rData )
658 : {
659 142 : sal_uLong nValidMask = rData.GetMask();
660 142 : if ( !nValidMask )
661 0 : return;
662 :
663 142 : if ( mbSysChild )
664 0 : return;
665 :
666 142 : Window* pWindow = this;
667 426 : while ( pWindow->mpWindowImpl->mpBorderWindow )
668 142 : pWindow = pWindow->mpWindowImpl->mpBorderWindow;
669 :
670 142 : if ( pWindow->mpWindowImpl->mbFrame )
671 : {
672 142 : sal_uLong nState = rData.GetState();
673 : SalFrameState aState;
674 142 : aState.mnMask = rData.GetMask();
675 142 : aState.mnX = rData.GetX();
676 142 : aState.mnY = rData.GetY();
677 142 : aState.mnWidth = rData.GetWidth();
678 142 : aState.mnHeight = rData.GetHeight();
679 :
680 142 : 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 142 : if( maMinOutSize.Width() > aState.mnWidth )
685 0 : aState.mnWidth = maMinOutSize.Width();
686 142 : if( maMinOutSize.Height() > aState.mnHeight )
687 0 : aState.mnHeight = maMinOutSize.Height();
688 : }
689 :
690 142 : aState.mnMaximizedX = rData.GetMaximizedX();
691 142 : aState.mnMaximizedY = rData.GetMaximizedY();
692 142 : aState.mnMaximizedWidth = rData.GetMaximizedWidth();
693 142 : 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 142 : aState.mnState = nState & SAL_FRAMESTATE_SYSTEMMASK;
698 :
699 : // normalize window positions onto screen
700 142 : ImplMoveToScreen( aState.mnX, aState.mnY, aState.mnWidth, aState.mnHeight, pWindow );
701 142 : 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 142 : if( !((rData.GetMask() & WINDOWSTATE_MASK_STATE) && (nState & WINDOWSTATE_STATE_MAXIMIZED)) )
706 142 : if( rData.GetMask() & (WINDOWSTATE_MASK_POS|WINDOWSTATE_MASK_WIDTH|WINDOWSTATE_MASK_HEIGHT) )
707 : {
708 142 : Rectangle aDesktop = GetDesktopRectPixel();
709 142 : ImplSVData *pSVData = ImplGetSVData();
710 142 : Window *pWin = pSVData->maWinData.mpFirstFrame;
711 142 : sal_Bool bWrapped = sal_False;
712 6073 : while( pWin )
713 : {
714 11516 : if( !pWin->ImplIsRealParentPath( this ) && ( pWin != this ) &&
715 5687 : pWin->ImplGetWindow()->IsTopWindow() && pWin->mpWindowImpl->mbReallyVisible )
716 : {
717 5585 : SalFrameGeometry g = pWin->mpWindowImpl->mpFrame->GetGeometry();
718 5585 : if( abs(g.nX-aState.mnX) < 2 && abs(g.nY-aState.mnY) < 5 )
719 : {
720 678 : long displacement = g.nTopDecoration ? g.nTopDecoration : 20;
721 1356 : if( (unsigned long) (aState.mnX + displacement + aState.mnWidth + g.nRightDecoration) > (unsigned long) aDesktop.Right() ||
722 678 : (unsigned long) (aState.mnY + displacement + aState.mnHeight + g.nBottomDecoration) > (unsigned long) aDesktop.Bottom() )
723 : {
724 : // displacing would leave screen
725 84 : aState.mnX = g.nLeftDecoration ? g.nLeftDecoration : 10; // should result in (0,0)
726 84 : aState.mnY = displacement;
727 172 : if( bWrapped ||
728 44 : (unsigned long) (aState.mnX + displacement + aState.mnWidth + g.nRightDecoration) > (unsigned long) aDesktop.Right() ||
729 44 : (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 44 : bWrapped = sal_True;
733 : }
734 : else
735 : {
736 : // displace
737 594 : aState.mnX += displacement;
738 594 : aState.mnY += displacement;
739 : }
740 638 : pWin = pSVData->maWinData.mpFirstFrame; // check new pos again
741 : }
742 : }
743 5789 : pWin = pWin->mpWindowImpl->mpFrameData->mpNextFrame;
744 : }
745 : }
746 :
747 142 : 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 142 : if( (rData.GetMask() & WINDOWSTATE_MASK_STATE) && (nState & WINDOWSTATE_STATE_MAXIMIZED) )
753 : {
754 : // query maximized size from frame
755 0 : 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 0 : if( aGeometry.nWidth != rData.GetWidth() || aGeometry.nHeight != rData.GetHeight() )
761 0 : ImplHandleResize( pWindow, aGeometry.nWidth, aGeometry.nHeight );
762 : }
763 : else
764 142 : if( rData.GetMask() & (WINDOWSTATE_MASK_WIDTH|WINDOWSTATE_MASK_HEIGHT) )
765 142 : 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 170 : void SystemWindow::GetWindowStateData( WindowStateData& rData ) const
813 : {
814 170 : sal_uLong nValidMask = rData.GetMask();
815 170 : if ( !nValidMask )
816 0 : return;
817 :
818 170 : if ( mbSysChild )
819 0 : return;
820 :
821 170 : const Window* pWindow = this;
822 510 : while ( pWindow->mpWindowImpl->mpBorderWindow )
823 170 : pWindow = pWindow->mpWindowImpl->mpBorderWindow;
824 :
825 170 : if ( pWindow->mpWindowImpl->mbFrame )
826 : {
827 : SalFrameState aState;
828 170 : aState.mnMask = 0xFFFFFFFF;
829 170 : if ( mpWindowImpl->mpFrame->GetWindowState( &aState ) )
830 : {
831 170 : if ( nValidMask & WINDOWSTATE_MASK_X )
832 170 : rData.SetX( aState.mnX );
833 170 : if ( nValidMask & WINDOWSTATE_MASK_Y )
834 170 : rData.SetY( aState.mnY );
835 170 : if ( nValidMask & WINDOWSTATE_MASK_WIDTH )
836 170 : rData.SetWidth( aState.mnWidth );
837 170 : if ( nValidMask & WINDOWSTATE_MASK_HEIGHT )
838 170 : rData.SetHeight( aState.mnHeight );
839 170 : if ( aState.mnMask & SAL_FRAMESTATE_MASK_MAXIMIZED_X )
840 : {
841 0 : rData.SetMaximizedX( aState.mnMaximizedX );
842 0 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_X;
843 : }
844 170 : if ( aState.mnMask & SAL_FRAMESTATE_MASK_MAXIMIZED_Y )
845 : {
846 0 : rData.SetMaximizedY( aState.mnMaximizedY );
847 0 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_Y;
848 : }
849 170 : if ( aState.mnMask & SAL_FRAMESTATE_MASK_MAXIMIZED_WIDTH )
850 : {
851 0 : rData.SetMaximizedWidth( aState.mnMaximizedWidth );
852 0 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_WIDTH;
853 : }
854 170 : if ( aState.mnMask & SAL_FRAMESTATE_MASK_MAXIMIZED_HEIGHT )
855 : {
856 0 : rData.SetMaximizedHeight( aState.mnMaximizedHeight );
857 0 : nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_HEIGHT;
858 : }
859 170 : if ( nValidMask & WINDOWSTATE_MASK_STATE )
860 : {
861 : // #94144# allow Minimize again, should be masked out when read from configuration
862 : // 91625 - ignore Minimize
863 170 : if ( !(nValidMask&WINDOWSTATE_MASK_MINIMIZED) )
864 63 : aState.mnState &= ~(WINDOWSTATE_STATE_MINIMIZED);
865 170 : rData.SetState( aState.mnState );
866 : }
867 170 : 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 142 : void SystemWindow::SetWindowState(const rtl::OString& rStr)
900 : {
901 142 : if (rStr.isEmpty())
902 142 : return;
903 :
904 142 : WindowStateData aData;
905 142 : ImplWindowStateFromStr( aData, rStr );
906 142 : SetWindowStateData( aData );
907 : }
908 :
909 : // -----------------------------------------------------------------------
910 :
911 170 : rtl::OString SystemWindow::GetWindowState( sal_uLong nMask ) const
912 : {
913 170 : WindowStateData aData;
914 170 : aData.SetMask( nMask );
915 170 : GetWindowStateData( aData );
916 :
917 170 : return ImplWindowStateToStr(aData);
918 : }
919 :
920 : // -----------------------------------------------------------------------
921 :
922 456 : void SystemWindow::SetMenuBar( MenuBar* pMenuBar )
923 : {
924 456 : if ( mpMenuBar != pMenuBar )
925 : {
926 299 : MenuBar* pOldMenuBar = mpMenuBar;
927 299 : Window* pOldWindow = NULL;
928 299 : Window* pNewWindow=NULL;
929 299 : mpMenuBar = pMenuBar;
930 :
931 299 : if ( mpWindowImpl->mpBorderWindow && (mpWindowImpl->mpBorderWindow->GetType() == WINDOW_BORDERWINDOW) )
932 : {
933 299 : if ( pOldMenuBar )
934 63 : pOldWindow = pOldMenuBar->ImplGetWindow();
935 : else
936 236 : pOldWindow = NULL;
937 299 : if ( pOldWindow )
938 : {
939 63 : ImplCallEventListeners( VCLEVENT_WINDOW_MENUBARREMOVED, (void*) pOldMenuBar );
940 63 : pOldWindow->SetAccessible( ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible >() );
941 : }
942 299 : if ( pMenuBar )
943 : {
944 : DBG_ASSERT( !pMenuBar->pWindow, "SystemWindow::SetMenuBar() - MenuBars can only set in one SystemWindow at time" );
945 236 : ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMenuBarWindow( pNewWindow = MenuBar::ImplCreate( mpWindowImpl->mpBorderWindow, pOldWindow, pMenuBar ) );
946 236 : ImplCallEventListeners( VCLEVENT_WINDOW_MENUBARADDED, (void*) pMenuBar );
947 : }
948 : else
949 63 : ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMenuBarWindow( NULL );
950 299 : ImplToBottomChild();
951 299 : if ( pOldMenuBar )
952 : {
953 63 : sal_Bool bDelete = (pMenuBar == 0) ? sal_True : sal_False;
954 63 : if( bDelete && pOldWindow )
955 : {
956 63 : if( mpImplData->mpTaskPaneList )
957 63 : mpImplData->mpTaskPaneList->RemoveWindow( pOldWindow );
958 : }
959 63 : MenuBar::ImplDestroy( pOldMenuBar, bDelete );
960 63 : if( bDelete )
961 63 : 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 299 : if( mpImplData->mpTaskPaneList )
975 : {
976 299 : if( pOldWindow )
977 0 : mpImplData->mpTaskPaneList->RemoveWindow( pOldWindow );
978 299 : if( pNewWindow )
979 236 : mpImplData->mpTaskPaneList->AddWindow( pNewWindow );
980 : }
981 : }
982 456 : }
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 385 : sal_Bool SystemWindow::ImplIsInTaskPaneList( Window* pWin )
1004 : {
1005 385 : if( mpImplData && mpImplData->mpTaskPaneList )
1006 385 : return mpImplData->mpTaskPaneList->IsInList( pWin );
1007 0 : 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 366 : void SystemWindow::SetApplicationID(const rtl::OUString &rApplicationID)
1021 : {
1022 366 : mpWindowImpl->mpFrame->SetApplicationID( rApplicationID );
1023 366 : }
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: */
|
