src/os2/treectrl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/treectrl.cpp
   3 // Purpose:     wxTreeCtrl
   4 // Author:      Julian Smart
   5 // Modified by: Vadim Zeitlin to be less MSW-specific on 10.10.98
   6 // Created:     1997
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #if wxUSE_TREECTRL
  28
  29 #include "wx/os2/private.h"
  30
  31 #include "wx/app.h"
  32 #include "wx/log.h"
  33 #include "wx/dynarray.h"
  34 #include "wx/imaglist.h"
  35 #include "wx/settings.h"
  36 #include "wx/os2/treectrl.h"
  37
  38 // a macro to hide the ugliness of nested casts
  39 #define HITEM(item)     (HTREEITEM)(WXHTREEITEM)(item)
  40
  41 // the native control doesn't support multiple selections under MSW and we
  42 // have 2 ways to emulate them: either using TVS_CHECKBOXES style and let
  43 // checkboxes be the selection status (checked == selected) or by really
  44 // emulating everything, i.e. intercepting mouse and key events &c. The first
  45 // approach is much easier but doesn't work with comctl32.dll < 4.71 and also
  46 // looks quite ugly.
  47 #define wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE 0
  48
  49 // ----------------------------------------------------------------------------
  50 // private functions
  51 // ----------------------------------------------------------------------------
  52
  53 // ----------------------------------------------------------------------------
  54 // private classes
  55 // ----------------------------------------------------------------------------
  56
  57 typedef struct _MYRECORD
  58 {
  59     RECORDCORE                      m_vRecord;
  60     ULONG                           m_ulItemId;
  61     ULONG                           m_ulUserData;
  62 } MYRECORD, *PMYRECORD;
  63
  64 struct wxTreeViewItem : public MYRECORD
  65 {
  66     wxTreeViewItem(const wxTreeItemId& rItem)
  67     {
  68         m_ulItemId = (ULONG)rItem.m_pItem;
  69     }
  70 }; // end of STRUCT wxTreeViewItem
  71
  72 class wxTreeItemInternalData
  73 {
  74 public:
  75
  76     wxTreeItemInternalData() {}
  77     ~wxTreeItemInternalData()
  78     {
  79         if(m_pAttr)
  80         {
  81             delete m_pAttr;
  82             m_pAttr = NULL;
  83         }
  84     }
  85
  86     wxTreeItemAttr*                 m_pAttr;
  87     WXLPARAM                        m_lParam; // user data
  88 #if defined(C_CM_COS232)
  89     PMYRECORD                       m_pMyRecord; // so we can set the m_ulUserData to 0 when this is deleted
  90 #endif
  91 }; // end of CLASS wxTreeItemInternalData
  92
  93 void BumpTreeRecordIds (
  94   HWND                              hWnd
  95 , PMYRECORD                         pRecord
  96 )
  97 {
  98     while(pRecord)
  99     {
 100         pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( hWnd
 101                                                       ,CM_QUERYRECORD
 102                                                       ,MPFROMP(pRecord)
 103                                                       ,MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER)
 104                                                      ));
 105         if (pRecord)
 106             pRecord->m_ulItemId++;
 107     }
 108 } // end of BumpTreeRecordIds
 109
 110 PMYRECORD FindOS2TreeRecordByID (
 111   HWND                              hWnd
 112 , long                              lItemId
 113 )
 114 {
 115     PMYRECORD                       pRecord = NULL;
 116     CNRINFO                         vCnrInfo;
 117     unsigned long                   i;
 118
 119     if (!::WinSendMsg( hWnd
 120                       ,CM_QUERYCNRINFO
 121                       ,MPFROMP(&vCnrInfo)
 122                       ,(MPARAM)(USHORT)sizeof(CNRINFO)
 123                      ))
 124         return NULL;
 125     for (i = 0; i < vCnrInfo.cRecords; i++)
 126     {
 127         if (i == 0)
 128             pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( hWnd
 129                                                           ,CM_QUERYRECORD
 130                                                           ,MPFROMP(pRecord)
 131                                                           ,MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER)
 132                                                          ));
 133         else
 134             pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( hWnd
 135                                                           ,CM_QUERYRECORD
 136                                                           ,MPFROMP(pRecord)
 137                                                           ,MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER)
 138                                                          ));
 139         if (!pRecord)
 140             return NULL;
 141         if (pRecord->m_ulItemId == (ULONG)lItemId)
 142             break;
 143     }
 144     return pRecord;
 145 } // end of FindOS2ListRecordByID
 146
 147
 148
 149 class wxTreeTraversal
 150 {
 151 public:
 152     wxTreeTraversal(const wxTreeCtrl* pTree)
 153     {
 154         m_pTree = pTree;
 155     }
 156
 157     //
 158     // Do traverse the tree: visit all items (recursively by default) under the
 159     // given one; return true if all items were traversed or false if the
 160     // traversal was aborted because OnVisit returned false
 161     //
 162     bool DoTraverse( const wxTreeItemId& rRoot
 163                     ,bool                bRecursively = true
 164                    );
 165
 166     //
 167     // Override this function to do whatever is needed for each item, return
 168     // false to stop traversing
 169     //
 170     virtual bool OnVisit(const wxTreeItemId& rItem) = 0;
 171
 172 protected:
 173     const wxTreeCtrl* GetTree(void) const { return m_pTree; }
 174
 175 private:
 176     bool Traverse( const wxTreeItemId& rRoot
 177                   ,bool                bRecursively
 178                  );
 179
 180     const wxTreeCtrl*               m_pTree;
 181     DECLARE_NO_COPY_CLASS(wxTreeTraversal)
 182 }; // end of CLASS wxTreeTraversal
 183
 184 //
 185 // Internal class for getting the selected items
 186 //
 187 class TraverseSelections : public wxTreeTraversal
 188 {
 189 public:
 190     TraverseSelections( const wxTreeCtrl*   pTree
 191                        ,wxArrayTreeItemIds& raSelections
 192                       )
 193                       : wxTreeTraversal(pTree)
 194                       , m_aSelections(raSelections)
 195     {
 196         m_aSelections.Empty();
 197         DoTraverse(pTree->GetRootItem());
 198     }
 199
 200     virtual bool OnVisit(const wxTreeItemId& rItem)
 201     {
 202         //
 203         // Can't visit a virtual node.
 204         //
 205         if ((GetTree()->GetRootItem() == rItem) && (GetTree()->GetWindowStyle() & wxTR_HIDE_ROOT))
 206         {
 207             return true;
 208         }
 209         PMYRECORD                   pRecord = FindOS2TreeRecordByID( (HWND)GetTree()->GetHWND()
 210                                                                     ,rItem.m_pItem
 211                                                                    );
 212         if (pRecord->m_vRecord.flRecordAttr & CRA_SELECTED)
 213         {
 214             m_aSelections.Add(rItem);
 215         }
 216         return true;
 217     }
 218
 219     size_t GetCount(void) const { return m_aSelections.GetCount(); }
 220
 221 private:
 222     wxArrayTreeItemIds&             m_aSelections;
 223 }; // end of CLASS TraverseSelections
 224
 225 //
 226 // Internal class for counting tree items
 227 //
 228 class TraverseCounter : public wxTreeTraversal
 229 {
 230 public:
 231     TraverseCounter( const wxTreeCtrl*   pTree
 232                     ,const wxTreeItemId& rRoot
 233                     ,bool                bRecursively
 234                    )
 235                    : wxTreeTraversal(pTree)
 236     {
 237         m_nCount = 0;
 238         DoTraverse(rRoot, bRecursively);
 239     }
 240
 241     virtual bool OnVisit(const wxTreeItemId& WXUNUSED(rItem))
 242     {
 243         m_nCount++;
 244         return true;
 245     }
 246
 247     size_t GetCount(void) const { return m_nCount; }
 248
 249 private:
 250     size_t                          m_nCount;
 251 }; // end of CLASS TraverseCounter
 252
 253 // ----------------------------------------------------------------------------
 254 // wxWin macros
 255 // ----------------------------------------------------------------------------
 256
 257 IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxControl)
 258
 259 // ----------------------------------------------------------------------------
 260 // constants
 261 // ----------------------------------------------------------------------------
 262
 263 // indices in gs_expandEvents table below
 264 enum
 265 {
 266     IDX_COLLAPSE,
 267     IDX_EXPAND,
 268     IDX_WHAT_MAX
 269 };
 270
 271 enum
 272 {
 273     IDX_DONE,
 274     IDX_DOING,
 275     IDX_HOW_MAX
 276 };
 277
 278 // handy table for sending events - it has to be initialized during run-time
 279 // now so can't be const any more
 280 static /* const */ wxEventType gs_expandEvents[IDX_WHAT_MAX][IDX_HOW_MAX];
 281
 282 /*
 283    but logically it's a const table with the following entries:
 284 =
 285 {
 286     { wxEVT_COMMAND_TREE_ITEM_COLLAPSED, wxEVT_COMMAND_TREE_ITEM_COLLAPSING },
 287     { wxEVT_COMMAND_TREE_ITEM_EXPANDED,  wxEVT_COMMAND_TREE_ITEM_EXPANDING  }
 288 };
 289 */
 290
 291 // ============================================================================
 292 // implementation
 293 // ============================================================================
 294
 295 // ----------------------------------------------------------------------------
 296 // tree traversal
 297 // ----------------------------------------------------------------------------
 298
 299 bool wxTreeTraversal::DoTraverse (
 300   const wxTreeItemId&               rRoot
 301 , bool                              bRecursively
 302 )
 303 {
 304     if (!OnVisit(rRoot))
 305         return false;
 306
 307     return Traverse( rRoot
 308                     ,bRecursively
 309                    );
 310 } // end of wxTreeTraversal::DoTraverse
 311
 312 bool wxTreeTraversal::Traverse (
 313   const wxTreeItemId&               rRoot
 314 , bool                              bRecursively
 315 )
 316 {
 317     long                            lCookie;
 318     wxTreeItemId                    vChild = m_pTree->GetFirstChild( rRoot
 319                                                                     ,lCookie
 320                                                                    );
 321     while (vChild.IsOk())
 322     {
 323         //
 324         // Depth first traversal
 325         //
 326         if (bRecursively && !Traverse(vChild, true))
 327             return false;
 328         if (!OnVisit(vChild))
 329             return false;
 330         vChild = m_pTree->GetNextChild( rRoot
 331                                        ,lCookie
 332                                       );
 333     }
 334     return true;
 335 } // end of wxTreeTraversal::Traverse
 336
 337 // ----------------------------------------------------------------------------
 338 // construction and destruction
 339 // ----------------------------------------------------------------------------
 340
 341 void wxTreeCtrl::Init ()
 342 {
 343     m_pImageListNormal     = NULL;
 344     m_pImageListState      = NULL;
 345     m_bOwnsImageListNormal = false;
 346     m_bOwnsImageListState  = false;
 347     m_bHasAnyAttr          = false;
 348     m_pDragImage           = NULL;
 349
 350     //
 351     // Initialize the global array of events now as it can't be done statically
 352     // with the wxEVT_XXX values being allocated during run-time only
 353     //
 354     gs_expandEvents[IDX_COLLAPSE][IDX_DONE]  = wxEVT_COMMAND_TREE_ITEM_COLLAPSED;
 355     gs_expandEvents[IDX_COLLAPSE][IDX_DOING] = wxEVT_COMMAND_TREE_ITEM_COLLAPSING;
 356     gs_expandEvents[IDX_EXPAND][IDX_DONE]    = wxEVT_COMMAND_TREE_ITEM_EXPANDED;
 357     gs_expandEvents[IDX_EXPAND][IDX_DOING]   = wxEVT_COMMAND_TREE_ITEM_EXPANDING;
 358 } // end of wxTreeCtrl::Init
 359
 360 bool wxTreeCtrl::Create (
 361   wxWindow*                         pParent
 362 , wxWindowID                        vId
 363 , const wxPoint&                    rPos
 364 , const wxSize&                     rSize
 365 , long                              lStyle
 366 , const wxValidator&                rValidator
 367 , const wxString&                   rsName
 368 )
 369 {
 370     CNRINFO                         vCnrInfo;
 371
 372     Init();
 373     if (!CreateControl( pParent
 374                        ,vId
 375                        ,rPos
 376                        ,rSize
 377                        ,lStyle
 378                        ,rValidator
 379                        ,rsName
 380                       ))
 381         return false;
 382
 383     DWORD                           dwStyle = WS_VISIBLE | WS_TABSTOP;
 384
 385     if (m_windowStyle & wxCLIP_SIBLINGS)
 386         dwStyle |= WS_CLIPSIBLINGS;
 387
 388     // Create the tree control.
 389     if (!OS2CreateControl( "CONTAINER"
 390                           ,dwStyle
 391                          ))
 392         return false;
 393
 394     //
 395     // Now set the display attributes to show a TREE/ICON view of the
 396     // OS/2 Container
 397     //
 398     if (!::WinSendMsg( GetHWND()
 399                       ,CM_QUERYCNRINFO
 400                       ,MPFROMP(&vCnrInfo)
 401                       ,(MPARAM)(USHORT)sizeof(CNRINFO)
 402                      ))
 403
 404     vCnrInfo.flWindowAttr = CV_TREE|CV_ICON;
 405     vCnrInfo.flWindowAttr |= CA_DRAWBITMAP;
 406     if (m_windowStyle & wxTR_NO_LINES)
 407         vCnrInfo.flWindowAttr |= CA_TREELINE;
 408
 409     ::WinSendMsg( GetHWND()
 410                  ,CM_SETCNRINFO
 411                  ,MPFROMP(&vCnrInfo)
 412                  ,(MPARAM)CMA_FLWINDOWATTR
 413                 );
 414
 415     SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
 416     SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
 417     SetFont(*wxSMALL_FONT);
 418     SetXComp(0);
 419     SetYComp(0);
 420     SetSize( rPos.x
 421             ,rPos.y
 422             ,rSize.x
 423             ,rSize.y
 424            );
 425     return true;
 426 } // end of wxTreeCtrl::Create
 427
 428 wxTreeCtrl::~wxTreeCtrl ()
 429 {
 430     //
 431     // Delete any attributes
 432     //
 433     if (m_bHasAnyAttr)
 434     {
 435         for (wxNode* pNode = m_vAttrs.Next(); pNode; pNode = m_vAttrs.Next())
 436         {
 437             delete (wxTreeItemAttr *)pNode->Data();
 438         }
 439         m_bHasAnyAttr = false;
 440     }
 441     DeleteTextCtrl();
 442
 443     //
 444     // Delete user data to prevent memory leaks
 445     // also deletes hidden root node storage.
 446     //
 447     DeleteAllItems();
 448     if (m_bOwnsImageListNormal)
 449         delete m_pImageListNormal;
 450     if (m_bOwnsImageListState)
 451         delete m_pImageListState;
 452 } // end of wxTreeCtrl::~wxTreeCtrl
 453
 454 // ----------------------------------------------------------------------------
 455 // accessors
 456 // ----------------------------------------------------------------------------
 457
 458 //
 459 // simple wrappers which add error checking in debug mode.  These methods
 460 // assume the items are properly filled out already.  If not, you get errors
 461 //
 462 bool wxTreeCtrl::DoGetItem (
 463   wxTreeViewItem*                   pTvItem
 464 ) const
 465 {
 466     PMYRECORD                       pRecord = FindOS2TreeRecordByID( GetHWND()
 467                                                                     ,pTvItem->m_ulItemId
 468                                                                    );
 469
 470     if (!pRecord)
 471     {
 472         wxLogLastError(wxT("Item not obtained"));
 473         return false;
 474     }
 475     return true;
 476 } // end of wxTreeCtrl::DoGetItem
 477
 478 void wxTreeCtrl::DoSetItem (
 479   wxTreeViewItem*                   pTvItem
 480 )
 481 {
 482     //
 483     // Just invalidate the record to redisplay it
 484     //
 485     if (!::WinSendMsg( GetHWND()
 486                       ,CM_INVALIDATERECORD
 487                       ,MPFROMP(pTvItem)
 488                       ,MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION | CMA_TEXTCHANGED)
 489                      ));
 490     {
 491         wxLogLastError(wxT("CM_INVALIDATERECORD"));
 492     }
 493 } // end of wxTreeCtrl::DoSetItem
 494
 495 unsigned int wxTreeCtrl::GetCount () const
 496 {
 497     CNRINFO  vCnrInfo;
 498
 499     ::WinSendMsg( GetHWND()
 500                  ,CM_QUERYCNRINFO
 501                  ,MPFROMP(&vCnrInfo)
 502                  ,(MPARAM)(USHORT)sizeof(CNRINFO)
 503                 );
 504
 505     return (unsigned int)vCnrInfo.cRecords;
 506 } // end of wxTreeCtrl::GetCount
 507
 508 unsigned int wxTreeCtrl::GetIndent () const
 509 {
 510     CNRINFO                         vCnrInfo;
 511
 512     ::WinSendMsg( GetHWND()
 513                  ,CM_QUERYCNRINFO
 514                  ,MPFROMP(&vCnrInfo)
 515                  ,(MPARAM)(USHORT)sizeof(CNRINFO)
 516                 );
 517     return (unsigned int)vCnrInfo.cxTreeIndent;
 518 } // end of wxTreeCtrl::GetIndent
 519
 520 void wxTreeCtrl::SetIndent (
 521   unsigned int                  uIndent
 522 )
 523 {
 524     CNRINFO                         vCnrInfo;
 525
 526     ::WinSendMsg( GetHWND()
 527                  ,CM_QUERYCNRINFO
 528                  ,MPFROMP(&vCnrInfo)
 529                  ,(MPARAM)(USHORT)sizeof(CNRINFO)
 530                 );
 531     vCnrInfo.cxTreeIndent = (LONG)uIndent;
 532     ::WinSendMsg( GetHWND()
 533                  ,CM_SETCNRINFO
 534                  ,MPFROMP(&vCnrInfo)
 535                  ,(MPARAM)CMA_CXTREEINDENT
 536                 );
 537 } // end of wxTreeCtrl::SetIndent
 538
 539 wxImageList* wxTreeCtrl::GetImageList () const
 540 {
 541     return m_pImageListNormal;
 542 } // end of wxTreeCtrl::GetImageList
 543
 544 #if WXWIN_COMPATIBILITY_2_4
 545
 546 wxImageList* wxTreeCtrl::GetImageList(int nVal) const
 547 {
 548     return GetImageList();
 549 }
 550
 551 void wxTreeCtrl::SetImageList(wxImageList* pImageList, int nVal)
 552 {
 553     SetImageList(pImageList);
 554 }
 555
 556 int wxTreeCtrl::GetItemSelectedImage(const wxTreeItemId& rItem) const
 557 {
 558     return GetItemImage(rItem, wxTreeItemIcon_Selected);
 559 }
 560
 561 void wxTreeCtrl::SetItemSelectedImage(const wxTreeItemId& rItem, int nImage)
 562 {
 563     SetItemImage(rItem, nImage, wxTreeItemIcon_Selected);
 564 }
 565
 566 #endif // WXWIN_COMPATIBILITY_2_4
 567
 568 wxImageList* wxTreeCtrl::GetStateImageList () const
 569 {
 570     return m_pImageListNormal;
 571 } // end of wxTreeCtrl::GetStateImageList
 572
 573 //
 574 // The SETS of imagelists really do nothing under OS2 as a RECORDCORE
 575 // struct has the icon imbedded in it that it uses for the icon being
 576 // displayed via the TREEITEMDESC member.  Provided for interface
 577 // compatibility only
 578 //
 579 void wxTreeCtrl::SetAnyImageList (
 580   wxImageList*                      WXUNUSED(pImageList)
 581 , int                               WXUNUSED(nWhich)
 582 )
 583 {
 584 } // end of wxTreeCtrl::SetAnyImageList
 585
 586 void wxTreeCtrl::SetImageList (
 587   wxImageList*                      WXUNUSED(pImageList)
 588 )
 589 {
 590     if (m_bOwnsImageListNormal)
 591         delete m_pImageListNormal;
 592     m_bOwnsImageListNormal = false;
 593 } // end of wxTreeCtrl::SetImageList
 594
 595 void wxTreeCtrl::SetStateImageList (
 596   wxImageList*                      WXUNUSED(pImageList)
 597 )
 598 {
 599     if (m_bOwnsImageListState)
 600         delete m_pImageListState;
 601     m_bOwnsImageListState = false;
 602 } // end of wxTreeCtrl::SetStateImageList
 603
 604 void wxTreeCtrl::AssignImageList (
 605   wxImageList*                      WXUNUSED(pImageList)
 606 )
 607 {
 608     m_bOwnsImageListNormal = true;
 609 } // end of wxTreeCtrl::AssignImageList
 610
 611 void wxTreeCtrl::AssignStateImageList (
 612   wxImageList*                      WXUNUSED(pImageList)
 613 )
 614 {
 615     m_bOwnsImageListState = true;
 616 } // end of wxTreeCtrl::AssignStateImageList
 617
 618 size_t wxTreeCtrl::GetChildrenCount (
 619   const wxTreeItemId&               rItem
 620 , bool                              bRecursively
 621 ) const
 622 {
 623     TraverseCounter                 vCounter( this
 624                                              ,rItem
 625                                              ,bRecursively
 626                                             );
 627     return vCounter.GetCount() - 1;
 628 } // end of wxTreeCtrl::GetChildrenCount
 629
 630 // ----------------------------------------------------------------------------
 631 // control colours
 632 // ----------------------------------------------------------------------------
 633
 634 bool wxTreeCtrl::SetBackgroundColour (
 635   const wxColour&                   rColour
 636 )
 637 {
 638     ULONG                           ulColor = wxColourToRGB(rColour);
 639
 640     if ( !wxWindowBase::SetBackgroundColour(rColour) )
 641         return false;
 642     ::WinSetPresParam( GetHWND()
 643                       ,PP_BACKGROUNDCOLOR
 644                       ,sizeof(ULONG)
 645                       ,&ulColor
 646                      );
 647     return true;
 648 } // end of wxTreeCtrl::SetBackgroundColour
 649
 650 bool wxTreeCtrl::SetForegroundColour (
 651   const wxColour&                   rColour
 652 )
 653 {
 654     ULONG                           ulColor = wxColourToRGB(rColour);
 655
 656     if (!wxWindowBase::SetForegroundColour(rColour))
 657         return false;
 658     ::WinSetPresParam( GetHWND()
 659                       ,PP_FOREGROUNDCOLOR
 660                       ,sizeof(ULONG)
 661                       ,&ulColor
 662                      );
 663     return true;
 664 } // end of wxTreeCtrl::SetForegroundColour
 665
 666 // ----------------------------------------------------------------------------
 667 // Item access
 668 // ----------------------------------------------------------------------------
 669
 670 wxString wxTreeCtrl::GetItemText (
 671   const wxTreeItemId&               rItem
 672 ) const
 673 {
 674     wxChar                          zBuf[512];  // the size is arbitrary...
 675     wxTreeViewItem                  vTvItem(rItem);
 676
 677     if (!DoGetItem(&vTvItem))
 678     {
 679         //
 680         // Don't return some garbage which was on stack, but an empty string
 681         //
 682         zBuf[0] = wxT('\0');
 683     }
 684     else
 685         strcpy(zBuf, vTvItem.m_vRecord.pszTree);
 686     return wxString(zBuf);
 687 } // end of wxTreeCtrl::GetItemText
 688
 689 void wxTreeCtrl::SetItemText (
 690   const wxTreeItemId&               rItem
 691 , const wxString&                   rsText
 692 )
 693 {
 694     wxTreeViewItem                  vTvItem(rItem);
 695
 696     vTvItem.m_vRecord.pszTree = (wxChar *)rsText.c_str();  // conversion is ok
 697     DoSetItem(&vTvItem);
 698 } // end of wxTreeCtrl::SetItemText
 699
 700 //
 701 // These functions under OS/2 PM are not needed.  OS/2 containers in tree view
 702 // provide for storing a custom expanded and collapsed icons and selected
 703 // and non selected icons, natively.  For instance, by default, a disk display
 704 // will display a tree list of folder icons with "+" icons (collapsed) beside
 705 // those folder which contain child members.  Double clicking a folder changes
 706 // the closed folder icon to an open folder icon with hatched selection
 707 // highlighting indicating an ICON view container of the folder is open
 708 // elsewhere on the desktop.  So the below is not really needed, but we will
 709 // simply return the appropriate icon requested out of OS/2's native PM
 710 // data structures.
 711 //
 712 int wxTreeCtrl::DoGetItemImageFromData (
 713   const wxTreeItemId&               WXUNUSED(rItem)
 714 , wxTreeItemIcon                    nWhich
 715 ) const
 716 {
 717     //
 718     // Image handles stored in CNRINFO.
 719     //
 720     CNRINFO                         vCnrInfo;
 721
 722     ::WinSendMsg( GetHWND()
 723                  ,CM_QUERYCNRINFO
 724                  ,MPFROMP(&vCnrInfo)
 725                  ,(MPARAM)(USHORT)sizeof(CNRINFO)
 726                 );
 727
 728     //
 729     // We really only have two to chose from.  If not custom (set in CNRINFO
 730     // then return the handle to system bitmap).  OS/2 automatically provides
 731     // in_use and selected bitmaps/icons
 732     //
 733     switch(nWhich)
 734     {
 735         case wxTreeItemIcon_Normal:
 736             if (vCnrInfo.hbmCollapsed == NULLHANDLE)
 737                 return (int)::WinGetSysBitmap(HWND_DESKTOP, SBMP_TREEPLUS);
 738             return vCnrInfo.hbmCollapsed;
 739
 740
 741         case wxTreeItemIcon_Expanded:
 742             if (vCnrInfo.hbmExpanded == NULLHANDLE)
 743                 return (int)::WinGetSysBitmap(HWND_DESKTOP, SBMP_TREEMINUS);
 744             return vCnrInfo.hbmExpanded;
 745
 746         default:
 747             return vCnrInfo.hbmCollapsed;
 748     }
 749 }
 750
 751 void wxTreeCtrl::DoSetItemImageFromData (
 752   const wxTreeItemId&               WXUNUSED(rItem)
 753 , int                               nImage
 754 , wxTreeItemIcon                    nWhich
 755 ) const
 756 {
 757     //
 758     // Image handles stored in CNRINFO.
 759     //
 760     CNRINFO                         vCnrInfo;
 761
 762     ::WinSendMsg( GetHWND()
 763                  ,CM_QUERYCNRINFO
 764                  ,MPFROMP(&vCnrInfo)
 765                  ,(MPARAM)(USHORT)sizeof(CNRINFO)
 766                 );
 767     if (nWhich == wxTreeItemIcon_Normal)
 768          vCnrInfo.hbmCollapsed = (HBITMAP)nImage;
 769     if (nWhich == wxTreeItemIcon_Expanded)
 770         vCnrInfo.hbmExpanded = (HBITMAP)nImage;
 771     ::WinSendMsg( GetHWND()
 772                  ,CM_SETCNRINFO
 773                  ,MPFROMP(&vCnrInfo)
 774                  ,(MPARAM)CMA_TREEBITMAP
 775                 );
 776 } // end of wxTreeCtrl::DoSetItemImageFromData
 777
 778 // Useless for OS/2
 779 void wxTreeCtrl::DoSetItemImages (
 780   const wxTreeItemId&               rItem
 781 , int                               nImage
 782 , int                               nImageSel
 783 )
 784 {
 785 } // end of wxTreeCtrl::DoSetItemImages
 786
 787 int wxTreeCtrl::GetItemImage (
 788   const wxTreeItemId&               rItem
 789 , wxTreeItemIcon                    nWhich
 790 ) const
 791 {
 792     if (HasIndirectData(rItem))
 793     {
 794         return DoGetItemImageFromData( rItem
 795                                       ,nWhich
 796                                      );
 797     }
 798
 799     CNRINFO                         vCnrInfo;
 800
 801     ::WinSendMsg( GetHWND()
 802                  ,CM_QUERYCNRINFO
 803                  ,MPFROMP(&vCnrInfo)
 804                  ,(MPARAM)(USHORT)sizeof(CNRINFO)
 805                 );
 806     switch (nWhich)
 807     {
 808         default:
 809             wxFAIL_MSG( wxT("unknown tree item image type") );
 810
 811         case wxTreeItemIcon_Normal:
 812             if (vCnrInfo.hbmCollapsed == NULLHANDLE)
 813                 return (int)::WinGetSysBitmap(HWND_DESKTOP, SBMP_TREEPLUS);
 814             return vCnrInfo.hbmCollapsed;
 815
 816
 817         case wxTreeItemIcon_Expanded:
 818             if (vCnrInfo.hbmExpanded == NULLHANDLE)
 819                 return (int)::WinGetSysBitmap(HWND_DESKTOP, SBMP_TREEMINUS);
 820             return vCnrInfo.hbmExpanded;
 821
 822         case wxTreeItemIcon_Selected:
 823         case wxTreeItemIcon_SelectedExpanded:
 824             return -1;
 825     }
 826 }
 827
 828 void wxTreeCtrl::SetItemImage (
 829   const wxTreeItemId&               WXUNUSED(rItem)
 830 , int                               nImage
 831 , wxTreeItemIcon                    nWhich
 832 )
 833 {
 834     CNRINFO                         vCnrInfo;
 835
 836     ::WinSendMsg( GetHWND()
 837                  ,CM_QUERYCNRINFO
 838                  ,MPFROMP(&vCnrInfo)
 839                  ,(MPARAM)(USHORT)sizeof(CNRINFO)
 840                 );
 841     switch (nWhich)
 842     {
 843         case wxTreeItemIcon_Normal:
 844             vCnrInfo.hbmCollapsed = (HBITMAP)nImage;
 845             break;
 846
 847         case wxTreeItemIcon_Expanded:
 848             vCnrInfo.hbmExpanded = (HBITMAP)nImage;
 849             break;
 850
 851         default:
 852             wxFAIL_MSG( wxT("unknown tree item image type") );
 853     }
 854     ::WinSendMsg( GetHWND()
 855                  ,CM_SETCNRINFO
 856                  ,MPFROMP(&vCnrInfo)
 857                  ,(MPARAM)CMA_TREEBITMAP
 858                 );
 859 } // end of wxTreeCtrl::SetItemImage
 860
 861 wxTreeItemData* wxTreeCtrl::GetItemData (
 862   const wxTreeItemId&               rItem
 863 ) const
 864 {
 865     wxTreeViewItem                  vTvItem(rItem);
 866
 867     if (!DoGetItem(&vTvItem))
 868     {
 869         return NULL;
 870     }
 871
 872     return (wxTreeItemData *)vTvItem.m_ulUserData;
 873 } // end of wxTreeCtrl::GetItemData
 874
 875 void wxTreeCtrl::SetItemData (
 876   const wxTreeItemId&               rItem
 877 , wxTreeItemData*                   pData
 878 )
 879 {
 880     //
 881     // first, associate this piece of data with this item
 882     if (pData)
 883     {
 884         pData->SetId(rItem);
 885     }
 886
 887     wxTreeViewItem                  vTvItem(rItem);
 888
 889     vTvItem.m_ulUserData = (ULONG)pData;
 890     DoSetItem(&vTvItem);
 891 } // end of wxTreeCtrl::SetItemData
 892
 893 // The following two do nothing under OS/2
 894 void wxTreeCtrl::SetIndirectItemData (
 895   const wxTreeItemId&               WXUNUSED(rItem)
 896 , wxTreeItemIndirectData*           WXUNUSED(pData)
 897 )
 898 {
 899 } // end of wxTreeCtrl::SetIndirectItemData
 900
 901 bool wxTreeCtrl::HasIndirectData (
 902   const wxTreeItemId&               WXUNUSED(rItem)
 903 ) const
 904 {
 905     return false;
 906 } // end of wxTreeCtrl::HasIndirectData
 907
 908 // Irreleveant under OS/2 --- item either has child records or it doesn't.
 909 void wxTreeCtrl::SetItemHasChildren (
 910   const wxTreeItemId&               WXUNUSED(rItem)
 911 , bool                              WXUNUSED(bHas)
 912 )
 913 {
 914 } // end of wxTreeCtrl::SetItemHasChildren
 915
 916 // Irreleveant under OS/2 --- function of the font in PM
 917 void wxTreeCtrl::SetItemBold (
 918   const wxTreeItemId&               WXUNUSED(rItem)
 919 , bool                              WXUNUSED(bBold)
 920 )
 921 {
 922 } // end of wxTreeCtrl::SetItemBold
 923
 924 void wxTreeCtrl::SetItemDropHighlight (
 925   const wxTreeItemId&               rItem
 926 , bool                              bHighlight
 927 )
 928 {
 929     wxTreeViewItem                  vTvItem(rItem);
 930
 931     ::WinSendMsg( GetHWND()
 932                  ,CM_SETRECORDEMPHASIS
 933                  ,MPFROMP(&vTvItem)
 934                  ,MPFROM2SHORT(bHighlight, CRA_SELECTED)
 935                 );
 936     DoSetItem(&vTvItem);
 937 } // end of wxTreeCtrl::SetItemDropHighlight
 938
 939 void wxTreeCtrl::RefreshItem (
 940   const wxTreeItemId&               rItem
 941 )
 942 {
 943     wxTreeViewItem                  vTvItem(rItem);
 944
 945     //
 946     // This just does a record invalidate causing it to be re-displayed
 947     //
 948     DoSetItem(&vTvItem);
 949 } // end of wxTreeCtrl::RefreshItem
 950
 951 wxColour wxTreeCtrl::GetItemTextColour (
 952   const wxTreeItemId&               rItem
 953 ) const
 954 {
 955     long                            lId = (long)rItem.m_pItem;
 956     wxTreeItemAttr*                 pAttr = (wxTreeItemAttr *)m_vAttrs.Get(lId);
 957
 958     if (!pAttr)
 959     {
 960         return wxNullColour;
 961     }
 962     return pAttr->GetTextColour();
 963 } // end of wxTreeCtrl::GetItemTextColour
 964
 965 wxColour wxTreeCtrl::GetItemBackgroundColour (
 966   const wxTreeItemId&               rItem
 967 ) const
 968 {
 969     long                            lId = (long)rItem.m_pItem;
 970     wxTreeItemAttr*                 pAttr = (wxTreeItemAttr *)m_vAttrs.Get(lId);
 971
 972     if (!pAttr)
 973     {
 974         return wxNullColour;
 975     }
 976     return pAttr->GetBackgroundColour();
 977 } // end of wxTreeCtrl::GetItemBackgroundColour
 978
 979 wxFont wxTreeCtrl::GetItemFont (
 980   const wxTreeItemId&               rItem
 981 ) const
 982 {
 983     long                            lId = (long)rItem.m_pItem;
 984     wxTreeItemAttr*                 pAttr = (wxTreeItemAttr *)m_vAttrs.Get(lId);
 985
 986     if (!pAttr)
 987     {
 988         return wxNullFont;
 989     }
 990     return pAttr->GetFont();
 991 } // end of wxTreeCtrl::GetItemFont
 992
 993 void wxTreeCtrl::SetItemTextColour (
 994   const wxTreeItemId&               rItem
 995 , const wxColour&                   rCol
 996 )
 997 {
 998     m_bHasAnyAttr = true;
 999
1000     long                            lId = (long)rItem.m_pItem;
1001     wxTreeItemAttr*                 pAttr = (wxTreeItemAttr *)m_vAttrs.Get(lId);
1002
1003     if (!pAttr)
1004     {
1005         pAttr = new wxTreeItemAttr;
1006         m_vAttrs.Put(lId, (wxObject *)pAttr);
1007     }
1008     pAttr->SetTextColour(rCol);
1009     RefreshItem(rItem);
1010 } // end of wxTreeCtrl::SetItemTextColour
1011
1012 void wxTreeCtrl::SetItemBackgroundColour (
1013   const wxTreeItemId&               rItem
1014 , const wxColour&                   rCol
1015 )
1016 {
1017     m_bHasAnyAttr = true;
1018
1019     long                            lId = (long)rItem.m_pItem;
1020     wxTreeItemAttr*                 pAttr = (wxTreeItemAttr *)m_vAttrs.Get(lId);
1021
1022     if (!pAttr)
1023     {
1024         pAttr = new wxTreeItemAttr;
1025         m_vAttrs.Put(lId, (wxObject *)pAttr);
1026     }
1027     pAttr->SetBackgroundColour(rCol);
1028     RefreshItem(rItem);
1029 } // end of wxTreeCtrl::SetItemBackgroundColour
1030
1031 void wxTreeCtrl::SetItemFont (
1032   const wxTreeItemId&               rItem
1033 , const wxFont&                     rFont
1034 )
1035 {
1036     m_bHasAnyAttr = true;
1037
1038     long                            lId = (long)rItem.m_pItem;
1039     wxTreeItemAttr*                 pAttr = (wxTreeItemAttr *)m_vAttrs.Get(lId);
1040
1041     if (!pAttr)
1042     {
1043         pAttr = new wxTreeItemAttr;
1044         m_vAttrs.Put(lId, (wxObject *)pAttr);
1045     }
1046     pAttr->SetFont(rFont);
1047     RefreshItem(rItem);
1048 } // end of wxTreeCtrl::SetItemFont
1049
1050 // ----------------------------------------------------------------------------
1051 // Item status
1052 // ----------------------------------------------------------------------------
1053
1054 bool wxTreeCtrl::IsVisible (
1055   const wxTreeItemId&               rItem
1056 ) const
1057 {
1058     // Bug in Gnu-Win32 headers, so don't use the macro TreeView_GetItemRect
1059     RECTL                           vRectRecord;
1060     RECTL                           vRectContainer;
1061     wxRect                          vWxRectRecord;
1062     wxRect                          vWxRectContainer;
1063     PMYRECORD                       pRecord = FindOS2TreeRecordByID ( GetHWND()
1064                                                                      ,rItem.m_pItem
1065                                                                     );
1066     QUERYRECORDRECT                 vQuery;
1067
1068     vQuery.cb                = sizeof(QUERYRECORDRECT);
1069     vQuery.pRecord           = (PRECORDCORE)pRecord;
1070     vQuery.fRightSplitWindow = FALSE;
1071     vQuery.fsExtent          = CMA_TREEICON;
1072
1073     ::WinSendMsg( GetHWND()
1074                  ,CM_QUERYVIEWPORTRECT
1075                  ,MPFROMP(&vRectContainer)
1076                  ,MPFROM2SHORT(CMA_WINDOW, FALSE)
1077                 );
1078     ::WinSendMsg( GetHWND()
1079                  ,CM_QUERYRECORDRECT
1080                  ,MPFROMP(&vRectRecord)
1081                  ,MPFROMP(&vQuery)
1082                 );
1083     vWxRectRecord.SetLeft(vRectRecord.xLeft);
1084     vWxRectRecord.SetTop(vRectRecord.yTop);
1085     vWxRectRecord.SetRight(vRectRecord.xRight);
1086     vWxRectRecord.SetBottom(vRectRecord.yBottom);
1087
1088     vWxRectContainer.SetLeft(vRectContainer.xLeft);
1089     vWxRectContainer.SetTop(vRectContainer.yTop);
1090     vWxRectContainer.SetRight(vRectContainer.xRight);
1091     vWxRectContainer.SetBottom(vRectContainer.yBottom);
1092     return (vWxRectContainer.Inside(wxPoint(vWxRectRecord.x, vWxRectRecord.y)));
1093 } // end of wxTreeCtrl::IsVisible
1094
1095 bool wxTreeCtrl::ItemHasChildren (
1096   const wxTreeItemId&               rItem
1097 ) const
1098 {
1099     wxTreeViewItem                  vTvItem(rItem);
1100     DoGetItem(&vTvItem);
1101
1102     //
1103     // A tree record with children will have one of these attributes
1104     //
1105     return (vTvItem.m_vRecord.flRecordAttr & CRA_EXPANDED ||
1106             vTvItem.m_vRecord.flRecordAttr & CRA_COLLAPSED) != 0;
1107 }
1108
1109 bool wxTreeCtrl::IsExpanded (
1110   const wxTreeItemId&               rItem
1111 ) const
1112 {
1113     wxTreeViewItem                  vTvItem(rItem);
1114     DoGetItem(&vTvItem);
1115
1116     return (vTvItem.m_vRecord.flRecordAttr & CRA_EXPANDED) != 0;
1117 } // end of wxTreeCtrl::IsExpanded
1118
1119 bool wxTreeCtrl::IsSelected (
1120   const wxTreeItemId&               rItem
1121 ) const
1122 {
1123     wxTreeViewItem                  vTvItem(rItem);
1124     DoGetItem(&vTvItem);
1125
1126     return (vTvItem.m_vRecord.flRecordAttr & CRA_SELECTED) != 0;
1127 } // end of wxTreeCtrl::IsSelected
1128
1129 // Not supported
1130 bool wxTreeCtrl::IsBold (
1131   const wxTreeItemId&               rItem
1132 ) const
1133 {
1134     return false;
1135 } // end of wxTreeCtrl::IsBold
1136
1137 // ----------------------------------------------------------------------------
1138 // navigation
1139 // ----------------------------------------------------------------------------
1140
1141 wxTreeItemId wxTreeCtrl::GetRootItem () const
1142 {
1143     PMYRECORD                       pRecord = NULL;
1144
1145     pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( GetHWND()
1146                                                   ,CM_QUERYRECORD
1147                                                   ,MPFROMP(pRecord)
1148                                                   ,MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER)
1149                                                  ));
1150
1151     if (!pRecord)
1152         return wxTreeItemId(-1L);
1153     return wxTreeItemId((long)pRecord->m_ulItemId);
1154 } // end of wxTreeCtrl::GetRootItem
1155
1156 wxTreeItemId wxTreeCtrl::GetSelection () const
1157 {
1158     wxCHECK_MSG( !(m_windowStyle & wxTR_MULTIPLE), (long)(WXHTREEITEM)0,
1159                  wxT("this only works with single selection controls") );
1160
1161     PMYRECORD                       pRecord = NULL;
1162
1163     pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( GetHWND()
1164                                                   ,CM_QUERYRECORDEMPHASIS
1165                                                   ,MPARAM(CMA_FIRST)
1166                                                   ,MPARAM(CRA_SELECTED)
1167                                                  ));
1168     if (!pRecord)
1169         return wxTreeItemId(-1L);
1170     return wxTreeItemId((long)pRecord->m_ulItemId);
1171 } // end of wxTreeCtrl::GetSelection
1172
1173 wxTreeItemId wxTreeCtrl::GetItemParent (
1174   const wxTreeItemId&               rItem
1175 ) const
1176 {
1177     PMYRECORD                       pRecord = FindOS2TreeRecordByID ( GetHWND()
1178                                                                      ,rItem.m_pItem
1179                                                                     );
1180
1181     if (!pRecord)
1182         return wxTreeItemId(-1L);
1183     pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( GetHWND()
1184                                                   ,CM_QUERYRECORD
1185                                                   ,MPFROMP(pRecord)
1186                                                   ,MPFROM2SHORT(CMA_PARENT, CMA_ITEMORDER)
1187                                                  ));
1188     if (!pRecord)
1189         return wxTreeItemId(-1L);
1190     return wxTreeItemId((long)pRecord->m_ulItemId);
1191 } // end of wxTreeCtrl::GetItemParent
1192
1193 wxTreeItemId wxTreeCtrl::GetFirstChild (
1194   const wxTreeItemId&               rItem
1195 , long&                             rCookie
1196 ) const
1197 {
1198     PMYRECORD                       pRecord = FindOS2TreeRecordByID ( GetHWND()
1199                                                                      ,rItem.m_pItem
1200                                                                     );
1201
1202     if (!pRecord)
1203         return wxTreeItemId(-1L);
1204     pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( GetHWND()
1205                                                   ,CM_QUERYRECORD
1206                                                   ,MPFROMP(pRecord)
1207                                                   ,MPFROM2SHORT(CMA_FIRSTCHILD, CMA_ITEMORDER)
1208                                                  ));
1209     if (!pRecord)
1210         return wxTreeItemId(-1L);
1211     //
1212     // Remember the last child returned in 'cookie'
1213     //
1214     rCookie = (long)pRecord->m_ulItemId;
1215     return wxTreeItemId(rCookie);
1216 } // end of wxTreeCtrl::GetFirstChild
1217
1218 wxTreeItemId wxTreeCtrl::GetNextChild (
1219   const wxTreeItemId&               WXUNUSED(rItem)
1220 , long&                             rCookie
1221 ) const
1222 {
1223     PMYRECORD                       pRecord = FindOS2TreeRecordByID ( GetHWND()
1224                                                                      ,rCookie
1225                                                                     );
1226
1227     if (!pRecord)
1228         return wxTreeItemId(-1L);
1229     pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( GetHWND()
1230                                                   ,CM_QUERYRECORD
1231                                                   ,MPFROMP(pRecord)
1232                                                   ,MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER)
1233                                                  ));
1234     if (!pRecord)
1235         return wxTreeItemId(-1L);
1236     rCookie = (long)pRecord->m_ulItemId;
1237     return wxTreeItemId(rCookie);
1238 } // end of wxTreeCtrl::GetNextChild
1239
1240 wxTreeItemId wxTreeCtrl::GetLastChild (
1241   const wxTreeItemId&               rItem
1242 ) const
1243 {
1244     PMYRECORD                       pRecord = FindOS2TreeRecordByID ( GetHWND()
1245                                                                      ,rItem.m_pItem
1246                                                                     );
1247
1248     if (!pRecord)
1249         return wxTreeItemId(-1L);
1250     pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( GetHWND()
1251                                                   ,CM_QUERYRECORD
1252                                                   ,MPFROMP(pRecord)
1253                                                   ,MPFROM2SHORT(CMA_LASTCHILD, CMA_ITEMORDER)
1254                                                  ));
1255     if (!pRecord)
1256         return wxTreeItemId(-1L);
1257     return wxTreeItemId((long)pRecord->m_ulItemId);
1258 } // end of wxTreeCtrl::GetLastChild
1259
1260 wxTreeItemId wxTreeCtrl::GetNextSibling (
1261   const wxTreeItemId&               rItem
1262 ) const
1263 {
1264     PMYRECORD                       pRecord = FindOS2TreeRecordByID ( GetHWND()
1265                                                                      ,rItem.m_pItem
1266                                                                     );
1267
1268     if (!pRecord)
1269         return wxTreeItemId(-1L);
1270     pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( GetHWND()
1271                                                   ,CM_QUERYRECORD
1272                                                   ,MPFROMP(pRecord)
1273                                                   ,MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER)
1274                                                  ));
1275     if (!pRecord)
1276         return wxTreeItemId(-1L);
1277     return wxTreeItemId((long)pRecord->m_ulItemId);
1278 } // end of wxTreeCtrl::GetNextSibling
1279
1280 wxTreeItemId wxTreeCtrl::GetPrevSibling (
1281   const wxTreeItemId&               rItem
1282 ) const
1283 {
1284     PMYRECORD                       pRecord = FindOS2TreeRecordByID ( GetHWND()
1285                                                                      ,rItem.m_pItem
1286                                                                     );
1287
1288     if (!pRecord)
1289         return wxTreeItemId(-1L);
1290     pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( GetHWND()
1291                                                   ,CM_QUERYRECORD
1292                                                   ,MPFROMP(pRecord)
1293                                                   ,MPFROM2SHORT(CMA_PREV, CMA_ITEMORDER)
1294                                                  ));
1295     if (!pRecord)
1296         return wxTreeItemId(-1L);
1297     return wxTreeItemId((long)pRecord->m_ulItemId);
1298 } // end of wxTreeCtrl::GetPrevSibling
1299
1300 wxTreeItemId wxTreeCtrl::GetFirstVisibleItem () const
1301 {
1302     PMYRECORD                       pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( GetHWND()
1303                                                                                   ,CM_QUERYRECORD
1304                                                                                   ,MPFROMP(pRecord)
1305                                                                                   ,MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER)
1306                                                                                  ));
1307     if (!pRecord)
1308         return wxTreeItemId(-1L);
1309
1310     if (IsVisible(wxTreeItemId((long)pRecord->m_ulItemId)))
1311         return wxTreeItemId((long)pRecord->m_ulItemId);
1312     while(pRecord)
1313     {
1314         pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( GetHWND()
1315                                                       ,CM_QUERYRECORD
1316                                                       ,MPFROMP(pRecord)
1317                                                       ,MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER)
1318                                                      ));
1319         if (!pRecord)
1320             return wxTreeItemId(-1L);
1321         if (IsVisible(wxTreeItemId((long)pRecord->m_ulItemId)))
1322             return wxTreeItemId((long)pRecord->m_ulItemId);
1323     }
1324     return wxTreeItemId(-1L);
1325 } // end of wxTreeCtrl::GetFirstVisibleItem
1326
1327 wxTreeItemId wxTreeCtrl::GetNextVisible (
1328   const wxTreeItemId&               rItem
1329 ) const
1330 {
1331     wxASSERT_MSG(IsVisible(rItem), wxT("The item you call GetNextVisible() for must be visible itself!"));
1332
1333     PMYRECORD                       pRecord = FindOS2TreeRecordByID ( GetHWND()
1334                                                                      ,rItem.m_pItem
1335                                                                     );
1336
1337     if (!pRecord)
1338         return wxTreeItemId(-1L);
1339     while(pRecord)
1340     {
1341         pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( GetHWND()
1342                                                       ,CM_QUERYRECORD
1343                                                       ,MPFROMP(pRecord)
1344                                                       ,MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER)
1345                                                      ));
1346         if (!pRecord)
1347             return wxTreeItemId(-1L);
1348         if (IsVisible(wxTreeItemId((long)pRecord->m_ulItemId)))
1349             return wxTreeItemId((long)pRecord->m_ulItemId);
1350     }
1351     return wxTreeItemId(-1L);
1352 } // end of wxTreeCtrl::GetNextVisible
1353
1354 wxTreeItemId wxTreeCtrl::GetPrevVisible (
1355   const wxTreeItemId&               rItem
1356 ) const
1357 {
1358     wxASSERT_MSG( IsVisible(rItem), wxT("The item you call GetPrevVisible() for must be visible itself!"));
1359
1360     PMYRECORD                       pRecord = FindOS2TreeRecordByID ( GetHWND()
1361                                                                      ,rItem.m_pItem
1362                                                                     );
1363
1364     if (!pRecord)
1365         return wxTreeItemId(-1L);
1366     while(pRecord)
1367     {
1368         pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( GetHWND()
1369                                                       ,CM_QUERYRECORD
1370                                                       ,MPFROMP(pRecord)
1371                                                       ,MPFROM2SHORT(CMA_PREV, CMA_ITEMORDER)
1372                                                      ));
1373         if (!pRecord)
1374             return wxTreeItemId(-1L);
1375         if (IsVisible(wxTreeItemId((long)pRecord->m_ulItemId)))
1376             return wxTreeItemId((long)pRecord->m_ulItemId);
1377     }
1378     return wxTreeItemId(-1L);
1379 } // end of wxTreeCtrl::GetPrevVisible
1380
1381 // ----------------------------------------------------------------------------
1382 // multiple selections emulation -- under OS/2 checked tree items is not
1383 // supported, but multisel is.  So we'll just check for selections here.
1384 // ----------------------------------------------------------------------------
1385
1386 bool wxTreeCtrl::IsItemChecked (
1387   const wxTreeItemId&               rItem
1388 ) const
1389 {
1390     wxTreeViewItem                  vTvItem(rItem);
1391
1392     DoGetItem(&vTvItem);
1393     return (vTvItem.m_vRecord.flRecordAttr & CRA_SELECTED);
1394 } // end of wxTreeCtrl::IsItemChecked
1395
1396 void wxTreeCtrl::SetItemCheck (
1397   const wxTreeItemId&               rItem
1398 , bool                              bCheck
1399 )
1400 {
1401     wxTreeViewItem                  vTvItem(rItem);
1402
1403     DoGetItem(&vTvItem);
1404     ::WinSendMsg( GetHWND()
1405                  ,CM_SETRECORDEMPHASIS
1406                  ,MPFROMP(&vTvItem)
1407                  ,MPFROM2SHORT(TRUE, CRA_SELECTED)
1408                 );
1409     DoSetItem(&vTvItem);
1410 } // end of wxTreeCtrl::SetItemCheck
1411
1412 size_t wxTreeCtrl::GetSelections (
1413   wxArrayTreeItemIds&               raSelections
1414 ) const
1415 {
1416     TraverseSelections              vSelector( this
1417                                               ,raSelections
1418                                              );
1419     return vSelector.GetCount();
1420 } // end of wxTreeCtrl::GetSelections
1421
1422 // ----------------------------------------------------------------------------
1423 // Usual operations
1424 // ----------------------------------------------------------------------------
1425
1426 wxTreeItemId wxTreeCtrl::DoInsertItem (
1427   const wxTreeItemId&               rParent
1428 , wxTreeItemId                      vInsertAfter
1429 , const wxString&                   rsText
1430 , int                               nImage
1431 , int                               selectedImage
1432 , wxTreeItemData*                   pData
1433 )
1434 {
1435     PMYRECORD                       pRecordAfter = FindOS2TreeRecordByID( GetHWND()
1436                                                                          ,vInsertAfter.m_pItem
1437                                                                         );
1438
1439     PMYRECORD                       pRecordParent = FindOS2TreeRecordByID( GetHWND()
1440                                                                           ,rParent.m_pItem
1441                                                                          );
1442
1443     PMYRECORD                       pRecord = (PMYRECORD)::WinSendMsg( GetHWND()
1444                                                                       ,CM_ALLOCRECORD
1445                                                                       ,MPFROMLONG(sizeof(MYRECORD) - sizeof(RECORDCORE))
1446                                                                       ,MPFROMLONG(1)
1447                                                                      );
1448     RECORDINSERT                    vInsert;
1449
1450     vInsert.cb                = sizeof(RECORDINSERT);
1451     if (rParent.m_pItem == 0L)
1452     {
1453         if (vInsertAfter.m_pItem == -1)
1454             vInsert.pRecordOrder      = (PRECORDCORE)CMA_END;
1455         else
1456             vInsert.pRecordOrder      = (PRECORDCORE)CMA_FIRST;
1457         vInsert.pRecordParent     = NULL;
1458     }
1459     else
1460     {
1461         if (vInsertAfter.m_pItem == 0)
1462             vInsert.pRecordOrder      = (PRECORDCORE)CMA_FIRST;
1463         else if (vInsertAfter.m_pItem == -1)
1464             vInsert.pRecordOrder      = (PRECORDCORE)CMA_END;
1465         else
1466             vInsert.pRecordOrder  = (PRECORDCORE)pRecordAfter;
1467         vInsert.pRecordParent     = (PRECORDCORE)pRecordParent;
1468     }
1469     vInsert.fInvalidateRecord = TRUE;
1470     vInsert.zOrder            = CMA_TOP;
1471     vInsert.cRecordsInsert    = 1;
1472
1473     pRecord->m_vRecord.pszTree   = (wxChar*)rsText.c_str();
1474     pRecord->m_vRecord.hbmBitmap = nImage;
1475     pRecord->m_ulItemId = pRecordAfter->m_ulItemId + 1;
1476     if (pData != NULL)
1477     {
1478         pRecord->m_ulUserData = (ULONG)pData;
1479     }
1480     ::WinSendMsg( GetHWND()
1481                  ,CM_INSERTRECORD
1482                  ,MPFROMP(pRecord)
1483                  ,MPFROMP(&vInsert)
1484                 );
1485
1486     //
1487     // OS/2 must mannually bump the index's of following records
1488     //
1489     BumpTreeRecordIds( GetHWND()
1490                   ,pRecord
1491                  );
1492     if (pData != NULL)
1493     {
1494         //
1495         // Associate the application tree item with PM tree item handle
1496         //
1497         pData->SetId((long)pRecord->m_ulItemId);
1498     }
1499     return wxTreeItemId((long)pRecord->m_ulItemId);
1500 }
1501
1502 #if WXWIN_COMPATIBILITY_2_4
1503
1504 // for compatibility only
1505 wxTreeItemId wxTreeCtrl::InsertItem (
1506   const wxTreeItemId&               rParent
1507 , const wxString&                   rsText
1508 , int                               nImage
1509 , int                               nSelImage
1510 , long                              lInsertAfter
1511 )
1512 {
1513     return DoInsertItem( rParent
1514                         ,wxTreeItemId(lInsertAfter)
1515                         ,rsText
1516                         ,nImage
1517                         ,nSelImage
1518                         ,NULL
1519                        );
1520 } // end of wxTreeCtrl::InsertItem
1521
1522 #endif // WXWIN_COMPATIBILITY_2_4
1523
1524 wxTreeItemId wxTreeCtrl::AddRoot (
1525   const wxString&                   rsText
1526 , int                               nImage
1527 , int                               nSelectedImage
1528 , wxTreeItemData*                   pData)
1529 {
1530
1531     return DoInsertItem( wxTreeItemId((long)0)
1532                         ,wxTreeItemId((long)-1)
1533                         ,rsText
1534                         ,nImage
1535                         ,nSelectedImage
1536                         ,pData
1537                        );
1538 } // end of wxTreeCtrl::AddRoot
1539
1540 wxTreeItemId wxTreeCtrl::PrependItem (
1541   const wxTreeItemId&               rParent
1542 , const wxString&                   rsText
1543 , int                               nImage
1544 , int                               nSelectedImage
1545 , wxTreeItemData*                   pData
1546 )
1547 {
1548     return DoInsertItem( rParent
1549                         ,wxTreeItemId((long)0)
1550                         ,rsText
1551                         ,nImage
1552                         ,nSelectedImage
1553                         ,pData
1554                        );
1555 } // end of wxTreeCtrl::PrependItem
1556
1557 wxTreeItemId wxTreeCtrl::InsertItem (
1558   const wxTreeItemId&               rParent
1559 , const wxTreeItemId&               rIdPrevious
1560 , const wxString&                   rsText
1561 , int                               nImage
1562 , int                               nSelectedImage
1563 , wxTreeItemData*                   pData
1564 )
1565 {
1566     return DoInsertItem( rParent
1567                         ,rIdPrevious
1568                         ,rsText
1569                         ,nImage
1570                         ,nSelectedImage
1571                         ,pData
1572                        );
1573 } // end of wxTreeCtrl::InsertItem
1574
1575 wxTreeItemId wxTreeCtrl::InsertItem (
1576   const wxTreeItemId&               rParent
1577 , size_t                            nIndex
1578 , const wxString&                   rsText
1579 , int                               nImage
1580 , int                               nSelectedImage
1581 , wxTreeItemData*                   pData
1582 )
1583 {
1584     return DoInsertItem( rParent
1585                         ,wxTreeItemId((long)nIndex)
1586                         ,rsText
1587                         ,nImage
1588                         ,nSelectedImage
1589                         ,pData
1590                        );
1591 } // end of wxTreeCtrl::InsertItem
1592
1593 wxTreeItemId wxTreeCtrl::AppendItem (
1594   const wxTreeItemId&               rParent
1595 , const wxString&                   rsText
1596 , int                               nImage
1597 , int                               nSelectedImage
1598 , wxTreeItemData*                   pData
1599 )
1600 {
1601     return DoInsertItem( rParent
1602                         ,wxTreeItemId((long)-1)
1603                         ,rsText
1604                         ,nImage
1605                         ,nSelectedImage
1606                         ,pData
1607                        );
1608 } // end of wxTreeCtrl::AppendItem
1609
1610 void wxTreeCtrl::Delete (
1611   const wxTreeItemId&               rItem
1612 )
1613 {
1614     //
1615     // OS/2 does not generate DELETEITEM events so do it here
1616     //
1617     wxEventType                     vEventType = wxEVT_NULL;
1618     wxTreeEvent                     vEvent( wxEVT_NULL
1619                                            ,m_windowId
1620                                           );
1621     PMYRECORD                       pRecord = FindOS2TreeRecordByID( GetHWND()
1622                                                                     ,rItem.m_pItem
1623                                                                    );
1624     vEvent.SetEventObject(this);
1625     ::WinSendMsg( GetHWND()
1626                  ,CM_REMOVERECORD
1627                  ,MPFROMP(pRecord)
1628                  ,(MPARAM)(CMA_FREE | CMA_INVALIDATE)
1629                 );
1630     vEvent.m_item = rItem.m_pItem;
1631     if (m_bHasAnyAttr)
1632     {
1633         delete (wxTreeItemAttr *)m_vAttrs.Delete((long)rItem.m_pItem);
1634     }
1635     vEvent.SetEventType(vEventType);
1636     GetEventHandler()->ProcessEvent(vEvent);
1637 } // end of wxTreeCtrl::Delete
1638
1639 // delete all children (but don't delete the item itself)
1640 void wxTreeCtrl::DeleteChildren (
1641   const wxTreeItemId&               rItem
1642 )
1643 {
1644     long                            lCookie;
1645     wxArrayLong                     aChildren;
1646     wxTreeItemId                    vChild = GetFirstChild( rItem
1647                                                            ,lCookie
1648                                                           );
1649
1650     while (vChild.IsOk())
1651     {
1652         aChildren.Add((long)(WXHTREEITEM)vChild);
1653         vChild = GetNextChild( rItem
1654                               ,lCookie
1655                              );
1656     }
1657
1658     size_t                          nCount = aChildren.Count();
1659
1660     for (size_t n = 0; n < nCount; n++)
1661     {
1662         Delete(aChildren[n]);
1663     }
1664 } // end of wxTreeCtrl::DeleteChildren
1665
1666 void wxTreeCtrl::DeleteAllItems ()
1667 {
1668     ::WinSendMsg( GetHWND()
1669                  ,CM_REMOVERECORD
1670                  ,NULL                // Remove all
1671                  ,(MPARAM)(CMA_FREE | CMA_INVALIDATE)
1672                 );
1673 } // end of wxTreeCtrl::DeleteAllItems
1674
1675 void wxTreeCtrl::DoExpand (
1676   const wxTreeItemId&               rItem
1677 , int                               nFlag
1678 )
1679 {
1680     PMYRECORD                       pRecord = FindOS2TreeRecordByID( GetHWND()
1681                                                                     ,rItem.m_pItem
1682                                                                    );
1683     switch(nFlag)
1684     {
1685         case wxTREE_EXPAND_EXPAND:
1686             ::WinSendMsg( GetHWND()
1687                          ,CM_EXPANDTREE
1688                          ,MPFROMP(pRecord)
1689                          ,NULL
1690                         );
1691             break;
1692
1693         case wxTREE_EXPAND_COLLAPSE:
1694             ::WinSendMsg( GetHWND()
1695                          ,CM_COLLAPSETREE
1696                          ,MPFROMP(pRecord)
1697                          ,NULL
1698                         );
1699             break;
1700
1701         case wxTREE_EXPAND_COLLAPSE_RESET:
1702             ::WinSendMsg( GetHWND()
1703                          ,CM_COLLAPSETREE
1704                          ,MPFROMP(pRecord)
1705                          ,NULL
1706                         );
1707             DeleteChildren(rItem);
1708             break;
1709
1710         case wxTREE_EXPAND_TOGGLE:
1711             if (pRecord->m_vRecord.flRecordAttr & CRA_COLLAPSED)
1712                 ::WinSendMsg( GetHWND()
1713                              ,CM_EXPANDTREE
1714                              ,MPFROMP(pRecord)
1715                              ,NULL
1716                             );
1717             else if (pRecord->m_vRecord.flRecordAttr & CRA_EXPANDED)
1718                 ::WinSendMsg( GetHWND()
1719                              ,CM_COLLAPSETREE
1720                              ,MPFROMP(pRecord)
1721                              ,NULL
1722                             );
1723             break;
1724
1725     }
1726 } // end of wxTreeCtrl::DoExpand
1727
1728 void wxTreeCtrl::Expand (
1729   const wxTreeItemId&               rItem
1730 )
1731 {
1732     DoExpand( rItem
1733              ,wxTREE_EXPAND_EXPAND
1734             );
1735 } // end of wxTreeCtrl::Expand
1736
1737 void wxTreeCtrl::Collapse (
1738   const wxTreeItemId&               rItem
1739 )
1740 {
1741     DoExpand( rItem
1742              ,wxTREE_EXPAND_COLLAPSE
1743             );
1744 } // end of wxTreeCtrl::Collapse
1745
1746 void wxTreeCtrl::CollapseAndReset (
1747   const wxTreeItemId&               rItem
1748 )
1749 {
1750     DoExpand( rItem
1751              ,wxTREE_EXPAND_COLLAPSE_RESET
1752             );
1753 } // end of wxTreeCtrl::CollapseAndReset
1754
1755 void wxTreeCtrl::Toggle (
1756   const wxTreeItemId&               rItem
1757 )
1758 {
1759     DoExpand( rItem
1760              ,wxTREE_EXPAND_TOGGLE
1761             );
1762 } // end of wxTreeCtrl::Toggle
1763
1764 #if WXWIN_COMPATIBILITY_2_4
1765
1766 void wxTreeCtrl::ExpandItem (
1767   const wxTreeItemId&               rItem
1768 , int                               nAction
1769 )
1770 {
1771     DoExpand( rItem
1772              ,nAction
1773             );
1774 } // end of wxTreeCtrl::ExpandItem
1775
1776 #endif // WXWIN_COMPATIBILITY_2_4
1777
1778 void wxTreeCtrl::Unselect ()
1779 {
1780     wxASSERT_MSG( !(m_windowStyle & wxTR_MULTIPLE),
1781                   wxT("doesn't make sense, may be you want UnselectAll()?") );
1782
1783     //
1784     // Just remove the selection
1785     //
1786     SelectItem(wxTreeItemId((long)0));
1787 } // end of wxTreeCtrl::Unselect
1788
1789 void wxTreeCtrl::UnselectAll ()
1790 {
1791     if (m_windowStyle & wxTR_MULTIPLE)
1792     {
1793         wxArrayTreeItemIds          aSelections;
1794         size_t                      nCount = GetSelections(aSelections);
1795
1796         for (size_t n = 0; n < nCount; n++)
1797         {
1798             SetItemCheck( aSelections[n]
1799                          ,false
1800                         );
1801         }
1802     }
1803     else
1804     {
1805         //
1806         // Just remove the selection
1807         //
1808         Unselect();
1809     }
1810 } // end of wxTreeCtrl::UnselectAll
1811
1812 void wxTreeCtrl::SelectItem (
1813   const wxTreeItemId&               rItem
1814 )
1815 {
1816     SetItemCheck(rItem);
1817 } // end of wxTreeCtrl::SelectItem
1818
1819 void wxTreeCtrl::EnsureVisible (
1820   const wxTreeItemId&               rItem
1821 )
1822 {
1823     wxTreeViewItem                  vTvItem(rItem);
1824
1825     DoGetItem(&vTvItem);
1826     if (!::WinSendMsg( GetHWND()
1827                       ,CM_INVALIDATERECORD
1828                       ,MPFROMP(&vTvItem)
1829                       ,MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION | CMA_TEXTCHANGED)
1830                      ));
1831 } // end of wxTreeCtrl::EnsureVisible
1832
1833 void wxTreeCtrl::ScrollTo (
1834   const wxTreeItemId&               rItem
1835 )
1836 {
1837     wxTreeViewItem                  vTvItem(rItem);
1838
1839     DoGetItem(&vTvItem);
1840     if (!::WinSendMsg( GetHWND()
1841                       ,CM_INVALIDATERECORD
1842                       ,MPFROMP(&vTvItem)
1843                       ,MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION | CMA_TEXTCHANGED)
1844                      ));
1845 }
1846
1847 wxTextCtrl* wxTreeCtrl::EditLabel (
1848   const wxTreeItemId&               rItem
1849 , wxClassInfo*                      WXUNUSED(pTextControlClass)
1850 )
1851 {
1852     CNREDITDATA                     vEdit;
1853     PMYRECORD                       pRecord = FindOS2TreeRecordByID( GetHWND()
1854                                                                     ,rItem.m_pItem
1855                                                                    );
1856
1857     vEdit.cb         = sizeof(CNREDITDATA);
1858     vEdit.hwndCnr    = GetHWND();
1859     vEdit.pRecord    = &pRecord->m_vRecord;
1860     vEdit.pFieldInfo = NULL;
1861     vEdit.ppszText   = NULL;
1862     vEdit.cbText     = 0;
1863     vEdit.id         = 0;
1864
1865     ::WinSendMsg( GetHWND()
1866                  ,CM_OPENEDIT
1867                  ,MPFROMP(&vEdit)
1868                  ,(MPARAM)0
1869                 );
1870     return NULL;
1871 } // end of wxTreeCtrl::EditLabel
1872
1873 // End label editing, optionally cancelling the edit
1874 void wxTreeCtrl::EndEditLabel (
1875   const wxTreeItemId&               WXUNUSED(rItem)
1876 , bool                              WXUNUSED(bDiscardChanges)
1877 )
1878 {
1879     ::WinSendMsg( GetHWND()
1880                  ,CM_CLOSEEDIT
1881                  ,(MPARAM)0
1882                  ,(MPARAM)0
1883                 );
1884 } // end of wxTreeCtrl::EndEditLabel
1885
1886 wxTreeItemId wxTreeCtrl::HitTest (
1887   const wxPoint&                    rPoint
1888 , int&                              WXUNUSED(rFlags)
1889 )
1890 {
1891     PMYRECORD                       pRecord = NULL;
1892     QUERYRECFROMRECT                vQueryRect;
1893     RECTL                           vRect;
1894     long                            lHeight;
1895
1896     //
1897     // Get height for OS/2 point conversion
1898     //
1899     ::WinSendMsg( GetHWND()
1900                  ,CM_QUERYVIEWPORTRECT
1901                  ,MPFROMP(&vRect)
1902                  ,MPFROM2SHORT(CMA_WINDOW, TRUE)
1903                 );
1904     lHeight = vRect.yTop - vRect.yBottom;
1905
1906     //
1907     // For now just try and get a record in the general vicinity and forget
1908     // the flag
1909     //
1910     vRect.xLeft   = rPoint.x - 2;
1911     vRect.xRight  = rPoint.x + 2;
1912     vRect.yTop    = (lHeight - rPoint.y) + 2;
1913     vRect.yBottom = (lHeight - rPoint.y) - 2;
1914
1915     vQueryRect.cb = sizeof(QUERYRECFROMRECT);
1916     vQueryRect.rect = vRect;
1917     vQueryRect.fsSearch = CMA_PARTIAL;
1918
1919     pRecord = (PMYRECORD)::WinSendMsg( GetHWND()
1920                                       ,CM_QUERYRECORDFROMRECT
1921                                       ,(MPARAM)CMA_FIRST
1922                                       ,MPFROMP(&vQueryRect)
1923                                     );
1924
1925     if (!pRecord)
1926         return -1L;
1927     return wxTreeItemId((long)pRecord->m_ulItemId);
1928 } // end of wxTreeCtrl::HitTest
1929
1930 bool wxTreeCtrl::GetBoundingRect (
1931   const wxTreeItemId&               rItem
1932 , wxRect&                           rRect
1933 , bool                              bTextOnly
1934 ) const
1935 {
1936     RECTL                           vRectRecord;
1937     PMYRECORD                       pRecord = FindOS2TreeRecordByID ( GetHWND()
1938                                                                      ,rItem.m_pItem
1939                                                                     );
1940     QUERYRECORDRECT                 vQuery;
1941
1942     vQuery.cb                = sizeof(QUERYRECORDRECT);
1943     vQuery.pRecord           = (PRECORDCORE)pRecord;
1944     vQuery.fRightSplitWindow = FALSE;
1945     if (bTextOnly)
1946         vQuery.fsExtent          = CMA_TEXT;
1947     else
1948         vQuery.fsExtent          = CMA_TREEICON | CMA_TEXT;
1949
1950     if (!::WinSendMsg( GetHWND()
1951                       ,CM_QUERYRECORDRECT
1952                       ,MPFROMP(&vRectRecord)
1953                       ,MPFROMP(&vQuery)
1954                      ))
1955         return false;
1956     rRect.SetLeft(vRectRecord.xLeft);
1957     rRect.SetTop(vRectRecord.yTop);
1958     rRect.SetRight(vRectRecord.xRight);
1959     rRect.SetBottom(vRectRecord.yBottom);
1960     return true;
1961 } // end of wxTreeCtrl::GetBoundingRect
1962
1963 // ----------------------------------------------------------------------------
1964 // sorting stuff
1965 // ----------------------------------------------------------------------------
1966
1967 SHORT EXPENTRY InternalDataCompareTreeFunc (
1968   PMYRECORD                         p1
1969 , PMYRECORD                         p2
1970 , PVOID                             pStorage
1971 )
1972 {
1973     wxCHECK_MSG( p1 && p2, 0,
1974                  wxT("sorting tree without data doesn't make sense") );
1975
1976     wxTreeCtrl*                     pTree = (wxTreeCtrl*)pStorage;
1977
1978     return pTree->OnCompareItems( p1->m_ulItemId
1979                                  ,p2->m_ulItemId
1980                                 );
1981 } // end of wxTreeSortHelper::Compare
1982
1983 int wxTreeCtrl::OnCompareItems (
1984   const wxTreeItemId&               rItem1
1985 , const wxTreeItemId&               rItem2
1986 )
1987 {
1988     return wxStrcmp( GetItemText(rItem1)
1989                     ,GetItemText(rItem2)
1990                    );
1991 } // end of wxTreeCtrl::OnCompareItems
1992
1993 void wxTreeCtrl::SortChildren (
1994   const wxTreeItemId&               rItem
1995 )
1996 {
1997     ::WinSendMsg( GetHWND()
1998                  ,CM_SORTRECORD
1999                  ,(PFN)InternalDataCompareTreeFunc
2000                  ,NULL
2001                 );
2002 } // end of wxTreeCtrl::SortChildren
2003
2004 // ----------------------------------------------------------------------------
2005 // implementation
2006 // ----------------------------------------------------------------------------
2007
2008 bool wxTreeCtrl::OS2Command (
2009   WXUINT                            uCmd
2010 , WXWORD                            wId
2011 )
2012 {
2013     if (uCmd == CN_ENDEDIT)
2014     {
2015         wxCommandEvent              vEvent( wxEVT_COMMAND_TEXT_UPDATED
2016                                            ,wId
2017                                           );
2018
2019         vEvent.SetEventObject( this );
2020         ProcessCommand(vEvent);
2021         return true;
2022     }
2023     else if (uCmd == CN_KILLFOCUS)
2024     {
2025         wxCommandEvent              vEvent( wxEVT_KILL_FOCUS
2026                                            ,wId
2027                                           );
2028         vEvent.SetEventObject( this );
2029         ProcessCommand(vEvent);
2030         return true;
2031     }
2032     else
2033         return false;
2034 } // end of wxTreeCtrl::OS2Command
2035
2036 //
2037 // TODO:  Fully implement direct manipulation when I figure it out
2038 //
2039 MRESULT wxTreeCtrl::OS2WindowProc (
2040   WXUINT                            uMsg
2041 , WXWPARAM                          wParam
2042 , WXLPARAM                          lParam
2043 )
2044 {
2045     bool                            bProcessed = false;
2046     MRESULT                         mRc = 0;
2047     wxTreeEvent                     vEvent( wxEVT_NULL
2048                                            ,m_windowId
2049                                           );
2050     wxEventType                     vEventType = wxEVT_NULL;
2051     PCNRDRAGINIT                    pDragInit = NULL;
2052     PCNREDITDATA                    pEditData = NULL;
2053     PNOTIFYRECORDENTER              pNotifyEnter = NULL;
2054
2055     vEvent.SetEventObject(this);
2056     switch (uMsg)
2057     {
2058         case WM_CONTROL:
2059             switch(SHORT2FROMMP(wParam))
2060             {
2061                 case CN_INITDRAG:
2062                     pDragInit = (PCNRDRAGINIT)lParam;
2063                     if (pDragInit)
2064                     {
2065                         PMYRECORD       pRecord = (PMYRECORD)pDragInit->pRecord;
2066
2067                         vEventType = wxEVT_COMMAND_TREE_BEGIN_DRAG;
2068                         vEvent.m_item        = pRecord->m_ulItemId;
2069                         vEvent.m_pointDrag.x = pDragInit->x;
2070                         vEvent.m_pointDrag.y = pDragInit->y;
2071                     }
2072                     break;
2073
2074                 case CN_BEGINEDIT:
2075                     pEditData = (PCNREDITDATA)lParam;
2076                     if (pEditData)
2077                     {
2078                         PMYRECORD       pRecord = (PMYRECORD)pEditData->pRecord;
2079
2080                         vEventType = wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT;
2081                         vEvent.m_item = pRecord->m_ulItemId;
2082                         vEvent.m_label = pRecord->m_vRecord.pszTree;
2083                         vEvent.m_editCancelled = false;
2084                     }
2085                     break;
2086
2087                 case CN_ENDEDIT:
2088                     pEditData = (PCNREDITDATA)lParam;
2089                     if (pEditData)
2090                     {
2091                         PMYRECORD       pRecord = (PMYRECORD)pEditData->pRecord;
2092
2093                         vEventType = wxEVT_COMMAND_TREE_END_LABEL_EDIT;
2094                         vEvent.m_item = pRecord->m_ulItemId;
2095                         vEvent.m_label = pRecord->m_vRecord.pszTree;
2096                         if (pRecord->m_vRecord.pszTree == NULL)
2097                         {
2098                             vEvent.m_editCancelled = true;
2099                         }
2100                         else
2101                         {
2102                             vEvent.m_editCancelled = false;
2103                         }
2104                     }
2105                     break;
2106
2107                 case CN_EXPANDTREE:
2108                     {
2109                         PMYRECORD       pRecord = (PMYRECORD)lParam;
2110
2111                         vEventType = gs_expandEvents[IDX_EXPAND][IDX_DONE];
2112                         vEvent.m_item = pRecord->m_ulItemId;
2113                     }
2114                     break;
2115             }
2116             vEvent.SetEventType(vEventType);
2117             bProcessed = GetEventHandler()->ProcessEvent(vEvent);
2118             break;
2119     }
2120     if (!bProcessed)
2121         mRc = wxControl::OS2WindowProc( uMsg
2122                                        ,wParam
2123                                        ,lParam
2124                                       );
2125     return mRc;
2126 } // end of wxTreeCtrl::OS2WindowProc
2127
2128 #endif // wxUSE_TREECTRL