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 3127 : DockingWindow::ImplData::ImplData()
56 : {
57 3127 : mpParent = NULL;
58 3127 : maMaxOutSize = Size( SHRT_MAX, SHRT_MAX );
59 3127 : }
60 :
61 997 : DockingWindow::ImplData::~ImplData()
62 : {
63 997 : }
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 : sal_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( sal_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 : ( 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 = sal_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 = sal_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 3127 : void DockingWindow::ImplInitDockingWindowData()
336 : {
337 3127 : mpImplData = new ImplData;
338 3127 : mpWindowImpl->mbDockWin = sal_True;
339 :
340 3127 : mpFloatWin = NULL;
341 3127 : mbDockCanceled = sal_False;
342 3127 : mbDockPrevented = sal_False;
343 3127 : mbFloatPrevented = sal_False;
344 3127 : mbDocking = sal_False;
345 3127 : mbPined = sal_False;
346 3127 : mbRollUp = sal_False;
347 3127 : mbDockBtn = sal_False;
348 3127 : mbHideBtn = sal_False;
349 3127 : }
350 :
351 : // -----------------------------------------------------------------------
352 :
353 3127 : void DockingWindow::ImplInit( Window* pParent, WinBits nStyle )
354 : {
355 3127 : if ( !(nStyle & WB_NODIALOGCONTROL) )
356 3127 : nStyle |= WB_DIALOGCONTROL;
357 :
358 3127 : mpImplData->mpParent = pParent;
359 3127 : mbDockable = (nStyle & WB_DOCKABLE) != 0;
360 3127 : mnFloatBits = WB_BORDER | (nStyle & DOCKWIN_FLOATSTYLES);
361 3127 : nStyle &= ~(DOCKWIN_FLOATSTYLES | WB_BORDER);
362 3127 : if ( nStyle & WB_DOCKBORDER )
363 0 : nStyle |= WB_BORDER;
364 :
365 3127 : Window::ImplInit( pParent, nStyle, NULL );
366 :
367 3127 : ImplInitSettings();
368 3127 : }
369 :
370 : // -----------------------------------------------------------------------
371 :
372 3127 : void DockingWindow::ImplInitSettings()
373 : {
374 : // Hack, damit man auch DockingWindows ohne Hintergrund bauen kann
375 : // und noch nicht alles umgestellt ist
376 3127 : if ( IsBackground() )
377 : {
378 3127 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
379 :
380 3127 : Color aColor;
381 3127 : if ( IsControlBackground() )
382 0 : aColor = GetControlBackground();
383 3127 : else if ( Window::GetStyle() & WB_3DLOOK )
384 2655 : aColor = rStyleSettings.GetFaceColor();
385 : else
386 472 : aColor = rStyleSettings.GetWindowColor();
387 3127 : SetBackground( aColor );
388 : }
389 3127 : }
390 :
391 : // -----------------------------------------------------------------------
392 :
393 4 : void DockingWindow::ImplLoadRes( const ResId& rResId )
394 : {
395 4 : Window::ImplLoadRes( rResId );
396 :
397 4 : sal_uLong nMask = ReadLongRes();
398 :
399 4 : if ( (RSC_DOCKINGWINDOW_XYMAPMODE | RSC_DOCKINGWINDOW_X |
400 : 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 4 : if ( nMask & RSC_DOCKINGWINDOW_FLOATING )
425 : {
426 0 : if ( (sal_Bool)ReadShortRes() )
427 0 : SetFloatingMode( sal_True );
428 : }
429 4 : }
430 :
431 : // -----------------------------------------------------------------------
432 :
433 3123 : DockingWindow::DockingWindow( WindowType nType ) :
434 3123 : Window( nType )
435 : {
436 3123 : ImplInitDockingWindowData();
437 3123 : }
438 :
439 : // -----------------------------------------------------------------------
440 :
441 0 : DockingWindow::DockingWindow( Window* pParent, WinBits nStyle ) :
442 0 : Window( WINDOW_DOCKINGWINDOW )
443 : {
444 0 : ImplInitDockingWindowData();
445 0 : ImplInit( pParent, nStyle );
446 0 : }
447 :
448 : // -----------------------------------------------------------------------
449 :
450 4 : DockingWindow::DockingWindow( Window* pParent, const ResId& rResId ) :
451 4 : Window( WINDOW_DOCKINGWINDOW )
452 : {
453 4 : ImplInitDockingWindowData();
454 4 : rResId.SetRT( RSC_DOCKINGWINDOW );
455 4 : WinBits nStyle = ImplInitRes( rResId );
456 4 : ImplInit( pParent, nStyle );
457 4 : ImplLoadRes( rResId );
458 :
459 4 : if ( !(nStyle & WB_HIDE) )
460 4 : Show();
461 4 : }
462 :
463 : // -----------------------------------------------------------------------
464 :
465 1994 : DockingWindow::~DockingWindow()
466 : {
467 997 : if ( IsFloatingMode() )
468 : {
469 0 : Show( sal_False, SHOW_NOFOCUSCHANGE );
470 0 : SetFloatingMode( sal_False );
471 : }
472 997 : delete mpImplData;
473 997 : }
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 158 : long DockingWindow::Notify( NotifyEvent& rNEvt )
600 : {
601 158 : if( GetDockingManager()->IsDockable( this ) ) // new docking interface
602 126 : return Window::Notify( rNEvt );
603 :
604 32 : if ( mbDockable )
605 : {
606 32 : 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 32 : 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 32 : 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 : sal_Bool bShow = sal_False;
672 0 : if ( bFloatMode != IsFloatingMode() )
673 : {
674 0 : Show( sal_False, SHOW_NOFOCUSCHANGE );
675 0 : SetFloatingMode( bFloatMode );
676 0 : bShow = sal_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 3053 : void DockingWindow::StateChanged( StateChangedType nType )
757 : {
758 3053 : if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
759 : {
760 0 : ImplInitSettings();
761 0 : Invalidate();
762 : }
763 :
764 3053 : Window::StateChanged( nType );
765 3053 : }
766 :
767 : // -----------------------------------------------------------------------
768 :
769 1024 : void DockingWindow::DataChanged( const DataChangedEvent& rDCEvt )
770 : {
771 2048 : if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
772 1024 : (rDCEvt.GetFlags() & SETTINGS_STYLE) )
773 : {
774 0 : ImplInitSettings();
775 0 : Invalidate();
776 : }
777 : else
778 1024 : Window::DataChanged( rDCEvt );
779 1024 : }
780 :
781 : // -----------------------------------------------------------------------
782 :
783 0 : void DockingWindow::SetFloatingMode( sal_Bool bFloatMode )
784 : {
785 0 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
786 0 : if( pWrapper )
787 : {
788 0 : pWrapper->SetFloatingMode( bFloatMode );
789 0 : return;
790 : }
791 0 : if ( IsFloatingMode() != bFloatMode )
792 : {
793 0 : if ( PrepareToggleFloatingMode() ) // changes to floating mode can be vetoed
794 : {
795 0 : sal_Bool bVisible = IsVisible();
796 :
797 0 : if ( bFloatMode )
798 : {
799 0 : Show( sal_False, SHOW_NOFOCUSCHANGE );
800 :
801 0 : maDockPos = Window::GetPosPixel();
802 :
803 0 : Window* pRealParent = mpWindowImpl->mpRealParent;
804 0 : mpOldBorderWin = mpWindowImpl->mpBorderWindow;
805 :
806 : ImplDockFloatWin* pWin =
807 : new ImplDockFloatWin(
808 : mpImplData->mpParent,
809 : mnFloatBits & ( WB_MOVEABLE | WB_SIZEABLE | WB_CLOSEABLE ) ? mnFloatBits | WB_SYSTEMWINDOW : mnFloatBits,
810 0 : this );
811 0 : mpFloatWin = pWin;
812 0 : mpWindowImpl->mpBorderWindow = NULL;
813 0 : mpWindowImpl->mnLeftBorder = 0;
814 0 : mpWindowImpl->mnTopBorder = 0;
815 0 : mpWindowImpl->mnRightBorder = 0;
816 0 : mpWindowImpl->mnBottomBorder = 0;
817 : // Falls Parent zerstoert wird, muessen wir auch vom
818 : // BorderWindow den Parent umsetzen
819 0 : if ( mpOldBorderWin )
820 0 : mpOldBorderWin->SetParent( pWin );
821 0 : SetParent( pWin );
822 0 : SetPosPixel( Point() );
823 0 : mpWindowImpl->mpBorderWindow = pWin;
824 0 : pWin->mpWindowImpl->mpClientWindow = this;
825 0 : mpWindowImpl->mpRealParent = pRealParent;
826 0 : pWin->SetText( Window::GetText() );
827 0 : pWin->SetOutputSizePixel( Window::GetSizePixel() );
828 0 : pWin->SetPosPixel( maFloatPos );
829 : // DockingDaten ans FloatingWindow weiterreichen
830 0 : pWin->ShowTitleButton( TITLE_BUTTON_DOCKING, mbDockBtn );
831 0 : pWin->ShowTitleButton( TITLE_BUTTON_HIDE, mbHideBtn );
832 0 : pWin->SetPin( mbPined );
833 0 : if ( mbRollUp )
834 0 : pWin->RollUp();
835 : else
836 0 : pWin->RollDown();
837 0 : pWin->SetRollUpOutputSizePixel( maRollUpOutSize );
838 0 : pWin->SetMinOutputSizePixel( maMinOutSize );
839 0 : pWin->SetMaxOutputSizePixel( mpImplData->maMaxOutSize );
840 :
841 0 : ToggleFloatingMode();
842 :
843 0 : if ( bVisible )
844 0 : Show();
845 : }
846 : else
847 : {
848 0 : Show( sal_False, SHOW_NOFOCUSCHANGE );
849 :
850 : // FloatingDaten wird im FloatingWindow speichern
851 0 : maFloatPos = mpFloatWin->GetPosPixel();
852 0 : mbDockBtn = mpFloatWin->IsTitleButtonVisible( TITLE_BUTTON_DOCKING );
853 0 : mbHideBtn = mpFloatWin->IsTitleButtonVisible( TITLE_BUTTON_HIDE );
854 0 : mbPined = mpFloatWin->IsPined();
855 0 : mbRollUp = mpFloatWin->IsRollUp();
856 0 : maRollUpOutSize = mpFloatWin->GetRollUpOutputSizePixel();
857 0 : maMinOutSize = mpFloatWin->GetMinOutputSizePixel();
858 0 : mpImplData->maMaxOutSize = mpFloatWin->GetMaxOutputSizePixel();
859 :
860 0 : Window* pRealParent = mpWindowImpl->mpRealParent;
861 0 : mpWindowImpl->mpBorderWindow = NULL;
862 0 : if ( mpOldBorderWin )
863 : {
864 0 : SetParent( mpOldBorderWin );
865 0 : ((ImplBorderWindow*)mpOldBorderWin)->GetBorder( mpWindowImpl->mnLeftBorder, mpWindowImpl->mnTopBorder, mpWindowImpl->mnRightBorder, mpWindowImpl->mnBottomBorder );
866 0 : mpOldBorderWin->Resize();
867 : }
868 0 : mpWindowImpl->mpBorderWindow = mpOldBorderWin;
869 0 : SetParent( pRealParent );
870 0 : mpWindowImpl->mpRealParent = pRealParent;
871 0 : delete static_cast<ImplDockFloatWin*>(mpFloatWin);
872 0 : mpFloatWin = NULL;
873 0 : SetPosPixel( maDockPos );
874 :
875 0 : ToggleFloatingMode();
876 :
877 0 : if ( bVisible )
878 0 : Show();
879 : }
880 : }
881 : }
882 : }
883 :
884 : // -----------------------------------------------------------------------
885 :
886 0 : void DockingWindow::SetFloatStyle( WinBits nStyle )
887 : {
888 0 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
889 0 : if( pWrapper )
890 : {
891 0 : pWrapper->SetFloatStyle( nStyle );
892 0 : return;
893 : }
894 :
895 0 : mnFloatBits = nStyle;
896 : }
897 :
898 : // -----------------------------------------------------------------------
899 :
900 731 : WinBits DockingWindow::GetFloatStyle() const
901 : {
902 731 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
903 731 : if( pWrapper )
904 : {
905 0 : return pWrapper->GetFloatStyle();
906 : }
907 :
908 731 : return mnFloatBits;
909 : }
910 :
911 : // -----------------------------------------------------------------------
912 :
913 4158 : void DockingWindow::setPosSizePixel( long nX, long nY,
914 : long nWidth, long nHeight,
915 : sal_uInt16 nFlags )
916 : {
917 4158 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
918 4158 : if( pWrapper )
919 : {
920 2446 : if ( pWrapper->mpFloatWin )
921 0 : pWrapper->mpFloatWin->setPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
922 : else
923 2446 : Window::setPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
924 6604 : return;
925 : }
926 :
927 1712 : if ( mpFloatWin )
928 0 : mpFloatWin->setPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
929 : else
930 1712 : Window::setPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
931 : }
932 :
933 : // -----------------------------------------------------------------------
934 :
935 3053 : Point DockingWindow::GetPosPixel() const
936 : {
937 3053 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
938 3053 : if( pWrapper )
939 : {
940 3053 : if ( pWrapper->mpFloatWin )
941 0 : return pWrapper->mpFloatWin->GetPosPixel();
942 : else
943 3053 : return Window::GetPosPixel();
944 : }
945 :
946 0 : if ( mpFloatWin )
947 0 : return mpFloatWin->GetPosPixel();
948 : else
949 0 : return Window::GetPosPixel();
950 : }
951 :
952 : // -----------------------------------------------------------------------
953 :
954 4744 : Size DockingWindow::GetSizePixel() const
955 : {
956 4744 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
957 4744 : if( pWrapper )
958 : {
959 3053 : if ( pWrapper->mpFloatWin )
960 0 : return pWrapper->mpFloatWin->GetSizePixel();
961 : else
962 3053 : return Window::GetSizePixel();
963 : }
964 :
965 1691 : if ( mpFloatWin )
966 0 : return mpFloatWin->GetSizePixel();
967 : else
968 1691 : return Window::GetSizePixel();
969 : }
970 :
971 : // -----------------------------------------------------------------------
972 :
973 1426 : void DockingWindow::SetOutputSizePixel( const Size& rNewSize )
974 : {
975 1426 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
976 1426 : if( pWrapper )
977 : {
978 927 : if ( pWrapper->mpFloatWin )
979 0 : pWrapper->mpFloatWin->SetOutputSizePixel( rNewSize );
980 : else
981 927 : Window::SetOutputSizePixel( rNewSize );
982 2353 : return;
983 : }
984 :
985 499 : if ( mpFloatWin )
986 0 : mpFloatWin->SetOutputSizePixel( rNewSize );
987 : else
988 499 : Window::SetOutputSizePixel( rNewSize );
989 : }
990 :
991 : // -----------------------------------------------------------------------
992 :
993 2022 : Size DockingWindow::GetOutputSizePixel() const
994 : {
995 2022 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
996 2022 : if( pWrapper )
997 : {
998 1976 : if ( pWrapper->mpFloatWin )
999 0 : return pWrapper->mpFloatWin->GetOutputSizePixel();
1000 : else
1001 1976 : return Window::GetOutputSizePixel();
1002 : }
1003 :
1004 46 : if ( mpFloatWin )
1005 0 : return mpFloatWin->GetOutputSizePixel();
1006 : else
1007 46 : return Window::GetOutputSizePixel();
1008 : }
1009 :
1010 0 : Point DockingWindow::GetFloatingPos() const
1011 : {
1012 0 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
1013 0 : if( pWrapper )
1014 : {
1015 0 : if ( pWrapper->mpFloatWin )
1016 : {
1017 0 : WindowStateData aData;
1018 0 : aData.SetMask( WINDOWSTATE_MASK_POS );
1019 0 : pWrapper->mpFloatWin->GetWindowStateData( aData );
1020 0 : Point aPos( aData.GetX(), aData.GetY() );
1021 0 : aPos = pWrapper->mpFloatWin->GetParent()->ImplGetFrameWindow()->AbsoluteScreenToOutputPixel( aPos );
1022 0 : return aPos;
1023 : }
1024 : else
1025 0 : return maFloatPos;
1026 : }
1027 :
1028 0 : if ( mpFloatWin )
1029 : {
1030 0 : WindowStateData aData;
1031 0 : aData.SetMask( WINDOWSTATE_MASK_POS );
1032 0 : mpFloatWin->GetWindowStateData( aData );
1033 0 : Point aPos( aData.GetX(), aData.GetY() );
1034 0 : aPos = mpFloatWin->GetParent()->ImplGetFrameWindow()->AbsoluteScreenToOutputPixel( aPos );
1035 0 : return aPos;
1036 : }
1037 : else
1038 0 : return maFloatPos;
1039 : }
1040 :
1041 23766 : sal_Bool DockingWindow::IsFloatingMode() const
1042 : {
1043 23766 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
1044 23766 : if( pWrapper )
1045 14629 : return pWrapper->IsFloatingMode();
1046 : else
1047 9137 : return (mpFloatWin != NULL);
1048 : }
1049 :
1050 0 : void DockingWindow::SetMaxOutputSizePixel( const Size& rSize )
1051 : {
1052 0 : if ( mpFloatWin )
1053 0 : mpFloatWin->SetMaxOutputSizePixel( rSize );
1054 0 : mpImplData->maMaxOutSize = rSize;
1055 0 : }
1056 :
1057 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
