]> git.saurik.com Git - wxWidgets.git/blob - src/msw/headerctrl.cpp
Don't use wxCHECK_W32API_VERSION() in #if when it can be undefined.
[wxWidgets.git] / 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/app.h"
30 #include "wx/log.h"
31 #endif // WX_PRECOMP
32
33 #include "wx/headerctrl.h"
34
35 #ifndef wxHAS_GENERIC_HEADERCTRL
36
37 #include "wx/imaglist.h"
38
39 #include "wx/msw/wrapcctl.h"
40 #include "wx/msw/private.h"
41
42 #ifndef HDM_SETBITMAPMARGIN
43 #define HDM_SETBITMAPMARGIN 0x1234
44 #endif
45
46 #ifndef Header_SetBitmapMargin
47 #define Header_SetBitmapMargin(hwnd, margin) \
48 ::SendMessage((hwnd), HDM_SETBITMAPMARGIN, (WPARAM)(margin), 0)
49 #endif
50
51 // from src/msw/listctrl.cpp
52 extern int WXDLLIMPEXP_CORE wxMSWGetColumnClicked(NMHDR *nmhdr, POINT *ptClick);
53
54 // ============================================================================
55 // wxHeaderCtrl implementation
56 // ============================================================================
57
58 // ----------------------------------------------------------------------------
59 // wxHeaderCtrl construction/destruction
60 // ----------------------------------------------------------------------------
61
62 void wxHeaderCtrl::Init()
63 {
64 m_numColumns = 0;
65 m_imageList = NULL;
66 m_scrollOffset = 0;
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().wx_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_COMMAND_HEADER_DCLICK
478 : wxEVT_COMMAND_HEADER_CLICK;
479 break;
480
481 case 1:
482 evtType = dblclk ? wxEVT_COMMAND_HEADER_RIGHT_DCLICK
483 : wxEVT_COMMAND_HEADER_RIGHT_CLICK;
484 break;
485
486 case 2:
487 evtType = dblclk ? wxEVT_COMMAND_HEADER_MIDDLE_DCLICK
488 : wxEVT_COMMAND_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 break;
529
530 // although we should get the notifications about the right clicks
531 // via HDN_ITEM[DBL]CLICK too according to MSDN this simply doesn't
532 // happen in practice on any Windows system up to 2003
533 case NM_RCLICK:
534 case NM_RDBLCLK:
535 {
536 POINT pt;
537 idx = wxMSWGetColumnClicked(&nmhdr->hdr, &pt);
538 if ( idx != wxNOT_FOUND )
539 {
540 idx = MSWFromNativeIdx(idx);
541
542 // due to a bug in mingw32 headers NM_RDBLCLK is signed
543 // there so we need a cast to avoid warnings about signed/
544 // unsigned comparison
545 evtType = GetClickEventType(
546 code == static_cast<UINT>(NM_RDBLCLK), 1);
547 }
548 //else: ignore clicks outside any column
549 }
550 break;
551
552 case HDN_DIVIDERDBLCLICK:
553 evtType = wxEVT_COMMAND_HEADER_SEPARATOR_DCLICK;
554 break;
555
556
557 // column resizing events
558 // ----------------------
559
560 // see comments in wxListCtrl::MSWOnNotify() for why we catch both
561 // ASCII and Unicode versions of this message
562 case HDN_BEGINTRACKA:
563 case HDN_BEGINTRACKW:
564 // non-resizable columns can't be resized no matter what, don't
565 // even generate any events for them
566 if ( !GetColumn(idx).IsResizeable() )
567 {
568 veto = true;
569 break;
570 }
571
572 evtType = wxEVT_COMMAND_HEADER_BEGIN_RESIZE;
573 // fall through
574
575 case HDN_ENDTRACKA:
576 case HDN_ENDTRACKW:
577 width = nmhdr->pitem->cxy;
578
579 if ( evtType == wxEVT_NULL )
580 {
581 evtType = wxEVT_COMMAND_HEADER_END_RESIZE;
582
583 // don't generate events with invalid width
584 const int minWidth = GetColumn(idx).GetMinWidth();
585 if ( width < minWidth )
586 width = minWidth;
587 }
588 break;
589
590 case HDN_ITEMCHANGING:
591 if ( nmhdr->pitem && (nmhdr->pitem->mask & HDI_WIDTH) )
592 {
593 // prevent the column from being shrunk beneath its min width
594 width = nmhdr->pitem->cxy;
595 if ( width < GetColumn(idx).GetMinWidth() )
596 {
597 // don't generate any events and prevent the change from
598 // happening
599 veto = true;
600 }
601 else // width is acceptable
602 {
603 // generate the resizing event from here as we don't seem
604 // to be getting HDN_TRACK events at all, at least with
605 // comctl32.dll v6
606 evtType = wxEVT_COMMAND_HEADER_RESIZING;
607 }
608 }
609 break;
610
611
612 // column reordering events
613 // ------------------------
614
615 case HDN_BEGINDRAG:
616 // Windows sometimes sends us events with invalid column indices
617 if ( nmhdr->iItem == -1 )
618 break;
619
620 // column must have the appropriate flag to be draggable
621 if ( !GetColumn(idx).IsReorderable() )
622 {
623 veto = true;
624 break;
625 }
626
627 evtType = wxEVT_COMMAND_HEADER_BEGIN_REORDER;
628 break;
629
630 case HDN_ENDDRAG:
631 wxASSERT_MSG( nmhdr->pitem->mask & HDI_ORDER, "should have order" );
632 order = nmhdr->pitem->iOrder;
633
634 // we also get messages with invalid order when column reordering
635 // is cancelled (e.g. by pressing Esc)
636 if ( order == -1 )
637 break;
638
639 order = MSWFromNativeOrder(order);
640
641 evtType = wxEVT_COMMAND_HEADER_END_REORDER;
642 break;
643
644 case NM_RELEASEDCAPTURE:
645 evtType = wxEVT_COMMAND_HEADER_DRAGGING_CANCELLED;
646 break;
647 }
648
649
650 // do generate the corresponding wx event
651 if ( evtType != wxEVT_NULL )
652 {
653 wxHeaderCtrlEvent event(evtType, GetId());
654 event.SetEventObject(this);
655 event.SetColumn(idx);
656 event.SetWidth(width);
657 if ( order != -1 )
658 event.SetNewOrder(order);
659
660 const bool processed = GetEventHandler()->ProcessEvent(event);
661
662 if ( processed && !event.IsAllowed() )
663 veto = true;
664
665 if ( !veto )
666 {
667 // special post-processing for HDN_ENDDRAG: we need to update the
668 // internal column indices array if this is allowed to go ahead as
669 // the native control is going to reorder its columns now
670 if ( evtType == wxEVT_COMMAND_HEADER_END_REORDER )
671 MoveColumnInOrderArray(m_colIndices, idx, order);
672
673 if ( processed )
674 {
675 // skip default processing below
676 return true;
677 }
678 }
679 }
680
681 if ( veto )
682 {
683 // all of HDN_BEGIN{DRAG,TRACK}, HDN_TRACK and HDN_ITEMCHANGING
684 // interpret TRUE return value as meaning to stop the control
685 // default handling of the message
686 *result = TRUE;
687
688 return true;
689 }
690
691 return wxHeaderCtrlBase::MSWOnNotify(idCtrl, lParam, result);
692 }
693
694 #endif // wxHAS_GENERIC_HEADERCTRL
695
696 #endif // wxUSE_HEADERCTRL