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