]> git.saurik.com Git - wxWidgets.git/blob - contrib/src/gizmos/splittree.cpp
Replaced embedded images
[wxWidgets.git] / contrib / src / gizmos / splittree.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: splittree.cpp
3 // Purpose: Classes to achieve a remotely-scrolled tree in a splitter
4 // window that can be scrolled by a scrolled window higher in the
5 // hierarchy
6 // Author: Julian Smart
7 // Modified by:
8 // Created: 8/7/2000
9 // RCS-ID: $Id$
10 // Copyright: (c) Julian Smart
11 // Licence: wxWindows licence
12 /////////////////////////////////////////////////////////////////////////////
13
14 // ============================================================================
15 // declarations
16 // ============================================================================
17
18 // ----------------------------------------------------------------------------
19 // headers
20 // ----------------------------------------------------------------------------
21 #ifdef __GNUG__
22 #pragma implementation "splittree.h"
23 #endif
24
25 // For compilers that support precompilation, includes "wx/wx.h".
26 #include "wx/wxprec.h"
27
28 #ifdef __BORLANDC__
29 #pragma hdrstop
30 #endif
31
32 // for all others, include the necessary headers (this file is usually all you
33 // need because it includes almost all "standard" wxWidgets headers)
34 #ifndef WX_PRECOMP
35 #include "wx/wx.h"
36 #endif
37
38 #ifdef __WXMSW__
39 #include <windows.h>
40 #include "wx/msw/winundef.h"
41 #endif
42
43 #include "wx/gizmos/splittree.h"
44 #include <math.h>
45
46 /*
47 * wxRemotelyScrolledTreeCtrl
48 */
49
50 #if USE_GENERIC_TREECTRL
51 IMPLEMENT_CLASS(wxRemotelyScrolledTreeCtrl, wxGenericTreeCtrl)
52 #else
53 IMPLEMENT_CLASS(wxRemotelyScrolledTreeCtrl, wxTreeCtrl)
54 #endif
55
56 #if USE_GENERIC_TREECTRL
57 BEGIN_EVENT_TABLE(wxRemotelyScrolledTreeCtrl, wxGenericTreeCtrl)
58 #else
59 BEGIN_EVENT_TABLE(wxRemotelyScrolledTreeCtrl, wxTreeCtrl)
60 #endif
61 EVT_SIZE(wxRemotelyScrolledTreeCtrl::OnSize)
62 EVT_PAINT(wxRemotelyScrolledTreeCtrl::OnPaint)
63 EVT_TREE_ITEM_EXPANDED(wxID_ANY, wxRemotelyScrolledTreeCtrl::OnExpand)
64 EVT_TREE_ITEM_COLLAPSED(wxID_ANY, wxRemotelyScrolledTreeCtrl::OnExpand)
65 EVT_SCROLLWIN(wxRemotelyScrolledTreeCtrl::OnScroll)
66 END_EVENT_TABLE()
67
68 wxRemotelyScrolledTreeCtrl::wxRemotelyScrolledTreeCtrl(
69 wxWindow* parent, wxWindowID id, const wxPoint& pt,
70 const wxSize& sz, long style)
71 : wxTreeCtrl(parent, id, pt, sz, style & ~wxTR_ROW_LINES)
72 {
73 m_companionWindow = NULL;
74
75 // We draw the row lines ourself so they match what's done
76 // by the companion window. That is why the flag is turned
77 // off above, so wxGenericTreeCtrl doesn't draw them in a
78 // different colour.
79 m_drawRowLines = (style & wxTR_ROW_LINES) != 0;
80 }
81
82 wxRemotelyScrolledTreeCtrl::~wxRemotelyScrolledTreeCtrl()
83 {
84 }
85
86 void wxRemotelyScrolledTreeCtrl::HideVScrollbar()
87 {
88 #if defined(__WXMSW__)
89 #if USE_GENERIC_TREECTRL
90 if (!IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
91 #endif
92 {
93 ::ShowScrollBar((HWND) GetHWND(), SB_VERT, false);
94 }
95 #if USE_GENERIC_TREECTRL
96 else
97 {
98 // Implicit in overriding SetScrollbars
99 }
100 #endif
101 #endif
102 }
103
104 // Number of pixels per user unit (0 or -1 for no scrollbar)
105 // Length of virtual canvas in user units
106 // Length of page in user units
107 void wxRemotelyScrolledTreeCtrl::SetScrollbars(
108 #if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
109 int pixelsPerUnitX, int pixelsPerUnitY,
110 int noUnitsX, int noUnitsY,
111 int xPos, int yPos,
112 bool noRefresh
113 #else
114 int WXUNUSED(pixelsPerUnitX), int WXUNUSED(pixelsPerUnitY),
115 int WXUNUSED(noUnitsX), int WXUNUSED(noUnitsY),
116 int WXUNUSED(xPos), int WXUNUSED(yPos),
117 bool WXUNUSED(noRefresh)
118 #endif
119 )
120 {
121 #if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
122 if (IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
123 {
124 wxGenericTreeCtrl* win = (wxGenericTreeCtrl*) this;
125 win->wxGenericTreeCtrl::SetScrollbars(pixelsPerUnitX, pixelsPerUnitY, noUnitsX, 0, xPos, 0, /* noRefresh */ true);
126
127 wxScrolledWindow* scrolledWindow = GetScrolledWindow();
128 if (scrolledWindow)
129 {
130 scrolledWindow->SetScrollbars(0, pixelsPerUnitY, 0, noUnitsY, 0, yPos, noRefresh);
131 }
132 }
133 #endif
134 }
135
136 // In case we're using the generic tree control.
137 int wxRemotelyScrolledTreeCtrl::GetScrollPos(
138 #if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
139 int orient
140 #else
141 int WXUNUSED(orient)
142 #endif
143 ) const
144 {
145
146 #if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
147 // this condition fixes extsitence of warning but
148 wxScrolledWindow* scrolledWindow =
149 // but GetScrolledWindow is still executed in case internally does something
150 #endif
151 GetScrolledWindow();
152
153 #if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
154 if (IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
155 {
156 wxGenericTreeCtrl* win = (wxGenericTreeCtrl*) this;
157
158 if (orient == wxHORIZONTAL)
159 return win->wxGenericTreeCtrl::GetScrollPos(orient);
160 else
161 {
162 return scrolledWindow->GetScrollPos(orient);
163 }
164 }
165 #endif
166 return 0;
167 }
168
169
170 // In case we're using the generic tree control.
171 // Get the view start
172 void wxRemotelyScrolledTreeCtrl::GetViewStart(int *x, int *y) const
173 {
174 wxScrolledWindow* scrolledWindow = GetScrolledWindow();
175
176 #if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
177 if (IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
178 {
179
180 wxGenericTreeCtrl* win = (wxGenericTreeCtrl*) this;
181 int x1, y1, x2, y2;
182 win->wxGenericTreeCtrl::GetViewStart(& x1, & y1);
183 * x = x1; * y = y1;
184 if (!scrolledWindow)
185 return;
186
187 scrolledWindow->GetViewStart(& x2, & y2);
188 * y = y2;
189 }
190 else
191 #endif
192 {
193 // x is wrong since the horizontal scrollbar is controlled by the
194 // tree control, but we probably don't need it.
195 scrolledWindow->GetViewStart(x, y);
196 }
197 }
198
199 // In case we're using the generic tree control.
200 void wxRemotelyScrolledTreeCtrl::PrepareDC(
201 #if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
202 wxDC& dc
203 #else
204 wxDC& WXUNUSED(dc)
205 #endif
206 )
207 {
208 #if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
209 if (IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
210 {
211 wxScrolledWindow* scrolledWindow = GetScrolledWindow();
212
213 wxGenericTreeCtrl* win = (wxGenericTreeCtrl*) this;
214
215 int startX, startY;
216 GetViewStart(& startX, & startY);
217
218 int xppu1, yppu1, xppu2, yppu2;
219 win->wxGenericTreeCtrl::GetScrollPixelsPerUnit(& xppu1, & yppu1);
220 scrolledWindow->GetScrollPixelsPerUnit(& xppu2, & yppu2);
221
222 dc.SetDeviceOrigin( -startX * xppu1, -startY * yppu2 );
223 // dc.SetUserScale( win->GetScaleX(), win->GetScaleY() );
224 }
225 #endif
226 }
227
228 // Scroll to the given line (in scroll units where each unit is
229 // the height of an item)
230 void wxRemotelyScrolledTreeCtrl::ScrollToLine(int WXUNUSED(posHoriz), int posVert)
231 {
232 #ifdef __WXMSW__
233 #if USE_GENERIC_TREECTRL
234 if (!IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
235 #endif
236 {
237 UINT sbCode = SB_THUMBPOSITION;
238 HWND vertScrollBar = 0;
239 MSWDefWindowProc((WXUINT) WM_VSCROLL, MAKELONG(sbCode, posVert), (WXLPARAM) vertScrollBar);
240 }
241 #if USE_GENERIC_TREECTRL
242 else
243 #endif
244 #endif
245 #if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
246 {
247 wxGenericTreeCtrl* win = (wxGenericTreeCtrl*) this;
248 win->Refresh();
249 /* Doesn't work yet because scrolling is ignored by Scroll
250 int xppu, yppu;
251 wxScrolledWindow* scrolledWindow = GetScrolledWindow();
252 if (scrolledWindow)
253 {
254 scrolledWindow->GetScrollPixelsPerUnit(& xppu, & yppu);
255 win->Scroll(-1, posVert*yppu);
256 }
257 */
258 }
259 #endif
260 }
261
262 void wxRemotelyScrolledTreeCtrl::OnSize(wxSizeEvent& event)
263 {
264 HideVScrollbar();
265 AdjustRemoteScrollbars();
266 event.Skip();
267 }
268
269 void wxRemotelyScrolledTreeCtrl::OnExpand(wxTreeEvent& event)
270 {
271 AdjustRemoteScrollbars();
272 event.Skip();
273
274 // If we don't have this, we get some bits of lines still remaining
275 if (event.GetEventType() == wxEVT_COMMAND_TREE_ITEM_COLLAPSED)
276 Refresh();
277
278 // Pass on the event
279 if (m_companionWindow)
280 m_companionWindow->GetEventHandler()->ProcessEvent(event);
281 }
282
283 void wxRemotelyScrolledTreeCtrl::OnPaint(wxPaintEvent& event)
284 {
285 wxPaintDC dc(this);
286
287 wxTreeCtrl::OnPaint(event);
288
289 if (! m_drawRowLines)
290 return;
291
292 // Reset the device origin since it may have been set
293 dc.SetDeviceOrigin(0, 0);
294
295 wxPen pen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT), 1, wxSOLID);
296 dc.SetPen(pen);
297 dc.SetBrush(* wxTRANSPARENT_BRUSH);
298
299 wxSize clientSize = GetClientSize();
300 wxRect itemRect;
301 wxTreeItemId h, lastH;
302 for (h=GetFirstVisibleItem();
303 h.IsOk();
304 h=GetNextVisible(h))
305 {
306 if (GetBoundingRect(h, itemRect))
307 {
308 int cy = itemRect.GetTop();
309 dc.DrawLine(0, cy, clientSize.x, cy);
310 lastH = h;
311 }
312 if (! IsVisible(h))
313 break;
314 }
315 if (lastH.IsOk() && GetBoundingRect(lastH, itemRect))
316 {
317 int cy = itemRect.GetBottom();
318 dc.DrawLine(0, cy, clientSize.x, cy);
319 }
320 }
321
322
323 // Adjust the containing wxScrolledWindow's scrollbars appropriately
324 void wxRemotelyScrolledTreeCtrl::AdjustRemoteScrollbars()
325 {
326 #if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
327 if (IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
328 {
329 // This is for the generic tree control.
330 // It calls SetScrollbars which has been overridden
331 // to adjust the parent scrolled window vertical
332 // scrollbar.
333 ((wxGenericTreeCtrl*) this)->AdjustMyScrollbars();
334 return;
335 }
336 else
337 #endif
338 {
339 // This is for the wxMSW tree control
340 wxScrolledWindow* scrolledWindow = GetScrolledWindow();
341 if (scrolledWindow)
342 {
343 wxRect itemRect;
344 if (GetBoundingRect(GetFirstVisibleItem(), itemRect))
345 {
346 // Actually, the real height seems to be 1 less than reported
347 // (e.g. 16 instead of 16)
348 int itemHeight = itemRect.GetHeight() - 1;
349
350 int w, h;
351 GetClientSize(&w, &h);
352
353 wxRect rect(0, 0, 0, 0);
354 CalcTreeSize(rect);
355
356 double f = ((double) (rect.GetHeight()) / (double) itemHeight) ;
357 int treeViewHeight = (int) ceil(f);
358
359 int scrollPixelsPerLine = itemHeight;
360 int scrollPos = - (itemRect.y / itemHeight);
361
362 scrolledWindow->SetScrollbars(0, scrollPixelsPerLine, 0, treeViewHeight, 0, scrollPos);
363
364 // Ensure that when a scrollbar becomes hidden or visible,
365 // the contained window sizes are right.
366 // Problem: this is called too early (?)
367 wxSizeEvent event(scrolledWindow->GetSize(), scrolledWindow->GetId());
368 scrolledWindow->GetEventHandler()->ProcessEvent(event);
369 }
370 }
371 }
372 }
373
374
375 // Calculate the area that contains both rectangles
376 static wxRect CombineRectangles(const wxRect& rect1, const wxRect& rect2)
377 {
378 wxRect rect;
379
380 int right1 = rect1.GetRight();
381 int bottom1 = rect1.GetBottom();
382 int right2 = rect2.GetRight();
383 int bottom2 = rect2.GetBottom();
384
385 wxPoint topLeft = wxPoint(wxMin(rect1.x, rect2.x), wxMin(rect1.y, rect2.y));
386 wxPoint bottomRight = wxPoint(wxMax(right1, right2), wxMax(bottom1, bottom2));
387
388 rect.x = topLeft.x; rect.y = topLeft.y;
389 rect.SetRight(bottomRight.x);
390 rect.SetBottom(bottomRight.y);
391
392 return rect;
393 }
394
395
396 // Calculate the tree overall size so we can set the scrollbar
397 // correctly
398 void wxRemotelyScrolledTreeCtrl::CalcTreeSize(wxRect& rect)
399 {
400 CalcTreeSize(GetRootItem(), rect);
401 }
402
403 void wxRemotelyScrolledTreeCtrl::CalcTreeSize(const wxTreeItemId& id, wxRect& rect)
404 {
405 // More efficient implementation would be to find the last item (but how?)
406 // Q: is the bounding rect relative to the top of the virtual tree workspace
407 // or the top of the window? How would we convert?
408 wxRect itemSize;
409 if (GetBoundingRect(id, itemSize))
410 {
411 rect = CombineRectangles(rect, itemSize);
412 }
413
414 wxTreeItemIdValue cookie;
415 wxTreeItemId childId = GetFirstChild(id, cookie);
416 while (childId)
417 {
418 CalcTreeSize(childId, rect);
419 childId = GetNextChild(childId, cookie);
420 }
421 }
422
423 // Find the scrolled window that contains this control
424 wxScrolledWindow* wxRemotelyScrolledTreeCtrl::GetScrolledWindow() const
425 {
426 wxWindow* parent = wxWindow::GetParent();
427 while (parent)
428 {
429 if (parent->IsKindOf(CLASSINFO(wxScrolledWindow)))
430 return (wxScrolledWindow*) parent;
431 parent = parent->GetParent();
432 }
433 return NULL;
434 }
435
436 void wxRemotelyScrolledTreeCtrl::OnScroll(wxScrollWinEvent& event)
437 {
438 int orient = event.GetOrientation();
439 if (orient == wxHORIZONTAL)
440 {
441 event.Skip();
442 return;
443 }
444 wxScrolledWindow* scrollWin = GetScrolledWindow();
445 if (!scrollWin)
446 return;
447
448 int x, y;
449 scrollWin->GetViewStart(& x, & y);
450
451 ScrollToLine(-1, y);
452 }
453
454 /*
455 * wxTreeCompanionWindow
456 *
457 * A window displaying values associated with tree control items.
458 */
459
460 IMPLEMENT_CLASS(wxTreeCompanionWindow, wxWindow)
461
462 BEGIN_EVENT_TABLE(wxTreeCompanionWindow, wxWindow)
463 EVT_PAINT(wxTreeCompanionWindow::OnPaint)
464 EVT_SCROLLWIN(wxTreeCompanionWindow::OnScroll)
465 EVT_TREE_ITEM_EXPANDED(-1, wxTreeCompanionWindow::OnExpand)
466 EVT_TREE_ITEM_COLLAPSED(-1, wxTreeCompanionWindow::OnExpand)
467 END_EVENT_TABLE()
468
469 wxTreeCompanionWindow::wxTreeCompanionWindow(wxWindow* parent, wxWindowID id,
470 const wxPoint& pos,
471 const wxSize& sz,
472 long style):
473 wxWindow(parent, id, pos, sz, style)
474 {
475 m_treeCtrl = NULL;
476 }
477
478 void wxTreeCompanionWindow::DrawItem(wxDC& dc, wxTreeItemId id, const wxRect& rect)
479 {
480 // TEST CODE
481 #if 1
482 if (m_treeCtrl)
483 {
484 wxString text = m_treeCtrl->GetItemText(id);
485 dc.SetTextForeground(* wxBLACK);
486 dc.SetBackgroundMode(wxTRANSPARENT);
487
488 int textW, textH;
489 dc.GetTextExtent(text, & textW, & textH);
490
491 int x = 5;
492 int y = rect.GetY() + wxMax(0, (rect.GetHeight() - textH) / 2);
493
494 dc.DrawText(text, x, y);
495 }
496 #endif
497 }
498
499 void wxTreeCompanionWindow::OnPaint(wxPaintEvent& WXUNUSED(event))
500 {
501 wxPaintDC dc(this);
502
503 if (!m_treeCtrl)
504 return;
505
506 wxPen pen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT), 1, wxSOLID);
507 dc.SetPen(pen);
508 dc.SetBrush(* wxTRANSPARENT_BRUSH);
509 wxFont font(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
510 dc.SetFont(font);
511
512 wxSize clientSize = GetClientSize();
513 wxRect itemRect;
514 wxTreeItemId h, lastH;
515 for (h=m_treeCtrl->GetFirstVisibleItem();
516 h.IsOk();
517 h=m_treeCtrl->GetNextVisible(h))
518 {
519 if (m_treeCtrl->GetBoundingRect(h, itemRect))
520 {
521 int cy = itemRect.GetTop();
522 wxRect drawItemRect(0, cy, clientSize.x, itemRect.GetHeight());
523
524 lastH = h;
525
526 // Draw the actual item
527 DrawItem(dc, h, drawItemRect);
528 dc.DrawLine(0, cy, clientSize.x, cy);
529 }
530 if (! m_treeCtrl->IsVisible(h))
531 break;
532 }
533 if (lastH.IsOk() && m_treeCtrl->GetBoundingRect(lastH, itemRect))
534 {
535 int cy = itemRect.GetBottom();
536 dc.DrawLine(0, cy, clientSize.x, cy);
537 }
538 }
539
540 void wxTreeCompanionWindow::OnScroll(wxScrollWinEvent& event)
541 {
542 int orient = event.GetOrientation();
543 if (orient == wxHORIZONTAL)
544 {
545 event.Skip();
546 return;
547 }
548 if (!m_treeCtrl)
549 return;
550
551 // TODO: scroll the window physically instead of just refreshing.
552 Refresh(true);
553 }
554
555 void wxTreeCompanionWindow::OnExpand(wxTreeEvent& WXUNUSED(event))
556 {
557 // TODO: something more optimized than simply refresh the whole
558 // window when the tree is expanded/collapsed. Tricky.
559 Refresh();
560 }
561
562 /*
563 * wxThinSplitterWindow
564 */
565
566 IMPLEMENT_CLASS(wxThinSplitterWindow, wxSplitterWindow)
567
568 BEGIN_EVENT_TABLE(wxThinSplitterWindow, wxSplitterWindow)
569 EVT_SIZE(wxThinSplitterWindow::OnSize)
570 END_EVENT_TABLE()
571
572 wxThinSplitterWindow::wxThinSplitterWindow(wxWindow* parent, wxWindowID id,
573 const wxPoint& pos,
574 const wxSize& sz,
575 long style):
576 wxSplitterWindow(parent, id, pos, sz, style)
577 {
578 wxColour faceColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
579 m_facePen = new wxPen(faceColour, 1, wxSOLID);
580 m_faceBrush = new wxBrush(faceColour, wxSOLID);
581 }
582
583 wxThinSplitterWindow::~wxThinSplitterWindow()
584 {
585 delete m_facePen;
586 delete m_faceBrush;
587 }
588
589
590 void wxThinSplitterWindow::SizeWindows()
591 {
592 // The client size may have changed inbetween
593 // the sizing of the first window and the sizing of
594 // the second. So repeat SizeWindows.
595 wxSplitterWindow::SizeWindows();
596 wxSplitterWindow::SizeWindows();
597 }
598
599 // Tests for x, y over sash
600 bool wxThinSplitterWindow::SashHitTest(int x, int y, int WXUNUSED(tolerance))
601 {
602 return wxSplitterWindow::SashHitTest(x, y, 4);
603 }
604
605 void wxThinSplitterWindow::DrawSash(wxDC& dc)
606 {
607 if ( m_sashPosition == 0 || !m_windowTwo)
608 return;
609 if (GetWindowStyle() & wxSP_NOSASH)
610 return;
611
612 int w, h;
613 GetClientSize(&w, &h);
614
615 if ( m_splitMode == wxSPLIT_VERTICAL )
616 {
617 dc.SetPen(* m_facePen);
618 dc.SetBrush(* m_faceBrush);
619 int h1 = h-1;
620 int y1 = 0;
621 if ( (GetWindowStyleFlag() & wxSP_BORDER) != wxSP_BORDER && (GetWindowStyleFlag() & wxSP_3DBORDER) != wxSP_3DBORDER )
622 h1 += 1; // Not sure why this is necessary...
623 if ( (GetWindowStyleFlag() & wxSP_3DBORDER) == wxSP_3DBORDER)
624 {
625 y1 = 2; h1 -= 3;
626 }
627 dc.DrawRectangle(m_sashPosition, y1, GetSashSize(), h1);
628 }
629 else
630 {
631 dc.SetPen(* m_facePen);
632 dc.SetBrush(* m_faceBrush);
633 int w1 = w-1;
634 int x1 = 0;
635 if ( (GetWindowStyleFlag() & wxSP_BORDER) != wxSP_BORDER && (GetWindowStyleFlag() & wxSP_3DBORDER) != wxSP_3DBORDER )
636 w1 ++;
637 if ( (GetWindowStyleFlag() & wxSP_3DBORDER) == wxSP_3DBORDER)
638 {
639 x1 = 2; w1 -= 3;
640 }
641 dc.DrawRectangle(x1, m_sashPosition, w1, GetSashSize());
642 }
643
644 dc.SetPen(wxNullPen);
645 dc.SetBrush(wxNullBrush);
646 }
647
648 void wxThinSplitterWindow::OnSize(wxSizeEvent& event)
649 {
650 wxSplitterWindow::OnSize(event);
651 }
652
653 /*
654 * wxSplitterScrolledWindow
655 */
656
657 IMPLEMENT_CLASS(wxSplitterScrolledWindow, wxScrolledWindow)
658
659 BEGIN_EVENT_TABLE(wxSplitterScrolledWindow, wxScrolledWindow)
660 EVT_SCROLLWIN(wxSplitterScrolledWindow::OnScroll)
661 EVT_SIZE(wxSplitterScrolledWindow::OnSize)
662 END_EVENT_TABLE()
663
664 wxSplitterScrolledWindow::wxSplitterScrolledWindow(wxWindow* parent, wxWindowID id,
665 const wxPoint& pos,
666 const wxSize& sz,
667 long style):
668 wxScrolledWindow(parent, id, pos, sz, style)
669 {
670 }
671
672 void wxSplitterScrolledWindow::OnSize(wxSizeEvent& WXUNUSED(event))
673 {
674 wxSize sz = GetClientSize();
675 if (GetChildren().GetFirst())
676 {
677 ((wxWindow*) GetChildren().GetFirst()->GetData())->SetSize(0, 0, sz.x, sz.y);
678 }
679 }
680
681 void wxSplitterScrolledWindow::OnScroll(wxScrollWinEvent& event)
682 {
683 // Ensure that events being propagated back up the window hierarchy
684 // don't cause an infinite loop
685 static bool inOnScroll = false;
686 if (inOnScroll)
687 {
688 event.Skip();
689 return;
690 }
691 inOnScroll = true;
692
693 int orient = event.GetOrientation();
694
695 int nScrollInc = CalcScrollInc(event);
696 if (nScrollInc == 0)
697 {
698 inOnScroll = false;
699 return;
700 }
701
702 if (orient == wxHORIZONTAL)
703 {
704 inOnScroll = false;
705 event.Skip();
706 return;
707 #if 0
708 int newPos = m_xScrollPosition + nScrollInc;
709 SetScrollPos(wxHORIZONTAL, newPos, true );
710 #endif
711 }
712 else
713 {
714 int newPos = m_yScrollPosition + nScrollInc;
715 SetScrollPos(wxVERTICAL, newPos, true );
716 }
717
718 if (orient == wxHORIZONTAL)
719 {
720 m_xScrollPosition += nScrollInc;
721 }
722 else
723 {
724 m_yScrollPosition += nScrollInc;
725 }
726
727 // Find targets in splitter window and send the event to them
728 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
729 while (node)
730 {
731 wxWindow* child = (wxWindow*) node->GetData();
732 if (child->IsKindOf(CLASSINFO(wxSplitterWindow)))
733 {
734 wxSplitterWindow* splitter = (wxSplitterWindow*) child;
735 if (splitter->GetWindow1())
736 splitter->GetWindow1()->ProcessEvent(event);
737 if (splitter->GetWindow2())
738 splitter->GetWindow2()->ProcessEvent(event);
739 break;
740 }
741 node = node->GetNext();
742 }
743
744 m_targetWindow->Update() ;
745
746 inOnScroll = false;
747 }
748