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/time.hxx>
21 : #include <tools/rc.h>
22 : #include <vcl/event.hxx>
23 : #include <vcl/floatwin.hxx>
24 : #include <vcl/dockwin.hxx>
25 : #include <vcl/layout.hxx>
26 : #include <vcl/svapp.hxx>
27 : #include <vcl/timer.hxx>
28 : #include <vcl/idle.hxx>
29 : #include <vcl/unowrap.hxx>
30 : #include <vcl/settings.hxx>
31 :
32 : #include <svdata.hxx>
33 : #include <window.h>
34 : #include <brdwin.hxx>
35 : #include <salframe.hxx>
36 :
37 : #define DOCKWIN_FLOATSTYLES (WB_SIZEABLE | WB_MOVEABLE | WB_CLOSEABLE | WB_STANDALONE | WB_PINABLE | WB_ROLLABLE )
38 :
39 : class DockingWindow::ImplData
40 : {
41 : public:
42 : ImplData();
43 : ~ImplData();
44 :
45 : VclPtr<vcl::Window> mpParent;
46 : Size maMaxOutSize;
47 : };
48 :
49 66663 : DockingWindow::ImplData::ImplData()
50 : {
51 66663 : mpParent = NULL;
52 66663 : maMaxOutSize = Size( SHRT_MAX, SHRT_MAX );
53 66663 : }
54 :
55 66580 : DockingWindow::ImplData::~ImplData()
56 : {
57 66580 : }
58 :
59 : class ImplDockFloatWin : public FloatingWindow
60 : {
61 : private:
62 : VclPtr<DockingWindow> mpDockWin;
63 : sal_uInt64 mnLastTicks;
64 : Idle maDockIdle;
65 : Point maDockPos;
66 : Rectangle maDockRect;
67 : bool mbInMove;
68 : ImplSVEvent * mnLastUserEvent;
69 :
70 : DECL_LINK(DockingHdl, void *);
71 : DECL_LINK_TYPED(DockTimerHdl, Idle *, void);
72 : public:
73 : ImplDockFloatWin( vcl::Window* pParent, WinBits nWinBits,
74 : DockingWindow* pDockingWin );
75 : virtual ~ImplDockFloatWin();
76 : virtual void dispose() SAL_OVERRIDE;
77 :
78 : virtual void Move() SAL_OVERRIDE;
79 : virtual void Resize() SAL_OVERRIDE;
80 : virtual void TitleButtonClick( TitleButton nButton ) SAL_OVERRIDE;
81 : virtual void Pin() SAL_OVERRIDE;
82 : virtual void Roll() SAL_OVERRIDE;
83 : virtual void PopupModeEnd() SAL_OVERRIDE;
84 : virtual void Resizing( Size& rSize ) SAL_OVERRIDE;
85 : virtual bool Close() SAL_OVERRIDE;
86 : };
87 :
88 0 : ImplDockFloatWin::ImplDockFloatWin( vcl::Window* pParent, WinBits nWinBits,
89 : DockingWindow* pDockingWin ) :
90 : FloatingWindow( pParent, nWinBits ),
91 : mpDockWin( pDockingWin ),
92 0 : mnLastTicks( tools::Time::GetSystemTicks() ),
93 : mbInMove( false ),
94 0 : mnLastUserEvent( 0 )
95 : {
96 : // copy settings of DockingWindow
97 0 : if ( pDockingWin )
98 : {
99 0 : SetSettings( pDockingWin->GetSettings() );
100 0 : Enable( pDockingWin->IsEnabled(), false );
101 0 : EnableInput( pDockingWin->IsInputEnabled(), false );
102 0 : AlwaysEnableInput( pDockingWin->IsAlwaysEnableInput(), false );
103 0 : EnableAlwaysOnTop( pDockingWin->IsAlwaysOnTopEnabled() );
104 0 : SetActivateMode( pDockingWin->GetActivateMode() );
105 : }
106 :
107 0 : SetBackground();
108 :
109 0 : maDockIdle.SetIdleHdl( LINK( this, ImplDockFloatWin, DockTimerHdl ) );
110 0 : maDockIdle.SetPriority( SchedulerPriority::MEDIUM );
111 0 : }
112 :
113 0 : ImplDockFloatWin::~ImplDockFloatWin()
114 : {
115 0 : disposeOnce();
116 0 : }
117 :
118 0 : void ImplDockFloatWin::dispose()
119 : {
120 0 : if( mnLastUserEvent )
121 0 : Application::RemoveUserEvent( mnLastUserEvent );
122 :
123 0 : disposeBuilder();
124 :
125 0 : mpDockWin.clear();
126 0 : FloatingWindow::dispose();
127 0 : }
128 :
129 0 : IMPL_LINK_NOARG_TYPED(ImplDockFloatWin, DockTimerHdl, Idle *, void)
130 : {
131 : DBG_ASSERT( mpDockWin->IsFloatingMode(), "docktimer called but not floating" );
132 :
133 0 : maDockIdle.Stop();
134 0 : PointerState aState = GetPointerState();
135 :
136 0 : if( aState.mnState & KEY_MOD1 )
137 : {
138 : // i43499 CTRL disables docking now
139 0 : mpDockWin->GetParent()->ImplGetFrameWindow()->HideTracking();
140 0 : mpDockWin->EndDocking( maDockRect, true );
141 0 : if( aState.mnState & ( MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT ) )
142 0 : maDockIdle.Start();
143 : }
144 0 : else if( ! ( aState.mnState & ( MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT ) ) )
145 : {
146 0 : mpDockWin->GetParent()->ImplGetFrameWindow()->HideTracking();
147 0 : mpDockWin->EndDocking( maDockRect, false );
148 : }
149 : else
150 : {
151 0 : mpDockWin->GetParent()->ImplGetFrameWindow()->ShowTracking( maDockRect, SHOWTRACK_BIG | SHOWTRACK_WINDOW );
152 0 : maDockIdle.Start();
153 : }
154 0 : }
155 :
156 0 : IMPL_LINK_NOARG(ImplDockFloatWin, DockingHdl)
157 : {
158 0 : PointerState aState = mpDockWin->GetParent()->GetPointerState();
159 :
160 0 : mnLastUserEvent = 0;
161 0 : if( mpDockWin->IsDockable() &&
162 0 : (tools::Time::GetSystemTicks() - mnLastTicks > 500) &&
163 0 : ( aState.mnState & ( MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT ) ) &&
164 0 : !(aState.mnState & KEY_MOD1) ) // i43499 CTRL disables docking now
165 : {
166 0 : maDockPos = Point( mpDockWin->GetParent()->AbsoluteScreenToOutputPixel( OutputToAbsoluteScreenPixel( Point() ) ) );
167 0 : maDockPos = mpDockWin->GetParent()->OutputToScreenPixel( maDockPos ); // sfx expects screen coordinates
168 :
169 0 : if( ! mpDockWin->IsDocking() )
170 0 : mpDockWin->StartDocking();
171 0 : maDockRect = Rectangle( maDockPos, mpDockWin->GetSizePixel() );
172 :
173 : // mouse pos also in screen pixels
174 0 : Point aMousePos = mpDockWin->GetParent()->OutputToScreenPixel( aState.maPos );
175 :
176 0 : bool bFloatMode = mpDockWin->Docking( aMousePos, maDockRect );
177 0 : if( ! bFloatMode )
178 : {
179 0 : mpDockWin->GetParent()->ImplGetFrameWindow()->ShowTracking( maDockRect, SHOWTRACK_OBJECT | SHOWTRACK_WINDOW );
180 0 : DockTimerHdl( nullptr );
181 : }
182 : else
183 : {
184 0 : mpDockWin->GetParent()->ImplGetFrameWindow()->HideTracking();
185 0 : maDockIdle.Stop();
186 0 : mpDockWin->EndDocking( maDockRect, true );
187 : }
188 : }
189 0 : mbInMove = false;
190 0 : return 0;
191 : }
192 :
193 0 : void ImplDockFloatWin::Move()
194 : {
195 0 : if( mbInMove )
196 0 : return;
197 :
198 0 : mbInMove = true;
199 0 : FloatingWindow::Move();
200 0 : mpDockWin->Move();
201 :
202 : /*
203 : * note: the window should only dock if
204 : * the user releases all mouse buttons. The real problem here
205 : * is that we don't get mouse events (at least not on X)
206 : * if the mouse is on the decoration. So we have to start an
207 : * awkward timer based process that polls the modifier/buttons
208 : * to see whether they are in the right condition shortly after the
209 : * last Move message.
210 : */
211 0 : if( ! mnLastUserEvent )
212 0 : mnLastUserEvent = Application::PostUserEvent( LINK( this, ImplDockFloatWin, DockingHdl ), NULL, true );
213 : }
214 :
215 0 : void ImplDockFloatWin::Resize()
216 : {
217 0 : FloatingWindow::Resize();
218 0 : Size aSize( GetSizePixel() );
219 0 : mpDockWin->ImplPosSizeWindow( 0, 0, aSize.Width(), aSize.Height(), PosSizeFlags::PosSize );
220 0 : }
221 :
222 0 : void ImplDockFloatWin::TitleButtonClick( TitleButton nButton )
223 : {
224 0 : FloatingWindow::TitleButtonClick( nButton );
225 0 : }
226 :
227 0 : void ImplDockFloatWin::Pin()
228 : {
229 0 : FloatingWindow::Pin();
230 0 : }
231 :
232 0 : void ImplDockFloatWin::Roll()
233 : {
234 0 : FloatingWindow::Roll();
235 0 : }
236 :
237 0 : void ImplDockFloatWin::PopupModeEnd()
238 : {
239 0 : FloatingWindow::PopupModeEnd();
240 0 : }
241 :
242 0 : void ImplDockFloatWin::Resizing( Size& rSize )
243 : {
244 0 : FloatingWindow::Resizing( rSize );
245 0 : mpDockWin->Resizing( rSize );
246 0 : }
247 :
248 0 : bool ImplDockFloatWin::Close()
249 : {
250 0 : return mpDockWin->Close();
251 : }
252 :
253 0 : bool DockingWindow::ImplStartDocking( const Point& rPos )
254 : {
255 0 : if ( !mbDockable )
256 0 : return false;
257 :
258 0 : maMouseOff = rPos;
259 0 : maMouseStart = maMouseOff;
260 0 : mbDocking = true;
261 0 : mbLastFloatMode = IsFloatingMode();
262 0 : mbStartFloat = mbLastFloatMode;
263 :
264 : // calculate FloatingBorder
265 0 : VclPtr<FloatingWindow> pWin;
266 0 : if ( mpFloatWin )
267 0 : pWin = mpFloatWin;
268 : else
269 0 : pWin = VclPtr<ImplDockFloatWin>::Create( mpImplData->mpParent, mnFloatBits, nullptr );
270 0 : pWin->GetBorder( mnDockLeft, mnDockTop, mnDockRight, mnDockBottom );
271 0 : if ( !mpFloatWin )
272 0 : pWin.disposeAndClear();
273 :
274 0 : Point aPos = ImplOutputToFrame( Point() );
275 0 : Size aSize = Window::GetOutputSizePixel();
276 0 : mnTrackX = aPos.X();
277 0 : mnTrackY = aPos.Y();
278 0 : mnTrackWidth = aSize.Width();
279 0 : mnTrackHeight = aSize.Height();
280 :
281 0 : if ( mbLastFloatMode )
282 : {
283 0 : maMouseOff.X() += mnDockLeft;
284 0 : maMouseOff.Y() += mnDockTop;
285 0 : mnTrackX -= mnDockLeft;
286 0 : mnTrackY -= mnDockTop;
287 0 : mnTrackWidth += mnDockLeft+mnDockRight;
288 0 : mnTrackHeight += mnDockTop+mnDockBottom;
289 : }
290 :
291 0 : if ( GetSettings().GetStyleSettings().GetDragFullOptions() & DragFullOptions::Docking &&
292 0 : !( mnFloatBits & ( WB_MOVEABLE | WB_SIZEABLE | WB_CLOSEABLE ) ) ) // no full drag when migrating to system window
293 0 : mbDragFull = true;
294 : else
295 : {
296 0 : StartDocking();
297 0 : mbDragFull = false;
298 0 : ImplUpdateAll();
299 0 : ImplGetFrameWindow()->ImplUpdateAll();
300 : }
301 :
302 0 : StartTracking( StartTrackingFlags::KeyMod );
303 0 : return true;
304 : }
305 :
306 66663 : void DockingWindow::ImplInitDockingWindowData()
307 : {
308 66663 : mpWindowImpl->mbDockWin = true;
309 66663 : mpFloatWin = NULL;
310 66663 : mpOldBorderWin = NULL;
311 66663 : mpImplData = new ImplData;
312 66663 : mnTrackX = 0;
313 66663 : mnTrackY = 0;
314 66663 : mnTrackWidth = 0;
315 66663 : mnTrackHeight = 0;
316 66663 : mnDockLeft = 0;
317 66663 : mnDockTop = 0;
318 66663 : mnDockRight = 0;
319 66663 : mnDockBottom = 0;
320 66663 : mnFloatBits = 0;
321 66663 : mbDockCanceled = false;
322 66663 : mbDockPrevented = false;
323 66663 : mbFloatPrevented = false;
324 66663 : mbDockable = false;
325 66663 : mbDocking = false;
326 66663 : mbDragFull = false;
327 66663 : mbLastFloatMode = false;
328 66663 : mbStartFloat = false;
329 66663 : mbTrackDock = false;
330 66663 : mbPinned = false;
331 66663 : mbRollUp = false;
332 66663 : mbDockBtn = false;
333 66663 : mbHideBtn = false;
334 66663 : mbIsDefferedInit = false;
335 66663 : mbIsCalculatingInitialLayoutSize = false;
336 66663 : mbInitialLayoutDone = false;
337 66663 : mpDialogParent = NULL;
338 :
339 : //To-Do, reuse maResizeTimer
340 66663 : maLayoutIdle.SetPriority(SchedulerPriority::RESIZE);
341 66663 : maLayoutIdle.SetIdleHdl( LINK( this, DockingWindow, ImplHandleLayoutTimerHdl ) );
342 66663 : }
343 :
344 66663 : void DockingWindow::ImplInit( vcl::Window* pParent, WinBits nStyle )
345 : {
346 66663 : if ( !(nStyle & WB_NODIALOGCONTROL) )
347 66663 : nStyle |= WB_DIALOGCONTROL;
348 :
349 66663 : mpImplData->mpParent = pParent;
350 66663 : mbDockable = (nStyle & WB_DOCKABLE) != 0;
351 66663 : mnFloatBits = WB_BORDER | (nStyle & DOCKWIN_FLOATSTYLES);
352 66663 : nStyle &= ~(DOCKWIN_FLOATSTYLES | WB_BORDER);
353 66663 : if ( nStyle & WB_DOCKBORDER )
354 0 : nStyle |= WB_BORDER;
355 :
356 66663 : Window::ImplInit( pParent, nStyle, NULL );
357 :
358 66663 : ImplInitSettings();
359 66663 : }
360 :
361 66891 : void DockingWindow::ImplInitSettings()
362 : {
363 : // Hack: to be able to build DockingWindows w/o background before switching
364 : // TODO: Hack
365 66891 : if ( IsBackground() )
366 : {
367 66890 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
368 :
369 66890 : Color aColor;
370 66890 : if ( IsControlBackground() )
371 0 : aColor = GetControlBackground();
372 66890 : else if ( Window::GetStyle() & WB_3DLOOK )
373 60481 : aColor = rStyleSettings.GetFaceColor();
374 : else
375 6409 : aColor = rStyleSettings.GetWindowColor();
376 66890 : SetBackground( aColor );
377 : }
378 66891 : }
379 :
380 17 : void DockingWindow::ImplLoadRes( const ResId& rResId )
381 : {
382 17 : Window::ImplLoadRes( rResId );
383 :
384 17 : sal_uLong nMask = ReadLongRes();
385 :
386 17 : if ( (RSC_DOCKINGWINDOW_XYMAPMODE | RSC_DOCKINGWINDOW_X |
387 17 : RSC_DOCKINGWINDOW_Y) & nMask )
388 : {
389 : // use Sizes of the Resource
390 0 : Point aPos;
391 0 : MapUnit ePosMap = MAP_PIXEL;
392 :
393 0 : if ( RSC_DOCKINGWINDOW_XYMAPMODE & nMask )
394 0 : ePosMap = (MapUnit)ReadLongRes();
395 :
396 0 : if ( RSC_DOCKINGWINDOW_X & nMask )
397 : {
398 0 : aPos.X() = ReadShortRes();
399 0 : aPos.X() = ImplLogicUnitToPixelX( aPos.X(), ePosMap );
400 : }
401 :
402 0 : if ( RSC_DOCKINGWINDOW_Y & nMask )
403 : {
404 0 : aPos.Y() = ReadShortRes();
405 0 : aPos.Y() = ImplLogicUnitToPixelY( aPos.Y(), ePosMap );
406 : }
407 :
408 0 : SetFloatingPos( aPos );
409 : }
410 :
411 17 : if ( nMask & RSC_DOCKINGWINDOW_FLOATING )
412 : {
413 0 : if ( ReadShortRes() != 0 )
414 0 : SetFloatingMode( true );
415 : }
416 17 : }
417 :
418 63394 : DockingWindow::DockingWindow( WindowType nType ) :
419 63394 : Window(nType)
420 : {
421 63394 : ImplInitDockingWindowData();
422 63394 : }
423 :
424 3252 : DockingWindow::DockingWindow( vcl::Window* pParent, WinBits nStyle ) :
425 3252 : Window( WINDOW_DOCKINGWINDOW )
426 : {
427 3252 : ImplInitDockingWindowData();
428 3252 : ImplInit( pParent, nStyle );
429 3252 : }
430 :
431 0 : DockingWindow::DockingWindow( vcl::Window* pParent, const ResId& rResId ) :
432 0 : Window( WINDOW_DOCKINGWINDOW )
433 : {
434 0 : ImplInitDockingWindowData();
435 0 : rResId.SetRT( RSC_DOCKINGWINDOW );
436 0 : WinBits nStyle = ImplInitRes( rResId );
437 0 : ImplInit( pParent, nStyle );
438 0 : ImplLoadRes( rResId );
439 :
440 0 : if ( !(nStyle & WB_HIDE) )
441 0 : Show();
442 0 : }
443 :
444 : //Find the real parent stashed in mpDialogParent.
445 17 : void DockingWindow::doDeferredInit(WinBits nBits)
446 : {
447 17 : vcl::Window *pParent = mpDialogParent;
448 17 : mpDialogParent = NULL;
449 17 : ImplInit(pParent, nBits);
450 17 : mbIsDefferedInit = false;
451 17 : }
452 :
453 17 : void DockingWindow::loadUI(vcl::Window* pParent, const OString& rID, const OUString& rUIXMLDescription,
454 : const css::uno::Reference<css::frame::XFrame> &rFrame)
455 : {
456 17 : mbIsDefferedInit = true;
457 17 : mpDialogParent = pParent; //should be unset in doDeferredInit
458 17 : m_pUIBuilder = new VclBuilder(this, getUIRootDir(), rUIXMLDescription, rID, rFrame);
459 17 : }
460 :
461 17 : DockingWindow::DockingWindow(vcl::Window* pParent, const OString& rID,
462 : const OUString& rUIXMLDescription, const css::uno::Reference<css::frame::XFrame> &rFrame)
463 17 : : Window(WINDOW_DOCKINGWINDOW)
464 : {
465 17 : ImplInitDockingWindowData();
466 :
467 17 : loadUI(pParent, rID, rUIXMLDescription, rFrame);
468 17 : }
469 :
470 131273 : DockingWindow::~DockingWindow()
471 : {
472 65636 : disposeOnce();
473 65637 : }
474 :
475 66580 : void DockingWindow::dispose()
476 : {
477 66580 : if ( IsFloatingMode() )
478 : {
479 0 : Show( false, ShowFlags::NoFocusChange );
480 0 : SetFloatingMode( false );
481 : }
482 66580 : delete mpImplData;
483 66580 : mpImplData = NULL;
484 66580 : mpFloatWin.clear();
485 66580 : mpOldBorderWin.clear();
486 66580 : mpDialogParent.clear();
487 66580 : disposeBuilder();
488 66580 : Window::dispose();
489 66580 : }
490 :
491 0 : void DockingWindow::Tracking( const TrackingEvent& rTEvt )
492 : {
493 0 : if( GetDockingManager()->IsDockable( this ) ) // new docking interface
494 0 : return Window::Tracking( rTEvt );
495 :
496 0 : if ( mbDocking )
497 : {
498 0 : if ( rTEvt.IsTrackingEnded() )
499 : {
500 0 : mbDocking = false;
501 0 : if ( mbDragFull )
502 : {
503 : // reset old state on Cancel
504 0 : if ( rTEvt.IsTrackingCanceled() )
505 : {
506 0 : StartDocking();
507 0 : Rectangle aRect( Point( mnTrackX, mnTrackY ), Size( mnTrackWidth, mnTrackHeight ) );
508 0 : EndDocking( aRect, mbStartFloat );
509 : }
510 : }
511 : else
512 : {
513 0 : HideTracking();
514 0 : if ( rTEvt.IsTrackingCanceled() )
515 : {
516 0 : mbDockCanceled = true;
517 0 : EndDocking( Rectangle( Point( mnTrackX, mnTrackY ), Size( mnTrackWidth, mnTrackHeight ) ), mbLastFloatMode );
518 0 : mbDockCanceled = false;
519 : }
520 : else
521 0 : EndDocking( Rectangle( Point( mnTrackX, mnTrackY ), Size( mnTrackWidth, mnTrackHeight ) ), mbLastFloatMode );
522 : }
523 : }
524 : // dock only for non-synthetic MouseEvents
525 0 : else if ( !rTEvt.GetMouseEvent().IsSynthetic() || rTEvt.GetMouseEvent().IsModifierChanged() )
526 : {
527 0 : Point aMousePos = rTEvt.GetMouseEvent().GetPosPixel();
528 0 : Point aFrameMousePos = ImplOutputToFrame( aMousePos );
529 0 : Size aFrameSize = mpWindowImpl->mpFrameWindow->GetOutputSizePixel();
530 0 : if ( aFrameMousePos.X() < 0 )
531 0 : aFrameMousePos.X() = 0;
532 0 : if ( aFrameMousePos.Y() < 0 )
533 0 : aFrameMousePos.Y() = 0;
534 0 : if ( aFrameMousePos.X() > aFrameSize.Width()-1 )
535 0 : aFrameMousePos.X() = aFrameSize.Width()-1;
536 0 : if ( aFrameMousePos.Y() > aFrameSize.Height()-1 )
537 0 : aFrameMousePos.Y() = aFrameSize.Height()-1;
538 0 : aMousePos = ImplFrameToOutput( aFrameMousePos );
539 0 : aMousePos.X() -= maMouseOff.X();
540 0 : aMousePos.Y() -= maMouseOff.Y();
541 0 : Point aFramePos = ImplOutputToFrame( aMousePos );
542 0 : Rectangle aTrackRect( aFramePos, Size( mnTrackWidth, mnTrackHeight ) );
543 0 : Rectangle aCompRect = aTrackRect;
544 0 : aFramePos.X() += maMouseOff.X();
545 0 : aFramePos.Y() += maMouseOff.Y();
546 0 : if ( mbDragFull )
547 0 : StartDocking();
548 0 : bool bFloatMode = Docking( aFramePos, aTrackRect );
549 0 : mbDockPrevented = false;
550 0 : mbFloatPrevented = false;
551 0 : if ( mbLastFloatMode != bFloatMode )
552 : {
553 0 : if ( bFloatMode )
554 : {
555 0 : aTrackRect.Left() -= mnDockLeft;
556 0 : aTrackRect.Top() -= mnDockTop;
557 0 : aTrackRect.Right() += mnDockRight;
558 0 : aTrackRect.Bottom() += mnDockBottom;
559 : }
560 : else
561 : {
562 0 : if ( aCompRect == aTrackRect )
563 : {
564 0 : aTrackRect.Left() += mnDockLeft;
565 0 : aTrackRect.Top() += mnDockTop;
566 0 : aTrackRect.Right() -= mnDockRight;
567 0 : aTrackRect.Bottom() -= mnDockBottom;
568 : }
569 : }
570 0 : mbLastFloatMode = bFloatMode;
571 : }
572 0 : if ( mbDragFull )
573 : {
574 0 : Point aPos;
575 0 : Point aOldPos = OutputToScreenPixel( aPos );
576 0 : EndDocking( aTrackRect, mbLastFloatMode );
577 : // repaint if state or position has changed
578 0 : if ( aOldPos != OutputToScreenPixel( aPos ) )
579 : {
580 0 : ImplUpdateAll();
581 0 : ImplGetFrameWindow()->ImplUpdateAll();
582 : }
583 : // EndDocking( aTrackRect, mbLastFloatMode );
584 : }
585 : else
586 : {
587 : sal_uInt16 nTrackStyle;
588 0 : if ( bFloatMode )
589 0 : nTrackStyle = SHOWTRACK_BIG;
590 : else
591 0 : nTrackStyle = SHOWTRACK_OBJECT;
592 0 : Rectangle aShowTrackRect = aTrackRect;
593 0 : aShowTrackRect.SetPos( ImplFrameToOutput( aShowTrackRect.TopLeft() ) );
594 0 : ShowTracking( aShowTrackRect, nTrackStyle );
595 :
596 : // recalculate mouse offset, as the rectangle was changed
597 0 : maMouseOff.X() = aFramePos.X() - aTrackRect.Left();
598 0 : maMouseOff.Y() = aFramePos.Y() - aTrackRect.Top();
599 : }
600 :
601 0 : mnTrackX = aTrackRect.Left();
602 0 : mnTrackY = aTrackRect.Top();
603 0 : mnTrackWidth = aTrackRect.GetWidth();
604 0 : mnTrackHeight = aTrackRect.GetHeight();
605 : }
606 : }
607 : }
608 :
609 187222 : bool DockingWindow::Notify( NotifyEvent& rNEvt )
610 : {
611 187222 : if( GetDockingManager()->IsDockable( this ) ) // new docking interface
612 12046 : return Window::Notify( rNEvt );
613 :
614 175176 : if ( mbDockable )
615 : {
616 84701 : if ( rNEvt.GetType() == MouseNotifyEvent::MOUSEBUTTONDOWN )
617 : {
618 0 : const MouseEvent* pMEvt = rNEvt.GetMouseEvent();
619 0 : if ( pMEvt->IsLeft() )
620 : {
621 0 : if ( pMEvt->IsMod1() && (pMEvt->GetClicks() == 2) )
622 : {
623 0 : SetFloatingMode( !IsFloatingMode() );
624 0 : return true;
625 : }
626 0 : else if ( pMEvt->GetClicks() == 1 )
627 : {
628 : // check if window is floating standalone (IsFloating())
629 : // or only partially floating and still docked with one border
630 : // ( !mpWindowImpl->mbFrame)
631 0 : if( ! IsFloatingMode() || ! mpFloatWin->mpWindowImpl->mbFrame )
632 : {
633 0 : Point aPos = pMEvt->GetPosPixel();
634 0 : vcl::Window* pWindow = rNEvt.GetWindow();
635 0 : if ( pWindow != this )
636 : {
637 0 : aPos = pWindow->OutputToScreenPixel( aPos );
638 0 : aPos = ScreenToOutputPixel( aPos );
639 : }
640 0 : ImplStartDocking( aPos );
641 : }
642 0 : return true;
643 : }
644 : }
645 : }
646 84701 : else if( rNEvt.GetType() == MouseNotifyEvent::KEYINPUT )
647 : {
648 0 : const vcl::KeyCode& rKey = rNEvt.GetKeyEvent()->GetKeyCode();
649 0 : if( rKey.GetCode() == KEY_F10 && rKey.GetModifier() &&
650 0 : rKey.IsShift() && rKey.IsMod1() )
651 : {
652 0 : SetFloatingMode( !IsFloatingMode() );
653 0 : return true;
654 : }
655 : }
656 : }
657 :
658 175176 : return Window::Notify( rNEvt );
659 : }
660 :
661 0 : void DockingWindow::StartDocking()
662 : {
663 0 : mbDocking = true;
664 0 : }
665 :
666 0 : bool DockingWindow::Docking( const Point&, Rectangle& )
667 : {
668 0 : return IsFloatingMode();
669 : }
670 :
671 0 : void DockingWindow::EndDocking( const Rectangle& rRect, bool bFloatMode )
672 : {
673 0 : if ( !IsDockingCanceled() )
674 : {
675 0 : bool bShow = false;
676 0 : if ( bool(bFloatMode) != IsFloatingMode() )
677 : {
678 0 : Show( false, ShowFlags::NoFocusChange );
679 0 : SetFloatingMode( bFloatMode );
680 0 : bShow = true;
681 0 : if ( bFloatMode && mpFloatWin )
682 0 : mpFloatWin->SetPosSizePixel( rRect.TopLeft(), rRect.GetSize() );
683 : }
684 0 : if ( !bFloatMode )
685 : {
686 0 : Point aPos = rRect.TopLeft();
687 0 : aPos = GetParent()->ScreenToOutputPixel( aPos );
688 0 : Window::SetPosSizePixel( aPos, rRect.GetSize() );
689 : }
690 :
691 0 : if ( bShow )
692 0 : Show();
693 : }
694 0 : mbDocking = false;
695 0 : }
696 :
697 0 : bool DockingWindow::PrepareToggleFloatingMode()
698 : {
699 0 : return true;
700 : }
701 :
702 0 : bool DockingWindow::Close()
703 : {
704 0 : ImplDelData aDelData;
705 0 : ImplAddDel( &aDelData );
706 0 : CallEventListeners( VCLEVENT_WINDOW_CLOSE );
707 0 : if ( aDelData.IsDead() )
708 0 : return false;
709 0 : ImplRemoveDel( &aDelData );
710 :
711 0 : if ( mpWindowImpl->mxWindowPeer.is() && IsCreatedWithToolkit() )
712 0 : return false;
713 :
714 0 : Show( false, ShowFlags::NoFocusChange );
715 0 : return true;
716 : }
717 :
718 0 : void DockingWindow::ToggleFloatingMode()
719 : {
720 0 : }
721 :
722 0 : void DockingWindow::Resizing( Size& )
723 : {
724 0 : }
725 :
726 28897 : void DockingWindow::DoInitialLayout()
727 : {
728 28897 : if ( GetSettings().GetStyleSettings().GetAutoMnemonic() )
729 28897 : ImplWindowAutoMnemonic( this );
730 :
731 28897 : if (isLayoutEnabled())
732 : {
733 34 : mbIsCalculatingInitialLayoutSize = true;
734 34 : setDeferredProperties();
735 34 : setOptimalLayoutSize();
736 34 : mbIsCalculatingInitialLayoutSize = false;
737 34 : mbInitialLayoutDone = true;
738 : }
739 28897 : }
740 :
741 146858 : void DockingWindow::StateChanged( StateChangedType nType )
742 : {
743 146858 : switch(nType)
744 : {
745 : case StateChangedType::InitShow:
746 28897 : DoInitialLayout();
747 28897 : break;
748 :
749 : case StateChangedType::ControlBackground:
750 0 : ImplInitSettings();
751 0 : Invalidate();
752 0 : break;
753 :
754 : case StateChangedType::Style:
755 0 : mbDockable = (GetStyle() & WB_DOCKABLE) != 0;
756 0 : break;
757 :
758 : default:
759 117961 : break;
760 : }
761 :
762 146858 : Window::StateChanged( nType );
763 146858 : }
764 :
765 267 : void DockingWindow::DataChanged( const DataChangedEvent& rDCEvt )
766 : {
767 1068 : if ( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
768 1068 : (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
769 : {
770 228 : ImplInitSettings();
771 228 : Invalidate();
772 : }
773 : else
774 39 : Window::DataChanged( rDCEvt );
775 267 : }
776 :
777 0 : void DockingWindow::SetFloatingMode( bool bFloatMode )
778 : {
779 0 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
780 0 : if( pWrapper )
781 : {
782 0 : pWrapper->SetFloatingMode( bFloatMode );
783 0 : return;
784 : }
785 0 : if ( IsFloatingMode() != bFloatMode )
786 : {
787 0 : if ( PrepareToggleFloatingMode() ) // changes to floating mode can be vetoed
788 : {
789 0 : bool bVisible = IsVisible();
790 :
791 0 : if ( bFloatMode )
792 : {
793 0 : Show( false, ShowFlags::NoFocusChange );
794 :
795 0 : sal_Int32 nBorderWidth = get_border_width();
796 :
797 0 : maDockPos = Window::GetPosPixel();
798 :
799 0 : vcl::Window* pRealParent = mpWindowImpl->mpRealParent;
800 0 : mpOldBorderWin = mpWindowImpl->mpBorderWindow;
801 :
802 : ImplDockFloatWin* pWin =
803 : VclPtr<ImplDockFloatWin>::Create(
804 :
805 : mpImplData->mpParent,
806 0 : mnFloatBits & ( WB_MOVEABLE | WB_SIZEABLE | WB_CLOSEABLE ) ? mnFloatBits | WB_SYSTEMWINDOW : mnFloatBits,
807 0 : this );
808 0 : mpFloatWin = pWin;
809 0 : mpWindowImpl->mpBorderWindow = NULL;
810 0 : mpWindowImpl->mnLeftBorder = 0;
811 0 : mpWindowImpl->mnTopBorder = 0;
812 0 : mpWindowImpl->mnRightBorder = 0;
813 0 : mpWindowImpl->mnBottomBorder = 0;
814 : // if the parent gets destroyed, we also have to reset the parent of the BorderWindow
815 0 : if ( mpOldBorderWin )
816 0 : mpOldBorderWin->SetParent( pWin );
817 :
818 : // #i123765# reset the buffered DropTargets when undocking, else it may not
819 : // be correctly initialized
820 0 : mpWindowImpl->mxDNDListenerContainer.clear();
821 :
822 0 : SetParent( pWin );
823 0 : SetPosPixel( Point() );
824 0 : mpWindowImpl->mpBorderWindow = pWin;
825 0 : pWin->mpWindowImpl->mpClientWindow = this;
826 0 : mpWindowImpl->mpRealParent = pRealParent;
827 0 : pWin->SetText( Window::GetText() );
828 0 : Size aSize(Window::GetSizePixel());
829 0 : pWin->SetOutputSizePixel(aSize);
830 0 : pWin->SetPosPixel( maFloatPos );
831 : // pass on DockingData to FloatingWindow
832 0 : pWin->ShowTitleButton( TitleButton::Docking, mbDockBtn );
833 0 : pWin->ShowTitleButton( TitleButton::Hide, mbHideBtn );
834 0 : pWin->SetPin( mbPinned );
835 0 : if ( mbRollUp )
836 0 : pWin->RollUp();
837 : else
838 0 : pWin->RollDown();
839 0 : pWin->SetRollUpOutputSizePixel( maRollUpOutSize );
840 0 : pWin->SetMinOutputSizePixel( maMinOutSize );
841 :
842 0 : pWin->SetMaxOutputSizePixel( mpImplData->maMaxOutSize );
843 :
844 0 : ToggleFloatingMode();
845 :
846 0 : set_border_width(nBorderWidth);
847 :
848 0 : if ( bVisible )
849 0 : Show();
850 :
851 0 : mpFloatWin->queue_resize();
852 : }
853 : else
854 : {
855 0 : Show( false, ShowFlags::NoFocusChange );
856 :
857 0 : sal_Int32 nBorderWidth = get_border_width();
858 :
859 : // store FloatingData in FloatingWindow
860 0 : maFloatPos = mpFloatWin->GetPosPixel();
861 0 : mbDockBtn = mpFloatWin->IsTitleButtonVisible( TitleButton::Docking );
862 0 : mbHideBtn = mpFloatWin->IsTitleButtonVisible( TitleButton::Hide );
863 0 : mbPinned = mpFloatWin->IsPinned();
864 0 : mbRollUp = mpFloatWin->IsRollUp();
865 0 : maRollUpOutSize = mpFloatWin->GetRollUpOutputSizePixel();
866 0 : maMinOutSize = mpFloatWin->GetMinOutputSizePixel();
867 0 : mpImplData->maMaxOutSize = mpFloatWin->GetMaxOutputSizePixel();
868 :
869 0 : vcl::Window* pRealParent = mpWindowImpl->mpRealParent;
870 0 : mpWindowImpl->mpBorderWindow = NULL;
871 0 : if ( mpOldBorderWin )
872 : {
873 0 : SetParent( mpOldBorderWin );
874 0 : static_cast<ImplBorderWindow*>(mpOldBorderWin.get())->GetBorder( mpWindowImpl->mnLeftBorder, mpWindowImpl->mnTopBorder, mpWindowImpl->mnRightBorder, mpWindowImpl->mnBottomBorder );
875 0 : mpOldBorderWin->Resize();
876 : }
877 0 : mpWindowImpl->mpBorderWindow = mpOldBorderWin;
878 0 : SetParent( pRealParent );
879 0 : mpWindowImpl->mpRealParent = pRealParent;
880 0 : mpFloatWin.disposeAndClear();
881 0 : SetPosPixel( maDockPos );
882 :
883 0 : ToggleFloatingMode();
884 :
885 0 : set_border_width(nBorderWidth);
886 :
887 0 : if ( bVisible )
888 0 : Show();
889 : }
890 : }
891 : }
892 : }
893 :
894 9 : void DockingWindow::SetFloatStyle( WinBits nStyle )
895 : {
896 9 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
897 9 : if( pWrapper )
898 : {
899 9 : pWrapper->SetFloatStyle( nStyle );
900 18 : return;
901 : }
902 :
903 0 : mnFloatBits = nStyle;
904 : }
905 :
906 15535 : WinBits DockingWindow::GetFloatStyle() const
907 : {
908 15535 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
909 15535 : if( pWrapper )
910 : {
911 9 : return pWrapper->GetFloatStyle();
912 : }
913 :
914 15526 : return mnFloatBits;
915 : }
916 :
917 120817 : void DockingWindow::setPosSizePixel( long nX, long nY,
918 : long nWidth, long nHeight,
919 : PosSizeFlags nFlags )
920 : {
921 120817 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
922 120817 : if (pWrapper)
923 : {
924 30714 : if (!pWrapper->mpFloatWin)
925 30714 : Window::setPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
926 : }
927 : else
928 : {
929 90103 : if (!mpFloatWin)
930 90103 : Window::setPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
931 : }
932 :
933 120817 : if (::isLayoutEnabled(this))
934 : {
935 251 : Size aSize(GetSizePixel());
936 :
937 251 : sal_Int32 nBorderWidth = get_border_width();
938 :
939 251 : aSize.Width() -= 2 * nBorderWidth;
940 251 : aSize.Height() -= 2 * nBorderWidth;
941 :
942 251 : Point aPos(nBorderWidth, nBorderWidth);
943 251 : Window *pBox = GetWindow(GetWindowType::FirstChild);
944 : assert(pBox);
945 251 : VclContainer::setLayoutAllocation(*pBox, aPos, aSize);
946 : }
947 120817 : }
948 :
949 74736 : Point DockingWindow::GetPosPixel() const
950 : {
951 74736 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
952 74736 : if( pWrapper )
953 : {
954 50517 : if ( pWrapper->mpFloatWin )
955 0 : return pWrapper->mpFloatWin->GetPosPixel();
956 : else
957 50517 : return Window::GetPosPixel();
958 : }
959 :
960 24219 : if ( mpFloatWin )
961 0 : return mpFloatWin->GetPosPixel();
962 : else
963 24219 : return Window::GetPosPixel();
964 : }
965 :
966 185995 : Size DockingWindow::GetSizePixel() const
967 : {
968 185995 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
969 185995 : if( pWrapper )
970 : {
971 50825 : if ( pWrapper->mpFloatWin )
972 0 : return pWrapper->mpFloatWin->GetSizePixel();
973 : else
974 50825 : return Window::GetSizePixel();
975 : }
976 :
977 135170 : if ( mpFloatWin )
978 0 : return mpFloatWin->GetSizePixel();
979 : else
980 135170 : return Window::GetSizePixel();
981 : }
982 :
983 19466 : void DockingWindow::SetOutputSizePixel( const Size& rNewSize )
984 : {
985 19466 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
986 19466 : if( pWrapper )
987 : {
988 9528 : if ( pWrapper->mpFloatWin )
989 0 : pWrapper->mpFloatWin->SetOutputSizePixel( rNewSize );
990 : else
991 9528 : Window::SetOutputSizePixel( rNewSize );
992 28994 : return;
993 : }
994 :
995 9938 : if ( mpFloatWin )
996 0 : mpFloatWin->SetOutputSizePixel( rNewSize );
997 : else
998 9938 : Window::SetOutputSizePixel( rNewSize );
999 : }
1000 :
1001 57084 : Size DockingWindow::GetOutputSizePixel() const
1002 : {
1003 57084 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
1004 57084 : if( pWrapper )
1005 : {
1006 13620 : if ( pWrapper->mpFloatWin )
1007 0 : return pWrapper->mpFloatWin->GetOutputSizePixel();
1008 : else
1009 13620 : return Window::GetOutputSizePixel();
1010 : }
1011 :
1012 43464 : if ( mpFloatWin )
1013 0 : return mpFloatWin->GetOutputSizePixel();
1014 : else
1015 43464 : return Window::GetOutputSizePixel();
1016 : }
1017 :
1018 3236 : Point DockingWindow::GetFloatingPos() const
1019 : {
1020 3236 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
1021 3236 : if( pWrapper )
1022 : {
1023 0 : if ( pWrapper->mpFloatWin )
1024 : {
1025 0 : WindowStateData aData;
1026 0 : aData.SetMask( WINDOWSTATE_MASK_POS );
1027 0 : pWrapper->mpFloatWin->GetWindowStateData( aData );
1028 0 : Point aPos( aData.GetX(), aData.GetY() );
1029 0 : aPos = pWrapper->mpFloatWin->GetParent()->ImplGetFrameWindow()->AbsoluteScreenToOutputPixel( aPos );
1030 0 : return aPos;
1031 : }
1032 : else
1033 0 : return maFloatPos;
1034 : }
1035 :
1036 3236 : if ( mpFloatWin )
1037 : {
1038 0 : WindowStateData aData;
1039 0 : aData.SetMask( WINDOWSTATE_MASK_POS );
1040 0 : mpFloatWin->GetWindowStateData( aData );
1041 0 : Point aPos( aData.GetX(), aData.GetY() );
1042 0 : aPos = mpFloatWin->GetParent()->ImplGetFrameWindow()->AbsoluteScreenToOutputPixel( aPos );
1043 0 : return aPos;
1044 : }
1045 : else
1046 3236 : return maFloatPos;
1047 : }
1048 :
1049 1171988 : bool DockingWindow::IsFloatingMode() const
1050 : {
1051 1171988 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
1052 1171988 : if( pWrapper )
1053 748419 : return pWrapper->IsFloatingMode();
1054 : else
1055 423569 : return (mpFloatWin != nullptr);
1056 : }
1057 :
1058 0 : void DockingWindow::SetMaxOutputSizePixel( const Size& rSize )
1059 : {
1060 0 : if ( mpFloatWin )
1061 0 : mpFloatWin->SetMaxOutputSizePixel( rSize );
1062 0 : mpImplData->maMaxOutSize = rSize;
1063 0 : }
1064 :
1065 13333 : void DockingWindow::SetText(const OUString& rStr)
1066 : {
1067 13333 : setDeferredProperties();
1068 13333 : Window::SetText(rStr);
1069 13333 : }
1070 :
1071 15967 : OUString DockingWindow::GetText() const
1072 : {
1073 15967 : const_cast<DockingWindow*>(this)->setDeferredProperties();
1074 15967 : return Window::GetText();
1075 : }
1076 :
1077 320941 : bool DockingWindow::isLayoutEnabled() const
1078 : {
1079 : //pre dtor called, and single child is a container => we're layout enabled
1080 320941 : return mpImplData && ::isLayoutEnabled(this);
1081 : }
1082 :
1083 34 : void DockingWindow::setOptimalLayoutSize()
1084 : {
1085 34 : maLayoutIdle.Stop();
1086 :
1087 : //resize DockingWindow to fit requisition on initial show
1088 34 : Window *pBox = GetWindow(GetWindowType::FirstChild);
1089 :
1090 34 : Size aSize = get_preferred_size();
1091 :
1092 34 : Size aMax(bestmaxFrameSizeForScreenSize(GetDesktopRectPixel().GetSize()));
1093 :
1094 34 : aSize.Width() = std::min(aMax.Width(), aSize.Width());
1095 34 : aSize.Height() = std::min(aMax.Height(), aSize.Height());
1096 :
1097 34 : SetMinOutputSizePixel(aSize);
1098 34 : SetSizePixel(aSize);
1099 34 : setPosSizeOnContainee(aSize, *pBox);
1100 34 : }
1101 :
1102 115 : void DockingWindow::setPosSizeOnContainee(Size aSize, Window &rBox)
1103 : {
1104 115 : sal_Int32 nBorderWidth = get_border_width();
1105 :
1106 115 : aSize.Width() -= 2 * nBorderWidth;
1107 115 : aSize.Height() -= 2 * nBorderWidth;
1108 :
1109 115 : Point aPos(nBorderWidth, nBorderWidth);
1110 115 : VclContainer::setLayoutAllocation(rBox, aPos, aSize);
1111 115 : }
1112 :
1113 49 : Size DockingWindow::GetOptimalSize() const
1114 : {
1115 49 : if (!isLayoutEnabled())
1116 0 : return Window::GetOptimalSize();
1117 :
1118 49 : Size aSize = VclContainer::getLayoutRequisition(*GetWindow(GetWindowType::FirstChild));
1119 :
1120 49 : sal_Int32 nBorderWidth = get_border_width();
1121 :
1122 98 : aSize.Height() += mpWindowImpl->mnLeftBorder + mpWindowImpl->mnRightBorder
1123 98 : + 2*nBorderWidth;
1124 98 : aSize.Width() += mpWindowImpl->mnTopBorder + mpWindowImpl->mnBottomBorder
1125 98 : + 2*nBorderWidth;
1126 :
1127 49 : return Window::CalcWindowSize(aSize);
1128 : }
1129 :
1130 291897 : void DockingWindow::queue_resize(StateChangedType eReason)
1131 : {
1132 291897 : bool bTriggerLayout = true;
1133 291897 : if (hasPendingLayout() || isCalculatingInitialLayoutSize())
1134 : {
1135 378 : bTriggerLayout = false;
1136 : }
1137 291897 : if (!isLayoutEnabled())
1138 : {
1139 291472 : bTriggerLayout = false;
1140 : }
1141 291897 : if (bTriggerLayout)
1142 : {
1143 149 : InvalidateSizeCache();
1144 149 : maLayoutIdle.Start();
1145 : }
1146 291897 : vcl::Window::queue_resize(eReason);
1147 291897 : }
1148 :
1149 196 : IMPL_LINK_NOARG_TYPED(DockingWindow, ImplHandleLayoutTimerHdl, Idle*, void)
1150 : {
1151 98 : if (!isLayoutEnabled())
1152 : {
1153 : SAL_WARN("vcl.layout", "DockingWindow has become non-layout because extra children have been added directly to it.");
1154 115 : return;
1155 : }
1156 :
1157 81 : Window *pBox = GetWindow(GetWindowType::FirstChild);
1158 : assert(pBox);
1159 81 : setPosSizeOnContainee(GetSizePixel(), *pBox);
1160 801 : }
1161 :
1162 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
