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/rc.h>
31 : : #include <tools/poly.hxx>
32 : :
33 : : #include <vcl/event.hxx>
34 : : #include <vcl/split.hxx>
35 : : #include <vcl/svapp.hxx>
36 : : #include <vcl/syswin.hxx>
37 : : #include <vcl/taskpanelist.hxx>
38 : : #include <vcl/gradient.hxx>
39 : : #include <vcl/lineinfo.hxx>
40 : :
41 : : #include <rtl/instance.hxx>
42 : :
43 : : #include <window.h>
44 : :
45 : : namespace
46 : : {
47 : : struct ImplBlackWall
48 : : : public rtl::StaticWithInit<Wallpaper, ImplBlackWall> {
49 : 44 : Wallpaper operator () () {
50 [ + - ]: 44 : return Wallpaper(COL_BLACK);
51 : : }
52 : : };
53 : : struct ImplWhiteWall
54 : : : public rtl::StaticWithInit<Wallpaper, ImplWhiteWall> {
55 : 0 : Wallpaper operator () () {
56 [ # # ]: 0 : return Wallpaper(COL_LIGHTGRAY);
57 : : }
58 : : };
59 : : }
60 : :
61 : : // =======================================================================
62 : :
63 : 460 : void Splitter::ImplInitSplitterData()
64 : : {
65 : 460 : ImplGetWindowImpl()->mbSplitter = sal_True;
66 : 460 : mpRefWin = NULL;
67 : 460 : mnSplitPos = 0;
68 : 460 : mnLastSplitPos = 0;
69 : 460 : mnStartSplitPos = 0;
70 : 460 : mbDragFull = sal_False;
71 : 460 : mbKbdSplitting = sal_False;
72 : 460 : mbInKeyEvent = 0;
73 : 460 : mnKeyboardStepSize = SPLITTER_DEFAULTSTEPSIZE;
74 : 460 : }
75 : :
76 : : // -----------------------------------------------------------------------
77 : :
78 : 460 : void Splitter::ImplInit( Window* pParent, WinBits nWinStyle )
79 : : {
80 : 460 : Window::ImplInit( pParent, nWinStyle, NULL );
81 : :
82 : 460 : mpRefWin = pParent;
83 : :
84 : 460 : const StyleSettings& rSettings = GetSettings().GetStyleSettings();
85 : 460 : long nA = rSettings.GetScrollBarSize();
86 : 460 : long nB = rSettings.GetSplitSize();
87 : :
88 : : PointerStyle ePointerStyle;
89 : :
90 [ + + ]: 460 : if ( nWinStyle & WB_HSCROLL )
91 : : {
92 : 231 : ePointerStyle = POINTER_HSPLIT;
93 : 231 : mbHorzSplit = sal_True;
94 [ + - ]: 231 : SetSizePixel( Size( nB, nA ) );
95 : : }
96 : : else
97 : : {
98 : 229 : ePointerStyle = POINTER_VSPLIT;
99 : 229 : mbHorzSplit = sal_False;
100 [ + - ]: 229 : SetSizePixel( Size( nA, nB ) );
101 : : }
102 : :
103 [ + - ]: 460 : SetPointer( Pointer( ePointerStyle ) );
104 : :
105 [ - + ]: 460 : if( GetSettings().GetStyleSettings().GetFaceColor().IsDark() )
106 : 0 : SetBackground( ImplWhiteWall::get() );
107 : : else
108 : 460 : SetBackground( ImplBlackWall::get() );
109 : :
110 : 460 : TaskPaneList *pTList = GetSystemWindow()->GetTaskPaneList();
111 : 460 : pTList->AddWindow( this );
112 : 460 : }
113 : :
114 : : // -----------------------------------------------------------------------
115 : :
116 : 0 : void Splitter::ImplSplitMousePos( Point& rPos )
117 : : {
118 [ # # ]: 0 : if ( mbHorzSplit )
119 : : {
120 [ # # ]: 0 : if ( rPos.X() > maDragRect.Right()-1 )
121 : 0 : rPos.X() = maDragRect.Right()-1;
122 [ # # ]: 0 : if ( rPos.X() < maDragRect.Left()+1 )
123 : 0 : rPos.X() = maDragRect.Left()+1;
124 : : }
125 : : else
126 : : {
127 [ # # ]: 0 : if ( rPos.Y() > maDragRect.Bottom()-1 )
128 : 0 : rPos.Y() = maDragRect.Bottom()-1;
129 [ # # ]: 0 : if ( rPos.Y() < maDragRect.Top()+1 )
130 : 0 : rPos.Y() = maDragRect.Top()+1;
131 : : }
132 : 0 : }
133 : :
134 : : // -----------------------------------------------------------------------
135 : :
136 : 0 : void Splitter::ImplDrawSplitter()
137 : : {
138 : 0 : Rectangle aInvRect( maDragRect );
139 : :
140 [ # # ]: 0 : if ( mbHorzSplit )
141 : : {
142 : 0 : aInvRect.Left() = maDragPos.X() - 1;
143 : 0 : aInvRect.Right() = maDragPos.X() + 1;
144 : : }
145 : : else
146 : : {
147 : 0 : aInvRect.Top() = maDragPos.Y() - 1;
148 : 0 : aInvRect.Bottom() = maDragPos.Y() + 1;
149 : : }
150 : :
151 [ # # ][ # # ]: 0 : mpRefWin->InvertTracking( mpRefWin->PixelToLogic(aInvRect), SHOWTRACK_SPLIT );
152 : 0 : }
153 : :
154 : : // -----------------------------------------------------------------------
155 : :
156 : 460 : Splitter::Splitter( Window* pParent, WinBits nStyle ) :
157 [ + - ][ + - ]: 460 : Window( WINDOW_SPLITTER )
[ + - ][ + - ]
158 : : {
159 : 460 : ImplInitSplitterData();
160 [ + - ]: 460 : ImplInit( pParent, nStyle );
161 : :
162 [ + - ]: 460 : SetLineColor();
163 [ + - ]: 460 : SetFillColor();
164 : 460 : }
165 : :
166 : : // -----------------------------------------------------------------------
167 : :
168 : 0 : Splitter::Splitter( Window* pParent, const ResId& rResId ) :
169 [ # # ][ # # ]: 0 : Window( WINDOW_SPLITTER )
[ # # ][ # # ]
170 : : {
171 : 0 : ImplInitSplitterData();
172 : 0 : rResId.SetRT( RSC_SPLITTER );
173 [ # # ]: 0 : WinBits nStyle = ImplInitRes( rResId );
174 [ # # ]: 0 : ImplInit( pParent, nStyle );
175 [ # # ]: 0 : ImplLoadRes( rResId );
176 : :
177 [ # # ]: 0 : SetLineColor();
178 [ # # ]: 0 : SetFillColor();
179 : :
180 [ # # ]: 0 : if ( !(nStyle & WB_HIDE) )
181 [ # # ]: 0 : Show();
182 : 0 : }
183 : :
184 : : // -----------------------------------------------------------------------
185 : :
186 : 452 : Splitter::~Splitter()
187 : : {
188 [ + - ][ + - ]: 452 : TaskPaneList *pTList = GetSystemWindow()->GetTaskPaneList();
189 [ + - ]: 452 : pTList->RemoveWindow( this );
190 [ - + ]: 454 : }
191 : :
192 : : // -----------------------------------------------------------------------
193 : :
194 : 458 : void Splitter::SetKeyboardStepSize( long nStepSize )
195 : : {
196 : 458 : mnKeyboardStepSize = nStepSize;
197 : 458 : }
198 : :
199 : : // -----------------------------------------------------------------------
200 : :
201 : 0 : Splitter* Splitter::ImplFindSibling()
202 : : {
203 : : // look for another splitter with the same parent but different orientation
204 : 0 : Window *pWin = GetParent()->GetWindow( WINDOW_FIRSTCHILD );
205 : 0 : Splitter *pSplitter = NULL;
206 [ # # ]: 0 : while( pWin )
207 : : {
208 [ # # ]: 0 : if( pWin->ImplIsSplitter() )
209 : : {
210 : 0 : pSplitter = (Splitter*) pWin;
211 [ # # ][ # # ]: 0 : if( pSplitter != this && IsHorizontal() != pSplitter->IsHorizontal() )
[ # # ]
212 : 0 : return pSplitter;
213 : : }
214 : 0 : pWin = pWin->GetWindow( WINDOW_NEXT );
215 : : }
216 : 0 : return NULL;
217 : : }
218 : :
219 : : // -----------------------------------------------------------------------
220 : :
221 : 0 : sal_Bool Splitter::ImplSplitterActive()
222 : : {
223 : : // is splitter in document or at scrollbar handle ?
224 : :
225 : 0 : sal_Bool bActive = sal_True;
226 : 0 : const StyleSettings& rSettings = GetSettings().GetStyleSettings();
227 : 0 : long nA = rSettings.GetScrollBarSize();
228 : 0 : long nB = rSettings.GetSplitSize();
229 : :
230 [ # # ]: 0 : Size aSize = GetOutputSize();
231 [ # # ]: 0 : if ( mbHorzSplit )
232 : : {
233 [ # # ][ # # ]: 0 : if( aSize.Width() == nB && aSize.Height() == nA )
[ # # ]
234 : 0 : bActive = sal_False;
235 : : }
236 : : else
237 : : {
238 [ # # ][ # # ]: 0 : if( aSize.Width() == nA && aSize.Height() == nB )
[ # # ]
239 : 0 : bActive = sal_False;
240 : : }
241 : 0 : return bActive;
242 : : }
243 : :
244 : : // -----------------------------------------------------------------------
245 : :
246 : 0 : void Splitter::MouseButtonDown( const MouseEvent& rMEvt )
247 : : {
248 [ # # ]: 0 : if ( rMEvt.GetClicks() == 2 )
249 : : {
250 [ # # ]: 0 : if ( mnLastSplitPos != mnSplitPos )
251 : : {
252 [ # # ]: 0 : StartSplit();
253 : 0 : Point aPos = rMEvt.GetPosPixel();
254 [ # # ]: 0 : if ( mbHorzSplit )
255 : 0 : aPos.X() = mnLastSplitPos;
256 : : else
257 : 0 : aPos.Y() = mnLastSplitPos;
258 : 0 : ImplSplitMousePos( aPos );
259 [ # # ]: 0 : Splitting( aPos );
260 : 0 : ImplSplitMousePos( aPos );
261 : 0 : long nTemp = mnSplitPos;
262 [ # # ]: 0 : if ( mbHorzSplit )
263 [ # # ]: 0 : SetSplitPosPixel( aPos.X() );
264 : : else
265 [ # # ]: 0 : SetSplitPosPixel( aPos.Y() );
266 : 0 : mnLastSplitPos = nTemp;
267 [ # # ]: 0 : Split();
268 [ # # ]: 0 : EndSplit();
269 : : }
270 : : }
271 : : else
272 : 0 : StartDrag();
273 : 0 : }
274 : :
275 : : // -----------------------------------------------------------------------
276 : :
277 : 0 : void Splitter::Tracking( const TrackingEvent& rTEvt )
278 : : {
279 [ # # ]: 0 : if ( rTEvt.IsTrackingEnded() )
280 : : {
281 [ # # ]: 0 : if ( !mbDragFull )
282 : 0 : ImplDrawSplitter();
283 : :
284 [ # # ]: 0 : if ( !rTEvt.IsTrackingCanceled() )
285 : : {
286 : : long nNewPos;
287 [ # # ]: 0 : if ( mbHorzSplit )
288 : 0 : nNewPos = maDragPos.X();
289 : : else
290 : 0 : nNewPos = maDragPos.Y();
291 [ # # ]: 0 : if ( nNewPos != mnStartSplitPos )
292 : : {
293 : 0 : SetSplitPosPixel( nNewPos );
294 : 0 : mnLastSplitPos = 0;
295 : 0 : Split();
296 : : }
297 : 0 : EndSplit();
298 : : }
299 [ # # ]: 0 : else if ( mbDragFull )
300 : : {
301 : 0 : SetSplitPosPixel( mnStartSplitPos );
302 : 0 : Split();
303 : : }
304 : 0 : mnStartSplitPos = 0;
305 : : }
306 : : else
307 : : {
308 : : //Point aNewPos = mpRefWin->ScreenToOutputPixel( OutputToScreenPixel( rTEvt.GetMouseEvent().GetPosPixel() ) );
309 [ # # ][ # # ]: 0 : Point aNewPos = mpRefWin->NormalizedScreenToOutputPixel( OutputToNormalizedScreenPixel( rTEvt.GetMouseEvent().GetPosPixel() ) );
310 : 0 : ImplSplitMousePos( aNewPos );
311 [ # # ]: 0 : Splitting( aNewPos );
312 : 0 : ImplSplitMousePos( aNewPos );
313 : :
314 [ # # ]: 0 : if ( mbHorzSplit )
315 : : {
316 [ # # ]: 0 : if ( aNewPos.X() == maDragPos.X() )
317 : : return;
318 : : }
319 : : else
320 : : {
321 [ # # ]: 0 : if ( aNewPos.Y() == maDragPos.Y() )
322 : : return;
323 : : }
324 : :
325 [ # # ]: 0 : if ( mbDragFull )
326 : : {
327 : 0 : maDragPos = aNewPos;
328 : : long nNewPos;
329 [ # # ]: 0 : if ( mbHorzSplit )
330 : 0 : nNewPos = maDragPos.X();
331 : : else
332 : 0 : nNewPos = maDragPos.Y();
333 [ # # ]: 0 : if ( nNewPos != mnSplitPos )
334 : : {
335 [ # # ]: 0 : SetSplitPosPixel( nNewPos );
336 : 0 : mnLastSplitPos = 0;
337 [ # # ]: 0 : Split();
338 : : }
339 : :
340 [ # # ][ # # ]: 0 : GetParent()->Update();
341 : : }
342 : : else
343 : : {
344 [ # # ]: 0 : ImplDrawSplitter();
345 : 0 : maDragPos = aNewPos;
346 [ # # ]: 0 : ImplDrawSplitter();
347 : : }
348 : : }
349 : : }
350 : :
351 : : // -----------------------------------------------------------------------
352 : :
353 : 0 : void Splitter::ImplKbdTracking( KeyCode aKeyCode )
354 : : {
355 : 0 : sal_uInt16 nCode = aKeyCode.GetCode();
356 [ # # ][ # # ]: 0 : if ( nCode == KEY_ESCAPE || nCode == KEY_RETURN )
357 : : {
358 [ # # ]: 0 : if( !mbKbdSplitting )
359 : 0 : return;
360 : : else
361 : 0 : mbKbdSplitting = sal_False;
362 : :
363 [ # # ]: 0 : if ( nCode != KEY_ESCAPE )
364 : : {
365 : : long nNewPos;
366 [ # # ]: 0 : if ( mbHorzSplit )
367 : 0 : nNewPos = maDragPos.X();
368 : : else
369 : 0 : nNewPos = maDragPos.Y();
370 [ # # ]: 0 : if ( nNewPos != mnStartSplitPos )
371 : : {
372 : 0 : SetSplitPosPixel( nNewPos );
373 : 0 : mnLastSplitPos = 0;
374 : 0 : Split();
375 : : }
376 : : }
377 : : else
378 : : {
379 : 0 : SetSplitPosPixel( mnStartSplitPos );
380 : 0 : Split();
381 : 0 : EndSplit();
382 : : }
383 : 0 : mnStartSplitPos = 0;
384 : : }
385 : : else
386 : : {
387 : 0 : Point aNewPos;
388 [ # # ]: 0 : Size aSize = mpRefWin->GetOutputSize();
389 [ # # ]: 0 : Point aPos = GetPosPixel();
390 : : // depending on the position calc allows continous moves or snaps to row/columns
391 : : // continous mode is active when position is at the origin or end of the splitter
392 : : // otherwise snap mode is active
393 : : // default here is snap, holding shift sets continous mode
394 [ # # ]: 0 : if( mbHorzSplit )
395 [ # # ][ # # ]: 0 : aNewPos = Point( ImplSplitterActive() ? aPos.X() : mnSplitPos, aKeyCode.IsShift() ? 0 : aSize.Height()/2);
[ # # ]
396 : : else
397 [ # # ][ # # ]: 0 : aNewPos = Point( aKeyCode.IsShift() ? 0 : aSize.Width()/2, ImplSplitterActive() ? aPos.Y() : mnSplitPos );
[ # # ]
398 : :
399 [ # # ]: 0 : Point aOldWindowPos = GetPosPixel();
400 : :
401 : 0 : int maxiter = 500; // avoid endless loop
402 : 0 : int delta=0;
403 [ # # ]: 0 : int delta_step = mbHorzSplit ? aSize.Width()/10 : aSize.Height()/10;
404 : :
405 : : // use the specified step size if it was set
406 [ # # ]: 0 : if( mnKeyboardStepSize != SPLITTER_DEFAULTSTEPSIZE )
407 : 0 : delta_step = mnKeyboardStepSize;
408 : :
409 [ # # ][ # # ]: 0 : while( maxiter-- && aOldWindowPos == GetPosPixel() )
[ # # ][ # # ]
[ # # ][ # # ]
410 : : {
411 : : // inc/dec position until application performs changes
412 : : // thus a single key press really moves the splitter
413 [ # # ]: 0 : if( aKeyCode.IsShift() )
414 : 0 : delta++;
415 : : else
416 : 0 : delta += delta_step;
417 : :
418 [ # # # # : 0 : switch( nCode )
# ]
419 : : {
420 : : case KEY_LEFT:
421 : 0 : aNewPos.X()-=delta;
422 : 0 : break;
423 : : case KEY_RIGHT:
424 : 0 : aNewPos.X()+=delta;
425 : 0 : break;
426 : : case KEY_UP:
427 : 0 : aNewPos.Y()-=delta;
428 : 0 : break;
429 : : case KEY_DOWN:
430 : 0 : aNewPos.Y()+=delta;
431 : 0 : break;
432 : : default:
433 : 0 : maxiter = 0; // leave loop
434 : 0 : break;
435 : : }
436 : 0 : ImplSplitMousePos( aNewPos );
437 [ # # ]: 0 : Splitting( aNewPos );
438 : 0 : ImplSplitMousePos( aNewPos );
439 : :
440 [ # # ]: 0 : if ( mbHorzSplit )
441 : : {
442 [ # # ]: 0 : if ( aNewPos.X() == maDragPos.X() )
443 : 0 : continue;
444 : : }
445 : : else
446 : : {
447 [ # # ]: 0 : if ( aNewPos.Y() == maDragPos.Y() )
448 : 0 : continue;
449 : : }
450 : :
451 : 0 : maDragPos = aNewPos;
452 : : long nNewPos;
453 [ # # ]: 0 : if ( mbHorzSplit )
454 : 0 : nNewPos = maDragPos.X();
455 : : else
456 : 0 : nNewPos = maDragPos.Y();
457 [ # # ]: 0 : if ( nNewPos != mnSplitPos )
458 : : {
459 [ # # ]: 0 : SetSplitPosPixel( nNewPos );
460 : 0 : mnLastSplitPos = 0;
461 [ # # ]: 0 : Split();
462 : : }
463 [ # # ][ # # ]: 0 : GetParent()->Update();
464 : : }
465 : : }
466 : : }
467 : :
468 : : // -----------------------------------------------------------------------
469 : :
470 : 0 : void Splitter::StartSplit()
471 : : {
472 : 0 : maStartSplitHdl.Call( this );
473 : 0 : }
474 : :
475 : : // -----------------------------------------------------------------------
476 : :
477 : 0 : void Splitter::Split()
478 : : {
479 : 0 : maSplitHdl.Call( this );
480 : 0 : }
481 : :
482 : : // -----------------------------------------------------------------------
483 : :
484 : 0 : void Splitter::EndSplit()
485 : : {
486 [ # # ]: 0 : if ( maEndSplitHdl.IsSet() )
487 : 0 : maEndSplitHdl.Call( this );
488 : 0 : }
489 : :
490 : : // -----------------------------------------------------------------------
491 : :
492 : 0 : void Splitter::Splitting( Point& /* rSplitPos */ )
493 : : {
494 : 0 : }
495 : :
496 : : // -----------------------------------------------------------------------
497 : :
498 : 1378 : void Splitter::SetDragRectPixel( const Rectangle& rDragRect, Window* _pRefWin )
499 : : {
500 : 1378 : maDragRect = rDragRect;
501 [ + + ]: 1378 : if ( !_pRefWin )
502 : 14 : mpRefWin = GetParent();
503 : : else
504 : 1364 : mpRefWin = _pRefWin;
505 : 1378 : }
506 : :
507 : : // -----------------------------------------------------------------------
508 : :
509 : 2 : void Splitter::SetSplitPosPixel( long nNewPos )
510 : : {
511 : 2 : mnSplitPos = nNewPos;
512 : 2 : }
513 : :
514 : : // -----------------------------------------------------------------------
515 : :
516 : 0 : void Splitter::StartDrag()
517 : : {
518 [ # # ]: 0 : if ( IsTracking() )
519 : 0 : return;
520 : :
521 : 0 : StartSplit();
522 : :
523 : : // Tracking starten
524 : 0 : StartTracking();
525 : :
526 : : // Start-Positon ermitteln
527 : 0 : maDragPos = mpRefWin->GetPointerPosPixel();
528 : 0 : ImplSplitMousePos( maDragPos );
529 : 0 : Splitting( maDragPos );
530 : 0 : ImplSplitMousePos( maDragPos );
531 [ # # ]: 0 : if ( mbHorzSplit )
532 : 0 : mnStartSplitPos = maDragPos.X();
533 : : else
534 : 0 : mnStartSplitPos = maDragPos.Y();
535 : :
536 : 0 : mbDragFull = (Application::GetSettings().GetStyleSettings().GetDragFullOptions() & DRAGFULL_OPTION_SPLIT) != 0;
537 [ # # ]: 0 : if ( !mbDragFull )
538 : 0 : ImplDrawSplitter();
539 : : }
540 : :
541 : :
542 : : // -----------------------------------------------------------------------
543 : :
544 : 0 : void Splitter::ImplStartKbdSplitting()
545 : : {
546 [ # # ]: 0 : if( mbKbdSplitting )
547 : 0 : return;
548 : :
549 : 0 : mbKbdSplitting = sal_True;
550 : :
551 [ # # ]: 0 : StartSplit();
552 : :
553 : : // determine start position
554 : : // because we have no mouse position we take either the position
555 : : // of the splitter window or the last split position
556 : : // the other coordinate is just the center of the reference window
557 [ # # ]: 0 : Size aSize = mpRefWin->GetOutputSize();
558 [ # # ]: 0 : Point aPos = GetPosPixel();
559 [ # # ]: 0 : if( mbHorzSplit )
560 [ # # ][ # # ]: 0 : maDragPos = Point( ImplSplitterActive() ? aPos.X() : mnSplitPos, aSize.Height()/2 );
561 : : else
562 [ # # ][ # # ]: 0 : maDragPos = Point( aSize.Width()/2, ImplSplitterActive() ? aPos.Y() : mnSplitPos );
563 : 0 : ImplSplitMousePos( maDragPos );
564 [ # # ]: 0 : Splitting( maDragPos );
565 : 0 : ImplSplitMousePos( maDragPos );
566 [ # # ]: 0 : if ( mbHorzSplit )
567 : 0 : mnStartSplitPos = maDragPos.X();
568 : : else
569 : 0 : mnStartSplitPos = maDragPos.Y();
570 : : }
571 : :
572 : : // -----------------------------------------------------------------------
573 : :
574 : 0 : void Splitter::ImplRestoreSplitter()
575 : : {
576 : : // set splitter in the center of the ref window
577 [ # # ]: 0 : StartSplit();
578 [ # # ]: 0 : Size aSize = mpRefWin->GetOutputSize();
579 : 0 : Point aPos = Point( aSize.Width()/2 , aSize.Height()/2);
580 [ # # ][ # # ]: 0 : if ( mnLastSplitPos != mnSplitPos && mnLastSplitPos > 5 )
581 : : {
582 : : // restore last pos if it was a useful position (>5)
583 [ # # ]: 0 : if ( mbHorzSplit )
584 : 0 : aPos.X() = mnLastSplitPos;
585 : : else
586 : 0 : aPos.Y() = mnLastSplitPos;
587 : : }
588 : :
589 : 0 : ImplSplitMousePos( aPos );
590 [ # # ]: 0 : Splitting( aPos );
591 : 0 : ImplSplitMousePos( aPos );
592 : 0 : long nTemp = mnSplitPos;
593 [ # # ]: 0 : if ( mbHorzSplit )
594 [ # # ]: 0 : SetSplitPosPixel( aPos.X() );
595 : : else
596 [ # # ]: 0 : SetSplitPosPixel( aPos.Y() );
597 : 0 : mnLastSplitPos = nTemp;
598 [ # # ]: 0 : Split();
599 [ # # ]: 0 : EndSplit();
600 : 0 : }
601 : :
602 : :
603 : : // -----------------------------------------------------------------------
604 : :
605 : 0 : void Splitter::GetFocus()
606 : : {
607 [ # # ]: 0 : if( !ImplSplitterActive() )
608 : 0 : ImplRestoreSplitter();
609 : :
610 : 0 : Invalidate();
611 : 0 : }
612 : :
613 : : // -----------------------------------------------------------------------
614 : :
615 : 0 : void Splitter::LoseFocus()
616 : : {
617 [ # # ]: 0 : if( mbKbdSplitting )
618 : : {
619 : 0 : KeyCode aReturnKey( KEY_RETURN );
620 [ # # ]: 0 : ImplKbdTracking( aReturnKey );
621 : 0 : mbKbdSplitting = sal_False;
622 : : }
623 : 0 : Invalidate();
624 : 0 : }
625 : :
626 : : // -----------------------------------------------------------------------
627 : :
628 : 0 : void Splitter::KeyInput( const KeyEvent& rKEvt )
629 : : {
630 [ # # ]: 0 : if( mbInKeyEvent )
631 : 0 : return;
632 : :
633 : 0 : mbInKeyEvent = 1;
634 : :
635 [ # # ]: 0 : Splitter *pSibling = ImplFindSibling();
636 : 0 : KeyCode aKeyCode = rKEvt.GetKeyCode();
637 : 0 : sal_uInt16 nCode = aKeyCode.GetCode();
638 [ # # # # : 0 : switch ( nCode )
# # ]
639 : : {
640 : : case KEY_UP:
641 : : case KEY_DOWN:
642 [ # # ]: 0 : if( !mbHorzSplit )
643 : : {
644 [ # # ]: 0 : ImplStartKbdSplitting();
645 [ # # ]: 0 : ImplKbdTracking( aKeyCode );
646 : : }
647 : : else
648 : : {
649 [ # # ]: 0 : if( pSibling )
650 : : {
651 [ # # ]: 0 : pSibling->GrabFocus();
652 [ # # ]: 0 : pSibling->KeyInput( rKEvt );
653 : : }
654 : : }
655 : 0 : break;
656 : : case KEY_RIGHT:
657 : : case KEY_LEFT:
658 [ # # ]: 0 : if( mbHorzSplit )
659 : : {
660 [ # # ]: 0 : ImplStartKbdSplitting();
661 [ # # ]: 0 : ImplKbdTracking( aKeyCode );
662 : : }
663 : : else
664 : : {
665 [ # # ]: 0 : if( pSibling )
666 : : {
667 [ # # ]: 0 : pSibling->GrabFocus();
668 [ # # ]: 0 : pSibling->KeyInput( rKEvt );
669 : : }
670 : : }
671 : 0 : break;
672 : :
673 : : case KEY_DELETE:
674 [ # # ][ # # ]: 0 : if( ImplSplitterActive() )
675 : : {
676 [ # # ]: 0 : if( mbKbdSplitting )
677 : : {
678 : 0 : KeyCode aKey( KEY_ESCAPE );
679 [ # # ]: 0 : ImplKbdTracking( aKey );
680 : : }
681 : :
682 [ # # ]: 0 : StartSplit();
683 : 0 : Point aPos;
684 [ # # ]: 0 : if ( mbHorzSplit )
685 : 0 : aPos.X() = 0;
686 : : else
687 : 0 : aPos.Y() = 0;
688 : 0 : ImplSplitMousePos( aPos );
689 [ # # ]: 0 : Splitting( aPos );
690 : 0 : ImplSplitMousePos( aPos );
691 : 0 : long nTemp = mnSplitPos;
692 [ # # ]: 0 : if ( mbHorzSplit )
693 [ # # ]: 0 : SetSplitPosPixel( aPos.X() );
694 : : else
695 [ # # ]: 0 : SetSplitPosPixel( aPos.Y() );
696 : 0 : mnLastSplitPos = nTemp;
697 [ # # ]: 0 : Split();
698 [ # # ]: 0 : EndSplit();
699 : :
700 : : // Shift-Del deletes both splitters
701 [ # # ][ # # ]: 0 : if( aKeyCode.IsShift() && pSibling )
[ # # ]
702 [ # # ]: 0 : pSibling->KeyInput( rKEvt );
703 : :
704 [ # # ]: 0 : GrabFocusToDocument();
705 : : }
706 : 0 : break;
707 : :
708 : : case KEY_ESCAPE:
709 [ # # ]: 0 : if( mbKbdSplitting )
710 [ # # ]: 0 : ImplKbdTracking( aKeyCode );
711 : : else
712 [ # # ]: 0 : GrabFocusToDocument();
713 : 0 : break;
714 : :
715 : : case KEY_RETURN:
716 [ # # ]: 0 : ImplKbdTracking( aKeyCode );
717 [ # # ]: 0 : GrabFocusToDocument();
718 : 0 : break;
719 : : default: // let any key input fix the splitter
720 [ # # ]: 0 : Window::KeyInput( rKEvt );
721 [ # # ]: 0 : GrabFocusToDocument();
722 : 0 : break;
723 : : }
724 : 0 : mbInKeyEvent = 0;
725 : : }
726 : :
727 : : // -----------------------------------------------------------------------
728 : :
729 : 8 : long Splitter::Notify( NotifyEvent& rNEvt )
730 : : {
731 : 8 : return Window::Notify( rNEvt );
732 : : }
733 : :
734 : : // -----------------------------------------------------------------------
735 : :
736 : 0 : void Splitter::DataChanged( const DataChangedEvent& rDCEvt )
737 : : {
738 : 0 : Window::DataChanged( rDCEvt );
739 [ # # ]: 0 : if( rDCEvt.GetType() == DATACHANGED_SETTINGS )
740 : : {
741 : 0 : Color oldFaceColor = ((AllSettings *) rDCEvt.GetData())->GetStyleSettings().GetFaceColor();
742 [ # # ]: 0 : Color newFaceColor = Application::GetSettings().GetStyleSettings().GetFaceColor();
743 [ # # ][ # # ]: 0 : if( oldFaceColor.IsDark() != newFaceColor.IsDark() )
[ # # ]
744 : : {
745 [ # # ][ # # ]: 0 : if( newFaceColor.IsDark() )
746 [ # # ][ # # ]: 0 : SetBackground( ImplWhiteWall::get() );
747 : : else
748 [ # # ][ # # ]: 0 : SetBackground( ImplBlackWall::get() );
749 : : }
750 : : }
751 : 0 : }
752 : :
753 : : // -----------------------------------------------------------------------
754 : :
755 : 2 : void Splitter::Paint( const Rectangle& rPaintRect )
756 : : {
757 [ + - ]: 2 : DrawRect( rPaintRect );
758 : :
759 [ + - ]: 2 : Polygon aPoly( rPaintRect );
760 [ + - ]: 2 : PolyPolygon aPolyPoly( aPoly );
761 [ + - ]: 2 : DrawTransparent( aPolyPoly, 85 );
762 : :
763 [ - + ]: 2 : if( mbKbdSplitting )
764 : : {
765 [ # # ]: 0 : LineInfo aInfo( LINE_DASH );
766 : : //aInfo.SetDashLen( 2 );
767 : : //aInfo.SetDashCount( 1 );
768 [ # # ]: 0 : aInfo.SetDistance( 1 );
769 [ # # ]: 0 : aInfo.SetDotLen( 2 );
770 [ # # ]: 0 : aInfo.SetDotCount( 3 );
771 : :
772 [ # # ][ # # ]: 0 : DrawPolyLine( aPoly, aInfo );
773 : : }
774 : : else
775 : : {
776 [ + - ]: 2 : DrawRect( rPaintRect );
777 [ + - ][ + - ]: 2 : }
778 : 2 : }
779 : :
780 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
