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