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 interface "splittree.cpp"
  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 #include "wx/generic/treectlg.h"
  39
  40 #include "wx/gizmos/splittree.h"
  41
  42 /*
  43  * wxRemotelyScrolledTreeCtrl
  44  */
  45
  46 #if USE_GENERIC_TREECTRL
  47 IMPLEMENT_CLASS(wxRemotelyScrolledTreeCtrl, wxGenericTreeCtrl)
  48 #else
  49 IMPLEMENT_CLASS(wxRemotelyScrolledTreeCtrl, wxTreeCtrl)
  50 #endif
  51
  52 #if USE_GENERIC_TREECTRL
  53 BEGIN_EVENT_TABLE(wxRemotelyScrolledTreeCtrl, wxGenericTreeCtrl)
  54 #else
  55 BEGIN_EVENT_TABLE(wxRemotelyScrolledTreeCtrl, wxTreeCtrl)
  56 #endif
  57         EVT_SIZE(wxRemotelyScrolledTreeCtrl::OnSize)
  58         EVT_TREE_ITEM_EXPANDED(-1, wxRemotelyScrolledTreeCtrl::OnExpand)
  59         EVT_TREE_ITEM_COLLAPSED(-1, wxRemotelyScrolledTreeCtrl::OnExpand)
  60         EVT_SCROLLWIN(wxRemotelyScrolledTreeCtrl::OnScroll)
  61 END_EVENT_TABLE()
  62
  63 wxRemotelyScrolledTreeCtrl::wxRemotelyScrolledTreeCtrl(wxWindow* parent, wxWindowID id, const wxPoint& pt,
  64         const wxSize& sz, long style):
  65         wxTreeCtrl(parent, id, pt, sz, style)
  66 {
  67 }
  68
  69 wxRemotelyScrolledTreeCtrl::~wxRemotelyScrolledTreeCtrl()
  70 {
  71 }
  72
  73 void wxRemotelyScrolledTreeCtrl::HideVScrollbar()
  74 {
  75 #ifdef __WXMSW__
  76     if (!IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
  77     {
  78         ::ShowScrollBar((HWND) GetHWND(), SB_VERT, FALSE);
  79     }
  80     else
  81 #endif
  82     {
  83         // Implicit in overriding SetScrollbars
  84     }
  85 }
  86
  87 // Number of pixels per user unit (0 or -1 for no scrollbar)
  88 // Length of virtual canvas in user units
  89 // Length of page in user units
  90 void wxRemotelyScrolledTreeCtrl::SetScrollbars(int pixelsPerUnitX, int pixelsPerUnitY,
  91                              int noUnitsX, int noUnitsY,
  92                              int xPos, int yPos,
  93                              bool noRefresh)
  94 {
  95     if (IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
  96     {
  97         wxGenericTreeCtrl* win = (wxGenericTreeCtrl*) this;
  98         win->wxGenericTreeCtrl::SetScrollbars(pixelsPerUnitX, 0, noUnitsX, 0, xPos, 0, noRefresh);
  99
 100             wxScrolledWindow* scrolledWindow = GetScrolledWindow();
 101             if (scrolledWindow)
 102             {
 103             scrolledWindow->SetScrollbars(0, pixelsPerUnitY, 0, noUnitsY, 0, yPos, noRefresh);
 104         }
 105     }
 106 }
 107
 108 // In case we're using the generic tree control.
 109 // Get the view start
 110 void wxRemotelyScrolledTreeCtrl::GetViewStart(int *x, int *y) const
 111 {
 112     if (IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
 113     {
 114             wxScrolledWindow* scrolledWindow = GetScrolledWindow();
 115
 116         wxGenericTreeCtrl* win = (wxGenericTreeCtrl*) this;
 117         int x1, y1, x2, y2;
 118         win->wxGenericTreeCtrl::GetViewStart(& x1, & y1);
 119         * x = x1; * y = y1;
 120         if (!scrolledWindow)
 121             return;
 122
 123         scrolledWindow->GetViewStart(& x2, & y2);
 124         * y = y2;
 125     }
 126 }
 127
 128 // In case we're using the generic tree control.
 129 void wxRemotelyScrolledTreeCtrl::PrepareDC(wxDC& dc)
 130 {
 131     if (IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
 132     {
 133             wxScrolledWindow* scrolledWindow = GetScrolledWindow();
 134
 135         wxGenericTreeCtrl* win = (wxGenericTreeCtrl*) this;
 136
 137         int startX, startY;
 138         GetViewStart(& startX, & startY);
 139
 140         int xppu1, yppu1, xppu2, yppu2;
 141         win->wxGenericTreeCtrl::GetScrollPixelsPerUnit(& xppu1, & yppu1);
 142         scrolledWindow->GetScrollPixelsPerUnit(& xppu2, & yppu2);
 143
 144         dc.SetDeviceOrigin( -startX * xppu1, -startY * yppu2 );
 145         dc.SetUserScale( win->GetScaleX(), win->GetScaleY() );
 146     }
 147 }
 148
 149 // Scroll to the given line (in scroll units where each unit is
 150 // the height of an item)
 151 void wxRemotelyScrolledTreeCtrl::ScrollToLine(int posHoriz, int posVert)
 152 {
 153 #ifdef __WXMSW__
 154     if (!IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
 155     {
 156             UINT sbCode = SB_THUMBPOSITION;
 157             HWND vertScrollBar = 0;
 158             MSWDefWindowProc((WXUINT) WM_VSCROLL, MAKELONG(sbCode, posVert), (WXHWND) vertScrollBar);
 159     }
 160     else
 161 #endif
 162     {
 163         wxGenericTreeCtrl* win = (wxGenericTreeCtrl*) this;
 164                 win->Refresh();
 165                 /* Doesn't work yet because scrolling is ignored by Scroll
 166         int xppu, yppu;
 167             wxScrolledWindow* scrolledWindow = GetScrolledWindow();
 168             if (scrolledWindow)
 169             {
 170                         scrolledWindow->GetScrollPixelsPerUnit(& xppu, & yppu);
 171                         win->Scroll(-1, posVert*yppu);
 172                 }
 173                 */
 174     }
 175 }
 176
 177 void wxRemotelyScrolledTreeCtrl::OnSize(wxSizeEvent& event)
 178 {
 179         HideVScrollbar();
 180         AdjustRemoteScrollbars();
 181         event.Skip();
 182 }
 183
 184 void wxRemotelyScrolledTreeCtrl::OnExpand(wxTreeEvent& event)
 185 {
 186         AdjustRemoteScrollbars();
 187         event.Skip();
 188
 189     // If we don't have this, we get some bits of lines still remaining
 190     if (event.GetEventType() == wxEVT_COMMAND_TREE_ITEM_COLLAPSED)
 191         Refresh();
 192 }
 193
 194 // Adjust the containing wxScrolledWindow's scrollbars appropriately
 195 void wxRemotelyScrolledTreeCtrl::AdjustRemoteScrollbars()
 196 {
 197     if (IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
 198         {
 199                 // This is for the generic tree control.
 200                 // It calls SetScrollbars which has been overridden
 201                 // to adjust the parent scrolled window vertical
 202                 // scrollbar.
 203                 ((wxGenericTreeCtrl*) this)->AdjustMyScrollbars();
 204         return;
 205         }
 206         else
 207         {
 208                 // This is for the wxMSW tree control
 209                 wxScrolledWindow* scrolledWindow = GetScrolledWindow();
 210                 if (scrolledWindow)
 211                 {
 212                         wxRect itemRect;
 213                         if (GetBoundingRect(GetRootItem(), itemRect))
 214                         {
 215                                 int itemHeight = itemRect.GetHeight();
 216
 217                                 int w, h;
 218                                 GetClientSize(&w, &h);
 219
 220                                 wxRect rect(0, 0, 0, 0);
 221                                 CalcTreeSize(rect);
 222                                 int treeViewHeight = rect.GetHeight()/itemHeight;
 223
 224                                 int scrollPixelsPerLine = itemHeight;
 225                                 int scrollPos = - (itemRect.y / itemHeight);
 226
 227                                 scrolledWindow->SetScrollbars(0, scrollPixelsPerLine, 0, treeViewHeight, 0, scrollPos);
 228
 229                                 // Ensure that when a scrollbar becomes hidden or visible,
 230                                 // the contained window sizes are right.
 231                                 // Problem: this is called too early (?)
 232                                 wxSizeEvent event(scrolledWindow->GetSize(), scrolledWindow->GetId());
 233                                 scrolledWindow->GetEventHandler()->ProcessEvent(event);
 234                         }
 235                 }
 236         }
 237 }
 238
 239
 240 // Calculate the area that contains both rectangles
 241 static wxRect CombineRectangles(const wxRect& rect1, const wxRect& rect2)
 242 {
 243     wxRect rect;
 244
 245     int right1 = rect1.GetRight();
 246     int bottom1 = rect1.GetBottom();
 247     int right2 = rect2.GetRight();
 248     int bottom2 = rect2.GetBottom();
 249
 250     wxPoint topLeft = wxPoint(wxMin(rect1.x, rect2.x), wxMin(rect1.y, rect2.y));
 251     wxPoint bottomRight = wxPoint(wxMax(right1, right2), wxMax(bottom1, bottom2));
 252
 253     rect.x = topLeft.x; rect.y = topLeft.y;
 254     rect.SetRight(bottomRight.x);
 255     rect.SetBottom(bottomRight.y);
 256
 257     return rect;
 258 }
 259
 260
 261 // Calculate the tree overall size so we can set the scrollbar
 262 // correctly
 263 void wxRemotelyScrolledTreeCtrl::CalcTreeSize(wxRect& rect)
 264 {
 265         CalcTreeSize(GetRootItem(), rect);
 266 }
 267
 268 void wxRemotelyScrolledTreeCtrl::CalcTreeSize(wxTreeItemId& id, wxRect& rect)
 269 {
 270         // TODO: implement GetFirst/NextVisibleItem
 271         // for wxGenericTreeCtrl, plus GetBoundingRect.
 272
 273         // More efficient implementation would be to find the last item (but how?)
 274         // Q: is the bounding rect relative to the top of the virtual tree workspace
 275         // or the top of the window? How would we convert?
 276         wxRect itemSize;
 277         if (GetBoundingRect(id, itemSize))
 278         {
 279                 rect = CombineRectangles(rect, itemSize);
 280         }
 281
 282         long cookie;
 283         wxTreeItemId childId = GetFirstChild(id, cookie);
 284         while (childId != 0)
 285         {
 286                 CalcTreeSize(childId, rect);
 287                 childId = GetNextChild(childId, cookie);
 288         }
 289 }
 290
 291 // Find the scrolled window that contains this control
 292 wxScrolledWindow* wxRemotelyScrolledTreeCtrl::GetScrolledWindow() const
 293 {
 294         wxWindow* parent = wxWindow::GetParent();
 295         while (parent)
 296         {
 297                 if (parent->IsKindOf(CLASSINFO(wxScrolledWindow)))
 298                         return (wxScrolledWindow*) parent;
 299                 parent = parent->GetParent();
 300         }
 301         return NULL;
 302 }
 303
 304 void wxRemotelyScrolledTreeCtrl::OnScroll(wxScrollWinEvent& event)
 305 {
 306     int orient = event.GetOrientation();
 307     if (orient == wxHORIZONTAL)
 308     {
 309         // Don't 'skip' or we'd get into infinite recursion
 310         return;
 311     }
 312     wxScrolledWindow* scrollWin = GetScrolledWindow();
 313     if (!scrollWin)
 314         return;
 315
 316     int x, y;
 317     scrollWin->GetViewStart(& x, & y);
 318
 319     ScrollToLine(-1, y);
 320 }
 321
 322 /*
 323  * wxThinSplitterWindow
 324  */
 325
 326 IMPLEMENT_CLASS(wxThinSplitterWindow, wxSplitterWindow)
 327
 328 BEGIN_EVENT_TABLE(wxThinSplitterWindow, wxSplitterWindow)
 329         EVT_SIZE(wxThinSplitterWindow::OnSize)
 330 END_EVENT_TABLE()
 331
 332 wxThinSplitterWindow::wxThinSplitterWindow(wxWindow* parent, wxWindowID id,
 333       const wxPoint& pos,
 334       const wxSize& sz,
 335       long style):
 336       wxSplitterWindow(parent, id, pos, sz, style)
 337 {
 338 }
 339
 340 void wxThinSplitterWindow::SizeWindows()
 341 {
 342         // The client size may have changed inbetween
 343         // the sizing of the first window and the sizing of
 344         // the second. So repeat SizeWindows.
 345     wxSplitterWindow::SizeWindows();
 346     wxSplitterWindow::SizeWindows();
 347 }
 348
 349 // Tests for x, y over sash
 350 bool wxThinSplitterWindow::SashHitTest(int x, int y, int tolerance)
 351 {
 352         return wxSplitterWindow::SashHitTest(x, y, 4);
 353 }
 354
 355 void wxThinSplitterWindow::DrawSash(wxDC& dc)
 356 {
 357     if ( m_sashPosition == 0 || !m_windowTwo)
 358         return;
 359     if (GetWindowStyle() & wxSP_NOSASH)
 360         return;
 361
 362     int w, h;
 363     GetClientSize(&w, &h);
 364
 365         if ( m_splitMode == wxSPLIT_VERTICAL )
 366         {
 367                 dc.SetPen(* m_facePen);
 368                 dc.SetBrush(* m_faceBrush);
 369                 int h1 = h-1;
 370                 int y1 = 0;
 371                 if ( (GetWindowStyleFlag() & wxSP_BORDER) != wxSP_BORDER && (GetWindowStyleFlag() & wxSP_3DBORDER) != wxSP_3DBORDER )
 372                         h1 += 1; // Not sure why this is necessary...
 373                 if ( (GetWindowStyleFlag() & wxSP_3DBORDER) == wxSP_3DBORDER)
 374                 {
 375                         y1 = 2; h1 -= 3;
 376                 }
 377                 dc.DrawRectangle(m_sashPosition, y1, m_sashSize, h1);
 378         }
 379         else
 380         {
 381                 dc.SetPen(* m_facePen);
 382                 dc.SetBrush(* m_faceBrush);
 383                 int w1 = w-1;
 384                 int x1 = 0;
 385                 if ( (GetWindowStyleFlag() & wxSP_BORDER) != wxSP_BORDER && (GetWindowStyleFlag() & wxSP_3DBORDER) != wxSP_3DBORDER )
 386                         w1 ++;
 387                 if ( (GetWindowStyleFlag() & wxSP_3DBORDER) == wxSP_3DBORDER)
 388                 {
 389                         x1 = 2; w1 -= 3;
 390                 }
 391                 dc.DrawRectangle(x1, m_sashPosition, w1, m_sashSize);
 392         }
 393
 394     dc.SetPen(wxNullPen);
 395     dc.SetBrush(wxNullBrush);
 396 }
 397
 398 void wxThinSplitterWindow::OnSize(wxSizeEvent& event)
 399 {
 400         wxSplitterWindow::OnSize(event);
 401 }
 402
 403 /*
 404  * wxSplitterScrolledWindow
 405  */
 406
 407 IMPLEMENT_CLASS(wxSplitterScrolledWindow, wxScrolledWindow)
 408
 409 BEGIN_EVENT_TABLE(wxSplitterScrolledWindow, wxScrolledWindow)
 410         EVT_SCROLLWIN(wxSplitterScrolledWindow::OnScroll)
 411         EVT_SIZE(wxSplitterScrolledWindow::OnSize)
 412 END_EVENT_TABLE()
 413
 414 wxSplitterScrolledWindow::wxSplitterScrolledWindow(wxWindow* parent, wxWindowID id,
 415       const wxPoint& pos,
 416       const wxSize& sz,
 417       long style):
 418       wxScrolledWindow(parent, id, pos, sz, style)
 419 {
 420 }
 421
 422 void wxSplitterScrolledWindow::OnSize(wxSizeEvent& event)
 423 {
 424         wxSize sz = GetClientSize();
 425         if (GetChildren().First())
 426         {
 427                 ((wxWindow*) GetChildren().First()->Data())->SetSize(0, 0, sz.x, sz.y);
 428         }
 429 }
 430
 431 void wxSplitterScrolledWindow::OnScroll(wxScrollWinEvent& event)
 432 {
 433     // Ensure that events being propagated back up the window hierarchy
 434     // don't cause an infinite loop
 435     static bool inOnScroll = FALSE;
 436     if (inOnScroll)
 437         return;
 438     inOnScroll = TRUE;
 439
 440     int orient = event.GetOrientation();
 441
 442     int nScrollInc = CalcScrollInc(event);
 443     if (nScrollInc == 0)
 444     {
 445         inOnScroll = FALSE;
 446         return;
 447     }
 448
 449     if (orient == wxHORIZONTAL)
 450     {
 451         int newPos = m_xScrollPosition + nScrollInc;
 452         SetScrollPos(wxHORIZONTAL, newPos, TRUE );
 453     }
 454     else
 455     {
 456         int newPos = m_yScrollPosition + nScrollInc;
 457         SetScrollPos(wxVERTICAL, newPos, TRUE );
 458     }
 459
 460     if (orient == wxHORIZONTAL)
 461     {
 462         m_xScrollPosition += nScrollInc;
 463     }
 464     else
 465     {
 466         m_yScrollPosition += nScrollInc;
 467     }
 468
 469     // Find targets in splitter window and send the event to them
 470     wxNode* node = GetChildren().First();
 471     while (node)
 472     {
 473         wxWindow* child = (wxWindow*) node->Data();
 474         if (child->IsKindOf(CLASSINFO(wxSplitterWindow)))
 475         {
 476             wxSplitterWindow* splitter = (wxSplitterWindow*) child;
 477             if (splitter->GetWindow1())
 478                 splitter->GetWindow1()->ProcessEvent(event);
 479             if (splitter->GetWindow2())
 480                 splitter->GetWindow2()->ProcessEvent(event);
 481             break;
 482         }
 483         node = node->Next();
 484     }
 485
 486 #ifdef __WXMAC__
 487     m_targetWindow->MacUpdateImmediately() ;
 488 #endif
 489
 490     inOnScroll = FALSE;
 491 }
 492