Applied patch [ 1195797 ] Fixes to compile on Win64

[wxWidgets.git] / src / univ / scrolbar.cpp

diff --git a/src/univ/scrolbar.cpp b/src/univ/scrolbar.cpp
index 49aee0df40a63e88ba00b9564771388ea5dea537..752ad21584f257a717cc7b07e1cc45b4b659a730 100644 (file)
--- a/src/univ/scrolbar.cpp
+++ b/src/univ/scrolbar.cpp
@@ -5,8 +5,8 @@
 // Modified by:
 // Created:     20.08.00
 // RCS-ID:      $Id$
 // Modified by:
 // Created:     20.08.00
 // RCS-ID:      $Id$

-// Copyright:   (c) 2000 Vadim Zeitlin
-// Licence:     wxWindows license
+// Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 /////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================


@@ -17,7 +17,7 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)

     #pragma implementation "univscrolbar.h"
 #endif
 
     #pragma implementation "univscrolbar.h"
 #endif
 


@@ -42,6 +42,7 @@
 #include "wx/univ/renderer.h"
 #include "wx/univ/inphand.h"
 #include "wx/univ/theme.h"
 #include "wx/univ/renderer.h"
 #include "wx/univ/inphand.h"
 #include "wx/univ/theme.h"

+#include "wx/log.h"

 
 #define WXDEBUG_SCROLLBAR
 
 
 #define WXDEBUG_SCROLLBAR
 


@@ -49,6 +50,10 @@
     #undef WXDEBUG_SCROLLBAR
 #endif // !__WXDEBUG__
 
     #undef WXDEBUG_SCROLLBAR
 #endif // !__WXDEBUG__
 

+#if defined(WXDEBUG_SCROLLBAR) && defined(__WXMSW__) && !defined(__WXMICROWIN__)
+#include "wx/msw/private.h"
+#endif
+

 // ----------------------------------------------------------------------------
 // wxScrollBarTimer: this class is used to repeatedly scroll the scrollbar
 // when the mouse is help pressed on the arrow or on the bar. It generates the
 // ----------------------------------------------------------------------------
 // wxScrollBarTimer: this class is used to repeatedly scroll the scrollbar
 // when the mouse is help pressed on the arrow or on the bar. It generates the


@@ -78,7 +83,6 @@ private:
 IMPLEMENT_DYNAMIC_CLASS(wxScrollBar, wxControl)
 
 BEGIN_EVENT_TABLE(wxScrollBar, wxScrollBarBase)
 IMPLEMENT_DYNAMIC_CLASS(wxScrollBar, wxControl)
 
 BEGIN_EVENT_TABLE(wxScrollBar, wxScrollBarBase)

-    EVT_IDLE(wxScrollBar::OnIdle)

 END_EVENT_TABLE()
 
 // ----------------------------------------------------------------------------
 END_EVENT_TABLE()
 
 // ----------------------------------------------------------------------------


@@ -129,7 +133,7 @@ void wxScrollBar::Init()
         m_elementsState[n] = 0;
     }
 
         m_elementsState[n] = 0;
     }
 

-    m_dirty = FALSE;
+    m_dirty = false;

 }
 
 bool wxScrollBar::Create(wxWindow *parent,
 }
 
 bool wxScrollBar::Create(wxWindow *parent,


@@ -143,8 +147,8 @@ bool wxScrollBar::Create(wxWindow *parent,
     // the scrollbars never have the border
     style &= ~wxBORDER_MASK;
 
     // the scrollbars never have the border
     style &= ~wxBORDER_MASK;
 

-    if ( !wxControl::Create(parent, id, pos, size, style, wxDefaultValidator, name) )
-        return FALSE;
+    if ( !wxControl::Create(parent, id, pos, size, style, validator, name) )
+        return false;

 
     SetBestSize(size);
 
 
     SetBestSize(size);
 


@@ -153,13 +157,35 @@ bool wxScrollBar::Create(wxWindow *parent,
 
     CreateInputHandler(wxINP_HANDLER_SCROLLBAR);
 
 
     CreateInputHandler(wxINP_HANDLER_SCROLLBAR);
 

-    return TRUE;
+    return true;

 }
 
 wxScrollBar::~wxScrollBar()
 {
 }
 
 }
 
 wxScrollBar::~wxScrollBar()
 {
 }
 

+// ----------------------------------------------------------------------------
+// misc accessors
+// ----------------------------------------------------------------------------
+
+bool wxScrollBar::IsStandalone() const
+{
+    wxWindow *parent = GetParent();
+    if ( !parent )
+    {
+        return true;
+    }
+
+    return (parent->GetScrollbar(wxHORIZONTAL) != this) &&
+           (parent->GetScrollbar(wxVERTICAL) != this);
+}
+
+bool wxScrollBar::AcceptsFocus() const
+{
+    // the window scrollbars never accept focus
+    return wxScrollBarBase::AcceptsFocus() && IsStandalone();
+}
+

 // ----------------------------------------------------------------------------
 // scrollbar API
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // scrollbar API
 // ----------------------------------------------------------------------------


@@ -196,7 +222,7 @@ void wxScrollBar::DoSetThumb(int pos)
     m_elementsState[Element_Thumb] |= wxCONTROL_DIRTY;
     m_elementsState[m_thumbPos > m_thumbPosOld
                         ? Element_Bar_1 : Element_Bar_2] |= wxCONTROL_DIRTY;
     m_elementsState[Element_Thumb] |= wxCONTROL_DIRTY;
     m_elementsState[m_thumbPos > m_thumbPosOld
                         ? Element_Bar_1 : Element_Bar_2] |= wxCONTROL_DIRTY;

-    m_dirty = TRUE;
+    m_dirty = true;

 }
 
 int wxScrollBar::GetThumbPosition() const
 }
 
 int wxScrollBar::GetThumbPosition() const


@@ -295,7 +321,13 @@ wxScrollArrows::Arrow wxScrollBar::HitTest(const wxPoint& pt) const
 // drawing
 // ----------------------------------------------------------------------------
 
 // drawing
 // ----------------------------------------------------------------------------
 

-void wxScrollBar::OnIdle(wxIdleEvent& event)
+void wxScrollBar::OnInternalIdle()
+{
+    UpdateThumb();
+    wxControl::OnInternalIdle();
+}
+
+void wxScrollBar::UpdateThumb()

 {
     if ( m_dirty )
     {
 {
     if ( m_dirty )
     {


@@ -344,7 +376,7 @@ void wxScrollBar::OnIdle(wxIdleEvent& event)
                     }
 
 #ifdef WXDEBUG_SCROLLBAR
                     }
 
 #ifdef WXDEBUG_SCROLLBAR

-        static bool s_refreshDebug = FALSE;
+        static bool s_refreshDebug = false;

         if ( s_refreshDebug )
         {
             wxClientDC dc(this);
         if ( s_refreshDebug )
         {
             wxClientDC dc(this);


@@ -360,17 +392,15 @@ void wxScrollBar::OnIdle(wxIdleEvent& event)
         }
 #endif // WXDEBUG_SCROLLBAR
 
         }
 #endif // WXDEBUG_SCROLLBAR
 

-                    Refresh(TRUE, &rect);
+                    Refresh(false, &rect);

                 }
 
                 m_elementsState[n] &= ~wxCONTROL_DIRTY;
             }
         }
 
                 }
 
                 m_elementsState[n] &= ~wxCONTROL_DIRTY;
             }
         }
 

-        m_dirty = FALSE;
+        m_dirty = false;

     }
     }

-
-    event.Skip();

 }
 
 void wxScrollBar::DoDraw(wxControlRenderer *renderer)
 }
 
 void wxScrollBar::DoDraw(wxControlRenderer *renderer)


@@ -378,7 +408,7 @@ void wxScrollBar::DoDraw(wxControlRenderer *renderer)
     renderer->DrawScrollbar(this, m_thumbPosOld);
 
     // clear all dirty flags
     renderer->DrawScrollbar(this, m_thumbPosOld);
 
     // clear all dirty flags

-    m_dirty = FALSE;
+    m_dirty = false;

     m_thumbPosOld = -1;
 }
 
     m_thumbPosOld = -1;
 }
 


@@ -426,7 +456,7 @@ void wxScrollBar::SetState(Element which, int flags)
     {
         m_elementsState[which] = flags | wxCONTROL_DIRTY;
 
     {
         m_elementsState[which] = flags | wxCONTROL_DIRTY;
 

-        m_dirty = TRUE;
+        m_dirty = true;

     }
 }
 
     }
 }
 


@@ -451,7 +481,7 @@ bool wxScrollBar::PerformAction(const wxControlAction& action,
 {
     int thumbOld = m_thumbPos;
 
 {
     int thumbOld = m_thumbPos;
 

-    bool notify = FALSE; // send an event about the change?
+    bool notify = false; // send an event about the change?

 
     wxEventType scrollType;
 
 
     wxEventType scrollType;
 


@@ -460,6 +490,10 @@ bool wxScrollBar::PerformAction(const wxControlAction& action,
     {
         DoSetThumb(numArg);
 
     {
         DoSetThumb(numArg);
 

+        // VS: we have to force redraw here, otherwise the thumb will lack
+        //     behind mouse cursor
+        UpdateThumb();
+

         scrollType = wxEVT_SCROLLWIN_THUMBTRACK;
     }
     else if ( action == wxACTION_SCROLL_LINE_UP )
         scrollType = wxEVT_SCROLLWIN_THUMBTRACK;
     }
     else if ( action == wxACTION_SCROLL_LINE_UP )


@@ -502,7 +536,7 @@ bool wxScrollBar::PerformAction(const wxControlAction& action,
     else if ( action == wxACTION_SCROLL_THUMB_RELEASE )
     {
         // always notify about this
     else if ( action == wxACTION_SCROLL_THUMB_RELEASE )
     {
         // always notify about this

-        notify = TRUE;
+        notify = true;

         scrollType = wxEVT_SCROLLWIN_THUMBRELEASE;
     }
     else
         scrollType = wxEVT_SCROLLWIN_THUMBRELEASE;
     }
     else


@@ -512,13 +546,23 @@ bool wxScrollBar::PerformAction(const wxControlAction& action,
     bool changed = m_thumbPos != thumbOld;
     if ( notify || changed )
     {
     bool changed = m_thumbPos != thumbOld;
     if ( notify || changed )
     {

+        if ( IsStandalone() )
+        {
+            // we should generate EVT_SCROLL events for the standalone
+            // scrollbars and not the EVT_SCROLLWIN ones
+            //
+            // NB: we assume that scrollbar events are sequentially numbered
+            //     but this should be ok as other code relies on this as well
+            scrollType += wxEVT_SCROLL_TOP - wxEVT_SCROLLWIN_TOP;
+        }
+

         wxScrollWinEvent event(scrollType, m_thumbPos,
                                IsVertical() ? wxVERTICAL : wxHORIZONTAL);
         event.SetEventObject(this);
         GetParent()->GetEventHandler()->ProcessEvent(event);
     }
 
         wxScrollWinEvent event(scrollType, m_thumbPos,
                                IsVertical() ? wxVERTICAL : wxHORIZONTAL);
         event.SetEventObject(this);
         GetParent()->GetEventHandler()->ProcessEvent(event);
     }
 

-    return TRUE;
+    return true;

 }
 
 void wxScrollBar::ScrollToStart()
 }
 
 void wxScrollBar::ScrollToStart()


@@ -531,14 +575,16 @@ void wxScrollBar::ScrollToEnd()
     DoSetThumb(m_range - m_thumbSize);
 }
 
     DoSetThumb(m_range - m_thumbSize);
 }
 

-void wxScrollBar::ScrollLines(int nLines)
+bool wxScrollBar::ScrollLines(int nLines)

 {
     DoSetThumb(m_thumbPos + nLines);
 {
     DoSetThumb(m_thumbPos + nLines);

+    return true;

 }
 
 }
 

-void wxScrollBar::ScrollPages(int nPages)
+bool wxScrollBar::ScrollPages(int nPages)

 {
     DoSetThumb(m_thumbPos + nPages*m_pageSize);
 {
     DoSetThumb(m_thumbPos + nPages*m_pageSize);

+    return true;

 }
 
 // ============================================================================
 }
 
 // ============================================================================


@@ -608,12 +654,12 @@ bool wxStdScrollBarInputHandler::OnScrollTimer(wxScrollBar *scrollbar,
     int oldThumbPos = scrollbar->GetThumbPosition();
     scrollbar->PerformAction(action);
     if ( scrollbar->GetThumbPosition() != oldThumbPos )
     int oldThumbPos = scrollbar->GetThumbPosition();
     scrollbar->PerformAction(action);
     if ( scrollbar->GetThumbPosition() != oldThumbPos )

-        return TRUE;
+        return true;

 
     // we scrolled till the end
     m_timerScroll->Stop();
 
 
     // we scrolled till the end
     m_timerScroll->Stop();
 

-    return FALSE;
+    return false;

 }
 
 void wxStdScrollBarInputHandler::StopScrolling(wxScrollBar *control)
 }
 
 void wxStdScrollBarInputHandler::StopScrolling(wxScrollBar *control)


@@ -634,7 +680,7 @@ void wxStdScrollBarInputHandler::StopScrolling(wxScrollBar *control)
     }
 
     // unpress the arrow and highlight the current element
     }
 
     // unpress the arrow and highlight the current element

-    Press(control, FALSE);
+    Press(control, false);

 }
 
 wxCoord
 }
 
 wxCoord


@@ -653,7 +699,7 @@ void wxStdScrollBarInputHandler::HandleThumbMove(wxScrollBar *scrollbar,
     scrollbar->PerformAction(wxACTION_SCROLL_THUMB_MOVE, thumbPos);
 }
 
     scrollbar->PerformAction(wxACTION_SCROLL_THUMB_MOVE, thumbPos);
 }
 

-bool wxStdScrollBarInputHandler::HandleKey(wxControl *control,
+bool wxStdScrollBarInputHandler::HandleKey(wxInputConsumer *consumer,

                                            const wxKeyEvent& event,
                                            bool pressed)
 {
                                            const wxKeyEvent& event,
                                            bool pressed)
 {


@@ -669,22 +715,24 @@ bool wxStdScrollBarInputHandler::HandleKey(wxControl *control,
             case WXK_LEFT:      action = wxACTION_SCROLL_LINE_UP;   break;
             case WXK_HOME:      action = wxACTION_SCROLL_START;     break;
             case WXK_END:       action = wxACTION_SCROLL_END;       break;
             case WXK_LEFT:      action = wxACTION_SCROLL_LINE_UP;   break;
             case WXK_HOME:      action = wxACTION_SCROLL_START;     break;
             case WXK_END:       action = wxACTION_SCROLL_END;       break;

+            case WXK_PAGEUP:

             case WXK_PRIOR:     action = wxACTION_SCROLL_PAGE_UP;   break;
             case WXK_PRIOR:     action = wxACTION_SCROLL_PAGE_UP;   break;

+            case WXK_PAGEDOWN:

             case WXK_NEXT:      action = wxACTION_SCROLL_PAGE_DOWN; break;
         }
 
             case WXK_NEXT:      action = wxACTION_SCROLL_PAGE_DOWN; break;
         }
 

-        if ( !!action )
+        if ( !action.IsEmpty() )

         {
         {

-            control->PerformAction(action);
+            consumer->PerformAction(action);

 
 

-            return TRUE;
+            return true;

         }
     }
 
         }
     }
 

-    return wxStdInputHandler::HandleKey(control, event, pressed);
+    return wxStdInputHandler::HandleKey(consumer, event, pressed);

 }
 
 }
 

-bool wxStdScrollBarInputHandler::HandleMouse(wxControl *control,
+bool wxStdScrollBarInputHandler::HandleMouse(wxInputConsumer *consumer,

                                              const wxMouseEvent& event)
 {
     // is this a click event from an acceptable button?
                                              const wxMouseEvent& event)
 {
     // is this a click event from an acceptable button?


@@ -692,7 +740,7 @@ bool wxStdScrollBarInputHandler::HandleMouse(wxControl *control,
     if ( (btn != -1) && IsAllowedButton(btn) )
     {
         // determine which part of the window mouse is in
     if ( (btn != -1) && IsAllowedButton(btn) )
     {
         // determine which part of the window mouse is in

-        wxScrollBar *scrollbar = wxStaticCast(control, wxScrollBar);
+        wxScrollBar *scrollbar = wxStaticCast(consumer->GetInputWindow(), wxScrollBar);

         wxHitTest ht = m_renderer->HitTestScrollbar
                                    (
                                     scrollbar,
         wxHitTest ht = m_renderer->HitTestScrollbar
                                    (
                                     scrollbar,


@@ -706,11 +754,11 @@ bool wxStdScrollBarInputHandler::HandleMouse(wxControl *control,
             if ( !m_winCapture )
             {
                 m_btnCapture = btn;
             if ( !m_winCapture )
             {
                 m_btnCapture = btn;

-                m_winCapture = control;
+                m_winCapture = consumer->GetInputWindow();

                 m_winCapture->CaptureMouse();
 
                 // generate the command
                 m_winCapture->CaptureMouse();
 
                 // generate the command

-                bool hasAction = TRUE;
+                bool hasAction = true;

                 wxControlAction action;
                 switch ( ht )
                 {
                 wxControlAction action;
                 switch ( ht )
                 {


@@ -733,25 +781,25 @@ bool wxStdScrollBarInputHandler::HandleMouse(wxControl *control,
                         break;
 
                     case wxHT_SCROLLBAR_THUMB:
                         break;
 
                     case wxHT_SCROLLBAR_THUMB:

-                        control->PerformAction(wxACTION_SCROLL_THUMB_DRAG);
+                        consumer->PerformAction(wxACTION_SCROLL_THUMB_DRAG);

                         m_ofsMouse = GetMouseCoord(scrollbar, event) -
                                      m_renderer->ScrollbarToPixel(scrollbar);
 
                         // fall through: there is no immediate action
 
                     default:
                         m_ofsMouse = GetMouseCoord(scrollbar, event) -
                                      m_renderer->ScrollbarToPixel(scrollbar);
 
                         // fall through: there is no immediate action
 
                     default:

-                        hasAction = FALSE;
+                        hasAction = false;

                 }
 
                 // remove highlighting
                 }
 
                 // remove highlighting

-                Highlight(scrollbar, FALSE);
+                Highlight(scrollbar, false);

                 m_htLast = ht;
 
                 // and press the arrow or highlight thumb now instead
                 if ( m_htLast == wxHT_SCROLLBAR_THUMB )
                 m_htLast = ht;
 
                 // and press the arrow or highlight thumb now instead
                 if ( m_htLast == wxHT_SCROLLBAR_THUMB )

-                    Highlight(scrollbar, TRUE);
+                    Highlight(scrollbar, true);

                 else
                 else

-                    Press(scrollbar, TRUE);
+                    Press(scrollbar, true);

 
                 // start dragging
                 if ( hasAction )
 
                 // start dragging
                 if ( hasAction )


@@ -779,7 +827,7 @@ bool wxStdScrollBarInputHandler::HandleMouse(wxControl *control,
                 }
 
                 m_htLast = ht;
                 }
 
                 m_htLast = ht;

-                Highlight(scrollbar, TRUE);
+                Highlight(scrollbar, true);

             }
             else
             {
             }
             else
             {


@@ -791,32 +839,32 @@ bool wxStdScrollBarInputHandler::HandleMouse(wxControl *control,
         }
     }
 
         }
     }
 

-    return wxStdInputHandler::HandleMouse(control, event);
+    return wxStdInputHandler::HandleMouse(consumer, event);

 }
 
 }
 

-bool wxStdScrollBarInputHandler::HandleMouseMove(wxControl *control,
+bool wxStdScrollBarInputHandler::HandleMouseMove(wxInputConsumer *consumer,

                                                  const wxMouseEvent& event)
 {
                                                  const wxMouseEvent& event)
 {

-    wxScrollBar *scrollbar = wxStaticCast(control, wxScrollBar);
+    wxScrollBar *scrollbar = wxStaticCast(consumer->GetInputWindow(), wxScrollBar);

 
     if ( m_winCapture )
     {
 
     if ( m_winCapture )
     {

-        if ( (m_htLast == wxHT_SCROLLBAR_THUMB) && event.Moving() )
+        if ( (m_htLast == wxHT_SCROLLBAR_THUMB) && event.Dragging() )

         {
             // make the thumb follow the mouse by keeping the same offset
             // between the mouse position and the top/left of the thumb
             HandleThumbMove(scrollbar, event);
 
         {
             // make the thumb follow the mouse by keeping the same offset
             // between the mouse position and the top/left of the thumb
             HandleThumbMove(scrollbar, event);
 

-            return TRUE;
+            return true;

         }
 
         // no other changes are possible while the mouse is captured
         }
 
         // no other changes are possible while the mouse is captured

-        return FALSE;
+        return false;

     }
 
     bool isArrow = scrollbar->GetArrows().HandleMouseMove(event);
 
     }
 
     bool isArrow = scrollbar->GetArrows().HandleMouseMove(event);
 

-    if ( event.Moving() )
+    if ( event.Dragging() )

     {
         wxHitTest ht = m_renderer->HitTestScrollbar
                                    (
     {
         wxHitTest ht = m_renderer->HitTestScrollbar
                                    (


@@ -826,35 +874,35 @@ bool wxStdScrollBarInputHandler::HandleMouseMove(wxControl *control,
         if ( ht == m_htLast )
         {
             // nothing changed
         if ( ht == m_htLast )
         {
             // nothing changed

-            return FALSE;
+            return false;

         }
 
 #ifdef DEBUG_MOUSE
         wxLogDebug("Scrollbar::OnMouseMove: ht = %d", ht);
 #endif // DEBUG_MOUSE
 
         }
 
 #ifdef DEBUG_MOUSE
         wxLogDebug("Scrollbar::OnMouseMove: ht = %d", ht);
 #endif // DEBUG_MOUSE
 

-        Highlight(scrollbar, FALSE);
+        Highlight(scrollbar, false);

         m_htLast = ht;
 
         if ( !isArrow )
         m_htLast = ht;
 
         if ( !isArrow )

-            Highlight(scrollbar, TRUE);
+            Highlight(scrollbar, true);

         //else: already done by wxScrollArrows::HandleMouseMove
     }
     else if ( event.Leaving() )
     {
         if ( !isArrow )
         //else: already done by wxScrollArrows::HandleMouseMove
     }
     else if ( event.Leaving() )
     {
         if ( !isArrow )

-            Highlight(scrollbar, FALSE);
+            Highlight(scrollbar, false);

 
         m_htLast = wxHT_NOWHERE;
     }
     else // event.Entering()
     {
         // we don't process this event
 
         m_htLast = wxHT_NOWHERE;
     }
     else // event.Entering()
     {
         // we don't process this event

-        return FALSE;
+        return false;

     }
 
     // we did something
     }
 
     // we did something

-    return TRUE;
+    return true;

 }
 
 #endif // wxUSE_SCROLLBAR
 }
 
 #endif // wxUSE_SCROLLBAR


@@ -865,7 +913,7 @@ bool wxStdScrollBarInputHandler::HandleMouseMove(wxControl *control,
 
 wxScrollTimer::wxScrollTimer()
 {
 
 wxScrollTimer::wxScrollTimer()
 {

-    m_skipNext = FALSE;
+    m_skipNext = false;

 }
 
 void wxScrollTimer::StartAutoScroll()
 }
 
 void wxScrollTimer::StartAutoScroll()


@@ -880,7 +928,7 @@ void wxScrollTimer::StartAutoScroll()
     // there is an initial delay before the scrollbar starts scrolling -
     // implement it by ignoring the first timer expiration and only start
     // scrolling from the second one
     // there is an initial delay before the scrollbar starts scrolling -
     // implement it by ignoring the first timer expiration and only start
     // scrolling from the second one

-    m_skipNext = TRUE;
+    m_skipNext = true;

     Start(200); // FIXME: hardcoded delay
 }
 
     Start(200); // FIXME: hardcoded delay
 }
 


@@ -892,7 +940,7 @@ void wxScrollTimer::Notify()
         Stop();
         Start(50); // FIXME: hardcoded delay
 
         Stop();
         Start(50); // FIXME: hardcoded delay
 

-        m_skipNext = FALSE;
+        m_skipNext = false;

     }
     else
     {
     }
     else
     {