]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/generic/splitter.cpp
More makefiles, distrib things,
[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(wxT("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
437 dc.SetPen(*m_facePen);
438 dc.SetBrush(*m_faceBrush);
439 dc.DrawRectangle(1, 1 , w-1, m_borderSize-2 ); //high
440 dc.DrawRectangle(1, m_borderSize-2 , m_borderSize-2, h-1 ); // left
441 dc.DrawRectangle(w-m_borderSize+2, m_borderSize-2 , w-1, h-1 ); // right
442 dc.DrawRectangle(m_borderSize-2, h-m_borderSize+2 , w-m_borderSize+2, h-1 ); //bottom
443
444 dc.SetPen(*m_mediumShadowPen);
445 dc.DrawLine(m_borderSize-2, m_borderSize-2, w-m_borderSize+1, m_borderSize-2);
446 dc.DrawLine(m_borderSize-2, m_borderSize-2, m_borderSize-2, h-m_borderSize+1);
447
448 dc.SetPen(*m_darkShadowPen);
449 dc.DrawLine(m_borderSize-1, m_borderSize-1, w-m_borderSize, m_borderSize-1);
450 dc.DrawLine(m_borderSize-1, m_borderSize-1, m_borderSize-1, h-m_borderSize);
451
452 dc.SetPen(*m_hilightPen);
453 dc.DrawLine(m_borderSize - 2, h-m_borderSize+1, w-m_borderSize+1, h-m_borderSize+1);
454 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.
455 /// Anyway, h is required for MSW.
456
457 dc.SetPen(*m_lightShadowPen);
458 dc.DrawLine(w-m_borderSize, m_borderSize-1, w-m_borderSize, h-m_borderSize); // Right hand side
459 dc.DrawLine(m_borderSize-1, h-m_borderSize, w-m_borderSize+1, h-m_borderSize); // Bottom
460 }
461 else if ( GetWindowStyleFlag() & wxSP_BORDER )
462 {
463 dc.SetBrush(*wxTRANSPARENT_BRUSH);
464 dc.SetPen(*wxBLACK_PEN);
465 dc.DrawRectangle(0, 0, w-1, h-1);
466 }
467
468 dc.SetPen(wxNullPen);
469 dc.SetBrush(wxNullBrush);
470}
471
472// Draw the sash
473void wxSplitterWindow::DrawSash(wxDC& dc)
474{
475 if ( m_sashPosition == 0 || !m_windowTwo)
476 return;
477
478 int w, h;
479 GetClientSize(&w, &h);
480
481 if ( GetWindowStyleFlag() & wxSP_3D )
482 {
483 if ( m_splitMode == wxSPLIT_VERTICAL )
484 {
485 dc.SetPen(*m_facePen);
486 dc.SetBrush(*m_faceBrush);
487 dc.DrawRectangle(m_sashPosition + 2, 0 , m_sashSize - 4, h );
488
489 dc.SetBrush(*wxTRANSPARENT_BRUSH);
490
491 dc.SetPen(*m_lightShadowPen);
492 int xShadow = m_borderSize ? m_borderSize - 1 : 0 ;
493 dc.DrawLine(m_sashPosition, xShadow , m_sashPosition, h-m_borderSize);
494
495 dc.SetPen(*m_hilightPen);
496 dc.DrawLine(m_sashPosition+1, m_borderSize - 2, m_sashPosition+1, h - m_borderSize+2);
497
498 dc.SetPen(*m_mediumShadowPen);
499 int yMedium = m_borderSize ? h-m_borderSize+1 : h ;
500 dc.DrawLine(m_sashPosition+m_sashSize-2, xShadow, m_sashPosition+m_sashSize-2, yMedium);
501
502 dc.SetPen(*m_darkShadowPen);
503 dc.DrawLine(m_sashPosition+m_sashSize-1, m_borderSize, m_sashPosition+m_sashSize-1, h-m_borderSize );
504 }
505 else
506 {
507 dc.SetPen(*m_facePen);
508 dc.SetBrush(*m_faceBrush);
509 dc.DrawRectangle( m_borderSize-2, m_sashPosition + 2, w-m_borderSize+2, m_sashSize - 4);
510
511 dc.SetBrush(*wxTRANSPARENT_BRUSH);
512
513 dc.SetPen(*m_lightShadowPen);
514 dc.DrawLine(m_borderSize-1, m_sashPosition, w-m_borderSize, m_sashPosition);
515
516 dc.SetPen(*m_hilightPen);
517 dc.DrawLine(m_borderSize-2, m_sashPosition+1, w-m_borderSize+1, m_sashPosition+1);
518
519 dc.SetPen(*m_mediumShadowPen);
520 dc.DrawLine(m_borderSize-1, m_sashPosition+m_sashSize-2, w-m_borderSize+1, m_sashPosition+m_sashSize-2);
521
522 dc.SetPen(*m_darkShadowPen);
523 dc.DrawLine(m_borderSize, m_sashPosition+m_sashSize-1, w-m_borderSize, m_sashPosition+m_sashSize-1);
524 }
525 }
526 else
527 {
528 if ( m_splitMode == wxSPLIT_VERTICAL )
529 {
530 dc.SetPen(*wxBLACK_PEN);
531 dc.SetBrush(*wxBLACK_BRUSH);
532 int h1 = h-1;
533 if ( (GetWindowStyleFlag() & wxSP_BORDER) != wxSP_BORDER )
534 h1 += 1; // Not sure why this is necessary...
535 dc.DrawRectangle(m_sashPosition, 0, m_sashSize, h1);
536 }
537 else
538 {
539 dc.SetPen(*wxBLACK_PEN);
540 dc.SetBrush(*wxBLACK_BRUSH);
541 int w1 = w-1;
542 if ( (GetWindowStyleFlag() & wxSP_BORDER) != wxSP_BORDER )
543 w1 ++;
544
545 dc.DrawRectangle(0, m_sashPosition, w1, m_sashSize);
546 }
547
548 }
549
550 dc.SetPen(wxNullPen);
551 dc.SetBrush(wxNullBrush);
552}
553
554// Draw the sash tracker (for whilst moving the sash)
555void wxSplitterWindow::DrawSashTracker(int x, int y)
556{
557 int w, h;
558 GetClientSize(&w, &h);
559
560 wxScreenDC screenDC;
561 int x1, y1;
562 int x2, y2;
563
564 if ( m_splitMode == wxSPLIT_VERTICAL )
565 {
566 x1 = x; y1 = 2;
567 x2 = x; y2 = h-2;
568
569 if ( x1 > w )
570 {
571 x1 = w; x2 = w;
572 }
573 else if ( x1 < 0 )
574 {
575 x1 = 0; x2 = 0;
576 }
577 }
578 else
579 {
580 x1 = 2; y1 = y;
581 x2 = w-2; y2 = y;
582
583 if ( y1 > h )
584 {
585 y1 = h;
586 y2 = h;
587 }
588 else if ( y1 < 0 )
589 {
590 y1 = 0;
591 y2 = 0;
592 }
593 }
594
595 ClientToScreen(&x1, &y1);
596 ClientToScreen(&x2, &y2);
597
598 screenDC.SetLogicalFunction(wxINVERT);
599 screenDC.SetPen(*m_sashTrackerPen);
600 screenDC.SetBrush(*wxTRANSPARENT_BRUSH);
601
602 screenDC.DrawLine(x1, y1, x2, y2);
603
604 screenDC.SetLogicalFunction(wxCOPY);
605
606 screenDC.SetPen(wxNullPen);
607 screenDC.SetBrush(wxNullBrush);
608}
609
610// Position and size subwindows.
611// Note that the border size applies to each subwindow, not
612// including the edges next to the sash.
613void wxSplitterWindow::SizeWindows()
614{
615 int w, h;
616 GetClientSize(&w, &h);
617
618 if ( m_windowOne && !m_windowTwo )
619 {
620 m_windowOne->SetSize(m_borderSize, m_borderSize, w - 2*m_borderSize, h - 2*m_borderSize);
621
622 if (m_windowOne->GetAutoLayout())
623 m_windowOne->Layout();
624 }
625 else if ( m_windowOne && m_windowTwo )
626 {
627 if (m_splitMode == wxSPLIT_VERTICAL)
628 {
629 int x1 = m_borderSize;
630 int y1 = m_borderSize;
631 int w1 = m_sashPosition - m_borderSize;
632 int h1 = h - 2*m_borderSize;
633
634 int x2 = m_sashPosition + m_sashSize;
635 int y2 = m_borderSize;
636 int w2 = w - 2*m_borderSize - m_sashSize - w1;
637 int h2 = h - 2*m_borderSize;
638
639 m_windowOne->SetSize(x1, y1, w1, h1);
640 m_windowTwo->SetSize(x2, y2, w2, h2);
641
642 if (m_windowOne->GetAutoLayout())
643 m_windowOne->Layout();
644 if (m_windowTwo->GetAutoLayout())
645 m_windowTwo->Layout();
646 }
647 else
648 {
649 m_windowOne->SetSize(m_borderSize, m_borderSize,
650 w - 2*m_borderSize, m_sashPosition - m_borderSize);
651 m_windowTwo->SetSize(m_borderSize, m_sashPosition + m_sashSize,
652 w - 2*m_borderSize, h - 2*m_borderSize - m_sashSize - (m_sashPosition - m_borderSize));
653
654 if (m_windowOne->GetAutoLayout())
655 m_windowOne->Layout();
656 if (m_windowTwo->GetAutoLayout())
657 m_windowTwo->Layout();
658 }
659 }
660 wxClientDC dc(this);
661 if ( m_borderSize > 0 )
662 DrawBorders(dc);
663 DrawSash(dc);
664}
665
666// Set pane for unsplit window
667void wxSplitterWindow::Initialize(wxWindow *window)
668{
669 m_windowOne = window;
670 m_windowTwo = (wxWindow *) NULL;
671 m_sashPosition = 0;
672}
673
674// Associates the given window with window 2, drawing the appropriate sash
675// and changing the split mode.
676// Does nothing and returns FALSE if the window is already split.
677bool wxSplitterWindow::SplitVertically(wxWindow *window1, wxWindow *window2, int sashPosition)
678{
679 if ( IsSplit() )
680 return FALSE;
681
682 int w, h;
683 GetClientSize(&w, &h);
684
685 m_splitMode = wxSPLIT_VERTICAL;
686 m_windowOne = window1;
687 m_windowTwo = window2;
688 if ( sashPosition > 0 )
689 m_sashPosition = sashPosition;
690 else if ( sashPosition < 0 )
691 m_sashPosition = w - sashPosition;
692 else // default
693 m_sashPosition = w/2;
694
695 SizeWindows();
696
697 return TRUE;
698}
699
700bool wxSplitterWindow::SplitHorizontally(wxWindow *window1, wxWindow *window2, int sashPosition)
701{
702 if ( IsSplit() )
703 return FALSE;
704
705 int w, h;
706 GetClientSize(&w, &h);
707
708 m_splitMode = wxSPLIT_HORIZONTAL;
709 m_windowOne = window1;
710 m_windowTwo = window2;
711 if ( sashPosition > 0 )
712 m_sashPosition = sashPosition;
713 else if ( sashPosition < 0 )
714 m_sashPosition = h - sashPosition;
715 else // default
716 m_sashPosition = h/2;
717
718 SizeWindows();
719
720 return TRUE;
721}
722
723
724// Remove the specified (or second) window from the view
725// Doesn't actually delete the window.
726bool wxSplitterWindow::Unsplit(wxWindow *toRemove)
727{
728 if ( ! IsSplit() )
729 return FALSE;
730
731 wxWindow *win = NULL;
732 if ( toRemove == NULL || toRemove == m_windowTwo)
733 {
734 win = m_windowTwo ;
735 m_windowTwo = (wxWindow *) NULL;
736 }
737 else if ( toRemove == m_windowOne )
738 {
739 win = m_windowOne ;
740 m_windowOne = m_windowTwo;
741 m_windowTwo = (wxWindow *) NULL;
742 }
743 else
744 {
745 wxFAIL_MSG(wxT("splitter: attempt to remove a non-existent window"));
746
747 return FALSE;
748 }
749
750 SendUnsplitEvent(win);
751 m_sashPosition = 0;
752 SizeWindows();
753
754 return TRUE;
755}
756
757// Replace a window with another one
758bool wxSplitterWindow::ReplaceWindow(wxWindow *winOld, wxWindow *winNew)
759{
760 wxCHECK_MSG( winOld, FALSE, wxT("use one of Split() functions instead") );
761 wxCHECK_MSG( winNew, FALSE, wxT("use Unsplit() functions instead") );
762
763 if ( winOld == m_windowTwo )
764 {
765 m_windowTwo = winNew;
766 }
767 else if ( winOld == m_windowOne )
768 {
769 m_windowOne = winNew;
770 }
771 else
772 {
773 wxFAIL_MSG(wxT("splitter: attempt to replace a non-existent window"));
774
775 return FALSE;
776 }
777
778 SizeWindows();
779
780 return TRUE;
781}
782
783void wxSplitterWindow::SetSashPosition(int position, bool redraw)
784{
785 m_sashPosition = position;
786
787 if ( redraw )
788 {
789 SizeWindows();
790 }
791}
792
793// Initialize colours
794void wxSplitterWindow::InitColours()
795{
796 wxDELETE( m_facePen );
797 wxDELETE( m_faceBrush );
798 wxDELETE( m_mediumShadowPen );
799 wxDELETE( m_darkShadowPen );
800 wxDELETE( m_lightShadowPen );
801 wxDELETE( m_hilightPen );
802
803 // Shadow colours
804#if defined(__WIN95__)
805 wxColour faceColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
806 m_facePen = new wxPen(faceColour, 1, wxSOLID);
807 m_faceBrush = new wxBrush(faceColour, wxSOLID);
808
809 wxColour mediumShadowColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DSHADOW));
810 m_mediumShadowPen = new wxPen(mediumShadowColour, 1, wxSOLID);
811
812 wxColour darkShadowColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DDKSHADOW));
813 m_darkShadowPen = new wxPen(darkShadowColour, 1, wxSOLID);
814
815 wxColour lightShadowColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DLIGHT));
816 m_lightShadowPen = new wxPen(lightShadowColour, 1, wxSOLID);
817
818 wxColour hilightColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DHILIGHT));
819 m_hilightPen = new wxPen(hilightColour, 1, wxSOLID);
820#else // !Win32
821 m_facePen = new wxPen("LIGHT GREY", 1, wxSOLID);
822 m_faceBrush = new wxBrush("LIGHT GREY", wxSOLID);
823 m_mediumShadowPen = new wxPen("GREY", 1, wxSOLID);
824 m_darkShadowPen = new wxPen("BLACK", 1, wxSOLID);
825 m_lightShadowPen = new wxPen("LIGHT GREY", 1, wxSOLID);
826 m_hilightPen = new wxPen("WHITE", 1, wxSOLID);
827#endif // Win32/!Win32
828}
829
830void wxSplitterWindow::SendUnsplitEvent(wxWindow *winRemoved)
831{
832 wxSplitterEvent event(wxEVT_COMMAND_SPLITTER_UNSPLIT, this);
833 event.m_data.win = winRemoved;
834
835 (void)GetEventHandler()->ProcessEvent(event);
836}
837
838// ---------------------------------------------------------------------------
839// splitter event handlers
840// ---------------------------------------------------------------------------
841
842void wxSplitterWindow::OnSashPosChanged(wxSplitterEvent& event)
843{
844 // If within UNSPLIT_THRESHOLD from edge, set to edge to cause closure.
845 const int UNSPLIT_THRESHOLD = 4;
846
847 int newSashPosition = event.GetSashPosition();
848
849 // Obtain relevant window dimension for bottom / right threshold check
850 int w, h;
851 GetClientSize(&w, &h);
852 int window_size = (m_splitMode == wxSPLIT_VERTICAL) ? w : h ;
853
854 bool unsplit_scenario = FALSE;
855 if ( m_permitUnsplitAlways
856 || m_minimumPaneSize == 0 )
857 {
858 // Do edge detection if unsplit premitted
859 if ( newSashPosition <= UNSPLIT_THRESHOLD )
860 {
861 // threshold top / left check
862 newSashPosition = 0;
863 unsplit_scenario = TRUE;
864 }
865 if ( newSashPosition >= window_size - UNSPLIT_THRESHOLD )
866 {
867 // threshold bottom/right check
868 newSashPosition = window_size;
869 unsplit_scenario = TRUE;
870 }
871 }
872
873 if ( !unsplit_scenario )
874 {
875 // If resultant pane would be too small, enlarge it
876 if ( newSashPosition < m_minimumPaneSize )
877 newSashPosition = m_minimumPaneSize;
878 if ( newSashPosition > window_size - m_minimumPaneSize )
879 newSashPosition = window_size - m_minimumPaneSize;
880 }
881
882 // If the result is out of bounds it means minimum size is too big,
883 // so split window in half as best compromise.
884 if ( newSashPosition < 0 || newSashPosition > window_size )
885 newSashPosition = window_size / 2;
886
887 // for compatibility, call the virtual function
888 if ( !OnSashPositionChange(newSashPosition) )
889 {
890 newSashPosition = -1;
891 }
892
893 event.SetSashPosition(newSashPosition);
894}
895
896// Called when the sash is double-clicked. The default behaviour is to remove
897// the sash if the minimum pane size is zero.
898void wxSplitterWindow::OnDoubleClick(wxSplitterEvent& event)
899{
900 // for compatibility, call the virtual function
901 OnDoubleClickSash(event.GetX(), event.GetY());
902
903 if ( GetMinimumPaneSize() == 0
904 || m_permitUnsplitAlways)
905 {
906 Unsplit();
907 }
908}
909
910void wxSplitterWindow::OnUnsplitEvent(wxSplitterEvent& event)
911{
912 wxWindow *win = event.GetWindowBeingRemoved();
913
914 // for compatibility, call the virtual function
915 OnUnsplit(win);
916
917 win->Show(FALSE);
918}