// Modified by:
// Created: 06.08.00
// RCS-ID: $Id$
-// Copyright: (c) 2000 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
-// Licence: wxWindows license
+// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
+// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// ===========================================================================
#include "wx/dcmemory.h"
#include "wx/window.h"
+ #include "wx/menu.h"
+
+ #include "wx/bmpbuttn.h"
#include "wx/button.h"
#include "wx/checkbox.h"
#include "wx/listbox.h"
#include "wx/checklst.h"
+ #include "wx/combobox.h"
#include "wx/scrolbar.h"
#include "wx/slider.h"
#include "wx/textctrl.h"
+ #include "wx/toolbar.h"
+ #include "wx/statusbr.h"
+
+ #include "wx/settings.h"
#endif // WX_PRECOMP
#include "wx/notebook.h"
#include "wx/spinbutt.h"
+#include "wx/toplevel.h"
+#include "wx/artprov.h"
+#include "wx/image.h"
#include "wx/univ/renderer.h"
#include "wx/univ/inphand.h"
#include "wx/univ/colschem.h"
#include "wx/univ/theme.h"
+class WXDLLEXPORT wxGTKMenuGeometryInfo;
+
// ----------------------------------------------------------------------------
// constants (to be removed, for testing only)
// ----------------------------------------------------------------------------
virtual void DrawBackground(wxDC& dc,
const wxColour& col,
const wxRect& rect,
- int flags = 0);
+ int flags = 0,
+ wxWindow *window = NULL );
virtual void DrawLabel(wxDC& dc,
const wxString& label,
const wxRect& rect,
wxAlignment align = wxALIGN_LEFT,
int indexAccel = -1);
+ virtual void DrawToolBarButton(wxDC& dc,
+ const wxString& label,
+ const wxBitmap& bitmap,
+ const wxRect& rect,
+ int flags = 0,
+ long style = 0);
+
virtual void DrawTextLine(wxDC& dc,
const wxString& text,
const wxRect& rect,
virtual void DrawSliderShaft(wxDC& dc,
const wxRect& rect,
+ int lenThumb,
wxOrientation orient,
int flags = 0,
+ long style = 0,
wxRect *rectShaft = NULL);
virtual void DrawSliderThumb(wxDC& dc,
const wxRect& rect,
wxOrientation orient,
- int flags = 0);
- virtual void DrawSliderTicks(wxDC& dc,
- const wxRect& rect,
- const wxSize& sizeThumb,
- wxOrientation orient,
- int start,
- int end,
- int step,
- int flags)
+ int flags = 0,
+ long style = 0);
+ virtual void DrawSliderTicks(wxDC& WXUNUSED(dc),
+ const wxRect& WXUNUSED(rect),
+ int WXUNUSED(lenThumb),
+ wxOrientation WXUNUSED(orient),
+ int WXUNUSED(start),
+ int WXUNUSED(end),
+ int WXUNUSED(step) = 1,
+ int WXUNUSED(flags) = 0,
+ long WXUNUSED(style) = 0)
{
// we don't have the ticks in GTK version
}
wxCoord y,
const wxMenuGeometryInfo& geomInfo);
+ virtual void DrawStatusField(wxDC& dc,
+ const wxRect& rect,
+ const wxString& label,
+ int flags = 0, int style = 0);
+
+ 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 wxCoord GetCheckItemMargin() const
{ return 2; }
+ virtual wxSize GetToolBarButtonSize(wxCoord *separator) const
+ { if ( separator ) *separator = 5; return wxSize(16, 15); }
+ virtual wxSize GetToolBarMargin() const
+ { return wxSize(6, 6); }
+
virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
- const wxRect& rect);
+ const wxRect& rect) const;
virtual wxRect GetTextClientArea(const wxTextCtrl *text,
const wxRect& rect,
- wxCoord *extraSpaceBeyond);
+ wxCoord *extraSpaceBeyond) const;
virtual wxSize GetTabIndent() const { return wxSize(2, 2); }
virtual wxSize GetTabPadding() const { return wxSize(6, 6); }
virtual wxCoord GetSliderDim() const { return 15; }
virtual wxCoord GetSliderTickLen() const { return 0; }
virtual wxRect GetSliderShaftRect(const wxRect& rect,
- wxOrientation orient) const;
+ int lenThumb,
+ wxOrientation orient,
+ long style = 0) const;
virtual wxSize GetSliderThumbSize(const wxRect& rect,
+ int lenThumb,
wxOrientation orient) const;
virtual wxSize GetProgressBarStep() const { return wxSize(16, 32); }
virtual wxMenuGeometryInfo *GetMenuGeometry(wxWindow *win,
const wxMenu& menu) const;
+ virtual wxSize GetStatusBarBorders(wxCoord *borderBetweenFields) const;
+
// 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
// draw the background with any colour, not only the default one(s)
void DoDrawBackground(wxDC& dc,
const wxColour& col,
- const wxRect& rect);
+ const wxRect& rect,
+ wxWindow *window = NULL);
// DrawBorder() helpers: all of them shift and clip the DC after drawing
// the border
}
// get the line wrap indicator bitmap
- wxBitmap GetLineWrapBitmap();
+ wxBitmap GetLineWrapBitmap() const;
// DrawCheckBitmap and DrawRadioBitmap helpers
wxAlignment align,
int indexAccel);
+ // common part of DrawMenuItem() and DrawMenuBarItem()
+ void DoDrawMenuItem(wxDC& dc,
+ const wxRect& rect,
+ const wxString& label,
+ int flags,
+ int indexAccel,
+ const wxString& accel = wxEmptyString,
+ const wxBitmap& bitmap = wxNullBitmap,
+ const wxGTKMenuGeometryInfo *geometryInfo = NULL);
+
+ // initialize the combo bitmaps
+ void InitComboBitmaps();
+
private:
const wxColourScheme *m_scheme;
m_penHighlight;
// the checkbox bitmaps: first row is for the normal, second for the
- // pressed state and the columns are for checked and unchecked status
- // respectively
- wxBitmap m_bitmapsCheckbox[2][2];
+ // pressed state and the columns are for checked, unchecked and
+ // undeterminated respectively
+ wxBitmap m_bitmapsCheckbox[2][3];
// the line wrap bitmap (drawn at the end of wrapped lines)
wxBitmap m_bmpLineWrap;
+
+ // the combobox bitmaps
+ enum
+ {
+ ComboState_Normal,
+ ComboState_Focus,
+ ComboState_Pressed,
+ ComboState_Disabled,
+ ComboState_Max
+ };
+
+ wxBitmap m_bitmapsCombo[ComboState_Max];
};
// ----------------------------------------------------------------------------
public:
wxGTKInputHandler(wxGTKRenderer *renderer);
- virtual bool HandleKey(wxControl *control,
+ virtual bool HandleKey(wxInputConsumer *control,
const wxKeyEvent& event,
bool pressed);
- virtual bool HandleMouse(wxControl *control,
+ virtual bool HandleMouse(wxInputConsumer *control,
const wxMouseEvent& event);
- virtual bool HandleMouseMove(wxControl *control, const wxMouseEvent& event);
+ virtual bool HandleMouseMove(wxInputConsumer *control, const wxMouseEvent& event);
protected:
wxGTKRenderer *m_renderer;
wxStdScrollBarInputHandler::Press(scrollbar, doIt);
}
- virtual bool IsAllowedButton(int WXUNUSED(button)) { return TRUE; }
+ virtual bool IsAllowedButton(int WXUNUSED(button)) { return true; }
bool IsArrow() const
{
wxGTKCheckboxInputHandler(wxInputHandler *handler)
: wxStdCheckboxInputHandler(handler) { }
- virtual bool HandleKey(wxControl *control,
+ virtual bool HandleKey(wxInputConsumer *control,
const wxKeyEvent& event,
bool pressed);
};
wxGTKTextCtrlInputHandler(wxInputHandler *handler)
: wxStdTextCtrlInputHandler(handler) { }
- virtual bool HandleKey(wxControl *control,
+ virtual bool HandleKey(wxInputConsumer *control,
const wxKeyEvent& event,
bool pressed);
};
virtual wxColour GetBackground(wxWindow *win) const;
};
+// ----------------------------------------------------------------------------
+// wxGTKArtProvider
+// ----------------------------------------------------------------------------
+
+class wxGTKArtProvider : public wxArtProvider
+{
+protected:
+ virtual wxBitmap CreateBitmap(const wxArtID& id,
+ const wxArtClient& client,
+ const wxSize& size);
+};
+
// ----------------------------------------------------------------------------
// wxGTKTheme
// ----------------------------------------------------------------------------
-WX_DEFINE_ARRAY(wxInputHandler *, wxArrayHandlers);
+WX_DEFINE_ARRAY_PTR(wxInputHandler *, wxArrayHandlers);
class wxGTKTheme : public wxTheme
{
wxGTKTheme();
virtual ~wxGTKTheme();
- virtual wxRenderer *GetRenderer() { return m_renderer; }
+ virtual wxRenderer *GetRenderer();
+ virtual wxArtProvider *GetArtProvider();
virtual wxInputHandler *GetInputHandler(const wxString& control);
- virtual wxColourScheme *GetColourScheme() { return m_scheme; }
+ virtual wxColourScheme *GetColourScheme();
private:
// get the default input handler
wxGTKRenderer *m_renderer;
+ wxGTKArtProvider *m_artProvider;
+
// the names of the already created handlers and the handlers themselves
// (these arrays are synchronized)
wxSortedArrayString m_handlerNames;
wxGTKTheme::wxGTKTheme()
{
- m_scheme = new wxGTKColourScheme;
- m_renderer = new wxGTKRenderer(m_scheme);
+ m_scheme = NULL;
+ m_renderer = NULL;
m_handlerDefault = NULL;
+ m_artProvider = NULL;
}
wxGTKTheme::~wxGTKTheme()
delete m_handlerDefault;
delete m_renderer;
delete m_scheme;
+ wxArtProvider::RemoveProvider(m_artProvider);
+}
+
+wxRenderer *wxGTKTheme::GetRenderer()
+{
+ if ( !m_renderer )
+ {
+ m_renderer = new wxGTKRenderer(GetColourScheme());
+ }
+
+ return m_renderer;
+}
+
+wxArtProvider *wxGTKTheme::GetArtProvider()
+{
+ if ( !m_artProvider )
+ {
+ m_artProvider = new wxGTKArtProvider;
+ }
+
+ return m_artProvider;
+}
+
+wxColourScheme *wxGTKTheme::GetColourScheme()
+{
+ if ( !m_scheme )
+ {
+ m_scheme = new wxGTKColourScheme;
+ }
+ return m_scheme;
}
wxInputHandler *wxGTKTheme::GetDefaultInputHandler()
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());
else
handler = GetDefaultInputHandler();
col = win->GetBackgroundColour();
}
- if ( win->IsContainerWindow() )
+ if ( !win->ShouldInheritColours() )
{
// doesn't depend on the state
if ( !col.Ok() )
case HIGHLIGHT: return wxColour(0x9c0000);
case HIGHLIGHT_TEXT: return wxColour(0xffffff);
+ case GAUGE: return Get(CONTROL_CURRENT);
+
case MAX:
default:
wxFAIL_MSG(_T("invalid standard colour"));
void wxGTKRenderer::DrawBorder(wxDC& dc,
wxBorder border,
const wxRect& rectTotal,
- int flags,
+ int WXUNUSED(flags),
wxRect *rectIn)
{
size_t width;
break;
case wxBORDER_STATIC:
- DrawShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
+ for ( width = 0; width < BORDER_THICKNESS; width++ )
+ {
+ DrawShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
+ }
break;
case wxBORDER_RAISED:
break;
case wxBORDER_DOUBLE:
- DrawShadedRect(dc, &rect, m_penLightGrey, m_penBlack);
- DrawShadedRect(dc, &rect, m_penHighlight, m_penDarkGrey);
- DrawRect(dc, &rect, m_penLightGrey);
+ 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:
- DrawRect(dc, &rect, m_penBlack);
+ for ( width = 0; width < BORDER_THICKNESS; width++ )
+ {
+ DrawRect(dc, &rect, m_penBlack);
+ }
break;
default:
case wxBORDER_SIMPLE:
case wxBORDER_STATIC:
- width = 1;
+ width = BORDER_THICKNESS;
break;
case wxBORDER_DOUBLE:
- width = 3;
+ width = 3*BORDER_THICKNESS;
break;
default:
bool wxGTKRenderer::AreScrollbarsInsideBorder() const
{
// no, the scrollbars are outside the border in GTK+
- return FALSE;
+ return false;
}
// ----------------------------------------------------------------------------
{
wxRect rect = rectOrig;
- if ( flags & wxCONTROL_FOCUSED )
- {
- DrawRect(dc, &rect, m_penBlack);
- DrawAntiShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
- }
- else // !focused
+ if ( border != wxBORDER_NONE )
{
- DrawAntiShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
- DrawAntiShadedRect(dc, &rect, m_penBlack, m_penHighlight);
+ if ( flags & wxCONTROL_FOCUSED )
+ {
+ DrawRect(dc, &rect, m_penBlack);
+ DrawAntiShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
+ }
+ else // !focused
+ {
+ DrawAntiShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
+ DrawAntiShadedRect(dc, &rect, m_penBlack, m_penHighlight);
+ }
}
if ( rectIn )
{
// button pressed: draw a black border around it and an inward shade
DrawRect(dc, &rect, m_penBlack);
- DrawAntiShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
- DrawAntiShadedRect(dc, &rect, m_penBlack, m_penDarkGrey);
+
+ for ( size_t width = 0; width < BORDER_THICKNESS; width++ )
+ {
+ DrawAntiShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
+ DrawAntiShadedRect(dc, &rect, m_penBlack, m_penDarkGrey);
+ }
}
else
{
}
// now draw a normal button
- DrawShadedRect(dc, &rect, m_penHighlight, m_penBlack);
- DrawAntiShadedRect(dc, &rect,
- wxPen(GetBackgroundColour(flags), 0, wxSOLID),
- m_penDarkGrey);
+ 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);
+ }
}
if ( rectIn )
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);
}
wxRect rectBitmap = rect;
rectBitmap.x -= 1;
rectBitmap.width = GetCheckBitmapSize().x;
+
// never draw the focus rect around the check indicators here
- DrawCheckButton(dc, _T(""), bitmap, rectBitmap, flags & ~wxCONTROL_FOCUSED);
+ DrawCheckButton(dc, wxEmptyString, bitmap, rectBitmap, flags & ~wxCONTROL_FOCUSED);
wxRect rectLabel = rect;
- wxCoord shift = rectBitmap.width + 2*GetCheckItemMargin();
+ wxCoord shift = rectBitmap.width + 2*GetCheckItemMargin();
rectLabel.x += shift;
rectLabel.width -= shift;
DrawItem(dc, label, rectLabel, flags);
// check/radion buttons
// ----------------------------------------------------------------------------
+void wxGTKRenderer::DrawUndeterminedBitmap(wxDC& dc,
+ const wxRect& rectTotal,
+ bool isPressed)
+{
+ // FIXME: For sure it is not GTK look but it is better than nothing.
+ // Show me correct look and I will immediatelly make it better (ABX)
+ wxRect rect = rectTotal;
+
+ wxColour col1, col2;
+
+ if ( isPressed )
+ {
+ col1 = wxSCHEME_COLOUR(m_scheme, SHADOW_DARK);
+ col2 = wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED);
+ }
+ else
+ {
+ col1 = wxSCHEME_COLOUR(m_scheme, SHADOW_DARK);
+ col2 = wxSCHEME_COLOUR(m_scheme, SHADOW_IN);
+ }
+
+ dc.SetPen(*wxTRANSPARENT_PEN);
+ dc.SetBrush(wxBrush(col1, wxSOLID));
+ dc.DrawRectangle(rect);
+ rect.Deflate(1);
+ dc.SetBrush(wxBrush(col2, wxSOLID));
+ dc.DrawRectangle(rect);
+}
+
void wxGTKRenderer::DrawUncheckBitmap(wxDC& dc,
const wxRect& rectTotal,
bool isPressed)
DrawUpZag(dc, x, xRight, yMid, y);
DrawUpZag(dc, x + 1, xRight - 1, yMid, y + 1);
- bool drawIt = TRUE;
+ bool drawIt = true;
if ( flags & wxCONTROL_CHECKED )
dc.SetPen(m_penBlack);
else if ( flags & wxCONTROL_PRESSED )
dc.SetPen(wxPen(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED), 0, wxSOLID));
else // unchecked and unpressed
- drawIt = FALSE;
+ drawIt = false;
if ( drawIt )
DrawUpZag(dc, x + 2, xRight - 2, yMid, y + 2);
DrawDownZag(dc, x + 1, xRight - 1, yMid, yBottom - 1);
if ( !(flags & wxCONTROL_CHECKED) )
- drawIt = TRUE; // with the same pen
+ drawIt = true; // with the same pen
else if ( flags & wxCONTROL_PRESSED )
{
dc.SetPen(wxPen(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED), 0, wxSOLID));
- drawIt = TRUE;
+ drawIt = true;
}
else // checked and unpressed
- drawIt = FALSE;
+ drawIt = false;
if ( drawIt )
DrawDownZag(dc, x + 2, xRight - 2, yMid, yBottom - 2);
rect.height = size.y;
for ( int i = 0; i < 2; i++ )
{
- for ( int j = 0; j < 2; j++ )
+ for ( int j = 0; j < 3; j++ )
m_bitmapsCheckbox[i][j].Create(rect.width, rect.height);
}
// normal unchecked
dc.SelectObject(m_bitmapsCheckbox[0][1]);
- DrawUncheckBitmap(dc, rect, FALSE);
+ DrawUncheckBitmap(dc, rect, false);
+
+ // normal undeterminated
+ dc.SelectObject(m_bitmapsCheckbox[0][2]);
+ DrawUndeterminedBitmap(dc, rect, false);
// pressed checked
m_bitmapsCheckbox[1][0] = m_bitmapsCheckbox[0][0];
// pressed unchecked
dc.SelectObject(m_bitmapsCheckbox[1][1]);
- DrawUncheckBitmap(dc, rect, TRUE);
+ DrawUncheckBitmap(dc, rect, true);
+
+ // pressed undeterminated
+ dc.SelectObject(m_bitmapsCheckbox[1][2]);
+ DrawUndeterminedBitmap(dc, rect, true);
}
- int row = flags & wxCONTROL_PRESSED ? 1 : 0;
- int col = flags & wxCONTROL_CHECKED ? 0 : 1;
+ int row = flags & wxCONTROL_PRESSED
+ ? 1
+ : 0;
+ int col = flags & wxCONTROL_CHECKED
+ ? 0
+ : ( flags & wxCONTROL_UNDETERMINED
+ ? 2
+ : 1 );
return m_bitmapsCheckbox[row][col];
}
-wxBitmap wxGTKRenderer::GetLineWrapBitmap()
+wxBitmap wxGTKRenderer::GetLineWrapBitmap() const
{
if ( !m_bmpLineWrap.Ok() )
{
}
else
{
- m_bmpLineWrap = bmpLineWrap;
+ wxConstCast(this, wxGTKRenderer)->m_bmpLineWrap = bmpLineWrap;
}
}
rectLabel.SetRight(rect.GetRight());
}
- dc.DrawBitmap(bitmap, xBmp, yBmp, TRUE /* use mask */);
+ dc.DrawBitmap(bitmap, xBmp, yBmp, true /* use mask */);
DrawLabel(dc, label, rectLabel, flags,
wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL, indexAccel);
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));
}
flags, align, indexAccel);
}
+void wxGTKRenderer::DrawToolBarButton(wxDC& dc,
+ const wxString& label,
+ const wxBitmap& bitmap,
+ const wxRect& rectOrig,
+ int flags,
+ long WXUNUSED(style))
+{
+ // we don't draw the separators at all
+ if ( !label.empty() || bitmap.Ok() )
+ {
+ wxRect rect = rectOrig;
+ rect.Deflate(BORDER_THICKNESS);
+
+ if ( flags & wxCONTROL_PRESSED )
+ {
+ DrawBorder(dc, wxBORDER_SUNKEN, rect, flags, &rect);
+
+ DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED), rect);
+ }
+ else if ( flags & wxCONTROL_CURRENT )
+ {
+ DrawBorder(dc, wxBORDER_RAISED, rect, flags, &rect);
+
+ DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL_CURRENT), rect);
+ }
+
+ dc.DrawLabel(label, bitmap, rect, wxALIGN_CENTRE);
+ }
+}
+
// ----------------------------------------------------------------------------
// text control
// ----------------------------------------------------------------------------
-wxRect wxGTKRenderer::GetTextTotalArea(const wxTextCtrl *text,
- const wxRect& rect)
+wxRect wxGTKRenderer::GetTextTotalArea(const wxTextCtrl * WXUNUSED(text),
+ const wxRect& rect) const
{
wxRect rectTotal = rect;
- rectTotal.Inflate(2);
+ rectTotal.Inflate(2*BORDER_THICKNESS);
return rectTotal;
}
wxRect wxGTKRenderer::GetTextClientArea(const wxTextCtrl *text,
const wxRect& rect,
- wxCoord *extraSpaceBeyond)
+ wxCoord *extraSpaceBeyond) const
{
wxRect rectText = rect;
- rectText.Inflate(-2);
+ rectText.Deflate(2*BORDER_THICKNESS);
if ( text->WrapLines() )
{
int flags,
int indexAccel)
{
+ #define SELECT_FOR_VERTICAL(X,Y) ( isVertical ? Y : X )
+ #define REVERSE_FOR_VERTICAL(X,Y) \
+ SELECT_FOR_VERTICAL(X,Y) \
+ , \
+ SELECT_FOR_VERTICAL(Y,X)
+
wxRect rect = rectOrig;
+ bool isVertical = ( dir == wxLEFT ) || ( dir == wxRIGHT );
+
// the current tab is drawn indented (to the top for default case) and
// bigger than the other ones
const wxSize indent = GetTabIndent();
if ( flags & wxCONTROL_SELECTED )
{
+ rect.Inflate( SELECT_FOR_VERTICAL( indent.x , 0),
+ SELECT_FOR_VERTICAL( 0, indent.y ));
switch ( dir )
{
default:
// fall through
case wxTOP:
- rect.Inflate(indent.x, 0);
rect.y -= indent.y;
- rect.height += indent.y;
- break;
-
+ // fall through
case wxBOTTOM:
- rect.Inflate(indent.x, 0);
rect.height += indent.y;
break;
case wxLEFT:
+ rect.x -= indent.x;
+ // fall through
case wxRIGHT:
- wxFAIL_MSG(_T("TODO"));
+ rect.width += indent.x;
break;
}
}
rectBorder.Deflate(4, 3);
if ( dir == wxBOTTOM )
rectBorder.Offset(0, -1);
+ if ( dir == wxRIGHT )
+ rectBorder.Offset(-1, 0);
DrawRect(dc, &rectBorder, m_penBlack);
}
// draw the text, image and the focus around them (if necessary)
- wxRect rectLabel = rect;
+ wxRect rectLabel( REVERSE_FOR_VERTICAL(rect.x,rect.y),
+ REVERSE_FOR_VERTICAL(rect.width,rect.height)
+ );
rectLabel.Deflate(1, 1);
- dc.DrawLabel(label, bitmap, rectLabel, wxALIGN_CENTRE, indexAccel);
+ if ( isVertical )
+ {
+ // draw it horizontally into memory and rotate for screen
+ wxMemoryDC dcMem;
+ wxBitmap bitmapRotated,
+ bitmapMem( rectLabel.x + rectLabel.width,
+ rectLabel.y + rectLabel.height );
+ dcMem.SelectObject(bitmapMem);
+ dcMem.SetBackground(dc.GetBackground());
+ dcMem.SetFont(dc.GetFont());
+ dcMem.SetTextForeground(dc.GetTextForeground());
+ dcMem.Clear();
+ bitmapRotated = wxBitmap( wxImage( bitmap.ConvertToImage() ).Rotate90(dir==wxLEFT) );
+ dcMem.DrawLabel(label, bitmapRotated, rectLabel, wxALIGN_CENTRE, indexAccel);
+ dcMem.SelectObject(wxNullBitmap);
+ bitmapMem = bitmapMem.GetSubBitmap(rectLabel);
+ bitmapMem = wxBitmap(wxImage(bitmapMem.ConvertToImage()).Rotate90(dir==wxRIGHT));
+ dc.DrawBitmap(bitmapMem, rectLabel.y, rectLabel.x, false);
+ }
+ else
+ {
+ dc.DrawLabel(label, bitmap, rectLabel, wxALIGN_CENTRE, indexAccel);
+ }
// now draw the tab itself
- wxCoord x = rect.x,
- y = rect.y,
- x2 = rect.GetRight(),
- y2 = rect.GetBottom();
+ wxCoord x = SELECT_FOR_VERTICAL(rect.x,rect.y),
+ y = SELECT_FOR_VERTICAL(rect.y,rect.x),
+ x2 = SELECT_FOR_VERTICAL(rect.GetRight(),rect.GetBottom()),
+ y2 = SELECT_FOR_VERTICAL(rect.GetBottom(),rect.GetRight());
switch ( dir )
{
default:
+ // default is top
+ case wxLEFT:
+ // left orientation looks like top but IsVertical makes x and y reversed
case wxTOP:
+ // top is not vertical so use coordinates in written order
dc.SetPen(m_penHighlight);
- dc.DrawLine(x, y2, x, y);
- dc.DrawLine(x + 1, y, x2, y);
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x, y2),
+ REVERSE_FOR_VERTICAL(x, y));
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y),
+ REVERSE_FOR_VERTICAL(x2, y));
dc.SetPen(m_penBlack);
- dc.DrawLine(x2, y2, x2, y);
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x2, y2),
+ REVERSE_FOR_VERTICAL(x2, y));
dc.SetPen(m_penDarkGrey);
- dc.DrawLine(x2 - 1, y2, x2 - 1, y + 1);
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x2 - 1, y2),
+ REVERSE_FOR_VERTICAL(x2 - 1, y + 1));
if ( flags & wxCONTROL_SELECTED )
{
dc.SetPen(m_penLightGrey);
// overwrite the part of the border below this tab
- dc.DrawLine(x + 1, y2 + 1, x2 - 1, y2 + 1);
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y2 + 1),
+ REVERSE_FOR_VERTICAL(x2 - 1, y2 + 1));
// and the shadow of the tab to the left of us
- dc.DrawLine(x + 1, y + 2, x + 1, y2 + 1);
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y + 2),
+ REVERSE_FOR_VERTICAL(x + 1, y2 + 1));
}
break;
+ case wxRIGHT:
+ // right orientation looks like bottom but IsVertical makes x and y reversed
case wxBOTTOM:
+ // bottom is not vertical so use coordinates in written order
dc.SetPen(m_penHighlight);
// we need to continue one pixel further to overwrite the corner of
// the border for the selected tab
- dc.DrawLine(x, y - (flags & wxCONTROL_SELECTED ? 1 : 0),
- x, y2);
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x, y - (flags & wxCONTROL_SELECTED ? 1 : 0)),
+ REVERSE_FOR_VERTICAL(x, y2));
// it doesn't work like this (TODO: implement it properly)
#if 0
// erase the corner of the tab to the right
dc.SetPen(m_penLightGrey);
- dc.DrawPoint(x2 - 1, y - 2);
- dc.DrawPoint(x2 - 2, y - 2);
- dc.DrawPoint(x2 - 2, y - 1);
+ dc.DrawPoint(REVERSE_FOR_VERTICAL(x2 - 1, y - 2));
+ dc.DrawPoint(REVERSE_FOR_VERTICAL(x2 - 2, y - 2));
+ dc.DrawPoint(REVERSE_FOR_VERTICAL(x2 - 2, y - 1));
#endif // 0
dc.SetPen(m_penBlack);
- dc.DrawLine(x + 1, y2, x2, y2);
- dc.DrawLine(x2, y, x2, y2);
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y2),
+ REVERSE_FOR_VERTICAL(x2, y2));
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x2, y),
+ REVERSE_FOR_VERTICAL(x2, y2));
dc.SetPen(m_penDarkGrey);
- dc.DrawLine(x + 2, y2 - 1, x2 - 1, y2 - 1);
- dc.DrawLine(x2 - 1, y, x2 - 1, y2);
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x + 2, y2 - 1),
+ REVERSE_FOR_VERTICAL(x2 - 1, y2 - 1));
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x2 - 1, y),
+ REVERSE_FOR_VERTICAL(x2 - 1, y2));
if ( flags & wxCONTROL_SELECTED )
{
dc.SetPen(m_penLightGrey);
// overwrite the part of the (double!) border above this tab
- dc.DrawLine(x + 1, y - 1, x2 - 1, y - 1);
- dc.DrawLine(x + 1, y - 2, x2 - 1, y - 2);
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y - 1),
+ REVERSE_FOR_VERTICAL(x2 - 1, y - 1));
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y - 2),
+ REVERSE_FOR_VERTICAL(x2 - 1, y - 2));
// and the shadow of the tab to the left of us
- dc.DrawLine(x + 1, y2 - 1, x + 1, y - 1);
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y2 - 1),
+ REVERSE_FOR_VERTICAL(x + 1, y - 1));
}
break;
-
- case wxLEFT:
- case wxRIGHT:
- wxFAIL_MSG(_T("TODO"));
}
}
// ----------------------------------------------------------------------------
wxSize wxGTKRenderer::GetSliderThumbSize(const wxRect& rect,
+ int lenThumb,
wxOrientation orient) const
{
static const wxCoord SLIDER_THUMB_LENGTH = 30;
wxSize size;
- wxRect rectShaft = GetSliderShaftRect(rect, orient);
+ wxRect rectShaft = GetSliderShaftRect(rect, lenThumb, orient);
if ( orient == wxHORIZONTAL )
{
size.x = wxMin(SLIDER_THUMB_LENGTH, rectShaft.width);
}
wxRect wxGTKRenderer::GetSliderShaftRect(const wxRect& rect,
- wxOrientation WXUNUSED(orient)) const
+ int WXUNUSED(lenThumb),
+ wxOrientation WXUNUSED(orient),
+ long WXUNUSED(style)) const
{
return rect.Deflate(2*BORDER_THICKNESS, 2*BORDER_THICKNESS);
}
void wxGTKRenderer::DrawSliderShaft(wxDC& dc,
const wxRect& rectOrig,
- wxOrientation orient,
+ int WXUNUSED(lenThumb),
+ wxOrientation WXUNUSED(orient),
int flags,
+ long WXUNUSED(style),
wxRect *rectShaft)
{
wxRect rect = rectOrig;
void wxGTKRenderer::DrawSliderThumb(wxDC& dc,
const wxRect& rectOrig,
wxOrientation orient,
- int flags)
+ int WXUNUSED(flags),
+ long WXUNUSED(style))
{
// draw the thumb border
wxRect rect = rectOrig;
// menu and menubar
// ----------------------------------------------------------------------------
+// wxGTKMenuGeometryInfo: the wxMenuGeometryInfo used by wxGTKRenderer
+class WXDLLEXPORT wxGTKMenuGeometryInfo : public wxMenuGeometryInfo
+{
+public:
+ virtual wxSize GetSize() const { return m_size; }
+
+ wxCoord GetLabelOffset() const { return m_ofsLabel; }
+ wxCoord GetAccelOffset() const { return m_ofsAccel; }
+
+ wxCoord GetItemHeight() const { return m_heightItem; }
+
+private:
+ // the total size of the menu
+ wxSize m_size;
+
+ // the offset of the start of the menu item label
+ wxCoord m_ofsLabel;
+
+ // the offset of the start of the accel label
+ wxCoord m_ofsAccel;
+
+ // the height of a normal (not separator) item
+ wxCoord m_heightItem;
+
+ friend wxMenuGeometryInfo *
+ wxGTKRenderer::GetMenuGeometry(wxWindow *, const wxMenu&) const;
+};
+
+// FIXME: all constants are hardcoded but shouldn't be
+static const wxCoord MENU_LEFT_MARGIN = 9;
+static const wxCoord MENU_RIGHT_MARGIN = 6;
+
+static const wxCoord MENU_HORZ_MARGIN = 6;
+static const wxCoord MENU_VERT_MARGIN = 3;
+
+// the margin around bitmap/check marks (on each side)
+static const wxCoord MENU_BMP_MARGIN = 2;
+
+// the margin between the labels and accel strings
+static const wxCoord MENU_ACCEL_MARGIN = 8;
+
+// the separator height in pixels: in fact, strangely enough, the real height
+// is 2 but Windows adds one extra pixel in the bottom margin, so take it into
+// account here
+static const wxCoord MENU_SEPARATOR_HEIGHT = 3;
+
+// the size of the standard checkmark bitmap
+static const wxCoord MENU_CHECK_SIZE = 9;
+
void wxGTKRenderer::DrawMenuBarItem(wxDC& dc,
const wxRect& rect,
const wxString& label,
int flags,
int indexAccel)
{
- DrawLabel(dc, label, rect, flags, wxALIGN_CENTRE, indexAccel);
+ DoDrawMenuItem(dc, rect, label, flags, indexAccel);
}
void wxGTKRenderer::DrawMenuItem(wxDC& dc,
wxCoord y,
- const wxMenuGeometryInfo& geometryInfo,
+ const wxMenuGeometryInfo& gi,
const wxString& label,
const wxString& accel,
const wxBitmap& bitmap,
int flags,
int indexAccel)
{
- wxFAIL_MSG(_T("TODO"));
+ const wxGTKMenuGeometryInfo& geomInfo = (const wxGTKMenuGeometryInfo&)gi;
+
+ wxRect rect;
+ rect.x = 0;
+ rect.y = y;
+ rect.width = geomInfo.GetSize().x;
+ rect.height = geomInfo.GetItemHeight();
+
+ DoDrawMenuItem(dc, rect, label, flags, indexAccel, accel, bitmap, &geomInfo);
+}
+
+void wxGTKRenderer::DoDrawMenuItem(wxDC& dc,
+ const wxRect& rectOrig,
+ const wxString& label,
+ int flags,
+ int indexAccel,
+ const wxString& accel,
+ const wxBitmap& bitmap,
+ const wxGTKMenuGeometryInfo *geometryInfo)
+{
+ wxRect rect = rectOrig;
+
+ // draw the selected item specially
+ if ( flags & wxCONTROL_SELECTED )
+ {
+ wxRect rectIn;
+ DrawBorder(dc, wxBORDER_RAISED, rect, flags, &rectIn);
+
+ DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL_CURRENT), rectIn);
+ }
+
+ rect.Deflate(MENU_HORZ_MARGIN, MENU_VERT_MARGIN);
+
+ // draw the bitmap: use the bitmap provided or the standard checkmark for
+ // the checkable items
+ if ( geometryInfo )
+ {
+ wxBitmap bmp = bitmap;
+ if ( !bmp.Ok() && (flags & wxCONTROL_CHECKABLE) )
+ {
+ bmp = GetCheckBitmap(flags);
+ }
+
+ if ( bmp.Ok() )
+ {
+ rect.SetRight(geometryInfo->GetLabelOffset());
+ wxControlRenderer::DrawBitmap(dc, bmp, rect);
+ }
+ }
+ //else: menubar items don't have bitmaps
+
+ // draw the label
+ if ( geometryInfo )
+ {
+ rect.x = geometryInfo->GetLabelOffset();
+ rect.SetRight(geometryInfo->GetAccelOffset());
+ }
+
+ DrawLabel(dc, label, rect, flags, wxALIGN_CENTRE_VERTICAL, indexAccel);
+
+ // draw the accel string
+ if ( !accel.empty() )
+ {
+ // menubar items shouldn't have them
+ wxCHECK_RET( geometryInfo, _T("accel strings only valid for menus") );
+
+ rect.x = geometryInfo->GetAccelOffset();
+ rect.SetRight(geometryInfo->GetSize().x);
+
+ // NB: no accel index here
+ DrawLabel(dc, accel, rect, flags, wxALIGN_CENTRE_VERTICAL);
+ }
+
+ // draw the submenu indicator
+ if ( flags & wxCONTROL_ISSUBMENU )
+ {
+ wxCHECK_RET( geometryInfo, _T("wxCONTROL_ISSUBMENU only valid for menus") );
+
+ rect.x = geometryInfo->GetSize().x - MENU_RIGHT_MARGIN;
+ rect.width = MENU_RIGHT_MARGIN;
+
+ DrawArrow(dc, wxRIGHT, rect, flags);
+ }
}
void wxGTKRenderer::DrawMenuSeparator(wxDC& dc,
wxCoord y,
const wxMenuGeometryInfo& geomInfo)
{
- wxFAIL_MSG(_T("TODO"));
+ DrawHorizontalLine(dc, y + MENU_VERT_MARGIN, 0, geomInfo.GetSize().x);
}
wxSize wxGTKRenderer::GetMenuBarItemSize(const wxSize& sizeText) const
{
- return sizeText;
+ wxSize size = sizeText;
+
+ // TODO: make this configurable
+ size.x += 2*MENU_HORZ_MARGIN;
+ size.y += 2*MENU_VERT_MARGIN;
+
+ return size;
}
wxMenuGeometryInfo *wxGTKRenderer::GetMenuGeometry(wxWindow *win,
const wxMenu& menu) const
{
- wxFAIL_MSG(_T("TODO"));
+ // prepare the dc: for now we draw all the items with the system font
+ wxClientDC dc(win);
+ dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
+
+ // the height of a normal item
+ wxCoord heightText = dc.GetCharHeight();
+
+ // the total height
+ wxCoord height = 0;
+
+ // the max length of label and accel strings: the menu width is the sum of
+ // them, even if they're for different items (as the accels should be
+ // aligned)
+ //
+ // the max length of the bitmap is never 0 as Windows always leaves enough
+ // space for a check mark indicator
+ wxCoord widthLabelMax = 0,
+ widthAccelMax = 0,
+ widthBmpMax = MENU_LEFT_MARGIN;
+
+ for ( wxMenuItemList::compatibility_iterator node = menu.GetMenuItems().GetFirst();
+ node;
+ node = node->GetNext() )
+ {
+ // height of this item
+ wxCoord h;
+
+ wxMenuItem *item = node->GetData();
+ if ( item->IsSeparator() )
+ {
+ h = MENU_SEPARATOR_HEIGHT;
+ }
+ else // not separator
+ {
+ h = heightText;
+
+ wxCoord widthLabel;
+ dc.GetTextExtent(item->GetLabel(), &widthLabel, NULL);
+ if ( widthLabel > widthLabelMax )
+ {
+ widthLabelMax = widthLabel;
+ }
+
+ wxCoord widthAccel;
+ dc.GetTextExtent(item->GetAccelString(), &widthAccel, NULL);
+ if ( widthAccel > widthAccelMax )
+ {
+ widthAccelMax = widthAccel;
+ }
+
+ const wxBitmap& bmp = item->GetBitmap();
+ if ( bmp.Ok() )
+ {
+ wxCoord widthBmp = bmp.GetWidth();
+ if ( widthBmp > widthBmpMax )
+ widthBmpMax = widthBmp;
+ }
+ //else if ( item->IsCheckable() ): no need to check for this as
+ // MENU_LEFT_MARGIN is big enough to show the check mark
+ }
+
+ h += 2*MENU_VERT_MARGIN;
- return NULL;
+ // remember the item position and height
+ item->SetGeometry(height, h);
+
+ height += h;
+ }
+
+ // bundle the metrics into a struct and return it
+ wxGTKMenuGeometryInfo *gi = new wxGTKMenuGeometryInfo;
+
+ gi->m_ofsLabel = widthBmpMax + 2*MENU_BMP_MARGIN;
+ gi->m_ofsAccel = gi->m_ofsLabel + widthLabelMax;
+ if ( widthAccelMax > 0 )
+ {
+ // if we actually have any accesl, add a margin
+ gi->m_ofsAccel += MENU_ACCEL_MARGIN;
+ }
+
+ gi->m_heightItem = heightText + 2*MENU_VERT_MARGIN;
+
+ gi->m_size.x = gi->m_ofsAccel + widthAccelMax + MENU_RIGHT_MARGIN;
+ gi->m_size.y = height;
+
+ return gi;
+}
+
+// ----------------------------------------------------------------------------
+// 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))
+{
}
// ----------------------------------------------------------------------------
// combobox
// ----------------------------------------------------------------------------
+void wxGTKRenderer::InitComboBitmaps()
+{
+ wxSize sizeArrow = m_sizeScrollbarArrow;
+ sizeArrow.x -= 2;
+ sizeArrow.y -= 2;
+
+ size_t n;
+
+ for ( n = ComboState_Normal; n < ComboState_Max; n++ )
+ {
+ m_bitmapsCombo[n].Create(sizeArrow.x, sizeArrow.y);
+ }
+
+ static const int comboButtonFlags[ComboState_Max] =
+ {
+ 0,
+ wxCONTROL_CURRENT,
+ wxCONTROL_PRESSED,
+ wxCONTROL_DISABLED,
+ };
+
+ wxRect rect(sizeArrow);
+
+ wxMemoryDC dc;
+ for ( n = ComboState_Normal; n < ComboState_Max; n++ )
+ {
+ int flags = comboButtonFlags[n];
+
+ dc.SelectObject(m_bitmapsCombo[n]);
+ DoDrawBackground(dc, GetBackgroundColour(flags), rect);
+ DrawArrow(dc, wxDOWN, rect, flags);
+ }
+}
+
void wxGTKRenderer::GetComboBitmaps(wxBitmap *bmpNormal,
+ wxBitmap *bmpFocus,
wxBitmap *bmpPressed,
wxBitmap *bmpDisabled)
{
- // TODO
+ if ( !m_bitmapsCombo[ComboState_Normal].Ok() )
+ {
+ InitComboBitmaps();
+ }
+
+ if ( bmpNormal )
+ *bmpNormal = m_bitmapsCombo[ComboState_Normal];
+ if ( bmpFocus )
+ *bmpFocus = m_bitmapsCombo[ComboState_Focus];
+ if ( bmpPressed )
+ *bmpPressed = m_bitmapsCombo[ComboState_Pressed];
+ if ( bmpDisabled )
+ *bmpDisabled = m_bitmapsCombo[ComboState_Disabled];
}
// ----------------------------------------------------------------------------
void wxGTKRenderer::DoDrawBackground(wxDC& dc,
const wxColour& col,
- const wxRect& rect)
+ const wxRect& rect,
+ wxWindow * WXUNUSED(window))
{
wxBrush brush(col, wxSOLID);
dc.SetBrush(brush);
void wxGTKRenderer::DrawBackground(wxDC& dc,
const wxColour& col,
const wxRect& rect,
- int flags)
+ int flags,
+ wxWindow *window )
{
wxColour colBg = col.Ok() ? col : GetBackgroundColour(flags);
- DoDrawBackground(dc, colBg, rect);
+ DoDrawBackground(dc, colBg, rect, window );
}
// ----------------------------------------------------------------------------
void wxGTKRenderer::DrawScrollbarShaft(wxDC& dc,
wxOrientation orient,
const wxRect& rect,
- int flags)
+ int WXUNUSED(flags))
{
wxRect rectBar = rect;
DrawThumbBorder(dc, &rectBar, orient);
void wxGTKRenderer::AdjustSize(wxSize *size, const wxWindow *window)
{
- if ( wxDynamicCast(window, wxButton) )
+#if wxUSE_BMPBUTTON
+ if ( wxDynamicCast(window, wxBitmapButton) )
{
- // TODO: this is ad hoc...
- size->x += 3*window->GetCharWidth();
- if ( size->x < 80 )
- size->x = 80;
- wxCoord minBtnHeight = 22;
- if ( size->y < minBtnHeight )
- size->y = minBtnHeight;
-
- // button border width
+ size->x += 4;
size->y += 4;
- }
- else if ( wxDynamicCast(window, wxScrollBar) )
+ } else
+#endif // wxUSE_BMPBUTTON
+#if wxUSE_BUTTON
+ if ( wxDynamicCast(window, wxButton) )
+ {
+ if ( !(window->GetWindowStyle() & wxBU_EXACTFIT) )
+ {
+ // TODO: this is ad hoc...
+ size->x += 3*window->GetCharWidth();
+ wxCoord minBtnHeight = 18;
+ if ( size->y < minBtnHeight )
+ size->y = minBtnHeight;
+
+ // button border width
+ size->y += 4;
+ }
+ } else
+#endif //wxUSE_BUTTON
+ if ( wxDynamicCast(window, wxScrollBar) )
{
// we only set the width of vert scrollbars and height of the
// horizontal ones
}
}
+// ----------------------------------------------------------------------------
+// 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
+// ----------------------------------------------------------------------------
+
+/* Copyright (c) Julian Smart */
+static const char *error_xpm[] = {
+/* columns rows colors chars-per-pixel */
+"48 48 4 1",
+" c None",
+"X c #242424",
+"o c #DCDF00",
+". c #C00000",
+/* pixels */
+" ",
+" ",
+" ",
+" ",
+" ",
+" ..... ",
+" ............. ",
+" ................. ",
+" ................... ",
+" ....................... ",
+" ......................... ",
+" ........................... ",
+" ...........................X ",
+" .............................X ",
+" ............................... ",
+" ...............................X ",
+" .................................X ",
+" .................................X ",
+" .................................XX ",
+" ...ooooooooooooooooooooooooooo...XX ",
+" ....ooooooooooooooooooooooooooo....X ",
+" ....ooooooooooooooooooooooooooo....X ",
+" ....ooooooooooooooooooooooooooo....XX ",
+" ....ooooooooooooooooooooooooooo....XX ",
+" ....ooooooooooooooooooooooooooo....XX ",
+" ...ooooooooooooooooooooooooooo...XXX ",
+" ...ooooooooooooooooooooooooooo...XXX ",
+" .................................XX ",
+" .................................XX ",
+" ...............................XXX ",
+" ...............................XXX ",
+" .............................XXX ",
+" ...........................XXXX ",
+" ...........................XXX ",
+" .........................XXX ",
+" .......................XXXX ",
+" X...................XXXXX ",
+" X.................XXXXX ",
+" X.............XXXXX ",
+" XXXX.....XXXXXXXX ",
+" XXXXXXXXXXXXX ",
+" XXXXX ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" "
+};
+
+/* Copyright (c) Julian Smart */
+static const char *info_xpm[] = {
+/* columns rows colors chars-per-pixel */
+"48 48 9 1",
+"$ c Black",
+"O c #FFFFFF",
+"@ c #808080",
+"+ c #000080",
+"o c #E8EB01",
+" c None",
+"X c #FFFF40",
+"# c #C0C0C0",
+". c #ABAD01",
+/* pixels */
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ..... ",
+" ..XXXXX.. ",
+" ..XXXXXXXXo.. ",
+" .XXXOXXXXXXXoo. ",
+" .XOOXXX+XXXXXo. ",
+" .XOOOXX+++XXXXoo. ",
+" .XOOXXX+++XXXXXo. ",
+" .XOOOXXX+++XXXXXXo. ",
+" .XOOXXXX+++XXXXXXo. ",
+" .XXXXXXX+++XXXXXXX. ",
+" .XXXXXXX+++XXXXXXo. ",
+" .XXXXXXX+++XXXXXoo. ",
+" .XXXXXX+++XXXXXo. ",
+" .XXXXXXX+XXXXXXo. ",
+" .XXXXXXXXXXXXo. ",
+" .XXXXX+++XXXoo. ",
+" .XXXX+++XXoo. ",
+" .XXXXXXXXo. ",
+" ..XXXXXXo.. ",
+" .XXXXXo.. ",
+" @#######@ ",
+" @@@@@@@@@ ",
+" @#######@ ",
+" @@@@@@@@@ ",
+" @#######@ ",
+" @@@@@@@ ",
+" ### ",
+" $$$ ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" "
+};
+
+/* Copyright (c) Julian Smart */
+static const char *warning_xpm[] = {
+/* columns rows colors chars-per-pixel */
+"48 48 9 1",
+"@ c Black",
+"o c #A6A800",
+"+ c #8A8C00",
+"$ c #B8BA00",
+" c None",
+"O c #6E7000",
+"X c #DCDF00",
+". c #C00000",
+"# c #373800",
+/* pixels */
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" . ",
+" ... ",
+" ... ",
+" ..... ",
+" ...X.. ",
+" ..XXX.. ",
+" ...XXX... ",
+" ..XXXXX.. ",
+" ..XXXXXX... ",
+" ...XXoO+XX.. ",
+" ..XXXO@#XXX.. ",
+" ..XXXXO@#XXX... ",
+" ...XXXXO@#XXXX.. ",
+" ..XXXXXO@#XXXX... ",
+" ...XXXXXo@OXXXXX.. ",
+" ...XXXXXXo@OXXXXXX.. ",
+" ..XXXXXXX$@OXXXXXX... ",
+" ...XXXXXXXX@XXXXXXXX.. ",
+" ...XXXXXXXXXXXXXXXXXX... ",
+" ..XXXXXXXXXXOXXXXXXXXX.. ",
+" ...XXXXXXXXXO@#XXXXXXXXX.. ",
+" ..XXXXXXXXXXX#XXXXXXXXXX... ",
+" ...XXXXXXXXXXXXXXXXXXXXXXX.. ",
+" ...XXXXXXXXXXXXXXXXXXXXXXXX... ",
+" .............................. ",
+" .............................. ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" "
+};
+
+/* Copyright (c) Julian Smart */
+static const char *question_xpm[] = {
+/* columns rows colors chars-per-pixel */
+"48 48 21 1",
+". c Black",
+"> c #696969",
+"O c #1F1F00",
+"+ c #181818",
+"o c #F6F900",
+"; c #3F3F00",
+"$ c #111111",
+" c None",
+"& c #202020",
+"X c #AAAA00",
+"@ c #949400",
+": c #303030",
+"1 c #383838",
+"% c #2A2A00",
+", c #404040",
+"= c #B4B400",
+"- c #484848",
+"# c #151500",
+"< c #9F9F00",
+"2 c #6A6A00",
+"* c #353500",
+/* pixels */
+" ",
+" ",
+" ",
+" ",
+" ......... ",
+" ...XXXXXXX.. ",
+" ..XXXXoooooXXXO+ ",
+" ..XXooooooooooooX@.. ",
+" ..XoooooooooooooooXX#. ",
+" $%XoooooooooooooooooXX#. ",
+" &.XoooooooXXXXXXooooooXX.. ",
+" .XooooooXX.$...$XXoooooX*. ",
+" $.XoooooX%.$ .*oooooo=.. ",
+" .XooooooX.. -.XoooooX.. ",
+" .XoooooX..+ .XoooooX;. ",
+" ...XXXX..: .XoooooX;. ",
+" ........ >.XoooooX;. ",
+" +.XoooooX.. ",
+" ,.Xoooooo<.. ",
+" 1#XooooooXO.. ",
+" &#XooooooX2.. ",
+" $%XooooooXX.. ",
+" $%XooooooXX.. ",
+" $%XooooooXX.. ",
+" &.XooooooXX.. ",
+" .XooooooXX.. ",
+" &.XoooooXX.. ",
+" ..XooooXX.. ",
+" ..XooooX... ",
+" ..XXooXX..& ",
+" ...XXXXX.. ",
+" ........ ",
+" ",
+" ",
+" ....... ",
+" ..XXXXX.. ",
+" ..XXoooXX.. ",
+" ..XoooooX.. ",
+" ..XoooooX.. ",
+" ..XXoooXX.. ",
+" ..XXXXX.. ",
+" ....... ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" "
+};
+
+wxBitmap wxGTKArtProvider::CreateBitmap(const wxArtID& id,
+ const wxArtClient& WXUNUSED(client),
+ const wxSize& WXUNUSED(size))
+{
+ if ( id == wxART_INFORMATION )
+ return wxBitmap(info_xpm);
+ if ( id == wxART_ERROR )
+ return wxBitmap(error_xpm);
+ if ( id == wxART_WARNING )
+ return wxBitmap(warning_xpm);
+ if ( id == wxART_QUESTION )
+ return wxBitmap(question_xpm);
+ return wxNullBitmap;
+}
+
+
// ============================================================================
// wxInputHandler
// ============================================================================
m_renderer = renderer;
}
-bool wxGTKInputHandler::HandleKey(wxControl *control,
- const wxKeyEvent& event,
- bool pressed)
+bool wxGTKInputHandler::HandleKey(wxInputConsumer * WXUNUSED(control),
+ const wxKeyEvent& WXUNUSED(event),
+ bool WXUNUSED(pressed))
{
- return FALSE;
+ return false;
}
-bool wxGTKInputHandler::HandleMouse(wxControl *control,
+bool wxGTKInputHandler::HandleMouse(wxInputConsumer *control,
const wxMouseEvent& event)
{
// clicking on the control gives it focus
- if ( event.ButtonDown() )
+ if ( event.ButtonDown() && wxWindow::FindFocus() != control->GetInputWindow() )
{
- control->SetFocus();
+ control->GetInputWindow()->SetFocus();
- return TRUE;
+ return true;
}
- return FALSE;
+ return false;
}
-bool wxGTKInputHandler::HandleMouseMove(wxControl *control,
+bool wxGTKInputHandler::HandleMouseMove(wxInputConsumer *control,
const wxMouseEvent& event)
{
if ( event.Entering() )
{
- control->SetCurrent(TRUE);
+ control->GetInputWindow()->SetCurrent(true);
}
else if ( event.Leaving() )
{
- control->SetCurrent(FALSE);
+ control->GetInputWindow()->SetCurrent(false);
}
else
{
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
// ----------------------------------------------------------------------------
// wxGTKCheckboxInputHandler
// ----------------------------------------------------------------------------
-bool wxGTKCheckboxInputHandler::HandleKey(wxControl *control,
+bool wxGTKCheckboxInputHandler::HandleKey(wxInputConsumer *control,
const wxKeyEvent& event,
bool pressed)
{
{
control->PerformAction(wxACTION_CHECKBOX_TOGGLE);
- return TRUE;
+ return true;
}
}
- return FALSE;
+ return false;
}
// ----------------------------------------------------------------------------
// wxGTKTextCtrlInputHandler
// ----------------------------------------------------------------------------
-bool wxGTKTextCtrlInputHandler::HandleKey(wxControl *control,
+bool wxGTKTextCtrlInputHandler::HandleKey(wxInputConsumer *control,
const wxKeyEvent& event,
bool pressed)
{
{
control->PerformAction(action);
- return TRUE;
+ return true;
}
}
projects / wxWidgets.git / blobdiff