1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/generic/splitter.cpp
3 // Purpose: wxSplitterWindow implementation
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // For compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
21 #include "wx/splitter.h"
24 #include "wx/string.h"
28 #include "wx/dcclient.h"
29 #include "wx/dcscreen.h"
31 #include "wx/window.h"
32 #include "wx/dialog.h"
35 #include "wx/settings.h"
38 #include "wx/renderer.h"
42 wxDEFINE_EVENT( wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED
, wxSplitterEvent
);
43 wxDEFINE_EVENT( wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING
, wxSplitterEvent
);
44 wxDEFINE_EVENT( wxEVT_COMMAND_SPLITTER_DOUBLECLICKED
, wxSplitterEvent
);
45 wxDEFINE_EVENT( wxEVT_COMMAND_SPLITTER_UNSPLIT
, wxSplitterEvent
);
47 IMPLEMENT_DYNAMIC_CLASS(wxSplitterWindow
, wxWindow
)
58 IMPLEMENT_DYNAMIC_CLASS(wxSplitterEvent
, wxNotifyEvent
)
60 BEGIN_EVENT_TABLE(wxSplitterWindow
, wxWindow
)
61 EVT_PAINT(wxSplitterWindow
::OnPaint
)
62 EVT_SIZE(wxSplitterWindow
::OnSize
)
63 EVT_MOUSE_EVENTS(wxSplitterWindow
::OnMouseEvent
)
64 EVT_MOUSE_CAPTURE_LOST(wxSplitterWindow
::OnMouseCaptureLost
)
66 #if defined( __WXMSW__ ) || defined( __WXMAC__)
67 EVT_SET_CURSOR(wxSplitterWindow
::OnSetCursor
)
71 static bool IsLive(wxSplitterWindow
* wnd
)
73 // with wxSP_LIVE_UPDATE style the splitter windows are always resized
74 // following the mouse movement while it drags the sash, without it we only
75 // draw the sash at the new position but only resize the windows when the
76 // dragging is finished
77 #if defined( __WXMAC__ ) && defined(TARGET_API_MAC_OSX) && TARGET_API_MAC_OSX == 1
78 return true; // Mac can't paint outside paint event - always need live mode
80 return wnd
->HasFlag(wxSP_LIVE_UPDATE
);
84 bool wxSplitterWindow
::Create(wxWindow
*parent
, wxWindowID id
,
90 // allow TABbing from one window to the other
91 style
|= wxTAB_TRAVERSAL
;
93 if ( !wxWindow
::Create(parent
, id
, pos
, size
, style
, name
) )
96 m_lastSize
= GetClientSize();
98 m_permitUnsplitAlways
= (style
& wxSP_PERMIT_UNSPLIT
) != 0;
100 // FIXME: with this line the background is not erased at all under GTK1,
101 // so temporary avoid it there
102 #if !defined(__WXGTK__) || defined(__WXGTK20__)
103 // don't erase the splitter background, it's pointless as we overwrite it
105 SetBackgroundStyle(wxBG_STYLE_CUSTOM
);
111 void wxSplitterWindow
::Init()
113 m_splitMode
= wxSPLIT_VERTICAL
;
114 m_permitUnsplitAlways
= true;
117 m_dragMode
= wxSPLIT_DRAG_NONE
;
122 m_requestedSashPosition
= INT_MAX
;
124 m_lastSize
= wxSize(0,0);
125 m_minimumPaneSize
= 0;
126 m_sashCursorWE
= wxCursor(wxCURSOR_SIZEWE
);
127 m_sashCursorNS
= wxCursor(wxCURSOR_SIZENS
);
128 m_sashTrackerPen
= new wxPen(*wxBLACK
, 2, wxPENSTYLE_SOLID
);
130 m_needUpdating
= false;
134 wxSplitterWindow
::~wxSplitterWindow()
136 delete m_sashTrackerPen
;
139 // ----------------------------------------------------------------------------
140 // entering/leaving sash
141 // ----------------------------------------------------------------------------
143 void wxSplitterWindow
::RedrawIfHotSensitive(bool isHot
)
145 if ( wxRendererNative
::Get().GetSplitterParams(this).isHotSensitive
)
152 //else: we don't change our appearance, don't redraw to avoid flicker
155 void wxSplitterWindow
::OnEnterSash()
159 RedrawIfHotSensitive(true);
162 void wxSplitterWindow
::OnLeaveSash()
164 SetCursor(*wxSTANDARD_CURSOR
);
166 RedrawIfHotSensitive(false);
169 void wxSplitterWindow
::SetResizeCursor()
171 SetCursor(m_splitMode
== wxSPLIT_VERTICAL ? m_sashCursorWE
175 // ----------------------------------------------------------------------------
176 // other event handlers
177 // ----------------------------------------------------------------------------
179 void wxSplitterWindow
::OnPaint(wxPaintEvent
& WXUNUSED(event
))
183 // as subpanels might have a transparent background we must erase the background
184 // at least on OSX, otherwise traces of the sash will remain
185 // test with: splitter sample->replace right window
192 void wxSplitterWindow
::OnInternalIdle()
194 wxWindow
::OnInternalIdle();
196 // We may need to update the children sizes in two cases: either because
197 // we're in the middle of a live update as indicated by m_needUpdating or
198 // because we have a requested but not yet set sash position as indicated
199 // by m_requestedSashPosition having a valid value.
200 if ( m_needUpdating
)
202 m_needUpdating
= false;
204 else if ( m_requestedSashPosition
== INT_MAX
)
206 // We don't need to resize the children.
213 void wxSplitterWindow
::OnMouseEvent(wxMouseEvent
& event
)
215 int x
= (int)event
.GetX(),
216 y
= (int)event
.GetY();
218 if ( GetWindowStyle() & wxSP_NOSASH
)
224 bool isLive
= IsLive(this);
226 if (event
.LeftDown())
228 if ( SashHitTest(x
, y
) )
230 // Start the drag now
231 m_dragMode
= wxSPLIT_DRAG_DRAGGING
;
233 // Capture mouse and set the cursor
239 // remember the initial sash position and draw the initial
241 m_sashPositionCurrent
= m_sashPosition
;
243 m_oldX
= (m_splitMode
== wxSPLIT_VERTICAL ? m_sashPositionCurrent
: x
);
244 m_oldY
= (m_splitMode
!= wxSPLIT_VERTICAL ? m_sashPositionCurrent
: y
);
245 DrawSashTracker(m_oldX
, m_oldY
);
248 m_ptStart
= wxPoint(x
,y
);
249 m_sashStart
= m_sashPosition
;
253 else if (event
.LeftUp() && m_dragMode
== wxSPLIT_DRAG_DRAGGING
)
255 // We can stop dragging now and see what we've got.
256 m_dragMode
= wxSPLIT_DRAG_NONE
;
258 // Release mouse and unset the cursor
260 SetCursor(* wxSTANDARD_CURSOR
);
262 // exit if unsplit after doubleclick
271 DrawSashTracker(m_oldX
, m_oldY
);
274 // the position of the click doesn't exactly correspond to
275 // m_sashPosition, rather it changes it by the distance by which the
277 int diff
= m_splitMode
== wxSPLIT_VERTICAL ? x
- m_ptStart
.x
: y
- m_ptStart
.y
;
279 int posSashNew
= OnSashPositionChanging(m_sashStart
+ diff
);
280 if ( posSashNew
== -1 )
282 // change not allowed
286 if ( m_permitUnsplitAlways
|| m_minimumPaneSize
== 0 )
288 // Deal with possible unsplit scenarios
289 if ( posSashNew
== 0 )
291 // We remove the first window from the view
292 wxWindow
*removedWindow
= m_windowOne
;
293 m_windowOne
= m_windowTwo
;
295 OnUnsplit(removedWindow
);
296 wxSplitterEvent
eventUnsplit(wxEVT_COMMAND_SPLITTER_UNSPLIT
, this);
297 eventUnsplit
.m_data
.win
= removedWindow
;
298 (void)DoSendEvent(eventUnsplit
);
299 SetSashPositionAndNotify(0);
301 else if ( posSashNew
== GetWindowSize() )
303 // We remove the second window from the view
304 wxWindow
*removedWindow
= m_windowTwo
;
306 OnUnsplit(removedWindow
);
307 wxSplitterEvent
eventUnsplit(wxEVT_COMMAND_SPLITTER_UNSPLIT
, this);
308 eventUnsplit
.m_data
.win
= removedWindow
;
309 (void)DoSendEvent(eventUnsplit
);
310 SetSashPositionAndNotify(0);
314 SetSashPositionAndNotify(posSashNew
);
319 SetSashPositionAndNotify(posSashNew
);
323 } // left up && dragging
324 else if ((event
.Moving() || event
.Leaving() || event
.Entering()) && (m_dragMode
== wxSPLIT_DRAG_NONE
))
326 if ( event
.Leaving() || !SashHitTest(x
, y
) )
331 else if (event
.Dragging() && (m_dragMode
== wxSPLIT_DRAG_DRAGGING
))
333 int diff
= m_splitMode
== wxSPLIT_VERTICAL ? x
- m_ptStart
.x
: y
- m_ptStart
.y
;
335 int posSashNew
= OnSashPositionChanging(m_sashStart
+ diff
);
336 if ( posSashNew
== -1 )
338 // change not allowed
344 if ( posSashNew
== m_sashPositionCurrent
)
347 m_sashPositionCurrent
= posSashNew
;
350 DrawSashTracker(m_oldX
, m_oldY
);
352 m_oldX
= (m_splitMode
== wxSPLIT_VERTICAL ? m_sashPositionCurrent
: x
);
353 m_oldY
= (m_splitMode
!= wxSPLIT_VERTICAL ? m_sashPositionCurrent
: y
);
356 // As we captured the mouse, we may get the mouse events from outside
357 // our window - for example, negative values in x, y. This has a weird
358 // consequence under MSW where we use unsigned values sometimes and
359 // signed ones other times: the coordinates turn as big positive
360 // numbers and so the sash is drawn on the *right* side of the window
361 // instead of the left (or bottom instead of top). Correct this.
362 if ( (short)m_oldX
< 0 )
364 if ( (short)m_oldY
< 0 )
369 DrawSashTracker(m_oldX
, m_oldY
);
373 if ( posSashNew
== m_sashPosition
)
376 DoSetSashPosition(posSashNew
);
378 // in live mode, the new position is the actual sash position, clear requested position!
379 m_requestedSashPosition
= INT_MAX
;
380 m_needUpdating
= true;
383 else if ( event
.LeftDClick() && m_windowTwo
)
385 OnDoubleClickSash(x
, y
);
393 void wxSplitterWindow
::OnMouseCaptureLost(wxMouseCaptureLostEvent
& WXUNUSED(event
))
395 if (m_dragMode
!= wxSPLIT_DRAG_DRAGGING
)
398 m_dragMode
= wxSPLIT_DRAG_NONE
;
400 SetCursor(* wxSTANDARD_CURSOR
);
405 DrawSashTracker(m_oldX
, m_oldY
);
409 void wxSplitterWindow
::OnSize(wxSizeEvent
& event
)
411 // only process this message if we're not iconized - otherwise iconizing
412 // and restoring a window containing the splitter has a funny side effect
413 // of changing the splitter position!
414 wxWindow
*parent
= wxGetTopLevelParent(this);
417 wxTopLevelWindow
*winTop
= wxDynamicCast(parent
, wxTopLevelWindow
);
420 iconized
= winTop
->IsIconized();
424 wxFAIL_MSG(wxT("should have a top level parent!"));
431 m_lastSize
= wxSize(0,0);
441 GetClientSize(&w
, &h
);
443 int size
= m_splitMode
== wxSPLIT_VERTICAL ? w
: h
;
445 int old_size
= m_splitMode
== wxSPLIT_VERTICAL ? m_lastSize
.x
: m_lastSize
.y
;
447 // Don't do anything if the size didn't really change. In particular,
448 // it is important that we don't reset our sash position because it's
449 // out of current range in this case as otherwise the really requested
450 // position would be lost and never set. Wait until we get a real size
451 // event with our non-initial size to do it.
452 if ( size
!= old_size
)
454 int delta
= (int) ( (size
- old_size
)*m_sashGravity
);
457 int newPosition
= m_sashPosition
+ delta
;
458 if( newPosition
< m_minimumPaneSize
)
459 newPosition
= m_minimumPaneSize
;
460 SetSashPositionAndNotify(newPosition
);
463 if ( m_sashPosition
>= size
- 5 )
464 SetSashPositionAndNotify(wxMax(10, size
- 40));
465 m_lastSize
= wxSize(w
,h
);
472 void wxSplitterWindow
::SetSashGravity(double gravity
)
474 wxCHECK_RET( gravity
>= 0. && gravity
<= 1.,
475 wxT("invalid gravity value") );
477 m_sashGravity
= gravity
;
480 bool wxSplitterWindow
::SashHitTest(int x
, int y
, int tolerance
)
482 if ( m_windowTwo
== NULL
|| m_sashPosition
== 0)
483 return false; // No sash
485 int z
= m_splitMode
== wxSPLIT_VERTICAL ? x
: y
;
486 int hitMin
= m_sashPosition
- tolerance
;
487 int hitMax
= m_sashPosition
+ GetSashSize() + tolerance
;
489 return z
>= hitMin
&& z
<= hitMax
;
492 int wxSplitterWindow
::GetSashSize() const
494 return wxRendererNative
::Get().GetSplitterParams(this).widthSash
;
497 int wxSplitterWindow
::GetBorderSize() const
499 return wxRendererNative
::Get().GetSplitterParams(this).border
;
503 void wxSplitterWindow
::DrawSash(wxDC
& dc
)
505 if (HasFlag(wxSP_3DBORDER
))
506 wxRendererNative
::Get().DrawSplitterBorder
513 // don't draw sash if we're not split
514 if ( m_sashPosition
== 0 || !m_windowTwo
)
517 // nor if we're configured to not show it
518 if ( HasFlag(wxSP_NOSASH
) )
521 wxRendererNative
::Get().DrawSplitterSash
527 m_splitMode
== wxSPLIT_VERTICAL ? wxVERTICAL
529 m_isHot ?
(int)wxCONTROL_CURRENT
: 0
533 // Draw the sash tracker (for whilst moving the sash)
534 void wxSplitterWindow
::DrawSashTracker(int x
, int y
)
537 GetClientSize(&w
, &h
);
543 if ( m_splitMode
== wxSPLIT_VERTICAL
)
545 x1
= x2
= wxClip(x
, 0, w
) + m_sashTrackerPen
->GetWidth()/2;
551 y1
= y2
= wxClip(y
, 0, h
) + m_sashTrackerPen
->GetWidth()/2;
556 ClientToScreen(&x1
, &y1
);
557 ClientToScreen(&x2
, &y2
);
559 screenDC
.SetLogicalFunction(wxINVERT
);
560 screenDC
.SetPen(*m_sashTrackerPen
);
561 screenDC
.SetBrush(*wxTRANSPARENT_BRUSH
);
563 screenDC
.DrawLine(x1
, y1
, x2
, y2
);
565 screenDC
.SetLogicalFunction(wxCOPY
);
568 int wxSplitterWindow
::GetWindowSize() const
570 wxSize size
= GetClientSize();
572 return m_splitMode
== wxSPLIT_VERTICAL ? size
.x
: size
.y
;
575 int wxSplitterWindow
::AdjustSashPosition(int sashPos
) const
582 // the window shouldn't be smaller than its own minimal size nor
583 // smaller than the minimual pane size specified for this splitter
584 int minSize
= m_splitMode
== wxSPLIT_VERTICAL ? win
->GetMinWidth()
585 : win
->GetMinHeight();
587 if ( minSize
== -1 || m_minimumPaneSize
> minSize
)
588 minSize
= m_minimumPaneSize
;
590 minSize
+= GetBorderSize();
592 if ( sashPos
< minSize
)
599 int minSize
= m_splitMode
== wxSPLIT_VERTICAL ? win
->GetMinWidth()
600 : win
->GetMinHeight();
602 if ( minSize
== -1 || m_minimumPaneSize
> minSize
)
603 minSize
= m_minimumPaneSize
;
605 int maxSize
= GetWindowSize() - minSize
- GetBorderSize() - GetSashSize();
606 if ( maxSize
> 0 && sashPos
> maxSize
&& maxSize
>= m_minimumPaneSize
)
613 bool wxSplitterWindow
::DoSetSashPosition(int sashPos
)
615 int newSashPosition
= AdjustSashPosition(sashPos
);
617 if ( newSashPosition
== m_sashPosition
)
620 m_sashPosition
= newSashPosition
;
625 void wxSplitterWindow
::SetSashPositionAndNotify(int sashPos
)
627 // we must reset the request here, otherwise the sash would be stuck at
628 // old position if the user attempted to move the sash after invalid
629 // (e.g. smaller than minsize) sash position was requested using
630 // SetSashPosition():
631 m_requestedSashPosition
= INT_MAX
;
633 // note that we must send the event in any case, i.e. even if the sash
634 // position hasn't changed and DoSetSashPosition() returns false because we
635 // must generate a CHANGED event at the end of resizing
636 DoSetSashPosition(sashPos
);
638 wxSplitterEvent
event(wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED
, this);
639 event
.m_data
.pos
= m_sashPosition
;
641 (void)DoSendEvent(event
);
644 // Position and size subwindows.
645 // Note that the border size applies to each subwindow, not
646 // including the edges next to the sash.
647 void wxSplitterWindow
::SizeWindows()
649 // check if we have delayed setting the real sash position
650 if ( m_requestedSashPosition
!= INT_MAX
)
652 int newSashPosition
= ConvertSashPosition(m_requestedSashPosition
);
653 if ( newSashPosition
!= m_sashPosition
)
655 DoSetSashPosition(newSashPosition
);
658 if ( newSashPosition
<= m_sashPosition
659 && newSashPosition
>= m_sashPosition
- GetBorderSize() )
661 // don't update it any more
662 m_requestedSashPosition
= INT_MAX
;
667 GetClientSize(&w
, &h
);
669 if ( GetWindow1() && !GetWindow2() )
671 GetWindow1()->SetSize(GetBorderSize(), GetBorderSize(),
672 w
- 2*GetBorderSize(), h
- 2*GetBorderSize());
674 else if ( GetWindow1() && GetWindow2() )
676 const int border
= GetBorderSize(),
677 sash
= GetSashSize();
679 int size1
= GetSashPosition() - border
,
680 size2
= GetSashPosition() + sash
;
682 int x2
, y2
, w1
, h1
, w2
, h2
;
683 if ( GetSplitMode() == wxSPLIT_VERTICAL
)
686 w2
= w
- 2*border
- sash
- w1
;
696 else // horz splitter
703 h2
= h
- 2*border
- sash
- h1
;
710 GetWindow2()->SetSize(x2
, y2
, w2
, h2
);
711 GetWindow1()->SetSize(border
, border
, w1
, h1
);
718 // Set pane for unsplit window
719 void wxSplitterWindow
::Initialize(wxWindow
*window
)
721 wxASSERT_MSG( (!window
|| window
->GetParent() == this),
722 wxT("windows in the splitter should have it as parent!") );
724 if (window
&& !window
->IsShown())
727 m_windowOne
= window
;
729 DoSetSashPosition(0);
732 // Associates the given window with window 2, drawing the appropriate sash
733 // and changing the split mode.
734 // Does nothing and returns false if the window is already split.
735 bool wxSplitterWindow
::DoSplit(wxSplitMode mode
,
736 wxWindow
*window1
, wxWindow
*window2
,
742 wxCHECK_MSG( window1
&& window2
, false,
743 wxT("cannot split with NULL window(s)") );
745 wxCHECK_MSG( window1
->GetParent() == this && window2
->GetParent() == this, false,
746 wxT("windows in the splitter should have it as parent!") );
748 if (! window1
->IsShown())
750 if (! window2
->IsShown())
754 m_windowOne
= window1
;
755 m_windowTwo
= window2
;
758 SetSashPosition(sashPosition
, true);
762 int wxSplitterWindow
::ConvertSashPosition(int sashPosition
) const
764 if ( sashPosition
> 0 )
768 else if ( sashPosition
< 0 )
770 // It's negative so adding is subtracting
771 return GetWindowSize() + sashPosition
;
773 else // sashPosition == 0
775 // default, put it in the centre
776 return GetWindowSize() / 2;
780 // Remove the specified (or second) window from the view
781 // Doesn't actually delete the window.
782 bool wxSplitterWindow
::Unsplit(wxWindow
*toRemove
)
788 if ( toRemove
== NULL
|| toRemove
== m_windowTwo
)
793 else if ( toRemove
== m_windowOne
)
796 m_windowOne
= m_windowTwo
;
801 wxFAIL_MSG(wxT("splitter: attempt to remove a non-existent window"));
807 DoSetSashPosition(0);
813 // Replace a window with another one
814 bool wxSplitterWindow
::ReplaceWindow(wxWindow
*winOld
, wxWindow
*winNew
)
816 wxCHECK_MSG( winOld
, false, wxT("use one of Split() functions instead") );
817 wxCHECK_MSG( winNew
, false, wxT("use Unsplit() functions instead") );
819 if ( winOld
== m_windowTwo
)
821 m_windowTwo
= winNew
;
823 else if ( winOld
== m_windowOne
)
825 m_windowOne
= winNew
;
829 wxFAIL_MSG(wxT("splitter: attempt to replace a non-existent window"));
839 void wxSplitterWindow
::SetMinimumPaneSize(int min
)
841 m_minimumPaneSize
= min
;
842 int pos
= m_requestedSashPosition
!= INT_MAX ? m_requestedSashPosition
: m_sashPosition
;
843 SetSashPosition(pos
); // re-check limits
846 void wxSplitterWindow
::SetSashPosition(int position
, bool redraw
)
848 // remember the sash position we want to set for later if we can't set it
849 // right now (e.g. because the window is too small)
850 m_requestedSashPosition
= position
;
852 DoSetSashPosition(ConvertSashPosition(position
));
860 // Make sure the child window sizes are updated. This is useful
861 // for reducing flicker by updating the sizes before a
862 // window is shown, if you know the overall size is correct.
863 void wxSplitterWindow
::UpdateSize()
868 bool wxSplitterWindow
::DoSendEvent(wxSplitterEvent
& event
)
870 return !GetEventHandler()->ProcessEvent(event
) || event
.IsAllowed();
873 wxSize wxSplitterWindow
::DoGetBestSize() const
875 // get best sizes of subwindows
878 size1
= m_windowOne
->GetEffectiveMinSize();
880 size2
= m_windowTwo
->GetEffectiveMinSize();
884 // pSash points to the size component to which sash size must be added
887 if ( m_splitMode
== wxSPLIT_VERTICAL
)
889 sizeBest
.y
= wxMax(size1
.y
, size2
.y
);
890 sizeBest
.x
= wxMax(size1
.x
, m_minimumPaneSize
) +
891 wxMax(size2
.x
, m_minimumPaneSize
);
895 else // wxSPLIT_HORIZONTAL
897 sizeBest
.x
= wxMax(size1
.x
, size2
.x
);
898 sizeBest
.y
= wxMax(size1
.y
, m_minimumPaneSize
) +
899 wxMax(size2
.y
, m_minimumPaneSize
);
904 // account for the sash if the window is actually split
905 if ( m_windowOne
&& m_windowTwo
)
906 *pSash
+= GetSashSize();
908 // account for the border too
909 int border
= 2*GetBorderSize();
910 sizeBest
.x
+= border
;
911 sizeBest
.y
+= border
;
916 // ---------------------------------------------------------------------------
917 // wxSplitterWindow virtual functions: they now just generate the events
918 // ---------------------------------------------------------------------------
920 bool wxSplitterWindow
::OnSashPositionChange(int WXUNUSED(newSashPosition
))
922 // always allow by default
926 int wxSplitterWindow
::OnSashPositionChanging(int newSashPosition
)
928 // If within UNSPLIT_THRESHOLD from edge, set to edge to cause closure.
929 const int UNSPLIT_THRESHOLD
= 4;
931 // first of all, check if OnSashPositionChange() doesn't forbid this change
932 if ( !OnSashPositionChange(newSashPosition
) )
938 // Obtain relevant window dimension for bottom / right threshold check
939 int window_size
= GetWindowSize();
941 bool unsplit_scenario
= false;
942 if ( m_permitUnsplitAlways
|| m_minimumPaneSize
== 0 )
944 // Do edge detection if unsplit premitted
945 if ( newSashPosition
<= UNSPLIT_THRESHOLD
)
947 // threshold top / left check
949 unsplit_scenario
= true;
951 if ( newSashPosition
>= window_size
- UNSPLIT_THRESHOLD
)
953 // threshold bottom/right check
954 newSashPosition
= window_size
;
955 unsplit_scenario
= true;
959 if ( !unsplit_scenario
)
961 // If resultant pane would be too small, enlarge it
962 newSashPosition
= AdjustSashPosition(newSashPosition
);
964 // If the result is out of bounds it means minimum size is too big,
965 // so split window in half as best compromise.
966 if ( newSashPosition
< 0 || newSashPosition
> window_size
)
967 newSashPosition
= window_size
/ 2;
970 // now let the event handler have it
972 // FIXME: shouldn't we do it before the adjustments above so as to ensure
973 // that the sash position is always reasonable?
974 wxSplitterEvent
event(wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING
, this);
975 event
.m_data
.pos
= newSashPosition
;
977 if ( !DoSendEvent(event
) )
979 // the event handler vetoed the change
980 newSashPosition
= -1;
984 // it could have been changed by it
985 newSashPosition
= event
.GetSashPosition();
988 return newSashPosition
;
991 // Called when the sash is double-clicked. The default behaviour is to remove
992 // the sash if the minimum pane size is zero.
993 void wxSplitterWindow
::OnDoubleClickSash(int x
, int y
)
995 wxCHECK_RET(m_windowTwo
, wxT("splitter: no window to remove"));
997 // new code should handle events instead of using the virtual functions
998 wxSplitterEvent
event(wxEVT_COMMAND_SPLITTER_DOUBLECLICKED
, this);
999 event
.m_data
.pt
.x
= x
;
1000 event
.m_data
.pt
.y
= y
;
1001 if ( DoSendEvent(event
) )
1003 if ( GetMinimumPaneSize() == 0 || m_permitUnsplitAlways
)
1005 wxWindow
* win
= m_windowTwo
;
1008 wxSplitterEvent
unsplitEvent(wxEVT_COMMAND_SPLITTER_UNSPLIT
, this);
1009 unsplitEvent
.m_data
.win
= win
;
1010 (void)DoSendEvent(unsplitEvent
);
1014 //else: blocked by user
1017 void wxSplitterWindow
::OnUnsplit(wxWindow
*winRemoved
)
1019 // call this before calling the event handler which may delete the window
1020 winRemoved
->Show(false);
1023 #if defined( __WXMSW__ ) || defined( __WXMAC__)
1025 // this is currently called (and needed) under MSW only...
1026 void wxSplitterWindow
::OnSetCursor(wxSetCursorEvent
& event
)
1028 // if we don't do it, the resizing cursor might be set for child window:
1029 // and like this we explicitly say that our cursor should not be used for
1030 // children windows which overlap us
1032 if ( SashHitTest(event
.GetX(), event
.GetY(), 0) )
1034 // default processing is ok
1037 //else: do nothing, in particular, don't call Skip()
1040 #endif // wxMSW || wxMac
1042 #endif // wxUSE_SPLITTER