]> git.saurik.com Git - wxWidgets.git/blobdiff - src/generic/scrlwing.cpp
no real changes, just refactor to remove some code duplication in wxToolBarTool
[wxWidgets.git] / src / generic / scrlwing.cpp
index 0b6c1fcc6e42143a957702293ae796e29aec20ed..45a6e21f3c5cff2f0662866417aebcd26ce3eb37 100644 (file)
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 
-#ifdef __VMS
-#define XtDisplay XTDISPLAY
-#endif
-
 #include "wx/scrolwin.h"
 
 #ifndef WX_PRECOMP
     #include "wx/utils.h"
     #include "wx/panel.h"
     #include "wx/dcclient.h"
 #include "wx/scrolwin.h"
 
 #ifndef WX_PRECOMP
     #include "wx/utils.h"
     #include "wx/panel.h"
     #include "wx/dcclient.h"
-    #if wxUSE_TIMER
-        #include "wx/timer.h"
-    #endif
+    #include "wx/timer.h"
     #include "wx/sizer.h"
     #include "wx/sizer.h"
+    #include "wx/settings.h"
 #endif
 
 #ifdef __WXMAC__
 #endif
 
 #ifdef __WXMAC__
@@ -443,6 +438,12 @@ void wxScrollHelper::DeleteEvtHandler()
     }
 }
 
     }
 }
 
+void wxScrollHelper::ResetDrawnFlag()
+{
+    wxCHECK_RET( m_handler, "invalid use of ResetDrawnFlag - no handler?" );
+    m_handler->ResetDrawnFlag();
+}
+
 void wxScrollHelper::DoSetTargetWindow(wxWindow *target)
 {
     m_targetWindow = target;
 void wxScrollHelper::DoSetTargetWindow(wxWindow *target)
 {
     m_targetWindow = target;
@@ -1059,29 +1060,6 @@ wxSize wxScrollHelper::ScrollGetBestVirtualSize() const
     return clientSize;
 }
 
     return clientSize;
 }
 
-// return the window best size from the given best virtual size
-wxSize
-wxScrollHelper::ScrollGetWindowSizeForVirtualSize(const wxSize& size) const
-{
-    // Only use the content to set the window size in the direction
-    // where there's no scrolling; otherwise we're going to get a huge
-    // window in the direction in which scrolling is enabled
-    int ppuX, ppuY;
-    GetScrollPixelsPerUnit(&ppuX, &ppuY);
-
-    wxSize minSize = m_win->GetMinSize();
-    if ( !minSize.IsFullySpecified() )
-        minSize = m_win->GetSize();
-
-    wxSize best(size);
-    if (ppuX > 0)
-        best.x = minSize.x;
-    if (ppuY > 0)
-        best.y = minSize.y;
-
-    return best;
-}
-
 // ----------------------------------------------------------------------------
 // event handlers
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // event handlers
 // ----------------------------------------------------------------------------
@@ -1359,20 +1337,68 @@ void wxScrollHelper::HandleOnChildFocus(wxChildFocusEvent& event)
 
     // find the immediate child under which the window receiving focus is:
     wxWindow *win = event.GetWindow();
 
     // find the immediate child under which the window receiving focus is:
     wxWindow *win = event.GetWindow();
-    while ( win->GetParent() != m_targetWindow )
+
+    if ( win == m_targetWindow )
+        return; // nothing to do
+
+    // 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();
-        wxCHECK_RET( win, "incorrectly sent wxChildFocusEvent - not our child" );
+        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);
@@ -1421,58 +1447,54 @@ void wxScrollHelper::HandleOnChildFocus(wxChildFocusEvent& event)
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
-// wxScrolledWindow implementation
+// wxScrolled<T> and wxScrolledWindow implementation
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 
-IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxPanel)
-
-BEGIN_EVENT_TABLE(wxScrolledWindow, wxPanel)
-    EVT_PAINT(wxScrolledWindow::OnPaint)
-END_EVENT_TABLE()
-
-bool wxScrolledWindow::Create(wxWindow *parent,
-                              wxWindowID id,
-                              const wxPoint& pos,
-                              const wxSize& size,
-                              long style,
-                              const wxString& name)
+wxSize wxScrolledT_Helper::FilterBestSize(const wxWindow *win,
+                                          const wxScrollHelperNative *helper,
+                                          const wxSize& origBest)
 {
 {
-    m_targetWindow = this;
-#ifdef __WXMAC__
-    MacSetClipChildren( true ) ;
-#endif
-
-    // by default, we're scrollable in both directions (but if one of the
-    // styles is specified explicitly, we shouldn't add the other one
-    // automatically)
-    if ( !(style & (wxHSCROLL | wxVSCROLL)) )
-        style |= wxHSCROLL | wxVSCROLL;
-
-    bool ok = wxPanel::Create(parent, id, pos, size, style, name);
-
-    return ok;
-}
+    // NB: We don't do this in WX_FORWARD_TO_SCROLL_HELPER, because not
+    //     all scrollable windows should behave like this, only those that
+    //     contain children controls within scrollable area
+    //     (i.e., wxScrolledWindow) and other some scrollable windows may
+    //     have different DoGetBestSize() implementation (e.g. wxTreeCtrl).
 
 
-wxScrolledWindow::~wxScrolledWindow()
-{
-}
+    wxSize best = origBest;
 
 
-void wxScrolledWindow::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();
+    if ( win->GetAutoLayout() )
+    {
+        // Only use the content to set the window size in the direction
+        // where there's no scrolling; otherwise we're going to get a huge
+        // window in the direction in which scrolling is enabled
+        int ppuX, ppuY;
+        helper->GetScrollPixelsPerUnit(&ppuX, &ppuY);
+
+        // NB: This code used to use *current* size if min size wasn't
+        //     specified, presumably to get some reasonable (i.e., larger than
+        //     minimal) size.  But that's a wrong thing to do in GetBestSize(),
+        //     so we use minimal size as specified. If the app needs some
+        //     minimal size for its scrolled window, it should set it and put
+        //     the window into sizer as expandable so that it can use all space
+        //     available to it.
+        //
+        //     See also http://svn.wxwidgets.org/viewvc/wx?view=rev&revision=45864
+
+        wxSize minSize = win->GetMinSize();
+
+        if ( ppuX > 0 )
+            best.x = minSize.x + wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
+
+        if ( ppuY > 0 )
+            best.y = minSize.y + wxSystemSettings::GetMetric(wxSYS_HSCROLL_Y);
+    }
 
 
-    event.Skip();
+    return best;
 }
 
 #ifdef __WXMSW__
 }
 
 #ifdef __WXMSW__
-WXLRESULT wxScrolledWindow::MSWWindowProc(WXUINT nMsg,
-                                       WXWPARAM wParam,
-                                       WXLPARAM lParam)
+WXLRESULT wxScrolledT_Helper::FilterMSWWindowProc(WXUINT nMsg, WXLRESULT rc)
 {
 {
-    WXLRESULT rc = wxPanel::MSWWindowProc(nMsg, wParam, lParam);
-
 #ifndef __WXWINCE__
     // we need to process arrows ourselves for scrolling
     if ( nMsg == WM_GETDLGCODE )
 #ifndef __WXWINCE__
     // we need to process arrows ourselves for scrolling
     if ( nMsg == WM_GETDLGCODE )
@@ -1480,8 +1502,10 @@ WXLRESULT wxScrolledWindow::MSWWindowProc(WXUINT nMsg,
         rc |= DLGC_WANTARROWS;
     }
 #endif
         rc |= DLGC_WANTARROWS;
     }
 #endif
-
     return rc;
 }
     return rc;
 }
-
 #endif // __WXMSW__
 #endif // __WXMSW__
+
+// NB: skipping wxScrolled<T> in wxRTTI information because being a templte,
+//     it doesn't and can't implement wxRTTI support
+IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxPanel)