///////////////////////////////////////////////////////////////////////////////
-// Name: univ/ctrlrend.cpp
+// Name: src/univ/ctrlrend.cpp
// Purpose: wxControlRenderer implementation
// Author: Vadim Zeitlin
// Modified by:
// headers
// ---------------------------------------------------------------------------
-#ifdef __GNUG__
- #pragma implementation "renderer.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#include "wx/listbox.h"
#include "wx/scrolbar.h"
#include "wx/dc.h"
+ #include "wx/log.h"
+ #include "wx/gauge.h"
+ #include "wx/image.h"
#endif // WX_PRECOMP
-#include "wx/image.h"
-#include "wx/log.h"
-
#include "wx/univ/theme.h"
#include "wx/univ/renderer.h"
#include "wx/univ/colschem.h"
-#if wxUSE_GAUGE
-#include "wx/gauge.h"
-#endif
-
// ============================================================================
// implementation
// ============================================================================
-// ----------------------------------------------------------------------------
-// wxRenderer: drawing helpers
-// ----------------------------------------------------------------------------
-
-void wxRenderer::StandardDrawFrame(wxDC& dc,
- const wxRect& rectFrame,
- const wxRect& rectLabel)
-{
- // draw left, bottom and right lines entirely
- DrawVerticalLine(dc, rectFrame.GetLeft(),
- rectFrame.GetTop(), rectFrame.GetBottom() - 2);
- DrawHorizontalLine(dc, rectFrame.GetBottom() - 1,
- rectFrame.GetLeft(), rectFrame.GetRight());
- DrawVerticalLine(dc, rectFrame.GetRight() - 1,
- rectFrame.GetTop(), rectFrame.GetBottom() - 1);
-
- // and 2 parts of the top line
- DrawHorizontalLine(dc, rectFrame.GetTop(),
- rectFrame.GetLeft() + 1, rectLabel.GetLeft());
- DrawHorizontalLine(dc, rectFrame.GetTop(),
- rectLabel.GetRight(), rectFrame.GetRight() - 2);
-}
-
-/* static */
-void wxRenderer::StandardDrawTextLine(wxDC& dc,
- const wxString& text,
- const wxRect& rect,
- int selStart, int selEnd,
- int flags)
-{
- if ( (selStart == -1) || !(flags & wxCONTROL_FOCUSED) )
- {
- // just draw it as is
- dc.DrawText(text, rect.x, rect.y);
- }
- else // we have selection
- {
- wxCoord width,
- x = rect.x;
-
- // draw the part before selection
- wxString s(text, (size_t)selStart);
- if ( !s.empty() )
- {
- dc.DrawText(s, x, rect.y);
-
- dc.GetTextExtent(s, &width, NULL);
- x += width;
- }
-
- // draw the selection itself
- s = wxString(text.c_str() + selStart, text.c_str() + selEnd);
- if ( !s.empty() )
- {
- wxColour colFg = dc.GetTextForeground(),
- colBg = dc.GetTextBackground();
- dc.SetTextForeground(wxTHEME_COLOUR(HIGHLIGHT_TEXT));
- dc.SetTextBackground(wxTHEME_COLOUR(HIGHLIGHT));
- dc.SetBackgroundMode(wxSOLID);
-
- dc.DrawText(s, x, rect.y);
- dc.GetTextExtent(s, &width, NULL);
- x += width;
-
- dc.SetBackgroundMode(wxTRANSPARENT);
- dc.SetTextBackground(colBg);
- dc.SetTextForeground(colFg);
- }
-
- // draw the final part
- s = text.c_str() + selEnd;
- if ( !s.empty() )
- {
- dc.DrawText(s, x, rect.y);
- }
- }
-}
-
-// ----------------------------------------------------------------------------
-// wxRenderer: scrollbar geometry
-// ----------------------------------------------------------------------------
-
-/* static */
-void wxRenderer::StandardScrollBarThumbSize(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;
- }
- }
-}
-
-/* static */
-wxRect wxRenderer::StandardGetScrollbarRect(const wxScrollBar *scrollbar,
- wxScrollBar::Element elem,
- int thumbPos,
- const wxSize& sizeArrow)
-{
- if ( thumbPos == -1 )
- {
- thumbPos = scrollbar->GetThumbPosition();
- }
-
- wxSize sizeTotal = scrollbar->GetClientSize();
- wxCoord *start, *width, 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
- {
- StandardScrollBarThumbSize(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;
-}
-
-/* static */
-wxCoord wxRenderer::StandardScrollBarSize(const wxScrollBar *scrollbar,
- const wxSize& sizeArrowSB)
-{
- 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;
-}
-
-/* static */
-wxCoord wxRenderer::StandardScrollbarToPixel(const wxScrollBar *scrollbar,
- int thumbPos,
- const wxSize& sizeArrow)
-{
- 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();
- }
-
- return ( thumbPos*StandardScrollBarSize(scrollbar, sizeArrow) ) / range
- + (scrollbar->IsVertical() ? sizeArrow.y : sizeArrow.x);
-}
-
-/* static */
-int wxRenderer::StandardPixelToScrollbar(const wxScrollBar *scrollbar,
- wxCoord coord,
- const wxSize& sizeArrow)
-{
- return ( (coord - (scrollbar->IsVertical() ? sizeArrow.y : sizeArrow.x)) *
- scrollbar->GetRange() ) /
- StandardScrollBarSize(scrollbar, sizeArrow);
-}
-
-/* static */
-wxHitTest wxRenderer::StandardHitTestScrollbar(const wxScrollBar *scrollbar,
- const wxPoint& pt,
- const wxSize& sizeArrowSB)
-{
- // 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)
- 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
- {
- StandardScrollBarThumbSize(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;
- }
-}
-
wxRenderer::~wxRenderer()
{
}
m_rect.height = size.y;
}
-void wxControlRenderer::DrawLabel(const wxBitmap& bitmap,
- wxCoord marginX, wxCoord marginY)
+void wxControlRenderer::DrawLabel()
+{
+ m_dc.SetBackgroundMode(wxTRANSPARENT);
+ m_dc.SetFont(m_window->GetFont());
+ m_dc.SetTextForeground(m_window->GetForegroundColour());
+
+ wxString label = m_window->GetLabel();
+ if ( !label.empty() )
+ {
+ wxControl *ctrl = wxStaticCast(m_window, wxControl);
+
+ m_renderer->DrawLabel(m_dc,
+ label,
+ m_rect,
+ m_window->GetStateFlags(),
+ ctrl->GetAlignment(),
+ ctrl->GetAccelIndex());
+ }
+}
+
+void wxControlRenderer::DrawButtonLabel(const wxBitmap& bitmap,
+ wxCoord marginX, wxCoord marginY)
{
m_dc.SetBackgroundMode(wxTRANSPARENT);
m_dc.SetFont(m_window->GetFont());
}
}
}
+#if wxUSE_IMAGE
else if ( stretch & wxEXPAND )
{
// stretch bitmap to fill the entire control
bmp = wxBitmap(wxImage(bmp.ConvertToImage()).Scale(rect.width, rect.height));
}
+#endif // wxUSE_IMAGE
else // not stretched, not tiled
{
if ( alignment & wxALIGN_RIGHT )
}
// do draw it
- dc.DrawBitmap(bmp, x, y, TRUE /* use mask */);
+ dc.DrawBitmap(bmp, x, y, true /* use mask */);
}
+#if wxUSE_SCROLLBAR
+
void wxControlRenderer::DrawScrollbar(const wxScrollBar *scrollbar,
int WXUNUSED(thumbPosOld))
{
{
wxRect rectUpdate = rgnUpdate.GetBox();
- wxLogTrace(_T("scrollbar"),
- _T("%s redraw: update box is (%d, %d)-(%d, %d)"),
- scrollbar->IsVertical() ? _T("vert") : _T("horz"),
+ wxLogTrace(wxT("scrollbar"),
+ wxT("%s redraw: update box is (%d, %d)-(%d, %d)"),
+ scrollbar->IsVertical() ? wxT("vert") : wxT("horz"),
rectUpdate.GetLeft(),
rectUpdate.GetTop(),
rectUpdate.GetRight(),
rectUpdate.GetBottom());
#if 0 //def WXDEBUG_SCROLLBAR
- static bool s_refreshDebug = FALSE;
+ static bool s_refreshDebug = false;
if ( s_refreshDebug )
{
wxClientDC dc(wxConstCast(scrollbar, wxScrollBar));
wxScrollBar::Element elem =
(wxScrollBar::Element)(wxScrollBar::Element_Bar_1 + nBar);
- wxRect rectBar = m_renderer->GetScrollbarRect(scrollbar, elem);
+ wxRect rectBar = scrollbar->GetScrollbarRect(elem);
if ( rgnUpdate.Contains(rectBar) )
{
- wxLogTrace(_T("scrollbar"),
- _T("drawing bar part %d at (%d, %d)-(%d, %d)"),
+ wxLogTrace(wxT("scrollbar"),
+ wxT("drawing bar part %d at (%d, %d)-(%d, %d)"),
nBar + 1,
rectBar.GetLeft(),
rectBar.GetTop(),
wxScrollBar::Element elem =
(wxScrollBar::Element)(wxScrollBar::Element_Arrow_Line_1 + nArrow);
- wxRect rectArrow = m_renderer->GetScrollbarRect(scrollbar, elem);
+ wxRect rectArrow = scrollbar->GetScrollbarRect(elem);
if ( rgnUpdate.Contains(rectArrow) )
{
- wxLogTrace(_T("scrollbar"),
- _T("drawing arrow %d at (%d, %d)-(%d, %d)"),
+ wxLogTrace(wxT("scrollbar"),
+ wxT("drawing arrow %d at (%d, %d)-(%d, %d)"),
nArrow + 1,
rectArrow.GetLeft(),
rectArrow.GetTop(),
(wxScrollArrows::Arrow)nArrow,
m_dc,
rectArrow,
- TRUE // draw a scrollbar arrow, not just an arrow
+ true // draw a scrollbar arrow, not just an arrow
);
}
}
// and the thumb
wxScrollBar::Element elem = wxScrollBar::Element_Thumb;
- wxRect rectThumb = m_renderer->GetScrollbarRect(scrollbar, elem);
+ wxRect rectThumb = scrollbar->GetScrollbarRect(elem);
if ( rectThumb.width && rectThumb.height && rgnUpdate.Contains(rectThumb) )
{
- wxLogTrace(_T("scrollbar"),
- _T("drawing thumb at (%d, %d)-(%d, %d)"),
+ wxLogTrace(wxT("scrollbar"),
+ wxT("drawing thumb at (%d, %d)-(%d, %d)"),
rectThumb.GetLeft(),
rectThumb.GetTop(),
rectThumb.GetRight(),
}
}
+#endif // wxUSE_SCROLLBAR
+
void wxControlRenderer::DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
{
wxASSERT_MSG( x1 == x2 || y1 == y2,
- _T("line must be either horizontal or vertical") );
+ wxT("line must be either horizontal or vertical") );
if ( x1 == x2 )
m_renderer->DrawVerticalLine(m_dc, x1, y1, y2);
void wxControlRenderer::DoDrawItems(const wxListBox *lbox,
size_t itemFirst, size_t itemLast,
- bool isCheckLbox)
+#if wxUSE_CHECKLISTBOX
+ bool isCheckLbox
+#else
+ bool WXUNUSED(isCheckLbox)
+#endif
+ )
{
// prepare for the drawing: calc the initial position
wxCoord lineHeight = lbox->GetLineHeight();
void wxControlRenderer::DrawCheckItems(const wxCheckListBox *lbox,
size_t itemFirst, size_t itemLast)
{
- DoDrawItems(lbox, itemFirst, itemLast, TRUE);
+ DoDrawItems(lbox, itemFirst, itemLast, true);
}
#endif // wxUSE_CHECKLISTBOX
int step = gauge->IsVertical() ? sizeStep.y : sizeStep.x;
// we divide by it below!
- wxCHECK_RET( step, _T("invalid wxGauge step") );
+ wxCHECK_RET( step, wxT("invalid wxGauge step") );
// round up to make the progress appear to start faster
int lenTotal = gauge->IsVertical() ? rect.height : rect.width;
int steps = ((lenTotal + step - 1) * pos) / (max * step);
// calc the coords of one small rect
- wxCoord *px, dx, dy;
+ wxCoord *px;
+ wxCoord dx, dy;
if ( gauge->IsVertical() )
{
// draw from bottom to top: so first set y to the bottom
}
#endif // wxUSE_GAUGE
-
projects / wxWidgets.git / blobdiff