// Created: 06.08.00
// RCS-ID: $Id$
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
-// Licence: wxWindows license
+// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// ===========================================================================
#include "wx/scrolbar.h"
#include "wx/slider.h"
#include "wx/textctrl.h"
+ #include "wx/toolbar.h"
#ifdef __WXMSW__
// for COLOR_* constants
#include "wx/spinbutt.h"
#include "wx/settings.h"
#include "wx/menu.h"
+#include "wx/artprov.h"
+#include "wx/toplevel.h"
#include "wx/univ/scrtimer.h"
-#include "wx/toplevel.h"
#include "wx/univ/renderer.h"
#include "wx/univ/inphand.h"
#include "wx/univ/colschem.h"
static const int FRAME_BUTTON_WIDTH = 16;
static const int FRAME_BUTTON_HEIGHT = 14;
+static const size_t NUM_STATUSBAR_GRIP_BANDS = 3;
+static const size_t WIDTH_STATUSBAR_GRIP_BAND = 4;
+static const size_t STATUSBAR_GRIP_SIZE =
+ WIDTH_STATUSBAR_GRIP_BAND*NUM_STATUSBAR_GRIP_BANDS;
+
+static const wxCoord SLIDER_MARGIN = 6; // margin around slider
+static const wxCoord SLIDER_THUMB_LENGTH = 18;
+static const wxCoord SLIDER_TICK_LENGTH = 6;
+
enum IndicatorType
{
IndicatorType_Check,
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,
int flags = 0,
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);
+ int flags = 0,
+ long style = 0);
virtual void DrawSliderTicks(wxDC& dc,
const wxRect& rect,
- const wxSize& sizeThumb,
+ int lenThumb,
wxOrientation orient,
int start,
int end,
int step = 1,
- int flags = 0);
-#if wxUSE_MENUS
+ int flags = 0,
+ long style = 0);
virtual void DrawMenuBarItem(wxDC& dc,
const wxRect& rect,
virtual void DrawMenuSeparator(wxDC& dc,
wxCoord y,
const wxMenuGeometryInfo& geomInfo);
-#endif
+
+ virtual void DrawStatusField(wxDC& dc,
+ const wxRect& rect,
+ const wxString& label,
+ int flags = 0);
+
// titlebars
virtual void DrawFrameTitleBar(wxDC& dc,
const wxRect& rect,
const wxString& title,
const wxIcon& icon,
int flags,
- int pressedButtons = 0);
+ int specialButton = 0,
+ int specialButtonFlags = 0);
virtual void DrawFrameBorder(wxDC& dc,
const wxRect& rect,
int flags);
int flags = 0);
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,
virtual wxCoord GetCheckItemMargin() const
{ return 0; }
+ virtual wxSize GetToolBarButtonSize(wxCoord *separator) const
+ { if ( separator ) *separator = 5; return wxSize(16, 15); }
+ virtual wxSize GetToolBarMargin() const
+ { return wxSize(4, 4); }
+
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, 5); }
- virtual wxCoord GetSliderDim() const { return 20; }
- virtual wxCoord GetSliderTickLen() const { return 4; }
+ virtual wxCoord GetSliderDim() const { return SLIDER_THUMB_LENGTH + 2*BORDER_THICKNESS; }
+ virtual wxCoord GetSliderTickLen() const { return SLIDER_TICK_LENGTH; }
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); }
-#if wxUSE_MENUS
virtual wxSize GetMenuBarItemSize(const wxSize& sizeText) const;
virtual wxMenuGeometryInfo *GetMenuGeometry(wxWindow *win,
const wxMenu& menu) const;
-#endif
+
+ virtual wxSize GetStatusBarBorders(wxCoord *borderBetweenFields) const;
+
protected:
// helper of DrawLabel() and DrawCheckOrRadioButton()
void DoDrawLabel(wxDC& dc,
// DrawButtonBorder() helper
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
m_penDarkGrey,
m_penLightGrey,
m_penHighlight;
-
+
wxFont m_titlebarFont;
-
+
+ // the checked and unchecked bitmaps for DrawCheckItem()
+ wxBitmap m_bmpCheckBitmaps[IndicatorStatus_Max];
+
+ // the bitmaps returned by GetIndicator()
+ wxBitmap m_bmpIndicators[IndicatorType_Max]
+ [IndicatorState_Max]
+ [IndicatorStatus_Max];
+
// titlebar icons:
wxBitmap m_bmpFrameButtons[FrameButton_Max];
protected:
virtual bool IsAllowedButton(int button) { return button == 1; }
- virtual void Highlight(wxScrollBar *scrollbar, bool doIt)
+ virtual void Highlight(wxScrollBar * WXUNUSED(scrollbar),
+ bool WXUNUSED(doIt))
{
// we don't highlight anything
}
bool pressed);
};
+class wxWin32StatusBarInputHandler : public wxStdInputHandler
+{
+public:
+ wxWin32StatusBarInputHandler(wxInputHandler *handler);
+
+ virtual bool HandleMouse(wxInputConsumer *consumer,
+ const wxMouseEvent& event);
+
+ virtual bool HandleMouseMove(wxInputConsumer *consumer,
+ const wxMouseEvent& event);
+
+protected:
+ // is the given point over the statusbar grip?
+ bool IsOnGrip(wxWindow *statbar, const wxPoint& pt) const;
+
+private:
+ // the cursor we had replaced with the resize one
+ wxCursor m_cursorOld;
+
+ // was the mouse over the grip last time we checked?
+ bool m_isOnGrip;
+};
+
+class wxWin32SystemMenuEvtHandler;
+
+class wxWin32FrameInputHandler : public wxStdFrameInputHandler
+{
+public:
+ wxWin32FrameInputHandler(wxInputHandler *handler);
+ ~wxWin32FrameInputHandler();
+
+ virtual bool HandleMouse(wxInputConsumer *control,
+ const wxMouseEvent& event);
+
+ virtual bool HandleActivation(wxInputConsumer *consumer, bool activated);
+
+ void PopupSystemMenu(wxTopLevelWindow *window, const wxPoint& pos) const;
+
+private:
+ // was the mouse over the grip last time we checked?
+ wxWin32SystemMenuEvtHandler *m_menuHandler;
+};
+
// ----------------------------------------------------------------------------
// wxWin32ColourScheme: uses (default) Win32 colours
// ----------------------------------------------------------------------------
virtual wxColour GetBackground(wxWindow *win) const;
};
+// ----------------------------------------------------------------------------
+// wxWin32ArtProvider
+// ----------------------------------------------------------------------------
+
+class wxWin32ArtProvider : public wxArtProvider
+{
+protected:
+ virtual wxBitmap CreateBitmap(const wxArtID& id,
+ const wxArtClient& client,
+ const wxSize& size);
+};
+
// ----------------------------------------------------------------------------
// wxWin32Theme
// ----------------------------------------------------------------------------
-WX_DEFINE_ARRAY(wxInputHandler *, wxArrayHandlers);
+WX_DEFINE_ARRAY_PTR(wxInputHandler *, wxArrayHandlers);
class wxWin32Theme : public wxTheme
{
wxWin32Theme();
virtual ~wxWin32Theme();
- virtual wxRenderer *GetRenderer() { return m_renderer; }
+ virtual wxRenderer *GetRenderer();
+ virtual wxArtProvider *GetArtProvider();
virtual wxInputHandler *GetInputHandler(const wxString& control);
virtual wxColourScheme *GetColourScheme();
wxInputHandler *GetDefaultInputHandler();
wxWin32Renderer *m_renderer;
+
+ wxWin32ArtProvider *m_artProvider;
// the names of the already created handlers and the handlers themselves
// (these arrays are synchronized)
static const char *frame_button_close_xpm[] = {
"12 10 2 1",
-" c None",
-". c black",
+" c None",
+". c black",
" ",
" .. .. ",
" .. .. ",
static const char *frame_button_help_xpm[] = {
"12 10 2 1",
-" c None",
-". c #000000",
+" c None",
+". c #000000",
" .... ",
" .. .. ",
" .. .. ",
static const char *frame_button_maximize_xpm[] = {
"12 10 2 1",
-" c None",
-". c #000000",
+" c None",
+". c #000000",
" ......... ",
" ......... ",
" . . ",
static const char *frame_button_minimize_xpm[] = {
"12 10 2 1",
-" c None",
-". c #000000",
+" c None",
+". c #000000",
" ",
" ",
" ",
static const char *frame_button_restore_xpm[] = {
"12 10 2 1",
-" c None",
-". c #000000",
+" c None",
+". c #000000",
" ...... ",
" ...... ",
" . . ",
};
static const char **
- bmpIndicators[IndicatorType_Max][IndicatorState_Max][IndicatorStatus_Max] =
+ xpmIndicators[IndicatorType_Max][IndicatorState_Max][IndicatorStatus_Max] =
{
// checkboxes first
{
}
};
+static const char **xpmChecked[IndicatorStatus_Max] =
+{
+ checked_item_xpm,
+ unchecked_item_xpm
+};
+
// ============================================================================
// implementation
// ============================================================================
wxWin32Theme::wxWin32Theme()
{
- m_scheme = new wxWin32ColourScheme;
- m_renderer = new wxWin32Renderer(m_scheme);
+ m_scheme = NULL;
+ m_renderer = NULL;
m_handlerDefault = NULL;
+ m_artProvider = NULL;
}
wxWin32Theme::~wxWin32Theme()
delete m_renderer;
delete m_scheme;
+ wxArtProvider::RemoveProvider(m_artProvider);
+}
+
+wxRenderer *wxWin32Theme::GetRenderer()
+{
+ if ( !m_renderer )
+ {
+ m_renderer = new wxWin32Renderer(GetColourScheme());
+ }
+
+ return m_renderer;
+}
+
+wxArtProvider *wxWin32Theme::GetArtProvider()
+{
+ if ( !m_artProvider )
+ {
+ m_artProvider = new wxWin32ArtProvider;
+ }
+
+ return m_artProvider;
}
wxInputHandler *wxWin32Theme::GetDefaultInputHandler()
else if ( control == wxINP_HANDLER_NOTEBOOK )
handler = new wxStdNotebookInputHandler(GetDefaultInputHandler());
#endif // wxUSE_NOTEBOOK
+#if wxUSE_STATUSBAR
+ else if ( control == wxINP_HANDLER_STATUSBAR )
+ handler = new wxWin32StatusBarInputHandler(GetDefaultInputHandler());
+#endif // wxUSE_STATUSBAR
+#if wxUSE_TOOLBAR
+ else if ( control == wxINP_HANDLER_TOOLBAR )
+ handler = new wxStdToolbarInputHandler(GetDefaultInputHandler());
+#endif // wxUSE_TOOLBAR
+ else if ( control == wxINP_HANDLER_TOPLEVEL )
+ handler = new wxWin32FrameInputHandler(GetDefaultInputHandler());
else
handler = GetDefaultInputHandler();
wxColourScheme *wxWin32Theme::GetColourScheme()
{
+ if ( !m_scheme )
+ {
+ m_scheme = new wxWin32ColourScheme;
+ }
return m_scheme;
}
// the colour set by the user should be used for the normal state
// and for the states for which we don't have any specific colours
- if ( !col.Ok() || (flags != 0) )
+ if ( !col.Ok() || (flags & wxCONTROL_PRESSED) != 0 )
{
if ( wxDynamicCast(win, wxScrollBar) )
col = Get(flags & wxCONTROL_PRESSED ? SCROLLBAR_PRESSED
case CONTROL_TEXT: return wxColour(GetSysColor(COLOR_BTNTEXT));
- case SCROLLBAR: return wxColour(GetSysColor(COLOR_SCROLLBAR));
- case SCROLLBAR_PRESSED: return wxColour(GetSysColor(COLOR_HIGHLIGHT));
+#if defined(COLOR_3DLIGHT)
+ case SCROLLBAR: return wxColour(GetSysColor(COLOR_3DLIGHT));
+#else
+ case SCROLLBAR: return wxColour(0xe0e0e0);
+#endif
+ case SCROLLBAR_PRESSED: return wxColour(GetSysColor(COLOR_BTNTEXT));
case HIGHLIGHT: return wxColour(GetSysColor(COLOR_HIGHLIGHT));
case HIGHLIGHT_TEXT: return wxColour(GetSysColor(COLOR_HIGHLIGHTTEXT));
#if defined(COLOR_3DDKSHADOW)
case SHADOW_DARK: return wxColour(GetSysColor(COLOR_3DDKSHADOW));
#else
- case SHADOW_DARK: return *wxBLACK;
+ case SHADOW_DARK: return wxColour(GetSysColor(COLOR_3DHADOW));
#endif
case CONTROL_TEXT_DISABLED:
case CONTROL_TEXT_DISABLED_SHADOW:
case SHADOW_OUT: return wxColour(GetSysColor(COLOR_BTNSHADOW));
-
+
case TITLEBAR: return wxColour(GetSysColor(COLOR_INACTIVECAPTION));
case TITLEBAR_ACTIVE: return wxColour(GetSysColor(COLOR_ACTIVECAPTION));
- case TITLEBAR_TEXT: return wxColour(GetSysColor(COLOR_CAPTIONTEXT));
+ case TITLEBAR_TEXT: return wxColour(GetSysColor(COLOR_INACTIVECAPTIONTEXT));
+ case TITLEBAR_ACTIVE_TEXT: return wxColour(GetSysColor(COLOR_CAPTIONTEXT));
+
+ case DESKTOP: return wxColour(0x808000);
#else // !__WXMSW__
// use the standard Windows colours elsewhere
case WINDOW: return *wxWHITE;
case TITLEBAR: return wxColour(0xaeaaae);
case TITLEBAR_ACTIVE: return wxColour(0x820300);
- case TITLEBAR_TEXT: return *wxWHITE;
+ case TITLEBAR_TEXT: return wxColour(0xc0c0c0);
+ case TITLEBAR_ACTIVE_TEXT:return *wxWHITE;
+
+ case DESKTOP: return wxColour(0x808000);
#endif // __WXMSW__
+ case GAUGE: return Get(HIGHLIGHT);
+
case MAX:
default:
wxFAIL_MSG(_T("invalid standard colour"));
m_colHighlight = wxSCHEME_COLOUR(scheme, SHADOW_HIGHLIGHT);
m_penHighlight = wxPen(m_colHighlight, 0, wxSOLID);
-
- m_titlebarFont = wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT);
+
+ m_titlebarFont = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
m_titlebarFont.SetWeight(wxFONTWEIGHT_BOLD);
// init the arrow bitmaps
m_bmpArrows[Arrow_Pressed][n] = m_bmpArrows[Arrow_Normal][n];
}
-
+
// init the frame buttons bitmaps
m_bmpFrameButtons[FrameButton_Close] = wxBitmap(frame_button_close_xpm);
m_bmpFrameButtons[FrameButton_Minimize] = wxBitmap(frame_button_minimize_xpm);
rect->GetRight(), rect->GetBottom());
// adjust the rect
- rect->width--;
- rect->height--;
+ rect->Inflate(-1);
}
void wxWin32Renderer::DrawShadedRect(wxDC& dc, wxRect *rect,
break;
default:
+ {
+ // char *crash = NULL;
+ // *crash = 0;
wxFAIL_MSG(_T("unknown border type"));
// fall through
+ }
case wxBORDER_DEFAULT:
case wxBORDER_NONE:
}
else // use default bitmap
{
- bmp = wxBitmap(flags & wxCONTROL_CHECKED ? checked_item_xpm
- : unchecked_item_xpm);
+ IndicatorStatus i = flags & wxCONTROL_CHECKED
+ ? IndicatorStatus_Checked
+ : IndicatorStatus_Unchecked;
+
+ if ( !m_bmpCheckBitmaps[i].Ok() )
+ {
+ m_bmpCheckBitmaps[i] = wxBitmap(xpmChecked[i]);
+ }
+
+ bmp = m_bmpCheckBitmaps[i];
}
dc.DrawBitmap(bmp, rect.x, rect.y + (rect.height - bmp.GetHeight()) / 2 - 1,
? IndicatorStatus_Checked
: IndicatorStatus_Unchecked;
- const char **xpm = bmpIndicators[indType][indState][indStatus];
- return xpm ? wxBitmap(xpm) : wxNullBitmap;
+ wxBitmap bmp = m_bmpIndicators[indType][indState][indStatus];
+ if ( !bmp.Ok() )
+ {
+ const char **xpm = xpmIndicators[indType][indState][indStatus];
+ if ( xpm )
+ {
+ // create and cache it
+ bmp = wxBitmap(xpm);
+ m_bmpIndicators[indType][indState][indStatus] = bmp;
+ }
+ }
+
+ return bmp;
}
void wxWin32Renderer::DrawCheckOrRadioButton(wxDC& dc,
wxAlignment align,
int indexAccel)
{
+ wxBitmap bmp;
+ if ( bitmap.Ok() )
+ bmp = bitmap;
+ else
+ bmp = GetRadioBitmap(flags);
+
DrawCheckOrRadioButton(dc, label,
- bitmap.Ok() ? bitmap : GetRadioBitmap(flags),
+ bmp,
rect, flags, align, indexAccel,
FOCUS_RECT_OFFSET_Y); // default focus rect offset
}
wxAlignment align,
int indexAccel)
{
+ wxBitmap bmp;
+ if ( bitmap.Ok() )
+ bmp = bitmap;
+ else
+ bmp = GetCheckBitmap(flags);
+
DrawCheckOrRadioButton(dc, label,
- bitmap.Ok() ? bitmap : GetCheckBitmap(flags),
+ bmp,
rect, flags, align, indexAccel,
0); // no focus rect offset for checkboxes
}
+void wxWin32Renderer::DrawToolBarButton(wxDC& dc,
+ const wxString& label,
+ const wxBitmap& bitmap,
+ const wxRect& rectOrig,
+ int flags,
+ long style)
+{
+ if (style == wxTOOL_STYLE_BUTTON)
+ {
+ wxRect rect = rectOrig;
+ rect.Deflate(BORDER_THICKNESS);
+
+ if ( flags & wxCONTROL_PRESSED )
+ {
+ DrawBorder(dc, wxBORDER_SUNKEN, rect, flags);
+ }
+ else if ( flags & wxCONTROL_CURRENT )
+ {
+ DrawBorder(dc, wxBORDER_RAISED, rect, flags);
+ }
+
+ dc.DrawLabel(label, bitmap, rect, wxALIGN_CENTRE);
+ }
+ else if (style == wxTOOL_STYLE_SEPARATOR)
+ {
+ // leave a small gap aroudn the line, also account for the toolbar
+ // border itself
+ DrawVerticalLine(dc, rectOrig.x + rectOrig.width/2,
+ rectOrig.y + 2*BORDER_THICKNESS,
+ rectOrig.GetBottom() - BORDER_THICKNESS);
+ }
+ // don't draw wxTOOL_STYLE_CONTROL
+}
+
// ----------------------------------------------------------------------------
// text control
// ----------------------------------------------------------------------------
StandardDrawTextLine(dc, text, rect, selStart, selEnd, flags);
}
-void wxWin32Renderer::DrawLineWrapMark(wxDC& dc, const wxRect& rect)
+void
+wxWin32Renderer::DrawLineWrapMark(wxDC& WXUNUSED(dc),
+ const wxRect& WXUNUSED(rect))
{
// we don't draw them
}
// slider
// ----------------------------------------------------------------------------
-wxSize wxWin32Renderer::GetSliderThumbSize(const wxRect& rect,
- wxOrientation orient) const
+wxSize
+wxWin32Renderer::GetSliderThumbSize(const wxRect& WXUNUSED(rect),
+ int lenThumb,
+ wxOrientation orient) const
{
wxSize size;
+ wxCoord width = wxMax (lenThumb, SLIDER_THUMB_LENGTH) / 2;
+ wxCoord height = wxMax (lenThumb, SLIDER_THUMB_LENGTH);
- wxRect rectShaft = GetSliderShaftRect(rect, orient);
- if ( orient == wxHORIZONTAL )
+ if (orient == wxHORIZONTAL)
{
- size.y = rect.height - 6;
- size.x = wxMin(size.y / 2, rectShaft.width);
+ size.x = width;
+ size.y = height;
}
- else // vertical
- {
- size.x = rect.width - 6;
- size.y = wxMin(size.x / 2, rectShaft.height);
+ else
+ { // == wxVERTICAL
+ size.x = height;
+ size.y = width;
}
return size;
}
wxRect wxWin32Renderer::GetSliderShaftRect(const wxRect& rectOrig,
- wxOrientation orient) const
+ int lenThumb,
+ wxOrientation orient,
+ long style) const
{
- static const wxCoord SLIDER_MARGIN = 6;
+ bool transpose = (orient == wxVERTICAL);
+ bool left = ((style & wxSL_AUTOTICKS) != 0) &
+ (((style & wxSL_TOP) != 0) & !transpose |
+ ((style & wxSL_LEFT) != 0) & transpose |
+ ((style & wxSL_BOTH) != 0));
+ bool right = ((style & wxSL_AUTOTICKS) != 0) &
+ (((style & wxSL_BOTTOM) != 0) & !transpose |
+ ((style & wxSL_RIGHT) != 0) & transpose |
+ ((style & wxSL_BOTH) != 0));
wxRect rect = rectOrig;
- if ( orient == wxHORIZONTAL )
- {
- // make the rect of minimal width and centre it
- rect.height = 2*BORDER_THICKNESS;
- rect.y = rectOrig.y + (rectOrig.height - rect.height) / 2;
- if ( rect.y < 0 )
- rect.y = 0;
+ wxSize sizeThumb = GetSliderThumbSize (rect, lenThumb, orient);
- // leave margins on the sides
- rect.Deflate(SLIDER_MARGIN, 0);
+ if (orient == wxHORIZONTAL) {
+ rect.x += SLIDER_MARGIN;
+ if (left & right)
+ {
+ rect.y += wxMax ((rect.height - 2*BORDER_THICKNESS) / 2, sizeThumb.y/2);
+ }
+ else if (left)
+ {
+ rect.y += wxMax ((rect.height - 2*BORDER_THICKNESS - sizeThumb.y/2), sizeThumb.y/2);
+ }
+ else
+ {
+ rect.y += sizeThumb.y/2;
+ }
+ rect.width -= 2*SLIDER_MARGIN;
+ rect.height = 2*BORDER_THICKNESS;
}
- else // vertical
- {
- // same as above but in other direction
+ else
+ { // == wxVERTICAL
+ rect.y += SLIDER_MARGIN;
+ if (left & right)
+ {
+ rect.x += wxMax ((rect.width - 2*BORDER_THICKNESS) / 2, sizeThumb.x/2);
+ }
+ else if (left)
+ {
+ rect.x += wxMax ((rect.width - 2*BORDER_THICKNESS - sizeThumb.x/2), sizeThumb.x/2);
+ }
+ else
+ {
+ rect.x += sizeThumb.x/2;
+ }
rect.width = 2*BORDER_THICKNESS;
- rect.x = rectOrig.x + (rectOrig.width - rect.width) / 2;
- if ( rect.x < 0 )
- rect.x = 0;
-
- rect.Deflate(0, SLIDER_MARGIN);
+ rect.height -= 2*SLIDER_MARGIN;
}
return rect;
void wxWin32Renderer::DrawSliderShaft(wxDC& dc,
const wxRect& rectOrig,
+ int lenThumb,
wxOrientation orient,
int flags,
+ long style,
wxRect *rectShaft)
{
- if ( flags & wxCONTROL_FOCUSED )
- {
+ /* show shaft geometry
+
+ shaft
+ +-------------+
+ | |
+ | XXX | <-- x1
+ | XXX |
+ | XXX |
+ | XXX |
+ | XXX | <-- x2
+ | |
+ +-------------+
+
+ ^ ^
+ | |
+ y1 y2
+ */
+
+ if (flags & wxCONTROL_FOCUSED) {
DrawFocusRect(dc, rectOrig);
}
- wxRect rect = GetSliderShaftRect(rectOrig, orient);
+ wxRect rect = GetSliderShaftRect(rectOrig, lenThumb, orient, style);
- if ( rectShaft )
- *rectShaft = rect;
+ if (rectShaft) *rectShaft = rect;
DrawSunkenBorder(dc, &rect);
}
void wxWin32Renderer::DrawSliderThumb(wxDC& dc,
const wxRect& rect,
wxOrientation orient,
- int flags)
+ int flags,
+ long style)
{
- /*
- we are drawing a shape of this form
-
- HHHHHHB <--- y
- H DB
- H DB
- H DB where H is hightlight colour
- H DB D dark grey
- H DB B black
- H DB
- H DB <--- y3
- H DB
- HDB
- B <--- y2
-
- ^ ^ ^
- | | |
- x x3 x2
+ /* show thumb geometry
+
+ H <--- y1
+ H H B
+ H H B
+ H H B <--- y3
+ H D B
+ H D B
+ H D B
+ H D B where H is hightlight colour
+ H D B D dark grey
+ H D B B black
+ H D B
+ H D B
+ H D B <--- y4
+ H D B
+ H D B
+ B <--- y2
+
+ ^ ^ ^
+ | | |
+ x1 x3 x2
The interior of this shape is filled with the hatched brush if the thumb
is pressed.
DrawBackground(dc, wxNullColour, rect, flags);
- bool transpose = orient == wxVERTICAL;
+ bool transpose = (orient == wxVERTICAL);
+ bool left = ((style & wxSL_AUTOTICKS) != 0) &
+ (((style & wxSL_TOP) != 0) & !transpose |
+ ((style & wxSL_LEFT) != 0) & transpose) &
+ ((style & wxSL_BOTH) == 0);
+ bool right = ((style & wxSL_AUTOTICKS) != 0) &
+ (((style & wxSL_BOTTOM) != 0) & !transpose |
+ ((style & wxSL_RIGHT) != 0) & transpose) &
+ ((style & wxSL_BOTH) == 0);
+
+ wxCoord sizeArrow = (transpose ? rect.height : rect.width) / 2;
+ wxCoord c = ((transpose ? rect.height : rect.width) - 2*sizeArrow);
+
+ wxCoord x1, x2, x3, y1, y2, y3, y4;
+ x1 = (transpose ? rect.y : rect.x);
+ x2 = (transpose ? rect.GetBottom() : rect.GetRight());
+ x3 = (x1-1+c) + sizeArrow;
+ y1 = (transpose ? rect.x : rect.y);
+ y2 = (transpose ? rect.GetRight() : rect.GetBottom());
+ y3 = (left ? (y1-1+c) + sizeArrow : y1);
+ y4 = (right ? (y2+1-c) - sizeArrow : y2);
- wxCoord x, y, x2, y2;
- if ( transpose )
+ dc.SetPen(m_penBlack);
+ if (left) {
+ DrawLine(dc, x3+1-c, y1, x2, y3, transpose);
+ }
+ DrawLine(dc, x2, y3, x2, y4, transpose);
+ if (right)
{
- x = rect.y;
- y = rect.x;
- x2 = rect.GetBottom();
- y2 = rect.GetRight();
+ DrawLine(dc, x3+1-c, y2, x2, y4, transpose);
}
else
{
- x = rect.x;
- y = rect.y;
- x2 = rect.GetRight();
- y2 = rect.GetBottom();
+ DrawLine(dc, x1, y2, x2, y2, transpose);
}
- // the size of the pointed part of the thumb
- wxCoord sizeArrow = (transpose ? rect.height : rect.width) / 2;
-
- wxCoord x3 = x + sizeArrow,
- y3 = y2 - sizeArrow;
-
- dc.SetPen(m_penHighlight);
- DrawLine(dc, x, y, x2, y, transpose);
- DrawLine(dc, x, y + 1, x, y2 - sizeArrow, transpose);
- DrawLine(dc, x, y3, x3, y2, transpose);
-
- dc.SetPen(m_penBlack);
- DrawLine(dc, x3, y2, x2, y3, transpose);
- DrawLine(dc, x2, y3, x2, y - 1, transpose);
-
dc.SetPen(m_penDarkGrey);
- DrawLine(dc, x3, y2 - 1, x2 - 1, y3, transpose);
- DrawLine(dc, x2 - 1, y3, x2 - 1, y, transpose);
+ DrawLine(dc, x2-1, y3+1, x2-1, y4-1, transpose);
+ if (right) {
+ DrawLine(dc, x3+1-c, y2-1, x2-1, y4, transpose);
+ }
+ else
+ {
+ DrawLine(dc, x1+1, y2-1, x2-1, y2-1, transpose);
+ }
- if ( flags & wxCONTROL_PRESSED )
+ dc.SetPen(m_penHighlight);
+ if (left)
+ {
+ DrawLine(dc, x1, y3, x3, y1, transpose);
+ DrawLine(dc, x3+1-c, y1+1, x2-1, y3, transpose);
+ }
+ else
{
+ DrawLine(dc, x1, y1, x2, y1, transpose);
+ }
+ DrawLine(dc, x1, y3, x1, y4, transpose);
+ if (right)
+ {
+ DrawLine(dc, x1, y4, x3+c, y2+c, transpose);
+ }
+
+ if (flags & wxCONTROL_PRESSED) {
// TODO: MSW fills the entire area inside, not just the rect
wxRect rectInt = rect;
- if ( transpose )
- rectInt.SetRight(y3);
+ if ( transpose )
+ {
+ rectInt.SetLeft(y3);
+ rectInt.SetRight(y4);
+ }
else
- rectInt.SetBottom(y3);
+ {
+ rectInt.SetTop(y3);
+ rectInt.SetBottom(y4);
+ }
rectInt.Deflate(2);
+#if !defined(__WXMGL__)
static const char *stipple_xpm[] = {
/* columns rows colors chars-per-pixel */
"2 2 2 1",
"w ",
" w",
};
+#else
+ // VS: MGL can only do 8x8 stipple brushes
+ static const char *stipple_xpm[] = {
+ /* columns rows colors chars-per-pixel */
+ "8 8 2 1",
+ " c None",
+ "w c white",
+ /* pixels */
+ "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",
+ };
+#endif
dc.SetBrush(wxBrush(stipple_xpm));
dc.SetTextForeground(wxSCHEME_COLOUR(m_scheme, SHADOW_HIGHLIGHT));
void wxWin32Renderer::DrawSliderTicks(wxDC& dc,
const wxRect& rect,
- const wxSize& sizeThumb,
+ int lenThumb,
wxOrientation orient,
int start,
int end,
int step,
- int flags)
+ int WXUNUSED(flags),
+ long style)
{
- if ( end == start )
- {
- // empty slider?
- return;
- }
-
- // the variable names correspond to horizontal case, but they can be used
- // for both orientations
- wxCoord x1, x2, y1, y2, len, widthThumb;
- if ( orient == wxHORIZONTAL )
- {
- x1 = rect.GetLeft();
- x2 = rect.GetRight();
-
- // draw from bottom to top to leave one pixel space between the ticks
- // and the slider as Windows do
- y1 = rect.GetBottom();
- y2 = rect.GetTop();
-
- len = rect.width;
-
- widthThumb = sizeThumb.x;
- }
- else // vertical
- {
- x1 = rect.GetTop();
- x2 = rect.GetBottom();
-
- y1 = rect.GetRight();
- y2 = rect.GetLeft();
-
- len = rect.height;
-
- widthThumb = sizeThumb.y;
- }
-
- // the first tick should be positioned in such way that a thumb drawn in
- // the first position points down directly to it
- x1 += widthThumb / 2;
- x2 -= widthThumb / 2;
+ /* show ticks geometry
+
+ left right
+ ticks shaft ticks
+ ---- XX ---- <-- x1
+ ---- XX ----
+ ---- XX ----
+ ---- XX ---- <-- x2
+
+ ^ ^ ^ ^
+ | | | |
+ y3 y1 y2 y4
+ */
- // this also means that we have slightly less space for the ticks in
- // between the first and the last
- len -= widthThumb;
+ // empty slider?
+ if (end == start) return;
+
+ bool transpose = (orient == wxVERTICAL);
+ bool left = ((style & wxSL_AUTOTICKS) != 0) &
+ (((style & wxSL_TOP) != 0) & !transpose |
+ ((style & wxSL_LEFT) != 0) & transpose |
+ ((style & wxSL_BOTH) != 0));
+ bool right = ((style & wxSL_AUTOTICKS) != 0) &
+ (((style & wxSL_BOTTOM) != 0) & !transpose |
+ ((style & wxSL_RIGHT) != 0) & transpose |
+ ((style & wxSL_BOTH) != 0));
+
+ // default thumb size
+ wxSize sizeThumb = GetSliderThumbSize (rect, 0, orient);
+ wxCoord defaultLen = (transpose ? sizeThumb.x : sizeThumb.y);
+
+ // normal thumb size
+ sizeThumb = GetSliderThumbSize (rect, lenThumb, orient);
+ wxCoord widthThumb = (transpose ? sizeThumb.y : sizeThumb.x);
+
+ wxRect rectShaft = GetSliderShaftRect (rect, lenThumb, orient, style);
+
+ wxCoord x1, x2, y1, y2, y3, y4 , len;
+ x1 = (transpose ? rectShaft.y : rectShaft.x) + widthThumb/2;
+ x2 = (transpose ? rectShaft.GetBottom() : rectShaft.GetRight()) - widthThumb/2;
+ y1 = (transpose ? rectShaft.x : rectShaft.y) - defaultLen/2;
+ y2 = (transpose ? rectShaft.GetRight() : rectShaft.GetBottom()) + defaultLen/2;
+ y3 = (transpose ? rect.x : rect.y);
+ y4 = (transpose ? rect.GetRight() : rect.GetBottom());
+ len = x2 - x1;
dc.SetPen(m_penBlack);
int range = end - start;
- for ( int n = 0; n < range; n += step )
- {
+ for ( int n = 0; n < range; n += step ) {
wxCoord x = x1 + (len*n) / range;
- DrawLine(dc, x, y1, x, y2, orient == wxVERTICAL);
+ if (left & (y1 > y3)) {
+ DrawLine(dc, x, y1, x, y3, orient == wxVERTICAL);
+ }
+ if (right & (y4 > y2)) {
+ DrawLine(dc, x, y2, x, y4, orient == wxVERTICAL);
+ }
}
-
// always draw the line at the end position
- DrawLine(dc, x2, y1, x2, y2, orient == wxVERTICAL);
+ if (left & (y1 > y3)) {
+ DrawLine(dc, x2, y1, x2, y3, orient == wxVERTICAL);
+ }
+ if (right & (y4 > y2)) {
+ DrawLine(dc, x2, y2, x2, y4, orient == wxVERTICAL);
+ }
}
// ----------------------------------------------------------------------------
// menu and menubar
// ----------------------------------------------------------------------------
-#if wxUSE_MENUS
-
// wxWin32MenuGeometryInfo: the wxMenuGeometryInfo used by wxWin32Renderer
class WXDLLEXPORT wxWin32MenuGeometryInfo : public wxMenuGeometryInfo
{
// the height of a normal (not separator) item
wxCoord m_heightItem;
- friend wxMenuGeometryInfo *wxWin32Renderer::
- GetMenuGeometry(wxWindow *, const wxMenu&) const;
+ friend wxMenuGeometryInfo *
+ wxWin32Renderer::GetMenuGeometry(wxWindow *, const wxMenu&) const;
};
-#endif // wxUSE_MENUS
-
// FIXME: all constants are hardcoded but shouldn't be
static const wxCoord MENU_LEFT_MARGIN = 9;
static const wxCoord MENU_RIGHT_MARGIN = 18;
// the size of the standard checkmark bitmap
static const wxCoord MENU_CHECK_SIZE = 9;
-// we can't implement these methods without wxMenuGeometryInfo implementation
-// which we don't have if !wxUSE_MENUS
-#if wxUSE_MENUS
-
void wxWin32Renderer::DrawMenuBarItem(wxDC& dc,
const wxRect& rectOrig,
const wxString& label,
{
// prepare the dc: for now we draw all the items with the system font
wxClientDC dc(win);
- dc.SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
+ dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
// the height of a normal item
wxCoord heightText = dc.GetCharHeight();
widthAccelMax = 0,
widthBmpMax = MENU_LEFT_MARGIN;
- for ( wxMenuItemList::Node *node = menu.GetMenuItems().GetFirst();
+ for ( wxMenuItemList::compatibility_iterator node = menu.GetMenuItems().GetFirst();
node;
node = node->GetNext() )
{
return gi;
}
-#else // !wxUSE_MENUS
+// ----------------------------------------------------------------------------
+// status bar
+// ----------------------------------------------------------------------------
-/*
-void wxWin32Renderer::DrawMenuBarItem(wxDC& WXUNUSED(dc),
- const wxRect& WXUNUSED(rectOrig),
- const wxString& WXUNUSED(label),
- int WXUNUSED(flags),
- int WXUNUSED(indexAccel))
-{
-}
+static const wxCoord STATBAR_BORDER_X = 2;
+static const wxCoord STATBAR_BORDER_Y = 2;
-void wxWin32Renderer::DrawMenuItem(wxDC& WXUNUSED(dc),
- wxCoord WXUNUSED(y),
- const wxMenuGeometryInfo& WXUNUSED(gi),
- const wxString& WXUNUSED(label),
- const wxString& WXUNUSED(accel),
- const wxBitmap& WXUNUSED(bitmap),
- int WXUNUSED(flags),
- int WXUNUSED(indexAccel))
+wxSize wxWin32Renderer::GetStatusBarBorders(wxCoord *borderBetweenFields) const
{
-}
+ if ( borderBetweenFields )
+ *borderBetweenFields = 2;
-void wxWin32Renderer::DrawMenuSeparator(wxDC& WXUNUSED(dc),
- wxCoord WXUNUSED(y),
- const wxMenuGeometryInfo& WXUNUSED(gi))
-{
+ return wxSize(STATBAR_BORDER_X, STATBAR_BORDER_Y);
}
-wxSize wxWin32Renderer::GetMenuBarItemSize(const wxSize& size) const
+void wxWin32Renderer::DrawStatusField(wxDC& dc,
+ const wxRect& rect,
+ const wxString& label,
+ int flags)
{
- return size;
-}
+ wxRect rectIn;
-wxMenuGeometryInfo *
-wxWin32Renderer::GetMenuGeometry(wxWindow *WXUNUSED(win),
- const wxMenu& WXUNUSED(menu)) const
-{
- return NULL;
-}
-*/
+ if ( flags & wxCONTROL_ISDEFAULT )
+ {
+ // draw the size grip: it is a normal rect except that in the lower
+ // right corner we have several bands which may be used for dragging
+ // the status bar corner
+ //
+ // each band consists of 4 stripes: m_penHighlight, double
+ // m_penDarkGrey and transparent one
+ wxCoord x2 = rect.GetRight(),
+ y2 = rect.GetBottom();
+
+ // draw the upper left part of the rect normally
+ dc.SetPen(m_penDarkGrey);
+ dc.DrawLine(rect.GetLeft(), rect.GetTop(), rect.GetLeft(), y2);
+ dc.DrawLine(rect.GetLeft() + 1, rect.GetTop(), x2, rect.GetTop());
+
+ // draw the grey stripes of the grip
+ size_t n;
+ wxCoord ofs = WIDTH_STATUSBAR_GRIP_BAND - 1;
+ for ( n = 0; n < NUM_STATUSBAR_GRIP_BANDS; n++, ofs += WIDTH_STATUSBAR_GRIP_BAND )
+ {
+ dc.DrawLine(x2 - ofs + 1, y2 - 1, x2, y2 - ofs);
+ dc.DrawLine(x2 - ofs, y2 - 1, x2, y2 - ofs - 1);
+ }
+
+ // draw the white stripes
+ dc.SetPen(m_penHighlight);
+ ofs = WIDTH_STATUSBAR_GRIP_BAND + 1;
+ for ( n = 0; n < NUM_STATUSBAR_GRIP_BANDS; n++, ofs += WIDTH_STATUSBAR_GRIP_BAND )
+ {
+ dc.DrawLine(x2 - ofs + 1, y2 - 1, x2, y2 - ofs);
+ }
+
+ // draw the remaining rect boundaries
+ ofs -= WIDTH_STATUSBAR_GRIP_BAND;
+ dc.DrawLine(x2, rect.GetTop(), x2, y2 - ofs + 1);
+ dc.DrawLine(rect.GetLeft(), y2, x2 - ofs + 1, y2);
+
+ rectIn = rect;
+ rectIn.Deflate(1);
+
+ rectIn.width -= STATUSBAR_GRIP_SIZE;
+ }
+ else // normal pane
+ {
+ DrawBorder(dc, wxBORDER_STATIC, rect, flags, &rectIn);
+ }
-#endif // wxUSE_MENUS/!wxUSE_MENUS
+ rectIn.Deflate(STATBAR_BORDER_X, STATBAR_BORDER_Y);
+
+ wxDCClipper clipper(dc, rectIn);
+ DrawLabel(dc, label, rectIn, flags, wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL);
+}
// ----------------------------------------------------------------------------
// combobox
// ----------------------------------------------------------------------------
void wxWin32Renderer::GetComboBitmaps(wxBitmap *bmpNormal,
- wxBitmap *bmpFocus,
+ wxBitmap * WXUNUSED(bmpFocus),
wxBitmap *bmpPressed,
wxBitmap *bmpDisabled)
{
void wxWin32Renderer::DoDrawBackground(wxDC& dc,
const wxColour& col,
- const wxRect& rect)
+ const wxRect& rect,
+ wxWindow * WXUNUSED(window))
{
wxBrush brush(col, wxSOLID);
dc.SetBrush(brush);
void wxWin32Renderer::DrawBackground(wxDC& dc,
const wxColour& col,
const wxRect& rect,
- int flags)
+ int WXUNUSED(flags),
+ wxWindow *window)
{
// just fill it with the given or default bg colour
wxColour colBg = col.Ok() ? col : wxSCHEME_COLOUR(m_scheme, CONTROL);
- DoDrawBackground(dc, colBg, rect);
+ DoDrawBackground(dc, colBg, rect, window );
}
// ----------------------------------------------------------------------------
}
void wxWin32Renderer::DrawScrollbarThumb(wxDC& dc,
- wxOrientation orient,
+ wxOrientation WXUNUSED(orient),
const wxRect& rect,
- int flags)
+ int WXUNUSED(flags))
{
// we don't use the flags, the thumb never changes appearance
wxRect rectThumb = rect;
}
void wxWin32Renderer::DrawScrollbarShaft(wxDC& dc,
- wxOrientation orient,
+ wxOrientation WXUNUSED(orient),
const wxRect& rectBar,
int flags)
{
// top level windows
// ----------------------------------------------------------------------------
+int wxWin32Renderer::HitTestFrame(const wxRect& rect, const wxPoint& pt, int flags) const
+{
+ wxRect client = GetFrameClientArea(rect, flags);
+
+ if ( client.Inside(pt) )
+ return wxHT_TOPLEVEL_CLIENT_AREA;
+
+ if ( flags & wxTOPLEVEL_TITLEBAR )
+ {
+ wxRect client = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
+
+ if ( flags & wxTOPLEVEL_ICON )
+ {
+ if ( wxRect(client.GetPosition(), GetFrameIconSize()).Inside(pt) )
+ return wxHT_TOPLEVEL_ICON;
+ }
+
+ wxRect btnRect(client.GetRight() - 2 - FRAME_BUTTON_WIDTH,
+ client.GetTop() + (FRAME_TITLEBAR_HEIGHT-FRAME_BUTTON_HEIGHT)/2,
+ FRAME_BUTTON_WIDTH, FRAME_BUTTON_HEIGHT);
+
+ if ( flags & wxTOPLEVEL_BUTTON_CLOSE )
+ {
+ if ( btnRect.Inside(pt) )
+ return wxHT_TOPLEVEL_BUTTON_CLOSE;
+ btnRect.x -= FRAME_BUTTON_WIDTH + 2;
+ }
+ if ( flags & wxTOPLEVEL_BUTTON_MAXIMIZE )
+ {
+ if ( btnRect.Inside(pt) )
+ return wxHT_TOPLEVEL_BUTTON_MAXIMIZE;
+ btnRect.x -= FRAME_BUTTON_WIDTH;
+ }
+ if ( flags & wxTOPLEVEL_BUTTON_RESTORE )
+ {
+ if ( btnRect.Inside(pt) )
+ return wxHT_TOPLEVEL_BUTTON_RESTORE;
+ btnRect.x -= FRAME_BUTTON_WIDTH;
+ }
+ if ( flags & wxTOPLEVEL_BUTTON_ICONIZE )
+ {
+ if ( btnRect.Inside(pt) )
+ return wxHT_TOPLEVEL_BUTTON_ICONIZE;
+ btnRect.x -= FRAME_BUTTON_WIDTH;
+ }
+ if ( flags & wxTOPLEVEL_BUTTON_HELP )
+ {
+ if ( btnRect.Inside(pt) )
+ return wxHT_TOPLEVEL_BUTTON_HELP;
+ btnRect.x -= FRAME_BUTTON_WIDTH;
+ }
+
+ if ( pt.y >= client.y && pt.y < client.y + FRAME_TITLEBAR_HEIGHT )
+ return wxHT_TOPLEVEL_TITLEBAR;
+ }
+
+ if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
+ {
+ // we are certainly at one of borders, lets decide which one:
+
+ int border = 0;
+ // dirty trick, relies on the way wxHT_TOPLEVEL_XXX are defined!
+ if ( pt.x < client.x )
+ border |= wxHT_TOPLEVEL_BORDER_W;
+ else if ( pt.x >= client.width + client.x )
+ border |= wxHT_TOPLEVEL_BORDER_E;
+ if ( pt.y < client.y )
+ border |= wxHT_TOPLEVEL_BORDER_N;
+ else if ( pt.y >= client.height + client.y )
+ border |= wxHT_TOPLEVEL_BORDER_S;
+ return border;
+ }
+
+ return wxHT_NOWHERE;
+}
+
void wxWin32Renderer::DrawFrameTitleBar(wxDC& dc,
const wxRect& rect,
const wxString& title,
const wxIcon& icon,
int flags,
- int pressedButtons = 0)
+ int specialButton,
+ int specialButtonFlags)
{
if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
{
if ( flags & wxTOPLEVEL_ICON )
DrawFrameIcon(dc, rect, icon, flags);
DrawFrameTitle(dc, rect, title, flags);
-
+
wxRect client = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
wxCoord x,y;
- x = client.GetRight() -2 - FRAME_BUTTON_WIDTH;
+ x = client.GetRight() - 2 - FRAME_BUTTON_WIDTH;
y = client.GetTop() + (FRAME_TITLEBAR_HEIGHT-FRAME_BUTTON_HEIGHT)/2;
-
- if ( flags & wxTOPLEVEL_CLOSE_BUTTON )
+
+ if ( flags & wxTOPLEVEL_BUTTON_CLOSE )
{
- DrawFrameButton(dc, x, y, wxTOPLEVEL_CLOSE_BUTTON);
+ DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_CLOSE,
+ (specialButton == wxTOPLEVEL_BUTTON_CLOSE) ?
+ specialButtonFlags : 0);
x -= FRAME_BUTTON_WIDTH + 2;
}
- if ( flags & wxTOPLEVEL_MAXIMIZE_BUTTON )
+ if ( flags & wxTOPLEVEL_BUTTON_MAXIMIZE )
{
- DrawFrameButton(dc, x, y, wxTOPLEVEL_MAXIMIZE_BUTTON);
+ DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_MAXIMIZE,
+ (specialButton == wxTOPLEVEL_BUTTON_MAXIMIZE) ?
+ specialButtonFlags : 0);
x -= FRAME_BUTTON_WIDTH;
}
- if ( flags & wxTOPLEVEL_RESTORE_BUTTON )
+ if ( flags & wxTOPLEVEL_BUTTON_RESTORE )
{
- DrawFrameButton(dc, x, y, wxTOPLEVEL_RESTORE_BUTTON);
+ DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_RESTORE,
+ (specialButton == wxTOPLEVEL_BUTTON_RESTORE) ?
+ specialButtonFlags : 0);
x -= FRAME_BUTTON_WIDTH;
}
- if ( flags & wxTOPLEVEL_MINIMIZE_BUTTON )
+ if ( flags & wxTOPLEVEL_BUTTON_ICONIZE )
{
- DrawFrameButton(dc, x, y, wxTOPLEVEL_MINIMIZE_BUTTON);
+ DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_ICONIZE,
+ (specialButton == wxTOPLEVEL_BUTTON_ICONIZE) ?
+ specialButtonFlags : 0);
x -= FRAME_BUTTON_WIDTH;
}
- if ( flags & wxTOPLEVEL_HELP_BUTTON )
+ if ( flags & wxTOPLEVEL_BUTTON_HELP )
{
- DrawFrameButton(dc, x, y, wxTOPLEVEL_HELP_BUTTON);
+ DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_HELP,
+ (specialButton == wxTOPLEVEL_BUTTON_HELP) ?
+ specialButtonFlags : 0);
x -= FRAME_BUTTON_WIDTH;
}
}
int flags)
{
if ( !(flags & wxTOPLEVEL_BORDER) ) return;
-
+
wxRect r(rect);
-
+
DrawShadedRect(dc, &r, m_penLightGrey, m_penBlack);
DrawShadedRect(dc, &r, m_penHighlight, m_penDarkGrey);
DrawShadedRect(dc, &r, m_penLightGrey, m_penLightGrey);
{
if ( !(flags & wxTOPLEVEL_TITLEBAR) ) return;
- wxColour col = (flags & wxTOPLEVEL_ACTIVE) ?
+ wxColour col = (flags & wxTOPLEVEL_ACTIVE) ?
wxSCHEME_COLOUR(m_scheme, TITLEBAR_ACTIVE) :
wxSCHEME_COLOUR(m_scheme, TITLEBAR);
wxRect r = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
r.height = FRAME_TITLEBAR_HEIGHT;
-
+
DrawBackground(dc, col, r);
}
const wxString& title,
int flags)
{
+ wxColour col = (flags & wxTOPLEVEL_ACTIVE) ?
+ wxSCHEME_COLOUR(m_scheme, TITLEBAR_ACTIVE_TEXT) :
+ wxSCHEME_COLOUR(m_scheme, TITLEBAR_TEXT);
+
wxRect r = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
r.height = FRAME_TITLEBAR_HEIGHT;
if ( flags & wxTOPLEVEL_ICON )
+ {
r.x += FRAME_TITLEBAR_HEIGHT;
+ r.width -= FRAME_TITLEBAR_HEIGHT + 2;
+ }
else
+ {
r.x += 1;
-
+ r.width -= 3;
+ }
+
+ if ( flags & wxTOPLEVEL_BUTTON_CLOSE )
+ r.width -= FRAME_BUTTON_WIDTH + 2;
+ if ( flags & wxTOPLEVEL_BUTTON_MAXIMIZE )
+ r.width -= FRAME_BUTTON_WIDTH;
+ if ( flags & wxTOPLEVEL_BUTTON_RESTORE )
+ r.width -= FRAME_BUTTON_WIDTH;
+ if ( flags & wxTOPLEVEL_BUTTON_ICONIZE )
+ r.width -= FRAME_BUTTON_WIDTH;
+ if ( flags & wxTOPLEVEL_BUTTON_HELP )
+ r.width -= FRAME_BUTTON_WIDTH;
+
dc.SetFont(m_titlebarFont);
- dc.SetTextForeground(wxSCHEME_COLOUR(m_scheme, TITLEBAR_TEXT));
- dc.DrawLabel(title, wxNullBitmap, r, wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL);
+ dc.SetTextForeground(col);
+
+ wxCoord textW;
+ dc.GetTextExtent(title, &textW, NULL);
+ if ( textW > r.width )
+ {
+ // text is too big, let's shorten it and add "..." after it:
+ size_t len = title.length();
+ wxCoord WSoFar, letterW;
+
+ dc.GetTextExtent(wxT("..."), &WSoFar, NULL);
+ if ( WSoFar > r.width )
+ {
+ // not enough space to draw anything
+ return;
+ }
+
+ wxString s;
+ s.Alloc(len);
+ for (size_t i = 0; i < len; i++)
+ {
+ dc.GetTextExtent(title[i], &letterW, NULL);
+ if ( letterW + WSoFar > r.width )
+ break;
+ WSoFar += letterW;
+ s << title[i];
+ }
+ s << wxT("...");
+ dc.DrawLabel(s, wxNullBitmap, r,
+ wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL);
+ }
+ else
+ dc.DrawLabel(title, wxNullBitmap, r,
+ wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL);
}
void wxWin32Renderer::DrawFrameIcon(wxDC& dc,
const wxIcon& icon,
int flags)
{
- wxRect r = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
- dc.DrawIcon(icon, r.x, r.y);
+ if ( icon.Ok() )
+ {
+ wxRect r = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
+ dc.DrawIcon(icon, r.x, r.y);
+ }
}
void wxWin32Renderer::DrawFrameButton(wxDC& dc,
wxCoord x, wxCoord y,
int button,
- int flags = 0)
+ int flags)
{
wxRect r(x, y, FRAME_BUTTON_WIDTH, FRAME_BUTTON_HEIGHT);
-
- DrawShadedRect(dc, &r, m_penHighlight, m_penBlack);
- DrawShadedRect(dc, &r, m_penLightGrey, m_penDarkGrey);
- DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), r);
-
+
size_t idx = 0;
switch (button)
{
- case wxTOPLEVEL_CLOSE_BUTTON: idx = FrameButton_Close; break;
- case wxTOPLEVEL_MAXIMIZE_BUTTON: idx = FrameButton_Maximize; break;
- case wxTOPLEVEL_MINIMIZE_BUTTON: idx = FrameButton_Minimize; break;
- case wxTOPLEVEL_RESTORE_BUTTON: idx = FrameButton_Restore; break;
- case wxTOPLEVEL_HELP_BUTTON: idx = FrameButton_Help; break;
+ case wxTOPLEVEL_BUTTON_CLOSE: idx = FrameButton_Close; break;
+ case wxTOPLEVEL_BUTTON_MAXIMIZE: idx = FrameButton_Maximize; break;
+ case wxTOPLEVEL_BUTTON_ICONIZE: idx = FrameButton_Minimize; break;
+ case wxTOPLEVEL_BUTTON_RESTORE: idx = FrameButton_Restore; break;
+ case wxTOPLEVEL_BUTTON_HELP: idx = FrameButton_Help; break;
default:
wxFAIL_MSG(wxT("incorrect button specification"));
}
-
- dc.DrawBitmap(m_bmpFrameButtons[idx], r.x, r.y, TRUE);
+
+ if ( flags & wxCONTROL_PRESSED )
+ {
+ DrawShadedRect(dc, &r, m_penBlack, m_penHighlight);
+ DrawShadedRect(dc, &r, m_penDarkGrey, m_penLightGrey);
+ DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), r);
+ dc.DrawBitmap(m_bmpFrameButtons[idx], r.x+1, r.y+1, TRUE);
+ }
+ else
+ {
+ DrawShadedRect(dc, &r, m_penHighlight, m_penBlack);
+ DrawShadedRect(dc, &r, m_penLightGrey, m_penDarkGrey);
+ DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), r);
+ dc.DrawBitmap(m_bmpFrameButtons[idx], r.x, r.y, TRUE);
+ }
}
if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
{
- int border = (flags & wxTOPLEVEL_RESIZEABLE) ?
+ int border = (flags & wxTOPLEVEL_RESIZEABLE) ?
RESIZEABLE_FRAME_BORDER_THICKNESS :
FRAME_BORDER_THICKNESS;
r.Inflate(-border);
if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
{
- int border = (flags & wxTOPLEVEL_RESIZEABLE) ?
+ int border = (flags & wxTOPLEVEL_RESIZEABLE) ?
+ RESIZEABLE_FRAME_BORDER_THICKNESS :
+ FRAME_BORDER_THICKNESS;
+ s.x += 2*border;
+ s.y += 2*border;
+ }
+ if ( flags & wxTOPLEVEL_TITLEBAR )
+ s.y += FRAME_TITLEBAR_HEIGHT;
+
+ return s;
+}
+
+wxSize wxWin32Renderer::GetFrameMinSize(int flags) const
+{
+ wxSize s(0, 0);
+
+ if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
+ {
+ int border = (flags & wxTOPLEVEL_RESIZEABLE) ?
RESIZEABLE_FRAME_BORDER_THICKNESS :
FRAME_BORDER_THICKNESS;
s.x += 2*border;
s.y += 2*border;
}
+
if ( flags & wxTOPLEVEL_TITLEBAR )
+ {
s.y += FRAME_TITLEBAR_HEIGHT;
+ if ( flags & wxTOPLEVEL_ICON )
+ s.x += FRAME_TITLEBAR_HEIGHT + 2;
+ if ( flags & wxTOPLEVEL_BUTTON_CLOSE )
+ s.x += FRAME_BUTTON_WIDTH + 2;
+ if ( flags & wxTOPLEVEL_BUTTON_MAXIMIZE )
+ s.x += FRAME_BUTTON_WIDTH;
+ if ( flags & wxTOPLEVEL_BUTTON_RESTORE )
+ s.x += FRAME_BUTTON_WIDTH;
+ if ( flags & wxTOPLEVEL_BUTTON_ICONIZE )
+ s.x += FRAME_BUTTON_WIDTH;
+ if ( flags & wxTOPLEVEL_BUTTON_HELP )
+ s.x += FRAME_BUTTON_WIDTH;
+ }
+
return s;
}
}
+// ----------------------------------------------------------------------------
+// standard icons
+// ----------------------------------------------------------------------------
+
+static char *error_xpm[]={
+"32 32 5 1",
+". c None",
+"# c #800000",
+"b c #808080",
+"a c #ff0000",
+"c c #ffffff",
+"...........########.............",
+"........###aaaaaaaa###..........",
+".......#aaaaaaaaaaaaaa#.........",
+".....##aaaaaaaaaaaaaaaa##.......",
+"....#aaaaaaaaaaaaaaaaaaaa#......",
+"...#aaaaaaaaaaaaaaaaaaaaaa#.....",
+"...#aaaaaaaaaaaaaaaaaaaaaa#b....",
+"..#aaaaaacaaaaaaaaaacaaaaaa#b...",
+".#aaaaaacccaaaaaaaacccaaaaaa#...",
+".#aaaaacccccaaaaaacccccaaaaa#b..",
+".#aaaaaacccccaaaacccccaaaaaa#bb.",
+"#aaaaaaaacccccaacccccaaaaaaaa#b.",
+"#aaaaaaaaaccccccccccaaaaaaaaa#b.",
+"#aaaaaaaaaaccccccccaaaaaaaaaa#bb",
+"#aaaaaaaaaaaccccccaaaaaaaaaaa#bb",
+"#aaaaaaaaaaaccccccaaaaaaaaaaa#bb",
+"#aaaaaaaaaaccccccccaaaaaaaaaa#bb",
+"#aaaaaaaaaccccccccccaaaaaaaaa#bb",
+"#aaaaaaaacccccaacccccaaaaaaaa#bb",
+".#aaaaaacccccaaaacccccaaaaaa#bbb",
+".#aaaaacccccaaaaaacccccaaaaa#bbb",
+".#aaaaaacccaaaaaaaacccaaaaaa#bb.",
+"..#aaaaaacaaaaaaaaaacaaaaaa#bbb.",
+"...#aaaaaaaaaaaaaaaaaaaaaa#bbbb.",
+"...#aaaaaaaaaaaaaaaaaaaaaa#bbb..",
+"....#aaaaaaaaaaaaaaaaaaaa#bbb...",
+".....##aaaaaaaaaaaaaaaa##bbbb...",
+"......b#aaaaaaaaaaaaaa#bbbbb....",
+".......b###aaaaaaaa###bbbbb.....",
+".........bb########bbbbbb.......",
+"..........bbbbbbbbbbbbbb........",
+".............bbbbbbbb..........."};
+
+static char *info_xpm[]={
+"32 32 6 1",
+". c None",
+"d c #000000",
+"c c #0000ff",
+"# c #808080",
+"a c #c0c0c0",
+"b c #ffffff",
+"...........########.............",
+"........###abbbbbba###..........",
+"......##abbbbbbbbbbbba##........",
+".....#abbbbbbbbbbbbbbbba#.......",
+"....#bbbbbbbaccccabbbbbbbd......",
+"...#bbbbbbbbccccccbbbbbbbbd.....",
+"..#bbbbbbbbbccccccbbbbbbbbbd....",
+".#abbbbbbbbbaccccabbbbbbbbbad...",
+".#bbbbbbbbbbbbbbbbbbbbbbbbbbd#..",
+"#abbbbbbbbbbbbbbbbbbbbbbbbbbad#.",
+"#bbbbbbbbbbcccccccbbbbbbbbbbbd#.",
+"#bbbbbbbbbbbbcccccbbbbbbbbbbbd##",
+"#bbbbbbbbbbbbcccccbbbbbbbbbbbd##",
+"#bbbbbbbbbbbbcccccbbbbbbbbbbbd##",
+"#bbbbbbbbbbbbcccccbbbbbbbbbbbd##",
+"#abbbbbbbbbbbcccccbbbbbbbbbbad##",
+".#bbbbbbbbbbbcccccbbbbbbbbbbd###",
+".#abbbbbbbbbbcccccbbbbbbbbbad###",
+"..#bbbbbbbbcccccccccbbbbbbbd###.",
+"...dbbbbbbbbbbbbbbbbbbbbbbd####.",
+"....dbbbbbbbbbbbbbbbbbbbbd####..",
+".....dabbbbbbbbbbbbbbbbad####...",
+"......ddabbbbbbbbbbbbadd####....",
+".......#dddabbbbbbaddd#####.....",
+"........###dddabbbd#######......",
+"..........####dbbbd#####........",
+".............#dbbbd##...........",
+"...............dbbd##...........",
+"................dbd##...........",
+".................dd##...........",
+"..................###...........",
+"...................##..........."};
+
+static char *question_xpm[]={
+"32 32 6 1",
+". c None",
+"c c #000000",
+"d c #0000ff",
+"# c #808080",
+"a c #c0c0c0",
+"b c #ffffff",
+"...........########.............",
+"........###abbbbbba###..........",
+"......##abbbbbbbbbbbba##........",
+".....#abbbbbbbbbbbbbbbba#.......",
+"....#bbbbbbbbbbbbbbbbbbbbc......",
+"...#bbbbbbbaddddddabbbbbbbc.....",
+"..#bbbbbbbadabbddddabbbbbbbc....",
+".#abbbbbbbddbbbbddddbbbbbbbac...",
+".#bbbbbbbbddddbbddddbbbbbbbbc#..",
+"#abbbbbbbbddddbaddddbbbbbbbbac#.",
+"#bbbbbbbbbaddabddddbbbbbbbbbbc#.",
+"#bbbbbbbbbbbbbadddbbbbbbbbbbbc##",
+"#bbbbbbbbbbbbbdddbbbbbbbbbbbbc##",
+"#bbbbbbbbbbbbbddabbbbbbbbbbbbc##",
+"#bbbbbbbbbbbbbddbbbbbbbbbbbbbc##",
+"#abbbbbbbbbbbbbbbbbbbbbbbbbbac##",
+".#bbbbbbbbbbbaddabbbbbbbbbbbc###",
+".#abbbbbbbbbbddddbbbbbbbbbbac###",
+"..#bbbbbbbbbbddddbbbbbbbbbbc###.",
+"...cbbbbbbbbbaddabbbbbbbbbc####.",
+"....cbbbbbbbbbbbbbbbbbbbbc####..",
+".....cabbbbbbbbbbbbbbbbac####...",
+"......ccabbbbbbbbbbbbacc####....",
+".......#cccabbbbbbaccc#####.....",
+"........###cccabbbc#######......",
+"..........####cbbbc#####........",
+".............#cbbbc##...........",
+"...............cbbc##...........",
+"................cbc##...........",
+".................cc##...........",
+"..................###...........",
+"...................##..........."};
+
+static char *warning_xpm[]={
+"32 32 6 1",
+". c None",
+"c c #000000",
+"# c #808000",
+"d c #808080",
+"b c #c0c0c0",
+"a c #ffff00",
+".............###................",
+"............#aabc...............",
+"...........#aaaabcd.............",
+"...........#aaaaacdd............",
+"..........#aaaaaabcdd...........",
+"..........#aaaaaaacdd...........",
+".........#aaaaaaaabcdd..........",
+".........#aaaaaaaaacdd..........",
+"........#aaaaaaaaaabcdd.........",
+"........#aaabcccbaaacdd.........",
+".......#aaaacccccaaabcdd........",
+".......#aaaacccccaaaacdd........",
+"......#aaaaacccccaaaabcdd.......",
+"......#aaaaacccccaaaaacdd.......",
+".....#aaaaaacccccaaaaabcdd......",
+".....#aaaaaa#ccc#aaaaaacdd......",
+"....#aaaaaaabcccbaaaaaabcdd.....",
+"....#aaaaaaaacccaaaaaaaacdd.....",
+"...#aaaaaaaaa#c#aaaaaaaabcdd....",
+"...#aaaaaaaaabcbaaaaaaaaacdd....",
+"..#aaaaaaaaaaacaaaaaaaaaabcdd...",
+"..#aaaaaaaaaaaaaaaaaaaaaaacdd...",
+".#aaaaaaaaaaabccbaaaaaaaaabcdd..",
+".#aaaaaaaaaaaccccaaaaaaaaaacdd..",
+"#aaaaaaaaaaaaccccaaaaaaaaaabcdd.",
+"#aaaaaaaaaaaabccbaaaaaaaaaaacdd.",
+"#aaaaaaaaaaaaaaaaaaaaaaaaaaacddd",
+"#aaaaaaaaaaaaaaaaaaaaaaaaaabcddd",
+".#aaaaaaaaaaaaaaaaaaaaaaaabcdddd",
+"..#ccccccccccccccccccccccccddddd",
+"....ddddddddddddddddddddddddddd.",
+".....ddddddddddddddddddddddddd.."};
+
+wxBitmap wxWin32ArtProvider::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;
+}
+
// ----------------------------------------------------------------------------
// text control geometry
return 1;
}
-wxRect wxWin32Renderer::GetTextTotalArea(const wxTextCtrl *text,
- const wxRect& rect)
+wxRect
+wxWin32Renderer::GetTextTotalArea(const wxTextCtrl * WXUNUSED(text),
+ const wxRect& rect) const
{
wxRect rectTotal = rect;
return rectTotal;
}
-wxRect wxWin32Renderer::GetTextClientArea(const wxTextCtrl *text,
- const wxRect& rect,
- wxCoord *extraSpaceBeyond)
+wxRect
+wxWin32Renderer::GetTextClientArea(const wxTextCtrl * WXUNUSED(text),
+ const wxRect& rect,
+ wxCoord *extraSpaceBeyond) const
{
wxRect rectText = rect;
size->y += 9;
}
+ // for compatibility with other ports, the buttons default size is never
+ // less than the standard one, but not when display not PDAs.
+ if (wxSystemSettings::GetScreenType() > wxSYS_SCREEN_PDA)
+ {
+ if ( !(window->GetWindowStyle() & wxBU_EXACTFIT) )
+ {
+ wxSize szDef = wxButton::GetDefaultSize();
+ if ( size->x < szDef.x )
+ size->x = szDef.x;
+ }
+ }
+
// no border width adjustments for buttons
return;
}
m_renderer = renderer;
}
-bool wxWin32InputHandler::HandleKey(wxInputConsumer *control,
- const wxKeyEvent& event,
- bool pressed)
+bool wxWin32InputHandler::HandleKey(wxInputConsumer * WXUNUSED(control),
+ const wxKeyEvent& WXUNUSED(event),
+ bool WXUNUSED(pressed))
{
return FALSE;
}
const wxMouseEvent& event)
{
// clicking on the control gives it focus
- if ( event.ButtonDown() && wxWindow::FindFocus() != control->GetInputWindow() )
+ if ( event.ButtonDown() )
{
- control->GetInputWindow()->SetFocus();
+ wxWindow *win = control->GetInputWindow();
- return TRUE;
+ if (( wxWindow::FindFocus() != control->GetInputWindow() ) &&
+ ( win->AcceptsFocus() ) )
+ {
+ win->SetFocus();
+
+ return TRUE;
+ }
}
return FALSE;
// if we're scrolling the scrollbar because the arrow or the shaft was
// pressed, check that the mouse stays on the same scrollbar element
+#if 0
+ // Always let thumb jump back if we leave the scrollbar
if ( event.Moving() )
{
ht = m_renderer->HitTestScrollbar(scrollbar, event.GetPosition());
{
ht = wxHT_NOWHERE;
}
+#else
+ // Jump back only if we get far away from it
+ wxPoint pos = event.GetPosition();
+ if (scrollbar->HasFlag( wxVERTICAL ))
+ {
+ if (pos.x > -40 && pos.x < scrollbar->GetSize().x+40)
+ pos.x = 5;
+ }
+ else
+ {
+ if (pos.y > -40 && pos.y < scrollbar->GetSize().y+40)
+ pos.y = 5;
+ }
+ ht = m_renderer->HitTestScrollbar(scrollbar, pos );
+#endif
// if we're dragging the thumb and the mouse stays in the scrollbar, it
// is still ok - we only want to catch the case when the mouse leaves
return wxStdTextCtrlInputHandler::HandleKey(control, event, pressed);
}
+// ----------------------------------------------------------------------------
+// wxWin32StatusBarInputHandler
+// ----------------------------------------------------------------------------
+
+wxWin32StatusBarInputHandler::
+wxWin32StatusBarInputHandler(wxInputHandler *handler)
+ : wxStdInputHandler(handler)
+{
+ m_isOnGrip = FALSE;
+}
+
+bool wxWin32StatusBarInputHandler::IsOnGrip(wxWindow *statbar,
+ const wxPoint& pt) const
+{
+ if ( statbar->HasFlag(wxST_SIZEGRIP) &&
+ statbar->GetParent()->HasFlag(wxRESIZE_BORDER) )
+ {
+ wxTopLevelWindow *
+ parentTLW = wxDynamicCast(statbar->GetParent(), wxTopLevelWindow);
+
+ wxCHECK_MSG( parentTLW, FALSE,
+ _T("the status bar should be a child of a TLW") );
+
+ // a maximized window can't be resized anyhow
+ if ( !parentTLW->IsMaximized() )
+ {
+ // VZ: I think that the standard Windows behaviour is to only
+ // show the resizing cursor when the mouse is on top of the
+ // grip itself but apparently different Windows versions behave
+ // differently (?) and it seems a better UI to allow resizing
+ // the status bar even when the mouse is above the grip
+ wxSize sizeSbar = statbar->GetSize();
+
+ int diff = sizeSbar.x - pt.x;
+ return diff >= 0 && diff < (wxCoord)STATUSBAR_GRIP_SIZE;
+ }
+ }
+
+ return FALSE;
+}
+
+bool wxWin32StatusBarInputHandler::HandleMouse(wxInputConsumer *consumer,
+ const wxMouseEvent& event)
+{
+ if ( event.Button(1) )
+ {
+ if ( event.ButtonDown(1) )
+ {
+ wxWindow *statbar = consumer->GetInputWindow();
+
+ if ( IsOnGrip(statbar, event.GetPosition()) )
+ {
+ wxTopLevelWindow *tlw = wxDynamicCast(statbar->GetParent(),
+ wxTopLevelWindow);
+ if ( tlw )
+ {
+ tlw->PerformAction(wxACTION_TOPLEVEL_RESIZE,
+ wxHT_TOPLEVEL_BORDER_SE);
+
+ statbar->SetCursor(m_cursorOld);
+
+ return TRUE;
+ }
+ }
+ }
+ }
+
+ return wxStdInputHandler::HandleMouse(consumer, event);
+}
+
+bool wxWin32StatusBarInputHandler::HandleMouseMove(wxInputConsumer *consumer,
+ const wxMouseEvent& event)
+{
+ wxWindow *statbar = consumer->GetInputWindow();
+
+ bool isOnGrip = IsOnGrip(statbar, event.GetPosition());
+ if ( isOnGrip != m_isOnGrip )
+ {
+ m_isOnGrip = isOnGrip;
+ if ( isOnGrip )
+ {
+ m_cursorOld = statbar->GetCursor();
+ statbar->SetCursor(wxCURSOR_SIZENWSE);
+ }
+ else
+ {
+ statbar->SetCursor(m_cursorOld);
+ }
+ }
+
+ return wxStdInputHandler::HandleMouseMove(consumer, event);
+}
+
+// ----------------------------------------------------------------------------
+// wxWin32FrameInputHandler
+// ----------------------------------------------------------------------------
+
+class wxWin32SystemMenuEvtHandler : public wxEvtHandler
+{
+public:
+ wxWin32SystemMenuEvtHandler(wxWin32FrameInputHandler *handler);
+
+ void Attach(wxInputConsumer *consumer);
+ void Detach();
+
+private:
+ DECLARE_EVENT_TABLE()
+ void OnSystemMenu(wxCommandEvent &event);
+ void OnCloseFrame(wxCommandEvent &event);
+ void OnClose(wxCloseEvent &event);
+
+ wxWin32FrameInputHandler *m_inputHnd;
+ wxTopLevelWindow *m_wnd;
+ wxAcceleratorTable m_oldAccelTable;
+};
+
+wxWin32SystemMenuEvtHandler::wxWin32SystemMenuEvtHandler(
+ wxWin32FrameInputHandler *handler)
+{
+ m_inputHnd = handler;
+ m_wnd = NULL;
+}
+
+void wxWin32SystemMenuEvtHandler::Attach(wxInputConsumer *consumer)
+{
+ wxASSERT_MSG( m_wnd == NULL, _T("can't attach the handler twice!") );
+
+ m_wnd = wxStaticCast(consumer->GetInputWindow(), wxTopLevelWindow);
+ m_wnd->PushEventHandler(this);
+
+ // VS: This code relies on using generic implementation of
+ // wxAcceleratorTable in wxUniv!
+ wxAcceleratorTable table = *m_wnd->GetAcceleratorTable();
+ m_oldAccelTable = table;
+ table.Add(wxAcceleratorEntry(wxACCEL_ALT, WXK_SPACE, wxID_SYSTEM_MENU));
+ table.Add(wxAcceleratorEntry(wxACCEL_ALT, WXK_F4, wxID_CLOSE_FRAME));
+ m_wnd->SetAcceleratorTable(table);
+}
+
+void wxWin32SystemMenuEvtHandler::Detach()
+{
+ if ( m_wnd )
+ {
+ m_wnd->SetAcceleratorTable(m_oldAccelTable);
+ m_wnd->RemoveEventHandler(this);
+ m_wnd = NULL;
+ }
+}
+
+BEGIN_EVENT_TABLE(wxWin32SystemMenuEvtHandler, wxEvtHandler)
+ EVT_MENU(wxID_SYSTEM_MENU, wxWin32SystemMenuEvtHandler::OnSystemMenu)
+ EVT_MENU(wxID_CLOSE_FRAME, wxWin32SystemMenuEvtHandler::OnCloseFrame)
+ EVT_CLOSE(wxWin32SystemMenuEvtHandler::OnClose)
+END_EVENT_TABLE()
+
+void wxWin32SystemMenuEvtHandler::OnSystemMenu(wxCommandEvent &WXUNUSED(event))
+{
+ int border = ((m_wnd->GetWindowStyle() & wxRESIZE_BORDER) &&
+ !m_wnd->IsMaximized()) ?
+ RESIZEABLE_FRAME_BORDER_THICKNESS :
+ FRAME_BORDER_THICKNESS;
+ wxPoint pt = m_wnd->GetClientAreaOrigin();
+ pt.x = -pt.x + border;
+ pt.y = -pt.y + border + FRAME_TITLEBAR_HEIGHT;
+
+ wxAcceleratorTable table = *m_wnd->GetAcceleratorTable();
+ m_wnd->SetAcceleratorTable(wxNullAcceleratorTable);
+ m_inputHnd->PopupSystemMenu(m_wnd, pt);
+ m_wnd->SetAcceleratorTable(table);
+}
+
+void wxWin32SystemMenuEvtHandler::OnCloseFrame(wxCommandEvent &WXUNUSED(event))
+{
+ m_wnd->PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK,
+ wxTOPLEVEL_BUTTON_CLOSE);
+}
+
+void wxWin32SystemMenuEvtHandler::OnClose(wxCloseEvent &event)
+{
+ m_wnd = NULL;
+ event.Skip();
+}
+
+
+wxWin32FrameInputHandler::wxWin32FrameInputHandler(wxInputHandler *handler)
+ : wxStdFrameInputHandler(handler)
+{
+ m_menuHandler = new wxWin32SystemMenuEvtHandler(this);
+}
+
+wxWin32FrameInputHandler::~wxWin32FrameInputHandler()
+{
+ if ( m_menuHandler )
+ {
+ m_menuHandler->Detach();
+ delete m_menuHandler;
+ }
+}
+
+bool wxWin32FrameInputHandler::HandleMouse(wxInputConsumer *consumer,
+ const wxMouseEvent& event)
+{
+ if ( event.LeftDClick() || event.LeftDown() || event.RightDown() )
+ {
+ wxTopLevelWindow *tlw =
+ wxStaticCast(consumer->GetInputWindow(), wxTopLevelWindow);
+
+ long hit = tlw->HitTest(event.GetPosition());
+
+ if ( event.LeftDClick() && hit == wxHT_TOPLEVEL_TITLEBAR )
+ {
+ tlw->PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK,
+ tlw->IsMaximized() ? wxTOPLEVEL_BUTTON_RESTORE
+ : wxTOPLEVEL_BUTTON_MAXIMIZE);
+ return TRUE;
+ }
+ else if ( tlw->GetWindowStyle() & wxSYSTEM_MENU )
+ {
+ if ( (event.LeftDown() && hit == wxHT_TOPLEVEL_ICON) ||
+ (event.RightDown() &&
+ (hit == wxHT_TOPLEVEL_TITLEBAR ||
+ hit == wxHT_TOPLEVEL_ICON)) )
+ {
+ PopupSystemMenu(tlw, event.GetPosition());
+ return TRUE;
+ }
+ }
+ }
+
+ return wxStdFrameInputHandler::HandleMouse(consumer, event);
+}
+
+void wxWin32FrameInputHandler::PopupSystemMenu(wxTopLevelWindow *window,
+ const wxPoint& pos) const
+{
+ wxMenu *menu = new wxMenu;
+
+ if ( window->GetWindowStyle() & wxMAXIMIZE_BOX )
+ menu->Append(wxID_RESTORE_FRAME , _("&Restore"));
+ menu->Append(wxID_MOVE_FRAME , _("&Move"));
+ if ( window->GetWindowStyle() & wxRESIZE_BORDER )
+ menu->Append(wxID_RESIZE_FRAME , _("&Size"));
+ if ( wxSystemSettings::HasFeature(wxSYS_CAN_ICONIZE_FRAME) )
+ menu->Append(wxID_ICONIZE_FRAME , _("Mi&nimize"));
+ if ( window->GetWindowStyle() & wxMAXIMIZE_BOX )
+ menu->Append(wxID_MAXIMIZE_FRAME , _("Ma&ximize"));
+ menu->AppendSeparator();
+ menu->Append(wxID_CLOSE_FRAME, _("Close\tAlt-F4"));
+
+ if ( window->GetWindowStyle() & wxMAXIMIZE_BOX )
+ {
+ if ( window->IsMaximized() )
+ {
+ menu->Enable(wxID_MAXIMIZE_FRAME, FALSE);
+ menu->Enable(wxID_MOVE_FRAME, FALSE);
+ if ( window->GetWindowStyle() & wxRESIZE_BORDER )
+ menu->Enable(wxID_RESIZE_FRAME, FALSE);
+ }
+ else
+ menu->Enable(wxID_RESTORE_FRAME, FALSE);
+ }
+
+ window->PopupMenu(menu, pos);
+ delete menu;
+}
+
+bool wxWin32FrameInputHandler::HandleActivation(wxInputConsumer *consumer,
+ bool activated)
+{
+ if ( consumer->GetInputWindow()->GetWindowStyle() & wxSYSTEM_MENU )
+ {
+ // always detach if active frame changed:
+ m_menuHandler->Detach();
+
+ if ( activated )
+ {
+ m_menuHandler->Attach(consumer);
+ }
+ }
+
+ return wxStdFrameInputHandler::HandleActivation(consumer, activated);
+}
projects / wxWidgets.git / blobdiff