]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/generic/splitter.cpp
added mingw32 host platform to configure.in, added WINVER define for windows
[wxWidgets.git] / src / generic / splitter.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: splitter.cpp
3// Purpose: wxSplitterWindow implementation
4// Author: Julian Smart
5// Modified by:
6// Created: 01/02/97
7// RCS-ID: $Id$
8// Copyright: (c) Julian Smart and Markus Holzem
9// Licence: wxWindows license
10/////////////////////////////////////////////////////////////////////////////
11
12#ifdef __GNUG__
13 #pragma implementation "splitter.h"
14#endif
15
16// For compilers that support precompilation, includes "wx.h".
17#include "wx/wxprec.h"
18
19#ifdef __BORLANDC__
20 #pragma hdrstop
21#endif
22
23#ifndef WX_PRECOMP
24 #include "wx/wx.h"
25#endif
26
27#include <stdlib.h>
28
29#include "wx/string.h"
30#include "wx/splitter.h"
31#include "wx/dcscreen.h"
32
33#if !USE_SHARED_LIBRARY
34IMPLEMENT_DYNAMIC_CLASS(wxSplitterWindow, wxWindow)
35IMPLEMENT_DYNAMIC_CLASS(wxSplitterEvent, wxCommandEvent)
36
37BEGIN_EVENT_TABLE(wxSplitterWindow, wxWindow)
38 EVT_PAINT(wxSplitterWindow::OnPaint)
39 EVT_SIZE(wxSplitterWindow::OnSize)
40 EVT_IDLE(wxSplitterWindow::OnIdle)
41 EVT_MOUSE_EVENTS(wxSplitterWindow::OnMouseEvent)
42
43 EVT_SPLITTER_SASH_POS_CHANGED(-1, wxSplitterWindow::OnSashPosChanged)
44 // NB: we borrow OnSashPosChanged for purposes of
45 // EVT_SPLITTER_SASH_POS_CHANGING since default implementation is identical
46 EVT_SPLITTER_SASH_POS_CHANGING(-1, wxSplitterWindow::OnSashPosChanged)
47 EVT_SPLITTER_DCLICK(-1, wxSplitterWindow::OnDoubleClick)
48 EVT_SPLITTER_UNSPLIT(-1, wxSplitterWindow::OnUnsplitEvent)
49END_EVENT_TABLE()
50#endif
51
52wxSplitterWindow::wxSplitterWindow()
53{
54 m_splitMode = wxSPLIT_VERTICAL;
55 m_permitUnsplitAlways = FALSE;
56 m_windowOne = (wxWindow *) NULL;
57 m_windowTwo = (wxWindow *) NULL;
58 m_dragMode = wxSPLIT_DRAG_NONE;
59 m_oldX = 0;
60 m_oldY = 0;
61 m_firstX = 0;
62 m_firstY = 0;
63 m_sashSize = 7;
64 m_borderSize = 2;
65 m_sashPosition = 0;
66 m_sashCursorWE = (wxCursor *) NULL;
67 m_sashCursorNS = (wxCursor *) NULL;
68 m_sashTrackerPen = (wxPen *) NULL;
69 m_lightShadowPen = (wxPen *) NULL;
70 m_mediumShadowPen = (wxPen *) NULL;
71 m_darkShadowPen = (wxPen *) NULL;
72 m_faceBrush = (wxBrush *) NULL;
73 m_facePen = (wxPen *) NULL;
74 m_hilightPen = (wxPen *) NULL;
75 m_minimumPaneSize = 0;
76 m_needUpdating = FALSE;
77}
78
79wxSplitterWindow::wxSplitterWindow(wxWindow *parent, wxWindowID id,
80 const wxPoint& pos,
81 const wxSize& size,
82 long style,
83 const wxString& name)
84 : wxWindow(parent, id, pos, size, style, name)
85{
86 m_splitMode = wxSPLIT_VERTICAL;
87 m_permitUnsplitAlways = (style & wxSP_PERMIT_UNSPLIT) != 0;
88 m_windowOne = (wxWindow *) NULL;
89 m_windowTwo = (wxWindow *) NULL;
90 m_dragMode = wxSPLIT_DRAG_NONE;
91 m_oldX = 0;
92 m_oldY = 0;
93 m_firstX = 0;
94 m_firstY = 0;
95 m_sashSize = 7;
96 m_borderSize = 2;
97 m_sashPosition = 0;
98 m_minimumPaneSize = 0;
99 m_sashCursorWE = new wxCursor(wxCURSOR_SIZEWE);
100 m_sashCursorNS = new wxCursor(wxCURSOR_SIZENS);
101 m_sashTrackerPen = new wxPen(*wxBLACK, 2, wxSOLID);
102 m_lightShadowPen = (wxPen *) NULL;
103 m_mediumShadowPen = (wxPen *) NULL;
104 m_darkShadowPen = (wxPen *) NULL;
105 m_faceBrush = (wxBrush *) NULL;
106 m_facePen = (wxPen *) NULL;
107 m_hilightPen = (wxPen *) NULL;
108
109 if ( style & wxSP_3D )
110 {
111 m_borderSize = 2;
112 m_sashSize = 7;
113 }
114 else if ( style & wxSP_BORDER )
115 {
116 m_borderSize = 1;
117 m_sashSize = 3;
118 }
119 else
120 {
121 m_borderSize = 0;
122 m_sashSize = 3;
123 }
124
125 // Eventually, we'll respond to colour change messages
126 InitColours();
127
128 // For debugging purposes, to see the background.
129// SetBackground(wxBLUE_BRUSH);
130
131 m_needUpdating = FALSE;
132}
133
134wxSplitterWindow::~wxSplitterWindow()
135{
136 delete m_sashCursorWE;
137 delete m_sashCursorNS;
138 delete m_sashTrackerPen;
139 delete m_lightShadowPen;
140 delete m_darkShadowPen;
141 delete m_mediumShadowPen;
142 delete m_hilightPen;
143 delete m_facePen;
144 delete m_faceBrush;
145}
146
147void wxSplitterWindow::OnPaint(wxPaintEvent& WXUNUSED(event))
148{
149 wxPaintDC dc(this);
150
151 if ( m_borderSize > 0 )
152 DrawBorders(dc);
153 DrawSash(dc);
154}
155
156void wxSplitterWindow::OnIdle(wxIdleEvent& WXUNUSED(event))
157{
158 if (m_needUpdating)
159 SizeWindows();
160}
161
162void wxSplitterWindow::OnMouseEvent(wxMouseEvent& event)
163{
164 long x = event.GetX();
165 long y = event.GetY();
166
167 // reset the cursor
168#ifdef __WXMOTIF__
169 SetCursor(* wxSTANDARD_CURSOR);
170#endif
171#ifdef __WXMSW__
172 SetCursor(wxCursor());
173#endif
174
175
176 if (event.LeftDown())
177 {
178 if ( SashHitTest(x, y) )
179 {
180 CaptureMouse();
181
182 m_dragMode = wxSPLIT_DRAG_DRAGGING;
183
184 if ((GetWindowStyleFlag() & wxSP_LIVE_UPDATE) == 0)
185 {
186 DrawSashTracker(x, y);
187 }
188
189 m_oldX = x;
190 m_oldY = y;
191 return;
192 }
193 }
194 else if (event.LeftUp() && m_dragMode == wxSPLIT_DRAG_DRAGGING)
195 {
196 // We can stop dragging now and see what we've got.
197 m_dragMode = wxSPLIT_DRAG_NONE;
198 ReleaseMouse();
199
200 // Erase old tracker
201 if ((GetWindowStyleFlag() & wxSP_LIVE_UPDATE) == 0)
202 {
203 DrawSashTracker(m_oldX, m_oldY);
204 }
205
206 // Obtain window size. We are only interested in the dimension the sash
207 // splits up
208 int w, h;
209 GetClientSize(&w, &h);
210 int window_size = (m_splitMode == wxSPLIT_VERTICAL ? w : h );
211 int new_sash_position =
212 (int) ( m_splitMode == wxSPLIT_VERTICAL ? x : y );
213
214 wxSplitterEvent eventSplitter(wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED,
215 this);
216 eventSplitter.m_data.pos = new_sash_position;
217 if ( GetEventHandler()->ProcessEvent(eventSplitter) )
218 {
219 new_sash_position = eventSplitter.GetSashPosition();
220 if ( new_sash_position == -1 )
221 {
222 // change not allowed
223 return;
224 }
225 }
226
227 if ( m_permitUnsplitAlways
228 || m_minimumPaneSize == 0 )
229 {
230 // Deal with possible unsplit scenarios
231 if ( new_sash_position == 0 )
232 {
233 // We remove the first window from the view
234 wxWindow *removedWindow = m_windowOne;
235 m_windowOne = m_windowTwo;
236 m_windowTwo = (wxWindow *) NULL;
237 SendUnsplitEvent(removedWindow);
238 m_sashPosition = 0;
239 }
240 else if ( new_sash_position == window_size )
241 {
242 // We remove the second window from the view
243 wxWindow *removedWindow = m_windowTwo;
244 m_windowTwo = (wxWindow *) NULL;
245 SendUnsplitEvent(removedWindow);
246 m_sashPosition = 0;
247 }
248 else
249 {
250 m_sashPosition = new_sash_position;
251 }
252 }
253 else
254 {
255 m_sashPosition = new_sash_position;
256 }
257
258 SizeWindows();
259 } // left up && dragging
260 else if (event.Moving() && !event.Dragging())
261 {
262 // Just change the cursor if required
263 if ( SashHitTest(x, y) )
264 {
265 if ( m_splitMode == wxSPLIT_VERTICAL )
266 {
267 SetCursor(*m_sashCursorWE);
268 }
269 else
270 {
271 SetCursor(*m_sashCursorNS);
272 }
273 }
274#ifdef __WXGTK__
275 else
276 {
277 // where else do we unset the cursor?
278 SetCursor(* wxSTANDARD_CURSOR);
279 }
280#endif // __WXGTK__
281 }
282 else if (event.Dragging() && (m_dragMode == wxSPLIT_DRAG_DRAGGING))
283 {
284 // Obtain window size. We are only interested in the dimension the sash
285 // splits up
286 int new_sash_position =
287 (int) ( m_splitMode == wxSPLIT_VERTICAL ? x : y );
288
289 wxSplitterEvent eventSplitter(wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING,
290 this);
291 eventSplitter.m_data.pos = new_sash_position;
292 if ( GetEventHandler()->ProcessEvent(eventSplitter) )
293 {
294 new_sash_position = eventSplitter.GetSashPosition();
295 if ( new_sash_position == -1 )
296 {
297 // change not allowed
298 return;
299 }
300 }
301
302 // Erase old tracker
303 if ((GetWindowStyleFlag() & wxSP_LIVE_UPDATE) == 0)
304 {
305 DrawSashTracker(m_oldX, m_oldY);
306 }
307
308 if (m_splitMode == wxSPLIT_VERTICAL)
309 x = new_sash_position;
310 else
311 y = new_sash_position;
312
313 if (new_sash_position != -1)
314 {
315 // Only modify if permitted
316 m_oldX = x;
317 m_oldY = y;
318 }
319
320#ifdef __WXMSW__
321 // As we captured the mouse, we may get the mouse events from outside
322 // our window - for example, negative values in x, y. This has a weird
323 // consequence under MSW where we use unsigned values sometimes and
324 // signed ones other times: the coordinates turn as big positive
325 // numbers and so the sash is drawn on the *right* side of the window
326 // instead of the left (or bottom instead of top). Correct this.
327 if ( (short)m_oldX < 0 )
328 m_oldX = 0;
329 if ( (short)m_oldY < 0 )
330 m_oldY = 0;
331#endif // __WXMSW__
332
333 // Draw new one
334 if ((GetWindowStyleFlag() & wxSP_LIVE_UPDATE) == 0)
335 {
336 DrawSashTracker(m_oldX, m_oldY);
337 }
338 else
339 {
340 m_sashPosition = new_sash_position;
341 m_needUpdating = TRUE;
342 }
343 }
344 else if ( event.LeftDClick() )
345 {
346 wxSplitterEvent eventSplitter(wxEVT_COMMAND_SPLITTER_DOUBLECLICKED,
347 this);
348 eventSplitter.m_data.pt.x = x;
349 eventSplitter.m_data.pt.y = y;
350
351 (void)GetEventHandler()->ProcessEvent(eventSplitter);
352 }
353}
354
355void wxSplitterWindow::OnSize(wxSizeEvent& event)
356{
357 // only process this message if we're not iconized - otherwise iconizing
358 // and restoring a window containing the splitter has a funny side effect
359 // of changing the splitter position!
360 wxWindow *parent = GetParent();
361 while ( parent && !parent->IsTopLevel() )
362 {
363 parent = parent->GetParent();
364 }
365
366 bool iconized = FALSE;
367 wxFrame *frame = wxDynamicCast(parent, wxFrame);
368 if ( frame )
369 iconized = frame->IsIconized();
370 else
371 {
372 wxDialog *dialog = wxDynamicCast(parent, wxDialog);
373 if ( dialog )
374 iconized = dialog->IsIconized();
375 else
376 wxFAIL_MSG(_T("should have a top level frame or dialog parent!"));
377 }
378
379 if ( iconized )
380 {
381 event.Skip();
382 }
383 else
384 {
385 int cw, ch;
386 GetClientSize( &cw, &ch );
387 if ( m_windowTwo )
388 {
389 if ( m_splitMode == wxSPLIT_VERTICAL )
390 {
391 if ( m_sashPosition >= (cw - 5) )
392 m_sashPosition = wxMax(10, cw - 40);
393 }
394 if ( m_splitMode == wxSPLIT_HORIZONTAL )
395 {
396 if ( m_sashPosition >= (ch - 5) )
397 m_sashPosition = wxMax(10, ch - 40);
398 }
399 }
400
401 SizeWindows();
402 }
403}
404
405bool wxSplitterWindow::SashHitTest(int x, int y, int tolerance)
406{
407 if ( m_windowTwo == NULL || m_sashPosition == 0)
408 return FALSE; // No sash
409
410 if ( m_splitMode == wxSPLIT_VERTICAL )
411 {
412 if ( (x >= m_sashPosition - tolerance) && (x <= m_sashPosition + m_sashSize + tolerance) )
413 return TRUE;
414 else
415 return FALSE;
416 }
417 else
418 {
419 if ( (y >= (m_sashPosition- tolerance)) && (y <= (m_sashPosition + m_sashSize + tolerance)) )
420 return TRUE;
421 else
422 return FALSE;
423 }
424
425 return FALSE;
426}
427
428// Draw 3D effect borders
429void wxSplitterWindow::DrawBorders(wxDC& dc)
430{
431 int w, h;
432 GetClientSize(&w, &h);
433
434 if ( GetWindowStyleFlag() & wxSP_3D )
435 {
436 dc.SetPen(*m_mediumShadowPen);
437 dc.DrawLine(0, 0, w-1, 0);
438 dc.DrawLine(0, 0, 0, h - 1);
439
440 dc.SetPen(*m_darkShadowPen);
441 dc.DrawLine(1, 1, w-2, 1);
442 dc.DrawLine(1, 1, 1, h-2);
443
444 dc.SetPen(*m_hilightPen);
445 dc.DrawLine(0, h-1, w-1, h-1);
446 dc.DrawLine(w-1, 0, w-1, h); // Surely the maximum y pos. should be h - 1.
447 /// Anyway, h is required for MSW.
448
449 dc.SetPen(*m_lightShadowPen);
450 dc.DrawLine(w-2, 1, w-2, h-2); // Right hand side
451 dc.DrawLine(1, h-2, w-1, h-2); // Bottom
452 }
453 else if ( GetWindowStyleFlag() & wxSP_BORDER )
454 {
455 dc.SetBrush(*wxTRANSPARENT_BRUSH);
456 dc.SetPen(*wxBLACK_PEN);
457 dc.DrawRectangle(0, 0, w-1, h-1);
458 }
459
460 dc.SetPen(wxNullPen);
461 dc.SetBrush(wxNullBrush);
462}
463
464// Draw the sash
465void wxSplitterWindow::DrawSash(wxDC& dc)
466{
467 if ( m_sashPosition == 0 || !m_windowTwo)
468 return;
469
470 int w, h;
471 GetClientSize(&w, &h);
472
473 if ( GetWindowStyleFlag() & wxSP_3D )
474 {
475 if ( m_splitMode == wxSPLIT_VERTICAL )
476 {
477 dc.SetPen(*m_facePen);
478 dc.SetBrush(*m_faceBrush);
479 dc.DrawRectangle(m_sashPosition + 2, 0, m_sashSize - 4, h);
480
481 dc.SetBrush(*wxTRANSPARENT_BRUSH);
482
483 dc.SetPen(*m_lightShadowPen);
484 dc.DrawLine(m_sashPosition, 1, m_sashPosition, h-2);
485
486 dc.SetPen(*m_hilightPen);
487 dc.DrawLine(m_sashPosition+1, 0, m_sashPosition+1, h);
488
489 dc.SetPen(*m_mediumShadowPen);
490 dc.DrawLine(m_sashPosition+m_sashSize-2, 1, m_sashPosition+m_sashSize-2, h-1);
491
492 dc.SetPen(*m_darkShadowPen);
493 dc.DrawLine(m_sashPosition+m_sashSize-1, 2, m_sashPosition+m_sashSize-1, h-2);
494 }
495 else
496 {
497 dc.SetPen(*m_facePen);
498 dc.SetBrush(*m_faceBrush);
499 dc.DrawRectangle(0, m_sashPosition + 2, w, m_sashSize - 4);
500
501 dc.SetBrush(*wxTRANSPARENT_BRUSH);
502
503 dc.SetPen(*m_lightShadowPen);
504 dc.DrawLine(1, m_sashPosition, w-2, m_sashPosition);
505
506 dc.SetPen(*m_hilightPen);
507 dc.DrawLine(0, m_sashPosition+1, w, m_sashPosition+1);
508
509 dc.SetPen(*m_mediumShadowPen);
510 dc.DrawLine(1, m_sashPosition+m_sashSize-2, w-1, m_sashPosition+m_sashSize-2);
511
512 dc.SetPen(*m_darkShadowPen);
513 dc.DrawLine(2, m_sashPosition+m_sashSize-1, w-2, m_sashPosition+m_sashSize-1);
514 }
515 }
516 else
517 {
518 if ( m_splitMode == wxSPLIT_VERTICAL )
519 {
520 dc.SetPen(*wxBLACK_PEN);
521 dc.SetBrush(*wxBLACK_BRUSH);
522 int h1 = h-1;
523 if ( (GetWindowStyleFlag() & wxSP_BORDER) != wxSP_BORDER )
524 h1 += 1; // Not sure why this is necessary...
525 dc.DrawRectangle(m_sashPosition, 0, m_sashSize, h1);
526 }
527 else
528 {
529 dc.SetPen(*wxBLACK_PEN);
530 dc.SetBrush(*wxBLACK_BRUSH);
531 int w1 = w-1;
532 if ( (GetWindowStyleFlag() & wxSP_BORDER) != wxSP_BORDER )
533 w1 ++;
534
535 dc.DrawRectangle(0, m_sashPosition, w1, m_sashSize);
536 }
537
538 }
539
540 dc.SetPen(wxNullPen);
541 dc.SetBrush(wxNullBrush);
542}
543
544// Draw the sash tracker (for whilst moving the sash)
545void wxSplitterWindow::DrawSashTracker(int x, int y)
546{
547 int w, h;
548 GetClientSize(&w, &h);
549
550 wxScreenDC screenDC;
551 int x1, y1;
552 int x2, y2;
553
554 if ( m_splitMode == wxSPLIT_VERTICAL )
555 {
556 x1 = x; y1 = 2;
557 x2 = x; y2 = h-2;
558
559 if ( x1 > w )
560 {
561 x1 = w; x2 = w;
562 }
563 else if ( x1 < 0 )
564 {
565 x1 = 0; x2 = 0;
566 }
567 }
568 else
569 {
570 x1 = 2; y1 = y;
571 x2 = w-2; y2 = y;
572
573 if ( y1 > h )
574 {
575 y1 = h;
576 y2 = h;
577 }
578 else if ( y1 < 0 )
579 {
580 y1 = 0;
581 y2 = 0;
582 }
583 }
584
585 ClientToScreen(&x1, &y1);
586 ClientToScreen(&x2, &y2);
587
588 screenDC.SetLogicalFunction(wxINVERT);
589 screenDC.SetPen(*m_sashTrackerPen);
590 screenDC.SetBrush(*wxTRANSPARENT_BRUSH);
591
592 screenDC.DrawLine(x1, y1, x2, y2);
593
594 screenDC.SetLogicalFunction(wxCOPY);
595
596 screenDC.SetPen(wxNullPen);
597 screenDC.SetBrush(wxNullBrush);
598}
599
600// Position and size subwindows.
601// Note that the border size applies to each subwindow, not
602// including the edges next to the sash.
603void wxSplitterWindow::SizeWindows()
604{
605 int w, h;
606 GetClientSize(&w, &h);
607
608 if ( m_windowOne && !m_windowTwo )
609 {
610 m_windowOne->SetSize(m_borderSize, m_borderSize, w - 2*m_borderSize, h - 2*m_borderSize);
611
612 if (m_windowOne->GetAutoLayout())
613 m_windowOne->Layout();
614 }
615 else if ( m_windowOne && m_windowTwo )
616 {
617 if (m_splitMode == wxSPLIT_VERTICAL)
618 {
619 int x1 = m_borderSize;
620 int y1 = m_borderSize;
621 int w1 = m_sashPosition - m_borderSize;
622 int h1 = h - 2*m_borderSize;
623
624 int x2 = m_sashPosition + m_sashSize;
625 int y2 = m_borderSize;
626 int w2 = w - 2*m_borderSize - m_sashSize - w1;
627 int h2 = h - 2*m_borderSize;
628
629 m_windowOne->SetSize(x1, y1, w1, h1);
630 m_windowTwo->SetSize(x2, y2, w2, h2);
631
632 if (m_windowOne->GetAutoLayout())
633 m_windowOne->Layout();
634 if (m_windowTwo->GetAutoLayout())
635 m_windowTwo->Layout();
636 }
637 else
638 {
639 m_windowOne->SetSize(m_borderSize, m_borderSize,
640 w - 2*m_borderSize, m_sashPosition - m_borderSize);
641 m_windowTwo->SetSize(m_borderSize, m_sashPosition + m_sashSize,
642 w - 2*m_borderSize, h - 2*m_borderSize - m_sashSize - (m_sashPosition - m_borderSize));
643
644 if (m_windowOne->GetAutoLayout())
645 m_windowOne->Layout();
646 if (m_windowTwo->GetAutoLayout())
647 m_windowTwo->Layout();
648 }
649 }
650 wxClientDC dc(this);
651 DrawBorders(dc);
652 DrawSash(dc);
653}
654
655// Set pane for unsplit window
656void wxSplitterWindow::Initialize(wxWindow *window)
657{
658 m_windowOne = window;
659 m_windowTwo = (wxWindow *) NULL;
660 m_sashPosition = 0;
661}
662
663// Associates the given window with window 2, drawing the appropriate sash
664// and changing the split mode.
665// Does nothing and returns FALSE if the window is already split.
666bool wxSplitterWindow::SplitVertically(wxWindow *window1, wxWindow *window2, int sashPosition)
667{
668 if ( IsSplit() )
669 return FALSE;
670
671 int w, h;
672 GetClientSize(&w, &h);
673
674 m_splitMode = wxSPLIT_VERTICAL;
675 m_windowOne = window1;
676 m_windowTwo = window2;
677 if ( sashPosition > 0 )
678 m_sashPosition = sashPosition;
679 else if ( sashPosition < 0 )
680 m_sashPosition = w - sashPosition;
681 else // default
682 m_sashPosition = w/2;
683
684 SizeWindows();
685
686 return TRUE;
687}
688
689bool wxSplitterWindow::SplitHorizontally(wxWindow *window1, wxWindow *window2, int sashPosition)
690{
691 if ( IsSplit() )
692 return FALSE;
693
694 int w, h;
695 GetClientSize(&w, &h);
696
697 m_splitMode = wxSPLIT_HORIZONTAL;
698 m_windowOne = window1;
699 m_windowTwo = window2;
700 if ( sashPosition > 0 )
701 m_sashPosition = sashPosition;
702 else if ( sashPosition < 0 )
703 m_sashPosition = h - sashPosition;
704 else // default
705 m_sashPosition = h/2;
706
707 SizeWindows();
708
709 return TRUE;
710}
711
712
713// Remove the specified (or second) window from the view
714// Doesn't actually delete the window.
715bool wxSplitterWindow::Unsplit(wxWindow *toRemove)
716{
717 if ( ! IsSplit() )
718 return FALSE;
719
720 wxWindow *win = NULL;
721 if ( toRemove == NULL || toRemove == m_windowTwo)
722 {
723 win = m_windowTwo ;
724 m_windowTwo = (wxWindow *) NULL;
725 }
726 else if ( toRemove == m_windowOne )
727 {
728 win = m_windowOne ;
729 m_windowOne = m_windowTwo;
730 m_windowTwo = (wxWindow *) NULL;
731 }
732 else
733 {
734 wxFAIL_MSG(_T("splitter: attempt to remove a non-existent window"));
735
736 return FALSE;
737 }
738
739 SendUnsplitEvent(win);
740 m_sashPosition = 0;
741 SizeWindows();
742
743 return TRUE;
744}
745
746// Replace a window with another one
747bool wxSplitterWindow::ReplaceWindow(wxWindow *winOld, wxWindow *winNew)
748{
749 wxCHECK_MSG( winOld, FALSE, _T("use one of Split() functions instead") );
750 wxCHECK_MSG( winNew, FALSE, _T("use Unsplit() functions instead") );
751
752 if ( winOld == m_windowTwo )
753 {
754 m_windowTwo = winNew;
755 }
756 else if ( winOld == m_windowOne )
757 {
758 m_windowOne = winNew;
759 }
760 else
761 {
762 wxFAIL_MSG(_T("splitter: attempt to replace a non-existent window"));
763
764 return FALSE;
765 }
766
767 SizeWindows();
768
769 return TRUE;
770}
771
772void wxSplitterWindow::SetSashPosition(int position, bool redraw)
773{
774 m_sashPosition = position;
775
776 if ( redraw )
777 {
778 SizeWindows();
779 }
780}
781
782// Initialize colours
783void wxSplitterWindow::InitColours()
784{
785 wxDELETE( m_facePen );
786 wxDELETE( m_faceBrush );
787 wxDELETE( m_mediumShadowPen );
788 wxDELETE( m_darkShadowPen );
789 wxDELETE( m_lightShadowPen );
790 wxDELETE( m_hilightPen );
791
792 // Shadow colours
793#if defined(__WIN95__)
794 wxColour faceColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
795 m_facePen = new wxPen(faceColour, 1, wxSOLID);
796 m_faceBrush = new wxBrush(faceColour, wxSOLID);
797
798 wxColour mediumShadowColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DSHADOW));
799 m_mediumShadowPen = new wxPen(mediumShadowColour, 1, wxSOLID);
800
801 wxColour darkShadowColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DDKSHADOW));
802 m_darkShadowPen = new wxPen(darkShadowColour, 1, wxSOLID);
803
804 wxColour lightShadowColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DLIGHT));
805 m_lightShadowPen = new wxPen(lightShadowColour, 1, wxSOLID);
806
807 wxColour hilightColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DHILIGHT));
808 m_hilightPen = new wxPen(hilightColour, 1, wxSOLID);
809#else // !Win32
810 m_facePen = new wxPen("LIGHT GREY", 1, wxSOLID);
811 m_faceBrush = new wxBrush("LIGHT GREY", wxSOLID);
812 m_mediumShadowPen = new wxPen("GREY", 1, wxSOLID);
813 m_darkShadowPen = new wxPen("BLACK", 1, wxSOLID);
814 m_lightShadowPen = new wxPen("LIGHT GREY", 1, wxSOLID);
815 m_hilightPen = new wxPen("WHITE", 1, wxSOLID);
816#endif // Win32/!Win32
817}
818
819void wxSplitterWindow::SendUnsplitEvent(wxWindow *winRemoved)
820{
821 wxSplitterEvent event(wxEVT_COMMAND_SPLITTER_UNSPLIT, this);
822 event.m_data.win = winRemoved;
823
824 (void)GetEventHandler()->ProcessEvent(event);
825}
826
827// ---------------------------------------------------------------------------
828// splitter event handlers
829// ---------------------------------------------------------------------------
830
831void wxSplitterWindow::OnSashPosChanged(wxSplitterEvent& event)
832{
833 // If within UNSPLIT_THRESHOLD from edge, set to edge to cause closure.
834 const int UNSPLIT_THRESHOLD = 4;
835
836 int newSashPosition = event.GetSashPosition();
837
838 // Obtain relevant window dimension for bottom / right threshold check
839 int w, h;
840 GetClientSize(&w, &h);
841 int window_size = (m_splitMode == wxSPLIT_VERTICAL) ? w : h ;
842
843 bool unsplit_scenario = FALSE;
844 if ( m_permitUnsplitAlways
845 || m_minimumPaneSize == 0 )
846 {
847 // Do edge detection if unsplit premitted
848 if ( newSashPosition <= UNSPLIT_THRESHOLD )
849 {
850 // threshold top / left check
851 newSashPosition = 0;
852 unsplit_scenario = TRUE;
853 }
854 if ( newSashPosition >= window_size - UNSPLIT_THRESHOLD )
855 {
856 // threshold bottom/right check
857 newSashPosition = window_size;
858 unsplit_scenario = TRUE;
859 }
860 }
861
862 if ( !unsplit_scenario )
863 {
864 // If resultant pane would be too small, enlarge it
865 if ( newSashPosition < m_minimumPaneSize )
866 newSashPosition = m_minimumPaneSize;
867 if ( newSashPosition > window_size - m_minimumPaneSize )
868 newSashPosition = window_size - m_minimumPaneSize;
869 }
870
871 // If the result is out of bounds it means minimum size is too big,
872 // so split window in half as best compromise.
873 if ( newSashPosition < 0 || newSashPosition > window_size )
874 newSashPosition = window_size / 2;
875
876 // for compatibility, call the virtual function
877 if ( !OnSashPositionChange(newSashPosition) )
878 {
879 newSashPosition = -1;
880 }
881
882 event.SetSashPosition(newSashPosition);
883}
884
885// Called when the sash is double-clicked. The default behaviour is to remove
886// the sash if the minimum pane size is zero.
887void wxSplitterWindow::OnDoubleClick(wxSplitterEvent& event)
888{
889 // for compatibility, call the virtual function
890 OnDoubleClickSash(event.GetX(), event.GetY());
891
892 if ( GetMinimumPaneSize() == 0
893 || m_permitUnsplitAlways)
894 {
895 Unsplit();
896 }
897}
898
899void wxSplitterWindow::OnUnsplitEvent(wxSplitterEvent& event)
900{
901 wxWindow *win = event.GetWindowBeingRemoved();
902
903 // for compatibility, call the virtual function
904 OnUnsplit(win);
905
906 win->Show(FALSE);
907}