]> git.saurik.com Git - wxWidgets.git/blobdiff - src/univ/stdrend.cpp
Fix warnings for the OSX WebKit backend.
[wxWidgets.git] / src / univ / stdrend.cpp
index 255092ca4419231d87abcc5f1e30248d7a1780aa..64e7903504031f8f396174209520f16bebae5405 100644 (file)
@@ -42,6 +42,9 @@ static const int FRAME_TITLEBAR_HEIGHT             = 18;
 static const int FRAME_BUTTON_WIDTH                = 16;
 static const int FRAME_BUTTON_HEIGHT               = 14;
 
 static const int FRAME_BUTTON_WIDTH                = 16;
 static const int FRAME_BUTTON_HEIGHT               = 14;
 
+// the margin between listbox item text and its rectangle
+static const int ITEM_MARGIN = 1;
+
 // ============================================================================
 // wxStdRenderer implementation
 // ============================================================================
 // ============================================================================
 // wxStdRenderer implementation
 // ============================================================================
@@ -148,7 +151,7 @@ wxStdRenderer::ArrowDirection wxStdRenderer::GetArrowDirection(wxDirection dir)
             return Arrow_Down;
 
         default:
             return Arrow_Down;
 
         default:
-            wxFAIL_MSG(_T("unknown arrow direction"));
+            wxFAIL_MSG(wxT("unknown arrow direction"));
     }
 
     return Arrow_Max;
     }
 
     return Arrow_Max;
@@ -164,9 +167,20 @@ void wxStdRenderer::DrawBackground(wxDC& dc,
                                    int WXUNUSED(flags),
                                    wxWindow *window)
 {
                                    int WXUNUSED(flags),
                                    wxWindow *window)
 {
-    wxColour colBg = col.Ok() ? col
-                              : window ? m_scheme->GetBackground(window)
-                                       : wxSCHEME_COLOUR(m_scheme, CONTROL);
+    wxColour colBg;
+
+    if (col.IsOk())
+    {
+        colBg = col;
+    }
+    else if (window)
+    {
+        colBg = m_scheme->GetBackground(window);
+    }
+    else
+    {
+        colBg = wxSCHEME_COLOUR(m_scheme, CONTROL);
+    }
 
     DrawSolidRect(dc, colBg, rect);
 }
 
     DrawSolidRect(dc, colBg, rect);
 }
@@ -185,7 +199,7 @@ void wxStdRenderer::DrawButtonSurface(wxDC& dc,
 // ----------------------------------------------------------------------------
 
 void
 // ----------------------------------------------------------------------------
 
 void
-wxStdRenderer::DrawFocusRect(wxDC& dc, const wxRect& rect, int WXUNUSED(flags))
+wxStdRenderer::DrawFocusRect(wxWindow* WXUNUSED(win), wxDC& dc, const wxRect& rect, int WXUNUSED(flags))
 {
     // draw the pixels manually because the "dots" in wxPen with wxDOT style
     // may be short traits and not really dots
 {
     // draw the pixels manually because the "dots" in wxPen with wxDOT style
     // may be short traits and not really dots
@@ -243,6 +257,8 @@ void wxStdRenderer::DrawButtonLabel(wxDC& dc,
                                     int indexAccel,
                                     wxRect *rectBounds)
 {
                                     int indexAccel,
                                     wxRect *rectBounds)
 {
+    wxDCTextColourChanger clrChanger(dc);
+
     wxRect rectLabel = rect;
     if ( !label.empty() && (flags & wxCONTROL_DISABLED) )
     {
     wxRect rectLabel = rect;
     if ( !label.empty() && (flags & wxCONTROL_DISABLED) )
     {
@@ -253,13 +269,13 @@ void wxStdRenderer::DrawButtonLabel(wxDC& dc,
         }
 
         // draw shadow of the text
         }
 
         // draw shadow of the text
-        dc.SetTextForeground(m_penHighlight.GetColour());
+        clrChanger.Set(m_penHighlight.GetColour());
         wxRect rectShadow = rect;
         rectShadow.Offset(1, 1);
         dc.DrawLabel(label, rectShadow, alignment, indexAccel);
 
         // make the main label text grey
         wxRect rectShadow = rect;
         rectShadow.Offset(1, 1);
         dc.DrawLabel(label, rectShadow, alignment, indexAccel);
 
         // make the main label text grey
-        dc.SetTextForeground(m_penDarkGrey.GetColour());
+        clrChanger.Set(m_penDarkGrey.GetColour());
 
         if ( flags & wxCONTROL_FOCUSED )
         {
 
         if ( flags & wxCONTROL_FOCUSED )
         {
@@ -274,7 +290,7 @@ void wxStdRenderer::DrawButtonLabel(wxDC& dc,
     {
         rectLabel.Inflate(-1);
 
     {
         rectLabel.Inflate(-1);
 
-        DrawFocusRect(dc, rectLabel);
+        DrawFocusRect(NULL, dc, rectLabel);
     }
 }
 
     }
 }
 
@@ -397,13 +413,17 @@ void wxStdRenderer::DrawBorder(wxDC& dc,
     switch ( border )
     {
         case wxBORDER_SUNKEN:
     switch ( border )
     {
         case wxBORDER_SUNKEN:
+        case wxBORDER_THEME:
             DrawSunkenBorder(dc, &rect);
             break;
 
             DrawSunkenBorder(dc, &rect);
             break;
 
+        // wxBORDER_DOUBLE and wxBORDER_THEME are currently the same value.
+#if 0
         case wxBORDER_DOUBLE:
             DrawAntiSunkenBorder(dc, &rect);
             DrawExtraBorder(dc, &rect);
             break;
         case wxBORDER_DOUBLE:
             DrawAntiSunkenBorder(dc, &rect);
             DrawExtraBorder(dc, &rect);
             break;
+#endif
 
         case wxBORDER_STATIC:
             DrawStaticBorder(dc, &rect);
 
         case wxBORDER_STATIC:
             DrawStaticBorder(dc, &rect);
@@ -418,7 +438,7 @@ void wxStdRenderer::DrawBorder(wxDC& dc,
             break;
 
         default:
             break;
 
         default:
-            wxFAIL_MSG(_T("unknown border type"));
+            wxFAIL_MSG(wxT("unknown border type"));
             // fall through
 
         case wxBORDER_DEFAULT:
             // fall through
 
         case wxBORDER_DEFAULT:
@@ -442,15 +462,16 @@ wxRect wxStdRenderer::GetBorderDimensions(wxBorder border) const
 
         case wxBORDER_RAISED:
         case wxBORDER_SUNKEN:
 
         case wxBORDER_RAISED:
         case wxBORDER_SUNKEN:
+        case wxBORDER_THEME:
             width = 2;
             break;
             width = 2;
             break;
-
+#if 0
         case wxBORDER_DOUBLE:
             width = 3;
             break;
         case wxBORDER_DOUBLE:
             width = 3;
             break;
-
+#endif
         default:
         default:
-            wxFAIL_MSG(_T("unknown border type"));
+            wxFAIL_MSG(wxT("unknown border type"));
             // fall through
 
         case wxBORDER_DEFAULT:
             // fall through
 
         case wxBORDER_DEFAULT:
@@ -483,7 +504,7 @@ bool wxStdRenderer::AreScrollbarsInsideBorder() const
 
 wxCoord wxStdRenderer::GetListboxItemHeight(wxCoord fontHeight)
 {
 
 wxCoord wxStdRenderer::GetListboxItemHeight(wxCoord fontHeight)
 {
-    return fontHeight + 2;
+    return fontHeight + 2*ITEM_MARGIN;
 }
 
 void wxStdRenderer::DrawTextBorder(wxDC& dc,
 }
 
 void wxStdRenderer::DrawTextBorder(wxDC& dc,
@@ -609,14 +630,14 @@ void wxStdRenderer::DrawItem(wxDC& dc,
         dc.DrawRectangle(rect);
     }
 
         dc.DrawRectangle(rect);
     }
 
+    // horizontal adjustment is arbitrary
     wxRect rectText = rect;
     wxRect rectText = rect;
-    rectText.x += 2;
-    rectText.width -= 2;
+    rectText.Deflate(2, ITEM_MARGIN);
     dc.DrawLabel(label, wxNullBitmap, rectText);
 
     if ( flags & wxCONTROL_FOCUSED )
     {
     dc.DrawLabel(label, wxNullBitmap, rectText);
 
     if ( flags & wxCONTROL_FOCUSED )
     {
-        DrawFocusRect(dc, rect, flags);
+        DrawFocusRect(NULL, dc, rect, flags);
     }
 }
 
     }
 }
 
@@ -657,9 +678,10 @@ void wxStdRenderer::DrawCheckButton(wxDC& dc,
                                     wxAlignment align,
                                     int indexAccel)
 {
                                     wxAlignment align,
                                     int indexAccel)
 {
-    wxBitmap bmp(bitmap.Ok() ? bitmap : GetCheckBitmap(flags));
-
-    DrawCheckOrRadioButton(dc, label, bmp, rect, flags, align, indexAccel);
+    if (bitmap.IsOk())
+        DrawCheckOrRadioButton(dc, label, bitmap, rect, flags, align, indexAccel);
+    else
+        DrawCheckOrRadioButton(dc, label, GetCheckBitmap(flags), rect, flags, align, indexAccel);
 }
 
 void wxStdRenderer::DrawRadioButton(wxDC& dc,
 }
 
 void wxStdRenderer::DrawRadioButton(wxDC& dc,
@@ -670,9 +692,11 @@ void wxStdRenderer::DrawRadioButton(wxDC& dc,
                                     wxAlignment align,
                                     int indexAccel)
 {
                                     wxAlignment align,
                                     int indexAccel)
 {
-    wxBitmap bmp(bitmap.Ok() ? bitmap : GetRadioBitmap(flags));
+    if (bitmap.IsOk())
+        DrawCheckOrRadioButton(dc, label, bitmap, rect, flags, align, indexAccel);
+    else
+        DrawCheckOrRadioButton(dc, label, GetRadioBitmap(flags), rect, flags, align, indexAccel);
 
 
-    DrawCheckOrRadioButton(dc, label, bmp, rect, flags, align, indexAccel);
 }
 
 void wxStdRenderer::DrawCheckOrRadioButton(wxDC& dc,
 }
 
 void wxStdRenderer::DrawCheckOrRadioButton(wxDC& dc,
@@ -823,270 +847,6 @@ void wxStdRenderer::DrawScrollCorner(wxDC& dc, const wxRect& rect)
     DrawSolidRect(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), rect);
 }
 
     DrawSolidRect(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), rect);
 }
 
-// ----------------------------------------------------------------------------
-// scrollbars geometry
-// ----------------------------------------------------------------------------
-
-#if wxUSE_SCROLLBAR
-
-/* static */
-void wxStdRenderer::GetScrollBarThumbSize(wxCoord length,
-                                          int thumbPos,
-                                          int thumbSize,
-                                          int range,
-                                          wxCoord *thumbStart,
-                                          wxCoord *thumbEnd)
-{
-    // the thumb can't be made less than this number of pixels
-    static const wxCoord thumbMinWidth = 8; // FIXME: should be configurable
-
-    *thumbStart = (length*thumbPos) / range;
-    *thumbEnd = (length*(thumbPos + thumbSize)) / range;
-
-    if ( *thumbEnd - *thumbStart < thumbMinWidth )
-    {
-        // adjust the end if possible
-        if ( *thumbStart <= length - thumbMinWidth )
-        {
-            // yes, just make it wider
-            *thumbEnd = *thumbStart + thumbMinWidth;
-        }
-        else // it is at the bottom of the scrollbar
-        {
-            // so move it a bit up
-            *thumbStart = length - thumbMinWidth;
-            *thumbEnd = length;
-        }
-    }
-}
-
-wxRect wxStdRenderer::GetScrollbarRect(const wxScrollBar *scrollbar,
-                                       wxScrollBar::Element elem,
-                                       int thumbPos) const
-{
-    if ( thumbPos == -1 )
-    {
-        thumbPos = scrollbar->GetThumbPosition();
-    }
-
-    const wxSize sizeArrow = GetScrollbarArrowSize();
-
-    wxSize sizeTotal = scrollbar->GetClientSize();
-    wxCoord *start, *width;
-    wxCoord length, arrow;
-    wxRect rect;
-    if ( scrollbar->IsVertical() )
-    {
-        rect.x = 0;
-        rect.width = sizeTotal.x;
-        length = sizeTotal.y;
-        start = &rect.y;
-        width = &rect.height;
-        arrow = sizeArrow.y;
-    }
-    else // horizontal
-    {
-        rect.y = 0;
-        rect.height = sizeTotal.y;
-        length = sizeTotal.x;
-        start = &rect.x;
-        width = &rect.width;
-        arrow = sizeArrow.x;
-    }
-
-    switch ( elem )
-    {
-        case wxScrollBar::Element_Arrow_Line_1:
-            *start = 0;
-            *width = arrow;
-            break;
-
-        case wxScrollBar::Element_Arrow_Line_2:
-            *start = length - arrow;
-            *width = arrow;
-            break;
-
-        case wxScrollBar::Element_Arrow_Page_1:
-        case wxScrollBar::Element_Arrow_Page_2:
-            // we don't have them at all
-            break;
-
-        case wxScrollBar::Element_Thumb:
-        case wxScrollBar::Element_Bar_1:
-        case wxScrollBar::Element_Bar_2:
-            // we need to calculate the thumb position - do it
-            {
-                length -= 2*arrow;
-                wxCoord thumbStart, thumbEnd;
-                int range = scrollbar->GetRange();
-                if ( !range )
-                {
-                    thumbStart =
-                    thumbEnd = 0;
-                }
-                else
-                {
-                    GetScrollBarThumbSize(length,
-                                          thumbPos,
-                                          scrollbar->GetThumbSize(),
-                                          range,
-                                          &thumbStart,
-                                          &thumbEnd);
-                }
-
-                if ( elem == wxScrollBar::Element_Thumb )
-                {
-                    *start = thumbStart;
-                    *width = thumbEnd - thumbStart;
-                }
-                else if ( elem == wxScrollBar::Element_Bar_1 )
-                {
-                    *start = 0;
-                    *width = thumbStart;
-                }
-                else // elem == wxScrollBar::Element_Bar_2
-                {
-                    *start = thumbEnd;
-                    *width = length - thumbEnd;
-                }
-
-                // everything is relative to the start of the shaft so far
-                *start += arrow;
-            }
-            break;
-
-        case wxScrollBar::Element_Max:
-        default:
-            wxFAIL_MSG( _T("unknown scrollbar element") );
-    }
-
-    return rect;
-}
-
-wxCoord wxStdRenderer::GetScrollbarSize(const wxScrollBar *scrollbar)
-{
-    const wxSize sizeArrowSB = GetScrollbarArrowSize();
-
-    wxCoord sizeArrow, sizeTotal;
-    if ( scrollbar->GetWindowStyle() & wxVERTICAL )
-    {
-        sizeArrow = sizeArrowSB.y;
-        sizeTotal = scrollbar->GetSize().y;
-    }
-    else // horizontal
-    {
-        sizeArrow = sizeArrowSB.x;
-        sizeTotal = scrollbar->GetSize().x;
-    }
-
-    return sizeTotal - 2*sizeArrow;
-}
-
-wxHitTest
-wxStdRenderer::HitTestScrollbar(const wxScrollBar *scrollbar, const wxPoint& pt) const
-{
-    // we only need to work with either x or y coord depending on the
-    // orientation, choose one (but still check the other one to verify if the
-    // mouse is in the window at all)
-    const wxSize sizeArrowSB = GetScrollbarArrowSize();
-
-    wxCoord coord, sizeArrow, sizeTotal;
-    wxSize size = scrollbar->GetSize();
-    if ( scrollbar->GetWindowStyle() & wxVERTICAL )
-    {
-        if ( pt.x < 0 || pt.x > size.x )
-            return wxHT_NOWHERE;
-
-        coord = pt.y;
-        sizeArrow = sizeArrowSB.y;
-        sizeTotal = size.y;
-    }
-    else // horizontal
-    {
-        if ( pt.y < 0 || pt.y > size.y )
-            return wxHT_NOWHERE;
-
-        coord = pt.x;
-        sizeArrow = sizeArrowSB.x;
-        sizeTotal = size.x;
-    }
-
-    // test for the arrows first as it's faster
-    if ( coord < 0 || coord > sizeTotal )
-    {
-        return wxHT_NOWHERE;
-    }
-    else if ( coord < sizeArrow )
-    {
-        return wxHT_SCROLLBAR_ARROW_LINE_1;
-    }
-    else if ( coord > sizeTotal - sizeArrow )
-    {
-        return wxHT_SCROLLBAR_ARROW_LINE_2;
-    }
-    else
-    {
-        // calculate the thumb position in pixels
-        sizeTotal -= 2*sizeArrow;
-        wxCoord thumbStart, thumbEnd;
-        int range = scrollbar->GetRange();
-        if ( !range )
-        {
-            // clicking the scrollbar without range has no effect
-            return wxHT_NOWHERE;
-        }
-        else
-        {
-            GetScrollBarThumbSize(sizeTotal,
-                                  scrollbar->GetThumbPosition(),
-                                  scrollbar->GetThumbSize(),
-                                  range,
-                                  &thumbStart,
-                                  &thumbEnd);
-        }
-
-        // now compare with the thumb position
-        coord -= sizeArrow;
-        if ( coord < thumbStart )
-            return wxHT_SCROLLBAR_BAR_1;
-        else if ( coord > thumbEnd )
-            return wxHT_SCROLLBAR_BAR_2;
-        else
-            return wxHT_SCROLLBAR_THUMB;
-    }
-}
-
-
-wxCoord
-wxStdRenderer::ScrollbarToPixel(const wxScrollBar *scrollbar, int thumbPos)
-{
-    int range = scrollbar->GetRange();
-    if ( !range )
-    {
-        // the only valid position anyhow
-        return 0;
-    }
-
-    if ( thumbPos == -1 )
-    {
-        // by default use the current thumb position
-        thumbPos = scrollbar->GetThumbPosition();
-    }
-
-    const wxSize sizeArrow = GetScrollbarArrowSize();
-    return (thumbPos*GetScrollbarSize(scrollbar)) / range
-             + (scrollbar->IsVertical() ? sizeArrow.y : sizeArrow.x);
-}
-
-int wxStdRenderer::PixelToScrollbar(const wxScrollBar *scrollbar, wxCoord coord)
-{
-    const wxSize sizeArrow = GetScrollbarArrowSize();
-    return ((coord - (scrollbar->IsVertical() ? sizeArrow.y : sizeArrow.x)) *
-               scrollbar->GetRange() ) / GetScrollbarSize(scrollbar);
-}
-
-#endif // wxUSE_SCROLLBAR
-
 // ----------------------------------------------------------------------------
 // status bar
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // status bar
 // ----------------------------------------------------------------------------
@@ -1102,7 +862,7 @@ wxSize wxStdRenderer::GetStatusBarBorders() const
     wxRect flat = GetBorderDimensions(wxBORDER_STATIC);
     wxASSERT_MSG( raised.x == raised.width && raised.y == raised.height &&
                   flat.x == flat.width && flat.y == flat.height,
     wxRect flat = GetBorderDimensions(wxBORDER_STATIC);
     wxASSERT_MSG( raised.x == raised.width && raised.y == raised.height &&
                   flat.x == flat.width && flat.y == flat.height,
-                  _T("this code expects uniform borders, you must override GetStatusBarBorders") );
+                  wxT("this code expects uniform borders, you must override GetStatusBarBorders") );
 
     // take the larger of flat/raised values:
     wxSize border(wxMax(raised.x, flat.x), wxMax(raised.y, flat.y));
 
     // take the larger of flat/raised values:
     wxSize border(wxMax(raised.x, flat.x), wxMax(raised.y, flat.y));
@@ -1132,6 +892,8 @@ void wxStdRenderer::DrawStatusField(wxDC& dc,
         DrawBorder(dc, wxBORDER_RAISED, rect, flags, &rectIn);
     else if ( style != wxSB_FLAT )
         DrawBorder(dc, wxBORDER_STATIC, rect, flags, &rectIn);
         DrawBorder(dc, wxBORDER_RAISED, rect, flags, &rectIn);
     else if ( style != wxSB_FLAT )
         DrawBorder(dc, wxBORDER_STATIC, rect, flags, &rectIn);
+    else
+        rectIn = rect;
 
     rectIn.Deflate(GetStatusBarFieldMargins());
 
 
     rectIn.Deflate(GetStatusBarFieldMargins());
 
@@ -1386,7 +1148,7 @@ void wxStdRenderer::DrawFrameIcon(wxDC& dc,
                                   const wxIcon& icon,
                                   int flags)
 {
                                   const wxIcon& icon,
                                   int flags)
 {
-    if ( icon.Ok() )
+    if ( icon.IsOk() )
     {
         wxRect r = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
         dc.DrawIcon(icon, r.x, r.y);
     {
         wxRect r = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
         dc.DrawIcon(icon, r.x, r.y);
@@ -1412,7 +1174,7 @@ void wxStdRenderer::DrawFrameButton(wxDC& dc,
     }
 
     wxBitmap bmp = GetFrameButtonBitmap(idx);
     }
 
     wxBitmap bmp = GetFrameButtonBitmap(idx);
-    if ( !bmp.Ok() )
+    if ( !bmp.IsOk() )
         return;
 
     wxRect rectBtn(x, y, FRAME_BUTTON_WIDTH, FRAME_BUTTON_HEIGHT);
         return;
 
     wxRect rectBtn(x, y, FRAME_BUTTON_WIDTH, FRAME_BUTTON_HEIGHT);