]> git.saurik.com Git - wxWidgets.git/blob - src/generic/sashwin.cpp
Don't generate any events from wxSpinCtrl and wxSpinCtrlDouble methods.
[wxWidgets.git] / src / generic / sashwin.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/generic/sashwin.cpp
3 // Purpose: wxSashWindow implementation. A sash window has an optional
4 // sash on each edge, allowing it to be dragged. An event
5 // is generated when the sash is released.
6 // Author: Julian Smart
7 // Modified by:
8 // Created: 01/02/97
9 // Copyright: (c) Julian Smart
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
12
13 // For compilers that support precompilation, includes "wx.h".
14 #include "wx/wxprec.h"
15
16 #ifdef __BORLANDC__
17 #pragma hdrstop
18 #endif
19
20 #if wxUSE_SASH
21
22 #include "wx/sashwin.h"
23
24 #ifndef WX_PRECOMP
25 #include "wx/dialog.h"
26 #include "wx/frame.h"
27 #include "wx/settings.h"
28 #include "wx/dcclient.h"
29 #include "wx/dcscreen.h"
30 #include "wx/math.h"
31 #endif
32
33 #include <stdlib.h>
34
35 #include "wx/laywin.h"
36
37 wxDEFINE_EVENT( wxEVT_SASH_DRAGGED, wxSashEvent );
38
39 IMPLEMENT_DYNAMIC_CLASS(wxSashWindow, wxWindow)
40 IMPLEMENT_DYNAMIC_CLASS(wxSashEvent, wxCommandEvent)
41
42 BEGIN_EVENT_TABLE(wxSashWindow, wxWindow)
43 EVT_PAINT(wxSashWindow::OnPaint)
44 EVT_SIZE(wxSashWindow::OnSize)
45 EVT_MOUSE_EVENTS(wxSashWindow::OnMouseEvent)
46 #if defined( __WXMSW__ ) || defined( __WXMAC__)
47 EVT_SET_CURSOR(wxSashWindow::OnSetCursor)
48 #endif // __WXMSW__ || __WXMAC__
49
50 END_EVENT_TABLE()
51
52 bool wxSashWindow::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos,
53 const wxSize& size, long style, const wxString& name)
54 {
55 return wxWindow::Create(parent, id, pos, size, style, name);
56 }
57
58 wxSashWindow::~wxSashWindow()
59 {
60 delete m_sashCursorWE;
61 delete m_sashCursorNS;
62 }
63
64 void wxSashWindow::Init()
65 {
66 m_draggingEdge = wxSASH_NONE;
67 m_dragMode = wxSASH_DRAG_NONE;
68 m_oldX = 0;
69 m_oldY = 0;
70 m_firstX = 0;
71 m_firstY = 0;
72 m_borderSize = 3;
73 m_extraBorderSize = 0;
74 m_minimumPaneSizeX = 0;
75 m_minimumPaneSizeY = 0;
76 m_maximumPaneSizeX = 10000;
77 m_maximumPaneSizeY = 10000;
78 m_sashCursorWE = new wxCursor(wxCURSOR_SIZEWE);
79 m_sashCursorNS = new wxCursor(wxCURSOR_SIZENS);
80 m_mouseCaptured = false;
81 m_currentCursor = NULL;
82
83 // Eventually, we'll respond to colour change messages
84 InitColours();
85 }
86
87 void wxSashWindow::OnPaint(wxPaintEvent& WXUNUSED(event))
88 {
89 wxPaintDC dc(this);
90
91 DrawBorders(dc);
92 DrawSashes(dc);
93 }
94
95 void wxSashWindow::OnMouseEvent(wxMouseEvent& event)
96 {
97 wxCoord x = 0, y = 0;
98 event.GetPosition(&x, &y);
99
100 wxSashEdgePosition sashHit = SashHitTest(x, y);
101
102 if (event.LeftDown())
103 {
104 CaptureMouse();
105 m_mouseCaptured = true;
106
107 if ( sashHit != wxSASH_NONE )
108 {
109 // Required for X to specify that
110 // that we wish to draw on top of all windows
111 // - and we optimise by specifying the area
112 // for creating the overlap window.
113 // Find the first frame or dialog and use this to specify
114 // the area to draw on.
115 wxWindow* parent = this;
116
117 while (parent && !wxDynamicCast(parent, wxDialog) &&
118 !wxDynamicCast(parent, wxFrame))
119 parent = parent->GetParent();
120
121 wxScreenDC::StartDrawingOnTop(parent);
122
123 // We don't say we're dragging yet; we leave that
124 // decision for the Dragging() branch, to ensure
125 // the user has dragged a little bit.
126 m_dragMode = wxSASH_DRAG_LEFT_DOWN;
127 m_draggingEdge = sashHit;
128 m_firstX = x;
129 m_firstY = y;
130
131 if ( (sashHit == wxSASH_LEFT) || (sashHit == wxSASH_RIGHT) )
132 {
133 if (m_currentCursor != m_sashCursorWE)
134 {
135 SetCursor(*m_sashCursorWE);
136 }
137 m_currentCursor = m_sashCursorWE;
138 }
139 else
140 {
141 if (m_currentCursor != m_sashCursorNS)
142 {
143 SetCursor(*m_sashCursorNS);
144 }
145 m_currentCursor = m_sashCursorNS;
146 }
147 }
148 }
149 else if ( event.LeftUp() && m_dragMode == wxSASH_DRAG_LEFT_DOWN )
150 {
151 // Wasn't a proper drag
152 if (m_mouseCaptured)
153 ReleaseMouse();
154 m_mouseCaptured = false;
155
156 wxScreenDC::EndDrawingOnTop();
157 m_dragMode = wxSASH_DRAG_NONE;
158 m_draggingEdge = wxSASH_NONE;
159 }
160 else if (event.LeftUp() && m_dragMode == wxSASH_DRAG_DRAGGING)
161 {
162 // We can stop dragging now and see what we've got.
163 m_dragMode = wxSASH_DRAG_NONE;
164 if (m_mouseCaptured)
165 ReleaseMouse();
166 m_mouseCaptured = false;
167
168 // Erase old tracker
169 DrawSashTracker(m_draggingEdge, m_oldX, m_oldY);
170
171 // End drawing on top (frees the window used for drawing
172 // over the screen)
173 wxScreenDC::EndDrawingOnTop();
174
175 int w, h;
176 GetSize(&w, &h);
177 int xp, yp;
178 GetPosition(&xp, &yp);
179
180 wxSashEdgePosition edge = m_draggingEdge;
181 m_draggingEdge = wxSASH_NONE;
182
183 wxRect dragRect;
184 wxSashDragStatus status = wxSASH_STATUS_OK;
185
186 // the new height and width of the window - if -1, it didn't change
187 int newHeight = wxDefaultCoord,
188 newWidth = wxDefaultCoord;
189
190 // NB: x and y may be negative and they're relative to the sash window
191 // upper left corner, while xp and yp are expressed in the parent
192 // window system of coordinates, so adjust them! After this
193 // adjustment, all coordinates are relative to the parent window.
194 y += yp;
195 x += xp;
196
197 switch (edge)
198 {
199 case wxSASH_TOP:
200 if ( y > yp + h )
201 {
202 // top sash shouldn't get below the bottom one
203 status = wxSASH_STATUS_OUT_OF_RANGE;
204 }
205 else
206 {
207 newHeight = h - (y - yp);
208 }
209 break;
210
211 case wxSASH_BOTTOM:
212 if ( y < yp )
213 {
214 // bottom sash shouldn't get above the top one
215 status = wxSASH_STATUS_OUT_OF_RANGE;
216 }
217 else
218 {
219 newHeight = y - yp;
220 }
221 break;
222
223 case wxSASH_LEFT:
224 if ( x > xp + w )
225 {
226 // left sash shouldn't get beyond the right one
227 status = wxSASH_STATUS_OUT_OF_RANGE;
228 }
229 else
230 {
231 newWidth = w - (x - xp);
232 }
233 break;
234
235 case wxSASH_RIGHT:
236 if ( x < xp )
237 {
238 // and the right sash, finally, shouldn't be beyond the
239 // left one
240 status = wxSASH_STATUS_OUT_OF_RANGE;
241 }
242 else
243 {
244 newWidth = x - xp;
245 }
246 break;
247
248 case wxSASH_NONE:
249 // can this happen at all?
250 break;
251 }
252
253 if ( newHeight == wxDefaultCoord )
254 {
255 // didn't change
256 newHeight = h;
257 }
258 else
259 {
260 // make sure it's in m_minimumPaneSizeY..m_maximumPaneSizeY range
261 newHeight = wxMax(newHeight, m_minimumPaneSizeY);
262 newHeight = wxMin(newHeight, m_maximumPaneSizeY);
263 }
264
265 if ( newWidth == wxDefaultCoord )
266 {
267 // didn't change
268 newWidth = w;
269 }
270 else
271 {
272 // make sure it's in m_minimumPaneSizeY..m_maximumPaneSizeY range
273 newWidth = wxMax(newWidth, m_minimumPaneSizeX);
274 newWidth = wxMin(newWidth, m_maximumPaneSizeX);
275 }
276
277 dragRect = wxRect(x, y, newWidth, newHeight);
278
279 wxSashEvent eventSash(GetId(), edge);
280 eventSash.SetEventObject(this);
281 eventSash.SetDragStatus(status);
282 eventSash.SetDragRect(dragRect);
283 GetEventHandler()->ProcessEvent(eventSash);
284 }
285 else if ( event.LeftUp() )
286 {
287 if (m_mouseCaptured)
288 ReleaseMouse();
289 m_mouseCaptured = false;
290 }
291 else if ((event.Moving() || event.Leaving()) && !event.Dragging())
292 {
293 // Just change the cursor if required
294 if ( sashHit != wxSASH_NONE )
295 {
296 if ( (sashHit == wxSASH_LEFT) || (sashHit == wxSASH_RIGHT) )
297 {
298 if (m_currentCursor != m_sashCursorWE)
299 {
300 SetCursor(*m_sashCursorWE);
301 }
302 m_currentCursor = m_sashCursorWE;
303 }
304 else
305 {
306 if (m_currentCursor != m_sashCursorNS)
307 {
308 SetCursor(*m_sashCursorNS);
309 }
310 m_currentCursor = m_sashCursorNS;
311 }
312 }
313 else
314 {
315 SetCursor(wxNullCursor);
316 m_currentCursor = NULL;
317 }
318 }
319 else if ( event.Dragging() &&
320 ((m_dragMode == wxSASH_DRAG_DRAGGING) ||
321 (m_dragMode == wxSASH_DRAG_LEFT_DOWN)) )
322 {
323 if ( (m_draggingEdge == wxSASH_LEFT) || (m_draggingEdge == wxSASH_RIGHT) )
324 {
325 if (m_currentCursor != m_sashCursorWE)
326 {
327 SetCursor(*m_sashCursorWE);
328 }
329 m_currentCursor = m_sashCursorWE;
330 }
331 else
332 {
333 if (m_currentCursor != m_sashCursorNS)
334 {
335 SetCursor(*m_sashCursorNS);
336 }
337 m_currentCursor = m_sashCursorNS;
338 }
339
340 if (m_dragMode == wxSASH_DRAG_LEFT_DOWN)
341 {
342 m_dragMode = wxSASH_DRAG_DRAGGING;
343 DrawSashTracker(m_draggingEdge, x, y);
344 }
345 else
346 {
347 if ( m_dragMode == wxSASH_DRAG_DRAGGING )
348 {
349 // Erase old tracker
350 DrawSashTracker(m_draggingEdge, m_oldX, m_oldY);
351
352 // Draw new one
353 DrawSashTracker(m_draggingEdge, x, y);
354 }
355 }
356 m_oldX = x;
357 m_oldY = y;
358 }
359 else if ( event.LeftDClick() )
360 {
361 // Nothing
362 }
363 else
364 {
365 }
366 }
367
368 void wxSashWindow::OnSize(wxSizeEvent& WXUNUSED(event))
369 {
370 SizeWindows();
371 }
372
373 wxSashEdgePosition wxSashWindow::SashHitTest(int x, int y, int WXUNUSED(tolerance))
374 {
375 int cx, cy;
376 GetClientSize(& cx, & cy);
377
378 int i;
379 for (i = 0; i < 4; i++)
380 {
381 wxSashEdge& edge = m_sashes[i];
382 wxSashEdgePosition position = (wxSashEdgePosition) i ;
383
384 if (edge.m_show)
385 {
386 switch (position)
387 {
388 case wxSASH_TOP:
389 {
390 if (y >= 0 && y <= GetEdgeMargin(position))
391 return wxSASH_TOP;
392 break;
393 }
394 case wxSASH_RIGHT:
395 {
396 if ((x >= cx - GetEdgeMargin(position)) && (x <= cx))
397 return wxSASH_RIGHT;
398 break;
399 }
400 case wxSASH_BOTTOM:
401 {
402 if ((y >= cy - GetEdgeMargin(position)) && (y <= cy))
403 return wxSASH_BOTTOM;
404 break;
405 }
406 case wxSASH_LEFT:
407 {
408 if ((x <= GetEdgeMargin(position)) && (x >= 0))
409 return wxSASH_LEFT;
410 break;
411 }
412 case wxSASH_NONE:
413 {
414 break;
415 }
416 }
417 }
418 }
419 return wxSASH_NONE;
420 }
421
422 // Draw 3D effect borders
423 void wxSashWindow::DrawBorders(wxDC& dc)
424 {
425 int w, h;
426 GetClientSize(&w, &h);
427
428 wxPen mediumShadowPen(m_mediumShadowColour, 1, wxPENSTYLE_SOLID);
429 wxPen darkShadowPen(m_darkShadowColour, 1, wxPENSTYLE_SOLID);
430 wxPen lightShadowPen(m_lightShadowColour, 1, wxPENSTYLE_SOLID);
431 wxPen hilightPen(m_hilightColour, 1, wxPENSTYLE_SOLID);
432
433 if ( GetWindowStyleFlag() & wxSW_3DBORDER )
434 {
435 dc.SetPen(mediumShadowPen);
436 dc.DrawLine(0, 0, w-1, 0);
437 dc.DrawLine(0, 0, 0, h - 1);
438
439 dc.SetPen(darkShadowPen);
440 dc.DrawLine(1, 1, w-2, 1);
441 dc.DrawLine(1, 1, 1, h-2);
442
443 dc.SetPen(hilightPen);
444 dc.DrawLine(0, h-1, w-1, h-1);
445 dc.DrawLine(w-1, 0, w-1, h); // Surely the maximum y pos. should be h - 1.
446 /// Anyway, h is required for MSW.
447
448 dc.SetPen(lightShadowPen);
449 dc.DrawLine(w-2, 1, w-2, h-2); // Right hand side
450 dc.DrawLine(1, h-2, w-1, h-2); // Bottom
451 }
452 else if ( GetWindowStyleFlag() & wxSW_BORDER )
453 {
454 dc.SetBrush(*wxTRANSPARENT_BRUSH);
455 dc.SetPen(*wxBLACK_PEN);
456 dc.DrawRectangle(0, 0, w-1, h-1);
457 }
458
459 dc.SetPen(wxNullPen);
460 dc.SetBrush(wxNullBrush);
461 }
462
463 void wxSashWindow::DrawSashes(wxDC& dc)
464 {
465 int i;
466 for (i = 0; i < 4; i++)
467 if (m_sashes[i].m_show)
468 DrawSash((wxSashEdgePosition) i, dc);
469 }
470
471 // Draw the sash
472 void wxSashWindow::DrawSash(wxSashEdgePosition edge, wxDC& dc)
473 {
474 int w, h;
475 GetClientSize(&w, &h);
476
477 wxPen facePen(m_faceColour, 1, wxPENSTYLE_SOLID);
478 wxBrush faceBrush(m_faceColour, wxBRUSHSTYLE_SOLID);
479 wxPen mediumShadowPen(m_mediumShadowColour, 1, wxPENSTYLE_SOLID);
480 wxPen darkShadowPen(m_darkShadowColour, 1, wxPENSTYLE_SOLID);
481 wxPen lightShadowPen(m_lightShadowColour, 1, wxPENSTYLE_SOLID);
482 wxPen hilightPen(m_hilightColour, 1, wxPENSTYLE_SOLID);
483 wxColour blackClr(0, 0, 0);
484 wxColour whiteClr(255, 255, 255);
485 wxPen blackPen(blackClr, 1, wxPENSTYLE_SOLID);
486 wxPen whitePen(whiteClr, 1, wxPENSTYLE_SOLID);
487
488 if ( edge == wxSASH_LEFT || edge == wxSASH_RIGHT )
489 {
490 int sashPosition = (edge == wxSASH_LEFT) ? 0 : ( w - GetEdgeMargin(edge) );
491
492 dc.SetPen(facePen);
493 dc.SetBrush(faceBrush);
494 dc.DrawRectangle(sashPosition, 0, GetEdgeMargin(edge), h);
495
496 if (GetWindowStyleFlag() & wxSW_3DSASH)
497 {
498 if (edge == wxSASH_LEFT)
499 {
500 // Draw a dark grey line on the left to indicate that the
501 // sash is raised
502 dc.SetPen(mediumShadowPen);
503 dc.DrawLine(GetEdgeMargin(edge), 0, GetEdgeMargin(edge), h);
504 }
505 else
506 {
507 // Draw a highlight line on the right to indicate that the
508 // sash is raised
509 dc.SetPen(hilightPen);
510 dc.DrawLine(w - GetEdgeMargin(edge), 0, w - GetEdgeMargin(edge), h);
511 }
512 }
513 }
514 else // top or bottom
515 {
516 int sashPosition = (edge == wxSASH_TOP) ? 0 : ( h - GetEdgeMargin(edge) );
517
518 dc.SetPen(facePen);
519 dc.SetBrush(faceBrush);
520 dc.DrawRectangle(0, sashPosition, w, GetEdgeMargin(edge));
521
522 if (GetWindowStyleFlag() & wxSW_3DSASH)
523 {
524 if (edge == wxSASH_BOTTOM)
525 {
526 // Draw a highlight line on the bottom to indicate that the
527 // sash is raised
528 dc.SetPen(hilightPen);
529 dc.DrawLine(0, h - GetEdgeMargin(edge), w, h - GetEdgeMargin(edge));
530 }
531 else
532 {
533 // Draw a drak grey line on the top to indicate that the
534 // sash is raised
535 dc.SetPen(mediumShadowPen);
536 dc.DrawLine(1, GetEdgeMargin(edge), w-1, GetEdgeMargin(edge));
537 }
538 }
539 }
540
541 dc.SetPen(wxNullPen);
542 dc.SetBrush(wxNullBrush);
543 }
544
545 // Draw the sash tracker (for whilst moving the sash)
546 void wxSashWindow::DrawSashTracker(wxSashEdgePosition edge, int x, int y)
547 {
548 int w, h;
549 GetClientSize(&w, &h);
550
551 wxScreenDC screenDC;
552 int x1, y1;
553 int x2, y2;
554
555 if ( edge == wxSASH_LEFT || edge == wxSASH_RIGHT )
556 {
557 x1 = x; y1 = 2;
558 x2 = x; y2 = h-2;
559
560 if ( (edge == wxSASH_LEFT) && (x1 > w) )
561 {
562 x1 = w; x2 = w;
563 }
564 else if ( (edge == wxSASH_RIGHT) && (x1 < 0) )
565 {
566 x1 = 0; x2 = 0;
567 }
568 }
569 else
570 {
571 x1 = 2; y1 = y;
572 x2 = w-2; y2 = y;
573
574 if ( (edge == wxSASH_TOP) && (y1 > h) )
575 {
576 y1 = h;
577 y2 = h;
578 }
579 else if ( (edge == wxSASH_BOTTOM) && (y1 < 0) )
580 {
581 y1 = 0;
582 y2 = 0;
583 }
584 }
585
586 ClientToScreen(&x1, &y1);
587 ClientToScreen(&x2, &y2);
588
589 wxPen sashTrackerPen(*wxBLACK, 2, wxPENSTYLE_SOLID);
590
591 screenDC.SetLogicalFunction(wxINVERT);
592 screenDC.SetPen(sashTrackerPen);
593 screenDC.SetBrush(*wxTRANSPARENT_BRUSH);
594
595 screenDC.DrawLine(x1, y1, x2, y2);
596
597 screenDC.SetLogicalFunction(wxCOPY);
598
599 screenDC.SetPen(wxNullPen);
600 screenDC.SetBrush(wxNullBrush);
601 }
602
603 // Position and size subwindows.
604 // Note that the border size applies to each subwindow, not
605 // including the edges next to the sash.
606 void wxSashWindow::SizeWindows()
607 {
608 int cw, ch;
609 GetClientSize(&cw, &ch);
610
611 if (GetChildren().GetCount() == 1)
612 {
613 wxWindow* child = GetChildren().GetFirst()->GetData();
614
615 int x = 0;
616 int y = 0;
617 int width = cw;
618 int height = ch;
619
620 // Top
621 if (m_sashes[0].m_show)
622 {
623 y = m_borderSize;
624 height -= m_borderSize;
625 }
626 y += m_extraBorderSize;
627
628 // Left
629 if (m_sashes[3].m_show)
630 {
631 x = m_borderSize;
632 width -= m_borderSize;
633 }
634 x += m_extraBorderSize;
635
636 // Right
637 if (m_sashes[1].m_show)
638 {
639 width -= m_borderSize;
640 }
641 width -= 2*m_extraBorderSize;
642
643 // Bottom
644 if (m_sashes[2].m_show)
645 {
646 height -= m_borderSize;
647 }
648 height -= 2*m_extraBorderSize;
649
650 child->SetSize(x, y, width, height);
651 }
652 else if (GetChildren().GetCount() > 1)
653 {
654 // Perhaps multiple children are themselves sash windows.
655 // TODO: this doesn't really work because the subwindows sizes/positions
656 // must be set to leave a gap for the parent's sash (hit-test and decorations).
657 // Perhaps we can allow for this within LayoutWindow, testing whether the parent
658 // is a sash window, and if so, allowing some space for the edges.
659 wxLayoutAlgorithm layout;
660 layout.LayoutWindow(this);
661 }
662
663 wxClientDC dc(this);
664 DrawBorders(dc);
665 DrawSashes(dc);
666 }
667
668 // Initialize colours
669 void wxSashWindow::InitColours()
670 {
671 // Shadow colours
672 m_faceColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
673 m_mediumShadowColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW);
674 m_darkShadowColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW);
675 m_lightShadowColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT);
676 m_hilightColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DHILIGHT);
677 }
678
679 void wxSashWindow::SetSashVisible(wxSashEdgePosition edge, bool sash)
680 {
681 m_sashes[edge].m_show = sash;
682 if (sash)
683 m_sashes[edge].m_margin = m_borderSize;
684 else
685 m_sashes[edge].m_margin = 0;
686 }
687
688 #if defined( __WXMSW__ ) || defined( __WXMAC__)
689
690 // this is currently called (and needed) under MSW only...
691 void wxSashWindow::OnSetCursor(wxSetCursorEvent& event)
692 {
693 // if we don't do it, the resizing cursor might be set for child window:
694 // and like this we explicitly say that our cursor should not be used for
695 // children windows which overlap us
696
697 if ( SashHitTest(event.GetX(), event.GetY()) != wxSASH_NONE)
698 {
699 // default processing is ok
700 event.Skip();
701 }
702 //else: do nothing, in particular, don't call Skip()
703 }
704
705 #endif // __WXMSW__ || __WXMAC__
706
707 #endif // wxUSE_SASH