update focus rectangle width when the columns are being added/removed on the fly

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

diff --git a/src/generic/scrlwing.cpp b/src/generic/scrlwing.cpp
index ce07d296b2388bc28eb2fae7c53f5b4932fd10ce..cf18c3bf8c85016308642174b75157b03126e8e5 100644 (file)
--- a/src/generic/scrlwing.cpp
+++ b/src/generic/scrlwing.cpp
@@ -64,7 +64,7 @@ IMPLEMENT_CLASS(wxScrolledWindow, wxGenericScrolledWindow)
 // them to wxScrollHelper
 // ----------------------------------------------------------------------------
 
 // them to wxScrollHelper
 // ----------------------------------------------------------------------------
 

-class wxScrollHelperEvtHandler : public wxEvtHandler
+class WXDLLEXPORT wxScrollHelperEvtHandler : public wxEvtHandler

 {
 public:
     wxScrollHelperEvtHandler(wxScrollHelper *scrollHelper)
 {
 public:
     wxScrollHelperEvtHandler(wxScrollHelper *scrollHelper)


@@ -74,8 +74,12 @@ public:
 
     virtual bool ProcessEvent(wxEvent& event);
 
 
     virtual bool ProcessEvent(wxEvent& event);
 

+    void ResetDrawnFlag() { m_hasDrawnWindow = FALSE; }
+

 private:
     wxScrollHelper *m_scrollHelper;
 private:
     wxScrollHelper *m_scrollHelper;

+
+    bool m_hasDrawnWindow;

 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------


@@ -169,13 +173,51 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event)
 {
     wxEventType evType = event.GetEventType();
 
 {
     wxEventType evType = event.GetEventType();
 

+    // the explanation of wxEVT_PAINT processing hack: for historic reasons
+    // there are 2 ways to process this event in classes deriving from
+    // wxScrolledWindow. The user code may
+    //
+    //  1. override wxScrolledWindow::OnDraw(dc)
+    //  2. define its own OnPaint() handler
+    //
+    // In addition, in wxUniversal wxWindow defines OnPaint() itself and
+    // always processes the draw event, so we can't just try the window
+    // OnPaint() first and call our HandleOnPaint() if it doesn't process it
+    // (the latter would never be called in wxUniversal).
+    //
+    // So the solution is to have a flag telling us whether the user code drew
+    // anything in the window. We set it to true here but reset it to false in
+    // wxScrolledWindow::OnPaint() handler (which wouldn't be called if the
+    // user code defined OnPaint() in the derived class)
+    m_hasDrawnWindow = TRUE;
+
+    // pass it on to the real handler
+    bool processed = wxEvtHandler::ProcessEvent(event);
+
+    // always process the size events ourselves, even if the user code handles
+    // them as well, as we need to AdjustScrollbars()
+    //
+    // NB: it is important to do it after processing the event in the normal
+    //     way as HandleOnSize() may generate a wxEVT_SIZE itself if the
+    //     scrollbar[s] (dis)appear and it should be seen by the user code
+    //     after this one

     if ( evType == wxEVT_SIZE )
     {
         m_scrollHelper->HandleOnSize((wxSizeEvent &)event);
     if ( evType == wxEVT_SIZE )
     {
         m_scrollHelper->HandleOnSize((wxSizeEvent &)event);

-    }

 
 

-    if ( wxEvtHandler::ProcessEvent(event) )

         return TRUE;
         return TRUE;

+    }
+
+    if ( processed )
+    {
+        // normally, nothing more to do here - except if it was a paint event
+        // which wasn't really processed, then we'll try to call our
+        // OnDraw() below (from HandleOnPaint)
+        if ( m_hasDrawnWindow )
+        {
+            return TRUE;
+        }
+    }

 
     // reset the skipped flag to FALSE as it might have been set to TRUE in
     // ProcessEvent() above
 
     // reset the skipped flag to FALSE as it might have been set to TRUE in
     // ProcessEvent() above


@@ -252,29 +294,17 @@ wxScrollHelper::wxScrollHelper(wxWindow *win)
 
     m_timerAutoScroll = (wxTimer *)NULL;
 
 
     m_timerAutoScroll = (wxTimer *)NULL;
 

+    m_handler = NULL;
+

     if ( win )
         SetWindow(win);
 }
 
     if ( win )
         SetWindow(win);
 }
 

-void wxScrollHelper::SetWindow(wxWindow *win)
-{
-    wxCHECK_RET( win, _T("wxScrollHelper needs a window to scroll") );
-
-    m_targetWindow = m_win = win;
-
-    // install the event handler which will intercept the events we're
-    // interested in
-    m_win->PushEventHandler(new wxScrollHelperEvtHandler(this));
-}
-

 wxScrollHelper::~wxScrollHelper()
 {
     StopAutoScrolling();
 
 wxScrollHelper::~wxScrollHelper()
 {
     StopAutoScrolling();
 

-    if ( m_targetWindow )
-        m_targetWindow->PopEventHandler(TRUE /* do delete it */);
-    if ( m_win && m_win != m_targetWindow)
-        m_win->PopEventHandler(TRUE /* do delete it */);
+    DeleteEvtHandler();

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -354,23 +384,60 @@ void wxScrollHelper::SetScrollbars(int pixelsPerUnitX,
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// target window handling
+// [target] window handling

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

-void wxScrollHelper::SetTargetWindow( wxWindow *target )
+void wxScrollHelper::DeleteEvtHandler()
+{
+    // search for m_handler in the handler list
+    if ( m_win && m_handler )
+    {
+        if ( m_win->RemoveEventHandler(m_handler) )
+        {
+            delete m_handler;
+        }
+        //else: something is very wrong, so better [maybe] leak memory than
+        //      risk a crash because of double deletion
+
+        m_handler = NULL;
+    }
+}
+
+void wxScrollHelper::SetWindow(wxWindow *win)
+{
+    wxCHECK_RET( win, _T("wxScrollHelper needs a window to scroll") );
+
+    m_win = win;
+
+    // by default, the associated window is also the target window
+    DoSetTargetWindow(win);
+}
+
+void wxScrollHelper::DoSetTargetWindow(wxWindow *target)

 {
 {

-    wxASSERT_MSG( target, wxT("target window must not be NULL") );
-    // FIXME: There is a potential problem with this way of deleting
-    // event handlers, basically you can not be sure that you delete
-    // the event handler that was create by this wxScrollHelper.
-    // Remove the old event handler from the previous target scroll window.
-    if (m_targetWindow && m_targetWindow != m_win)
-        m_targetWindow->PopEventHandler(TRUE /* Delete old event handler*/);

     m_targetWindow = target;
     m_targetWindow = target;

-    // Install a new event handler, which will intercept the events we're
-    // interested in from the target scroll window.
-    if (m_targetWindow != m_win)
-        m_targetWindow->PushEventHandler(new wxScrollHelperEvtHandler(this));
+
+    // install the event handler which will intercept the events we're
+    // interested in (but only do it for our real window, not the target window
+    // which we scroll - we don't need to hijack its events)
+    if ( m_targetWindow == m_win )
+    {
+        // if we already have a handler, delete it first
+        DeleteEvtHandler();
+
+        m_handler = new wxScrollHelperEvtHandler(this);
+        m_targetWindow->PushEventHandler(m_handler);
+    }
+}
+
+void wxScrollHelper::SetTargetWindow(wxWindow *target)
+{
+    wxCHECK_RET( target, wxT("target window must not be NULL") );
+
+    if ( target == m_targetWindow )
+        return;
+
+    DoSetTargetWindow(target);

 }
 
 wxWindow *wxScrollHelper::GetTargetWindow() const
 }
 
 wxWindow *wxScrollHelper::GetTargetWindow() const


@@ -397,12 +464,12 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event)
     if (orient == wxHORIZONTAL)
     {
         m_xScrollPosition += nScrollInc;
     if (orient == wxHORIZONTAL)
     {
         m_xScrollPosition += nScrollInc;

-        m_targetWindow->SetScrollPos(wxHORIZONTAL, m_xScrollPosition);
+        m_win->SetScrollPos(wxHORIZONTAL, m_xScrollPosition);

     }
     else
     {
         m_yScrollPosition += nScrollInc;
     }
     else
     {
         m_yScrollPosition += nScrollInc;

-        m_targetWindow->SetScrollPos(wxVERTICAL, m_yScrollPosition);
+        m_win->SetScrollPos(wxVERTICAL, m_yScrollPosition);

     }
 
     bool needsRefresh = FALSE;
     }
 
     bool needsRefresh = FALSE;


@@ -567,14 +634,14 @@ void wxScrollHelper::AdjustScrollbars()
         m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition);
         m_xScrollPosition = wxMax( 0, m_xScrollPosition );
 
         m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition);
         m_xScrollPosition = wxMax( 0, m_xScrollPosition );
 

-        m_targetWindow->SetScrollbar(wxHORIZONTAL, m_xScrollPosition, noPagePositions, m_xScrollLines);
+        m_win->SetScrollbar(wxHORIZONTAL, m_xScrollPosition, noPagePositions, m_xScrollLines);

         // The amount by which we scroll when paging
         SetScrollPageSize(wxHORIZONTAL, noPagePositions);
     }
     else
     {
         m_xScrollPosition = 0;
         // The amount by which we scroll when paging
         SetScrollPageSize(wxHORIZONTAL, noPagePositions);
     }
     else
     {
         m_xScrollPosition = 0;

-        m_targetWindow->SetScrollbar (wxHORIZONTAL, 0, 0, 0, FALSE);
+        m_win->SetScrollbar (wxHORIZONTAL, 0, 0, 0, FALSE);

     }
 
     if (m_yScrollLines > 0)
     }
 
     if (m_yScrollLines > 0)


@@ -591,14 +658,14 @@ void wxScrollHelper::AdjustScrollbars()
         m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition );
         m_yScrollPosition = wxMax( 0, m_yScrollPosition );
 
         m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition );
         m_yScrollPosition = wxMax( 0, m_yScrollPosition );
 

-        m_targetWindow->SetScrollbar(wxVERTICAL, m_yScrollPosition, noPagePositions, m_yScrollLines);
+        m_win->SetScrollbar(wxVERTICAL, m_yScrollPosition, noPagePositions, m_yScrollLines);

         // The amount by which we scroll when paging
         SetScrollPageSize(wxVERTICAL, noPagePositions);
     }
     else
     {
         m_yScrollPosition = 0;
         // The amount by which we scroll when paging
         SetScrollPageSize(wxVERTICAL, noPagePositions);
     }
     else
     {
         m_yScrollPosition = 0;

-        m_targetWindow->SetScrollbar (wxVERTICAL, 0, 0, 0, FALSE);
+        m_win->SetScrollbar (wxVERTICAL, 0, 0, 0, FALSE);

     }
 
     if (oldXScroll != m_xScrollPosition)
     }
 
     if (oldXScroll != m_xScrollPosition)


@@ -690,7 +757,7 @@ void wxScrollHelper::Scroll( int x_pos, int y_pos )
         m_xScrollPosition = wxMax( 0, m_xScrollPosition );
 
         if (old_x != m_xScrollPosition) {
         m_xScrollPosition = wxMax( 0, m_xScrollPosition );
 
         if (old_x != m_xScrollPosition) {

-            m_targetWindow->SetScrollPos( wxHORIZONTAL, m_xScrollPosition );
+            m_win->SetScrollPos( wxHORIZONTAL, m_xScrollPosition );

             m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0,
                                           GetRect() );
         }
             m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0,
                                           GetRect() );
         }


@@ -711,7 +778,7 @@ void wxScrollHelper::Scroll( int x_pos, int y_pos )
         m_yScrollPosition = wxMax( 0, m_yScrollPosition );
 
         if (old_y != m_yScrollPosition) {
         m_yScrollPosition = wxMax( 0, m_yScrollPosition );
 
         if (old_y != m_yScrollPosition) {

-            m_targetWindow->SetScrollPos( wxVERTICAL, m_yScrollPosition );
+            m_win->SetScrollPos( wxVERTICAL, m_yScrollPosition );

             m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*m_yScrollPixelsPerLine,
                                           GetRect() );
         }
             m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*m_yScrollPixelsPerLine,
                                           GetRect() );
         }


@@ -770,8 +837,8 @@ void wxScrollHelper::CalcUnscrolledPosition(int x, int y, int *xx, int *yy) cons
 void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event))
 {
 #if wxUSE_CONSTRAINTS
 void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event))
 {
 #if wxUSE_CONSTRAINTS

-    if ( m_targetWindow->GetAutoLayout() )
-        m_targetWindow->Layout();
+    if ( m_win->GetAutoLayout() )
+        m_win->Layout();

 #endif
 
     AdjustScrollbars();
 #endif
 
     AdjustScrollbars();


@@ -781,7 +848,8 @@ void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event))
 // scroll position
 void wxScrollHelper::HandleOnPaint(wxPaintEvent& WXUNUSED(event))
 {
 // scroll position
 void wxScrollHelper::HandleOnPaint(wxPaintEvent& WXUNUSED(event))
 {

-    wxPaintDC dc(m_targetWindow);
+    // don't use m_targetWindow here, this is always called for ourselves
+    wxPaintDC dc(m_win);

     DoPrepareDC(dc);
 
     OnDraw(dc);
     DoPrepareDC(dc);
 
     OnDraw(dc);


@@ -1019,6 +1087,10 @@ void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event)
 
 IMPLEMENT_DYNAMIC_CLASS(wxGenericScrolledWindow, wxPanel)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxGenericScrolledWindow, wxPanel)
 

+BEGIN_EVENT_TABLE(wxGenericScrolledWindow, wxPanel)
+    EVT_PAINT(wxGenericScrolledWindow::OnPaint)
+END_EVENT_TABLE()
+

 bool wxGenericScrolledWindow::Create(wxWindow *parent,
                               wxWindowID id,
                               const wxPoint& pos,
 bool wxGenericScrolledWindow::Create(wxWindow *parent,
                               wxWindowID id,
                               const wxPoint& pos,


@@ -1030,11 +1102,6 @@ bool wxGenericScrolledWindow::Create(wxWindow *parent,
 
     bool ok = wxPanel::Create(parent, id, pos, size, style, name);
 
 
     bool ok = wxPanel::Create(parent, id, pos, size, style, name);
 

-#ifdef __WXMSW__
-    // we need to process arrows ourselves for scrolling
-    m_lDlgCode |= DLGC_WANTARROWS;
-#endif // __WXMSW__
-

     return ok;
 }
 
     return ok;
 }
 


@@ -1042,7 +1109,36 @@ wxGenericScrolledWindow::~wxGenericScrolledWindow()
 {
 }
 
 {
 }
 

+void wxGenericScrolledWindow::OnPaint(wxPaintEvent& event)
+{
+    // the user code didn't really draw the window if we got here, so set this
+    // flag to try to call OnDraw() later
+    m_handler->ResetDrawnFlag();
+
+    event.Skip();
+}
+
+#ifdef __WXMSW__
+long
+wxGenericScrolledWindow::MSWWindowProc(WXUINT nMsg,
+                                       WXWPARAM wParam,
+                                       WXLPARAM lParam)
+{
+    long rc = wxPanel::MSWWindowProc(nMsg, wParam, lParam);
+
+    // we need to process arrows ourselves for scrolling
+    if ( nMsg == WM_GETDLGCODE )
+    {
+        rc |= DLGC_WANTARROWS;
+    }
+
+    return rc;
+}
+
+#endif // __WXMSW__
+

 #if WXWIN_COMPATIBILITY
 #if WXWIN_COMPATIBILITY

+

 void wxGenericScrolledWindow::GetScrollUnitsPerPage (int *x_page, int *y_page) const
 {
       *x_page = GetScrollPageSize(wxHORIZONTAL);
 void wxGenericScrolledWindow::GetScrollUnitsPerPage (int *x_page, int *y_page) const
 {
       *x_page = GetScrollPageSize(wxHORIZONTAL);


@@ -1056,6 +1152,7 @@ void wxGenericScrolledWindow::CalcUnscrolledPosition(int x, int y, float *xx, fl
     if ( yy )
         *yy = (float)(y + m_yScrollPosition * m_yScrollPixelsPerLine);
 }
     if ( yy )
         *yy = (float)(y + m_yScrollPosition * m_yScrollPixelsPerLine);
 }

+

 #endif // WXWIN_COMPATIBILITY
 
 #endif // !wxGTK
 #endif // WXWIN_COMPATIBILITY
 
 #endif // !wxGTK