+ if (event.m_keyCode == WXK_RETURN)
+ {
+ (*m_accept) = TRUE;
+ (*m_res) = GetValue();
+
+ if (!wxPendingDelete.Member(this))
+ wxPendingDelete.Append(this);
+
+ if ((*m_accept) && ((*m_res) != m_startValue))
+ m_owner->OnRenameAccept();
+
+ return;
+ }
+ if (event.m_keyCode == WXK_ESCAPE)
+ {
+ (*m_accept) = FALSE;
+ (*m_res) = "";
+
+ if (!wxPendingDelete.Member(this))
+ wxPendingDelete.Append(this);
+
+ return;
+ }
+
+ event.Skip();
+}
+
+void wxListTextCtrl::OnKeyUp( wxKeyEvent &event )
+{
+ // auto-grow the textctrl:
+ wxSize parentSize = m_owner->GetSize();
+ wxPoint myPos = GetPosition();
+ wxSize mySize = GetSize();
+ int sx, sy;
+ GetTextExtent(GetValue() + _T("MM"), &sx, &sy); // FIXME: MM??
+ if (myPos.x + sx > parentSize.x)
+ sx = parentSize.x - myPos.x;
+ if (mySize.x > sx)
+ sx = mySize.x;
+ SetSize(sx, -1);
+
+ event.Skip();
+}
+
+void wxListTextCtrl::OnKillFocus( wxFocusEvent &WXUNUSED(event) )
+{
+ if (!wxPendingDelete.Member(this))
+ wxPendingDelete.Append(this);
+
+ if ((*m_accept) && ((*m_res) != m_startValue))
+ m_owner->OnRenameAccept();
+}
+
+//-----------------------------------------------------------------------------
+// wxListMainWindow
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxListMainWindow,wxScrolledWindow);
+
+BEGIN_EVENT_TABLE(wxListMainWindow,wxScrolledWindow)
+ EVT_PAINT (wxListMainWindow::OnPaint)
+ EVT_MOUSE_EVENTS (wxListMainWindow::OnMouse)
+ EVT_CHAR (wxListMainWindow::OnChar)
+ EVT_KEY_DOWN (wxListMainWindow::OnKeyDown)
+ EVT_SET_FOCUS (wxListMainWindow::OnSetFocus)
+ EVT_KILL_FOCUS (wxListMainWindow::OnKillFocus)
+ EVT_SCROLLWIN (wxListMainWindow::OnScroll)
+END_EVENT_TABLE()
+
+void wxListMainWindow::Init()
+{
+ m_columns.DeleteContents( TRUE );
+ m_dirty = TRUE;
+ m_countVirt = 0;
+ m_lineFrom =
+ m_lineTo = (size_t)-1;
+ m_linesPerPage = 0;
+
+ m_headerWidth =
+ m_lineHeight = 0;
+
+ m_small_image_list = (wxImageList *) NULL;
+ m_normal_image_list = (wxImageList *) NULL;
+
+ m_small_spacing = 30;
+ m_normal_spacing = 40;
+
+ m_hasFocus = FALSE;
+ m_dragCount = 0;
+ m_isCreated = FALSE;
+
+ m_lastOnSame = FALSE;
+ m_renameTimer = new wxListRenameTimer( this );
+ m_renameAccept = FALSE;
+
+ m_current =
+ m_currentEdit =
+ m_lineLastClicked =
+ m_lineBeforeLastClicked = (size_t)-1;
+}
+
+void wxListMainWindow::InitScrolling()
+{
+ if ( HasFlag(wxLC_REPORT) )
+ {
+ m_xScroll = SCROLL_UNIT_X;
+ m_yScroll = SCROLL_UNIT_Y;
+ }
+ else
+ {
+ m_xScroll = SCROLL_UNIT_Y;
+ m_yScroll = 0;
+ }
+}
+
+wxListMainWindow::wxListMainWindow()
+{
+ Init();
+
+ m_highlightBrush = (wxBrush *) NULL;
+
+ m_xScroll =
+ m_yScroll = 0;
+}
+
+wxListMainWindow::wxListMainWindow( wxWindow *parent,
+ wxWindowID id,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString &name )
+ : wxScrolledWindow( parent, id, pos, size,
+ style | wxHSCROLL | wxVSCROLL, name )
+{
+ Init();
+
+ m_highlightBrush = new wxBrush( wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHT), wxSOLID );
+ wxSize sz = size;
+ sz.y = 25;
+
+ InitScrolling();
+ SetScrollbars( m_xScroll, m_yScroll, 0, 0, 0, 0 );
+
+ SetBackgroundColour( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_LISTBOX ) );
+}
+
+wxListMainWindow::~wxListMainWindow()
+{
+ DoDeleteAllItems();
+
+ delete m_highlightBrush;
+
+ delete m_renameTimer;
+}
+
+void wxListMainWindow::CacheLineData(size_t line)
+{
+ wxListCtrl *listctrl = GetListCtrl();
+
+ wxListLineData *ld = GetDummyLine();
+
+ size_t countCol = GetColumnCount();
+ for ( size_t col = 0; col < countCol; col++ )
+ {
+ ld->SetText(col, listctrl->OnGetItemText(line, col));
+ }
+
+ ld->SetImage(listctrl->OnGetItemImage(line));
+ ld->SetAttr(listctrl->OnGetItemAttr(line));
+}
+
+wxListLineData *wxListMainWindow::GetDummyLine() const
+{
+ wxASSERT_MSG( !IsEmpty(), _T("invalid line index") );
+
+ if ( m_lines.IsEmpty() )
+ {
+ // normal controls are supposed to have something in m_lines
+ // already if it's not empty
+ wxASSERT_MSG( IsVirtual(), _T("logic error") );
+
+ wxListMainWindow *self = wxConstCast(this, wxListMainWindow);
+ wxListLineData *line = new wxListLineData(self);
+ self->m_lines.Add(line);
+ }
+
+ return &m_lines[0];
+}
+
+// ----------------------------------------------------------------------------
+// line geometry (report mode only)
+// ----------------------------------------------------------------------------
+
+wxCoord wxListMainWindow::GetLineHeight() const
+{
+ wxASSERT_MSG( HasFlag(wxLC_REPORT), _T("only works in report mode") );
+
+ // we cache the line height as calling GetTextExtent() is slow
+ if ( !m_lineHeight )
+ {
+ wxListMainWindow *self = wxConstCast(this, wxListMainWindow);
+
+ wxClientDC dc( self );
+ dc.SetFont( GetFont() );
+
+ wxCoord y;
+ dc.GetTextExtent(_T("H"), NULL, &y);
+
+ if ( y < SCROLL_UNIT_Y )
+ y = SCROLL_UNIT_Y;
+ y += EXTRA_HEIGHT;
+
+ self->m_lineHeight = y + LINE_SPACING;
+ }
+
+ return m_lineHeight;
+}
+
+wxCoord wxListMainWindow::GetLineY(size_t line) const
+{
+ wxASSERT_MSG( HasFlag(wxLC_REPORT), _T("only works in report mode") );
+
+ return LINE_SPACING + line*GetLineHeight();
+}
+
+wxRect wxListMainWindow::GetLineRect(size_t line) const
+{
+ if ( !InReportView() )
+ return GetLine(line)->m_gi->m_rectAll;
+
+ wxRect rect;
+ rect.x = HEADER_OFFSET_X;
+ rect.y = GetLineY(line);
+ rect.width = GetHeaderWidth();
+ rect.height = GetLineHeight();
+
+ return rect;
+}
+
+wxRect wxListMainWindow::GetLineLabelRect(size_t line) const
+{
+ if ( !InReportView() )
+ return GetLine(line)->m_gi->m_rectLabel;
+
+ wxRect rect;
+ rect.x = HEADER_OFFSET_X;
+ rect.y = GetLineY(line);
+ rect.width = GetColumnWidth(0);
+ rect.height = GetLineHeight();
+
+ return rect;
+}
+
+wxRect wxListMainWindow::GetLineIconRect(size_t line) const
+{
+ if ( !InReportView() )
+ return GetLine(line)->m_gi->m_rectIcon;
+
+ wxListLineData *ld = GetLine(line);
+ wxASSERT_MSG( ld->HasImage(), _T("should have an image") );
+
+ wxRect rect;
+ rect.x = HEADER_OFFSET_X;
+ rect.y = GetLineY(line);
+ GetImageSize(ld->GetImage(), rect.width, rect.height);
+
+ return rect;
+}
+
+wxRect wxListMainWindow::GetLineHighlightRect(size_t line) const
+{
+ return InReportView() ? GetLineRect(line)
+ : GetLine(line)->m_gi->m_rectHighlight;
+}
+
+long wxListMainWindow::HitTestLine(size_t line, int x, int y) const
+{
+ wxListLineData *ld = GetLine(line);
+
+ if ( ld->HasImage() && GetLineIconRect(line).Inside(x, y) )
+ return wxLIST_HITTEST_ONITEMICON;
+
+ if ( ld->HasText() )
+ {
+ wxRect rect = InReportView() ? GetLineRect(line)
+ : GetLineLabelRect(line);
+
+ if ( rect.Inside(x, y) )
+ return wxLIST_HITTEST_ONITEMLABEL;
+ }
+
+ return 0;
+}
+
+// ----------------------------------------------------------------------------
+// highlight (selection) handling
+// ----------------------------------------------------------------------------
+
+bool wxListMainWindow::IsHighlighted(size_t line) const
+{
+ if ( IsVirtual() )
+ {
+ return m_selStore.IsSelected(line);
+ }
+ else // !virtual
+ {
+ wxListLineData *ld = GetLine(line);
+ wxCHECK_MSG( ld, FALSE, _T("invalid index in IsHighlighted") );
+
+ return ld->IsHighlighted();
+ }
+}
+
+void wxListMainWindow::HighlightLines( size_t lineFrom, size_t lineTo, bool highlight )
+{
+ if ( IsVirtual() )
+ {
+ m_selStore.SelectRange(lineFrom, lineTo, highlight);
+ RefreshLines(lineFrom, lineTo);
+ }
+ else
+ {
+ // do it the dumb way
+ bool needsRefresh = FALSE;
+ for ( size_t line = lineFrom; line <= lineTo; line++ )
+ {
+ if ( HighlightLine(line, highlight) )
+ needsRefresh = TRUE;
+ }
+
+ if ( needsRefresh )
+ RefreshLines(lineFrom, lineTo);
+ }
+}
+
+bool wxListMainWindow::HighlightLine( size_t line, bool highlight )
+{
+ bool changed;
+
+ if ( IsVirtual() )
+ {
+ changed = m_selStore.SelectItem(line, highlight);
+ }
+ else // !virtual
+ {
+ wxListLineData *ld = GetLine(line);
+ wxCHECK_MSG( ld, FALSE, _T("invalid index in IsHighlighted") );
+
+ changed = ld->Highlight(highlight);
+ }
+
+ if ( changed )
+ {
+ SendNotify( line, highlight ? wxEVT_COMMAND_LIST_ITEM_SELECTED
+ : wxEVT_COMMAND_LIST_ITEM_DESELECTED );
+ }
+
+ return changed;
+}
+
+void wxListMainWindow::RefreshLine( size_t line )
+{
+ wxRect rect = GetLineRect(line);
+
+ CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
+ RefreshRect( rect );
+}
+
+void wxListMainWindow::RefreshLines( size_t lineFrom, size_t lineTo )
+{
+ // we suppose that they are ordered by caller
+ wxASSERT_MSG( lineFrom <= lineTo, _T("indices in disorder") );
+
+ wxASSERT_MSG( lineTo < GetItemCount(), _T("invalid line range") );
+
+ if ( HasFlag(wxLC_REPORT) )
+ {
+ size_t visibleFrom, visibleTo;
+ GetVisibleLinesRange(&visibleFrom, &visibleTo);
+
+ if ( lineFrom < visibleFrom )
+ lineFrom = visibleFrom;
+ if ( lineTo > visibleTo )
+ lineTo = visibleTo;
+
+ wxRect rect;
+ rect.x = 0;
+ rect.y = GetLineY(lineFrom);
+ rect.width = GetClientSize().x;
+ rect.height = GetLineY(lineTo) - rect.y;
+
+ CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
+ RefreshRect( rect );
+ }
+ else // !report
+ {
+ // TODO: this should be optimized...
+ for ( size_t line = lineFrom; line <= lineTo; line++ )
+ {
+ RefreshLine(line);
+ }
+ }
+}
+
+void wxListMainWindow::RefreshAfter( size_t lineFrom )
+{
+ if ( HasFlag(wxLC_REPORT) )
+ {
+ size_t visibleFrom;
+ GetVisibleLinesRange(&visibleFrom, NULL);
+
+ if ( lineFrom < visibleFrom )
+ lineFrom = visibleFrom;
+
+ wxRect rect;
+ rect.x = 0;
+ rect.y = GetLineY(lineFrom);
+
+ wxSize size = GetClientSize();
+ rect.width = size.x;
+ // refresh till the bottom of the window
+ rect.height = size.y - rect.y;
+
+ CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
+ RefreshRect( rect );
+ }
+ else // !report
+ {
+ // TODO: how to do it more efficiently?
+ m_dirty = TRUE;
+ }
+}
+
+void wxListMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
+{
+ // Note: a wxPaintDC must be constructed even if no drawing is
+ // done (a Windows requirement).
+ wxPaintDC dc( this );
+
+ if ( IsEmpty() )
+ {
+ // empty control. nothing to draw
+ return;
+ }
+
+ if ( m_dirty )
+ {
+ // delay the repainting until we calculate all the items positions
+ return;
+ }
+
+ PrepareDC( dc );
+
+ int dev_x, dev_y;
+ CalcScrolledPosition( 0, 0, &dev_x, &dev_y );
+
+ dc.BeginDrawing();
+
+ dc.SetFont( GetFont() );
+
+ if ( HasFlag(wxLC_REPORT) )
+ {
+ int lineHeight = GetLineHeight();
+
+ size_t visibleFrom, visibleTo;
+ GetVisibleLinesRange(&visibleFrom, &visibleTo);
+
+ wxRect rectLine;
+ wxCoord xOrig, yOrig;
+ CalcUnscrolledPosition(0, 0, &xOrig, &yOrig);
+
+ // tell the caller cache to cache the data
+ wxListEvent evCache(wxEVT_COMMAND_LIST_CACHE_HINT, GetParent()->GetId());
+ evCache.SetEventObject( GetParent() );
+ evCache.m_oldItemIndex = visibleFrom;
+ evCache.m_itemIndex = visibleTo;
+ GetParent()->GetEventHandler()->ProcessEvent( evCache );
+
+ for ( size_t line = visibleFrom; line <= visibleTo; line++ )
+ {
+ rectLine = GetLineRect(line);
+
+ if ( !IsExposed(rectLine.x - xOrig, rectLine.y - yOrig,
+ rectLine.width, rectLine.height) )
+ {
+ // don't redraw unaffected lines to avoid flicker
+ continue;
+ }
+
+ GetLine(line)->DrawInReportMode( &dc,
+ rectLine,
+ GetLineHighlightRect(line),
+ IsHighlighted(line) );
+ }
+
+ if ( HasFlag(wxLC_HRULES) )
+ {
+ wxPen pen(GetRuleColour(), 1, wxSOLID);
+ wxSize clientSize = GetClientSize();
+
+ for ( size_t i = visibleFrom; i <= visibleTo; i++ )
+ {
+ dc.SetPen(pen);
+ dc.SetBrush( *wxTRANSPARENT_BRUSH );
+ dc.DrawLine(0 - dev_x, i*lineHeight,
+ clientSize.x - dev_x, i*lineHeight);
+ }
+
+ // Draw last horizontal rule
+ if ( visibleTo > visibleFrom )
+ {
+ dc.SetPen(pen);
+ dc.SetBrush( *wxTRANSPARENT_BRUSH );
+ dc.DrawLine(0 - dev_x, m_lineTo*lineHeight,
+ clientSize.x - dev_x , m_lineTo*lineHeight );
+ }
+ }
+
+ // Draw vertical rules if required
+ if ( HasFlag(wxLC_VRULES) && !IsEmpty() )
+ {
+ wxPen pen(GetRuleColour(), 1, wxSOLID);
+
+ int col = 0;
+ wxRect firstItemRect;
+ wxRect lastItemRect;
+ GetItemRect(0, firstItemRect);
+ GetItemRect(GetItemCount() - 1, lastItemRect);
+ int x = firstItemRect.GetX();
+ dc.SetPen(pen);
+ dc.SetBrush(* wxTRANSPARENT_BRUSH);
+ for (col = 0; col < GetColumnCount(); col++)
+ {
+ int colWidth = GetColumnWidth(col);
+ x += colWidth;
+ dc.DrawLine(x - dev_x, firstItemRect.GetY() - 1 - dev_y,
+ x - dev_x, lastItemRect.GetBottom() + 1 - dev_y);
+ }
+ }
+ }
+ else // !report
+ {
+ size_t count = GetItemCount();
+ for ( size_t i = 0; i < count; i++ )
+ {
+ GetLine(i)->Draw( &dc );
+ }
+ }
+
+ if ( HasCurrent() && m_hasFocus )
+ {
+#ifdef __WXMAC__
+ // no rect outline, we already have the background color
+#else
+ dc.SetPen( *wxBLACK_PEN );
+ dc.SetBrush( *wxTRANSPARENT_BRUSH );
+ dc.DrawRectangle( GetLineHighlightRect(m_current) );
+#endif
+ }
+
+ dc.EndDrawing();
+}
+
+void wxListMainWindow::HighlightAll( bool on )
+{
+ if ( IsSingleSel() )
+ {
+ wxASSERT_MSG( !on, _T("can't do this in a single sel control") );
+
+ // we just have one item to turn off
+ if ( HasCurrent() && IsHighlighted(m_current) )
+ {
+ HighlightLine(m_current, FALSE);
+ RefreshLine(m_current);
+ }
+ }
+ else // multi sel
+ {
+ HighlightLines(0, GetItemCount() - 1, on);
+ }
+}
+
+void wxListMainWindow::SendNotify( size_t line,
+ wxEventType command,
+ wxPoint point )
+{
+ wxListEvent le( command, GetParent()->GetId() );
+ le.SetEventObject( GetParent() );
+ le.m_itemIndex = line;
+
+ // set only for events which have position
+ if ( point != wxDefaultPosition )
+ le.m_pointDrag = point;
+
+ GetLine(line)->GetItem( 0, le.m_item );
+ GetParent()->GetEventHandler()->ProcessEvent( le );
+}
+
+void wxListMainWindow::OnFocusLine( size_t WXUNUSED(line) )
+{
+// SendNotify( line, wxEVT_COMMAND_LIST_ITEM_FOCUSSED );
+}
+
+void wxListMainWindow::OnUnfocusLine( size_t WXUNUSED(line) )
+{
+// SendNotify( line, wxEVT_COMMAND_LIST_ITEM_UNFOCUSSED );
+}
+
+void wxListMainWindow::EditLabel( long item )
+{
+ wxCHECK_RET( (item >= 0) && ((size_t)item < GetItemCount()),
+ wxT("wrong index in wxListCtrl::EditLabel()") );
+
+ m_currentEdit = (size_t)item;
+
+ wxListEvent le( wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT, GetParent()->GetId() );
+ le.SetEventObject( GetParent() );
+ le.m_itemIndex = item;
+ wxListLineData *data = GetLine(m_currentEdit);
+ wxCHECK_RET( data, _T("invalid index in EditLabel()") );
+ data->GetItem( 0, le.m_item );
+ GetParent()->GetEventHandler()->ProcessEvent( le );
+
+ if (!le.IsAllowed())
+ return;
+
+ // We have to call this here because the label in question might just have
+ // been added and no screen update taken place.
+ if (m_dirty)
+ wxSafeYield();
+
+ wxClientDC dc(this);
+ PrepareDC( dc );
+
+ wxString s = data->GetText(0);
+ wxRect rectLabel = GetLineLabelRect(m_currentEdit);
+
+ rectLabel.x = dc.LogicalToDeviceX( rectLabel.x );
+ rectLabel.y = dc.LogicalToDeviceY( rectLabel.y );
+
+ wxListTextCtrl *text = new wxListTextCtrl
+ (
+ this, -1,
+ &m_renameAccept,
+ &m_renameRes,
+ this,
+ s,
+ wxPoint(rectLabel.x-4,rectLabel.y-4),
+ wxSize(rectLabel.width+11,rectLabel.height+8)
+ );
+ text->SetFocus();
+}
+
+void wxListMainWindow::OnRenameTimer()
+{
+ wxCHECK_RET( HasCurrent(), wxT("unexpected rename timer") );
+
+ EditLabel( m_current );
+}
+
+void wxListMainWindow::OnRenameAccept()
+{
+ wxListEvent le( wxEVT_COMMAND_LIST_END_LABEL_EDIT, GetParent()->GetId() );
+ le.SetEventObject( GetParent() );
+ le.m_itemIndex = m_currentEdit;
+
+ wxListLineData *data = GetLine(m_currentEdit);
+ wxCHECK_RET( data, _T("invalid index in OnRenameAccept()") );
+
+ data->GetItem( 0, le.m_item );
+ le.m_item.m_text = m_renameRes;
+ GetParent()->GetEventHandler()->ProcessEvent( le );
+
+ if (!le.IsAllowed()) return;
+
+ wxListItem info;
+ info.m_mask = wxLIST_MASK_TEXT;
+ info.m_itemId = le.m_itemIndex;
+ info.m_text = m_renameRes;
+ info.SetTextColour(le.m_item.GetTextColour());
+ SetItem( info );
+}
+
+void wxListMainWindow::OnMouse( wxMouseEvent &event )
+{
+ event.SetEventObject( GetParent() );
+ if ( GetParent()->GetEventHandler()->ProcessEvent( event) )
+ return;
+
+ if ( !HasCurrent() || IsEmpty() )
+ return;
+
+ if (m_dirty)
+ return;
+
+ if ( !(event.Dragging() || event.ButtonDown() || event.LeftUp() ||
+ event.ButtonDClick()) )
+ return;
+
+ int x = event.GetX();
+ int y = event.GetY();
+ CalcUnscrolledPosition( x, y, &x, &y );
+
+ // where did we hit it (if we did)?
+ long hitResult = 0;
+
+ size_t count = GetItemCount(),
+ current;
+
+ if ( HasFlag(wxLC_REPORT) )
+ {
+ current = y / GetLineHeight();
+ if ( current < count )
+ hitResult = HitTestLine(current, x, y);
+ }
+ else // !report
+ {
+ // TODO: optimize it too! this is less simple than for report view but
+ // enumerating all items is still not a way to do it!!
+ for ( current = 0; current < count; current++ )
+ {
+ hitResult = HitTestLine(current, x, y);
+ if ( hitResult )
+ break;
+ }
+ }
+
+ if (event.Dragging())
+ {
+ if (m_dragCount == 0)
+ m_dragStart = wxPoint(x,y);
+
+ m_dragCount++;
+
+ if (m_dragCount != 3)
+ return;
+
+ int command = event.RightIsDown() ? wxEVT_COMMAND_LIST_BEGIN_RDRAG
+ : wxEVT_COMMAND_LIST_BEGIN_DRAG;
+
+ wxListEvent le( command, GetParent()->GetId() );
+ le.SetEventObject( GetParent() );
+ le.m_pointDrag = m_dragStart;
+ GetParent()->GetEventHandler()->ProcessEvent( le );
+
+ return;
+ }
+ else
+ {
+ m_dragCount = 0;
+ }
+
+ if ( !hitResult )
+ {
+ // outside of any item
+ return;
+ }
+
+ bool forceClick = FALSE;
+ if (event.ButtonDClick())
+ {
+ m_renameTimer->Stop();
+ m_lastOnSame = FALSE;
+
+ if ( current == m_lineBeforeLastClicked )
+ {
+ SendNotify( current, wxEVT_COMMAND_LIST_ITEM_ACTIVATED );
+
+ return;
+ }
+ else
+ {
+ // the first click was on another item, so don't interpret this as
+ // a double click, but as a simple click instead
+ forceClick = TRUE;
+ }
+ }
+
+ if (event.LeftUp() && m_lastOnSame)
+ {
+ if ((current == m_current) &&
+ (hitResult == wxLIST_HITTEST_ONITEMLABEL) &&
+ HasFlag(wxLC_EDIT_LABELS) )
+ {
+ m_renameTimer->Start( 100, TRUE );
+ }
+ m_lastOnSame = FALSE;
+ }
+ else if (event.RightDown())
+ {
+ SendNotify( current, wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK,
+ event.GetPosition() );
+ }
+ else if (event.MiddleDown())
+ {
+ SendNotify( current, wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK );
+ }
+ else if ( event.LeftDown() || forceClick )
+ {
+ m_lineBeforeLastClicked = m_lineLastClicked;
+ m_lineLastClicked = current;
+
+ size_t oldCurrent = m_current;
+
+ if ( IsSingleSel() || !(event.ControlDown() || event.ShiftDown()) )
+ {
+ HighlightAll( FALSE );
+ m_current = current;
+
+ ReverseHighlight(m_current);
+ }
+ else // multi sel & either ctrl or shift is down
+ {
+ if (event.ControlDown())
+ {
+ m_current = current;
+
+ ReverseHighlight(m_current);
+ }
+ else if (event.ShiftDown())
+ {
+ m_current = current;
+
+ size_t lineFrom = oldCurrent,
+ lineTo = current;
+
+ if ( lineTo < lineFrom )
+ {
+ lineTo = lineFrom;
+ lineFrom = m_current;
+ }
+
+ HighlightLines(lineFrom, lineTo);
+ }
+ else // !ctrl, !shift
+ {
+ // test in the enclosing if should make it impossible
+ wxFAIL_MSG( _T("how did we get here?") );
+ }
+ }
+
+ if (m_current != oldCurrent)
+ {
+ RefreshLine( oldCurrent );
+ OnUnfocusLine( oldCurrent );
+ OnFocusLine( m_current );
+ }
+
+ // forceClick is only set if the previous click was on another item
+ m_lastOnSame = !forceClick && (m_current == oldCurrent);
+ }
+}
+
+void wxListMainWindow::MoveToFocus()
+{
+ if ( !HasCurrent() )
+ return;
+
+ wxRect rect = GetLineRect(m_current);
+
+ int client_w, client_h;
+ GetClientSize( &client_w, &client_h );
+
+ int view_x = m_xScroll*GetScrollPos( wxHORIZONTAL );
+ int view_y = m_yScroll*GetScrollPos( wxVERTICAL );
+
+ if ( HasFlag(wxLC_REPORT) )
+ {
+ // the next we need the range of lines shown it might be different, so
+ // recalculate it
+ ResetVisibleLinesRange();
+
+ if (rect.y < view_y )
+ Scroll( -1, rect.y/m_yScroll );
+ if (rect.y+rect.height+5 > view_y+client_h)
+ Scroll( -1, (rect.y+rect.height-client_h+SCROLL_UNIT_Y)/m_yScroll );
+ }
+ else // !report
+ {
+ if (rect.x-view_x < 5)
+ Scroll( (rect.x-5)/m_xScroll, -1 );
+ if (rect.x+rect.width-5 > view_x+client_w)
+ Scroll( (rect.x+rect.width-client_w+SCROLL_UNIT_X)/m_xScroll, -1 );
+ }
+}
+
+// ----------------------------------------------------------------------------
+// keyboard handling
+// ----------------------------------------------------------------------------
+
+void wxListMainWindow::OnArrowChar(size_t newCurrent, const wxKeyEvent& event)
+{
+ wxCHECK_RET( newCurrent < (size_t)GetItemCount(),
+ _T("invalid item index in OnArrowChar()") );
+
+ size_t oldCurrent = m_current;
+
+ // in single selection we just ignore Shift as we can't select several
+ // items anyhow
+ if ( event.ShiftDown() && !IsSingleSel() )
+ {
+ m_current = newCurrent;
+
+ // select all the items between the old and the new one
+ if ( oldCurrent > newCurrent )
+ {
+ newCurrent = oldCurrent;
+ oldCurrent = m_current;
+ }
+
+ HighlightLines(oldCurrent, newCurrent);
+ }
+ else // !shift
+ {
+ // all previously selected items are unselected unless ctrl is held
+ if ( !event.ControlDown() )
+ HighlightAll(FALSE);
+
+ m_current = newCurrent;
+
+ HighlightLine( oldCurrent, FALSE );
+ RefreshLine( oldCurrent );
+
+ if ( !event.ControlDown() )
+ {
+ HighlightLine( m_current, TRUE );
+ }
+ }
+
+ OnUnfocusLine( oldCurrent );
+ OnFocusLine( m_current );
+ RefreshLine( m_current );
+
+ MoveToFocus();
+}
+
+void wxListMainWindow::OnKeyDown( wxKeyEvent &event )
+{
+ wxWindow *parent = GetParent();
+
+ /* we propagate the key event up */
+ wxKeyEvent ke( wxEVT_KEY_DOWN );
+ ke.m_shiftDown = event.m_shiftDown;
+ ke.m_controlDown = event.m_controlDown;
+ ke.m_altDown = event.m_altDown;
+ ke.m_metaDown = event.m_metaDown;
+ ke.m_keyCode = event.m_keyCode;
+ ke.m_x = event.m_x;
+ ke.m_y = event.m_y;
+ ke.SetEventObject( parent );
+ if (parent->GetEventHandler()->ProcessEvent( ke )) return;
+
+ event.Skip();
+}
+
+void wxListMainWindow::OnChar( wxKeyEvent &event )
+{
+ wxWindow *parent = GetParent();
+
+ /* we send a list_key event up */
+ if ( HasCurrent() )
+ {
+ wxListEvent le( wxEVT_COMMAND_LIST_KEY_DOWN, GetParent()->GetId() );
+ le.m_itemIndex = m_current;
+ GetLine(m_current)->GetItem( 0, le.m_item );
+ le.m_code = (int)event.KeyCode();
+ le.SetEventObject( parent );
+ parent->GetEventHandler()->ProcessEvent( le );
+ }
+
+ /* we propagate the char event up */
+ wxKeyEvent ke( wxEVT_CHAR );
+ ke.m_shiftDown = event.m_shiftDown;
+ ke.m_controlDown = event.m_controlDown;
+ ke.m_altDown = event.m_altDown;
+ ke.m_metaDown = event.m_metaDown;
+ ke.m_keyCode = event.m_keyCode;
+ ke.m_x = event.m_x;
+ ke.m_y = event.m_y;
+ ke.SetEventObject( parent );
+ if (parent->GetEventHandler()->ProcessEvent( ke )) return;
+
+ if (event.KeyCode() == WXK_TAB)
+ {
+ wxNavigationKeyEvent nevent;
+ nevent.SetWindowChange( event.ControlDown() );
+ nevent.SetDirection( !event.ShiftDown() );
+ nevent.SetEventObject( GetParent()->GetParent() );
+ nevent.SetCurrentFocus( m_parent );
+ if (GetParent()->GetParent()->GetEventHandler()->ProcessEvent( nevent )) return;
+ }
+
+ /* no item -> nothing to do */
+ if (!HasCurrent())
+ {
+ event.Skip();
+ return;
+ }
+
+ switch (event.KeyCode())
+ {
+ case WXK_UP:
+ if ( m_current > 0 )
+ OnArrowChar( m_current - 1, event );
+ break;
+
+ case WXK_DOWN:
+ if ( m_current < (size_t)GetItemCount() - 1 )
+ OnArrowChar( m_current + 1, event );
+ break;
+
+ case WXK_END:
+ if (!IsEmpty())
+ OnArrowChar( GetItemCount() - 1, event );
+ break;
+
+ case WXK_HOME:
+ if (!IsEmpty())
+ OnArrowChar( 0, event );
+ break;
+
+ case WXK_PRIOR:
+ {
+ int steps = 0;
+ if ( HasFlag(wxLC_REPORT) )
+ {
+ steps = m_linesPerPage - 1;
+ }
+ else
+ {
+ steps = m_current % m_linesPerPage;
+ }
+
+ int index = m_current - steps;
+ if (index < 0)
+ index = 0;
+
+ OnArrowChar( index, event );
+ }
+ break;
+
+ case WXK_NEXT:
+ {
+ int steps = 0;
+ if ( HasFlag(wxLC_REPORT) )
+ {
+ steps = m_linesPerPage - 1;
+ }
+ else
+ {
+ steps = m_linesPerPage - (m_current % m_linesPerPage) - 1;
+ }
+
+ size_t index = m_current + steps;
+ size_t count = GetItemCount();
+ if ( index >= count )
+ index = count - 1;
+
+ OnArrowChar( index, event );
+ }
+ break;
+
+ case WXK_LEFT:
+ if ( !HasFlag(wxLC_REPORT) )
+ {
+ int index = m_current - m_linesPerPage;
+ if (index < 0)
+ index = 0;
+
+ OnArrowChar( index, event );
+ }
+ break;
+
+ case WXK_RIGHT:
+ if ( !HasFlag(wxLC_REPORT) )
+ {
+ size_t index = m_current + m_linesPerPage;
+
+ size_t count = GetItemCount();
+ if ( index >= count )
+ index = count - 1;
+
+ OnArrowChar( index, event );
+ }
+ break;
+
+ case WXK_SPACE:
+ if ( IsSingleSel() )
+ {
+ wxListEvent le( wxEVT_COMMAND_LIST_ITEM_ACTIVATED,
+ GetParent()->GetId() );
+ le.SetEventObject( GetParent() );
+ le.m_itemIndex = m_current;
+ GetLine(m_current)->GetItem( 0, le.m_item );
+ GetParent()->GetEventHandler()->ProcessEvent( le );
+ }
+ else
+ {
+ ReverseHighlight(m_current);
+ }
+ break;
+
+ case WXK_RETURN:
+ case WXK_EXECUTE:
+ {
+ wxListEvent le( wxEVT_COMMAND_LIST_ITEM_ACTIVATED,
+ GetParent()->GetId() );
+ le.SetEventObject( GetParent() );
+ le.m_itemIndex = m_current;
+ GetLine(m_current)->GetItem( 0, le.m_item );
+ GetParent()->GetEventHandler()->ProcessEvent( le );
+ }
+ break;
+
+ default:
+ event.Skip();
+ }
+}
+
+// ----------------------------------------------------------------------------
+// focus handling
+// ----------------------------------------------------------------------------
+
+#ifdef __WXGTK__
+extern wxWindow *g_focusWindow;
+#endif
+
+void wxListMainWindow::OnSetFocus( wxFocusEvent &WXUNUSED(event) )
+{
+ m_hasFocus = TRUE;
+
+ if ( HasCurrent() )
+ RefreshLine( m_current );
+
+ if (!GetParent())
+ return;
+
+#ifdef __WXGTK__
+ g_focusWindow = GetParent();
+#endif
+
+ wxFocusEvent event( wxEVT_SET_FOCUS, GetParent()->GetId() );
+ event.SetEventObject( GetParent() );
+ GetParent()->GetEventHandler()->ProcessEvent( event );
+}
+
+void wxListMainWindow::OnKillFocus( wxFocusEvent &WXUNUSED(event) )
+{
+ m_hasFocus = FALSE;
+
+ if ( HasCurrent() )
+ RefreshLine( m_current );
+}
+
+void wxListMainWindow::DrawImage( int index, wxDC *dc, int x, int y )
+{
+ if ( HasFlag(wxLC_ICON) && (m_normal_image_list))
+ {
+ m_normal_image_list->Draw( index, *dc, x, y, wxIMAGELIST_DRAW_TRANSPARENT );
+ }
+ else if ( HasFlag(wxLC_SMALL_ICON) && (m_small_image_list))
+ {
+ m_small_image_list->Draw( index, *dc, x, y, wxIMAGELIST_DRAW_TRANSPARENT );
+ }
+ else if ( HasFlag(wxLC_LIST) && (m_small_image_list))
+ {
+ m_small_image_list->Draw( index, *dc, x, y, wxIMAGELIST_DRAW_TRANSPARENT );
+ }
+ else if ( HasFlag(wxLC_REPORT) && (m_small_image_list))
+ {
+ m_small_image_list->Draw( index, *dc, x, y, wxIMAGELIST_DRAW_TRANSPARENT );
+ }
+}
+
+void wxListMainWindow::GetImageSize( int index, int &width, int &height ) const
+{
+ if ( HasFlag(wxLC_ICON) && m_normal_image_list )
+ {
+ m_normal_image_list->GetSize( index, width, height );
+ }
+ else if ( HasFlag(wxLC_SMALL_ICON) && m_small_image_list )
+ {
+ m_small_image_list->GetSize( index, width, height );
+ }
+ else if ( HasFlag(wxLC_LIST) && m_small_image_list )
+ {
+ m_small_image_list->GetSize( index, width, height );
+ }
+ else if ( HasFlag(wxLC_REPORT) && m_small_image_list )
+ {
+ m_small_image_list->GetSize( index, width, height );
+ }
+ else
+ {
+ width =
+ height = 0;
+ }
+}
+
+int wxListMainWindow::GetTextLength( const wxString &s ) const
+{
+ wxClientDC dc( wxConstCast(this, wxListMainWindow) );
+ dc.SetFont( GetFont() );
+
+ wxCoord lw;
+ dc.GetTextExtent( s, &lw, NULL );
+
+ return lw + AUTOSIZE_COL_MARGIN;
+}
+
+void wxListMainWindow::SetImageList( wxImageList *imageList, int which )
+{
+ m_dirty = TRUE;
+
+ // calc the spacing from the icon size
+ int width = 0,
+ height = 0;
+ if ((imageList) && (imageList->GetImageCount()) )
+ {
+ imageList->GetSize(0, width, height);
+ }
+
+ if (which == wxIMAGE_LIST_NORMAL)
+ {
+ m_normal_image_list = imageList;
+ m_normal_spacing = width + 8;
+ }
+
+ if (which == wxIMAGE_LIST_SMALL)
+ {
+ m_small_image_list = imageList;
+ m_small_spacing = width + 14;
+ }
+}
+
+void wxListMainWindow::SetItemSpacing( int spacing, bool isSmall )
+{
+ m_dirty = TRUE;
+ if (isSmall)
+ {
+ m_small_spacing = spacing;
+ }
+ else
+ {
+ m_normal_spacing = spacing;
+ }
+}
+
+int wxListMainWindow::GetItemSpacing( bool isSmall )
+{
+ return isSmall ? m_small_spacing : m_normal_spacing;
+}
+
+// ----------------------------------------------------------------------------
+// columns
+// ----------------------------------------------------------------------------
+
+void wxListMainWindow::SetColumn( int col, wxListItem &item )
+{
+ wxListHeaderDataList::Node *node = m_columns.Item( col );
+
+ wxCHECK_RET( node, _T("invalid column index in SetColumn") );
+
+ if ( item.m_width == wxLIST_AUTOSIZE_USEHEADER )
+ item.m_width = GetTextLength( item.m_text );
+
+ wxListHeaderData *column = node->GetData();
+ column->SetItem( item );
+
+ wxListHeaderWindow *headerWin = GetListCtrl()->m_headerWin;
+ if ( headerWin )
+ headerWin->m_dirty = TRUE;
+
+ m_dirty = TRUE;
+
+ // invalidate it as it has to be recalculated
+ m_headerWidth = 0;
+}
+
+void wxListMainWindow::SetColumnWidth( int col, int width )
+{
+ wxCHECK_RET( col >= 0 && col < GetColumnCount(),
+ _T("invalid column index") );
+
+ wxCHECK_RET( HasFlag(wxLC_REPORT),
+ _T("SetColumnWidth() can only be called in report mode.") );
+
+ m_dirty = TRUE;
+
+ wxListHeaderDataList::Node *node = m_columns.Item( col );
+ wxCHECK_RET( node, _T("no column?") );
+
+ wxListHeaderData *column = node->GetData();
+
+ size_t count = GetItemCount();
+
+ if (width == wxLIST_AUTOSIZE_USEHEADER)
+ {
+ width = GetTextLength(column->GetText());
+ }
+ else if ( width == wxLIST_AUTOSIZE )
+ {
+ if ( IsVirtual() )
+ {
+ // TODO: determine the max width somehow...
+ width = WIDTH_COL_DEFAULT;
+ }
+ else // !virtual
+ {
+ wxClientDC dc(this);
+ dc.SetFont( GetFont() );
+
+ int max = AUTOSIZE_COL_MARGIN;
+
+ for ( size_t i = 0; i < count; i++ )
+ {
+ wxListLineData *line = GetLine(i);
+ wxListItemDataList::Node *n = line->m_items.Item( col );
+
+ wxCHECK_RET( n, _T("no subitem?") );
+
+ wxListItemData *item = n->GetData();
+ int current = 0;
+
+ if (item->HasImage())
+ {
+ int ix, iy;
+ GetImageSize( item->GetImage(), ix, iy );
+ current += ix + 5;
+ }
+
+ if (item->HasText())
+ {
+ wxCoord w;
+ dc.GetTextExtent( item->GetText(), &w, NULL );
+ current += w;
+ }
+
+ if (current > max)
+ max = current;
+ }
+
+ width = max + AUTOSIZE_COL_MARGIN;
+ }
+ }
+
+ column->SetWidth( width );
+
+ // invalidate it as it has to be recalculated
+ m_headerWidth = 0;
+}
+
+int wxListMainWindow::GetHeaderWidth() const
+{
+ if ( !m_headerWidth )
+ {
+ wxListMainWindow *self = wxConstCast(this, wxListMainWindow);
+
+ size_t count = GetColumnCount();
+ for ( size_t col = 0; col < count; col++ )
+ {
+ self->m_headerWidth += GetColumnWidth(col);
+ }
+ }
+
+ return m_headerWidth;
+}
+
+void wxListMainWindow::GetColumn( int col, wxListItem &item ) const
+{
+ wxListHeaderDataList::Node *node = m_columns.Item( col );
+ wxCHECK_RET( node, _T("invalid column index in GetColumn") );
+
+ wxListHeaderData *column = node->GetData();
+ column->GetItem( item );
+}
+
+int wxListMainWindow::GetColumnWidth( int col ) const
+{
+ wxListHeaderDataList::Node *node = m_columns.Item( col );
+ wxCHECK_MSG( node, 0, _T("invalid column index") );
+
+ wxListHeaderData *column = node->GetData();
+ return column->GetWidth();
+}
+
+// ----------------------------------------------------------------------------
+// item state
+// ----------------------------------------------------------------------------
+
+void wxListMainWindow::SetItem( wxListItem &item )
+{
+ long id = item.m_itemId;
+ wxCHECK_RET( id >= 0 && (size_t)id < GetItemCount(),
+ _T("invalid item index in SetItem") );
+
+ if ( !IsVirtual() )
+ {
+ wxListLineData *line = GetLine((size_t)id);
+ line->SetItem( item.m_col, item );
+ }
+
+ if ( InReportView() )
+ {
+ // just refresh the line to show the new value of the text/image
+ RefreshLine((size_t)id);
+ }
+ else // !report
+ {
+ // refresh everything (resulting in horrible flicker - FIXME!)
+ m_dirty = TRUE;
+ }
+}
+
+void wxListMainWindow::SetItemState( long litem, long state, long stateMask )
+{
+ wxCHECK_RET( litem >= 0 && (size_t)litem < GetItemCount(),
+ _T("invalid list ctrl item index in SetItem") );
+
+ size_t oldCurrent = m_current;
+ size_t item = (size_t)litem; // sdafe because of the check above
+
+ if ( stateMask & wxLIST_STATE_FOCUSED )
+ {
+ if ( state & wxLIST_STATE_FOCUSED )
+ {
+ // don't do anything if this item is already focused
+ if ( item != m_current )
+ {
+ OnUnfocusLine( m_current );
+ m_current = item;
+ OnFocusLine( m_current );
+
+ if ( IsSingleSel() && (oldCurrent != (size_t)-1) )
+ {
+ HighlightLine(oldCurrent, FALSE);
+ RefreshLine(oldCurrent);
+ }
+
+ RefreshLine( m_current );
+ }
+ }
+ else // unfocus
+ {
+ // don't do anything if this item is not focused
+ if ( item == m_current )
+ {
+ OnUnfocusLine( m_current );
+ m_current = (size_t)-1;
+ }
+ }
+ }
+
+ if ( stateMask & wxLIST_STATE_SELECTED )
+ {
+ bool on = (state & wxLIST_STATE_SELECTED) != 0;
+
+ if ( IsSingleSel() )
+ {
+ if ( on )
+ {
+ // selecting the item also makes it the focused one in the
+ // single sel mode
+ if ( m_current != item )
+ {
+ OnUnfocusLine( m_current );
+ m_current = item;
+ OnFocusLine( m_current );
+
+ if ( oldCurrent != (size_t)-1 )
+ {
+ HighlightLine( oldCurrent, FALSE );
+ RefreshLine( oldCurrent );
+ }
+ }
+ }
+ else // off
+ {
+ // only the current item may be selected anyhow
+ if ( item != m_current )
+ return;
+ }
+ }
+
+ if ( HighlightLine(item, on) )
+ {
+ RefreshLine(item);
+ }
+ }