#pragma hdrstop
#endif
+#include "wx/univ/theme.h"
+
+#if wxUSE_THEME_GTK
+
#ifndef WX_PRECOMP
#include "wx/intl.h"
#include "wx/log.h"
#include "wx/dcmemory.h"
+ #include "wx/dcclient.h"
#include "wx/window.h"
#include "wx/menu.h"
#include "wx/settings.h"
#include "wx/toplevel.h"
+ #include "wx/image.h"
#endif // WX_PRECOMP
#include "wx/notebook.h"
#include "wx/spinbutt.h"
#include "wx/artprov.h"
-#include "wx/image.h"
#ifdef wxUSE_TOGGLEBTN
#include "wx/tglbtn.h"
#endif // wxUSE_TOGGLEBTN
-#include "wx/univ/renderer.h"
+#include "wx/univ/stdrend.h"
+#include "wx/univ/inpcons.h"
#include "wx/univ/inphand.h"
#include "wx/univ/colschem.h"
-#include "wx/univ/theme.h"
-class WXDLLEXPORT wxGTKMenuGeometryInfo;
+class wxGTKMenuGeometryInfo;
// ----------------------------------------------------------------------------
-// constants (to be removed, for testing only)
+// constants
// ----------------------------------------------------------------------------
-static const size_t BORDER_THICKNESS = 1;
+// standard border size
+static const int BORDER_THICKNESS = 2;
// ----------------------------------------------------------------------------
// wxGTKRenderer: draw the GUI elements in GTK style
// ----------------------------------------------------------------------------
-class wxGTKRenderer : public wxRenderer
+class wxGTKRenderer : public wxStdRenderer
{
public:
wxGTKRenderer(const wxColourScheme *scheme);
- // implement the base class pure virtuals
- virtual void DrawBackground(wxDC& dc,
- const wxColour& col,
+ // wxRenderer methods
+ virtual void DrawFocusRect(wxWindow* win, wxDC& dc, const wxRect& rect, int flags = 0);
+ virtual void DrawTextBorder(wxDC& dc,
+ wxBorder border,
const wxRect& rect,
int flags = 0,
- wxWindow *window = NULL );
- virtual void DrawLabel(wxDC& dc,
- const wxString& label,
- const wxRect& rect,
- int flags = 0,
- int alignment = wxALIGN_LEFT | wxALIGN_TOP,
- int indexAccel = -1,
- wxRect *rectBounds = NULL);
+ wxRect *rectIn = NULL);
virtual void DrawButtonLabel(wxDC& dc,
const wxString& label,
const wxBitmap& image,
const wxRect& rect,
- int flags = 0,
- int alignment = wxALIGN_LEFT | wxALIGN_TOP,
- int indexAccel = -1,
- wxRect *rectBounds = NULL);
- virtual void DrawBorder(wxDC& dc,
- wxBorder border,
- const wxRect& rect,
- int flags = 0,
- wxRect *rectIn = (wxRect *)NULL);
- virtual void DrawHorizontalLine(wxDC& dc,
- wxCoord y, wxCoord x1, wxCoord x2);
- virtual void DrawVerticalLine(wxDC& dc,
- wxCoord x, wxCoord y1, wxCoord y2);
- virtual void DrawFrame(wxDC& dc,
- const wxString& label,
- const wxRect& rect,
- int flags = 0,
- int alignment = wxALIGN_LEFT,
- int indexAccel = -1);
- virtual void DrawTextBorder(wxDC& dc,
- wxBorder border,
- const wxRect& rect,
- int flags = 0,
- wxRect *rectIn = (wxRect *)NULL);
+ int flags,
+ int alignment,
+ int indexAccel,
+ wxRect *rectBounds);
virtual void DrawButtonBorder(wxDC& dc,
const wxRect& rect,
int flags = 0,
- wxRect *rectIn = (wxRect *)NULL);
+ wxRect *rectIn = NULL);
virtual void DrawArrow(wxDC& dc,
wxDirection dir,
const wxRect& rect,
wxOrientation orient,
const wxRect& rect,
int flags = 0);
- virtual void DrawScrollCorner(wxDC& dc,
- const wxRect& rect);
- virtual void DrawItem(wxDC& dc,
- const wxString& label,
- const wxRect& rect,
- int flags = 0);
- virtual void DrawCheckItem(wxDC& dc,
- const wxString& label,
- const wxBitmap& bitmap,
- const wxRect& rect,
- int flags = 0);
- virtual void DrawCheckButton(wxDC& dc,
- const wxString& label,
- const wxBitmap& bitmap,
- const wxRect& rect,
- int flags = 0,
- wxAlignment align = wxALIGN_LEFT,
- int indexAccel = -1);
-
- virtual void DrawRadioButton(wxDC& dc,
- const wxString& label,
- const wxBitmap& bitmap,
- const wxRect& rect,
- int flags = 0,
- wxAlignment align = wxALIGN_LEFT,
- int indexAccel = -1);
#if wxUSE_TOOLBAR
virtual void DrawToolBarButton(wxDC& dc,
int tbarStyle = 0);
#endif // wxUSE_TOOLBAR
- virtual void DrawTextLine(wxDC& dc,
- const wxString& text,
- const wxRect& rect,
- int selStart = -1,
- int selEnd = -1,
- int flags = 0);
+#if wxUSE_TEXTCTRL
virtual void DrawLineWrapMark(wxDC& dc, const wxRect& rect);
+#endif // wxUSE_TEXTCTRL
+
+#if wxUSE_NOTEBOOK
virtual void DrawTab(wxDC& dc,
const wxRect& rect,
wxDirection dir,
const wxBitmap& bitmap = wxNullBitmap,
int flags = 0,
int indexAccel = -1);
+#endif // wxUSE_NOTEBOOK
#if wxUSE_SLIDER
virtual void DrawSliderShaft(wxDC& dc,
const wxMenuGeometryInfo& geomInfo);
#endif // wxUSE_MENUS
-#if wxUSE_STATUSBAR
- virtual void DrawStatusField(wxDC& dc,
- const wxRect& rect,
- const wxString& label,
- int flags = 0, int style = 0);
-#endif // wxUSE_STATUSBAR
-
- virtual void DrawFrameTitleBar(wxDC& dc,
- const wxRect& rect,
- const wxString& title,
- const wxIcon& icon,
- int flags,
- int specialButton = 0,
- int specialButtonFlag = 0);
- virtual void DrawFrameBorder(wxDC& dc,
- const wxRect& rect,
- int flags);
- virtual void DrawFrameBackground(wxDC& dc,
- const wxRect& rect,
- int flags);
- virtual void DrawFrameTitle(wxDC& dc,
- const wxRect& rect,
- const wxString& title,
- int flags);
- virtual void DrawFrameIcon(wxDC& dc,
- const wxRect& rect,
- const wxIcon& icon,
- int flags);
- virtual void DrawFrameButton(wxDC& dc,
- wxCoord x, wxCoord y,
- int button,
- int flags = 0);
-
- // titlebars
- virtual wxRect GetFrameClientArea(const wxRect& rect, int flags) const;
- virtual wxSize GetFrameTotalSize(const wxSize& clientSize, int flags) const;
- virtual wxSize GetFrameMinSize(int flags) const;
- virtual wxSize GetFrameIconSize() const;
- virtual int HitTestFrame(const wxRect& rect, const wxPoint& pt, int flags) const;
-
virtual void GetComboBitmaps(wxBitmap *bmpNormal,
wxBitmap *bmpFocus,
wxBitmap *bmpPressed,
wxBitmap *bmpDisabled);
virtual void AdjustSize(wxSize *size, const wxWindow *window);
- virtual wxRect GetBorderDimensions(wxBorder border) const;
- virtual bool AreScrollbarsInsideBorder() const;
// geometry and hit testing
+#if wxUSE_SCROLLBAR
virtual wxSize GetScrollbarArrowSize() const
{ return m_sizeScrollbarArrow; }
-#if wxUSE_SCROLLBAR
- virtual wxRect GetScrollbarRect(const wxScrollBar *scrollbar,
- wxScrollBar::Element elem,
- int thumbPos = -1) const;
- virtual wxCoord GetScrollbarSize(const wxScrollBar *scrollbar);
- virtual wxHitTest HitTestScrollbar(const wxScrollBar *scrollbar,
- const wxPoint& pt) const;
- virtual wxCoord ScrollbarToPixel(const wxScrollBar *scrollbar,
- int thumbPos = -1);
- virtual int PixelToScrollbar(const wxScrollBar *scrollbar, wxCoord coord);
#endif // wxUSE_SCROLLBAR
- virtual wxCoord GetListboxItemHeight(wxCoord fontHeight)
- { return fontHeight + 2; }
virtual wxSize GetCheckBitmapSize() const
{ return wxSize(10, 10); }
virtual wxSize GetRadioBitmapSize() const
virtual wxCoord GetCheckItemMargin() const
{ return 2; }
+#if wxUSE_TOOLBAR
virtual wxSize GetToolBarButtonSize(wxCoord *separator) const
{ if ( separator ) *separator = 5; return wxSize(16, 15); }
virtual wxSize GetToolBarMargin() const
{ return wxSize(6, 6); }
+#endif // wxUSE_TOOLBAR
#if wxUSE_TEXTCTRL
- virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
- const wxRect& rect) const;
virtual wxRect GetTextClientArea(const wxTextCtrl *text,
const wxRect& rect,
wxCoord *extraSpaceBeyond) const;
#endif // wxUSE_TEXTCTRL
+#if wxUSE_NOTEBOOK
virtual wxSize GetTabIndent() const { return wxSize(2, 2); }
virtual wxSize GetTabPadding() const { return wxSize(6, 6); }
+#endif // wxUSE_NOTEBOOK
#if wxUSE_SLIDER
virtual wxCoord GetSliderDim() const { return 15; }
const wxMenu& menu) const;
#endif // wxUSE_MENUS
-#if wxUSE_STATUSBAR
- virtual wxSize GetStatusBarBorders(wxCoord *borderBetweenFields) const;
-#endif // wxUSE_STATUSBAR
-
// helpers for "wxBitmap wxColourScheme::Get()"
void DrawCheckBitmap(wxDC& dc, const wxRect& rect);
void DrawUncheckBitmap(wxDC& dc, const wxRect& rect, bool isPressed);
void DrawUndeterminedBitmap(wxDC& dc, const wxRect& rect, bool isPressed);
protected:
- // DrawBackground() helpers
+ // overridden wxStdRenderer methods
+ virtual void DrawSunkenBorder(wxDC& dc, wxRect *rect);
+
+ virtual void DrawFrameWithLabel(wxDC& dc,
+ const wxString& label,
+ const wxRect& rectFrame,
+ const wxRect& rectText,
+ int flags,
+ int alignment,
+ int indexAccel);
+
+ virtual void DrawCheckItemBitmap(wxDC& dc,
+ const wxBitmap& bitmap,
+ const wxRect& rect,
+ int flags);
// get the colour to use for background
wxColour GetBackgroundColour(int flags) const
return wxSCHEME_COLOUR(m_scheme, CONTROL);
}
- // draw the background with any colour, not only the default one(s)
- void DoDrawBackground(wxDC& dc,
- const wxColour& col,
- const wxRect& rect,
- wxWindow *window = NULL);
-
- // DrawBorder() helpers: all of them shift and clip the DC after drawing
- // the border
-
- // just draw a rectangle with the given pen
- void DrawRect(wxDC& dc, wxRect *rect, const wxPen& pen);
-
- // draw the lower left part of rectangle
- void DrawHalfRect(wxDC& dc, wxRect *rect, const wxPen& pen);
-
- // draw the rectange using the first brush for the left and top sides and
- // the second one for the bottom and right ones
- void DrawShadedRect(wxDC& dc, wxRect *rect,
- const wxPen& pen1, const wxPen& pen2);
-
// as DrawShadedRect() but the pixels in the bottom left and upper right
// border are drawn with the pen1, not pen2
void DrawAntiShadedRect(wxDC& dc, wxRect *rect,
wxRect *rect,
wxOrientation orient);
- // draw the normal 3D border
- void DrawRaisedBorder(wxDC& dc, wxRect *rect);
-
// just as DrawRaisedBorder() except that the bottom left and up right
// pixels of the interior rect are drawn in another colour (i.e. the inner
// rect is drawn with DrawAntiShadedRect() and not DrawShadedRect())
void DrawAntiRaisedBorder(wxDC& dc, wxRect *rect);
-#if wxUSE_SCROLLBAR
- // returns the size of the arrow for the scrollbar (depends on
- // orientation)
- wxSize GetScrollbarArrowSize(const wxScrollBar *scrollbar) const
- {
- wxSize size;
- if ( scrollbar->IsVertical() )
- {
- size = m_sizeScrollbarArrow;
- }
- else
- {
- size.x = m_sizeScrollbarArrow.y;
- size.y = m_sizeScrollbarArrow.x;
- }
-
- return size;
- }
-#endif // wxUSE_SCROLLBAR
+ // draw inner GTK shadow
+ void DrawInnerShadedRect(wxDC& dc, wxRect *rect);
// get the line wrap indicator bitmap
wxBitmap GetLineWrapBitmap() const;
- // DrawCheckBitmap and DrawRadioBitmap helpers
-
- // draw the check bitmaps once and cache them for later use
- wxBitmap GetCheckBitmap(int flags);
+ virtual wxBitmap GetCheckBitmap(int flags);
+ virtual wxBitmap GetRadioBitmap(int flags);
// draw a /\ or \/ line from (x1, y1) to (x2, y1) passing by the point
// ((x1 + x2)/2, y2)
// draw the radio button bitmap for the given state
void DrawRadioBitmap(wxDC& dc, const wxRect& rect, int flags);
- // draw check/radio - the bitmap must be a valid one by now
- void DoDrawCheckOrRadioBitmap(wxDC& dc,
- const wxString& label,
- const wxBitmap& bitmap,
- const wxRect& rectTotal,
- int flags,
- wxAlignment align,
- int indexAccel);
-
// common part of DrawMenuItem() and DrawMenuBarItem()
void DoDrawMenuItem(wxDC& dc,
const wxRect& rect,
// initialize the combo bitmaps
void InitComboBitmaps();
-private:
- const wxColourScheme *m_scheme;
+ virtual wxBitmap GetFrameButtonBitmap(FrameButtonType WXUNUSED(type))
+ {
+ return wxNullBitmap;
+ }
+private:
// data
wxSize m_sizeScrollbarArrow;
// GDI objects
- wxPen m_penBlack,
- m_penDarkGrey,
- m_penGrey,
- m_penLightGrey,
- m_penHighlight;
+ wxPen m_penGrey;
- // the checkbox bitmaps: first row is for the normal, second for the
- // pressed state and the columns are for checked, unchecked and
- // undeterminated respectively
- wxBitmap m_bitmapsCheckbox[2][3];
+ // the checkbox and radio button bitmaps: first row is for the normal,
+ // second for the pressed state and the columns are for checked, unchecked
+ // and undeterminated respectively
+ wxBitmap m_bitmapsCheckbox[IndicatorState_MaxCtrl][IndicatorStatus_Max],
+ m_bitmapsRadiobtn[IndicatorState_MaxCtrl][IndicatorStatus_Max];
// the line wrap bitmap (drawn at the end of wrapped lines)
wxBitmap m_bmpLineWrap;
class wxGTKInputHandler : public wxInputHandler
{
public:
- wxGTKInputHandler(wxGTKRenderer *renderer);
+ wxGTKInputHandler() { }
virtual bool HandleKey(wxInputConsumer *control,
const wxKeyEvent& event,
bool pressed);
virtual bool HandleMouse(wxInputConsumer *control,
const wxMouseEvent& event);
- virtual bool HandleMouseMove(wxInputConsumer *control, const wxMouseEvent& event);
-
-protected:
- wxGTKRenderer *m_renderer;
+ virtual bool HandleMouseMove(wxInputConsumer *control,
+ const wxMouseEvent& event);
};
#if wxUSE_SCROLLBAR
wxStdScrollBarInputHandler::Press(scrollbar, doIt);
}
- virtual bool IsAllowedButton(int WXUNUSED(button)) { return true; }
+ // any button can be used to drag the scrollbar under GTK+
+ virtual bool IsAllowedButton(int WXUNUSED(button)) const { return true; }
bool IsArrow() const
{
#if wxUSE_CHECKBOX
-class wxGTKCheckboxInputHandler : public wxStdCheckboxInputHandler
+class wxGTKCheckboxInputHandler : public wxStdInputHandler
{
public:
wxGTKCheckboxInputHandler(wxInputHandler *handler)
- : wxStdCheckboxInputHandler(handler) { }
+ : wxStdInputHandler(handler) { }
virtual bool HandleKey(wxInputConsumer *control,
const wxKeyEvent& event,
#if wxUSE_TEXTCTRL
-class wxGTKTextCtrlInputHandler : public wxStdTextCtrlInputHandler
+class wxGTKTextCtrlInputHandler : public wxStdInputHandler
{
public:
wxGTKTextCtrlInputHandler(wxInputHandler *handler)
- : wxStdTextCtrlInputHandler(handler) { }
+ : wxStdInputHandler(handler) { }
virtual bool HandleKey(wxInputConsumer *control,
const wxKeyEvent& event,
virtual wxRenderer *GetRenderer();
virtual wxArtProvider *GetArtProvider();
- virtual wxInputHandler *GetInputHandler(const wxString& control);
+ virtual wxInputHandler *GetInputHandler(const wxString& control,
+ wxInputConsumer *consumer);
virtual wxColourScheme *GetColourScheme();
private:
- // get the default input handler
- wxInputHandler *GetDefaultInputHandler();
-
wxGTKRenderer *m_renderer;
wxGTKArtProvider *m_artProvider;
wxSortedArrayString m_handlerNames;
wxArrayHandlers m_handlers;
- wxGTKInputHandler *m_handlerDefault;
-
wxGTKColourScheme *m_scheme;
WX_DECLARE_THEME(gtk)
{
m_scheme = NULL;
m_renderer = NULL;
- m_handlerDefault = NULL;
m_artProvider = NULL;
}
wxGTKTheme::~wxGTKTheme()
{
- size_t count = m_handlers.GetCount();
- for ( size_t n = 0; n < count; n++ )
- {
- if ( m_handlers[n] != m_handlerDefault )
- delete m_handlers[n];
- }
-
- delete m_handlerDefault;
delete m_renderer;
delete m_scheme;
- wxArtProvider::RemoveProvider(m_artProvider);
+ delete m_artProvider;
}
wxRenderer *wxGTKTheme::GetRenderer()
return m_scheme;
}
-wxInputHandler *wxGTKTheme::GetDefaultInputHandler()
-{
- if ( !m_handlerDefault )
- {
- m_handlerDefault = new wxGTKInputHandler(m_renderer);
- }
-
- return m_handlerDefault;
-}
-
-wxInputHandler *wxGTKTheme::GetInputHandler(const wxString& control)
+wxInputHandler *wxGTKTheme::GetInputHandler(const wxString& control,
+ wxInputConsumer *consumer)
{
wxInputHandler *handler = NULL;
int n = m_handlerNames.Index(control);
if ( n == wxNOT_FOUND )
{
+ static wxGTKInputHandler s_handlerDef;
+
+ wxInputHandler * const
+ handlerStd = consumer->DoGetStdInputHandler(&s_handlerDef);
+
// create a new handler
- if ( control == wxINP_HANDLER_SCROLLBAR )
+#if wxUSE_CHECKBOX
+ if ( control == wxINP_HANDLER_CHECKBOX )
{
-#if wxUSE_SCROLLBAR
- handler = new wxGTKScrollBarInputHandler(m_renderer,
- GetDefaultInputHandler());
-#endif // wxUSE_SCROLLBAR
+ static wxGTKCheckboxInputHandler s_handler(handlerStd);
+
+ handler = &s_handler;
}
-#if wxUSE_BUTTON
- else if ( control == wxINP_HANDLER_BUTTON )
- handler = new wxStdButtonInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_CHECKBOX
-#if wxUSE_CHECKBOX
- else if ( control == wxINP_HANDLER_CHECKBOX )
- handler = new wxGTKCheckboxInputHandler(GetDefaultInputHandler());
+ else
#endif // wxUSE_CHECKBOX
-#if wxUSE_COMBOBOX
- else if ( control == wxINP_HANDLER_COMBOBOX )
- handler = new wxStdComboBoxInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_COMBOBOX
-#if wxUSE_LISTBOX
- else if ( control == wxINP_HANDLER_LISTBOX )
- handler = new wxStdListboxInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_LISTBOX
-#if wxUSE_CHECKLISTBOX
- else if ( control == wxINP_HANDLER_CHECKLISTBOX )
- handler = new wxStdCheckListboxInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_CHECKLISTBOX
+#if wxUSE_SCROLLBAR
+ if ( control == wxINP_HANDLER_SCROLLBAR )
+ {
+ static wxGTKScrollBarInputHandler s_handler(m_renderer, handlerStd);
+
+ handler = &s_handler;
+ }
+ else
+#endif // wxUSE_SCROLLBAR
#if wxUSE_TEXTCTRL
- else if ( control == wxINP_HANDLER_TEXTCTRL )
- handler = new wxGTKTextCtrlInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_TEXTCTRL
-#if wxUSE_SLIDER
- else if ( control == wxINP_HANDLER_SLIDER )
- handler = new wxStdSliderButtonInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_SLIDER
-#if wxUSE_SPINBTN
- else if ( control == wxINP_HANDLER_SPINBTN )
- handler = new wxStdSpinButtonInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_SPINBTN
-#if wxUSE_NOTEBOOK
- else if ( control == wxINP_HANDLER_NOTEBOOK )
- handler = new wxStdNotebookInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_NOTEBOOK
-#if wxUSE_TOOLBAR
- else if ( control == wxINP_HANDLER_TOOLBAR )
- handler = new wxStdToolbarInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_TOOLBAR
- else if ( control == wxINP_HANDLER_TOPLEVEL )
- handler = new wxStdFrameInputHandler(GetDefaultInputHandler());
+ if ( control == wxINP_HANDLER_TEXTCTRL )
+ {
+ static wxGTKTextCtrlInputHandler s_handler(handlerStd);
- if(!handler)
- handler = GetDefaultInputHandler();
+ handler = &s_handler;
+ }
+ else
+#endif // wxUSE_TEXTCTRL
+ {
+ // no special handler for this control
+ handler = handlerStd;
+ }
n = m_handlerNames.Add(control);
m_handlers.Insert(handler, n);
{
switch ( col )
{
+ case FRAME:
case WINDOW: return *wxWHITE;
case SHADOW_DARK: return *wxBLACK;
// ----------------------------------------------------------------------------
wxGTKRenderer::wxGTKRenderer(const wxColourScheme *scheme)
+ : wxStdRenderer(scheme)
{
- // init data
- m_scheme = scheme;
m_sizeScrollbarArrow = wxSize(15, 14);
- // init pens
- m_penBlack = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_DARK), 0, wxSOLID);
- m_penDarkGrey = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_OUT), 0, wxSOLID);
- m_penGrey = wxPen(wxSCHEME_COLOUR(scheme, SCROLLBAR), 0, wxSOLID);
- m_penLightGrey = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_IN), 0, wxSOLID);
- m_penHighlight = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_HIGHLIGHT), 0, wxSOLID);
+ m_penGrey = wxPen(wxSCHEME_COLOUR(scheme, SCROLLBAR));
}
// ----------------------------------------------------------------------------
// border stuff
// ----------------------------------------------------------------------------
-void wxGTKRenderer::DrawRect(wxDC& dc, wxRect *rect, const wxPen& pen)
-{
- // draw
- dc.SetPen(pen);
- dc.SetBrush(*wxTRANSPARENT_BRUSH);
- dc.DrawRectangle(*rect);
-
- // adjust the rect
- rect->Inflate(-1);
-}
-
-void wxGTKRenderer::DrawHalfRect(wxDC& dc, wxRect *rect, const wxPen& pen)
-{
- // draw the bottom and right sides
- dc.SetPen(pen);
- dc.DrawLine(rect->GetLeft(), rect->GetBottom(),
- rect->GetRight() + 1, rect->GetBottom());
- dc.DrawLine(rect->GetRight(), rect->GetTop(),
- rect->GetRight(), rect->GetBottom());
-
- // adjust the rect
- rect->width--;
- rect->height--;
-}
-
-void wxGTKRenderer::DrawShadedRect(wxDC& dc, wxRect *rect,
- const wxPen& pen1, const wxPen& pen2)
-{
- // draw the rectangle
- dc.SetPen(pen1);
- dc.DrawLine(rect->GetLeft(), rect->GetTop(),
- rect->GetLeft(), rect->GetBottom());
- dc.DrawLine(rect->GetLeft() + 1, rect->GetTop(),
- rect->GetRight(), rect->GetTop());
- dc.SetPen(pen2);
- dc.DrawLine(rect->GetRight(), rect->GetTop(),
- rect->GetRight(), rect->GetBottom());
- dc.DrawLine(rect->GetLeft(), rect->GetBottom(),
- rect->GetRight() + 1, rect->GetBottom());
-
- // adjust the rect
- rect->Inflate(-1);
-}
-
void wxGTKRenderer::DrawAntiShadedRectSide(wxDC& dc,
const wxRect& rect,
const wxPen& pen1,
rect->Inflate(-1);
}
-void wxGTKRenderer::DrawRaisedBorder(wxDC& dc, wxRect *rect)
+void wxGTKRenderer::DrawInnerShadedRect(wxDC& dc, wxRect *rect)
{
- DrawShadedRect(dc, rect, m_penHighlight, m_penBlack);
- DrawShadedRect(dc, rect, m_penLightGrey, m_penDarkGrey);
+ DrawAntiShadedRect(dc, rect, m_penDarkGrey, m_penHighlight);
+ DrawAntiShadedRect(dc, rect, m_penBlack, m_penHighlight);
}
void wxGTKRenderer::DrawAntiRaisedBorder(wxDC& dc, wxRect *rect)
DrawAntiShadedRect(dc, rect, m_penLightGrey, m_penDarkGrey);
}
-void wxGTKRenderer::DrawBorder(wxDC& dc,
- wxBorder border,
- const wxRect& rectTotal,
- int WXUNUSED(flags),
- wxRect *rectIn)
-{
- size_t width;
-
- wxRect rect = rectTotal;
-
- switch ( border )
- {
- case wxBORDER_SUNKEN:
- for ( width = 0; width < BORDER_THICKNESS; width++ )
- {
- DrawAntiShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
- DrawShadedRect(dc, &rect, m_penBlack, m_penLightGrey);
- }
- break;
-
- case wxBORDER_STATIC:
- for ( width = 0; width < BORDER_THICKNESS; width++ )
- {
- DrawShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
- }
- break;
-
- case wxBORDER_RAISED:
- for ( width = 0; width < BORDER_THICKNESS; width++ )
- {
- DrawRaisedBorder(dc, &rect);
- }
- break;
-
- case wxBORDER_DOUBLE:
- for ( width = 0; width < BORDER_THICKNESS; width++ )
- {
- DrawShadedRect(dc, &rect, m_penLightGrey, m_penBlack);
- DrawShadedRect(dc, &rect, m_penHighlight, m_penDarkGrey);
- DrawRect(dc, &rect, m_penLightGrey);
- }
- break;
-
- case wxBORDER_SIMPLE:
- for ( width = 0; width < BORDER_THICKNESS; width++ )
- {
- DrawRect(dc, &rect, m_penBlack);
- }
- break;
-
- default:
- wxFAIL_MSG(_T("unknown border type"));
- // fall through
-
- case wxBORDER_DEFAULT:
- case wxBORDER_NONE:
- break;
- }
-
- if ( rectIn )
- *rectIn = rect;
-}
-
-wxRect wxGTKRenderer::GetBorderDimensions(wxBorder border) const
+void wxGTKRenderer::DrawSunkenBorder(wxDC& dc, wxRect *rect)
{
- wxCoord width;
- switch ( border )
- {
- case wxBORDER_RAISED:
- case wxBORDER_SUNKEN:
- width = 2*BORDER_THICKNESS;
- break;
-
- case wxBORDER_SIMPLE:
- case wxBORDER_STATIC:
- width = BORDER_THICKNESS;
- break;
-
- case wxBORDER_DOUBLE:
- width = 3*BORDER_THICKNESS;
- break;
-
- default:
- wxFAIL_MSG(_T("unknown border type"));
- // fall through
-
- case wxBORDER_DEFAULT:
- case wxBORDER_NONE:
- width = 0;
- break;
- }
-
- wxRect rect;
- rect.x =
- rect.y =
- rect.width =
- rect.height = width;
-
- return rect;
+ DrawAntiShadedRect(dc, rect, m_penDarkGrey, m_penHighlight);
+ DrawShadedRect(dc, rect, m_penBlack, m_penLightGrey);
}
-bool wxGTKRenderer::AreScrollbarsInsideBorder() const
+void
+wxGTKRenderer::DrawFocusRect(wxWindow* WXUNUSED(win), wxDC& dc, const wxRect& rect, int WXUNUSED(flags))
{
- // no, the scrollbars are outside the border in GTK+
- return false;
+ dc.SetBrush(*wxTRANSPARENT_BRUSH);
+ wxRect rectFocus = rect;
+ DrawRect(dc, &rectFocus, m_penBlack);
}
-// ----------------------------------------------------------------------------
-// special borders
-// ----------------------------------------------------------------------------
-
void wxGTKRenderer::DrawTextBorder(wxDC& dc,
wxBorder border,
const wxRect& rectOrig,
}
else // !focused
{
- DrawAntiShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
- DrawAntiShadedRect(dc, &rect, m_penBlack, m_penHighlight);
+ DrawInnerShadedRect(dc, &rect);
}
}
*rectIn = rect;
}
+void wxGTKRenderer::DrawButtonLabel(wxDC& dc,
+ const wxString& label,
+ const wxBitmap& image,
+ const wxRect& rect,
+ int flags,
+ int alignment,
+ int indexAccel,
+ wxRect *rectBounds)
+{
+ // no focus rect around buttons label in GTK+
+ wxStdRenderer::DrawButtonLabel(dc, label, image, rect, flags,
+ alignment, indexAccel, rectBounds);
+}
+
void wxGTKRenderer::DrawButtonBorder(wxDC& dc,
const wxRect& rectTotal,
int flags,
// button pressed: draw a black border around it and an inward shade
DrawRect(dc, &rect, m_penBlack);
- for ( size_t width = 0; width < BORDER_THICKNESS; width++ )
- {
- DrawAntiShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
- DrawAntiShadedRect(dc, &rect, m_penBlack, m_penDarkGrey);
- }
+ DrawInnerShadedRect(dc, &rect);
}
- else
+ else // button not pressed
{
- // button not pressed
-
if ( flags & wxCONTROL_ISDEFAULT )
{
// TODO
}
// now draw a normal button
- for ( size_t width = 0; width < BORDER_THICKNESS; width++ )
- {
- DrawShadedRect(dc, &rect, m_penHighlight, m_penBlack);
- DrawAntiShadedRect(dc, &rect,
- wxPen(GetBackgroundColour(flags), 0, wxSOLID),
- m_penDarkGrey);
- }
+ DrawShadedRect(dc, &rect, m_penHighlight, m_penBlack);
+ DrawAntiShadedRect(dc, &rect, GetBackgroundColour(flags), m_penDarkGrey);
}
if ( rectIn )
- {
*rectIn = rect;
- }
}
// ----------------------------------------------------------------------------
// lines and frames
// ----------------------------------------------------------------------------
-void wxGTKRenderer::DrawHorizontalLine(wxDC& dc,
- wxCoord y, wxCoord x1, wxCoord x2)
-{
- dc.SetPen(m_penDarkGrey);
- dc.DrawLine(x1, y, x2 + 1, y);
- dc.SetPen(m_penHighlight);
- y++;
- dc.DrawLine(x1, y, x2 + 1, y);
-}
-
-void wxGTKRenderer::DrawVerticalLine(wxDC& dc,
- wxCoord x, wxCoord y1, wxCoord y2)
-{
- dc.SetPen(m_penDarkGrey);
- dc.DrawLine(x, y1, x, y2 + 1);
- dc.SetPen(m_penHighlight);
- x++;
- dc.DrawLine(x, y1, x, y2 + 1);
-}
-
-void wxGTKRenderer::DrawFrame(wxDC& dc,
- const wxString& label,
- const wxRect& rect,
- int flags,
- int alignment,
- int indexAccel)
+void wxGTKRenderer::DrawFrameWithLabel(wxDC& dc,
+ const wxString& label,
+ const wxRect& rectFrame,
+ const wxRect& rectTextOrig,
+ int flags,
+ int alignment,
+ int indexAccel)
{
- wxCoord height = 0; // of the label
- wxRect rectFrame = rect;
- if ( !label.empty() )
- {
- // the text should touch the top border of the rect, so the frame
- // itself should be lower
- dc.GetTextExtent(label, NULL, &height);
- rectFrame.y += height / 2;
- rectFrame.height -= height / 2;
-
- // TODO: the +4 should be customizable
+ wxRect rectText(rectTextOrig);
+ rectText.Inflate(1, 0);
- wxRect rectText;
- rectText.x = rectFrame.x + 4;
- rectText.y = rect.y;
- rectText.width = rectFrame.width - 8;
- rectText.height = height;
-
- wxRect rectLabel;
- DrawLabel(dc, label, rectText, flags, alignment, indexAccel, &rectLabel);
- rectLabel.x -= 1;
- rectLabel.width += 2;
+ wxRect rectLabel;
+ DrawLabel(dc, label, rectText, flags, alignment, indexAccel, &rectLabel);
+ rectLabel.x -= 1;
+ rectLabel.width += 2;
- StandardDrawFrame(dc, rectFrame, rectLabel);
+ DrawFrameWithoutLabel(dc, rectFrame, rectLabel);
- // GTK+ does it like this
- dc.SetPen(m_penHighlight);
- dc.DrawPoint(rectText.x, rectFrame.y);
- dc.DrawPoint(rectText.x + rectLabel.width - 3, rectFrame.y);
- }
- else
- {
- // just draw the complete frame
- DrawShadedRect(dc, &rectFrame, m_penDarkGrey, m_penHighlight);
- DrawShadedRect(dc, &rectFrame, m_penHighlight, m_penDarkGrey);
- }
+ // GTK+ does it like this
+ dc.SetPen(m_penHighlight);
+ dc.DrawPoint(rectText.x, rectFrame.y);
+ dc.DrawPoint(rectText.x + rectLabel.width - 3, rectFrame.y);
}
// ----------------------------------------------------------------------------
-// label
+// check/radio buttons
// ----------------------------------------------------------------------------
-void wxGTKRenderer::DrawLabel(wxDC& dc,
- const wxString& label,
- const wxRect& rect,
- int flags,
- int alignment,
- int indexAccel,
- wxRect *rectBounds)
-{
- DrawButtonLabel(dc, label, wxNullBitmap, rect, flags,
- alignment, indexAccel, rectBounds);
-}
-
-void wxGTKRenderer::DrawButtonLabel(wxDC& dc,
- const wxString& label,
- const wxBitmap& image,
- const wxRect& rect,
- int flags,
- int alignment,
- int indexAccel,
- wxRect *rectBounds)
-{
- if ( flags & wxCONTROL_DISABLED )
- {
- // make the text grey and draw a shade for it
- dc.SetTextForeground(*wxWHITE); // FIXME hardcoded colour
- wxRect rectShadow = rect;
- rectShadow.x++;
- rectShadow.y++;
- dc.DrawLabel(label, rectShadow, alignment, indexAccel);
- dc.SetTextForeground(wxSCHEME_COLOUR(m_scheme, CONTROL_TEXT_DISABLED));
- }
- else
- {
- dc.SetTextForeground(wxSCHEME_COLOUR(m_scheme, CONTROL_TEXT));
- }
-
- dc.DrawLabel(label, image, rect, alignment, indexAccel, rectBounds);
-}
-
-void wxGTKRenderer::DrawItem(wxDC& dc,
- const wxString& label,
- const wxRect& rect,
- int flags)
-{
- wxLogTrace(_T("listbox"), _T("drawing item '%s' at (%d, %d)-(%d, %d)"),
- label.c_str(),
- rect.x, rect.y,
- rect.x + rect.width, rect.y + rect.height);
-
- wxColour colFg;
- if ( flags & wxCONTROL_SELECTED )
- {
- dc.SetBrush(wxBrush(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT), wxSOLID));
- dc.SetPen(*wxTRANSPARENT_PEN);
- dc.DrawRectangle(rect);
-
- colFg = dc.GetTextForeground();
- dc.SetTextForeground(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
- }
-
- if ( flags & wxCONTROL_FOCUSED )
- {
- dc.SetBrush(*wxTRANSPARENT_BRUSH);
- wxRect rectFocus = rect;
- DrawRect(dc, &rectFocus, m_penBlack);
- }
-
- wxRect rectText = rect;
- rectText.x += 2;
- rectText.y++;
- dc.DrawLabel(label, wxNullBitmap, rectText);
-
- if ( flags & wxCONTROL_SELECTED )
- {
- dc.SetBackgroundMode(wxTRANSPARENT);
- }
-
- // restore the text colour
- if ( colFg.Ok() )
- {
- dc.SetTextForeground(colFg);
- }
-}
-
-void wxGTKRenderer::DrawCheckItem(wxDC& dc,
- const wxString& label,
- const wxBitmap& bitmap,
- const wxRect& rect,
- int flags)
+void wxGTKRenderer::DrawCheckItemBitmap(wxDC& dc,
+ const wxBitmap& bitmap,
+ const wxRect& rect,
+ int flags)
{
- wxRect rectBitmap = rect;
- rectBitmap.x -= 1;
- rectBitmap.width = GetCheckBitmapSize().x;
-
// never draw the focus rect around the check indicators here
- DrawCheckButton(dc, wxEmptyString, bitmap, rectBitmap, flags & ~wxCONTROL_FOCUSED);
-
- wxRect rectLabel = rect;
- wxCoord shift = rectBitmap.width + 2*GetCheckItemMargin();
- rectLabel.x += shift;
- rectLabel.width -= shift;
- DrawItem(dc, label, rectLabel, flags);
+ DrawCheckButton(dc, wxEmptyString, bitmap, rect, flags & ~wxCONTROL_FOCUSED);
}
-// ----------------------------------------------------------------------------
-// check/radion buttons
-// ----------------------------------------------------------------------------
-
void wxGTKRenderer::DrawUndeterminedBitmap(wxDC& dc,
const wxRect& rectTotal,
bool isPressed)
}
dc.SetPen(*wxTRANSPARENT_PEN);
- dc.SetBrush(wxBrush(col1, wxSOLID));
+ dc.SetBrush(col1);
dc.DrawRectangle(rect);
rect.Deflate(1);
- dc.SetBrush(wxBrush(col2, wxSOLID));
+ dc.SetBrush(col2);
dc.DrawRectangle(rect);
}
DrawAntiRaisedBorder(dc, &rect);
wxColour col = wxSCHEME_COLOUR(m_scheme, SHADOW_IN);
- dc.SetPen(wxPen(col, 0, wxSOLID));
+ dc.SetPen(wxPen(col));
dc.DrawPoint(rect.GetRight() - 1, rect.GetBottom() - 1);
if ( isPressed )
//else: it is SHADOW_IN, leave as is
dc.SetPen(*wxTRANSPARENT_PEN);
- dc.SetBrush(wxBrush(col, wxSOLID));
+ dc.SetBrush(col);
dc.DrawRectangle(rect);
}
DrawShadedRect(dc, &rect, m_penBlack, m_penLightGrey);
dc.SetPen(*wxTRANSPARENT_PEN);
- dc.SetBrush(wxBrush(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED), wxSOLID));
+ dc.SetBrush(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED));
dc.DrawRectangle(rect);
}
wxCoord yMid = (y + yBottom) / 2;
- // this looks ugly when the background colour of the control is not the
- // same ours - radiobox is not transparent as it should be
-#if 0
- // first fill the middle: as FloodFill() is not implemented on all
- // platforms, this is the only thing to do
- wxColour colBg = flags & wxCONTROL_CURRENT
- ? wxSCHEME_COLOUR(m_scheme, CONTROL_CURRENT)
- : wxSCHEME_COLOUR(m_scheme, SHADOW_IN);
- dc.SetBrush(wxBrush(colBg, wxSOLID));
- dc.SetPen(*wxTRANSPARENT_PEN);
- dc.DrawRectangle(rect);
-#endif // 0
-
// then draw the upper half
dc.SetPen(flags & wxCONTROL_CHECKED ? m_penDarkGrey : m_penHighlight);
DrawUpZag(dc, x, xRight, yMid, y);
if ( flags & wxCONTROL_CHECKED )
dc.SetPen(m_penBlack);
else if ( flags & wxCONTROL_PRESSED )
- dc.SetPen(wxPen(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED), 0, wxSOLID));
+ dc.SetPen(wxPen(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED)));
else // unchecked and unpressed
drawIt = false;
drawIt = true; // with the same pen
else if ( flags & wxCONTROL_PRESSED )
{
- dc.SetPen(wxPen(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED), 0, wxSOLID));
+ dc.SetPen(wxPen(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED)));
drawIt = true;
}
else // checked and unpressed
DrawUndeterminedBitmap(dc, rect, true);
}
- int row = flags & wxCONTROL_PRESSED
- ? 1
- : 0;
- int col = flags & wxCONTROL_CHECKED
- ? 0
- : ( flags & wxCONTROL_UNDETERMINED
- ? 2
- : 1 );
+ IndicatorState state;
+ IndicatorStatus status;
+ GetIndicatorsFromFlags(flags, state, status);
+
+ // disabled looks the same as normal
+ if ( state == IndicatorState_Disabled )
+ state = IndicatorState_Normal;
- return m_bitmapsCheckbox[row][col];
+ return m_bitmapsCheckbox[state][status];
+}
+
+wxBitmap wxGTKRenderer::GetRadioBitmap(int flags)
+{
+ IndicatorState state;
+ IndicatorStatus status;
+ GetIndicatorsFromFlags(flags, state, status);
+
+ wxBitmap& bmp = m_bitmapsRadiobtn[state][status];
+ if ( !bmp.Ok() )
+ {
+ const wxSize size = GetRadioBitmapSize();
+
+ wxMemoryDC dc;
+ bmp.Create(size.x, size.y);
+ dc.SelectObject(bmp);
+
+ DrawRadioBitmap(dc, size, flags);
+ }
+
+ return bmp;
}
wxBitmap wxGTKRenderer::GetLineWrapBitmap() const
return m_bmpLineWrap;
}
-void wxGTKRenderer::DrawCheckButton(wxDC& dc,
- const wxString& label,
- const wxBitmap& bitmapOrig,
- const wxRect& rectTotal,
- int flags,
- wxAlignment align,
- int indexAccel)
-{
- wxBitmap bitmap;
- if ( bitmapOrig.Ok() )
- {
- bitmap = bitmapOrig;
- }
- else
- {
- bitmap = GetCheckBitmap(flags);
- }
-
- DoDrawCheckOrRadioBitmap(dc, label, bitmap, rectTotal,
- flags, align, indexAccel);
-}
-
-void wxGTKRenderer::DoDrawCheckOrRadioBitmap(wxDC& dc,
- const wxString& label,
- const wxBitmap& bitmap,
- const wxRect& rectTotal,
- int flags,
- wxAlignment align,
- int indexAccel)
-{
- wxRect rect = rectTotal;
-
- if ( flags & wxCONTROL_FOCUSED )
- {
- // draw the focus border around everything
- DrawRect(dc, &rect, m_penBlack);
- }
- else
- {
- // the border does not offset the string under GTK
- rect.Inflate(-1);
- }
-
- // calculate the position of the bitmap and of the label
- wxCoord xBmp,
- yBmp = rect.y + (rect.height - bitmap.GetHeight()) / 2;
-
- wxRect rectLabel;
- dc.GetMultiLineTextExtent(label, NULL, &rectLabel.height);
- rectLabel.y = rect.y + (rect.height - rectLabel.height) / 2;
-
- if ( align == wxALIGN_RIGHT )
- {
- xBmp = rect.GetRight() - bitmap.GetWidth();
- rectLabel.x = rect.x + 2;
- rectLabel.SetRight(xBmp);
- }
- else // normal (checkbox to the left of the text) case
- {
- xBmp = rect.x + 2;
- rectLabel.x = xBmp + bitmap.GetWidth() + 4;
- rectLabel.SetRight(rect.GetRight());
- }
-
- dc.DrawBitmap(bitmap, xBmp, yBmp, true /* use mask */);
-
- DrawLabel(dc, label, rectLabel, flags,
- wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL, indexAccel);
-}
-
-void wxGTKRenderer::DrawRadioButton(wxDC& dc,
- const wxString& label,
- const wxBitmap& bitmapOrig,
- const wxRect& rectTotal,
- int flags,
- wxAlignment align,
- int indexAccel)
-{
- wxBitmap bitmap;
- if ( bitmapOrig.Ok() )
- {
- bitmap = bitmapOrig;
- }
- else
- {
- wxRect rect;
- wxSize size = GetRadioBitmapSize();
- rect.width = size.x;
- rect.height = size.y;
- bitmap.Create(rect.width, rect.height);
- wxMemoryDC dc;
- dc.SelectObject(bitmap);
- dc.SetBackground(*wxLIGHT_GREY_BRUSH);
- dc.Clear();
- DrawRadioBitmap(dc, rect, flags);
-
- // must unselect the bitmap before setting a mask for it because of the
- // MSW limitations
- dc.SelectObject(wxNullBitmap);
- bitmap.SetMask(new wxMask(bitmap, *wxLIGHT_GREY));
- }
-
- DoDrawCheckOrRadioBitmap(dc, label, bitmap, rectTotal,
- flags, align, indexAccel);
-}
-
#if wxUSE_TOOLBAR
void wxGTKRenderer::DrawToolBarButton(wxDC& dc,
const wxString& label,
#if wxUSE_TEXTCTRL
-wxRect wxGTKRenderer::GetTextTotalArea(const wxTextCtrl * WXUNUSED(text),
- const wxRect& rect) const
-{
- wxRect rectTotal = rect;
- rectTotal.Inflate(2*BORDER_THICKNESS);
- return rectTotal;
-}
-
wxRect wxGTKRenderer::GetTextClientArea(const wxTextCtrl *text,
const wxRect& rect,
wxCoord *extraSpaceBeyond) const
{
- wxRect rectText = rect;
- rectText.Deflate(2*BORDER_THICKNESS);
+ wxRect
+ rectText = wxStdRenderer::GetTextClientArea(text, rect, extraSpaceBeyond);
if ( text->WrapLines() )
{
return rectText;
}
-#endif // wxUSE_TEXTCTRL
-
-void wxGTKRenderer::DrawTextLine(wxDC& dc,
- const wxString& text,
- const wxRect& rect,
- int selStart,
- int selEnd,
- int flags)
-{
- // TODO: GTK+ draws selection even for unfocused controls, just with
- // different colours
- StandardDrawTextLine(dc, text, rect, selStart, selEnd, flags);
-}
-
void wxGTKRenderer::DrawLineWrapMark(wxDC& dc, const wxRect& rect)
{
wxBitmap bmpLineWrap = GetLineWrapBitmap();
}
}
+#endif // wxUSE_TEXTCTRL
+
// ----------------------------------------------------------------------------
// notebook
// ----------------------------------------------------------------------------
+#if wxUSE_NOTEBOOK
+
void wxGTKRenderer::DrawTab(wxDC& dc,
const wxRect& rectOrig,
wxDirection dir,
wxColour col = flags & wxCONTROL_SELECTED
? wxSCHEME_COLOUR(m_scheme, SHADOW_IN)
: wxSCHEME_COLOUR(m_scheme, SCROLLBAR);
- DoDrawBackground(dc, col, rect);
+ DrawSolidRect(dc, col, rect);
if ( flags & wxCONTROL_FOCUSED )
{
}
}
-#if wxUSE_SLIDER
+#endif // wxUSE_NOTEBOOK
// ----------------------------------------------------------------------------
// slider
// ----------------------------------------------------------------------------
+#if wxUSE_SLIDER
+
wxSize wxGTKRenderer::GetSliderThumbSize(const wxRect& rect,
int lenThumb,
wxOrientation orient) const
if ( flags & wxCONTROL_FOCUSED )
{
DrawRect(dc, &rect, m_penBlack);
- DrawAntiShadedRect(dc, &rect, m_penBlack, m_penLightGrey);
}
else // not focused, normal
{
DrawAntiShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
- DrawAntiShadedRect(dc, &rect, m_penBlack, m_penLightGrey);
}
+ DrawAntiShadedRect(dc, &rect, m_penBlack, m_penLightGrey);
+
// and the background
- DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, SCROLLBAR), rect);
+ DrawSolidRect(dc, wxSCHEME_COLOUR(m_scheme, SCROLLBAR), rect);
if ( rectShaft )
*rectShaft = rect;
// ----------------------------------------------------------------------------
// wxGTKMenuGeometryInfo: the wxMenuGeometryInfo used by wxGTKRenderer
-class WXDLLEXPORT wxGTKMenuGeometryInfo : public wxMenuGeometryInfo
+class wxGTKMenuGeometryInfo : public wxMenuGeometryInfo
{
public:
virtual wxSize GetSize() const { return m_size; }
h = heightText;
wxCoord widthLabel;
- dc.GetTextExtent(item->GetLabel(), &widthLabel, NULL);
+ dc.GetTextExtent(item->GetItemLabelText(), &widthLabel, NULL);
if ( widthLabel > widthLabelMax )
{
widthLabelMax = widthLabel;
#endif // wxUSE_MENUS
-#if wxUSE_STATUSBAR
-
-// ----------------------------------------------------------------------------
-// status bar
-// ----------------------------------------------------------------------------
-
-wxSize
-wxGTKRenderer::GetStatusBarBorders(wxCoord * WXUNUSED(borderBetweenFields)) const
-{
- return wxSize(0,0);
-}
-
-void wxGTKRenderer::DrawStatusField(wxDC& WXUNUSED(dc),
- const wxRect& WXUNUSED(rect),
- const wxString& WXUNUSED(label),
- int WXUNUSED(flags), int WXUNUSED(style))
-{
-}
-
-#endif // wxUSE_STATUSBAR
-
// ----------------------------------------------------------------------------
// combobox
// ----------------------------------------------------------------------------
int flags = comboButtonFlags[n];
dc.SelectObject(m_bitmapsCombo[n]);
- DoDrawBackground(dc, GetBackgroundColour(flags), rect);
+ DrawSolidRect(dc, GetBackgroundColour(flags), rect);
DrawArrow(dc, wxDOWN, rect, flags);
}
}
*bmpDisabled = m_bitmapsCombo[ComboState_Disabled];
}
-// ----------------------------------------------------------------------------
-// background
-// ----------------------------------------------------------------------------
-
-void wxGTKRenderer::DoDrawBackground(wxDC& dc,
- const wxColour& col,
- const wxRect& rect,
- wxWindow * WXUNUSED(window))
-{
- wxBrush brush(col, wxSOLID);
- dc.SetBrush(brush);
- dc.SetPen(*wxTRANSPARENT_PEN);
- dc.DrawRectangle(rect);
-}
-
-void wxGTKRenderer::DrawBackground(wxDC& dc,
- const wxColour& col,
- const wxRect& rect,
- int flags,
- wxWindow *window )
-{
- wxColour colBg = col.Ok() ? col : GetBackgroundColour(flags);
- DoDrawBackground(dc, colBg, rect, window );
-}
-
// ----------------------------------------------------------------------------
// scrollbar
// ----------------------------------------------------------------------------
rect2.Inflate(-1);
rectInner.Inflate(-2);
- DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, SCROLLBAR), *rect);
+ DrawSolidRect(dc, wxSCHEME_COLOUR(m_scheme, SCROLLBAR), *rect);
// find the side not to draw and also adjust the rectangles to compensate
// for it
// draw the arrow interior
dc.SetPen(*wxTRANSPARENT_PEN);
- dc.SetBrush(wxBrush(colInside, wxSOLID));
+ dc.SetBrush(colInside);
switch ( dir )
{
{
wxRect rectBar = rect;
DrawThumbBorder(dc, &rectBar, orient);
- DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, SCROLLBAR), rectBar);
-}
-
-void wxGTKRenderer::DrawScrollCorner(wxDC& dc, const wxRect& rect)
-{
- DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), rect);
-}
-
-#if wxUSE_SCROLLBAR
-wxRect wxGTKRenderer::GetScrollbarRect(const wxScrollBar *scrollbar,
- wxScrollBar::Element elem,
- int thumbPos) const
-{
- // as GTK scrollbars can't be disabled, it makes no sense to remove the
- // thumb for a scrollbar with range 0 - instead, make it fill the entire
- // scrollbar shaft
- if ( (elem == wxScrollBar::Element_Thumb) && !scrollbar->GetRange() )
- {
- elem = wxScrollBar::Element_Bar_2;
- }
-
- return StandardGetScrollbarRect(scrollbar, elem,
- thumbPos,
- GetScrollbarArrowSize(scrollbar));
+ DrawSolidRect(dc, wxSCHEME_COLOUR(m_scheme, SCROLLBAR), rectBar);
}
-wxCoord wxGTKRenderer::GetScrollbarSize(const wxScrollBar *scrollbar)
-{
- return StandardScrollBarSize(scrollbar, GetScrollbarArrowSize(scrollbar));
-}
-
-wxHitTest wxGTKRenderer::HitTestScrollbar(const wxScrollBar *scrollbar,
- const wxPoint& pt) const
-{
- return StandardHitTestScrollbar(scrollbar, pt,
- GetScrollbarArrowSize(scrollbar));
-}
-
-wxCoord wxGTKRenderer::ScrollbarToPixel(const wxScrollBar *scrollbar,
- int thumbPos)
-{
- return StandardScrollbarToPixel(scrollbar, thumbPos,
- GetScrollbarArrowSize(scrollbar));
-}
-
-int wxGTKRenderer::PixelToScrollbar(const wxScrollBar *scrollbar,
- wxCoord coord)
-{
- return StandardPixelToScrollbar(scrollbar, coord,
- GetScrollbarArrowSize(scrollbar));
-}
-#endif // wxUSE_SCROLLBAR
-
// ----------------------------------------------------------------------------
// size adjustments
// ----------------------------------------------------------------------------
#endif // wxUSE_SCROLLBAR
{
// take into account the border width
- wxRect rectBorder = GetBorderDimensions(window->GetBorder());
- size->x += rectBorder.x + rectBorder.width;
- size->y += rectBorder.y + rectBorder.height;
+ wxStdRenderer::AdjustSize(size, window);
}
}
-// ----------------------------------------------------------------------------
-// top level windows
-// ----------------------------------------------------------------------------
-
-void wxGTKRenderer::DrawFrameTitleBar(wxDC& WXUNUSED(dc),
- const wxRect& WXUNUSED(rect),
- const wxString& WXUNUSED(title),
- const wxIcon& WXUNUSED(icon),
- int WXUNUSED(flags),
- int WXUNUSED(specialButton),
- int WXUNUSED(specialButtonFlag))
-{
-}
-
-void wxGTKRenderer::DrawFrameBorder(wxDC& WXUNUSED(dc),
- const wxRect& WXUNUSED(rect),
- int WXUNUSED(flags))
-{
-}
-
-void wxGTKRenderer::DrawFrameBackground(wxDC& WXUNUSED(dc),
- const wxRect& WXUNUSED(rect),
- int WXUNUSED(flags))
-{
-}
-
-void wxGTKRenderer::DrawFrameTitle(wxDC& WXUNUSED(dc),
- const wxRect& WXUNUSED(rect),
- const wxString& WXUNUSED(title),
- int WXUNUSED(flags))
-{
-}
-
-void wxGTKRenderer::DrawFrameIcon(wxDC& WXUNUSED(dc),
- const wxRect& WXUNUSED(rect),
- const wxIcon& WXUNUSED(icon),
- int WXUNUSED(flags))
-{
-}
-
-void wxGTKRenderer::DrawFrameButton(wxDC& WXUNUSED(dc),
- wxCoord WXUNUSED(x),
- wxCoord WXUNUSED(y),
- int WXUNUSED(button),
- int WXUNUSED(flags))
-{
-}
-
-wxRect
-wxGTKRenderer::GetFrameClientArea(const wxRect& rect,
- int WXUNUSED(flags)) const
-{
- return rect;
-}
-
-wxSize
-wxGTKRenderer::GetFrameTotalSize(const wxSize& clientSize,
- int WXUNUSED(flags)) const
-{
- return clientSize;
-}
-
-wxSize wxGTKRenderer::GetFrameMinSize(int WXUNUSED(flags)) const
-{
- return wxSize(0,0);
-}
-
-wxSize wxGTKRenderer::GetFrameIconSize() const
-{
- return wxSize(wxDefaultCoord, wxDefaultCoord);
-}
-
-int
-wxGTKRenderer::HitTestFrame(const wxRect& WXUNUSED(rect),
- const wxPoint& WXUNUSED(pt),
- int WXUNUSED(flags)) const
-{
- return wxHT_TOPLEVEL_CLIENT_AREA;
-}
-
-
// ----------------------------------------------------------------------------
// standard icons
// ----------------------------------------------------------------------------
// wxGTKInputHandler
// ----------------------------------------------------------------------------
-wxGTKInputHandler::wxGTKInputHandler(wxGTKRenderer *renderer)
-{
- m_renderer = renderer;
-}
-
bool wxGTKInputHandler::HandleKey(wxInputConsumer * WXUNUSED(control),
const wxKeyEvent& WXUNUSED(event),
bool WXUNUSED(pressed))
}
}
- return wxStdTextCtrlInputHandler::HandleKey(control, event, pressed);
+ return wxStdInputHandler::HandleKey(control, event, pressed);
}
#endif // wxUSE_TEXTCTRL
+
+#endif // wxUSE_THEME_GTK
projects / wxWidgets.git / blobdiff