src/common/headerctrlcmn.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/headerctrlcmn.cpp
   3 // Purpose:     implementation of wxHeaderCtrlBase
   4 // Author:      Vadim Zeitlin
   5 // Created:     2008-12-02
   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 #ifndef WX_PRECOMP
  27     #include "wx/menu.h"
  28 #endif // WX_PRECOMP
  29
  30 #include "wx/headerctrl.h"
  31 #include "wx/rearrangectrl.h"
  32
  33 namespace
  34 {
  35
  36 // ----------------------------------------------------------------------------
  37 // constants
  38 // ----------------------------------------------------------------------------
  39
  40 const unsigned int wxNO_COLUMN = static_cast<unsigned>(-1);
  41
  42 // ----------------------------------------------------------------------------
  43 // wxHeaderColumnsRearrangeDialog: dialog for customizing our columns
  44 // ----------------------------------------------------------------------------
  45
  46 class wxHeaderColumnsRearrangeDialog : public wxRearrangeDialog
  47 {
  48 public:
  49     wxHeaderColumnsRearrangeDialog(wxWindow *parent,
  50                                    const wxArrayInt& order,
  51                                    const wxArrayString& items)
  52         : wxRearrangeDialog
  53           (
  54             parent,
  55             _("Please select the columns to show and define their order:"),
  56             _("Customize Columns"),
  57             order,
  58             items
  59           )
  60     {
  61     }
  62 };
  63
  64 } // anonymous namespace
  65
  66 // ============================================================================
  67 // wxHeaderCtrlBase implementation
  68 // ============================================================================
  69
  70 extern WXDLLIMPEXP_DATA_CORE(const char) wxHeaderCtrlNameStr[] = "wxHeaderCtrl";
  71
  72 BEGIN_EVENT_TABLE(wxHeaderCtrlBase, wxControl)
  73     EVT_HEADER_SEPARATOR_DCLICK(wxID_ANY, wxHeaderCtrlBase::OnSeparatorDClick)
  74 #if wxUSE_MENU
  75     EVT_HEADER_RIGHT_CLICK(wxID_ANY, wxHeaderCtrlBase::OnRClick)
  76 #endif // wxUSE_MENU
  77 END_EVENT_TABLE()
  78
  79 void wxHeaderCtrlBase::ScrollWindow(int dx,
  80                                     int WXUNUSED_UNLESS_DEBUG(dy),
  81                                     const wxRect * WXUNUSED_UNLESS_DEBUG(rect))
  82
  83 {
  84     // this doesn't make sense at all
  85     wxASSERT_MSG( !dy, "header window can't be scrolled vertically" );
  86
  87     // this would actually be nice to support for "frozen" headers but it isn't
  88     // supported currently
  89     wxASSERT_MSG( !rect, "header window can't be scrolled partially" );
  90
  91     DoScrollHorz(dx);
  92 }
  93
  94 void wxHeaderCtrlBase::SetColumnCount(unsigned int count)
  95 {
  96     if ( count != GetColumnCount() )
  97         OnColumnCountChanging(count);
  98
  99     // still call DoSetCount() even if the count didn't really change in order
 100     // to update all the columns
 101     DoSetCount(count);
 102 }
 103
 104 // ----------------------------------------------------------------------------
 105 // wxHeaderCtrlBase event handling
 106 // ----------------------------------------------------------------------------
 107
 108 void wxHeaderCtrlBase::OnSeparatorDClick(wxHeaderCtrlEvent& event)
 109 {
 110     const unsigned col = event.GetColumn();
 111
 112     int w = wxWindowBase::GetTextExtent(GetColumn(col).GetTitle()).x;
 113     w += 4*GetCharWidth(); // add some arbitrary margins around text
 114
 115     if ( !UpdateColumnWidthToFit(col, w) )
 116         event.Skip();
 117     else
 118         UpdateColumn(col);
 119 }
 120
 121 #if wxUSE_MENU
 122
 123 void wxHeaderCtrlBase::OnRClick(wxHeaderCtrlEvent& event)
 124 {
 125     if ( !HasFlag(wxHD_ALLOW_HIDE) )
 126     {
 127         event.Skip();
 128         return;
 129     }
 130
 131     ShowColumnsMenu(ScreenToClient(wxGetMousePosition()));
 132 }
 133
 134 #endif // wxUSE_MENU
 135
 136 // ----------------------------------------------------------------------------
 137 // wxHeaderCtrlBase column reordering
 138 // ----------------------------------------------------------------------------
 139
 140 void wxHeaderCtrlBase::SetColumnsOrder(const wxArrayInt& order)
 141 {
 142     const unsigned count = GetColumnCount();
 143     wxCHECK_RET( order.size() == count, "wrong number of columns" );
 144
 145     // check the array validity
 146     wxArrayInt seen(count, 0);
 147     for ( unsigned n = 0; n < count; n++ )
 148     {
 149         const unsigned idx = order[n];
 150         wxCHECK_RET( idx < count, "invalid column index" );
 151         wxCHECK_RET( !seen[idx], "duplicate column index" );
 152
 153         seen[idx] = 1;
 154     }
 155
 156     DoSetColumnsOrder(order);
 157
 158     // TODO-RTL: do we need to reverse the array?
 159 }
 160
 161 void wxHeaderCtrlBase::ResetColumnsOrder()
 162 {
 163     const unsigned count = GetColumnCount();
 164     wxArrayInt order(count);
 165     for ( unsigned n = 0; n < count; n++ )
 166         order[n] = n;
 167
 168     DoSetColumnsOrder(order);
 169 }
 170
 171 wxArrayInt wxHeaderCtrlBase::GetColumnsOrder() const
 172 {
 173     const wxArrayInt order = DoGetColumnsOrder();
 174
 175     wxASSERT_MSG( order.size() == GetColumnCount(), "invalid order array" );
 176
 177     return order;
 178 }
 179
 180 unsigned int wxHeaderCtrlBase::GetColumnAt(unsigned int pos) const
 181 {
 182     wxCHECK_MSG( pos < GetColumnCount(), wxNO_COLUMN, "invalid position" );
 183
 184     return GetColumnsOrder()[pos];
 185 }
 186
 187 unsigned int wxHeaderCtrlBase::GetColumnPos(unsigned int idx) const
 188 {
 189     const unsigned count = GetColumnCount();
 190
 191     wxCHECK_MSG( idx < count, wxNO_COLUMN, "invalid index" );
 192
 193     const wxArrayInt order = GetColumnsOrder();
 194     for ( unsigned n = 0; n < count; n++ )
 195     {
 196         if ( (unsigned)order[n] == idx )
 197             return n;
 198     }
 199
 200     wxFAIL_MSG( "column unexpectedly not displayed at all" );
 201
 202     return wxNO_COLUMN;
 203 }
 204
 205 /* static */
 206 void wxHeaderCtrlBase::MoveColumnInOrderArray(wxArrayInt& order,
 207                                               unsigned int idx,
 208                                               unsigned int pos)
 209 {
 210     const unsigned count = order.size();
 211
 212     wxArrayInt orderNew;
 213     orderNew.reserve(count);
 214     for ( unsigned n = 0; ; n++ )
 215     {
 216         // NB: order of checks is important for this to work when the new
 217         //     column position is the same as the old one
 218
 219         // insert the column at its new position
 220         if ( orderNew.size() == pos )
 221             orderNew.push_back(idx);
 222
 223         if ( n == count )
 224             break;
 225
 226         // delete the column from its old position
 227         const unsigned idxOld = order[n];
 228         if ( idxOld == idx )
 229             continue;
 230
 231         orderNew.push_back(idxOld);
 232     }
 233
 234     order.swap(orderNew);
 235 }
 236
 237 void
 238 wxHeaderCtrlBase::DoResizeColumnIndices(wxArrayInt& colIndices, unsigned int count)
 239 {
 240     // update the column indices array if necessary
 241     const unsigned countOld = colIndices.size();
 242     if ( count > countOld )
 243     {
 244         // all new columns have default positions equal to their indices
 245         for ( unsigned n = countOld; n < count; n++ )
 246             colIndices.push_back(n);
 247     }
 248     else if ( count < countOld )
 249     {
 250         // filter out all the positions which are invalid now while keeping the
 251         // order of the remaining ones
 252         wxArrayInt colIndicesNew;
 253         colIndicesNew.reserve(count);
 254         for ( unsigned n = 0; n < countOld; n++ )
 255         {
 256             const unsigned idx = colIndices[n];
 257             if ( idx < count )
 258                 colIndicesNew.push_back(idx);
 259         }
 260
 261         colIndices.swap(colIndicesNew);
 262     }
 263     //else: count didn't really change, nothing to do
 264
 265     wxASSERT_MSG( colIndices.size() == count, "logic error" );
 266 }
 267
 268 // ----------------------------------------------------------------------------
 269 // wxHeaderCtrl extra UI
 270 // ----------------------------------------------------------------------------
 271
 272 #if wxUSE_MENU
 273
 274 void wxHeaderCtrlBase::AddColumnsItems(wxMenu& menu, int idColumnsBase)
 275 {
 276     const unsigned count = GetColumnCount();
 277     for ( unsigned n = 0; n < count; n++ )
 278     {
 279         const wxHeaderColumn& col = GetColumn(n);
 280         menu.AppendCheckItem(idColumnsBase + n, col.GetTitle());
 281         if ( col.IsShown() )
 282             menu.Check(n, true);
 283     }
 284 }
 285
 286 bool wxHeaderCtrlBase::ShowColumnsMenu(const wxPoint& pt, const wxString& title)
 287 {
 288     // construct the menu with the entries for all columns
 289     wxMenu menu;
 290     if ( !title.empty() )
 291         menu.SetTitle(title);
 292
 293     AddColumnsItems(menu);
 294
 295     // ... and an extra one to show the customization dialog if the user is
 296     // allowed to reorder the columns too
 297     const unsigned count = GetColumnCount();
 298     if ( HasFlag(wxHD_ALLOW_REORDER) )
 299     {
 300         menu.AppendSeparator();
 301         menu.Append(count, _("&Customize..."));
 302     }
 303
 304     // do show the menu and get the user selection
 305     const int rc = GetPopupMenuSelectionFromUser(menu, pt);
 306     if ( rc == wxID_NONE )
 307         return false;
 308
 309     if ( static_cast<unsigned>(rc) == count )
 310     {
 311         return ShowCustomizeDialog();
 312     }
 313     else // a column selected from the menu
 314     {
 315         UpdateColumnVisibility(rc, !GetColumn(rc).IsShown());
 316     }
 317
 318     return true;
 319 }
 320
 321 #endif // wxUSE_MENU
 322
 323 bool wxHeaderCtrlBase::ShowCustomizeDialog()
 324 {
 325 #if wxUSE_REARRANGECTRL
 326     // prepare the data for showing the dialog
 327     wxArrayInt order = GetColumnsOrder();
 328
 329     const unsigned count = GetColumnCount();
 330
 331     // notice that titles are always in the index order, they will be shown
 332     // rearranged according to the display order in the dialog
 333     wxArrayString titles;
 334     titles.reserve(count);
 335     for ( unsigned n = 0; n < count; n++ )
 336         titles.push_back(GetColumn(n).GetTitle());
 337
 338     // this loop is however over positions and not indices
 339     unsigned pos;
 340     for ( pos = 0; pos < count; pos++ )
 341     {
 342         int& idx = order[pos];
 343         if ( GetColumn(idx).IsHidden() )
 344         {
 345             // indicate that this one is hidden
 346             idx = ~idx;
 347         }
 348     }
 349
 350     // do show it
 351     wxHeaderColumnsRearrangeDialog dlg(this, order, titles);
 352     if ( dlg.ShowModal() == wxID_OK )
 353     {
 354         // and apply the changes
 355         order = dlg.GetOrder();
 356         for ( pos = 0; pos < count; pos++ )
 357         {
 358             int& idx = order[pos];
 359             const bool show = idx >= 0;
 360             if ( !show )
 361             {
 362                 // make all indices positive for passing them to SetColumnsOrder()
 363                 idx = ~idx;
 364             }
 365
 366             if ( show != GetColumn(idx).IsShown() )
 367                 UpdateColumnVisibility(idx, show);
 368         }
 369
 370         UpdateColumnsOrder(order);
 371         SetColumnsOrder(order);
 372
 373         return true;
 374     }
 375 #endif // wxUSE_REARRANGECTRL
 376
 377     return false;
 378 }
 379
 380 // ============================================================================
 381 // wxHeaderCtrlSimple implementation
 382 // ============================================================================
 383
 384 void wxHeaderCtrlSimple::Init()
 385 {
 386     m_sortKey = wxNO_COLUMN;
 387 }
 388
 389 const wxHeaderColumn& wxHeaderCtrlSimple::GetColumn(unsigned int idx) const
 390 {
 391     return m_cols[idx];
 392 }
 393
 394 void wxHeaderCtrlSimple::DoInsert(const wxHeaderColumnSimple& col, unsigned int idx)
 395 {
 396     m_cols.insert(m_cols.begin() + idx, col);
 397
 398     UpdateColumnCount();
 399 }
 400
 401 void wxHeaderCtrlSimple::DoDelete(unsigned int idx)
 402 {
 403     m_cols.erase(m_cols.begin() + idx);
 404     if ( idx == m_sortKey )
 405         m_sortKey = wxNO_COLUMN;
 406
 407     UpdateColumnCount();
 408 }
 409
 410 void wxHeaderCtrlSimple::DeleteAllColumns()
 411 {
 412     m_cols.clear();
 413     m_sortKey = wxNO_COLUMN;
 414
 415     UpdateColumnCount();
 416 }
 417
 418
 419 void wxHeaderCtrlSimple::DoShowColumn(unsigned int idx, bool show)
 420 {
 421     if ( show != m_cols[idx].IsShown() )
 422     {
 423         m_cols[idx].SetHidden(!show);
 424
 425         UpdateColumn(idx);
 426     }
 427 }
 428
 429 void wxHeaderCtrlSimple::DoShowSortIndicator(unsigned int idx, bool ascending)
 430 {
 431     RemoveSortIndicator();
 432
 433     m_cols[idx].SetAsSortKey(ascending);
 434     m_sortKey = idx;
 435
 436     UpdateColumn(idx);
 437 }
 438
 439 void wxHeaderCtrlSimple::RemoveSortIndicator()
 440 {
 441     if ( m_sortKey != wxNO_COLUMN )
 442     {
 443         const unsigned sortOld = m_sortKey;
 444         m_sortKey = wxNO_COLUMN;
 445
 446         m_cols[sortOld].UnsetAsSortKey();
 447
 448         UpdateColumn(sortOld);
 449     }
 450 }
 451
 452 bool
 453 wxHeaderCtrlSimple::UpdateColumnWidthToFit(unsigned int idx, int widthTitle)
 454 {
 455     const int widthContents = GetBestFittingWidth(idx);
 456     if ( widthContents == -1 )
 457         return false;
 458
 459     m_cols[idx].SetWidth(wxMax(widthContents, widthTitle));
 460
 461     return true;
 462 }
 463
 464 // ============================================================================
 465 // wxHeaderCtrlEvent implementation
 466 // ============================================================================
 467
 468 IMPLEMENT_DYNAMIC_CLASS(wxHeaderCtrlEvent, wxNotifyEvent)
 469
 470 const wxEventType wxEVT_COMMAND_HEADER_CLICK = wxNewEventType();
 471 const wxEventType wxEVT_COMMAND_HEADER_RIGHT_CLICK = wxNewEventType();
 472 const wxEventType wxEVT_COMMAND_HEADER_MIDDLE_CLICK = wxNewEventType();
 473
 474 const wxEventType wxEVT_COMMAND_HEADER_DCLICK = wxNewEventType();
 475 const wxEventType wxEVT_COMMAND_HEADER_RIGHT_DCLICK = wxNewEventType();
 476 const wxEventType wxEVT_COMMAND_HEADER_MIDDLE_DCLICK = wxNewEventType();
 477
 478 const wxEventType wxEVT_COMMAND_HEADER_SEPARATOR_DCLICK = wxNewEventType();
 479
 480 const wxEventType wxEVT_COMMAND_HEADER_BEGIN_RESIZE = wxNewEventType();
 481 const wxEventType wxEVT_COMMAND_HEADER_RESIZING = wxNewEventType();
 482 const wxEventType wxEVT_COMMAND_HEADER_END_RESIZE = wxNewEventType();
 483
 484 const wxEventType wxEVT_COMMAND_HEADER_BEGIN_REORDER = wxNewEventType();
 485 const wxEventType wxEVT_COMMAND_HEADER_END_REORDER = wxNewEventType();
 486
 487 const wxEventType wxEVT_COMMAND_HEADER_DRAGGING_CANCELLED = wxNewEventType();