src/palmos/treectrl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/palmos/treectrl.cpp
   3 // Purpose:     wxTreeCtrl
   4 // Author:      William Osborne
   5 // Modified by:
   6 // Created:     10/13/04
   7 // RCS-ID:      $Id:
   8 // Copyright:   (c) William Osborne
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  21     #pragma implementation "treectrl.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #if wxUSE_TREECTRL
  32
  33 #include "wx/palmos/private.h"
  34
  35 #include "wx/app.h"
  36 #include "wx/log.h"
  37 #include "wx/dynarray.h"
  38 #include "wx/imaglist.h"
  39 #include "wx/settings.h"
  40
  41 // macros to hide the cast ugliness
  42 // --------------------------------
  43
  44 // ptr is the real item id, i.e. wxTreeItemId::m_pItem
  45 #define HITEM_PTR(ptr)     (HTREEITEM)(ptr)
  46
  47 // item here is a wxTreeItemId
  48 #define HITEM(item)     HITEM_PTR((item).m_pItem)
  49
  50 // the native control doesn't support multiple selections under MSW and we
  51 // have 2 ways to emulate them: either using TVS_CHECKBOXES style and let
  52 // checkboxes be the selection status (checked == selected) or by really
  53 // emulating everything, i.e. intercepting mouse and key events &c. The first
  54 // approach is much easier but doesn't work with comctl32.dll < 4.71 and also
  55 // looks quite ugly.
  56 #define wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE 0
  57
  58 // ----------------------------------------------------------------------------
  59 // private functions
  60 // ----------------------------------------------------------------------------
  61
  62 // ----------------------------------------------------------------------------
  63 // private classes
  64 // ----------------------------------------------------------------------------
  65
  66 // ----------------------------------------------------------------------------
  67 // wxWin macros
  68 // ----------------------------------------------------------------------------
  69
  70 #if wxUSE_EXTENDED_RTTI
  71 WX_DEFINE_FLAGS( wxTreeCtrlStyle )
  72
  73 wxBEGIN_FLAGS( wxTreeCtrlStyle )
  74     // new style border flags, we put them first to
  75     // use them for streaming out
  76     wxFLAGS_MEMBER(wxBORDER_SIMPLE)
  77     wxFLAGS_MEMBER(wxBORDER_SUNKEN)
  78     wxFLAGS_MEMBER(wxBORDER_DOUBLE)
  79     wxFLAGS_MEMBER(wxBORDER_RAISED)
  80     wxFLAGS_MEMBER(wxBORDER_STATIC)
  81     wxFLAGS_MEMBER(wxBORDER_NONE)
  82
  83     // old style border flags
  84     wxFLAGS_MEMBER(wxSIMPLE_BORDER)
  85     wxFLAGS_MEMBER(wxSUNKEN_BORDER)
  86     wxFLAGS_MEMBER(wxDOUBLE_BORDER)
  87     wxFLAGS_MEMBER(wxRAISED_BORDER)
  88     wxFLAGS_MEMBER(wxSTATIC_BORDER)
  89     wxFLAGS_MEMBER(wxBORDER)
  90
  91     // standard window styles
  92     wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
  93     wxFLAGS_MEMBER(wxCLIP_CHILDREN)
  94     wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
  95     wxFLAGS_MEMBER(wxWANTS_CHARS)
  96     wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
  97     wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
  98     wxFLAGS_MEMBER(wxVSCROLL)
  99     wxFLAGS_MEMBER(wxHSCROLL)
 100
 101     wxFLAGS_MEMBER(wxTR_EDIT_LABELS)
 102     wxFLAGS_MEMBER(wxTR_NO_BUTTONS)
 103     wxFLAGS_MEMBER(wxTR_HAS_BUTTONS)
 104     wxFLAGS_MEMBER(wxTR_TWIST_BUTTONS)
 105     wxFLAGS_MEMBER(wxTR_NO_LINES)
 106     wxFLAGS_MEMBER(wxTR_FULL_ROW_HIGHLIGHT)
 107     wxFLAGS_MEMBER(wxTR_LINES_AT_ROOT)
 108     wxFLAGS_MEMBER(wxTR_HIDE_ROOT)
 109     wxFLAGS_MEMBER(wxTR_ROW_LINES)
 110     wxFLAGS_MEMBER(wxTR_HAS_VARIABLE_ROW_HEIGHT)
 111     wxFLAGS_MEMBER(wxTR_SINGLE)
 112     wxFLAGS_MEMBER(wxTR_MULTIPLE)
 113     wxFLAGS_MEMBER(wxTR_EXTENDED)
 114     wxFLAGS_MEMBER(wxTR_DEFAULT_STYLE)
 115
 116 wxEND_FLAGS( wxTreeCtrlStyle )
 117
 118 IMPLEMENT_DYNAMIC_CLASS_XTI(wxTreeCtrl, wxControl,"wx/treectrl.h")
 119
 120 wxBEGIN_PROPERTIES_TABLE(wxTreeCtrl)
 121     wxEVENT_PROPERTY( TextUpdated , wxEVT_COMMAND_TEXT_UPDATED , wxCommandEvent )
 122     wxEVENT_RANGE_PROPERTY( TreeEvent , wxEVT_COMMAND_TREE_BEGIN_DRAG , wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK , wxTreeEvent )
 123     wxPROPERTY_FLAGS( WindowStyle , wxTreeCtrlStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
 124 wxEND_PROPERTIES_TABLE()
 125
 126 wxBEGIN_HANDLERS_TABLE(wxTreeCtrl)
 127 wxEND_HANDLERS_TABLE()
 128
 129 wxCONSTRUCTOR_5( wxTreeCtrl , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle )
 130 #else
 131 IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxControl)
 132 #endif
 133
 134 // ----------------------------------------------------------------------------
 135 // constants
 136 // ----------------------------------------------------------------------------
 137
 138 // indices in gs_expandEvents table below
 139 enum
 140 {
 141     IDX_COLLAPSE,
 142     IDX_EXPAND,
 143     IDX_WHAT_MAX
 144 };
 145
 146 enum
 147 {
 148     IDX_DONE,
 149     IDX_DOING,
 150     IDX_HOW_MAX
 151 };
 152
 153 // handy table for sending events - it has to be initialized during run-time
 154 // now so can't be const any more
 155 static /* const */ wxEventType gs_expandEvents[IDX_WHAT_MAX][IDX_HOW_MAX];
 156
 157 /*
 158    but logically it's a const table with the following entries:
 159 =
 160 {
 161     { wxEVT_COMMAND_TREE_ITEM_COLLAPSED, wxEVT_COMMAND_TREE_ITEM_COLLAPSING },
 162     { wxEVT_COMMAND_TREE_ITEM_EXPANDED,  wxEVT_COMMAND_TREE_ITEM_EXPANDING  }
 163 };
 164 */
 165
 166 // ============================================================================
 167 // implementation
 168 // ============================================================================
 169
 170 // ----------------------------------------------------------------------------
 171 // construction and destruction
 172 // ----------------------------------------------------------------------------
 173
 174 void wxTreeCtrl::Init()
 175 {
 176 }
 177
 178 bool wxTreeCtrl::Create(wxWindow *parent,
 179                         wxWindowID id,
 180                         const wxPoint& pos,
 181                         const wxSize& size,
 182                         long style,
 183                         const wxValidator& validator,
 184                         const wxString& name)
 185 {
 186     return false;
 187 }
 188
 189 wxTreeCtrl::~wxTreeCtrl()
 190 {
 191 }
 192
 193 // ----------------------------------------------------------------------------
 194 // accessors
 195 // ----------------------------------------------------------------------------
 196
 197 /* static */ wxVisualAttributes
 198 wxTreeCtrl::GetClassDefaultAttributes(wxWindowVariant variant)
 199 {
 200     wxVisualAttributes attrs;
 201
 202     return attrs;
 203 }
 204
 205
 206 // simple wrappers which add error checking in debug mode
 207
 208 bool wxTreeCtrl::DoGetItem(wxTreeViewItem* tvItem) const
 209 {
 210     return false;
 211 }
 212
 213 void wxTreeCtrl::DoSetItem(wxTreeViewItem* tvItem)
 214 {
 215 }
 216
 217 size_t wxTreeCtrl::GetCount() const
 218 {
 219     return 0;
 220 }
 221
 222 unsigned int wxTreeCtrl::GetIndent() const
 223 {
 224     return 0;
 225 }
 226
 227 void wxTreeCtrl::SetIndent(unsigned int indent)
 228 {
 229 }
 230
 231 wxImageList *wxTreeCtrl::GetImageList() const
 232 {
 233     return m_imageListNormal;
 234 }
 235
 236 wxImageList *wxTreeCtrl::GetStateImageList() const
 237 {
 238     return m_imageListState;
 239 }
 240
 241 void wxTreeCtrl::SetAnyImageList(wxImageList *imageList, int which)
 242 {
 243 }
 244
 245 void wxTreeCtrl::SetImageList(wxImageList *imageList)
 246 {
 247 }
 248
 249 void wxTreeCtrl::SetStateImageList(wxImageList *imageList)
 250 {
 251 }
 252
 253 void wxTreeCtrl::AssignImageList(wxImageList *imageList)
 254 {
 255 }
 256
 257 void wxTreeCtrl::AssignStateImageList(wxImageList *imageList)
 258 {
 259 }
 260
 261 size_t wxTreeCtrl::GetChildrenCount(const wxTreeItemId& item,
 262                                     bool recursively) const
 263 {
 264     return 0;
 265 }
 266
 267 // ----------------------------------------------------------------------------
 268 // control colours
 269 // ----------------------------------------------------------------------------
 270
 271 bool wxTreeCtrl::SetBackgroundColour(const wxColour &colour)
 272 {
 273     return false;
 274 }
 275
 276 bool wxTreeCtrl::SetForegroundColour(const wxColour &colour)
 277 {
 278     return false;
 279 }
 280
 281 // ----------------------------------------------------------------------------
 282 // Item access
 283 // ----------------------------------------------------------------------------
 284
 285 wxString wxTreeCtrl::GetItemText(const wxTreeItemId& item) const
 286 {
 287     return wxString;
 288 }
 289
 290 void wxTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
 291 {
 292 }
 293
 294 int wxTreeCtrl::DoGetItemImageFromData(const wxTreeItemId& item,
 295                                        wxTreeItemIcon which) const
 296 {
 297     return -1;
 298 }
 299
 300 void wxTreeCtrl::DoSetItemImageFromData(const wxTreeItemId& item,
 301                                         int image,
 302                                         wxTreeItemIcon which) const
 303 {
 304 }
 305
 306 void wxTreeCtrl::DoSetItemImages(const wxTreeItemId& item,
 307                                  int image,
 308                                  int imageSel)
 309 {
 310 }
 311
 312 int wxTreeCtrl::GetItemImage(const wxTreeItemId& item,
 313                              wxTreeItemIcon which) const
 314 {
 315     return -1;
 316 }
 317
 318 void wxTreeCtrl::SetItemImage(const wxTreeItemId& item, int image,
 319                               wxTreeItemIcon which)
 320 {
 321 }
 322
 323 wxTreeItemData *wxTreeCtrl::GetItemData(const wxTreeItemId& item) const
 324 {
 325     return NULL;
 326 }
 327
 328 void wxTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
 329 {
 330 }
 331
 332 void wxTreeCtrl::SetIndirectItemData(const wxTreeItemId& item,
 333                                      wxTreeItemIndirectData *data)
 334 {
 335 }
 336
 337 bool wxTreeCtrl::HasIndirectData(const wxTreeItemId& item) const
 338 {
 339     return false;
 340 }
 341
 342 void wxTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
 343 {
 344 }
 345
 346 void wxTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
 347 {
 348 }
 349
 350 void wxTreeCtrl::SetItemDropHighlight(const wxTreeItemId& item, bool highlight)
 351 {
 352 }
 353
 354 void wxTreeCtrl::RefreshItem(const wxTreeItemId& item)
 355 {
 356 }
 357
 358 wxColour wxTreeCtrl::GetItemTextColour(const wxTreeItemId& item) const
 359 {
 360     return wxNullColour;
 361 }
 362
 363 wxColour wxTreeCtrl::GetItemBackgroundColour(const wxTreeItemId& item) const
 364 {
 365     return wxNullColour;
 366 }
 367
 368 wxFont wxTreeCtrl::GetItemFont(const wxTreeItemId& item) const
 369 {
 370     return wxNullFont;
 371 }
 372
 373 void wxTreeCtrl::SetItemTextColour(const wxTreeItemId& item,
 374                                    const wxColour& col)
 375 {
 376 }
 377
 378 void wxTreeCtrl::SetItemBackgroundColour(const wxTreeItemId& item,
 379                                          const wxColour& col)
 380 {
 381 }
 382
 383 void wxTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font)
 384 {
 385 }
 386
 387 // ----------------------------------------------------------------------------
 388 // Item status
 389 // ----------------------------------------------------------------------------
 390
 391 bool wxTreeCtrl::IsVisible(const wxTreeItemId& item) const
 392 {
 393     return false;
 394 }
 395
 396 bool wxTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
 397 {
 398     return false;
 399 }
 400
 401 bool wxTreeCtrl::IsExpanded(const wxTreeItemId& item) const
 402 {
 403     return false;
 404 }
 405
 406 bool wxTreeCtrl::IsSelected(const wxTreeItemId& item) const
 407 {
 408     return false;
 409 }
 410
 411 bool wxTreeCtrl::IsBold(const wxTreeItemId& item) const
 412 {
 413     return false;
 414 }
 415
 416 // ----------------------------------------------------------------------------
 417 // navigation
 418 // ----------------------------------------------------------------------------
 419
 420 wxTreeItemId wxTreeCtrl::GetRootItem() const
 421 {
 422     // Root may be real (visible) or virtual (hidden).
 423     if ( GET_VIRTUAL_ROOT() )
 424         return TVI_ROOT;
 425
 426     return wxTreeItemId(TreeView_GetRoot(GetHwnd()));
 427 }
 428
 429 wxTreeItemId wxTreeCtrl::GetSelection() const
 430 {
 431     return 0;
 432 }
 433
 434 wxTreeItemId wxTreeCtrl::GetItemParent(const wxTreeItemId& item) const
 435 {
 436     return 0;
 437 }
 438
 439 wxTreeItemId wxTreeCtrl::GetFirstChild(const wxTreeItemId& item,
 440                                        wxTreeItemIdValue& cookie) const
 441 {
 442     return 0;
 443 }
 444
 445 wxTreeItemId wxTreeCtrl::GetNextChild(const wxTreeItemId& WXUNUSED(item),
 446                                       wxTreeItemIdValue& cookie) const
 447 {
 448     return 0;
 449 }
 450
 451 wxTreeItemId wxTreeCtrl::GetLastChild(const wxTreeItemId& item) const
 452 {
 453     return 0;
 454 }
 455
 456 wxTreeItemId wxTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
 457 {
 458     return 0;
 459 }
 460
 461 wxTreeItemId wxTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
 462 {
 463     return 0;
 464 }
 465
 466 wxTreeItemId wxTreeCtrl::GetFirstVisibleItem() const
 467 {
 468     return 0;
 469 }
 470
 471 wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
 472 {
 473     return 0;
 474 }
 475
 476 wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
 477 {
 478     return 0;
 479 }
 480
 481 // ----------------------------------------------------------------------------
 482 // multiple selections emulation
 483 // ----------------------------------------------------------------------------
 484
 485 bool wxTreeCtrl::IsItemChecked(const wxTreeItemId& item) const
 486 {
 487     return false;
 488 }
 489
 490 void wxTreeCtrl::SetItemCheck(const wxTreeItemId& item, bool check)
 491 {
 492 }
 493
 494 size_t wxTreeCtrl::GetSelections(wxArrayTreeItemIds& selections) const
 495 {
 496     return 0;
 497 }
 498
 499 // ----------------------------------------------------------------------------
 500 // Usual operations
 501 // ----------------------------------------------------------------------------
 502
 503 wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parent,
 504                                       wxTreeItemId hInsertAfter,
 505                                       const wxString& text,
 506                                       int image, int selectedImage,
 507                                       wxTreeItemData *data)
 508 {
 509     return 0;
 510 }
 511
 512 wxTreeItemId wxTreeCtrl::AddRoot(const wxString& text,
 513                                  int image, int selectedImage,
 514                                  wxTreeItemData *data)
 515 {
 516     return 0;
 517 }
 518
 519 wxTreeItemId wxTreeCtrl::PrependItem(const wxTreeItemId& parent,
 520                                      const wxString& text,
 521                                      int image, int selectedImage,
 522                                      wxTreeItemData *data)
 523 {
 524     return 0;
 525 }
 526
 527 wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
 528                                     const wxTreeItemId& idPrevious,
 529                                     const wxString& text,
 530                                     int image, int selectedImage,
 531                                     wxTreeItemData *data)
 532 {
 533     return 0;
 534 }
 535
 536 wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
 537                                     size_t index,
 538                                     const wxString& text,
 539                                     int image, int selectedImage,
 540                                     wxTreeItemData *data)
 541 {
 542     return 0;
 543 }
 544
 545 wxTreeItemId wxTreeCtrl::AppendItem(const wxTreeItemId& parent,
 546                                     const wxString& text,
 547                                     int image, int selectedImage,
 548                                     wxTreeItemData *data)
 549 {
 550     return 0;
 551 }
 552
 553 void wxTreeCtrl::Delete(const wxTreeItemId& item)
 554 {
 555     return 0;
 556 }
 557
 558 // delete all children (but don't delete the item itself)
 559 void wxTreeCtrl::DeleteChildren(const wxTreeItemId& item)
 560 {
 561 }
 562
 563 void wxTreeCtrl::DeleteAllItems()
 564 {
 565 }
 566
 567 void wxTreeCtrl::DoExpand(const wxTreeItemId& item, int flag)
 568 {
 569 }
 570
 571 void wxTreeCtrl::Expand(const wxTreeItemId& item)
 572 {
 573 }
 574
 575 void wxTreeCtrl::Collapse(const wxTreeItemId& item)
 576 {
 577 }
 578
 579 void wxTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
 580 {
 581 }
 582
 583 void wxTreeCtrl::Toggle(const wxTreeItemId& item)
 584 {
 585 }
 586
 587 void wxTreeCtrl::Unselect()
 588 {
 589 }
 590
 591 void wxTreeCtrl::UnselectAll()
 592 {
 593 }
 594
 595 void wxTreeCtrl::SelectItem(const wxTreeItemId& item, bool select)
 596 {
 597 }
 598
 599 void wxTreeCtrl::UnselectItem(const wxTreeItemId& item)
 600 {
 601 }
 602
 603 void wxTreeCtrl::ToggleItemSelection(const wxTreeItemId& item)
 604 {
 605 }
 606
 607 void wxTreeCtrl::EnsureVisible(const wxTreeItemId& item)
 608 {
 609 }
 610
 611 void wxTreeCtrl::ScrollTo(const wxTreeItemId& item)
 612 {
 613 }
 614
 615 wxTextCtrl *wxTreeCtrl::GetEditControl() const
 616 {
 617     return NULL;
 618 }
 619
 620 void wxTreeCtrl::DeleteTextCtrl()
 621 {
 622 }
 623
 624 wxTextCtrl* wxTreeCtrl::EditLabel(const wxTreeItemId& item,
 625                                   wxClassInfo* textControlClass)
 626 {
 627     return NULL;
 628 }
 629
 630 // End label editing, optionally cancelling the edit
 631 void wxTreeCtrl::EndEditLabel(const wxTreeItemId& WXUNUSED(item), bool discardChanges)
 632 {
 633 }
 634
 635 wxTreeItemId wxTreeCtrl::HitTest(const wxPoint& point, int& flags)
 636 {
 637     return 0;
 638 }
 639
 640 bool wxTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
 641                                  wxRect& rect,
 642                                  bool textOnly) const
 643 {
 644     return false;
 645 }
 646
 647 // ----------------------------------------------------------------------------
 648 // sorting stuff
 649 // ----------------------------------------------------------------------------
 650
 651 // this is just a tiny namespace which is friend to wxTreeCtrl and so can use
 652 // functions such as IsDataIndirect()
 653 class wxTreeSortHelper
 654 {
 655 public:
 656     static int CALLBACK Compare(LPARAM data1, LPARAM data2, LPARAM tree);
 657
 658 private:
 659     static wxTreeItemId GetIdFromData(wxTreeCtrl *tree, LPARAM item)
 660     {
 661         wxTreeItemData *data = (wxTreeItemData *)item;
 662         if ( tree->IsDataIndirect(data) )
 663         {
 664             data = ((wxTreeItemIndirectData *)data)->GetData();
 665         }
 666
 667         return data->GetId();
 668     }
 669 };
 670
 671 int CALLBACK wxTreeSortHelper::Compare(LPARAM pItem1,
 672                                        LPARAM pItem2,
 673                                        LPARAM htree)
 674 {
 675     wxCHECK_MSG( pItem1 && pItem2, 0,
 676                  wxT("sorting tree without data doesn't make sense") );
 677
 678     wxTreeCtrl *tree = (wxTreeCtrl *)htree;
 679
 680     return tree->OnCompareItems(GetIdFromData(tree, pItem1),
 681                                 GetIdFromData(tree, pItem2));
 682 }
 683
 684 int wxTreeCtrl::OnCompareItems(const wxTreeItemId& item1,
 685                                const wxTreeItemId& item2)
 686 {
 687     return wxStrcmp(GetItemText(item1), GetItemText(item2));
 688 }
 689
 690 void wxTreeCtrl::SortChildren(const wxTreeItemId& item)
 691 {
 692     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
 693
 694     // rely on the fact that TreeView_SortChildren does the same thing as our
 695     // default behaviour, i.e. sorts items alphabetically and so call it
 696     // directly if we're not in derived class (much more efficient!)
 697     if ( GetClassInfo() == CLASSINFO(wxTreeCtrl) )
 698     {
 699         TreeView_SortChildren(GetHwnd(), HITEM(item), 0);
 700     }
 701     else
 702     {
 703         TV_SORTCB tvSort;
 704         tvSort.hParent = HITEM(item);
 705         tvSort.lpfnCompare = wxTreeSortHelper::Compare;
 706         tvSort.lParam = (LPARAM)this;
 707         TreeView_SortChildrenCB(GetHwnd(), &tvSort, 0 /* reserved */);
 708     }
 709 }
 710
 711 // ----------------------------------------------------------------------------
 712 // State control.
 713 // ----------------------------------------------------------------------------
 714
 715 // why do they define INDEXTOSTATEIMAGEMASK but not the inverse?
 716 #define STATEIMAGEMASKTOINDEX(state) (((state) & TVIS_STATEIMAGEMASK) >> 12)
 717
 718 void wxTreeCtrl::SetState(const wxTreeItemId& node, int state)
 719 {
 720 }
 721
 722 int wxTreeCtrl::GetState(const wxTreeItemId& node)
 723 {
 724     return 0;
 725 }
 726
 727 #endif // wxUSE_TREECTRL
 728