don't take EVT_HEADER_END_DRAG into account if it indicates the the drag was cancelled

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

diff --git a/src/generic/scrlwing.cpp b/src/generic/scrlwing.cpp
index 7d14e6a55682024b26b429dd725166c00291a3ab..c3f25599f9f1b9f113ce8bf1d7b81b1fafdc4a0d 100644 (file)
--- a/src/generic/scrlwing.cpp
+++ b/src/generic/scrlwing.cpp
@@ -644,7 +644,61 @@ int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event)
     return nScrollInc;
 }
 
     return nScrollInc;
 }
 

-// Adjust the scrollbars - new version.
+void
+wxScrollHelper::AdjustScrollbar(int orient,
+                                int clientSize,
+                                int virtSize,
+                                int& pixelsPerUnit,
+                                int& scrollUnits,
+                                int& scrollPosition)
+{
+    // scroll lines per page: if 0, no scrolling is needed
+    int unitsPerPage;
+
+    // check if we need scrollbar in this direction at all
+    if ( pixelsPerUnit == 0 || clientSize >= virtSize )
+    {
+        // scrolling is disabled or unnecessary
+        scrollUnits =
+        scrollPosition = 0;
+        unitsPerPage = 0;
+    }
+    else // might need scrolling
+    {
+        // Round up integer division to catch any "leftover" client space.
+        scrollUnits = (virtSize + pixelsPerUnit - 1) / pixelsPerUnit;
+
+        // Calculate the number of fully scroll units
+        unitsPerPage = clientSize / pixelsPerUnit;
+
+        if (unitsPerPage >= scrollUnits)
+        {
+            // we're big enough to not need scrolling
+            scrollUnits =
+            scrollPosition = 0;
+            unitsPerPage = 0;
+        }
+        else // we do need a scrollbar
+        {
+            if ( unitsPerPage < 1 )
+                unitsPerPage = 1;
+
+            // Correct position if greater than extent of canvas minus
+            // the visible portion of it or if below zero
+            const int posMax = scrollUnits - unitsPerPage;
+            if ( scrollPosition > posMax )
+                scrollPosition = posMax;
+            else if ( scrollPosition < 0 )
+                scrollPosition = 0;
+        }
+    }
+
+    m_win->SetScrollbar(orient, scrollPosition, unitsPerPage, scrollUnits);
+
+    // The amount by which we scroll when paging
+    SetScrollPageSize(orient, unitsPerPage);
+}
+

 void wxScrollHelper::AdjustScrollbars()
 {
     static wxRecursionGuardFlag s_flagReentrancy;
 void wxScrollHelper::AdjustScrollbars()
 {
     static wxRecursionGuardFlag s_flagReentrancy;


@@ -660,137 +714,62 @@ void wxScrollHelper::AdjustScrollbars()
         return;
     }
 
         return;
     }
 

-    int w = 0, h = 0;
-    int oldw, oldh;
-

     int oldXScroll = m_xScrollPosition;
     int oldYScroll = m_yScrollPosition;
 
     int oldXScroll = m_xScrollPosition;
     int oldYScroll = m_yScrollPosition;
 

-    // VZ: at least under Windows this loop is useless because when scrollbars
-    //     [dis]appear we get a WM_SIZE resulting in another call to
-    //     AdjustScrollbars() anyhow. As it doesn't seem to do any harm I leave
-    //     it here for now but it would be better to ensure that all ports
-    //     generate EVT_SIZE when scrollbars [dis]appear, emulating it if
-    //     necessary, and remove it later
-    // JACS: Stop potential infinite loop by limiting number of iterations
-    int iterationCount = 0;
-    const int iterationMax = 5;
-    do
+    // we may need to readjust the scrollbars several times as enabling one of
+    // them reduces the area available for the window contents and so can make
+    // the other scrollbar necessary now although it wasn't necessary before
+    //
+    // VZ: normally this loop should be over in at most 2 iterations, I don't
+    //     know why do we need 5 of them
+    for ( int iterationCount = 0; iterationCount < 5; iterationCount++ )

     {
     {

-        iterationCount ++;
-
-        GetTargetSize(&w, 0);
-
-        // scroll lines per page: if 0, no scrolling is needed
-        int linesPerPage;
-
-        if ( m_xScrollPixelsPerLine == 0 )
-        {
-            // scrolling is disabled
-            m_xScrollLines = 0;
-            m_xScrollPosition = 0;
-            linesPerPage = 0;
-        }
-        else // might need scrolling
-        {
-            // Round up integer division to catch any "leftover" client space.
-            const int wVirt = m_targetWindow->GetVirtualSize().GetWidth();
-            m_xScrollLines = (wVirt + m_xScrollPixelsPerLine - 1) / m_xScrollPixelsPerLine;
-
-            // Calculate page size i.e. number of scroll units you get on the
-            // current client window.
-            linesPerPage = w / m_xScrollPixelsPerLine;
-
-            // Special case. When client and virtual size are very close but
-            // the client is big enough, kill scrollbar.
-            if ((linesPerPage < m_xScrollLines) && (w >= wVirt)) ++linesPerPage;
-
-            if (linesPerPage >= m_xScrollLines)
-            {
-                // we're big enough to not need scrolling
-                linesPerPage =
-                m_xScrollLines =
-                m_xScrollPosition = 0;
-            }
-            else // we do need a scrollbar
-            {
-                if ( linesPerPage < 1 )
-                    linesPerPage = 1;
-
-                // Correct position if greater than extent of canvas minus
-                // the visible portion of it or if below zero
-                const int posMax = m_xScrollLines - linesPerPage;
-                if ( m_xScrollPosition > posMax )
-                    m_xScrollPosition = posMax;
-                else if ( m_xScrollPosition < 0 )
-                    m_xScrollPosition = 0;
-            }
-        }
-
-        m_win->SetScrollbar(wxHORIZONTAL, m_xScrollPosition,
-                            linesPerPage, m_xScrollLines);
-
-        // The amount by which we scroll when paging
-        SetScrollPageSize(wxHORIZONTAL, linesPerPage);
-
-        GetTargetSize(0, &h);
-
-        if ( m_yScrollPixelsPerLine == 0 )
-        {
-            // scrolling is disabled
-            m_yScrollLines = 0;
-            m_yScrollPosition = 0;
-            linesPerPage = 0;
-        }
-        else // might need scrolling
+        wxSize clientSize = GetTargetSize();
+        const wxSize virtSize = m_targetWindow->GetVirtualSize();
+
+        // this block of code tries to work around the following problem: the
+        // window could have been just resized to have enough space to show its
+        // full contents without the scrollbars, but its client size could be
+        // not big enough because it does have the scrollbars right now and so
+        // the scrollbars would remain even though we don't need them any more
+        //
+        // to prevent this from happening, check if we have enough space for
+        // everything without the scrollbars and explicitly disable them then
+        const wxSize availSize = GetSizeAvailableForScrollTarget(
+            m_win->GetSize() - m_win->GetWindowBorderSize());
+        if ( availSize != clientSize )

         {
         {

-            // Round up integer division to catch any "leftover" client space.
-            const int hVirt = m_targetWindow->GetVirtualSize().GetHeight();
-            m_yScrollLines = ( hVirt + m_yScrollPixelsPerLine - 1 ) / m_yScrollPixelsPerLine;
-
-            // Calculate page size i.e. number of scroll units you get on the
-            // current client window.
-            linesPerPage = h / m_yScrollPixelsPerLine;
-
-            // Special case. When client and virtual size are very close but
-            // the client is big enough, kill scrollbar.
-            if ((linesPerPage < m_yScrollLines) && (h >= hVirt)) ++linesPerPage;
-
-            if (linesPerPage >= m_yScrollLines)
-            {
-                // we're big enough to not need scrolling
-                linesPerPage =
-                m_yScrollLines =
-                m_yScrollPosition = 0;
-            }
-            else // we do need a scrollbar
+            if ( availSize.x >= virtSize.x && availSize.y >= virtSize.y )

             {
             {

-                if ( linesPerPage < 1 )
-                    linesPerPage = 1;
-
-                // Correct position if greater than extent of canvas minus
-                // the visible portion of it or if below zero
-                const int posMax = m_yScrollLines - linesPerPage;
-                if ( m_yScrollPosition > posMax )
-                    m_yScrollPosition = posMax;
-                else if ( m_yScrollPosition < 0 )
-                    m_yScrollPosition = 0;
+                // this will be enough to make the scrollbars disappear below
+                // and then the client size will indeed become equal to the
+                // full available size
+                clientSize = availSize;

             }
         }
 
             }
         }
 

-        m_win->SetScrollbar(wxVERTICAL, m_yScrollPosition,
-                            linesPerPage, m_yScrollLines);

 
 

-        // The amount by which we scroll when paging
-        SetScrollPageSize(wxVERTICAL, linesPerPage);
+        AdjustScrollbar(wxHORIZONTAL,
+                        clientSize.x,
+                        virtSize.x,
+                        m_xScrollPixelsPerLine,
+                        m_xScrollLines,
+                        m_xScrollPosition);

 
 

+        AdjustScrollbar(wxVERTICAL,
+                        clientSize.y,
+                        virtSize.y,
+                        m_yScrollPixelsPerLine,
+                        m_yScrollLines,
+                        m_yScrollPosition);

 
 

-        // If a scrollbar (dis)appeared as a result of this, adjust them again.
-        oldw = w;
-        oldh = h;

 
 

-        GetTargetSize( &w, &h );
-    } while ( (w != oldw || h != oldh) && (iterationCount < iterationMax) );
+        // If a scrollbar (dis)appeared as a result of this, we need to adjust
+        // them again but if the client size didn't change, then we're done
+        if ( GetTargetSize() == clientSize )
+            break;
+    }

 
 #ifdef __WXMOTIF__
     // Sorry, some Motif-specific code to implement a backing pixmap
 
 #ifdef __WXMOTIF__
     // Sorry, some Motif-specific code to implement a backing pixmap


@@ -849,7 +828,7 @@ void wxScrollHelper::DoPrepareDC(wxDC& dc)
     wxPoint pt = dc.GetDeviceOrigin();
 #ifdef __WXGTK__
     // It may actually be correct to always query
     wxPoint pt = dc.GetDeviceOrigin();
 #ifdef __WXGTK__
     // It may actually be correct to always query

-    // the m_sign from the DC here, but I leve the
+    // the m_sign from the DC here, but I leave the

     // #ifdef GTK for now.
     if (m_win->GetLayoutDirection() == wxLayout_RightToLeft)
         dc.SetDeviceOrigin( pt.x + m_xScrollPosition * m_xScrollPixelsPerLine,
     // #ifdef GTK for now.
     if (m_win->GetLayoutDirection() == wxLayout_RightToLeft)
         dc.SetDeviceOrigin( pt.x + m_xScrollPosition * m_xScrollPixelsPerLine,


@@ -1341,21 +1320,69 @@ void wxScrollHelper::HandleOnChildFocus(wxChildFocusEvent& event)
     if ( win == m_targetWindow )
         return; // nothing to do
 
     if ( win == m_targetWindow )
         return; // nothing to do
 

-    while ( win->GetParent() != m_targetWindow )
+#ifdef __WXMAC__
+    if (wxDynamicCast(win, wxScrollBar))
+        return;
+#endif
+
+    // Fixing ticket: http://trac.wxwidgets.org/ticket/9563
+    // When a child inside a wxControlContainer receives a focus, the
+    // wxControlContainer generates an artificial wxChildFocusEvent for
+    // itself, telling its parent that 'it' received the focus. The effect is
+    // that this->HandleOnChildFocus is called twice, first with the
+    // artificial wxChildFocusEvent and then with the original event.  We need
+    // to ignore the artificial event here or otherwise HandleOnChildFocus
+    // would first scroll the target window to make the entire
+    // wxControlContainer visible and immediately afterwards scroll the target
+    // window again to make the child widget visible. This leads to ugly
+    // flickering when using nested wxPanels/wxScrolledWindows.
+    //
+    // Ignore this event if 'win' is derived from wxControlContainer AND its
+    // parent is the m_targetWindow AND 'win' is not actually reciving the
+    // focus (win != FindFocus).  TODO: This affects all wxControlContainer
+    // objects, but wxControlContainer is not part of the wxWidgets RTTI and
+    // so wxDynamicCast(win, wxControlContainer) does not compile.  Find a way
+    // to determine if 'win' derives from wxControlContainer. Until then,
+    // testing if 'win' derives from wxPanel will probably get >90% of all
+    // cases.
+
+    wxWindow *actual_focus=wxWindow::FindFocus();
+    if (win != actual_focus &&
+        wxDynamicCast(win, wxPanel) != 0 &&
+        win->GetParent() == m_targetWindow)
+        // if win is a wxPanel and receives the focus, it should not be
+        // scrolled into view
+        return; 
+
+    wxSize view(m_targetWindow->GetClientSize());
+
+    // For composite controls such as wxComboCtrl we should try to fit the
+    // entire control inside the visible area of the target window, not just
+    // the focused child of the control. Otherwise we'd make only the textctrl
+    // part of a wxComboCtrl visible and the button would still be outside the
+    // scrolled area.  But do so only if the parent fits *entirely* inside the
+    // scrolled window. In other situations, such as nested wxPanel or
+    // wxScrolledWindows, the parent might be way to big to fit inside the
+    // scrolled window. If that is the case, then make only the focused window
+    // visible
+    if ( win->GetParent() != m_targetWindow)

     {
     {

-        win = win->GetParent();
-        if ( !win )
-            return; // event is not from a child of the target window
+        wxWindow *parent=win->GetParent();
+        wxSize parent_size=parent->GetSize();
+        if (parent_size.GetWidth() <= view.GetWidth() &&
+            parent_size.GetHeight() <= view.GetHeight())
+            // make the immediate parent visible instead of the focused control
+            win=parent; 

     }
 
     // if the child is not fully visible, try to scroll it into view:
     int stepx, stepy;
     GetScrollPixelsPerUnit(&stepx, &stepy);
 
     }
 
     // if the child is not fully visible, try to scroll it into view:
     int stepx, stepy;
     GetScrollPixelsPerUnit(&stepx, &stepy);
 

-    // NB: we don't call CalcScrolledPosition() on win->GetPosition() here,
-    //     because children' positions are already scrolled
-    wxRect winrect(win->GetPosition(), win->GetSize());
-    wxSize view(m_targetWindow->GetClientSize());
+    // 'win' position coordinates are relative to it's parent
+    // convert them so that they are relative to the m_targetWindow viewing area
+    wxRect winrect(m_targetWindow->ScreenToClient(win->GetScreenPosition()),
+                   win->GetSize());

 
     int startx, starty;
     GetViewStart(&startx, &starty);
 
     int startx, starty;
     GetViewStart(&startx, &starty);


@@ -1450,7 +1477,7 @@ wxSize wxScrolledT_Helper::FilterBestSize(const wxWindow *win,
 }
 
 #ifdef __WXMSW__
 }
 
 #ifdef __WXMSW__

-WXLRESULT wxScrolledT_Helper::FilterMSWWindowProc(WXLRESULT rc)
+WXLRESULT wxScrolledT_Helper::FilterMSWWindowProc(WXUINT nMsg, WXLRESULT rc)

 {
 #ifndef __WXWINCE__
     // we need to process arrows ourselves for scrolling
 {
 #ifndef __WXWINCE__
     // we need to process arrows ourselves for scrolling