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