move Ellipsize() to wxControl so it can be easily used by other controls

[wxWidgets.git] / src / generic / headerctrlg.cpp

diff --git a/src/generic/headerctrlg.cpp b/src/generic/headerctrlg.cpp
index c4e6d1eaa904d764a9388b699b3c0e08f80a13a5..37d848fc184d9a4ddfef2ed873e1be3978494c02 100644 (file)
--- a/src/generic/headerctrlg.cpp
+++ b/src/generic/headerctrlg.cpp
@@ -58,7 +58,9 @@ void wxHeaderCtrl::Init()
 {
     m_numColumns = 0;
     m_hover =
 {
     m_numColumns = 0;
     m_hover =

-    m_colBeingResized = COL_NONE;
+    m_colBeingResized =
+    m_colBeingReordered = COL_NONE;
+    m_dragOffset = 0;

     m_scrollOffset = 0;
 }
 
     m_scrollOffset = 0;
 }
 


@@ -90,8 +92,12 @@ wxHeaderCtrl::~wxHeaderCtrl()
 
 void wxHeaderCtrl::DoSetCount(unsigned int count)
 {
 
 void wxHeaderCtrl::DoSetCount(unsigned int count)
 {

+    // update the column indices order array before changing m_numColumns
+    DoResizeColumnIndices(m_colIndices, count);
+

     m_numColumns = count;
 
     m_numColumns = count;
 

+    InvalidateBestSize();

     Refresh();
 }
 
     Refresh();
 }
 


@@ -102,6 +108,8 @@ unsigned int wxHeaderCtrl::DoGetCount() const
 
 void wxHeaderCtrl::DoUpdate(unsigned int idx)
 {
 
 void wxHeaderCtrl::DoUpdate(unsigned int idx)
 {

+    InvalidateBestSize();
+

     // we need to refresh not only this column but also the ones after it in
     // case it was shown or hidden or its width changed -- it would be nice to
     // avoid doing this unnecessary by storing the old column width (TODO)
     // we need to refresh not only this column but also the ones after it in
     // case it was shown or hidden or its width changed -- it would be nice to
     // avoid doing this unnecessary by storing the old column width (TODO)


@@ -128,17 +136,23 @@ wxSize wxHeaderCtrl::DoGetBestSize() const
 {
     // the vertical size is rather arbitrary but it looks better if we leave
     // some space around the text
 {
     // the vertical size is rather arbitrary but it looks better if we leave
     // some space around the text

-    return wxSize(GetColStart(GetColumnCount()), (7*GetCharHeight())/4);
+    const wxSize size(IsEmpty() ? wxHeaderCtrlBase::DoGetBestSize().x
+                                : GetColEnd(GetColumnCount() - 1),
+                      (7*GetCharHeight())/4);
+    CacheBestSize(size);
+    return size;

 }
 
 int wxHeaderCtrl::GetColStart(unsigned int idx) const
 {
 }
 
 int wxHeaderCtrl::GetColStart(unsigned int idx) const
 {

-    wxHeaderCtrl * const self = const_cast<wxHeaderCtrl *>(this);
-

     int pos = m_scrollOffset;
     int pos = m_scrollOffset;

-    for ( unsigned n = 0; n < idx; n++ )
+    for ( unsigned n = 0; ; n++ )

     {
     {

-        const wxHeaderColumnBase& col = self->GetColumn(n);
+        const unsigned i = m_colIndices[n];
+        if ( i == idx )
+            break;
+
+        const wxHeaderColumn& col = GetColumn(i);

         if ( col.IsShown() )
             pos += col.GetWidth();
     }
         if ( col.IsShown() )
             pos += col.GetWidth();
     }


@@ -146,15 +160,21 @@ int wxHeaderCtrl::GetColStart(unsigned int idx) const
     return pos;
 }
 
     return pos;
 }
 

-int wxHeaderCtrl::FindColumnAtPos(int x, bool& onSeparator) const
+int wxHeaderCtrl::GetColEnd(unsigned int idx) const

 {
 {

-    wxHeaderCtrl * const self = const_cast<wxHeaderCtrl *>(this);
+    int x = GetColStart(idx);

 
 

+    return x + GetColumn(idx).GetWidth();
+}
+
+unsigned int wxHeaderCtrl::FindColumnAtPoint(int x, bool *onSeparator) const
+{

     int pos = 0;
     const unsigned count = GetColumnCount();
     for ( unsigned n = 0; n < count; n++ )
     {
     int pos = 0;
     const unsigned count = GetColumnCount();
     for ( unsigned n = 0; n < count; n++ )
     {

-        const wxHeaderColumnBase& col = self->GetColumn(n);
+        const unsigned idx = m_colIndices[n];
+        const wxHeaderColumn& col = GetColumn(idx);

         if ( col.IsHidden() )
             continue;
 
         if ( col.IsHidden() )
             continue;
 


@@ -166,18 +186,22 @@ int wxHeaderCtrl::FindColumnAtPos(int x, bool& onSeparator) const
         // TODO: don't hardcode sensitivity
         if ( col.IsResizeable() && abs(x - pos) < 8 )
         {
         // TODO: don't hardcode sensitivity
         if ( col.IsResizeable() && abs(x - pos) < 8 )
         {

-            onSeparator = true;
-            return n;
+            if ( onSeparator )
+                *onSeparator = true;
+            return idx;

         }
 
         // inside this column?
         if ( x < pos )
         {
         }
 
         // inside this column?
         if ( x < pos )
         {

-            onSeparator = false;
-            return n;
+            if ( onSeparator )
+                *onSeparator = false;
+            return idx;

         }
     }
 
         }
     }
 

+    if ( onSeparator )
+        *onSeparator = false;

     return COL_NONE;
 }
 
     return COL_NONE;
 }
 


@@ -211,30 +235,45 @@ void wxHeaderCtrl::RefreshColsAfter(unsigned int idx)
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// wxHeaderCtrl dragging
+// wxHeaderCtrl dragging/resizing/reordering

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

+bool wxHeaderCtrl::IsResizing() const
+{
+    return m_colBeingResized != COL_NONE;
+}
+
+bool wxHeaderCtrl::IsReordering() const
+{
+    return m_colBeingReordered != COL_NONE;
+}
+
+void wxHeaderCtrl::ClearMarkers()
+{
+    wxClientDC dc(this);
+
+    wxDCOverlay dcover(m_overlay, &dc);
+    dcover.Clear();
+}
+

 void wxHeaderCtrl::UpdateResizingMarker(int xPhysical)
 {
 void wxHeaderCtrl::UpdateResizingMarker(int xPhysical)
 {

-    // unfortunately drawing the marker over the parent window doesn't work as
-    // it's usually covered by another window (the main control view) so just
-    // draw the marker over the header itself, even if it makes it not very
-    // useful

     wxClientDC dc(this);
 
     wxDCOverlay dcover(m_overlay, &dc);
     dcover.Clear();
 
     wxClientDC dc(this);
 
     wxDCOverlay dcover(m_overlay, &dc);
     dcover.Clear();
 

-    if ( xPhysical != -1 )
-    {
-        dc.SetPen(*wxLIGHT_GREY_PEN);
-        dc.DrawLine(xPhysical, 0, xPhysical, GetClientSize().y);
-    }
+    // unfortunately drawing the marker over the parent window doesn't work as
+    // it's usually covered by another window (the main control view) so just
+    // draw the marker over the header itself, even if it makes it not very
+    // useful
+    dc.SetPen(*wxLIGHT_GREY_PEN);
+    dc.DrawLine(xPhysical, 0, xPhysical, GetClientSize().y);

 }
 
 void wxHeaderCtrl::EndDragging()
 {
 }
 
 void wxHeaderCtrl::EndDragging()
 {

-    UpdateResizingMarker(-1);
+    ClearMarkers();

 
     m_overlay.Reset();
 
 
     m_overlay.Reset();
 


@@ -242,31 +281,200 @@ void wxHeaderCtrl::EndDragging()
     SetCursor(wxNullCursor);
 }
 
     SetCursor(wxNullCursor);
 }
 

-void wxHeaderCtrl::EndResizing(int width)
+void wxHeaderCtrl::CancelDragging()
+{
+    wxASSERT_MSG( IsDragging(),
+                  "shouldn't be called if we're not dragging anything" );
+
+    EndDragging();
+
+    unsigned int& col = IsResizing() ? m_colBeingResized : m_colBeingReordered;
+
+    wxHeaderCtrlEvent event(wxEVT_COMMAND_HEADER_DRAGGING_CANCELLED, GetId());
+    event.SetEventObject(this);
+    event.SetColumn(col);
+
+    GetEventHandler()->ProcessEvent(event);
+
+    col = COL_NONE;
+}
+
+int wxHeaderCtrl::ConstrainByMinWidth(unsigned int col, int& xPhysical)

 {
 {

-    wxASSERT_MSG( m_colBeingResized != COL_NONE,
-                  "shouldn't be called if we're not resizing" );
+    const int xStart = GetColStart(col);
+
+    // notice that GetMinWidth() returns 0 if there is no minimal width so it
+    // still makes sense to use it even in this case
+    const int xMinEnd = xStart + GetColumn(col).GetMinWidth();
+
+    if ( xPhysical < xMinEnd )
+        xPhysical = xMinEnd;
+
+    return xPhysical - xStart;
+}
+
+void wxHeaderCtrl::StartOrContinueResizing(unsigned int col, int xPhysical)
+{
+    wxHeaderCtrlEvent event(IsResizing() ? wxEVT_COMMAND_HEADER_RESIZING
+                                         : wxEVT_COMMAND_HEADER_BEGIN_RESIZE,
+                            GetId());
+    event.SetEventObject(this);
+    event.SetColumn(col);
+
+    event.SetWidth(ConstrainByMinWidth(col, xPhysical));
+
+    if ( GetEventHandler()->ProcessEvent(event) && !event.IsAllowed() )
+    {
+        if ( IsResizing() )
+        {
+            ReleaseMouse();
+            CancelDragging();
+        }
+        //else: nothing to do -- we just don't start to resize
+    }
+    else // go ahead with resizing
+    {
+        if ( !IsResizing() )
+        {
+            m_colBeingResized = col;
+            SetCursor(wxCursor(wxCURSOR_SIZEWE));
+            CaptureMouse();
+        }
+        //else: we had already done the above when we started
+
+        UpdateResizingMarker(xPhysical);
+    }
+}
+
+void wxHeaderCtrl::EndResizing(int xPhysical)
+{
+    wxASSERT_MSG( IsResizing(), "shouldn't be called if we're not resizing" );

 
     EndDragging();
 
 
     EndDragging();
 

-    // if dragging was cancelled we must have already lost the mouse capture so
-    // don't try to release it
-    if ( width != -1 )
-        ReleaseMouse();
+    ReleaseMouse();

 
 

-    wxHeaderCtrlEvent event(wxEVT_COMMAND_HEADER_END_DRAG, GetId());
+    wxHeaderCtrlEvent event(wxEVT_COMMAND_HEADER_END_RESIZE, GetId());

     event.SetEventObject(this);
     event.SetColumn(m_colBeingResized);
     event.SetEventObject(this);
     event.SetColumn(m_colBeingResized);

-    if ( width == -1 )
-        event.SetCancelled();
-    else
-        event.SetWidth(width);
+    event.SetWidth(ConstrainByMinWidth(m_colBeingResized, xPhysical));

 
     GetEventHandler()->ProcessEvent(event);
 
     m_colBeingResized = COL_NONE;
 }
 
 
     GetEventHandler()->ProcessEvent(event);
 
     m_colBeingResized = COL_NONE;
 }
 

+void wxHeaderCtrl::UpdateReorderingMarker(int xPhysical)
+{
+    wxClientDC dc(this);
+
+    wxDCOverlay dcover(m_overlay, &dc);
+    dcover.Clear();
+
+    dc.SetPen(*wxBLUE);
+    dc.SetBrush(*wxTRANSPARENT_BRUSH);
+
+    // draw the phantom position of the column being dragged
+    int x = xPhysical - m_dragOffset;
+    int y = GetClientSize().y;
+    dc.DrawRectangle(x, 0,
+                     GetColumn(m_colBeingReordered).GetWidth(), y);
+
+    // and also a hint indicating where it is going to be inserted if it's
+    // dropped now
+    unsigned int col = FindColumnAtPoint(xPhysical);
+    if ( col != COL_NONE )
+    {
+        static const int DROP_MARKER_WIDTH = 4;
+
+        dc.SetBrush(*wxBLUE);
+        dc.DrawRectangle(GetColEnd(col) - DROP_MARKER_WIDTH/2, 0,
+                         DROP_MARKER_WIDTH, y);
+    }
+}
+
+void wxHeaderCtrl::StartReordering(unsigned int col, int xPhysical)
+{
+    wxHeaderCtrlEvent event(wxEVT_COMMAND_HEADER_BEGIN_REORDER, GetId());
+    event.SetEventObject(this);
+    event.SetColumn(col);
+
+    if ( GetEventHandler()->ProcessEvent(event) && !event.IsAllowed() )
+    {
+        // don't start dragging it, nothing to do otherwise
+        return;
+    }
+
+    m_dragOffset = xPhysical - GetColStart(col);
+
+    m_colBeingReordered = col;
+    SetCursor(wxCursor(wxCURSOR_HAND));
+    CaptureMouse();
+
+    // do not call UpdateReorderingMarker() here: we don't want to give
+    // feedback for reordering until the user starts to really move the mouse
+    // as he might want to just click on the column and not move it at all
+}
+
+bool wxHeaderCtrl::EndReordering(int xPhysical)
+{
+    wxASSERT_MSG( IsReordering(), "shouldn't be called if we're not reordering" );
+
+    EndDragging();
+
+    ReleaseMouse();
+
+    const int colOld = m_colBeingReordered,
+              colNew = FindColumnAtPoint(xPhysical);
+
+    m_colBeingReordered = COL_NONE;
+
+    if ( xPhysical - GetColStart(colOld) == m_dragOffset )
+        return false;
+
+    if ( colNew != colOld )
+    {
+        wxHeaderCtrlEvent event(wxEVT_COMMAND_HEADER_END_REORDER, GetId());
+        event.SetEventObject(this);
+        event.SetColumn(colOld);
+
+        const unsigned pos = GetColumnPos(FindColumnAtPoint(xPhysical));
+        event.SetNewOrder(pos);
+
+        if ( !GetEventHandler()->ProcessEvent(event) || event.IsAllowed() )
+        {
+            // do reorder the columns
+            DoMoveCol(colOld, pos);
+        }
+    }
+
+    // whether we moved the column or not, the user did move the mouse and so
+    // did try to do it so return true
+    return true;
+}
+
+// ----------------------------------------------------------------------------
+// wxHeaderCtrl column reordering
+// ----------------------------------------------------------------------------
+
+void wxHeaderCtrl::DoSetColumnsOrder(const wxArrayInt& order)
+{
+    m_colIndices = order;
+    Refresh();
+}
+
+wxArrayInt wxHeaderCtrl::DoGetColumnsOrder() const
+{
+    return m_colIndices;
+}
+
+void wxHeaderCtrl::DoMoveCol(unsigned int idx, unsigned int pos)
+{
+    MoveColumnInOrderArray(m_colIndices, idx, pos);
+
+    Refresh();
+}
+

 // ----------------------------------------------------------------------------
 // wxHeaderCtrl event handlers
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxHeaderCtrl event handlers
 // ----------------------------------------------------------------------------


@@ -277,6 +485,8 @@ BEGIN_EVENT_TABLE(wxHeaderCtrl, wxHeaderCtrlBase)
     EVT_MOUSE_EVENTS(wxHeaderCtrl::OnMouse)
 
     EVT_MOUSE_CAPTURE_LOST(wxHeaderCtrl::OnCaptureLost)
     EVT_MOUSE_EVENTS(wxHeaderCtrl::OnMouse)
 
     EVT_MOUSE_CAPTURE_LOST(wxHeaderCtrl::OnCaptureLost)

+
+    EVT_KEY_DOWN(wxHeaderCtrl::OnKeyDown)

 END_EVENT_TABLE()
 
 void wxHeaderCtrl::OnPaint(wxPaintEvent& WXUNUSED(event))
 END_EVENT_TABLE()
 
 void wxHeaderCtrl::OnPaint(wxPaintEvent& WXUNUSED(event))


@@ -296,7 +506,8 @@ void wxHeaderCtrl::OnPaint(wxPaintEvent& WXUNUSED(event))
     int xpos = 0;
     for ( unsigned int i = 0; i < count; i++ )
     {
     int xpos = 0;
     for ( unsigned int i = 0; i < count; i++ )
     {

-        const wxHeaderColumnBase& col = GetColumn(i);
+        const unsigned idx = m_colIndices[i];
+        const wxHeaderColumn& col = GetColumn(idx);

         if ( col.IsHidden() )
             continue;
 
         if ( col.IsHidden() )
             continue;
 


@@ -316,7 +527,7 @@ void wxHeaderCtrl::OnPaint(wxPaintEvent& WXUNUSED(event))
         int state = 0;
         if ( IsEnabled() )
         {
         int state = 0;
         if ( IsEnabled() )
         {

-            if ( i == m_hover )
+            if ( idx == m_hover )

                 state = wxCONTROL_CURRENT;
         }
         else // disabled
                 state = wxCONTROL_CURRENT;
         }
         else // disabled


@@ -345,8 +556,24 @@ void wxHeaderCtrl::OnPaint(wxPaintEvent& WXUNUSED(event))
 
 void wxHeaderCtrl::OnCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
 {
 
 void wxHeaderCtrl::OnCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
 {

-    if ( m_colBeingResized != COL_NONE )
-        EndResizing(-1);
+    if ( IsDragging() )
+        CancelDragging();
+}
+
+void wxHeaderCtrl::OnKeyDown(wxKeyEvent& event)
+{
+    if ( event.GetKeyCode() == WXK_ESCAPE )
+    {
+        if ( IsDragging() )
+        {
+            ReleaseMouse();
+            CancelDragging();
+
+            return;
+        }
+    }
+
+    event.Skip();

 }
 
 void wxHeaderCtrl::OnMouse(wxMouseEvent& mevent)
 }
 
 void wxHeaderCtrl::OnMouse(wxMouseEvent& mevent)


@@ -362,22 +589,38 @@ void wxHeaderCtrl::OnMouse(wxMouseEvent& mevent)
 
     // first deal with the [continuation of any] dragging operations in
     // progress
 
     // first deal with the [continuation of any] dragging operations in
     // progress

-    if ( m_colBeingResized != COL_NONE )
+    if ( IsResizing() )

     {
         if ( mevent.LeftUp() )
     {
         if ( mevent.LeftUp() )

-            EndResizing(xPhysical - GetColStart(m_colBeingResized));
+            EndResizing(xPhysical);

         else // update the live separator position
         else // update the live separator position

-            UpdateResizingMarker(xPhysical);
+            StartOrContinueResizing(m_colBeingResized, xPhysical);

 
         return;
     }
 
 
         return;
     }
 

+    if ( IsReordering() )
+    {
+        if ( !mevent.LeftUp() )
+        {
+            // update the column position
+            UpdateReorderingMarker(xPhysical);
+
+            return;
+        }
+
+        // finish reordering and continue to generate a click event below if we
+        // didn't really reorder anything
+        if ( EndReordering(xPhysical) )
+            return;
+    }
+

 
     // find if the event is over a column at all
     bool onSeparator;
     const unsigned col = mevent.Leaving()
                             ? (onSeparator = false, COL_NONE)
 
     // find if the event is over a column at all
     bool onSeparator;
     const unsigned col = mevent.Leaving()
                             ? (onSeparator = false, COL_NONE)

-                            : FindColumnAtPos(xLogical, onSeparator);
+                            : FindColumnAtPoint(xLogical, &onSeparator);

 
 
     // update the highlighted column if it changed
 
 
     // update the highlighted column if it changed


@@ -408,15 +651,15 @@ void wxHeaderCtrl::OnMouse(wxMouseEvent& mevent)
         if ( onSeparator )
         {
             // start resizing the column
         if ( onSeparator )
         {
             // start resizing the column

-            m_colBeingResized = col;
-            SetCursor(wxCursor(wxCURSOR_SIZEWE));
-            CaptureMouse();
-            UpdateResizingMarker(xPhysical);
+            wxASSERT_MSG( !IsResizing(), "reentering column resize mode?" );
+            StartOrContinueResizing(col, xPhysical);

         }
         else // on column itself
         {
         }
         else // on column itself
         {

-            // TODO: drag column
-            ;
+            // start dragging the column
+            wxASSERT_MSG( !IsReordering(), "reentering column move mode?" );
+
+            StartReordering(col, xPhysical);

         }
 
         return;
         }
 
         return;