X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/cb305e1e9ff819725734250d3020c1a074ef8174..f100b1c33ed3266515ae7c2cd4978ea9c9fceddc:/src/mac/carbon/listctrl_mac.cpp?ds=sidebyside

diff --git a/src/mac/carbon/listctrl_mac.cpp b/src/mac/carbon/listctrl_mac.cpp
index 31dfaa7fa8..5a1a1f0bc8 100644
--- a/src/mac/carbon/listctrl_mac.cpp
+++ b/src/mac/carbon/listctrl_mac.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        src/msw/listctrl.cpp
+// Name:        src/mac/listctrl_mac.cpp
 // Purpose:     wxListCtrl
 // Author:      Julian Smart
 // Modified by: Agron Selimaj
@@ -26,22 +26,19 @@
 
 #if wxUSE_LISTCTRL
 
+#include "wx/listctrl.h"
+
 #ifndef WX_PRECOMP
-    #include "wx/app.h"
     #include "wx/intl.h"
-    #include "wx/log.h"
-    #include "wx/settings.h"
-    #include "wx/dcclient.h"
-    #include "wx/textctrl.h"
 #endif
 
 #include "wx/mac/uma.h"
 
 #include "wx/imaglist.h"
-#include "wx/listctrl.h"
 #include "wx/sysopt.h"
+#include "wx/timer.h"
 
-#define wxMAC_ALWAYS_USE_GENERIC_LISTCTRL wxT("mac.listctrl.always_use_generic")
+#include "wx/hashmap.h"
 
 #if wxUSE_EXTENDED_RTTI
 WX_DEFINE_FLAGS( wxListCtrlStyle )
@@ -116,65 +113,404 @@ IMPLEMENT_DYNAMIC_CLASS(wxListItem, wxObject)
 
 IMPLEMENT_DYNAMIC_CLASS(wxListEvent, wxNotifyEvent)
 
-WX_DECLARE_EXPORTED_LIST(wxListItem, wxListItemList);
+WX_DECLARE_HASH_MAP( int, wxListItem*, wxIntegerHash, wxIntegerEqual, wxListItemList );
+
 #include "wx/listimpl.cpp"
-WX_DEFINE_LIST(wxListItemList)
+WX_DEFINE_LIST(wxColumnList)
+
+// so we can check for column clicks
+static const EventTypeSpec eventList[] =
+{
+    { kEventClassControl, kEventControlHit },
+    { kEventClassControl, kEventControlDraw }
+};
+
+static pascal OSStatus wxMacListCtrlEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
+{
+    OSStatus result = eventNotHandledErr ;
+
+    wxMacCarbonEvent cEvent( event ) ;
+
+    ControlRef controlRef ;
+    cEvent.GetParameter( kEventParamDirectObject , &controlRef ) ;
+
+    wxListCtrl *window = (wxListCtrl*) data ;
+    wxListEvent le( wxEVT_COMMAND_LIST_COL_CLICK, window->GetId() );
+    le.SetEventObject( window );
+
+    switch ( GetEventKind( event ) )
+    {
+        // check if the column was clicked on and fire an event if so
+        case kEventControlHit :
+            {
+                ControlPartCode result = cEvent.GetParameter<ControlPartCode>(kEventParamControlPart, typeControlPartCode) ;
+                if (result == kControlButtonPart){
+                    DataBrowserPropertyID col;
+                    GetDataBrowserSortProperty(controlRef, &col);
+                    int column = col - kMinColumnId;
+                    le.m_col = column;
+                    // FIXME: we can't use the sort property for virtual listctrls
+                    // so we need to find a better way to determine which column was clicked...
+                    if (!window->IsVirtual())
+                        window->GetEventHandler()->ProcessEvent( le );
+                }
+                result = CallNextEventHandler(handler, event);
+                break;
+            }
+        case kEventControlDraw:
+            {
+                CGContextRef context = cEvent.GetParameter<CGContextRef>(kEventParamCGContextRef, typeCGContextRef) ;
+                window->MacSetDrawingContext(context);
+                result = CallNextEventHandler(handler, event);
+                window->MacSetDrawingContext(NULL);
+                break;
+            }
+        default :
+            break ;
+    }
+
+
+    return result ;
+}
+
+DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacListCtrlEventHandler )
 
 class wxMacListCtrlItem : public wxMacListBoxItem
 {
 public:
     wxMacListCtrlItem();
-    
+
     virtual void Notification(wxMacDataItemBrowserControl *owner ,
         DataBrowserItemNotification message,
         DataBrowserItemDataRef itemData ) const;
-        
+
     virtual void SetColumnInfo( unsigned int column, wxListItem* item );
     virtual wxListItem* GetColumnInfo( unsigned int column );
     virtual bool HasColumnInfo( unsigned int column );
-    
+
     virtual void SetColumnTextValue( unsigned int column, const wxString& text );
-    virtual const wxString& GetColumnTextValue( unsigned int column ); 
-        
+    virtual wxString GetColumnTextValue( unsigned int column );
+
     virtual int GetColumnImageValue( unsigned int column );
     virtual void SetColumnImageValue( unsigned int column, int imageIndex );
-    
-    virtual OSStatus GetSetData( wxMacDataItemBrowserControl *owner ,
-    DataBrowserPropertyID property,
-    DataBrowserItemDataRef itemData,
-    bool changeValue );
 
-        
     virtual ~wxMacListCtrlItem();
 protected:
     wxListItemList m_rowItems;
 };
 
+DataBrowserDrawItemUPP gDataBrowserDrawItemUPP = NULL;
+//DataBrowserEditItemUPP gDataBrowserEditItemUPP = NULL;
+DataBrowserHitTestUPP gDataBrowserHitTestUPP = NULL;
+
 // TODO: Make a better name!!
 class wxMacDataBrowserListCtrlControl : public wxMacDataItemBrowserControl
 {
 public:
     wxMacDataBrowserListCtrlControl( wxWindow *peer, const wxPoint& pos, const wxSize& size, long style );
+    wxMacDataBrowserListCtrlControl() {}
     virtual ~wxMacDataBrowserListCtrlControl();
 
     // create a list item (can be a subclass of wxMacListBoxItem)
 
-    virtual wxMacListCtrlItem* CreateItem();
-    
+    virtual wxMacDataItem* CreateItem();
+
     virtual void MacInsertItem( unsigned int n, wxListItem* item );
     virtual void MacSetColumnInfo( unsigned int row, unsigned int column, wxListItem* item );
     virtual void MacGetColumnInfo( unsigned int row, unsigned int column, wxListItem& item );
     virtual void UpdateState(wxMacDataItem* dataItem, wxListItem* item);
-    
+    int GetFlags() { return m_flags; }
+
 protected:
+    // we need to override to provide specialized handling for virtual wxListCtrls
+    virtual OSStatus GetSetItemData(DataBrowserItemID itemID,
+                        DataBrowserPropertyID property,
+                        DataBrowserItemDataRef itemData,
+                        Boolean changeValue );
+
+    virtual void    ItemNotification(
+                        DataBrowserItemID itemID,
+                        DataBrowserItemNotification message,
+                        DataBrowserItemDataRef itemData);
+
+    virtual Boolean CompareItems(DataBrowserItemID itemOneID,
+                        DataBrowserItemID itemTwoID,
+                        DataBrowserPropertyID sortProperty);
+
+    static pascal void    DataBrowserDrawItemProc(ControlRef browser,
+                        DataBrowserItemID item,
+                        DataBrowserPropertyID property,
+                        DataBrowserItemState itemState,
+                        const Rect *theRect,
+                        SInt16 gdDepth,
+                        Boolean colorDevice);
+
+    virtual void        DrawItem(DataBrowserItemID itemID,
+                            DataBrowserPropertyID property,
+                            DataBrowserItemState itemState,
+                            const Rect *itemRect,
+                            SInt16 gdDepth,
+                            Boolean colorDevice);
+
+    static pascal Boolean  DataBrowserEditTextProc(ControlRef browser,
+                                    DataBrowserItemID item,
+                                    DataBrowserPropertyID property,
+                                    CFStringRef theString,
+                                    Rect *maxEditTextRect,
+                                    Boolean *shrinkToFit);
+
+    static pascal Boolean  DataBrowserHitTestProc(ControlRef browser,
+                                    DataBrowserItemID itemID,
+                                    DataBrowserPropertyID property,
+                                    const Rect *theRect,
+                                    const Rect *mouseRect) { return true; }
+
+    virtual bool        ConfirmEditText(DataBrowserItemID item,
+                                    DataBrowserPropertyID property,
+                                    CFStringRef theString,
+                                    Rect *maxEditTextRect,
+                                    Boolean *shrinkToFit);
+
+
+
     wxClientDataType m_clientDataItemsType;
+    bool m_isVirtual;
+    int m_flags;
+    DECLARE_DYNAMIC_CLASS_NO_COPY(wxMacDataBrowserListCtrlControl)
+};
+
+class wxMacListCtrlEventDelegate : public wxEvtHandler
+{
+public:
+    wxMacListCtrlEventDelegate( wxListCtrl* list, int id );
+    virtual bool ProcessEvent( wxEvent& event );
+
+private:
+    wxListCtrl* m_list;
+    int         m_id;
+};
+
+wxMacListCtrlEventDelegate::wxMacListCtrlEventDelegate( wxListCtrl* list, int id )
+{
+    m_list = list;
+    m_id = id;
+}
+
+bool wxMacListCtrlEventDelegate::ProcessEvent( wxEvent& event )
+{
+    // even though we use a generic list ctrl underneath, make sure
+    // we present ourselves as wxListCtrl.
+    event.SetEventObject( m_list );
+    event.SetId( m_id );
+
+    if ( !event.IsKindOf( CLASSINFO( wxCommandEvent ) ) )
+    {
+        if (m_list->GetEventHandler()->ProcessEvent( event ))
+            return true;
+    }
+    return wxEvtHandler::ProcessEvent(event);
+}
+
+//-----------------------------------------------------------------------------
+// wxListCtrlRenameTimer (internal)
+//-----------------------------------------------------------------------------
+
+class wxListCtrlRenameTimer: public wxTimer
+{
+private:
+    wxListCtrl *m_owner;
+
+public:
+    wxListCtrlRenameTimer( wxListCtrl *owner );
+    void Notify();
+};
+
+//-----------------------------------------------------------------------------
+// wxListCtrlTextCtrlWrapper: wraps a wxTextCtrl to make it work for inline editing
+//-----------------------------------------------------------------------------
+
+class wxListCtrlTextCtrlWrapper : public wxEvtHandler
+{
+public:
+    // NB: text must be a valid object but not Create()d yet
+    wxListCtrlTextCtrlWrapper(wxListCtrl *owner,
+                          wxTextCtrl *text,
+                          long itemEdit);
+
+    wxTextCtrl *GetText() const { return m_text; }
 
+    void AcceptChangesAndFinish();
+
+protected:
+    void OnChar( wxKeyEvent &event );
+    void OnKeyUp( wxKeyEvent &event );
+    void OnKillFocus( wxFocusEvent &event );
+
+    bool AcceptChanges();
+    void Finish();
+
+private:
+    wxListCtrl         *m_owner;
+    wxTextCtrl         *m_text;
+    wxString            m_startValue;
+    long              m_itemEdited;
+    bool                m_finished;
+    bool                m_aboutToFinish;
+
+    DECLARE_EVENT_TABLE()
 };
 
-// TODO: This gives errors, find out why. 
-//BEGIN_EVENT_TABLE(wxListCtrl, wxControl)
-//    EVT_PAINT(wxListCtrl::OnPaint)
-//END_EVENT_TABLE()
+//-----------------------------------------------------------------------------
+// wxListCtrlRenameTimer (internal)
+//-----------------------------------------------------------------------------
+
+wxListCtrlRenameTimer::wxListCtrlRenameTimer( wxListCtrl *owner )
+{
+    m_owner = owner;
+}
+
+void wxListCtrlRenameTimer::Notify()
+{
+    m_owner->OnRenameTimer();
+}
+
+//-----------------------------------------------------------------------------
+// wxListCtrlTextCtrlWrapper (internal)
+//-----------------------------------------------------------------------------
+
+BEGIN_EVENT_TABLE(wxListCtrlTextCtrlWrapper, wxEvtHandler)
+    EVT_CHAR           (wxListCtrlTextCtrlWrapper::OnChar)
+    EVT_KEY_UP         (wxListCtrlTextCtrlWrapper::OnKeyUp)
+    EVT_KILL_FOCUS     (wxListCtrlTextCtrlWrapper::OnKillFocus)
+END_EVENT_TABLE()
+
+wxListCtrlTextCtrlWrapper::wxListCtrlTextCtrlWrapper(wxListCtrl *owner,
+                                             wxTextCtrl *text,
+                                             long itemEdit)
+              : m_startValue(owner->GetItemText(itemEdit)),
+                m_itemEdited(itemEdit)
+{
+    m_owner = owner;
+    m_text = text;
+    m_finished = false;
+    m_aboutToFinish = false;
+
+    wxRect rectLabel;
+    int offset = 8;
+    owner->GetItemRect(itemEdit, rectLabel);
+
+    m_text->Create(owner, wxID_ANY, m_startValue,
+                   wxPoint(rectLabel.x+offset,rectLabel.y),
+                   wxSize(rectLabel.width-offset,rectLabel.height));
+    m_text->SetFocus();
+
+    m_text->PushEventHandler(this);
+}
+
+void wxListCtrlTextCtrlWrapper::Finish()
+{
+    if ( !m_finished )
+    {
+        m_finished = true;
+
+        m_text->RemoveEventHandler(this);
+        m_owner->FinishEditing(m_text);
+
+        wxPendingDelete.Append( this );
+    }
+}
+
+bool wxListCtrlTextCtrlWrapper::AcceptChanges()
+{
+    const wxString value = m_text->GetValue();
+
+    if ( value == m_startValue )
+        // nothing changed, always accept
+        return true;
+
+    if ( !m_owner->OnRenameAccept(m_itemEdited, value) )
+        // vetoed by the user
+        return false;
+
+    // accepted, do rename the item
+    m_owner->SetItemText(m_itemEdited, value);
+
+    return true;
+}
+
+void wxListCtrlTextCtrlWrapper::AcceptChangesAndFinish()
+{
+    m_aboutToFinish = true;
+
+    // Notify the owner about the changes
+    AcceptChanges();
+
+    // Even if vetoed, close the control (consistent with MSW)
+    Finish();
+}
+
+void wxListCtrlTextCtrlWrapper::OnChar( wxKeyEvent &event )
+{
+    switch ( event.m_keyCode )
+    {
+        case WXK_RETURN:
+            AcceptChangesAndFinish();
+            break;
+
+        case WXK_ESCAPE:
+            m_owner->OnRenameCancelled( m_itemEdited );
+            Finish();
+            break;
+
+        default:
+            event.Skip();
+    }
+}
+
+void wxListCtrlTextCtrlWrapper::OnKeyUp( wxKeyEvent &event )
+{
+    if (m_finished)
+    {
+        event.Skip();
+        return;
+    }
+
+    // auto-grow the textctrl:
+    wxSize parentSize = m_owner->GetSize();
+    wxPoint myPos = m_text->GetPosition();
+    wxSize mySize = m_text->GetSize();
+    int sx, sy;
+    m_text->GetTextExtent(m_text->GetValue() + _T("MM"), &sx, &sy);
+    if (myPos.x + sx > parentSize.x)
+        sx = parentSize.x - myPos.x;
+    if (mySize.x > sx)
+        sx = mySize.x;
+    m_text->SetSize(sx, wxDefaultCoord);
+
+    event.Skip();
+}
+
+void wxListCtrlTextCtrlWrapper::OnKillFocus( wxFocusEvent &event )
+{
+    if ( !m_finished && !m_aboutToFinish )
+    {
+        if ( !AcceptChanges() )
+            m_owner->OnRenameCancelled( m_itemEdited );
+
+        Finish();
+    }
+
+    // We must let the native text control handle focus
+    event.Skip();
+}
+
+BEGIN_EVENT_TABLE(wxListCtrl, wxControl)
+    EVT_LEFT_DOWN(wxListCtrl::OnLeftDown)
+    EVT_LEFT_DCLICK(wxListCtrl::OnDblClick)
+    EVT_MIDDLE_DOWN(wxListCtrl::OnMiddleDown)
+    EVT_RIGHT_DOWN(wxListCtrl::OnRightDown)
+    EVT_CHAR(wxListCtrl::OnChar)
+END_EVENT_TABLE()
 
 // ============================================================================
 // implementation
@@ -182,7 +518,8 @@ protected:
 
 wxMacListControl* wxListCtrl::GetPeer() const
 {
-    return dynamic_cast<wxMacListControl*>(m_peer);
+    wxMacDataBrowserListCtrlControl *lb = wxDynamicCast(m_peer,wxMacDataBrowserListCtrlControl);
+    return lb ? wx_static_cast(wxMacListControl*,lb) : 0 ;
 }
 
 // ----------------------------------------------------------------------------
@@ -194,7 +531,7 @@ void wxListCtrl::Init()
     m_imageListNormal = NULL;
     m_imageListSmall = NULL;
     m_imageListState = NULL;
-    
+
     // keep track of if we created our own image lists, or if they were assigned
     // to us.
     m_ownsImageListNormal = m_ownsImageListSmall = m_ownsImageListState = false;
@@ -203,8 +540,170 @@ void wxListCtrl::Init()
     m_textCtrl = NULL;
     m_genericImpl = NULL;
     m_dbImpl = NULL;
+    m_compareFunc = NULL;
+    m_compareFuncData = 0;
+    m_colsInfo = wxColumnList();
+    m_textColor = wxNullColour;
+    m_bgColor = wxNullColour;
+    m_textctrlWrapper = NULL;
+    m_current = -1;
+    m_renameTimer = new wxListCtrlRenameTimer( this );
 }
 
+class wxGenericListCtrlHook : public wxGenericListCtrl
+{
+public:
+    wxGenericListCtrlHook(wxListCtrl* parent,
+                          wxWindowID id,
+                          const wxPoint& pos,
+                          const wxSize& size,
+                          long style,
+                          const wxValidator& validator,
+                          const wxString& name)
+        : wxGenericListCtrl(parent, id, pos, size, style, validator, name),
+          m_nativeListCtrl(parent)
+    {
+    }
+
+protected:
+    virtual wxListItemAttr * OnGetItemAttr(long item) const
+    {
+        return m_nativeListCtrl->OnGetItemAttr(item);
+    }
+
+    virtual int OnGetItemImage(long item) const
+    {
+        return m_nativeListCtrl->OnGetItemImage(item);
+    }
+
+    virtual int OnGetItemColumnImage(long item, long column) const
+    {
+        return m_nativeListCtrl->OnGetItemColumnImage(item, column);
+    }
+
+    virtual wxString OnGetItemText(long item, long column) const
+    {
+        return m_nativeListCtrl->OnGetItemText(item, column);
+    }
+
+    wxListCtrl* m_nativeListCtrl;
+
+};
+
+void wxListCtrl::OnLeftDown(wxMouseEvent& event)
+{
+    if ( m_textctrlWrapper )
+    {
+        m_current = -1;
+        m_textctrlWrapper->AcceptChangesAndFinish();
+    }
+
+    int hitResult;
+    long current = HitTest(event.GetPosition(), hitResult);
+    if ((current == m_current) &&
+        (hitResult == wxLIST_HITTEST_ONITEM) &&
+        HasFlag(wxLC_EDIT_LABELS) )
+    {
+        m_renameTimer->Start( 100, true );
+    }
+    else
+    {
+        m_current = current;
+    }
+    event.Skip();
+}
+
+void wxListCtrl::OnDblClick(wxMouseEvent& event)
+{
+    m_current = -1;
+    event.Skip();
+}
+
+#if wxABI_VERSION >= 20801
+void wxListCtrl::OnRightDown(wxMouseEvent& event)
+{
+    if (m_dbImpl)
+        FireMouseEvent(wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK, event.GetPosition());
+    event.Skip();
+}
+
+void wxListCtrl::OnMiddleDown(wxMouseEvent& event)
+{
+    if (m_dbImpl)
+        FireMouseEvent(wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK, event.GetPosition());
+    event.Skip();
+}
+
+void wxListCtrl::FireMouseEvent(wxEventType eventType, wxPoint position)
+{
+    wxListEvent le( eventType, GetId() );
+    le.SetEventObject(this);
+    le.m_pointDrag = position;
+    le.m_itemIndex = -1;
+
+    int flags;
+    long item = HitTest(position, flags);
+    if (flags & wxLIST_HITTEST_ONITEM)
+    {
+        le.m_itemIndex = item;
+        le.m_item.m_itemId = item;
+        GetItem(le.m_item);
+        GetEventHandler()->ProcessEvent(le);
+    }
+}
+
+void wxListCtrl::OnChar(wxKeyEvent& event)
+{
+
+    
+    if (m_dbImpl)
+    {
+        wxListEvent le( wxEVT_COMMAND_LIST_KEY_DOWN, GetId() );
+        le.SetEventObject(this);
+        le.m_code = event.GetKeyCode();
+        le.m_itemIndex = -1;
+        
+        if (m_current == -1)
+        {
+            // if m_current isn't set, check if there's been a selection
+            // made before continuing
+            m_current = GetNextItem(-1, wxLIST_NEXT_BELOW, wxLIST_STATE_SELECTED);
+        }
+        
+        // We need to determine m_current ourselves when navigation keys
+        // are used. Note that PAGEUP and PAGEDOWN do not alter the current
+        // item on native Mac ListCtrl, so we only handle up and down keys.
+        switch ( event.GetKeyCode() )
+        {
+            case WXK_UP:
+                if ( m_current > 0 )
+                    m_current -= 1;
+                else
+                    m_current = 0;
+                    
+                break;
+
+            case WXK_DOWN:
+                if ( m_current < GetItemCount() - 1 )
+                    m_current += 1;
+                else
+                    m_current = GetItemCount() - 1;
+                    
+                break;
+        }
+
+        if (m_current != -1)
+        {
+            le.m_itemIndex = m_current;
+            le.m_item.m_itemId = m_current;
+            GetItem(le.m_item);
+            GetEventHandler()->ProcessEvent(le);
+        }
+    }
+    event.Skip();
+}
+#endif
+
 bool wxListCtrl::Create(wxWindow *parent,
                         wxWindowID id,
                         const wxPoint& pos,
@@ -217,41 +716,60 @@ bool wxListCtrl::Create(wxWindow *parent,
     // for now, we'll always use the generic list control for ICON and LIST views,
     // because they dynamically change the number of columns on resize.
     // Also, allow the user to set it to use the list ctrl as well.
-    if ( (wxSystemOptions::HasOption( wxMAC_ALWAYS_USE_GENERIC_LISTCTRL ) 
+    if ( (wxSystemOptions::HasOption( wxMAC_ALWAYS_USE_GENERIC_LISTCTRL )
             && (wxSystemOptions::GetOptionInt( wxMAC_ALWAYS_USE_GENERIC_LISTCTRL ) == 1)) ||
-            (style & wxLC_ICON) || (style & wxLC_SMALL_ICON) || (style & wxLC_LIST))
+            (style & wxLC_ICON) || (style & wxLC_SMALL_ICON) || (style & wxLC_LIST) )
     {
         m_macIsUserPane = true;
-    
-        if ( !wxWindow::Create(parent, id, pos, size, style, name) )
+
+        long paneStyle = style;
+        paneStyle &= ~wxSIMPLE_BORDER;
+        paneStyle &= ~wxDOUBLE_BORDER;
+        paneStyle &= ~wxSUNKEN_BORDER;
+        paneStyle &= ~wxRAISED_BORDER;
+        paneStyle &= ~wxSTATIC_BORDER;
+        if ( !wxWindow::Create(parent, id, pos, size, paneStyle | wxNO_BORDER, name) )
             return false;
-        m_genericImpl = new wxGenericListCtrl(this, id, pos, size, style, validator, name);
+
+        // since the generic control is a child, make sure we position it at 0, 0
+        m_genericImpl = new wxGenericListCtrlHook(this, id, wxPoint(0, 0), size, style, validator, name);
+        m_genericImpl->PushEventHandler( new wxMacListCtrlEventDelegate( this, GetId() ) );
         return true;
     }
-    
+
     else
     {
          m_macIsUserPane = false;
-        
-        if ( !wxWindow::Create(parent, id, pos, size, style, name) )
+        if ( !wxWindow::Create(parent, id, pos, size, style & ~(wxHSCROLL | wxVSCROLL), name) )
             return false;
         m_dbImpl = new wxMacDataBrowserListCtrlControl( this, pos, size, style );
         m_peer = m_dbImpl;
 
         MacPostControlCreate( pos, size );
+
+        InstallControlEventHandler( m_peer->GetControlRef() , GetwxMacListCtrlEventHandlerUPP(),
+            GetEventTypeCount(eventList), eventList, this,
+            (EventHandlerRef *)&m_macListCtrlEventHandler);
     }
-    
+
     return true;
 }
 
 wxListCtrl::~wxListCtrl()
-{        
+{
+    if (m_genericImpl)
+    {
+        m_genericImpl->PopEventHandler(/* deleteHandler = */ true);
+    }
+
     if (m_ownsImageListNormal)
         delete m_imageListNormal;
     if (m_ownsImageListSmall)
         delete m_imageListSmall;
     if (m_ownsImageListState)
         delete m_imageListState;
+
+    delete m_renameTimer;
 }
 
 // ----------------------------------------------------------------------------
@@ -289,7 +807,8 @@ void wxListCtrl::SetWindowStyleFlag(long flag)
     {
         m_windowStyle = flag;
 
-        if (m_genericImpl){
+        if (m_genericImpl)
+        {
             m_genericImpl->SetWindowStyleFlag(flag);
         }
 
@@ -297,11 +816,76 @@ void wxListCtrl::SetWindowStyleFlag(long flag)
     }
 }
 
-void wxListCtrl::DoSetSize( int x, int y, int width, int height, int sizeFlags ){
+void wxListCtrl::DoSetSize( int x, int y, int width, int height, int sizeFlags )
+{
     wxControl::DoSetSize(x, y, width, height, sizeFlags);
-            
+
+    if (m_genericImpl)
+        m_genericImpl->SetSize(0, 0, width, height, sizeFlags);
+
+    // determine if we need a horizontal scrollbar, and add it if so
+    if (m_dbImpl)
+    {
+        int totalWidth = 0;
+        for (int column = 0; column < GetColumnCount(); column++)
+        {
+              totalWidth += m_dbImpl->GetColumnWidth( column );
+        }
+
+        if ( !(m_dbImpl->GetFlags() & wxHSCROLL) )
+        {
+            Boolean vertScrollBar;
+            GetDataBrowserHasScrollBars( m_dbImpl->GetControlRef(), NULL, &vertScrollBar );
+            if (totalWidth > width)
+                SetDataBrowserHasScrollBars( m_dbImpl->GetControlRef(), true, vertScrollBar );
+            else
+                SetDataBrowserHasScrollBars( m_dbImpl->GetControlRef(), false, vertScrollBar );
+        }
+    }
+}
+
+wxSize wxListCtrl::DoGetBestSize() const
+{
+    return wxWindow::DoGetBestSize();
+}
+
+bool wxListCtrl::SetFont(const wxFont& font)
+{
+    bool rv = true;
+    rv = wxControl::SetFont(font);
+    if (m_genericImpl)
+        rv = m_genericImpl->SetFont(font);
+    return rv;
+}
+
+bool wxListCtrl::SetForegroundColour(const wxColour& colour)
+{
+    bool rv = true;
+    if (m_genericImpl)
+        rv = m_genericImpl->SetForegroundColour(colour);
+    if (m_dbImpl)
+        SetTextColour(colour);
+    return rv;
+}
+
+bool wxListCtrl::SetBackgroundColour(const wxColour& colour)
+{
+    bool rv = true;
+    if (m_genericImpl)
+        rv = m_genericImpl->SetBackgroundColour(colour);
+    if (m_dbImpl)
+        m_bgColor = colour;
+    return rv;
+}
+
+wxColour wxListCtrl::GetBackgroundColour()
+{
     if (m_genericImpl)
-        m_genericImpl->SetSize(x, y, width, height, sizeFlags);
+        return m_genericImpl->GetBackgroundColour();
+    if (m_dbImpl)
+        return m_bgColor;
+
+    return wxNullColour;
 }
 
 // ----------------------------------------------------------------------------
@@ -315,24 +899,28 @@ bool wxListCtrl::GetColumn(int col, wxListItem& item) const
         return m_genericImpl->GetColumn(col, item);
 
     bool success = true;
-    
-    if ( item.m_mask & wxLIST_MASK_TEXT )
-    {
-    }
 
-    if ( item.m_mask & wxLIST_MASK_FORMAT )
+    if (m_dbImpl)
     {
-    }
+        wxColumnList::compatibility_iterator node = m_colsInfo.Item( col );
+        wxASSERT_MSG( node, _T("invalid column index in wxMacListCtrlItem") );
+        wxListItem* column = node->GetData();
 
-    if ( item.m_mask & wxLIST_MASK_IMAGE )
-    {
-    }
-
-    if ( (item.m_mask & wxLIST_MASK_TEXT) )
-    {
+        long mask = column->GetMask();
+        if (mask & wxLIST_MASK_TEXT)
+            item.SetText(column->GetText());
+        if (mask & wxLIST_MASK_DATA)
+            item.SetData(column->GetData());
+        if (mask & wxLIST_MASK_IMAGE)
+            item.SetImage(column->GetImage());
+        if (mask & wxLIST_MASK_STATE)
+            item.SetState(column->GetState());
+        if (mask & wxLIST_MASK_FORMAT)
+            item.SetAlign(column->GetAlign());
+        if (mask & wxLIST_MASK_WIDTH)
+            item.SetWidth(column->GetWidth());
     }
 
-
     return success;
 }
 
@@ -341,16 +929,80 @@ bool wxListCtrl::SetColumn(int col, wxListItem& item)
 {
     if (m_genericImpl)
         return m_genericImpl->SetColumn(col, item);
-        
-    return false;
+
+    if (m_dbImpl)
+    {
+        long mask = item.GetMask();
+        if ( col >= (int)m_colsInfo.GetCount() )
+        {
+            wxListItem* listItem = new wxListItem(item);
+            m_colsInfo.Append( listItem );
+        }
+        else
+        {
+            wxListItem listItem;
+            GetColumn( col, listItem );
+
+            if (mask & wxLIST_MASK_TEXT)
+                listItem.SetText(item.GetText());
+            if (mask & wxLIST_MASK_DATA)
+                listItem.SetData(item.GetData());
+            if (mask & wxLIST_MASK_IMAGE)
+                listItem.SetImage(item.GetImage());
+            if (mask & wxLIST_MASK_STATE)
+                listItem.SetState(item.GetState());
+            if (mask & wxLIST_MASK_FORMAT)
+                listItem.SetAlign(item.GetAlign());
+            if (mask & wxLIST_MASK_WIDTH)
+                listItem.SetWidth(item.GetWidth());
+        }
+
+        // change the appearance in the databrowser.
+        DataBrowserListViewHeaderDesc columnDesc;
+        columnDesc.version=kDataBrowserListViewLatestHeaderDesc;
+        verify_noerr( m_dbImpl->GetHeaderDesc( kMinColumnId + col, &columnDesc ) );
+
+        /*
+        if (item.GetMask() & wxLIST_MASK_TEXT)
+        {
+            wxFontEncoding enc;
+            if ( m_font.Ok() )
+                enc = m_font.GetEncoding();
+            else
+                enc = wxLocale::GetSystemEncoding();
+            wxMacCFStringHolder cfTitle;
+            cfTitle.Assign( item.GetText() , enc );
+            if(columnDesc.titleString)
+                CFRelease(columnDesc.titleString);
+            columnDesc.titleString = cfTitle;
+        }
+        */
+
+        if (item.GetMask() & wxLIST_MASK_IMAGE && item.GetImage() != -1 )
+        {
+            columnDesc.btnContentInfo.contentType = kControlContentIconRef;
+            wxImageList* imageList = GetImageList(wxIMAGE_LIST_SMALL);
+            if (imageList && imageList->GetImageCount() > 0 )
+            {
+                wxBitmap bmp = imageList->GetBitmap( item.GetImage() );
+                IconRef icon = bmp.GetBitmapData()->GetIconRef();
+                columnDesc.btnContentInfo.u.iconRef = icon;
+            }
+        }
+
+        verify_noerr( m_dbImpl->SetHeaderDesc( kMinColumnId + col, &columnDesc ) );
+
+    }
+    return true;
 }
 
 int wxListCtrl::GetColumnCount() const
 {
     if (m_genericImpl)
         return m_genericImpl->GetColumnCount();
-        
-    if (m_dbImpl){
+
+    if (m_dbImpl)
+    {
         UInt32 count;
         m_dbImpl->GetColumnCount(&count);
         return count;
@@ -364,8 +1016,9 @@ int wxListCtrl::GetColumnWidth(int col) const
 {
     if (m_genericImpl)
         return m_genericImpl->GetColumnWidth(col);
-        
-    if (m_dbImpl){
+
+    if (m_dbImpl)
+    {
         return m_dbImpl->GetColumnWidth(col);
     }
 
@@ -377,16 +1030,38 @@ bool wxListCtrl::SetColumnWidth(int col, int width)
 {
     if (m_genericImpl)
         return m_genericImpl->SetColumnWidth(col, width);
-        
-    // TODO: This is setting the width of the first column
-    //       to the entire window width; investigate why
-    //       this is.
-    
-    //if (m_dbImpl){
-    //    m_dbImpl->SetColumnWidth(col+1, width);
-    //    return true;
-    //}
-    
+
+    if (m_dbImpl)
+    {
+        int mywidth = width;
+        if (width == wxLIST_AUTOSIZE || width == wxLIST_AUTOSIZE_USEHEADER)
+            mywidth = 150;
+
+        if (col == -1)
+        {
+            for (int column = 0; column < GetColumnCount(); column++)
+            {
+                wxListItem colInfo;
+                GetColumn(col, colInfo);
+
+                colInfo.SetWidth(width);
+                SetColumn(col, colInfo);
+
+                m_dbImpl->SetColumnWidth(col, mywidth);
+            }
+        }
+        else
+        {
+            wxListItem colInfo;
+            GetColumn(col, colInfo);
+
+            colInfo.SetWidth(width);
+            SetColumn(col, colInfo);
+            m_dbImpl->SetColumnWidth(col, mywidth);
+        }
+        return true;
+    }
+
     return false;
 }
 
@@ -398,10 +1073,11 @@ int wxListCtrl::GetCountPerPage() const
 {
     if (m_genericImpl)
         return m_genericImpl->GetCountPerPage();
-        
-    if (m_dbImpl){
+
+    if (m_dbImpl)
+    {
     }
-        
+
     return 1;
 }
 
@@ -410,7 +1086,7 @@ wxTextCtrl* wxListCtrl::GetEditControl() const
 {
     if (m_genericImpl)
         return m_genericImpl->GetEditControl();
-        
+
     return NULL;
 }
 
@@ -419,9 +1095,36 @@ bool wxListCtrl::GetItem(wxListItem& info) const
 {
     if (m_genericImpl)
         return m_genericImpl->GetItem(info);
-        
+
     if (m_dbImpl)
-        m_dbImpl->MacGetColumnInfo(info.m_itemId, info.m_col, info);
+    {
+        if (!IsVirtual())
+        {
+            if (info.m_itemId >= 0 && info.m_itemId < GetItemCount())
+                m_dbImpl->MacGetColumnInfo(info.m_itemId, info.m_col, info);
+        }
+        else
+        {
+            if (info.m_itemId >= 0 && info.m_itemId < GetItemCount())
+            {
+                info.SetText( OnGetItemText(info.m_itemId, info.m_col) );
+                info.SetImage( OnGetItemColumnImage(info.m_itemId, info.m_col) );
+                if (info.GetMask() & wxLIST_MASK_STATE)
+                {
+                    if (IsDataBrowserItemSelected( m_dbImpl->GetControlRef(), info.m_itemId+1 ))
+                        info.SetState(info.GetState() | wxLIST_STATE_SELECTED);
+                }
+
+                wxListItemAttr* attrs = OnGetItemAttr( info.m_itemId );
+                if (attrs)
+                {
+                    info.SetFont( attrs->GetFont() );
+                    info.SetBackgroundColour( attrs->GetBackgroundColour() );
+                    info.SetTextColour( attrs->GetTextColour() );
+                }
+            }
+        }
+    }
     bool success = true;
     return success;
 }
@@ -462,17 +1165,35 @@ int wxListCtrl::GetItemState(long item, long stateMask) const
 {
     if (m_genericImpl)
         return m_genericImpl->GetItemState(item, stateMask);
-        
-    wxListItem info;
 
-    info.m_mask = wxLIST_MASK_STATE;
-    info.m_stateMask = stateMask;
-    info.m_itemId = item;
+    if (m_dbImpl)
+    {
+        if ( HasFlag(wxLC_VIRTUAL) )
+        {
+            if (stateMask == wxLIST_STATE_SELECTED)
+            {
+                if (IsDataBrowserItemSelected( m_dbImpl->GetControlRef(), item+1 ))
+                    return wxLIST_STATE_SELECTED;
+                else
+                    return 0;
+            }
+        }
+        else
+        {
+            wxListItem info;
 
-    if (!GetItem(info))
-        return 0;
+            info.m_mask = wxLIST_MASK_STATE;
+            info.m_stateMask = stateMask;
+            info.m_itemId = item;
 
-    return info.m_state;
+            if (!GetItem(info))
+                return 0;
+
+            return info.m_state;
+        }
+    }
+
+    return 0;
 }
 
 // Sets the item state
@@ -481,12 +1202,58 @@ bool wxListCtrl::SetItemState(long item, long state, long stateMask)
     if (m_genericImpl)
         return m_genericImpl->SetItemState(item, state, stateMask);
 
-    wxListItem info;
-    info.m_mask = wxLIST_MASK_STATE;
-    info.m_stateMask = stateMask;
-    info.m_state = state;
-    info.m_itemId = item;
-    return SetItem(info);
+    if (m_dbImpl)
+    {
+        DataBrowserSetOption option = kDataBrowserItemsAdd;
+        if ( (stateMask & wxLIST_STATE_SELECTED) && state == 0 )
+            option = kDataBrowserItemsRemove;
+
+        if (item == -1)
+        {
+            if ( HasFlag(wxLC_VIRTUAL) )
+            {
+                wxMacDataItemBrowserSelectionSuppressor suppressor(m_dbImpl);
+                m_dbImpl->SetSelectedAllItems(option);
+            }
+            else
+            {
+                for(int i = 0; i < GetItemCount();i++)
+                {
+                    wxListItem info;
+                    info.m_itemId = i;
+                    info.m_mask = wxLIST_MASK_STATE;
+                    info.m_stateMask = stateMask;
+                    info.m_state = state;
+                    SetItem(info);
+                }
+            }
+        }
+        else
+        {
+            if ( HasFlag(wxLC_VIRTUAL) )
+            {
+                long itemID = item+1;
+                bool isSelected = IsDataBrowserItemSelected(m_dbImpl->GetControlRef(), (DataBrowserItemID)itemID );
+                bool isSelectedState = (state == wxLIST_STATE_SELECTED);
+
+                // toggle the selection state if wxListInfo state and actual state don't match.
+                if ( (stateMask & wxLIST_STATE_SELECTED) && isSelected != isSelectedState )
+                {
+                SetDataBrowserSelectedItems(m_dbImpl->GetControlRef(), 1, (DataBrowserItemID*)&itemID, option);
+            }
+            }
+            else
+            {
+                wxListItem info;
+                info.m_itemId = item;
+                info.m_mask = wxLIST_MASK_STATE;
+                info.m_stateMask = stateMask;
+                info.m_state = state;
+                return SetItem(info);
+            }
+        }
+    }
+    return true;
 }
 
 // Sets the item image
@@ -516,7 +1283,7 @@ wxString wxListCtrl::GetItemText(long item) const
 {
     if (m_genericImpl)
         return m_genericImpl->GetItemText(item);
-        
+
     wxListItem info;
 
     info.m_mask = wxLIST_MASK_TEXT;
@@ -532,7 +1299,7 @@ void wxListCtrl::SetItemText(long item, const wxString& str)
 {
     if (m_genericImpl)
         return m_genericImpl->SetItemText(item, str);
-        
+
     wxListItem info;
 
     info.m_mask = wxLIST_MASK_TEXT;
@@ -559,11 +1326,11 @@ long wxListCtrl::GetItemData(long item) const
 }
 
 // Sets the item data
-bool wxListCtrl::SetItemData(long item, long data)
+bool wxListCtrl::SetItemPtrData(long item, wxUIntPtr data)
 {
     if (m_genericImpl)
         return m_genericImpl->SetItemData(item, data);
-        
+
     wxListItem info;
 
     info.m_mask = wxLIST_MASK_DATA;
@@ -577,10 +1344,10 @@ wxRect wxListCtrl::GetViewRect() const
 {
     wxASSERT_MSG( !HasFlag(wxLC_REPORT | wxLC_LIST),
                     _T("wxListCtrl::GetViewRect() only works in icon mode") );
-                    
+
     if (m_genericImpl)
         return m_genericImpl->GetViewRect();
-        
+
     wxRect rect;
     return rect;
 }
@@ -591,7 +1358,35 @@ bool wxListCtrl::GetItemRect(long item, wxRect& rect, int code) const
     if (m_genericImpl)
         return m_genericImpl->GetItemRect(item, rect, code);
 
-    return true; 
+
+    if (m_dbImpl)
+    {
+        DataBrowserItemID id;
+        DataBrowserPropertyID col = kMinColumnId;
+        Rect bounds;
+        DataBrowserPropertyPart part = kDataBrowserPropertyEnclosingPart;
+        if ( code == wxLIST_RECT_LABEL )
+            part = kDataBrowserPropertyTextPart;
+        else if ( code == wxLIST_RECT_ICON )
+            part = kDataBrowserPropertyIconPart;
+
+        if ( !(GetWindowStyleFlag() & wxLC_VIRTUAL) )
+        {
+            wxMacDataItem* thisItem = m_dbImpl->GetItemFromLine(item);
+            id = (DataBrowserItemID) thisItem;
+        }
+        else
+            id = item+1;
+
+        GetDataBrowserItemPartBounds( m_dbImpl->GetControlRef(), id, col, part, &bounds );
+
+        rect.x = bounds.left;
+        rect.y = bounds.top;
+        rect.width = bounds.right - bounds.left; //GetClientSize().x; // we need the width of the whole row, not just the item.
+        rect.height = bounds.bottom - bounds.top;
+        //fprintf("id = %d, bounds = %d, %d, %d, %d\n", id, rect.x, rect.y, rect.width, rect.height);
+    }
+    return true;
 }
 
 // Gets the item position
@@ -602,6 +1397,14 @@ bool wxListCtrl::GetItemPosition(long item, wxPoint& pos) const
 
     bool success = false;
 
+    if (m_dbImpl)
+    {
+        wxRect itemRect;
+        GetItemRect(item, itemRect);
+        pos = itemRect.GetPosition();
+        success = true;
+    }
+
     return success;
 }
 
@@ -622,7 +1425,7 @@ int wxListCtrl::GetItemCount() const
 
     if (m_dbImpl)
         return m_dbImpl->MacGetCount();
-    
+
     return m_count;
 }
 
@@ -642,10 +1445,12 @@ wxSize wxListCtrl::GetItemSpacing() const
 
 void wxListCtrl::SetItemTextColour( long item, const wxColour &col )
 {
-    if (m_genericImpl){
+    if (m_genericImpl)
+    {
         m_genericImpl->SetItemTextColour(item, col);
+        return;
     }
-    
+
     wxListItem info;
     info.m_itemId = item;
     info.SetTextColour( col );
@@ -656,8 +1461,9 @@ wxColour wxListCtrl::GetItemTextColour( long item ) const
 {
     if (m_genericImpl)
         return m_genericImpl->GetItemTextColour(item);
-        
-    if (m_dbImpl){
+
+    if (m_dbImpl)
+    {
         wxListItem info;
         if (GetItem(info))
             return info.GetTextColour();
@@ -667,11 +1473,12 @@ wxColour wxListCtrl::GetItemTextColour( long item ) const
 
 void wxListCtrl::SetItemBackgroundColour( long item, const wxColour &col )
 {
-    if (m_genericImpl){
+    if (m_genericImpl)
+    {
         m_genericImpl->SetItemBackgroundColour(item, col);
         return;
     }
-    
+
     wxListItem info;
     info.m_itemId = item;
     info.SetBackgroundColour( col );
@@ -682,8 +1489,9 @@ wxColour wxListCtrl::GetItemBackgroundColour( long item ) const
 {
     if (m_genericImpl)
         return m_genericImpl->GetItemBackgroundColour(item);
-        
-    if (m_dbImpl){
+
+    if (m_dbImpl)
+    {
         wxListItem info;
         if (GetItem(info))
             return info.GetBackgroundColour();
@@ -693,7 +1501,8 @@ wxColour wxListCtrl::GetItemBackgroundColour( long item ) const
 
 void wxListCtrl::SetItemFont( long item, const wxFont &f )
 {
-    if (m_genericImpl){
+    if (m_genericImpl)
+    {
         m_genericImpl->SetItemFont(item, f);
         return;
     }
@@ -708,8 +1517,9 @@ wxFont wxListCtrl::GetItemFont( long item ) const
 {
     if (m_genericImpl)
         return m_genericImpl->GetItemFont(item);
-        
-    if (m_dbImpl){
+
+    if (m_dbImpl)
+    {
         wxListItem info;
         if (GetItem(info))
             return info.GetFont();
@@ -738,19 +1548,22 @@ wxColour wxListCtrl::GetTextColour() const
 
     // TODO: we need owner drawn list items to customize text color.
     if (m_dbImpl)
-        return *wxBLACK;
+        return m_textColor;
+
+    return wxNullColour;
 }
 
 // Sets the text colour of the listview
 void wxListCtrl::SetTextColour(const wxColour& col)
 {
-    if (m_genericImpl){
+    if (m_genericImpl)
+    {
         m_genericImpl->SetTextColour(col);
         return;
     }
-    
-    // TODO: if we add owner-drawn item support for DataBrowser,
-    // consider supporting this property
+
+    if (m_dbImpl)
+        m_textColor = col;
 }
 
 // Gets the index of the topmost visible item when in
@@ -759,7 +1572,15 @@ long wxListCtrl::GetTopItem() const
 {
     if (m_genericImpl)
         return m_genericImpl->GetTopItem();
-        
+
+    if (m_dbImpl)
+    {
+        int flags = 0;
+        long item = HitTest( wxPoint(1, 1), flags);
+        if (flags == wxLIST_HITTEST_ONITEM)
+            return item;
+    }
+
     return 0;
 }
 
@@ -776,7 +1597,48 @@ long wxListCtrl::GetNextItem(long item, int geom, int state) const
     if (m_genericImpl)
         return m_genericImpl->GetNextItem(item, geom, state);
 
-    return 0;
+    // TODO: implement all geometry and state options?
+    if ( m_dbImpl )
+    {
+        if ( geom == wxLIST_NEXT_ALL || geom == wxLIST_NEXT_BELOW )
+        {
+            long count = m_dbImpl->MacGetCount() ;
+            for ( long line = item + 1 ; line < count; line++ )
+            {
+                DataBrowserItemID id = line + 1;
+                if ( !IsVirtual() )
+                    id = (DataBrowserItemID)m_dbImpl->GetItemFromLine(line);
+
+                if ( (state == wxLIST_STATE_DONTCARE ) )
+                    return line;
+
+                if ( (state & wxLIST_STATE_SELECTED) && IsDataBrowserItemSelected(m_dbImpl->GetControlRef(), id ) )
+                    return line;
+            }
+        }
+
+        if ( geom == wxLIST_NEXT_ABOVE )
+        {
+            int item2 = item;
+            if ( item2 == -1 )
+                item2 = m_dbImpl->MacGetCount();
+
+            for ( long line = item2 - 1 ; line >= 0; line-- )
+            {
+                DataBrowserItemID id = line + 1;
+                if ( !IsVirtual() )
+                    id = (DataBrowserItemID)m_dbImpl->GetItemFromLine(line);
+
+                if ( (state == wxLIST_STATE_DONTCARE ) )
+                    return line;
+
+                if ( (state & wxLIST_STATE_SELECTED) && IsDataBrowserItemSelected(m_dbImpl->GetControlRef(), id ) )
+                    return line;
+            }
+        }
+    }
+
+    return -1;
 }
 
 
@@ -802,12 +1664,12 @@ wxImageList *wxListCtrl::GetImageList(int which) const
 
 void wxListCtrl::SetImageList(wxImageList *imageList, int which)
 {
-    if (m_genericImpl){
+    if (m_genericImpl)
+    {
         m_genericImpl->SetImageList(imageList, which);
         return;
     }
 
-    int flags = 0;
     if ( which == wxIMAGE_LIST_NORMAL )
     {
         if (m_ownsImageListNormal) delete m_imageListNormal;
@@ -830,7 +1692,8 @@ void wxListCtrl::SetImageList(wxImageList *imageList, int which)
 
 void wxListCtrl::AssignImageList(wxImageList *imageList, int which)
 {
-    if (m_genericImpl){
+    if (m_genericImpl)
+    {
         m_genericImpl->AssignImageList(imageList, which);
         return;
     }
@@ -861,14 +1724,15 @@ bool wxListCtrl::DeleteItem(long item)
 {
     if (m_genericImpl)
         return m_genericImpl->DeleteItem(item);
-        
-    if (m_dbImpl){
+
+    if (m_dbImpl)
+    {
         m_dbImpl->MacDelete(item);
         wxListEvent event( wxEVT_COMMAND_LIST_DELETE_ITEM, GetId() );
         event.SetEventObject( this );
         event.m_itemIndex = item;
-        GetEventHandler()->ProcessEvent( event );   
-    
+        GetEventHandler()->ProcessEvent( event );
+
     }
     return true;
 }
@@ -878,12 +1742,13 @@ bool wxListCtrl::DeleteAllItems()
 {
     if (m_genericImpl)
         return m_genericImpl->DeleteAllItems();
-        
-    if (m_dbImpl){
+
+    if (m_dbImpl)
+    {
         m_dbImpl->MacClear();
         wxListEvent event( wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS, GetId() );
         event.SetEventObject( this );
-        GetEventHandler()->ProcessEvent( event );   
+        GetEventHandler()->ProcessEvent( event );
     }
     return true;
 }
@@ -893,15 +1758,17 @@ bool wxListCtrl::DeleteAllColumns()
 {
     if (m_genericImpl)
         return m_genericImpl->DeleteAllColumns();
-        
-    if (m_dbImpl){
+
+    if (m_dbImpl)
+    {
         UInt32 cols;
         m_dbImpl->GetColumnCount(&cols);
-        for (UInt32 col = 0; col < cols; col++){
-                DeleteColumn(col);
-        } 
+        for (UInt32 col = 0; col < cols; col++)
+        {
+                DeleteColumn(0);
+        }
     }
-        
+
     return true;
 }
 
@@ -910,33 +1777,61 @@ bool wxListCtrl::DeleteColumn(int col)
 {
     if (m_genericImpl)
         return m_genericImpl->DeleteColumn(col);
-        
-    if (m_dbImpl){
+
+    if (m_dbImpl)
+    {
         OSStatus err = m_dbImpl->RemoveColumn(col);
         return err == noErr;
     }
-    
+
     return true;
 }
 
 // Clears items, and columns if there are any.
 void wxListCtrl::ClearAll()
 {
-    if (m_genericImpl){
+    if (m_genericImpl)
+    {
         m_genericImpl->ClearAll();
         return;
     }
-    
-    DeleteAllItems();
-    if ( m_colCount > 0 )
+
+    if (m_dbImpl)
+    {
+        DeleteAllItems();
         DeleteAllColumns();
+    }
 }
 
 wxTextCtrl* wxListCtrl::EditLabel(long item, wxClassInfo* textControlClass)
 {
     if (m_genericImpl)
         return m_genericImpl->EditLabel(item, textControlClass);
-        
+
+    if (m_dbImpl)
+    {
+        wxCHECK_MSG( (item >= 0) && ((long)item < GetItemCount()), NULL,
+                     wxT("wrong index in wxListCtrl::EditLabel()") );
+
+        wxASSERT_MSG( textControlClass->IsKindOf(CLASSINFO(wxTextCtrl)),
+                     wxT("EditLabel() needs a text control") );
+
+        wxListEvent le( wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT, GetParent()->GetId() );
+        le.SetEventObject( this );
+        le.m_itemIndex = item;
+        le.m_col = 0;
+        GetItem( le.m_item );
+
+        if ( GetParent()->GetEventHandler()->ProcessEvent( le ) && !le.IsAllowed() )
+        {
+            // vetoed by user code
+            return NULL;
+        }
+
+        wxTextCtrl * const text = (wxTextCtrl *)textControlClass->CreateObject();
+        m_textctrlWrapper = new wxListCtrlTextCtrlWrapper(this, text, item);
+        return m_textctrlWrapper->GetText();
+    }
     return NULL;
 }
 
@@ -945,10 +1840,11 @@ bool wxListCtrl::EndEditLabel(bool cancel)
 {
     // TODO: generic impl. doesn't have this method - is it needed for us?
     if (m_genericImpl)
-        return false; // m_genericImpl->EndEditLabel(cancel);
-        
-    bool b = true;
-    return b;
+        return true; // m_genericImpl->EndEditLabel(cancel);
+
+    if (m_dbImpl)
+        verify_noerr( SetDataBrowserEditItem(m_dbImpl->GetControlRef(), kDataBrowserNoItem, kMinColumnId) );
+    return true;
 }
 
 // Ensures this item is visible
@@ -956,11 +1852,14 @@ bool wxListCtrl::EnsureVisible(long item)
 {
     if (m_genericImpl)
         return m_genericImpl->EnsureVisible(item);
-        
-    if (m_dbImpl){
+
+    if (m_dbImpl)
+    {
         wxMacDataItem* dataItem = m_dbImpl->GetItemFromLine(item);
         m_dbImpl->RevealItem(dataItem, kDataBrowserRevealWithoutSelecting);
     }
+
+    return true;
 }
 
 // Find an item whose label matches this string, starting from the item after 'start'
@@ -970,7 +1869,31 @@ long wxListCtrl::FindItem(long start, const wxString& str, bool partial)
     if (m_genericImpl)
         return m_genericImpl->FindItem(start, str, partial);
 
-    return -1;
+    wxString str_upper = str.Upper();
+
+    long idx = start;
+    if (idx < 0)
+        idx = 0;
+    long count = GetItemCount();
+
+    while (idx < count)
+    {
+        wxString line_upper = GetItemText(idx).Upper();
+        if (!partial)
+        {
+            if (line_upper == str_upper )
+                return idx;
+        }
+        else
+        {
+            if (line_upper.find(str_upper) == 0)
+                return idx;
+        }
+
+        idx++;
+    };
+
+    return wxNOT_FOUND;
 }
 
 // Find an item whose data matches this data, starting from the item after 'start'
@@ -979,8 +1902,10 @@ long wxListCtrl::FindItem(long start, long data)
 {
     if (m_genericImpl)
         return m_genericImpl->FindItem(start, data);
-        
-    long  idx = start + 1;
+
+    long idx = start;
+    if (idx < 0)
+        idx = 0;
     long count = GetItemCount();
 
     while (idx < count)
@@ -990,7 +1915,7 @@ long wxListCtrl::FindItem(long start, long data)
         idx++;
     };
 
-    return -1;
+    return wxNOT_FOUND;
 }
 
 // Find an item nearest this position in the specified direction, starting from
@@ -1010,9 +1935,70 @@ wxListCtrl::HitTest(const wxPoint& point, int& flags, long *ptrSubItem) const
     if (m_genericImpl)
         return m_genericImpl->HitTest(point, flags, ptrSubItem);
 
-    return -1;
-}
+    flags = wxLIST_HITTEST_NOWHERE;
+    if (m_dbImpl)
+    {
+        int colHeaderHeight = 22; // TODO: Find a way to get this value from the db control?
+        UInt16 rowHeight = 0;
+        m_dbImpl->GetDefaultRowHeight(&rowHeight);
 
+        int y = point.y;
+        // get the actual row by taking scroll position into account
+        UInt32 offsetX, offsetY;
+        m_dbImpl->GetScrollPosition( &offsetY, &offsetX );
+        y += offsetY;
+
+        if ( !(GetWindowStyleFlag() & wxLC_NO_HEADER) )
+            y -= colHeaderHeight;
+
+        if ( y < 0 )
+            return -1;
+
+        int row = y / rowHeight;
+        DataBrowserItemID id;
+        m_dbImpl->GetItemID( (DataBrowserTableViewRowIndex) row, &id );
+
+        // TODO: Use GetDataBrowserItemPartBounds to return if we are in icon or label
+        if ( !(GetWindowStyleFlag() & wxLC_VIRTUAL ) )
+        {
+            wxMacListCtrlItem* lcItem;
+            lcItem = (wxMacListCtrlItem*) id;
+            if (lcItem)
+            {
+                flags = wxLIST_HITTEST_ONITEM;
+                return row;
+            }
+        }
+        else
+        {
+            if (row < GetItemCount() )
+            {
+                flags = wxLIST_HITTEST_ONITEM;
+                return row;
+            }
+        }
+
+    }
+    return -1;
+}
+
+int wxListCtrl::GetScrollPos(int orient) const
+{
+    if (m_genericImpl)
+        return m_genericImpl->GetScrollPos(orient);
+
+    if (m_dbImpl)
+    {
+        UInt32 offsetX, offsetY;
+        m_dbImpl->GetScrollPosition( &offsetY, &offsetX );
+        if ( orient == wxHORIZONTAL )
+           return offsetX;
+        else
+           return offsetY;
+    }
+
+    return 0;
+}
 
 // Inserts an item, returning the index of the new item if successful,
 // -1 otherwise.
@@ -1022,21 +2008,23 @@ long wxListCtrl::InsertItem(wxListItem& info)
 
     if (m_genericImpl)
         return m_genericImpl->InsertItem(info);
-        
-    if (m_dbImpl){
+
+    if (m_dbImpl && !IsVirtual())
+    {
         int count = GetItemCount();
 
         if (info.m_itemId > count)
             info.m_itemId = count;
-    
+
         m_dbImpl->MacInsertItem(info.m_itemId, &info );
+
         wxListEvent event( wxEVT_COMMAND_LIST_INSERT_ITEM, GetId() );
         event.SetEventObject( this );
         event.m_itemIndex = info.m_itemId;
-        GetEventHandler()->ProcessEvent( event );   
+        GetEventHandler()->ProcessEvent( event );
+        return info.m_itemId;
     }
-
-    return info.m_itemId;
+    return -1;
 }
 
 long wxListCtrl::InsertItem(long index, const wxString& label)
@@ -1056,7 +2044,7 @@ long wxListCtrl::InsertItem(long index, int imageIndex)
 {
     if (m_genericImpl)
         return m_genericImpl->InsertItem(index, imageIndex);
-        
+
     wxListItem info;
     info.m_image = imageIndex;
     info.m_mask = wxLIST_MASK_IMAGE;
@@ -1069,7 +2057,7 @@ long wxListCtrl::InsertItem(long index, const wxString& label, int imageIndex)
 {
     if (m_genericImpl)
         return m_genericImpl->InsertItem(index, label, imageIndex);
-        
+
     wxListItem info;
     info.m_image = imageIndex;
     info.m_text = label;
@@ -1083,22 +2071,25 @@ long wxListCtrl::InsertColumn(long col, wxListItem& item)
 {
     if (m_genericImpl)
         return m_genericImpl->InsertColumn(col, item);
-    
-    if (m_dbImpl){
-        if ( !(item.GetMask() & wxLIST_MASK_WIDTH) ) 
-            item.SetWidth(150);
-        
-        DataBrowserPropertyType type = kDataBrowserTextType;
+
+    if (m_dbImpl)
+    {
+        int width = item.GetWidth();
+        if ( !(item.GetMask() & wxLIST_MASK_WIDTH) )
+            width = 150;
+
+        DataBrowserPropertyType type = kDataBrowserCustomType; //kDataBrowserTextType;
         wxImageList* imageList = GetImageList(wxIMAGE_LIST_SMALL);
-        if (imageList && imageList->GetImageCount() > 0){
+        if (imageList && imageList->GetImageCount() > 0)
+        {
             wxBitmap bmp = imageList->GetBitmap(0);
-            if (bmp.Ok())
-                type = kDataBrowserIconAndTextType;
+            //if (bmp.Ok())
+            //    type = kDataBrowserIconAndTextType;
         }
-        
-        fprintf(stderr, "Flush is %d\n", item.GetAlign());
+
         SInt16 just = teFlushDefault;
-        if (item.GetMask() & wxLIST_MASK_FORMAT){
+        if (item.GetMask() & wxLIST_MASK_FORMAT)
+        {
             if (item.GetAlign() == wxLIST_FORMAT_LEFT)
                 just = teFlushLeft;
             else if (item.GetAlign() == wxLIST_FORMAT_CENTER)
@@ -1106,19 +2097,23 @@ long wxListCtrl::InsertColumn(long col, wxListItem& item)
             else if (item.GetAlign() == wxLIST_FORMAT_RIGHT)
                 just = teFlushRight;
         }
-        m_dbImpl->InsertColumn(col, type, item.GetText(), just, item.GetWidth());
-        
+        m_dbImpl->InsertColumn(col, type, item.GetText(), just, width);
+        SetColumn(col, item);
+
+        // set/remove options based on the wxListCtrl type.
+        DataBrowserTableViewColumnID id;
+        m_dbImpl->GetColumnIDFromIndex(col, &id);
+        DataBrowserPropertyFlags flags;
+        verify_noerr(m_dbImpl->GetPropertyFlags(id, &flags));
         if (GetWindowStyleFlag() & wxLC_EDIT_LABELS)
-        {
-            DataBrowserTableViewColumnID id;
-            m_dbImpl->GetColumnIDFromIndex(col, &id);
-            DataBrowserPropertyFlags flags;
-            verify_noerr(m_dbImpl->GetPropertyFlags(id, &flags));
             flags |= kDataBrowserPropertyIsEditable;
-            verify_noerr(m_dbImpl->SetPropertyFlags(id, flags));
+
+        if (GetWindowStyleFlag() & wxLC_VIRTUAL){
+            flags &= ~kDataBrowserListViewSortableColumn;
         }
+        verify_noerr(m_dbImpl->SetPropertyFlags(id, flags));
     }
-    
+
     return col;
 }
 
@@ -1149,8 +2144,9 @@ bool wxListCtrl::ScrollList(int dx, int dy)
 {
     if (m_genericImpl)
         return m_genericImpl->ScrollList(dx, dy);
-        
-    if (m_dbImpl){
+
+    if (m_dbImpl)
+    {
         m_dbImpl->SetScrollPosition(dx, dy);
     }
     return true;
@@ -1161,10 +2157,55 @@ bool wxListCtrl::SortItems(wxListCtrlCompare fn, long data)
 {
     if (m_genericImpl)
         return m_genericImpl->SortItems(fn, data);
-        
+
+    if (m_dbImpl)
+    {
+        m_compareFunc = fn;
+        m_compareFuncData = data;
+        SortDataBrowserContainer( m_dbImpl->GetControlRef(), kDataBrowserNoItem, true);
+
+        // we need to do this after each call, else we get a crash from wxPython when
+        // SortItems is called the second time.
+        m_compareFunc = NULL;
+        m_compareFuncData = 0;
+    }
+
     return true;
 }
 
+void wxListCtrl::OnRenameTimer()
+{
+    wxCHECK_RET( HasCurrent(), wxT("unexpected rename timer") );
+
+    EditLabel( m_current );
+}
+
+bool wxListCtrl::OnRenameAccept(long itemEdit, const wxString& value)
+{
+    wxListEvent le( wxEVT_COMMAND_LIST_END_LABEL_EDIT, GetId() );
+    le.SetEventObject( this );
+    le.m_itemIndex = itemEdit;
+
+    GetItem( le.m_item );
+    le.m_item.m_text = value;
+    return !GetEventHandler()->ProcessEvent( le ) ||
+                le.IsAllowed();
+}
+
+void wxListCtrl::OnRenameCancelled(long itemEdit)
+{
+    // let owner know that the edit was cancelled
+    wxListEvent le( wxEVT_COMMAND_LIST_END_LABEL_EDIT, GetParent()->GetId() );
+
+    le.SetEditCanceled(true);
+
+    le.SetEventObject( this );
+    le.m_itemIndex = itemEdit;
+
+    GetItem( le.m_item );
+    GetEventHandler()->ProcessEvent( le );
+}
+
 // ----------------------------------------------------------------------------
 // virtual list controls
 // ----------------------------------------------------------------------------
@@ -1207,21 +2248,43 @@ void wxListCtrl::SetItemCount(long count)
 {
     wxASSERT_MSG( IsVirtual(), _T("this is for virtual controls only") );
 
-    if (m_genericImpl){
+    if (m_genericImpl)
+    {
         m_genericImpl->SetItemCount(count);
         return;
     }
-    
+
+    if (m_dbImpl)
+    {
+        // we need to temporarily disable the new item creation notification
+        // procedure to speed things up
+        // FIXME: Even this doesn't seem to help much...
+
+        // FIXME: Find a more efficient way to do this.
+        m_dbImpl->MacClear();
+
+        DataBrowserCallbacks callbacks;
+        DataBrowserItemNotificationUPP itemUPP;
+        GetDataBrowserCallbacks(m_dbImpl->GetControlRef(), &callbacks);
+        itemUPP = callbacks.u.v1.itemNotificationCallback;
+        callbacks.u.v1.itemNotificationCallback = 0;
+        m_dbImpl->SetCallbacks(&callbacks);
+        ::AddDataBrowserItems(m_dbImpl->GetControlRef(), kDataBrowserNoItem,
+            count, NULL, kDataBrowserItemNoProperty);
+        callbacks.u.v1.itemNotificationCallback = itemUPP;
+        m_dbImpl->SetCallbacks(&callbacks);
+    }
     m_count = count;
 }
 
 void wxListCtrl::RefreshItem(long item)
 {
-    if (m_genericImpl){
+    if (m_genericImpl)
+    {
         m_genericImpl->RefreshItem(item);
         return;
     }
-    
+
     wxRect rect;
     GetItemRect(item, rect);
     RefreshRect(rect);
@@ -1229,7 +2292,8 @@ void wxListCtrl::RefreshItem(long item)
 
 void wxListCtrl::RefreshItems(long itemFrom, long itemTo)
 {
-    if (m_genericImpl){
+    if (m_genericImpl)
+    {
         m_genericImpl->RefreshItems(itemFrom, itemTo);
         return;
     }
@@ -1244,8 +2308,43 @@ void wxListCtrl::RefreshItems(long itemFrom, long itemTo)
     RefreshRect(rect);
 }
 
+void wxListCtrl::SetDropTarget( wxDropTarget *dropTarget )
+{
+#if wxUSE_DRAG_AND_DROP
+    if (m_genericImpl)
+        m_genericImpl->SetDropTarget( dropTarget );
+
+    if (m_dbImpl)
+        wxWindow::SetDropTarget( dropTarget );
+#endif
+}
+
+wxDropTarget *wxListCtrl::GetDropTarget() const
+{
+#if wxUSE_DRAG_AND_DROP
+    if (m_genericImpl)
+        return m_genericImpl->GetDropTarget();
 
-// wxMac internal data structures 
+    if (m_dbImpl)
+        return wxWindow::GetDropTarget();
+#endif
+    return NULL;
+}
+
+#if wxABI_VERSION >= 20801
+void wxListCtrl::SetFocus()
+{
+        if (m_genericImpl)
+        {
+                m_genericImpl->SetFocus();
+                return;
+        }
+
+        wxWindow::SetFocus();
+}
+#endif
+
+// wxMac internal data structures
 
 wxMacListCtrlItem::~wxMacListCtrlItem()
 {
@@ -1256,7 +2355,7 @@ void wxMacListCtrlItem::Notification(wxMacDataItemBrowserControl *owner ,
     DataBrowserItemDataRef itemData ) const
 {
 
-    wxMacDataBrowserListCtrlControl *lb = dynamic_cast<wxMacDataBrowserListCtrlControl*>(owner);
+    wxMacDataBrowserListCtrlControl *lb = wxDynamicCast(owner, wxMacDataBrowserListCtrlControl);
 
     // we want to depend on as little as possible to make sure tear-down of controls is safe
     if ( message == kDataBrowserItemRemoved)
@@ -1277,18 +2376,18 @@ void wxMacListCtrlItem::Notification(wxMacDataItemBrowserControl *owner ,
     }
 
     wxListCtrl *list = wxDynamicCast( owner->GetPeer() , wxListCtrl );
-    if ( list ){
+    if ( list && lb )
+    {
         bool trigger = false;
-            
+
         wxListEvent event( wxEVT_COMMAND_LIST_ITEM_SELECTED, list->GetId() );
-        bool isSingle = list->GetWindowStyle() | wxLC_SINGLE_SEL;
+        bool isSingle = (list->GetWindowStyle() & wxLC_SINGLE_SEL) != 0;
+
         event.SetEventObject( list );
         event.m_itemIndex = owner->GetLineFromItem( this ) ;
-        if ( !list->IsVirtual() )
-        {
-            lb->MacGetColumnInfo(event.m_itemIndex,0,event.m_item);
-        }
-        
+        event.m_item.m_itemId = event.m_itemIndex;
+        list->GetItem(event.m_item);
+
         switch (message)
         {
             case kDataBrowserItemDeselected:
@@ -1302,7 +2401,7 @@ void wxMacListCtrlItem::Notification(wxMacDataItemBrowserControl *owner ,
                 break;
 
             case kDataBrowserItemDoubleClicked:
-                event.SetEventType( wxEVT_LEFT_DCLICK );
+                event.SetEventType( wxEVT_COMMAND_LIST_ITEM_ACTIVATED );
                 trigger = true;
                 break;
 
@@ -1311,7 +2410,7 @@ void wxMacListCtrlItem::Notification(wxMacDataItemBrowserControl *owner ,
                 event.SetEventType( wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT ) ;
                 trigger = true ;
                 break ;
-                
+
             case kDataBrowserEditStopped :
                 // TODO probably trigger only upon the value store callback, because
                 // here IIRC we cannot veto
@@ -1332,11 +2431,18 @@ void wxMacListCtrlItem::Notification(wxMacDataItemBrowserControl *owner ,
 
 }
 
+IMPLEMENT_DYNAMIC_CLASS(wxMacDataBrowserListCtrlControl, wxMacDataItemBrowserControl )
+
 wxMacDataBrowserListCtrlControl::wxMacDataBrowserListCtrlControl( wxWindow *peer, const wxPoint& pos, const wxSize& size, long style)
     : wxMacDataItemBrowserControl( peer, pos, size, style )
 {
     OSStatus err = noErr;
     m_clientDataItemsType = wxClientData_None;
+    m_isVirtual = false;
+    m_flags = 0;
+
+    if ( style & wxLC_VIRTUAL )
+        m_isVirtual = true;
 
     DataBrowserSelectionFlags  options = kDataBrowserDragSelect;
     if ( style & wxLC_SINGLE_SEL )
@@ -1345,41 +2451,614 @@ wxMacDataBrowserListCtrlControl::wxMacDataBrowserListCtrlControl( wxWindow *peer
     }
     else
     {
-        options |= kDataBrowserAlwaysExtendSelection | kDataBrowserCmdTogglesSelection;
+        options |= kDataBrowserCmdTogglesSelection;
     }
 
     err = SetSelectionFlags( options );
     verify_noerr( err );
 
-    if ( style & wxLC_LIST ){
+    DataBrowserCustomCallbacks callbacks;
+    InitializeDataBrowserCustomCallbacks( &callbacks, kDataBrowserLatestCustomCallbacks );
+
+    if ( gDataBrowserDrawItemUPP == NULL )
+        gDataBrowserDrawItemUPP = NewDataBrowserDrawItemUPP(DataBrowserDrawItemProc);
+
+    if ( gDataBrowserHitTestUPP == NULL )
+        gDataBrowserHitTestUPP = NewDataBrowserHitTestUPP(DataBrowserHitTestProc);
+
+    callbacks.u.v1.drawItemCallback = gDataBrowserDrawItemUPP;
+    callbacks.u.v1.hitTestCallback = gDataBrowserHitTestUPP;
+
+    SetDataBrowserCustomCallbacks( GetControlRef(), &callbacks );
+
+    if ( style & wxLC_LIST )
+    {
         InsertColumn(0, kDataBrowserIconAndTextType, wxEmptyString, -1, -1);
         verify_noerr( AutoSizeColumns() );
+    }
+
+    if ( style & wxLC_LIST || style & wxLC_NO_HEADER )
         verify_noerr( SetHeaderButtonHeight( 0 ) );
+
+    if ( m_isVirtual )
+        SetSortProperty( kMinColumnId - 1 );
+    else
+        SetSortProperty( kMinColumnId );
+
+    m_sortOrder = SortOrder_None;
+
+    if ( style & wxLC_SORT_DESCENDING )
+    {
+        SetSortOrder( kDataBrowserOrderDecreasing );
+    }
+    else if ( style & wxLC_SORT_ASCENDING )
+    {
+        SetSortOrder( kDataBrowserOrderIncreasing );
+    }
+
+    if ( style & wxLC_VRULES )
+    {
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
+        verify_noerr( DataBrowserChangeAttributes(m_controlRef, kDataBrowserAttributeListViewDrawColumnDividers, kDataBrowserAttributeNone) );
+#endif
+    }
+
+    verify_noerr( SetHiliteStyle(kDataBrowserTableViewFillHilite ) );
+    verify_noerr( SetHasScrollBars( (style & wxHSCROLL) != 0 , true ) );
+}
+
+pascal Boolean wxMacDataBrowserListCtrlControl::DataBrowserEditTextProc(
+        ControlRef browser,
+        DataBrowserItemID itemID,
+        DataBrowserPropertyID property,
+        CFStringRef theString,
+        Rect *maxEditTextRect,
+        Boolean *shrinkToFit)
+{
+    Boolean result = false;
+    wxMacDataBrowserListCtrlControl* ctl = wxDynamicCast(wxMacControl::GetReferenceFromNativeControl( browser ), wxMacDataBrowserListCtrlControl);
+    if ( ctl != 0 )
+    {
+        result = ctl->ConfirmEditText(itemID, property, theString, maxEditTextRect, shrinkToFit);
+        theString = CFSTR("Hello!");
+    }
+    return result;
+}
+
+bool wxMacDataBrowserListCtrlControl::ConfirmEditText(
+        DataBrowserItemID itemID,
+        DataBrowserPropertyID property,
+        CFStringRef theString,
+        Rect *maxEditTextRect,
+        Boolean *shrinkToFit)
+{
+    return false;
+}
+
+pascal void wxMacDataBrowserListCtrlControl::DataBrowserDrawItemProc(
+        ControlRef browser,
+        DataBrowserItemID itemID,
+        DataBrowserPropertyID property,
+        DataBrowserItemState itemState,
+        const Rect *itemRect,
+        SInt16 gdDepth,
+        Boolean colorDevice)
+{
+    wxMacDataBrowserListCtrlControl* ctl = wxDynamicCast(wxMacControl::GetReferenceFromNativeControl( browser ), wxMacDataBrowserListCtrlControl);
+    if ( ctl != 0 )
+    {
+        ctl->DrawItem(itemID, property, itemState, itemRect, gdDepth, colorDevice);
+    }
+}
+
+// routines needed for DrawItem
+enum
+{
+  kIconWidth = 16,
+  kIconHeight = 16,
+  kTextBoxHeight = 14,
+  kIconTextSpacingV = 2,
+  kItemPadding = 4,
+  kContentHeight = kIconHeight + kTextBoxHeight + kIconTextSpacingV
+};
+
+static void calculateCGDrawingBounds(CGRect inItemRect, CGRect *outIconRect, CGRect *outTextRect, bool hasIcon = false)
+{
+  float textBottom;
+  float iconH, iconW = 0;
+  float padding = kItemPadding;
+  if (hasIcon)
+  {
+    iconH = kIconHeight;
+    iconW = kIconWidth;
+    padding = padding*2;
+  }
+
+  textBottom = inItemRect.origin.y;
+
+  *outIconRect = CGRectMake(inItemRect.origin.x + kItemPadding,
+                textBottom + kIconTextSpacingV, kIconWidth,
+                kIconHeight);
+
+  *outTextRect = CGRectMake(inItemRect.origin.x + padding + iconW,
+                textBottom + kIconTextSpacingV, inItemRect.size.width - padding - iconW,
+                inItemRect.size.height - kIconTextSpacingV);
+}
+
+void wxMacDataBrowserListCtrlControl::DrawItem(
+        DataBrowserItemID itemID,
+        DataBrowserPropertyID property,
+        DataBrowserItemState itemState,
+        const Rect *itemRect,
+        SInt16 gdDepth,
+        Boolean colorDevice)
+{
+    wxString text;
+    wxFont font = wxNullFont;
+    int imgIndex = -1;
+    short listColumn = property - kMinColumnId;
+
+    wxListCtrl* list = wxDynamicCast( GetPeer() , wxListCtrl );
+    wxMacListCtrlItem* lcItem;
+    wxColour color = *wxBLACK;
+    wxColour bgColor = wxNullColour;
+
+    if (listColumn >= 0)
+    {
+        if (!m_isVirtual)
+        {
+            lcItem = (wxMacListCtrlItem*) itemID;
+            if (lcItem->HasColumnInfo(listColumn)){
+                wxListItem* item = lcItem->GetColumnInfo(listColumn);
+
+                // we always use the 0 column to get font and text/background colors.
+                if (lcItem->HasColumnInfo(0))
+                {
+                    wxListItem* firstItem = lcItem->GetColumnInfo(0);
+                    color = firstItem->GetTextColour();
+                    bgColor = firstItem->GetBackgroundColour();
+                    font = firstItem->GetFont();
+                }
+
+                if (item->GetMask() & wxLIST_MASK_TEXT)
+                    text = item->GetText();
+                if (item->GetMask() & wxLIST_MASK_IMAGE)
+                    imgIndex = item->GetImage();
+            }
+
+        }
+        else
+        {
+            long itemNum = (long)itemID-1;
+            if (itemNum >= 0 && itemNum < list->GetItemCount())
+            {
+                text = list->OnGetItemText( itemNum, listColumn );
+                imgIndex = list->OnGetItemColumnImage( itemNum, listColumn );
+                wxListItemAttr* attrs = list->OnGetItemAttr( itemNum );
+                if (attrs)
+                {
+                    if (attrs->HasBackgroundColour())
+                        bgColor = attrs->GetBackgroundColour();
+                    if (attrs->HasTextColour())
+                        color = attrs->GetTextColour();
+                    if (attrs->HasFont())
+                        font = attrs->GetFont();
+                }
+            }
+        }
     }
 
-    SetDataBrowserSortProperty( m_controlRef , kMinColumnId );
-    if ( style & wxLC_SORT_ASCENDING )
+    wxColour listBgColor = list->GetBackgroundColour();
+    if (bgColor == wxNullColour)
+        bgColor = listBgColor;
+
+    wxFont listFont = list->GetFont();
+    if (font == wxNullFont)
+        font = listFont;
+
+    wxMacCFStringHolder cfString;
+    cfString.Assign( text, wxLocale::GetSystemEncoding() );
+
+    Rect enclosingRect;
+    CGRect enclosingCGRect, iconCGRect, textCGRect;
+    Boolean active;
+    ThemeDrawingState savedState = NULL;
+    CGContextRef context = (CGContextRef)list->MacGetDrawingContext();
+    RGBColor labelColor;
+    labelColor.red = 0;
+    labelColor.green = 0;
+    labelColor.blue = 0;
+
+    RGBColor backgroundColor;
+    backgroundColor.red = 255;
+    backgroundColor.green = 255;
+    backgroundColor.blue = 255;
+
+    GetDataBrowserItemPartBounds(GetControlRef(), itemID, property, kDataBrowserPropertyEnclosingPart,
+              &enclosingRect);
+
+    enclosingCGRect = CGRectMake(enclosingRect.left,
+                      enclosingRect.top,
+                      enclosingRect.right - enclosingRect.left,
+                      enclosingRect.bottom - enclosingRect.top);
+
+    bool hasFocus = (wxWindow::FindFocus() == list);
+    active = IsControlActive(GetControlRef());
+
+    // don't paint the background over the vertical rule line
+    if ( list->GetWindowStyleFlag() & wxLC_VRULES )
     {
-        m_sortOrder = SortOrder_Text_Ascending;
-        SetDataBrowserSortProperty( m_controlRef , kMinColumnId );
-        SetDataBrowserSortOrder( m_controlRef , kDataBrowserOrderIncreasing);
+        enclosingCGRect.origin.x += 1;
+        enclosingCGRect.size.width -= 1;
     }
-    else if ( style & wxLC_SORT_DESCENDING )
+    if (itemState == kDataBrowserItemIsSelected)
     {
-        m_sortOrder = SortOrder_Text_Descending;
-        SetDataBrowserSortProperty( m_controlRef , kMinColumnId );
-        SetDataBrowserSortOrder( m_controlRef , kDataBrowserOrderDecreasing);
+
+        GetThemeDrawingState(&savedState);
+
+        if (active && hasFocus)
+        {
+            GetThemeBrushAsColor(kThemeBrushAlternatePrimaryHighlightColor, 32, true, &backgroundColor);
+            GetThemeTextColor(kThemeTextColorWhite, gdDepth, colorDevice, &labelColor);
+        }
+        else
+        {
+            GetThemeBrushAsColor(kThemeBrushSecondaryHighlightColor, 32, true, &backgroundColor);
+            GetThemeTextColor(kThemeTextColorBlack, gdDepth, colorDevice, &labelColor);
+        }
+        CGContextSaveGState(context);
+
+        CGContextSetRGBFillColor(context, (float)backgroundColor.red / (float)USHRT_MAX,
+                      (float)backgroundColor.green / (float)USHRT_MAX,
+                      (float)backgroundColor.blue / (float)USHRT_MAX, 1.0);
+        CGContextFillRect(context, enclosingCGRect);
+
+        CGContextRestoreGState(context);
     }
     else
     {
-        m_sortOrder = SortOrder_None;
-        SetDataBrowserSortProperty( m_controlRef , kMinColumnId);
-        SetDataBrowserSortOrder( m_controlRef , kDataBrowserOrderIncreasing);
+
+        if (color.Ok())
+            labelColor = MAC_WXCOLORREF( color.GetPixel() );
+        else if (list->GetTextColour().Ok())
+            labelColor = MAC_WXCOLORREF( list->GetTextColour().GetPixel() );
+
+        if (bgColor.Ok())
+        {
+            backgroundColor = MAC_WXCOLORREF( bgColor.GetPixel() );
+            CGContextSaveGState(context);
+
+            CGContextSetRGBFillColor(context, (float)backgroundColor.red / (float)USHRT_MAX,
+                          (float)backgroundColor.green / (float)USHRT_MAX,
+                          (float)backgroundColor.blue / (float)USHRT_MAX, 1.0);
+            CGContextFillRect(context, enclosingCGRect);
+
+            CGContextRestoreGState(context);
+        }
     }
 
-    verify_noerr( AutoSizeColumns() );
-    verify_noerr( SetHiliteStyle(kDataBrowserTableViewFillHilite ) );
-    err = SetHasScrollBars( (style & wxHSCROLL) != 0 , true );
+    calculateCGDrawingBounds(enclosingCGRect, &iconCGRect, &textCGRect, (imgIndex != -1) );
+
+    if (imgIndex != -1)
+    {
+        wxImageList* imageList = list->GetImageList(wxIMAGE_LIST_SMALL);
+        if (imageList && imageList->GetImageCount() > 0){
+            wxBitmap bmp = imageList->GetBitmap(imgIndex);
+            IconRef icon = bmp.GetBitmapData()->GetIconRef();
+
+            CGContextSaveGState(context);
+            CGContextTranslateCTM(context, 0,iconCGRect.origin.y + CGRectGetMaxY(iconCGRect));
+            CGContextScaleCTM(context,1.0f,-1.0f);
+            PlotIconRefInContext(context, &iconCGRect, kAlignNone,
+              active ? kTransformNone : kTransformDisabled, NULL,
+              kPlotIconRefNormalFlags, icon);
+
+            CGContextRestoreGState(context);
+        }
+    }
+
+    HIThemeTextHorizontalFlush hFlush = kHIThemeTextHorizontalFlushLeft;
+    UInt16 fontID = kThemeViewsFont;
+
+    if (font.Ok())
+    {
+        if (font.GetFamily() != wxFONTFAMILY_DEFAULT)
+            fontID = font.MacGetThemeFontID();
+
+// FIXME: replace these with CG or ATSUI calls so we can remove this #ifndef.
+#ifndef __LP64__
+        ::TextSize( (short)(font.MacGetFontSize()) ) ;
+        ::TextFace( font.MacGetFontStyle() ) ;
+#endif
+    }
+
+    wxListItem item;
+    list->GetColumn(listColumn, item);
+    if (item.GetMask() & wxLIST_MASK_FORMAT)
+    {
+        if (item.GetAlign() == wxLIST_FORMAT_LEFT)
+            hFlush = kHIThemeTextHorizontalFlushLeft;
+        else if (item.GetAlign() == wxLIST_FORMAT_CENTER)
+            hFlush = kHIThemeTextHorizontalFlushCenter;
+        else if (item.GetAlign() == wxLIST_FORMAT_RIGHT)
+        {
+            hFlush = kHIThemeTextHorizontalFlushRight;
+            textCGRect.origin.x -= kItemPadding; // give a little extra paddding
+        }
+    }
+
+    HIThemeTextInfo info;
+    info.version = kHIThemeTextInfoVersionZero;
+    info.state = active ? kThemeStateActive : kThemeStateInactive;
+    info.fontID = fontID;
+    info.horizontalFlushness = hFlush;
+    info.verticalFlushness = kHIThemeTextVerticalFlushCenter;
+    info.options = kHIThemeTextBoxOptionNone;
+    info.truncationPosition = kHIThemeTextTruncationEnd;
+    info.truncationMaxLines = 1;
+
+    CGContextSaveGState(context);
+    CGContextSetRGBFillColor (context, (float)labelColor.red / (float)USHRT_MAX,
+                      (float)labelColor.green / (float)USHRT_MAX,
+                      (float)labelColor.blue / (float)USHRT_MAX, 1.0);
+
+    HIThemeDrawTextBox(cfString, &textCGRect, &info, context, kHIThemeOrientationNormal);
+
+    CGContextRestoreGState(context);
+
+    if (savedState != NULL)
+        SetThemeDrawingState(savedState, true);
+}
+
+OSStatus wxMacDataBrowserListCtrlControl::GetSetItemData(DataBrowserItemID itemID,
+                        DataBrowserPropertyID property,
+                        DataBrowserItemDataRef itemData,
+                        Boolean changeValue )
+{
+    wxString text;
+    int imgIndex = -1;
+    short listColumn = property - kMinColumnId;
+
+    OSStatus err = errDataBrowserPropertyNotSupported;
+    wxListCtrl* list = wxDynamicCast( GetPeer() , wxListCtrl );
+    wxMacListCtrlItem* lcItem;
+
+    if (listColumn >= 0)
+    {
+        if (!m_isVirtual)
+        {
+            lcItem = (wxMacListCtrlItem*) itemID;
+            if (lcItem && lcItem->HasColumnInfo(listColumn)){
+                wxListItem* item = lcItem->GetColumnInfo(listColumn);
+                if (item->GetMask() & wxLIST_MASK_TEXT)
+                    text = item->GetText();
+                if (item->GetMask() & wxLIST_MASK_IMAGE)
+                    imgIndex = item->GetImage();
+            }
+        }
+        else
+        {
+            long itemNum = (long)itemID-1;
+            if (itemNum >= 0 && itemNum < list->GetItemCount())
+            {
+                text = list->OnGetItemText( itemNum, listColumn );
+                imgIndex = list->OnGetItemColumnImage( itemNum, listColumn );
+            }
+        }
+    }
+
+    if ( !changeValue )
+    {
+        switch (property)
+        {
+            case kDataBrowserItemIsEditableProperty :
+                if ( list && list->HasFlag( wxLC_EDIT_LABELS ) )
+                {
+                    verify_noerr(SetDataBrowserItemDataBooleanValue( itemData, true ));
+                }
+                break ;
+            default :
+                if ( property >= kMinColumnId )
+                {
+                    wxMacCFStringHolder cfStr(text);
+                    verify_noerr( ::SetDataBrowserItemDataText( itemData, cfStr) );
+
+
+
+                    if ( imgIndex != -1 )
+                    {
+                        wxImageList* imageList = list->GetImageList(wxIMAGE_LIST_SMALL);
+                        if (imageList && imageList->GetImageCount() > 0){
+                            wxBitmap bmp = imageList->GetBitmap(imgIndex);
+                            IconRef icon = bmp.GetBitmapData()->GetIconRef();
+                            ::SetDataBrowserItemDataIcon(itemData, icon);
+                        }
+                    }
+
+                }
+                break ;
+        }
+
+    }
+    else
+    {
+        switch (property)
+        {
+             default:
+                if ( property >= kMinColumnId )
+                {
+                    short listColumn = property - kMinColumnId;
+
+                    // TODO probably send the 'end edit' from here, as we
+                    // can then deal with the veto
+                    CFStringRef sr ;
+                    verify_noerr( GetDataBrowserItemDataText( itemData , &sr ) ) ;
+                    wxMacCFStringHolder cfStr(sr) ;;
+                    if (m_isVirtual)
+                        list->SetItem( (long)itemData-1 , listColumn, cfStr.AsString() ) ;
+                    else
+                    {
+                        if (lcItem)
+                            lcItem->SetColumnTextValue( listColumn, cfStr.AsString() );
+                    }
+                    err = noErr ;
+                }
+                break;
+        }
+    }
+    return err;
+}
+
+void wxMacDataBrowserListCtrlControl::ItemNotification(DataBrowserItemID itemID,
+    DataBrowserItemNotification message,
+    DataBrowserItemDataRef itemData )
+{
+    // we want to depend on as little as possible to make sure tear-down of controls is safe
+    if ( message == kDataBrowserItemRemoved)
+    {
+        // make sure MacDelete does the proper teardown.
+        return;
+    }
+    else if ( message == kDataBrowserItemAdded )
+    {
+        // we don't issue events on adding, the item is not really stored in the list yet, so we
+        // avoid asserts by getting out now
+        return  ;
+    }
+
+    wxListCtrl *list = wxDynamicCast( GetPeer() , wxListCtrl );
+    if ( list )
+    {
+        bool trigger = false;
+
+        wxListEvent event( wxEVT_COMMAND_LIST_ITEM_SELECTED, list->GetId() );
+        bool isSingle = (list->GetWindowStyle() & wxLC_SINGLE_SEL) != 0;
+
+        event.SetEventObject( list );
+        if ( !list->IsVirtual() )
+        {
+            DataBrowserTableViewRowIndex result = 0;
+            verify_noerr( GetItemRow( itemID, &result ) ) ;
+            event.m_itemIndex = result;
+        }
+        else
+        {
+            event.m_itemIndex = (long)itemID-1;
+        }
+        event.m_item.m_itemId = event.m_itemIndex;
+        list->GetItem(event.m_item);
+
+        switch (message)
+        {
+            case kDataBrowserItemDeselected:
+                event.SetEventType(wxEVT_COMMAND_LIST_ITEM_DESELECTED);
+                if ( !isSingle )
+                    trigger = !IsSelectionSuppressed();
+                break;
+
+            case kDataBrowserItemSelected:
+                trigger = !IsSelectionSuppressed();
+
+                break;
+
+            case kDataBrowserItemDoubleClicked:
+                event.SetEventType( wxEVT_COMMAND_LIST_ITEM_ACTIVATED );
+                trigger = true;
+                break;
+
+            case kDataBrowserEditStarted :
+                // TODO : how to veto ?
+                event.SetEventType( wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT ) ;
+                trigger = true ;
+                break ;
+
+            case kDataBrowserEditStopped :
+                // TODO probably trigger only upon the value store callback, because
+                // here IIRC we cannot veto
+                event.SetEventType( wxEVT_COMMAND_LIST_END_LABEL_EDIT ) ;
+                trigger = true ;
+                break ;
+
+            default:
+                break;
+        }
+
+        if ( trigger )
+        {
+            // direct notification is not always having the listbox GetSelection() having in synch with event
+            wxPostEvent( list->GetEventHandler(), event );
+        }
+    }
+}
+
+Boolean wxMacDataBrowserListCtrlControl::CompareItems(DataBrowserItemID itemOneID,
+                        DataBrowserItemID itemTwoID,
+                        DataBrowserPropertyID sortProperty)
+{
+
+    bool retval = false;
+    wxString itemText;
+    wxString otherItemText;
+    long itemOrder;
+    long otherItemOrder;
+
+    int colId = sortProperty - kMinColumnId;
+
+    wxListCtrl* list = wxDynamicCast( GetPeer() , wxListCtrl );
+
+    DataBrowserSortOrder sort;
+    verify_noerr(GetSortOrder(&sort));
+
+    if (colId >= 0)
+    {
+        if (!m_isVirtual)
+        {
+            wxMacListCtrlItem* item = (wxMacListCtrlItem*)itemOneID;
+            wxMacListCtrlItem* otherItem = (wxMacListCtrlItem*)itemTwoID;
+
+            itemOrder = item->GetOrder();
+            otherItemOrder = item->GetOrder();
+
+            wxListCtrlCompare func = list->GetCompareFunc();
+            if (func != NULL)
+            {
+                long item1 = -1;
+                long item2 = -1;
+                if (item && item->HasColumnInfo(0))
+                    item1 = item->GetColumnInfo(0)->GetData();
+                if (otherItem && otherItem->HasColumnInfo(0))
+                    item2 = otherItem->GetColumnInfo(0)->GetData();
+
+                if (item1 > -1 && item2 > -1)
+                {
+                    int result = func(item1, item2, list->GetCompareFuncData());
+                    if (sort == kDataBrowserOrderIncreasing)
+                        return result >= 0;
+                    else
+                        return result < 0;
+                }
+            }
+
+            // we can't use the native control's sorting abilities, so just
+            // sort by item id.
+            return itemOrder < otherItemOrder;
+        }
+        else
+        {
+
+            long itemNum = (long)itemOneID;
+            long otherItemNum = (long)itemTwoID;
+
+            // virtual listctrls don't support sorting
+            return itemNum < otherItemNum;
+        }
+    }
+    else{
+        // fallback for undefined cases
+        retval = itemOneID < itemTwoID;
+    }
+
+    return retval;
 }
 
 wxMacDataBrowserListCtrlControl::~wxMacDataBrowserListCtrlControl()
@@ -1387,63 +3066,85 @@ wxMacDataBrowserListCtrlControl::~wxMacDataBrowserListCtrlControl()
 }
 
 void wxMacDataBrowserListCtrlControl::MacSetColumnInfo( unsigned int row, unsigned int column, wxListItem* item )
-{ 
+{
     wxMacDataItem* dataItem = GetItemFromLine(row);
-    if (item){
-        wxMacListCtrlItem* listItem = dynamic_cast<wxMacListCtrlItem*>(dataItem);
+    wxASSERT_MSG( dataItem, _T("could not obtain wxMacDataItem for row in MacSetColumnInfo. Is row a valid wxListCtrl row?") );
+    if (item)
+    {
+        wxMacListCtrlItem* listItem = wx_static_cast(wxMacListCtrlItem*,dataItem);
+        bool hasInfo = listItem->HasColumnInfo( column );
         listItem->SetColumnInfo( column, item );
+        listItem->SetOrder(row);
         UpdateState(dataItem, item);
+
+        wxListCtrl* list = wxDynamicCast( GetPeer() , wxListCtrl );
+
+        // NB: When this call was made before a control was completely shown, it would
+        // update the item prematurely (i.e. no text would be listed) and, on show,
+        // only the sorted column would be refreshed, meaning only first column text labels
+        // would be shown. Making sure not to update items until the control is visible
+        // seems to fix this issue.
+        if (hasInfo && list->IsShown())
+            UpdateItem( wxMacDataBrowserRootContainer, listItem , kMinColumnId + column );
     }
 }
 
-// apply changes that need to happen immediately, rather than when the 
+// apply changes that need to happen immediately, rather than when the
 // databrowser control fires a callback.
 void wxMacDataBrowserListCtrlControl::UpdateState(wxMacDataItem* dataItem, wxListItem* listItem)
 {
     bool isSelected = IsItemSelected( dataItem );
     bool isSelectedState = (listItem->GetState() == wxLIST_STATE_SELECTED);
 
-    // toggle the selection state if wxListInfo state and actual state don't match.    
-    if ( isSelected != isSelectedState ){
+    // toggle the selection state if wxListInfo state and actual state don't match.
+    if ( isSelected != isSelectedState )
+    {
         DataBrowserSetOption options = kDataBrowserItemsAdd;
         if (!isSelectedState)
             options = kDataBrowserItemsRemove;
-        fprintf(stderr, "state = %d, db options = %d\n", isSelectedState, options);
         SetSelectedItem(dataItem, options);
     }
     // TODO: Set column width if item width > than current column width
 }
 
 void wxMacDataBrowserListCtrlControl::MacGetColumnInfo( unsigned int row, unsigned int column, wxListItem& item )
-{ 
+{
     wxMacDataItem* dataItem = GetItemFromLine(row);
+    wxASSERT_MSG( dataItem, _T("could not obtain wxMacDataItem in MacGetColumnInfo. Is row a valid wxListCtrl row?") );
     // CS should this guard against dataItem = 0 ? , as item is not a pointer if (item) is not appropriate
-    //if (item) 
+    //if (item)
     {
-        wxMacListCtrlItem* listItem = dynamic_cast<wxMacListCtrlItem*>(dataItem);
-        wxListItem* oldItem = listItem->GetColumnInfo( column );
-        
-        long mask = item.GetMask();
-        if ( !mask )
-            // by default, get everything for backwards compatibility
-            mask = -1;
+        wxMacListCtrlItem* listItem =wx_static_cast(wxMacListCtrlItem*,dataItem);
+
+        if (!listItem->HasColumnInfo( column ))
+            return;
 
-        if ( mask & wxLIST_MASK_TEXT )
-            item.SetText(oldItem->GetText());
-        if ( mask & wxLIST_MASK_IMAGE )
-            item.SetImage(oldItem->GetImage());
-        if ( mask & wxLIST_MASK_DATA )
-            item.SetData(oldItem->GetData());
-        if ( mask & wxLIST_MASK_STATE )
-            item.SetState(oldItem->GetState());
-        if ( mask & wxLIST_MASK_WIDTH )
-            item.SetWidth(oldItem->GetWidth());
-        if ( mask & wxLIST_MASK_FORMAT )
-            item.SetAlign(oldItem->GetAlign());
+        wxListItem* oldItem = listItem->GetColumnInfo( column );
 
-        item.SetTextColour(oldItem->GetTextColour());
-        item.SetBackgroundColour(oldItem->GetBackgroundColour());
-        item.SetFont(oldItem->GetFont());   
+        if (oldItem)
+        {
+            long mask = item.GetMask();
+            if ( !mask )
+                // by default, get everything for backwards compatibility
+                mask = -1;
+
+            if ( mask & wxLIST_MASK_TEXT )
+                item.SetText(oldItem->GetText());
+            if ( mask & wxLIST_MASK_IMAGE )
+                item.SetImage(oldItem->GetImage());
+            if ( mask & wxLIST_MASK_DATA )
+                item.SetData(oldItem->GetData());
+            if ( mask & wxLIST_MASK_STATE )
+                item.SetState(oldItem->GetState());
+            if ( mask & wxLIST_MASK_WIDTH )
+                item.SetWidth(oldItem->GetWidth());
+            if ( mask & wxLIST_MASK_FORMAT )
+                item.SetAlign(oldItem->GetAlign());
+
+            item.SetTextColour(oldItem->GetTextColour());
+            item.SetBackgroundColour(oldItem->GetBackgroundColour());
+            item.SetFont(oldItem->GetFont());
+        }
     }
 }
 
@@ -1453,7 +3154,7 @@ void wxMacDataBrowserListCtrlControl::MacInsertItem( unsigned int n, wxListItem*
     MacSetColumnInfo(n, 0, item);
 }
 
-wxMacListCtrlItem* wxMacDataBrowserListCtrlControl::CreateItem()
+wxMacDataItem* wxMacDataBrowserListCtrlControl::CreateItem()
 {
     return new wxMacListCtrlItem();
 }
@@ -1465,26 +3166,34 @@ wxMacListCtrlItem::wxMacListCtrlItem()
 
 int wxMacListCtrlItem::GetColumnImageValue( unsigned int column )
 {
-    return GetColumnInfo(column)->GetImage();
+    if ( HasColumnInfo(column) )
+        return GetColumnInfo(column)->GetImage();
+
+    return -1;
 }
 
 void wxMacListCtrlItem::SetColumnImageValue( unsigned int column, int imageIndex )
 {
-    GetColumnInfo(column)->SetImage(imageIndex);
+    if ( HasColumnInfo(column) )
+        GetColumnInfo(column)->SetImage(imageIndex);
 }
 
-const wxString& wxMacListCtrlItem::GetColumnTextValue( unsigned int column )
+wxString wxMacListCtrlItem::GetColumnTextValue( unsigned int column )
 {
     if ( column == 0 )
         return GetLabel();
 
-    return GetColumnInfo(column)->GetText();
+    if ( HasColumnInfo(column) )
+        return GetColumnInfo(column)->GetText();
+
+    return wxEmptyString;
 }
 
 void wxMacListCtrlItem::SetColumnTextValue( unsigned int column, const wxString& text )
 {
-    GetColumnInfo(column)->SetText(text);
-    
+    if ( HasColumnInfo(column) )
+        GetColumnInfo(column)->SetText(text);
+
     // for compatibility with superclass APIs
     if ( column == 0 )
         SetLabel(text);
@@ -1492,35 +3201,25 @@ void wxMacListCtrlItem::SetColumnTextValue( unsigned int column, const wxString&
 
 wxListItem* wxMacListCtrlItem::GetColumnInfo( unsigned int column )
 {
-    wxListItemList::compatibility_iterator node = m_rowItems.Item( column );
-    wxASSERT_MSG( node, _T("invalid column index in wxMacListCtrlItem") );
-
-    return node->GetData();
+    wxASSERT_MSG( HasColumnInfo(column), _T("invalid column index in wxMacListCtrlItem") );
+    return m_rowItems[column];
 }
 
 bool wxMacListCtrlItem::HasColumnInfo( unsigned int column )
 {
-    return m_rowItems.GetCount() > column;
+    return !(m_rowItems.find( column ) == m_rowItems.end());
 }
 
 void wxMacListCtrlItem::SetColumnInfo( unsigned int column, wxListItem* item )
 {
 
-    if ( column >= m_rowItems.GetCount() ){
+    if ( !HasColumnInfo(column) )
+    {
         wxListItem* listItem = new wxListItem(*item);
-        //listItem->SetAlign(item->GetAlign());
-        //listItem->SetBackgroundColour(item->GetBackgroundColour());
-        //listItem->SetColumn(item->GetColumn());
-        //listItem->SetData(item->GetData());
-        //listItem->SetFont(item->GetFont());
-        //listItem->SetId(GetOrder());
-        //listItem->SetImage(item->GetImage());
-        //listItem->SetMask(item->GetMask());
-        
-        //listItem->SetText(item->GetText());      
-        m_rowItems.Append( listItem );
+        m_rowItems[column] = listItem;
     }
-    else{
+    else
+    {
         wxListItem* listItem = GetColumnInfo( column );
         long mask = item->GetMask();
         if (mask & wxLIST_MASK_TEXT)
@@ -1535,84 +3234,20 @@ void wxMacListCtrlItem::SetColumnInfo( unsigned int column, wxListItem* item )
             listItem->SetAlign(item->GetAlign());
         if (mask & wxLIST_MASK_WIDTH)
             listItem->SetWidth(item->GetWidth());
-    }
-}
 
-OSStatus wxMacListCtrlItem::GetSetData( wxMacDataItemBrowserControl *owner ,
-    DataBrowserPropertyID property,
-    DataBrowserItemDataRef itemData,
-    bool changeValue )
-{
-        
-    OSStatus err = errDataBrowserPropertyNotSupported;
-    wxListCtrl* list = wxDynamicCast( owner->GetPeer() , wxListCtrl );
-    if ( !changeValue )
-    {
-        switch (property)
+        if ( item->HasAttributes() )
         {
-            case kDataBrowserItemIsEditableProperty :
-                if ( list && list->HasFlag( wxLC_EDIT_LABELS ) )
-                {
-                    verify_noerr(SetDataBrowserItemDataBooleanValue( itemData, true ));
-                    err = noErr ;
-                }
-                break ;
-            default :
-                if ( property >= kMinColumnId ){
-                    short listColumn = property - kMinColumnId;
-                    
-                    if (HasColumnInfo(listColumn)){
-                        wxListItem* item = GetColumnInfo(listColumn);
-                        wxMacCFStringHolder cfStr;
-                        
-                        if (item->GetText()){
-                            cfStr.Assign( item->GetText(), wxLocale::GetSystemEncoding() );
-                            err = ::SetDataBrowserItemDataText( itemData, cfStr );
-                            err = noErr;
-                        }
-                        
-                        int imgIndex = item->GetImage();
-                        if ( (item->GetMask() & wxLIST_MASK_IMAGE) ){
-                            wxImageList* imageList = list->GetImageList(wxIMAGE_LIST_SMALL);
-                            if (imageList && imageList->GetImageCount() > 0){
-                                wxBitmap bmp = imageList->GetBitmap(imgIndex);
-                                IconRef icon = bmp.GetBitmapData()->GetIconRef();
-                                ::SetDataBrowserItemDataIcon(itemData, icon);
-                            }
-                        }
-                        
-                    }
-                }
-                break ;
-        }
-    }
-    else
-    {
-        switch (property)
-        {
-             default:
-                if ( property >= kMinColumnId ){
-                    short listColumn = property - kMinColumnId;
-                    
-                    if (HasColumnInfo(listColumn)){
-                        // TODO probably send the 'end edit' from here, as we
-                        // can then deal with the veto
-                        CFStringRef sr ;
-                        verify_noerr( GetDataBrowserItemDataText( itemData , &sr ) ) ;
-                        wxMacCFStringHolder cfStr(sr) ;;
-                        list->SetItem( owner->GetLineFromItem(this) , listColumn, cfStr.AsString() ) ;
-                        err = noErr ;                        
-                    }
-                }
-                break;
+            if ( listItem->HasAttributes() )
+                listItem->GetAttributes()->AssignFrom(*item->GetAttributes());
+            else
+            {
+                listItem->SetTextColour(item->GetTextColour());
+                listItem->SetBackgroundColour(item->GetBackgroundColour());
+                listItem->SetFont(item->GetFont());
+            }
         }
     }
-    
-    // don't duplicate the numeric order column handling
-    if (err == errDataBrowserPropertyNotSupported) 
-        err = wxMacDataItem::GetSetData(owner, property, itemData, changeValue);
-        
-    return err;
 }
 
 #endif // wxUSE_LISTCTRL
+