// Created: 06.08.00
// RCS-ID: $Id$
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
-// Licence: wxWindows license
+// 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/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/univ/renderer.h"
#include "wx/univ/inphand.h"
#include "wx/univ/colschem.h"
#include "wx/univ/theme.h"
-#include "wx/toplevel.h"
+
+class WXDLLEXPORT wxGTKMenuGeometryInfo;
// ----------------------------------------------------------------------------
// constants (to be removed, for testing only)
// ----------------------------------------------------------------------------
-static const wxCoord BORDER_THICKNESS = 1;
+static const size_t BORDER_THICKNESS = 1;
// ----------------------------------------------------------------------------
// wxGTKRenderer: draw the GUI elements in GTK style
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
}
virtual void DrawStatusField(wxDC& dc,
const wxRect& rect,
const wxString& label,
- int flags = 0);
+ int flags = 0, int style = 0);
virtual void DrawFrameTitleBar(wxDC& dc,
const wxRect& rect,
// 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 wxIcon GetStdIcon(int which) const;
virtual void GetComboBitmaps(wxBitmap *bmpNormal,
wxBitmap *bmpFocus,
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); }
// 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 = _T(""),
+ const wxBitmap& bitmap = wxNullBitmap,
+ const wxGTKMenuGeometryInfo *geometryInfo = NULL);
+
// initialize the combo bitmaps
void InitComboBitmaps();
wxStdScrollBarInputHandler::Press(scrollbar, doIt);
}
- virtual bool IsAllowedButton(int WXUNUSED(button)) { return TRUE; }
+ virtual bool IsAllowedButton(int WXUNUSED(button)) { return true; }
bool IsArrow() const
{
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
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;
bool wxGTKRenderer::AreScrollbarsInsideBorder() const
{
// no, the scrollbars are outside the border in GTK+
- return FALSE;
+ return false;
}
// ----------------------------------------------------------------------------
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);
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);
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);
// normal unchecked
dc.SelectObject(m_bitmapsCheckbox[0][1]);
- DrawUncheckBitmap(dc, rect, FALSE);
+ DrawUncheckBitmap(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);
}
int row = flags & wxCONTROL_PRESSED ? 1 : 0;
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*BORDER_THICKNESS);
wxRect wxGTKRenderer::GetTextClientArea(const wxTextCtrl *text,
const wxRect& rect,
- wxCoord *extraSpaceBeyond)
+ wxCoord *extraSpaceBeyond) const
{
wxRect rectText = rect;
- rectText.Inflate(-2*BORDER_THICKNESS);
+ rectText.Deflate(2*BORDER_THICKNESS);
if ( text->WrapLines() )
{
// ----------------------------------------------------------------------------
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;
+
+ // 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;
- return NULL;
+ gi->m_size.x = gi->m_ofsAccel + widthAccelMax + MENU_RIGHT_MARGIN;
+ gi->m_size.y = height;
+
+ return gi;
}
// ----------------------------------------------------------------------------
// status bar
// ----------------------------------------------------------------------------
-wxSize wxGTKRenderer::GetStatusBarBorders(wxCoord *borderBetweenFields) const
+wxSize
+wxGTKRenderer::GetStatusBarBorders(wxCoord * WXUNUSED(borderBetweenFields)) const
{
return wxSize(0, 0);
}
-void wxGTKRenderer::DrawStatusField(wxDC& dc,
- const wxRect& rect,
- const wxString& label,
- int flags)
+void wxGTKRenderer::DrawStatusField(wxDC& WXUNUSED(dc),
+ const wxRect& WXUNUSED(rect),
+ const wxString& WXUNUSED(label),
+ int WXUNUSED(flags), int WXUNUSED(style))
{
}
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);
size->y += 4;
}
} else
-#endif wxUSE_BUTTON
+#endif //wxUSE_BUTTON
if ( wxDynamicCast(window, wxScrollBar) )
{
// we only set the width of vert scrollbars and height of the
// top level windows
// ----------------------------------------------------------------------------
-void wxGTKRenderer::DrawFrameTitleBar(wxDC& dc,
- const wxRect& rect,
- const wxString& title,
- const wxIcon& icon,
- int flags,
- int specialButton,
- int specialButtonFlag)
+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& dc,
- const wxRect& rect,
- int flags)
+void wxGTKRenderer::DrawFrameBorder(wxDC& WXUNUSED(dc),
+ const wxRect& WXUNUSED(rect),
+ int WXUNUSED(flags))
{
}
-void wxGTKRenderer::DrawFrameBackground(wxDC& dc,
- const wxRect& rect,
- int flags)
+void wxGTKRenderer::DrawFrameBackground(wxDC& WXUNUSED(dc),
+ const wxRect& WXUNUSED(rect),
+ int WXUNUSED(flags))
{
}
-void wxGTKRenderer::DrawFrameTitle(wxDC& dc,
- const wxRect& rect,
- const wxString& title,
- int flags)
+void wxGTKRenderer::DrawFrameTitle(wxDC& WXUNUSED(dc),
+ const wxRect& WXUNUSED(rect),
+ const wxString& WXUNUSED(title),
+ int WXUNUSED(flags))
{
}
-void wxGTKRenderer::DrawFrameIcon(wxDC& dc,
- const wxRect& rect,
- const wxIcon& icon,
- int flags)
+void wxGTKRenderer::DrawFrameIcon(wxDC& WXUNUSED(dc),
+ const wxRect& WXUNUSED(rect),
+ const wxIcon& WXUNUSED(icon),
+ int WXUNUSED(flags))
{
}
-void wxGTKRenderer::DrawFrameButton(wxDC& dc,
- wxCoord x, wxCoord y,
- int button,
- int 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 flags) const
+wxRect
+wxGTKRenderer::GetFrameClientArea(const wxRect& rect,
+ int WXUNUSED(flags)) const
{
return rect;
}
-wxSize wxGTKRenderer::GetFrameTotalSize(const wxSize& clientSize, int flags) const
+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(-1, -1);
+ return wxSize(wxDefaultCoord, wxDefaultCoord);
}
-int wxGTKRenderer::HitTestFrame(const wxRect& rect, const wxPoint& pt, int flags) const
+int
+wxGTKRenderer::HitTestFrame(const wxRect& WXUNUSED(rect),
+ const wxPoint& WXUNUSED(pt),
+ int WXUNUSED(flags)) const
{
return wxHT_TOPLEVEL_CLIENT_AREA;
}
// standard icons
// ----------------------------------------------------------------------------
-static char *error_xpm[] = {
+static const char *error_xpm[] = {
/* columns rows colors chars-per-pixel */
"48 48 537 2",
" c Gray0",
"W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+"
};
-static char *info_xpm[] = {
+static const char *info_xpm[] = {
/* columns rows colors chars-per-pixel */
"48 48 478 2",
" c Gray0",
};
/* XPM */
-static char *warning_xpm[] = {
+static const char *warning_xpm[] = {
/* columns rows colors chars-per-pixel */
"48 48 270 2",
" c Gray0",
};
/* XPM */
-static char *question_xpm[] = {
+static const char *question_xpm[] = {
/* columns rows colors chars-per-pixel */
"48 48 101 2",
" c Gray0",
"$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$."
};
-
-wxIcon wxGTKRenderer::GetStdIcon(int which) const
+wxBitmap wxGTKArtProvider::CreateBitmap(const wxArtID& id,
+ const wxArtClient& WXUNUSED(client),
+ const wxSize& WXUNUSED(size))
{
- switch(which)
- {
- case wxICON_INFORMATION:
- return wxIcon(info_xpm);
-
- case wxICON_QUESTION:
- return wxIcon(question_xpm);
-
- case wxICON_EXCLAMATION:
- return wxIcon(warning_xpm);
-
- default:
- wxFAIL_MSG(wxT("requested non existent standard icon"));
- // still fall through
-
- case wxICON_HAND:
- return wxIcon(error_xpm);
- }
+ 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;
}
m_renderer = renderer;
}
-bool wxGTKInputHandler::HandleKey(wxInputConsumer *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(wxInputConsumer *control,
{
control->GetInputWindow()->SetFocus();
- return TRUE;
+ return true;
}
- return FALSE;
+ return false;
}
bool wxGTKInputHandler::HandleMouseMove(wxInputConsumer *control,
{
if ( event.Entering() )
{
- control->GetInputWindow()->SetCurrent(TRUE);
+ control->GetInputWindow()->SetCurrent(true);
}
else if ( event.Leaving() )
{
- control->GetInputWindow()->SetCurrent(FALSE);
+ control->GetInputWindow()->SetCurrent(false);
}
else
{
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
// ----------------------------------------------------------------------------
{
control->PerformAction(wxACTION_CHECKBOX_TOGGLE);
- return TRUE;
+ return true;
}
}
- return FALSE;
+ return false;
}
// ----------------------------------------------------------------------------
{
control->PerformAction(action);
- return TRUE;
+ return true;
}
}
projects / wxWidgets.git / blobdiff