]> git.saurik.com Git - wxWidgets.git/blob - contrib/src/gizmos/dynamicsash.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Warning fixes.
[wxWidgets.git] / contrib / src / gizmos / dynamicsash.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: dynamicsash.cpp
3 // Purpose: A window which can be dynamically split to an arbitrary depth
4 // and later reunified through the user interface
5 // Author: Matt Kimball
6 // Modified by:
7 // Created: 7/15/2001
8 // RCS-ID: $Id$
9 // Copyright: (c) 2001 Matt Kimball
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
12
13 #ifdef __GNUG__
14 #pragma implementation "splittree.h"
15 #endif
16
17 // For compilers that support precompilation, includes "wx/wx.h".
18 #include "wx/wxprec.h"
19
20 #ifdef __BORLANDC__
21 #pragma hdrstop
22 #endif
23
24 // for all others, include the necessary headers (this file is usually all you
25 // need because it includes almost all "standard" wxWidgets headers)
26 #ifndef WX_PRECOMP
27 #include "wx/wx.h"
28 #endif
29
30 #ifdef __WXMSW__
31 #include "wx/mdi.h"
32 #endif
33
34 #include "wx/gizmos/dynamicsash.h"
35
36
37 const wxChar* wxDynamicSashWindowNameStr = wxT("dynamicSashWindow");
38
39
40 /*
41 wxDynamicSashWindow works by internally storing a tree of Implementation
42 objects (wxDynamicSsahWindowImpl) and Leaf objects
43 (wxDynamicSashWindowLeaf). The wxDynamicSashWindow has a pointer to one
44 implementation, and each implementation either has a pointer to a one
45 leaf (m_leaf) or a pointer to two children implementation objects
46 (m_child). The leaves each are responsible for drawing the frame and
47 decorations around one user-provided views and for responding to mouse
48 and scrollbar events.
49
50 A resulting tree might look something like this:
51
52 wxDynamicSashWindow
53 |
54 +- wxDynamicSashWindowImpl
55 |
56 +- wxDynamicSashWindowLeaf
57 | |
58 | +- user view window
59 |
60 +- wxDynamicSashWindowImpl
61 |
62 +- wxDynamicSashWindowLeaf
63 | |
64 | +- user view window
65 |
66 +- wxDynamicSashWindowLeaf
67 |
68 +- user view window
69
70 Each time a split occurs, one of the implementation objects removes its
71 leaf, generates two new implementation object children, each with a new
72 leaf, and reparents the user view which was connected to its old leaf
73 to be one of the new leaf's user view, and sends a Split event to the
74 user view in the hopes that it will generate a new user view for the
75 other new leaf.
76
77 When a unification ocurrs, an implementation object is replaced by one
78 of its children, and the tree of its other child is pruned.
79
80 One quirk is that the top-level implementation object (m_top) always
81 keeps a pointer to the implementation object where a new child is needed.
82 (m_add_child_target). This is so that when a new uesr view is added
83 to the hierarchy, AddChild() is able to reparent the new user view to
84 the correct implementation object's leaf.
85
86 */
87
88 #include <wx/dcmemory.h>
89 #include <wx/dcscreen.h>
90 #include <wx/layout.h>
91 #include <wx/scrolbar.h>
92 #include <wx/settings.h>
93
94
95 #define wxEVT_DYNAMIC_SASH_PRIVATE (wxEVT_DYNAMIC_SASH_BASE + 8)
96 #define wxEVT_DYNAMIC_SASH_REPARENT (wxEVT_DYNAMIC_SASH_PRIVATE + 1)
97
98
99 /*
100 wxDynamicSashReparentEvent is generated by the AddChild() method of
101 wxDynamicSashWindow when it wants a Leaf to reparent a user view window
102 to its viewport at some time in the future. We can't reparent the window
103 immediately, because switching parents in AddChild() confuses the wxWindow
104 class. Instead, we queue up this event, and the window is actually
105 reparented the next time we process events in the idle loop.
106 */
107 class wxDynamicSashReparentEvent : public wxEvent {
108 public:
109 wxDynamicSashReparentEvent();
110 wxDynamicSashReparentEvent(wxObject *object);
111 wxDynamicSashReparentEvent(const wxDynamicSashReparentEvent& evt);
112
113 virtual wxEvent* Clone() const { return new wxDynamicSashReparentEvent(*this); }
114
115 DECLARE_DYNAMIC_CLASS(wxDynamicSashReparentEvent)
116 };
117
118
119 enum DynamicSashRegion {
120 DSR_NONE,
121 DSR_VERTICAL_TAB,
122 DSR_HORIZONTAL_TAB,
123 DSR_CORNER,
124 DSR_LEFT_EDGE,
125 DSR_TOP_EDGE,
126 DSR_RIGHT_EDGE,
127 DSR_BOTTOM_EDGE
128 };
129
130
131 class wxDynamicSashWindowImpl : public wxEvtHandler {
132 public:
133 wxDynamicSashWindowImpl(wxDynamicSashWindow *window);
134 ~wxDynamicSashWindowImpl();
135
136 bool Create();
137 void AddChild(wxWindow *window);
138 void DrawSash(int x, int y) const;
139 void ConstrainChildren(int px, int py);
140 void Split(int x, int y);
141 void Unify(int panel);
142 void Resize(int x, int y);
143 wxDynamicSashWindowImpl *FindParent(DynamicSashRegion side) const;
144 wxDynamicSashWindowImpl *FindUpperParent(wxDynamicSashWindowImpl *sash_a,
145 wxDynamicSashWindowImpl *sash_b) const;
146 wxWindow *FindFrame() const;
147 wxScrollBar *FindScrollBar(const wxWindow *child, int vert) const;
148
149 void OnSize(wxSizeEvent &event);
150 void OnPaint(wxPaintEvent &event);
151 void OnMouseMove(wxMouseEvent &event);
152 void OnLeave(wxMouseEvent &event);
153 void OnPress(wxMouseEvent &event);
154 void OnRelease(wxMouseEvent &event);
155
156 wxDynamicSashWindow *m_window;
157 wxDynamicSashWindowImpl *m_add_child_target;
158
159 /* This is the window we are responsible for managing. Either of
160 leaf or our children are in this window. For the top level
161 implementation object, this is the same as m_window.
162 Otherwise it is a window we've created an will destroy when we
163 are deleted. */
164 wxWindow *m_container;
165
166 wxDynamicSashWindowImpl *m_parent;
167 wxDynamicSashWindowImpl *m_top;
168 wxDynamicSashWindowImpl *m_child[2];
169
170 class wxDynamicSashWindowLeaf *m_leaf;
171
172 /* If the implementation is split horizontally or vertically, m_split
173 is set to DSR_HORIZONTAL_TAB or DSR_VERTICAL_TAB, respectively.
174 Otherwise it is set to DSR_NONE. */
175 DynamicSashRegion m_split;
176
177 /* These are used to keep track of a sash as it is being dragged, for
178 drawing the user interface correctly. */
179 DynamicSashRegion m_dragging;
180 int m_drag_x, m_drag_y;
181 };
182
183 class wxDynamicSashWindowLeaf : public wxEvtHandler {
184 public:
185 wxDynamicSashWindowLeaf(wxDynamicSashWindowImpl *impl);
186 ~wxDynamicSashWindowLeaf();
187
188 bool Create();
189 void AddChild(wxWindow *window);
190 DynamicSashRegion GetRegion(int x, int y);
191 void ResizeChild(wxSize size);
192 wxScrollBar *FindScrollBar(const wxWindow *child, int vert) const;
193
194 void OnSize(wxSizeEvent &event);
195 void OnPaint(wxPaintEvent &event);
196 void OnScroll(wxScrollEvent &event);
197 void OnFocus(wxFocusEvent &event);
198 void OnMouseMove(wxMouseEvent &event);
199 void OnLeave(wxMouseEvent &event);
200 void OnPress(wxMouseEvent &event);
201 void OnRelease(wxMouseEvent &event);
202 void OnReparent(wxEvent &event);
203
204 wxDynamicSashWindowImpl *m_impl;
205
206 wxScrollBar *m_vscroll, *m_hscroll;
207
208 /* m_child is the window provided to us by the application developer.
209 m_viewport is a window we've created, and it is the immediately
210 parent of m_child. We scroll m_child by moving it around within
211 m_viewport. */
212 wxWindow *m_viewport, *m_child;
213 };
214
215 // wxDynamicSashWindow //////////////////////////////////////////////////////
216
217 wxDynamicSashWindow::wxDynamicSashWindow() {
218 m_impl = NULL;
219 }
220
221 wxDynamicSashWindow::wxDynamicSashWindow(wxWindow *parent, wxWindowID id,
222 const wxPoint& pos, const wxSize& size,
223 long style, const wxString& name) {
224 m_impl = NULL;
225 Create(parent, id, pos, size, style, name);
226 }
227
228 wxDynamicSashWindow::~wxDynamicSashWindow() {
229 SetEventHandler(this);
230 delete m_impl;
231 }
232
233 bool wxDynamicSashWindow::Create(wxWindow *parent, wxWindowID id,
234 const wxPoint& pos, const wxSize& size,
235 long style, const wxString& name) {
236 if (m_impl)
237 return false;
238
239 if (!wxWindow::Create(parent, id, pos, size, style, name))
240 return false;
241
242 m_impl = new wxDynamicSashWindowImpl(this);
243 if (!m_impl)
244 return false;
245
246 if (!m_impl->Create()) {
247 delete m_impl;
248 m_impl = NULL;
249 return false;
250 }
251
252 return true;
253 }
254
255 void wxDynamicSashWindow::AddChild(wxWindowBase *child) {
256 wxWindow::AddChild(child);
257
258 m_impl->AddChild(wxDynamicCast(child, wxWindow));
259 }
260
261 wxScrollBar *wxDynamicSashWindow::GetHScrollBar(const wxWindow *child) const {
262 return m_impl->FindScrollBar(child, 0);
263 }
264
265 wxScrollBar *wxDynamicSashWindow::GetVScrollBar(const wxWindow *child) const {
266 return m_impl->FindScrollBar(child, 1);
267 }
268
269 IMPLEMENT_DYNAMIC_CLASS(wxDynamicSashWindow, wxWindow)
270
271 // wxDynamicSashWindowImpl //////////////////////////////////////////////////
272
273 wxDynamicSashWindowImpl::wxDynamicSashWindowImpl(wxDynamicSashWindow *window) {
274 m_window = window;
275 m_add_child_target = this;
276
277 m_container = NULL;
278 m_parent = NULL;
279 m_top = this;
280 m_child[0] = m_child[1] = NULL;
281 m_leaf = NULL;
282 m_dragging = DSR_NONE;
283 m_split = DSR_NONE;
284 }
285
286 wxDynamicSashWindowImpl::~wxDynamicSashWindowImpl() {
287 delete m_leaf;
288 delete m_child[0];
289 m_child[0] = NULL;
290 delete m_child[1];
291 m_child[1] = NULL;
292 m_leaf = NULL;
293
294 if (m_container != m_window && m_container) {
295 m_container->SetEventHandler(m_container);
296 m_container->Destroy();
297 }
298 }
299
300 bool wxDynamicSashWindowImpl::Create() {
301 if (!m_container) {
302 m_container = m_window;
303 }
304
305 wxCursor cursor(wxCURSOR_ARROW);
306 m_container->SetCursor(cursor);
307
308 m_leaf = new wxDynamicSashWindowLeaf(this);
309 if (!m_leaf)
310 return false;
311
312 if (!m_leaf->Create()) {
313 delete m_leaf;
314 m_leaf = NULL;
315 return false;
316 }
317
318 m_container->SetEventHandler(this);
319
320 Connect(wxID_ANY, wxEVT_SIZE, (wxObjectEventFunction)
321 (wxEventFunction)
322 (wxSizeEventFunction)&wxDynamicSashWindowImpl::OnSize);
323 Connect(wxID_ANY, wxEVT_PAINT, (wxObjectEventFunction)
324 (wxEventFunction)
325 (wxPaintEventFunction)&wxDynamicSashWindowImpl::OnPaint);
326 Connect(wxID_ANY, wxEVT_MOTION, (wxObjectEventFunction)
327 (wxEventFunction)
328 (wxMouseEventFunction)&wxDynamicSashWindowImpl::OnMouseMove);
329 Connect(wxID_ANY, wxEVT_ENTER_WINDOW, (wxObjectEventFunction)
330 (wxEventFunction)
331 (wxMouseEventFunction)&wxDynamicSashWindowImpl::OnMouseMove);
332 Connect(wxID_ANY, wxEVT_LEAVE_WINDOW, (wxObjectEventFunction)
333 (wxEventFunction)
334 (wxMouseEventFunction)&wxDynamicSashWindowImpl::OnLeave);
335 Connect(wxID_ANY, wxEVT_LEFT_DOWN, (wxObjectEventFunction)
336 (wxEventFunction)
337 (wxMouseEventFunction)&wxDynamicSashWindowImpl::OnPress);
338 Connect(wxID_ANY, wxEVT_LEFT_UP, (wxObjectEventFunction)
339 (wxEventFunction)
340 (wxMouseEventFunction)&wxDynamicSashWindowImpl::OnRelease);
341
342 return true;
343 }
344
345 void wxDynamicSashWindowImpl::AddChild(wxWindow *window) {
346 if (m_add_child_target && m_add_child_target->m_leaf) {
347 m_add_child_target->m_leaf->AddChild(window);
348 }
349 }
350
351 void wxDynamicSashWindowImpl::DrawSash(int x, int y) const {
352 int i, j;
353
354 wxScreenDC dc;
355 dc.StartDrawingOnTop(m_container);
356
357 wxBitmap bmp(8, 8);
358 wxMemoryDC bdc;
359 bdc.SelectObject(bmp);
360 bdc.DrawRectangle(-1, -1, 10, 10);
361 for (i = 0; i < 8; i++) {
362 for (j = 0; j < 8; j++) {
363 if ((i + j) & 1) {
364 bdc.DrawPoint(i, j);
365 }
366 }
367 }
368
369 wxBrush brush(bmp);
370 dc.SetBrush(brush);
371 dc.SetLogicalFunction(wxXOR);
372
373 if ((m_dragging == DSR_CORNER) &&
374 (m_window->GetWindowStyle() & wxDS_DRAG_CORNER) != 0) {
375 int cx = 0;
376 int cy = 0;
377
378 m_container->ClientToScreen(&cx, &cy);
379 m_container->ClientToScreen(&x, &y);
380
381 if (cx < x && cy < y) {
382 dc.DrawRectangle(cx - 2, cy - 2, x - cx + 4, 4);
383 dc.DrawRectangle(x - 2, cy + 2, 4, y - cy);
384 dc.DrawRectangle(cx - 2, cy + 2, 4, y - cy);
385 dc.DrawRectangle(cx + 2, y - 2, x - cx - 4, 4);
386 }
387 } else {
388 int body_w, body_h;
389 m_container->GetClientSize(&body_w, &body_h);
390
391 if (y < 0)
392 y = 0;
393 if (y > body_h)
394 y = body_h;
395 if (x < 0)
396 x = 0;
397 if (x > body_w)
398 x = body_w;
399
400 if (m_dragging == DSR_HORIZONTAL_TAB)
401 x = 0;
402 else
403 y = 0;
404
405 m_container->ClientToScreen(&x, &y);
406
407 int w, h;
408 w = body_w; h = body_h;
409
410 if (m_dragging == DSR_HORIZONTAL_TAB)
411 dc.DrawRectangle(x, y - 2, w, 4);
412 else
413 dc.DrawRectangle(x - 2, y, 4, h);
414 }
415
416 dc.EndDrawingOnTop();
417 }
418
419 wxDynamicSashWindowImpl *wxDynamicSashWindowImpl::FindParent(DynamicSashRegion side) const {
420 if (m_parent == NULL) {
421 return NULL;
422 }
423
424 if (m_parent->m_split == DSR_HORIZONTAL_TAB) {
425 if (side == DSR_TOP_EDGE && m_parent->m_child[1] == this)
426 return m_parent;
427 if (side == DSR_BOTTOM_EDGE && m_parent->m_child[0] == this)
428 return m_parent;
429 } else if (m_parent->m_split == DSR_VERTICAL_TAB) {
430 if (side == DSR_LEFT_EDGE && m_parent->m_child[1] == this)
431 return m_parent;
432 if (side == DSR_RIGHT_EDGE && m_parent->m_child[0] == this)
433 return m_parent;
434 }
435
436 return m_parent->FindParent(side);
437 }
438
439 wxDynamicSashWindowImpl *wxDynamicSashWindowImpl::FindUpperParent(wxDynamicSashWindowImpl *sash_a,
440 wxDynamicSashWindowImpl *sash_b) const {
441 wxWindow *win;
442 win = sash_a->m_container->GetParent();
443 while (win && !win->IsTopLevel()) {
444 if (win == sash_b->m_container) {
445 return sash_b;
446 }
447
448 win = win->GetParent();
449 }
450
451 return sash_a;
452 }
453
454
455 wxWindow *wxDynamicSashWindowImpl::FindFrame() const {
456 wxWindow *win;
457
458 win = m_window->GetParent();
459 while (win && !win->IsTopLevel()
460 #ifdef __WXMSW__
461 && ! wxIsKindOf(win, wxMDIChildFrame) // not top-level but still a frame
462 #endif
463 ) {
464 win = win->GetParent();
465 }
466
467 return win;
468 }
469
470 wxScrollBar *wxDynamicSashWindowImpl::FindScrollBar(const wxWindow *child, int vert) const {
471 if (m_child[0] == NULL && m_leaf == NULL) {
472 return NULL;
473 }
474
475 if (!m_child[0]) {
476 return m_leaf->FindScrollBar(child, vert);
477 } else {
478 wxScrollBar *ret = m_child[0]->FindScrollBar(child, vert);
479 if (!ret) {
480 ret = m_child[1]->FindScrollBar(child, vert);
481 }
482
483 return ret;
484 }
485 }
486
487 void wxDynamicSashWindowImpl::ConstrainChildren(int px, int py) {
488 wxLayoutConstraints *layout = new wxLayoutConstraints();
489 layout->left.SameAs(m_container, wxLeft);
490 layout->top.SameAs(m_container, wxTop);
491 if (m_split == DSR_HORIZONTAL_TAB) {
492 layout->right.SameAs(m_container, wxRight);
493 layout->height.PercentOf(m_container, wxHeight, py);
494 } else {
495 layout->bottom.SameAs(m_container, wxBottom);
496 layout->width.PercentOf(m_container, wxWidth, px);
497 }
498 m_child[0]->m_container->SetConstraints(layout);
499
500 layout = new wxLayoutConstraints();
501 layout->right.SameAs(m_container, wxRight);
502 layout->bottom.SameAs(m_container, wxBottom);
503 if (m_split == DSR_HORIZONTAL_TAB) {
504 layout->top.Below(m_child[0]->m_container, 1);
505 layout->left.SameAs(m_container, wxLeft);
506 } else {
507 layout->left.RightOf(m_child[0]->m_container, 1);
508 layout->top.SameAs(m_container, wxTop);
509 }
510 m_child[1]->m_container->SetConstraints(layout);
511 }
512
513 void wxDynamicSashWindowImpl::Unify(int panel) {
514 int other = 0;
515 if (panel == 0) {
516 other = 1;
517 }
518
519 if (m_child[panel]->m_leaf) {
520 wxDynamicSashWindowImpl *child[2];
521
522 child[0] = m_child[0];
523 child[1] = m_child[1];
524
525 m_child[0] = m_child[1] = NULL;
526
527 m_leaf = new wxDynamicSashWindowLeaf(this);
528 m_leaf->Create();
529 m_leaf->m_child = child[panel]->m_leaf->m_child;
530
531 m_leaf->m_vscroll->SetScrollbar(child[panel]->m_leaf->m_vscroll->GetThumbPosition(),
532 child[panel]->m_leaf->m_vscroll->GetThumbSize(),
533 child[panel]->m_leaf->m_vscroll->GetRange(),
534 child[panel]->m_leaf->m_vscroll->GetPageSize());
535 m_leaf->m_hscroll->SetScrollbar(child[panel]->m_leaf->m_hscroll->GetThumbPosition(),
536 child[panel]->m_leaf->m_hscroll->GetThumbSize(),
537 child[panel]->m_leaf->m_hscroll->GetRange(),
538 child[panel]->m_leaf->m_hscroll->GetPageSize());
539 m_add_child_target = NULL;
540 wxDynamicSashReparentEvent event(m_leaf);
541 m_leaf->ProcessEvent(event);
542
543 delete child[0];
544 delete child[1];
545
546 m_split = DSR_NONE;
547
548 wxDynamicSashUnifyEvent unify(m_leaf->m_child);
549 m_leaf->m_child->ProcessEvent(unify);
550 } else {
551 m_split = m_child[panel]->m_split;
552
553 delete m_child[other];
554
555 wxDynamicSashWindowImpl *child_panel = m_child[panel];
556 m_child[0] = child_panel->m_child[0];
557 m_child[1] = child_panel->m_child[1];
558
559 m_child[0]->m_parent = this;
560 m_child[1]->m_parent = this;
561
562 m_add_child_target = NULL;
563 m_child[0]->m_container->Reparent(m_container);
564 m_child[1]->m_container->Reparent(m_container);
565
566 child_panel->m_child[0] = child_panel->m_child[1] = NULL;
567 delete child_panel;
568
569 wxSize size = m_container->GetSize();
570 wxSize child_size = m_child[0]->m_container->GetSize();
571
572 ConstrainChildren(child_size.GetWidth() * 100 / size.GetWidth(),
573 child_size.GetHeight() * 100 / size.GetHeight());
574
575 m_container->Layout();
576 }
577 }
578
579 void wxDynamicSashWindowImpl::Split(int px, int py) {
580
581 m_add_child_target = NULL;
582
583 m_child[0] = new wxDynamicSashWindowImpl(m_window);
584 m_child[0]->m_container = new wxWindow(m_container, wxID_ANY);
585 m_child[0]->m_parent = this;
586 m_child[0]->m_top = m_top;
587 m_child[0]->Create();
588 if (m_leaf->m_child) {
589 m_leaf->m_child->Reparent(m_container);
590 m_child[0]->AddChild(m_leaf->m_child);
591 }
592
593 m_child[1] = new wxDynamicSashWindowImpl(m_window);
594 m_child[1]->m_container = new wxWindow(m_container, wxID_ANY);
595 m_child[1]->m_parent = this;
596 m_child[1]->m_top = m_top;
597 m_child[1]->Create();
598
599 m_split = m_dragging;
600 ConstrainChildren(px, py);
601
602 m_top->m_add_child_target = m_child[1];
603 wxDynamicSashSplitEvent split(m_child[0]->m_leaf->m_child);
604 m_child[0]->m_leaf->m_child->ProcessEvent(split);
605
606 m_child[0]->m_leaf->m_vscroll->SetScrollbar(m_leaf->m_vscroll->GetThumbPosition(),
607 m_leaf->m_vscroll->GetThumbSize(),
608 m_leaf->m_vscroll->GetRange(),
609 m_leaf->m_vscroll->GetPageSize());
610 m_child[0]->m_leaf->m_hscroll->SetScrollbar(m_leaf->m_hscroll->GetThumbPosition(),
611 m_leaf->m_hscroll->GetThumbSize(),
612 m_leaf->m_hscroll->GetRange(),
613 m_leaf->m_hscroll->GetPageSize());
614 m_child[1]->m_leaf->m_vscroll->SetScrollbar(m_leaf->m_vscroll->GetThumbPosition(),
615 m_leaf->m_vscroll->GetThumbSize(),
616 m_leaf->m_vscroll->GetRange(),
617 m_leaf->m_vscroll->GetPageSize());
618 m_child[1]->m_leaf->m_hscroll->SetScrollbar(m_leaf->m_hscroll->GetThumbPosition(),
619 m_leaf->m_hscroll->GetThumbSize(),
620 m_leaf->m_hscroll->GetRange(),
621 m_leaf->m_hscroll->GetPageSize());
622 delete m_leaf;
623 m_leaf = NULL;
624
625 m_container->Layout();
626 }
627
628
629 /* This code is called when you finish resizing a view by dragging the
630 corner tab, but I think this implementation is lousy and will surprise
631 the user more often than it will do what they are trying to do. What
632 I really need to be doing here is do a rewrite such that *no* sashes
633 move except the ones immediately to the bottom and right of this window,
634 and handle the case where you resize a window larger than it's neighbors
635 by destroying the neighbors.
636
637 But this will do for now. */
638 void wxDynamicSashWindowImpl::Resize(int x, int y) {
639 wxDynamicSashWindowImpl *h_parent = FindParent(DSR_BOTTOM_EDGE);
640 wxDynamicSashWindowImpl *v_parent = FindParent(DSR_RIGHT_EDGE);
641 int h_unify = -1;
642 int v_unify = -1;
643 wxWindow *frame = FindFrame();
644
645 if (x < 0) {
646 x = 0;
647 }
648 if (y < 0) {
649 y = 0;
650 }
651
652 if (h_parent) {
653 m_container->ClientToScreen(NULL, &y);
654 h_parent->m_container->ScreenToClient(NULL, &y);
655
656 int py = (int)((y * 100) / h_parent->m_container->GetSize().GetHeight() + 0.5);
657
658 if (py < 10) {
659 wxDynamicSashWindowImpl *ho_parent = FindParent(DSR_TOP_EDGE);
660
661 if (ho_parent) {
662 if (FindUpperParent(h_parent, ho_parent) == ho_parent) {
663 h_unify = 1;
664 } else {
665 py = (int)((ho_parent->m_child[0]->m_container->GetSize().GetHeight() * 100)
666 / h_parent->m_container->GetSize().GetHeight() + 0.5);
667 h_parent->m_child[0]->m_container->GetConstraints()->height.PercentOf(
668 h_parent->m_container, wxHeight, py);
669
670 h_parent = ho_parent;
671 h_unify = 0;
672 }
673 } else {
674 h_unify = 1;
675 }
676 } else if (py > 90) {
677 h_unify = 0;
678 } else {
679 h_parent->m_child[0]->m_container->GetConstraints()->height.PercentOf(
680 h_parent->m_container, wxHeight, py);
681 h_parent->m_container->Layout();
682 }
683 } else {
684 int do_resize = 1;
685 h_parent = FindParent(DSR_TOP_EDGE);
686
687 if (h_parent) {
688 int py = (int)((y * 100) /
689 (h_parent->m_container->GetSize().GetHeight() +
690 y - m_container->GetSize().GetHeight()) + 0.5);
691
692 if (py < 10) {
693 h_unify = 0;
694 }
695 } else if (y < 64) {
696 do_resize = 0;
697 }
698
699 if (do_resize) {
700 wxSize size = frame->GetSize();
701 frame->SetSize(size.GetWidth(), size.GetHeight() + y - m_container->GetSize().GetHeight());
702 }
703 }
704
705 if (v_parent) {
706 m_container->ClientToScreen(&x, NULL);
707 v_parent->m_container->ScreenToClient(&x, NULL);
708
709 int px = (int)((x * 100) / v_parent->m_container->GetSize().GetWidth() + 0.5);
710
711 if (px < 10) {
712 wxDynamicSashWindowImpl *vo_parent = FindParent(DSR_LEFT_EDGE);
713
714 if (vo_parent) {
715 if (FindUpperParent(v_parent, vo_parent) == vo_parent) {
716 v_unify = 1;
717 } else {
718 px = (int)((vo_parent->m_child[0]->m_container->GetSize().GetWidth() * 100)
719 / v_parent->m_container->GetSize().GetWidth() + 0.5);
720 v_parent->m_child[0]->m_container->GetConstraints()->width.PercentOf(
721 v_parent->m_container, wxWidth, px);
722
723 v_parent = vo_parent;
724 v_unify = 0;
725 }
726 } else {
727 v_unify = 1;
728 }
729 } else if (px > 90) {
730 v_unify = 0;
731 } else {
732 v_parent->m_child[0]->m_container->GetConstraints()->width.PercentOf(
733 v_parent->m_container, wxWidth, px);
734 v_parent->m_container->Layout();
735 }
736 } else {
737 int do_resize = 1;
738 v_parent = FindParent(DSR_LEFT_EDGE);
739
740 if (v_parent) {
741 int px = (int)((x * 100) /
742 (v_parent->m_container->GetSize().GetWidth() +
743 x - m_container->GetSize().GetWidth()) + 0.5);
744
745 if (px < 10) {
746 v_unify = 0;
747 }
748 } else if (x < 64) {
749 do_resize = 0;
750 }
751
752 if (do_resize) {
753 wxSize size = frame->GetSize();
754 frame->SetSize(size.GetWidth() + x - m_container->GetSize().GetWidth(), size.GetHeight());
755 }
756 }
757
758 if (h_unify != -1 && v_unify != -1) {
759 wxDynamicSashWindowImpl *parent = FindUpperParent(h_parent, v_parent);
760
761 if (parent == h_parent) {
762 h_parent->Unify(h_unify);
763 } else {
764 v_parent->Unify(v_unify);
765 }
766 } else if (h_unify != -1) {
767 h_parent->Unify(h_unify);
768 } else if (v_unify != -1) {
769 v_parent->Unify(v_unify);
770 }
771 }
772
773
774 void wxDynamicSashWindowImpl::OnSize(wxSizeEvent &event) {
775 m_container->Layout();
776
777 if (m_leaf)
778 m_leaf->OnSize(event);
779 }
780
781 void wxDynamicSashWindowImpl::OnPaint(wxPaintEvent &event) {
782 if (m_leaf)
783 m_leaf->OnPaint(event);
784 else {
785 wxPaintDC dc(m_container);
786 dc.SetBackground(wxBrush(m_container->GetBackgroundColour(), wxSOLID));
787 dc.Clear();
788 }
789 }
790
791 void wxDynamicSashWindowImpl::OnMouseMove(wxMouseEvent &event) {
792 if (m_dragging) {
793 DrawSash(m_drag_x, m_drag_y);
794 m_drag_x = event.m_x; m_drag_y = event.m_y;
795 DrawSash(m_drag_x, m_drag_y);
796 } else if (m_leaf) {
797 m_leaf->OnMouseMove(event);
798 }
799 }
800
801 void wxDynamicSashWindowImpl::OnLeave(wxMouseEvent &event) {
802 if (m_leaf) {
803 m_leaf->OnLeave(event);
804 }
805 }
806
807 void wxDynamicSashWindowImpl::OnPress(wxMouseEvent &event) {
808 if (m_leaf) {
809 m_leaf->OnPress(event);
810 } else {
811 m_dragging = m_split;
812 m_drag_x = event.m_x;
813 m_drag_y = event.m_y;
814 DrawSash(m_drag_x, m_drag_y);
815 m_container->CaptureMouse();
816 }
817 }
818
819 void wxDynamicSashWindowImpl::OnRelease(wxMouseEvent &event) {
820 if ((m_dragging == DSR_CORNER) &&
821 (m_window->GetWindowStyle() & wxDS_DRAG_CORNER) != 0) {
822 DrawSash(m_drag_x, m_drag_y);
823 m_container->ReleaseMouse();
824
825 Resize(event.m_x, event.m_y);
826
827 m_dragging = DSR_NONE;
828 } else if (m_dragging) {
829 DrawSash(m_drag_x, m_drag_y);
830 m_container->ReleaseMouse();
831
832 wxSize size = m_container->GetSize();
833 int px = (int)((event.m_x * 100) / size.GetWidth() + 0.5);
834 int py = (int)((event.m_y * 100) / size.GetHeight() + 0.5);
835
836 if ((m_dragging == DSR_HORIZONTAL_TAB && py >= 10 && py <= 90)
837 || (m_dragging == DSR_VERTICAL_TAB && px >= 10 && px <= 90)) {
838 if (m_child[0] == NULL) {
839 Split(px, py);
840 } else {
841 /* It would be nice if moving *this* sash didn't implicitly move
842 the sashes of our children (if any). But this will do. */
843 wxLayoutConstraints *layout = m_child[0]->m_container->GetConstraints();
844 if (m_split == DSR_HORIZONTAL_TAB) {
845 layout->height.PercentOf(m_container, wxHeight, py);
846 } else {
847 layout->width.PercentOf(m_container, wxWidth, px);
848 }
849 m_container->Layout();
850 }
851 } else {
852 if (m_child[0] != NULL) {
853 if ((m_dragging == DSR_HORIZONTAL_TAB && py <= 10)
854 || (m_dragging == DSR_VERTICAL_TAB && px <= 10)) {
855 Unify(1);
856 } else {
857 Unify(0);
858 }
859 }
860 }
861
862 wxCursor cursor(wxCURSOR_ARROW);
863 if (m_split == DSR_HORIZONTAL_TAB) {
864 cursor = wxCursor(wxCURSOR_SIZENS);
865 } else if (m_split == DSR_VERTICAL_TAB) {
866 cursor = wxCursor(wxCURSOR_SIZEWE);
867 }
868 m_container->SetCursor(cursor);
869
870 m_dragging = DSR_NONE;
871 } else if (m_leaf) {
872 m_leaf->OnRelease(event);
873 }
874 }
875
876 // wxDynamicSashWindowLeaf //////////////////////////////////////////////////
877
878 wxDynamicSashWindowLeaf::wxDynamicSashWindowLeaf(wxDynamicSashWindowImpl *impl) {
879 m_impl = impl;
880
881 m_hscroll = m_vscroll = NULL;
882 m_child = NULL;
883 }
884
885 wxDynamicSashWindowLeaf::~wxDynamicSashWindowLeaf() {
886 m_hscroll->SetEventHandler(m_hscroll);
887 m_vscroll->SetEventHandler(m_vscroll);
888 m_viewport->SetEventHandler(m_viewport);
889
890 m_hscroll->Destroy();
891 m_vscroll->Destroy();
892 m_viewport->Destroy();
893 }
894
895 bool wxDynamicSashWindowLeaf::Create() {
896 bool success;
897
898 m_hscroll = new wxScrollBar();
899 m_vscroll = new wxScrollBar();
900 m_viewport = new wxWindow();
901
902 if (!m_hscroll || !m_vscroll || !m_viewport) {
903 return false;
904 }
905
906 wxDynamicSashWindowImpl *add_child_target = m_impl->m_add_child_target;
907 m_impl->m_add_child_target = NULL;
908 success = m_hscroll->Create(m_impl->m_container, wxID_ANY, wxDefaultPosition, wxDefaultSize,
909 wxSB_HORIZONTAL);
910 success = success && m_vscroll->Create(m_impl->m_container, wxID_ANY, wxDefaultPosition, wxDefaultSize,
911 wxSB_VERTICAL);
912 success = success && m_viewport->Create(m_impl->m_container, wxID_ANY);
913 m_impl->m_add_child_target = add_child_target;
914
915 wxCursor cursor(wxCURSOR_ARROW);
916 m_hscroll->SetCursor(cursor);
917 m_vscroll->SetCursor(cursor);
918 m_viewport->SetCursor(cursor);
919
920 m_viewport->SetEventHandler(this);
921 Connect(wxID_ANY, wxEVT_DYNAMIC_SASH_REPARENT, (wxObjectEventFunction)&wxDynamicSashWindowLeaf::OnReparent);
922
923 if (m_impl->m_window->GetWindowStyle() & wxDS_MANAGE_SCROLLBARS) {
924 m_hscroll->SetEventHandler(this);
925 m_vscroll->SetEventHandler(this);
926
927 Connect(wxID_ANY, wxEVT_SET_FOCUS, (wxObjectEventFunction)
928 (wxEventFunction)
929 (wxFocusEventFunction)&wxDynamicSashWindowLeaf::OnFocus);
930 Connect(wxID_ANY, wxEVT_SCROLL_TOP, (wxObjectEventFunction)
931 (wxEventFunction)
932 (wxScrollEventFunction)&wxDynamicSashWindowLeaf::OnScroll);
933 Connect(wxID_ANY, wxEVT_SCROLL_BOTTOM, (wxObjectEventFunction)
934 (wxEventFunction)
935 (wxScrollEventFunction)&wxDynamicSashWindowLeaf::OnScroll);
936 Connect(wxID_ANY, wxEVT_SCROLL_LINEUP, (wxObjectEventFunction)
937 (wxEventFunction)
938 (wxScrollEventFunction)&wxDynamicSashWindowLeaf::OnScroll);
939 Connect(wxID_ANY, wxEVT_SCROLL_LINEDOWN, (wxObjectEventFunction)
940 (wxEventFunction)
941 (wxScrollEventFunction)&wxDynamicSashWindowLeaf::OnScroll);
942 Connect(wxID_ANY, wxEVT_SCROLL_PAGEUP, (wxObjectEventFunction)
943 (wxEventFunction)
944 (wxScrollEventFunction)&wxDynamicSashWindowLeaf::OnScroll);
945 Connect(wxID_ANY, wxEVT_SCROLL_PAGEDOWN, (wxObjectEventFunction)
946 (wxEventFunction)
947 (wxScrollEventFunction)&wxDynamicSashWindowLeaf::OnScroll);
948 Connect(wxID_ANY, wxEVT_SCROLL_THUMBTRACK, (wxObjectEventFunction)
949 (wxEventFunction)
950 (wxScrollEventFunction)&wxDynamicSashWindowLeaf::OnScroll);
951 Connect(wxID_ANY, wxEVT_SCROLL_THUMBRELEASE, (wxObjectEventFunction)
952 (wxEventFunction)
953 (wxScrollEventFunction)&wxDynamicSashWindowLeaf::OnScroll);
954 }
955
956 wxLayoutConstraints *layout = new wxLayoutConstraints();
957 if (!layout)
958 return false;
959 wxSize size = m_hscroll->GetBestSize();
960 #ifdef __WXMSW__
961 size = m_hscroll->GetSize();
962 #endif
963
964 layout->left.SameAs(m_impl->m_container, wxLeft, 10);
965 layout->right.LeftOf(m_vscroll);
966 layout->bottom.SameAs(m_impl->m_container, wxBottom, 3);
967 layout->height.Absolute(size.GetHeight());
968 m_hscroll->SetConstraints(layout);
969
970 layout = new wxLayoutConstraints();
971 if (!layout)
972 return false;
973 size = size = m_vscroll->GetBestSize();
974 #ifdef __WXMSW__
975 size = m_vscroll->GetSize();
976 #endif
977
978 layout->top.SameAs(m_impl->m_container, wxTop, 10);
979 layout->bottom.Above(m_hscroll);
980 layout->right.SameAs(m_impl->m_container, wxRight, 3);
981 layout->width.Absolute(size.GetWidth());
982 m_vscroll->SetConstraints(layout);
983
984 layout = new wxLayoutConstraints();
985 if (!layout)
986 return false;
987 layout->left.SameAs(m_impl->m_container, wxLeft, 3);
988 layout->right.LeftOf(m_vscroll);
989 layout->top.SameAs(m_impl->m_container, wxTop, 3);
990 layout->bottom.Above(m_hscroll);
991 m_viewport->SetConstraints(layout);
992
993 m_impl->m_container->Layout();
994
995 return success;
996 }
997
998 void wxDynamicSashWindowLeaf::AddChild(wxWindow *window) {
999 if (m_child) {
1000 m_child->Destroy();
1001 }
1002
1003 m_child = window;
1004
1005 wxDynamicSashReparentEvent event(this);
1006 AddPendingEvent(event);
1007 }
1008
1009 DynamicSashRegion wxDynamicSashWindowLeaf::GetRegion(int x, int y) {
1010 wxSize size = m_impl->m_container->GetSize();
1011 int w = size.GetWidth();
1012 int h = size.GetHeight();
1013 size = m_hscroll->GetSize();
1014 int sh = size.GetHeight();
1015 size = m_vscroll->GetSize();
1016 int sw = size.GetWidth();
1017
1018 if (x >= w - sw - 3 && x < w && y >= h - sh - 3 && y < h)
1019 return DSR_CORNER;
1020 if (x >= 3 && x < 10 && y >= h - sh - 3 && y < h - 2)
1021 return DSR_VERTICAL_TAB;
1022 if (x >= w - sw - 3 && x < w - 2 && y >= 3 && y < 10)
1023 return DSR_HORIZONTAL_TAB;
1024 if (x < 3)
1025 return DSR_LEFT_EDGE;
1026 if (y < 3)
1027 return DSR_TOP_EDGE;
1028 if (x >= w - 2)
1029 return DSR_RIGHT_EDGE;
1030 if (y >= h - 2)
1031 return DSR_BOTTOM_EDGE;
1032
1033 return DSR_NONE;
1034 }
1035
1036 void wxDynamicSashWindowLeaf::ResizeChild(wxSize size) {
1037 if (m_child) {
1038 if (m_impl->m_window->GetWindowStyle() & wxDS_MANAGE_SCROLLBARS) {
1039 m_child->SetSize(size);
1040 wxSize best_size = m_child->GetBestSize();
1041 if (best_size.GetWidth() < size.GetWidth()) {
1042 best_size.SetWidth(size.GetWidth());
1043 }
1044 if (best_size.GetHeight() < size.GetHeight()) {
1045 best_size.SetHeight(size.GetHeight());
1046 }
1047 m_child->SetSize(best_size);
1048
1049 int hpos = m_hscroll->GetThumbPosition();
1050 int vpos = m_vscroll->GetThumbPosition();
1051
1052 if (hpos < 0) {
1053 hpos = 0;
1054 }
1055 if (vpos < 0) {
1056 vpos = 0;
1057 }
1058 if (hpos > best_size.GetWidth() - size.GetWidth()) {
1059 hpos = best_size.GetWidth() - size.GetWidth();
1060 }
1061 if (vpos > best_size.GetHeight() - size.GetHeight()) {
1062 vpos = best_size.GetHeight() - size.GetHeight();
1063 }
1064
1065 m_hscroll->SetScrollbar(hpos, size.GetWidth(),
1066 best_size.GetWidth(), size.GetWidth());
1067 m_vscroll->SetScrollbar(vpos, size.GetHeight(),
1068 best_size.GetHeight(), size.GetHeight());
1069
1070 // Umm, the scrollbars are doing something insane under GTK+ and subtracting
1071 // one from the position I pass in. This works around that.
1072 m_hscroll->SetThumbPosition(hpos + hpos - m_hscroll->GetThumbPosition());
1073 m_vscroll->SetThumbPosition(vpos + vpos - m_vscroll->GetThumbPosition());
1074
1075 wxPoint pos = m_child->GetPosition();
1076 m_viewport->ScrollWindow(-hpos - pos.x, -vpos - pos.y);
1077 } else {
1078 m_child->SetSize(size);
1079 }
1080 }
1081 }
1082
1083 wxScrollBar *wxDynamicSashWindowLeaf::FindScrollBar(const wxWindow *child, int vert) const {
1084 if (m_child == child) {
1085 if (vert) {
1086 return m_vscroll;
1087 } else {
1088 return m_hscroll;
1089 }
1090 }
1091
1092 return NULL;
1093 }
1094
1095 void wxDynamicSashWindowLeaf::OnSize(wxSizeEvent &WXUNUSED(event)) {
1096 m_impl->m_container->Refresh();
1097 ResizeChild(m_viewport->GetSize());
1098 }
1099
1100 void wxDynamicSashWindowLeaf::OnPaint(wxPaintEvent &WXUNUSED(event)) {
1101 wxPaintDC dc(m_impl->m_container);
1102 dc.SetBackground(wxBrush(m_impl->m_container->GetBackgroundColour(), wxSOLID));
1103 dc.Clear();
1104
1105 wxPen highlight(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNHIGHLIGHT), 1, wxSOLID);
1106 wxPen shadow(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNSHADOW), 1, wxSOLID);
1107 wxPen black(*wxBLACK, 1, wxSOLID);
1108
1109 wxSize size = m_impl->m_container->GetSize();
1110 int w = size.GetWidth();
1111 int h = size.GetHeight();
1112 size = m_hscroll->GetSize();
1113 int sh = size.GetHeight();
1114 size = m_vscroll->GetSize();
1115 int sw = size.GetWidth();
1116
1117 dc.SetPen(shadow);
1118 dc.DrawLine(1, 1, 1, h - 2);
1119 dc.DrawLine(1, 1, w - 2, 1);
1120 dc.SetPen(black);
1121 dc.DrawLine(2, 2, 2, h - 3);
1122 dc.DrawLine(2, 2, w - 3, 2);
1123 dc.SetPen(highlight);
1124 dc.DrawLine(w - 2, 2, w - 2, h - sh - 2);
1125 dc.DrawLine(w - 2, h - sh - 2, w - sw - 2, h - sh - 2);
1126 dc.DrawLine(w - sw - 2, h - sh - 2, w - sw - 2, h - 2);
1127 dc.DrawLine(w - sw - 2, h - 2, 2, h - 2);
1128
1129 dc.SetPen(highlight);
1130 dc.DrawLine(w - sw - 2, 8, w - sw - 2, 4);
1131 dc.DrawLine(w - sw - 2, 4, w - 5, 4);
1132 dc.SetPen(shadow);
1133 dc.DrawLine(w - 5, 4, w - 5, 8);
1134 dc.DrawLine(w - 5, 8, w - sw - 2, 8);
1135 dc.SetPen(black);
1136 dc.DrawLine(w - 4, 3, w - 4, 9);
1137 dc.DrawLine(w - 4, 9, w - sw - 3, 9);
1138
1139 dc.SetPen(highlight);
1140 dc.DrawLine(4, h - 5, 4, h - sh - 2);
1141 dc.DrawLine(4, h - sh - 2, 8, h - sh - 2);
1142 dc.SetPen(shadow);
1143 dc.DrawLine(8, h - sh - 2, 8, h - 5);
1144 dc.DrawLine(8, h - 5, 4, h - 5);
1145 dc.SetPen(black);
1146 dc.DrawLine(9, h - sh - 3, 9, h - 4);
1147 dc.DrawLine(9, h - 4, 3, h - 4);
1148
1149 int cy = (h - sh + h - 6) / 2 + 1;
1150 int cx = (w - sw + w - 6) / 2 + 1;
1151 int sy = cy;
1152 while (sy > h - sh)
1153 sy -= 4;
1154 int sx = cx;
1155 while (sx > w - sw)
1156 sx -= 4;
1157
1158 int x, y;
1159 for (y = sy; y < h - 2; y += 4) {
1160 for (x = sx; x < w - 2; x += 4) {
1161 if (x - cx >= -(y - cy)) {
1162 dc.SetPen(highlight);
1163 dc.DrawPoint(x, y);
1164 dc.SetPen(shadow);
1165 dc.DrawPoint(x + 1, y + 1);
1166 }
1167 }
1168 }
1169 }
1170
1171 void wxDynamicSashWindowLeaf::OnScroll(wxScrollEvent &WXUNUSED(event)) {
1172 int nx = -m_hscroll->GetThumbPosition();
1173 int ny = -m_vscroll->GetThumbPosition();
1174
1175 if (m_child) {
1176 wxPoint pos = m_child->GetPosition();
1177
1178 m_viewport->ScrollWindow(nx - pos.x, ny - pos.y);
1179 }
1180 }
1181
1182 void wxDynamicSashWindowLeaf::OnFocus(wxFocusEvent &event) {
1183 if (event.GetEventObject() == m_hscroll || event.GetEventObject() == m_vscroll) {
1184 m_child->SetFocus();
1185 }
1186 }
1187
1188
1189 void wxDynamicSashWindowLeaf::OnMouseMove(wxMouseEvent &event) {
1190 if (m_impl->m_dragging) {
1191 return;
1192 }
1193
1194 DynamicSashRegion region = GetRegion(event.m_x, event.m_y);
1195
1196 wxCursor cursor(wxCURSOR_ARROW);
1197 if (region == DSR_HORIZONTAL_TAB) {
1198 cursor = wxCursor(wxCURSOR_SIZENS);
1199 } else if (region == DSR_VERTICAL_TAB) {
1200 cursor = wxCursor(wxCURSOR_SIZEWE);
1201 } else if ((region == DSR_CORNER) &&
1202 (m_impl->m_window->GetWindowStyle() & wxDS_DRAG_CORNER) != 0) {
1203 cursor = wxCursor(wxCURSOR_SIZENWSE);
1204 } else if (region == DSR_LEFT_EDGE || region == DSR_TOP_EDGE
1205 || region == DSR_RIGHT_EDGE || region == DSR_BOTTOM_EDGE) {
1206 if (m_impl->FindParent(region)) {
1207 if (region == DSR_LEFT_EDGE || region == DSR_RIGHT_EDGE) {
1208 cursor = wxCursor(wxCURSOR_SIZEWE);
1209 } else {
1210 cursor = wxCursor(wxCURSOR_SIZENS);
1211 }
1212 }
1213 }
1214
1215 m_impl->m_container->SetCursor(cursor);
1216 }
1217
1218 void wxDynamicSashWindowLeaf::OnLeave(wxMouseEvent &WXUNUSED(event)) {
1219 wxCursor cursor(wxCURSOR_ARROW);
1220 m_impl->m_container->SetCursor(cursor);
1221 }
1222
1223
1224 void wxDynamicSashWindowLeaf::OnPress(wxMouseEvent &event) {
1225 DynamicSashRegion region = GetRegion(event.m_x, event.m_y);
1226
1227 if ((region == DSR_CORNER) && (m_impl->m_window->GetWindowStyle() & wxDS_DRAG_CORNER) == 0)
1228 return;
1229
1230 if (region == DSR_HORIZONTAL_TAB || region == DSR_VERTICAL_TAB || region == DSR_CORNER) {
1231 m_impl->m_dragging = region;
1232 m_impl->m_drag_x = event.m_x;
1233 m_impl->m_drag_y = event.m_y;
1234 m_impl->DrawSash(event.m_x, event.m_y);
1235 m_impl->m_container->CaptureMouse();
1236 } else if (region == DSR_LEFT_EDGE || region == DSR_TOP_EDGE
1237 || region == DSR_RIGHT_EDGE || region == DSR_BOTTOM_EDGE) {
1238 wxDynamicSashWindowImpl *parent = m_impl->FindParent(region);
1239
1240 if (parent) {
1241 int x = event.m_x;
1242 int y = event.m_y;
1243
1244 m_impl->m_container->ClientToScreen(&x, &y);
1245 parent->m_container->ScreenToClient(&x, &y);
1246
1247 parent->m_dragging = parent->m_split;
1248 parent->m_drag_x = x;
1249 parent->m_drag_y = y;
1250 parent->DrawSash(x, y);
1251 parent->m_container->CaptureMouse();
1252 }
1253 }
1254 }
1255
1256 void wxDynamicSashWindowLeaf::OnRelease(wxMouseEvent &WXUNUSED(event)) {
1257 }
1258
1259 void wxDynamicSashWindowLeaf::OnReparent(wxEvent &WXUNUSED(event)) {
1260 if (m_child) {
1261 m_child->Reparent(m_viewport);
1262 }
1263
1264 ResizeChild(m_viewport->GetSize());
1265 }
1266
1267 // wxDynamicSashSplitEvent //////////////////////////////////////////////////
1268
1269 wxDynamicSashSplitEvent::wxDynamicSashSplitEvent() {
1270 m_eventObject = NULL;
1271 m_eventType = wxEVT_DYNAMIC_SASH_SPLIT;
1272 }
1273
1274 wxDynamicSashSplitEvent::wxDynamicSashSplitEvent(wxObject *object) {
1275 m_eventObject = object;
1276 m_eventType = wxEVT_DYNAMIC_SASH_SPLIT;
1277 }
1278
1279 IMPLEMENT_DYNAMIC_CLASS(wxDynamicSashSplitEvent, wxCommandEvent)
1280
1281 // wxDynamicSashUnifyEvent //////////////////////////////////////////////////
1282
1283 wxDynamicSashUnifyEvent::wxDynamicSashUnifyEvent() {
1284 m_eventObject = NULL;
1285 m_eventType = wxEVT_DYNAMIC_SASH_UNIFY;
1286 }
1287
1288 wxDynamicSashUnifyEvent::wxDynamicSashUnifyEvent(wxObject *object) {
1289 m_eventObject = object;
1290 m_eventType = wxEVT_DYNAMIC_SASH_UNIFY;
1291 }
1292
1293 IMPLEMENT_DYNAMIC_CLASS(wxDynamicSashUnifyEvent, wxCommandEvent)
1294
1295 // wxDynamicSsahReparentEvent ///////////////////////////////////////////////
1296
1297 wxDynamicSashReparentEvent::wxDynamicSashReparentEvent() {
1298 m_eventObject = NULL;
1299 m_eventType = wxEVT_DYNAMIC_SASH_REPARENT;
1300 }
1301
1302 wxDynamicSashReparentEvent::wxDynamicSashReparentEvent(wxObject *object) {
1303 m_eventObject = object;
1304 m_eventType = wxEVT_DYNAMIC_SASH_REPARENT;
1305 }
1306
1307 wxDynamicSashReparentEvent::wxDynamicSashReparentEvent(const wxDynamicSashReparentEvent& evt)
1308 : wxEvent(evt)
1309 {
1310 }
1311
1312 IMPLEMENT_DYNAMIC_CLASS(wxDynamicSashReparentEvent, wxEvent)
1313
1314 /////////////////////////////////////////////////////////////////////////////
wxWidgets (Impactor)