Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

wxBitmapButton added (doesn't work yet)

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/branches/wxUNIVERSAL@8190 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2000-08-25 21:45:03 +00:00
parent 325443b96b
commit 1a1edfc0ca
27 changed files with 655 additions and 387 deletions
Download Patch File Download Diff File Expand all files Collapse all files

92
include/wx/bmpbuttn.h
View File

@@ -1,20 +1,94 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/bmpbutton.h
// Purpose: wxBitmapButton class interface
// Author: Vadim Zeitlin
// Modified by:
// Created: 25.08.00
// RCS-ID: $Id$
// Copyright: (c) 2000 Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_BMPBUTTON_H_BASE_
#define _WX_BMPBUTTON_H_BASE_
#if defined(__WXMSW__)
#include "wx/msw/bmpbuttn.h"
#if wxUSE_BMPBUTTON
#include "wx/bitmap.h"
#include "wx/button.h"
WXDLLEXPORT_DATA(extern const wxChar*) wxButtonNameStr;
// ----------------------------------------------------------------------------
// wxBitmapButton: a button which shows bitmaps instead of the usual string.
// It has different bitmaps for different states (focused/disabled/pressed)
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxBitmapButtonBase : public wxButton
{
public:
wxBitmapButtonBase() { m_marginX = m_marginY = 0; }
// set the bitmaps
void SetBitmapLabel(const wxBitmap& bitmap)
{ m_bmpNormal = bitmap; OnSetBitmap(); }
void SetBitmapSelected(const wxBitmap& sel)
{ m_bmpSelected = sel; OnSetBitmap(); };
void SetBitmapFocus(const wxBitmap& focus)
{ m_bmpFocus = focus; OnSetBitmap(); };
void SetBitmapDisabled(const wxBitmap& disabled)
{ m_bmpDisabled = disabled; OnSetBitmap(); };
void SetLabel(const wxBitmap& bitmap)
{ SetBitmapLabel(bitmap); }
// retrieve the bitmaps
const wxBitmap& GetBitmapLabel() const { return m_bmpNormal; }
const wxBitmap& GetBitmapSelected() const { return m_bmpSelected; }
const wxBitmap& GetBitmapFocus() const { return m_bmpFocus; }
const wxBitmap& GetBitmapDisabled() const { return m_bmpDisabled; }
wxBitmap& GetBitmapLabel() { return m_bmpNormal; }
wxBitmap& GetBitmapSelected() { return m_bmpSelected; }
wxBitmap& GetBitmapFocus() { return m_bmpFocus; }
wxBitmap& GetBitmapDisabled() { return m_bmpDisabled; }
// set/get the margins around the button
virtual void SetMargins(int x, int y) { m_marginX = x; m_marginY = y; }
int GetMarginX() const { return m_marginX; }
int GetMarginY() const { return m_marginY; }
protected:
// function called when any of the bitmaps changes
virtual void OnSetBitmap() { }
// the bitmaps for various states
wxBitmap m_bmpNormal,
m_bmpSelected,
m_bmpFocus,
m_bmpDisabled;
// the margins around the bitmap
int m_marginX,
m_marginY;
};
#if defined(__WXUNIVERSAL__)
#include "wx/univ/bmpbuttn.h"
#elif defined(__WXMSW__)
#include "wx/msw/bmpbuttn.h"
#elif defined(__WXMOTIF__)
#include "wx/motif/bmpbuttn.h"
#include "wx/motif/bmpbuttn.h"
#elif defined(__WXGTK__)
#include "wx/gtk/bmpbuttn.h"
#include "wx/gtk/bmpbuttn.h"
#elif defined(__WXQT__)
#include "wx/qt/bmpbuttn.h"
#include "wx/qt/bmpbuttn.h"
#elif defined(__WXMAC__)
#include "wx/mac/bmpbuttn.h"
#include "wx/mac/bmpbuttn.h"
#elif defined(__WXPM__)
#include "wx/os2/bmpbuttn.h"
#include "wx/os2/bmpbuttn.h"
#elif defined(__WXSTUBS__)
#include "wx/stubs/bmpbuttn.h"
#include "wx/stubs/bmpbuttn.h"
#endif
#endif
#endif // wxUSE_BMPBUTTON
#endif // _WX_BMPBUTTON_H_BASE_

3
include/wx/button.h
View File

@@ -30,6 +30,9 @@ public:
// show the image in the button in addition to the label
virtual void SetImageLabel(const wxBitmap& bitmap) { }
// set the margins around the image
virtual void SetImageMargins(wxCoord x, wxCoord y) { }
// this wxButton method is called when the button becomes the default one
// on its panel
virtual void SetDefault() { }

81
include/wx/gtk/bmpbuttn.h
View File

@@ -15,71 +15,41 @@
#pragma interface
#endif
#include "wx/defs.h"
#if wxUSE_BMPBUTTON
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
#include "wx/bitmap.h"
#include "wx/button.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxBitmapButton;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const wxChar *wxButtonNameStr;
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// wxBitmapButton
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
class wxBitmapButton: public wxButton
class wxBitmapButton: public wxBitmapButtonBase
{
public:
wxBitmapButton();
inline wxBitmapButton( wxWindow *parent, wxWindowID id, const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = wxBU_AUTODRAW,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr )
wxBitmapButton(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxBU_AUTODRAW,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
{
Create(parent, id, bitmap, pos, size, style, validator, name);
}
bool Create( wxWindow *parent, wxWindowID id, const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = wxBU_AUTODRAW,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxBU_AUTODRAW,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
virtual void SetDefault();
virtual bool Enable(bool enable = TRUE);
void SetLabel( const wxString &label );
wxString GetLabel() const;
virtual void SetLabel( const wxBitmap& bitmap ) { SetBitmapLabel(bitmap); }
wxBitmap& GetBitmapDisabled() const { return (wxBitmap&) m_disabled; }
wxBitmap& GetBitmapFocus() const { return (wxBitmap&) m_focus; }
wxBitmap& GetBitmapLabel() const { return (wxBitmap&) m_bitmap; }
wxBitmap& GetBitmapSelected() const { return (wxBitmap&) m_selected; }
void SetBitmapDisabled( const wxBitmap& bitmap );
void SetBitmapFocus( const wxBitmap& bitmap );
void SetBitmapLabel( const wxBitmap& bitmap );
void SetBitmapSelected( const wxBitmap& bitmap );
void SetMargins(int x, int y) { m_marginX = x; m_marginY = y; }
int GetMarginX() const { return m_marginX; }
int GetMarginY() const { return m_marginY; }
virtual bool Enable(bool enable);
// implementation
// --------------
@@ -92,19 +62,12 @@ public:
bool m_hasFocus;
bool m_isSelected;
wxBitmap m_bitmap;
wxBitmap m_disabled;
wxBitmap m_focus;
wxBitmap m_selected;
protected:
int m_marginX;
int m_marginY;
virtual void OnSetBitmap();
private:
DECLARE_DYNAMIC_CLASS(wxBitmapButton)
};
#endif
#endif // __BMPBUTTONH__

81
include/wx/gtk1/bmpbuttn.h
View File

@@ -15,71 +15,41 @@
#pragma interface
#endif
#include "wx/defs.h"
#if wxUSE_BMPBUTTON
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
#include "wx/bitmap.h"
#include "wx/button.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxBitmapButton;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const wxChar *wxButtonNameStr;
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// wxBitmapButton
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
class wxBitmapButton: public wxButton
class wxBitmapButton: public wxBitmapButtonBase
{
public:
wxBitmapButton();
inline wxBitmapButton( wxWindow *parent, wxWindowID id, const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = wxBU_AUTODRAW,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr )
wxBitmapButton(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxBU_AUTODRAW,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
{
Create(parent, id, bitmap, pos, size, style, validator, name);
}
bool Create( wxWindow *parent, wxWindowID id, const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = wxBU_AUTODRAW,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxBU_AUTODRAW,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
virtual void SetDefault();
virtual bool Enable(bool enable = TRUE);
void SetLabel( const wxString &label );
wxString GetLabel() const;
virtual void SetLabel( const wxBitmap& bitmap ) { SetBitmapLabel(bitmap); }
wxBitmap& GetBitmapDisabled() const { return (wxBitmap&) m_disabled; }
wxBitmap& GetBitmapFocus() const { return (wxBitmap&) m_focus; }
wxBitmap& GetBitmapLabel() const { return (wxBitmap&) m_bitmap; }
wxBitmap& GetBitmapSelected() const { return (wxBitmap&) m_selected; }
void SetBitmapDisabled( const wxBitmap& bitmap );
void SetBitmapFocus( const wxBitmap& bitmap );
void SetBitmapLabel( const wxBitmap& bitmap );
void SetBitmapSelected( const wxBitmap& bitmap );
void SetMargins(int x, int y) { m_marginX = x; m_marginY = y; }
int GetMarginX() const { return m_marginX; }
int GetMarginY() const { return m_marginY; }
virtual bool Enable(bool enable);
// implementation
// --------------
@@ -92,19 +62,12 @@ public:
bool m_hasFocus;
bool m_isSelected;
wxBitmap m_bitmap;
wxBitmap m_disabled;
wxBitmap m_focus;
wxBitmap m_selected;
protected:
int m_marginX;
int m_marginY;
virtual void OnSetBitmap();
private:
DECLARE_DYNAMIC_CLASS(wxBitmapButton)
};
#endif
#endif // __BMPBUTTONH__

70
include/wx/msw/bmpbuttn.h
View File

@@ -16,60 +16,41 @@
#pragma interface "bmpbuttn.h"
#endif
#if wxUSE_BMPBUTTON
#include "wx/button.h"
#include "wx/bitmap.h"
WXDLLEXPORT_DATA(extern const wxChar*) wxButtonNameStr;
#define wxDEFAULT_BUTTON_MARGIN 4
class WXDLLEXPORT wxBitmapButton: public wxButton
class WXDLLEXPORT wxBitmapButton: public wxBitmapButtonBase
{
DECLARE_DYNAMIC_CLASS(wxBitmapButton)
public:
wxBitmapButton() { m_marginX = wxDEFAULT_BUTTON_MARGIN; m_marginY = wxDEFAULT_BUTTON_MARGIN; }
wxBitmapButton(wxWindow *parent, wxWindowID id, const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = wxBU_AUTODRAW,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
wxBitmapButton()
{ m_marginX = m_marginY = wxDEFAULT_BUTTON_MARGIN; }
wxBitmapButton(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxBU_AUTODRAW,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
{
Create(parent, id, bitmap, pos, size, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id, const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = wxBU_AUTODRAW,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
virtual void SetLabel(const wxBitmap& bitmap)
{
SetBitmapLabel(bitmap);
}
virtual void SetBitmapLabel(const wxBitmap& bitmap);
bool Create(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxBU_AUTODRAW,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
#if WXWIN_COMPATIBILITY
wxBitmap *GetBitmap() const { return (wxBitmap *) & m_buttonBitmap; }
wxBitmap *GetBitmap() const { return (wxBitmap *) & m_bmp; }
#endif
wxBitmap& GetBitmapLabel() const { return (wxBitmap&) m_buttonBitmap; }
wxBitmap& GetBitmapSelected() const { return (wxBitmap&) m_buttonBitmapSelected; }
wxBitmap& GetBitmapFocus() const { return (wxBitmap&) m_buttonBitmapFocus; }
wxBitmap& GetBitmapDisabled() const { return (wxBitmap&) m_buttonBitmapDisabled; }
void SetBitmapSelected(const wxBitmap& sel) { m_buttonBitmapSelected = sel; };
void SetBitmapFocus(const wxBitmap& focus) { m_buttonBitmapFocus = focus; };
void SetBitmapDisabled(const wxBitmap& disabled) { m_buttonBitmapDisabled = disabled; };
void SetMargins(int x, int y) { m_marginX = x; m_marginY = y; }
int GetMarginX() const { return m_marginX; }
int GetMarginY() const { return m_marginY; }
// Implementation
virtual void SetDefault();
virtual bool MSWOnDraw(WXDRAWITEMSTRUCT *item);
@@ -77,16 +58,9 @@ public:
virtual void DrawButtonFocus( WXHDC dc, int left, int top, int right, int bottom, bool sel );
virtual void DrawButtonDisable( WXHDC dc, int left, int top, int right, int bottom, bool with_marg );
protected:
wxBitmap m_buttonBitmap;
wxBitmap m_buttonBitmapSelected;
wxBitmap m_buttonBitmapFocus;
wxBitmap m_buttonBitmapDisabled;
int m_marginX;
int m_marginY;
private:
DECLARE_DYNAMIC_CLASS(wxBitmapButton)
};
#endif // wxUSE_BMPBUTTON
#endif
// _WX_BMPBUTTN_H_

73
include/wx/univ/bmpbuttn.h Normal file
View File

@@ -0,0 +1,73 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/bmpbuttn.h
// Purpose: wxBitmapButton class for wxUniversal
// Author: Vadim Zeitlin
// Modified by:
// Created: 25.08.00
// RCS-ID: $Id$
// Copyright: (c) Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_BMPBUTTN_H_
#define _WX_UNIV_BMPBUTTN_H_
#ifdef __GNUG__
#pragma interface "univbmpbuttn.h"
#endif
class WXDLLEXPORT wxBitmapButton : public wxBitmapButtonBase
{
public:
wxBitmapButton() { }
wxBitmapButton(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
{
Create(parent, id, bitmap, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
virtual void SetMargins(int x, int y)
{
SetImageMargins(x, y);
wxBitmapButtonBase::SetMargins(x, y);
}
virtual bool Enable(bool enable = TRUE);
virtual void SetCurrent(bool doit = TRUE);
virtual void Press();
virtual void Release();
protected:
void OnSetFocus(wxFocusEvent& event);
void OnKillFocus(wxFocusEvent& event);
// set bitmap to the given one if it's ok or to m_bmpNormal and return
// TRUE if the bitmap really changed
bool ChangeBitmap(const wxBitmap& bmp);
private:
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxBitmapButton)
};
#endif // _WX_UNIV_BMPBUTTN_H_

45
include/wx/univ/button.h
View File

@@ -18,6 +18,8 @@
class WXDLLEXPORT wxInputHandler;
#include "wx/bitmap.h"
// ----------------------------------------------------------------------------
// the actions supported by this control
// ----------------------------------------------------------------------------
@@ -35,6 +37,21 @@ class WXDLLEXPORT wxButton : public wxButtonBase
{
public:
wxButton() { Init(); }
wxButton(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
{
Init();
Create(parent, id, bitmap, label, pos, size, style, validator, name);
}
wxButton(wxWindow *parent,
wxWindowID id,
const wxString& label,
@@ -56,20 +73,36 @@ public:
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
{
return Create(parent, id, wxNullBitmap, label,
pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
virtual ~wxButton();
virtual void SetImageLabel(const wxBitmap& bitmap);
virtual void SetImageMargins(wxCoord x, wxCoord y);
virtual void SetDefault();
virtual bool IsPressed() const { return m_isPressed; }
virtual bool IsDefault() const { return m_isDefault; }
// wxButton actions
void Press();
void Release();
void Toggle();
void Click();
virtual void Press();
virtual void Release();
virtual void Click();
protected:
virtual bool PerformAction(const wxControlAction& action,
@@ -80,9 +113,15 @@ protected:
// common part of all ctors
void Init();
// current state
bool m_isPressed,
m_isDefault;
// the (optional) image to show and the margins around it
wxBitmap m_bitmap;
wxCoord m_marginBmpX,
m_marginBmpY;
private:
DECLARE_DYNAMIC_CLASS(wxButton)
};

5
include/wx/univ/control.h
View File

@@ -124,7 +124,7 @@ public:
int GetStateFlags() const;
// operations
void SetCurrent(bool doit = TRUE);
virtual void SetCurrent(bool doit = TRUE);
// implementation only from now on
@@ -158,6 +158,9 @@ protected:
// draw the controls contents
virtual void DoDraw(wxControlRenderer *renderer);
// adjust the size of the control to take into account its borders
wxSize AdjustSize(const wxSize& size) const;
// event handlers
void OnMouse(wxMouseEvent& event);
void OnKeyDown(wxKeyEvent& event);

10
include/wx/univ/renderer.h
View File

@@ -259,13 +259,18 @@ public:
wxControlRenderer(wxControl *control, wxDC& dc, wxRenderer *renderer);
// operations
void DrawLabel();
void DrawLabel(const wxBitmap& bitmap = wxNullBitmap,
wxCoord marginX = 0, wxCoord marginY = 0);
void DrawBorder();
void DrawButtonBorder();
// the line must be either horizontal or vertical
void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2);
void DrawFrame();
void DrawBitmap(const wxBitmap& bitmap);
void DrawBitmap(const wxBitmap& bitmap,
const wxRect& rect,
int alignment = wxALIGN_CENTRE | wxALIGN_CENTRE_VERTICAL,
wxStretch stretch = wxSTRETCH_NOT);
void DrawBackgroundBitmap();
void DrawScrollbar(const wxScrollBar *scrollbar);
@@ -277,9 +282,6 @@ public:
const wxRect& GetRect() const { return m_rect; }
wxRect& GetRect() { return m_rect; }
protected:
void DoDrawBitmap(const wxBitmap& bmp, int alignment, wxStretch stretch);
private:
wxControl *m_ctrl;
wxRenderer *m_renderer;

25
include/wx/window.h
View File

@@ -767,23 +767,20 @@ protected:
static int WidthDefault(int w) { return w == -1 ? 20 : w; }
static int HeightDefault(int h) { return h == -1 ? 20 : h; }
// sets the size to be size but take width and/or height from
// DoGetBestSize() if width/height of size is -1
//
// NB: when calling this function from the ctor, the DoGetBestSize() of
// the class with the same name as the ctor, not the real (most
// derived) one - but this is what we usually want
void SetSizeOrDefault(const wxSize& size = wxDefaultSize)
// set the best size for the control if the default size was given:
// replaces the fields of size == -1 with the best values for them and
// calls SetSize() if needed
void SetBestSize(const wxSize& size)
{
if ( size.x == -1 || size.y == -1 )
{
wxSize sizeDef = GetBestSize();
SetSize( size.x == -1 ? sizeDef.x : size.x,
size.y == -1 ? sizeDef.y : size.y);
}
else
{
SetSize(size);
wxSize sizeBest = DoGetBestSize();
if ( size.x != -1 )
sizeBest.x = size.x;
if ( size.y != -1 )
sizeBest.y = size.y;
SetSize(sizeBest);
}
}

30
samples/univ/open.xpm Normal file
View File

@@ -0,0 +1,30 @@
/* XPM */
static char *open_xpm[] = {
/* columns rows colors chars-per-pixel */
"20 19 5 1",
" c Gray0",
". c #7f007f000000",
"X c Yellow",
"o c Gray100",
"O c None",
/* pixels */
"OOOOOOOOOOOOOOOOOOOO",
"OOOOOOOOOOOOOOOOOOOO",
"OOOOOOOOOOO OOOOOO",
"OOOOOOOOOO OOO O OOO",
"OOOOOOOOOOOOOOO OOO",
"OOO OOOOOOOO OOO",
"OO XoX OOOOOOO",
"OO oXoXoXoXo OOOOOOO",
"OO XoXoXoXoX OOOOOOO",
"OO oXoX OO",
"OO XoX ......... OOO",
"OO oX ......... OOOO",
"OO X ......... OOOOO",
"OO ......... OOOOOO",
"OO OOOOOOO",
"OOOOOOOOOOOOOOOOOOOO",
"OOOOOOOOOOOOOOOOOOOO",
"OOOOOOOOOOOOOOOOOOOO",
"OOOOOOOOOOOOOOOOOOOO"
};

27
samples/univ/univ.cpp
View File

@@ -34,6 +34,7 @@
#include "wx/frame.h"
#include "wx/dcclient.h"
#include "wx/bmpbuttn.h"
#include "wx/button.h"
#include "wx/scrolbar.h"
#include "wx/statbmp.h"
@@ -47,6 +48,7 @@
// ----------------------------------------------------------------------------
#include "wx/generic/tip.xpm"
#include "open.xpm"
// ----------------------------------------------------------------------------
// constants
@@ -201,12 +203,33 @@ MyUnivFrame::MyUnivFrame(const wxString& title)
sb->SetScrollbar(0, 10, 100, 10);
sb = new wxScrollBar(this, -1, wxPoint(200, 330), wxSize(-1, 150), wxSB_VERTICAL);
sb->SetScrollbar(50, 50, 100, 10);
new wxButton(this, -1, wxBitmap(open_xpm), _T("&Open..."), wxPoint(10, 420));
wxBitmap bmp1(wxTheApp->GetStdIcon(wxICON_INFORMATION)),
bmp2(wxTheApp->GetStdIcon(wxICON_WARNING)),
bmp3(wxTheApp->GetStdIcon(wxICON_QUESTION));
wxBitmapButton *bmpBtn = new wxBitmapButton
(
this, -1,
bmp1,
wxPoint(10, 470)
);
bmpBtn->SetBitmapSelected(bmp2);
bmpBtn->SetBitmapFocus(bmp3);
}
void MyUnivFrame::OnButton(wxCommandEvent& event)
{
wxLogDebug(_T("Button %d pressed."),
event.GetId() == Univ_Button1 ? 1 : 2);
int btn = event.GetId();
if ( btn == Univ_Button1 || btn == Univ_Button2 )
{
wxLogDebug(_T("Button %d pressed."), btn == Univ_Button1 ? 1 : 2);
}
else
{
wxLogDebug(_T("Another button pressed."));
}
}
void MyUnivFrame::OnLeftUp(wxMouseEvent& event)

2
src/common/dcbase.cpp
View File

@@ -241,7 +241,7 @@ void wxDCBase::DrawLabel(const wxString& text,
{
x = rect.GetRight() - width;
}
else if ( alignment & wxALIGN_CENTRE )
else if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
{
x = (rect.GetLeft() + rect.GetRight() - width) / 2;
}

70
src/gtk/bmpbuttn.cpp
View File

@@ -119,9 +119,6 @@ bool wxBitmapButton::Create( wxWindow *parent, wxWindowID id, const wxBitmap &bi
m_needParent = TRUE;
m_acceptsFocus = TRUE;
m_marginX =
m_marginY = 0;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
@@ -129,10 +126,10 @@ bool wxBitmapButton::Create( wxWindow *parent, wxWindowID id, const wxBitmap &bi
return FALSE;
}
m_bitmap = bitmap;
m_disabled = bitmap;
m_focus = bitmap;
m_selected = bitmap;
m_bmpNormal =
m_bmpDisabled =
m_bmpFocus =
m_bmpSelected = bitmap;
m_widget = gtk_button_new();
@@ -141,21 +138,21 @@ bool wxBitmapButton::Create( wxWindow *parent, wxWindowID id, const wxBitmap &bi
gtk_button_set_relief( GTK_BUTTON(m_widget), GTK_RELIEF_NONE );
#endif
if (m_bitmap.Ok())
if (m_bmpNormal.Ok())
{
wxSize newSize = size;
GdkBitmap *mask = (GdkBitmap *) NULL;
if (m_bitmap.GetMask()) mask = m_bitmap.GetMask()->GetBitmap();
GtkWidget *pixmap = gtk_pixmap_new( m_bitmap.GetPixmap(), mask );
if (m_bmpNormal.GetMask()) mask = m_bmpNormal.GetMask()->GetBitmap();
GtkWidget *pixmap = gtk_pixmap_new( m_bmpNormal.GetPixmap(), mask );
gtk_widget_show( pixmap );
gtk_container_add( GTK_CONTAINER(m_widget), pixmap );
int border = 10;
if (style & wxNO_BORDER) border = 4;
if (newSize.x == -1) newSize.x = m_bitmap.GetWidth()+border;
if (newSize.y == -1) newSize.y = m_bitmap.GetHeight()+border;
if (newSize.x == -1) newSize.x = m_bmpNormal.GetWidth()+border;
if (newSize.y == -1) newSize.y = m_bmpNormal.GetHeight()+border;
SetSize( newSize.x, newSize.y );
}
@@ -210,28 +207,28 @@ void wxBitmapButton::ApplyWidgetStyle()
void wxBitmapButton::SetBitmap()
{
wxCHECK_RET( m_widget != NULL, wxT("invalid button") );
wxCHECK_RET( m_widget != NULL, wxT("invalid bitmap button") );
wxBitmap the_one;
if (!m_isEnabled)
the_one = m_disabled;
the_one = m_bmpDisabled;
else
{
if (m_isSelected)
{
the_one = m_selected;
the_one = m_bmpSelected;
}
else
{
if (m_hasFocus)
the_one = m_focus;
the_one = m_bmpFocus;
else
the_one = m_bitmap;
the_one = m_bmpNormal;
}
}
if (!the_one.Ok()) the_one = m_bitmap;
if (!the_one.Ok()) the_one = m_bmpNormal;
if (!the_one.Ok()) return;
GtkButton *bin = GTK_BUTTON( m_widget );
@@ -243,43 +240,8 @@ void wxBitmapButton::SetBitmap()
gtk_pixmap_set( g_pixmap, the_one.GetPixmap(), mask );
}
void wxBitmapButton::SetBitmapDisabled( const wxBitmap& bitmap )
void wxBitmapButton::OnSetBitmap()
{
wxCHECK_RET( m_widget != NULL, wxT("invalid button") );
if ( ! m_disabled.Ok() ) return;
m_disabled = bitmap;
SetBitmap();
}
void wxBitmapButton::SetBitmapFocus( const wxBitmap& bitmap )
{
wxCHECK_RET( m_widget != NULL, wxT("invalid button") );
if ( ! m_focus.Ok() ) return;
m_focus = bitmap;
SetBitmap();
}
void wxBitmapButton::SetBitmapLabel( const wxBitmap& bitmap )
{
wxCHECK_RET( m_widget != NULL, wxT("invalid button") );
if (!m_bitmap.Ok()) return;
m_bitmap = bitmap;
SetBitmap();
}
void wxBitmapButton::SetBitmapSelected( const wxBitmap& bitmap )
{
wxCHECK_RET( m_widget != NULL, wxT("invalid button") );
if ( ! m_selected.Ok() ) return;
m_selected = bitmap;
SetBitmap();
}

70
src/gtk1/bmpbuttn.cpp
View File

@@ -119,9 +119,6 @@ bool wxBitmapButton::Create( wxWindow *parent, wxWindowID id, const wxBitmap &bi
m_needParent = TRUE;
m_acceptsFocus = TRUE;
m_marginX =
m_marginY = 0;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
@@ -129,10 +126,10 @@ bool wxBitmapButton::Create( wxWindow *parent, wxWindowID id, const wxBitmap &bi
return FALSE;
}
m_bitmap = bitmap;
m_disabled = bitmap;
m_focus = bitmap;
m_selected = bitmap;
m_bmpNormal =
m_bmpDisabled =
m_bmpFocus =
m_bmpSelected = bitmap;
m_widget = gtk_button_new();
@@ -141,21 +138,21 @@ bool wxBitmapButton::Create( wxWindow *parent, wxWindowID id, const wxBitmap &bi
gtk_button_set_relief( GTK_BUTTON(m_widget), GTK_RELIEF_NONE );
#endif
if (m_bitmap.Ok())
if (m_bmpNormal.Ok())
{
wxSize newSize = size;
GdkBitmap *mask = (GdkBitmap *) NULL;
if (m_bitmap.GetMask()) mask = m_bitmap.GetMask()->GetBitmap();
GtkWidget *pixmap = gtk_pixmap_new( m_bitmap.GetPixmap(), mask );
if (m_bmpNormal.GetMask()) mask = m_bmpNormal.GetMask()->GetBitmap();
GtkWidget *pixmap = gtk_pixmap_new( m_bmpNormal.GetPixmap(), mask );
gtk_widget_show( pixmap );
gtk_container_add( GTK_CONTAINER(m_widget), pixmap );
int border = 10;
if (style & wxNO_BORDER) border = 4;
if (newSize.x == -1) newSize.x = m_bitmap.GetWidth()+border;
if (newSize.y == -1) newSize.y = m_bitmap.GetHeight()+border;
if (newSize.x == -1) newSize.x = m_bmpNormal.GetWidth()+border;
if (newSize.y == -1) newSize.y = m_bmpNormal.GetHeight()+border;
SetSize( newSize.x, newSize.y );
}
@@ -210,28 +207,28 @@ void wxBitmapButton::ApplyWidgetStyle()
void wxBitmapButton::SetBitmap()
{
wxCHECK_RET( m_widget != NULL, wxT("invalid button") );
wxCHECK_RET( m_widget != NULL, wxT("invalid bitmap button") );
wxBitmap the_one;
if (!m_isEnabled)
the_one = m_disabled;
the_one = m_bmpDisabled;
else
{
if (m_isSelected)
{
the_one = m_selected;
the_one = m_bmpSelected;
}
else
{
if (m_hasFocus)
the_one = m_focus;
the_one = m_bmpFocus;
else
the_one = m_bitmap;
the_one = m_bmpNormal;
}
}
if (!the_one.Ok()) the_one = m_bitmap;
if (!the_one.Ok()) the_one = m_bmpNormal;
if (!the_one.Ok()) return;
GtkButton *bin = GTK_BUTTON( m_widget );
@@ -243,43 +240,8 @@ void wxBitmapButton::SetBitmap()
gtk_pixmap_set( g_pixmap, the_one.GetPixmap(), mask );
}
void wxBitmapButton::SetBitmapDisabled( const wxBitmap& bitmap )
void wxBitmapButton::OnSetBitmap()
{
wxCHECK_RET( m_widget != NULL, wxT("invalid button") );
if ( ! m_disabled.Ok() ) return;
m_disabled = bitmap;
SetBitmap();
}
void wxBitmapButton::SetBitmapFocus( const wxBitmap& bitmap )
{
wxCHECK_RET( m_widget != NULL, wxT("invalid button") );
if ( ! m_focus.Ok() ) return;
m_focus = bitmap;
SetBitmap();
}
void wxBitmapButton::SetBitmapLabel( const wxBitmap& bitmap )
{
wxCHECK_RET( m_widget != NULL, wxT("invalid button") );
if (!m_bitmap.Ok()) return;
m_bitmap = bitmap;
SetBitmap();
}
void wxBitmapButton::SetBitmapSelected( const wxBitmap& bitmap )
{
wxCHECK_RET( m_widget != NULL, wxT("invalid button") );
if ( ! m_selected.Ok() ) return;
m_selected = bitmap;
SetBitmap();
}

23
src/msw/bmpbuttn.cpp
View File

@@ -40,7 +40,7 @@ bool wxBitmapButton::Create(wxWindow *parent, wxWindowID id, const wxBitmap& bit
const wxValidator& validator,
const wxString& name)
{
m_buttonBitmap = bitmap;
m_bmpNormal = bitmap;
SetName(name);
#if wxUSE_VALIDATORS
@@ -52,8 +52,6 @@ bool wxBitmapButton::Create(wxWindow *parent, wxWindowID id, const wxBitmap& bit
m_backgroundColour = parent->GetBackgroundColour();
m_foregroundColour = parent->GetForegroundColour();
m_windowStyle = style;
m_marginX = 0;
m_marginY = 0;
if ( style & wxBU_AUTODRAW )
{
@@ -113,11 +111,6 @@ bool wxBitmapButton::Create(wxWindow *parent, wxWindowID id, const wxBitmap& bit
return TRUE;
}
void wxBitmapButton::SetBitmapLabel(const wxBitmap& bitmap)
{
m_buttonBitmap = bitmap;
}
// VZ: should be at the very least less than wxDEFAULT_BUTTON_MARGIN
#define FOCUS_MARGIN 3
@@ -143,14 +136,14 @@ bool wxBitmapButton::MSWOnDraw(WXDRAWITEMSTRUCT *item)
// choose the bitmap to use depending on the button state
wxBitmap* bitmap;
if ( isSelected && m_buttonBitmapSelected.Ok() )
bitmap = &m_buttonBitmapSelected;
else if ((state & ODS_FOCUS) && m_buttonBitmapFocus.Ok())
bitmap = &m_buttonBitmapFocus;
else if ((state & ODS_DISABLED) && m_buttonBitmapDisabled.Ok())
bitmap = &m_buttonBitmapDisabled;
if ( isSelected && m_bmpSelected.Ok() )
bitmap = &m_bmpSelected;
else if ((state & ODS_FOCUS) && m_bmpFocus.Ok())
bitmap = &m_bmpFocus;
else if ((state & ODS_DISABLED) && m_bmpDisabled.Ok())
bitmap = &m_bmpDisabled;
else
bitmap = &m_buttonBitmap;
bitmap = &m_bmpNormal;
if ( !bitmap->Ok() )
return FALSE;

135
src/univ/bmpbuttn.cpp Normal file
View File

@@ -0,0 +1,135 @@
/////////////////////////////////////////////////////////////////////////////
// Name: univ/bmpbuttn.cpp
// Purpose: wxBitmapButton implementation
// Author: Vadim Zeitlin
// Modified by:
// Created: 25.08.00
// RCS-ID: $Id$
// Copyright: (c) 2000 Vadim Zeitlin
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#ifdef __GNUG__
#pragma implementation "univbmpbuttn.h"
#endif
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#if wxUSE_STATLINE
#ifndef WX_PRECOMP
#include "wx/dc.h"
#include "wx/bmpbuttn.h"
#include "wx/validate.h"
#endif
#include "wx/univ/renderer.h"
// ============================================================================
// implementation
// ============================================================================
IMPLEMENT_DYNAMIC_CLASS(wxBitmapButton, wxControl)
BEGIN_EVENT_TABLE(wxBitmapButton, wxButton)
EVT_SET_FOCUS(wxBitmapButton::OnSetFocus)
EVT_KILL_FOCUS(wxBitmapButton::OnKillFocus)
END_EVENT_TABLE()
// ----------------------------------------------------------------------------
// wxBitmapButton
// ----------------------------------------------------------------------------
bool wxBitmapButton::Create(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint &pos,
const wxSize &size,
long style,
const wxValidator& validator,
const wxString &name)
{
if ( !wxButton::Create(parent, id, bitmap, _T(""),
pos, size, style, validator, name) )
return FALSE;
m_bmpNormal = bitmap;
return TRUE;
}
bool wxBitmapButton::ChangeBitmap(const wxBitmap& bmp)
{
wxBitmap bitmap = bmp.Ok() ? bmp : m_bmpNormal;
if ( bitmap != m_bitmap )
{
m_bitmap = bitmap;
return TRUE;
}
return FALSE;
}
bool wxBitmapButton::Enable(bool enable)
{
if ( !wxButton::Enable(enable) )
return FALSE;
if ( !enable && ChangeBitmap(m_bmpDisabled) )
Refresh();
return TRUE;
}
void wxBitmapButton::SetCurrent(bool doit)
{
ChangeBitmap(doit ? m_bmpFocus : m_bmpNormal);
wxButton::SetCurrent(doit);
}
void wxBitmapButton::OnSetFocus(wxFocusEvent& event)
{
if ( ChangeBitmap(m_bmpFocus) )
Refresh();
event.Skip();
}
void wxBitmapButton::OnKillFocus(wxFocusEvent& event)
{
if ( ChangeBitmap(m_bmpNormal) )
Refresh();
event.Skip();
}
void wxBitmapButton::Press()
{
ChangeBitmap(m_bmpSelected);
wxButton::Press();
}
void wxBitmapButton::Release()
{
ChangeBitmap(m_bmpNormal);
wxButton::Release();
}
#endif // wxUSE_STATLINE

67
src/univ/button.cpp
View File

@@ -39,6 +39,14 @@
#include "wx/univ/inphand.h"
#include "wx/univ/theme.h"
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
// default margins around the image
static const wxCoord DEFAULT_BTN_MARGIN_X = 6;
static const wxCoord DEFAULT_BTN_MARGIN_Y = 3;
// ============================================================================
// implementation
// ============================================================================
@@ -57,6 +65,7 @@ void wxButton::Init()
bool wxButton::Create(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxString &label,
const wxPoint &pos,
const wxSize &size,
@@ -67,20 +76,26 @@ bool wxButton::Create(wxWindow *parent,
// center label by default
if ( !(style & wxALIGN_MASK) )
{
style |= wxALIGN_CENTRE | wxALIGN_CENTRE_VERTICAL;
style |= wxALIGN_CENTRE_VERTICAL;
// normally, buttons are centered, but it looks better to put them
// near the image for the buttons which have one
if ( bitmap.Ok() )
{
style |= wxALIGN_LEFT;
}
else
{
style |= wxALIGN_CENTRE_HORIZONTAL;
}
}
if ( !wxControl::Create(parent, id, pos, size, style, wxDefaultValidator, name) )
return FALSE;
SetLabel(label);
if ( size.x == -1 || size.y == -1 )
{
wxSize sizeBest = DoGetBestSize();
SetSize(size.x == -1 ? sizeBest.x : size.x,
size.y == -1 ? sizeBest.y : size.y);
}
SetImageLabel(bitmap);
SetBestSize(size);
return TRUE;
}
@@ -99,9 +114,17 @@ wxSize wxButton::DoGetBestSize() const
wxCoord width, height;
dc.GetMultiLineTextExtent(GetLabel(), &width, &height);
wxSize sz(width, height);
wxTheme::Get()->GetRenderer()->AdjustSize(&sz, this);
return sz;
if ( m_bitmap.Ok() )
{
// allocate extra space for the bitmap
wxCoord heightBmp = m_bitmap.GetHeight() + 2*m_marginBmpY;
if ( height < heightBmp )
height = heightBmp;
width += m_bitmap.GetWidth() + 2*m_marginBmpX;
}
return AdjustSize(wxSize(width, height));
}
// ----------------------------------------------------------------------------
@@ -111,7 +134,7 @@ wxSize wxButton::DoGetBestSize() const
void wxButton::DoDraw(wxControlRenderer *renderer)
{
renderer->DrawButtonBorder();
renderer->DrawLabel();
renderer->DrawLabel(m_bitmap, m_marginBmpX, m_marginBmpY);
}
// ----------------------------------------------------------------------------
@@ -130,7 +153,10 @@ void wxButton::Release()
void wxButton::Toggle()
{
m_isPressed = !m_isPressed;
if ( m_isPressed )
Release();
else
Press();
if ( !m_isPressed )
{
@@ -166,9 +192,22 @@ bool wxButton::PerformAction(const wxControlAction& action,
}
// ----------------------------------------------------------------------------
//
// misc
// ----------------------------------------------------------------------------
void wxButton::SetImageLabel(const wxBitmap& bitmap)
{
m_bitmap = bitmap;
m_marginBmpX = DEFAULT_BTN_MARGIN_X;
m_marginBmpY = DEFAULT_BTN_MARGIN_Y;
}
void wxButton::SetImageMargins(wxCoord x, wxCoord y)
{
m_marginBmpX = x;
m_marginBmpY = y;
}
void wxButton::SetDefault()
{
m_isDefault = TRUE;

14
src/univ/control.cpp
View File

@@ -139,6 +139,17 @@ int wxControl::GetStateFlags() const
return flags;
}
// ----------------------------------------------------------------------------
// size
// ----------------------------------------------------------------------------
wxSize wxControl::AdjustSize(const wxSize& size) const
{
wxSize sz = size;
wxTheme::Get()->GetRenderer()->AdjustSize(&sz, this);
return sz;
}
// ----------------------------------------------------------------------------
// mnemonics handling
// ----------------------------------------------------------------------------
@@ -267,7 +278,8 @@ void wxControl::DoDraw(wxControlRenderer *renderer)
void wxControl::OnFocus(wxFocusEvent& event)
{
Refresh();
// do nothing here for now...
event.Skip();
}
// ----------------------------------------------------------------------------

2
src/univ/files.lst
View File

@@ -1,4 +1,5 @@
UNIVOBJS = \
bmpbuttn.o \
button.o \
colschem.o \
control.o \
@@ -14,6 +15,7 @@ UNIVOBJS = \
win32.o
UNIVDEPS = \
bmpbuttn.d \
button.d \
colschem.d \
control.d \

7
src/univ/inphand.cpp
View File

@@ -156,8 +156,11 @@ wxControlActions wxStdButtonInputHandler::Map(wxControl *control,
}
else // up
{
m_winCapture->ReleaseMouse();
m_winCapture = NULL;
if ( m_winCapture )
{
m_winCapture->ReleaseMouse();
m_winCapture = NULL;
}
if ( m_winHasMouse )
{

71
src/univ/renderer.cpp
View File

@@ -186,17 +186,39 @@ void wxControlRenderer::DrawBorder()
m_renderer->DrawBackground(m_dc, m_rect, flags);
}
void wxControlRenderer::DrawLabel()
void wxControlRenderer::DrawLabel(const wxBitmap& bitmap,
wxCoord marginX, wxCoord marginY)
{
m_dc.SetFont(m_ctrl->GetFont());
m_dc.SetTextForeground(m_ctrl->GetForegroundColour());
m_renderer->DrawLabel(m_dc,
m_ctrl->GetLabel(),
m_rect,
m_ctrl->GetStateFlags(),
m_ctrl->GetAlignment(),
m_ctrl->GetAccelIndex());
wxRect rectLabel = m_rect;
if ( bitmap.Ok() )
{
wxRect rectBmp;
int width = bitmap.GetWidth();
rectBmp.x = m_rect.x + marginX;
rectBmp.y = m_rect.y + marginY;
rectBmp.width = width;
rectBmp.height = m_rect.height - marginY;
DrawBitmap(bitmap, rectBmp, wxALIGN_CENTRE | wxALIGN_CENTRE_VERTICAL);
width += 2*marginX;
rectLabel.x += width;
rectLabel.width -= width;
}
wxString label = m_ctrl->GetLabel();
if ( !label.empty() )
{
m_renderer->DrawLabel(m_dc,
label,
rectLabel,
m_ctrl->GetStateFlags(),
m_ctrl->GetAlignment(),
m_ctrl->GetAccelIndex());
}
}
void wxControlRenderer::DrawFrame()
@@ -225,9 +247,9 @@ void wxControlRenderer::DrawButtonBorder()
void wxControlRenderer::DrawBitmap(const wxBitmap& bitmap)
{
int style = m_ctrl->GetWindowStyle();
DoDrawBitmap(bitmap,
style & wxALIGN_MASK,
style & wxBI_EXPAND ? wxEXPAND : wxSTRETCH_NOT);
DrawBitmap(bitmap, m_rect,
style & wxALIGN_MASK,
style & wxBI_EXPAND ? wxEXPAND : wxSTRETCH_NOT);
}
void wxControlRenderer::DrawBackgroundBitmap()
@@ -237,13 +259,16 @@ void wxControlRenderer::DrawBackgroundBitmap()
wxStretch stretch;
wxBitmap bmp = m_ctrl->GetBackgroundBitmap(&alignment, &stretch);
DoDrawBitmap(bmp, alignment, stretch);
DrawBitmap(bmp, m_rect, alignment, stretch);
}
void wxControlRenderer::DoDrawBitmap(const wxBitmap& bmp,
int alignment,
wxStretch stretch)
void wxControlRenderer::DrawBitmap(const wxBitmap& bitmap,
const wxRect& rect,
int alignment,
wxStretch stretch)
{
// we may change the bitmap if we stretch it
wxBitmap bmp = bitmap;
if ( !bmp.Ok() )
return;
@@ -255,9 +280,9 @@ void wxControlRenderer::DoDrawBitmap(const wxBitmap& bmp,
if ( stretch & wxTILE )
{
// tile the bitmap
for ( ; x < m_rect.width; x += width )
for ( ; x < rect.width; x += width )
{
for ( y = 0; y < m_rect.height; y += height )
for ( y = 0; y < rect.height; y += height )
{
m_dc.DrawBitmap(bmp, x, y);
}
@@ -266,34 +291,34 @@ void wxControlRenderer::DoDrawBitmap(const wxBitmap& bmp,
else if ( stretch & wxEXPAND )
{
// stretch bitmap to fill the entire control
bmp = wxImage(bmp).Scale(m_rect.width, m_rect.height).ConvertToBitmap();
bmp = wxImage(bmp).Scale(rect.width, rect.height).ConvertToBitmap();
}
else // not stretched, not tiled
{
if ( alignment & wxALIGN_RIGHT )
{
x = m_rect.GetRight() - width;
x = rect.GetRight() - width;
}
else if ( alignment & wxALIGN_CENTRE )
{
x = (m_rect.GetLeft() + m_rect.GetRight() - width) / 2;
x = (rect.GetLeft() + rect.GetRight() - width) / 2;
}
else // alignment & wxALIGN_LEFT
{
x = m_rect.GetLeft();
x = rect.GetLeft();
}
if ( alignment & wxALIGN_BOTTOM )
{
y = m_rect.GetBottom() - height;
y = rect.GetBottom() - height;
}
else if ( alignment & wxALIGN_CENTRE_VERTICAL )
{
y = (m_rect.GetTop() + m_rect.GetBottom() - height) / 2;
y = (rect.GetTop() + rect.GetBottom() - height) / 2;
}
else // alignment & wxALIGN_TOP
{
y = m_rect.GetTop();
y = rect.GetTop();
}
}

5
src/univ/scrolbar.cpp
View File

@@ -162,9 +162,8 @@ void wxScrollBar::SetScrollbar(int position, int thumbSize,
wxSize wxScrollBar::DoGetBestSize() const
{
wxSize sz(140, 140);
wxTheme::Get()->GetRenderer()->AdjustSize(&sz, this);
return sz;
// completely arbitrary
return AdjustSize(wxSize(140, 140));
}
// ----------------------------------------------------------------------------

15
src/univ/statbmp.cpp
View File

@@ -64,16 +64,7 @@ bool wxStaticBitmap::Create(wxWindow *parent,
SetBitmap(label);
// and adjust our size to fit it after this
if ( size.x == -1 || size.y == -1 )
{
wxSize sizeBest = DoGetBestSize();
if ( size.x != -1 )
sizeBest.x = size.x;
if ( size.y != -1 )
sizeBest.y = size.y;
SetSize(sizeBest);
}
SetBestSize(size);
return TRUE;
}
@@ -113,9 +104,7 @@ wxIcon wxStaticBitmap::GetIcon() const
wxSize wxStaticBitmap::DoGetBestSize() const
{
wxSize sz = wxStaticBitmapBase::DoGetBestSize();
wxTheme::Get()->GetRenderer()->AdjustSize(&sz, this);
return sz;
return AdjustSize(wxStaticBitmapBase::DoGetBestSize());
}
void wxStaticBitmap::DoDraw(wxControlRenderer *renderer)

4
src/univ/stattext.cpp
View File

@@ -84,9 +84,7 @@ wxSize wxStaticText::DoGetBestSize() const
wxCoord width, height;
dc.GetMultiLineTextExtent(GetLabel(), &width, &height);
wxSize sz(width, height);
wxTheme::Get()->GetRenderer()->AdjustSize(&sz, this);
return sz;
return AdjustSize(wxSize(width, height));
}
// ----------------------------------------------------------------------------

13
src/univ/themes/gtk.cpp
View File

@@ -249,7 +249,7 @@ wxInputHandler *wxGTKTheme::GetInputHandler(const wxString& control)
// create a new handler
n = m_handlerNames.Add(control);
if ( control == _T("wxButton") )
if ( control.Matches(_T("wx*Button")) )
handler = new wxStdButtonInputHandler(GetInputHandler(_T("wxControl")));
else if ( control == _T("wxScrollBar") )
handler = new wxGTKScrollBarInputHandler(m_renderer,
@@ -284,7 +284,7 @@ wxColour wxGTKColourScheme::Get(wxGTKColourScheme::StdColour col,
case CONTROL:
if ( flags & wxCONTROL_PRESSED )
{
return wxColour(0x7f7f7f);
return wxColour(0xc3c3c3);
}
else if ( flags & wxCONTROL_CURRENT )
{
@@ -892,9 +892,14 @@ void wxGTKRenderer::AdjustSize(wxSize *size, const wxWindow *window)
{
if ( wxDynamicCast(window, wxButton) )
{
// TODO
// TODO: this is ad hoc...
size->x += 3*window->GetCharWidth();
size->y = (11*(window->GetCharHeight() + 8))/10;
wxCoord minBtnHeight = (11*(window->GetCharHeight() + 8))/10;
if ( size->y < minBtnHeight )
size->y = minBtnHeight;
// button border width
size->y += 4;
}
else
{

2
src/univ/themes/win32.cpp
View File

@@ -283,7 +283,7 @@ wxInputHandler *wxWin32Theme::GetInputHandler(const wxString& control)
// create a new handler
n = m_handlerNames.Add(control);
if ( control == _T("wxButton") )
if ( control.Matches(_T("wx*Button")) )
handler = new wxStdButtonInputHandler(GetInputHandler(_T("wxControl")));
else if ( control == _T("wxScrollBar") )
handler = new wxWin32ScrollBarInputHandler(m_renderer,