setting clipping correctly

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

diff --git a/src/univ/stdrend.cpp b/src/univ/stdrend.cpp
index d184d762141ce5caa37186db366b8953e86da983..5a78545902b1a7ffb56c8a223811e5e416e8950b 100644 (file)
--- a/src/univ/stdrend.cpp
+++ b/src/univ/stdrend.cpp
@@ -24,6 +24,11 @@
 #endif
 
 #ifndef WX_PRECOMP
 #endif
 
 #ifndef WX_PRECOMP

+    #include "wx/settings.h"
+    #include "wx/brush.h"
+    #include "wx/dc.h"
+    #include "wx/statusbr.h"
+    #include "wx/toplevel.h"

 #endif //WX_PRECOMP
 
 #include "wx/univ/stdrend.h"
 #endif //WX_PRECOMP
 
 #include "wx/univ/stdrend.h"


@@ -33,12 +38,13 @@
 // constants
 // ----------------------------------------------------------------------------
 
 // constants
 // ----------------------------------------------------------------------------
 

-static const int FRAME_BORDER_THICKNESS            = 3;
-static const int RESIZEABLE_FRAME_BORDER_THICKNESS = 4;

 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_TITLEBAR_HEIGHT             = 18;
 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
 // ============================================================================


@@ -161,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.Ok())
+    {
+        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);
 }


@@ -181,7 +198,8 @@ void wxStdRenderer::DrawButtonSurface(wxDC& dc,
 // text
 // ----------------------------------------------------------------------------
 
 // text
 // ----------------------------------------------------------------------------
 

-void wxStdRenderer::DrawFocusRect(wxDC& dc, const wxRect& rect)
+void
+wxStdRenderer::DrawFocusRect(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


@@ -366,12 +384,22 @@ void wxStdRenderer::DrawAntiSunkenBorder(wxDC& dc, wxRect *rect)
     DrawShadedRect(dc, rect, m_penHighlight, m_penDarkGrey);
 }
 
     DrawShadedRect(dc, rect, m_penHighlight, m_penDarkGrey);
 }
 

-void wxStdRenderer::DrawFrameBorder(wxDC& dc, wxRect *rect)
+void wxStdRenderer::DrawBoxBorder(wxDC& dc, wxRect *rect)

 {
     DrawShadedRect(dc, rect, m_penDarkGrey, m_penHighlight);
     DrawShadedRect(dc, rect, m_penHighlight, m_penDarkGrey);
 }
 
 {
     DrawShadedRect(dc, rect, m_penDarkGrey, m_penHighlight);
     DrawShadedRect(dc, rect, m_penHighlight, m_penDarkGrey);
 }
 

+void wxStdRenderer::DrawStaticBorder(wxDC& dc, wxRect *rect)
+{
+    DrawShadedRect(dc, rect, m_penDarkGrey, m_penHighlight);
+}
+
+void wxStdRenderer::DrawExtraBorder(wxDC& dc, wxRect *rect)
+{
+    DrawRect(dc, rect, m_penLightGrey);
+}
+

 void wxStdRenderer::DrawBorder(wxDC& dc,
                                wxBorder border,
                                const wxRect& rectTotal,
 void wxStdRenderer::DrawBorder(wxDC& dc,
                                wxBorder border,
                                const wxRect& rectTotal,


@@ -388,11 +416,11 @@ void wxStdRenderer::DrawBorder(wxDC& dc,
 
         case wxBORDER_DOUBLE:
             DrawAntiSunkenBorder(dc, &rect);
 
         case wxBORDER_DOUBLE:
             DrawAntiSunkenBorder(dc, &rect);

-            DrawRect(dc, &rect, m_penLightGrey);
+            DrawExtraBorder(dc, &rect);

             break;
 
         case wxBORDER_STATIC:
             break;
 
         case wxBORDER_STATIC:

-            DrawShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
+            DrawStaticBorder(dc, &rect);

             break;
 
         case wxBORDER_RAISED:
             break;
 
         case wxBORDER_RAISED:


@@ -469,7 +497,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,


@@ -574,7 +602,7 @@ void wxStdRenderer::DrawFrame(wxDC& dc,
     }
     else // no label
     {
     }
     else // no label
     {

-        DrawFrameBorder(dc, &rectFrame);
+        DrawBoxBorder(dc, &rectFrame);

     }
 }
 
     }
 }
 


@@ -595,14 +623,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);
+        DrawFocusRect(dc, rect, flags);

     }
 }
 
     }
 }
 


@@ -1079,11 +1107,30 @@ int wxStdRenderer::PixelToScrollbar(const wxScrollBar *scrollbar, wxCoord coord)
 
 #if wxUSE_STATUSBAR
 
 
 #if wxUSE_STATUSBAR
 

-wxSize wxStdRenderer::GetStatusBarBorders(wxCoord *borderBetweenFields) const
+wxSize wxStdRenderer::GetStatusBarBorders() const

 {
 {

-    if ( borderBetweenFields )
-        *borderBetweenFields = 2;
+    // Rendered border may be different depending on field's style, we use
+    // the largest value so that any field certainly fits into the borders
+    // we return:
+    wxRect raised = GetBorderDimensions(wxBORDER_RAISED);
+    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") );
+
+    // take the larger of flat/raised values:
+    wxSize border(wxMax(raised.x, flat.x), wxMax(raised.y, flat.y));
+
+    return border;
+}

 
 

+wxCoord wxStdRenderer::GetStatusBarBorderBetweenFields() const
+{
+    return 2;
+}
+
+wxSize wxStdRenderer::GetStatusBarFieldMargins() const
+{

     return wxSize(2, 2);
 }
 
     return wxSize(2, 2);
 }
 


@@ -1100,7 +1147,7 @@ void wxStdRenderer::DrawStatusField(wxDC& dc,
     else if ( style != wxSB_FLAT )
         DrawBorder(dc, wxBORDER_STATIC, rect, flags, &rectIn);
 
     else if ( style != wxSB_FLAT )
         DrawBorder(dc, wxBORDER_STATIC, rect, flags, &rectIn);
 

-    rectIn.Deflate(GetStatusBarBorders(NULL));
+    rectIn.Deflate(GetStatusBarFieldMargins());

 
     wxDCClipper clipper(dc, rectIn);
     DrawLabel(dc, label, rectIn, flags, wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL);
 
     wxDCClipper clipper(dc, rectIn);
     DrawLabel(dc, label, rectIn, flags, wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL);


@@ -1256,11 +1303,10 @@ void wxStdRenderer::DrawFrameBorder(wxDC& dc, const wxRect& rect, int flags)
 
     wxRect r(rect);
 
 
     wxRect r(rect);
 

-    DrawShadedRect(dc, &r, m_penLightGrey, m_penBlack);
-    DrawShadedRect(dc, &r, m_penHighlight, m_penDarkGrey);
-    DrawShadedRect(dc, &r, m_penLightGrey, m_penLightGrey);
+    DrawAntiSunkenBorder(dc, &r);
+    DrawExtraBorder(dc, &r);

     if ( flags & wxTOPLEVEL_RESIZEABLE )
     if ( flags & wxTOPLEVEL_RESIZEABLE )

-        DrawShadedRect(dc, &r, m_penLightGrey, m_penLightGrey);
+        DrawExtraBorder(dc, &r);

 }
 
 void wxStdRenderer::DrawFrameBackground(wxDC& dc, const wxRect& rect, int flags)
 }
 
 void wxStdRenderer::DrawFrameBackground(wxDC& dc, const wxRect& rect, int flags)


@@ -1383,22 +1429,27 @@ void wxStdRenderer::DrawFrameButton(wxDC& dc,
     if ( !bmp.Ok() )
         return;
 
     if ( !bmp.Ok() )
         return;
 

-    wxRect r(x, y, FRAME_BUTTON_WIDTH, FRAME_BUTTON_HEIGHT);
+    wxRect rectBtn(x, y, FRAME_BUTTON_WIDTH, FRAME_BUTTON_HEIGHT);

     if ( flags & wxCONTROL_PRESSED )
     {
     if ( flags & wxCONTROL_PRESSED )
     {

-        DrawSunkenBorder(dc, &r);
+        DrawSunkenBorder(dc, &rectBtn);

 
 

-        r.x++;
-        r.y++;
+        rectBtn.Offset(1, 1);

     }
     else
     {
     }
     else
     {

-        DrawRaisedBorder(dc, &r);
+        DrawRaisedBorder(dc, &rectBtn);

     }
 
     }
 

-    DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), r);
+    DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), rectBtn);
+
+    wxRect rectBmp(0, 0, bmp.GetWidth(), bmp.GetHeight());
+    dc.DrawBitmap(bmp, rectBmp.CentreIn(rectBtn).GetPosition(), true);
+}

 
 

-    dc.DrawBitmap(bmp, r.x, r.y, true);
+int wxStdRenderer::GetFrameBorderWidth(int flags) const
+{
+    return flags & wxTOPLEVEL_RESIZEABLE ? 4 : 3;

 }
 
 
 }
 
 


@@ -1408,10 +1459,7 @@ wxRect wxStdRenderer::GetFrameClientArea(const wxRect& rect, int flags) const
 
     if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
     {
 
     if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
     {

-        int border = flags & wxTOPLEVEL_RESIZEABLE
-                        ? RESIZEABLE_FRAME_BORDER_THICKNESS
-                        : FRAME_BORDER_THICKNESS;
-        r.Inflate(-border);
+        r.Inflate(-GetFrameBorderWidth(flags));

     }
 
     if ( flags & wxTOPLEVEL_TITLEBAR )
     }
 
     if ( flags & wxTOPLEVEL_TITLEBAR )


@@ -1430,11 +1478,7 @@ wxStdRenderer::GetFrameTotalSize(const wxSize& clientSize, int flags) const
 
     if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
     {
 
     if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
     {

-        int border = flags & wxTOPLEVEL_RESIZEABLE
-                        ? RESIZEABLE_FRAME_BORDER_THICKNESS
-                        : FRAME_BORDER_THICKNESS;
-        s.x += 2*border;
-        s.y += 2*border;
+        s.IncBy(2*GetFrameBorderWidth(flags));

     }
 
     if ( flags & wxTOPLEVEL_TITLEBAR )
     }
 
     if ( flags & wxTOPLEVEL_TITLEBAR )


@@ -1449,11 +1493,7 @@ wxSize wxStdRenderer::GetFrameMinSize(int flags) const
 
     if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
     {
 
     if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
     {

-        int border = (flags & wxTOPLEVEL_RESIZEABLE) ?
-                        RESIZEABLE_FRAME_BORDER_THICKNESS :
-                        FRAME_BORDER_THICKNESS;
-        s.x += 2*border;
-        s.y += 2*border;
+        s.IncBy(2*GetFrameBorderWidth(flags));

     }
 
     if ( flags & wxTOPLEVEL_TITLEBAR )
     }
 
     if ( flags & wxTOPLEVEL_TITLEBAR )


@@ -1481,4 +1521,3 @@ wxSize wxStdRenderer::GetFrameIconSize() const
 {
     return wxSize(16, 16);
 }
 {
     return wxSize(16, 16);
 }

-