src/generic/headerctrlg.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/generic/headerctrlg.cpp
   3 // Purpose:     generic wxHeaderCtrl implementation
   4 // Author:      Vadim Zeitlin
   5 // Created:     2008-12-03
   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 #endif // WX_PRECOMP
  28
  29 #include "wx/headerctrl.h"
  30
  31 #ifdef wxHAS_GENERIC_HEADERCTRL
  32
  33 #include "wx/dcbuffer.h"
  34 #include "wx/renderer.h"
  35
  36 // ----------------------------------------------------------------------------
  37 // constants
  38 // ----------------------------------------------------------------------------
  39
  40 namespace
  41 {
  42
  43 const unsigned NO_SORT = (unsigned)-1;
  44
  45 const unsigned COL_NONE = (unsigned)-1;
  46
  47 } // anonymous namespace
  48
  49 // ============================================================================
  50 // wxHeaderCtrl implementation
  51 // ============================================================================
  52
  53 // ----------------------------------------------------------------------------
  54 // wxHeaderCtrl creation
  55 // ----------------------------------------------------------------------------
  56
  57 void wxHeaderCtrl::Init()
  58 {
  59     m_numColumns = 0;
  60     m_hover =
  61     m_colBeingResized = COL_NONE;
  62     m_scrollOffset = 0;
  63 }
  64
  65 bool wxHeaderCtrl::Create(wxWindow *parent,
  66                           wxWindowID id,
  67                           const wxPoint& pos,
  68                           const wxSize& size,
  69                           long style,
  70                           const wxString& name)
  71 {
  72     if ( !wxHeaderCtrlBase::Create(parent, id, pos, size,
  73                                    style, wxDefaultValidator, name) )
  74         return false;
  75
  76     // tell the system to not paint the background at all to avoid flicker as
  77     // we paint the entire window area in our OnPaint()
  78     SetBackgroundStyle(wxBG_STYLE_CUSTOM);
  79
  80     return true;
  81 }
  82
  83 wxHeaderCtrl::~wxHeaderCtrl()
  84 {
  85 }
  86
  87 // ----------------------------------------------------------------------------
  88 // wxHeaderCtrl columns manipulation
  89 // ----------------------------------------------------------------------------
  90
  91 void wxHeaderCtrl::DoSetCount(unsigned int count)
  92 {
  93     m_numColumns = count;
  94
  95     Refresh();
  96 }
  97
  98 unsigned int wxHeaderCtrl::DoGetCount() const
  99 {
 100     return m_numColumns;
 101 }
 102
 103 void wxHeaderCtrl::DoUpdate(unsigned int idx)
 104 {
 105     // we need to refresh not only this column but also the ones after it in
 106     // case it was shown or hidden or its width changed -- it would be nice to
 107     // avoid doing this unnecessary by storing the old column width (TODO)
 108     RefreshColsAfter(idx);
 109 }
 110
 111 // ----------------------------------------------------------------------------
 112 // wxHeaderCtrl scrolling
 113 // ----------------------------------------------------------------------------
 114
 115 void wxHeaderCtrl::DoScrollHorz(int dx)
 116 {
 117     m_scrollOffset += dx;
 118
 119     // don't call our own version which calls this function!
 120     wxControl::ScrollWindow(dx, 0);
 121 }
 122
 123 // ----------------------------------------------------------------------------
 124 // wxHeaderCtrl geometry
 125 // ----------------------------------------------------------------------------
 126
 127 wxSize wxHeaderCtrl::DoGetBestSize() const
 128 {
 129     // the vertical size is rather arbitrary but it looks better if we leave
 130     // some space around the text
 131     return wxSize(GetColStart(GetColumnCount()), (7*GetCharHeight())/4);
 132 }
 133
 134 int wxHeaderCtrl::GetColStart(unsigned int idx) const
 135 {
 136     wxHeaderCtrl * const self = const_cast<wxHeaderCtrl *>(this);
 137
 138     int pos = m_scrollOffset;
 139     for ( unsigned n = 0; n < idx; n++ )
 140     {
 141         const wxHeaderColumnBase& col = self->GetColumn(n);
 142         if ( col.IsShown() )
 143             pos += col.GetWidth();
 144     }
 145
 146     return pos;
 147 }
 148
 149 int wxHeaderCtrl::FindColumnAtPos(int x, bool& onSeparator) const
 150 {
 151     wxHeaderCtrl * const self = const_cast<wxHeaderCtrl *>(this);
 152
 153     int pos = 0;
 154     const unsigned count = GetColumnCount();
 155     for ( unsigned n = 0; n < count; n++ )
 156     {
 157         const wxHeaderColumnBase& col = self->GetColumn(n);
 158         if ( col.IsHidden() )
 159             continue;
 160
 161         pos += col.GetWidth();
 162
 163         // if the column is resizeable, check if we're approximatively over the
 164         // line separating it from the next column
 165         //
 166         // TODO: don't hardcode sensitivity
 167         if ( col.IsResizeable() && abs(x - pos) < 8 )
 168         {
 169             onSeparator = true;
 170             return n;
 171         }
 172
 173         // inside this column?
 174         if ( x < pos )
 175         {
 176             onSeparator = false;
 177             return n;
 178         }
 179     }
 180
 181     return COL_NONE;
 182 }
 183
 184 // ----------------------------------------------------------------------------
 185 // wxHeaderCtrl repainting
 186 // ----------------------------------------------------------------------------
 187
 188 void wxHeaderCtrl::RefreshCol(unsigned int idx)
 189 {
 190     wxRect rect = GetClientRect();
 191     rect.x += GetColStart(idx);
 192     rect.width = GetColumn(idx).GetWidth();
 193
 194     RefreshRect(rect);
 195 }
 196
 197 void wxHeaderCtrl::RefreshColIfNotNone(unsigned int idx)
 198 {
 199     if ( idx != COL_NONE )
 200         RefreshCol(idx);
 201 }
 202
 203 void wxHeaderCtrl::RefreshColsAfter(unsigned int idx)
 204 {
 205     wxRect rect = GetClientRect();
 206     const int ofs = GetColStart(idx);
 207     rect.x += ofs;
 208     rect.width -= ofs;
 209
 210     RefreshRect(rect);
 211 }
 212
 213 // ----------------------------------------------------------------------------
 214 // wxHeaderCtrl dragging
 215 // ----------------------------------------------------------------------------
 216
 217 bool wxHeaderCtrl::IsResizing() const
 218 {
 219     return m_colBeingResized != COL_NONE;
 220 }
 221
 222 void wxHeaderCtrl::UpdateResizingMarker(int xPhysical)
 223 {
 224     // unfortunately drawing the marker over the parent window doesn't work as
 225     // it's usually covered by another window (the main control view) so just
 226     // draw the marker over the header itself, even if it makes it not very
 227     // useful
 228     wxClientDC dc(this);
 229
 230     wxDCOverlay dcover(m_overlay, &dc);
 231     dcover.Clear();
 232
 233     if ( xPhysical != -1 )
 234     {
 235         dc.SetPen(*wxLIGHT_GREY_PEN);
 236         dc.DrawLine(xPhysical, 0, xPhysical, GetClientSize().y);
 237     }
 238 }
 239
 240 void wxHeaderCtrl::EndDragging()
 241 {
 242     UpdateResizingMarker(-1);
 243
 244     m_overlay.Reset();
 245
 246     // don't use the special dragging cursor any more
 247     SetCursor(wxNullCursor);
 248 }
 249
 250 int wxHeaderCtrl::ConstrainByMinWidth(unsigned int col, int& xPhysical)
 251 {
 252     const int xStart = GetColStart(col);
 253
 254     // notice that GetMinWidth() returns 0 if there is no minimal width so it
 255     // still makes sense to use it even in this case
 256     const int xMinEnd = xStart + GetColumn(col).GetMinWidth();
 257
 258     if ( xPhysical < xMinEnd )
 259         xPhysical = xMinEnd;
 260
 261     return xPhysical - xStart;
 262 }
 263
 264 void wxHeaderCtrl::StartOrContinueResizing(unsigned int col, int xPhysical)
 265 {
 266     wxHeaderCtrlEvent event(IsResizing() ? wxEVT_COMMAND_HEADER_RESIZING
 267                                          : wxEVT_COMMAND_HEADER_BEGIN_RESIZE,
 268                             GetId());
 269     event.SetEventObject(this);
 270     event.SetColumn(col);
 271
 272     event.SetWidth(ConstrainByMinWidth(col, xPhysical));
 273
 274     if ( GetEventHandler()->ProcessEvent(event) && !event.IsAllowed() )
 275     {
 276         if ( IsResizing() )
 277         {
 278             ReleaseMouse();
 279             EndResizing(-1);
 280         }
 281         //else: nothing to do -- we just don't start to resize
 282     }
 283     else // go ahead with resizing
 284     {
 285         if ( !IsResizing() )
 286         {
 287             m_colBeingResized = col;
 288             SetCursor(wxCursor(wxCURSOR_SIZEWE));
 289             CaptureMouse();
 290         }
 291         //else: we had already done the above when we started
 292
 293         UpdateResizingMarker(xPhysical);
 294     }
 295 }
 296
 297 void wxHeaderCtrl::EndResizing(int xPhysical)
 298 {
 299     wxASSERT_MSG( IsResizing(), "shouldn't be called if we're not resizing" );
 300
 301     EndDragging();
 302
 303     const bool cancelled = xPhysical == -1;
 304
 305     // if dragging was cancelled we must have already lost the mouse capture so
 306     // don't try to release it
 307     if ( !cancelled )
 308         ReleaseMouse();
 309
 310     wxHeaderCtrlEvent event(cancelled ? wxEVT_COMMAND_HEADER_DRAGGING_CANCELLED
 311                                       : wxEVT_COMMAND_HEADER_END_RESIZE,
 312                             GetId());
 313     event.SetEventObject(this);
 314     event.SetColumn(m_colBeingResized);
 315     if ( !cancelled )
 316         event.SetWidth(ConstrainByMinWidth(m_colBeingResized, xPhysical));
 317
 318     GetEventHandler()->ProcessEvent(event);
 319
 320     m_colBeingResized = COL_NONE;
 321 }
 322
 323 // ----------------------------------------------------------------------------
 324 // wxHeaderCtrl event handlers
 325 // ----------------------------------------------------------------------------
 326
 327 BEGIN_EVENT_TABLE(wxHeaderCtrl, wxHeaderCtrlBase)
 328     EVT_PAINT(wxHeaderCtrl::OnPaint)
 329
 330     EVT_MOUSE_EVENTS(wxHeaderCtrl::OnMouse)
 331
 332     EVT_MOUSE_CAPTURE_LOST(wxHeaderCtrl::OnCaptureLost)
 333
 334     EVT_KEY_DOWN(wxHeaderCtrl::OnKeyDown)
 335 END_EVENT_TABLE()
 336
 337 void wxHeaderCtrl::OnPaint(wxPaintEvent& WXUNUSED(event))
 338 {
 339     int w, h;
 340     GetClientSize(&w, &h);
 341
 342     wxAutoBufferedPaintDC dc(this);
 343
 344     dc.SetBackground(GetBackgroundColour());
 345     dc.Clear();
 346
 347     // account for the horizontal scrollbar offset in the parent window
 348     dc.SetDeviceOrigin(m_scrollOffset, 0);
 349
 350     const unsigned int count = m_numColumns;
 351     int xpos = 0;
 352     for ( unsigned int i = 0; i < count; i++ )
 353     {
 354         const wxHeaderColumnBase& col = GetColumn(i);
 355         if ( col.IsHidden() )
 356             continue;
 357
 358         const int colWidth = col.GetWidth();
 359
 360         wxHeaderSortIconType sortArrow;
 361         if ( col.IsSortKey() )
 362         {
 363             sortArrow = col.IsSortOrderAscending() ? wxHDR_SORT_ICON_UP
 364                                                    : wxHDR_SORT_ICON_DOWN;
 365         }
 366         else // not sorting by this column
 367         {
 368             sortArrow = wxHDR_SORT_ICON_NONE;
 369         }
 370
 371         int state = 0;
 372         if ( IsEnabled() )
 373         {
 374             if ( i == m_hover )
 375                 state = wxCONTROL_CURRENT;
 376         }
 377         else // disabled
 378         {
 379             state = wxCONTROL_DISABLED;
 380         }
 381
 382         wxHeaderButtonParams params;
 383         params.m_labelText = col.GetTitle();
 384         params.m_labelBitmap = col.GetBitmap();
 385         params.m_labelAlignment = col.GetAlignment();
 386
 387         wxRendererNative::Get().DrawHeaderButton
 388                                 (
 389                                     this,
 390                                     dc,
 391                                     wxRect(xpos, 0, colWidth, h),
 392                                     state,
 393                                     sortArrow,
 394                                     &params
 395                                 );
 396
 397         xpos += colWidth;
 398     }
 399 }
 400
 401 void wxHeaderCtrl::OnCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
 402 {
 403     if ( IsResizing() )
 404         EndResizing(-1);
 405 }
 406
 407 void wxHeaderCtrl::OnKeyDown(wxKeyEvent& event)
 408 {
 409     if ( IsResizing() && event.GetKeyCode() == WXK_ESCAPE )
 410     {
 411         ReleaseMouse();
 412         EndResizing(-1);
 413     }
 414     else
 415     {
 416         event.Skip();
 417     }
 418 }
 419
 420 void wxHeaderCtrl::OnMouse(wxMouseEvent& mevent)
 421 {
 422     // do this in advance to allow simply returning if we're not interested,
 423     // we'll undo it if we do handle the event below
 424     mevent.Skip();
 425
 426
 427     // account for the control displacement
 428     const int xPhysical = mevent.GetX();
 429     const int xLogical = xPhysical - m_scrollOffset;
 430
 431     // first deal with the [continuation of any] dragging operations in
 432     // progress
 433     if ( IsResizing() )
 434     {
 435         if ( mevent.LeftUp() )
 436             EndResizing(xPhysical);
 437         else // update the live separator position
 438             StartOrContinueResizing(m_colBeingResized, xPhysical);
 439
 440         return;
 441     }
 442
 443
 444     // find if the event is over a column at all
 445     bool onSeparator;
 446     const unsigned col = mevent.Leaving()
 447                             ? (onSeparator = false, COL_NONE)
 448                             : FindColumnAtPos(xLogical, onSeparator);
 449
 450
 451     // update the highlighted column if it changed
 452     if ( col != m_hover )
 453     {
 454         const unsigned hoverOld = m_hover;
 455         m_hover = col;
 456
 457         RefreshColIfNotNone(hoverOld);
 458         RefreshColIfNotNone(m_hover);
 459     }
 460
 461     // update mouse cursor as it moves around
 462     if ( mevent.Moving() )
 463     {
 464         SetCursor(onSeparator ? wxCursor(wxCURSOR_SIZEWE) : wxNullCursor);
 465         return;
 466     }
 467
 468     // all the other events only make sense when they happen over a column
 469     if ( col == COL_NONE )
 470         return;
 471
 472
 473     // enter various dragging modes on left mouse press
 474     if ( mevent.LeftDown() )
 475     {
 476         if ( onSeparator )
 477         {
 478             // start resizing the column
 479             wxASSERT_MSG( !IsResizing(), "reentering resize mode?" );
 480             StartOrContinueResizing(col, xPhysical);
 481         }
 482         else // on column itself
 483         {
 484             // TODO: drag column
 485             ;
 486         }
 487
 488         return;
 489     }
 490
 491     // determine the type of header event corresponding to click events
 492     wxEventType evtType = wxEVT_NULL;
 493     const bool click = mevent.ButtonUp(),
 494                dblclk = mevent.ButtonDClick();
 495     if ( click || dblclk )
 496     {
 497         switch ( mevent.GetButton() )
 498         {
 499             case wxMOUSE_BTN_LEFT:
 500                 // treat left double clicks on separator specially
 501                 if ( onSeparator && dblclk )
 502                 {
 503                     evtType = wxEVT_COMMAND_HEADER_SEPARATOR_DCLICK;
 504                 }
 505                 else // not double click on separator
 506                 {
 507                     evtType = click ? wxEVT_COMMAND_HEADER_CLICK
 508                                     : wxEVT_COMMAND_HEADER_DCLICK;
 509                 }
 510                 break;
 511
 512             case wxMOUSE_BTN_RIGHT:
 513                 evtType = click ? wxEVT_COMMAND_HEADER_RIGHT_CLICK
 514                                 : wxEVT_COMMAND_HEADER_RIGHT_DCLICK;
 515                 break;
 516
 517             case wxMOUSE_BTN_MIDDLE:
 518                 evtType = click ? wxEVT_COMMAND_HEADER_MIDDLE_CLICK
 519                                 : wxEVT_COMMAND_HEADER_MIDDLE_DCLICK;
 520                 break;
 521
 522             default:
 523                 // ignore clicks from other mouse buttons
 524                 ;
 525         }
 526     }
 527
 528     if ( evtType == wxEVT_NULL )
 529         return;
 530
 531     wxHeaderCtrlEvent event(evtType, GetId());
 532     event.SetEventObject(this);
 533     event.SetColumn(col);
 534
 535     if ( GetEventHandler()->ProcessEvent(event) )
 536         mevent.Skip(false);
 537 }
 538
 539 #endif // wxHAS_GENERIC_HEADERCTRL