+ // these are only used by GetImage/SetImage above, we don't support images
+ // with subitems at the public API level yet
+ void SetImage( int index, int image );
+ int GetImage( int index ) const;
+};
+
+WX_DECLARE_EXPORTED_OBJARRAY(wxListLineData, wxListLineDataArray);
+#include "wx/arrimpl.cpp"
+WX_DEFINE_OBJARRAY(wxListLineDataArray);
+
+//-----------------------------------------------------------------------------
+// wxListHeaderWindow (internal)
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxListHeaderWindow : public wxWindow
+{
+protected:
+ wxListMainWindow *m_owner;
+ wxCursor *m_currentCursor;
+ wxCursor *m_resizeCursor;
+ bool m_isDragging;
+
+ // column being resized
+ int m_column;
+
+ // divider line position in logical (unscrolled) coords
+ int m_currentX;
+
+ // minimal position beyond which the divider line can't be dragged in
+ // logical coords
+ int m_minX;
+
+public:
+ wxListHeaderWindow();
+
+ wxListHeaderWindow( wxWindow *win,
+ wxWindowID id,
+ wxListMainWindow *owner,
+ const wxPoint &pos = wxDefaultPosition,
+ const wxSize &size = wxDefaultSize,
+ long style = 0,
+ const wxString &name = "wxlistctrlcolumntitles" );
+
+ virtual ~wxListHeaderWindow();
+
+ void DoDrawRect( wxDC *dc, int x, int y, int w, int h );
+ void DrawCurrent();
+ void AdjustDC(wxDC& dc);
+
+ void OnPaint( wxPaintEvent &event );
+ void OnMouse( wxMouseEvent &event );
+ void OnSetFocus( wxFocusEvent &event );
+
+ // needs refresh
+ bool m_dirty;
+
+private:
+ // common part of all ctors
+ void Init();
+
+ DECLARE_DYNAMIC_CLASS(wxListHeaderWindow)
+ DECLARE_EVENT_TABLE()
+};
+
+//-----------------------------------------------------------------------------
+// wxListRenameTimer (internal)
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxListRenameTimer: public wxTimer
+{
+private:
+ wxListMainWindow *m_owner;
+
+public:
+ wxListRenameTimer( wxListMainWindow *owner );
+ void Notify();
+};
+
+//-----------------------------------------------------------------------------
+// wxListTextCtrl (internal)
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxListTextCtrl: public wxTextCtrl
+{
+private:
+ bool *m_accept;
+ wxString *m_res;
+ wxListMainWindow *m_owner;
+ wxString m_startValue;
+
+public:
+ wxListTextCtrl() {}
+ wxListTextCtrl( wxWindow *parent, const wxWindowID id,
+ bool *accept, wxString *res, wxListMainWindow *owner,
+ const wxString &value = "",
+ const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
+ int style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString &name = "listctrltextctrl" );
+ void OnChar( wxKeyEvent &event );
+ void OnKeyUp( wxKeyEvent &event );
+ void OnKillFocus( wxFocusEvent &event );
+
+private:
+ DECLARE_DYNAMIC_CLASS(wxListTextCtrl);
+ DECLARE_EVENT_TABLE()
+};
+
+//-----------------------------------------------------------------------------
+// wxListMainWindow (internal)
+//-----------------------------------------------------------------------------
+
+WX_DECLARE_LIST(wxListHeaderData, wxListHeaderDataList);
+#include "wx/listimpl.cpp"
+WX_DEFINE_LIST(wxListHeaderDataList);
+
+class WXDLLEXPORT wxListMainWindow : public wxScrolledWindow
+{
+public:
+ wxListMainWindow();
+ wxListMainWindow( wxWindow *parent,
+ wxWindowID id,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = 0,
+ const wxString &name = _T("listctrlmainwindow") );
+
+ virtual ~wxListMainWindow();
+
+ bool HasFlag(int flag) const { return m_parent->HasFlag(flag); }
+
+ // return true if this is a virtual list control
+ bool IsVirtual() const { return HasFlag(wxLC_VIRTUAL); }
+
+ // return true if the control is in report mode
+ bool InReportView() const { return HasFlag(wxLC_REPORT); }
+
+ // return true if we are in single selection mode, false if multi sel
+ bool IsSingleSel() const { return HasFlag(wxLC_SINGLE_SEL); }
+
+ // do we have a header window?
+ bool HasHeader() const
+ { return HasFlag(wxLC_REPORT) && !HasFlag(wxLC_NO_HEADER); }
+
+ void HighlightAll( bool on );
+
+ // all these functions only do something if the line is currently visible
+
+ // change the line "selected" state, return TRUE if it really changed
+ bool HighlightLine( size_t line, bool highlight = TRUE);
+
+ // as HighlightLine() but do it for the range of lines: this is incredibly
+ // more efficient for virtual list controls!
+ //
+ // NB: unlike HighlightLine() this one does refresh the lines on screen
+ void HighlightLines( size_t lineFrom, size_t lineTo, bool on = TRUE );
+
+ // toggle the line state and refresh it
+ void ReverseHighlight( size_t line )
+ { HighlightLine(line, !IsHighlighted(line)); RefreshLine(line); }
+
+ // return true if the line is highlighted
+ bool IsHighlighted(size_t line) const;
+
+ // refresh one or several lines at once
+ void RefreshLine( size_t line );
+ void RefreshLines( size_t lineFrom, size_t lineTo );
+
+ // refresh all selected items
+ void RefreshSelected();
+
+ // refresh all lines below the given one: the difference with
+ // RefreshLines() is that the index here might not be a valid one (happens
+ // when the last line is deleted)
+ void RefreshAfter( size_t lineFrom );
+
+ // the methods which are forwarded to wxListLineData itself in list/icon
+ // modes but are here because the lines don't store their positions in the
+ // report mode
+
+ // get the bound rect for the entire line
+ wxRect GetLineRect(size_t line) const;
+
+ // get the bound rect of the label
+ wxRect GetLineLabelRect(size_t line) const;
+
+ // get the bound rect of the items icon (only may be called if we do have
+ // an icon!)
+ wxRect GetLineIconRect(size_t line) const;
+
+ // get the rect to be highlighted when the item has focus
+ wxRect GetLineHighlightRect(size_t line) const;
+
+ // get the size of the total line rect
+ wxSize GetLineSize(size_t line) const
+ { return GetLineRect(line).GetSize(); }
+
+ // return the hit code for the corresponding position (in this line)
+ long HitTestLine(size_t line, int x, int y) const;
+
+ // bring the selected item into view, scrolling to it if necessary
+ void MoveToItem(size_t item);
+
+ // bring the current item into view
+ void MoveToFocus() { MoveToItem(m_current); }
+
+ // start editing the label of the given item
+ void EditLabel( long item );
+
+ // suspend/resume redrawing the control
+ void Freeze();
+ void Thaw();
+
+ void OnRenameTimer();
+ void OnRenameAccept();
+
+ void OnMouse( wxMouseEvent &event );
+
+ // called to switch the selection from the current item to newCurrent,
+ void OnArrowChar( size_t newCurrent, const wxKeyEvent& event );
+
+ void OnChar( wxKeyEvent &event );
+ void OnKeyDown( wxKeyEvent &event );
+ void OnSetFocus( wxFocusEvent &event );
+ void OnKillFocus( wxFocusEvent &event );
+ void OnScroll(wxScrollWinEvent& event) ;
+
+ void OnPaint( wxPaintEvent &event );
+
+ void DrawImage( int index, wxDC *dc, int x, int y );
+ void GetImageSize( int index, int &width, int &height ) const;
+ int GetTextLength( const wxString &s ) const;
+
+ void SetImageList( wxImageList *imageList, int which );
+ void SetItemSpacing( int spacing, bool isSmall = FALSE );
+ int GetItemSpacing( bool isSmall = FALSE );
+
+ void SetColumn( int col, wxListItem &item );
+ void SetColumnWidth( int col, int width );
+ void GetColumn( int col, wxListItem &item ) const;
+ int GetColumnWidth( int col ) const;
+ int GetColumnCount() const { return m_columns.GetCount(); }
+
+ // returns the sum of the heights of all columns
+ int GetHeaderWidth() const;
+
+ int GetCountPerPage() const;
+
+ void SetItem( wxListItem &item );
+ void GetItem( wxListItem &item );
+ void SetItemState( long item, long state, long stateMask );
+ int GetItemState( long item, long stateMask );
+ void GetItemRect( long index, wxRect &rect );
+ bool GetItemPosition( long item, wxPoint& pos );
+ int GetSelectedItemCount();
+
+ // set the scrollbars and update the positions of the items
+ void RecalculatePositions(bool noRefresh = FALSE);
+
+ // refresh the window and the header
+ void RefreshAll();
+
+ long GetNextItem( long item, int geometry, int state );
+ void DeleteItem( long index );
+ void DeleteAllItems();
+ void DeleteColumn( int col );
+ void DeleteEverything();
+ void EnsureVisible( long index );
+ long FindItem( long start, const wxString& str, bool partial = FALSE );
+ long FindItem( long start, long data);
+ long HitTest( int x, int y, int &flags );
+ void InsertItem( wxListItem &item );
+ void InsertColumn( long col, wxListItem &item );
+ void SortItems( wxListCtrlCompare fn, long data );
+
+ size_t GetItemCount() const;
+ bool IsEmpty() const { return GetItemCount() == 0; }
+ void SetItemCount(long count);
+
+ // change the current (== focused) item, send a notification event
+ void ChangeCurrent(size_t current);
+ void ResetCurrent() { ChangeCurrent((size_t)-1); }
+ bool HasCurrent() const { return m_current != (size_t)-1; }
+
+ // send out a wxListEvent
+ void SendNotify( size_t line,
+ wxEventType command,
+ wxPoint point = wxDefaultPosition );
+
+ // override base class virtual to reset m_lineHeight when the font changes
+ virtual bool SetFont(const wxFont& font)
+ {
+ if ( !wxScrolledWindow::SetFont(font) )
+ return FALSE;
+
+ m_lineHeight = 0;
+
+ return TRUE;
+ }
+
+ // these are for wxListLineData usage only
+
+ // get the backpointer to the list ctrl
+ wxListCtrl *GetListCtrl() const
+ {
+ return wxStaticCast(GetParent(), wxListCtrl);
+ }
+
+ // get the height of all lines (assuming they all do have the same height)
+ wxCoord GetLineHeight() const;
+
+ // get the y position of the given line (only for report view)
+ wxCoord GetLineY(size_t line) const;
+
+ // get the brush to use for the item highlighting
+ wxBrush *GetHighlightBrush() const
+ {
+ return m_hasFocus ? m_highlightBrush : m_highlightUnfocusedBrush;
+ }
+
+//protected:
+ // the array of all line objects for a non virtual list control
+ wxListLineDataArray m_lines;
+
+ // the list of column objects
+ wxListHeaderDataList m_columns;
+
+ // currently focused item or -1
+ size_t m_current;
+
+ // the item currently being edited or -1
+ size_t m_currentEdit;
+
+ // the number of lines per page
+ int m_linesPerPage;
+
+ // this flag is set when something which should result in the window
+ // redrawing happens (i.e. an item was added or deleted, or its appearance
+ // changed) and OnPaint() doesn't redraw the window while it is set which
+ // allows to minimize the number of repaintings when a lot of items are
+ // being added. The real repainting occurs only after the next OnIdle()
+ // call
+ bool m_dirty;
+
+ wxColour *m_highlightColour;
+ int m_xScroll,
+ m_yScroll;
+ wxImageList *m_small_image_list;
+ wxImageList *m_normal_image_list;
+ int m_small_spacing;
+ int m_normal_spacing;
+ bool m_hasFocus;
+
+ bool m_lastOnSame;
+ wxTimer *m_renameTimer;
+ bool m_renameAccept;
+ wxString m_renameRes;
+ bool m_isCreated;
+ int m_dragCount;
+ wxPoint m_dragStart;
+
+ // for double click logic
+ size_t m_lineLastClicked,
+ m_lineBeforeLastClicked;
+
+protected:
+ // the total count of items in a virtual list control
+ size_t m_countVirt;
+
+ // the object maintaining the items selection state, only used in virtual
+ // controls
+ wxSelectionStore m_selStore;
+
+ // common part of all ctors
+ void Init();
+
+ // intiialize m_[xy]Scroll
+ void InitScrolling();
+
+ // get the line data for the given index
+ wxListLineData *GetLine(size_t n) const
+ {
+ wxASSERT_MSG( n != (size_t)-1, _T("invalid line index") );
+
+ if ( IsVirtual() )
+ {
+ wxConstCast(this, wxListMainWindow)->CacheLineData(n);
+
+ n = 0;
+ }
+
+ return &m_lines[n];
+ }
+
+ // get a dummy line which can be used for geometry calculations and such:
+ // you must use GetLine() if you want to really draw the line
+ wxListLineData *GetDummyLine() const;
+
+ // cache the line data of the n-th line in m_lines[0]
+ void CacheLineData(size_t line);
+
+ // get the range of visible lines
+ void GetVisibleLinesRange(size_t *from, size_t *to);
+
+ // force us to recalculate the range of visible lines
+ void ResetVisibleLinesRange() { m_lineFrom = (size_t)-1; }
+
+ // get the colour to be used for drawing the rules
+ wxColour GetRuleColour() const
+ {
+#ifdef __WXMAC__
+ return *wxWHITE;
+#else
+ return wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DLIGHT);
+#endif
+ }
+
+private:
+ // initialize the current item if needed
+ void UpdateCurrent();
+
+ // delete all items but don't refresh: called from dtor
+ void DoDeleteAllItems();
+
+ // the height of one line using the current font
+ wxCoord m_lineHeight;
+
+ // the total header width or 0 if not calculated yet
+ wxCoord m_headerWidth;
+
+ // the first and last lines being shown on screen right now (inclusive),
+ // both may be -1 if they must be calculated so never access them directly:
+ // use GetVisibleLinesRange() above instead
+ size_t m_lineFrom,
+ m_lineTo;
+
+ // the brushes to use for item highlighting when we do/don't have focus
+ wxBrush *m_highlightBrush,
+ *m_highlightUnfocusedBrush;
+
+ // if this is > 0, the control is frozen and doesn't redraw itself
+ size_t m_freezeCount;
+
+ DECLARE_DYNAMIC_CLASS(wxListMainWindow);
+ DECLARE_EVENT_TABLE()
+};
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxSelectionStore
+// ----------------------------------------------------------------------------
+
+bool wxSelectionStore::IsSelected(size_t item) const
+{
+ bool isSel = m_itemsSel.Index(item) != wxNOT_FOUND;
+
+ // if the default state is to be selected, being in m_itemsSel means that
+ // the item is not selected, so we have to inverse the logic
+ return m_defaultState ? !isSel : isSel;
+}
+
+bool wxSelectionStore::SelectItem(size_t item, bool select)
+{
+ // search for the item ourselves as like this we get the index where to
+ // insert it later if needed, so we do only one search in the array instead
+ // of two (adding item to a sorted array requires a search)
+ size_t index = m_itemsSel.IndexForInsert(item);
+ bool isSel = index < m_itemsSel.GetCount() && m_itemsSel[index] == item;
+
+ if ( select != m_defaultState )
+ {
+ if ( !isSel )
+ {
+ m_itemsSel.AddAt(item, index);
+
+ return TRUE;
+ }
+ }
+ else // reset to default state
+ {
+ if ( isSel )
+ {
+ m_itemsSel.RemoveAt(index);
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+bool wxSelectionStore::SelectRange(size_t itemFrom, size_t itemTo,
+ bool select,
+ wxArrayInt *itemsChanged)
+{
+ // 100 is hardcoded but it shouldn't matter much: the important thing is
+ // that we don't refresh everything when really few (e.g. 1 or 2) items
+ // change state
+ static const size_t MANY_ITEMS = 100;
+
+ wxASSERT_MSG( itemFrom <= itemTo, _T("should be in order") );
+
+ // are we going to have more [un]selected items than the other ones?
+ if ( itemTo - itemFrom > m_count/2 )
+ {
+ if ( select != m_defaultState )
+ {
+ // the default state now becomes the same as 'select'
+ m_defaultState = select;
+
+ // so all the old selections (which had state select) shouldn't be
+ // selected any more, but all the other ones should
+ wxIndexArray selOld = m_itemsSel;
+ m_itemsSel.Empty();
+
+ // TODO: it should be possible to optimize the searches a bit
+ // knowing the possible range
+
+ size_t item;
+ for ( item = 0; item < itemFrom; item++ )
+ {
+ if ( selOld.Index(item) == wxNOT_FOUND )
+ m_itemsSel.Add(item);
+ }
+
+ for ( item = itemTo + 1; item < m_count; item++ )
+ {
+ if ( selOld.Index(item) == wxNOT_FOUND )
+ m_itemsSel.Add(item);
+ }
+
+ // many items (> half) changed state
+ itemsChanged = NULL;
+ }
+ else // select == m_defaultState
+ {
+ // get the inclusive range of items between itemFrom and itemTo
+ size_t count = m_itemsSel.GetCount(),
+ start = m_itemsSel.IndexForInsert(itemFrom),
+ end = m_itemsSel.IndexForInsert(itemTo);
+
+ if ( start == count || m_itemsSel[start] < itemFrom )
+ {
+ start++;
+ }
+
+ if ( end == count || m_itemsSel[end] > itemTo )
+ {
+ end--;
+ }
+
+ if ( start <= end )
+ {
+ // delete all of them (from end to avoid changing indices)
+ for ( int i = end; i >= (int)start; i-- )
+ {
+ if ( itemsChanged )
+ {
+ if ( itemsChanged->GetCount() > MANY_ITEMS )
+ {
+ // stop counting (see comment below)
+ itemsChanged = NULL;
+ }
+
+ itemsChanged->Add(m_itemsSel[i]);
+ }
+
+ m_itemsSel.RemoveAt(i);
+ }
+ }
+ }
+ }
+ else // "few" items change state
+ {
+ if ( itemsChanged )
+ {
+ itemsChanged->Empty();
+ }
+
+ // just add the items to the selection
+ for ( size_t item = itemFrom; item <= itemTo; item++ )
+ {
+ if ( SelectItem(item, select) && itemsChanged )
+ {
+ itemsChanged->Add(item);
+
+ if ( itemsChanged->GetCount() > MANY_ITEMS )
+ {
+ // stop counting them, we'll just eat gobs of memory
+ // for nothing at all - faster to refresh everything in
+ // this case
+ itemsChanged = NULL;
+ }
+ }
+ }
+ }
+
+ // we set it to NULL if there are many items changing state
+ return itemsChanged != NULL;
+}
+
+void wxSelectionStore::OnItemDelete(size_t item)
+{
+ size_t count = m_itemsSel.GetCount(),
+ i = m_itemsSel.IndexForInsert(item);
+
+ if ( i < count && m_itemsSel[i] == item )
+ {
+ // this item itself was in m_itemsSel, remove it from there
+ m_itemsSel.RemoveAt(i);
+
+ count--;
+ }
+
+ // and adjust the index of all which follow it
+ while ( i < count )
+ {
+ // all following elements must be greater than the one we deleted
+ wxASSERT_MSG( m_itemsSel[i] > item, _T("logic error") );
+
+ m_itemsSel[i++]--;
+ }
+}
+
+//-----------------------------------------------------------------------------
+// wxListItemData
+//-----------------------------------------------------------------------------
+
+wxListItemData::~wxListItemData()
+{
+ // in the virtual list control the attributes are managed by the main
+ // program, so don't delete them
+ if ( !m_owner->IsVirtual() )
+ {
+ delete m_attr;
+ }
+
+ delete m_rect;
+}
+
+void wxListItemData::Init()
+{
+ m_image = -1;
+ m_data = 0;
+
+ m_attr = NULL;
+}
+
+wxListItemData::wxListItemData(wxListMainWindow *owner)
+{
+ Init();
+
+ m_owner = owner;
+
+ if ( owner->InReportView() )
+ {
+ m_rect = NULL;
+ }
+ else
+ {
+ m_rect = new wxRect;
+ }
+}
+
+void wxListItemData::SetItem( const wxListItem &info )
+{
+ if ( info.m_mask & wxLIST_MASK_TEXT )
+ SetText(info.m_text);
+ if ( info.m_mask & wxLIST_MASK_IMAGE )
+ m_image = info.m_image;
+ if ( info.m_mask & wxLIST_MASK_DATA )
+ m_data = info.m_data;
+
+ if ( info.HasAttributes() )
+ {
+ if ( m_attr )
+ *m_attr = *info.GetAttributes();
+ else
+ m_attr = new wxListItemAttr(*info.GetAttributes());
+ }
+
+ if ( m_rect )
+ {
+ m_rect->x =
+ m_rect->y =
+ m_rect->height = 0;
+ m_rect->width = info.m_width;
+ }
+}
+
+void wxListItemData::SetPosition( int x, int y )
+{
+ wxCHECK_RET( m_rect, _T("unexpected SetPosition() call") );
+
+ m_rect->x = x;
+ m_rect->y = y;
+}
+
+void wxListItemData::SetSize( int width, int height )
+{
+ wxCHECK_RET( m_rect, _T("unexpected SetSize() call") );
+
+ if ( width != -1 )
+ m_rect->width = width;
+ if ( height != -1 )
+ m_rect->height = height;
+}
+
+bool wxListItemData::IsHit( int x, int y ) const
+{
+ wxCHECK_MSG( m_rect, FALSE, _T("can't be called in this mode") );
+
+ return wxRect(GetX(), GetY(), GetWidth(), GetHeight()).Inside(x, y);
+}
+
+int wxListItemData::GetX() const
+{
+ wxCHECK_MSG( m_rect, 0, _T("can't be called in this mode") );
+
+ return m_rect->x;
+}
+
+int wxListItemData::GetY() const
+{
+ wxCHECK_MSG( m_rect, 0, _T("can't be called in this mode") );
+
+ return m_rect->y;
+}
+
+int wxListItemData::GetWidth() const
+{
+ wxCHECK_MSG( m_rect, 0, _T("can't be called in this mode") );
+
+ return m_rect->width;
+}
+
+int wxListItemData::GetHeight() const
+{
+ wxCHECK_MSG( m_rect, 0, _T("can't be called in this mode") );
+
+ return m_rect->height;
+}
+
+void wxListItemData::GetItem( wxListItem &info ) const
+{
+ info.m_text = m_text;
+ info.m_image = m_image;
+ info.m_data = m_data;
+
+ if ( m_attr )
+ {
+ if ( m_attr->HasTextColour() )
+ info.SetTextColour(m_attr->GetTextColour());
+ if ( m_attr->HasBackgroundColour() )
+ info.SetBackgroundColour(m_attr->GetBackgroundColour());
+ if ( m_attr->HasFont() )
+ info.SetFont(m_attr->GetFont());
+ }
+}
+
+//-----------------------------------------------------------------------------
+// wxListHeaderData
+//-----------------------------------------------------------------------------
+
+void wxListHeaderData::Init()
+{
+ m_mask = 0;
+ m_image = -1;
+ m_format = 0;
+ m_width = 0;
+ m_xpos = 0;
+ m_ypos = 0;
+ m_height = 0;
+}
+
+wxListHeaderData::wxListHeaderData()
+{
+ Init();
+}
+
+wxListHeaderData::wxListHeaderData( const wxListItem &item )
+{
+ Init();
+
+ SetItem( item );
+}
+
+void wxListHeaderData::SetItem( const wxListItem &item )
+{
+ m_mask = item.m_mask;
+
+ if ( m_mask & wxLIST_MASK_TEXT )
+ m_text = item.m_text;
+
+ if ( m_mask & wxLIST_MASK_IMAGE )
+ m_image = item.m_image;
+
+ if ( m_mask & wxLIST_MASK_FORMAT )
+ m_format = item.m_format;
+
+ if ( m_mask & wxLIST_MASK_WIDTH )
+ SetWidth(item.m_width);
+}
+
+void wxListHeaderData::SetPosition( int x, int y )
+{
+ m_xpos = x;
+ m_ypos = y;
+}
+
+void wxListHeaderData::SetHeight( int h )
+{
+ m_height = h;
+}
+
+void wxListHeaderData::SetWidth( int w )
+{
+ m_width = w;
+ if (m_width < 0)
+ m_width = WIDTH_COL_DEFAULT;
+ else if (m_width < WIDTH_COL_MIN)
+ m_width = WIDTH_COL_MIN;
+}
+
+void wxListHeaderData::SetFormat( int format )
+{
+ m_format = format;
+}
+
+bool wxListHeaderData::HasImage() const
+{
+ return m_image != -1;
+}
+
+bool wxListHeaderData::IsHit( int x, int y ) const
+{
+ return ((x >= m_xpos) && (x <= m_xpos+m_width) && (y >= m_ypos) && (y <= m_ypos+m_height));
+}
+
+void wxListHeaderData::GetItem( wxListItem& item )
+{
+ item.m_mask = m_mask;
+ item.m_text = m_text;
+ item.m_image = m_image;
+ item.m_format = m_format;
+ item.m_width = m_width;
+}
+
+int wxListHeaderData::GetImage() const
+{
+ return m_image;
+}
+
+int wxListHeaderData::GetWidth() const
+{
+ return m_width;
+}
+
+int wxListHeaderData::GetFormat() const
+{
+ return m_format;
+}
+
+//-----------------------------------------------------------------------------
+// wxListLineData
+//-----------------------------------------------------------------------------
+
+inline int wxListLineData::GetMode() const
+{
+ return m_owner->GetListCtrl()->GetWindowStyleFlag() & wxLC_MASK_TYPE;
+}
+
+inline bool wxListLineData::InReportView() const
+{
+ return m_owner->HasFlag(wxLC_REPORT);
+}
+
+inline bool wxListLineData::IsVirtual() const
+{
+ return m_owner->IsVirtual();
+}
+
+wxListLineData::wxListLineData( wxListMainWindow *owner )
+{
+ m_owner = owner;
+ m_items.DeleteContents( TRUE );
+
+ if ( InReportView() )
+ {
+ m_gi = NULL;
+ }
+ else // !report
+ {
+ m_gi = new GeometryInfo;
+ }
+
+ m_highlighted = FALSE;
+
+ InitItems( GetMode() == wxLC_REPORT ? m_owner->GetColumnCount() : 1 );
+}
+
+void wxListLineData::CalculateSize( wxDC *dc, int spacing )
+{
+ wxListItemDataList::Node *node = m_items.GetFirst();
+ wxCHECK_RET( node, _T("no subitems at all??") );
+
+ wxListItemData *item = node->GetData();
+
+ switch ( GetMode() )
+ {
+ case wxLC_ICON:
+ case wxLC_SMALL_ICON:
+ {
+ m_gi->m_rectAll.width = spacing;
+
+ wxString s = item->GetText();
+
+ wxCoord lw, lh;
+ if ( s.empty() )
+ {
+ lh =
+ m_gi->m_rectLabel.width =
+ m_gi->m_rectLabel.height = 0;
+ }
+ else // has label
+ {
+ dc->GetTextExtent( s, &lw, &lh );
+ if (lh < SCROLL_UNIT_Y)
+ lh = SCROLL_UNIT_Y;
+ lw += EXTRA_WIDTH;
+ lh += EXTRA_HEIGHT;
+
+ m_gi->m_rectAll.height = spacing + lh;
+ if (lw > spacing)
+ m_gi->m_rectAll.width = lw;
+
+ m_gi->m_rectLabel.width = lw;
+ m_gi->m_rectLabel.height = lh;
+ }
+
+ if (item->HasImage())
+ {
+ int w, h;
+ m_owner->GetImageSize( item->GetImage(), w, h );
+ m_gi->m_rectIcon.width = w + 8;
+ m_gi->m_rectIcon.height = h + 8;
+
+ if ( m_gi->m_rectIcon.width > m_gi->m_rectAll.width )
+ m_gi->m_rectAll.width = m_gi->m_rectIcon.width;
+ if ( m_gi->m_rectIcon.height + lh > m_gi->m_rectAll.height - 4 )
+ m_gi->m_rectAll.height = m_gi->m_rectIcon.height + lh + 4;
+ }
+
+ if ( item->HasText() )
+ {
+ m_gi->m_rectHighlight.width = m_gi->m_rectLabel.width;
+ m_gi->m_rectHighlight.height = m_gi->m_rectLabel.height;
+ }
+ else // no text, highlight the icon
+ {
+ m_gi->m_rectHighlight.width = m_gi->m_rectIcon.width;
+ m_gi->m_rectHighlight.height = m_gi->m_rectIcon.height;
+ }
+ }
+ break;
+
+ case wxLC_LIST:
+ {
+ wxString s = item->GetTextForMeasuring();
+
+ wxCoord lw,lh;
+ dc->GetTextExtent( s, &lw, &lh );
+ if (lh < SCROLL_UNIT_Y)
+ lh = SCROLL_UNIT_Y;
+ lw += EXTRA_WIDTH;
+ lh += EXTRA_HEIGHT;
+
+ m_gi->m_rectLabel.width = lw;
+ m_gi->m_rectLabel.height = lh;
+
+ m_gi->m_rectAll.width = lw;
+ m_gi->m_rectAll.height = lh;
+
+ if (item->HasImage())
+ {
+ int w, h;
+ m_owner->GetImageSize( item->GetImage(), w, h );
+ m_gi->m_rectIcon.width = w;
+ m_gi->m_rectIcon.height = h;
+
+ m_gi->m_rectAll.width += 4 + w;
+ if (h > m_gi->m_rectAll.height)
+ m_gi->m_rectAll.height = h;
+ }
+
+ m_gi->m_rectHighlight.width = m_gi->m_rectAll.width;
+ m_gi->m_rectHighlight.height = m_gi->m_rectAll.height;
+ }
+ break;
+
+ case wxLC_REPORT:
+ wxFAIL_MSG( _T("unexpected call to SetSize") );
+ break;
+
+ default:
+ wxFAIL_MSG( _T("unknown mode") );
+ }
+}
+
+void wxListLineData::SetPosition( int x, int y,
+ int window_width,
+ int spacing )
+{
+ wxListItemDataList::Node *node = m_items.GetFirst();
+ wxCHECK_RET( node, _T("no subitems at all??") );
+
+ wxListItemData *item = node->GetData();
+
+ switch ( GetMode() )
+ {
+ case wxLC_ICON:
+ case wxLC_SMALL_ICON:
+ m_gi->m_rectAll.x = x;
+ m_gi->m_rectAll.y = y;
+
+ if ( item->HasImage() )
+ {
+ m_gi->m_rectIcon.x = m_gi->m_rectAll.x + 4
+ + (spacing - m_gi->m_rectIcon.width)/2;
+ m_gi->m_rectIcon.y = m_gi->m_rectAll.y + 4;
+ }
+
+ if ( item->HasText() )
+ {
+ if (m_gi->m_rectAll.width > spacing)
+ m_gi->m_rectLabel.x = m_gi->m_rectAll.x + 2;
+ else
+ m_gi->m_rectLabel.x = m_gi->m_rectAll.x + 2 + (spacing/2) - (m_gi->m_rectLabel.width/2);
+ m_gi->m_rectLabel.y = m_gi->m_rectAll.y + m_gi->m_rectAll.height + 2 - m_gi->m_rectLabel.height;
+ m_gi->m_rectHighlight.x = m_gi->m_rectLabel.x - 2;
+ m_gi->m_rectHighlight.y = m_gi->m_rectLabel.y - 2;
+ }
+ else // no text, highlight the icon
+ {
+ m_gi->m_rectHighlight.x = m_gi->m_rectIcon.x - 4;
+ m_gi->m_rectHighlight.y = m_gi->m_rectIcon.y - 4;
+ }
+ break;
+
+ case wxLC_LIST:
+ m_gi->m_rectAll.x = x;
+ m_gi->m_rectAll.y = y;
+
+ m_gi->m_rectHighlight.x = m_gi->m_rectAll.x;
+ m_gi->m_rectHighlight.y = m_gi->m_rectAll.y;
+ m_gi->m_rectLabel.y = m_gi->m_rectAll.y + 2;
+
+ if (item->HasImage())
+ {
+ m_gi->m_rectIcon.x = m_gi->m_rectAll.x + 2;
+ m_gi->m_rectIcon.y = m_gi->m_rectAll.y + 2;
+ m_gi->m_rectLabel.x = m_gi->m_rectAll.x + 6 + m_gi->m_rectIcon.width;
+ }
+ else
+ {
+ m_gi->m_rectLabel.x = m_gi->m_rectAll.x + 2;
+ }
+ break;
+
+ case wxLC_REPORT:
+ wxFAIL_MSG( _T("unexpected call to SetPosition") );
+ break;
+
+ default:
+ wxFAIL_MSG( _T("unknown mode") );
+ }
+}
+
+void wxListLineData::InitItems( int num )
+{
+ for (int i = 0; i < num; i++)
+ m_items.Append( new wxListItemData(m_owner) );
+}
+
+void wxListLineData::SetItem( int index, const wxListItem &info )
+{
+ wxListItemDataList::Node *node = m_items.Item( index );
+ wxCHECK_RET( node, _T("invalid column index in SetItem") );
+
+ wxListItemData *item = node->GetData();
+ item->SetItem( info );
+}
+
+void wxListLineData::GetItem( int index, wxListItem &info )
+{
+ wxListItemDataList::Node *node = m_items.Item( index );
+ if (node)
+ {
+ wxListItemData *item = node->GetData();
+ item->GetItem( info );
+ }
+}
+
+wxString wxListLineData::GetText(int index) const
+{
+ wxString s;
+
+ wxListItemDataList::Node *node = m_items.Item( index );
+ if (node)
+ {
+ wxListItemData *item = node->GetData();
+ s = item->GetText();
+ }
+
+ return s;
+}
+
+void wxListLineData::SetText( int index, const wxString s )
+{
+ wxListItemDataList::Node *node = m_items.Item( index );
+ if (node)
+ {
+ wxListItemData *item = node->GetData();
+ item->SetText( s );
+ }
+}
+
+void wxListLineData::SetImage( int index, int image )
+{
+ wxListItemDataList::Node *node = m_items.Item( index );
+ wxCHECK_RET( node, _T("invalid column index in SetImage()") );
+
+ wxListItemData *item = node->GetData();
+ item->SetImage(image);
+}
+
+int wxListLineData::GetImage( int index ) const
+{
+ wxListItemDataList::Node *node = m_items.Item( index );
+ wxCHECK_MSG( node, -1, _T("invalid column index in GetImage()") );
+
+ wxListItemData *item = node->GetData();
+ return item->GetImage();
+}
+
+wxListItemAttr *wxListLineData::GetAttr() const
+{
+ wxListItemDataList::Node *node = m_items.GetFirst();
+ wxCHECK_MSG( node, NULL, _T("invalid column index in GetAttr()") );
+
+ wxListItemData *item = node->GetData();
+ return item->GetAttr();
+}
+
+void wxListLineData::SetAttr(wxListItemAttr *attr)
+{
+ wxListItemDataList::Node *node = m_items.GetFirst();
+ wxCHECK_RET( node, _T("invalid column index in SetAttr()") );
+
+ wxListItemData *item = node->GetData();
+ item->SetAttr(attr);
+}
+
+bool wxListLineData::SetAttributes(wxDC *dc,
+ const wxListItemAttr *attr,
+ bool highlighted)
+{
+ wxWindow *listctrl = m_owner->GetParent();
+
+ // fg colour
+
+ // don't use foreground colour for drawing highlighted items - this might
+ // make them completely invisible (and there is no way to do bit
+ // arithmetics on wxColour, unfortunately)
+ wxColour colText;
+ if ( highlighted )
+ {
+ colText = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
+ }
+ else
+ {
+ if ( attr && attr->HasTextColour() )
+ {
+ colText = attr->GetTextColour();
+ }
+ else
+ {
+ colText = listctrl->GetForegroundColour();
+ }
+ }
+
+ dc->SetTextForeground(colText);
+
+ // font
+ wxFont font;
+ if ( attr && attr->HasFont() )
+ {
+ font = attr->GetFont();
+ }
+ else
+ {
+ font = listctrl->GetFont();
+ }
+
+ dc->SetFont(font);
+
+ // bg colour
+ bool hasBgCol = attr && attr->HasBackgroundColour();
+ if ( highlighted || hasBgCol )
+ {
+ if ( highlighted )
+ {
+ dc->SetBrush( *m_owner->GetHighlightBrush() );
+ }
+ else
+ {
+ dc->SetBrush(wxBrush(attr->GetBackgroundColour(), wxSOLID));
+ }
+
+ dc->SetPen( *wxTRANSPARENT_PEN );
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+void wxListLineData::Draw( wxDC *dc )
+{
+ wxListItemDataList::Node *node = m_items.GetFirst();
+ wxCHECK_RET( node, _T("no subitems at all??") );
+
+ bool highlighted = IsHighlighted();
+
+ wxListItemAttr *attr = GetAttr();
+
+ if ( SetAttributes(dc, attr, highlighted) )
+ {
+ dc->DrawRectangle( m_gi->m_rectHighlight );
+ }
+
+ wxListItemData *item = node->GetData();
+ if (item->HasImage())
+ {
+ wxRect rectIcon = m_gi->m_rectIcon;
+ m_owner->DrawImage( item->GetImage(), dc,
+ rectIcon.x, rectIcon.y );
+ }
+
+ if (item->HasText())
+ {
+ wxRect rectLabel = m_gi->m_rectLabel;
+
+ wxDCClipper clipper(*dc, rectLabel);
+ dc->DrawText( item->GetText(), rectLabel.x, rectLabel.y );
+ }
+}
+
+void wxListLineData::DrawInReportMode( wxDC *dc,
+ const wxRect& rect,
+ const wxRect& rectHL,
+ bool highlighted )
+{
+ // TODO: later we should support setting different attributes for
+ // different columns - to do it, just add "col" argument to
+ // GetAttr() and move these lines into the loop below
+ wxListItemAttr *attr = GetAttr();
+ if ( SetAttributes(dc, attr, highlighted) )
+ {
+ dc->DrawRectangle( rectHL );
+ }
+
+ wxListItemDataList::Node *node = m_items.GetFirst();
+ wxCHECK_RET( node, _T("no subitems at all??") );
+
+ size_t col = 0;
+ wxCoord x = rect.x + HEADER_OFFSET_X,
+ y = rect.y + (LINE_SPACING + EXTRA_HEIGHT) / 2;
+
+ while ( node )
+ {
+ wxListItemData *item = node->GetData();
+
+ int width = m_owner->GetColumnWidth(col++);
+ int xOld = x;
+ x += width;
+
+ if ( item->HasImage() )
+ {
+ int ix, iy;
+ m_owner->DrawImage( item->GetImage(), dc, xOld, y );
+ m_owner->GetImageSize( item->GetImage(), ix, iy );
+
+ ix += IMAGE_MARGIN_IN_REPORT_MODE;
+
+ xOld += ix;
+ width -= ix;
+ }
+
+ wxDCClipper clipper(*dc, xOld, y, width, rect.height);
+
+ if ( item->HasText() )
+ {
+ dc->DrawText( item->GetText(), xOld, y );
+ }
+
+ node = node->GetNext();
+ }
+}
+
+bool wxListLineData::Highlight( bool on )
+{
+ wxCHECK_MSG( !m_owner->IsVirtual(), FALSE, _T("unexpected call to Highlight") );
+
+ if ( on == m_highlighted )
+ return FALSE;
+
+ m_highlighted = on;
+
+ return TRUE;
+}
+
+void wxListLineData::ReverseHighlight( void )
+{
+ Highlight(!IsHighlighted());
+}
+
+//-----------------------------------------------------------------------------
+// wxListHeaderWindow
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxListHeaderWindow,wxWindow);
+
+BEGIN_EVENT_TABLE(wxListHeaderWindow,wxWindow)
+ EVT_PAINT (wxListHeaderWindow::OnPaint)
+ EVT_MOUSE_EVENTS (wxListHeaderWindow::OnMouse)
+ EVT_SET_FOCUS (wxListHeaderWindow::OnSetFocus)
+END_EVENT_TABLE()
+
+void wxListHeaderWindow::Init()
+{
+ m_currentCursor = (wxCursor *) NULL;
+ m_isDragging = FALSE;
+ m_dirty = FALSE;
+}
+
+wxListHeaderWindow::wxListHeaderWindow()
+{
+ Init();
+
+ m_owner = (wxListMainWindow *) NULL;
+ m_resizeCursor = (wxCursor *) NULL;
+}
+
+wxListHeaderWindow::wxListHeaderWindow( wxWindow *win,
+ wxWindowID id,
+ wxListMainWindow *owner,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString &name )
+ : wxWindow( win, id, pos, size, style, name )
+{
+ Init();
+
+ m_owner = owner;
+ m_resizeCursor = new wxCursor( wxCURSOR_SIZEWE );
+
+ SetBackgroundColour( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE ) );
+}
+
+wxListHeaderWindow::~wxListHeaderWindow()
+{
+ delete m_resizeCursor;
+}
+
+void wxListHeaderWindow::DoDrawRect( wxDC *dc, int x, int y, int w, int h )
+{
+#ifdef __WXGTK__
+ GtkStateType state = m_parent->IsEnabled() ? GTK_STATE_NORMAL
+ : GTK_STATE_INSENSITIVE;
+
+ x = dc->XLOG2DEV( x );
+
+ gtk_paint_box (m_wxwindow->style, GTK_PIZZA(m_wxwindow)->bin_window,
+ state, GTK_SHADOW_OUT,
+ (GdkRectangle*) NULL, m_wxwindow, "button",
+ x-1, y-1, w+2, h+2);
+#elif defined( __WXMAC__ )
+ const int m_corner = 1;
+
+ dc->SetBrush( *wxTRANSPARENT_BRUSH );
+
+ dc->SetPen( wxPen( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNSHADOW ) , 1 , wxSOLID ) );
+ dc->DrawLine( x+w-m_corner+1, y, x+w, y+h ); // right (outer)
+ dc->DrawRectangle( x, y+h, w+1, 1 ); // bottom (outer)
+
+ wxPen pen( wxColour( 0x88 , 0x88 , 0x88 ), 1, wxSOLID );
+
+ dc->SetPen( pen );
+ dc->DrawLine( x+w-m_corner, y, x+w-1, y+h ); // right (inner)
+ dc->DrawRectangle( x+1, y+h-1, w-2, 1 ); // bottom (inner)
+
+ dc->SetPen( *wxWHITE_PEN );
+ dc->DrawRectangle( x, y, w-m_corner+1, 1 ); // top (outer)
+ dc->DrawRectangle( x, y, 1, h ); // left (outer)
+ dc->DrawLine( x, y+h-1, x+1, y+h-1 );
+ dc->DrawLine( x+w-1, y, x+w-1, y+1 );
+#else // !GTK, !Mac
+ const int m_corner = 1;
+
+ dc->SetBrush( *wxTRANSPARENT_BRUSH );
+
+ dc->SetPen( *wxBLACK_PEN );
+ dc->DrawLine( x+w-m_corner+1, y, x+w, y+h ); // right (outer)
+ dc->DrawRectangle( x, y+h, w+1, 1 ); // bottom (outer)
+
+ wxPen pen( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNSHADOW ), 1, wxSOLID );
+
+ dc->SetPen( pen );
+ dc->DrawLine( x+w-m_corner, y, x+w-1, y+h ); // right (inner)
+ dc->DrawRectangle( x+1, y+h-1, w-2, 1 ); // bottom (inner)
+
+ dc->SetPen( *wxWHITE_PEN );
+ dc->DrawRectangle( x, y, w-m_corner+1, 1 ); // top (outer)
+ dc->DrawRectangle( x, y, 1, h ); // left (outer)
+ dc->DrawLine( x, y+h-1, x+1, y+h-1 );
+ dc->DrawLine( x+w-1, y, x+w-1, y+1 );
+#endif
projects / wxWidgets.git / blobdiff