src/msw/headerctrl.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/headerctrl.cpp
   3 // Purpose:     implementation of wxHeaderCtrl for wxMSW
   4 // Author:      Vadim Zeitlin
   5 // Created:     2008-12-01
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2008 Vadim Zeitlin <vadim@wxwidgets.org>
   8 // Licence:     wxWindows licence
   9 ///////////////////////////////////////////////////////////////////////////////
  10
  11 // ============================================================================
  12 // declarations
  13 // ============================================================================
  14
  15 // ----------------------------------------------------------------------------
  16 // headers
  17 // ----------------------------------------------------------------------------
  18
  19 // for compilers that support precompilation, includes "wx.h".
  20 #include "wx/wxprec.h"
  21
  22 #ifdef __BORLANDC__
  23     #pragma hdrstop
  24 #endif
  25
  26 #if wxUSE_HEADERCTRL
  27
  28 #ifndef WX_PRECOMP
  29     #include "wx/log.h"
  30 #endif // WX_PRECOMP
  31
  32 #include "wx/headerctrl.h"
  33
  34 #ifndef wxHAS_GENERIC_HEADERCTRL
  35
  36 #include "wx/imaglist.h"
  37
  38 #include "wx/msw/wrapcctl.h"
  39 #include "wx/msw/private.h"
  40
  41 // from src/msw/listctrl.cpp
  42 extern int WXDLLIMPEXP_CORE wxMSWGetColumnClicked(NMHDR *nmhdr, POINT *ptClick);
  43
  44 // ============================================================================
  45 // wxHeaderCtrl implementation
  46 // ============================================================================
  47
  48 // ----------------------------------------------------------------------------
  49 // wxHeaderCtrl construction/destruction
  50 // ----------------------------------------------------------------------------
  51
  52 void wxHeaderCtrl::Init()
  53 {
  54     m_numColumns = 0;
  55     m_imageList = NULL;
  56     m_scrollOffset = 0;
  57 }
  58
  59 bool wxHeaderCtrl::Create(wxWindow *parent,
  60                           wxWindowID id,
  61                           const wxPoint& pos,
  62                           const wxSize& size,
  63                           long style,
  64                           const wxString& name)
  65 {
  66     // notice that we don't need InitCommonControlsEx(ICC_LISTVIEW_CLASSES)
  67     // here as we already call InitCommonControls() in wxApp initialization
  68     // code which covers this
  69
  70     if ( !CreateControl(parent, id, pos, size, style, wxDefaultValidator, name) )
  71         return false;
  72
  73     if ( !MSWCreateControl(WC_HEADER, _T(""), pos, size) )
  74         return false;
  75
  76     return true;
  77 }
  78
  79 WXDWORD wxHeaderCtrl::MSWGetStyle(long style, WXDWORD *exstyle) const
  80 {
  81     WXDWORD msStyle = wxControl::MSWGetStyle(style, exstyle);
  82
  83     if ( style & wxHD_ALLOW_REORDER )
  84         msStyle |= HDS_DRAGDROP;
  85
  86     // the control looks nicer with these styles and there doesn't seem to be
  87     // any reason to not use them so we always do (as for HDS_HORZ it is 0
  88     // anyhow but include it for clarity)
  89     msStyle |= HDS_HORZ | HDS_BUTTONS | HDS_FLAT | HDS_FULLDRAG | HDS_HOTTRACK;
  90
  91     return msStyle;
  92 }
  93
  94 wxHeaderCtrl::~wxHeaderCtrl()
  95 {
  96     delete m_imageList;
  97 }
  98
  99 // ----------------------------------------------------------------------------
 100 // wxHeaderCtrl scrolling
 101 // ----------------------------------------------------------------------------
 102
 103 void wxHeaderCtrl::DoSetSize(int x, int y,
 104                              int w, int h,
 105                              int sizeFlags)
 106 {
 107     wxHeaderCtrlBase::DoSetSize(x + m_scrollOffset, y, w - m_scrollOffset, h,
 108                                 sizeFlags);
 109 }
 110
 111 void wxHeaderCtrl::DoScrollHorz(int dx)
 112 {
 113     // as the native control doesn't support offsetting its contents, we use a
 114     // hack here to make it appear correctly when the parent is scrolled:
 115     // instead of scrolling or repainting we simply move the control window
 116     // itself: to be precise, offset it by the scroll increment to the left and
 117     // increment its width to still extend to the right boundary to compensate
 118     // for it (notice that dx is negative when scrolling to the right)
 119     m_scrollOffset += dx;
 120
 121     wxHeaderCtrlBase::DoSetSize(GetPosition().x + dx, -1,
 122                                 GetSize().x - dx, -1,
 123                                 wxSIZE_USE_EXISTING);
 124 }
 125
 126 // ----------------------------------------------------------------------------
 127 // wxHeaderCtrl geometry calculation
 128 // ----------------------------------------------------------------------------
 129
 130 wxSize wxHeaderCtrl::DoGetBestSize() const
 131 {
 132     RECT rc = wxGetClientRect(GetHwndOf(GetParent()));
 133     WINDOWPOS wpos;
 134     HDLAYOUT layout = { &rc, &wpos };
 135     if ( !Header_Layout(GetHwnd(), &layout) )
 136     {
 137         wxLogLastError(_T("Header_Layout"));
 138         return wxControl::DoGetBestSize();
 139     }
 140
 141     return wxSize(wpos.cx, wpos.cy);
 142 }
 143
 144 // ----------------------------------------------------------------------------
 145 // wxHeaderCtrl columns managements
 146 // ----------------------------------------------------------------------------
 147
 148 unsigned int wxHeaderCtrl::DoGetCount() const
 149 {
 150     // we can't use Header_GetItemCount() here because it doesn't take the
 151     // hidden columns into account and we can't find the hidden columns after
 152     // the last shown one in MSWFromNativeIdx() without knowing where to stop
 153     // so we have to store the columns count internally
 154     return m_numColumns;
 155 }
 156
 157 int wxHeaderCtrl::GetShownColumnsCount() const
 158 {
 159     const int numItems = Header_GetItemCount(GetHwnd());
 160
 161     wxASSERT_MSG( numItems >= 0 && (unsigned)numItems <= m_numColumns,
 162                   "unexpected number of items in the native control" );
 163
 164     return numItems;
 165 }
 166
 167 void wxHeaderCtrl::DoSetCount(unsigned int count)
 168 {
 169     unsigned n;
 170
 171     // first delete all old columns
 172     const unsigned countOld = GetShownColumnsCount();
 173     for ( n = 0; n < countOld; n++ )
 174     {
 175         if ( !Header_DeleteItem(GetHwnd(), 0) )
 176         {
 177             wxLogLastError(_T("Header_DeleteItem"));
 178         }
 179     }
 180
 181     // update the column indices order array before changing m_numColumns
 182     DoResizeColumnIndices(m_colIndices, count);
 183
 184     // and add the new ones
 185     m_numColumns = count;
 186     m_isHidden.resize(m_numColumns);
 187     for ( n = 0; n < count; n++ )
 188     {
 189         const wxHeaderColumn& col = GetColumn(n);
 190         if ( col.IsShown() )
 191         {
 192             m_isHidden[n] = false;
 193
 194             DoInsertItem(col, n);
 195         }
 196         else // hidden initially
 197         {
 198             m_isHidden[n] = true;
 199         }
 200     }
 201 }
 202
 203 void wxHeaderCtrl::DoUpdate(unsigned int idx)
 204 {
 205     // the native control does provide Header_SetItem() but it's inconvenient
 206     // to use it because it sends HDN_ITEMCHANGING messages and we'd have to
 207     // arrange not to block setting the width from there and the logic would be
 208     // more complicated as we'd have to reset the old values as well as setting
 209     // the new ones -- so instead just recreate the column
 210
 211     const wxHeaderColumn& col = GetColumn(idx);
 212     if ( col.IsHidden() )
 213     {
 214         // column is hidden now
 215         if ( !m_isHidden[idx] )
 216         {
 217             // but it wasn't hidden before, so remove it
 218             Header_DeleteItem(GetHwnd(), MSWToNativeIdx(idx));
 219
 220             m_isHidden[idx] = true;
 221         }
 222         //else: nothing to do, updating hidden column doesn't have any effect
 223     }
 224     else // column is shown now
 225     {
 226         if ( m_isHidden[idx] )
 227         {
 228             m_isHidden[idx] = false;
 229         }
 230         else // and it was shown before as well
 231         {
 232             // we need to remove the old column
 233             Header_DeleteItem(GetHwnd(), MSWToNativeIdx(idx));
 234         }
 235
 236         DoInsertItem(col, idx);
 237     }
 238 }
 239
 240 void wxHeaderCtrl::DoInsertItem(const wxHeaderColumn& col, unsigned int idx)
 241 {
 242     wxASSERT_MSG( !col.IsHidden(), "should only be called for shown columns" );
 243
 244     wxHDITEM hdi;
 245
 246     // notice that we need to store the string we use the pointer to until we
 247     // pass it to the control
 248     hdi.mask |= HDI_TEXT;
 249     wxWxCharBuffer buf = col.GetTitle().wx_str();
 250     hdi.pszText = buf.data();
 251     hdi.cchTextMax = wxStrlen(buf);
 252
 253     const wxBitmap bmp = col.GetBitmap();
 254     if ( bmp.IsOk() )
 255     {
 256         hdi.mask |= HDI_IMAGE;
 257
 258         if ( bmp.IsOk() )
 259         {
 260             const int bmpWidth = bmp.GetWidth(),
 261                       bmpHeight = bmp.GetHeight();
 262
 263             if ( !m_imageList )
 264             {
 265                 m_imageList = new wxImageList(bmpWidth, bmpHeight);
 266                 Header_SetImageList(GetHwnd(), GetHimagelistOf(m_imageList));
 267             }
 268             else // already have an image list
 269             {
 270                 // check that all bitmaps we use have the same size
 271                 int imageWidth,
 272                     imageHeight;
 273                 m_imageList->GetSize(0, imageWidth, imageHeight);
 274
 275                 wxASSERT_MSG( imageWidth == bmpWidth && imageHeight == bmpHeight,
 276                               "all column bitmaps must have the same size" );
 277             }
 278
 279             m_imageList->Add(bmp);
 280             hdi.iImage = m_imageList->GetImageCount() - 1;
 281         }
 282         else // no bitmap but we still need to update the item
 283         {
 284             hdi.iImage = I_IMAGENONE;
 285         }
 286     }
 287
 288     if ( col.GetAlignment() != wxALIGN_NOT )
 289     {
 290         hdi.mask |= HDI_FORMAT;
 291         switch ( col.GetAlignment() )
 292         {
 293             case wxALIGN_LEFT:
 294                 hdi.fmt |= HDF_LEFT;
 295                 break;
 296
 297             case wxALIGN_CENTER:
 298             case wxALIGN_CENTER_HORIZONTAL:
 299                 hdi.fmt |= HDF_CENTER;
 300                 break;
 301
 302             case wxALIGN_RIGHT:
 303                 hdi.fmt |= HDF_RIGHT;
 304                 break;
 305
 306             default:
 307                 wxFAIL_MSG( "invalid column header alignment" );
 308         }
 309     }
 310
 311     if ( col.IsSortKey() )
 312     {
 313         hdi.mask |= HDI_FORMAT;
 314         hdi.fmt |= col.IsSortOrderAscending() ? HDF_SORTUP : HDF_SORTDOWN;
 315     }
 316
 317     if ( col.GetWidth() != wxCOL_WIDTH_DEFAULT )
 318     {
 319         hdi.mask |= HDI_WIDTH;
 320         hdi.cxy = col.GetWidth();
 321     }
 322
 323     hdi.mask |= HDI_ORDER;
 324     hdi.iOrder = MSWToNativeOrder(m_colIndices.Index(idx));
 325
 326     if ( ::SendMessage(GetHwnd(), HDM_INSERTITEM,
 327                        MSWToNativeIdx(idx), (LPARAM)&hdi) == -1 )
 328     {
 329         wxLogLastError(_T("Header_InsertItem()"));
 330     }
 331 }
 332
 333 void wxHeaderCtrl::DoSetColumnsOrder(const wxArrayInt& order)
 334 {
 335     wxArrayInt orderShown;
 336     orderShown.reserve(m_numColumns);
 337
 338     for ( unsigned n = 0; n < m_numColumns; n++ )
 339     {
 340         const int idx = order[n];
 341         if ( GetColumn(idx).IsShown() )
 342             orderShown.push_back(MSWToNativeIdx(idx));
 343     }
 344
 345     if ( !Header_SetOrderArray(GetHwnd(), orderShown.size(), &orderShown[0]) )
 346     {
 347         wxLogLastError(_T("Header_GetOrderArray"));
 348     }
 349
 350     m_colIndices = order;
 351 }
 352
 353 wxArrayInt wxHeaderCtrl::DoGetColumnsOrder() const
 354 {
 355     // we don't use Header_GetOrderArray() here because it doesn't return
 356     // information about the hidden columns, instead we just save the columns
 357     // order array in DoSetColumnsOrder() and update it when they're reordered
 358     return m_colIndices;
 359 }
 360
 361 // ----------------------------------------------------------------------------
 362 // wxHeaderCtrl indexes and positions translation
 363 // ----------------------------------------------------------------------------
 364
 365 int wxHeaderCtrl::MSWToNativeIdx(int idx)
 366 {
 367     // don't check for GetColumn(idx).IsShown() as it could have just became
 368     // false and we may be called from DoUpdate() to delete the old column
 369     wxASSERT_MSG( !m_isHidden[idx],
 370                   "column must be visible to have an "
 371                   "index in the native control" );
 372
 373     int item = idx;
 374     for ( int i = 0; i < idx; i++ )
 375     {
 376         if ( GetColumn(i).IsHidden() )
 377             item--; // one less column the native control knows about
 378     }
 379
 380     wxASSERT_MSG( item >= 0 && item <= GetShownColumnsCount(), "logic error" );
 381
 382     return item;
 383 }
 384
 385 int wxHeaderCtrl::MSWFromNativeIdx(int item)
 386 {
 387     wxASSERT_MSG( item >= 0 && item < GetShownColumnsCount(),
 388                   "column index out of range" );
 389
 390     // reverse the above function
 391
 392     unsigned idx = item;
 393     for ( unsigned n = 0; n < m_numColumns; n++ )
 394     {
 395         if ( n > idx )
 396             break;
 397
 398         if ( GetColumn(n).IsHidden() )
 399             idx++;
 400     }
 401
 402     wxASSERT_MSG( MSWToNativeIdx(idx) == item, "logic error" );
 403
 404     return idx;
 405 }
 406
 407 int wxHeaderCtrl::MSWToNativeOrder(int pos)
 408 {
 409     wxASSERT_MSG( pos >= 0 && static_cast<unsigned>(pos) < m_numColumns,
 410                   "column position out of range" );
 411
 412     int order = pos;
 413     for ( int n = 0; n < pos; n++ )
 414     {
 415         if ( GetColumn(m_colIndices[n]).IsHidden() )
 416             order--;
 417     }
 418
 419     wxASSERT_MSG( order >= 0 && order <= GetShownColumnsCount(), "logic error" );
 420
 421     return order;
 422 }
 423
 424 int wxHeaderCtrl::MSWFromNativeOrder(int order)
 425 {
 426     wxASSERT_MSG( order >= 0 && order < GetShownColumnsCount(),
 427                   "native column position out of range" );
 428
 429     unsigned pos = order;
 430     for ( unsigned n = 0; n < m_numColumns; n++ )
 431     {
 432         if ( n > pos )
 433             break;
 434
 435         if ( GetColumn(m_colIndices[n]).IsHidden() )
 436             pos++;
 437     }
 438
 439     wxASSERT_MSG( MSWToNativeOrder(pos) == order, "logic error" );
 440
 441     return pos;
 442 }
 443
 444 // ----------------------------------------------------------------------------
 445 // wxHeaderCtrl events
 446 // ----------------------------------------------------------------------------
 447
 448 wxEventType wxHeaderCtrl::GetClickEventType(bool dblclk, int button)
 449 {
 450     wxEventType evtType;
 451     switch ( button )
 452     {
 453         case 0:
 454             evtType = dblclk ? wxEVT_COMMAND_HEADER_DCLICK
 455                              : wxEVT_COMMAND_HEADER_CLICK;
 456             break;
 457
 458         case 1:
 459             evtType = dblclk ? wxEVT_COMMAND_HEADER_RIGHT_DCLICK
 460                              : wxEVT_COMMAND_HEADER_RIGHT_CLICK;
 461             break;
 462
 463         case 2:
 464             evtType = dblclk ? wxEVT_COMMAND_HEADER_MIDDLE_DCLICK
 465                              : wxEVT_COMMAND_HEADER_MIDDLE_CLICK;
 466             break;
 467
 468         default:
 469             wxFAIL_MSG( wxS("unexpected event type") );
 470             evtType = wxEVT_NULL;
 471     }
 472
 473     return evtType;
 474 }
 475
 476 bool wxHeaderCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
 477 {
 478     NMHEADER * const nmhdr = (NMHEADER *)lParam;
 479
 480     wxEventType evtType = wxEVT_NULL;
 481     int width = 0;
 482     int order = -1;
 483     bool veto = false;
 484     const UINT code = nmhdr->hdr.code;
 485
 486     // we don't have the index for all events, e.g. not for NM_RELEASEDCAPTURE
 487     // so only access for header control events (and yes, the direction of
 488     // comparisons with FIRST/LAST is correct even if it seems inverted)
 489     int idx = code <= HDN_FIRST && code > HDN_LAST ? nmhdr->iItem : -1;
 490     if ( idx != -1 )
 491     {
 492         // we also get bogus HDN_BEGINDRAG with -1 index so don't call
 493         // MSWFromNativeIdx() unconditionally for nmhdr->iItem
 494         idx = MSWFromNativeIdx(idx);
 495     }
 496
 497     switch ( code )
 498     {
 499         // click events
 500         // ------------
 501
 502         case HDN_ITEMCLICK:
 503         case HDN_ITEMDBLCLICK:
 504             evtType = GetClickEventType(code == HDN_ITEMDBLCLICK, nmhdr->iButton);
 505             break;
 506
 507             // although we should get the notifications about the right clicks
 508             // via HDN_ITEM[DBL]CLICK too according to MSDN this simply doesn't
 509             // happen in practice on any Windows system up to 2003
 510         case NM_RCLICK:
 511         case NM_RDBLCLK:
 512             {
 513                 POINT pt;
 514                 idx = wxMSWGetColumnClicked(&nmhdr->hdr, &pt);
 515                 if ( idx != wxNOT_FOUND )
 516                 {
 517                     idx = MSWFromNativeIdx(idx);
 518                     evtType = GetClickEventType(code == NM_RDBLCLK, 1);
 519                 }
 520                 //else: ignore clicks outside any column
 521             }
 522             break;
 523
 524         case HDN_DIVIDERDBLCLICK:
 525             evtType = wxEVT_COMMAND_HEADER_SEPARATOR_DCLICK;
 526             break;
 527
 528
 529         // column resizing events
 530         // ----------------------
 531
 532         // see comments in wxListCtrl::MSWOnNotify() for why we catch both
 533         // ASCII and Unicode versions of this message
 534         case HDN_BEGINTRACKA:
 535         case HDN_BEGINTRACKW:
 536             // non-resizeable columns can't be resized no matter what, don't
 537             // even generate any events for them
 538             if ( !GetColumn(idx).IsResizeable() )
 539             {
 540                 veto = true;
 541                 break;
 542             }
 543
 544             evtType = wxEVT_COMMAND_HEADER_BEGIN_RESIZE;
 545             // fall through
 546
 547         case HDN_ENDTRACKA:
 548         case HDN_ENDTRACKW:
 549             width = nmhdr->pitem->cxy;
 550
 551             if ( evtType == wxEVT_NULL )
 552             {
 553                 evtType = wxEVT_COMMAND_HEADER_END_RESIZE;
 554
 555                 // don't generate events with invalid width
 556                 const int minWidth = GetColumn(idx).GetMinWidth();
 557                 if ( width < minWidth )
 558                     width = minWidth;
 559             }
 560             break;
 561
 562         case HDN_ITEMCHANGING:
 563             if ( nmhdr->pitem && (nmhdr->pitem->mask & HDI_WIDTH) )
 564             {
 565                 // prevent the column from being shrunk beneath its min width
 566                 width = nmhdr->pitem->cxy;
 567                 if ( width < GetColumn(idx).GetMinWidth() )
 568                 {
 569                     // don't generate any events and prevent the change from
 570                     // happening
 571                     veto = true;
 572                 }
 573                 else // width is acceptable
 574                 {
 575                     // generate the resizing event from here as we don't seem
 576                     // to be getting HDN_TRACK events at all, at least with
 577                     // comctl32.dll v6
 578                     evtType = wxEVT_COMMAND_HEADER_RESIZING;
 579                 }
 580             }
 581             break;
 582
 583
 584         // column reordering events
 585         // ------------------------
 586
 587         case HDN_BEGINDRAG:
 588             // Windows sometimes sends us events with invalid column indices
 589             if ( nmhdr->iItem == -1 )
 590                 break;
 591
 592             // column must have the appropriate flag to be draggable
 593             if ( !GetColumn(idx).IsReorderable() )
 594             {
 595                 veto = true;
 596                 break;
 597             }
 598
 599             evtType = wxEVT_COMMAND_HEADER_BEGIN_REORDER;
 600             break;
 601
 602         case HDN_ENDDRAG:
 603             wxASSERT_MSG( nmhdr->pitem->mask & HDI_ORDER, "should have order" );
 604             order = nmhdr->pitem->iOrder;
 605
 606             // we also get messages with invalid order when column reordering
 607             // is cancelled (e.g. by pressing Esc)
 608             if ( order == -1 )
 609                 break;
 610
 611             order = MSWFromNativeOrder(order);
 612
 613             evtType = wxEVT_COMMAND_HEADER_END_REORDER;
 614             break;
 615
 616         case NM_RELEASEDCAPTURE:
 617             evtType = wxEVT_COMMAND_HEADER_DRAGGING_CANCELLED;
 618             break;
 619     }
 620
 621
 622     // do generate the corresponding wx event
 623     if ( evtType != wxEVT_NULL )
 624     {
 625         wxHeaderCtrlEvent event(evtType, GetId());
 626         event.SetEventObject(this);
 627         event.SetColumn(idx);
 628         event.SetWidth(width);
 629         if ( order != -1 )
 630             event.SetNewOrder(order);
 631
 632         if ( GetEventHandler()->ProcessEvent(event) )
 633         {
 634             if ( event.IsAllowed() )
 635                 return true;    // skip default message handling below
 636
 637             // we need to veto the default handling of this message, don't
 638             // return to execute the code in the "if veto" branch below
 639             veto = true;
 640         }
 641         else // not processed
 642         {
 643             // special post-processing for HDN_ENDDRAG: we need to update the
 644             // internal column indices array if this is allowed to go ahead as
 645             // the native control is going to reorder its columns now
 646             if ( evtType == wxEVT_COMMAND_HEADER_END_REORDER )
 647                 MoveColumnInOrderArray(m_colIndices, idx, order);
 648         }
 649     }
 650
 651     if ( veto )
 652     {
 653         // all of HDN_BEGIN{DRAG,TRACK}, HDN_TRACK and HDN_ITEMCHANGING
 654         // interpret TRUE return value as meaning to stop the control
 655         // default handling of the message
 656         *result = TRUE;
 657
 658         return true;
 659     }
 660
 661     return wxHeaderCtrlBase::MSWOnNotify(idCtrl, lParam, result);
 662 }
 663
 664 #endif // wxHAS_GENERIC_HEADERCTRL
 665
 666 #endif // wxUSE_HEADERCTRL