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 :
21 : #include <tools/time.hxx>
22 : #include <tools/rc.h>
23 : #include <vcl/event.hxx>
24 : #include <vcl/floatwin.hxx>
25 : #include <vcl/dockwin.hxx>
26 : #include <vcl/svapp.hxx>
27 : #include <vcl/timer.hxx>
28 : #include <vcl/unowrap.hxx>
29 :
30 : #include <svdata.hxx>
31 : #include <window.h>
32 : #include <brdwin.hxx>
33 : #include <salframe.hxx>
34 :
35 :
36 :
37 : // =======================================================================
38 :
39 : #define DOCKWIN_FLOATSTYLES (WB_SIZEABLE | WB_MOVEABLE | WB_CLOSEABLE | WB_STANDALONE | WB_PINABLE | WB_ROLLABLE )
40 :
41 : // =======================================================================
42 :
43 : // -----------------------------------------------------------------------
44 :
45 : class DockingWindow::ImplData
46 : {
47 : public:
48 : ImplData();
49 : ~ImplData();
50 :
51 : Window* mpParent;
52 : Size maMaxOutSize;
53 : };
54 :
55 14111 : DockingWindow::ImplData::ImplData()
56 : {
57 14111 : mpParent = NULL;
58 14111 : maMaxOutSize = Size( SHRT_MAX, SHRT_MAX );
59 14111 : }
60 :
61 14047 : DockingWindow::ImplData::~ImplData()
62 : {
63 14047 : }
64 :
65 : // -----------------------------------------------------------------------
66 :
67 : class ImplDockFloatWin : public FloatingWindow
68 : {
69 : private:
70 : DockingWindow* mpDockWin;
71 : sal_uLong mnLastTicks;
72 : Timer maDockTimer;
73 : Point maDockPos;
74 : Rectangle maDockRect;
75 : bool mbInMove;
76 : sal_uLong mnLastUserEvent;
77 :
78 : DECL_LINK(DockingHdl, void *);
79 : DECL_LINK(DockTimerHdl, void *);
80 : public:
81 : ImplDockFloatWin( Window* pParent, WinBits nWinBits,
82 : DockingWindow* pDockingWin );
83 : ~ImplDockFloatWin();
84 :
85 : virtual void Move();
86 : virtual void Resize();
87 : virtual void TitleButtonClick( sal_uInt16 nButton );
88 : virtual void Pin();
89 : virtual void Roll();
90 : virtual void PopupModeEnd();
91 : virtual void Resizing( Size& rSize );
92 : virtual sal_Bool Close();
93 :
94 : sal_uLong GetLastTicks() const { return mnLastTicks; }
95 : };
96 :
97 :
98 0 : ImplDockFloatWin::ImplDockFloatWin( Window* pParent, WinBits nWinBits,
99 : DockingWindow* pDockingWin ) :
100 : FloatingWindow( pParent, nWinBits ),
101 : mpDockWin( pDockingWin ),
102 0 : mnLastTicks( Time::GetSystemTicks() ),
103 : mbInMove( false ),
104 0 : mnLastUserEvent( 0 )
105 : {
106 : // Daten vom DockingWindow uebernehmen
107 0 : if ( pDockingWin )
108 : {
109 0 : SetSettings( pDockingWin->GetSettings() );
110 0 : Enable( pDockingWin->IsEnabled(), sal_False );
111 0 : EnableInput( pDockingWin->IsInputEnabled(), sal_False );
112 0 : AlwaysEnableInput( pDockingWin->IsAlwaysEnableInput(), sal_False );
113 0 : EnableAlwaysOnTop( pDockingWin->IsAlwaysOnTopEnabled() );
114 0 : SetActivateMode( pDockingWin->GetActivateMode() );
115 : }
116 :
117 0 : SetBackground();
118 :
119 0 : maDockTimer.SetTimeoutHdl( LINK( this, ImplDockFloatWin, DockTimerHdl ) );
120 0 : maDockTimer.SetTimeout( 50 );
121 0 : }
122 :
123 : // -----------------------------------------------------------------------
124 :
125 0 : ImplDockFloatWin::~ImplDockFloatWin()
126 : {
127 0 : if( mnLastUserEvent )
128 0 : Application::RemoveUserEvent( mnLastUserEvent );
129 0 : }
130 :
131 : // -----------------------------------------------------------------------
132 :
133 0 : IMPL_LINK_NOARG(ImplDockFloatWin, DockTimerHdl)
134 : {
135 : DBG_ASSERT( mpDockWin->IsFloatingMode(), "docktimer called but not floating" );
136 :
137 0 : maDockTimer.Stop();
138 0 : PointerState aState = GetPointerState();
139 :
140 0 : if( aState.mnState & KEY_MOD1 )
141 : {
142 : // i43499 CTRL disables docking now
143 0 : mpDockWin->GetParent()->ImplGetFrameWindow()->HideTracking();
144 0 : mpDockWin->EndDocking( maDockRect, sal_True );
145 0 : if( aState.mnState & ( MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT ) )
146 0 : maDockTimer.Start();
147 : }
148 0 : else if( ! ( aState.mnState & ( MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT ) ) )
149 : {
150 0 : mpDockWin->GetParent()->ImplGetFrameWindow()->HideTracking();
151 0 : mpDockWin->EndDocking( maDockRect, sal_False );
152 : }
153 : else
154 : {
155 0 : mpDockWin->GetParent()->ImplGetFrameWindow()->ShowTracking( maDockRect, SHOWTRACK_BIG | SHOWTRACK_WINDOW );
156 0 : maDockTimer.Start();
157 : }
158 :
159 0 : return 0;
160 : }
161 :
162 0 : IMPL_LINK_NOARG(ImplDockFloatWin, DockingHdl)
163 : {
164 0 : PointerState aState = mpDockWin->GetParent()->GetPointerState();
165 :
166 0 : mnLastUserEvent = 0;
167 0 : if( mpDockWin->IsDockable() &&
168 0 : (Time::GetSystemTicks() - mnLastTicks > 500) &&
169 0 : ( aState.mnState & ( MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT ) ) &&
170 0 : !(aState.mnState & KEY_MOD1) ) // i43499 CTRL disables docking now
171 : {
172 0 : maDockPos = Point( mpDockWin->GetParent()->AbsoluteScreenToOutputPixel( OutputToAbsoluteScreenPixel( Point() ) ) );
173 0 : maDockPos = mpDockWin->GetParent()->OutputToScreenPixel( maDockPos ); // sfx expects screen coordinates
174 :
175 0 : if( ! mpDockWin->IsDocking() )
176 0 : mpDockWin->StartDocking();
177 0 : maDockRect = Rectangle( maDockPos, mpDockWin->GetSizePixel() );
178 :
179 : // mouse pos also in screen pixels
180 0 : Point aMousePos = mpDockWin->GetParent()->OutputToScreenPixel( aState.maPos );
181 :
182 0 : sal_Bool bFloatMode = mpDockWin->Docking( aMousePos, maDockRect );
183 0 : if( ! bFloatMode )
184 : {
185 0 : mpDockWin->GetParent()->ImplGetFrameWindow()->ShowTracking( maDockRect, SHOWTRACK_OBJECT | SHOWTRACK_WINDOW );
186 0 : DockTimerHdl( this );
187 : }
188 : else
189 : {
190 0 : mpDockWin->GetParent()->ImplGetFrameWindow()->HideTracking();
191 0 : maDockTimer.Stop();
192 0 : mpDockWin->EndDocking( maDockRect, sal_True );
193 : }
194 : }
195 0 : mbInMove = false;
196 0 : return 0;
197 : }
198 : // -----------------------------------------------------------------------
199 :
200 0 : void ImplDockFloatWin::Move()
201 : {
202 0 : if( mbInMove )
203 0 : return;
204 :
205 0 : mbInMove = true;
206 0 : FloatingWindow::Move();
207 0 : mpDockWin->Move();
208 :
209 : /*
210 : * note: the window should only dock if
211 : * the user releases all mouse buttons. The real problem here
212 : * is that we don't get mouse events (at least not on X)
213 : * if the mouse is on the decoration. So we have to start an
214 : * awkward timer based process that polls the modifier/buttons
215 : * to see whether they are in the right condition shortly after the
216 : * last Move message.
217 : */
218 0 : if( ! mnLastUserEvent )
219 0 : mnLastUserEvent = Application::PostUserEvent( LINK( this, ImplDockFloatWin, DockingHdl ) );
220 : }
221 :
222 : // -----------------------------------------------------------------------
223 :
224 0 : void ImplDockFloatWin::Resize()
225 : {
226 0 : FloatingWindow::Resize();
227 0 : Size aSize( GetSizePixel() );
228 0 : mpDockWin->ImplPosSizeWindow( 0, 0, aSize.Width(), aSize.Height(), WINDOW_POSSIZE_POSSIZE );
229 0 : }
230 :
231 : // -----------------------------------------------------------------------
232 :
233 0 : void ImplDockFloatWin::TitleButtonClick( sal_uInt16 nButton )
234 : {
235 0 : FloatingWindow::TitleButtonClick( nButton );
236 0 : mpDockWin->TitleButtonClick( nButton );
237 0 : }
238 :
239 : // -----------------------------------------------------------------------
240 :
241 0 : void ImplDockFloatWin::Pin()
242 : {
243 0 : FloatingWindow::Pin();
244 0 : mpDockWin->Pin();
245 0 : }
246 :
247 : // -----------------------------------------------------------------------
248 :
249 0 : void ImplDockFloatWin::Roll()
250 : {
251 0 : FloatingWindow::Roll();
252 0 : mpDockWin->Roll();
253 0 : }
254 :
255 : // -----------------------------------------------------------------------
256 :
257 0 : void ImplDockFloatWin::PopupModeEnd()
258 : {
259 0 : FloatingWindow::PopupModeEnd();
260 0 : mpDockWin->PopupModeEnd();
261 0 : }
262 :
263 : // -----------------------------------------------------------------------
264 :
265 0 : void ImplDockFloatWin::Resizing( Size& rSize )
266 : {
267 0 : FloatingWindow::Resizing( rSize );
268 0 : mpDockWin->Resizing( rSize );
269 0 : }
270 :
271 : // -----------------------------------------------------------------------
272 :
273 0 : sal_Bool ImplDockFloatWin::Close()
274 : {
275 0 : return mpDockWin->Close();
276 : }
277 :
278 : // =======================================================================
279 :
280 0 : sal_Bool DockingWindow::ImplStartDocking( const Point& rPos )
281 : {
282 0 : if ( !mbDockable )
283 0 : return sal_False;
284 :
285 0 : maMouseOff = rPos;
286 0 : maMouseStart = maMouseOff;
287 0 : mbDocking = sal_True;
288 0 : mbLastFloatMode = IsFloatingMode();
289 0 : mbStartFloat = mbLastFloatMode;
290 :
291 : // FloatingBorder berechnen
292 : FloatingWindow* pWin;
293 0 : if ( mpFloatWin )
294 0 : pWin = mpFloatWin;
295 : else
296 0 : pWin = new ImplDockFloatWin( mpImplData->mpParent, mnFloatBits, NULL );
297 0 : pWin->GetBorder( mnDockLeft, mnDockTop, mnDockRight, mnDockBottom );
298 0 : if ( !mpFloatWin )
299 0 : delete pWin;
300 :
301 0 : Point aPos = ImplOutputToFrame( Point() );
302 0 : Size aSize = Window::GetOutputSizePixel();
303 0 : mnTrackX = aPos.X();
304 0 : mnTrackY = aPos.Y();
305 0 : mnTrackWidth = aSize.Width();
306 0 : mnTrackHeight = aSize.Height();
307 :
308 0 : if ( mbLastFloatMode )
309 : {
310 0 : maMouseOff.X() += mnDockLeft;
311 0 : maMouseOff.Y() += mnDockTop;
312 0 : mnTrackX -= mnDockLeft;
313 0 : mnTrackY -= mnDockTop;
314 0 : mnTrackWidth += mnDockLeft+mnDockRight;
315 0 : mnTrackHeight += mnDockTop+mnDockBottom;
316 : }
317 :
318 0 : if ( GetSettings().GetStyleSettings().GetDragFullOptions() & DRAGFULL_OPTION_DOCKING &&
319 0 : !( mnFloatBits & ( WB_MOVEABLE | WB_SIZEABLE | WB_CLOSEABLE ) ) ) // no full drag when migrating to system window
320 0 : mbDragFull = sal_True;
321 : else
322 : {
323 0 : StartDocking();
324 0 : mbDragFull = sal_False;
325 0 : ImplUpdateAll();
326 0 : ImplGetFrameWindow()->ImplUpdateAll();
327 : }
328 :
329 0 : StartTracking( STARTTRACK_KEYMOD );
330 0 : return sal_True;
331 : }
332 :
333 : // =======================================================================
334 :
335 14111 : void DockingWindow::ImplInitDockingWindowData()
336 : {
337 14111 : mpImplData = new ImplData;
338 14111 : mpWindowImpl->mbDockWin = sal_True;
339 :
340 14111 : mpFloatWin = NULL;
341 14111 : mbDockCanceled = sal_False;
342 14111 : mbDockPrevented = sal_False;
343 14111 : mbFloatPrevented = sal_False;
344 14111 : mbDocking = sal_False;
345 14111 : mbPined = sal_False;
346 14111 : mbRollUp = sal_False;
347 14111 : mbDockBtn = sal_False;
348 14111 : mbHideBtn = sal_False;
349 14111 : }
350 :
351 : // -----------------------------------------------------------------------
352 :
353 14111 : void DockingWindow::ImplInit( Window* pParent, WinBits nStyle )
354 : {
355 14111 : if ( !(nStyle & WB_NODIALOGCONTROL) )
356 14111 : nStyle |= WB_DIALOGCONTROL;
357 :
358 14111 : mpImplData->mpParent = pParent;
359 14111 : mbDockable = (nStyle & WB_DOCKABLE) != 0;
360 14111 : mnFloatBits = WB_BORDER | (nStyle & DOCKWIN_FLOATSTYLES);
361 14111 : nStyle &= ~(DOCKWIN_FLOATSTYLES | WB_BORDER);
362 14111 : if ( nStyle & WB_DOCKBORDER )
363 0 : nStyle |= WB_BORDER;
364 :
365 14111 : Window::ImplInit( pParent, nStyle, NULL );
366 :
367 14111 : ImplInitSettings();
368 14111 : }
369 :
370 : // -----------------------------------------------------------------------
371 :
372 14201 : void DockingWindow::ImplInitSettings()
373 : {
374 : // Hack, damit man auch DockingWindows ohne Hintergrund bauen kann
375 : // und noch nicht alles umgestellt ist
376 14201 : if ( IsBackground() )
377 : {
378 14201 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
379 :
380 14201 : Color aColor;
381 14201 : if ( IsControlBackground() )
382 0 : aColor = GetControlBackground();
383 14201 : else if ( Window::GetStyle() & WB_3DLOOK )
384 12055 : aColor = rStyleSettings.GetFaceColor();
385 : else
386 2146 : aColor = rStyleSettings.GetWindowColor();
387 14201 : SetBackground( aColor );
388 : }
389 14201 : }
390 :
391 : // -----------------------------------------------------------------------
392 :
393 406 : void DockingWindow::ImplLoadRes( const ResId& rResId )
394 : {
395 406 : Window::ImplLoadRes( rResId );
396 :
397 406 : sal_uLong nMask = ReadLongRes();
398 :
399 406 : if ( (RSC_DOCKINGWINDOW_XYMAPMODE | RSC_DOCKINGWINDOW_X |
400 406 : RSC_DOCKINGWINDOW_Y) & nMask )
401 : {
402 : // Groessenangabe aus der Resource verwenden
403 0 : Point aPos;
404 0 : MapUnit ePosMap = MAP_PIXEL;
405 :
406 0 : if ( RSC_DOCKINGWINDOW_XYMAPMODE & nMask )
407 0 : ePosMap = (MapUnit)ReadLongRes();
408 :
409 0 : if ( RSC_DOCKINGWINDOW_X & nMask )
410 : {
411 0 : aPos.X() = ReadShortRes();
412 0 : aPos.X() = ImplLogicUnitToPixelX( aPos.X(), ePosMap );
413 : }
414 :
415 0 : if ( RSC_DOCKINGWINDOW_Y & nMask )
416 : {
417 0 : aPos.Y() = ReadShortRes();
418 0 : aPos.Y() = ImplLogicUnitToPixelY( aPos.Y(), ePosMap );
419 : }
420 :
421 0 : SetFloatingPos( aPos );
422 : }
423 :
424 406 : if ( nMask & RSC_DOCKINGWINDOW_FLOATING )
425 : {
426 0 : if ( (sal_Bool)ReadShortRes() )
427 0 : SetFloatingMode( sal_True );
428 : }
429 406 : }
430 :
431 : // -----------------------------------------------------------------------
432 :
433 13933 : DockingWindow::DockingWindow( WindowType nType ) :
434 13933 : Window( nType )
435 : {
436 13933 : ImplInitDockingWindowData();
437 13933 : }
438 :
439 : // -----------------------------------------------------------------------
440 :
441 2 : DockingWindow::DockingWindow( Window* pParent, WinBits nStyle ) :
442 2 : Window( WINDOW_DOCKINGWINDOW )
443 : {
444 2 : ImplInitDockingWindowData();
445 2 : ImplInit( pParent, nStyle );
446 2 : }
447 :
448 : // -----------------------------------------------------------------------
449 :
450 176 : DockingWindow::DockingWindow( Window* pParent, const ResId& rResId ) :
451 176 : Window( WINDOW_DOCKINGWINDOW )
452 : {
453 176 : ImplInitDockingWindowData();
454 176 : rResId.SetRT( RSC_DOCKINGWINDOW );
455 176 : WinBits nStyle = ImplInitRes( rResId );
456 176 : ImplInit( pParent, nStyle );
457 176 : ImplLoadRes( rResId );
458 :
459 176 : if ( !(nStyle & WB_HIDE) )
460 38 : Show();
461 176 : }
462 :
463 : // -----------------------------------------------------------------------
464 :
465 28095 : DockingWindow::~DockingWindow()
466 : {
467 14047 : if ( IsFloatingMode() )
468 : {
469 0 : Show( sal_False, SHOW_NOFOCUSCHANGE );
470 0 : SetFloatingMode( sal_False );
471 : }
472 14047 : delete mpImplData;
473 14048 : }
474 :
475 : // -----------------------------------------------------------------------
476 :
477 0 : void DockingWindow::Tracking( const TrackingEvent& rTEvt )
478 : {
479 0 : if( GetDockingManager()->IsDockable( this ) ) // new docking interface
480 0 : return Window::Tracking( rTEvt );
481 :
482 0 : if ( mbDocking )
483 : {
484 0 : if ( rTEvt.IsTrackingEnded() )
485 : {
486 0 : mbDocking = sal_False;
487 0 : if ( mbDragFull )
488 : {
489 : // Bei Abbruch alten Zustand wieder herstellen
490 0 : if ( rTEvt.IsTrackingCanceled() )
491 : {
492 0 : StartDocking();
493 0 : Rectangle aRect( Point( mnTrackX, mnTrackY ), Size( mnTrackWidth, mnTrackHeight ) );
494 0 : EndDocking( aRect, mbStartFloat );
495 : }
496 : }
497 : else
498 : {
499 0 : HideTracking();
500 0 : if ( rTEvt.IsTrackingCanceled() )
501 : {
502 0 : mbDockCanceled = sal_True;
503 0 : EndDocking( Rectangle( Point( mnTrackX, mnTrackY ), Size( mnTrackWidth, mnTrackHeight ) ), mbLastFloatMode );
504 0 : mbDockCanceled = sal_False;
505 : }
506 : else
507 0 : EndDocking( Rectangle( Point( mnTrackX, mnTrackY ), Size( mnTrackWidth, mnTrackHeight ) ), mbLastFloatMode );
508 : }
509 : }
510 : // Docking nur bei nicht synthetischen MouseEvents
511 0 : else if ( !rTEvt.GetMouseEvent().IsSynthetic() || rTEvt.GetMouseEvent().IsModifierChanged() )
512 : {
513 0 : Point aMousePos = rTEvt.GetMouseEvent().GetPosPixel();
514 0 : Point aFrameMousePos = ImplOutputToFrame( aMousePos );
515 0 : Size aFrameSize = mpWindowImpl->mpFrameWindow->GetOutputSizePixel();
516 0 : if ( aFrameMousePos.X() < 0 )
517 0 : aFrameMousePos.X() = 0;
518 0 : if ( aFrameMousePos.Y() < 0 )
519 0 : aFrameMousePos.Y() = 0;
520 0 : if ( aFrameMousePos.X() > aFrameSize.Width()-1 )
521 0 : aFrameMousePos.X() = aFrameSize.Width()-1;
522 0 : if ( aFrameMousePos.Y() > aFrameSize.Height()-1 )
523 0 : aFrameMousePos.Y() = aFrameSize.Height()-1;
524 0 : aMousePos = ImplFrameToOutput( aFrameMousePos );
525 0 : aMousePos.X() -= maMouseOff.X();
526 0 : aMousePos.Y() -= maMouseOff.Y();
527 0 : Point aFramePos = ImplOutputToFrame( aMousePos );
528 0 : Rectangle aTrackRect( aFramePos, Size( mnTrackWidth, mnTrackHeight ) );
529 0 : Rectangle aCompRect = aTrackRect;
530 0 : aFramePos.X() += maMouseOff.X();
531 0 : aFramePos.Y() += maMouseOff.Y();
532 0 : if ( mbDragFull )
533 0 : StartDocking();
534 0 : sal_Bool bFloatMode = Docking( aFramePos, aTrackRect );
535 0 : mbDockPrevented = sal_False;
536 0 : mbFloatPrevented = sal_False;
537 0 : if ( mbLastFloatMode != bFloatMode )
538 : {
539 0 : if ( bFloatMode )
540 : {
541 0 : aTrackRect.Left() -= mnDockLeft;
542 0 : aTrackRect.Top() -= mnDockTop;
543 0 : aTrackRect.Right() += mnDockRight;
544 0 : aTrackRect.Bottom() += mnDockBottom;
545 : }
546 : else
547 : {
548 0 : if ( aCompRect == aTrackRect )
549 : {
550 0 : aTrackRect.Left() += mnDockLeft;
551 0 : aTrackRect.Top() += mnDockTop;
552 0 : aTrackRect.Right() -= mnDockRight;
553 0 : aTrackRect.Bottom() -= mnDockBottom;
554 : }
555 : }
556 0 : mbLastFloatMode = bFloatMode;
557 : }
558 0 : if ( mbDragFull )
559 : {
560 0 : Point aPos;
561 0 : Point aOldPos = OutputToScreenPixel( aPos );
562 0 : EndDocking( aTrackRect, mbLastFloatMode );
563 : // Wenn der Status bzw. die Position sich
564 : // geaendert hat, dann neu ausgeben
565 0 : if ( aOldPos != OutputToScreenPixel( aPos ) )
566 : {
567 0 : ImplUpdateAll();
568 0 : ImplGetFrameWindow()->ImplUpdateAll();
569 : }
570 : // EndDocking( aTrackRect, mbLastFloatMode );
571 : }
572 : else
573 : {
574 : sal_uInt16 nTrackStyle;
575 0 : if ( bFloatMode )
576 0 : nTrackStyle = SHOWTRACK_BIG;
577 : else
578 0 : nTrackStyle = SHOWTRACK_OBJECT;
579 0 : Rectangle aShowTrackRect = aTrackRect;
580 0 : aShowTrackRect.SetPos( ImplFrameToOutput( aShowTrackRect.TopLeft() ) );
581 0 : ShowTracking( aShowTrackRect, nTrackStyle );
582 :
583 : // Maus-Offset neu berechnen, da Rechteck veraendert werden
584 : // konnte
585 0 : maMouseOff.X() = aFramePos.X() - aTrackRect.Left();
586 0 : maMouseOff.Y() = aFramePos.Y() - aTrackRect.Top();
587 : }
588 :
589 0 : mnTrackX = aTrackRect.Left();
590 0 : mnTrackY = aTrackRect.Top();
591 0 : mnTrackWidth = aTrackRect.GetWidth();
592 0 : mnTrackHeight = aTrackRect.GetHeight();
593 : }
594 : }
595 : }
596 :
597 : // -----------------------------------------------------------------------
598 :
599 13571 : long DockingWindow::Notify( NotifyEvent& rNEvt )
600 : {
601 13571 : if( GetDockingManager()->IsDockable( this ) ) // new docking interface
602 7796 : return Window::Notify( rNEvt );
603 :
604 5775 : if ( mbDockable )
605 : {
606 1561 : if ( rNEvt.GetType() == EVENT_MOUSEBUTTONDOWN )
607 : {
608 0 : const MouseEvent* pMEvt = rNEvt.GetMouseEvent();
609 0 : if ( pMEvt->IsLeft() )
610 : {
611 0 : if ( pMEvt->IsMod1() && (pMEvt->GetClicks() == 2) )
612 : {
613 0 : SetFloatingMode( !IsFloatingMode() );
614 0 : return sal_True;
615 : }
616 0 : else if ( pMEvt->GetClicks() == 1 )
617 : {
618 : // check if window is floating standalone (IsFloating())
619 : // or only partially floating and still docked with one border
620 : // ( !mpWindowImpl->mbFrame)
621 0 : if( ! IsFloatingMode() || ! mpFloatWin->mpWindowImpl->mbFrame )
622 : {
623 0 : Point aPos = pMEvt->GetPosPixel();
624 0 : Window* pWindow = rNEvt.GetWindow();
625 0 : if ( pWindow != this )
626 : {
627 0 : aPos = pWindow->OutputToScreenPixel( aPos );
628 0 : aPos = ScreenToOutputPixel( aPos );
629 : }
630 0 : ImplStartDocking( aPos );
631 : }
632 0 : return sal_True;
633 : }
634 : }
635 : }
636 1561 : else if( rNEvt.GetType() == EVENT_KEYINPUT )
637 : {
638 0 : const KeyCode& rKey = rNEvt.GetKeyEvent()->GetKeyCode();
639 0 : if( rKey.GetCode() == KEY_F10 && rKey.GetModifier() &&
640 0 : rKey.IsShift() && rKey.IsMod1() )
641 : {
642 0 : SetFloatingMode( !IsFloatingMode() );
643 0 : return sal_True;
644 : }
645 : }
646 : }
647 :
648 5775 : return Window::Notify( rNEvt );
649 : }
650 :
651 : // -----------------------------------------------------------------------
652 :
653 0 : void DockingWindow::StartDocking()
654 : {
655 0 : mbDocking = sal_True;
656 0 : }
657 :
658 : // -----------------------------------------------------------------------
659 :
660 0 : sal_Bool DockingWindow::Docking( const Point&, Rectangle& )
661 : {
662 0 : return IsFloatingMode();
663 : }
664 :
665 : // -----------------------------------------------------------------------
666 :
667 0 : void DockingWindow::EndDocking( const Rectangle& rRect, sal_Bool bFloatMode )
668 : {
669 0 : if ( !IsDockingCanceled() )
670 : {
671 0 : bool bShow = false;
672 0 : if ( bFloatMode != IsFloatingMode() )
673 : {
674 0 : Show( sal_False, SHOW_NOFOCUSCHANGE );
675 0 : SetFloatingMode( bFloatMode );
676 0 : bShow = true;
677 0 : if ( bFloatMode && mpFloatWin )
678 0 : mpFloatWin->SetPosSizePixel( rRect.TopLeft(), rRect.GetSize() );
679 : }
680 0 : if ( !bFloatMode )
681 : {
682 0 : Point aPos = rRect.TopLeft();
683 0 : aPos = GetParent()->ScreenToOutputPixel( aPos );
684 0 : Window::SetPosSizePixel( aPos, rRect.GetSize() );
685 : }
686 :
687 0 : if ( bShow )
688 0 : Show();
689 : }
690 0 : mbDocking = sal_False;
691 0 : }
692 :
693 : // -----------------------------------------------------------------------
694 :
695 0 : sal_Bool DockingWindow::PrepareToggleFloatingMode()
696 : {
697 0 : return sal_True;
698 : }
699 :
700 : // -----------------------------------------------------------------------
701 :
702 0 : sal_Bool DockingWindow::Close()
703 : {
704 0 : ImplDelData aDelData;
705 0 : ImplAddDel( &aDelData );
706 0 : ImplCallEventListeners( VCLEVENT_WINDOW_CLOSE );
707 0 : if ( aDelData.IsDead() )
708 0 : return sal_False;
709 0 : ImplRemoveDel( &aDelData );
710 :
711 0 : if ( mpWindowImpl->mxWindowPeer.is() && IsCreatedWithToolkit() )
712 0 : return sal_False;
713 :
714 0 : Show( sal_False, SHOW_NOFOCUSCHANGE );
715 0 : return sal_True;
716 : }
717 :
718 : // -----------------------------------------------------------------------
719 :
720 0 : void DockingWindow::ToggleFloatingMode()
721 : {
722 0 : }
723 :
724 : // -----------------------------------------------------------------------
725 :
726 0 : void DockingWindow::TitleButtonClick( sal_uInt16 )
727 : {
728 0 : }
729 :
730 : // -----------------------------------------------------------------------
731 :
732 0 : void DockingWindow::Pin()
733 : {
734 0 : }
735 :
736 : // -----------------------------------------------------------------------
737 :
738 0 : void DockingWindow::Roll()
739 : {
740 0 : }
741 :
742 : // -----------------------------------------------------------------------
743 :
744 0 : void DockingWindow::PopupModeEnd()
745 : {
746 0 : }
747 :
748 : // -----------------------------------------------------------------------
749 :
750 0 : void DockingWindow::Resizing( Size& )
751 : {
752 0 : }
753 :
754 : // -----------------------------------------------------------------------
755 :
756 22227 : void DockingWindow::StateChanged( StateChangedType nType )
757 : {
758 22227 : switch(nType)
759 : {
760 : case STATE_CHANGE_CONTROLBACKGROUND:
761 0 : ImplInitSettings();
762 0 : Invalidate();
763 0 : break;
764 :
765 : case STATE_CHANGE_STYLE:
766 0 : mbDockable = (GetStyle() & WB_DOCKABLE) != 0;
767 0 : break;
768 :
769 : default:
770 22227 : break;
771 : }
772 :
773 22227 : Window::StateChanged( nType );
774 22227 : }
775 :
776 : // -----------------------------------------------------------------------
777 :
778 174 : void DockingWindow::DataChanged( const DataChangedEvent& rDCEvt )
779 : {
780 348 : if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
781 174 : (rDCEvt.GetFlags() & SETTINGS_STYLE) )
782 : {
783 90 : ImplInitSettings();
784 90 : Invalidate();
785 : }
786 : else
787 84 : Window::DataChanged( rDCEvt );
788 174 : }
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 0 : 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 9 : void DockingWindow::SetFloatStyle( WinBits nStyle )
896 : {
897 9 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
898 9 : if( pWrapper )
899 : {
900 9 : pWrapper->SetFloatStyle( nStyle );
901 18 : return;
902 : }
903 :
904 0 : mnFloatBits = nStyle;
905 : }
906 :
907 : // -----------------------------------------------------------------------
908 :
909 2718 : WinBits DockingWindow::GetFloatStyle() const
910 : {
911 2718 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
912 2718 : if( pWrapper )
913 : {
914 9 : return pWrapper->GetFloatStyle();
915 : }
916 :
917 2709 : return mnFloatBits;
918 : }
919 :
920 : // -----------------------------------------------------------------------
921 :
922 22561 : void DockingWindow::setPosSizePixel( long nX, long nY,
923 : long nWidth, long nHeight,
924 : sal_uInt16 nFlags )
925 : {
926 22561 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
927 22561 : if( pWrapper )
928 : {
929 9849 : if ( pWrapper->mpFloatWin )
930 0 : pWrapper->mpFloatWin->setPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
931 : else
932 9849 : Window::setPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
933 32410 : return;
934 : }
935 :
936 12712 : if ( mpFloatWin )
937 0 : mpFloatWin->setPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
938 : else
939 12712 : Window::setPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
940 : }
941 :
942 : // -----------------------------------------------------------------------
943 :
944 22512 : Point DockingWindow::GetPosPixel() const
945 : {
946 22512 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
947 22512 : if( pWrapper )
948 : {
949 21109 : if ( pWrapper->mpFloatWin )
950 0 : return pWrapper->mpFloatWin->GetPosPixel();
951 : else
952 21109 : return Window::GetPosPixel();
953 : }
954 :
955 1403 : if ( mpFloatWin )
956 0 : return mpFloatWin->GetPosPixel();
957 : else
958 1403 : return Window::GetPosPixel();
959 : }
960 :
961 : // -----------------------------------------------------------------------
962 :
963 35146 : Size DockingWindow::GetSizePixel() const
964 : {
965 35146 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
966 35146 : if( pWrapper )
967 : {
968 21445 : if ( pWrapper->mpFloatWin )
969 0 : return pWrapper->mpFloatWin->GetSizePixel();
970 : else
971 21445 : return Window::GetSizePixel();
972 : }
973 :
974 13701 : if ( mpFloatWin )
975 0 : return mpFloatWin->GetSizePixel();
976 : else
977 13701 : return Window::GetSizePixel();
978 : }
979 :
980 : // -----------------------------------------------------------------------
981 :
982 4750 : void DockingWindow::SetOutputSizePixel( const Size& rNewSize )
983 : {
984 4750 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
985 4750 : if( pWrapper )
986 : {
987 2330 : if ( pWrapper->mpFloatWin )
988 0 : pWrapper->mpFloatWin->SetOutputSizePixel( rNewSize );
989 : else
990 2330 : Window::SetOutputSizePixel( rNewSize );
991 7080 : return;
992 : }
993 :
994 2420 : if ( mpFloatWin )
995 0 : mpFloatWin->SetOutputSizePixel( rNewSize );
996 : else
997 2420 : Window::SetOutputSizePixel( rNewSize );
998 : }
999 :
1000 : // -----------------------------------------------------------------------
1001 :
1002 96125 : Size DockingWindow::GetOutputSizePixel() const
1003 : {
1004 96125 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
1005 96125 : if( pWrapper )
1006 : {
1007 89436 : if ( pWrapper->mpFloatWin )
1008 0 : return pWrapper->mpFloatWin->GetOutputSizePixel();
1009 : else
1010 89436 : return Window::GetOutputSizePixel();
1011 : }
1012 :
1013 6689 : if ( mpFloatWin )
1014 0 : return mpFloatWin->GetOutputSizePixel();
1015 : else
1016 6689 : return Window::GetOutputSizePixel();
1017 : }
1018 :
1019 173 : Point DockingWindow::GetFloatingPos() const
1020 : {
1021 173 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
1022 173 : 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 173 : 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 173 : return maFloatPos;
1048 : }
1049 :
1050 698677 : sal_Bool DockingWindow::IsFloatingMode() const
1051 : {
1052 698677 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
1053 698677 : if( pWrapper )
1054 569230 : return pWrapper->IsFloatingMode();
1055 : else
1056 129447 : 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 465 : }
1065 :
1066 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
