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