Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*************************************************************************
3 : : *
4 : : * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 : : *
6 : : * Copyright 2000, 2010 Oracle and/or its affiliates.
7 : : *
8 : : * OpenOffice.org - a multi-platform office productivity suite
9 : : *
10 : : * This file is part of OpenOffice.org.
11 : : *
12 : : * OpenOffice.org is free software: you can redistribute it and/or modify
13 : : * it under the terms of the GNU Lesser General Public License version 3
14 : : * only, as published by the Free Software Foundation.
15 : : *
16 : : * OpenOffice.org is distributed in the hope that it will be useful,
17 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 : : * GNU Lesser General Public License version 3 for more details
20 : : * (a copy is included in the LICENSE file that accompanied this code).
21 : : *
22 : : * You should have received a copy of the GNU Lesser General Public License
23 : : * version 3 along with OpenOffice.org. If not, see
24 : : * <http://www.openoffice.org/license.html>
25 : : * for a copy of the LGPLv3 License.
26 : : *
27 : : ************************************************************************/
28 : :
29 : :
30 : : #include <tools/time.hxx>
31 : : #include <tools/rc.h>
32 : : #include <vcl/event.hxx>
33 : : #include <vcl/floatwin.hxx>
34 : : #include <vcl/dockwin.hxx>
35 : : #include <vcl/svapp.hxx>
36 : : #include <vcl/timer.hxx>
37 : : #include <vcl/unowrap.hxx>
38 : :
39 : : #include <svdata.hxx>
40 : : #include <window.h>
41 : : #include <brdwin.hxx>
42 : : #include <salframe.hxx>
43 : :
44 : :
45 : :
46 : : // =======================================================================
47 : :
48 : : #define DOCKWIN_FLOATSTYLES (WB_SIZEABLE | WB_MOVEABLE | WB_CLOSEABLE | WB_STANDALONE | WB_PINABLE | WB_ROLLABLE )
49 : :
50 : : // =======================================================================
51 : :
52 : : // -----------------------------------------------------------------------
53 : :
54 : : class DockingWindow::ImplData
55 : : {
56 : : public:
57 : : ImplData();
58 : : ~ImplData();
59 : :
60 : : Window* mpParent;
61 : : Size maMaxOutSize;
62 : : };
63 : :
64 : 24256 : DockingWindow::ImplData::ImplData()
65 : : {
66 : 24256 : mpParent = NULL;
67 : 24256 : maMaxOutSize = Size( SHRT_MAX, SHRT_MAX );
68 : 24256 : }
69 : :
70 : 23251 : DockingWindow::ImplData::~ImplData()
71 : : {
72 : 23251 : }
73 : :
74 : : // -----------------------------------------------------------------------
75 : :
76 : : class ImplDockFloatWin : public FloatingWindow
77 : : {
78 : : private:
79 : : DockingWindow* mpDockWin;
80 : : sal_uLong mnLastTicks;
81 : : Timer maDockTimer;
82 : : Point maDockPos;
83 : : Rectangle maDockRect;
84 : : sal_Bool mbInMove;
85 : : sal_uLong mnLastUserEvent;
86 : :
87 : : DECL_LINK(DockingHdl, void *);
88 : : DECL_LINK(DockTimerHdl, void *);
89 : : public:
90 : : ImplDockFloatWin( Window* pParent, WinBits nWinBits,
91 : : DockingWindow* pDockingWin );
92 : : ~ImplDockFloatWin();
93 : :
94 : : virtual void Move();
95 : : virtual void Resize();
96 : : virtual void TitleButtonClick( sal_uInt16 nButton );
97 : : virtual void Pin();
98 : : virtual void Roll();
99 : : virtual void PopupModeEnd();
100 : : virtual void Resizing( Size& rSize );
101 : : virtual sal_Bool Close();
102 : :
103 : : sal_uLong GetLastTicks() const { return mnLastTicks; }
104 : : };
105 : :
106 : :
107 : 0 : ImplDockFloatWin::ImplDockFloatWin( Window* pParent, WinBits nWinBits,
108 : : DockingWindow* pDockingWin ) :
109 : : FloatingWindow( pParent, nWinBits ),
110 : : mpDockWin( pDockingWin ),
111 [ # # ]: 0 : mnLastTicks( Time::GetSystemTicks() ),
112 : : mbInMove( sal_False ),
113 [ # # ][ # # ]: 0 : mnLastUserEvent( 0 )
114 : : {
115 : : // Daten vom DockingWindow uebernehmen
116 [ # # ]: 0 : if ( pDockingWin )
117 : : {
118 [ # # ]: 0 : SetSettings( pDockingWin->GetSettings() );
119 [ # # ][ # # ]: 0 : Enable( pDockingWin->IsEnabled(), sal_False );
120 [ # # ][ # # ]: 0 : EnableInput( pDockingWin->IsInputEnabled(), sal_False );
121 [ # # ][ # # ]: 0 : AlwaysEnableInput( pDockingWin->IsAlwaysEnableInput(), sal_False );
122 [ # # ][ # # ]: 0 : EnableAlwaysOnTop( pDockingWin->IsAlwaysOnTopEnabled() );
123 [ # # ][ # # ]: 0 : SetActivateMode( pDockingWin->GetActivateMode() );
124 : : }
125 : :
126 [ # # ]: 0 : SetBackground();
127 : :
128 [ # # ]: 0 : maDockTimer.SetTimeoutHdl( LINK( this, ImplDockFloatWin, DockTimerHdl ) );
129 [ # # ]: 0 : maDockTimer.SetTimeout( 50 );
130 : 0 : }
131 : :
132 : : // -----------------------------------------------------------------------
133 : :
134 [ # # ]: 0 : ImplDockFloatWin::~ImplDockFloatWin()
135 : : {
136 [ # # ]: 0 : if( mnLastUserEvent )
137 [ # # ]: 0 : Application::RemoveUserEvent( mnLastUserEvent );
138 [ # # ]: 0 : }
139 : :
140 : : // -----------------------------------------------------------------------
141 : :
142 : 0 : IMPL_LINK_NOARG(ImplDockFloatWin, DockTimerHdl)
143 : : {
144 : : DBG_ASSERT( mpDockWin->IsFloatingMode(), "docktimer called but not floating" );
145 : :
146 [ # # ]: 0 : maDockTimer.Stop();
147 [ # # ]: 0 : PointerState aState = GetPointerState();
148 : :
149 [ # # ]: 0 : if( aState.mnState & KEY_MOD1 )
150 : : {
151 : : // i43499 CTRL disables docking now
152 [ # # ][ # # ]: 0 : mpDockWin->GetParent()->ImplGetFrameWindow()->HideTracking();
[ # # ]
153 [ # # ]: 0 : mpDockWin->EndDocking( maDockRect, sal_True );
154 [ # # ]: 0 : if( aState.mnState & ( MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT ) )
155 [ # # ]: 0 : maDockTimer.Start();
156 : : }
157 [ # # ]: 0 : else if( ! ( aState.mnState & ( MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT ) ) )
158 : : {
159 [ # # ][ # # ]: 0 : mpDockWin->GetParent()->ImplGetFrameWindow()->HideTracking();
[ # # ]
160 [ # # ]: 0 : mpDockWin->EndDocking( maDockRect, sal_False );
161 : : }
162 : : else
163 : : {
164 [ # # ][ # # ]: 0 : mpDockWin->GetParent()->ImplGetFrameWindow()->ShowTracking( maDockRect, SHOWTRACK_BIG | SHOWTRACK_WINDOW );
[ # # ]
165 [ # # ]: 0 : maDockTimer.Start();
166 : : }
167 : :
168 : 0 : return 0;
169 : : }
170 : :
171 : 0 : IMPL_LINK_NOARG(ImplDockFloatWin, DockingHdl)
172 : : {
173 [ # # ][ # # ]: 0 : PointerState aState = mpDockWin->GetParent()->GetPointerState();
174 : :
175 : 0 : mnLastUserEvent = 0;
176 [ # # ][ # # ]: 0 : if( mpDockWin->IsDockable() &&
[ # # ][ # # ]
[ # # ]
177 [ # # ]: 0 : (Time::GetSystemTicks() - mnLastTicks > 500) &&
178 : : ( aState.mnState & ( MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT ) ) &&
179 : 0 : !(aState.mnState & KEY_MOD1) ) // i43499 CTRL disables docking now
180 : : {
181 [ # # ][ # # ]: 0 : maDockPos = Point( mpDockWin->GetParent()->AbsoluteScreenToOutputPixel( OutputToAbsoluteScreenPixel( Point() ) ) );
[ # # ]
182 [ # # ][ # # ]: 0 : maDockPos = mpDockWin->GetParent()->OutputToScreenPixel( maDockPos ); // sfx expects screen coordinates
183 : :
184 [ # # ]: 0 : if( ! mpDockWin->IsDocking() )
185 [ # # ]: 0 : mpDockWin->StartDocking();
186 [ # # ][ # # ]: 0 : maDockRect = Rectangle( maDockPos, mpDockWin->GetSizePixel() );
187 : :
188 : : // mouse pos also in screen pixels
189 [ # # ][ # # ]: 0 : Point aMousePos = mpDockWin->GetParent()->OutputToScreenPixel( aState.maPos );
190 : :
191 [ # # ]: 0 : sal_Bool bFloatMode = mpDockWin->Docking( aMousePos, maDockRect );
192 [ # # ]: 0 : if( ! bFloatMode )
193 : : {
194 [ # # ][ # # ]: 0 : mpDockWin->GetParent()->ImplGetFrameWindow()->ShowTracking( maDockRect, SHOWTRACK_OBJECT | SHOWTRACK_WINDOW );
[ # # ]
195 [ # # ]: 0 : DockTimerHdl( this );
196 : : }
197 : : else
198 : : {
199 [ # # ][ # # ]: 0 : mpDockWin->GetParent()->ImplGetFrameWindow()->HideTracking();
[ # # ]
200 [ # # ]: 0 : maDockTimer.Stop();
201 [ # # ]: 0 : mpDockWin->EndDocking( maDockRect, sal_True );
202 : : }
203 : : }
204 : 0 : mbInMove = sal_False;
205 : 0 : return 0;
206 : : }
207 : : // -----------------------------------------------------------------------
208 : :
209 : 0 : void ImplDockFloatWin::Move()
210 : : {
211 [ # # ]: 0 : if( mbInMove )
212 : 0 : return;
213 : :
214 : 0 : mbInMove = sal_True;
215 : 0 : FloatingWindow::Move();
216 : 0 : mpDockWin->Move();
217 : :
218 : : /*
219 : : * note: the window should only dock if
220 : : * the user releases all mouse buttons. The real problem here
221 : : * is that we don't get mouse events (at least not on X)
222 : : * if the mouse is on the decoration. So we have to start an
223 : : * awkward timer based process that polls the modifier/buttons
224 : : * to see whether they are in the right condition shortly after the
225 : : * last Move message.
226 : : */
227 [ # # ]: 0 : if( ! mnLastUserEvent )
228 [ # # ]: 0 : mnLastUserEvent = Application::PostUserEvent( LINK( this, ImplDockFloatWin, DockingHdl ) );
229 : : }
230 : :
231 : : // -----------------------------------------------------------------------
232 : :
233 : 0 : void ImplDockFloatWin::Resize()
234 : : {
235 [ # # ]: 0 : FloatingWindow::Resize();
236 [ # # ]: 0 : Size aSize( GetSizePixel() );
237 [ # # ]: 0 : mpDockWin->ImplPosSizeWindow( 0, 0, aSize.Width(), aSize.Height(), WINDOW_POSSIZE_POSSIZE );
238 : 0 : }
239 : :
240 : : // -----------------------------------------------------------------------
241 : :
242 : 0 : void ImplDockFloatWin::TitleButtonClick( sal_uInt16 nButton )
243 : : {
244 : 0 : FloatingWindow::TitleButtonClick( nButton );
245 : 0 : mpDockWin->TitleButtonClick( nButton );
246 : 0 : }
247 : :
248 : : // -----------------------------------------------------------------------
249 : :
250 : 0 : void ImplDockFloatWin::Pin()
251 : : {
252 : 0 : FloatingWindow::Pin();
253 : 0 : mpDockWin->Pin();
254 : 0 : }
255 : :
256 : : // -----------------------------------------------------------------------
257 : :
258 : 0 : void ImplDockFloatWin::Roll()
259 : : {
260 : 0 : FloatingWindow::Roll();
261 : 0 : mpDockWin->Roll();
262 : 0 : }
263 : :
264 : : // -----------------------------------------------------------------------
265 : :
266 : 0 : void ImplDockFloatWin::PopupModeEnd()
267 : : {
268 : 0 : FloatingWindow::PopupModeEnd();
269 : 0 : mpDockWin->PopupModeEnd();
270 : 0 : }
271 : :
272 : : // -----------------------------------------------------------------------
273 : :
274 : 0 : void ImplDockFloatWin::Resizing( Size& rSize )
275 : : {
276 : 0 : FloatingWindow::Resizing( rSize );
277 : 0 : mpDockWin->Resizing( rSize );
278 : 0 : }
279 : :
280 : : // -----------------------------------------------------------------------
281 : :
282 : 0 : sal_Bool ImplDockFloatWin::Close()
283 : : {
284 : 0 : return mpDockWin->Close();
285 : : }
286 : :
287 : : // =======================================================================
288 : :
289 : 0 : sal_Bool DockingWindow::ImplStartDocking( const Point& rPos )
290 : : {
291 [ # # ]: 0 : if ( !mbDockable )
292 : 0 : return sal_False;
293 : :
294 : 0 : maMouseOff = rPos;
295 : 0 : maMouseStart = maMouseOff;
296 : 0 : mbDocking = sal_True;
297 [ # # ]: 0 : mbLastFloatMode = IsFloatingMode();
298 : 0 : mbStartFloat = mbLastFloatMode;
299 : :
300 : : // FloatingBorder berechnen
301 : : FloatingWindow* pWin;
302 [ # # ]: 0 : if ( mpFloatWin )
303 : 0 : pWin = mpFloatWin;
304 : : else
305 [ # # ][ # # ]: 0 : pWin = new ImplDockFloatWin( mpImplData->mpParent, mnFloatBits, NULL );
306 [ # # ]: 0 : pWin->GetBorder( mnDockLeft, mnDockTop, mnDockRight, mnDockBottom );
307 [ # # ]: 0 : if ( !mpFloatWin )
308 [ # # ][ # # ]: 0 : delete pWin;
309 : :
310 [ # # ]: 0 : Point aPos = ImplOutputToFrame( Point() );
311 : 0 : Size aSize = Window::GetOutputSizePixel();
312 : 0 : mnTrackX = aPos.X();
313 : 0 : mnTrackY = aPos.Y();
314 : 0 : mnTrackWidth = aSize.Width();
315 : 0 : mnTrackHeight = aSize.Height();
316 : :
317 [ # # ]: 0 : if ( mbLastFloatMode )
318 : : {
319 : 0 : maMouseOff.X() += mnDockLeft;
320 : 0 : maMouseOff.Y() += mnDockTop;
321 : 0 : mnTrackX -= mnDockLeft;
322 : 0 : mnTrackY -= mnDockTop;
323 : 0 : mnTrackWidth += mnDockLeft+mnDockRight;
324 : 0 : mnTrackHeight += mnDockTop+mnDockBottom;
325 : : }
326 : :
327 [ # # ][ # # ]: 0 : if ( GetSettings().GetStyleSettings().GetDragFullOptions() & DRAGFULL_OPTION_DOCKING &&
[ # # ]
328 : 0 : !( mnFloatBits & ( WB_MOVEABLE | WB_SIZEABLE | WB_CLOSEABLE ) ) ) // no full drag when migrating to system window
329 : 0 : mbDragFull = sal_True;
330 : : else
331 : : {
332 [ # # ]: 0 : StartDocking();
333 : 0 : mbDragFull = sal_False;
334 [ # # ]: 0 : ImplUpdateAll();
335 [ # # ][ # # ]: 0 : ImplGetFrameWindow()->ImplUpdateAll();
336 : : }
337 : :
338 [ # # ]: 0 : StartTracking( STARTTRACK_KEYMOD );
339 : 0 : return sal_True;
340 : : }
341 : :
342 : : // =======================================================================
343 : :
344 : 24256 : void DockingWindow::ImplInitDockingWindowData()
345 : : {
346 [ + - ]: 24256 : mpImplData = new ImplData;
347 : 24256 : mpWindowImpl->mbDockWin = sal_True;
348 : :
349 : 24256 : mpFloatWin = NULL;
350 : 24256 : mbDockCanceled = sal_False;
351 : 24256 : mbDockPrevented = sal_False;
352 : 24256 : mbFloatPrevented = sal_False;
353 : 24256 : mbDocking = sal_False;
354 : 24256 : mbPined = sal_False;
355 : 24256 : mbRollUp = sal_False;
356 : 24256 : mbDockBtn = sal_False;
357 : 24256 : mbHideBtn = sal_False;
358 : 24256 : }
359 : :
360 : : // -----------------------------------------------------------------------
361 : :
362 : 24256 : void DockingWindow::ImplInit( Window* pParent, WinBits nStyle )
363 : : {
364 [ + - ]: 24256 : if ( !(nStyle & WB_NODIALOGCONTROL) )
365 : 24256 : nStyle |= WB_DIALOGCONTROL;
366 : :
367 : 24256 : mpImplData->mpParent = pParent;
368 : 24256 : mbDockable = (nStyle & WB_DOCKABLE) != 0;
369 : 24256 : mnFloatBits = WB_BORDER | (nStyle & DOCKWIN_FLOATSTYLES);
370 : 24256 : nStyle &= ~(DOCKWIN_FLOATSTYLES | WB_BORDER);
371 [ - + ]: 24256 : if ( nStyle & WB_DOCKBORDER )
372 : 0 : nStyle |= WB_BORDER;
373 : :
374 : 24256 : Window::ImplInit( pParent, nStyle, NULL );
375 : :
376 : 24256 : ImplInitSettings();
377 : 24256 : }
378 : :
379 : : // -----------------------------------------------------------------------
380 : :
381 : 24430 : void DockingWindow::ImplInitSettings()
382 : : {
383 : : // Hack, damit man auch DockingWindows ohne Hintergrund bauen kann
384 : : // und noch nicht alles umgestellt ist
385 [ + - ]: 24430 : if ( IsBackground() )
386 : : {
387 : 24430 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
388 : :
389 : 24430 : Color aColor;
390 [ - + ][ + - ]: 24430 : if ( IsControlBackground() )
391 [ # # ]: 0 : aColor = GetControlBackground();
392 [ + - ][ + + ]: 24430 : else if ( Window::GetStyle() & WB_3DLOOK )
393 : 21012 : aColor = rStyleSettings.GetFaceColor();
394 : : else
395 : 3418 : aColor = rStyleSettings.GetWindowColor();
396 [ + - ][ + - ]: 24430 : SetBackground( aColor );
[ + - ]
397 : : }
398 : 24430 : }
399 : :
400 : : // -----------------------------------------------------------------------
401 : :
402 : 770 : void DockingWindow::ImplLoadRes( const ResId& rResId )
403 : : {
404 : 770 : Window::ImplLoadRes( rResId );
405 : :
406 : 770 : sal_uLong nMask = ReadLongRes();
407 : :
408 [ - + ]: 770 : if ( (RSC_DOCKINGWINDOW_XYMAPMODE | RSC_DOCKINGWINDOW_X |
409 : : RSC_DOCKINGWINDOW_Y) & nMask )
410 : : {
411 : : // Groessenangabe aus der Resource verwenden
412 : 0 : Point aPos;
413 : 0 : MapUnit ePosMap = MAP_PIXEL;
414 : :
415 [ # # ]: 0 : if ( RSC_DOCKINGWINDOW_XYMAPMODE & nMask )
416 [ # # ]: 0 : ePosMap = (MapUnit)ReadLongRes();
417 : :
418 [ # # ]: 0 : if ( RSC_DOCKINGWINDOW_X & nMask )
419 : : {
420 [ # # ]: 0 : aPos.X() = ReadShortRes();
421 [ # # ]: 0 : aPos.X() = ImplLogicUnitToPixelX( aPos.X(), ePosMap );
422 : : }
423 : :
424 [ # # ]: 0 : if ( RSC_DOCKINGWINDOW_Y & nMask )
425 : : {
426 [ # # ]: 0 : aPos.Y() = ReadShortRes();
427 [ # # ]: 0 : aPos.Y() = ImplLogicUnitToPixelY( aPos.Y(), ePosMap );
428 : : }
429 : :
430 [ # # ]: 0 : SetFloatingPos( aPos );
431 : : }
432 : :
433 [ - + ]: 770 : if ( nMask & RSC_DOCKINGWINDOW_FLOATING )
434 : : {
435 [ # # ]: 0 : if ( (sal_Bool)ReadShortRes() )
436 : 0 : SetFloatingMode( sal_True );
437 : : }
438 : 770 : }
439 : :
440 : : // -----------------------------------------------------------------------
441 : :
442 : 23942 : DockingWindow::DockingWindow( WindowType nType ) :
443 : 23942 : Window( nType )
444 : : {
445 [ + - ]: 23942 : ImplInitDockingWindowData();
446 : 23942 : }
447 : :
448 : : // -----------------------------------------------------------------------
449 : :
450 : 4 : DockingWindow::DockingWindow( Window* pParent, WinBits nStyle ) :
451 : 4 : Window( WINDOW_DOCKINGWINDOW )
452 : : {
453 [ + - ]: 4 : ImplInitDockingWindowData();
454 [ + - ]: 4 : ImplInit( pParent, nStyle );
455 : 4 : }
456 : :
457 : : // -----------------------------------------------------------------------
458 : :
459 : 310 : DockingWindow::DockingWindow( Window* pParent, const ResId& rResId ) :
460 : 310 : Window( WINDOW_DOCKINGWINDOW )
461 : : {
462 [ + - ]: 310 : ImplInitDockingWindowData();
463 : 310 : rResId.SetRT( RSC_DOCKINGWINDOW );
464 [ + - ]: 310 : WinBits nStyle = ImplInitRes( rResId );
465 [ + - ]: 310 : ImplInit( pParent, nStyle );
466 [ + - ]: 310 : ImplLoadRes( rResId );
467 : :
468 [ + + ]: 310 : if ( !(nStyle & WB_HIDE) )
469 [ + - ]: 34 : Show();
470 : 310 : }
471 : :
472 : : // -----------------------------------------------------------------------
473 : :
474 : 23251 : DockingWindow::~DockingWindow()
475 : : {
476 [ + - ][ - + ]: 23251 : if ( IsFloatingMode() )
477 : : {
478 [ # # ]: 0 : Show( sal_False, SHOW_NOFOCUSCHANGE );
479 [ # # ]: 0 : SetFloatingMode( sal_False );
480 : : }
481 [ + - ][ + - ]: 23251 : delete mpImplData;
482 [ - + ]: 23253 : }
483 : :
484 : : // -----------------------------------------------------------------------
485 : :
486 : 0 : void DockingWindow::Tracking( const TrackingEvent& rTEvt )
487 : : {
488 [ # # ]: 0 : if( GetDockingManager()->IsDockable( this ) ) // new docking interface
489 : 0 : return Window::Tracking( rTEvt );
490 : :
491 [ # # ]: 0 : if ( mbDocking )
492 : : {
493 [ # # ]: 0 : if ( rTEvt.IsTrackingEnded() )
494 : : {
495 : 0 : mbDocking = sal_False;
496 [ # # ]: 0 : if ( mbDragFull )
497 : : {
498 : : // Bei Abbruch alten Zustand wieder herstellen
499 [ # # ]: 0 : if ( rTEvt.IsTrackingCanceled() )
500 : : {
501 [ # # ]: 0 : StartDocking();
502 [ # # ]: 0 : Rectangle aRect( Point( mnTrackX, mnTrackY ), Size( mnTrackWidth, mnTrackHeight ) );
503 [ # # ]: 0 : EndDocking( aRect, mbStartFloat );
504 : : }
505 : : }
506 : : else
507 : : {
508 : 0 : HideTracking();
509 [ # # ]: 0 : if ( rTEvt.IsTrackingCanceled() )
510 : : {
511 : 0 : mbDockCanceled = sal_True;
512 [ # # ][ # # ]: 0 : EndDocking( Rectangle( Point( mnTrackX, mnTrackY ), Size( mnTrackWidth, mnTrackHeight ) ), mbLastFloatMode );
513 : 0 : mbDockCanceled = sal_False;
514 : : }
515 : : else
516 [ # # ][ # # ]: 0 : EndDocking( Rectangle( Point( mnTrackX, mnTrackY ), Size( mnTrackWidth, mnTrackHeight ) ), mbLastFloatMode );
517 : : }
518 : : }
519 : : // Docking nur bei nicht synthetischen MouseEvents
520 [ # # ][ # # ]: 0 : else if ( !rTEvt.GetMouseEvent().IsSynthetic() || rTEvt.GetMouseEvent().IsModifierChanged() )
[ # # ]
521 : : {
522 : 0 : Point aMousePos = rTEvt.GetMouseEvent().GetPosPixel();
523 [ # # ]: 0 : Point aFrameMousePos = ImplOutputToFrame( aMousePos );
524 : 0 : Size aFrameSize = mpWindowImpl->mpFrameWindow->GetOutputSizePixel();
525 [ # # ]: 0 : if ( aFrameMousePos.X() < 0 )
526 : 0 : aFrameMousePos.X() = 0;
527 [ # # ]: 0 : if ( aFrameMousePos.Y() < 0 )
528 : 0 : aFrameMousePos.Y() = 0;
529 [ # # ]: 0 : if ( aFrameMousePos.X() > aFrameSize.Width()-1 )
530 : 0 : aFrameMousePos.X() = aFrameSize.Width()-1;
531 [ # # ]: 0 : if ( aFrameMousePos.Y() > aFrameSize.Height()-1 )
532 : 0 : aFrameMousePos.Y() = aFrameSize.Height()-1;
533 [ # # ]: 0 : aMousePos = ImplFrameToOutput( aFrameMousePos );
534 : 0 : aMousePos.X() -= maMouseOff.X();
535 : 0 : aMousePos.Y() -= maMouseOff.Y();
536 [ # # ]: 0 : Point aFramePos = ImplOutputToFrame( aMousePos );
537 [ # # ]: 0 : Rectangle aTrackRect( aFramePos, Size( mnTrackWidth, mnTrackHeight ) );
538 : 0 : Rectangle aCompRect = aTrackRect;
539 : 0 : aFramePos.X() += maMouseOff.X();
540 : 0 : aFramePos.Y() += maMouseOff.Y();
541 [ # # ]: 0 : if ( mbDragFull )
542 [ # # ]: 0 : StartDocking();
543 [ # # ]: 0 : sal_Bool bFloatMode = Docking( aFramePos, aTrackRect );
544 : 0 : mbDockPrevented = sal_False;
545 : 0 : mbFloatPrevented = sal_False;
546 [ # # ]: 0 : if ( mbLastFloatMode != bFloatMode )
547 : : {
548 [ # # ]: 0 : if ( bFloatMode )
549 : : {
550 : 0 : aTrackRect.Left() -= mnDockLeft;
551 : 0 : aTrackRect.Top() -= mnDockTop;
552 : 0 : aTrackRect.Right() += mnDockRight;
553 : 0 : aTrackRect.Bottom() += mnDockBottom;
554 : : }
555 : : else
556 : : {
557 [ # # ][ # # ]: 0 : if ( aCompRect == aTrackRect )
558 : : {
559 : 0 : aTrackRect.Left() += mnDockLeft;
560 : 0 : aTrackRect.Top() += mnDockTop;
561 : 0 : aTrackRect.Right() -= mnDockRight;
562 : 0 : aTrackRect.Bottom() -= mnDockBottom;
563 : : }
564 : : }
565 : 0 : mbLastFloatMode = bFloatMode;
566 : : }
567 [ # # ]: 0 : if ( mbDragFull )
568 : : {
569 : 0 : Point aPos;
570 [ # # ]: 0 : Point aOldPos = OutputToScreenPixel( aPos );
571 [ # # ]: 0 : EndDocking( aTrackRect, mbLastFloatMode );
572 : : // Wenn der Status bzw. die Position sich
573 : : // geaendert hat, dann neu ausgeben
574 [ # # ][ # # ]: 0 : if ( aOldPos != OutputToScreenPixel( aPos ) )
575 : : {
576 [ # # ]: 0 : ImplUpdateAll();
577 [ # # ][ # # ]: 0 : ImplGetFrameWindow()->ImplUpdateAll();
578 : : }
579 : : // EndDocking( aTrackRect, mbLastFloatMode );
580 : : }
581 : : else
582 : : {
583 : : sal_uInt16 nTrackStyle;
584 [ # # ]: 0 : if ( bFloatMode )
585 : 0 : nTrackStyle = SHOWTRACK_BIG;
586 : : else
587 : 0 : nTrackStyle = SHOWTRACK_OBJECT;
588 : 0 : Rectangle aShowTrackRect = aTrackRect;
589 [ # # ]: 0 : aShowTrackRect.SetPos( ImplFrameToOutput( aShowTrackRect.TopLeft() ) );
590 [ # # ]: 0 : ShowTracking( aShowTrackRect, nTrackStyle );
591 : :
592 : : // Maus-Offset neu berechnen, da Rechteck veraendert werden
593 : : // konnte
594 : 0 : maMouseOff.X() = aFramePos.X() - aTrackRect.Left();
595 : 0 : maMouseOff.Y() = aFramePos.Y() - aTrackRect.Top();
596 : : }
597 : :
598 : 0 : mnTrackX = aTrackRect.Left();
599 : 0 : mnTrackY = aTrackRect.Top();
600 [ # # ]: 0 : mnTrackWidth = aTrackRect.GetWidth();
601 [ # # ]: 0 : mnTrackHeight = aTrackRect.GetHeight();
602 : : }
603 : : }
604 : : }
605 : :
606 : : // -----------------------------------------------------------------------
607 : :
608 : 21641 : long DockingWindow::Notify( NotifyEvent& rNEvt )
609 : : {
610 [ + + ]: 21641 : if( GetDockingManager()->IsDockable( this ) ) // new docking interface
611 : 14280 : return Window::Notify( rNEvt );
612 : :
613 [ + + ]: 7361 : if ( mbDockable )
614 : : {
615 [ - + ]: 2298 : if ( rNEvt.GetType() == EVENT_MOUSEBUTTONDOWN )
616 : : {
617 : 0 : const MouseEvent* pMEvt = rNEvt.GetMouseEvent();
618 [ # # ]: 0 : if ( pMEvt->IsLeft() )
619 : : {
620 [ # # ][ # # ]: 0 : if ( pMEvt->IsMod1() && (pMEvt->GetClicks() == 2) )
[ # # ]
621 : : {
622 : 0 : SetFloatingMode( !IsFloatingMode() );
623 : 0 : return sal_True;
624 : : }
625 [ # # ]: 0 : else if ( pMEvt->GetClicks() == 1 )
626 : : {
627 : : // check if window is floating standalone (IsFloating())
628 : : // or only partially floating and still docked with one border
629 : : // ( !mpWindowImpl->mbFrame)
630 [ # # ][ # # ]: 0 : if( ! IsFloatingMode() || ! mpFloatWin->mpWindowImpl->mbFrame )
[ # # ]
631 : : {
632 : 0 : Point aPos = pMEvt->GetPosPixel();
633 : 0 : Window* pWindow = rNEvt.GetWindow();
634 [ # # ]: 0 : if ( pWindow != this )
635 : : {
636 [ # # ]: 0 : aPos = pWindow->OutputToScreenPixel( aPos );
637 [ # # ]: 0 : aPos = ScreenToOutputPixel( aPos );
638 : : }
639 [ # # ]: 0 : ImplStartDocking( aPos );
640 : : }
641 : 0 : return sal_True;
642 : : }
643 : : }
644 : : }
645 [ - + ]: 2298 : else if( rNEvt.GetType() == EVENT_KEYINPUT )
646 : : {
647 : 0 : const KeyCode& rKey = rNEvt.GetKeyEvent()->GetKeyCode();
648 [ # # # # : 0 : if( rKey.GetCode() == KEY_F10 && rKey.GetModifier() &&
# # ][ # # ]
[ # # ]
649 : 0 : rKey.IsShift() && rKey.IsMod1() )
650 : : {
651 : 0 : SetFloatingMode( !IsFloatingMode() );
652 : 0 : return sal_True;
653 : : }
654 : : }
655 : : }
656 : :
657 : 21641 : return Window::Notify( rNEvt );
658 : : }
659 : :
660 : : // -----------------------------------------------------------------------
661 : :
662 : 0 : void DockingWindow::StartDocking()
663 : : {
664 : 0 : mbDocking = sal_True;
665 : 0 : }
666 : :
667 : : // -----------------------------------------------------------------------
668 : :
669 : 0 : sal_Bool DockingWindow::Docking( const Point&, Rectangle& )
670 : : {
671 : 0 : return IsFloatingMode();
672 : : }
673 : :
674 : : // -----------------------------------------------------------------------
675 : :
676 : 0 : void DockingWindow::EndDocking( const Rectangle& rRect, sal_Bool bFloatMode )
677 : : {
678 [ # # ]: 0 : if ( !IsDockingCanceled() )
679 : : {
680 : 0 : sal_Bool bShow = sal_False;
681 [ # # ]: 0 : if ( bFloatMode != IsFloatingMode() )
682 : : {
683 : 0 : Show( sal_False, SHOW_NOFOCUSCHANGE );
684 : 0 : SetFloatingMode( bFloatMode );
685 : 0 : bShow = sal_True;
686 [ # # ][ # # ]: 0 : if ( bFloatMode && mpFloatWin )
687 [ # # ]: 0 : mpFloatWin->SetPosSizePixel( rRect.TopLeft(), rRect.GetSize() );
688 : : }
689 [ # # ]: 0 : if ( !bFloatMode )
690 : : {
691 : 0 : Point aPos = rRect.TopLeft();
692 [ # # ][ # # ]: 0 : aPos = GetParent()->ScreenToOutputPixel( aPos );
693 [ # # ][ # # ]: 0 : Window::SetPosSizePixel( aPos, rRect.GetSize() );
694 : : }
695 : :
696 [ # # ]: 0 : if ( bShow )
697 : 0 : Show();
698 : : }
699 : 0 : mbDocking = sal_False;
700 : 0 : }
701 : :
702 : : // -----------------------------------------------------------------------
703 : :
704 : 0 : sal_Bool DockingWindow::PrepareToggleFloatingMode()
705 : : {
706 : 0 : return sal_True;
707 : : }
708 : :
709 : : // -----------------------------------------------------------------------
710 : :
711 : 0 : sal_Bool DockingWindow::Close()
712 : : {
713 [ # # ]: 0 : ImplDelData aDelData;
714 [ # # ]: 0 : ImplAddDel( &aDelData );
715 [ # # ]: 0 : ImplCallEventListeners( VCLEVENT_WINDOW_CLOSE );
716 [ # # ]: 0 : if ( aDelData.IsDead() )
717 : 0 : return sal_False;
718 [ # # ]: 0 : ImplRemoveDel( &aDelData );
719 : :
720 [ # # ][ # # ]: 0 : if ( mpWindowImpl->mxWindowPeer.is() && IsCreatedWithToolkit() )
[ # # ][ # # ]
721 : 0 : return sal_False;
722 : :
723 [ # # ]: 0 : Show( sal_False, SHOW_NOFOCUSCHANGE );
724 [ # # ]: 0 : return sal_True;
725 : : }
726 : :
727 : : // -----------------------------------------------------------------------
728 : :
729 : 0 : void DockingWindow::ToggleFloatingMode()
730 : : {
731 : 0 : }
732 : :
733 : : // -----------------------------------------------------------------------
734 : :
735 : 0 : void DockingWindow::TitleButtonClick( sal_uInt16 )
736 : : {
737 : 0 : }
738 : :
739 : : // -----------------------------------------------------------------------
740 : :
741 : 0 : void DockingWindow::Pin()
742 : : {
743 : 0 : }
744 : :
745 : : // -----------------------------------------------------------------------
746 : :
747 : 0 : void DockingWindow::Roll()
748 : : {
749 : 0 : }
750 : :
751 : : // -----------------------------------------------------------------------
752 : :
753 : 0 : void DockingWindow::PopupModeEnd()
754 : : {
755 : 0 : }
756 : :
757 : : // -----------------------------------------------------------------------
758 : :
759 : 0 : void DockingWindow::Resizing( Size& )
760 : : {
761 : 0 : }
762 : :
763 : : // -----------------------------------------------------------------------
764 : :
765 : 33934 : void DockingWindow::StateChanged( StateChangedType nType )
766 : : {
767 [ - + ]: 33934 : if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
768 : : {
769 : 0 : ImplInitSettings();
770 : 0 : Invalidate();
771 : : }
772 : :
773 : 33934 : Window::StateChanged( nType );
774 : 33934 : }
775 : :
776 : : // -----------------------------------------------------------------------
777 : :
778 : 322 : void DockingWindow::DataChanged( const DataChangedEvent& rDCEvt )
779 : : {
780 [ + - + + ]: 644 : if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
[ + + ]
781 : 322 : (rDCEvt.GetFlags() & SETTINGS_STYLE) )
782 : : {
783 : 174 : ImplInitSettings();
784 : 174 : Invalidate();
785 : : }
786 : : else
787 : 148 : Window::DataChanged( rDCEvt );
788 : 322 : }
789 : :
790 : : // -----------------------------------------------------------------------
791 : :
792 : 0 : void DockingWindow::SetFloatingMode( sal_Bool bFloatMode )
793 : : {
794 : 0 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
795 [ # # ]: 0 : if( pWrapper )
796 : : {
797 : 0 : pWrapper->SetFloatingMode( bFloatMode );
798 : 0 : return;
799 : : }
800 [ # # ]: 0 : if ( IsFloatingMode() != bFloatMode )
801 : : {
802 [ # # ]: 0 : if ( PrepareToggleFloatingMode() ) // changes to floating mode can be vetoed
803 : : {
804 : 0 : sal_Bool bVisible = IsVisible();
805 : :
806 [ # # ]: 0 : if ( bFloatMode )
807 : : {
808 : 0 : Show( sal_False, SHOW_NOFOCUSCHANGE );
809 : :
810 : 0 : maDockPos = Window::GetPosPixel();
811 : :
812 : 0 : Window* pRealParent = mpWindowImpl->mpRealParent;
813 : 0 : mpOldBorderWin = mpWindowImpl->mpBorderWindow;
814 : :
815 : : ImplDockFloatWin* pWin =
816 : : new ImplDockFloatWin(
817 : : mpImplData->mpParent,
818 : : mnFloatBits & ( WB_MOVEABLE | WB_SIZEABLE | WB_CLOSEABLE ) ? mnFloatBits | WB_SYSTEMWINDOW : mnFloatBits,
819 [ # # ][ # # ]: 0 : this );
820 : 0 : mpFloatWin = pWin;
821 : 0 : mpWindowImpl->mpBorderWindow = NULL;
822 : 0 : mpWindowImpl->mnLeftBorder = 0;
823 : 0 : mpWindowImpl->mnTopBorder = 0;
824 : 0 : mpWindowImpl->mnRightBorder = 0;
825 : 0 : mpWindowImpl->mnBottomBorder = 0;
826 : : // Falls Parent zerstoert wird, muessen wir auch vom
827 : : // BorderWindow den Parent umsetzen
828 [ # # ]: 0 : if ( mpOldBorderWin )
829 : 0 : mpOldBorderWin->SetParent( pWin );
830 : 0 : SetParent( pWin );
831 [ # # ]: 0 : SetPosPixel( Point() );
832 : 0 : mpWindowImpl->mpBorderWindow = pWin;
833 : 0 : pWin->mpWindowImpl->mpClientWindow = this;
834 : 0 : mpWindowImpl->mpRealParent = pRealParent;
835 [ # # ]: 0 : pWin->SetText( Window::GetText() );
836 [ # # ]: 0 : pWin->SetOutputSizePixel( Window::GetSizePixel() );
837 : 0 : pWin->SetPosPixel( maFloatPos );
838 : : // DockingDaten ans FloatingWindow weiterreichen
839 : 0 : pWin->ShowTitleButton( TITLE_BUTTON_DOCKING, mbDockBtn );
840 : 0 : pWin->ShowTitleButton( TITLE_BUTTON_HIDE, mbHideBtn );
841 : 0 : pWin->SetPin( mbPined );
842 [ # # ]: 0 : if ( mbRollUp )
843 : 0 : pWin->RollUp();
844 : : else
845 : 0 : pWin->RollDown();
846 : 0 : pWin->SetRollUpOutputSizePixel( maRollUpOutSize );
847 : 0 : pWin->SetMinOutputSizePixel( maMinOutSize );
848 : 0 : pWin->SetMaxOutputSizePixel( mpImplData->maMaxOutSize );
849 : :
850 : 0 : ToggleFloatingMode();
851 : :
852 [ # # ]: 0 : if ( bVisible )
853 : 0 : Show();
854 : : }
855 : : else
856 : : {
857 : 0 : Show( sal_False, SHOW_NOFOCUSCHANGE );
858 : :
859 : : // FloatingDaten wird im FloatingWindow speichern
860 : 0 : maFloatPos = mpFloatWin->GetPosPixel();
861 : 0 : mbDockBtn = mpFloatWin->IsTitleButtonVisible( TITLE_BUTTON_DOCKING );
862 : 0 : mbHideBtn = mpFloatWin->IsTitleButtonVisible( TITLE_BUTTON_HIDE );
863 : 0 : mbPined = mpFloatWin->IsPined();
864 : 0 : mbRollUp = mpFloatWin->IsRollUp();
865 : 0 : maRollUpOutSize = mpFloatWin->GetRollUpOutputSizePixel();
866 : 0 : maMinOutSize = mpFloatWin->GetMinOutputSizePixel();
867 : 0 : mpImplData->maMaxOutSize = mpFloatWin->GetMaxOutputSizePixel();
868 : :
869 : 0 : Window* pRealParent = mpWindowImpl->mpRealParent;
870 : 0 : mpWindowImpl->mpBorderWindow = NULL;
871 [ # # ]: 0 : if ( mpOldBorderWin )
872 : : {
873 : 0 : SetParent( mpOldBorderWin );
874 : 0 : ((ImplBorderWindow*)mpOldBorderWin)->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 : delete static_cast<ImplDockFloatWin*>(mpFloatWin);
881 : 0 : mpFloatWin = NULL;
882 : 0 : SetPosPixel( maDockPos );
883 : :
884 : 0 : ToggleFloatingMode();
885 : :
886 [ # # ]: 0 : if ( bVisible )
887 : 0 : Show();
888 : : }
889 : : }
890 : : }
891 : : }
892 : :
893 : : // -----------------------------------------------------------------------
894 : :
895 : 18 : void DockingWindow::SetFloatStyle( WinBits nStyle )
896 : : {
897 : 18 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
898 [ + - ]: 18 : if( pWrapper )
899 : : {
900 : 18 : pWrapper->SetFloatStyle( nStyle );
901 : 18 : return;
902 : : }
903 : :
904 : 0 : mnFloatBits = nStyle;
905 : : }
906 : :
907 : : // -----------------------------------------------------------------------
908 : :
909 : 6157 : WinBits DockingWindow::GetFloatStyle() const
910 : : {
911 : 6157 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
912 [ + + ]: 6157 : if( pWrapper )
913 : : {
914 : 18 : return pWrapper->GetFloatStyle();
915 : : }
916 : :
917 : 6157 : return mnFloatBits;
918 : : }
919 : :
920 : : // -----------------------------------------------------------------------
921 : :
922 : 36285 : void DockingWindow::SetPosSizePixel( long nX, long nY,
923 : : long nWidth, long nHeight,
924 : : sal_uInt16 nFlags )
925 : : {
926 : 36285 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
927 [ + + ]: 36285 : if( pWrapper )
928 : : {
929 [ - + ]: 16114 : if ( pWrapper->mpFloatWin )
930 : 0 : pWrapper->mpFloatWin->SetPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
931 : : else
932 : 16114 : Window::SetPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
933 : 36285 : return;
934 : : }
935 : :
936 [ - + ]: 20171 : if ( mpFloatWin )
937 : 0 : mpFloatWin->SetPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
938 : : else
939 : 20171 : Window::SetPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
940 : : }
941 : :
942 : : // -----------------------------------------------------------------------
943 : :
944 : 35807 : Point DockingWindow::GetPosPixel() const
945 : : {
946 : 35807 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
947 [ + + ]: 35807 : if( pWrapper )
948 : : {
949 [ - + ]: 33325 : if ( pWrapper->mpFloatWin )
950 : 0 : return pWrapper->mpFloatWin->GetPosPixel();
951 : : else
952 : 33325 : return Window::GetPosPixel();
953 : : }
954 : :
955 [ - + ]: 2482 : if ( mpFloatWin )
956 : 0 : return mpFloatWin->GetPosPixel();
957 : : else
958 : 35807 : return Window::GetPosPixel();
959 : : }
960 : :
961 : : // -----------------------------------------------------------------------
962 : :
963 : 54705 : Size DockingWindow::GetSizePixel() const
964 : : {
965 : 54705 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
966 [ + + ]: 54705 : if( pWrapper )
967 : : {
968 [ - + ]: 33997 : if ( pWrapper->mpFloatWin )
969 : 0 : return pWrapper->mpFloatWin->GetSizePixel();
970 : : else
971 : 33997 : return Window::GetSizePixel();
972 : : }
973 : :
974 [ - + ]: 20708 : if ( mpFloatWin )
975 : 0 : return mpFloatWin->GetSizePixel();
976 : : else
977 : 54705 : return Window::GetSizePixel();
978 : : }
979 : :
980 : : // -----------------------------------------------------------------------
981 : :
982 : 7584 : void DockingWindow::SetOutputSizePixel( const Size& rNewSize )
983 : : {
984 : 7584 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
985 [ + + ]: 7584 : if( pWrapper )
986 : : {
987 [ - + ]: 3721 : if ( pWrapper->mpFloatWin )
988 : 0 : pWrapper->mpFloatWin->SetOutputSizePixel( rNewSize );
989 : : else
990 : 3721 : Window::SetOutputSizePixel( rNewSize );
991 : 7584 : return;
992 : : }
993 : :
994 [ - + ]: 3863 : if ( mpFloatWin )
995 : 0 : mpFloatWin->SetOutputSizePixel( rNewSize );
996 : : else
997 : 3863 : Window::SetOutputSizePixel( rNewSize );
998 : : }
999 : :
1000 : : // -----------------------------------------------------------------------
1001 : :
1002 : 155572 : Size DockingWindow::GetOutputSizePixel() const
1003 : : {
1004 : 155572 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
1005 [ + + ]: 155572 : if( pWrapper )
1006 : : {
1007 [ - + ]: 144972 : if ( pWrapper->mpFloatWin )
1008 : 0 : return pWrapper->mpFloatWin->GetOutputSizePixel();
1009 : : else
1010 : 144972 : return Window::GetOutputSizePixel();
1011 : : }
1012 : :
1013 [ - + ]: 10600 : if ( mpFloatWin )
1014 : 0 : return mpFloatWin->GetOutputSizePixel();
1015 : : else
1016 : 155572 : return Window::GetOutputSizePixel();
1017 : : }
1018 : :
1019 : 312 : Point DockingWindow::GetFloatingPos() const
1020 : : {
1021 : 312 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
1022 [ - + ]: 312 : if( pWrapper )
1023 : : {
1024 [ # # ]: 0 : if ( pWrapper->mpFloatWin )
1025 : : {
1026 : 0 : WindowStateData aData;
1027 : 0 : aData.SetMask( WINDOWSTATE_MASK_POS );
1028 [ # # ]: 0 : pWrapper->mpFloatWin->GetWindowStateData( aData );
1029 : 0 : Point aPos( aData.GetX(), aData.GetY() );
1030 [ # # ][ # # ]: 0 : aPos = pWrapper->mpFloatWin->GetParent()->ImplGetFrameWindow()->AbsoluteScreenToOutputPixel( aPos );
[ # # ]
1031 : 0 : return aPos;
1032 : : }
1033 : : else
1034 : 0 : return maFloatPos;
1035 : : }
1036 : :
1037 [ - + ]: 312 : if ( mpFloatWin )
1038 : : {
1039 : 0 : WindowStateData aData;
1040 : 0 : aData.SetMask( WINDOWSTATE_MASK_POS );
1041 [ # # ]: 0 : mpFloatWin->GetWindowStateData( aData );
1042 : 0 : Point aPos( aData.GetX(), aData.GetY() );
1043 [ # # ][ # # ]: 0 : aPos = mpFloatWin->GetParent()->ImplGetFrameWindow()->AbsoluteScreenToOutputPixel( aPos );
[ # # ]
1044 : 0 : return aPos;
1045 : : }
1046 : : else
1047 : 312 : return maFloatPos;
1048 : : }
1049 : :
1050 : 1156491 : sal_Bool DockingWindow::IsFloatingMode() const
1051 : : {
1052 : 1156491 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
1053 [ + + ]: 1156491 : if( pWrapper )
1054 : 946087 : return pWrapper->IsFloatingMode();
1055 : : else
1056 : 1156491 : return (mpFloatWin != NULL);
1057 : : }
1058 : :
1059 : 0 : void DockingWindow::SetMaxOutputSizePixel( const Size& rSize )
1060 : : {
1061 [ # # ]: 0 : if ( mpFloatWin )
1062 : 0 : mpFloatWin->SetMaxOutputSizePixel( rSize );
1063 : 0 : mpImplData->maMaxOutSize = rSize;
1064 : 0 : }
1065 : :
1066 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
