wxPython/src/controls.i

/////////////////////////////////////////////////////////////////////////////
// Name:        controls.i
// Purpose:     Control (widget) classes for wxPython
//
// Author:      Robin Dunn
//
// Created:     6/10/98
// RCS-ID:      $Id$
// Copyright:   (c) 1998 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

%module controls

%{
#include "helpers.h"
#include <wx/slider.h>
#include <wx/spinbutt.h>
#include <wx/spinctrl.h>
#include <wx/dynarray.h>
#include <wx/statline.h>
#include <wx/tglbtn.h>

#ifdef __WXMSW__
#if wxUSE_OWNER_DRAWN
#include <wx/checklst.h>
#endif
#endif

#ifdef __WXGTK__
#include <wx/checklst.h>
#endif

%}

//----------------------------------------------------------------------

%include typemaps.i
%include my_typemaps.i

// Import some definitions of other classes, etc.
%import _defs.i
%import misc.i
%import windows.i
%import gdi.i
%import events.i

%pragma(python) code = "import wx"

//----------------------------------------------------------------------

%readonly
wxValidator wxDefaultValidator;
%readwrite

//----------------------------------------------------------------------

class wxControl : public wxWindow {
public:
    wxControl(wxWindow *parent,
                       wxWindowID id,
                       const wxPoint& pos=wxDefaultPosition,
                       const wxSize& size=wxDefaultSize,
                       long style=0,
                       const wxValidator& validator=wxDefaultValidator,
                       const char* name="control");

    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"

    void Command(wxCommandEvent& event);
    wxString GetLabel();
    void SetLabel(const wxString& label);
};


//----------------------------------------------------------------------

class wxButton : public wxControl {
public:
    wxButton(wxWindow* parent, wxWindowID id, const wxString& label,
             const wxPoint& pos = wxDefaultPosition,
             const wxSize& size = wxDefaultSize,
             long style = 0,
             const wxValidator& validator = wxDefaultValidator,
             char* name = "button");

    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"

    void SetDefault();
    void SetBackgroundColour(const wxColour& colour);
    void SetForegroundColour(const wxColour& colour);
};


%inline %{
    wxSize wxButton_GetDefaultSize() {
        return wxButton::GetDefaultSize();
    }
%}

//----------------------------------------------------------------------

class wxBitmapButton : public wxButton {
public:
    wxBitmapButton(wxWindow* parent, wxWindowID id, const wxBitmap& bitmap,
                   const wxPoint& pos = wxDefaultPosition,
                   const wxSize& size = wxDefaultSize,
                   long style = wxBU_AUTODRAW,
                   const wxValidator& validator = wxDefaultValidator,
                   char* name = "button");

    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"

    wxBitmap& GetBitmapLabel();
    wxBitmap& GetBitmapDisabled();
    wxBitmap& GetBitmapFocus();
    wxBitmap& GetBitmapSelected();
    void SetBitmapDisabled(const wxBitmap& bitmap);
    void SetBitmapFocus(const wxBitmap& bitmap);
    void SetBitmapSelected(const wxBitmap& bitmap);
    void SetBitmapLabel(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; }
};

//----------------------------------------------------------------------

class wxCheckBox : public wxControl {
public:
    wxCheckBox(wxWindow* parent, wxWindowID id, const wxString& label,
               const wxPoint& pos = wxDefaultPosition,
               const wxSize& size = wxDefaultSize,
               long style = 0,
               const wxValidator& val = wxDefaultValidator,
               char* name = "checkBox");

    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"

    bool GetValue();
    void SetValue(const bool state);
};

//----------------------------------------------------------------------

class wxChoice : public wxControl {
public:
    wxChoice(wxWindow *parent, wxWindowID id,
             const wxPoint& pos = wxDefaultPosition,
             const wxSize& size = wxDefaultSize,
             int LCOUNT=0, wxString* choices=NULL,
             long style = 0,
             const wxValidator& validator = wxDefaultValidator,
             char* name = "choice");

    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"

    void Append(const wxString& item);
    void Clear();
    void Delete(int n);
    int FindString(const wxString& string);
    int GetColumns();
    int GetSelection();
    wxString GetString(const int n);
    wxString GetStringSelection();
    int GetCount();
    void SetColumns(const int n = 1);
    void SetSelection(const int n);
    void SetStringSelection(const wxString& string);
    void SetString(int n, const wxString& s);

    %pragma(python) addtoclass = "
    Number = GetCount
    Select = SetSelection
    "

};

//----------------------------------------------------------------------

class wxComboBox : public wxChoice {
public:
    wxComboBox(wxWindow* parent, wxWindowID id, char* value = "",
               const wxPoint& pos = wxDefaultPosition,
               const wxSize& size = wxDefaultSize,
               int LCOUNT=0, wxString* choices=NULL,
               long style = 0,
               const wxValidator& validator = wxDefaultValidator,
               char* name = "comboBox");

    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"

    void Append(const wxString& item);
    // TODO: void Append(const wxString& item, char* clientData);
    void Clear();
    void Copy();
    void Cut();
    void Delete(int n);
    // NotMember??:    void Deselect(int n);
    int FindString(const wxString& string);
    // TODO: char* GetClientData(const int n);
    long GetInsertionPoint();
    long GetLastPosition();
    int GetSelection();
    wxString GetString(int n);
    wxString GetStringSelection();
    wxString GetValue();
    void Paste();
    void Replace(long from, long to, const wxString& text);
    void Remove(long from, long to);
    // TODO:    void SetClientData(const int n, char* data);
    void SetInsertionPoint(long pos);
    void SetInsertionPointEnd();
    void SetSelection(int n);
    %name(SetMark)void SetSelection(long from, long to);
    void SetValue(const wxString& text);
    void SetEditable(bool editable);
};

//----------------------------------------------------------------------

class wxGauge : public wxControl {
public:
    wxGauge(wxWindow* parent, wxWindowID id, int range,
            const wxPoint& pos = wxDefaultPosition,
            const wxSize& size = wxDefaultSize,
            long style = wxGA_HORIZONTAL,
            const wxValidator& validator = wxDefaultValidator,
            char* name = "gauge");

    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"

    int GetBezelFace();
    int GetRange();
    int GetShadowWidth();
    int GetValue();
    void SetBezelFace(int width);
    void SetRange(int range);
    void SetShadowWidth(int width);
    void SetValue(int pos);
};

//----------------------------------------------------------------------

class wxStaticBox : public wxControl {
public:
    wxStaticBox(wxWindow* parent, wxWindowID id, const wxString& label,
                const wxPoint& pos = wxDefaultPosition,
                const wxSize& size = wxDefaultSize,
                long style = 0,
                char* name = "staticBox");
};


//----------------------------------------------------------------------


class wxStaticLine : public wxControl {
public:
    wxStaticLine( wxWindow *parent, wxWindowID id,
                  const wxPoint &pos = wxDefaultPosition,
                  const wxSize &size = wxDefaultSize,
                  long style = wxLI_HORIZONTAL,
                  const char* name = "staticLine" );
};


//----------------------------------------------------------------------

class wxStaticText : public wxControl {
public:
    wxStaticText(wxWindow* parent, wxWindowID id, const wxString& label,
                 const wxPoint& pos = wxDefaultPosition,
                 const wxSize& size = wxDefaultSize,
                 long style = 0,
                 char* name = "staticText");

    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"

    wxString GetLabel();
    void SetLabel(const wxString& label);
};

//----------------------------------------------------------------------

class wxListBox : public wxControl {
public:
    wxListBox(wxWindow* parent, wxWindowID id,
              const wxPoint& pos = wxDefaultPosition,
              const wxSize& size = wxDefaultSize,
              int LCOUNT, wxString* choices = NULL,
              long style = 0,
              const wxValidator& validator = wxDefaultValidator,
              char* name = "listBox");

    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"

    void Append(const wxString& item);
    // TODO:    void Append(const wxString& item, char* clientData);
    void Clear();
    void Delete(int n);
    void Deselect(int n);
    int FindString(const wxString& string);
    // TODO:    char* GetClientData(const int n);
    int GetSelection();

    // int GetSelections(int **selections);
    %addmethods {
      PyObject* GetSelections() {
          wxArrayInt lst;
          self->GetSelections(lst);
          PyObject *tup = PyTuple_New(lst.GetCount());
          for(size_t i=0; i<lst.GetCount(); i++) {
              PyTuple_SetItem(tup, i, PyInt_FromLong(lst[i]));
          }
          return tup;
      }
    }

    void InsertItems(int LCOUNT, wxString* choices, int pos);

    wxString GetString(int n);
    wxString GetStringSelection();
    int GetCount();
    %pragma(python) addtoclass = "Number = GetCount"
    bool IsSelected(const int n);
    bool Selected(const int n);
    void Set(int LCOUNT, wxString* choices);
    // TODO:    void SetClientData(const int n, char* data);
    void SetFirstItem(int n);
    %name(SetFirstItemStr)void SetFirstItem(const wxString& string);
    void SetSelection(int n, bool select = TRUE);
    void SetString(int n, const wxString& string);
    void SetStringSelection(const wxString& string, bool select = TRUE);
};


//----------------------------------------------------------------------

class wxCheckListBox : public wxListBox {
public:
    wxCheckListBox(wxWindow *parent, wxWindowID id,
                   const wxPoint& pos = wxDefaultPosition,
                   const wxSize& size = wxDefaultSize,
                   int LCOUNT = 0,
                   wxString* choices = NULL,
                   long style = 0,
                   const wxValidator& validator = wxDefaultValidator,
                   char* name = "listBox");

    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"

    bool  IsChecked(int uiIndex);
    void  Check(int uiIndex, int bCheck = TRUE);
    void InsertItems(int LCOUNT, wxString* choices, int pos);

    int GetItemHeight();
};

//----------------------------------------------------------------------


class wxTextAttr
{
public:
    // ctors
    wxTextAttr(const wxColour& colText = wxNullColour,
               const wxColour& colBack = wxNullColour,
               const wxFont& font = wxNullFont);
    ~wxTextAttr();

    // setters
    void SetTextColour(const wxColour& colText);
    void SetBackgroundColour(const wxColour& colBack);
    void SetFont(const wxFont& font);

    // accessors
    bool HasTextColour() const;
    bool HasBackgroundColour() const;
    bool HasFont() const;

    const wxColour& GetTextColour() const;
    const wxColour& GetBackgroundColour() const;
    const wxFont& GetFont() const;
};


class wxTextCtrl : public wxControl {
public:
    wxTextCtrl(wxWindow* parent, wxWindowID id, char* value = "",
               const wxPoint& pos = wxDefaultPosition,
               const wxSize& size = wxDefaultSize,
               long style = 0,
               const wxValidator& validator = wxDefaultValidator,
               char* name = "text");

    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"

    void Clear();
    void Copy();
    void Cut();
    void DiscardEdits();
    long GetInsertionPoint();
    long GetLastPosition();
    int GetLineLength(long lineNo);
    wxString GetLineText(long lineNo);
    int GetNumberOfLines();
    wxString GetValue();
    bool IsModified();
    bool LoadFile(const wxString& filename);
    void Paste();
    void PositionToXY(long pos, long *OUTPUT, long *OUTPUT);
    void Remove(long from, long to);
    void Replace(long from, long to, const wxString& value);
    bool SaveFile(const wxString& filename);
    void SetEditable(bool editable);
    void SetInsertionPoint(long pos);
    void SetInsertionPointEnd();
    void SetSelection(long from, long to);
    void SetValue(const wxString& value);
    void ShowPosition(long pos);
    void WriteText(const wxString& text);
    void AppendText(const wxString& text);
    long XYToPosition(long x, long y);

    bool CanCopy();
    bool CanCut();
    bool CanPaste();
    bool CanRedo();
    bool CanUndo();
    void GetSelection(long* OUTPUT, long* OUTPUT);
    bool IsEditable();
    void Undo();
    void Redo();

    bool SetStyle(long start, long end, const wxTextAttr& style);
    bool SetDefaultStyle(const wxTextAttr& style);
    const wxTextAttr& GetDefaultStyle() const;

    %addmethods {
        void write(const wxString& text) {
            self->AppendText(text);
        }
    }
};

//----------------------------------------------------------------------

class wxScrollBar : public wxControl {
public:
    wxScrollBar(wxWindow* parent, wxWindowID id = -1,
                const wxPoint& pos = wxDefaultPosition,
                const wxSize& size = wxDefaultSize,
                long style = wxSB_HORIZONTAL,
                const wxValidator& validator = wxDefaultValidator,
                char* name = "scrollBar");

    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"

    int GetRange();
    int GetPageSize();
    int GetThumbPosition();
    int GetThumbSize();
    %name(GetThumbLength) int GetThumbSize();  // to match the docs
    void SetThumbPosition(int viewStart);
    void SetScrollbar(int position, int thumbSize,
                      int range,    int pageSize,
                      bool refresh = TRUE);
};

//----------------------------------------------------------------------

class wxSpinButton : public wxControl {
public:
    wxSpinButton(wxWindow* parent, wxWindowID id = -1,
                 const wxPoint& pos = wxDefaultPosition,
                 const wxSize& size = wxDefaultSize,
                 long style = wxSP_HORIZONTAL,
                 char* name = "spinButton");

    int GetMax();
    int GetMin();
    int GetValue();
    void SetRange(int min, int max);
    void SetValue(int value);
};

//----------------------------------------------------------------------

class wxStaticBitmap : public wxControl {
public:
    wxStaticBitmap(wxWindow* parent, wxWindowID id,
                   const wxBitmap& bitmap,
                   const wxPoint& pos = wxDefaultPosition,
                   const wxSize& size = wxDefaultSize,
                   long style = 0,
                   char* name = "staticBitmap");

    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"

    const wxBitmap& GetBitmap();
    void SetBitmap(const wxBitmap& bitmap);
    void SetIcon(const wxIcon& icon);
};

//----------------------------------------------------------------------

class wxRadioBox : public wxControl {
public:
    wxRadioBox(wxWindow* parent, wxWindowID id,
               const wxString& label,
               const wxPoint& point = wxDefaultPosition,
               const wxSize& size = wxDefaultSize,
               int LCOUNT = 0, wxString* choices = NULL,
               int majorDimension = 0,
               long style = wxRA_HORIZONTAL,
               const wxValidator& validator = wxDefaultValidator,
               char* name = "radioBox");

    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"

    void Enable(bool enable);
    %name(EnableItem)void Enable(int n, bool enable);
    int FindString(const wxString& string);

    wxString GetString(int n);

#ifdef __WXMSW__
    void SetString(int n, const wxString& label);
    %pragma(python) addtoclass = "
    GetItemLabel = GetString
    SetItemLabel = SetString
    "
    int GetColumnCount();
    int GetRowCount();
#else
    %name(GetItemLabel)wxString GetLabel( int item );
    %name(SetItemLabel)void SetLabel( int item, const wxString& label );
#endif

    int GetSelection();
    wxString GetStringSelection();
    int GetCount();
    %pragma(python) addtoclass = "Number = GetCount"

    void SetSelection(int n);
    void SetStringSelection(const wxString& string);
    void Show(bool show);
    %name(ShowItem)void Show(int item, bool show);
};

//----------------------------------------------------------------------

class wxRadioButton : public wxControl {
public:
    wxRadioButton(wxWindow* parent, wxWindowID id,
                  const wxString& label,
                  const wxPoint& pos = wxDefaultPosition,
                  const wxSize& size = wxDefaultSize,
                  long style = 0,
                  const wxValidator& validator = wxDefaultValidator,
                  char* name = "radioButton");

    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"

    bool GetValue();
    void SetValue(bool value);
};

//----------------------------------------------------------------------

class wxSlider : public wxControl {
public:
    wxSlider(wxWindow* parent, wxWindowID id,
             int value, int minValue, int maxValue,
             const wxPoint& point = wxDefaultPosition,
             const wxSize& size = wxDefaultSize,
             long style = wxSL_HORIZONTAL,
             const wxValidator& validator = wxDefaultValidator,
             char* name = "slider");

    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"

    void ClearSel();
    void ClearTicks();
    int GetLineSize();
    int GetMax();
    int GetMin();
    int GetPageSize();
    int GetSelEnd();
    int GetSelStart();
    int GetThumbLength();
    int GetTickFreq();
    int GetValue();
    void SetRange(int minValue, int maxValue);
    void SetTickFreq(int n, int pos);
    void SetLineSize(int lineSize);
    void SetPageSize(int pageSize);
    void SetSelection(int startPos, int endPos);
    void SetThumbLength(int len);
    void SetTick(int tickPos);
    void SetValue(int value);
};


//----------------------------------------------------------------------

class wxSpinCtrl : public wxSpinButton {
public:
    wxSpinCtrl(wxWindow *parent,
               wxWindowID id = -1,
               const char* value = "",
               const wxPoint& pos = wxDefaultPosition,
               const wxSize& size = wxDefaultSize,
               long style = wxSP_ARROW_KEYS,
               int min = 0, int max = 100, int initial = 0,
               const char* name = "wxSpinCtrl");


    int GetMax();
    int GetMin();
    int GetValue();
    void SetRange(int min, int max);
    void SetValue(int value);

};


//----------------------------------------------------------------------

enum { wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, };

class wxToggleButton : public wxControl {
public:
    wxToggleButton(wxWindow *parent,
                   wxWindowID id,
                   const wxString& label,
                   const wxPoint& pos = wxDefaultPosition,
                   const wxSize& size = wxDefaultSize,
                   long style = 0,
                   const wxValidator& validator = wxDefaultValidator,
                   const char* name = "toggle");

    void SetValue(bool value);
    bool GetValue() const ;
    void SetLabel(const wxString& label);

};

//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: controls.i
	3	// Purpose: Control (widget) classes for wxPython
	4	//
	5	// Author: Robin Dunn
	6	//
	7	// Created: 6/10/98
	8	// RCS-ID: $Id$
	9	// Copyright: (c) 1998 by Total Control Software
	10	// Licence: wxWindows license
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13	%module controls
	14
	15	%{
	16	#include "helpers.h"
	17	#include <wx/slider.h>
	18	#include <wx/spinbutt.h>
	19	#include <wx/spinctrl.h>
	20	#include <wx/dynarray.h>
	21	#include <wx/statline.h>
	22	#include <wx/tglbtn.h>
	23
	24	#ifdef __WXMSW__
	25	#if wxUSE_OWNER_DRAWN
	26	#include <wx/checklst.h>
	27	#endif
	28	#endif
	29
	30	#ifdef __WXGTK__
	31	#include <wx/checklst.h>
	32	#endif
	33
	34	%}
	35
	36	//----------------------------------------------------------------------
	37
	38	%include typemaps.i
	39	%include my_typemaps.i
	40
	41	// Import some definitions of other classes, etc.
	42	%import _defs.i
	43	%import misc.i
	44	%import windows.i
	45	%import gdi.i
	46	%import events.i
	47
	48	%pragma(python) code = "import wx"
	49
	50	//----------------------------------------------------------------------
	51
	52	%readonly
	53	wxValidator wxDefaultValidator;
	54	%readwrite
	55
	56	//----------------------------------------------------------------------
	57
	58	class wxControl : public wxWindow {
	59	public:
	60	wxControl(wxWindow *parent,
	61	wxWindowID id,
	62	const wxPoint& pos=wxDefaultPosition,
	63	const wxSize& size=wxDefaultSize,
	64	long style=0,
	65	const wxValidator& validator=wxDefaultValidator,
	66	const char* name="control");
	67
	68	%pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
	69
	70	void Command(wxCommandEvent& event);
	71	wxString GetLabel();
	72	void SetLabel(const wxString& label);
	73	};
	74
	75
	76	//----------------------------------------------------------------------
	77
	78	class wxButton : public wxControl {
	79	public:
	80	wxButton(wxWindow* parent, wxWindowID id, const wxString& label,
	81	const wxPoint& pos = wxDefaultPosition,
	82	const wxSize& size = wxDefaultSize,
	83	long style = 0,
	84	const wxValidator& validator = wxDefaultValidator,
	85	char* name = "button");
	86
	87	%pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
	88
	89	void SetDefault();
	90	void SetBackgroundColour(const wxColour& colour);
	91	void SetForegroundColour(const wxColour& colour);
	92	};
	93
	94
	95	%inline %{
	96	wxSize wxButton_GetDefaultSize() {
	97	return wxButton::GetDefaultSize();
	98	}
	99	%}
	100
	101	//----------------------------------------------------------------------
	102
	103	class wxBitmapButton : public wxButton {
	104	public:
	105	wxBitmapButton(wxWindow* parent, wxWindowID id, const wxBitmap& bitmap,
	106	const wxPoint& pos = wxDefaultPosition,
	107	const wxSize& size = wxDefaultSize,
	108	long style = wxBU_AUTODRAW,
	109	const wxValidator& validator = wxDefaultValidator,
	110	char* name = "button");
	111
	112	%pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
	113
	114	wxBitmap& GetBitmapLabel();
	115	wxBitmap& GetBitmapDisabled();
	116	wxBitmap& GetBitmapFocus();
	117	wxBitmap& GetBitmapSelected();
	118	void SetBitmapDisabled(const wxBitmap& bitmap);
	119	void SetBitmapFocus(const wxBitmap& bitmap);
	120	void SetBitmapSelected(const wxBitmap& bitmap);
	121	void SetBitmapLabel(const wxBitmap& bitmap);
	122
	123	void SetMargins(int x, int y) { m_marginX = x; m_marginY = y; }
	124	int GetMarginX() const { return m_marginX; }
	125	int GetMarginY() const { return m_marginY; }
	126	};
	127
	128	//----------------------------------------------------------------------
	129
	130	class wxCheckBox : public wxControl {
	131	public:
	132	wxCheckBox(wxWindow* parent, wxWindowID id, const wxString& label,
	133	const wxPoint& pos = wxDefaultPosition,
	134	const wxSize& size = wxDefaultSize,
	135	long style = 0,
	136	const wxValidator& val = wxDefaultValidator,
	137	char* name = "checkBox");
	138
	139	%pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
	140
	141	bool GetValue();
	142	void SetValue(const bool state);
	143	};
	144
	145	//----------------------------------------------------------------------
	146
	147	class wxChoice : public wxControl {
	148	public:
	149	wxChoice(wxWindow *parent, wxWindowID id,
	150	const wxPoint& pos = wxDefaultPosition,
	151	const wxSize& size = wxDefaultSize,
	152	int LCOUNT=0, wxString* choices=NULL,
	153	long style = 0,
	154	const wxValidator& validator = wxDefaultValidator,
	155	char* name = "choice");
	156
	157	%pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
	158
	159	void Append(const wxString& item);
	160	void Clear();
	161	void Delete(int n);
	162	int FindString(const wxString& string);
	163	int GetColumns();
	164	int GetSelection();
	165	wxString GetString(const int n);
	166	wxString GetStringSelection();
	167	int GetCount();
	168	void SetColumns(const int n = 1);
	169	void SetSelection(const int n);
	170	void SetStringSelection(const wxString& string);
	171	void SetString(int n, const wxString& s);
	172
	173	%pragma(python) addtoclass = "
	174	Number = GetCount
	175	Select = SetSelection
	176	"
	177
	178	};
	179
	180	//----------------------------------------------------------------------
	181
	182	class wxComboBox : public wxChoice {
	183	public:
	184	wxComboBox(wxWindow* parent, wxWindowID id, char* value = "",
	185	const wxPoint& pos = wxDefaultPosition,
	186	const wxSize& size = wxDefaultSize,
	187	int LCOUNT=0, wxString* choices=NULL,
	188	long style = 0,
	189	const wxValidator& validator = wxDefaultValidator,
	190	char* name = "comboBox");
	191
	192	%pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
	193
	194	void Append(const wxString& item);
	195	// TODO: void Append(const wxString& item, char* clientData);
	196	void Clear();
	197	void Copy();
	198	void Cut();
	199	void Delete(int n);
	200	// NotMember??: void Deselect(int n);
	201	int FindString(const wxString& string);
	202	// TODO: char* GetClientData(const int n);
	203	long GetInsertionPoint();
	204	long GetLastPosition();
	205	int GetSelection();
	206	wxString GetString(int n);
	207	wxString GetStringSelection();
	208	wxString GetValue();
	209	void Paste();
	210	void Replace(long from, long to, const wxString& text);
	211	void Remove(long from, long to);
	212	// TODO: void SetClientData(const int n, char* data);
	213	void SetInsertionPoint(long pos);
	214	void SetInsertionPointEnd();
	215	void SetSelection(int n);
	216	%name(SetMark)void SetSelection(long from, long to);
	217	void SetValue(const wxString& text);
	218	void SetEditable(bool editable);
	219	};
	220
	221	//----------------------------------------------------------------------
	222
	223	class wxGauge : public wxControl {
	224	public:
	225	wxGauge(wxWindow* parent, wxWindowID id, int range,
	226	const wxPoint& pos = wxDefaultPosition,
	227	const wxSize& size = wxDefaultSize,
	228	long style = wxGA_HORIZONTAL,
	229	const wxValidator& validator = wxDefaultValidator,
	230	char* name = "gauge");
	231
	232	%pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
	233
	234	int GetBezelFace();
	235	int GetRange();
	236	int GetShadowWidth();
	237	int GetValue();
	238	void SetBezelFace(int width);
	239	void SetRange(int range);
	240	void SetShadowWidth(int width);
	241	void SetValue(int pos);
	242	};
	243
	244	//----------------------------------------------------------------------
	245
	246	class wxStaticBox : public wxControl {
	247	public:
	248	wxStaticBox(wxWindow* parent, wxWindowID id, const wxString& label,
	249	const wxPoint& pos = wxDefaultPosition,
	250	const wxSize& size = wxDefaultSize,
	251	long style = 0,
	252	char* name = "staticBox");
	253	};
	254
	255
	256	//----------------------------------------------------------------------
	257
	258
	259	class wxStaticLine : public wxControl {
	260	public:
	261	wxStaticLine( wxWindow *parent, wxWindowID id,
	262	const wxPoint &pos = wxDefaultPosition,
	263	const wxSize &size = wxDefaultSize,
	264	long style = wxLI_HORIZONTAL,
	265	const char* name = "staticLine" );
	266	};
	267
	268
	269	//----------------------------------------------------------------------
	270
	271	class wxStaticText : public wxControl {
	272	public:
	273	wxStaticText(wxWindow* parent, wxWindowID id, const wxString& label,
	274	const wxPoint& pos = wxDefaultPosition,
	275	const wxSize& size = wxDefaultSize,
	276	long style = 0,
	277	char* name = "staticText");
	278
	279	%pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
	280
	281	wxString GetLabel();
	282	void SetLabel(const wxString& label);
	283	};
	284
	285	//----------------------------------------------------------------------
	286
	287	class wxListBox : public wxControl {
	288	public:
	289	wxListBox(wxWindow* parent, wxWindowID id,
	290	const wxPoint& pos = wxDefaultPosition,
	291	const wxSize& size = wxDefaultSize,
	292	int LCOUNT, wxString* choices = NULL,
	293	long style = 0,
	294	const wxValidator& validator = wxDefaultValidator,
	295	char* name = "listBox");
	296
	297	%pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
	298
	299	void Append(const wxString& item);
	300	// TODO: void Append(const wxString& item, char* clientData);
	301	void Clear();
	302	void Delete(int n);
	303	void Deselect(int n);
	304	int FindString(const wxString& string);
	305	// TODO: char* GetClientData(const int n);
	306	int GetSelection();
	307
	308	// int GetSelections(int **selections);
	309	%addmethods {
	310	PyObject* GetSelections() {
	311	wxArrayInt lst;
	312	self->GetSelections(lst);
	313	PyObject *tup = PyTuple_New(lst.GetCount());
	314	for(size_t i=0; i<lst.GetCount(); i++) {
	315	PyTuple_SetItem(tup, i, PyInt_FromLong(lst[i]));
	316	}
	317	return tup;
	318	}
	319	}
	320
	321	void InsertItems(int LCOUNT, wxString* choices, int pos);
	322
	323	wxString GetString(int n);
	324	wxString GetStringSelection();
	325	int GetCount();
	326	%pragma(python) addtoclass = "Number = GetCount"
	327	bool IsSelected(const int n);
	328	bool Selected(const int n);
	329	void Set(int LCOUNT, wxString* choices);
	330	// TODO: void SetClientData(const int n, char* data);
	331	void SetFirstItem(int n);
	332	%name(SetFirstItemStr)void SetFirstItem(const wxString& string);
	333	void SetSelection(int n, bool select = TRUE);
	334	void SetString(int n, const wxString& string);
	335	void SetStringSelection(const wxString& string, bool select = TRUE);
	336	};
	337
	338
	339	//----------------------------------------------------------------------
	340
	341	class wxCheckListBox : public wxListBox {
	342	public:
	343	wxCheckListBox(wxWindow *parent, wxWindowID id,
	344	const wxPoint& pos = wxDefaultPosition,
	345	const wxSize& size = wxDefaultSize,
	346	int LCOUNT = 0,
	347	wxString* choices = NULL,
	348	long style = 0,
	349	const wxValidator& validator = wxDefaultValidator,
	350	char* name = "listBox");
	351
	352	%pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
	353
	354	bool IsChecked(int uiIndex);
	355	void Check(int uiIndex, int bCheck = TRUE);
	356	void InsertItems(int LCOUNT, wxString* choices, int pos);
	357
	358	int GetItemHeight();
	359	};
	360
	361	//----------------------------------------------------------------------
	362
	363
	364	class wxTextAttr
	365	{
	366	public:
	367	// ctors
	368	wxTextAttr(const wxColour& colText = wxNullColour,
	369	const wxColour& colBack = wxNullColour,
	370	const wxFont& font = wxNullFont);
	371	~wxTextAttr();
	372
	373	// setters
	374	void SetTextColour(const wxColour& colText);
	375	void SetBackgroundColour(const wxColour& colBack);
	376	void SetFont(const wxFont& font);
	377
	378	// accessors
	379	bool HasTextColour() const;
	380	bool HasBackgroundColour() const;
	381	bool HasFont() const;
	382
	383	const wxColour& GetTextColour() const;
	384	const wxColour& GetBackgroundColour() const;
	385	const wxFont& GetFont() const;
	386	};
	387
	388
	389
	390	class wxTextCtrl : public wxControl {
	391	public:
	392	wxTextCtrl(wxWindow* parent, wxWindowID id, char* value = "",
	393	const wxPoint& pos = wxDefaultPosition,
	394	const wxSize& size = wxDefaultSize,
	395	long style = 0,
	396	const wxValidator& validator = wxDefaultValidator,
	397	char* name = "text");
	398
	399	%pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
	400
	401	void Clear();
	402	void Copy();
	403	void Cut();
	404	void DiscardEdits();
	405	long GetInsertionPoint();
	406	long GetLastPosition();
	407	int GetLineLength(long lineNo);
	408	wxString GetLineText(long lineNo);
	409	int GetNumberOfLines();
	410	wxString GetValue();
	411	bool IsModified();
	412	bool LoadFile(const wxString& filename);
	413	void Paste();
	414	void PositionToXY(long pos, long OUTPUT, long OUTPUT);
	415	void Remove(long from, long to);
	416	void Replace(long from, long to, const wxString& value);
	417	bool SaveFile(const wxString& filename);
	418	void SetEditable(bool editable);
	419	void SetInsertionPoint(long pos);
	420	void SetInsertionPointEnd();
	421	void SetSelection(long from, long to);
	422	void SetValue(const wxString& value);
	423	void ShowPosition(long pos);
	424	void WriteText(const wxString& text);
	425	void AppendText(const wxString& text);
	426	long XYToPosition(long x, long y);
	427
	428	bool CanCopy();
	429	bool CanCut();
	430	bool CanPaste();
	431	bool CanRedo();
	432	bool CanUndo();
	433	void GetSelection(long* OUTPUT, long* OUTPUT);
	434	bool IsEditable();
	435	void Undo();
	436	void Redo();
	437
	438	bool SetStyle(long start, long end, const wxTextAttr& style);
	439	bool SetDefaultStyle(const wxTextAttr& style);
	440	const wxTextAttr& GetDefaultStyle() const;
	441
	442	%addmethods {
	443	void write(const wxString& text) {
	444	self->AppendText(text);
	445	}
	446	}
	447	};
	448
	449	//----------------------------------------------------------------------
	450
	451	class wxScrollBar : public wxControl {
	452	public:
	453	wxScrollBar(wxWindow* parent, wxWindowID id = -1,
	454	const wxPoint& pos = wxDefaultPosition,
	455	const wxSize& size = wxDefaultSize,
	456	long style = wxSB_HORIZONTAL,
	457	const wxValidator& validator = wxDefaultValidator,
	458	char* name = "scrollBar");
	459
	460	%pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
	461
	462	int GetRange();
	463	int GetPageSize();
	464	int GetThumbPosition();
	465	int GetThumbSize();
	466	%name(GetThumbLength) int GetThumbSize(); // to match the docs
	467	void SetThumbPosition(int viewStart);
	468	void SetScrollbar(int position, int thumbSize,
	469	int range, int pageSize,
	470	bool refresh = TRUE);
	471	};
	472
	473	//----------------------------------------------------------------------
	474
	475	class wxSpinButton : public wxControl {
	476	public:
	477	wxSpinButton(wxWindow* parent, wxWindowID id = -1,
	478	const wxPoint& pos = wxDefaultPosition,
	479	const wxSize& size = wxDefaultSize,
	480	long style = wxSP_HORIZONTAL,
	481	char* name = "spinButton");
	482
	483	int GetMax();
	484	int GetMin();
	485	int GetValue();
	486	void SetRange(int min, int max);
	487	void SetValue(int value);
	488	};
	489
	490	//----------------------------------------------------------------------
	491
	492	class wxStaticBitmap : public wxControl {
	493	public:
	494	wxStaticBitmap(wxWindow* parent, wxWindowID id,
	495	const wxBitmap& bitmap,
	496	const wxPoint& pos = wxDefaultPosition,
	497	const wxSize& size = wxDefaultSize,
	498	long style = 0,
	499	char* name = "staticBitmap");
	500
	501	%pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
	502
	503	const wxBitmap& GetBitmap();
	504	void SetBitmap(const wxBitmap& bitmap);
	505	void SetIcon(const wxIcon& icon);
	506	};
	507
	508	//----------------------------------------------------------------------
	509
	510	class wxRadioBox : public wxControl {
	511	public:
	512	wxRadioBox(wxWindow* parent, wxWindowID id,
	513	const wxString& label,
	514	const wxPoint& point = wxDefaultPosition,
	515	const wxSize& size = wxDefaultSize,
	516	int LCOUNT = 0, wxString* choices = NULL,
	517	int majorDimension = 0,
	518	long style = wxRA_HORIZONTAL,
	519	const wxValidator& validator = wxDefaultValidator,
	520	char* name = "radioBox");
	521
	522	%pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
	523
	524	void Enable(bool enable);
	525	%name(EnableItem)void Enable(int n, bool enable);
	526	int FindString(const wxString& string);
	527
	528	wxString GetString(int n);
	529
	530	#ifdef __WXMSW__
	531	void SetString(int n, const wxString& label);
	532	%pragma(python) addtoclass = "
	533	GetItemLabel = GetString
	534	SetItemLabel = SetString
	535	"
	536	int GetColumnCount();
	537	int GetRowCount();
	538	#else
	539	%name(GetItemLabel)wxString GetLabel( int item );
	540	%name(SetItemLabel)void SetLabel( int item, const wxString& label );
	541	#endif
	542
	543	int GetSelection();
	544	wxString GetStringSelection();
	545	int GetCount();
	546	%pragma(python) addtoclass = "Number = GetCount"
	547
	548	void SetSelection(int n);
	549	void SetStringSelection(const wxString& string);
	550	void Show(bool show);
	551	%name(ShowItem)void Show(int item, bool show);
	552	};
	553
	554	//----------------------------------------------------------------------
	555
	556	class wxRadioButton : public wxControl {
	557	public:
	558	wxRadioButton(wxWindow* parent, wxWindowID id,
	559	const wxString& label,
	560	const wxPoint& pos = wxDefaultPosition,
	561	const wxSize& size = wxDefaultSize,
	562	long style = 0,
	563	const wxValidator& validator = wxDefaultValidator,
	564	char* name = "radioButton");
	565
	566	%pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
	567
	568	bool GetValue();
	569	void SetValue(bool value);
	570	};
	571
	572	//----------------------------------------------------------------------
	573
	574	class wxSlider : public wxControl {
	575	public:
	576	wxSlider(wxWindow* parent, wxWindowID id,
	577	int value, int minValue, int maxValue,
	578	const wxPoint& point = wxDefaultPosition,
	579	const wxSize& size = wxDefaultSize,
	580	long style = wxSL_HORIZONTAL,
	581	const wxValidator& validator = wxDefaultValidator,
	582	char* name = "slider");
	583
	584	%pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
	585
	586	void ClearSel();
	587	void ClearTicks();
	588	int GetLineSize();
	589	int GetMax();
	590	int GetMin();
	591	int GetPageSize();
	592	int GetSelEnd();
	593	int GetSelStart();
	594	int GetThumbLength();
	595	int GetTickFreq();
	596	int GetValue();
	597	void SetRange(int minValue, int maxValue);
	598	void SetTickFreq(int n, int pos);
	599	void SetLineSize(int lineSize);
	600	void SetPageSize(int pageSize);
	601	void SetSelection(int startPos, int endPos);
	602	void SetThumbLength(int len);
	603	void SetTick(int tickPos);
	604	void SetValue(int value);
	605	};
	606
	607
	608	//----------------------------------------------------------------------
	609
	610	class wxSpinCtrl : public wxSpinButton {
	611	public:
	612	wxSpinCtrl(wxWindow *parent,
	613	wxWindowID id = -1,
	614	const char* value = "",
	615	const wxPoint& pos = wxDefaultPosition,
	616	const wxSize& size = wxDefaultSize,
	617	long style = wxSP_ARROW_KEYS,
	618	int min = 0, int max = 100, int initial = 0,
	619	const char* name = "wxSpinCtrl");
	620
	621
	622	int GetMax();
	623	int GetMin();
	624	int GetValue();
	625	void SetRange(int min, int max);
	626	void SetValue(int value);
	627
	628	};
	629
	630
	631	//----------------------------------------------------------------------
	632
	633	enum { wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, };
	634
	635	class wxToggleButton : public wxControl {
	636	public:
	637	wxToggleButton(wxWindow *parent,
	638	wxWindowID id,
	639	const wxString& label,
	640	const wxPoint& pos = wxDefaultPosition,
	641	const wxSize& size = wxDefaultSize,
	642	long style = 0,
	643	const wxValidator& validator = wxDefaultValidator,
	644	const char* name = "toggle");
	645
	646	void SetValue(bool value);
	647	bool GetValue() const ;
	648	void SetLabel(const wxString& label);
	649
	650	};
	651
	652	//----------------------------------------------------------------------
	653	//----------------------------------------------------------------------
	654	//----------------------------------------------------------------------
	655
	656
	657