1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: wxSplitterWindow implementation
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart and Markus Holzem
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
13 #pragma implementation "splitter.h"
16 // For compilers that support precompilation, includes "wx.h".
17 #include "wx/wxprec.h"
24 #include "wx/window.h"
25 #include "wx/dialog.h"
31 #include "wx/string.h"
32 #include "wx/splitter.h"
33 #include "wx/dcscreen.h"
34 #include "wx/settings.h"
36 IMPLEMENT_DYNAMIC_CLASS(wxSplitterWindow
, wxWindow
)
37 IMPLEMENT_DYNAMIC_CLASS(wxSplitterEvent
, wxCommandEvent
)
39 BEGIN_EVENT_TABLE(wxSplitterWindow
, wxWindow
)
40 EVT_PAINT(wxSplitterWindow::OnPaint
)
41 EVT_SIZE(wxSplitterWindow::OnSize
)
42 EVT_IDLE(wxSplitterWindow::OnIdle
)
43 EVT_MOUSE_EVENTS(wxSplitterWindow::OnMouseEvent
)
45 EVT_SET_CURSOR(wxSplitterWindow::OnSetCursor
)
47 EVT_SPLITTER_SASH_POS_CHANGED(-1, wxSplitterWindow::OnSashPosChanged
)
48 // NB: we borrow OnSashPosChanged for purposes of
49 // EVT_SPLITTER_SASH_POS_CHANGING since default implementation is identical
50 EVT_SPLITTER_SASH_POS_CHANGING(-1, wxSplitterWindow::OnSashPosChanged
)
51 EVT_SPLITTER_DCLICK(-1, wxSplitterWindow::OnDoubleClick
)
52 EVT_SPLITTER_UNSPLIT(-1, wxSplitterWindow::OnUnsplitEvent
)
55 wxSplitterWindow::wxSplitterWindow()
57 m_splitMode
= wxSPLIT_VERTICAL
;
58 m_permitUnsplitAlways
= FALSE
;
59 m_windowOne
= (wxWindow
*) NULL
;
60 m_windowTwo
= (wxWindow
*) NULL
;
61 m_dragMode
= wxSPLIT_DRAG_NONE
;
69 m_sashCursorWE
= (wxCursor
*) NULL
;
70 m_sashCursorNS
= (wxCursor
*) NULL
;
71 m_sashTrackerPen
= (wxPen
*) NULL
;
72 m_lightShadowPen
= (wxPen
*) NULL
;
73 m_mediumShadowPen
= (wxPen
*) NULL
;
74 m_darkShadowPen
= (wxPen
*) NULL
;
75 m_faceBrush
= (wxBrush
*) NULL
;
76 m_facePen
= (wxPen
*) NULL
;
77 m_hilightPen
= (wxPen
*) NULL
;
78 m_minimumPaneSize
= 0;
79 m_needUpdating
= FALSE
;
82 wxSplitterWindow::wxSplitterWindow(wxWindow
*parent
, wxWindowID id
,
87 : wxWindow(parent
, id
, pos
, size
, style
, name
)
89 m_splitMode
= wxSPLIT_VERTICAL
;
90 m_permitUnsplitAlways
= (style
& wxSP_PERMIT_UNSPLIT
) != 0;
91 m_windowOne
= (wxWindow
*) NULL
;
92 m_windowTwo
= (wxWindow
*) NULL
;
93 m_dragMode
= wxSPLIT_DRAG_NONE
;
101 m_minimumPaneSize
= 0;
102 m_sashCursorWE
= new wxCursor(wxCURSOR_SIZEWE
);
103 m_sashCursorNS
= new wxCursor(wxCURSOR_SIZENS
);
104 m_sashTrackerPen
= new wxPen(*wxBLACK
, 2, wxSOLID
);
105 m_lightShadowPen
= (wxPen
*) NULL
;
106 m_mediumShadowPen
= (wxPen
*) NULL
;
107 m_darkShadowPen
= (wxPen
*) NULL
;
108 m_faceBrush
= (wxBrush
*) NULL
;
109 m_facePen
= (wxPen
*) NULL
;
110 m_hilightPen
= (wxPen
*) NULL
;
112 if ( style
& wxSP_3D
)
117 else if ( style
& wxSP_BORDER
)
128 // Eventually, we'll respond to colour change messages
131 // For debugging purposes, to see the background.
132 // SetBackground(wxBLUE_BRUSH);
134 m_needUpdating
= FALSE
;
137 wxSplitterWindow::~wxSplitterWindow()
139 delete m_sashCursorWE
;
140 delete m_sashCursorNS
;
141 delete m_sashTrackerPen
;
142 delete m_lightShadowPen
;
143 delete m_darkShadowPen
;
144 delete m_mediumShadowPen
;
150 void wxSplitterWindow::OnPaint(wxPaintEvent
& WXUNUSED(event
))
154 if ( m_borderSize
> 0 )
159 void wxSplitterWindow::OnIdle(wxIdleEvent
& WXUNUSED(event
))
165 void wxSplitterWindow::OnMouseEvent(wxMouseEvent
& event
)
167 wxCoord x
= (wxCoord
)event
.GetX(),
168 y
= (wxCoord
)event
.GetY();
172 SetCursor(* wxSTANDARD_CURSOR
);
175 SetCursor(wxCursor());
179 if (event
.LeftDown())
181 if ( SashHitTest(x
, y
) )
185 m_dragMode
= wxSPLIT_DRAG_DRAGGING
;
187 if ((GetWindowStyleFlag() & wxSP_LIVE_UPDATE
) == 0)
189 DrawSashTracker(x
, y
);
195 if ( m_splitMode
== wxSPLIT_VERTICAL
)
197 SetCursor(*m_sashCursorWE
);
201 SetCursor(*m_sashCursorNS
);
206 else if (event
.LeftUp() && m_dragMode
== wxSPLIT_DRAG_DRAGGING
)
208 // We can stop dragging now and see what we've got.
209 m_dragMode
= wxSPLIT_DRAG_NONE
;
213 if ((GetWindowStyleFlag() & wxSP_LIVE_UPDATE
) == 0)
215 DrawSashTracker(m_oldX
, m_oldY
);
218 // Obtain window size. We are only interested in the dimension the sash
221 GetClientSize(&w
, &h
);
222 int window_size
= (m_splitMode
== wxSPLIT_VERTICAL
? w
: h
);
223 int new_sash_position
=
224 (int) ( m_splitMode
== wxSPLIT_VERTICAL
? x
: y
);
226 wxSplitterEvent
eventSplitter(wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED
,
228 eventSplitter
.m_data
.pos
= new_sash_position
;
229 if ( GetEventHandler()->ProcessEvent(eventSplitter
) )
231 new_sash_position
= eventSplitter
.GetSashPosition();
232 if ( new_sash_position
== -1 )
234 // change not allowed
239 if ( m_permitUnsplitAlways
|| m_minimumPaneSize
== 0 )
241 // Deal with possible unsplit scenarios
242 if ( new_sash_position
== 0 )
244 // We remove the first window from the view
245 wxWindow
*removedWindow
= m_windowOne
;
246 m_windowOne
= m_windowTwo
;
247 m_windowTwo
= (wxWindow
*) NULL
;
248 SendUnsplitEvent(removedWindow
);
251 else if ( new_sash_position
== window_size
)
253 // We remove the second window from the view
254 wxWindow
*removedWindow
= m_windowTwo
;
255 m_windowTwo
= (wxWindow
*) NULL
;
256 SendUnsplitEvent(removedWindow
);
261 m_sashPosition
= new_sash_position
;
266 m_sashPosition
= new_sash_position
;
270 m_needUpdating
= FALSE
;
271 } // left up && dragging
272 else if (event
.Moving() && !event
.Dragging())
274 // Just change the cursor if required
275 if ( SashHitTest(x
, y
) )
277 if ( m_splitMode
== wxSPLIT_VERTICAL
)
279 SetCursor(*m_sashCursorWE
);
283 SetCursor(*m_sashCursorNS
);
286 #if defined(__WXGTK__) || defined(__WXMSW__)
289 // We must set the normal cursor in MSW, because
290 // if the child window doesn't have a cursor, the
291 // parent's (splitter window) will be used, and this
292 // must be the standard cursor.
293 wxLogDebug("wxSplitterWindow: Setting to standard cursor");
295 // where else do we unset the cursor?
296 SetCursor(* wxSTANDARD_CURSOR
);
300 m_needUpdating
= FALSE
;
302 else if (event
.Dragging() && (m_dragMode
== wxSPLIT_DRAG_DRAGGING
))
305 // Otherwise, the cursor sometimes reverts to the normal cursor
307 if ( m_splitMode
== wxSPLIT_VERTICAL
)
309 SetCursor(*m_sashCursorWE
);
313 SetCursor(*m_sashCursorNS
);
317 // Obtain window size. We are only interested in the dimension the sash
319 int new_sash_position
=
320 (int) ( m_splitMode
== wxSPLIT_VERTICAL
? x
: y
);
322 wxSplitterEvent
eventSplitter(wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING
,
324 eventSplitter
.m_data
.pos
= new_sash_position
;
325 if ( GetEventHandler()->ProcessEvent(eventSplitter
) )
327 new_sash_position
= eventSplitter
.GetSashPosition();
328 if ( new_sash_position
== -1 )
330 // change not allowed
336 if ((GetWindowStyleFlag() & wxSP_LIVE_UPDATE
) == 0)
338 DrawSashTracker(m_oldX
, m_oldY
);
341 if (m_splitMode
== wxSPLIT_VERTICAL
)
342 x
= new_sash_position
;
344 y
= new_sash_position
;
346 if (new_sash_position
!= -1)
348 // Only modify if permitted
354 // As we captured the mouse, we may get the mouse events from outside
355 // our window - for example, negative values in x, y. This has a weird
356 // consequence under MSW where we use unsigned values sometimes and
357 // signed ones other times: the coordinates turn as big positive
358 // numbers and so the sash is drawn on the *right* side of the window
359 // instead of the left (or bottom instead of top). Correct this.
360 if ( (short)m_oldX
< 0 )
362 if ( (short)m_oldY
< 0 )
367 if ((GetWindowStyleFlag() & wxSP_LIVE_UPDATE
) == 0)
369 DrawSashTracker(m_oldX
, m_oldY
);
373 m_sashPosition
= new_sash_position
;
374 m_needUpdating
= TRUE
;
377 else if ( event
.LeftDClick() )
379 wxSplitterEvent
eventSplitter(wxEVT_COMMAND_SPLITTER_DOUBLECLICKED
,
381 eventSplitter
.m_data
.pt
.x
= x
;
382 eventSplitter
.m_data
.pt
.y
= y
;
384 (void)GetEventHandler()->ProcessEvent(eventSplitter
);
388 void wxSplitterWindow::OnSize(wxSizeEvent
& event
)
390 // only process this message if we're not iconized - otherwise iconizing
391 // and restoring a window containing the splitter has a funny side effect
392 // of changing the splitter position!
393 wxWindow
*parent
= GetParent();
394 while ( parent
&& !parent
->IsTopLevel() )
396 parent
= parent
->GetParent();
399 bool iconized
= FALSE
;
400 wxFrame
*frame
= wxDynamicCast(parent
, wxFrame
);
402 iconized
= frame
->IsIconized();
405 wxDialog
*dialog
= wxDynamicCast(parent
, wxDialog
);
407 iconized
= dialog
->IsIconized();
409 wxFAIL_MSG(wxT("should have a top level frame or dialog parent!"));
419 GetClientSize( &cw
, &ch
);
422 if ( m_splitMode
== wxSPLIT_VERTICAL
)
424 if ( m_sashPosition
>= (cw
- 5) )
425 m_sashPosition
= wxMax(10, cw
- 40);
427 if ( m_splitMode
== wxSPLIT_HORIZONTAL
)
429 if ( m_sashPosition
>= (ch
- 5) )
430 m_sashPosition
= wxMax(10, ch
- 40);
438 bool wxSplitterWindow::SashHitTest(int x
, int y
, int tolerance
)
440 if ( m_windowTwo
== NULL
|| m_sashPosition
== 0)
441 return FALSE
; // No sash
443 if ( m_splitMode
== wxSPLIT_VERTICAL
)
445 if ( (x
>= m_sashPosition
- tolerance
) && (x
<= m_sashPosition
+ m_sashSize
+ tolerance
) )
452 if ( (y
>= (m_sashPosition
- tolerance
)) && (y
<= (m_sashPosition
+ m_sashSize
+ tolerance
)) )
459 // Draw 3D effect borders
460 void wxSplitterWindow::DrawBorders(wxDC
& dc
)
463 GetClientSize(&w
, &h
);
465 if ( GetWindowStyleFlag() & wxSP_3D
)
468 dc
.SetPen(*m_facePen
);
469 dc
.SetBrush(*m_faceBrush
);
470 dc
.DrawRectangle(1, 1 , w
-1, m_borderSize
-2 ); //high
471 dc
.DrawRectangle(1, m_borderSize
-2 , m_borderSize
-2, h
-1 ); // left
472 dc
.DrawRectangle(w
-m_borderSize
+2, m_borderSize
-2 , w
-1, h
-1 ); // right
473 dc
.DrawRectangle(m_borderSize
-2, h
-m_borderSize
+2 , w
-m_borderSize
+2, h
-1 ); //bottom
475 dc
.SetPen(*m_mediumShadowPen
);
476 dc
.DrawLine(m_borderSize
-2, m_borderSize
-2, w
-m_borderSize
+1, m_borderSize
-2);
477 dc
.DrawLine(m_borderSize
-2, m_borderSize
-2, m_borderSize
-2, h
-m_borderSize
+1);
479 dc
.SetPen(*m_darkShadowPen
);
480 dc
.DrawLine(m_borderSize
-1, m_borderSize
-1, w
-m_borderSize
, m_borderSize
-1);
481 dc
.DrawLine(m_borderSize
-1, m_borderSize
-1, m_borderSize
-1, h
-m_borderSize
);
483 dc
.SetPen(*m_hilightPen
);
484 dc
.DrawLine(m_borderSize
- 2, h
-m_borderSize
+1, w
-m_borderSize
+1, h
-m_borderSize
+1);
485 dc
.DrawLine(w
-m_borderSize
+1, m_borderSize
- 2, w
-m_borderSize
+1, h
-m_borderSize
+2); // Surely the maximum y pos. should be h - 1.
486 /// Anyway, h is required for MSW.
488 dc
.SetPen(*m_lightShadowPen
);
489 dc
.DrawLine(w
-m_borderSize
, m_borderSize
-1, w
-m_borderSize
, h
-m_borderSize
); // Right hand side
490 dc
.DrawLine(m_borderSize
-1, h
-m_borderSize
, w
-m_borderSize
+1, h
-m_borderSize
); // Bottom
492 else if ( GetWindowStyleFlag() & wxSP_BORDER
)
494 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
495 dc
.SetPen(*wxBLACK_PEN
);
496 dc
.DrawRectangle(0, 0, w
-1, h
-1);
499 dc
.SetPen(wxNullPen
);
500 dc
.SetBrush(wxNullBrush
);
504 void wxSplitterWindow::DrawSash(wxDC
& dc
)
506 if ( m_sashPosition
== 0 || !m_windowTwo
)
510 GetClientSize(&w
, &h
);
512 if ( GetWindowStyleFlag() & wxSP_3D
)
514 if ( m_splitMode
== wxSPLIT_VERTICAL
)
516 dc
.SetPen(*m_facePen
);
517 dc
.SetBrush(*m_faceBrush
);
518 dc
.DrawRectangle(m_sashPosition
+ 2, 0 , m_sashSize
- 4, h
);
520 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
522 dc
.SetPen(*m_lightShadowPen
);
523 int xShadow
= m_borderSize
? m_borderSize
- 1 : 0 ;
524 dc
.DrawLine(m_sashPosition
, xShadow
, m_sashPosition
, h
-m_borderSize
);
526 dc
.SetPen(*m_hilightPen
);
527 dc
.DrawLine(m_sashPosition
+1, m_borderSize
- 2, m_sashPosition
+1, h
- m_borderSize
+2);
529 dc
.SetPen(*m_mediumShadowPen
);
530 int yMedium
= m_borderSize
? h
-m_borderSize
+1 : h
;
531 dc
.DrawLine(m_sashPosition
+m_sashSize
-2, xShadow
, m_sashPosition
+m_sashSize
-2, yMedium
);
533 dc
.SetPen(*m_darkShadowPen
);
534 dc
.DrawLine(m_sashPosition
+m_sashSize
-1, m_borderSize
, m_sashPosition
+m_sashSize
-1, h
-m_borderSize
);
538 dc
.SetPen(*m_facePen
);
539 dc
.SetBrush(*m_faceBrush
);
540 dc
.DrawRectangle( m_borderSize
-2, m_sashPosition
+ 2, w
-m_borderSize
+2, m_sashSize
- 4);
542 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
544 dc
.SetPen(*m_lightShadowPen
);
545 dc
.DrawLine(m_borderSize
-1, m_sashPosition
, w
-m_borderSize
, m_sashPosition
);
547 dc
.SetPen(*m_hilightPen
);
548 dc
.DrawLine(m_borderSize
-2, m_sashPosition
+1, w
-m_borderSize
+1, m_sashPosition
+1);
550 dc
.SetPen(*m_mediumShadowPen
);
551 dc
.DrawLine(m_borderSize
-1, m_sashPosition
+m_sashSize
-2, w
-m_borderSize
+1, m_sashPosition
+m_sashSize
-2);
553 dc
.SetPen(*m_darkShadowPen
);
554 dc
.DrawLine(m_borderSize
, m_sashPosition
+m_sashSize
-1, w
-m_borderSize
, m_sashPosition
+m_sashSize
-1);
559 if ( m_splitMode
== wxSPLIT_VERTICAL
)
561 dc
.SetPen(*wxBLACK_PEN
);
562 dc
.SetBrush(*wxBLACK_BRUSH
);
564 if ( (GetWindowStyleFlag() & wxSP_BORDER
) != wxSP_BORDER
)
565 h1
+= 1; // Not sure why this is necessary...
566 dc
.DrawRectangle(m_sashPosition
, 0, m_sashSize
, h1
);
570 dc
.SetPen(*wxBLACK_PEN
);
571 dc
.SetBrush(*wxBLACK_BRUSH
);
573 if ( (GetWindowStyleFlag() & wxSP_BORDER
) != wxSP_BORDER
)
576 dc
.DrawRectangle(0, m_sashPosition
, w1
, m_sashSize
);
581 dc
.SetPen(wxNullPen
);
582 dc
.SetBrush(wxNullBrush
);
585 // Draw the sash tracker (for whilst moving the sash)
586 void wxSplitterWindow::DrawSashTracker(int x
, int y
)
589 GetClientSize(&w
, &h
);
595 if ( m_splitMode
== wxSPLIT_VERTICAL
)
626 ClientToScreen(&x1
, &y1
);
627 ClientToScreen(&x2
, &y2
);
629 screenDC
.SetLogicalFunction(wxINVERT
);
630 screenDC
.SetPen(*m_sashTrackerPen
);
631 screenDC
.SetBrush(*wxTRANSPARENT_BRUSH
);
633 screenDC
.DrawLine(x1
, y1
, x2
, y2
);
635 screenDC
.SetLogicalFunction(wxCOPY
);
637 screenDC
.SetPen(wxNullPen
);
638 screenDC
.SetBrush(wxNullBrush
);
641 // Position and size subwindows.
642 // Note that the border size applies to each subwindow, not
643 // including the edges next to the sash.
644 void wxSplitterWindow::SizeWindows()
647 GetClientSize(&w
, &h
);
649 if ( m_windowOne
&& !m_windowTwo
)
651 m_windowOne
->SetSize(m_borderSize
, m_borderSize
, w
- 2*m_borderSize
, h
- 2*m_borderSize
);
654 else if ( m_windowOne
&& m_windowTwo
)
656 if (m_splitMode
== wxSPLIT_VERTICAL
)
658 int x1
= m_borderSize
;
659 int y1
= m_borderSize
;
660 int w1
= m_sashPosition
- m_borderSize
;
661 int h1
= h
- 2*m_borderSize
;
663 int x2
= m_sashPosition
+ m_sashSize
;
664 int y2
= m_borderSize
;
665 int w2
= w
- 2*m_borderSize
- m_sashSize
- w1
;
666 int h2
= h
- 2*m_borderSize
;
668 m_windowOne
->SetSize(x1
, y1
, w1
, h1
);
669 m_windowTwo
->SetSize(x2
, y2
, w2
, h2
);
674 m_windowOne
->SetSize(m_borderSize
, m_borderSize
,
675 w
- 2*m_borderSize
, m_sashPosition
- m_borderSize
);
676 m_windowTwo
->SetSize(m_borderSize
, m_sashPosition
+ m_sashSize
,
677 w
- 2*m_borderSize
, h
- 2*m_borderSize
- m_sashSize
- (m_sashPosition
- m_borderSize
));
682 if ( m_borderSize
> 0 )
687 // Set pane for unsplit window
688 void wxSplitterWindow::Initialize(wxWindow
*window
)
690 m_windowOne
= window
;
691 m_windowTwo
= (wxWindow
*) NULL
;
695 // Associates the given window with window 2, drawing the appropriate sash
696 // and changing the split mode.
697 // Does nothing and returns FALSE if the window is already split.
698 bool wxSplitterWindow::SplitVertically(wxWindow
*window1
, wxWindow
*window2
, int sashPosition
)
704 GetClientSize(&w
, &h
);
706 m_splitMode
= wxSPLIT_VERTICAL
;
707 m_windowOne
= window1
;
708 m_windowTwo
= window2
;
709 if ( sashPosition
> 0 )
710 m_sashPosition
= sashPosition
;
711 else if ( sashPosition
< 0 )
712 m_sashPosition
= w
- sashPosition
;
714 m_sashPosition
= w
/2;
721 bool wxSplitterWindow::SplitHorizontally(wxWindow
*window1
, wxWindow
*window2
, int sashPosition
)
727 GetClientSize(&w
, &h
);
729 m_splitMode
= wxSPLIT_HORIZONTAL
;
730 m_windowOne
= window1
;
731 m_windowTwo
= window2
;
732 if ( sashPosition
> 0 )
733 m_sashPosition
= sashPosition
;
734 else if ( sashPosition
< 0 )
735 m_sashPosition
= h
- sashPosition
;
737 m_sashPosition
= h
/2;
745 // Remove the specified (or second) window from the view
746 // Doesn't actually delete the window.
747 bool wxSplitterWindow::Unsplit(wxWindow
*toRemove
)
752 wxWindow
*win
= NULL
;
753 if ( toRemove
== NULL
|| toRemove
== m_windowTwo
)
756 m_windowTwo
= (wxWindow
*) NULL
;
758 else if ( toRemove
== m_windowOne
)
761 m_windowOne
= m_windowTwo
;
762 m_windowTwo
= (wxWindow
*) NULL
;
766 wxFAIL_MSG(wxT("splitter: attempt to remove a non-existent window"));
771 SendUnsplitEvent(win
);
778 // Replace a window with another one
779 bool wxSplitterWindow::ReplaceWindow(wxWindow
*winOld
, wxWindow
*winNew
)
781 wxCHECK_MSG( winOld
, FALSE
, wxT("use one of Split() functions instead") );
782 wxCHECK_MSG( winNew
, FALSE
, wxT("use Unsplit() functions instead") );
784 if ( winOld
== m_windowTwo
)
786 m_windowTwo
= winNew
;
788 else if ( winOld
== m_windowOne
)
790 m_windowOne
= winNew
;
794 wxFAIL_MSG(wxT("splitter: attempt to replace a non-existent window"));
804 void wxSplitterWindow::SetSashPosition(int position
, bool redraw
)
806 m_sashPosition
= position
;
814 // Initialize colours
815 void wxSplitterWindow::InitColours()
817 wxDELETE( m_facePen
);
818 wxDELETE( m_faceBrush
);
819 wxDELETE( m_mediumShadowPen
);
820 wxDELETE( m_darkShadowPen
);
821 wxDELETE( m_lightShadowPen
);
822 wxDELETE( m_hilightPen
);
825 #if defined(__WIN95__)
826 wxColour
faceColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE
));
827 m_facePen
= new wxPen(faceColour
, 1, wxSOLID
);
828 m_faceBrush
= new wxBrush(faceColour
, wxSOLID
);
830 wxColour
mediumShadowColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DSHADOW
));
831 m_mediumShadowPen
= new wxPen(mediumShadowColour
, 1, wxSOLID
);
833 wxColour
darkShadowColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DDKSHADOW
));
834 m_darkShadowPen
= new wxPen(darkShadowColour
, 1, wxSOLID
);
836 wxColour
lightShadowColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DLIGHT
));
837 m_lightShadowPen
= new wxPen(lightShadowColour
, 1, wxSOLID
);
839 wxColour
hilightColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DHILIGHT
));
840 m_hilightPen
= new wxPen(hilightColour
, 1, wxSOLID
);
842 m_facePen
= new wxPen("LIGHT GREY", 1, wxSOLID
);
843 m_faceBrush
= new wxBrush("LIGHT GREY", wxSOLID
);
844 m_mediumShadowPen
= new wxPen("GREY", 1, wxSOLID
);
845 m_darkShadowPen
= new wxPen("BLACK", 1, wxSOLID
);
846 m_lightShadowPen
= new wxPen("LIGHT GREY", 1, wxSOLID
);
847 m_hilightPen
= new wxPen("WHITE", 1, wxSOLID
);
848 #endif // Win32/!Win32
851 void wxSplitterWindow::SendUnsplitEvent(wxWindow
*winRemoved
)
853 wxSplitterEvent
event(wxEVT_COMMAND_SPLITTER_UNSPLIT
, this);
854 event
.m_data
.win
= winRemoved
;
856 (void)GetEventHandler()->ProcessEvent(event
);
859 // ---------------------------------------------------------------------------
860 // splitter event handlers
861 // ---------------------------------------------------------------------------
863 void wxSplitterWindow::OnSashPosChanged(wxSplitterEvent
& event
)
865 // If within UNSPLIT_THRESHOLD from edge, set to edge to cause closure.
866 const int UNSPLIT_THRESHOLD
= 4;
868 int newSashPosition
= event
.GetSashPosition();
870 // Obtain relevant window dimension for bottom / right threshold check
872 GetClientSize(&w
, &h
);
873 int window_size
= (m_splitMode
== wxSPLIT_VERTICAL
) ? w
: h
;
875 bool unsplit_scenario
= FALSE
;
876 if ( m_permitUnsplitAlways
877 || m_minimumPaneSize
== 0 )
879 // Do edge detection if unsplit premitted
880 if ( newSashPosition
<= UNSPLIT_THRESHOLD
)
882 // threshold top / left check
884 unsplit_scenario
= TRUE
;
886 if ( newSashPosition
>= window_size
- UNSPLIT_THRESHOLD
)
888 // threshold bottom/right check
889 newSashPosition
= window_size
;
890 unsplit_scenario
= TRUE
;
894 if ( !unsplit_scenario
)
896 // If resultant pane would be too small, enlarge it
897 if ( newSashPosition
< m_minimumPaneSize
)
898 newSashPosition
= m_minimumPaneSize
;
899 if ( newSashPosition
> window_size
- m_minimumPaneSize
)
900 newSashPosition
= window_size
- m_minimumPaneSize
;
903 // If the result is out of bounds it means minimum size is too big,
904 // so split window in half as best compromise.
905 if ( newSashPosition
< 0 || newSashPosition
> window_size
)
906 newSashPosition
= window_size
/ 2;
908 // for compatibility, call the virtual function
909 if ( !OnSashPositionChange(newSashPosition
) )
911 newSashPosition
= -1;
914 event
.SetSashPosition(newSashPosition
);
917 // Called when the sash is double-clicked. The default behaviour is to remove
918 // the sash if the minimum pane size is zero.
919 void wxSplitterWindow::OnDoubleClick(wxSplitterEvent
& event
)
921 // for compatibility, call the virtual function
922 OnDoubleClickSash(event
.GetX(), event
.GetY());
924 if ( GetMinimumPaneSize() == 0 || m_permitUnsplitAlways
)
930 void wxSplitterWindow::OnUnsplitEvent(wxSplitterEvent
& event
)
932 wxWindow
*win
= event
.GetWindowBeingRemoved();
934 // do it before calling OnUnsplit() which may delete the window
937 // for compatibility, call the virtual function
941 void wxSplitterWindow::OnSetCursor(wxSetCursorEvent
& event
)
943 // this is currently called (and needed) under MSW only...
946 // if we don't do it, the resizing cursor might be set for child window:
947 // and like this we explicitly say that our cursor should not be used for
948 // children windows which overlap us
950 if ( SashHitTest(event
.GetX(), event
.GetY()) )
952 // default processing is ok
955 //else: do nothing, in particular, don't call Skip()