+///////////////////////////////////////////////////////////////////////////////
// Name: univ/themes/win32.cpp
// Purpose: wxUniversal theme implementing Win32-like LNF
// Author: Vadim Zeitlin
// 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/button.h"
+ #include "wx/bmpbuttn.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/listbox.h"
#include "wx/toolbar.h"
+ #include "wx/statusbr.h"
#ifdef __WXMSW__
// for COLOR_* constants
#include "wx/menu.h"
#include "wx/artprov.h"
#include "wx/toplevel.h"
+#include "wx/image.h"
#include "wx/univ/scrtimer.h"
#include "wx/univ/renderer.h"
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,
{
IndicatorStatus_Checked,
IndicatorStatus_Unchecked,
+ IndicatorStatus_Undeterminated,
IndicatorStatus_Max
};
Arrow_Normal,
Arrow_Disabled,
Arrow_Pressed,
- Arrow_Inversed,
- Arrow_InversedDisabled,
+ Arrow_Inverted,
+ Arrow_InvertedDisabled,
Arrow_StateMax
};
const wxString& label,
const wxBitmap& bitmap,
const wxRect& rect,
- int flags);
+ 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);
+ int flags = 0,
+ long style = 0);
virtual void DrawMenuBarItem(wxDC& dc,
const wxRect& rect,
virtual void DrawStatusField(wxDC& dc,
const wxRect& rect,
const wxString& label,
- int flags = 0);
+ int flags = 0, int style = 0);
// titlebars
virtual void DrawFrameTitleBar(wxDC& dc,
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); }
void DrawSunkenBorder(wxDC& dc, wxRect *rect);
// draw the border used for scrollbar arrows
- void DrawArrowBorder(wxDC& dc, wxRect *rect, bool isPressed = FALSE);
+ void DrawArrowBorder(wxDC& dc, wxRect *rect, bool isPressed = false);
// public DrawArrow()s helper
void DrawArrow(wxDC& dc, const wxRect& rect,
void DrawLine(wxDC& dc,
wxCoord x1, wxCoord y1,
wxCoord x2, wxCoord y2,
- bool transpose = FALSE)
+ bool transpose = false)
{
if ( transpose )
dc.DrawLine(y1, x1, y2, x2);
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
}
const wxMouseEvent& event);
virtual bool HandleActivation(wxInputConsumer *consumer, bool activated);
-
+
void PopupSystemMenu(wxTopLevelWindow *window, const wxPoint& pos) const;
private:
// wxWin32Theme
// ----------------------------------------------------------------------------
-WX_DEFINE_ARRAY(wxInputHandler *, wxArrayHandlers);
+WX_DEFINE_ARRAY_PTR(wxInputHandler *, wxArrayHandlers);
class wxWin32Theme : public wxTheme
{
wxInputHandler *GetDefaultInputHandler();
wxWin32Renderer *m_renderer;
-
+
wxWin32ArtProvider *m_artProvider;
// the names of the already created handlers and the handlers themselves
"wwwwwwwwwwwww"
};
+static const char *undetermined_xpm[] = {
+/* columns rows colors chars-per-pixel */
+"13 13 5 1",
+"A c #030303",
+"B c #838383",
+"C c #C3C3C3",
+"D c #FBFBFB",
+"E c #DBDBDB",
+/* pixels */
+"BBBBBBBBBBBBD",
+"BAAAAAAAAAAED",
+"BACDCDCDCDCED",
+"BADCDCDCDBDED",
+"BACDCDCDBBCED",
+"BADBDCEBBBDED",
+"BACBBDBBBDCED",
+"BADBBBBBDCDED",
+"BACDBBBDCDCED",
+"BADCDBDCDCDED",
+"BACDCDCDCDCED",
+"BEEEEEEEEEEED",
+"DDDDDDDDDDDDD"
+};
+
+static const char *pressed_undetermined_xpm[] = {
+/* columns rows colors chars-per-pixel */
+"13 13 5 1",
+"A c #040404",
+"B c #848484",
+"C c #C4C4C4",
+"D c #FCFCFC",
+"E c #DCDCDC",
+/* pixels */
+"BBBBBBBBBBBBD",
+"BAAAAAAAAAAED",
+"BACCCCCCCCCCD",
+"BACCCCCCCACED",
+"BACCCCCCAACED",
+"BACACCCAAACED",
+"BACAACAAACCED",
+"BACAAAAACCCED",
+"BACCAAACCCCCD",
+"BACCCACCCCCED",
+"BACCCCCCCCCED",
+"BEEEEEEEEEEED",
+"DDDDDDDDDDDDD"
+};
+
static const char *checked_radio_xpm[] = {
/* columns rows colors chars-per-pixel */
"12 12 6 1",
// checkboxes first
{
// normal state
- { checked_xpm, unchecked_xpm },
+ { checked_xpm, unchecked_xpm, undetermined_xpm },
// pressed state
- { pressed_checked_xpm, pressed_unchecked_xpm },
+ { pressed_checked_xpm, pressed_unchecked_xpm, pressed_undetermined_xpm },
// disabled state
- { pressed_disabled_checked_xpm, pressed_unchecked_xpm },
+ { pressed_disabled_checked_xpm, pressed_unchecked_xpm, pressed_disabled_checked_xpm },
},
// radio
{
// normal state
- { checked_radio_xpm, unchecked_radio_xpm },
+ { checked_radio_xpm, unchecked_radio_xpm, NULL },
// pressed state
- { pressed_checked_radio_xpm, pressed_unchecked_radio_xpm },
+ { pressed_checked_radio_xpm, pressed_unchecked_radio_xpm, NULL },
// disabled state
- { pressed_disabled_checked_radio_xpm, pressed_unchecked_radio_xpm },
+ { pressed_disabled_checked_radio_xpm, pressed_unchecked_radio_xpm, NULL },
},
// menu
{
// normal state
- { checked_menu_xpm, NULL },
+ { checked_menu_xpm, NULL, NULL },
// selected state
- { selected_checked_menu_xpm, NULL },
+ { selected_checked_menu_xpm, NULL, NULL },
// disabled state
- { disabled_checked_menu_xpm, NULL },
+ { disabled_checked_menu_xpm, NULL, NULL },
// disabled selected state
- { selected_disabled_checked_menu_xpm, NULL },
+ { selected_disabled_checked_menu_xpm, NULL, NULL },
}
};
col = win->GetBackgroundColour();
}
- if ( win->IsContainerWindow() )
+ if ( !win->ShouldInheritColours() )
{
wxTextCtrl *text = wxDynamicCast(win, wxTextCtrl);
- if ( text )
+#if wxUSE_LISTBOX
+ wxListBox* listBox = wxDynamicCast(win, wxListBox);
+#endif
+ if ( text
+#if wxUSE_LISTBOX
+ || listBox
+#endif
+ )
{
- if ( !text->IsEnabled() ) // not IsEditable()
+ if ( !win->IsEnabled() ) // not IsEditable()
col = Get(CONTROL);
- //else: execute code below
+ else
+ {
+ if ( !col.Ok() )
+ {
+ // doesn't depend on the state
+ col = Get(WINDOW);
+ }
+ }
}
- if ( !col.Ok() )
- {
- // doesn't depend on the state
- col = Get(WINDOW);
- }
+ if (!col.Ok())
+ col = Get(CONTROL); // Most controls should be this colour, not WINDOW
}
else
{
}
- // create the inversed bitmap but only for the right arrow as we only
+ // create the inverted bitmap but only for the right arrow as we only
// use it for the menus
if ( n == Arrow_Right )
{
- m_bmpArrows[Arrow_Inversed][n].Create(w, h);
- dcInverse.SelectObject(m_bmpArrows[Arrow_Inversed][n]);
+ m_bmpArrows[Arrow_Inverted][n].Create(w, h);
+ dcInverse.SelectObject(m_bmpArrows[Arrow_Inverted][n]);
dcInverse.Clear();
dcInverse.Blit(0, 0, w, h,
&dcNormal, 0, 0,
wxXOR);
dcInverse.SelectObject(wxNullBitmap);
- mask = new wxMask(m_bmpArrows[Arrow_Inversed][n], *wxBLACK);
- m_bmpArrows[Arrow_Inversed][n].SetMask(mask);
+ mask = new wxMask(m_bmpArrows[Arrow_Inverted][n], *wxBLACK);
+ m_bmpArrows[Arrow_Inverted][n].SetMask(mask);
- m_bmpArrows[Arrow_InversedDisabled][n].Create(w, h);
- dcInverse.SelectObject(m_bmpArrows[Arrow_InversedDisabled][n]);
+ m_bmpArrows[Arrow_InvertedDisabled][n].Create(w, h);
+ dcInverse.SelectObject(m_bmpArrows[Arrow_InvertedDisabled][n]);
dcInverse.Clear();
dcInverse.Blit(0, 0, w, h,
&dcDisabled, 0, 0,
wxXOR);
dcInverse.SelectObject(wxNullBitmap);
- mask = new wxMask(m_bmpArrows[Arrow_InversedDisabled][n], *wxBLACK);
- m_bmpArrows[Arrow_InversedDisabled][n].SetMask(mask);
+ mask = new wxMask(m_bmpArrows[Arrow_InvertedDisabled][n], *wxBLACK);
+ m_bmpArrows[Arrow_InvertedDisabled][n].SetMask(mask);
}
dcNormal.SelectObject(wxNullBitmap);
break;
default:
- {
+ {
// char *crash = NULL;
// *crash = 0;
wxFAIL_MSG(_T("unknown border type"));
bool wxWin32Renderer::AreScrollbarsInsideBorder() const
{
- return TRUE;
+ return true;
}
// ----------------------------------------------------------------------------
}
dc.DrawBitmap(bmp, rect.x, rect.y + (rect.height - bmp.GetHeight()) / 2 - 1,
- TRUE /* use mask */);
+ true /* use mask */);
wxRect rectLabel = rect;
int bmpWidth = bmp.GetWidth();
IndicatorStatus indStatus = flags & wxCONTROL_CHECKED
? IndicatorStatus_Checked
- : IndicatorStatus_Unchecked;
+ : ( flags & wxCONTROL_UNDETERMINED
+ ? IndicatorStatus_Undeterminated
+ : IndicatorStatus_Unchecked );
wxBitmap bmp = m_bmpIndicators[indType][indState][indStatus];
if ( !bmp.Ok() )
rectLabel.SetRight(rect.GetRight());
}
- dc.DrawBitmap(bitmap, xBmp, yBmp, TRUE /* use mask */);
+ dc.DrawBitmap(bitmap, xBmp, yBmp, true /* use mask */);
DoDrawLabel(
dc, label, rectLabel,
const wxString& label,
const wxBitmap& bitmap,
const wxRect& rectOrig,
- int flags)
+ int flags,
+ long style)
{
- if ( !label.empty() || bitmap.Ok() )
+ if (style == wxTOOL_STYLE_BUTTON)
{
wxRect rect = rectOrig;
rect.Deflate(BORDER_THICKNESS);
dc.DrawLabel(label, bitmap, rect, wxALIGN_CENTRE);
}
- else // a separator
+ else if (style == wxTOOL_STYLE_SEPARATOR)
{
// leave a small gap aroudn the line, also account for the toolbar
// border itself
rectOrig.y + 2*BORDER_THICKNESS,
rectOrig.GetBottom() - BORDER_THICKNESS);
}
+ // don't draw wxTOOL_STYLE_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
}
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;
}
}
// 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);
- DrawButtonLabel(dc, label, bitmap, rectLabel,
- flags, 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) );
+ DrawButtonLabel(dcMem, label, bitmapRotated, rectLabel,
+ flags, 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
+ {
+ DrawButtonLabel(dc, label, bitmap, rectLabel,
+ flags, wxALIGN_CENTRE, indexAccel);
+ }
// now draw the tab border itself (maybe use DrawRoundedRectangle()?)
static const wxCoord CUTOFF = 2; // radius of the rounded corner
- 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());
// FIXME: all this code will break if the tab indent or the border width,
// it is tied to the fact that both of them are equal to 2
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 + CUTOFF);
- dc.DrawLine(x, y + CUTOFF, x + CUTOFF, y);
- dc.DrawLine(x + CUTOFF, y, x2 - CUTOFF + 1, y);
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x, y2),
+ REVERSE_FOR_VERTICAL(x, y + CUTOFF));
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x, y + CUTOFF),
+ REVERSE_FOR_VERTICAL(x + CUTOFF, y));
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x + CUTOFF, y),
+ REVERSE_FOR_VERTICAL(x2 - CUTOFF + 1, y));
dc.SetPen(m_penBlack);
- dc.DrawLine(x2, y2, x2, y + CUTOFF);
- dc.DrawLine(x2, y + CUTOFF, x2 - CUTOFF, y);
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x2, y2),
+ REVERSE_FOR_VERTICAL(x2, y + CUTOFF));
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x2, y + CUTOFF),
+ REVERSE_FOR_VERTICAL(x2 - CUTOFF, y));
dc.SetPen(m_penDarkGrey);
- dc.DrawLine(x2 - 1, y2, x2 - 1, y + CUTOFF - 1);
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x2 - 1, y2),
+ REVERSE_FOR_VERTICAL(x2 - 1, y + CUTOFF - 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 + CUTOFF + 1, x + 1, y2 + 1);
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y + CUTOFF + 1),
+ 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 - CUTOFF);
- dc.DrawLine(x, y2 - CUTOFF, x + CUTOFF, y2);
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x, y - (flags & wxCONTROL_SELECTED ? 1 : 0)),
+ REVERSE_FOR_VERTICAL(x, y2 - CUTOFF));
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x, y2 - CUTOFF),
+ REVERSE_FOR_VERTICAL(x + CUTOFF, y2));
dc.SetPen(m_penBlack);
- dc.DrawLine(x + CUTOFF, y2, x2 - CUTOFF + 1, y2);
- dc.DrawLine(x2, y, x2, y2 - CUTOFF);
- dc.DrawLine(x2, y2 - CUTOFF, x2 - CUTOFF, y2);
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x + CUTOFF, y2),
+ REVERSE_FOR_VERTICAL(x2 - CUTOFF + 1, y2));
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x2, y),
+ REVERSE_FOR_VERTICAL(x2, y2 - CUTOFF));
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x2, y2 - CUTOFF),
+ REVERSE_FOR_VERTICAL(x2 - CUTOFF, y2));
dc.SetPen(m_penDarkGrey);
- dc.DrawLine(x + CUTOFF, y2 - 1, x2 - CUTOFF + 1, y2 - 1);
- dc.DrawLine(x2 - 1, y, x2 - 1, y2 - CUTOFF + 1);
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x + CUTOFF, y2 - 1),
+ REVERSE_FOR_VERTICAL(x2 - CUTOFF + 1, y2 - 1));
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x2 - 1, y),
+ REVERSE_FOR_VERTICAL(x2 - 1, y2 - CUTOFF + 1));
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 - CUTOFF, x + 1, y - 1);
+ dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y2 - CUTOFF),
+ REVERSE_FOR_VERTICAL(x + 1, y - 1));
}
break;
-
- case wxLEFT:
- case wxRIGHT:
- wxFAIL_MSG(_T("TODO"));
}
+
+ #undef SELECT_FOR_VERTICAL
+ #undef REVERSE_FOR_VERTICAL
}
// ----------------------------------------------------------------------------
// 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 highlight 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);
+ {
+ rectInt.SetLeft(y3);
+ rectInt.SetRight(y4);
+ }
else
- rectInt.SetBottom(y3);
+ {
+ rectInt.SetTop(y3);
+ rectInt.SetBottom(y4);
+ }
rectInt.Deflate(2);
#if !defined(__WXMGL__)
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;
- }
-
- // this would lead to an infinite loop below
- wxCHECK_RET( step > 1, _T("invalid step in wxRenderer::DrawSliderTicks") );
-
- // 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);
+ }
}
// ----------------------------------------------------------------------------
wxArrowStyle arrowStyle;
if ( flags & wxCONTROL_DISABLED )
- arrowStyle = flags & wxCONTROL_SELECTED ? Arrow_InversedDisabled
+ arrowStyle = flags & wxCONTROL_SELECTED ? Arrow_InvertedDisabled
: Arrow_Disabled;
else if ( flags & wxCONTROL_SELECTED )
- arrowStyle = Arrow_Inversed;
+ arrowStyle = Arrow_Inverted;
else
arrowStyle = Arrow_Normal;
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() )
{
void wxWin32Renderer::DrawStatusField(wxDC& dc,
const wxRect& rect,
const wxString& label,
- int flags)
+ int flags, int style /*=0*/)
{
wxRect rectIn;
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());
+ if (style != wxSB_FLAT)
+ {
+ if (style == wxSB_RAISED)
+ dc.SetPen(m_penHighlight);
+ else
+ 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;
}
// 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);
+ if (style != wxSB_FLAT)
+ {
+ if (style == wxSB_RAISED)
+ dc.SetPen(m_penDarkGrey);
+ else
+ dc.SetPen(m_penHighlight);
+ 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);
}
else // normal pane
{
- DrawBorder(dc, wxBORDER_STATIC, rect, flags, &rectIn);
+ if (style == wxSB_RAISED)
+ DrawBorder(dc, wxBORDER_RAISED, rect, flags, &rectIn);
+ else if (style != wxSB_FLAT)
+ DrawBorder(dc, wxBORDER_STATIC, rect, flags, &rectIn);
}
rectIn.Deflate(STATBAR_BORDER_X, STATBAR_BORDER_Y);
// ----------------------------------------------------------------------------
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,
- wxWindow *window )
+ wxWindow * WXUNUSED(window))
{
wxBrush brush(col, wxSOLID);
dc.SetBrush(brush);
void wxWin32Renderer::DrawBackground(wxDC& dc,
const wxColour& col,
const wxRect& rect,
- int flags,
- wxWindow *window )
+ 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);
x--;
// draw it
- dc.DrawBitmap(bmp, x, y, TRUE /* use mask */);
+ dc.DrawBitmap(bmp, x, y, true /* use mask */);
}
void wxWin32Renderer::DrawArrowButton(wxDC& dc,
}
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)
{
DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_HELP,
(specialButton == wxTOPLEVEL_BUTTON_HELP) ?
specialButtonFlags : 0);
- x -= FRAME_BUTTON_WIDTH;
}
}
}
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);
+ 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);
+ dc.DrawBitmap(m_bmpFrameButtons[idx], r.x, r.y, true);
}
}
wxSize wxWin32Renderer::GetFrameMinSize(int flags) const
{
- wxSize s(0, 0);
+ wxSize s;
if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
{
// standard icons
// ----------------------------------------------------------------------------
+/* Copyright (c) Julian Smart */
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..........."};
+/* columns rows colors chars-per-pixel */
+"32 32 70 1",
+"- c #BF0101",
+"b c #361F1F",
+"& c #C08484",
+"X c #BF3333",
+"# c #C08181",
+"% c #C01111",
+"d c #C51515",
+"s c #551818",
+"O c #C07E7E",
+": c #C00E0E",
+"u c #E28A8A",
+"2 c #C81F1F",
+"8 c #FFFFFF",
+"p c #E59494",
+"< c #BB0101",
+"y c #DA6A6A",
+"A c #4C4C4C",
+"9 c #F7DFDF",
+"@ c #BF5353",
+"w c #FAE9E9",
+"F c #272727",
+"5 c #D24A4A",
+". c #C06363",
+"n c #BF8282",
+"7 c #F2C9C9",
+"t c #C09292",
+"M c #3E3E3E",
+"x c #4D4D4D",
+"4 c #CA2A2A",
+"h c #E79F9F",
+"* c #C05454",
+"D c #711212",
+"V c #737373",
+"$ c #BF3232",
+"N c #900B0B",
+"6 c #BD0303",
+"3 c #DF7F7F",
+"K c #6F1212",
+"C c #BD0000",
+"m c #950909",
+"P c #8A8A8A",
+"j c #D75F5F",
+" c None",
+"e c #F4D4D4",
+"S c #BF2020",
+"L c #747474",
+"G c #842C2C",
+"c c #ECB4B4",
+"l c #2E2121",
+"g c #BF7E7E",
+"k c #9B0808",
+"= c #BF0505",
+"a c #B10303",
+"q c #7E2020",
+"1 c #642222",
+"J c #676767",
+"B c #322020",
+"; c #C00303",
+"i c #242424",
+"o c #C00000",
+"> c #BF1F1F",
+", c #842B2B",
+"f c #701212",
+"0 c #BE0000",
+"r c #960909",
+"H c #686868",
+"v c #BC0000",
+"Z c #671414",
+"+ c #C02020",
+"z c #CD3535",
+/* pixels */
+" ",
+" ",
+" .XoooOO ",
+" .+ooooooooo@# ",
+" $oooooooooooo%& ",
+" *=-ooooooooooooo;: ",
+" *oooooooooooooooooo> ",
+" =ooooooooooooooooooo, ",
+" $-ooooooooooooooooooo<1 ",
+" .oooooo2334ooo533oooooo6 ",
+" +ooooooo789oo2883oooooo0q ",
+" oooooooo2w83o78eoooooooor ",
+" toooooooooy88u884oooooooori ",
+" Xooooooooooe888poooooooooas ",
+" ooooooooooo4889doooooooooof ",
+" ooooooooooo588w2oooooooooofi ",
+" oooooooooodw8887oooooooooofi ",
+" goooooooooh8w588jooooooookli ",
+" tooooooooz885op8wdooooooorix ",
+" oooooood98cood98cooooooori ",
+" @oooooop8w2ooo5885ooooovbi ",
+" n%ooooooooooooooooooooomiM ",
+" &;oooooooooooooooooooNBiV ",
+" :ooooooooooooooooooCZiA ",
+" nSooooooooooooooooCDiF ",
+" nG<oooooooooooooNZiiH ",
+" 160ooooooooovmBiFH ",
+" nqrraoookrrbiiA ",
+" nJisKKKliiiML ",
+" nPiiix ",
+" ",
+" "
+};
+/* Copyright (c) Julian Smart */
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##...........",
-"..................###...........",
-"...................##..........."};
+/* columns rows colors chars-per-pixel */
+"32 32 17 1",
+"* c #A1A3FB",
+"X c #FFFFFF",
+"O c #191EF4",
+"= c #777AF9",
+": c #4D51F7",
+" c None",
+"- c #2328F5",
+"+ c #4247F6",
+"; c #C1C2FC",
+". c #C0C0C0",
+"& c #E0E1FE",
+"% c #242424",
+"> c #2D32F5",
+"o c #CBCCFD",
+"# c #0309F3",
+"@ c #8C8FFA",
+"$ c #EAEBFE",
+/* pixels */
+" ....... ",
+" ...XXXXXXX... ",
+" ..XXXXXXXXXXXXX.. ",
+" .XXXXXXXXXXXXXXXXX. ",
+" .XXXXXXXXoO+XXXXXXXX. ",
+" .XXXXXXXXX@#OXXXXXXXXX. ",
+" .XXXXXXXXXX$@oXXXXXXXXXX. ",
+" .XXXXXXXXXXXXXXXXXXXXXXX.% ",
+" .XXXXXXXXX&*=-XXXXXXXXXX.%% ",
+".XXXXXXXXXX;:#>XXXXXXXXXXX.% ",
+".XXXXXXXXXXX;#+XXXXXXXXXXX.% ",
+".XXXXXXXXXXX;#+XXXXXXXXXXX.%% ",
+" .XXXXXXXXXX;#+XXXXXXXXXX.%%% ",
+" .XXXXXXXXXX;#+XXXXXXXXXX.%%% ",
+" .XXXXXXXXXX;#+XXXXXXXXXX.%% ",
+" .XXXXXXXX*-##+XXXXXXXX.%%% ",
+" .XXXXXXXXXXXXXXXXXXX.%%%% ",
+" .XXXXXXXXXXXXXXXXX.%%%% ",
+" ..XXXXXXXXXXXXX..%%%% ",
+" %...XXXXXXXX..%%%%% ",
+" %%%..XXXXXX.%%%%% ",
+" %%%.XXXXX.%%% ",
+" %.XXXX.%% ",
+" .XXX.%% ",
+" .XX.%% ",
+" .X.%% ",
+" ..%% ",
+" .%% ",
+" %% ",
+" % ",
+" ",
+" "
+};
+/* Copyright (c) Julian Smart */
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##...........",
-"..................###...........",
-"...................##..........."};
+/* columns rows colors chars-per-pixel */
+"32 32 16 1",
+"O c #A3A3FF",
+"X c #FFFFFF",
+"% c #CACAFF",
+"- c #4141FF",
+"= c #6060FF",
+"* c #2B2BFF",
+"@ c #B5B5FF",
+" c None",
+"# c #1616FF",
+"+ c #8181FF",
+"$ c #0000FF",
+". c #C0C0C0",
+"; c #5555FF",
+": c #242424",
+"o c #E7E7FF",
+"& c #7575FF",
+/* pixels */
+" ....... ",
+" ...XXXXXXX... ",
+" ..XXXXXXXXXXXXX.. ",
+" .XXXXXXoO++@XXXXXX. ",
+" .XXXXXXO#$$$$#%XXXXX. ",
+" .XXXXXX@$$#&&#$#oXXXXX. ",
+" .XXXXXXX*$$%XX%$$=XXXXXX. ",
+" .XXXXXXX+-;XXXX$$-XXXXXX.: ",
+" .XXXXXXXXXXXXX+$$&XXXXXX.:: ",
+".XXXXXXXXXXXXo;$$*oXXXXXXX.: ",
+".XXXXXXXXXXXo*$$*oXXXXXXXX.: ",
+".XXXXXXXXXXX+$$*oXXXXXXXXX.:: ",
+" .XXXXXXXXXX-$$oXXXXXXXXX.::: ",
+" .XXXXXXXXXXX--XXXXXXXXXX.::: ",
+" .XXXXXXXXXXXXXXXXXXXXXXX.:: ",
+" .XXXXXXXXX-$$XXXXXXXXX.::: ",
+" .XXXXXXXX-$$XXXXXXXX.:::: ",
+" .XXXXXXXO++XXXXXXX.:::: ",
+" ..XXXXXXXXXXXXX..:::: ",
+" :...XXXXXXXX..::::: ",
+" :::..XXXXXX.::::: ",
+" :::.XXXXX.::: ",
+" :.XXXX.:: ",
+" .XXX.:: ",
+" .XX.:: ",
+" .X.:: ",
+" ..:: ",
+" .:: ",
+" :: ",
+" : ",
+" ",
+" "
+};
+/* Copyright (c) Julian Smart */
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.."};
+/* columns rows colors chars-per-pixel */
+"32 32 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... ",
+" .............................. ",
+" .............................. ",
+" ",
+" ",
+" "
+};
+
wxBitmap wxWin32ArtProvider::CreateBitmap(const wxArtID& id,
const wxArtClient& WXUNUSED(client),
return 1;
}
-wxRect wxWin32Renderer::GetTextTotalArea(const wxTextCtrl *text,
- const wxRect& rect) const
+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) const
+wxRect
+wxWin32Renderer::GetTextClientArea(const wxTextCtrl * WXUNUSED(text),
+ const wxRect& rect,
+ wxCoord *extraSpaceBeyond) const
{
wxRect rectText = rect;
}
#endif // wxUSE_SCROLLBAR/!wxUSE_SCROLLBAR
+#if wxUSE_BMPBUTTON
+ if ( wxDynamicCast(window, wxBitmapButton) )
+ {
+ // do nothing
+ } else
+#endif // wxUSE_BMPBUTTON
#if wxUSE_BUTTON
if ( wxDynamicCast(window, wxButton) )
{
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;
+ return false;
}
bool wxWin32InputHandler::HandleMouse(wxInputConsumer *control,
{
win->SetFocus();
- return TRUE;
+ return true;
}
}
- return FALSE;
+ return false;
}
// ----------------------------------------------------------------------------
wxInputHandler *handler)
: wxStdScrollBarInputHandler(renderer, handler)
{
- m_scrollPaused = FALSE;
+ m_scrollPaused = false;
m_interval = 0;
}
{
// stop if went beyond the position of the original click (this can only
// happen when we scroll by pages)
- bool stop = FALSE;
+ bool stop = false;
if ( action == wxACTION_SCROLL_PAGE_DOWN )
{
stop = m_renderer->HitTestScrollbar(scrollbar, m_ptStartScrolling)
scrollbar->Refresh();
- return FALSE;
+ return false;
}
return wxStdScrollBarInputHandler::OnScrollTimer(scrollbar, action);
// mouse move events normally - only do it while mouse is captured (i.e.
// when we're dragging the thumb or pressing on something)
if ( !m_winCapture )
- return FALSE;
+ return false;
if ( event.Entering() )
{
// we're not interested in this at all
- return FALSE;
+ return false;
}
wxScrollBar *scrollbar = wxStaticCast(control->GetInputWindow(), wxScrollBar);
if ( event.Leaving() )
{
// it surely didn't
- return FALSE;
+ return false;
}
ht = m_renderer->HitTestScrollbar(scrollbar, event.GetPosition());
if ( ht == m_htLast )
{
// yes it did, resume scrolling
- m_scrollPaused = FALSE;
+ m_scrollPaused = false;
if ( m_timerScroll )
{
// we were scrolling by line/page, restart timer
m_timerScroll->Start(m_interval);
- Press(scrollbar, TRUE);
+ Press(scrollbar, true);
}
else // we were dragging the thumb
{
HandleThumbMove(scrollbar, m_eventLastDrag);
}
- return TRUE;
+ return true;
}
}
else // normal case, scrolling hasn't been paused
// pause scrolling
m_interval = m_timerScroll->GetInterval();
m_timerScroll->Stop();
- m_scrollPaused = TRUE;
+ m_scrollPaused = true;
// unpress the arrow
- Press(scrollbar, FALSE);
+ Press(scrollbar, false);
}
else // we were dragging the thumb
{
HandleThumbMove(scrollbar, m_eventStartDrag);
}
- return TRUE;
+ return true;
}
}
break;
}
- if ( !!action )
+ if ( !action.IsEmpty() )
{
control->PerformAction(action);
- return TRUE;
+ return true;
}
}
- return FALSE;
+ return false;
}
// ----------------------------------------------------------------------------
{
control->PerformAction(action);
- return TRUE;
+ return true;
}
}
wxWin32StatusBarInputHandler(wxInputHandler *handler)
: wxStdInputHandler(handler)
{
- m_isOnGrip = FALSE;
+ m_isOnGrip = false;
}
bool wxWin32StatusBarInputHandler::IsOnGrip(wxWindow *statbar,
wxTopLevelWindow *
parentTLW = wxDynamicCast(statbar->GetParent(), wxTopLevelWindow);
- wxCHECK_MSG( parentTLW, FALSE,
+ wxCHECK_MSG( parentTLW, false,
_T("the status bar should be a child of a TLW") );
// a maximized window can't be resized anyhow
}
}
- return FALSE;
+ return false;
}
bool wxWin32StatusBarInputHandler::HandleMouse(wxInputConsumer *consumer,
statbar->SetCursor(m_cursorOld);
- return TRUE;
+ return true;
}
}
}
{
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;
+#if wxUSE_ACCEL
wxAcceleratorTable m_oldAccelTable;
+#endif
};
wxWin32SystemMenuEvtHandler::wxWin32SystemMenuEvtHandler(
m_wnd = wxStaticCast(consumer->GetInputWindow(), wxTopLevelWindow);
m_wnd->PushEventHandler(this);
-
- // VS: This code relies on using generic implementation of
+
+#if wxUSE_ACCEL
+ // 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);
+#endif
}
void wxWin32SystemMenuEvtHandler::Detach()
{
if ( m_wnd )
{
+#if wxUSE_ACCEL
m_wnd->SetAcceleratorTable(m_oldAccelTable);
- m_wnd->RemoveEventHandler(this);
+#endif
+ m_wnd->RemoveEventHandler(this);
m_wnd = NULL;
}
}
pt.x = -pt.x + border;
pt.y = -pt.y + border + FRAME_TITLEBAR_HEIGHT;
+#if wxUSE_ACCEL
wxAcceleratorTable table = *m_wnd->GetAcceleratorTable();
m_wnd->SetAcceleratorTable(wxNullAcceleratorTable);
+#endif
+
m_inputHnd->PopupSystemMenu(m_wnd, pt);
+
+#if wxUSE_ACCEL
m_wnd->SetAcceleratorTable(table);
+#endif
}
void wxWin32SystemMenuEvtHandler::OnCloseFrame(wxCommandEvent &WXUNUSED(event))
tlw->PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK,
tlw->IsMaximized() ? wxTOPLEVEL_BUTTON_RESTORE
: wxTOPLEVEL_BUTTON_MAXIMIZE);
- return TRUE;
+ return true;
}
else if ( tlw->GetWindowStyle() & wxSYSTEM_MENU )
{
if ( (event.LeftDown() && hit == wxHT_TOPLEVEL_ICON) ||
- (event.RightDown() &&
- (hit == wxHT_TOPLEVEL_TITLEBAR ||
+ (event.RightDown() &&
+ (hit == wxHT_TOPLEVEL_TITLEBAR ||
hit == wxHT_TOPLEVEL_ICON)) )
{
PopupSystemMenu(tlw, event.GetPosition());
- return TRUE;
+ return true;
}
}
}
return wxStdFrameInputHandler::HandleMouse(consumer, event);
}
-void wxWin32FrameInputHandler::PopupSystemMenu(wxTopLevelWindow *window,
+void wxWin32FrameInputHandler::PopupSystemMenu(wxTopLevelWindow *window,
const wxPoint& pos) const
{
wxMenu *menu = new wxMenu;
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);
+ menu->Enable(wxID_MAXIMIZE_FRAME, false);
+ menu->Enable(wxID_MOVE_FRAME, false);
if ( window->GetWindowStyle() & wxRESIZE_BORDER )
- menu->Enable(wxID_RESIZE_FRAME, FALSE);
+ menu->Enable(wxID_RESIZE_FRAME, false);
}
else
- menu->Enable(wxID_RESTORE_FRAME, FALSE);
+ menu->Enable(wxID_RESTORE_FRAME, false);
}
window->PopupMenu(menu, pos);
delete menu;
}
-bool wxWin32FrameInputHandler::HandleActivation(wxInputConsumer *consumer,
+bool wxWin32FrameInputHandler::HandleActivation(wxInputConsumer *consumer,
bool activated)
{
if ( consumer->GetInputWindow()->GetWindowStyle() & wxSYSTEM_MENU )
projects / wxWidgets.git / blobdiff