]> git.saurik.com Git - wxWidgets.git/blob - src/generic/listctrl.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Project file updates; cast in strconv.cpp to compile with VC++ 6
[wxWidgets.git] / src / generic / listctrl.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: listctrl.cpp
3 // Purpose:
4 // Author: Robert Roebling
5 // Id: $Id$
6 // Copyright: (c) 1998 Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 #ifdef __GNUG__
11 #pragma implementation "listctrl.h"
12 #pragma implementation "listctrlbase.h"
13 #endif
14
15 // For compilers that support precompilation, includes "wx.h".
16 #include "wx/wxprec.h"
17
18 #ifdef __BORLANDC__
19 #pragma hdrstop
20 #endif
21
22 #include "wx/dcscreen.h"
23 #include "wx/app.h"
24 #include "wx/listctrl.h"
25 #include "wx/generic/imaglist.h"
26 #include "wx/dynarray.h"
27
28 #ifdef __WXGTK__
29 #include <gtk/gtk.h>
30 #include "wx/gtk/win_gtk.h"
31 #endif
32
33 #ifndef wxUSE_GENERIC_LIST_EXTENSIONS
34 #define wxUSE_GENERIC_LIST_EXTENSIONS 1
35 #endif
36
37 // ----------------------------------------------------------------------------
38 // events
39 // ----------------------------------------------------------------------------
40
41 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_BEGIN_DRAG)
42 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_BEGIN_RDRAG)
43 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT)
44 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_END_LABEL_EDIT)
45 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_DELETE_ITEM)
46 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS)
47 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_GET_INFO)
48 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_SET_INFO)
49 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_SELECTED)
50 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_DESELECTED)
51 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_KEY_DOWN)
52 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_INSERT_ITEM)
53 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_COL_CLICK)
54 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK)
55 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK)
56 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_ACTIVATED)
57
58 // ============================================================================
59 // private classes
60 // ============================================================================
61
62 //-----------------------------------------------------------------------------
63 // wxListItemData (internal)
64 //-----------------------------------------------------------------------------
65
66 class WXDLLEXPORT wxListItemData : public wxObject
67 {
68 public:
69 wxString m_text;
70 int m_image;
71 long m_data;
72 int m_xpos,m_ypos;
73 int m_width,m_height;
74
75 wxListItemAttr *m_attr;
76
77 public:
78 wxListItemData();
79 ~wxListItemData() { delete m_attr; }
80
81 wxListItemData( const wxListItem &info );
82 void SetItem( const wxListItem &info );
83 void SetText( const wxString &s );
84 void SetImage( int image );
85 void SetData( long data );
86 void SetPosition( int x, int y );
87 void SetSize( int width, int height );
88 bool HasImage() const;
89 bool HasText() const;
90 bool IsHit( int x, int y ) const;
91 void GetText( wxString &s );
92 const wxString& GetText() { return m_text; }
93 int GetX( void ) const;
94 int GetY( void ) const;
95 int GetWidth() const;
96 int GetHeight() const;
97 int GetImage() const;
98 void GetItem( wxListItem &info ) const;
99
100 wxListItemAttr *GetAttributes() const { return m_attr; }
101
102 private:
103 DECLARE_DYNAMIC_CLASS(wxListItemData);
104 };
105
106 //-----------------------------------------------------------------------------
107 // wxListHeaderData (internal)
108 //-----------------------------------------------------------------------------
109
110 class WXDLLEXPORT wxListHeaderData : public wxObject
111 {
112 protected:
113 long m_mask;
114 int m_image;
115 wxString m_text;
116 int m_format;
117 int m_width;
118 int m_xpos,m_ypos;
119 int m_height;
120
121 public:
122 wxListHeaderData();
123 wxListHeaderData( const wxListItem &info );
124 void SetItem( const wxListItem &item );
125 void SetPosition( int x, int y );
126 void SetWidth( int w );
127 void SetFormat( int format );
128 void SetHeight( int h );
129 bool HasImage() const;
130 bool HasText() const;
131 bool IsHit( int x, int y ) const;
132 void GetItem( wxListItem &item );
133 void GetText( wxString &s );
134 int GetImage() const;
135 int GetWidth() const;
136 int GetFormat() const;
137
138 private:
139 DECLARE_DYNAMIC_CLASS(wxListHeaderData);
140 };
141
142 //-----------------------------------------------------------------------------
143 // wxListLineData (internal)
144 //-----------------------------------------------------------------------------
145
146 class WXDLLEXPORT wxListLineData : public wxObject
147 {
148 public:
149 wxList m_items;
150 wxRect m_bound_all;
151 wxRect m_bound_label;
152 wxRect m_bound_icon;
153 wxRect m_bound_hilight;
154 int m_mode;
155 bool m_hilighted;
156 wxBrush *m_hilightBrush;
157 int m_spacing;
158 wxListMainWindow *m_owner;
159
160 void DoDraw( wxDC *dc, bool hilight, bool paintBG );
161
162 public:
163 wxListLineData() {}
164 wxListLineData( wxListMainWindow *owner, int mode, wxBrush *hilightBrush );
165 void CalculateSize( wxDC *dc, int spacing );
166 void SetPosition( wxDC *dc, int x, int y, int window_width );
167 void SetColumnPosition( int index, int x );
168 void GetSize( int &width, int &height );
169 void GetExtent( int &x, int &y, int &width, int &height );
170 void GetLabelExtent( int &x, int &y, int &width, int &height );
171 long IsHit( int x, int y );
172 void InitItems( int num );
173 void SetItem( int index, const wxListItem &info );
174 void GetItem( int index, wxListItem &info );
175 void GetText( int index, wxString &s );
176 void SetText( int index, const wxString s );
177 int GetImage( int index );
178 void GetRect( wxRect &rect );
179 void Hilight( bool on );
180 void ReverseHilight();
181 void DrawRubberBand( wxDC *dc, bool on );
182 void Draw( wxDC *dc );
183 bool IsInRect( int x, int y, const wxRect &rect );
184 bool IsHilighted();
185 void AssignRect( wxRect &dest, int x, int y, int width, int height );
186 void AssignRect( wxRect &dest, const wxRect &source );
187
188 private:
189 void SetAttributes(wxDC *dc,
190 const wxListItemAttr *attr,
191 const wxColour& colText, const wxFont& font,
192 bool hilight);
193
194 DECLARE_DYNAMIC_CLASS(wxListLineData);
195 };
196
197
198 WX_DECLARE_EXPORTED_OBJARRAY(wxListLineData, wxListLineDataArray);
199 #include "wx/arrimpl.cpp"
200 WX_DEFINE_OBJARRAY(wxListLineDataArray);
201
202 //-----------------------------------------------------------------------------
203 // wxListHeaderWindow (internal)
204 //-----------------------------------------------------------------------------
205
206 class WXDLLEXPORT wxListHeaderWindow : public wxWindow
207 {
208 protected:
209 wxListMainWindow *m_owner;
210 wxCursor *m_currentCursor;
211 wxCursor *m_resizeCursor;
212 bool m_isDragging;
213
214 // column being resized
215 int m_column;
216
217 // divider line position in logical (unscrolled) coords
218 int m_currentX;
219
220 // minimal position beyond which the divider line can't be dragged in
221 // logical coords
222 int m_minX;
223
224 public:
225 wxListHeaderWindow();
226 virtual ~wxListHeaderWindow();
227
228 wxListHeaderWindow( wxWindow *win,
229 wxWindowID id,
230 wxListMainWindow *owner,
231 const wxPoint &pos = wxDefaultPosition,
232 const wxSize &size = wxDefaultSize,
233 long style = 0,
234 const wxString &name = "wxlistctrlcolumntitles" );
235
236 void DoDrawRect( wxDC *dc, int x, int y, int w, int h );
237 void DrawCurrent();
238 void AdjustDC(wxDC& dc);
239
240 void OnPaint( wxPaintEvent &event );
241 void OnMouse( wxMouseEvent &event );
242 void OnSetFocus( wxFocusEvent &event );
243
244 // needs refresh
245 bool m_dirty;
246
247 private:
248 DECLARE_DYNAMIC_CLASS(wxListHeaderWindow)
249 DECLARE_EVENT_TABLE()
250 };
251
252 //-----------------------------------------------------------------------------
253 // wxListRenameTimer (internal)
254 //-----------------------------------------------------------------------------
255
256 class WXDLLEXPORT wxListRenameTimer: public wxTimer
257 {
258 private:
259 wxListMainWindow *m_owner;
260
261 public:
262 wxListRenameTimer( wxListMainWindow *owner );
263 void Notify();
264 };
265
266 //-----------------------------------------------------------------------------
267 // wxListTextCtrl (internal)
268 //-----------------------------------------------------------------------------
269
270 class WXDLLEXPORT wxListTextCtrl: public wxTextCtrl
271 {
272 private:
273 bool *m_accept;
274 wxString *m_res;
275 wxListMainWindow *m_owner;
276 wxString m_startValue;
277
278 public:
279 wxListTextCtrl() {}
280 wxListTextCtrl( wxWindow *parent, const wxWindowID id,
281 bool *accept, wxString *res, wxListMainWindow *owner,
282 const wxString &value = "",
283 const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
284 int style = 0,
285 const wxValidator& validator = wxDefaultValidator,
286 const wxString &name = "listctrltextctrl" );
287 void OnChar( wxKeyEvent &event );
288 void OnKeyUp( wxKeyEvent &event );
289 void OnKillFocus( wxFocusEvent &event );
290
291 private:
292 DECLARE_DYNAMIC_CLASS(wxListTextCtrl);
293 DECLARE_EVENT_TABLE()
294 };
295
296 //-----------------------------------------------------------------------------
297 // wxListMainWindow (internal)
298 //-----------------------------------------------------------------------------
299
300 class WXDLLEXPORT wxListMainWindow: public wxScrolledWindow
301 {
302 public:
303 long m_mode;
304 wxListLineDataArray m_lines;
305 wxList m_columns;
306 wxListLineData *m_current;
307 wxListLineData *m_currentEdit;
308 int m_visibleLines;
309 wxBrush *m_hilightBrush;
310 wxColour *m_hilightColour;
311 int m_xScroll,m_yScroll;
312 bool m_dirty;
313 wxImageList *m_small_image_list;
314 wxImageList *m_normal_image_list;
315 int m_small_spacing;
316 int m_normal_spacing;
317 bool m_hasFocus;
318 bool m_usedKeys;
319 bool m_lastOnSame;
320 wxTimer *m_renameTimer;
321 bool m_renameAccept;
322 wxString m_renameRes;
323 bool m_isCreated;
324 int m_dragCount;
325 wxPoint m_dragStart;
326
327 // for double click logic
328 wxListLineData *m_lineLastClicked,
329 *m_lineBeforeLastClicked;
330
331 public:
332 wxListMainWindow();
333 wxListMainWindow( wxWindow *parent, wxWindowID id,
334 const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
335 long style = 0, const wxString &name = "listctrlmainwindow" );
336 ~wxListMainWindow();
337 void RefreshLine( wxListLineData *line );
338 void OnPaint( wxPaintEvent &event );
339 void HilightAll( bool on );
340 void SendNotify( wxListLineData *line,
341 wxEventType command,
342 wxPoint point = wxDefaultPosition );
343 void FocusLine( wxListLineData *line );
344 void UnfocusLine( wxListLineData *line );
345 void SelectLine( wxListLineData *line );
346 void DeselectLine( wxListLineData *line );
347 void DeleteLine( wxListLineData *line );
348
349 void EditLabel( long item );
350 void Edit( long item ) { EditLabel(item); } // deprecated
351 void OnRenameTimer();
352 void OnRenameAccept();
353
354 void OnMouse( wxMouseEvent &event );
355 void MoveToFocus();
356 void OnArrowChar( wxListLineData *newCurrent, bool shiftDown );
357 void OnChar( wxKeyEvent &event );
358 void OnKeyDown( wxKeyEvent &event );
359 void OnSetFocus( wxFocusEvent &event );
360 void OnKillFocus( wxFocusEvent &event );
361 void OnSize( wxSizeEvent &event );
362 void OnScroll(wxScrollWinEvent& event) ;
363
364 void DrawImage( int index, wxDC *dc, int x, int y );
365 void GetImageSize( int index, int &width, int &height );
366 int GetIndexOfLine( const wxListLineData *line );
367 int GetTextLength( wxString &s ); // should be const
368
369 void SetImageList( wxImageList *imageList, int which );
370 void SetItemSpacing( int spacing, bool isSmall = FALSE );
371 int GetItemSpacing( bool isSmall = FALSE );
372 void SetColumn( int col, wxListItem &item );
373 void SetColumnWidth( int col, int width );
374 void GetColumn( int col, wxListItem &item );
375 int GetColumnWidth( int vol );
376 int GetColumnCount();
377 int GetCountPerPage();
378 void SetItem( wxListItem &item );
379 void GetItem( wxListItem &item );
380 void SetItemState( long item, long state, long stateMask );
381 int GetItemState( long item, long stateMask );
382 int GetItemCount();
383 void GetItemRect( long index, wxRect &rect );
384 bool GetItemPosition( long item, wxPoint& pos );
385 int GetSelectedItemCount();
386 void SetMode( long mode );
387 long GetMode() const;
388 void CalculatePositions();
389 void RealizeChanges();
390 long GetNextItem( long item, int geometry, int state );
391 void DeleteItem( long index );
392 void DeleteAllItems();
393 void DeleteColumn( int col );
394 void DeleteEverything();
395 void EnsureVisible( long index );
396 long FindItem( long start, const wxString& str, bool partial = FALSE );
397 long FindItem( long start, long data);
398 long HitTest( int x, int y, int &flags );
399 void InsertItem( wxListItem &item );
400 // void AddItem( wxListItem &item );
401 void InsertColumn( long col, wxListItem &item );
402 // void AddColumn( wxListItem &item );
403 void SortItems( wxListCtrlCompare fn, long data );
404
405 private:
406 DECLARE_DYNAMIC_CLASS(wxListMainWindow);
407 DECLARE_EVENT_TABLE()
408 };
409
410 // ============================================================================
411 // implementation
412 // ============================================================================
413
414 //-----------------------------------------------------------------------------
415 // wxListItemData
416 //-----------------------------------------------------------------------------
417
418 IMPLEMENT_DYNAMIC_CLASS(wxListItemData,wxObject);
419
420 wxListItemData::wxListItemData()
421 {
422 m_image = -1;
423 m_data = 0;
424 m_xpos = 0;
425 m_ypos = 0;
426 m_width = 0;
427 m_height = 0;
428 m_attr = NULL;
429 }
430
431 wxListItemData::wxListItemData( const wxListItem &info )
432 {
433 m_image = -1;
434 m_data = 0;
435 m_attr = NULL;
436
437 SetItem( info );
438 }
439
440 void wxListItemData::SetItem( const wxListItem &info )
441 {
442 if (info.m_mask & wxLIST_MASK_TEXT) m_text = info.m_text;
443 if (info.m_mask & wxLIST_MASK_IMAGE) m_image = info.m_image;
444 if (info.m_mask & wxLIST_MASK_DATA) m_data = info.m_data;
445
446 if ( info.HasAttributes() )
447 {
448 if ( m_attr )
449 *m_attr = *info.GetAttributes();
450 else
451 m_attr = new wxListItemAttr(*info.GetAttributes());
452 }
453
454 m_xpos = 0;
455 m_ypos = 0;
456 m_width = info.m_width;
457 m_height = 0;
458 }
459
460 void wxListItemData::SetText( const wxString &s )
461 {
462 m_text = s;
463 }
464
465 void wxListItemData::SetImage( int image )
466 {
467 m_image = image;
468 }
469
470 void wxListItemData::SetData( long data )
471 {
472 m_data = data;
473 }
474
475 void wxListItemData::SetPosition( int x, int y )
476 {
477 m_xpos = x;
478 m_ypos = y;
479 }
480
481 void wxListItemData::SetSize( int width, int height )
482 {
483 if (width != -1) m_width = width;
484 if (height != -1) m_height = height;
485 }
486
487 bool wxListItemData::HasImage() const
488 {
489 return (m_image >= 0);
490 }
491
492 bool wxListItemData::HasText() const
493 {
494 return (!m_text.IsNull());
495 }
496
497 bool wxListItemData::IsHit( int x, int y ) const
498 {
499 return ((x >= m_xpos) && (x <= m_xpos+m_width) && (y >= m_ypos) && (y <= m_ypos+m_height));
500 }
501
502 void wxListItemData::GetText( wxString &s )
503 {
504 s = m_text;
505 }
506
507 int wxListItemData::GetX() const
508 {
509 return m_xpos;
510 }
511
512 int wxListItemData::GetY() const
513 {
514 return m_ypos;
515 }
516
517 int wxListItemData::GetWidth() const
518 {
519 return m_width;
520 }
521
522 int wxListItemData::GetHeight() const
523 {
524 return m_height;
525 }
526
527 int wxListItemData::GetImage() const
528 {
529 return m_image;
530 }
531
532 void wxListItemData::GetItem( wxListItem &info ) const
533 {
534 info.m_text = m_text;
535 info.m_image = m_image;
536 info.m_data = m_data;
537
538 if ( m_attr )
539 {
540 if ( m_attr->HasTextColour() )
541 info.SetTextColour(m_attr->GetTextColour());
542 if ( m_attr->HasBackgroundColour() )
543 info.SetBackgroundColour(m_attr->GetBackgroundColour());
544 if ( m_attr->HasFont() )
545 info.SetFont(m_attr->GetFont());
546 }
547 }
548
549 //-----------------------------------------------------------------------------
550 // wxListHeaderData
551 //-----------------------------------------------------------------------------
552
553 IMPLEMENT_DYNAMIC_CLASS(wxListHeaderData,wxObject);
554
555 wxListHeaderData::wxListHeaderData()
556 {
557 m_mask = 0;
558 m_image = 0;
559 m_format = 0;
560 m_width = 0;
561 m_xpos = 0;
562 m_ypos = 0;
563 m_height = 0;
564 }
565
566 wxListHeaderData::wxListHeaderData( const wxListItem &item )
567 {
568 SetItem( item );
569 m_xpos = 0;
570 m_ypos = 0;
571 m_height = 0;
572 }
573
574 void wxListHeaderData::SetItem( const wxListItem &item )
575 {
576 m_mask = item.m_mask;
577 m_text = item.m_text;
578 m_image = item.m_image;
579 m_format = item.m_format;
580 m_width = item.m_width;
581 if (m_width < 0) m_width = 80;
582 if (m_width < 6) m_width = 6;
583 }
584
585 void wxListHeaderData::SetPosition( int x, int y )
586 {
587 m_xpos = x;
588 m_ypos = y;
589 }
590
591 void wxListHeaderData::SetHeight( int h )
592 {
593 m_height = h;
594 }
595
596 void wxListHeaderData::SetWidth( int w )
597 {
598 m_width = w;
599 if (m_width < 0) m_width = 80;
600 if (m_width < 6) m_width = 6;
601 }
602
603 void wxListHeaderData::SetFormat( int format )
604 {
605 m_format = format;
606 }
607
608 bool wxListHeaderData::HasImage() const
609 {
610 return (m_image != 0);
611 }
612
613 bool wxListHeaderData::HasText() const
614 {
615 return (m_text.Length() > 0);
616 }
617
618 bool wxListHeaderData::IsHit( int x, int y ) const
619 {
620 return ((x >= m_xpos) && (x <= m_xpos+m_width) && (y >= m_ypos) && (y <= m_ypos+m_height));
621 }
622
623 void wxListHeaderData::GetItem( wxListItem &item )
624 {
625 item.m_mask = m_mask;
626 item.m_text = m_text;
627 item.m_image = m_image;
628 item.m_format = m_format;
629 item.m_width = m_width;
630 }
631
632 void wxListHeaderData::GetText( wxString &s )
633 {
634 s = m_text;
635 }
636
637 int wxListHeaderData::GetImage() const
638 {
639 return m_image;
640 }
641
642 int wxListHeaderData::GetWidth() const
643 {
644 return m_width;
645 }
646
647 int wxListHeaderData::GetFormat() const
648 {
649 return m_format;
650 }
651
652 //-----------------------------------------------------------------------------
653 // wxListLineData
654 //-----------------------------------------------------------------------------
655
656 IMPLEMENT_DYNAMIC_CLASS(wxListLineData,wxObject);
657
658 wxListLineData::wxListLineData( wxListMainWindow *owner, int mode, wxBrush *hilightBrush )
659 {
660 m_mode = mode;
661 m_hilighted = FALSE;
662 m_owner = owner;
663 m_hilightBrush = hilightBrush;
664 m_items.DeleteContents( TRUE );
665 m_spacing = 0;
666 }
667
668 void wxListLineData::CalculateSize( wxDC *dc, int spacing )
669 {
670 m_spacing = spacing;
671 switch (m_mode)
672 {
673 case wxLC_ICON:
674 {
675 m_bound_all.width = m_spacing;
676 wxNode *node = m_items.First();
677 if (node)
678 {
679 wxListItemData *item = (wxListItemData*)node->Data();
680 wxString s = item->GetText();
681 if (s.IsEmpty()) s = wxT("H");
682 wxCoord lw,lh;
683 dc->GetTextExtent( s, &lw, &lh );
684 if (lh < 15) lh = 15;
685 lw += 4;
686 lh += 3;
687
688 m_bound_all.height = m_spacing+lh;
689 if (lw > m_spacing) m_bound_all.width = lw;
690 m_bound_label.width = lw;
691 m_bound_label.height = lh;
692
693 if (item->HasImage())
694 {
695 int w = 0;
696 int h = 0;
697 m_owner->GetImageSize( item->GetImage(), w, h );
698 m_bound_icon.width = w + 8;
699 m_bound_icon.height = h + 8;
700
701 if ( m_bound_icon.width > m_bound_all.width )
702 m_bound_all.width = m_bound_icon.width;
703 if ( h + lh > m_bound_all.height - 4 )
704 m_bound_all.height = h + lh + 4;
705 }
706
707 if (!item->HasText())
708 {
709 m_bound_hilight.width = m_bound_icon.width;
710 m_bound_hilight.height = m_bound_icon.height;
711 }
712 else
713 {
714 m_bound_hilight.width = m_bound_label.width;
715 m_bound_hilight.height = m_bound_label.height;
716 }
717 }
718 break;
719 }
720 case wxLC_LIST:
721 {
722 wxNode *node = m_items.First();
723 if (node)
724 {
725 wxListItemData *item = (wxListItemData*)node->Data();
726
727 wxString s = item->GetText();
728 if (s.IsEmpty()) s = wxT("H");
729 wxCoord lw,lh;
730 dc->GetTextExtent( s, &lw, &lh );
731 if (lh < 15) lh = 15;
732 lw += 4;
733 lh += 3;
734 m_bound_label.width = lw;
735 m_bound_label.height = lh;
736
737 m_bound_all.width = lw;
738 m_bound_all.height = lh;
739
740 if (item->HasImage())
741 {
742 int w = 0;
743 int h = 0;
744 m_owner->GetImageSize( item->GetImage(), w, h );
745 m_bound_icon.width = w;
746 m_bound_icon.height = h;
747
748 m_bound_all.width += 4 + w;
749 if (h > m_bound_all.height) m_bound_all.height = h;
750 }
751
752 m_bound_hilight.width = m_bound_all.width;
753 m_bound_hilight.height = m_bound_all.height;
754 }
755 break;
756 }
757 case wxLC_REPORT:
758 {
759 m_bound_all.width = 0;
760 m_bound_all.height = 0;
761 wxNode *node = m_items.First();
762 if (node)
763 {
764 wxListItemData *item = (wxListItemData*)node->Data();
765 if (item->HasImage())
766 {
767 int w = 0;
768 int h = 0;
769 m_owner->GetImageSize( item->GetImage(), w, h );
770 m_bound_icon.width = w;
771 m_bound_icon.height = h;
772 }
773 else
774 {
775 m_bound_icon.width = 0;
776 m_bound_icon.height = 0;
777 }
778 }
779 while (node)
780 {
781 wxListItemData *item = (wxListItemData*)node->Data();
782 wxString s = item->GetText();
783 if (s.IsEmpty()) s = wxT("H");
784 wxCoord lw,lh;
785 dc->GetTextExtent( s, &lw, &lh );
786 if (lh < 15) lh = 15;
787 lw += 4;
788 lh += 3;
789
790 item->SetSize( item->GetWidth(), lh );
791 m_bound_all.width += lw;
792 m_bound_all.height = lh;
793 node = node->Next();
794 }
795 m_bound_label.width = m_bound_all.width;
796 m_bound_label.height = m_bound_all.height;
797 break;
798 }
799 }
800 }
801
802 void wxListLineData::SetPosition( wxDC * WXUNUSED(dc),
803 int x, int y, int window_width )
804 {
805 m_bound_all.x = x;
806 m_bound_all.y = y;
807 switch (m_mode)
808 {
809 case wxLC_ICON:
810 {
811 wxNode *node = m_items.First();
812 if (node)
813 {
814 wxListItemData *item = (wxListItemData*)node->Data();
815 if (item->HasImage())
816 {
817 m_bound_icon.x = m_bound_all.x + 4
818 + (m_spacing - m_bound_icon.width)/2;
819 m_bound_icon.y = m_bound_all.y + 4;
820 }
821 if (item->HasText())
822 {
823 if (m_bound_all.width > m_spacing)
824 m_bound_label.x = m_bound_all.x + 2;
825 else
826 m_bound_label.x = m_bound_all.x + 2 + (m_spacing/2) - (m_bound_label.width/2);
827 m_bound_label.y = m_bound_all.y + m_bound_all.height + 2 - m_bound_label.height;
828 m_bound_hilight.x = m_bound_label.x - 2;
829 m_bound_hilight.y = m_bound_label.y - 2;
830 }
831 else
832 {
833 m_bound_hilight.x = m_bound_icon.x - 4;
834 m_bound_hilight.y = m_bound_icon.y - 4;
835 }
836 }
837 break;
838 }
839 case wxLC_LIST:
840 {
841 m_bound_hilight.x = m_bound_all.x;
842 m_bound_hilight.y = m_bound_all.y;
843 m_bound_label.y = m_bound_all.y + 2;
844 wxNode *node = m_items.First();
845 if (node)
846 {
847 wxListItemData *item = (wxListItemData*)node->Data();
848 if (item->HasImage())
849 {
850 m_bound_icon.x = m_bound_all.x + 2;
851 m_bound_icon.y = m_bound_all.y + 2;
852 m_bound_label.x = m_bound_all.x + 6 + m_bound_icon.width;
853 }
854 else
855 {
856 m_bound_label.x = m_bound_all.x + 2;
857 }
858 }
859 break;
860 }
861 case wxLC_REPORT:
862 {
863 m_bound_all.x = 0;
864 m_bound_all.width = window_width;
865 AssignRect( m_bound_hilight, m_bound_all );
866 m_bound_label.x = m_bound_all.x + 2;
867 m_bound_label.y = m_bound_all.y + 2;
868 wxNode *node = m_items.First();
869 if (node)
870 {
871 wxListItemData *item = (wxListItemData*)node->Data();
872 if (item->HasImage())
873 {
874 m_bound_icon.x = m_bound_all.x + 2;
875 m_bound_icon.y = m_bound_all.y + 2;
876 m_bound_label.x += 4 + m_bound_icon.width;
877 }
878 }
879 break;
880 }
881 }
882 }
883
884 void wxListLineData::SetColumnPosition( int index, int x )
885 {
886 wxNode *node = m_items.Nth( (size_t)index );
887 if (node)
888 {
889 wxListItemData *item = (wxListItemData*)node->Data();
890 item->SetPosition( x, m_bound_all.y+1 );
891 }
892 }
893
894 void wxListLineData::GetSize( int &width, int &height )
895 {
896 width = m_bound_all.width;
897 height = m_bound_all.height;
898 }
899
900 void wxListLineData::GetExtent( int &x, int &y, int &width, int &height )
901 {
902 x = m_bound_all.x;
903 y = m_bound_all.y;
904 width = m_bound_all.width;
905 height = m_bound_all.height;
906 }
907
908 void wxListLineData::GetLabelExtent( int &x, int &y, int &width, int &height )
909 {
910 x = m_bound_label.x;
911 y = m_bound_label.y;
912 width = m_bound_label.width;
913 height = m_bound_label.height;
914 }
915
916 void wxListLineData::GetRect( wxRect &rect )
917 {
918 AssignRect( rect, m_bound_all );
919 }
920
921 long wxListLineData::IsHit( int x, int y )
922 {
923 wxNode *node = m_items.First();
924 if (node)
925 {
926 wxListItemData *item = (wxListItemData*)node->Data();
927 if (item->HasImage() && IsInRect( x, y, m_bound_icon )) return wxLIST_HITTEST_ONITEMICON;
928 if (item->HasText() && IsInRect( x, y, m_bound_label )) return wxLIST_HITTEST_ONITEMLABEL;
929 // if (!(item->HasImage() || item->HasText())) return 0;
930 }
931 // if there is no icon or text = empty
932 if (IsInRect( x, y, m_bound_all )) return wxLIST_HITTEST_ONITEMICON;
933 return 0;
934 }
935
936 void wxListLineData::InitItems( int num )
937 {
938 for (int i = 0; i < num; i++) m_items.Append( new wxListItemData() );
939 }
940
941 void wxListLineData::SetItem( int index, const wxListItem &info )
942 {
943 wxNode *node = m_items.Nth( index );
944 if (node)
945 {
946 wxListItemData *item = (wxListItemData*)node->Data();
947 item->SetItem( info );
948 }
949 }
950
951 void wxListLineData::GetItem( int index, wxListItem &info )
952 {
953 int i = index;
954 wxNode *node = m_items.Nth( i );
955 if (node)
956 {
957 wxListItemData *item = (wxListItemData*)node->Data();
958 item->GetItem( info );
959 }
960 }
961
962 void wxListLineData::GetText( int index, wxString &s )
963 {
964 int i = index;
965 wxNode *node = m_items.Nth( i );
966 s = "";
967 if (node)
968 {
969 wxListItemData *item = (wxListItemData*)node->Data();
970 item->GetText( s );
971 }
972 }
973
974 void wxListLineData::SetText( int index, const wxString s )
975 {
976 int i = index;
977 wxNode *node = m_items.Nth( i );
978 if (node)
979 {
980 wxListItemData *item = (wxListItemData*)node->Data();
981 item->SetText( s );
982 }
983 }
984
985 int wxListLineData::GetImage( int index )
986 {
987 int i = index;
988 wxNode *node = m_items.Nth( i );
989 if (node)
990 {
991 wxListItemData *item = (wxListItemData*)node->Data();
992 return item->GetImage();
993 }
994 return -1;
995 }
996
997 void wxListLineData::SetAttributes(wxDC *dc,
998 const wxListItemAttr *attr,
999 const wxColour& colText,
1000 const wxFont& font,
1001 bool hilight)
1002 {
1003 // don't use foregroud colour for drawing highlighted items - this might
1004 // make them completely invisible (and there is no way to do bit
1005 // arithmetics on wxColour, unfortunately)
1006 if ( !hilight && attr && attr->HasTextColour() )
1007 {
1008 dc->SetTextForeground(attr->GetTextColour());
1009 }
1010 else
1011 {
1012 dc->SetTextForeground(colText);
1013 }
1014
1015 if ( attr && attr->HasFont() )
1016 {
1017 dc->SetFont(attr->GetFont());
1018 }
1019 else
1020 {
1021 dc->SetFont(font);
1022 }
1023 }
1024
1025 void wxListLineData::DoDraw( wxDC *dc, bool hilight, bool paintBG )
1026 {
1027 int dev_x = 0;
1028 int dev_y = 0;
1029 m_owner->CalcScrolledPosition( m_bound_all.x, m_bound_all.y, &dev_x, &dev_y );
1030 wxCoord dev_w = m_bound_all.width;
1031 wxCoord dev_h = m_bound_all.height;
1032
1033 if (!m_owner->IsExposed( dev_x, dev_y, dev_w, dev_h ))
1034 return;
1035
1036 wxWindow *listctrl = m_owner->GetParent();
1037
1038 // default foreground colour
1039 wxColour colText;
1040 if ( hilight )
1041 {
1042 colText = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_HIGHLIGHTTEXT );
1043 }
1044 else
1045 {
1046 colText = listctrl->GetForegroundColour();
1047 }
1048
1049 // default font
1050 wxFont font = listctrl->GetFont();
1051
1052 // VZ: currently we set the colours/fonts only once, but like this (i.e.
1053 // using SetAttributes() inside the loop), it will be trivial to
1054 // customize the subitems (in report mode) too.
1055 wxListItemData *item = (wxListItemData*)m_items.First()->Data();
1056 wxListItemAttr *attr = item->GetAttributes();
1057 SetAttributes(dc, attr, colText, font, hilight);
1058
1059 bool hasBgCol = attr && attr->HasBackgroundColour();
1060 if ( paintBG || hasBgCol )
1061 {
1062 if (hilight)
1063 {
1064 dc->SetBrush( * m_hilightBrush );
1065 }
1066 else
1067 {
1068 if ( hasBgCol )
1069 dc->SetBrush(wxBrush(attr->GetBackgroundColour(), wxSOLID));
1070 else
1071 dc->SetBrush( * wxWHITE_BRUSH );
1072 }
1073
1074 dc->SetPen( * wxTRANSPARENT_PEN );
1075 dc->DrawRectangle( m_bound_hilight.x, m_bound_hilight.y,
1076 m_bound_hilight.width, m_bound_hilight.height );
1077 }
1078
1079 if (m_mode == wxLC_REPORT)
1080 {
1081 wxNode *node = m_items.First();
1082 while (node)
1083 {
1084 wxListItemData *item = (wxListItemData*)node->Data();
1085 int x = item->GetX();
1086 if (item->HasImage())
1087 {
1088 int y = 0;
1089 m_owner->DrawImage( item->GetImage(), dc, x, item->GetY() );
1090 m_owner->GetImageSize( item->GetImage(), x, y );
1091 x += item->GetX() + 5;
1092 }
1093 dc->SetClippingRegion( item->GetX(), item->GetY(), item->GetWidth()-3, item->GetHeight() );
1094 if (item->HasText())
1095 {
1096 dc->DrawText( item->GetText(), x, item->GetY()+1 );
1097 }
1098 dc->DestroyClippingRegion();
1099 node = node->Next();
1100 }
1101 }
1102 else
1103 {
1104 wxNode *node = m_items.First();
1105 if (node)
1106 {
1107 wxListItemData *item = (wxListItemData*)node->Data();
1108 if (item->HasImage())
1109 {
1110 m_owner->DrawImage( item->GetImage(), dc, m_bound_icon.x, m_bound_icon.y );
1111 }
1112 if (item->HasText())
1113 {
1114 dc->DrawText( item->GetText(), m_bound_label.x, m_bound_label.y );
1115 }
1116 }
1117 }
1118 }
1119
1120 void wxListLineData::Hilight( bool on )
1121 {
1122 if (on == m_hilighted) return;
1123 m_hilighted = on;
1124 if (on)
1125 m_owner->SelectLine( this );
1126 else
1127 m_owner->DeselectLine( this );
1128 }
1129
1130 void wxListLineData::ReverseHilight( void )
1131 {
1132 m_hilighted = !m_hilighted;
1133 if (m_hilighted)
1134 m_owner->SelectLine( this );
1135 else
1136 m_owner->DeselectLine( this );
1137 }
1138
1139 void wxListLineData::DrawRubberBand( wxDC *dc, bool on )
1140 {
1141 if (on)
1142 {
1143 dc->SetPen( * wxBLACK_PEN );
1144 dc->SetBrush( * wxTRANSPARENT_BRUSH );
1145 dc->DrawRectangle( m_bound_hilight.x, m_bound_hilight.y,
1146 m_bound_hilight.width, m_bound_hilight.height );
1147 }
1148 }
1149
1150 void wxListLineData::Draw( wxDC *dc )
1151 {
1152 DoDraw( dc, m_hilighted, m_hilighted );
1153 }
1154
1155 bool wxListLineData::IsInRect( int x, int y, const wxRect &rect )
1156 {
1157 return ((x >= rect.x) && (x <= rect.x+rect.width) &&
1158 (y >= rect.y) && (y <= rect.y+rect.height));
1159 }
1160
1161 bool wxListLineData::IsHilighted( void )
1162 {
1163 return m_hilighted;
1164 }
1165
1166 void wxListLineData::AssignRect( wxRect &dest, int x, int y, int width, int height )
1167 {
1168 dest.x = x;
1169 dest.y = y;
1170 dest.width = width;
1171 dest.height = height;
1172 }
1173
1174 void wxListLineData::AssignRect( wxRect &dest, const wxRect &source )
1175 {
1176 dest.x = source.x;
1177 dest.y = source.y;
1178 dest.width = source.width;
1179 dest.height = source.height;
1180 }
1181
1182 //-----------------------------------------------------------------------------
1183 // wxListHeaderWindow
1184 //-----------------------------------------------------------------------------
1185
1186 IMPLEMENT_DYNAMIC_CLASS(wxListHeaderWindow,wxWindow);
1187
1188 BEGIN_EVENT_TABLE(wxListHeaderWindow,wxWindow)
1189 EVT_PAINT (wxListHeaderWindow::OnPaint)
1190 EVT_MOUSE_EVENTS (wxListHeaderWindow::OnMouse)
1191 EVT_SET_FOCUS (wxListHeaderWindow::OnSetFocus)
1192 END_EVENT_TABLE()
1193
1194 wxListHeaderWindow::wxListHeaderWindow( void )
1195 {
1196 m_owner = (wxListMainWindow *) NULL;
1197 m_currentCursor = (wxCursor *) NULL;
1198 m_resizeCursor = (wxCursor *) NULL;
1199 m_isDragging = FALSE;
1200 }
1201
1202 wxListHeaderWindow::wxListHeaderWindow( wxWindow *win, wxWindowID id, wxListMainWindow *owner,
1203 const wxPoint &pos, const wxSize &size,
1204 long style, const wxString &name ) :
1205 wxWindow( win, id, pos, size, style, name )
1206 {
1207 m_owner = owner;
1208 // m_currentCursor = wxSTANDARD_CURSOR;
1209 m_currentCursor = (wxCursor *) NULL;
1210 m_resizeCursor = new wxCursor( wxCURSOR_SIZEWE );
1211 m_isDragging = FALSE;
1212 m_dirty = FALSE;
1213
1214 SetBackgroundColour( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE ) );
1215 }
1216
1217 wxListHeaderWindow::~wxListHeaderWindow( void )
1218 {
1219 delete m_resizeCursor;
1220 }
1221
1222 void wxListHeaderWindow::DoDrawRect( wxDC *dc, int x, int y, int w, int h )
1223 {
1224 #ifdef __WXGTK__
1225 GtkStateType state = GTK_STATE_NORMAL;
1226 if (!m_parent->IsEnabled()) state = GTK_STATE_INSENSITIVE;
1227
1228 x = dc->XLOG2DEV( x );
1229
1230 gtk_paint_box (m_wxwindow->style, GTK_PIZZA(m_wxwindow)->bin_window, state, GTK_SHADOW_OUT,
1231 (GdkRectangle*) NULL, m_wxwindow, "button", x-1, y-1, w+2, h+2);
1232 #else
1233 const int m_corner = 1;
1234
1235 dc->SetBrush( *wxTRANSPARENT_BRUSH );
1236
1237 dc->SetPen( *wxBLACK_PEN );
1238 dc->DrawLine( x+w-m_corner+1, y, x+w, y+h ); // right (outer)
1239 dc->DrawRectangle( x, y+h, w+1, 1 ); // bottom (outer)
1240
1241 wxPen pen( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNSHADOW ), 1, wxSOLID );
1242
1243 dc->SetPen( pen );
1244 dc->DrawLine( x+w-m_corner, y, x+w-1, y+h ); // right (inner)
1245 dc->DrawRectangle( x+1, y+h-1, w-2, 1 ); // bottom (inner)
1246
1247 dc->SetPen( *wxWHITE_PEN );
1248 dc->DrawRectangle( x, y, w-m_corner+1, 1 ); // top (outer)
1249 dc->DrawRectangle( x, y, 1, h ); // left (outer)
1250 dc->DrawLine( x, y+h-1, x+1, y+h-1 );
1251 dc->DrawLine( x+w-1, y, x+w-1, y+1 );
1252 #endif
1253 }
1254
1255 // shift the DC origin to match the position of the main window horz
1256 // scrollbar: this allows us to always use logical coords
1257 void wxListHeaderWindow::AdjustDC(wxDC& dc)
1258 {
1259 #if wxUSE_GENERIC_LIST_EXTENSIONS
1260 int xpix;
1261 m_owner->GetScrollPixelsPerUnit( &xpix, NULL );
1262
1263 int x;
1264 m_owner->GetViewStart( &x, NULL );
1265
1266 // account for the horz scrollbar offset
1267 dc.SetDeviceOrigin( -x * xpix, 0 );
1268 #endif // wxUSE_GENERIC_LIST_EXTENSIONS
1269 }
1270
1271 void wxListHeaderWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
1272 {
1273 #ifdef __WXGTK__
1274 wxClientDC dc( this );
1275 #else
1276 wxPaintDC dc( this );
1277 #endif
1278
1279 PrepareDC( dc );
1280 AdjustDC( dc );
1281
1282 dc.BeginDrawing();
1283
1284 dc.SetFont( GetFont() );
1285
1286 // width and height of the entire header window
1287 int w, h;
1288 GetClientSize( &w, &h );
1289 #if wxUSE_GENERIC_LIST_EXTENSIONS
1290 m_owner->CalcUnscrolledPosition(w, 0, &w, NULL);
1291 #endif // wxUSE_GENERIC_LIST_EXTENSIONS
1292
1293 dc.SetBackgroundMode(wxTRANSPARENT);
1294
1295 // do *not* use the listctrl colour for headers - one day we will have a
1296 // function to set it separately
1297 //dc.SetTextForeground( *wxBLACK );
1298 dc.SetTextForeground(wxSystemSettings::GetSystemColour( wxSYS_COLOUR_WINDOWTEXT ));
1299
1300 int x = 1; // left of the header rect
1301 const int y = 1; // top
1302 int numColumns = m_owner->GetColumnCount();
1303 wxListItem item;
1304 for (int i = 0; i < numColumns; i++)
1305 {
1306 m_owner->GetColumn( i, item );
1307 int wCol = item.m_width;
1308 int cw = wCol - 2; // the width of the rect to draw
1309
1310 int xEnd = x + wCol;
1311
1312 // VZ: no, draw it normally - this is better now as we allow resizing
1313 // of the last column as well
1314 #if 0
1315 // let the last column occupy all available space
1316 if ( i == numColumns - 1 )
1317 cw = w-x-1;
1318 #endif // 0
1319
1320 dc.SetPen( *wxWHITE_PEN );
1321
1322 DoDrawRect( &dc, x, y, cw, h-2 );
1323 dc.SetClippingRegion( x, y, cw-5, h-4 );
1324 dc.DrawText( item.m_text, x+4, y+3 );
1325 dc.DestroyClippingRegion();
1326 x += wCol;
1327
1328 if (xEnd > w+5)
1329 break;
1330 }
1331 dc.EndDrawing();
1332 }
1333
1334 void wxListHeaderWindow::DrawCurrent()
1335 {
1336 int x1 = m_currentX;
1337 int y1 = 0;
1338 ClientToScreen( &x1, &y1 );
1339
1340 int x2 = m_currentX-1;
1341 int y2 = 0;
1342 m_owner->GetClientSize( NULL, &y2 );
1343 m_owner->ClientToScreen( &x2, &y2 );
1344
1345 wxScreenDC dc;
1346 dc.SetLogicalFunction( wxINVERT );
1347 dc.SetPen( wxPen( *wxBLACK, 2, wxSOLID ) );
1348 dc.SetBrush( *wxTRANSPARENT_BRUSH );
1349
1350 AdjustDC(dc);
1351
1352 dc.DrawLine( x1, y1, x2, y2 );
1353
1354 dc.SetLogicalFunction( wxCOPY );
1355
1356 dc.SetPen( wxNullPen );
1357 dc.SetBrush( wxNullBrush );
1358 }
1359
1360 void wxListHeaderWindow::OnMouse( wxMouseEvent &event )
1361 {
1362 // we want to work with logical coords
1363 #if wxUSE_GENERIC_LIST_EXTENSIONS
1364 int x;
1365 m_owner->CalcUnscrolledPosition(event.GetX(), 0, &x, NULL);
1366 #else // !wxUSE_GENERIC_LIST_EXTENSIONS
1367 int x = event.GetX();
1368 #endif // wxUSE_GENERIC_LIST_EXTENSIONS
1369 int y = event.GetY();
1370
1371 if (m_isDragging)
1372 {
1373 // we don't draw the line beyond our window, but we allow dragging it
1374 // there
1375 int w = 0;
1376 GetClientSize( &w, NULL );
1377 #if wxUSE_GENERIC_LIST_EXTENSIONS
1378 m_owner->CalcUnscrolledPosition(w, 0, &w, NULL);
1379 #endif // wxUSE_GENERIC_LIST_EXTENSIONS
1380 w -= 6;
1381
1382 // erase the line if it was drawn
1383 if ( m_currentX < w )
1384 DrawCurrent();
1385
1386 if (event.ButtonUp())
1387 {
1388 ReleaseMouse();
1389 m_isDragging = FALSE;
1390 m_dirty = TRUE;
1391 m_owner->SetColumnWidth( m_column, m_currentX - m_minX );
1392 }
1393 else
1394 {
1395 if (x > m_minX + 7)
1396 m_currentX = x;
1397 else
1398 m_currentX = m_minX + 7;
1399
1400 // draw in the new location
1401 if ( m_currentX < w )
1402 DrawCurrent();
1403 }
1404 }
1405 else // not dragging
1406 {
1407 m_minX = 0;
1408 bool hit_border = FALSE;
1409
1410 // end of the current column
1411 int xpos = 0;
1412
1413 // find the column where this event occured
1414 int countCol = m_owner->GetColumnCount();
1415 for (int j = 0; j < countCol; j++)
1416 {
1417 xpos += m_owner->GetColumnWidth( j );
1418 m_column = j;
1419
1420 if ( (abs(x-xpos) < 3) && (y < 22) )
1421 {
1422 // near the column border
1423 hit_border = TRUE;
1424 break;
1425 }
1426
1427 if ( x < xpos )
1428 {
1429 // inside the column
1430 break;
1431 }
1432
1433 m_minX = xpos;
1434 }
1435
1436 if (event.LeftDown())
1437 {
1438 if (hit_border)
1439 {
1440 m_isDragging = TRUE;
1441 m_currentX = x;
1442 DrawCurrent();
1443 CaptureMouse();
1444 }
1445 else
1446 {
1447 wxWindow *parent = GetParent();
1448 wxListEvent le( wxEVT_COMMAND_LIST_COL_CLICK, parent->GetId() );
1449 le.SetEventObject( parent );
1450 le.m_col = m_column;
1451 parent->GetEventHandler()->ProcessEvent( le );
1452 }
1453 }
1454 else if (event.Moving())
1455 {
1456 bool setCursor;
1457 if (hit_border)
1458 {
1459 setCursor = m_currentCursor == wxSTANDARD_CURSOR;
1460 m_currentCursor = m_resizeCursor;
1461 }
1462 else
1463 {
1464 setCursor = m_currentCursor != wxSTANDARD_CURSOR;
1465 m_currentCursor = wxSTANDARD_CURSOR;
1466 }
1467
1468 if ( setCursor )
1469 SetCursor(*m_currentCursor);
1470 }
1471 }
1472 }
1473
1474 void wxListHeaderWindow::OnSetFocus( wxFocusEvent &WXUNUSED(event) )
1475 {
1476 m_owner->SetFocus();
1477 }
1478
1479 //-----------------------------------------------------------------------------
1480 // wxListRenameTimer (internal)
1481 //-----------------------------------------------------------------------------
1482
1483 wxListRenameTimer::wxListRenameTimer( wxListMainWindow *owner )
1484 {
1485 m_owner = owner;
1486 }
1487
1488 void wxListRenameTimer::Notify()
1489 {
1490 m_owner->OnRenameTimer();
1491 }
1492
1493 //-----------------------------------------------------------------------------
1494 // wxListTextCtrl (internal)
1495 //-----------------------------------------------------------------------------
1496
1497 IMPLEMENT_DYNAMIC_CLASS(wxListTextCtrl,wxTextCtrl);
1498
1499 BEGIN_EVENT_TABLE(wxListTextCtrl,wxTextCtrl)
1500 EVT_CHAR (wxListTextCtrl::OnChar)
1501 EVT_KEY_UP (wxListTextCtrl::OnKeyUp)
1502 EVT_KILL_FOCUS (wxListTextCtrl::OnKillFocus)
1503 END_EVENT_TABLE()
1504
1505 wxListTextCtrl::wxListTextCtrl( wxWindow *parent,
1506 const wxWindowID id,
1507 bool *accept,
1508 wxString *res,
1509 wxListMainWindow *owner,
1510 const wxString &value,
1511 const wxPoint &pos,
1512 const wxSize &size,
1513 int style,
1514 const wxValidator& validator,
1515 const wxString &name )
1516 : wxTextCtrl( parent, id, value, pos, size, style, validator, name )
1517 {
1518 m_res = res;
1519 m_accept = accept;
1520 m_owner = owner;
1521 (*m_accept) = FALSE;
1522 (*m_res) = "";
1523 m_startValue = value;
1524 }
1525
1526 void wxListTextCtrl::OnChar( wxKeyEvent &event )
1527 {
1528 if (event.m_keyCode == WXK_RETURN)
1529 {
1530 (*m_accept) = TRUE;
1531 (*m_res) = GetValue();
1532
1533 if (!wxPendingDelete.Member(this))
1534 wxPendingDelete.Append(this);
1535
1536 if ((*m_accept) && ((*m_res) != m_startValue))
1537 m_owner->OnRenameAccept();
1538
1539 return;
1540 }
1541 if (event.m_keyCode == WXK_ESCAPE)
1542 {
1543 (*m_accept) = FALSE;
1544 (*m_res) = "";
1545
1546 if (!wxPendingDelete.Member(this))
1547 wxPendingDelete.Append(this);
1548
1549 return;
1550 }
1551
1552 event.Skip();
1553 }
1554
1555 void wxListTextCtrl::OnKeyUp( wxKeyEvent &event )
1556 {
1557 // auto-grow the textctrl:
1558 wxSize parentSize = m_owner->GetSize();
1559 wxPoint myPos = GetPosition();
1560 wxSize mySize = GetSize();
1561 int sx, sy;
1562 GetTextExtent(GetValue() + _T("MM"), &sx, &sy);
1563 if (myPos.x + sx > parentSize.x) sx = parentSize.x - myPos.x;
1564 if (mySize.x > sx) sx = mySize.x;
1565 SetSize(sx, -1);
1566
1567 event.Skip();
1568 }
1569
1570 void wxListTextCtrl::OnKillFocus( wxFocusEvent &WXUNUSED(event) )
1571 {
1572 if (!wxPendingDelete.Member(this))
1573 wxPendingDelete.Append(this);
1574
1575 if ((*m_accept) && ((*m_res) != m_startValue))
1576 m_owner->OnRenameAccept();
1577 }
1578
1579 //-----------------------------------------------------------------------------
1580 // wxListMainWindow
1581 //-----------------------------------------------------------------------------
1582
1583 IMPLEMENT_DYNAMIC_CLASS(wxListMainWindow,wxScrolledWindow);
1584
1585 BEGIN_EVENT_TABLE(wxListMainWindow,wxScrolledWindow)
1586 EVT_PAINT (wxListMainWindow::OnPaint)
1587 EVT_SIZE (wxListMainWindow::OnSize)
1588 EVT_MOUSE_EVENTS (wxListMainWindow::OnMouse)
1589 EVT_CHAR (wxListMainWindow::OnChar)
1590 EVT_KEY_DOWN (wxListMainWindow::OnKeyDown)
1591 EVT_SET_FOCUS (wxListMainWindow::OnSetFocus)
1592 EVT_KILL_FOCUS (wxListMainWindow::OnKillFocus)
1593 EVT_SCROLLWIN (wxListMainWindow::OnScroll)
1594 END_EVENT_TABLE()
1595
1596 wxListMainWindow::wxListMainWindow()
1597 {
1598 m_mode = 0;
1599 m_columns.DeleteContents( TRUE );
1600 m_current = (wxListLineData *) NULL;
1601 m_visibleLines = 0;
1602 m_hilightBrush = (wxBrush *) NULL;
1603 m_xScroll = 0;
1604 m_yScroll = 0;
1605 m_dirty = TRUE;
1606 m_small_image_list = (wxImageList *) NULL;
1607 m_normal_image_list = (wxImageList *) NULL;
1608 m_small_spacing = 30;
1609 m_normal_spacing = 40;
1610 m_hasFocus = FALSE;
1611 m_usedKeys = TRUE;
1612 m_lastOnSame = FALSE;
1613 m_renameTimer = new wxListRenameTimer( this );
1614 m_isCreated = FALSE;
1615 m_dragCount = 0;
1616
1617 m_lineLastClicked =
1618 m_lineBeforeLastClicked = (wxListLineData *)NULL;
1619 }
1620
1621 wxListMainWindow::wxListMainWindow( wxWindow *parent, wxWindowID id,
1622 const wxPoint &pos, const wxSize &size,
1623 long style, const wxString &name ) :
1624 wxScrolledWindow( parent, id, pos, size, style|wxHSCROLL|wxVSCROLL, name )
1625 {
1626 m_mode = style;
1627 m_columns.DeleteContents( TRUE );
1628 m_current = (wxListLineData *) NULL;
1629 m_dirty = TRUE;
1630 m_visibleLines = 0;
1631 m_hilightBrush = new wxBrush( wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHT), wxSOLID );
1632 m_small_image_list = (wxImageList *) NULL;
1633 m_normal_image_list = (wxImageList *) NULL;
1634 m_small_spacing = 30;
1635 m_normal_spacing = 40;
1636 m_hasFocus = FALSE;
1637 m_dragCount = 0;
1638 m_isCreated = FALSE;
1639 wxSize sz = size;
1640 sz.y = 25;
1641
1642 if (m_mode & wxLC_REPORT)
1643 {
1644 #if wxUSE_GENERIC_LIST_EXTENSIONS
1645 m_xScroll = 15;
1646 #else
1647 m_xScroll = 0;
1648 #endif
1649 m_yScroll = 15;
1650 }
1651 else
1652 {
1653 m_xScroll = 15;
1654 m_yScroll = 0;
1655 }
1656 SetScrollbars( m_xScroll, m_yScroll, 0, 0, 0, 0 );
1657
1658 m_usedKeys = TRUE;
1659 m_lastOnSame = FALSE;
1660 m_renameTimer = new wxListRenameTimer( this );
1661 m_renameAccept = FALSE;
1662
1663 SetBackgroundColour( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_LISTBOX ) );
1664 }
1665
1666 wxListMainWindow::~wxListMainWindow()
1667 {
1668 DeleteEverything();
1669
1670 if (m_hilightBrush) delete m_hilightBrush;
1671
1672 delete m_renameTimer;
1673 }
1674
1675 void wxListMainWindow::RefreshLine( wxListLineData *line )
1676 {
1677 if (m_dirty) return;
1678
1679 if (!line) return;
1680
1681 int x = 0;
1682 int y = 0;
1683 int w = 0;
1684 int h = 0;
1685 line->GetExtent( x, y, w, h );
1686 CalcScrolledPosition( x, y, &x, &y );
1687 wxRect rect( x, y, w, h );
1688 Refresh( TRUE, &rect );
1689 }
1690
1691 void wxListMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
1692 {
1693 // Note: a wxPaintDC must be constructed even if no drawing is
1694 // done (a Windows requirement).
1695 wxPaintDC dc( this );
1696 PrepareDC( dc );
1697
1698 int dev_x = 0;
1699 int dev_y = 0;
1700 CalcScrolledPosition( 0, 0, &dev_x, &dev_y );
1701
1702 if (m_dirty) return;
1703
1704 if (m_lines.GetCount() == 0) return;
1705
1706 dc.BeginDrawing();
1707
1708 dc.SetFont( GetFont() );
1709
1710 if (m_mode & wxLC_REPORT)
1711 {
1712 wxPen pen(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DLIGHT), 1, wxSOLID);
1713 wxSize clientSize = GetClientSize();
1714
1715 int lineSpacing = 0;
1716 wxListLineData *line = &m_lines[0];
1717 int dummy = 0;
1718 line->GetSize( dummy, lineSpacing );
1719 lineSpacing += 1;
1720
1721 int y_s = m_yScroll*GetScrollPos( wxVERTICAL );
1722
1723 size_t i_to = y_s / lineSpacing + m_visibleLines+2;
1724 if (i_to >= m_lines.GetCount()) i_to = m_lines.GetCount();
1725 size_t i;
1726 for (i = y_s / lineSpacing; i < i_to; i++)
1727 {
1728 m_lines[i].Draw( &dc );
1729 // Draw horizontal rule if required
1730 if (GetWindowStyle() & wxLC_HRULES)
1731 {
1732 dc.SetPen(pen);
1733 dc.SetBrush(* wxTRANSPARENT_BRUSH);
1734 dc.DrawLine(0 - dev_x , i*lineSpacing , clientSize.x - dev_x , i*lineSpacing );
1735 }
1736 }
1737
1738 // Draw last horizontal rule
1739 if ((i > (size_t) (y_s / lineSpacing)) && (GetWindowStyle() & wxLC_HRULES))
1740 {
1741 dc.SetPen(pen);
1742 dc.SetBrush(* wxTRANSPARENT_BRUSH);
1743 dc.DrawLine(0 - dev_x , i*lineSpacing , clientSize.x - dev_x , i*lineSpacing );
1744 }
1745
1746 // Draw vertical rules if required
1747 if ((GetWindowStyle() & wxLC_VRULES) && (GetItemCount() > 0))
1748 {
1749 int col = 0;
1750 wxRect firstItemRect;
1751 wxRect lastItemRect;
1752 GetItemRect(0, firstItemRect);
1753 GetItemRect(GetItemCount() - 1, lastItemRect);
1754 int x = firstItemRect.GetX();
1755 dc.SetPen(pen);
1756 dc.SetBrush(* wxTRANSPARENT_BRUSH);
1757 for (col = 0; col < GetColumnCount(); col++)
1758 {
1759 int colWidth = GetColumnWidth(col);
1760 x += colWidth ;
1761 dc.DrawLine(x - dev_x, firstItemRect.GetY() - 1 - dev_y, x - dev_x, lastItemRect.GetBottom() + 1 - dev_y);
1762 }
1763 }
1764 }
1765 else
1766 {
1767 for (size_t i = 0; i < m_lines.GetCount(); i++)
1768 m_lines[i].Draw( &dc );
1769 }
1770
1771 if (m_current) m_current->DrawRubberBand( &dc, m_hasFocus );
1772
1773 dc.EndDrawing();
1774 }
1775
1776 void wxListMainWindow::HilightAll( bool on )
1777 {
1778 for (size_t i = 0; i < m_lines.GetCount(); i++)
1779 {
1780 wxListLineData *line = &m_lines[i];
1781 if (line->IsHilighted() != on)
1782 {
1783 line->Hilight( on );
1784 RefreshLine( line );
1785 }
1786 }
1787 }
1788
1789 void wxListMainWindow::SendNotify( wxListLineData *line,
1790 wxEventType command,
1791 wxPoint point )
1792 {
1793 wxListEvent le( command, GetParent()->GetId() );
1794 le.SetEventObject( GetParent() );
1795 le.m_itemIndex = GetIndexOfLine( line );
1796
1797 // set only for events which have position
1798 if ( point != wxDefaultPosition )
1799 le.m_pointDrag = point;
1800
1801 line->GetItem( 0, le.m_item );
1802 GetParent()->GetEventHandler()->ProcessEvent( le );
1803 // GetParent()->GetEventHandler()->AddPendingEvent( le );
1804 }
1805
1806 void wxListMainWindow::FocusLine( wxListLineData *WXUNUSED(line) )
1807 {
1808 // SendNotify( line, wxEVT_COMMAND_LIST_ITEM_FOCUSSED );
1809 }
1810
1811 void wxListMainWindow::UnfocusLine( wxListLineData *WXUNUSED(line) )
1812 {
1813 // SendNotify( line, wxEVT_COMMAND_LIST_ITEM_UNFOCUSSED );
1814 }
1815
1816 void wxListMainWindow::SelectLine( wxListLineData *line )
1817 {
1818 SendNotify( line, wxEVT_COMMAND_LIST_ITEM_SELECTED );
1819 }
1820
1821 void wxListMainWindow::DeselectLine( wxListLineData *line )
1822 {
1823 SendNotify( line, wxEVT_COMMAND_LIST_ITEM_DESELECTED );
1824 }
1825
1826 void wxListMainWindow::DeleteLine( wxListLineData *line )
1827 {
1828 SendNotify( line, wxEVT_COMMAND_LIST_DELETE_ITEM );
1829 }
1830
1831 /* *** */
1832
1833 void wxListMainWindow::EditLabel( long item )
1834 {
1835 wxCHECK_RET( ((size_t)item < m_lines.GetCount()),
1836 wxT("wrong index in wxListCtrl::Edit()") );
1837
1838 m_currentEdit = &m_lines[(size_t)item];
1839
1840 wxListEvent le( wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT, GetParent()->GetId() );
1841 le.SetEventObject( GetParent() );
1842 le.m_itemIndex = GetIndexOfLine( m_currentEdit );
1843 m_currentEdit->GetItem( 0, le.m_item );
1844 GetParent()->GetEventHandler()->ProcessEvent( le );
1845
1846 if (!le.IsAllowed())
1847 return;
1848
1849 // We have to call this here because the label in
1850 // question might just have been added and no screen
1851 // update taken place.
1852 if (m_dirty) wxYield();
1853
1854 wxString s;
1855 m_currentEdit->GetText( 0, s );
1856 int x = 0;
1857 int y = 0;
1858 int w = 0;
1859 int h = 0;
1860 m_currentEdit->GetLabelExtent( x, y, w, h );
1861
1862 wxClientDC dc(this);
1863 PrepareDC( dc );
1864 x = dc.LogicalToDeviceX( x );
1865 y = dc.LogicalToDeviceY( y );
1866
1867 wxListTextCtrl *text = new wxListTextCtrl(
1868 this, -1, &m_renameAccept, &m_renameRes, this, s, wxPoint(x-4,y-4), wxSize(w+11,h+8) );
1869 text->SetFocus();
1870 }
1871
1872 void wxListMainWindow::OnRenameTimer()
1873 {
1874 wxCHECK_RET( m_current, wxT("invalid m_current") );
1875
1876 Edit( m_lines.Index( *m_current ) );
1877 }
1878
1879 void wxListMainWindow::OnRenameAccept()
1880 {
1881 wxListEvent le( wxEVT_COMMAND_LIST_END_LABEL_EDIT, GetParent()->GetId() );
1882 le.SetEventObject( GetParent() );
1883 le.m_itemIndex = GetIndexOfLine( m_currentEdit );
1884 m_currentEdit->GetItem( 0, le.m_item );
1885 le.m_item.m_text = m_renameRes;
1886 GetParent()->GetEventHandler()->ProcessEvent( le );
1887
1888 if (!le.IsAllowed()) return;
1889
1890 wxListItem info;
1891 info.m_mask = wxLIST_MASK_TEXT;
1892 info.m_itemId = le.m_itemIndex;
1893 info.m_text = m_renameRes;
1894 info.SetTextColour(le.m_item.GetTextColour());
1895 SetItem( info );
1896 }
1897
1898 void wxListMainWindow::OnMouse( wxMouseEvent &event )
1899 {
1900 event.SetEventObject( GetParent() );
1901 if (GetParent()->GetEventHandler()->ProcessEvent( event)) return;
1902
1903 if (!m_current) return;
1904 if (m_dirty) return;
1905 if ( !(event.Dragging() || event.ButtonDown() || event.LeftUp() || event.ButtonDClick()) ) return;
1906
1907 int x = event.GetX();
1908 int y = event.GetY();
1909 CalcUnscrolledPosition( x, y, &x, &y );
1910
1911 /* Did we actually hit an item ? */
1912 long hitResult = 0;
1913 wxListLineData *line = (wxListLineData *) NULL;
1914 for (size_t i = 0; i < m_lines.GetCount(); i++)
1915 {
1916 line = &m_lines[i];
1917 hitResult = line->IsHit( x, y );
1918 if (hitResult) break;
1919 line = (wxListLineData *) NULL;
1920 }
1921
1922 if (event.Dragging())
1923 {
1924 if (m_dragCount == 0)
1925 m_dragStart = wxPoint(x,y);
1926
1927 m_dragCount++;
1928
1929 if (m_dragCount != 3) return;
1930
1931 int command = event.RightIsDown() ? wxEVT_COMMAND_LIST_BEGIN_RDRAG
1932 : wxEVT_COMMAND_LIST_BEGIN_DRAG;
1933
1934 wxListEvent le( command, GetParent()->GetId() );
1935 le.SetEventObject( GetParent() );
1936 le.m_pointDrag = m_dragStart;
1937 GetParent()->GetEventHandler()->ProcessEvent( le );
1938
1939 return;
1940 }
1941 else
1942 {
1943 m_dragCount = 0;
1944 }
1945
1946 if (!line) return;
1947
1948 bool forceClick = FALSE;
1949 if (event.ButtonDClick())
1950 {
1951 m_renameTimer->Stop();
1952 m_lastOnSame = FALSE;
1953
1954 if ( line == m_lineBeforeLastClicked )
1955 {
1956 m_usedKeys = FALSE;
1957
1958 SendNotify( line, wxEVT_COMMAND_LIST_ITEM_ACTIVATED );
1959
1960 return;
1961 }
1962 else
1963 {
1964 // the first click was on another item, so don't interpret this as
1965 // a double click, but as a simple click instead
1966 forceClick = TRUE;
1967 }
1968 }
1969
1970 if (event.LeftUp() && m_lastOnSame)
1971 {
1972 m_usedKeys = FALSE;
1973 if ((line == m_current) &&
1974 (hitResult == wxLIST_HITTEST_ONITEMLABEL) &&
1975 (m_mode & wxLC_EDIT_LABELS) )
1976 {
1977 m_renameTimer->Start( 100, TRUE );
1978 }
1979 m_lastOnSame = FALSE;
1980 return;
1981 }
1982
1983 if (event.RightDown())
1984 {
1985 SendNotify( line, wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK,
1986 event.GetPosition() );
1987 return;
1988 }
1989
1990 if (event.MiddleDown())
1991 {
1992 SendNotify( line, wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK );
1993 return;
1994 }
1995
1996 if ( event.LeftDown() || forceClick )
1997 {
1998 m_lineBeforeLastClicked = m_lineLastClicked;
1999 m_lineLastClicked = line;
2000
2001 m_usedKeys = FALSE;
2002 wxListLineData *oldCurrent = m_current;
2003 if (m_mode & wxLC_SINGLE_SEL)
2004 {
2005 m_current = line;
2006 HilightAll( FALSE );
2007 m_current->ReverseHilight();
2008 RefreshLine( m_current );
2009 }
2010 else
2011 {
2012 if (event.ControlDown())
2013 {
2014 m_current = line;
2015 m_current->ReverseHilight();
2016 RefreshLine( m_current );
2017 }
2018 else if (event.ShiftDown())
2019 {
2020 size_t j;
2021
2022 m_current = line;
2023
2024 int numOfCurrent = -1;
2025 for (j = 0; j < m_lines.GetCount(); j++)
2026 {
2027 wxListLineData *test_line = &m_lines[j];
2028 numOfCurrent++;
2029 if (test_line == oldCurrent) break;
2030 }
2031
2032 int numOfLine = -1;
2033
2034 for (j = 0; j < m_lines.GetCount(); j++)
2035 {
2036 wxListLineData *test_line = &m_lines[j];
2037 numOfLine++;
2038 if (test_line == line) break;
2039 }
2040
2041 if (numOfLine < numOfCurrent)
2042 {
2043 int i = numOfLine;
2044 numOfLine = numOfCurrent;
2045 numOfCurrent = i;
2046 }
2047
2048 for (int i = 0; i <= numOfLine-numOfCurrent; i++)
2049 {
2050 wxListLineData *test_line= &m_lines[numOfCurrent + i];
2051 test_line->Hilight(TRUE);
2052 RefreshLine( test_line );
2053 }
2054 }
2055 else
2056 {
2057 m_current = line;
2058 HilightAll( FALSE );
2059 m_current->ReverseHilight();
2060 RefreshLine( m_current );
2061 }
2062 }
2063 if (m_current != oldCurrent)
2064 {
2065 RefreshLine( oldCurrent );
2066 UnfocusLine( oldCurrent );
2067 FocusLine( m_current );
2068 }
2069
2070 // forceClick is only set if the previous click was on another item
2071 m_lastOnSame = !forceClick && (m_current == oldCurrent);
2072
2073 return;
2074 }
2075 }
2076
2077 void wxListMainWindow::MoveToFocus()
2078 {
2079 if (!m_current) return;
2080
2081 int item_x = 0;
2082 int item_y = 0;
2083 int item_w = 0;
2084 int item_h = 0;
2085 m_current->GetExtent( item_x, item_y, item_w, item_h );
2086
2087 int client_w = 0;
2088 int client_h = 0;
2089 GetClientSize( &client_w, &client_h );
2090
2091 int view_x = m_xScroll*GetScrollPos( wxHORIZONTAL );
2092 int view_y = m_yScroll*GetScrollPos( wxVERTICAL );
2093
2094 if (m_mode & wxLC_REPORT)
2095 {
2096 if (item_y < view_y )
2097 Scroll( -1, (item_y)/m_yScroll );
2098 if (item_y+item_h+5 > view_y+client_h)
2099 Scroll( -1, (item_y+item_h-client_h+15)/m_yScroll );
2100 }
2101 else
2102 {
2103 if (item_x-view_x < 5)
2104 Scroll( (item_x-5)/m_xScroll, -1 );
2105 if (item_x+item_w-5 > view_x+client_w)
2106 Scroll( (item_x+item_w-client_w+15)/m_xScroll, -1 );
2107 }
2108 }
2109
2110 void wxListMainWindow::OnArrowChar( wxListLineData *newCurrent, bool shiftDown )
2111 {
2112 if ((m_mode & wxLC_SINGLE_SEL) || (m_usedKeys == FALSE)) m_current->Hilight( FALSE );
2113 wxListLineData *oldCurrent = m_current;
2114 m_current = newCurrent;
2115 if (shiftDown || (m_mode & wxLC_SINGLE_SEL)) m_current->Hilight( TRUE );
2116 RefreshLine( m_current );
2117 RefreshLine( oldCurrent );
2118 FocusLine( m_current );
2119 UnfocusLine( oldCurrent );
2120 MoveToFocus();
2121 }
2122
2123 void wxListMainWindow::OnKeyDown( wxKeyEvent &event )
2124 {
2125 wxWindow *parent = GetParent();
2126
2127 /* we propagate the key event up */
2128 wxKeyEvent ke( wxEVT_KEY_DOWN );
2129 ke.m_shiftDown = event.m_shiftDown;
2130 ke.m_controlDown = event.m_controlDown;
2131 ke.m_altDown = event.m_altDown;
2132 ke.m_metaDown = event.m_metaDown;
2133 ke.m_keyCode = event.m_keyCode;
2134 ke.m_x = event.m_x;
2135 ke.m_y = event.m_y;
2136 ke.SetEventObject( parent );
2137 if (parent->GetEventHandler()->ProcessEvent( ke )) return;
2138
2139 event.Skip();
2140 }
2141
2142 void wxListMainWindow::OnChar( wxKeyEvent &event )
2143 {
2144 wxWindow *parent = GetParent();
2145
2146 /* we send a list_key event up */
2147 if ( m_current )
2148 {
2149 wxListEvent le( wxEVT_COMMAND_LIST_KEY_DOWN, GetParent()->GetId() );
2150 le.m_itemIndex = GetIndexOfLine( m_current );
2151 m_current->GetItem( 0, le.m_item );
2152 le.m_code = (int)event.KeyCode();
2153 le.SetEventObject( parent );
2154 parent->GetEventHandler()->ProcessEvent( le );
2155 }
2156
2157 /* we propagate the char event up */
2158 wxKeyEvent ke( wxEVT_CHAR );
2159 ke.m_shiftDown = event.m_shiftDown;
2160 ke.m_controlDown = event.m_controlDown;
2161 ke.m_altDown = event.m_altDown;
2162 ke.m_metaDown = event.m_metaDown;
2163 ke.m_keyCode = event.m_keyCode;
2164 ke.m_x = event.m_x;
2165 ke.m_y = event.m_y;
2166 ke.SetEventObject( parent );
2167 if (parent->GetEventHandler()->ProcessEvent( ke )) return;
2168
2169 if (event.KeyCode() == WXK_TAB)
2170 {
2171 wxNavigationKeyEvent nevent;
2172 nevent.SetWindowChange( event.ControlDown() );
2173 nevent.SetDirection( !event.ShiftDown() );
2174 nevent.SetEventObject( GetParent()->GetParent() );
2175 nevent.SetCurrentFocus( m_parent );
2176 if (GetParent()->GetParent()->GetEventHandler()->ProcessEvent( nevent )) return;
2177 }
2178
2179 /* no item -> nothing to do */
2180 if (!m_current)
2181 {
2182 event.Skip();
2183 return;
2184 }
2185
2186 switch (event.KeyCode())
2187 {
2188 case WXK_UP:
2189 {
2190 int index = m_lines.Index(*m_current);
2191 if (index != wxNOT_FOUND && index > 0)
2192 OnArrowChar( &m_lines[index-1], event.ShiftDown() );
2193 break;
2194 }
2195 case WXK_DOWN:
2196 {
2197 int index = m_lines.Index(*m_current);
2198 if (index != wxNOT_FOUND && (size_t)index < m_lines.GetCount()-1)
2199 OnArrowChar( &m_lines[index+1], event.ShiftDown() );
2200 break;
2201 }
2202 case WXK_END:
2203 {
2204 if (!m_lines.IsEmpty())
2205 OnArrowChar( &m_lines.Last(), event.ShiftDown() );
2206 break;
2207 }
2208 case WXK_HOME:
2209 {
2210 if (!m_lines.IsEmpty())
2211 OnArrowChar( &m_lines[0], event.ShiftDown() );
2212 break;
2213 }
2214 case WXK_PRIOR:
2215 {
2216 int steps = 0;
2217 int index = m_lines.Index(*m_current);
2218 if (m_mode & wxLC_REPORT)
2219 {
2220 steps = m_visibleLines-1;
2221 }
2222 else
2223 {
2224 steps = index % m_visibleLines;
2225 }
2226 if (index != wxNOT_FOUND)
2227 {
2228 index -= steps;
2229 if (index < 0) index = 0;
2230 OnArrowChar( &m_lines[index], event.ShiftDown() );
2231 }
2232 break;
2233 }
2234 case WXK_NEXT:
2235 {
2236 int steps = 0;
2237 int index = m_lines.Index(*m_current);
2238 if (m_mode & wxLC_REPORT)
2239 {
2240 steps = m_visibleLines-1;
2241 }
2242 else
2243 {
2244 steps = m_visibleLines-(index % m_visibleLines)-1;
2245 }
2246
2247 if (index != wxNOT_FOUND)
2248 {
2249 index += steps;
2250 if ((size_t)index >= m_lines.GetCount())
2251 index = m_lines.GetCount()-1;
2252 OnArrowChar( &m_lines[index], event.ShiftDown() );
2253 }
2254 break;
2255 }
2256 case WXK_LEFT:
2257 {
2258 if (!(m_mode & wxLC_REPORT))
2259 {
2260 int index = m_lines.Index(*m_current);
2261 if (index != wxNOT_FOUND)
2262 {
2263 index -= m_visibleLines;
2264 if (index < 0) index = 0;
2265 OnArrowChar( &m_lines[index], event.ShiftDown() );
2266 }
2267 }
2268 break;
2269 }
2270 case WXK_RIGHT:
2271 {
2272 if (!(m_mode & wxLC_REPORT))
2273 {
2274 int index = m_lines.Index(*m_current);
2275 if (index != wxNOT_FOUND)
2276 {
2277 index += m_visibleLines;
2278 if ((size_t)index >= m_lines.GetCount())
2279 index = m_lines.GetCount()-1;
2280 OnArrowChar( &m_lines[index], event.ShiftDown() );
2281 }
2282 }
2283 break;
2284 }
2285 case WXK_SPACE:
2286 {
2287 if (m_mode & wxLC_SINGLE_SEL)
2288 {
2289 wxListEvent le( wxEVT_COMMAND_LIST_ITEM_ACTIVATED, GetParent()->GetId() );
2290 le.SetEventObject( GetParent() );
2291 le.m_itemIndex = GetIndexOfLine( m_current );
2292 m_current->GetItem( 0, le.m_item );
2293 GetParent()->GetEventHandler()->ProcessEvent( le );
2294 }
2295 else
2296 {
2297 m_current->ReverseHilight();
2298 RefreshLine( m_current );
2299 }
2300 break;
2301 }
2302 case WXK_INSERT:
2303 {
2304 if (!(m_mode & wxLC_SINGLE_SEL))
2305 {
2306 wxListLineData *oldCurrent = m_current;
2307 m_current->ReverseHilight();
2308 int index = m_lines.Index( *m_current ) + 1;
2309 if ( (size_t)index < m_lines.GetCount() )
2310 m_current = &m_lines[index];
2311 RefreshLine( oldCurrent );
2312 RefreshLine( m_current );
2313 UnfocusLine( oldCurrent );
2314 FocusLine( m_current );
2315 MoveToFocus();
2316 }
2317 break;
2318 }
2319 case WXK_RETURN:
2320 case WXK_EXECUTE:
2321 {
2322 wxListEvent le( wxEVT_COMMAND_LIST_ITEM_ACTIVATED, GetParent()->GetId() );
2323 le.SetEventObject( GetParent() );
2324 le.m_itemIndex = GetIndexOfLine( m_current );
2325 m_current->GetItem( 0, le.m_item );
2326 GetParent()->GetEventHandler()->ProcessEvent( le );
2327 break;
2328 }
2329 default:
2330 {
2331 event.Skip();
2332 return;
2333 }
2334 }
2335 m_usedKeys = TRUE;
2336 }
2337
2338 #ifdef __WXGTK__
2339 extern wxWindow *g_focusWindow;
2340 #endif
2341
2342 void wxListMainWindow::OnSetFocus( wxFocusEvent &WXUNUSED(event) )
2343 {
2344 m_hasFocus = TRUE;
2345 RefreshLine( m_current );
2346
2347 if (!GetParent()) return;
2348
2349 #ifdef __WXGTK__
2350 g_focusWindow = GetParent();
2351 #endif
2352
2353 wxFocusEvent event( wxEVT_SET_FOCUS, GetParent()->GetId() );
2354 event.SetEventObject( GetParent() );
2355 GetParent()->GetEventHandler()->ProcessEvent( event );
2356 }
2357
2358 void wxListMainWindow::OnKillFocus( wxFocusEvent &WXUNUSED(event) )
2359 {
2360 m_hasFocus = FALSE;
2361 RefreshLine( m_current );
2362 }
2363
2364 void wxListMainWindow::OnSize( wxSizeEvent &WXUNUSED(event) )
2365 {
2366 /*
2367 We don't even allow the wxScrolledWindow::AdjustScrollbars() call
2368
2369 */
2370 m_dirty = TRUE;
2371 }
2372
2373 void wxListMainWindow::DrawImage( int index, wxDC *dc, int x, int y )
2374 {
2375 if ((m_mode & wxLC_ICON) && (m_normal_image_list))
2376 {
2377 m_normal_image_list->Draw( index, *dc, x, y, wxIMAGELIST_DRAW_TRANSPARENT );
2378 return;
2379 }
2380 if ((m_mode & wxLC_SMALL_ICON) && (m_small_image_list))
2381 {
2382 m_small_image_list->Draw( index, *dc, x, y, wxIMAGELIST_DRAW_TRANSPARENT );
2383 }
2384 if ((m_mode & wxLC_LIST) && (m_small_image_list))
2385 {
2386 m_small_image_list->Draw( index, *dc, x, y, wxIMAGELIST_DRAW_TRANSPARENT );
2387 }
2388 if ((m_mode & wxLC_REPORT) && (m_small_image_list))
2389 {
2390 m_small_image_list->Draw( index, *dc, x, y, wxIMAGELIST_DRAW_TRANSPARENT );
2391 return;
2392 }
2393 }
2394
2395 void wxListMainWindow::GetImageSize( int index, int &width, int &height )
2396 {
2397 if ((m_mode & wxLC_ICON) && (m_normal_image_list))
2398 {
2399 m_normal_image_list->GetSize( index, width, height );
2400 return;
2401 }
2402 if ((m_mode & wxLC_SMALL_ICON) && (m_small_image_list))
2403 {
2404 m_small_image_list->GetSize( index, width, height );
2405 return;
2406 }
2407 if ((m_mode & wxLC_LIST) && (m_small_image_list))
2408 {
2409 m_small_image_list->GetSize( index, width, height );
2410 return;
2411 }
2412 if ((m_mode & wxLC_REPORT) && (m_small_image_list))
2413 {
2414 m_small_image_list->GetSize( index, width, height );
2415 return;
2416 }
2417 width = 0;
2418 height = 0;
2419 }
2420
2421 int wxListMainWindow::GetTextLength( wxString &s )
2422 {
2423 wxClientDC dc( this );
2424 wxCoord lw = 0;
2425 wxCoord lh = 0;
2426 dc.GetTextExtent( s, &lw, &lh );
2427 return lw + 6;
2428 }
2429
2430 int wxListMainWindow::GetIndexOfLine( const wxListLineData *line )
2431 {
2432 int i = m_lines.Index(*line);
2433 if (i == wxNOT_FOUND) return -1;
2434 else return i;
2435 }
2436
2437 void wxListMainWindow::SetImageList( wxImageList *imageList, int which )
2438 {
2439 m_dirty = TRUE;
2440
2441 // calc the spacing from the icon size
2442 int width = 0,
2443 height = 0;
2444 if ((imageList) && (imageList->GetImageCount()) )
2445 {
2446 imageList->GetSize(0, width, height);
2447 }
2448
2449 if (which == wxIMAGE_LIST_NORMAL)
2450 {
2451 m_normal_image_list = imageList;
2452 m_normal_spacing = width + 8;
2453 }
2454
2455 if (which == wxIMAGE_LIST_SMALL)
2456 {
2457 m_small_image_list = imageList;
2458 m_small_spacing = width + 14;
2459 }
2460 }
2461
2462 void wxListMainWindow::SetItemSpacing( int spacing, bool isSmall )
2463 {
2464 m_dirty = TRUE;
2465 if (isSmall)
2466 {
2467 m_small_spacing = spacing;
2468 }
2469 else
2470 {
2471 m_normal_spacing = spacing;
2472 }
2473 }
2474
2475 int wxListMainWindow::GetItemSpacing( bool isSmall )
2476 {
2477 return isSmall ? m_small_spacing : m_normal_spacing;
2478 }
2479
2480 void wxListMainWindow::SetColumn( int col, wxListItem &item )
2481 {
2482 m_dirty = TRUE;
2483 wxNode *node = m_columns.Nth( col );
2484 if (node)
2485 {
2486 if (item.m_width == wxLIST_AUTOSIZE_USEHEADER) item.m_width = GetTextLength( item.m_text )+7;
2487 wxListHeaderData *column = (wxListHeaderData*)node->Data();
2488 column->SetItem( item );
2489 }
2490
2491 wxListHeaderWindow *headerWin = ((wxListCtrl*) GetParent())->m_headerWin;
2492 if ( headerWin )
2493 headerWin->m_dirty = TRUE;
2494 }
2495
2496 void wxListMainWindow::SetColumnWidth( int col, int width )
2497 {
2498 wxCHECK_RET( m_mode & wxLC_REPORT,
2499 _T("SetColumnWidth() can only be called in report mode.") );
2500
2501 m_dirty = TRUE;
2502
2503 wxNode *node = (wxNode*) NULL;
2504
2505 if (width == wxLIST_AUTOSIZE_USEHEADER)
2506 {
2507 // TODO do use the header
2508 width = 80;
2509 }
2510 else if (width == wxLIST_AUTOSIZE)
2511 {
2512 wxClientDC dc(this);
2513 dc.SetFont( GetFont() );
2514 int max = 10;
2515
2516 for (size_t i = 0; i < m_lines.GetCount(); i++)
2517 {
2518 wxListLineData *line = &m_lines[i];
2519 wxNode *n = line->m_items.Nth( col );
2520 if (n)
2521 {
2522 wxListItemData *item = (wxListItemData*)n->Data();
2523 int current = 0, ix = 0, iy = 0;
2524 wxCoord lx = 0, ly = 0;
2525 if (item->HasImage())
2526 {
2527 GetImageSize( item->GetImage(), ix, iy );
2528 current = ix + 5;
2529 }
2530 if (item->HasText())
2531 {
2532 wxString str;
2533 item->GetText( str );
2534 dc.GetTextExtent( str, &lx, &ly );
2535 current += lx;
2536 }
2537 if (current > max) max = current;
2538 }
2539 }
2540 width = max+10;
2541 }
2542
2543 node = m_columns.Nth( col );
2544 if (node)
2545 {
2546 wxListHeaderData *column = (wxListHeaderData*)node->Data();
2547 column->SetWidth( width );
2548 }
2549
2550 for (size_t i = 0; i < m_lines.GetCount(); i++)
2551 {
2552 wxListLineData *line = &m_lines[i];
2553 wxNode *n = line->m_items.Nth( col );
2554 if (n)
2555 {
2556 wxListItemData *item = (wxListItemData*)n->Data();
2557 item->SetSize( width, -1 );
2558 }
2559 }
2560
2561 wxListHeaderWindow *headerWin = ((wxListCtrl*) GetParent())->m_headerWin;
2562 if ( headerWin )
2563 headerWin->m_dirty = TRUE;
2564 }
2565
2566 void wxListMainWindow::GetColumn( int col, wxListItem &item )
2567 {
2568 wxNode *node = m_columns.Nth( col );
2569 if (node)
2570 {
2571 wxListHeaderData *column = (wxListHeaderData*)node->Data();
2572 column->GetItem( item );
2573 }
2574 else
2575 {
2576 item.m_format = 0;
2577 item.m_width = 0;
2578 item.m_text = "";
2579 item.m_image = 0;
2580 item.m_data = 0;
2581 }
2582 }
2583
2584 int wxListMainWindow::GetColumnWidth( int col )
2585 {
2586 wxNode *node = m_columns.Nth( col );
2587 if (node)
2588 {
2589 wxListHeaderData *column = (wxListHeaderData*)node->Data();
2590 return column->GetWidth();
2591 }
2592 else
2593 {
2594 return 0;
2595 }
2596 }
2597
2598 int wxListMainWindow::GetColumnCount()
2599 {
2600 return m_columns.Number();
2601 }
2602
2603 int wxListMainWindow::GetCountPerPage()
2604 {
2605 return m_visibleLines;
2606 }
2607
2608 void wxListMainWindow::SetItem( wxListItem &item )
2609 {
2610 m_dirty = TRUE;
2611 if (item.m_itemId >= 0 && (size_t)item.m_itemId < m_lines.GetCount())
2612 {
2613 wxListLineData *line = &m_lines[(size_t)item.m_itemId];
2614 if (m_mode & wxLC_REPORT) item.m_width = GetColumnWidth( item.m_col )-3;
2615 line->SetItem( item.m_col, item );
2616 }
2617 }
2618
2619 void wxListMainWindow::SetItemState( long item, long state, long stateMask )
2620 {
2621 // m_dirty = TRUE; no recalcs needed
2622
2623 wxListLineData *oldCurrent = m_current;
2624
2625 if (stateMask & wxLIST_STATE_FOCUSED)
2626 {
2627 if (item >= 0 && (size_t)item < m_lines.GetCount())
2628 {
2629 wxListLineData *line = &m_lines[(size_t)item];
2630 UnfocusLine( m_current );
2631 m_current = line;
2632 FocusLine( m_current );
2633 if ((m_mode & wxLC_SINGLE_SEL) && oldCurrent) oldCurrent->Hilight( FALSE );
2634 RefreshLine( m_current );
2635 if (oldCurrent) RefreshLine( oldCurrent );
2636 }
2637 }
2638
2639 if (stateMask & wxLIST_STATE_SELECTED)
2640 {
2641 bool on = (state & wxLIST_STATE_SELECTED) != 0;
2642 if (!on && (m_mode & wxLC_SINGLE_SEL)) return;
2643
2644 if (item >= 0 && (size_t)item < m_lines.GetCount())
2645 {
2646 wxListLineData *line = &m_lines[(size_t)item];
2647 if (m_mode & wxLC_SINGLE_SEL)
2648 {
2649 UnfocusLine( m_current );
2650 m_current = line;
2651 FocusLine( m_current );
2652 if (oldCurrent) oldCurrent->Hilight( FALSE );
2653 RefreshLine( m_current );
2654 if (oldCurrent) RefreshLine( oldCurrent );
2655 }
2656 bool on = (state & wxLIST_STATE_SELECTED) != 0;
2657 if (on != line->IsHilighted())
2658 {
2659 line->Hilight( on );
2660 RefreshLine( line );
2661 }
2662 }
2663 }
2664 }
2665
2666 int wxListMainWindow::GetItemState( long item, long stateMask )
2667 {
2668 int ret = wxLIST_STATE_DONTCARE;
2669 if (stateMask & wxLIST_STATE_FOCUSED)
2670 {
2671 if (item >= 0 && (size_t)item < m_lines.GetCount())
2672 {
2673 wxListLineData *line = &m_lines[(size_t)item];
2674 if (line == m_current) ret |= wxLIST_STATE_FOCUSED;
2675 }
2676 }
2677 if (stateMask & wxLIST_STATE_SELECTED)
2678 {
2679 if (item >= 0 && (size_t)item < m_lines.GetCount())
2680 {
2681 wxListLineData *line = &m_lines[(size_t)item];
2682 if (line->IsHilighted()) ret |= wxLIST_STATE_SELECTED;
2683 }
2684 }
2685 return ret;
2686 }
2687
2688 void wxListMainWindow::GetItem( wxListItem &item )
2689 {
2690 if (item.m_itemId >= 0 && (size_t)item.m_itemId < m_lines.GetCount())
2691 {
2692 wxListLineData *line = &m_lines[(size_t)item.m_itemId];
2693 line->GetItem( item.m_col, item );
2694 }
2695 else
2696 {
2697 item.m_mask = 0;
2698 item.m_text = "";
2699 item.m_image = 0;
2700 item.m_data = 0;
2701 }
2702 }
2703
2704 int wxListMainWindow::GetItemCount()
2705 {
2706 return m_lines.GetCount();
2707 }
2708
2709 void wxListMainWindow::GetItemRect( long index, wxRect &rect )
2710 {
2711 if (index >= 0 && (size_t)index < m_lines.GetCount())
2712 {
2713 m_lines[(size_t)index].GetRect( rect );
2714 this->CalcScrolledPosition(rect.x,rect.y,&rect.x,&rect.y);
2715 }
2716 else
2717 {
2718 rect.x = 0;
2719 rect.y = 0;
2720 rect.width = 0;
2721 rect.height = 0;
2722 }
2723 }
2724
2725 bool wxListMainWindow::GetItemPosition(long item, wxPoint& pos)
2726 {
2727 wxRect rect;
2728 this->GetItemRect(item,rect);
2729 pos.x=rect.x; pos.y=rect.y;
2730 return TRUE;
2731 }
2732
2733 int wxListMainWindow::GetSelectedItemCount()
2734 {
2735 int ret = 0;
2736 for (size_t i = 0; i < m_lines.GetCount(); i++)
2737 {
2738 if (m_lines[i].IsHilighted()) ret++;
2739 }
2740 return ret;
2741 }
2742
2743 void wxListMainWindow::SetMode( long mode )
2744 {
2745 m_dirty = TRUE;
2746 m_mode = mode;
2747
2748 DeleteEverything();
2749
2750 if (m_mode & wxLC_REPORT)
2751 {
2752 #if wxUSE_GENERIC_LIST_EXTENSIONS
2753 m_xScroll = 15;
2754 #else
2755 m_xScroll = 0;
2756 #endif
2757 m_yScroll = 15;
2758 }
2759 else
2760 {
2761 m_xScroll = 15;
2762 m_yScroll = 0;
2763 }
2764 }
2765
2766 long wxListMainWindow::GetMode() const
2767 {
2768 return m_mode;
2769 }
2770
2771 void wxListMainWindow::CalculatePositions()
2772 {
2773 if (m_lines.IsEmpty()) return;
2774
2775 wxClientDC dc( this );
2776 dc.SetFont( GetFont() );
2777
2778 int iconSpacing = 0;
2779 if (m_mode & wxLC_ICON) iconSpacing = m_normal_spacing;
2780 if (m_mode & wxLC_SMALL_ICON) iconSpacing = m_small_spacing;
2781
2782 // we take the first line (which also can be an icon or
2783 // an a text item in wxLC_ICON and wxLC_LIST modes) to
2784 // measure the size of the line
2785
2786 int lineWidth = 0;
2787 int lineHeight = 0;
2788 int lineSpacing = 0;
2789
2790 wxListLineData *line = &m_lines[0];
2791 line->CalculateSize( &dc, iconSpacing );
2792 int dummy = 0;
2793 line->GetSize( dummy, lineSpacing );
2794 lineSpacing += 1;
2795
2796 int clientWidth = 0;
2797 int clientHeight = 0;
2798
2799 if (m_mode & wxLC_REPORT)
2800 {
2801 // scroll one line per step
2802 m_yScroll = lineSpacing;
2803
2804 int x = 4;
2805 int y = 1;
2806 int entireHeight = m_lines.GetCount() * lineSpacing + 2;
2807 int scroll_pos = GetScrollPos( wxVERTICAL );
2808 #if wxUSE_GENERIC_LIST_EXTENSIONS
2809 int x_scroll_pos = GetScrollPos( wxHORIZONTAL );
2810 #else
2811 SetScrollbars( m_xScroll, m_yScroll, 0, entireHeight/m_yScroll +1, 0, scroll_pos, TRUE );
2812 #endif
2813 GetClientSize( &clientWidth, &clientHeight );
2814
2815 int entireWidth = 0 ;
2816 for (size_t j = 0; j < m_lines.GetCount(); j++)
2817 {
2818 wxListLineData *line = &m_lines[j];
2819 line->CalculateSize( &dc, iconSpacing );
2820 line->SetPosition( &dc, x, y, clientWidth );
2821 int col_x = 2;
2822 for (int i = 0; i < GetColumnCount(); i++)
2823 {
2824 line->SetColumnPosition( i, col_x );
2825 col_x += GetColumnWidth( i );
2826 }
2827 entireWidth = wxMax( entireWidth , col_x ) ;
2828 #if wxUSE_GENERIC_LIST_EXTENSIONS
2829 line->SetPosition( &dc, x, y, col_x );
2830 #endif
2831 y += lineSpacing; // one pixel blank line between items
2832 }
2833 m_visibleLines = clientHeight / lineSpacing;
2834 #if wxUSE_GENERIC_LIST_EXTENSIONS
2835 SetScrollbars( m_xScroll, m_yScroll, entireWidth/m_xScroll +1, entireHeight/m_yScroll +1, x_scroll_pos , scroll_pos, TRUE );
2836 #endif
2837 }
2838 else
2839 {
2840 // at first we try without any scrollbar. if the items don't
2841 // fit into the window, we recalculate after subtracting an
2842 // approximated 15 pt for the horizontal scrollbar
2843
2844 GetSize( &clientWidth, &clientHeight );
2845 clientHeight -= 4; // sunken frame
2846
2847 int entireWidth = 0;
2848
2849 for (int tries = 0; tries < 2; tries++)
2850 {
2851 entireWidth = 0;
2852 int x = 2;
2853 int y = 2;
2854 int maxWidth = 0;
2855 m_visibleLines = 0;
2856 int m_currentVisibleLines = 0;
2857 for (size_t i = 0; i < m_lines.GetCount(); i++)
2858 {
2859 m_currentVisibleLines++;
2860 wxListLineData *line = &m_lines[i];
2861 line->CalculateSize( &dc, iconSpacing );
2862 line->SetPosition( &dc, x, y, clientWidth );
2863 line->GetSize( lineWidth, lineHeight );
2864 if (lineWidth > maxWidth) maxWidth = lineWidth;
2865 y += lineSpacing;
2866 if (m_currentVisibleLines > m_visibleLines)
2867 m_visibleLines = m_currentVisibleLines;
2868 if (y+lineSpacing-6 >= clientHeight) // -6 for earlier "line breaking"
2869 {
2870 m_currentVisibleLines = 0;
2871 y = 2;
2872 x += maxWidth+6;
2873 entireWidth += maxWidth+6;
2874 maxWidth = 0;
2875 }
2876 if (i == m_lines.GetCount()-1) entireWidth += maxWidth;
2877 if ((tries == 0) && (entireWidth > clientWidth))
2878 {
2879 clientHeight -= 15; // scrollbar height
2880 m_visibleLines = 0;
2881 m_currentVisibleLines = 0;
2882 break;
2883 }
2884 if (i == m_lines.GetCount()-1) tries = 1; // everything fits, no second try required
2885 }
2886 }
2887
2888 int scroll_pos = GetScrollPos( wxHORIZONTAL );
2889 SetScrollbars( m_xScroll, m_yScroll, (entireWidth+15) / m_xScroll, 0, scroll_pos, 0, TRUE );
2890 }
2891 }
2892
2893 void wxListMainWindow::RealizeChanges()
2894 {
2895 if (!m_current)
2896 {
2897 if (!m_lines.IsEmpty())
2898 m_current = &m_lines[0];
2899 }
2900 if (m_current)
2901 {
2902 FocusLine( m_current );
2903 // TODO: MSW doesn't automatically hilight the
2904 // first item.
2905 // if (m_mode & wxLC_SINGLE_SEL) m_current->Hilight( TRUE );
2906 }
2907 }
2908
2909 long wxListMainWindow::GetNextItem( long item,
2910 int WXUNUSED(geometry),
2911 int state )
2912 {
2913 long ret = item,
2914 max = GetItemCount();
2915 wxCHECK_MSG( (ret == -1) || (ret < max), -1,
2916 _T("invalid listctrl index in GetNextItem()") );
2917
2918 // notice that we start with the next item (or the first one if item == -1)
2919 // and this is intentional to allow writing a simple loop to iterate over
2920 // all selected items
2921 ret++;
2922 if ( ret == max )
2923 {
2924 // this is not an error because the index was ok initially, just no
2925 // such item
2926 return -1;
2927 }
2928
2929 for (size_t i = (size_t)ret; i < m_lines.GetCount(); i++)
2930 {
2931 wxListLineData *line = &m_lines[i];
2932 if ((state & wxLIST_STATE_FOCUSED) && (line == m_current))
2933 return ret;
2934 if ((state & wxLIST_STATE_SELECTED) && (line->IsHilighted()))
2935 return ret;
2936 if (!state)
2937 return ret;
2938 ret++;
2939 }
2940
2941 return -1;
2942 }
2943
2944 void wxListMainWindow::DeleteItem( long index )
2945 {
2946 m_dirty = TRUE;
2947 if (index >= 0 && (size_t)index < m_lines.GetCount())
2948 {
2949 wxListLineData *line = &m_lines[(size_t)index];
2950 if (m_current == line) m_current = (wxListLineData *) NULL;
2951 DeleteLine( line );
2952 m_lines.RemoveAt( (size_t)index );
2953 }
2954 }
2955
2956 void wxListMainWindow::DeleteColumn( int col )
2957 {
2958 wxCHECK_RET( col < (int)m_columns.GetCount(),
2959 wxT("attempting to delete inexistent column in wxListView") );
2960
2961 m_dirty = TRUE;
2962 wxNode *node = m_columns.Nth( col );
2963 if (node) m_columns.DeleteNode( node );
2964 }
2965
2966 void wxListMainWindow::DeleteAllItems()
2967 {
2968 m_dirty = TRUE;
2969 m_current = (wxListLineData *) NULL;
2970
2971 // to make the deletion of all items faster, we don't send the
2972 // notifications in this case: this is compatible with wxMSW and
2973 // documented in DeleteAllItems() description
2974
2975 wxListEvent event( wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS, GetParent()->GetId() );
2976 event.SetEventObject( GetParent() );
2977 GetParent()->GetEventHandler()->ProcessEvent( event );
2978
2979 m_lines.Clear();
2980 }
2981
2982 void wxListMainWindow::DeleteEverything()
2983 {
2984 DeleteAllItems();
2985
2986 m_columns.Clear();
2987 }
2988
2989 void wxListMainWindow::EnsureVisible( long index )
2990 {
2991 // We have to call this here because the label in
2992 // question might just have been added and no screen
2993 // update taken place.
2994 if (m_dirty) wxYield();
2995
2996 wxListLineData *oldCurrent = m_current;
2997 m_current = (wxListLineData *) NULL;
2998 if (index >= 0 && (size_t)index < m_lines.GetCount())
2999 m_current = &m_lines[(size_t)index];
3000 if (m_current) MoveToFocus();
3001 m_current = oldCurrent;
3002 }
3003
3004 long wxListMainWindow::FindItem(long start, const wxString& str, bool WXUNUSED(partial) )
3005 {
3006 long pos = start;
3007 wxString tmp = str;
3008 if (pos < 0) pos = 0;
3009 for (size_t i = (size_t)pos; i < m_lines.GetCount(); i++)
3010 {
3011 wxListLineData *line = &m_lines[i];
3012 wxString s = "";
3013 line->GetText( 0, s );
3014 if (s == tmp) return pos;
3015 pos++;
3016 }
3017 return -1;
3018 }
3019
3020 long wxListMainWindow::FindItem(long start, long data)
3021 {
3022 long pos = start;
3023 if (pos < 0) pos = 0;
3024 for (size_t i = (size_t)pos; i < m_lines.GetCount(); i++)
3025 {
3026 wxListLineData *line = &m_lines[i];
3027 wxListItem item;
3028 line->GetItem( 0, item );
3029 if (item.m_data == data) return pos;
3030 pos++;
3031 }
3032 return -1;
3033 }
3034
3035 long wxListMainWindow::HitTest( int x, int y, int &flags )
3036 {
3037 CalcUnscrolledPosition( x, y, &x, &y );
3038
3039 int count = 0;
3040 for (size_t i = 0; i < m_lines.GetCount(); i++)
3041 {
3042 wxListLineData *line = &m_lines[i];
3043 long ret = line->IsHit( x, y );
3044 if (ret) // & flags) // No: flags is output-only so may be garbage at this point
3045 {
3046 flags = (int)ret;
3047 return count;
3048 }
3049 count++;
3050 }
3051 return -1;
3052 }
3053
3054 void wxListMainWindow::InsertItem( wxListItem &item )
3055 {
3056 m_dirty = TRUE;
3057 int mode = 0;
3058 if (m_mode & wxLC_REPORT) mode = wxLC_REPORT;
3059 else if (m_mode & wxLC_LIST) mode = wxLC_LIST;
3060 else if (m_mode & wxLC_ICON) mode = wxLC_ICON;
3061 else if (m_mode & wxLC_SMALL_ICON) mode = wxLC_ICON; // no typo
3062
3063 wxListLineData *line = new wxListLineData( this, mode, m_hilightBrush );
3064
3065 if (m_mode & wxLC_REPORT)
3066 {
3067 line->InitItems( GetColumnCount() );
3068 item.m_width = GetColumnWidth( 0 )-3;
3069 }
3070 else
3071 {
3072 line->InitItems( 1 );
3073 }
3074
3075 line->SetItem( 0, item );
3076 if ((item.m_itemId >= 0) && ((size_t)item.m_itemId < m_lines.GetCount()))
3077 {
3078 m_lines.Insert( line, (size_t)item.m_itemId );
3079 }
3080 else
3081 {
3082 m_lines.Add( line );
3083 item.m_itemId = m_lines.GetCount()-1;
3084 }
3085 }
3086
3087 void wxListMainWindow::InsertColumn( long col, wxListItem &item )
3088 {
3089 m_dirty = TRUE;
3090 if (m_mode & wxLC_REPORT)
3091 {
3092 if (item.m_width == wxLIST_AUTOSIZE_USEHEADER) item.m_width = GetTextLength( item.m_text );
3093 wxListHeaderData *column = new wxListHeaderData( item );
3094 if ((col >= 0) && (col < (int)m_columns.GetCount()))
3095 {
3096 wxNode *node = m_columns.Nth( (size_t)col );
3097 if (node)
3098 m_columns.Insert( node, column );
3099 }
3100 else
3101 {
3102 m_columns.Append( column );
3103 }
3104 }
3105 }
3106
3107 wxListCtrlCompare list_ctrl_compare_func_2;
3108 long list_ctrl_compare_data;
3109
3110 int LINKAGEMODE list_ctrl_compare_func_1( wxListLineData **arg1, wxListLineData **arg2 )
3111 {
3112 wxListLineData *line1 = *arg1;
3113 wxListLineData *line2 = *arg2;
3114 wxListItem item;
3115 line1->GetItem( 0, item );
3116 long data1 = item.m_data;
3117 line2->GetItem( 0, item );
3118 long data2 = item.m_data;
3119 return list_ctrl_compare_func_2( data1, data2, list_ctrl_compare_data );
3120 }
3121
3122 void wxListMainWindow::SortItems( wxListCtrlCompare fn, long data )
3123 {
3124 list_ctrl_compare_func_2 = fn;
3125 list_ctrl_compare_data = data;
3126 m_lines.Sort( list_ctrl_compare_func_1 );
3127 m_dirty = TRUE;
3128 }
3129
3130 void wxListMainWindow::OnScroll(wxScrollWinEvent& event)
3131 {
3132 wxScrolledWindow::OnScroll( event ) ;
3133
3134 #if wxUSE_GENERIC_LIST_EXTENSIONS
3135
3136 if (event.GetOrientation() == wxHORIZONTAL && ( m_mode & wxLC_REPORT ))
3137 {
3138 wxListCtrl* lc = wxDynamicCast( GetParent() , wxListCtrl ) ;
3139 if ( lc )
3140 {
3141 lc->m_headerWin->Refresh() ;
3142 #ifdef __WXMAC__
3143 lc->m_headerWin->MacUpdateImmediately() ;
3144 #endif
3145 }
3146 }
3147 #endif
3148 }
3149
3150 // -------------------------------------------------------------------------------------
3151 // wxListItem
3152 // -------------------------------------------------------------------------------------
3153
3154 IMPLEMENT_DYNAMIC_CLASS(wxListItem, wxObject)
3155
3156 wxListItem::wxListItem()
3157 {
3158 m_mask = 0;
3159 m_itemId = 0;
3160 m_col = 0;
3161 m_state = 0;
3162 m_stateMask = 0;
3163 m_image = 0;
3164 m_data = 0;
3165 m_format = wxLIST_FORMAT_CENTRE;
3166 m_width = 0;
3167
3168 m_attr = NULL;
3169 }
3170
3171 void wxListItem::Clear()
3172 {
3173 m_mask = 0;
3174 m_itemId = 0;
3175 m_col = 0;
3176 m_state = 0;
3177 m_stateMask = 0;
3178 m_image = 0;
3179 m_data = 0;
3180 m_format = wxLIST_FORMAT_CENTRE;
3181 m_width = 0;
3182 m_text = wxEmptyString;
3183
3184 if (m_attr) delete m_attr;
3185 m_attr = NULL;
3186 }
3187
3188 void wxListItem::ClearAttributes()
3189 {
3190 if (m_attr) delete m_attr;
3191 m_attr = NULL;
3192 }
3193
3194 // -------------------------------------------------------------------------------------
3195 // wxListEvent
3196 // -------------------------------------------------------------------------------------
3197
3198 IMPLEMENT_DYNAMIC_CLASS(wxListEvent, wxNotifyEvent)
3199
3200 wxListEvent::wxListEvent( wxEventType commandType, int id ):
3201 wxNotifyEvent( commandType, id )
3202 {
3203 m_code = 0;
3204 m_itemIndex = 0;
3205 m_oldItemIndex = 0;
3206 m_col = 0;
3207 m_cancelled = FALSE;
3208 m_pointDrag.x = 0;
3209 m_pointDrag.y = 0;
3210 }
3211
3212 void wxListEvent::CopyObject(wxObject& object_dest) const
3213 {
3214 wxListEvent *obj = (wxListEvent *)&object_dest;
3215
3216 wxNotifyEvent::CopyObject(object_dest);
3217
3218 obj->m_code = m_code;
3219 obj->m_itemIndex = m_itemIndex;
3220 obj->m_oldItemIndex = m_oldItemIndex;
3221 obj->m_col = m_col;
3222 obj->m_cancelled = m_cancelled;
3223 obj->m_pointDrag = m_pointDrag;
3224 obj->m_item.m_mask = m_item.m_mask;
3225 obj->m_item.m_itemId = m_item.m_itemId;
3226 obj->m_item.m_col = m_item.m_col;
3227 obj->m_item.m_state = m_item.m_state;
3228 obj->m_item.m_stateMask = m_item.m_stateMask;
3229 obj->m_item.m_text = m_item.m_text;
3230 obj->m_item.m_image = m_item.m_image;
3231 obj->m_item.m_data = m_item.m_data;
3232 obj->m_item.m_format = m_item.m_format;
3233 obj->m_item.m_width = m_item.m_width;
3234
3235 if ( m_item.HasAttributes() )
3236 {
3237 obj->m_item.SetTextColour(m_item.GetTextColour());
3238 }
3239 }
3240
3241 // -------------------------------------------------------------------------------------
3242 // wxListCtrl
3243 // -------------------------------------------------------------------------------------
3244
3245 IMPLEMENT_DYNAMIC_CLASS(wxListCtrl, wxControl)
3246
3247 BEGIN_EVENT_TABLE(wxListCtrl,wxControl)
3248 EVT_SIZE (wxListCtrl::OnSize)
3249 EVT_IDLE (wxListCtrl::OnIdle)
3250 END_EVENT_TABLE()
3251
3252 wxListCtrl::wxListCtrl()
3253 {
3254 m_imageListNormal = (wxImageList *) NULL;
3255 m_imageListSmall = (wxImageList *) NULL;
3256 m_imageListState = (wxImageList *) NULL;
3257 m_ownsImageListNormal = m_ownsImageListSmall = m_ownsImageListState = FALSE;
3258 m_mainWin = (wxListMainWindow*) NULL;
3259 m_headerWin = (wxListHeaderWindow*) NULL;
3260 }
3261
3262 wxListCtrl::~wxListCtrl()
3263 {
3264 if (m_ownsImageListNormal) delete m_imageListNormal;
3265 if (m_ownsImageListSmall) delete m_imageListSmall;
3266 if (m_ownsImageListState) delete m_imageListState;
3267 }
3268
3269 bool wxListCtrl::Create(wxWindow *parent,
3270 wxWindowID id,
3271 const wxPoint &pos,
3272 const wxSize &size,
3273 long style,
3274 const wxValidator &validator,
3275 const wxString &name)
3276 {
3277 m_imageListNormal = (wxImageList *) NULL;
3278 m_imageListSmall = (wxImageList *) NULL;
3279 m_imageListState = (wxImageList *) NULL;
3280 m_ownsImageListNormal = m_ownsImageListSmall = m_ownsImageListState = FALSE;
3281 m_mainWin = (wxListMainWindow*) NULL;
3282 m_headerWin = (wxListHeaderWindow*) NULL;
3283
3284 if ( !(style & (wxLC_REPORT | wxLC_LIST | wxLC_ICON)) )
3285 {
3286 style = style | wxLC_LIST;
3287 }
3288
3289 bool ret = wxControl::Create( parent, id, pos, size, style, validator, name );
3290
3291
3292 if (style & wxSUNKEN_BORDER)
3293 style -= wxSUNKEN_BORDER;
3294
3295 m_mainWin = new wxListMainWindow( this, -1, wxPoint(0,0), size, style );
3296
3297 if (HasFlag(wxLC_REPORT))
3298 {
3299 m_headerWin = new wxListHeaderWindow( this, -1, m_mainWin, wxPoint(0,0), wxSize(size.x,23), wxTAB_TRAVERSAL );
3300 if (HasFlag(wxLC_NO_HEADER))
3301 m_headerWin->Show( FALSE );
3302 }
3303 else
3304 {
3305 m_headerWin = (wxListHeaderWindow *) NULL;
3306 }
3307
3308 return ret;
3309 }
3310
3311 void wxListCtrl::OnSize( wxSizeEvent &WXUNUSED(event) )
3312 {
3313 /* handled in OnIdle */
3314
3315 if (m_mainWin) m_mainWin->m_dirty = TRUE;
3316 }
3317
3318 void wxListCtrl::SetSingleStyle( long style, bool add )
3319 {
3320 long flag = GetWindowStyle();
3321
3322 if (add)
3323 {
3324 if (style & wxLC_MASK_TYPE) flag = flag & ~wxLC_MASK_TYPE;
3325 if (style & wxLC_MASK_ALIGN) flag = flag & ~wxLC_MASK_ALIGN;
3326 if (style & wxLC_MASK_SORT) flag = flag & ~wxLC_MASK_SORT;
3327 }
3328
3329 if (add)
3330 {
3331 flag |= style;
3332 }
3333 else
3334 {
3335 if (flag & style) flag -= style;
3336 }
3337
3338 SetWindowStyleFlag( flag );
3339 }
3340
3341 void wxListCtrl::SetWindowStyleFlag( long flag )
3342 {
3343 if (m_mainWin)
3344 {
3345 m_mainWin->DeleteEverything();
3346
3347 int width = 0;
3348 int height = 0;
3349 GetClientSize( &width, &height );
3350
3351 m_mainWin->SetMode( flag );
3352
3353 if (flag & wxLC_REPORT)
3354 {
3355 if (!HasFlag(wxLC_REPORT))
3356 {
3357 if (!m_headerWin)
3358 {
3359 m_headerWin = new wxListHeaderWindow( this, -1, m_mainWin,
3360 wxPoint(0,0), wxSize(width,23), wxTAB_TRAVERSAL );
3361 if (HasFlag(wxLC_NO_HEADER))
3362 m_headerWin->Show( FALSE );
3363 }
3364 else
3365 {
3366 if (flag & wxLC_NO_HEADER)
3367 m_headerWin->Show( FALSE );
3368 else
3369 m_headerWin->Show( TRUE );
3370 }
3371 }
3372 }
3373 else
3374 {
3375 if (HasFlag(wxLC_REPORT) && !(HasFlag(wxLC_NO_HEADER)))
3376 {
3377 m_headerWin->Show( FALSE );
3378 }
3379 }
3380 }
3381
3382 wxWindow::SetWindowStyleFlag( flag );
3383 }
3384
3385 bool wxListCtrl::GetColumn(int col, wxListItem &item) const
3386 {
3387 m_mainWin->GetColumn( col, item );
3388 return TRUE;
3389 }
3390
3391 bool wxListCtrl::SetColumn( int col, wxListItem& item )
3392 {
3393 m_mainWin->SetColumn( col, item );
3394 return TRUE;
3395 }
3396
3397 int wxListCtrl::GetColumnWidth( int col ) const
3398 {
3399 return m_mainWin->GetColumnWidth( col );
3400 }
3401
3402 bool wxListCtrl::SetColumnWidth( int col, int width )
3403 {
3404 m_mainWin->SetColumnWidth( col, width );
3405 return TRUE;
3406 }
3407
3408 int wxListCtrl::GetCountPerPage() const
3409 {
3410 return m_mainWin->GetCountPerPage(); // different from Windows ?
3411 }
3412
3413 bool wxListCtrl::GetItem( wxListItem &info ) const
3414 {
3415 m_mainWin->GetItem( info );
3416 return TRUE;
3417 }
3418
3419 bool wxListCtrl::SetItem( wxListItem &info )
3420 {
3421 m_mainWin->SetItem( info );
3422 return TRUE;
3423 }
3424
3425 long wxListCtrl::SetItem( long index, int col, const wxString& label, int imageId )
3426 {
3427 wxListItem info;
3428 info.m_text = label;
3429 info.m_mask = wxLIST_MASK_TEXT;
3430 info.m_itemId = index;
3431 info.m_col = col;
3432 if ( imageId > -1 )
3433 {
3434 info.m_image = imageId;
3435 info.m_mask |= wxLIST_MASK_IMAGE;
3436 };
3437 m_mainWin->SetItem(info);
3438 return TRUE;
3439 }
3440
3441 int wxListCtrl::GetItemState( long item, long stateMask ) const
3442 {
3443 return m_mainWin->GetItemState( item, stateMask );
3444 }
3445
3446 bool wxListCtrl::SetItemState( long item, long state, long stateMask )
3447 {
3448 m_mainWin->SetItemState( item, state, stateMask );
3449 return TRUE;
3450 }
3451
3452 bool wxListCtrl::SetItemImage( long item, int image, int WXUNUSED(selImage) )
3453 {
3454 wxListItem info;
3455 info.m_image = image;
3456 info.m_mask = wxLIST_MASK_IMAGE;
3457 info.m_itemId = item;
3458 m_mainWin->SetItem( info );
3459 return TRUE;
3460 }
3461
3462 wxString wxListCtrl::GetItemText( long item ) const
3463 {
3464 wxListItem info;
3465 info.m_itemId = item;
3466 m_mainWin->GetItem( info );
3467 return info.m_text;
3468 }
3469
3470 void wxListCtrl::SetItemText( long item, const wxString &str )
3471 {
3472 wxListItem info;
3473 info.m_mask = wxLIST_MASK_TEXT;
3474 info.m_itemId = item;
3475 info.m_text = str;
3476 m_mainWin->SetItem( info );
3477 }
3478
3479 long wxListCtrl::GetItemData( long item ) const
3480 {
3481 wxListItem info;
3482 info.m_itemId = item;
3483 m_mainWin->GetItem( info );
3484 return info.m_data;
3485 }
3486
3487 bool wxListCtrl::SetItemData( long item, long data )
3488 {
3489 wxListItem info;
3490 info.m_mask = wxLIST_MASK_DATA;
3491 info.m_itemId = item;
3492 info.m_data = data;
3493 m_mainWin->SetItem( info );
3494 return TRUE;
3495 }
3496
3497 bool wxListCtrl::GetItemRect( long item, wxRect &rect, int WXUNUSED(code) ) const
3498 {
3499 m_mainWin->GetItemRect( item, rect );
3500 return TRUE;
3501 }
3502
3503 bool wxListCtrl::GetItemPosition( long item, wxPoint& pos ) const
3504 {
3505 m_mainWin->GetItemPosition( item, pos );
3506 return TRUE;
3507 }
3508
3509 bool wxListCtrl::SetItemPosition( long WXUNUSED(item), const wxPoint& WXUNUSED(pos) )
3510 {
3511 return 0;
3512 }
3513
3514 int wxListCtrl::GetItemCount() const
3515 {
3516 return m_mainWin->GetItemCount();
3517 }
3518
3519 int wxListCtrl::GetColumnCount() const
3520 {
3521 return m_mainWin->GetColumnCount();
3522 }
3523
3524 void wxListCtrl::SetItemSpacing( int spacing, bool isSmall )
3525 {
3526 m_mainWin->SetItemSpacing( spacing, isSmall );
3527 }
3528
3529 int wxListCtrl::GetItemSpacing( bool isSmall ) const
3530 {
3531 return m_mainWin->GetItemSpacing( isSmall );
3532 }
3533
3534 int wxListCtrl::GetSelectedItemCount() const
3535 {
3536 return m_mainWin->GetSelectedItemCount();
3537 }
3538
3539 wxColour wxListCtrl::GetTextColour() const
3540 {
3541 return GetForegroundColour();
3542 }
3543
3544 void wxListCtrl::SetTextColour(const wxColour& col)
3545 {
3546 SetForegroundColour(col);
3547 }
3548
3549 long wxListCtrl::GetTopItem() const
3550 {
3551 return 0;
3552 }
3553
3554 long wxListCtrl::GetNextItem( long item, int geom, int state ) const
3555 {
3556 return m_mainWin->GetNextItem( item, geom, state );
3557 }
3558
3559 wxImageList *wxListCtrl::GetImageList(int which) const
3560 {
3561 if (which == wxIMAGE_LIST_NORMAL)
3562 {
3563 return m_imageListNormal;
3564 }
3565 else if (which == wxIMAGE_LIST_SMALL)
3566 {
3567 return m_imageListSmall;
3568 }
3569 else if (which == wxIMAGE_LIST_STATE)
3570 {
3571 return m_imageListState;
3572 }
3573 return (wxImageList *) NULL;
3574 }
3575
3576 void wxListCtrl::SetImageList( wxImageList *imageList, int which )
3577 {
3578 if ( which == wxIMAGE_LIST_NORMAL )
3579 {
3580 if (m_ownsImageListNormal) delete m_imageListNormal;
3581 m_imageListNormal = imageList;
3582 m_ownsImageListNormal = FALSE;
3583 }
3584 else if ( which == wxIMAGE_LIST_SMALL )
3585 {
3586 if (m_ownsImageListSmall) delete m_imageListSmall;
3587 m_imageListSmall = imageList;
3588 m_ownsImageListSmall = FALSE;
3589 }
3590 else if ( which == wxIMAGE_LIST_STATE )
3591 {
3592 if (m_ownsImageListState) delete m_imageListState;
3593 m_imageListState = imageList;
3594 m_ownsImageListState = FALSE;
3595 }
3596
3597 m_mainWin->SetImageList( imageList, which );
3598 }
3599
3600 void wxListCtrl::AssignImageList(wxImageList *imageList, int which)
3601 {
3602 SetImageList(imageList, which);
3603 if ( which == wxIMAGE_LIST_NORMAL )
3604 m_ownsImageListNormal = TRUE;
3605 else if ( which == wxIMAGE_LIST_SMALL )
3606 m_ownsImageListSmall = TRUE;
3607 else if ( which == wxIMAGE_LIST_STATE )
3608 m_ownsImageListState = TRUE;
3609 }
3610
3611 bool wxListCtrl::Arrange( int WXUNUSED(flag) )
3612 {
3613 return 0;
3614 }
3615
3616 bool wxListCtrl::DeleteItem( long item )
3617 {
3618 m_mainWin->DeleteItem( item );
3619 return TRUE;
3620 }
3621
3622 bool wxListCtrl::DeleteAllItems()
3623 {
3624 m_mainWin->DeleteAllItems();
3625 return TRUE;
3626 }
3627
3628 bool wxListCtrl::DeleteAllColumns()
3629 {
3630 for ( size_t n = 0; n < m_mainWin->m_columns.GetCount(); n++ )
3631 DeleteColumn(n);
3632
3633 return TRUE;
3634 }
3635
3636 void wxListCtrl::ClearAll()
3637 {
3638 m_mainWin->DeleteEverything();
3639 }
3640
3641 bool wxListCtrl::DeleteColumn( int col )
3642 {
3643 m_mainWin->DeleteColumn( col );
3644 return TRUE;
3645 }
3646
3647 void wxListCtrl::Edit( long item )
3648 {
3649 m_mainWin->Edit( item );
3650 }
3651
3652 bool wxListCtrl::EnsureVisible( long item )
3653 {
3654 m_mainWin->EnsureVisible( item );
3655 return TRUE;
3656 }
3657
3658 long wxListCtrl::FindItem( long start, const wxString& str, bool partial )
3659 {
3660 return m_mainWin->FindItem( start, str, partial );
3661 }
3662
3663 long wxListCtrl::FindItem( long start, long data )
3664 {
3665 return m_mainWin->FindItem( start, data );
3666 }
3667
3668 long wxListCtrl::FindItem( long WXUNUSED(start), const wxPoint& WXUNUSED(pt),
3669 int WXUNUSED(direction))
3670 {
3671 return 0;
3672 }
3673
3674 long wxListCtrl::HitTest( const wxPoint &point, int &flags )
3675 {
3676 return m_mainWin->HitTest( (int)point.x, (int)point.y, flags );
3677 }
3678
3679 long wxListCtrl::InsertItem( wxListItem& info )
3680 {
3681 m_mainWin->InsertItem( info );
3682 return info.m_itemId;
3683 }
3684
3685 long wxListCtrl::InsertItem( long index, const wxString &label )
3686 {
3687 wxListItem info;
3688 info.m_text = label;
3689 info.m_mask = wxLIST_MASK_TEXT;
3690 info.m_itemId = index;
3691 return InsertItem( info );
3692 }
3693
3694 long wxListCtrl::InsertItem( long index, int imageIndex )
3695 {
3696 wxListItem info;
3697 info.m_mask = wxLIST_MASK_IMAGE;
3698 info.m_image = imageIndex;
3699 info.m_itemId = index;
3700 return InsertItem( info );
3701 }
3702
3703 long wxListCtrl::InsertItem( long index, const wxString &label, int imageIndex )
3704 {
3705 wxListItem info;
3706 info.m_text = label;
3707 info.m_image = imageIndex;
3708 info.m_mask = wxLIST_MASK_TEXT | wxLIST_MASK_IMAGE;
3709 info.m_itemId = index;
3710 return InsertItem( info );
3711 }
3712
3713 long wxListCtrl::InsertColumn( long col, wxListItem &item )
3714 {
3715 wxASSERT( m_headerWin );
3716 m_mainWin->InsertColumn( col, item );
3717 m_headerWin->Refresh();
3718
3719 return 0;
3720 }
3721
3722 long wxListCtrl::InsertColumn( long col, const wxString &heading,
3723 int format, int width )
3724 {
3725 wxListItem item;
3726 item.m_mask = wxLIST_MASK_TEXT | wxLIST_MASK_FORMAT;
3727 item.m_text = heading;
3728 if (width >= -2)
3729 {
3730 item.m_mask |= wxLIST_MASK_WIDTH;
3731 item.m_width = width;
3732 }
3733 item.m_format = format;
3734
3735 return InsertColumn( col, item );
3736 }
3737
3738 bool wxListCtrl::ScrollList( int WXUNUSED(dx), int WXUNUSED(dy) )
3739 {
3740 return 0;
3741 }
3742
3743 // Sort items.
3744 // fn is a function which takes 3 long arguments: item1, item2, data.
3745 // item1 is the long data associated with a first item (NOT the index).
3746 // item2 is the long data associated with a second item (NOT the index).
3747 // data is the same value as passed to SortItems.
3748 // The return value is a negative number if the first item should precede the second
3749 // item, a positive number of the second item should precede the first,
3750 // or zero if the two items are equivalent.
3751 // data is arbitrary data to be passed to the sort function.
3752
3753 bool wxListCtrl::SortItems( wxListCtrlCompare fn, long data )
3754 {
3755 m_mainWin->SortItems( fn, data );
3756 return TRUE;
3757 }
3758
3759 void wxListCtrl::OnIdle( wxIdleEvent &WXUNUSED(event) )
3760 {
3761 if (!m_mainWin->m_dirty) return;
3762
3763 int cw = 0;
3764 int ch = 0;
3765 GetClientSize( &cw, &ch );
3766
3767 int x = 0;
3768 int y = 0;
3769 int w = 0;
3770 int h = 0;
3771
3772 if (HasFlag(wxLC_REPORT) && !HasFlag(wxLC_NO_HEADER))
3773 {
3774 m_headerWin->GetPosition( &x, &y );
3775 m_headerWin->GetSize( &w, &h );
3776 if ((x != 0) || (y != 0) || (w != cw) || (h != 23))
3777 m_headerWin->SetSize( 0, 0, cw, 23 );
3778
3779 m_mainWin->GetPosition( &x, &y );
3780 m_mainWin->GetSize( &w, &h );
3781 if ((x != 0) || (y != 24) || (w != cw) || (h != ch-24))
3782 m_mainWin->SetSize( 0, 24, cw, ch-24 );
3783 }
3784 else
3785 {
3786 m_mainWin->GetPosition( &x, &y );
3787 m_mainWin->GetSize( &w, &h );
3788 if ((x != 0) || (y != 24) || (w != cw) || (h != ch))
3789 m_mainWin->SetSize( 0, 0, cw, ch );
3790 }
3791
3792 m_mainWin->CalculatePositions();
3793 m_mainWin->RealizeChanges();
3794 m_mainWin->m_dirty = FALSE;
3795 m_mainWin->Refresh();
3796
3797 if ( m_headerWin && m_headerWin->m_dirty )
3798 {
3799 m_headerWin->m_dirty = FALSE;
3800 m_headerWin->Refresh();
3801 }
3802 }
3803
3804 bool wxListCtrl::SetBackgroundColour( const wxColour &colour )
3805 {
3806 if (m_mainWin)
3807 {
3808 m_mainWin->SetBackgroundColour( colour );
3809 m_mainWin->m_dirty = TRUE;
3810 }
3811
3812 return TRUE;
3813 }
3814
3815 bool wxListCtrl::SetForegroundColour( const wxColour &colour )
3816 {
3817 if ( !wxWindow::SetForegroundColour( colour ) )
3818 return FALSE;
3819
3820 if (m_mainWin)
3821 {
3822 m_mainWin->SetForegroundColour( colour );
3823 m_mainWin->m_dirty = TRUE;
3824 }
3825
3826 if (m_headerWin)
3827 {
3828 m_headerWin->SetForegroundColour( colour );
3829 }
3830
3831 return TRUE;
3832 }
3833
3834 bool wxListCtrl::SetFont( const wxFont &font )
3835 {
3836 if ( !wxWindow::SetFont( font ) )
3837 return FALSE;
3838
3839 if (m_mainWin)
3840 {
3841 m_mainWin->SetFont( font );
3842 m_mainWin->m_dirty = TRUE;
3843 }
3844
3845 if (m_headerWin)
3846 {
3847 m_headerWin->SetFont( font );
3848 }
3849
3850 return TRUE;
3851 }
3852
3853 #if wxUSE_DRAG_AND_DROP
3854
3855 void wxListCtrl::SetDropTarget( wxDropTarget *dropTarget )
3856 {
3857 m_mainWin->SetDropTarget( dropTarget );
3858 }
3859
3860 wxDropTarget *wxListCtrl::GetDropTarget() const
3861 {
3862 return m_mainWin->GetDropTarget();
3863 }
3864
3865 #endif // wxUSE_DRAG_AND_DROP
3866
3867 bool wxListCtrl::SetCursor( const wxCursor &cursor )
3868 {
3869 return m_mainWin ? m_mainWin->wxWindow::SetCursor(cursor) : FALSE;
3870 }
3871
3872 wxColour wxListCtrl::GetBackgroundColour() const
3873 {
3874 return m_mainWin ? m_mainWin->GetBackgroundColour() : wxColour();
3875 }
3876
3877 wxColour wxListCtrl::GetForegroundColour() const
3878 {
3879 return m_mainWin ? m_mainWin->GetForegroundColour() : wxColour();
3880 }
3881
3882 bool wxListCtrl::DoPopupMenu( wxMenu *menu, int x, int y )
3883 {
3884 return m_mainWin->PopupMenu( menu, x, y );
3885 }
3886
3887 void wxListCtrl::SetFocus()
3888 {
3889 /* The test in window.cpp fails as we are a composite
3890 window, so it checks against "this", but not m_mainWin. */
3891 if ( FindFocus() != this )
3892 m_mainWin->SetFocus();
3893 }
wxWidgets (Impactor)