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