]> git.saurik.com Git - wxWidgets.git/blob - contrib/src/gizmos/splittree.cpp
set SMALL_FONT for controls here because InheritAttributes() doesn't do it any longer
[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" wxWindows 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(-1, wxRemotelyScrolledTreeCtrl::OnExpand)
64 EVT_TREE_ITEM_COLLAPSED(-1, 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();h;h=GetNextVisible(h))
303 {
304 if (GetBoundingRect(h, itemRect))
305 {
306 int cy = itemRect.GetTop();
307 dc.DrawLine(0, cy, clientSize.x, cy);
308 lastH = h;
309 }
310 }
311 if (lastH.IsOk() && GetBoundingRect(lastH, itemRect))
312 {
313 int cy = itemRect.GetBottom();
314 dc.DrawLine(0, cy, clientSize.x, cy);
315 }
316 }
317
318
319 // Adjust the containing wxScrolledWindow's scrollbars appropriately
320 void wxRemotelyScrolledTreeCtrl::AdjustRemoteScrollbars()
321 {
322 #if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
323 if (IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
324 {
325 // This is for the generic tree control.
326 // It calls SetScrollbars which has been overridden
327 // to adjust the parent scrolled window vertical
328 // scrollbar.
329 ((wxGenericTreeCtrl*) this)->AdjustMyScrollbars();
330 return;
331 }
332 else
333 #endif
334 {
335 // This is for the wxMSW tree control
336 wxScrolledWindow* scrolledWindow = GetScrolledWindow();
337 if (scrolledWindow)
338 {
339 wxRect itemRect;
340 if (GetBoundingRect(GetFirstVisibleItem(), itemRect))
341 {
342 // Actually, the real height seems to be 1 less than reported
343 // (e.g. 16 instead of 16)
344 int itemHeight = itemRect.GetHeight() - 1;
345
346 int w, h;
347 GetClientSize(&w, &h);
348
349 wxRect rect(0, 0, 0, 0);
350 CalcTreeSize(rect);
351
352 double f = ((double) (rect.GetHeight()) / (double) itemHeight) ;
353 int treeViewHeight = (int) ceil(f);
354
355 int scrollPixelsPerLine = itemHeight;
356 int scrollPos = - (itemRect.y / itemHeight);
357
358 scrolledWindow->SetScrollbars(0, scrollPixelsPerLine, 0, treeViewHeight, 0, scrollPos);
359
360 // Ensure that when a scrollbar becomes hidden or visible,
361 // the contained window sizes are right.
362 // Problem: this is called too early (?)
363 wxSizeEvent event(scrolledWindow->GetSize(), scrolledWindow->GetId());
364 scrolledWindow->GetEventHandler()->ProcessEvent(event);
365 }
366 }
367 }
368 }
369
370
371 // Calculate the area that contains both rectangles
372 static wxRect CombineRectangles(const wxRect& rect1, const wxRect& rect2)
373 {
374 wxRect rect;
375
376 int right1 = rect1.GetRight();
377 int bottom1 = rect1.GetBottom();
378 int right2 = rect2.GetRight();
379 int bottom2 = rect2.GetBottom();
380
381 wxPoint topLeft = wxPoint(wxMin(rect1.x, rect2.x), wxMin(rect1.y, rect2.y));
382 wxPoint bottomRight = wxPoint(wxMax(right1, right2), wxMax(bottom1, bottom2));
383
384 rect.x = topLeft.x; rect.y = topLeft.y;
385 rect.SetRight(bottomRight.x);
386 rect.SetBottom(bottomRight.y);
387
388 return rect;
389 }
390
391
392 // Calculate the tree overall size so we can set the scrollbar
393 // correctly
394 void wxRemotelyScrolledTreeCtrl::CalcTreeSize(wxRect& rect)
395 {
396 CalcTreeSize(GetRootItem(), rect);
397 }
398
399 void wxRemotelyScrolledTreeCtrl::CalcTreeSize(const wxTreeItemId& id, wxRect& rect)
400 {
401 // More efficient implementation would be to find the last item (but how?)
402 // Q: is the bounding rect relative to the top of the virtual tree workspace
403 // or the top of the window? How would we convert?
404 wxRect itemSize;
405 if (GetBoundingRect(id, itemSize))
406 {
407 rect = CombineRectangles(rect, itemSize);
408 }
409
410 wxTreeItemIdValue cookie;
411 wxTreeItemId childId = GetFirstChild(id, cookie);
412 while (childId)
413 {
414 CalcTreeSize(childId, rect);
415 childId = GetNextChild(childId, cookie);
416 }
417 }
418
419 // Find the scrolled window that contains this control
420 wxScrolledWindow* wxRemotelyScrolledTreeCtrl::GetScrolledWindow() const
421 {
422 wxWindow* parent = wxWindow::GetParent();
423 while (parent)
424 {
425 if (parent->IsKindOf(CLASSINFO(wxScrolledWindow)))
426 return (wxScrolledWindow*) parent;
427 parent = parent->GetParent();
428 }
429 return NULL;
430 }
431
432 void wxRemotelyScrolledTreeCtrl::OnScroll(wxScrollWinEvent& event)
433 {
434 int orient = event.GetOrientation();
435 if (orient == wxHORIZONTAL)
436 {
437 event.Skip();
438 return;
439 }
440 wxScrolledWindow* scrollWin = GetScrolledWindow();
441 if (!scrollWin)
442 return;
443
444 int x, y;
445 scrollWin->GetViewStart(& x, & y);
446
447 ScrollToLine(-1, y);
448 }
449
450 /*
451 * wxTreeCompanionWindow
452 *
453 * A window displaying values associated with tree control items.
454 */
455
456 IMPLEMENT_CLASS(wxTreeCompanionWindow, wxWindow)
457
458 BEGIN_EVENT_TABLE(wxTreeCompanionWindow, wxWindow)
459 EVT_PAINT(wxTreeCompanionWindow::OnPaint)
460 EVT_SCROLLWIN(wxTreeCompanionWindow::OnScroll)
461 EVT_TREE_ITEM_EXPANDED(-1, wxTreeCompanionWindow::OnExpand)
462 EVT_TREE_ITEM_COLLAPSED(-1, wxTreeCompanionWindow::OnExpand)
463 END_EVENT_TABLE()
464
465 wxTreeCompanionWindow::wxTreeCompanionWindow(wxWindow* parent, wxWindowID id,
466 const wxPoint& pos,
467 const wxSize& sz,
468 long style):
469 wxWindow(parent, id, pos, sz, style)
470 {
471 m_treeCtrl = NULL;
472 }
473
474 void wxTreeCompanionWindow::DrawItem(wxDC& dc, wxTreeItemId id, const wxRect& rect)
475 {
476 // TEST CODE
477 #if 1
478 if (m_treeCtrl)
479 {
480 wxString text = m_treeCtrl->GetItemText(id);
481 dc.SetTextForeground(* wxBLACK);
482 dc.SetBackgroundMode(wxTRANSPARENT);
483
484 int textW, textH;
485 dc.GetTextExtent(text, & textW, & textH);
486
487 int x = 5;
488 int y = rect.GetY() + wxMax(0, (rect.GetHeight() - textH) / 2);
489
490 dc.DrawText(text, x, y);
491 }
492 #endif
493 }
494
495 void wxTreeCompanionWindow::OnPaint(wxPaintEvent& WXUNUSED(event))
496 {
497 wxPaintDC dc(this);
498
499 if (!m_treeCtrl)
500 return;
501
502 wxPen pen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT), 1, wxSOLID);
503 dc.SetPen(pen);
504 dc.SetBrush(* wxTRANSPARENT_BRUSH);
505 wxFont font(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
506 dc.SetFont(font);
507
508 wxSize clientSize = GetClientSize();
509 wxRect itemRect;
510 wxTreeItemId h, lastH;
511 for(h=m_treeCtrl->GetFirstVisibleItem();h;h=m_treeCtrl->GetNextVisible(h))
512 {
513 if (m_treeCtrl->GetBoundingRect(h, itemRect))
514 {
515 int cy = itemRect.GetTop();
516 wxRect drawItemRect(0, cy, clientSize.x, itemRect.GetHeight());
517
518 lastH = h;
519
520 // Draw the actual item
521 DrawItem(dc, h, drawItemRect);
522 dc.DrawLine(0, cy, clientSize.x, cy);
523 }
524 }
525 if (lastH.IsOk() && m_treeCtrl->GetBoundingRect(lastH, itemRect))
526 {
527 int cy = itemRect.GetBottom();
528 dc.DrawLine(0, cy, clientSize.x, cy);
529 }
530 }
531
532 void wxTreeCompanionWindow::OnScroll(wxScrollWinEvent& event)
533 {
534 int orient = event.GetOrientation();
535 if (orient == wxHORIZONTAL)
536 {
537 event.Skip();
538 return;
539 }
540 if (!m_treeCtrl)
541 return;
542
543 // TODO: scroll the window physically instead of just refreshing.
544 Refresh(TRUE);
545 }
546
547 void wxTreeCompanionWindow::OnExpand(wxTreeEvent& WXUNUSED(event))
548 {
549 // TODO: something more optimized than simply refresh the whole
550 // window when the tree is expanded/collapsed. Tricky.
551 Refresh();
552 }
553
554 /*
555 * wxThinSplitterWindow
556 */
557
558 IMPLEMENT_CLASS(wxThinSplitterWindow, wxSplitterWindow)
559
560 BEGIN_EVENT_TABLE(wxThinSplitterWindow, wxSplitterWindow)
561 EVT_SIZE(wxThinSplitterWindow::OnSize)
562 END_EVENT_TABLE()
563
564 wxThinSplitterWindow::wxThinSplitterWindow(wxWindow* parent, wxWindowID id,
565 const wxPoint& pos,
566 const wxSize& sz,
567 long style):
568 wxSplitterWindow(parent, id, pos, sz, style)
569 {
570 wxColour faceColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
571 m_facePen = new wxPen(faceColour, 1, wxSOLID);
572 m_faceBrush = new wxBrush(faceColour, wxSOLID);
573 }
574
575 wxThinSplitterWindow::~wxThinSplitterWindow()
576 {
577 delete m_facePen;
578 delete m_faceBrush;
579 }
580
581
582 void wxThinSplitterWindow::SizeWindows()
583 {
584 // The client size may have changed inbetween
585 // the sizing of the first window and the sizing of
586 // the second. So repeat SizeWindows.
587 wxSplitterWindow::SizeWindows();
588 wxSplitterWindow::SizeWindows();
589 }
590
591 // Tests for x, y over sash
592 bool wxThinSplitterWindow::SashHitTest(int x, int y, int WXUNUSED(tolerance))
593 {
594 return wxSplitterWindow::SashHitTest(x, y, 4);
595 }
596
597 void wxThinSplitterWindow::DrawSash(wxDC& dc)
598 {
599 if ( m_sashPosition == 0 || !m_windowTwo)
600 return;
601 if (GetWindowStyle() & wxSP_NOSASH)
602 return;
603
604 int w, h;
605 GetClientSize(&w, &h);
606
607 if ( m_splitMode == wxSPLIT_VERTICAL )
608 {
609 dc.SetPen(* m_facePen);
610 dc.SetBrush(* m_faceBrush);
611 int h1 = h-1;
612 int y1 = 0;
613 if ( (GetWindowStyleFlag() & wxSP_BORDER) != wxSP_BORDER && (GetWindowStyleFlag() & wxSP_3DBORDER) != wxSP_3DBORDER )
614 h1 += 1; // Not sure why this is necessary...
615 if ( (GetWindowStyleFlag() & wxSP_3DBORDER) == wxSP_3DBORDER)
616 {
617 y1 = 2; h1 -= 3;
618 }
619 dc.DrawRectangle(m_sashPosition, y1, GetSashSize(), h1);
620 }
621 else
622 {
623 dc.SetPen(* m_facePen);
624 dc.SetBrush(* m_faceBrush);
625 int w1 = w-1;
626 int x1 = 0;
627 if ( (GetWindowStyleFlag() & wxSP_BORDER) != wxSP_BORDER && (GetWindowStyleFlag() & wxSP_3DBORDER) != wxSP_3DBORDER )
628 w1 ++;
629 if ( (GetWindowStyleFlag() & wxSP_3DBORDER) == wxSP_3DBORDER)
630 {
631 x1 = 2; w1 -= 3;
632 }
633 dc.DrawRectangle(x1, m_sashPosition, w1, GetSashSize());
634 }
635
636 dc.SetPen(wxNullPen);
637 dc.SetBrush(wxNullBrush);
638 }
639
640 void wxThinSplitterWindow::OnSize(wxSizeEvent& event)
641 {
642 wxSplitterWindow::OnSize(event);
643 }
644
645 /*
646 * wxSplitterScrolledWindow
647 */
648
649 IMPLEMENT_CLASS(wxSplitterScrolledWindow, wxScrolledWindow)
650
651 BEGIN_EVENT_TABLE(wxSplitterScrolledWindow, wxScrolledWindow)
652 EVT_SCROLLWIN(wxSplitterScrolledWindow::OnScroll)
653 EVT_SIZE(wxSplitterScrolledWindow::OnSize)
654 END_EVENT_TABLE()
655
656 wxSplitterScrolledWindow::wxSplitterScrolledWindow(wxWindow* parent, wxWindowID id,
657 const wxPoint& pos,
658 const wxSize& sz,
659 long style):
660 wxScrolledWindow(parent, id, pos, sz, style)
661 {
662 }
663
664 void wxSplitterScrolledWindow::OnSize(wxSizeEvent& WXUNUSED(event))
665 {
666 wxSize sz = GetClientSize();
667 if (GetChildren().GetFirst())
668 {
669 ((wxWindow*) GetChildren().GetFirst()->GetData())->SetSize(0, 0, sz.x, sz.y);
670 }
671 }
672
673 void wxSplitterScrolledWindow::OnScroll(wxScrollWinEvent& event)
674 {
675 // Ensure that events being propagated back up the window hierarchy
676 // don't cause an infinite loop
677 static bool inOnScroll = FALSE;
678 if (inOnScroll)
679 {
680 event.Skip();
681 return;
682 }
683 inOnScroll = TRUE;
684
685 int orient = event.GetOrientation();
686
687 int nScrollInc = CalcScrollInc(event);
688 if (nScrollInc == 0)
689 {
690 inOnScroll = FALSE;
691 return;
692 }
693
694 if (orient == wxHORIZONTAL)
695 {
696 inOnScroll = FALSE;
697 event.Skip();
698 return;
699 #if 0
700 int newPos = m_xScrollPosition + nScrollInc;
701 SetScrollPos(wxHORIZONTAL, newPos, TRUE );
702 #endif
703 }
704 else
705 {
706 int newPos = m_yScrollPosition + nScrollInc;
707 SetScrollPos(wxVERTICAL, newPos, TRUE );
708 }
709
710 if (orient == wxHORIZONTAL)
711 {
712 m_xScrollPosition += nScrollInc;
713 }
714 else
715 {
716 m_yScrollPosition += nScrollInc;
717 }
718
719 // Find targets in splitter window and send the event to them
720 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
721 while (node)
722 {
723 wxWindow* child = (wxWindow*) node->GetData();
724 if (child->IsKindOf(CLASSINFO(wxSplitterWindow)))
725 {
726 wxSplitterWindow* splitter = (wxSplitterWindow*) child;
727 if (splitter->GetWindow1())
728 splitter->GetWindow1()->ProcessEvent(event);
729 if (splitter->GetWindow2())
730 splitter->GetWindow2()->ProcessEvent(event);
731 break;
732 }
733 node = node->GetNext();
734 }
735
736 #ifdef __WXMAC__
737 m_targetWindow->MacUpdateImmediately() ;
738 #endif
739
740 inOnScroll = FALSE;
741 }
742