]> git.saurik.com Git - wxWidgets.git/blob - src/osx/carbon/listctrl_mac.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
No real changes, just removed unnecessary SetInitialSize() call.
[wxWidgets.git] / src / osx / carbon / listctrl_mac.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/osx/listctrl_mac.cpp
3 // Purpose: wxListCtrl
4 // Author: Julian Smart
5 // Modified by: Agron Selimaj
6 // Created: 04/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #if wxUSE_LISTCTRL
28
29 #include "wx/listctrl.h"
30
31 #ifndef WX_PRECOMP
32 #include "wx/intl.h"
33 #include "wx/settings.h"
34 #endif
35
36 #include "wx/osx/uma.h"
37
38 #include "wx/imaglist.h"
39 #include "wx/sysopt.h"
40 #include "wx/timer.h"
41
42 #include "wx/hashmap.h"
43
44 #if wxUSE_EXTENDED_RTTI
45 WX_DEFINE_FLAGS( wxListCtrlStyle )
46
47 wxBEGIN_FLAGS( wxListCtrlStyle )
48 // new style border flags, we put them first to
49 // use them for streaming out
50 wxFLAGS_MEMBER(wxBORDER_SIMPLE)
51 wxFLAGS_MEMBER(wxBORDER_SUNKEN)
52 wxFLAGS_MEMBER(wxBORDER_DOUBLE)
53 wxFLAGS_MEMBER(wxBORDER_RAISED)
54 wxFLAGS_MEMBER(wxBORDER_STATIC)
55 wxFLAGS_MEMBER(wxBORDER_NONE)
56
57 // old style border flags
58 wxFLAGS_MEMBER(wxSIMPLE_BORDER)
59 wxFLAGS_MEMBER(wxSUNKEN_BORDER)
60 wxFLAGS_MEMBER(wxDOUBLE_BORDER)
61 wxFLAGS_MEMBER(wxRAISED_BORDER)
62 wxFLAGS_MEMBER(wxSTATIC_BORDER)
63 wxFLAGS_MEMBER(wxBORDER)
64
65 // standard window styles
66 wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
67 wxFLAGS_MEMBER(wxCLIP_CHILDREN)
68 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
69 wxFLAGS_MEMBER(wxWANTS_CHARS)
70 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
71 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
72 wxFLAGS_MEMBER(wxVSCROLL)
73 wxFLAGS_MEMBER(wxHSCROLL)
74
75 wxFLAGS_MEMBER(wxLC_LIST)
76 wxFLAGS_MEMBER(wxLC_REPORT)
77 wxFLAGS_MEMBER(wxLC_ICON)
78 wxFLAGS_MEMBER(wxLC_SMALL_ICON)
79 wxFLAGS_MEMBER(wxLC_ALIGN_TOP)
80 wxFLAGS_MEMBER(wxLC_ALIGN_LEFT)
81 wxFLAGS_MEMBER(wxLC_AUTOARRANGE)
82 wxFLAGS_MEMBER(wxLC_USER_TEXT)
83 wxFLAGS_MEMBER(wxLC_EDIT_LABELS)
84 wxFLAGS_MEMBER(wxLC_NO_HEADER)
85 wxFLAGS_MEMBER(wxLC_SINGLE_SEL)
86 wxFLAGS_MEMBER(wxLC_SORT_ASCENDING)
87 wxFLAGS_MEMBER(wxLC_SORT_DESCENDING)
88 wxFLAGS_MEMBER(wxLC_VIRTUAL)
89
90 wxEND_FLAGS( wxListCtrlStyle )
91
92 IMPLEMENT_DYNAMIC_CLASS_XTI(wxListCtrl, wxControl,"wx/listctrl.h")
93
94 wxBEGIN_PROPERTIES_TABLE(wxListCtrl)
95 wxEVENT_PROPERTY( TextUpdated , wxEVT_COMMAND_TEXT_UPDATED , wxCommandEvent )
96
97 wxPROPERTY_FLAGS( WindowStyle , wxListCtrlStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
98 wxEND_PROPERTIES_TABLE()
99
100 wxBEGIN_HANDLERS_TABLE(wxListCtrl)
101 wxEND_HANDLERS_TABLE()
102
103 wxCONSTRUCTOR_5( wxListCtrl , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle )
104
105 /*
106 TODO : Expose more information of a list's layout etc. via appropriate objects (a la NotebookPageInfo)
107 */
108 #else
109 IMPLEMENT_DYNAMIC_CLASS(wxListCtrl, wxControl)
110 #endif
111
112 IMPLEMENT_DYNAMIC_CLASS(wxListView, wxListCtrl)
113 IMPLEMENT_DYNAMIC_CLASS(wxListItem, wxObject)
114
115 IMPLEMENT_DYNAMIC_CLASS(wxListEvent, wxNotifyEvent)
116
117 WX_DECLARE_HASH_MAP( int, wxListItem*, wxIntegerHash, wxIntegerEqual, wxListItemList );
118
119 #include "wx/listimpl.cpp"
120 WX_DEFINE_LIST(wxColumnList)
121
122 // so we can check for column clicks
123 static const EventTypeSpec eventList[] =
124 {
125 { kEventClassControl, kEventControlHit },
126 { kEventClassControl, kEventControlDraw }
127 };
128
129 static pascal OSStatus wxMacListCtrlEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
130 {
131 OSStatus result = eventNotHandledErr ;
132
133 wxMacCarbonEvent cEvent( event ) ;
134
135 ControlRef controlRef ;
136 cEvent.GetParameter( kEventParamDirectObject , &controlRef ) ;
137
138 wxListCtrl *window = (wxListCtrl*) data ;
139 wxListEvent le( wxEVT_COMMAND_LIST_COL_CLICK, window->GetId() );
140 le.SetEventObject( window );
141
142 switch ( GetEventKind( event ) )
143 {
144 // check if the column was clicked on and fire an event if so
145 case kEventControlHit :
146 {
147 ControlPartCode result = cEvent.GetParameter<ControlPartCode>(kEventParamControlPart, typeControlPartCode) ;
148 if (result == kControlButtonPart){
149 DataBrowserPropertyID col;
150 GetDataBrowserSortProperty(controlRef, &col);
151
152 DataBrowserTableViewColumnIndex column = 0;
153 verify_noerr( GetDataBrowserTableViewColumnPosition( controlRef, col, &column ) );
154
155 le.m_col = column;
156 // FIXME: we can't use the sort property for virtual listctrls
157 // so we need to find a better way to determine which column was clicked...
158 if (!window->IsVirtual())
159 window->HandleWindowEvent( le );
160 }
161 result = CallNextEventHandler(handler, event);
162 break;
163 }
164 case kEventControlDraw:
165 {
166 CGContextRef context = cEvent.GetParameter<CGContextRef>(kEventParamCGContextRef, typeCGContextRef) ;
167 window->MacSetDrawingContext(context);
168 result = CallNextEventHandler(handler, event);
169 window->MacSetDrawingContext(NULL);
170 break;
171 }
172 default :
173 break ;
174 }
175
176
177 return result ;
178 }
179
180 DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacListCtrlEventHandler )
181
182 class wxMacListCtrlItem : public wxMacDataItem
183 {
184 public:
185 wxMacListCtrlItem();
186
187 virtual void Notification(wxMacDataItemBrowserControl *owner ,
188 DataBrowserItemNotification message,
189 DataBrowserItemDataRef itemData ) const;
190
191 virtual void SetColumnInfo( unsigned int column, wxListItem* item );
192 virtual wxListItem* GetColumnInfo( unsigned int column );
193 virtual bool HasColumnInfo( unsigned int column );
194
195 virtual void SetColumnTextValue( unsigned int column, const wxString& text );
196 virtual wxString GetColumnTextValue( unsigned int column );
197
198 virtual int GetColumnImageValue( unsigned int column );
199 virtual void SetColumnImageValue( unsigned int column, int imageIndex );
200
201 virtual ~wxMacListCtrlItem();
202 protected:
203 wxListItemList m_rowItems;
204 };
205
206 DataBrowserDrawItemUPP gDataBrowserDrawItemUPP = NULL;
207 //DataBrowserEditItemUPP gDataBrowserEditItemUPP = NULL;
208 DataBrowserHitTestUPP gDataBrowserHitTestUPP = NULL;
209
210 // TODO: Make a better name!!
211 class wxMacDataBrowserListCtrlControl : public wxMacDataItemBrowserControl
212 {
213 public:
214 wxMacDataBrowserListCtrlControl( wxWindow *peer, const wxPoint& pos, const wxSize& size, long style );
215 wxMacDataBrowserListCtrlControl() {}
216 virtual ~wxMacDataBrowserListCtrlControl();
217
218 // create a list item (can be a subclass of wxMacListBoxItem)
219
220 virtual void MacInsertItem( unsigned int n, wxListItem* item );
221 virtual void MacSetColumnInfo( unsigned int row, unsigned int column, wxListItem* item );
222 virtual void MacGetColumnInfo( unsigned int row, unsigned int column, wxListItem& item );
223 virtual void UpdateState(wxMacDataItem* dataItem, wxListItem* item);
224 int GetFlags() { return m_flags; }
225
226 protected:
227 // we need to override to provide specialized handling for virtual wxListCtrls
228 virtual OSStatus GetSetItemData(DataBrowserItemID itemID,
229 DataBrowserPropertyID property,
230 DataBrowserItemDataRef itemData,
231 Boolean changeValue );
232
233 virtual void ItemNotification(
234 DataBrowserItemID itemID,
235 DataBrowserItemNotification message,
236 DataBrowserItemDataRef itemData);
237
238 virtual Boolean CompareItems(DataBrowserItemID itemOneID,
239 DataBrowserItemID itemTwoID,
240 DataBrowserPropertyID sortProperty);
241
242 static pascal void DataBrowserDrawItemProc(ControlRef browser,
243 DataBrowserItemID item,
244 DataBrowserPropertyID property,
245 DataBrowserItemState itemState,
246 const Rect *theRect,
247 SInt16 gdDepth,
248 Boolean colorDevice);
249
250 virtual void DrawItem(DataBrowserItemID itemID,
251 DataBrowserPropertyID property,
252 DataBrowserItemState itemState,
253 const Rect *itemRect,
254 SInt16 gdDepth,
255 Boolean colorDevice);
256
257 static pascal Boolean DataBrowserEditTextProc(ControlRef browser,
258 DataBrowserItemID item,
259 DataBrowserPropertyID property,
260 CFStringRef theString,
261 Rect *maxEditTextRect,
262 Boolean *shrinkToFit);
263
264 static pascal Boolean DataBrowserHitTestProc(ControlRef WXUNUSED(browser),
265 DataBrowserItemID WXUNUSED(itemID),
266 DataBrowserPropertyID WXUNUSED(property),
267 const Rect *WXUNUSED(theRect),
268 const Rect *WXUNUSED(mouseRect)) { return true; }
269
270 virtual bool ConfirmEditText(DataBrowserItemID item,
271 DataBrowserPropertyID property,
272 CFStringRef theString,
273 Rect *maxEditTextRect,
274 Boolean *shrinkToFit);
275
276
277
278 wxClientDataType m_clientDataItemsType;
279 bool m_isVirtual;
280 int m_flags;
281 DECLARE_DYNAMIC_CLASS_NO_COPY(wxMacDataBrowserListCtrlControl)
282 };
283
284 class wxMacListCtrlEventDelegate : public wxEvtHandler
285 {
286 public:
287 wxMacListCtrlEventDelegate( wxListCtrl* list, int id );
288 virtual bool ProcessEvent( wxEvent& event );
289
290 private:
291 wxListCtrl* m_list;
292 int m_id;
293 };
294
295 wxMacListCtrlEventDelegate::wxMacListCtrlEventDelegate( wxListCtrl* list, int id )
296 {
297 m_list = list;
298 m_id = id;
299 }
300
301 bool wxMacListCtrlEventDelegate::ProcessEvent( wxEvent& event )
302 {
303 int id = event.GetId();
304 wxObject* obj = event.GetEventObject();
305
306 // even though we use a generic list ctrl underneath, make sure
307 // we present ourselves as wxListCtrl.
308 event.SetEventObject( m_list );
309 event.SetId( m_id );
310
311 if ( !event.IsKindOf( CLASSINFO( wxCommandEvent ) ) )
312 {
313 if (m_list->GetEventHandler()->ProcessEvent( event ))
314 {
315 event.SetId(id);
316 event.SetEventObject(obj);
317 return true;
318 }
319 }
320 // Also try with the original id
321 bool success = wxEvtHandler::ProcessEvent(event);
322 event.SetId(id);
323 event.SetEventObject(obj);
324 if (!success && id != m_id)
325 success = wxEvtHandler::ProcessEvent(event);
326 return success;
327 }
328
329 //-----------------------------------------------------------------------------
330 // wxListCtrlRenameTimer (internal)
331 //-----------------------------------------------------------------------------
332
333 class wxListCtrlRenameTimer: public wxTimer
334 {
335 private:
336 wxListCtrl *m_owner;
337
338 public:
339 wxListCtrlRenameTimer( wxListCtrl *owner );
340 void Notify();
341 };
342
343 //-----------------------------------------------------------------------------
344 // wxListCtrlTextCtrlWrapper: wraps a wxTextCtrl to make it work for inline editing
345 //-----------------------------------------------------------------------------
346
347 class wxListCtrlTextCtrlWrapper : public wxEvtHandler
348 {
349 public:
350 // NB: text must be a valid object but not Create()d yet
351 wxListCtrlTextCtrlWrapper(wxListCtrl *owner,
352 wxTextCtrl *text,
353 long itemEdit);
354
355 wxTextCtrl *GetText() const { return m_text; }
356
357 void AcceptChangesAndFinish();
358
359 protected:
360 void OnChar( wxKeyEvent &event );
361 void OnKeyUp( wxKeyEvent &event );
362 void OnKillFocus( wxFocusEvent &event );
363
364 bool AcceptChanges();
365 void Finish();
366
367 private:
368 wxListCtrl *m_owner;
369 wxTextCtrl *m_text;
370 wxString m_startValue;
371 long m_itemEdited;
372 bool m_finished;
373 bool m_aboutToFinish;
374
375 DECLARE_EVENT_TABLE()
376 };
377
378 //-----------------------------------------------------------------------------
379 // wxListCtrlRenameTimer (internal)
380 //-----------------------------------------------------------------------------
381
382 wxListCtrlRenameTimer::wxListCtrlRenameTimer( wxListCtrl *owner )
383 {
384 m_owner = owner;
385 }
386
387 void wxListCtrlRenameTimer::Notify()
388 {
389 m_owner->OnRenameTimer();
390 }
391
392 //-----------------------------------------------------------------------------
393 // wxListCtrlTextCtrlWrapper (internal)
394 //-----------------------------------------------------------------------------
395
396 BEGIN_EVENT_TABLE(wxListCtrlTextCtrlWrapper, wxEvtHandler)
397 EVT_CHAR (wxListCtrlTextCtrlWrapper::OnChar)
398 EVT_KEY_UP (wxListCtrlTextCtrlWrapper::OnKeyUp)
399 EVT_KILL_FOCUS (wxListCtrlTextCtrlWrapper::OnKillFocus)
400 END_EVENT_TABLE()
401
402 wxListCtrlTextCtrlWrapper::wxListCtrlTextCtrlWrapper(wxListCtrl *owner,
403 wxTextCtrl *text,
404 long itemEdit)
405 : m_startValue(owner->GetItemText(itemEdit)),
406 m_itemEdited(itemEdit)
407 {
408 m_owner = owner;
409 m_text = text;
410 m_finished = false;
411 m_aboutToFinish = false;
412
413 wxRect rectLabel;
414 int offset = 8;
415 owner->GetItemRect(itemEdit, rectLabel);
416
417 m_text->Create(owner, wxID_ANY, m_startValue,
418 wxPoint(rectLabel.x+offset,rectLabel.y),
419 wxSize(rectLabel.width-offset,rectLabel.height));
420 m_text->SetFocus();
421
422 m_text->PushEventHandler(this);
423 }
424
425 void wxListCtrlTextCtrlWrapper::Finish()
426 {
427 if ( !m_finished )
428 {
429 m_finished = true;
430
431 m_text->RemoveEventHandler(this);
432 m_owner->FinishEditing(m_text);
433
434 wxPendingDelete.Append( this );
435 }
436 }
437
438 bool wxListCtrlTextCtrlWrapper::AcceptChanges()
439 {
440 const wxString value = m_text->GetValue();
441
442 if ( value == m_startValue )
443 // nothing changed, always accept
444 return true;
445
446 if ( !m_owner->OnRenameAccept(m_itemEdited, value) )
447 // vetoed by the user
448 return false;
449
450 // accepted, do rename the item
451 m_owner->SetItemText(m_itemEdited, value);
452
453 return true;
454 }
455
456 void wxListCtrlTextCtrlWrapper::AcceptChangesAndFinish()
457 {
458 m_aboutToFinish = true;
459
460 // Notify the owner about the changes
461 AcceptChanges();
462
463 // Even if vetoed, close the control (consistent with MSW)
464 Finish();
465 }
466
467 void wxListCtrlTextCtrlWrapper::OnChar( wxKeyEvent &event )
468 {
469 switch ( event.m_keyCode )
470 {
471 case WXK_RETURN:
472 AcceptChangesAndFinish();
473 break;
474
475 case WXK_ESCAPE:
476 m_owner->OnRenameCancelled( m_itemEdited );
477 Finish();
478 break;
479
480 default:
481 event.Skip();
482 }
483 }
484
485 void wxListCtrlTextCtrlWrapper::OnKeyUp( wxKeyEvent &event )
486 {
487 if (m_finished)
488 {
489 event.Skip();
490 return;
491 }
492
493 // auto-grow the textctrl:
494 wxSize parentSize = m_owner->GetSize();
495 wxPoint myPos = m_text->GetPosition();
496 wxSize mySize = m_text->GetSize();
497 int sx, sy;
498 m_text->GetTextExtent(m_text->GetValue() + wxT("MM"), &sx, &sy);
499 if (myPos.x + sx > parentSize.x)
500 sx = parentSize.x - myPos.x;
501 if (mySize.x > sx)
502 sx = mySize.x;
503 m_text->SetSize(sx, wxDefaultCoord);
504
505 event.Skip();
506 }
507
508 void wxListCtrlTextCtrlWrapper::OnKillFocus( wxFocusEvent &event )
509 {
510 if ( !m_finished && !m_aboutToFinish )
511 {
512 if ( !AcceptChanges() )
513 m_owner->OnRenameCancelled( m_itemEdited );
514
515 Finish();
516 }
517
518 // We must let the native text control handle focus
519 event.Skip();
520 }
521
522 BEGIN_EVENT_TABLE(wxListCtrl, wxControl)
523 EVT_LEFT_DOWN(wxListCtrl::OnLeftDown)
524 EVT_LEFT_DCLICK(wxListCtrl::OnDblClick)
525 EVT_MIDDLE_DOWN(wxListCtrl::OnMiddleDown)
526 EVT_RIGHT_DOWN(wxListCtrl::OnRightDown)
527 EVT_CHAR(wxListCtrl::OnChar)
528 END_EVENT_TABLE()
529
530 // ============================================================================
531 // implementation
532 // ============================================================================
533
534 wxMacDataBrowserListCtrlControl* wxListCtrl::GetListPeer() const
535 {
536 return dynamic_cast<wxMacDataBrowserListCtrlControl*> ( GetPeer() );
537 }
538
539 // ----------------------------------------------------------------------------
540 // wxListCtrl construction
541 // ----------------------------------------------------------------------------
542
543 void wxListCtrl::Init()
544 {
545 m_imageListNormal = NULL;
546 m_imageListSmall = NULL;
547 m_imageListState = NULL;
548
549 // keep track of if we created our own image lists, or if they were assigned
550 // to us.
551 m_ownsImageListNormal = m_ownsImageListSmall = m_ownsImageListState = false;
552 m_colCount = 0;
553 m_count = 0;
554 m_textCtrl = NULL;
555 m_genericImpl = NULL;
556 m_dbImpl = NULL;
557 m_compareFunc = NULL;
558 m_compareFuncData = 0;
559 m_colsInfo = wxColumnList();
560 m_textColor = wxNullColour;
561 m_bgColor = wxNullColour;
562 m_textctrlWrapper = NULL;
563 m_current = -1;
564 m_renameTimer = new wxListCtrlRenameTimer( this );
565 }
566
567 class wxGenericListCtrlHook : public wxGenericListCtrl
568 {
569 public:
570 wxGenericListCtrlHook(wxListCtrl* parent,
571 wxWindowID id,
572 const wxPoint& pos,
573 const wxSize& size,
574 long style,
575 const wxValidator& validator,
576 const wxString& name)
577 : wxGenericListCtrl(parent, id, pos, size, style, validator, name),
578 m_nativeListCtrl(parent)
579 {
580 }
581
582 protected:
583 virtual wxListItemAttr * OnGetItemAttr(long item) const
584 {
585 return m_nativeListCtrl->OnGetItemAttr(item);
586 }
587
588 virtual int OnGetItemImage(long item) const
589 {
590 return m_nativeListCtrl->OnGetItemImage(item);
591 }
592
593 virtual int OnGetItemColumnImage(long item, long column) const
594 {
595 return m_nativeListCtrl->OnGetItemColumnImage(item, column);
596 }
597
598 virtual wxString OnGetItemText(long item, long column) const
599 {
600 return m_nativeListCtrl->OnGetItemText(item, column);
601 }
602
603 wxListCtrl* m_nativeListCtrl;
604
605 };
606
607 void wxListCtrl::OnLeftDown(wxMouseEvent& event)
608 {
609 if ( m_textctrlWrapper )
610 {
611 m_current = -1;
612 m_textctrlWrapper->AcceptChangesAndFinish();
613 }
614
615 int hitResult;
616 long current = HitTest(event.GetPosition(), hitResult);
617 if ((current == m_current) &&
618 (hitResult & wxLIST_HITTEST_ONITEMLABEL) &&
619 HasFlag(wxLC_EDIT_LABELS) )
620 {
621 m_renameTimer->Start( 100, true );
622 }
623 else
624 {
625 m_current = current;
626 }
627 event.Skip();
628 }
629
630 void wxListCtrl::OnDblClick(wxMouseEvent& event)
631 {
632 if ( m_renameTimer->IsRunning() )
633 m_renameTimer->Stop();
634 event.Skip();
635 }
636
637 #if wxABI_VERSION >= 20801
638 void wxListCtrl::OnRightDown(wxMouseEvent& event)
639 {
640 if (m_dbImpl)
641 FireMouseEvent(wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK, event.GetPosition());
642 event.Skip();
643 }
644
645 void wxListCtrl::OnMiddleDown(wxMouseEvent& event)
646 {
647 if (m_dbImpl)
648 FireMouseEvent(wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK, event.GetPosition());
649 event.Skip();
650 }
651
652 void wxListCtrl::FireMouseEvent(wxEventType eventType, wxPoint position)
653 {
654 wxListEvent le( eventType, GetId() );
655 le.SetEventObject(this);
656 le.m_pointDrag = position;
657 le.m_itemIndex = -1;
658
659 int flags;
660 long item = HitTest(position, flags);
661 if (flags & wxLIST_HITTEST_ONITEM)
662 {
663 le.m_itemIndex = item;
664 le.m_item.m_itemId = item;
665 GetItem(le.m_item);
666 HandleWindowEvent(le);
667 }
668 }
669
670 void wxListCtrl::OnChar(wxKeyEvent& event)
671 {
672
673
674 if (m_dbImpl)
675 {
676 wxListEvent le( wxEVT_COMMAND_LIST_KEY_DOWN, GetId() );
677 le.SetEventObject(this);
678 le.m_code = event.GetKeyCode();
679 le.m_itemIndex = -1;
680
681 if (m_current == -1)
682 {
683 // if m_current isn't set, check if there's been a selection
684 // made before continuing
685 m_current = GetNextItem(-1, wxLIST_NEXT_BELOW, wxLIST_STATE_SELECTED);
686 }
687
688 // We need to determine m_current ourselves when navigation keys
689 // are used. Note that PAGEUP and PAGEDOWN do not alter the current
690 // item on native Mac ListCtrl, so we only handle up and down keys.
691 switch ( event.GetKeyCode() )
692 {
693 case WXK_UP:
694 if ( m_current > 0 )
695 m_current -= 1;
696 else
697 m_current = 0;
698
699 break;
700
701 case WXK_DOWN:
702 if ( m_current < GetItemCount() - 1 )
703 m_current += 1;
704 else
705 m_current = GetItemCount() - 1;
706
707 break;
708 }
709
710 if (m_current != -1)
711 {
712 le.m_itemIndex = m_current;
713 le.m_item.m_itemId = m_current;
714 GetItem(le.m_item);
715 HandleWindowEvent(le);
716 }
717 }
718 event.Skip();
719 }
720 #endif
721
722 bool wxListCtrl::Create(wxWindow *parent,
723 wxWindowID id,
724 const wxPoint& pos,
725 const wxSize& size,
726 long style,
727 const wxValidator& validator,
728 const wxString& name)
729 {
730
731 // for now, we'll always use the generic list control for ICON and LIST views,
732 // because they dynamically change the number of columns on resize.
733 // Also, allow the user to set it to use the list ctrl as well.
734 if ( (wxSystemOptions::HasOption( wxMAC_ALWAYS_USE_GENERIC_LISTCTRL )
735 && (wxSystemOptions::GetOptionInt( wxMAC_ALWAYS_USE_GENERIC_LISTCTRL ) == 1)) ||
736 (style & wxLC_ICON) || (style & wxLC_SMALL_ICON) || (style & wxLC_LIST) )
737 {
738 m_macIsUserPane = true;
739
740 long paneStyle = style;
741 paneStyle &= ~wxSIMPLE_BORDER;
742 paneStyle &= ~wxDOUBLE_BORDER;
743 paneStyle &= ~wxSUNKEN_BORDER;
744 paneStyle &= ~wxRAISED_BORDER;
745 paneStyle &= ~wxSTATIC_BORDER;
746 if ( !wxWindow::Create(parent, id, pos, size, paneStyle | wxNO_BORDER, name) )
747 return false;
748
749 // since the generic control is a child, make sure we position it at 0, 0
750 m_genericImpl = new wxGenericListCtrlHook(this, id, wxPoint(0, 0), size, style, validator, name);
751 m_genericImpl->PushEventHandler( new wxMacListCtrlEventDelegate( this, GetId() ) );
752 return true;
753 }
754
755 else
756 {
757 m_macIsUserPane = false;
758 if ( !wxWindow::Create(parent, id, pos, size, style & ~(wxHSCROLL | wxVSCROLL), name) )
759 return false;
760 m_dbImpl = new wxMacDataBrowserListCtrlControl( this, pos, size, style );
761 m_peer = m_dbImpl;
762
763 MacPostControlCreate( pos, size );
764
765 InstallControlEventHandler( m_peer->GetControlRef() , GetwxMacListCtrlEventHandlerUPP(),
766 GetEventTypeCount(eventList), eventList, this,
767 (EventHandlerRef *)&m_macListCtrlEventHandler);
768 }
769
770 return true;
771 }
772
773 wxListCtrl::~wxListCtrl()
774 {
775 if (m_genericImpl)
776 {
777 m_genericImpl->PopEventHandler(/* deleteHandler = */ true);
778 }
779
780 if (m_ownsImageListNormal)
781 delete m_imageListNormal;
782 if (m_ownsImageListSmall)
783 delete m_imageListSmall;
784 if (m_ownsImageListState)
785 delete m_imageListState;
786
787 delete m_renameTimer;
788
789 WX_CLEAR_LIST(wxColumnList, m_colsInfo);
790 }
791
792 /*static*/
793 wxVisualAttributes
794 wxListCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
795 {
796 wxVisualAttributes attr;
797
798 attr.colFg = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT );
799 attr.colBg = wxSystemSettings::GetColour( wxSYS_COLOUR_LISTBOX );
800 attr.font.CreateSystemFont(wxOSX_SYSTEM_FONT_VIEWS);
801
802 return attr;
803 }
804
805 // ----------------------------------------------------------------------------
806 // set/get/change style
807 // ----------------------------------------------------------------------------
808
809 // Add or remove a single window style
810 void wxListCtrl::SetSingleStyle(long style, bool add)
811 {
812 long flag = GetWindowStyleFlag();
813
814 // Get rid of conflicting styles
815 if ( add )
816 {
817 if ( style & wxLC_MASK_TYPE)
818 flag = flag & ~wxLC_MASK_TYPE;
819 if ( style & wxLC_MASK_ALIGN )
820 flag = flag & ~wxLC_MASK_ALIGN;
821 if ( style & wxLC_MASK_SORT )
822 flag = flag & ~wxLC_MASK_SORT;
823 }
824
825 if ( add )
826 flag |= style;
827 else
828 flag &= ~style;
829
830 SetWindowStyleFlag(flag);
831 }
832
833 // Set the whole window style
834 void wxListCtrl::SetWindowStyleFlag(long flag)
835 {
836 if ( flag != m_windowStyle )
837 {
838 m_windowStyle = flag;
839
840 if (m_genericImpl)
841 {
842 m_genericImpl->SetWindowStyleFlag(flag);
843 }
844
845 Refresh();
846 }
847 }
848
849 void wxListCtrl::DoSetSize( int x, int y, int width, int height, int sizeFlags )
850 {
851 wxControl::DoSetSize(x, y, width, height, sizeFlags);
852
853 if (m_genericImpl)
854 m_genericImpl->SetSize(0, 0, width, height, sizeFlags);
855
856 // determine if we need a horizontal scrollbar, and add it if so
857 if (m_dbImpl)
858 {
859 int totalWidth = 0;
860 for (int column = 0; column < GetColumnCount(); column++)
861 {
862 totalWidth += m_dbImpl->GetColumnWidth( column );
863 }
864
865 if ( !(m_dbImpl->GetFlags() & wxHSCROLL) )
866 {
867 Boolean vertScrollBar;
868 GetDataBrowserHasScrollBars( m_dbImpl->GetControlRef(), NULL, &vertScrollBar );
869 if (totalWidth > width)
870 SetDataBrowserHasScrollBars( m_dbImpl->GetControlRef(), true, vertScrollBar );
871 else
872 SetDataBrowserHasScrollBars( m_dbImpl->GetControlRef(), false, vertScrollBar );
873 }
874 }
875 }
876
877 wxSize wxListCtrl::DoGetBestSize() const
878 {
879 return wxWindow::DoGetBestSize();
880 }
881
882 bool wxListCtrl::SetFont(const wxFont& font)
883 {
884 bool rv = true;
885 rv = wxControl::SetFont(font);
886 if (m_genericImpl)
887 rv = m_genericImpl->SetFont(font);
888 return rv;
889 }
890
891 bool wxListCtrl::SetForegroundColour(const wxColour& colour)
892 {
893 bool rv = true;
894 if (m_genericImpl)
895 rv = m_genericImpl->SetForegroundColour(colour);
896 if (m_dbImpl)
897 SetTextColour(colour);
898 return rv;
899 }
900
901 bool wxListCtrl::SetBackgroundColour(const wxColour& colour)
902 {
903 bool rv = true;
904 if (m_genericImpl)
905 rv = m_genericImpl->SetBackgroundColour(colour);
906 if (m_dbImpl)
907 m_bgColor = colour;
908 return rv;
909 }
910
911 wxColour wxListCtrl::GetBackgroundColour() const
912 {
913 if (m_genericImpl)
914 return m_genericImpl->GetBackgroundColour();
915 if (m_dbImpl)
916 return m_bgColor;
917
918 return wxNullColour;
919 }
920
921 void wxListCtrl::Freeze ()
922 {
923 if (m_genericImpl)
924 m_genericImpl->Freeze();
925 wxControl::Freeze();
926 }
927
928 void wxListCtrl::Thaw ()
929 {
930 if (m_genericImpl)
931 m_genericImpl->Thaw();
932 wxControl::Thaw();
933 }
934
935 void wxListCtrl::Update ()
936 {
937 if (m_genericImpl)
938 m_genericImpl->Update();
939 wxControl::Update();
940 }
941
942 // ----------------------------------------------------------------------------
943 // accessors
944 // ----------------------------------------------------------------------------
945
946 // Gets information about this column
947 bool wxListCtrl::GetColumn(int col, wxListItem& item) const
948 {
949 if (m_genericImpl)
950 return m_genericImpl->GetColumn(col, item);
951
952 bool success = true;
953
954 if (m_dbImpl)
955 {
956 wxColumnList::compatibility_iterator node = m_colsInfo.Item( col );
957 wxASSERT_MSG( node, wxT("invalid column index in wxMacListCtrlItem") );
958 wxListItem* column = node->GetData();
959
960 long mask = column->GetMask();
961 if (mask & wxLIST_MASK_TEXT)
962 item.SetText(column->GetText());
963 if (mask & wxLIST_MASK_DATA)
964 item.SetData(column->GetData());
965 if (mask & wxLIST_MASK_IMAGE)
966 item.SetImage(column->GetImage());
967 if (mask & wxLIST_MASK_STATE)
968 item.SetState(column->GetState());
969 if (mask & wxLIST_MASK_FORMAT)
970 item.SetAlign(column->GetAlign());
971 if (mask & wxLIST_MASK_WIDTH)
972 item.SetWidth(column->GetWidth());
973 }
974
975 return success;
976 }
977
978 // Sets information about this column
979 bool wxListCtrl::SetColumn(int col, wxListItem& item)
980 {
981 if (m_genericImpl)
982 return m_genericImpl->SetColumn(col, item);
983
984 if (m_dbImpl)
985 {
986 wxASSERT_MSG( col < (int)m_colsInfo.GetCount(), wxT("invalid column index in wxMacListCtrlItem") );
987
988 long mask = item.GetMask();
989 {
990 wxListItem listItem;
991 GetColumn( col, listItem );
992
993 if (mask & wxLIST_MASK_TEXT)
994 listItem.SetText(item.GetText());
995 if (mask & wxLIST_MASK_DATA)
996 listItem.SetData(item.GetData());
997 if (mask & wxLIST_MASK_IMAGE)
998 listItem.SetImage(item.GetImage());
999 if (mask & wxLIST_MASK_STATE)
1000 listItem.SetState(item.GetState());
1001 if (mask & wxLIST_MASK_FORMAT)
1002 listItem.SetAlign(item.GetAlign());
1003 if (mask & wxLIST_MASK_WIDTH)
1004 listItem.SetWidth(item.GetWidth());
1005 }
1006
1007 // change the appearance in the databrowser.
1008 DataBrowserListViewHeaderDesc columnDesc;
1009 columnDesc.version=kDataBrowserListViewLatestHeaderDesc;
1010
1011 DataBrowserTableViewColumnID id = 0;
1012 verify_noerr( m_dbImpl->GetColumnIDFromIndex( col, &id ) );
1013 verify_noerr( m_dbImpl->GetHeaderDesc( id, &columnDesc ) );
1014
1015 /*
1016 if (item.GetMask() & wxLIST_MASK_TEXT)
1017 {
1018 wxFontEncoding enc;
1019 if ( m_font.Ok() )
1020 enc = GetFont().GetEncoding();
1021 else
1022 enc = wxLocale::GetSystemEncoding();
1023 wxCFStringRef cfTitle;
1024 cfTitle.Assign( item.GetText() , enc );
1025 if(columnDesc.titleString)
1026 CFRelease(columnDesc.titleString);
1027 columnDesc.titleString = cfTitle;
1028 }
1029 */
1030
1031 if (item.GetMask() & wxLIST_MASK_IMAGE && item.GetImage() != -1 )
1032 {
1033 wxImageList* imageList = GetImageList(wxIMAGE_LIST_SMALL);
1034 if (imageList && imageList->GetImageCount() > 0 )
1035 {
1036 wxBitmap bmp = imageList->GetBitmap( item.GetImage() );
1037 IconRef icon = bmp.GetIconRef();
1038 columnDesc.btnContentInfo.u.iconRef = icon;
1039 columnDesc.btnContentInfo.contentType = kControlContentIconRef;
1040 }
1041 }
1042
1043 verify_noerr( m_dbImpl->SetHeaderDesc( id, &columnDesc ) );
1044
1045 }
1046 return true;
1047 }
1048
1049 int wxListCtrl::GetColumnCount() const
1050 {
1051 if (m_genericImpl)
1052 return m_genericImpl->GetColumnCount();
1053
1054 if (m_dbImpl)
1055 {
1056 UInt32 count;
1057 m_dbImpl->GetColumnCount(&count);
1058 return count;
1059 }
1060
1061 return m_colCount;
1062 }
1063
1064 // Gets the column width
1065 int wxListCtrl::GetColumnWidth(int col) const
1066 {
1067 if (m_genericImpl)
1068 return m_genericImpl->GetColumnWidth(col);
1069
1070 if (m_dbImpl)
1071 {
1072 return m_dbImpl->GetColumnWidth(col);
1073 }
1074
1075 return 0;
1076 }
1077
1078 // Sets the column width
1079 bool wxListCtrl::SetColumnWidth(int col, int width)
1080 {
1081 if (m_genericImpl)
1082 return m_genericImpl->SetColumnWidth(col, width);
1083
1084 if (m_dbImpl)
1085 {
1086 if ( width == wxLIST_AUTOSIZE_USEHEADER )
1087 {
1088 width = 150; // FIXME
1089 }
1090
1091 if (col == -1)
1092 {
1093 for (int column = 0; column < GetColumnCount(); column++)
1094 {
1095 wxListItem colInfo;
1096 GetColumn(column, colInfo);
1097
1098 colInfo.SetWidth(width);
1099 SetColumn(column, colInfo);
1100
1101 const int mywidth = (width == wxLIST_AUTOSIZE)
1102 ? CalcColumnAutoWidth(column) : width;
1103 m_dbImpl->SetColumnWidth(column, mywidth);
1104 }
1105 }
1106 else
1107 {
1108 if ( width == wxLIST_AUTOSIZE )
1109 width = CalcColumnAutoWidth(col);
1110
1111 wxListItem colInfo;
1112 GetColumn(col, colInfo);
1113
1114 colInfo.SetWidth(width);
1115 SetColumn(col, colInfo);
1116 m_dbImpl->SetColumnWidth(col, width);
1117 }
1118 return true;
1119 }
1120
1121 return false;
1122 }
1123
1124 // Gets the number of items that can fit vertically in the
1125 // visible area of the list control (list or report view)
1126 // or the total number of items in the list control (icon
1127 // or small icon view)
1128 int wxListCtrl::GetCountPerPage() const
1129 {
1130 if (m_genericImpl)
1131 return m_genericImpl->GetCountPerPage();
1132
1133 if (m_dbImpl)
1134 {
1135 UInt16 height = 1;
1136 m_dbImpl->GetDefaultRowHeight( &height );
1137 if (height > 0)
1138 return GetClientSize().y / height;
1139 }
1140
1141 return 1;
1142 }
1143
1144 // Gets the edit control for editing labels.
1145 wxTextCtrl* wxListCtrl::GetEditControl() const
1146 {
1147 if (m_genericImpl)
1148 return m_genericImpl->GetEditControl();
1149
1150 return NULL;
1151 }
1152
1153 // Gets information about the item
1154 bool wxListCtrl::GetItem(wxListItem& info) const
1155 {
1156 if (m_genericImpl)
1157 return m_genericImpl->GetItem(info);
1158
1159 if (m_dbImpl)
1160 {
1161 if (!IsVirtual())
1162 {
1163 if (info.m_itemId >= 0 && info.m_itemId < GetItemCount())
1164 {
1165 m_dbImpl->MacGetColumnInfo(info.m_itemId, info.m_col, info);
1166 // MacGetColumnInfo returns erroneous information in the state field, so zero it.
1167 info.SetState(0);
1168 if (info.GetMask() & wxLIST_MASK_STATE)
1169 {
1170 DataBrowserItemID id = (DataBrowserItemID)m_dbImpl->GetItemFromLine(info.m_itemId);
1171 if (IsDataBrowserItemSelected( m_dbImpl->GetControlRef(), id ))
1172 info.SetState(info.GetState() | wxLIST_STATE_SELECTED);
1173 }
1174 }
1175 }
1176 else
1177 {
1178 if (info.m_itemId >= 0 && info.m_itemId < GetItemCount())
1179 {
1180 info.SetText( OnGetItemText(info.m_itemId, info.m_col) );
1181 info.SetImage( OnGetItemColumnImage(info.m_itemId, info.m_col) );
1182 if (info.GetMask() & wxLIST_MASK_STATE)
1183 {
1184 if (IsDataBrowserItemSelected( m_dbImpl->GetControlRef(), info.m_itemId+1 ))
1185 info.SetState(info.GetState() | wxLIST_STATE_SELECTED);
1186 }
1187
1188 wxListItemAttr* attrs = OnGetItemAttr( info.m_itemId );
1189 if (attrs)
1190 {
1191 info.SetFont( attrs->GetFont() );
1192 info.SetBackgroundColour( attrs->GetBackgroundColour() );
1193 info.SetTextColour( attrs->GetTextColour() );
1194 }
1195 }
1196 }
1197 }
1198 bool success = true;
1199 return success;
1200 }
1201
1202 // Sets information about the item
1203 bool wxListCtrl::SetItem(wxListItem& info)
1204 {
1205 if (m_genericImpl)
1206 return m_genericImpl->SetItem(info);
1207
1208 if (m_dbImpl)
1209 m_dbImpl->MacSetColumnInfo( info.m_itemId, info.m_col, &info );
1210
1211 return true;
1212 }
1213
1214 long wxListCtrl::SetItem(long index, int col, const wxString& label, int imageId)
1215 {
1216 if (m_genericImpl)
1217 return m_genericImpl->SetItem(index, col, label, imageId);
1218
1219 wxListItem info;
1220 info.m_text = label;
1221 info.m_mask = wxLIST_MASK_TEXT;
1222 info.m_itemId = index;
1223 info.m_col = col;
1224 if ( imageId > -1 )
1225 {
1226 info.m_image = imageId;
1227 info.m_mask |= wxLIST_MASK_IMAGE;
1228 }
1229 return SetItem(info);
1230 }
1231
1232
1233 // Gets the item state
1234 int wxListCtrl::GetItemState(long item, long stateMask) const
1235 {
1236 if (m_genericImpl)
1237 return m_genericImpl->GetItemState(item, stateMask);
1238
1239 if (m_dbImpl)
1240 {
1241 if ( HasFlag(wxLC_VIRTUAL) )
1242 {
1243 if (stateMask == wxLIST_STATE_SELECTED)
1244 {
1245 if (IsDataBrowserItemSelected( m_dbImpl->GetControlRef(), item+1 ))
1246 return wxLIST_STATE_SELECTED;
1247 else
1248 return 0;
1249 }
1250 }
1251 else
1252 {
1253 wxListItem info;
1254
1255 info.m_mask = wxLIST_MASK_STATE;
1256 info.m_stateMask = stateMask;
1257 info.m_itemId = item;
1258
1259 if (!GetItem(info))
1260 return 0;
1261
1262 return info.m_state;
1263 }
1264 }
1265
1266 return 0;
1267 }
1268
1269 // Sets the item state
1270 bool wxListCtrl::SetItemState(long item, long state, long stateMask)
1271 {
1272 if (m_genericImpl)
1273 return m_genericImpl->SetItemState(item, state, stateMask);
1274
1275 if (m_dbImpl)
1276 {
1277 DataBrowserSetOption option = kDataBrowserItemsAdd;
1278 if ( (stateMask & wxLIST_STATE_SELECTED) && state == 0 )
1279 option = kDataBrowserItemsRemove;
1280
1281 if (item == -1)
1282 {
1283 if ( HasFlag(wxLC_VIRTUAL) )
1284 {
1285 wxMacDataItemBrowserSelectionSuppressor suppressor(m_dbImpl);
1286 m_dbImpl->SetSelectedAllItems(option);
1287 }
1288 else
1289 {
1290 for(int i = 0; i < GetItemCount();i++)
1291 {
1292 wxListItem info;
1293 info.m_itemId = i;
1294 info.m_mask = wxLIST_MASK_STATE;
1295 info.m_stateMask = stateMask;
1296 info.m_state = state;
1297 SetItem(info);
1298 }
1299 }
1300 }
1301 else
1302 {
1303 if ( HasFlag(wxLC_VIRTUAL) )
1304 {
1305 long itemID = item+1;
1306 bool isSelected = IsDataBrowserItemSelected(m_dbImpl->GetControlRef(), (DataBrowserItemID)itemID );
1307 bool isSelectedState = (state == wxLIST_STATE_SELECTED);
1308
1309 // toggle the selection state if wxListInfo state and actual state don't match.
1310 if ( (stateMask & wxLIST_STATE_SELECTED) && isSelected != isSelectedState )
1311 {
1312 SetDataBrowserSelectedItems(m_dbImpl->GetControlRef(), 1, (DataBrowserItemID*)&itemID, option);
1313 }
1314 }
1315 else
1316 {
1317 wxListItem info;
1318 info.m_itemId = item;
1319 info.m_mask = wxLIST_MASK_STATE;
1320 info.m_stateMask = stateMask;
1321 info.m_state = state;
1322 return SetItem(info);
1323 }
1324 }
1325 }
1326 return true;
1327 }
1328
1329 // Sets the item image
1330 bool wxListCtrl::SetItemImage(long item, int image, int WXUNUSED(selImage))
1331 {
1332 return SetItemColumnImage(item, 0, image);
1333 }
1334
1335 // Sets the item image
1336 bool wxListCtrl::SetItemColumnImage(long item, long column, int image)
1337 {
1338 if (m_genericImpl)
1339 return m_genericImpl->SetItemColumnImage(item, column, image);
1340
1341 wxListItem info;
1342
1343 info.m_mask = wxLIST_MASK_IMAGE;
1344 info.m_image = image;
1345 info.m_itemId = item;
1346 info.m_col = column;
1347
1348 return SetItem(info);
1349 }
1350
1351 // Gets the item text
1352 wxString wxListCtrl::GetItemText(long item) const
1353 {
1354 if (m_genericImpl)
1355 return m_genericImpl->GetItemText(item);
1356
1357 wxListItem info;
1358
1359 info.m_mask = wxLIST_MASK_TEXT;
1360 info.m_itemId = item;
1361
1362 if (!GetItem(info))
1363 return wxEmptyString;
1364 return info.m_text;
1365 }
1366
1367 // Sets the item text
1368 void wxListCtrl::SetItemText(long item, const wxString& str)
1369 {
1370 if (m_genericImpl)
1371 return m_genericImpl->SetItemText(item, str);
1372
1373 wxListItem info;
1374
1375 info.m_mask = wxLIST_MASK_TEXT;
1376 info.m_itemId = item;
1377 info.m_text = str;
1378
1379 SetItem(info);
1380 }
1381
1382 // Gets the item data
1383 long wxListCtrl::GetItemData(long item) const
1384 {
1385 if (m_genericImpl)
1386 return m_genericImpl->GetItemData(item);
1387
1388 wxListItem info;
1389
1390 info.m_mask = wxLIST_MASK_DATA;
1391 info.m_itemId = item;
1392
1393 if (!GetItem(info))
1394 return 0;
1395 return info.m_data;
1396 }
1397
1398 // Sets the item data
1399 bool wxListCtrl::SetItemPtrData(long item, wxUIntPtr data)
1400 {
1401 if (m_genericImpl)
1402 return m_genericImpl->SetItemData(item, data);
1403
1404 wxListItem info;
1405
1406 info.m_mask = wxLIST_MASK_DATA;
1407 info.m_itemId = item;
1408 info.m_data = data;
1409
1410 return SetItem(info);
1411 }
1412
1413 wxRect wxListCtrl::GetViewRect() const
1414 {
1415 wxASSERT_MSG( !HasFlag(wxLC_REPORT | wxLC_LIST),
1416 wxT("wxListCtrl::GetViewRect() only works in icon mode") );
1417
1418 if (m_genericImpl)
1419 return m_genericImpl->GetViewRect();
1420
1421 wxRect rect;
1422 return rect;
1423 }
1424
1425 bool wxListCtrl::GetSubItemRect( long item, long subItem, wxRect& rect, int code ) const
1426 {
1427 if (m_genericImpl)
1428 return m_genericImpl->GetSubItemRect(item, subItem, rect, code);
1429
1430 // TODO: implement for DataBrowser implementation
1431 return false;
1432 }
1433
1434 // Gets the item rectangle
1435 bool wxListCtrl::GetItemRect(long item, wxRect& rect, int code) const
1436 {
1437 if (m_genericImpl)
1438 return m_genericImpl->GetItemRect(item, rect, code);
1439
1440
1441 if (m_dbImpl)
1442 {
1443 DataBrowserItemID id;
1444
1445 DataBrowserTableViewColumnID col = 0;
1446 verify_noerr( m_dbImpl->GetColumnIDFromIndex( 0, &col ) );
1447
1448 Rect bounds;
1449 DataBrowserPropertyPart part = kDataBrowserPropertyEnclosingPart;
1450 if ( code == wxLIST_RECT_LABEL )
1451 part = kDataBrowserPropertyTextPart;
1452 else if ( code == wxLIST_RECT_ICON )
1453 part = kDataBrowserPropertyIconPart;
1454
1455 if ( !(GetWindowStyleFlag() & wxLC_VIRTUAL) )
1456 {
1457 wxMacDataItem* thisItem = m_dbImpl->GetItemFromLine(item);
1458 id = (DataBrowserItemID) thisItem;
1459 }
1460 else
1461 id = item+1;
1462
1463 GetDataBrowserItemPartBounds( m_dbImpl->GetControlRef(), id, col, part, &bounds );
1464
1465 rect.x = bounds.left;
1466 rect.y = bounds.top;
1467 rect.width = bounds.right - bounds.left; //GetClientSize().x; // we need the width of the whole row, not just the item.
1468 rect.height = bounds.bottom - bounds.top;
1469 //fprintf("id = %d, bounds = %d, %d, %d, %d\n", id, rect.x, rect.y, rect.width, rect.height);
1470 }
1471 return true;
1472 }
1473
1474 // Gets the item position
1475 bool wxListCtrl::GetItemPosition(long item, wxPoint& pos) const
1476 {
1477 if (m_genericImpl)
1478 return m_genericImpl->GetItemPosition(item, pos);
1479
1480 bool success = false;
1481
1482 if (m_dbImpl)
1483 {
1484 wxRect itemRect;
1485 GetItemRect(item, itemRect);
1486 pos = itemRect.GetPosition();
1487 success = true;
1488 }
1489
1490 return success;
1491 }
1492
1493 // Sets the item position.
1494 bool wxListCtrl::SetItemPosition(long item, const wxPoint& pos)
1495 {
1496 if (m_genericImpl)
1497 return m_genericImpl->SetItemPosition(item, pos);
1498
1499 return false;
1500 }
1501
1502 // Gets the number of items in the list control
1503 int wxListCtrl::GetItemCount() const
1504 {
1505 if (m_genericImpl)
1506 return m_genericImpl->GetItemCount();
1507
1508 if (m_dbImpl)
1509 return m_dbImpl->MacGetCount();
1510
1511 return m_count;
1512 }
1513
1514 void wxListCtrl::SetItemSpacing( int spacing, bool isSmall )
1515 {
1516 if (m_genericImpl)
1517 m_genericImpl->SetItemSpacing(spacing, isSmall);
1518 }
1519
1520 wxSize wxListCtrl::GetItemSpacing() const
1521 {
1522 if (m_genericImpl)
1523 return m_genericImpl->GetItemSpacing();
1524
1525 return wxSize(0, 0);
1526 }
1527
1528 void wxListCtrl::SetItemTextColour( long item, const wxColour &col )
1529 {
1530 if (m_genericImpl)
1531 {
1532 m_genericImpl->SetItemTextColour(item, col);
1533 return;
1534 }
1535
1536 wxListItem info;
1537 info.m_itemId = item;
1538 info.SetTextColour( col );
1539 SetItem( info );
1540 }
1541
1542 wxColour wxListCtrl::GetItemTextColour( long item ) const
1543 {
1544 if (m_genericImpl)
1545 return m_genericImpl->GetItemTextColour(item);
1546
1547 if (m_dbImpl)
1548 {
1549 wxListItem info;
1550 if (GetItem(info))
1551 return info.GetTextColour();
1552 }
1553 return wxNullColour;
1554 }
1555
1556 void wxListCtrl::SetItemBackgroundColour( long item, const wxColour &col )
1557 {
1558 if (m_genericImpl)
1559 {
1560 m_genericImpl->SetItemBackgroundColour(item, col);
1561 return;
1562 }
1563
1564 wxListItem info;
1565 info.m_itemId = item;
1566 info.SetBackgroundColour( col );
1567 SetItem( info );
1568 }
1569
1570 wxColour wxListCtrl::GetItemBackgroundColour( long item ) const
1571 {
1572 if (m_genericImpl)
1573 return m_genericImpl->GetItemBackgroundColour(item);
1574
1575 if (m_dbImpl)
1576 {
1577 wxListItem info;
1578 if (GetItem(info))
1579 return info.GetBackgroundColour();
1580 }
1581 return wxNullColour;
1582 }
1583
1584 void wxListCtrl::SetItemFont( long item, const wxFont &f )
1585 {
1586 if (m_genericImpl)
1587 {
1588 m_genericImpl->SetItemFont(item, f);
1589 return;
1590 }
1591
1592 wxListItem info;
1593 info.m_itemId = item;
1594 info.SetFont( f );
1595 SetItem( info );
1596 }
1597
1598 wxFont wxListCtrl::GetItemFont( long item ) const
1599 {
1600 if (m_genericImpl)
1601 return m_genericImpl->GetItemFont(item);
1602
1603 if (m_dbImpl)
1604 {
1605 wxListItem info;
1606 if (GetItem(info))
1607 return info.GetFont();
1608 }
1609
1610 return wxNullFont;
1611 }
1612
1613 // Gets the number of selected items in the list control
1614 int wxListCtrl::GetSelectedItemCount() const
1615 {
1616 if (m_genericImpl)
1617 return m_genericImpl->GetSelectedItemCount();
1618
1619 if (m_dbImpl)
1620 return m_dbImpl->GetSelectedItemCount(NULL, true);
1621
1622 return 0;
1623 }
1624
1625 // Gets the text colour of the listview
1626 wxColour wxListCtrl::GetTextColour() const
1627 {
1628 if (m_genericImpl)
1629 return m_genericImpl->GetTextColour();
1630
1631 // TODO: we need owner drawn list items to customize text color.
1632 if (m_dbImpl)
1633 return m_textColor;
1634
1635 return wxNullColour;
1636 }
1637
1638 // Sets the text colour of the listview
1639 void wxListCtrl::SetTextColour(const wxColour& col)
1640 {
1641 if (m_genericImpl)
1642 {
1643 m_genericImpl->SetTextColour(col);
1644 return;
1645 }
1646
1647 if (m_dbImpl)
1648 m_textColor = col;
1649 }
1650
1651 // Gets the index of the topmost visible item when in
1652 // list or report view
1653 long wxListCtrl::GetTopItem() const
1654 {
1655 if (m_genericImpl)
1656 return m_genericImpl->GetTopItem();
1657
1658 if (m_dbImpl)
1659 {
1660 int flags = 0;
1661 long item = HitTest( wxPoint(1, 1), flags);
1662 if (flags == wxLIST_HITTEST_ONITEM)
1663 return item;
1664 }
1665
1666 return 0;
1667 }
1668
1669 // Searches for an item, starting from 'item'.
1670 // 'geometry' is one of
1671 // wxLIST_NEXT_ABOVE/ALL/BELOW/LEFT/RIGHT.
1672 // 'state' is a state bit flag, one or more of
1673 // wxLIST_STATE_DROPHILITED/FOCUSED/SELECTED/CUT.
1674 // item can be -1 to find the first item that matches the
1675 // specified flags.
1676 // Returns the item or -1 if unsuccessful.
1677 long wxListCtrl::GetNextItem(long item, int geom, int state) const
1678 {
1679 if (m_genericImpl)
1680 return m_genericImpl->GetNextItem(item, geom, state);
1681
1682 // TODO: implement all geometry and state options?
1683 if ( m_dbImpl )
1684 {
1685 if ( geom == wxLIST_NEXT_ALL || geom == wxLIST_NEXT_BELOW )
1686 {
1687 long count = m_dbImpl->MacGetCount() ;
1688 for ( long line = item + 1 ; line < count; line++ )
1689 {
1690 DataBrowserItemID id = line + 1;
1691 if ( !IsVirtual() )
1692 id = (DataBrowserItemID)m_dbImpl->GetItemFromLine(line);
1693
1694 if ( (state & wxLIST_STATE_FOCUSED) && (m_current == line))
1695 return line;
1696
1697 if ( (state == wxLIST_STATE_DONTCARE ) )
1698 return line;
1699
1700 if ( (state & wxLIST_STATE_SELECTED) && IsDataBrowserItemSelected(m_dbImpl->GetControlRef(), id ) )
1701 return line;
1702 }
1703 }
1704
1705 if ( geom == wxLIST_NEXT_ABOVE )
1706 {
1707 int item2 = item;
1708 if ( item2 == -1 )
1709 item2 = m_dbImpl->MacGetCount();
1710
1711 for ( long line = item2 - 1 ; line >= 0; line-- )
1712 {
1713 DataBrowserItemID id = line + 1;
1714 if ( !IsVirtual() )
1715 id = (DataBrowserItemID)m_dbImpl->GetItemFromLine(line);
1716
1717 if ( (state & wxLIST_STATE_FOCUSED) && (m_current == line))
1718 return line;
1719
1720 if ( (state == wxLIST_STATE_DONTCARE ) )
1721 return line;
1722
1723 if ( (state & wxLIST_STATE_SELECTED) && IsDataBrowserItemSelected(m_dbImpl->GetControlRef(), id ) )
1724 return line;
1725 }
1726 }
1727 }
1728
1729 return -1;
1730 }
1731
1732
1733 wxImageList *wxListCtrl::GetImageList(int which) const
1734 {
1735 if (m_genericImpl)
1736 return m_genericImpl->GetImageList(which);
1737
1738 if ( which == wxIMAGE_LIST_NORMAL )
1739 {
1740 return m_imageListNormal;
1741 }
1742 else if ( which == wxIMAGE_LIST_SMALL )
1743 {
1744 return m_imageListSmall;
1745 }
1746 else if ( which == wxIMAGE_LIST_STATE )
1747 {
1748 return m_imageListState;
1749 }
1750 return NULL;
1751 }
1752
1753 void wxListCtrl::SetImageList(wxImageList *imageList, int which)
1754 {
1755 if (m_genericImpl)
1756 {
1757 m_genericImpl->SetImageList(imageList, which);
1758 return;
1759 }
1760
1761 if ( which == wxIMAGE_LIST_NORMAL )
1762 {
1763 if (m_ownsImageListNormal) delete m_imageListNormal;
1764 m_imageListNormal = imageList;
1765 m_ownsImageListNormal = false;
1766 }
1767 else if ( which == wxIMAGE_LIST_SMALL )
1768 {
1769 if (m_ownsImageListSmall) delete m_imageListSmall;
1770 m_imageListSmall = imageList;
1771 m_ownsImageListSmall = false;
1772 }
1773 else if ( which == wxIMAGE_LIST_STATE )
1774 {
1775 if (m_ownsImageListState) delete m_imageListState;
1776 m_imageListState = imageList;
1777 m_ownsImageListState = false;
1778 }
1779 }
1780
1781 void wxListCtrl::AssignImageList(wxImageList *imageList, int which)
1782 {
1783 if (m_genericImpl)
1784 {
1785 m_genericImpl->AssignImageList(imageList, which);
1786 return;
1787 }
1788
1789 SetImageList(imageList, which);
1790 if ( which == wxIMAGE_LIST_NORMAL )
1791 m_ownsImageListNormal = true;
1792 else if ( which == wxIMAGE_LIST_SMALL )
1793 m_ownsImageListSmall = true;
1794 else if ( which == wxIMAGE_LIST_STATE )
1795 m_ownsImageListState = true;
1796 }
1797
1798 // ----------------------------------------------------------------------------
1799 // Operations
1800 // ----------------------------------------------------------------------------
1801
1802 // Arranges the items
1803 bool wxListCtrl::Arrange(int flag)
1804 {
1805 if (m_genericImpl)
1806 return m_genericImpl->Arrange(flag);
1807 return false;
1808 }
1809
1810 // Deletes an item
1811 bool wxListCtrl::DeleteItem(long item)
1812 {
1813 if (m_genericImpl)
1814 return m_genericImpl->DeleteItem(item);
1815
1816 if (m_dbImpl)
1817 {
1818 m_dbImpl->MacDelete(item);
1819 wxListEvent event( wxEVT_COMMAND_LIST_DELETE_ITEM, GetId() );
1820 event.SetEventObject( this );
1821 event.m_itemIndex = item;
1822 HandleWindowEvent( event );
1823
1824 }
1825 return true;
1826 }
1827
1828 // Deletes all items
1829 bool wxListCtrl::DeleteAllItems()
1830 {
1831 m_current = -1;
1832 if (m_genericImpl)
1833 return m_genericImpl->DeleteAllItems();
1834
1835 if (m_dbImpl)
1836 {
1837 m_dbImpl->MacClear();
1838 wxListEvent event( wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS, GetId() );
1839 event.SetEventObject( this );
1840 HandleWindowEvent( event );
1841 }
1842 return true;
1843 }
1844
1845 // Deletes all items
1846 bool wxListCtrl::DeleteAllColumns()
1847 {
1848 if (m_genericImpl)
1849 return m_genericImpl->DeleteAllColumns();
1850
1851 if (m_dbImpl)
1852 {
1853 UInt32 cols;
1854 m_dbImpl->GetColumnCount(&cols);
1855 for (UInt32 col = 0; col < cols; col++)
1856 {
1857 DeleteColumn(0);
1858 }
1859 }
1860
1861 return true;
1862 }
1863
1864 // Deletes a column
1865 bool wxListCtrl::DeleteColumn(int col)
1866 {
1867 if (m_genericImpl)
1868 return m_genericImpl->DeleteColumn(col);
1869
1870 if (m_dbImpl)
1871 {
1872 OSStatus err = m_dbImpl->RemoveColumn(col);
1873 return err == noErr;
1874 }
1875
1876 return true;
1877 }
1878
1879 // Clears items, and columns if there are any.
1880 void wxListCtrl::ClearAll()
1881 {
1882 if (m_genericImpl)
1883 {
1884 m_genericImpl->ClearAll();
1885 return;
1886 }
1887
1888 if (m_dbImpl)
1889 {
1890 DeleteAllItems();
1891 DeleteAllColumns();
1892 }
1893 }
1894
1895 wxTextCtrl* wxListCtrl::EditLabel(long item, wxClassInfo* textControlClass)
1896 {
1897 if (m_genericImpl)
1898 return m_genericImpl->EditLabel(item, textControlClass);
1899
1900 if (m_dbImpl)
1901 {
1902 wxCHECK_MSG( (item >= 0) && ((long)item < GetItemCount()), NULL,
1903 wxT("wrong index in wxListCtrl::EditLabel()") );
1904
1905 wxASSERT_MSG( textControlClass->IsKindOf(CLASSINFO(wxTextCtrl)),
1906 wxT("EditLabel() needs a text control") );
1907
1908 wxListEvent le( wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT, GetParent()->GetId() );
1909 le.SetEventObject( this );
1910 le.m_itemIndex = item;
1911 le.m_col = 0;
1912 GetItem( le.m_item );
1913
1914 if ( GetParent()->HandleWindowEvent( le ) && !le.IsAllowed() )
1915 {
1916 // vetoed by user code
1917 return NULL;
1918 }
1919
1920 wxTextCtrl * const text = (wxTextCtrl *)textControlClass->CreateObject();
1921 m_textctrlWrapper = new wxListCtrlTextCtrlWrapper(this, text, item);
1922 return m_textctrlWrapper->GetText();
1923 }
1924 return NULL;
1925 }
1926
1927 // End label editing, optionally cancelling the edit
1928 bool wxListCtrl::EndEditLabel(bool WXUNUSED(cancel))
1929 {
1930 // TODO: generic impl. doesn't have this method - is it needed for us?
1931 if (m_genericImpl)
1932 return true; // m_genericImpl->EndEditLabel(cancel);
1933
1934 if (m_dbImpl)
1935 {
1936 DataBrowserTableViewColumnID id = 0;
1937 verify_noerr( m_dbImpl->GetColumnIDFromIndex( 0, &id ) );
1938 verify_noerr( SetDataBrowserEditItem(m_dbImpl->GetControlRef(), kDataBrowserNoItem, id ) );
1939 }
1940 return true;
1941 }
1942
1943 // Ensures this item is visible
1944 bool wxListCtrl::EnsureVisible(long item)
1945 {
1946 if (m_genericImpl)
1947 return m_genericImpl->EnsureVisible(item);
1948
1949 if (m_dbImpl)
1950 {
1951 wxMacDataItem* dataItem = m_dbImpl->GetItemFromLine(item);
1952 m_dbImpl->RevealItem(dataItem, kDataBrowserRevealWithoutSelecting);
1953 }
1954
1955 return true;
1956 }
1957
1958 // Find an item whose label matches this string, starting from the item after 'start'
1959 // or the beginning if 'start' is -1.
1960 long wxListCtrl::FindItem(long start, const wxString& str, bool partial)
1961 {
1962 if (m_genericImpl)
1963 return m_genericImpl->FindItem(start, str, partial);
1964
1965 wxString str_upper = str.Upper();
1966
1967 long idx = start;
1968 if (idx < 0)
1969 idx = 0;
1970 long count = GetItemCount();
1971
1972 while (idx < count)
1973 {
1974 wxString line_upper = GetItemText(idx).Upper();
1975 if (!partial)
1976 {
1977 if (line_upper == str_upper )
1978 return idx;
1979 }
1980 else
1981 {
1982 if (line_upper.find(str_upper) == 0)
1983 return idx;
1984 }
1985
1986 idx++;
1987 };
1988
1989 return wxNOT_FOUND;
1990 }
1991
1992 // Find an item whose data matches this data, starting from the item after 'start'
1993 // or the beginning if 'start' is -1.
1994 long wxListCtrl::FindItem(long start, long data)
1995 {
1996 if (m_genericImpl)
1997 return m_genericImpl->FindItem(start, data);
1998
1999 long idx = start;
2000 if (idx < 0)
2001 idx = 0;
2002 long count = GetItemCount();
2003
2004 while (idx < count)
2005 {
2006 if (GetItemData(idx) == data)
2007 return idx;
2008 idx++;
2009 };
2010
2011 return wxNOT_FOUND;
2012 }
2013
2014 // Find an item nearest this position in the specified direction, starting from
2015 // the item after 'start' or the beginning if 'start' is -1.
2016 long wxListCtrl::FindItem(long start, const wxPoint& pt, int direction)
2017 {
2018 if (m_genericImpl)
2019 return m_genericImpl->FindItem(start, pt, direction);
2020 return -1;
2021 }
2022
2023 static void calculateCGDrawingBounds(CGRect inItemRect, CGRect *outIconRect, CGRect *outTextRect, bool hasIcon);
2024
2025 // Determines which item (if any) is at the specified point,
2026 // giving details in 'flags' (see wxLIST_HITTEST_... flags above)
2027 long
2028 wxListCtrl::HitTest(const wxPoint& point, int& flags, long *ptrSubItem) const
2029 {
2030 if (ptrSubItem)
2031 *ptrSubItem = -1;
2032
2033 if (m_genericImpl)
2034 return m_genericImpl->HitTest(point, flags, ptrSubItem);
2035
2036 flags = wxLIST_HITTEST_NOWHERE;
2037 if (m_dbImpl)
2038 {
2039 int colHeaderHeight = 22; // TODO: Find a way to get this value from the db control?
2040 UInt16 rowHeight = 0;
2041 m_dbImpl->GetDefaultRowHeight(&rowHeight);
2042
2043 int y = point.y;
2044 // get the actual row by taking scroll position into account
2045 UInt32 offsetX, offsetY;
2046 m_dbImpl->GetScrollPosition( &offsetY, &offsetX );
2047 y += offsetY;
2048
2049 if ( !(GetWindowStyleFlag() & wxLC_NO_HEADER) )
2050 y -= colHeaderHeight;
2051
2052 if ( y < 0 )
2053 return -1;
2054
2055 int row = y / rowHeight;
2056 DataBrowserItemID id;
2057 m_dbImpl->GetItemID( (DataBrowserTableViewRowIndex) row, &id );
2058
2059 CGPoint click_point = CGPointMake( point.x, point.y );
2060 if (row < GetItemCount() )
2061 {
2062 short column;
2063 for( column = 0; column < GetColumnCount(); column++ )
2064 {
2065 Rect enclosingRect;
2066 CGRect enclosingCGRect, iconCGRect, textCGRect;
2067 int imgIndex = -1;
2068 wxMacListCtrlItem* lcItem;
2069
2070 WXUNUSED_UNLESS_DEBUG( OSStatus status = ) m_dbImpl->GetItemPartBounds( id, kMinColumnId + column, kDataBrowserPropertyEnclosingPart, &enclosingRect );
2071 wxASSERT( status == noErr );
2072
2073 enclosingCGRect = CGRectMake(enclosingRect.left,
2074 enclosingRect.top,
2075 enclosingRect.right - enclosingRect.left,
2076 enclosingRect.bottom - enclosingRect.top);
2077
2078 if (column >= 0)
2079 {
2080 if ( !(GetWindowStyleFlag() & wxLC_VIRTUAL ) )
2081 {
2082 lcItem = (wxMacListCtrlItem*) id;
2083 if (lcItem->HasColumnInfo(column))
2084 {
2085 wxListItem* item = lcItem->GetColumnInfo(column);
2086
2087 if (item->GetMask() & wxLIST_MASK_IMAGE)
2088 {
2089 imgIndex = item->GetImage();
2090 }
2091 }
2092 }
2093 else
2094 {
2095 long itemNum = (long)id-1;
2096 if (itemNum >= 0 && itemNum < GetItemCount())
2097 {
2098 imgIndex = OnGetItemColumnImage( itemNum, column );
2099 }
2100 }
2101 }
2102
2103 calculateCGDrawingBounds(enclosingCGRect, &iconCGRect, &textCGRect, (imgIndex != -1) );
2104
2105 if ( CGRectContainsPoint( iconCGRect, click_point ) )
2106 {
2107 flags = wxLIST_HITTEST_ONITEMICON;
2108 if (ptrSubItem)
2109 *ptrSubItem = column;
2110 return row;
2111 }
2112 else if ( CGRectContainsPoint( textCGRect, click_point ) )
2113 {
2114 flags = wxLIST_HITTEST_ONITEMLABEL;
2115 if (ptrSubItem)
2116 *ptrSubItem = column;
2117 return row;
2118 }
2119 }
2120
2121 if ( !(GetWindowStyleFlag() & wxLC_VIRTUAL ) )
2122 {
2123 wxMacListCtrlItem* lcItem;
2124 lcItem = (wxMacListCtrlItem*) id;
2125 if (lcItem)
2126 {
2127 flags = wxLIST_HITTEST_ONITEM;
2128 if (ptrSubItem)
2129 *ptrSubItem = column;
2130 return row;
2131 }
2132 }
2133 else
2134 {
2135 flags = wxLIST_HITTEST_ONITEM;
2136 if (ptrSubItem)
2137 *ptrSubItem = column;
2138 return row;
2139 }
2140 }
2141 else
2142 {
2143 if ( wxControl::HitTest( point ) )
2144 flags = wxLIST_HITTEST_NOWHERE;
2145 }
2146 }
2147
2148 return -1;
2149 }
2150
2151 int wxListCtrl::GetScrollPos(int orient) const
2152 {
2153 if (m_genericImpl)
2154 return m_genericImpl->GetScrollPos(orient);
2155
2156 if (m_dbImpl)
2157 {
2158 UInt32 offsetX, offsetY;
2159 m_dbImpl->GetScrollPosition( &offsetY, &offsetX );
2160 if ( orient == wxHORIZONTAL )
2161 return offsetX;
2162 else
2163 return offsetY;
2164 }
2165
2166 return 0;
2167 }
2168
2169 // Inserts an item, returning the index of the new item if successful,
2170 // -1 otherwise.
2171 long wxListCtrl::InsertItem(wxListItem& info)
2172 {
2173 wxASSERT_MSG( !IsVirtual(), wxT("can't be used with virtual controls") );
2174
2175 if (m_genericImpl)
2176 return m_genericImpl->InsertItem(info);
2177
2178 if (m_dbImpl && !IsVirtual())
2179 {
2180 int count = GetItemCount();
2181
2182 if (info.m_itemId > count)
2183 info.m_itemId = count;
2184
2185 m_dbImpl->MacInsertItem(info.m_itemId, &info );
2186
2187 wxListEvent event( wxEVT_COMMAND_LIST_INSERT_ITEM, GetId() );
2188 event.SetEventObject( this );
2189 event.m_itemIndex = info.m_itemId;
2190 HandleWindowEvent( event );
2191 return info.m_itemId;
2192 }
2193 return -1;
2194 }
2195
2196 long wxListCtrl::InsertItem(long index, const wxString& label)
2197 {
2198 if (m_genericImpl)
2199 return m_genericImpl->InsertItem(index, label);
2200
2201 wxListItem info;
2202 info.m_text = label;
2203 info.m_mask = wxLIST_MASK_TEXT;
2204 info.m_itemId = index;
2205 return InsertItem(info);
2206 }
2207
2208 // Inserts an image item
2209 long wxListCtrl::InsertItem(long index, int imageIndex)
2210 {
2211 if (m_genericImpl)
2212 return m_genericImpl->InsertItem(index, imageIndex);
2213
2214 wxListItem info;
2215 info.m_image = imageIndex;
2216 info.m_mask = wxLIST_MASK_IMAGE;
2217 info.m_itemId = index;
2218 return InsertItem(info);
2219 }
2220
2221 // Inserts an image/string item
2222 long wxListCtrl::InsertItem(long index, const wxString& label, int imageIndex)
2223 {
2224 if (m_genericImpl)
2225 return m_genericImpl->InsertItem(index, label, imageIndex);
2226
2227 wxListItem info;
2228 info.m_image = imageIndex;
2229 info.m_text = label;
2230 info.m_mask = wxLIST_MASK_IMAGE | wxLIST_MASK_TEXT;
2231 info.m_itemId = index;
2232 return InsertItem(info);
2233 }
2234
2235 // For list view mode (only), inserts a column.
2236 long wxListCtrl::InsertColumn(long col, wxListItem& item)
2237 {
2238 if (m_genericImpl)
2239 return m_genericImpl->InsertColumn(col, item);
2240
2241 if (m_dbImpl)
2242 {
2243 int width = item.GetWidth();
2244 if ( !(item.GetMask() & wxLIST_MASK_WIDTH) )
2245 width = 150;
2246
2247 DataBrowserPropertyType type = kDataBrowserCustomType; //kDataBrowserTextType;
2248 wxImageList* imageList = GetImageList(wxIMAGE_LIST_SMALL);
2249 if (imageList && imageList->GetImageCount() > 0)
2250 {
2251 wxBitmap bmp = imageList->GetBitmap(0);
2252 //if (bmp.Ok())
2253 // type = kDataBrowserIconAndTextType;
2254 }
2255
2256 SInt16 just = teFlushDefault;
2257 if (item.GetMask() & wxLIST_MASK_FORMAT)
2258 {
2259 if (item.GetAlign() == wxLIST_FORMAT_LEFT)
2260 just = teFlushLeft;
2261 else if (item.GetAlign() == wxLIST_FORMAT_CENTER)
2262 just = teCenter;
2263 else if (item.GetAlign() == wxLIST_FORMAT_RIGHT)
2264 just = teFlushRight;
2265 }
2266 m_dbImpl->InsertColumn(col, type, item.GetText(), just, width);
2267
2268 wxListItem* listItem = new wxListItem(item);
2269 m_colsInfo.Insert( col, listItem );
2270 SetColumn(col, item);
2271
2272 // set/remove options based on the wxListCtrl type.
2273 DataBrowserTableViewColumnID id;
2274 m_dbImpl->GetColumnIDFromIndex(col, &id);
2275 DataBrowserPropertyFlags flags;
2276 verify_noerr(m_dbImpl->GetPropertyFlags(id, &flags));
2277 if (GetWindowStyleFlag() & wxLC_EDIT_LABELS)
2278 flags |= kDataBrowserPropertyIsEditable;
2279
2280 if (GetWindowStyleFlag() & wxLC_VIRTUAL){
2281 flags &= ~kDataBrowserListViewSortableColumn;
2282 }
2283 verify_noerr(m_dbImpl->SetPropertyFlags(id, flags));
2284 }
2285
2286 return col;
2287 }
2288
2289 long wxListCtrl::InsertColumn(long col,
2290 const wxString& heading,
2291 int format,
2292 int width)
2293 {
2294 if (m_genericImpl)
2295 return m_genericImpl->InsertColumn(col, heading, format, width);
2296
2297 wxListItem item;
2298 item.m_mask = wxLIST_MASK_TEXT | wxLIST_MASK_FORMAT;
2299 item.m_text = heading;
2300 if ( width > -1 )
2301 {
2302 item.m_mask |= wxLIST_MASK_WIDTH;
2303 item.m_width = width;
2304 }
2305 item.m_format = format;
2306
2307 return InsertColumn(col, item);
2308 }
2309
2310 // scroll the control by the given number of pixels (exception: in list view,
2311 // dx is interpreted as number of columns)
2312 bool wxListCtrl::ScrollList(int dx, int dy)
2313 {
2314 if (m_genericImpl)
2315 return m_genericImpl->ScrollList(dx, dy);
2316
2317 if (m_dbImpl)
2318 {
2319 m_dbImpl->SetScrollPosition(dx, dy);
2320 }
2321 return true;
2322 }
2323
2324
2325 bool wxListCtrl::SortItems(wxListCtrlCompare fn, wxIntPtr data)
2326 {
2327 if (m_genericImpl)
2328 return m_genericImpl->SortItems(fn, data);
2329
2330 if (m_dbImpl)
2331 {
2332 m_compareFunc = fn;
2333 m_compareFuncData = data;
2334 SortDataBrowserContainer( m_dbImpl->GetControlRef(), kDataBrowserNoItem, true);
2335
2336 // we need to do this after each call, else we get a crash from wxPython when
2337 // SortItems is called the second time.
2338 m_compareFunc = NULL;
2339 m_compareFuncData = 0;
2340 }
2341
2342 return true;
2343 }
2344
2345 void wxListCtrl::OnRenameTimer()
2346 {
2347 wxCHECK_RET( HasCurrent(), wxT("unexpected rename timer") );
2348
2349 EditLabel( m_current );
2350 }
2351
2352 bool wxListCtrl::OnRenameAccept(long itemEdit, const wxString& value)
2353 {
2354 wxListEvent le( wxEVT_COMMAND_LIST_END_LABEL_EDIT, GetId() );
2355 le.SetEventObject( this );
2356 le.m_itemIndex = itemEdit;
2357
2358 GetItem( le.m_item );
2359 le.m_item.m_text = value;
2360 return !HandleWindowEvent( le ) ||
2361 le.IsAllowed();
2362 }
2363
2364 void wxListCtrl::OnRenameCancelled(long itemEdit)
2365 {
2366 // let owner know that the edit was cancelled
2367 wxListEvent le( wxEVT_COMMAND_LIST_END_LABEL_EDIT, GetParent()->GetId() );
2368
2369 le.SetEditCanceled(true);
2370
2371 le.SetEventObject( this );
2372 le.m_itemIndex = itemEdit;
2373
2374 GetItem( le.m_item );
2375 HandleWindowEvent( le );
2376 }
2377
2378 // ----------------------------------------------------------------------------
2379 // virtual list controls
2380 // ----------------------------------------------------------------------------
2381
2382 wxString wxListCtrl::OnGetItemText(long WXUNUSED(item), long WXUNUSED(col)) const
2383 {
2384 // this is a pure virtual function, in fact - which is not really pure
2385 // because the controls which are not virtual don't need to implement it
2386 wxFAIL_MSG( wxT("wxListCtrl::OnGetItemText not supposed to be called") );
2387
2388 return wxEmptyString;
2389 }
2390
2391 int wxListCtrl::OnGetItemImage(long WXUNUSED(item)) const
2392 {
2393 wxCHECK_MSG(!GetImageList(wxIMAGE_LIST_SMALL),
2394 -1,
2395 wxT("List control has an image list, OnGetItemImage or OnGetItemColumnImage should be overridden."));
2396 return -1;
2397 }
2398
2399 int wxListCtrl::OnGetItemColumnImage(long item, long column) const
2400 {
2401 if (!column)
2402 return OnGetItemImage(item);
2403
2404 return -1;
2405 }
2406
2407 wxListItemAttr *wxListCtrl::OnGetItemAttr(long WXUNUSED_UNLESS_DEBUG(item)) const
2408 {
2409 wxASSERT_MSG( item >= 0 && item < GetItemCount(),
2410 wxT("invalid item index in OnGetItemAttr()") );
2411
2412 // no attributes by default
2413 return NULL;
2414 }
2415
2416 void wxListCtrl::SetItemCount(long count)
2417 {
2418 wxASSERT_MSG( IsVirtual(), wxT("this is for virtual controls only") );
2419
2420 if (m_genericImpl)
2421 {
2422 m_genericImpl->SetItemCount(count);
2423 return;
2424 }
2425
2426 if (m_dbImpl)
2427 {
2428 // we need to temporarily disable the new item creation notification
2429 // procedure to speed things up
2430 // FIXME: Even this doesn't seem to help much...
2431
2432 // FIXME: Find a more efficient way to do this.
2433 m_dbImpl->MacClear();
2434
2435 DataBrowserCallbacks callbacks;
2436 DataBrowserItemNotificationUPP itemUPP;
2437 GetDataBrowserCallbacks(m_dbImpl->GetControlRef(), &callbacks);
2438 itemUPP = callbacks.u.v1.itemNotificationCallback;
2439 callbacks.u.v1.itemNotificationCallback = 0;
2440 m_dbImpl->SetCallbacks(&callbacks);
2441 ::AddDataBrowserItems(m_dbImpl->GetControlRef(), kDataBrowserNoItem,
2442 count, NULL, kDataBrowserItemNoProperty);
2443 callbacks.u.v1.itemNotificationCallback = itemUPP;
2444 m_dbImpl->SetCallbacks(&callbacks);
2445 }
2446 m_count = count;
2447 }
2448
2449 void wxListCtrl::RefreshItem(long item)
2450 {
2451 if (m_genericImpl)
2452 {
2453 m_genericImpl->RefreshItem(item);
2454 return;
2455 }
2456
2457 if (m_dbImpl)
2458 {
2459 DataBrowserItemID id;
2460
2461 if ( !IsVirtual() )
2462 {
2463 wxMacDataItem* thisItem = m_dbImpl->GetItemFromLine(item);
2464 id = (DataBrowserItemID) thisItem;
2465 }
2466 else
2467 id = item+1;
2468
2469 m_dbImpl->wxMacDataBrowserControl::UpdateItems
2470 (
2471 kDataBrowserNoItem,
2472 1, &id,
2473 kDataBrowserItemNoProperty, // preSortProperty
2474 kDataBrowserNoItem // update all columns
2475 );
2476 }
2477 }
2478
2479 void wxListCtrl::RefreshItems(long itemFrom, long itemTo)
2480 {
2481 if (m_genericImpl)
2482 {
2483 m_genericImpl->RefreshItems(itemFrom, itemTo);
2484 return;
2485 }
2486
2487 if (m_dbImpl)
2488 {
2489 const long count = itemTo - itemFrom + 1;
2490 DataBrowserItemID *ids = new DataBrowserItemID[count];
2491
2492 if ( !IsVirtual() )
2493 {
2494 for ( long i = 0; i < count; i++ )
2495 {
2496 wxMacDataItem* thisItem = m_dbImpl->GetItemFromLine(itemFrom+i);
2497 ids[i] = (DataBrowserItemID) thisItem;
2498 }
2499 }
2500 else
2501 {
2502 for ( long i = 0; i < count; i++ )
2503 ids[i] = itemFrom+i+1;
2504 }
2505
2506 m_dbImpl->wxMacDataBrowserControl::UpdateItems
2507 (
2508 kDataBrowserNoItem,
2509 count, ids,
2510 kDataBrowserItemNoProperty, // preSortProperty
2511 kDataBrowserNoItem // update all columns
2512 );
2513
2514 delete[] ids;
2515 }
2516 }
2517
2518 void wxListCtrl::SetDropTarget( wxDropTarget *dropTarget )
2519 {
2520 #if wxUSE_DRAG_AND_DROP
2521 if (m_genericImpl)
2522 m_genericImpl->SetDropTarget( dropTarget );
2523
2524 if (m_dbImpl)
2525 wxWindow::SetDropTarget( dropTarget );
2526 #endif
2527 }
2528
2529 wxDropTarget *wxListCtrl::GetDropTarget() const
2530 {
2531 #if wxUSE_DRAG_AND_DROP
2532 if (m_genericImpl)
2533 return m_genericImpl->GetDropTarget();
2534
2535 if (m_dbImpl)
2536 return wxWindow::GetDropTarget();
2537 #endif
2538 return NULL;
2539 }
2540
2541 #if wxABI_VERSION >= 20801
2542 void wxListCtrl::SetFocus()
2543 {
2544 if (m_genericImpl)
2545 {
2546 m_genericImpl->SetFocus();
2547 return;
2548 }
2549
2550 wxWindow::SetFocus();
2551 }
2552 #endif
2553
2554 // wxMac internal data structures
2555
2556 wxMacListCtrlItem::~wxMacListCtrlItem()
2557 {
2558 WX_CLEAR_HASH_MAP( wxListItemList, m_rowItems );
2559 }
2560
2561 void wxMacListCtrlItem::Notification(wxMacDataItemBrowserControl *owner ,
2562 DataBrowserItemNotification message,
2563 DataBrowserItemDataRef WXUNUSED(itemData) ) const
2564 {
2565
2566 wxMacDataBrowserListCtrlControl *lb = wxDynamicCast(owner, wxMacDataBrowserListCtrlControl);
2567
2568 // we want to depend on as little as possible to make sure tear-down of controls is safe
2569 if ( message == kDataBrowserItemRemoved)
2570 {
2571 delete this;
2572 return;
2573 }
2574 else if ( message == kDataBrowserItemAdded )
2575 {
2576 // we don't issue events on adding, the item is not really stored in the list yet, so we
2577 // avoid asserts by gettting out now
2578 return ;
2579 }
2580
2581 wxListCtrl *list = wxDynamicCast( owner->GetWXPeer() , wxListCtrl );
2582 if ( list && lb )
2583 {
2584 bool trigger = false;
2585
2586 wxListEvent event( wxEVT_COMMAND_LIST_ITEM_SELECTED, list->GetId() );
2587 bool isSingle = (list->GetWindowStyle() & wxLC_SINGLE_SEL) != 0;
2588
2589 event.SetEventObject( list );
2590 event.m_itemIndex = owner->GetLineFromItem( this ) ;
2591 event.m_item.m_itemId = event.m_itemIndex;
2592 list->GetItem(event.m_item);
2593
2594 switch (message)
2595 {
2596 case kDataBrowserItemDeselected:
2597 event.SetEventType(wxEVT_COMMAND_LIST_ITEM_DESELECTED);
2598 if ( !isSingle )
2599 trigger = !lb->IsSelectionSuppressed();
2600 break;
2601
2602 case kDataBrowserItemSelected:
2603 trigger = !lb->IsSelectionSuppressed();
2604 break;
2605
2606 case kDataBrowserItemDoubleClicked:
2607 event.SetEventType( wxEVT_COMMAND_LIST_ITEM_ACTIVATED );
2608 trigger = true;
2609 break;
2610
2611 case kDataBrowserEditStarted :
2612 // TODO : how to veto ?
2613 event.SetEventType( wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT ) ;
2614 trigger = true ;
2615 break ;
2616
2617 case kDataBrowserEditStopped :
2618 // TODO probably trigger only upon the value store callback, because
2619 // here IIRC we cannot veto
2620 event.SetEventType( wxEVT_COMMAND_LIST_END_LABEL_EDIT ) ;
2621 trigger = true ;
2622 break ;
2623
2624 default:
2625 break;
2626 }
2627
2628 if ( trigger )
2629 {
2630 // direct notification is not always having the listbox GetSelection() having in synch with event
2631 wxPostEvent( list->GetEventHandler(), event );
2632 }
2633 }
2634
2635 }
2636
2637 IMPLEMENT_DYNAMIC_CLASS(wxMacDataBrowserListCtrlControl, wxMacDataItemBrowserControl )
2638
2639 wxMacDataBrowserListCtrlControl::wxMacDataBrowserListCtrlControl( wxWindow *peer, const wxPoint& pos, const wxSize& size, long style)
2640 : wxMacDataItemBrowserControl( peer, pos, size, style )
2641 {
2642 OSStatus err = noErr;
2643 m_clientDataItemsType = wxClientData_None;
2644 m_isVirtual = false;
2645 m_flags = 0;
2646
2647 if ( style & wxLC_VIRTUAL )
2648 m_isVirtual = true;
2649
2650 DataBrowserSelectionFlags options = kDataBrowserDragSelect;
2651 if ( style & wxLC_SINGLE_SEL )
2652 {
2653 options |= kDataBrowserSelectOnlyOne;
2654 }
2655 else
2656 {
2657 options |= kDataBrowserCmdTogglesSelection;
2658 }
2659
2660 err = SetSelectionFlags( options );
2661 verify_noerr( err );
2662
2663 DataBrowserCustomCallbacks callbacks;
2664 InitializeDataBrowserCustomCallbacks( &callbacks, kDataBrowserLatestCustomCallbacks );
2665
2666 if ( gDataBrowserDrawItemUPP == NULL )
2667 gDataBrowserDrawItemUPP = NewDataBrowserDrawItemUPP(DataBrowserDrawItemProc);
2668
2669 if ( gDataBrowserHitTestUPP == NULL )
2670 gDataBrowserHitTestUPP = NewDataBrowserHitTestUPP(DataBrowserHitTestProc);
2671
2672 callbacks.u.v1.drawItemCallback = gDataBrowserDrawItemUPP;
2673 callbacks.u.v1.hitTestCallback = gDataBrowserHitTestUPP;
2674
2675 SetDataBrowserCustomCallbacks( GetControlRef(), &callbacks );
2676
2677 if ( style & wxLC_LIST )
2678 {
2679 InsertColumn(0, kDataBrowserIconAndTextType, wxEmptyString, -1, -1);
2680 verify_noerr( AutoSizeColumns() );
2681 }
2682
2683 if ( style & wxLC_LIST || style & wxLC_NO_HEADER )
2684 verify_noerr( SetHeaderButtonHeight( 0 ) );
2685
2686 if ( m_isVirtual )
2687 SetSortProperty( kMinColumnId - 1 );
2688 else
2689 SetSortProperty( kMinColumnId );
2690
2691 m_sortOrder = SortOrder_None;
2692
2693 if ( style & wxLC_SORT_DESCENDING )
2694 {
2695 SetSortOrder( kDataBrowserOrderDecreasing );
2696 }
2697 else if ( style & wxLC_SORT_ASCENDING )
2698 {
2699 SetSortOrder( kDataBrowserOrderIncreasing );
2700 }
2701
2702 if ( style & wxLC_VRULES )
2703 {
2704 verify_noerr( DataBrowserChangeAttributes(m_controlRef, kDataBrowserAttributeListViewDrawColumnDividers, kDataBrowserAttributeNone) );
2705 }
2706
2707 verify_noerr( SetHiliteStyle(kDataBrowserTableViewFillHilite ) );
2708 verify_noerr( SetHasScrollBars( (style & wxHSCROLL) != 0 , true ) );
2709 }
2710
2711 pascal Boolean wxMacDataBrowserListCtrlControl::DataBrowserEditTextProc(
2712 ControlRef browser,
2713 DataBrowserItemID itemID,
2714 DataBrowserPropertyID property,
2715 CFStringRef theString,
2716 Rect *maxEditTextRect,
2717 Boolean *shrinkToFit)
2718 {
2719 Boolean result = false;
2720 wxMacDataBrowserListCtrlControl* ctl = wxDynamicCast(wxMacControl::GetReferenceFromNativeControl( browser ), wxMacDataBrowserListCtrlControl);
2721 if ( ctl != 0 )
2722 {
2723 result = ctl->ConfirmEditText(itemID, property, theString, maxEditTextRect, shrinkToFit);
2724 theString = CFSTR("Hello!");
2725 }
2726 return result;
2727 }
2728
2729 bool wxMacDataBrowserListCtrlControl::ConfirmEditText(
2730 DataBrowserItemID WXUNUSED(itemID),
2731 DataBrowserPropertyID WXUNUSED(property),
2732 CFStringRef WXUNUSED(theString),
2733 Rect *WXUNUSED(maxEditTextRect),
2734 Boolean *WXUNUSED(shrinkToFit))
2735 {
2736 return false;
2737 }
2738
2739 pascal void wxMacDataBrowserListCtrlControl::DataBrowserDrawItemProc(
2740 ControlRef browser,
2741 DataBrowserItemID itemID,
2742 DataBrowserPropertyID property,
2743 DataBrowserItemState itemState,
2744 const Rect *itemRect,
2745 SInt16 gdDepth,
2746 Boolean colorDevice)
2747 {
2748 wxMacDataBrowserListCtrlControl* ctl = wxDynamicCast(wxMacControl::GetReferenceFromNativeControl( browser ), wxMacDataBrowserListCtrlControl);
2749 if ( ctl != 0 )
2750 {
2751 ctl->DrawItem(itemID, property, itemState, itemRect, gdDepth, colorDevice);
2752 }
2753 }
2754
2755 // routines needed for DrawItem
2756 enum
2757 {
2758 kIconWidth = 16,
2759 kIconHeight = 16,
2760 kTextBoxHeight = 14,
2761 kIconTextSpacingV = 2,
2762 kItemPadding = 4,
2763 kContentHeight = kIconHeight + kTextBoxHeight + kIconTextSpacingV
2764 };
2765
2766 static void calculateCGDrawingBounds(CGRect inItemRect, CGRect *outIconRect, CGRect *outTextRect, bool hasIcon = false)
2767 {
2768 float textBottom;
2769 float iconH, iconW = 0;
2770 float padding = kItemPadding;
2771 if (hasIcon)
2772 {
2773 iconH = kIconHeight;
2774 iconW = kIconWidth;
2775 padding = padding*2;
2776 }
2777
2778 textBottom = inItemRect.origin.y;
2779
2780 *outIconRect = CGRectMake(inItemRect.origin.x + kItemPadding,
2781 textBottom + kIconTextSpacingV, kIconWidth,
2782 kIconHeight);
2783
2784 *outTextRect = CGRectMake(inItemRect.origin.x + padding + iconW,
2785 textBottom + kIconTextSpacingV, inItemRect.size.width - padding - iconW,
2786 inItemRect.size.height - kIconTextSpacingV);
2787 }
2788
2789 void wxMacDataBrowserListCtrlControl::DrawItem(
2790 DataBrowserItemID itemID,
2791 DataBrowserPropertyID property,
2792 DataBrowserItemState itemState,
2793 const Rect *WXUNUSED(itemRect),
2794 SInt16 gdDepth,
2795 Boolean colorDevice)
2796 {
2797 wxString text;
2798 wxFont font = wxNullFont;
2799 int imgIndex = -1;
2800
2801 DataBrowserTableViewColumnIndex listColumn = 0;
2802 GetColumnPosition( property, &listColumn );
2803
2804 wxListCtrl* list = wxDynamicCast( GetWXPeer() , wxListCtrl );
2805 wxMacListCtrlItem* lcItem;
2806 wxColour color = *wxBLACK;
2807 wxColour bgColor = wxNullColour;
2808
2809 if (listColumn >= 0)
2810 {
2811 if (!m_isVirtual)
2812 {
2813 lcItem = (wxMacListCtrlItem*) itemID;
2814 if (lcItem->HasColumnInfo(listColumn))
2815 {
2816 wxListItem* item = lcItem->GetColumnInfo(listColumn);
2817
2818 // we always use the 0 column to get font and text/background colors.
2819 if (lcItem->HasColumnInfo(0))
2820 {
2821 wxListItem* firstItem = lcItem->GetColumnInfo(0);
2822 color = firstItem->GetTextColour();
2823 bgColor = firstItem->GetBackgroundColour();
2824 font = firstItem->GetFont();
2825 }
2826
2827 if (item->GetMask() & wxLIST_MASK_TEXT)
2828 text = item->GetText();
2829 if (item->GetMask() & wxLIST_MASK_IMAGE)
2830 imgIndex = item->GetImage();
2831 }
2832
2833 }
2834 else
2835 {
2836 long itemNum = (long)itemID-1;
2837 if (itemNum >= 0 && itemNum < list->GetItemCount())
2838 {
2839 text = list->OnGetItemText( itemNum, listColumn );
2840 imgIndex = list->OnGetItemColumnImage( itemNum, listColumn );
2841 wxListItemAttr* attrs = list->OnGetItemAttr( itemNum );
2842 if (attrs)
2843 {
2844 if (attrs->HasBackgroundColour())
2845 bgColor = attrs->GetBackgroundColour();
2846 if (attrs->HasTextColour())
2847 color = attrs->GetTextColour();
2848 if (attrs->HasFont())
2849 font = attrs->GetFont();
2850 }
2851 }
2852 }
2853 }
2854
2855 wxColour listBgColor = list->GetBackgroundColour();
2856 if (bgColor == wxNullColour)
2857 bgColor = listBgColor;
2858
2859 if (!font.Ok())
2860 font = list->GetFont();
2861
2862 wxCFStringRef cfString( text, wxLocale::GetSystemEncoding() );
2863
2864 Rect enclosingRect;
2865 CGRect enclosingCGRect, iconCGRect, textCGRect;
2866 Boolean active;
2867 ThemeDrawingState savedState = NULL;
2868 CGContextRef context = (CGContextRef)list->MacGetDrawingContext();
2869 wxMacCGContextStateSaver top_saver_cg( context );
2870
2871 RGBColor labelColor;
2872 labelColor.red = 0;
2873 labelColor.green = 0;
2874 labelColor.blue = 0;
2875
2876 RGBColor backgroundColor;
2877 backgroundColor.red = 255;
2878 backgroundColor.green = 255;
2879 backgroundColor.blue = 255;
2880
2881 GetDataBrowserItemPartBounds(GetControlRef(), itemID, property, kDataBrowserPropertyEnclosingPart,
2882 &enclosingRect);
2883
2884 enclosingCGRect = CGRectMake(enclosingRect.left,
2885 enclosingRect.top,
2886 enclosingRect.right - enclosingRect.left,
2887 enclosingRect.bottom - enclosingRect.top);
2888
2889 bool hasFocus = (wxWindow::FindFocus() == list);
2890 active = IsControlActive(GetControlRef());
2891
2892 // don't paint the background over the vertical rule line
2893 if ( list->GetWindowStyleFlag() & wxLC_VRULES )
2894 {
2895 enclosingCGRect.origin.x += 1;
2896 enclosingCGRect.size.width -= 1;
2897 }
2898 if (itemState == kDataBrowserItemIsSelected)
2899 {
2900
2901 GetThemeDrawingState(&savedState);
2902
2903 if (active && hasFocus)
2904 {
2905 GetThemeBrushAsColor(kThemeBrushAlternatePrimaryHighlightColor, 32, true, &backgroundColor);
2906 GetThemeTextColor(kThemeTextColorWhite, gdDepth, colorDevice, &labelColor);
2907 }
2908 else
2909 {
2910 GetThemeBrushAsColor(kThemeBrushSecondaryHighlightColor, 32, true, &backgroundColor);
2911 GetThemeTextColor(kThemeTextColorBlack, gdDepth, colorDevice, &labelColor);
2912 }
2913 wxMacCGContextStateSaver cg( context );
2914
2915 CGContextSetRGBFillColor(context, (CGFloat)backgroundColor.red / (CGFloat)USHRT_MAX,
2916 (CGFloat)backgroundColor.green / (CGFloat)USHRT_MAX,
2917 (CGFloat)backgroundColor.blue / (CGFloat)USHRT_MAX, (CGFloat) 1.0);
2918 CGContextFillRect(context, enclosingCGRect);
2919 }
2920 else
2921 {
2922
2923 if (color.Ok())
2924 color.GetRGBColor(&labelColor);
2925 else if (list->GetTextColour().Ok())
2926 list->GetTextColour().GetRGBColor(&labelColor);
2927
2928 if (bgColor.Ok())
2929 {
2930 bgColor.GetRGBColor(&backgroundColor);
2931 CGContextSaveGState(context);
2932
2933 CGContextSetRGBFillColor(context, (CGFloat)backgroundColor.red / (CGFloat)USHRT_MAX,
2934 (CGFloat)backgroundColor.green / (CGFloat)USHRT_MAX,
2935 (CGFloat)backgroundColor.blue / (CGFloat)USHRT_MAX, (CGFloat) 1.0);
2936 CGContextFillRect(context, enclosingCGRect);
2937
2938 CGContextRestoreGState(context);
2939 }
2940 }
2941
2942 calculateCGDrawingBounds(enclosingCGRect, &iconCGRect, &textCGRect, (imgIndex != -1) );
2943
2944 if (imgIndex != -1)
2945 {
2946 wxImageList* imageList = list->GetImageList(wxIMAGE_LIST_SMALL);
2947 if (imageList && imageList->GetImageCount() > 0)
2948 {
2949 wxBitmap bmp = imageList->GetBitmap(imgIndex);
2950 IconRef icon = bmp.GetIconRef();
2951
2952 wxMacCGContextStateSaver cg( context );
2953
2954 CGContextTranslateCTM(context, 0,iconCGRect.origin.y + CGRectGetMaxY(iconCGRect));
2955 CGContextScaleCTM(context,1.0f,-1.0f);
2956 PlotIconRefInContext(context, &iconCGRect, kAlignNone,
2957 active ? kTransformNone : kTransformDisabled, NULL,
2958 kPlotIconRefNormalFlags, icon);
2959 }
2960 }
2961
2962 HIThemeTextHorizontalFlush hFlush = kHIThemeTextHorizontalFlushLeft;
2963 HIThemeTextInfo info;
2964 bool setup = false;
2965 #if wxOSX_USE_CORE_TEXT
2966 if ( UMAGetSystemVersion() >= 0x1050 )
2967 {
2968 info.version = kHIThemeTextInfoVersionOne;
2969 info.fontID = kThemeViewsFont;
2970 if (font.Ok())
2971 {
2972 info.fontID = kThemeSpecifiedFont;
2973 info.font = (CTFontRef) font.OSXGetCTFont();
2974 setup = true;
2975 }
2976 }
2977 #endif
2978 #if wxOSX_USE_ATSU_TEXT
2979 if ( !setup )
2980 {
2981 info.version = kHIThemeTextInfoVersionZero;
2982 info.fontID = kThemeViewsFont;
2983
2984 if (font.Ok())
2985 {
2986 info.fontID = font.MacGetThemeFontID();
2987
2988 ::TextSize( (short)(font.GetPointSize()) ) ;
2989 ::TextFace( font.MacGetFontStyle() ) ;
2990 }
2991 }
2992 #endif
2993
2994 wxListItem item;
2995 list->GetColumn(listColumn, item);
2996 if (item.GetMask() & wxLIST_MASK_FORMAT)
2997 {
2998 if (item.GetAlign() == wxLIST_FORMAT_LEFT)
2999 hFlush = kHIThemeTextHorizontalFlushLeft;
3000 else if (item.GetAlign() == wxLIST_FORMAT_CENTER)
3001 hFlush = kHIThemeTextHorizontalFlushCenter;
3002 else if (item.GetAlign() == wxLIST_FORMAT_RIGHT)
3003 {
3004 hFlush = kHIThemeTextHorizontalFlushRight;
3005 textCGRect.origin.x -= kItemPadding; // give a little extra paddding
3006 }
3007 }
3008
3009 info.state = active ? kThemeStateActive : kThemeStateInactive;
3010 info.horizontalFlushness = hFlush;
3011 info.verticalFlushness = kHIThemeTextVerticalFlushCenter;
3012 info.options = kHIThemeTextBoxOptionNone;
3013 info.truncationPosition = kHIThemeTextTruncationEnd;
3014 info.truncationMaxLines = 1;
3015
3016 {
3017 wxMacCGContextStateSaver cg( context );
3018 CGContextSetRGBFillColor (context, (CGFloat)labelColor.red / (CGFloat)USHRT_MAX,
3019 (CGFloat)labelColor.green / (CGFloat)USHRT_MAX,
3020 (CGFloat)labelColor.blue / (CGFloat)USHRT_MAX, (CGFloat) 1.0);
3021
3022 HIThemeDrawTextBox(cfString, &textCGRect, &info, context, kHIThemeOrientationNormal);
3023 }
3024
3025 #ifndef __LP64__
3026 if (savedState != NULL)
3027 SetThemeDrawingState(savedState, true);
3028 #endif
3029 }
3030
3031 OSStatus wxMacDataBrowserListCtrlControl::GetSetItemData(DataBrowserItemID itemID,
3032 DataBrowserPropertyID property,
3033 DataBrowserItemDataRef itemData,
3034 Boolean changeValue )
3035 {
3036 wxString text;
3037 int imgIndex = -1;
3038
3039 DataBrowserTableViewColumnIndex listColumn = 0;
3040 verify_noerr( GetColumnPosition( property, &listColumn ) );
3041
3042 OSStatus err = errDataBrowserPropertyNotSupported;
3043 wxListCtrl* list = wxDynamicCast( GetWXPeer() , wxListCtrl );
3044 wxMacListCtrlItem* lcItem = NULL;
3045
3046 if (listColumn >= 0)
3047 {
3048 if (!m_isVirtual)
3049 {
3050 lcItem = (wxMacListCtrlItem*) itemID;
3051 if (lcItem && lcItem->HasColumnInfo(listColumn)){
3052 wxListItem* item = lcItem->GetColumnInfo(listColumn);
3053 if (item->GetMask() & wxLIST_MASK_TEXT)
3054 text = item->GetText();
3055 if (item->GetMask() & wxLIST_MASK_IMAGE)
3056 imgIndex = item->GetImage();
3057 }
3058 }
3059 else
3060 {
3061 long itemNum = (long)itemID-1;
3062 if (itemNum >= 0 && itemNum < list->GetItemCount())
3063 {
3064 text = list->OnGetItemText( itemNum, listColumn );
3065 imgIndex = list->OnGetItemColumnImage( itemNum, listColumn );
3066 }
3067 }
3068 }
3069
3070 if ( !changeValue )
3071 {
3072 switch (property)
3073 {
3074 case kDataBrowserItemIsEditableProperty :
3075 if ( list && list->HasFlag( wxLC_EDIT_LABELS ) )
3076 {
3077 verify_noerr(SetDataBrowserItemDataBooleanValue( itemData, true ));
3078 err = noErr ;
3079 }
3080 break ;
3081 default :
3082 if ( property >= kMinColumnId )
3083 {
3084 if (!text.IsEmpty()){
3085 wxCFStringRef cfStr( text, wxLocale::GetSystemEncoding() );
3086 err = ::SetDataBrowserItemDataText( itemData, cfStr );
3087 err = noErr;
3088 }
3089
3090
3091
3092 if ( imgIndex != -1 )
3093 {
3094 wxImageList* imageList = list->GetImageList(wxIMAGE_LIST_SMALL);
3095 if (imageList && imageList->GetImageCount() > 0){
3096 wxBitmap bmp = imageList->GetBitmap(imgIndex);
3097 IconRef icon = bmp.GetIconRef();
3098 ::SetDataBrowserItemDataIcon(itemData, icon);
3099 }
3100 }
3101
3102 }
3103 break ;
3104 }
3105
3106 }
3107 else
3108 {
3109 switch (property)
3110 {
3111 default:
3112 if ( property >= kMinColumnId )
3113 {
3114 DataBrowserTableViewColumnIndex listColumn = 0;
3115 verify_noerr( GetColumnPosition( property, &listColumn ) );
3116
3117 // TODO probably send the 'end edit' from here, as we
3118 // can then deal with the veto
3119 CFStringRef sr ;
3120 verify_noerr( GetDataBrowserItemDataText( itemData , &sr ) ) ;
3121 wxCFStringRef cfStr(sr) ;;
3122 if (m_isVirtual)
3123 list->SetItem( (long)itemData-1 , listColumn, cfStr.AsString() ) ;
3124 else
3125 {
3126 if (lcItem)
3127 lcItem->SetColumnTextValue( listColumn, cfStr.AsString() );
3128 }
3129 err = noErr ;
3130 }
3131 break;
3132 }
3133 }
3134 return err;
3135 }
3136
3137 void wxMacDataBrowserListCtrlControl::ItemNotification(DataBrowserItemID itemID,
3138 DataBrowserItemNotification message,
3139 DataBrowserItemDataRef itemData )
3140 {
3141 wxMacListCtrlItem *item = NULL;
3142 if ( !m_isVirtual )
3143 {
3144 item = (wxMacListCtrlItem *) itemID;
3145 }
3146
3147 // we want to depend on as little as possible to make sure tear-down of controls is safe
3148 if ( message == kDataBrowserItemRemoved )
3149 {
3150 if ( item )
3151 item->Notification(this, message, itemData);
3152 return;
3153 }
3154 else if ( message == kDataBrowserItemAdded )
3155 {
3156 // we don't issue events on adding, the item is not really stored in the list yet, so we
3157 // avoid asserts by getting out now
3158 if ( item )
3159 item->Notification(this, message, itemData);
3160 return ;
3161 }
3162
3163 wxListCtrl *list = wxDynamicCast( GetWXPeer() , wxListCtrl );
3164 if ( list )
3165 {
3166 bool trigger = false;
3167
3168 wxListEvent event( wxEVT_COMMAND_LIST_ITEM_SELECTED, list->GetId() );
3169
3170 event.SetEventObject( list );
3171 if ( !list->IsVirtual() )
3172 {
3173 DataBrowserTableViewRowIndex result = 0;
3174 verify_noerr( GetItemRow( itemID, &result ) ) ;
3175 event.m_itemIndex = result;
3176 }
3177 else
3178 {
3179 event.m_itemIndex = (long)itemID-1;
3180 }
3181 event.m_item.m_itemId = event.m_itemIndex;
3182 list->GetItem(event.m_item);
3183
3184 switch (message)
3185 {
3186 case kDataBrowserItemDeselected:
3187 event.SetEventType(wxEVT_COMMAND_LIST_ITEM_DESELECTED);
3188 // as the generic implementation is also triggering this
3189 // event for single selection, we do the same (different than listbox)
3190 trigger = !IsSelectionSuppressed();
3191 break;
3192
3193 case kDataBrowserItemSelected:
3194 trigger = !IsSelectionSuppressed();
3195
3196 break;
3197
3198 case kDataBrowserItemDoubleClicked:
3199 event.SetEventType( wxEVT_COMMAND_LIST_ITEM_ACTIVATED );
3200 trigger = true;
3201 break;
3202
3203 case kDataBrowserEditStarted :
3204 // TODO : how to veto ?
3205 event.SetEventType( wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT ) ;
3206 trigger = true ;
3207 break ;
3208
3209 case kDataBrowserEditStopped :
3210 // TODO probably trigger only upon the value store callback, because
3211 // here IIRC we cannot veto
3212 event.SetEventType( wxEVT_COMMAND_LIST_END_LABEL_EDIT ) ;
3213 trigger = true ;
3214 break ;
3215
3216 default:
3217 break;
3218 }
3219
3220 if ( trigger )
3221 {
3222 // direct notification is not always having the listbox GetSelection() having in synch with event
3223 wxPostEvent( list->GetEventHandler(), event );
3224 }
3225 }
3226 }
3227
3228 Boolean wxMacDataBrowserListCtrlControl::CompareItems(DataBrowserItemID itemOneID,
3229 DataBrowserItemID itemTwoID,
3230 DataBrowserPropertyID sortProperty)
3231 {
3232
3233 bool retval = false;
3234 wxString itemText;
3235 wxString otherItemText;
3236 long itemOrder;
3237 long otherItemOrder;
3238
3239 DataBrowserTableViewColumnIndex colId = 0;
3240 verify_noerr( GetColumnPosition( sortProperty, &colId ) );
3241
3242 wxListCtrl* list = wxDynamicCast( GetWXPeer() , wxListCtrl );
3243
3244 DataBrowserSortOrder sort;
3245 verify_noerr(GetSortOrder(&sort));
3246
3247 if (colId >= 0)
3248 {
3249 if (!m_isVirtual)
3250 {
3251 wxMacListCtrlItem* item = (wxMacListCtrlItem*)itemOneID;
3252 wxMacListCtrlItem* otherItem = (wxMacListCtrlItem*)itemTwoID;
3253
3254 itemOrder = item->GetOrder();
3255 otherItemOrder = otherItem->GetOrder();
3256
3257 wxListCtrlCompare func = list->GetCompareFunc();
3258 if (func != NULL)
3259 {
3260
3261 long item1 = -1;
3262 long item2 = -1;
3263 if (item && item->HasColumnInfo(0))
3264 item1 = item->GetColumnInfo(0)->GetData();
3265 if (otherItem && otherItem->HasColumnInfo(0))
3266 item2 = otherItem->GetColumnInfo(0)->GetData();
3267
3268 if (item1 > -1 && item2 > -1)
3269 {
3270 int result = func(item1, item2, list->GetCompareFuncData());
3271 if (sort == kDataBrowserOrderIncreasing)
3272 return result >= 0;
3273 else
3274 return result < 0;
3275 }
3276 }
3277
3278 // we can't use the native control's sorting abilities, so just
3279 // sort by item id.
3280 return itemOrder < otherItemOrder;
3281 }
3282 else
3283 {
3284
3285 long itemNum = (long)itemOneID;
3286 long otherItemNum = (long)itemTwoID;
3287
3288 // virtual listctrls don't support sorting
3289 return itemNum < otherItemNum;
3290 }
3291 }
3292 else{
3293 // fallback for undefined cases
3294 retval = itemOneID < itemTwoID;
3295 }
3296
3297 return retval;
3298 }
3299
3300 wxMacDataBrowserListCtrlControl::~wxMacDataBrowserListCtrlControl()
3301 {
3302 }
3303
3304 void wxMacDataBrowserListCtrlControl::MacSetColumnInfo( unsigned int row, unsigned int column, wxListItem* item )
3305 {
3306 wxMacDataItem* dataItem = GetItemFromLine(row);
3307 wxASSERT_MSG( dataItem, wxT("could not obtain wxMacDataItem for row in MacSetColumnInfo. Is row a valid wxListCtrl row?") );
3308 if (item)
3309 {
3310 wxMacListCtrlItem* listItem = static_cast<wxMacListCtrlItem *>(dataItem);
3311 bool hasInfo = listItem->HasColumnInfo( column );
3312 listItem->SetColumnInfo( column, item );
3313 listItem->SetOrder(row);
3314 UpdateState(dataItem, item);
3315
3316 wxListCtrl* list = wxDynamicCast( GetWXPeer() , wxListCtrl );
3317
3318 // NB: When this call was made before a control was completely shown, it would
3319 // update the item prematurely (i.e. no text would be listed) and, on show,
3320 // only the sorted column would be refreshed, meaning only first column text labels
3321 // would be shown. Making sure not to update items until the control is visible
3322 // seems to fix this issue.
3323 if (hasInfo && list->IsShown())
3324 {
3325 DataBrowserTableViewColumnID id = 0;
3326 verify_noerr( GetColumnIDFromIndex( column, &id ) );
3327 UpdateItem( wxMacDataBrowserRootContainer, listItem , id );
3328 }
3329 }
3330 }
3331
3332 // apply changes that need to happen immediately, rather than when the
3333 // databrowser control fires a callback.
3334 void wxMacDataBrowserListCtrlControl::UpdateState(wxMacDataItem* dataItem, wxListItem* listItem)
3335 {
3336 bool isSelected = IsItemSelected( dataItem );
3337 bool isSelectedState = (listItem->GetState() == wxLIST_STATE_SELECTED);
3338
3339 // toggle the selection state if wxListInfo state and actual state don't match.
3340 if ( listItem->GetMask() & wxLIST_MASK_STATE && isSelected != isSelectedState )
3341 {
3342 DataBrowserSetOption options = kDataBrowserItemsAdd;
3343 if (!isSelectedState)
3344 options = kDataBrowserItemsRemove;
3345 SetSelectedItem(dataItem, options);
3346 }
3347 // TODO: Set column width if item width > than current column width
3348 }
3349
3350 void wxMacDataBrowserListCtrlControl::MacGetColumnInfo( unsigned int row, unsigned int column, wxListItem& item )
3351 {
3352 wxMacDataItem* dataItem = GetItemFromLine(row);
3353 wxASSERT_MSG( dataItem, wxT("could not obtain wxMacDataItem in MacGetColumnInfo. Is row a valid wxListCtrl row?") );
3354 // CS should this guard against dataItem = 0 ? , as item is not a pointer if (item) is not appropriate
3355 //if (item)
3356 {
3357 wxMacListCtrlItem* listItem = static_cast<wxMacListCtrlItem *>(dataItem);
3358
3359 if (!listItem->HasColumnInfo( column ))
3360 return;
3361
3362 wxListItem* oldItem = listItem->GetColumnInfo( column );
3363
3364 if (oldItem)
3365 {
3366 long mask = item.GetMask();
3367 if ( !mask )
3368 // by default, get everything for backwards compatibility
3369 mask = -1;
3370
3371 if ( mask & wxLIST_MASK_TEXT )
3372 item.SetText(oldItem->GetText());
3373 if ( mask & wxLIST_MASK_IMAGE )
3374 item.SetImage(oldItem->GetImage());
3375 if ( mask & wxLIST_MASK_DATA )
3376 item.SetData(oldItem->GetData());
3377 if ( mask & wxLIST_MASK_STATE )
3378 item.SetState(oldItem->GetState());
3379 if ( mask & wxLIST_MASK_WIDTH )
3380 item.SetWidth(oldItem->GetWidth());
3381 if ( mask & wxLIST_MASK_FORMAT )
3382 item.SetAlign(oldItem->GetAlign());
3383
3384 item.SetTextColour(oldItem->GetTextColour());
3385 item.SetBackgroundColour(oldItem->GetBackgroundColour());
3386 item.SetFont(oldItem->GetFont());
3387 }
3388 }
3389 }
3390
3391 void wxMacDataBrowserListCtrlControl::MacInsertItem( unsigned int n, wxListItem* item )
3392 {
3393
3394 wxMacDataItemBrowserControl::MacInsert(n, new wxMacListCtrlItem() );
3395 MacSetColumnInfo(n, 0, item);
3396 }
3397
3398 wxMacListCtrlItem::wxMacListCtrlItem()
3399 {
3400 m_rowItems = wxListItemList();
3401 }
3402
3403 int wxMacListCtrlItem::GetColumnImageValue( unsigned int column )
3404 {
3405 if ( HasColumnInfo(column) )
3406 return GetColumnInfo(column)->GetImage();
3407
3408 return -1;
3409 }
3410
3411 void wxMacListCtrlItem::SetColumnImageValue( unsigned int column, int imageIndex )
3412 {
3413 if ( HasColumnInfo(column) )
3414 GetColumnInfo(column)->SetImage(imageIndex);
3415 }
3416
3417 wxString wxMacListCtrlItem::GetColumnTextValue( unsigned int column )
3418 {
3419 /* TODO CHECK REMOVE
3420 if ( column == 0 )
3421 return GetLabel();
3422 */
3423 if ( HasColumnInfo(column) )
3424 return GetColumnInfo(column)->GetText();
3425
3426 return wxEmptyString;
3427 }
3428
3429 void wxMacListCtrlItem::SetColumnTextValue( unsigned int column, const wxString& text )
3430 {
3431 if ( HasColumnInfo(column) )
3432 GetColumnInfo(column)->SetText(text);
3433
3434 /* TODO CHECK REMOVE
3435 // for compatibility with superclass APIs
3436 if ( column == 0 )
3437 SetLabel(text);
3438 */
3439 }
3440
3441 wxListItem* wxMacListCtrlItem::GetColumnInfo( unsigned int column )
3442 {
3443 wxASSERT_MSG( HasColumnInfo(column), wxT("invalid column index in wxMacListCtrlItem") );
3444 return m_rowItems[column];
3445 }
3446
3447 bool wxMacListCtrlItem::HasColumnInfo( unsigned int column )
3448 {
3449 return !(m_rowItems.find( column ) == m_rowItems.end());
3450 }
3451
3452 void wxMacListCtrlItem::SetColumnInfo( unsigned int column, wxListItem* item )
3453 {
3454
3455 if ( !HasColumnInfo(column) )
3456 {
3457 wxListItem* listItem = new wxListItem(*item);
3458 m_rowItems[column] = listItem;
3459 }
3460 else
3461 {
3462 wxListItem* listItem = GetColumnInfo( column );
3463 long mask = item->GetMask();
3464 if (mask & wxLIST_MASK_TEXT)
3465 listItem->SetText(item->GetText());
3466 if (mask & wxLIST_MASK_DATA)
3467 listItem->SetData(item->GetData());
3468 if (mask & wxLIST_MASK_IMAGE)
3469 listItem->SetImage(item->GetImage());
3470 if (mask & wxLIST_MASK_STATE)
3471 listItem->SetState(item->GetState());
3472 if (mask & wxLIST_MASK_FORMAT)
3473 listItem->SetAlign(item->GetAlign());
3474 if (mask & wxLIST_MASK_WIDTH)
3475 listItem->SetWidth(item->GetWidth());
3476
3477 if ( item->HasAttributes() )
3478 {
3479 if ( listItem->HasAttributes() )
3480 listItem->GetAttributes()->AssignFrom(*item->GetAttributes());
3481 else
3482 {
3483 listItem->SetTextColour(item->GetTextColour());
3484 listItem->SetBackgroundColour(item->GetBackgroundColour());
3485 listItem->SetFont(item->GetFont());
3486 }
3487 }
3488 }
3489 }
3490
3491 int wxListCtrl::CalcColumnAutoWidth(int col) const
3492 {
3493 int width = 0;
3494
3495 for ( int i = 0; i < GetItemCount(); i++ )
3496 {
3497 wxListItem info;
3498 info.SetMask(wxLIST_MASK_TEXT | wxLIST_MASK_IMAGE);
3499 info.SetId(i);
3500 info.SetColumn(col);
3501 GetItem(info);
3502
3503 const wxFont font = info.GetFont();
3504
3505 int w = 0;
3506 if ( font.IsOk() )
3507 GetTextExtent(info.GetText(), &w, NULL, NULL, NULL, &font);
3508 else
3509 GetTextExtent(info.GetText(), &w, NULL);
3510
3511 w += 2 * kItemPadding;
3512
3513 if ( info.GetImage() != -1 )
3514 w += kIconWidth;
3515
3516 width = wxMax(width, w);
3517 }
3518
3519 return width;
3520 }
3521
3522 #endif // wxUSE_LISTCTRL
3523
wxWidgets (Impactor)