utils/wxPython/src/gdi.i

/////////////////////////////////////////////////////////////////////////////
// Name:        gdi.i
// Purpose:     SWIG interface file for wxDC, wxBrush, wxPen, wxFont, etc.
//
// Author:      Robin Dunn
//
// Created:     7/7/97
// RCS-ID:      $Id$
// Copyright:   (c) 1998 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////


%module gdi

%{
#include "helpers.h"
#include <wx/metafile.h>
#include <wx/imaglist.h>
#ifndef __WXMSW__
#include <wx/dcps.h>
#endif
%}

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

%include typemaps.i
%include my_typemaps.i

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

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

//  class wxGDIImage {
//  public:
//      long GetHandle();
//      void SetHandle(long handle);
//      bool Ok();
//      int GetWidth();
//      int GetHeight();
//      int GetDepth();
//      void SetWidth(int w);
//      void SetHeight(int h);
//      void SetDepth(int d);
//      void SetSize(const wxSize& size);
//  };

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

class wxBitmap
//: public wxGDIImage
{
public:
    wxBitmap(const wxString& name, long type);
    ~wxBitmap();

    wxPalette* GetPalette();
    wxMask* GetMask();
    bool LoadFile(const wxString& name, long flags);
    bool SaveFile(const wxString& name, int type, wxPalette* palette = NULL);
    void SetMask(wxMask* mask);
#ifdef __WXMSW__
    void SetPalette(wxPalette& palette);
#endif

    // wxGDIImage methods
#ifdef __WXMSW__
    long GetHandle();
    void SetHandle(long handle);
#endif
    bool Ok();
    int GetWidth();
    int GetHeight();
    int GetDepth();
    void SetWidth(int w);
    void SetHeight(int h);
    void SetDepth(int d);
#ifdef __WXMSW__
    void SetSize(const wxSize& size);
#endif
};


%new wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1);

#ifdef __WXMSW__
%new wxBitmap* wxBitmapFromData(char* data, long type,
                                int width, int height, int depth = 1);
#endif

%{                              // Alternate 'constructor'
    wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1) {
        return new wxBitmap(width, height, depth);
    }

#ifdef __WXMSW__
    wxBitmap* wxBitmapFromData(char* data, long type,
                               int width, int height, int depth = 1) {
        return new wxBitmap((void*)data, type, width, height, depth);
    }
#endif
%}

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

class wxMask {
public:
    wxMask(const wxBitmap& bitmap);
    //~wxMask();
};

%new wxMask* wxMaskColour(const wxBitmap& bitmap, const wxColour& colour);
%{
    wxMask* wxMaskColour(const wxBitmap& bitmap, const wxColour& colour) {
        return new wxMask(bitmap, colour);
    }
%}


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


class wxIcon
//: public wxGDIImage
{
public:
    wxIcon(const wxString& name, long flags,
           int desiredWidth = -1, int desiredHeight = -1);
    ~wxIcon();

    bool LoadFile(const wxString& name, long flags);

    // wxGDIImage methods
#ifdef __WXMSW__
    long GetHandle();
    void SetHandle(long handle);
#endif
    bool Ok();
    int GetWidth();
    int GetHeight();
    int GetDepth();
    void SetWidth(int w);
    void SetHeight(int h);
    void SetDepth(int d);
#ifdef __WXMSW__
    void SetSize(const wxSize& size);
#endif
};


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

class wxCursor
//: public wxGDIImage
{
public:
#ifdef __WXMSW__
    wxCursor(const wxString& cursorName, long flags, int hotSpotX=0, int hotSpotY=0);
#endif
    ~wxCursor();

    // wxGDIImage methods
#ifdef __WXMSW__
    long GetHandle();
    void SetHandle(long handle);
#endif
    bool Ok();
#ifdef __WXMSW__
    int GetWidth();
    int GetHeight();
    int GetDepth();
    void SetWidth(int w);
    void SetHeight(int h);
    void SetDepth(int d);
    void SetSize(const wxSize& size);
#endif
};

%name(wxStockCursor) %new wxCursor* wxPyStockCursor(int id);
%{                              // Alternate 'constructor'
    wxCursor* wxPyStockCursor(int id) {
        return new wxCursor(id);
    }
%}

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


enum wxFontEncoding
{
    wxFONTENCODING_SYSTEM = -1,     // system default
    wxFONTENCODING_DEFAULT,         // current default encoding

    // ISO8859 standard defines a number of single-byte charsets
    wxFONTENCODING_ISO8859_1,       // West European (Latin1)
    wxFONTENCODING_ISO8859_2,       // Central and East European (Latin2)
    wxFONTENCODING_ISO8859_3,       // Esperanto (Latin3)
    wxFONTENCODING_ISO8859_4,       // Baltic languages (Estonian) (Latin4)
    wxFONTENCODING_ISO8859_5,       // Cyrillic
    wxFONTENCODING_ISO8859_6,       // Arabic
    wxFONTENCODING_ISO8859_7,       // Greek
    wxFONTENCODING_ISO8859_8,       // Hebrew
    wxFONTENCODING_ISO8859_9,       // Turkish (Latin5)
    wxFONTENCODING_ISO8859_10,      // Variation of Latin4 (Latin6)
    wxFONTENCODING_ISO8859_11,      // Thai
    wxFONTENCODING_ISO8859_12,      // doesn't exist currently, but put it
                                    // here anyhow to make all ISO8859
                                    // consecutive numbers
    wxFONTENCODING_ISO8859_13,      // Latin7
    wxFONTENCODING_ISO8859_14,      // Latin8
    wxFONTENCODING_ISO8859_15,      // Latin9 (a.k.a. Latin0, includes euro)

    // Cyrillic charset soup (see http://czyborra.com/charsets/cyrillic.html)
    wxFONTENCODING_KOI8,            // we don't support any of KOI8 variants
    wxFONTENCODING_ALTERNATIVE,     // same as MS-DOS CP866
    wxFONTENCODING_BULGARIAN,       // used under Linux in Bulgaria

    // what would we do without Microsoft? They have their own encodings
        // for DOS
    wxFONTENCODING_CP437,           // original MS-DOS codepage
    wxFONTENCODING_CP850,           // CP437 merged with Latin1
    wxFONTENCODING_CP852,           // CP437 merged with Latin2
    wxFONTENCODING_CP855,           // another cyrillic encoding
    wxFONTENCODING_CP866,           // and another one
        // and for Windows
    wxFONTENCODING_CP1250,          // WinLatin2
    wxFONTENCODING_CP1251,          // WinCyrillic
    wxFONTENCODING_CP1252,          // WinLatin1

    wxFONTENCODING_MAX
};

class wxFont {
public:
    // I'll do it this way to use long-lived objects and not have to
    // worry about when python may delete the object.
    %addmethods {
        wxFont( int pointSize, int family, int style, int weight,
                int underline=FALSE, char* faceName = "",
                wxFontEncoding encoding=wxFONTENCODING_DEFAULT) {

            return wxTheFontList->FindOrCreateFont(pointSize, family, style, weight,
                                                   underline, faceName, encoding);
        }
        // NO Destructor.
    }

    bool Ok();

    wxString GetFaceName();
    int GetFamily();
#ifdef __WXMSW__
    int GetFontId();
#endif
    int GetPointSize();
    int GetStyle();
    bool GetUnderlined();
    int GetWeight();
    wxFontEncoding GetEncoding();
    void SetFaceName(const wxString& faceName);
    void SetFamily(int family);
    void SetPointSize(int pointSize);
    void SetStyle(int style);
    void SetUnderlined(bool underlined);
    void SetWeight(int weight);
    void SetEncoding(wxFontEncoding encoding);
    wxString GetFamilyString();
    wxString GetStyleString();
    wxString GetWeightString();
};

%inline %{
    wxFontEncoding wxFont_GetDefaultEncoding() {
        return wxFont::GetDefaultEncoding();
    }

    void wxFont_SetDefaultEncoding(wxFontEncoding encoding) {
        wxFont::SetDefaultEncoding(encoding);
    }
%}

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

class wxColour {
public:
    wxColour(unsigned char red=0, unsigned char green=0, unsigned char blue=0);
    ~wxColour();
    unsigned char Red();
    unsigned char Green();
    unsigned char Blue();
    bool Ok();
    void Set(unsigned char red, unsigned char green, unsigned char blue);
    %addmethods {
        PyObject* Get() {
            PyObject* rv = PyTuple_New(3);
            PyTuple_SetItem(rv, 0, PyInt_FromLong(self->Red()));
            PyTuple_SetItem(rv, 1, PyInt_FromLong(self->Green()));
            PyTuple_SetItem(rv, 2, PyInt_FromLong(self->Blue()));
            return rv;
        }
    }
    %pragma(python) addtoclass = "asTuple = Get"
    %pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())"
    %pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())"

};

%new wxColour* wxNamedColour(const wxString& colorName);
%{                                      // Alternate 'constructor'
    wxColour* wxNamedColour(const wxString& colorName) {
        return new wxColour(colorName);
    }
%}


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

#ifdef __WXMSW__
typedef unsigned long wxDash;
#else
typedef char wxDash;
#endif


class wxPen {
public:
    // I'll do it this way to use long-lived objects and not have to
    // worry about when python may delete the object.
    %addmethods {
        wxPen(wxColour* colour, int width=1, int style=wxSOLID) {
            return wxThePenList->FindOrCreatePen(*colour, width, style);
        }
        // NO Destructor.
    }

    int GetCap();
    wxColour& GetColour();

    int GetJoin();
    int GetStyle();
    int GetWidth();
    bool Ok();
    void SetCap(int cap_style);
    void SetColour(wxColour& colour);
    void SetJoin(int join_style);
    void SetStyle(int style);
    void SetWidth(int width);

            // **** This one needs to return a list of ints (wxDash)
    int GetDashes(wxDash **dashes);
    void SetDashes(int LCOUNT, wxDash* LIST);

#ifdef __WXMSW__
    wxBitmap* GetStipple();
    void SetStipple(wxBitmap& stipple);
#endif
};

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

class wxBrush {
public:
    // I'll do it this way to use long-lived objects and not have to
    // worry about when python may delete the object.
    %addmethods {
        wxBrush(wxColour* colour, int style=wxSOLID) {
            return wxTheBrushList->FindOrCreateBrush(*colour, style);
        }
        // NO Destructor.
    }

    wxColour& GetColour();
    wxBitmap * GetStipple();
    int GetStyle();
    bool Ok();
    void SetColour(wxColour &colour);
    void SetStipple(wxBitmap& bitmap);
    void SetStyle(int style);
};

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


class wxDC {
public:
//    wxDC(); **** abstract base class, can't instantiate.
    ~wxDC();

    void BeginDrawing();
//  %name(BlitXY)
    bool Blit(long xdest, long ydest,
              long width, long height,
              wxDC *source, long xsrc, long ysrc,
              int logicalFunc = wxCOPY, int useMask = FALSE);
//      bool Blit(const wxPoint& destPt, const wxSize& sz,
//                wxDC *source, const wxPoint& srcPt,
//                int logicalFunc = wxCOPY, int useMask = FALSE);

    void Clear();
    void CrossHair(long x, long y);
    void DestroyClippingRegion();
    long DeviceToLogicalX(long x);
    long DeviceToLogicalXRel(long x);
    long DeviceToLogicalY(long y);
    long DeviceToLogicalYRel(long y);
    void DrawArc(long x1, long y1, long x2, long y2, long xc, long yc);
    void DrawCircle(long x, long y, long radius);
    void DrawEllipse(long x, long y, long width, long height);
    void DrawEllipticArc(long x, long y, long width, long height, long start, long end);
    void DrawIcon(const wxIcon& icon, long x, long y);
    void DrawLine(long x1, long y1, long x2, long y2);
    void DrawLines(int LCOUNT, wxPoint* LIST, long xoffset=0, long yoffset=0);
    void DrawPolygon(int LCOUNT, wxPoint* LIST, long xoffset=0, long yoffset=0,
                     int fill_style=wxODDEVEN_RULE);
    void DrawPoint(long x, long y);
    void DrawRectangle(long x, long y, long width, long height);
    void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle);
    void DrawRoundedRectangle(long x, long y, long width, long height, long radius=20);
    void DrawSpline(int LCOUNT, wxPoint* LIST);
    void DrawText(const wxString& text, long x, long y);
    void EndDoc();
    void EndDrawing();
    void EndPage();
    void FloodFill(long x, long y, const wxColour& colour, int style=wxFLOOD_SURFACE);
    wxBrush&  GetBackground();
    wxBrush&  GetBrush();
    long GetCharHeight();
    long GetCharWidth();
    void GetClippingBox(long *OUTPUT, long *OUTPUT,
                        long *OUTPUT, long *OUTPUT);
    wxFont& GetFont();
    int GetLogicalFunction();
    int GetMapMode();
    bool GetOptimization();
    wxPen& GetPen();
    %addmethods {
        %new wxColour* GetPixel(long x, long y) {
            wxColour* wc = new wxColour();
            self->GetPixel(x, y, wc);
            return wc;
        }
    }
    %name(GetSizeTuple)void GetSize(int* OUTPUT, int* OUTPUT);
    wxSize GetSize();
    wxColour& GetTextBackground();
    void GetTextExtent(const wxString& string, long *OUTPUT, long *OUTPUT);
    %name(GetFullTextExtent)void GetTextExtent(const wxString& string,
                       long *OUTPUT, long *OUTPUT, long *OUTPUT, long* OUTPUT,
                       const wxFont* font = NULL);
    wxColour& GetTextForeground();
    long LogicalToDeviceX(long x);
    long LogicalToDeviceXRel(long x);
    long LogicalToDeviceY(long y);
    long LogicalToDeviceYRel(long y);
    long MaxX();
    long MaxY();
    long MinX();
    long MinY();
    bool Ok();
    void SetDeviceOrigin(long x, long y);
    void SetBackground(const wxBrush& brush);
    void SetBackgroundMode(int mode);
    void SetClippingRegion(long x, long y, long width, long height);
    void SetPalette(const wxPalette& colourMap);
    void SetBrush(const wxBrush& brush);
    void SetFont(const wxFont& font);
    void SetLogicalFunction(int function);
    void SetMapMode(int mode);
    void SetOptimization(bool optimize);
    void SetPen(const wxPen& pen);
    void SetTextBackground(const wxColour& colour);
    void SetTextForeground(const wxColour& colour);
    void SetUserScale(double x_scale, double y_scale);
    bool StartDoc(const wxString& message);
    void StartPage();


//  Don't need this one anymore as wxWindows has one...
//      %addmethods {
//              // This one is my own creation...
//          void DrawBitmap(wxBitmap& bitmap, long x, long y, bool swapPalette=TRUE) {
//              wxMemoryDC* memDC = new wxMemoryDC;
//              memDC->SelectObject(bitmap);
//  #ifdef __WXMSW__
//              if (swapPalette)
//                  self->SetPalette(*bitmap.GetPalette());
//  #endif
//              self->Blit(x, y, bitmap.GetWidth(), bitmap.GetHeight(), memDC,
//                      0, 0, self->GetLogicalFunction());
//              memDC->SelectObject(wxNullBitmap);
//              delete memDC;
//          }
//      }

    void DrawBitmap(const wxBitmap& bitmap, long x, long y,
                    int useMask = FALSE);

};


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

class wxMemoryDC : public wxDC {
public:
    wxMemoryDC();

    void SelectObject(const wxBitmap& bitmap);
}

%new wxMemoryDC* wxMemoryDCFromDC(wxDC* oldDC);
%{                                      // Alternate 'constructor'
    wxMemoryDC* wxMemoryDCFromDC(wxDC* oldDC) {
        return new wxMemoryDC(oldDC);
    }
%}


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

class wxScreenDC : public wxDC {
public:
    wxScreenDC();

    bool StartDrawingOnTop(wxWindow* window);
    %name(StartDrawingOnTopRect) bool StartDrawingOnTop(wxRect* rect = NULL);
    bool EndDrawingOnTop();
};

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

class wxClientDC : public wxDC {
public:
      wxClientDC(wxWindow* win);
};

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

class wxPaintDC : public wxDC {
public:
      wxPaintDC(wxWindow* win);
};

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

class wxWindowDC : public wxDC {
public:
      wxWindowDC(wxWindow* win);
};

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

#ifndef __WXMSW__
class wxPostScriptDC : public wxDC {
public:
      wxPostScriptDC(const wxString& output, bool interactive = TRUE, wxWindow* win = NULL);
};
#endif

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

#ifdef __WXMSW__
class  wxPrinterDC : public wxDC {
public:
    wxPrinterDC(const wxString& driver, const wxString& device, const wxString& output,
                bool interactive = TRUE, int orientation = wxPORTRAIT);
};
#endif

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

#ifdef __WXMSW__
class wxMetaFileDC : public wxDC {
public:
    wxMetaFileDC(const wxString& filename = wxPyEmptyStr);
    wxMetaFile* Close();
};
#endif

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


%readonly
%{
#if 0
%}
extern wxFont *wxNORMAL_FONT;
extern wxFont *wxSMALL_FONT;
extern wxFont *wxITALIC_FONT;
extern wxFont *wxSWISS_FONT;

extern wxPen *wxRED_PEN;
extern wxPen *wxCYAN_PEN;
extern wxPen *wxGREEN_PEN;
extern wxPen *wxBLACK_PEN;
extern wxPen *wxWHITE_PEN;
extern wxPen *wxTRANSPARENT_PEN;
extern wxPen *wxBLACK_DASHED_PEN;
extern wxPen *wxGREY_PEN;
extern wxPen *wxMEDIUM_GREY_PEN;
extern wxPen *wxLIGHT_GREY_PEN;

extern wxBrush *wxBLUE_BRUSH;
extern wxBrush *wxGREEN_BRUSH;
extern wxBrush *wxWHITE_BRUSH;
extern wxBrush *wxBLACK_BRUSH;
extern wxBrush *wxTRANSPARENT_BRUSH;
extern wxBrush *wxCYAN_BRUSH;
extern wxBrush *wxRED_BRUSH;
extern wxBrush *wxGREY_BRUSH;
extern wxBrush *wxMEDIUM_GREY_BRUSH;
extern wxBrush *wxLIGHT_GREY_BRUSH;

extern wxColour *wxBLACK;
extern wxColour *wxWHITE;
extern wxColour *wxRED;
extern wxColour *wxBLUE;
extern wxColour *wxGREEN;
extern wxColour *wxCYAN;
extern wxColour *wxLIGHT_GREY;

extern wxCursor *wxSTANDARD_CURSOR;
extern wxCursor *wxHOURGLASS_CURSOR;
extern wxCursor *wxCROSS_CURSOR;

extern wxBitmap wxNullBitmap;
extern wxIcon   wxNullIcon;
extern wxCursor wxNullCursor;
extern wxPen    wxNullPen;
extern wxBrush  wxNullBrush;
extern wxPalette wxNullPalette;
extern wxFont   wxNullFont;
extern wxColour wxNullColour;

%readwrite
%{
#endif
%}

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

class wxPalette {
public:
    wxPalette(int LCOUNT, byte* LIST, byte* LIST, byte* LIST);
    ~wxPalette();

    int GetPixel(byte red, byte green, byte blue);
    bool GetRGB(int pixel, byte* OUTPUT, byte* OUTPUT, byte* OUTPUT);
    bool Ok();
};

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

enum {
    wxIMAGELIST_DRAW_NORMAL ,
    wxIMAGELIST_DRAW_TRANSPARENT,
    wxIMAGELIST_DRAW_SELECTED,
    wxIMAGELIST_DRAW_FOCUSED,
    wxIMAGE_LIST_NORMAL,
    wxIMAGE_LIST_SMALL,
    wxIMAGE_LIST_STATE
};

class wxImageList {
public:
    wxImageList(int width, int height, int mask=TRUE, int initialCount=1);
    ~wxImageList();

#ifdef __WXMSW__
    int Add(const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap);
    %name(AddWithColourMask)int Add(const wxBitmap& bitmap, const wxColour& maskColour);
    %name(AddIcon)int Add(const wxIcon& icon);
    bool Replace(int index, const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap);
    %name(ReplaceIcon)bool Replace(int index, const wxIcon& icon);
#else
    int Add(const wxBitmap& bitmap);
    bool Replace(int index, const wxBitmap& bitmap);
#endif

    bool Draw(int index, wxDC& dc, int x, int x, int flags = wxIMAGELIST_DRAW_NORMAL,
              const bool solidBackground = FALSE);

    int GetImageCount();
    bool Remove(int index);
    bool RemoveAll();
};


//---------------------------------------------------------------------------
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: gdi.i
	3	// Purpose: SWIG interface file for wxDC, wxBrush, wxPen, wxFont, etc.
	4	//
	5	// Author: Robin Dunn
	6	//
	7	// Created: 7/7/97
	8	// RCS-ID: $Id$
	9	// Copyright: (c) 1998 by Total Control Software
	10	// Licence: wxWindows license
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13
	14	%module gdi
	15
	16	%{
	17	#include "helpers.h"
	18	#include <wx/metafile.h>
	19	#include <wx/imaglist.h>
	20	#ifndef __WXMSW__
	21	#include <wx/dcps.h>
	22	#endif
	23	%}
	24
	25	//----------------------------------------------------------------------
	26
	27	%include typemaps.i
	28	%include my_typemaps.i
	29
	30	// Import some definitions of other classes, etc.
	31	%import _defs.i
	32	%import misc.i
	33
	34	//---------------------------------------------------------------------------
	35
	36	// class wxGDIImage {
	37	// public:
	38	// long GetHandle();
	39	// void SetHandle(long handle);
	40	// bool Ok();
	41	// int GetWidth();
	42	// int GetHeight();
	43	// int GetDepth();
	44	// void SetWidth(int w);
	45	// void SetHeight(int h);
	46	// void SetDepth(int d);
	47	// void SetSize(const wxSize& size);
	48	// };
	49
	50	//---------------------------------------------------------------------------
	51
	52	class wxBitmap
	53	//: public wxGDIImage
	54	{
	55	public:
	56	wxBitmap(const wxString& name, long type);
	57	~wxBitmap();
	58
	59	wxPalette* GetPalette();
	60	wxMask* GetMask();
	61	bool LoadFile(const wxString& name, long flags);
	62	bool SaveFile(const wxString& name, int type, wxPalette* palette = NULL);
	63	void SetMask(wxMask* mask);
	64	#ifdef __WXMSW__
	65	void SetPalette(wxPalette& palette);
	66	#endif
	67
	68	// wxGDIImage methods
	69	#ifdef __WXMSW__
	70	long GetHandle();
	71	void SetHandle(long handle);
	72	#endif
	73	bool Ok();
	74	int GetWidth();
	75	int GetHeight();
	76	int GetDepth();
	77	void SetWidth(int w);
	78	void SetHeight(int h);
	79	void SetDepth(int d);
	80	#ifdef __WXMSW__
	81	void SetSize(const wxSize& size);
	82	#endif
	83	};
	84
	85
	86	%new wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1);
	87
	88	#ifdef __WXMSW__
	89	%new wxBitmap* wxBitmapFromData(char* data, long type,
	90	int width, int height, int depth = 1);
	91	#endif
	92
	93	%{ // Alternate 'constructor'
	94	wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1) {
	95	return new wxBitmap(width, height, depth);
	96	}
	97
	98	#ifdef __WXMSW__
	99	wxBitmap* wxBitmapFromData(char* data, long type,
	100	int width, int height, int depth = 1) {
	101	return new wxBitmap((void*)data, type, width, height, depth);
	102	}
	103	#endif
	104	%}
	105
	106	//---------------------------------------------------------------------------
	107
	108	class wxMask {
	109	public:
	110	wxMask(const wxBitmap& bitmap);
	111	//~wxMask();
	112	};
	113
	114	%new wxMask* wxMaskColour(const wxBitmap& bitmap, const wxColour& colour);
	115	%{
	116	wxMask* wxMaskColour(const wxBitmap& bitmap, const wxColour& colour) {
	117	return new wxMask(bitmap, colour);
	118	}
	119	%}
	120
	121
	122	//---------------------------------------------------------------------------
	123
	124
	125	class wxIcon
	126	//: public wxGDIImage
	127	{
	128	public:
	129	wxIcon(const wxString& name, long flags,
	130	int desiredWidth = -1, int desiredHeight = -1);
	131	~wxIcon();
	132
	133	bool LoadFile(const wxString& name, long flags);
	134
	135	// wxGDIImage methods
	136	#ifdef __WXMSW__
	137	long GetHandle();
	138	void SetHandle(long handle);
	139	#endif
	140	bool Ok();
	141	int GetWidth();
	142	int GetHeight();
	143	int GetDepth();
	144	void SetWidth(int w);
	145	void SetHeight(int h);
	146	void SetDepth(int d);
	147	#ifdef __WXMSW__
	148	void SetSize(const wxSize& size);
	149	#endif
	150	};
	151
	152
	153	//---------------------------------------------------------------------------
	154
	155	class wxCursor
	156	//: public wxGDIImage
	157	{
	158	public:
	159	#ifdef __WXMSW__
	160	wxCursor(const wxString& cursorName, long flags, int hotSpotX=0, int hotSpotY=0);
	161	#endif
	162	~wxCursor();
	163
	164	// wxGDIImage methods
	165	#ifdef __WXMSW__
	166	long GetHandle();
	167	void SetHandle(long handle);
	168	#endif
	169	bool Ok();
	170	#ifdef __WXMSW__
	171	int GetWidth();
	172	int GetHeight();
	173	int GetDepth();
	174	void SetWidth(int w);
	175	void SetHeight(int h);
	176	void SetDepth(int d);
	177	void SetSize(const wxSize& size);
	178	#endif
	179	};
	180
	181	%name(wxStockCursor) %new wxCursor* wxPyStockCursor(int id);
	182	%{ // Alternate 'constructor'
	183	wxCursor* wxPyStockCursor(int id) {
	184	return new wxCursor(id);
	185	}
	186	%}
	187
	188	//----------------------------------------------------------------------
	189
	190
	191	enum wxFontEncoding
	192	{
	193	wxFONTENCODING_SYSTEM = -1, // system default
	194	wxFONTENCODING_DEFAULT, // current default encoding
	195
	196	// ISO8859 standard defines a number of single-byte charsets
	197	wxFONTENCODING_ISO8859_1, // West European (Latin1)
	198	wxFONTENCODING_ISO8859_2, // Central and East European (Latin2)
	199	wxFONTENCODING_ISO8859_3, // Esperanto (Latin3)
	200	wxFONTENCODING_ISO8859_4, // Baltic languages (Estonian) (Latin4)
	201	wxFONTENCODING_ISO8859_5, // Cyrillic
	202	wxFONTENCODING_ISO8859_6, // Arabic
	203	wxFONTENCODING_ISO8859_7, // Greek
	204	wxFONTENCODING_ISO8859_8, // Hebrew
	205	wxFONTENCODING_ISO8859_9, // Turkish (Latin5)
	206	wxFONTENCODING_ISO8859_10, // Variation of Latin4 (Latin6)
	207	wxFONTENCODING_ISO8859_11, // Thai
	208	wxFONTENCODING_ISO8859_12, // doesn't exist currently, but put it
	209	// here anyhow to make all ISO8859
	210	// consecutive numbers
	211	wxFONTENCODING_ISO8859_13, // Latin7
	212	wxFONTENCODING_ISO8859_14, // Latin8
	213	wxFONTENCODING_ISO8859_15, // Latin9 (a.k.a. Latin0, includes euro)
	214
	215	// Cyrillic charset soup (see http://czyborra.com/charsets/cyrillic.html)
	216	wxFONTENCODING_KOI8, // we don't support any of KOI8 variants
	217	wxFONTENCODING_ALTERNATIVE, // same as MS-DOS CP866
	218	wxFONTENCODING_BULGARIAN, // used under Linux in Bulgaria
	219
	220	// what would we do without Microsoft? They have their own encodings
	221	// for DOS
	222	wxFONTENCODING_CP437, // original MS-DOS codepage
	223	wxFONTENCODING_CP850, // CP437 merged with Latin1
	224	wxFONTENCODING_CP852, // CP437 merged with Latin2
	225	wxFONTENCODING_CP855, // another cyrillic encoding
	226	wxFONTENCODING_CP866, // and another one
	227	// and for Windows
	228	wxFONTENCODING_CP1250, // WinLatin2
	229	wxFONTENCODING_CP1251, // WinCyrillic
	230	wxFONTENCODING_CP1252, // WinLatin1
	231
	232	wxFONTENCODING_MAX
	233	};
	234
	235	class wxFont {
	236	public:
	237	// I'll do it this way to use long-lived objects and not have to
	238	// worry about when python may delete the object.
	239	%addmethods {
	240	wxFont( int pointSize, int family, int style, int weight,
	241	int underline=FALSE, char* faceName = "",
	242	wxFontEncoding encoding=wxFONTENCODING_DEFAULT) {
	243
	244	return wxTheFontList->FindOrCreateFont(pointSize, family, style, weight,
	245	underline, faceName, encoding);
	246	}
	247	// NO Destructor.
	248	}
	249
	250	bool Ok();
	251
	252	wxString GetFaceName();
	253	int GetFamily();
	254	#ifdef __WXMSW__
	255	int GetFontId();
	256	#endif
	257	int GetPointSize();
	258	int GetStyle();
	259	bool GetUnderlined();
	260	int GetWeight();
	261	wxFontEncoding GetEncoding();
	262	void SetFaceName(const wxString& faceName);
	263	void SetFamily(int family);
	264	void SetPointSize(int pointSize);
	265	void SetStyle(int style);
	266	void SetUnderlined(bool underlined);
	267	void SetWeight(int weight);
	268	void SetEncoding(wxFontEncoding encoding);
	269	wxString GetFamilyString();
	270	wxString GetStyleString();
	271	wxString GetWeightString();
	272	};
	273
	274	%inline %{
	275	wxFontEncoding wxFont_GetDefaultEncoding() {
	276	return wxFont::GetDefaultEncoding();
	277	}
	278
	279	void wxFont_SetDefaultEncoding(wxFontEncoding encoding) {
	280	wxFont::SetDefaultEncoding(encoding);
	281	}
	282	%}
	283
	284	//----------------------------------------------------------------------
	285
	286	class wxColour {
	287	public:
	288	wxColour(unsigned char red=0, unsigned char green=0, unsigned char blue=0);
	289	~wxColour();
	290	unsigned char Red();
	291	unsigned char Green();
	292	unsigned char Blue();
	293	bool Ok();
	294	void Set(unsigned char red, unsigned char green, unsigned char blue);
	295	%addmethods {
	296	PyObject* Get() {
	297	PyObject* rv = PyTuple_New(3);
	298	PyTuple_SetItem(rv, 0, PyInt_FromLong(self->Red()));
	299	PyTuple_SetItem(rv, 1, PyInt_FromLong(self->Green()));
	300	PyTuple_SetItem(rv, 2, PyInt_FromLong(self->Blue()));
	301	return rv;
	302	}
	303	}
	304	%pragma(python) addtoclass = "asTuple = Get"
	305	%pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())"
	306	%pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())"
	307
	308	};
	309
	310	%new wxColour* wxNamedColour(const wxString& colorName);
	311	%{ // Alternate 'constructor'
	312	wxColour* wxNamedColour(const wxString& colorName) {
	313	return new wxColour(colorName);
	314	}
	315	%}
	316
	317
	318	//----------------------------------------------------------------------
	319
	320	#ifdef __WXMSW__
	321	typedef unsigned long wxDash;
	322	#else
	323	typedef char wxDash;
	324	#endif
	325
	326
	327	class wxPen {
	328	public:
	329	// I'll do it this way to use long-lived objects and not have to
	330	// worry about when python may delete the object.
	331	%addmethods {
	332	wxPen(wxColour* colour, int width=1, int style=wxSOLID) {
	333	return wxThePenList->FindOrCreatePen(*colour, width, style);
	334	}
	335	// NO Destructor.
	336	}
	337
	338	int GetCap();
	339	wxColour& GetColour();
	340
	341	int GetJoin();
	342	int GetStyle();
	343	int GetWidth();
	344	bool Ok();
	345	void SetCap(int cap_style);
	346	void SetColour(wxColour& colour);
	347	void SetJoin(int join_style);
	348	void SetStyle(int style);
	349	void SetWidth(int width);
	350
	351	// **** This one needs to return a list of ints (wxDash)
	352	int GetDashes(wxDash **dashes);
	353	void SetDashes(int LCOUNT, wxDash* LIST);
	354
	355	#ifdef __WXMSW__
	356	wxBitmap* GetStipple();
	357	void SetStipple(wxBitmap& stipple);
	358	#endif
	359	};
	360
	361	//----------------------------------------------------------------------
	362
	363	class wxBrush {
	364	public:
	365	// I'll do it this way to use long-lived objects and not have to
	366	// worry about when python may delete the object.
	367	%addmethods {
	368	wxBrush(wxColour* colour, int style=wxSOLID) {
	369	return wxTheBrushList->FindOrCreateBrush(*colour, style);
	370	}
	371	// NO Destructor.
	372	}
	373
	374	wxColour& GetColour();
	375	wxBitmap * GetStipple();
	376	int GetStyle();
	377	bool Ok();
	378	void SetColour(wxColour &colour);
	379	void SetStipple(wxBitmap& bitmap);
	380	void SetStyle(int style);
	381	};
	382
	383	//----------------------------------------------------------------------
	384
	385
	386
	387	class wxDC {
	388	public:
	389	// wxDC(); **** abstract base class, can't instantiate.
	390	~wxDC();
	391
	392	void BeginDrawing();
	393	// %name(BlitXY)
	394	bool Blit(long xdest, long ydest,
	395	long width, long height,
	396	wxDC *source, long xsrc, long ysrc,
	397	int logicalFunc = wxCOPY, int useMask = FALSE);
	398	// bool Blit(const wxPoint& destPt, const wxSize& sz,
	399	// wxDC *source, const wxPoint& srcPt,
	400	// int logicalFunc = wxCOPY, int useMask = FALSE);
	401
	402	void Clear();
	403	void CrossHair(long x, long y);
	404	void DestroyClippingRegion();
	405	long DeviceToLogicalX(long x);
	406	long DeviceToLogicalXRel(long x);
	407	long DeviceToLogicalY(long y);
	408	long DeviceToLogicalYRel(long y);
	409	void DrawArc(long x1, long y1, long x2, long y2, long xc, long yc);
	410	void DrawCircle(long x, long y, long radius);
	411	void DrawEllipse(long x, long y, long width, long height);
	412	void DrawEllipticArc(long x, long y, long width, long height, long start, long end);
	413	void DrawIcon(const wxIcon& icon, long x, long y);
	414	void DrawLine(long x1, long y1, long x2, long y2);
	415	void DrawLines(int LCOUNT, wxPoint* LIST, long xoffset=0, long yoffset=0);
	416	void DrawPolygon(int LCOUNT, wxPoint* LIST, long xoffset=0, long yoffset=0,
	417	int fill_style=wxODDEVEN_RULE);
	418	void DrawPoint(long x, long y);
	419	void DrawRectangle(long x, long y, long width, long height);
	420	void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle);
	421	void DrawRoundedRectangle(long x, long y, long width, long height, long radius=20);
	422	void DrawSpline(int LCOUNT, wxPoint* LIST);
	423	void DrawText(const wxString& text, long x, long y);
	424	void EndDoc();
	425	void EndDrawing();
	426	void EndPage();
	427	void FloodFill(long x, long y, const wxColour& colour, int style=wxFLOOD_SURFACE);
	428	wxBrush& GetBackground();
	429	wxBrush& GetBrush();
	430	long GetCharHeight();
	431	long GetCharWidth();
	432	void GetClippingBox(long OUTPUT, long OUTPUT,
	433	long OUTPUT, long OUTPUT);
	434	wxFont& GetFont();
	435	int GetLogicalFunction();
	436	int GetMapMode();
	437	bool GetOptimization();
	438	wxPen& GetPen();
	439	%addmethods {
	440	%new wxColour* GetPixel(long x, long y) {
	441	wxColour* wc = new wxColour();
	442	self->GetPixel(x, y, wc);
	443	return wc;
	444	}
	445	}
	446	%name(GetSizeTuple)void GetSize(int* OUTPUT, int* OUTPUT);
	447	wxSize GetSize();
	448	wxColour& GetTextBackground();
	449	void GetTextExtent(const wxString& string, long OUTPUT, long OUTPUT);
	450	%name(GetFullTextExtent)void GetTextExtent(const wxString& string,
	451	long OUTPUT, long OUTPUT, long OUTPUT, long OUTPUT,
	452	const wxFont* font = NULL);
	453	wxColour& GetTextForeground();
	454	long LogicalToDeviceX(long x);
	455	long LogicalToDeviceXRel(long x);
	456	long LogicalToDeviceY(long y);
	457	long LogicalToDeviceYRel(long y);
	458	long MaxX();
	459	long MaxY();
	460	long MinX();
	461	long MinY();
	462	bool Ok();
	463	void SetDeviceOrigin(long x, long y);
	464	void SetBackground(const wxBrush& brush);
	465	void SetBackgroundMode(int mode);
	466	void SetClippingRegion(long x, long y, long width, long height);
	467	void SetPalette(const wxPalette& colourMap);
	468	void SetBrush(const wxBrush& brush);
	469	void SetFont(const wxFont& font);
	470	void SetLogicalFunction(int function);
	471	void SetMapMode(int mode);
	472	void SetOptimization(bool optimize);
	473	void SetPen(const wxPen& pen);
	474	void SetTextBackground(const wxColour& colour);
	475	void SetTextForeground(const wxColour& colour);
	476	void SetUserScale(double x_scale, double y_scale);
	477	bool StartDoc(const wxString& message);
	478	void StartPage();
	479
	480
	481	// Don't need this one anymore as wxWindows has one...
	482	// %addmethods {
	483	// // This one is my own creation...
	484	// void DrawBitmap(wxBitmap& bitmap, long x, long y, bool swapPalette=TRUE) {
	485	// wxMemoryDC* memDC = new wxMemoryDC;
	486	// memDC->SelectObject(bitmap);
	487	// #ifdef __WXMSW__
	488	// if (swapPalette)
	489	// self->SetPalette(*bitmap.GetPalette());
	490	// #endif
	491	// self->Blit(x, y, bitmap.GetWidth(), bitmap.GetHeight(), memDC,
	492	// 0, 0, self->GetLogicalFunction());
	493	// memDC->SelectObject(wxNullBitmap);
	494	// delete memDC;
	495	// }
	496	// }
	497
	498	void DrawBitmap(const wxBitmap& bitmap, long x, long y,
	499	int useMask = FALSE);
	500
	501	};
	502
	503
	504	//----------------------------------------------------------------------
	505
	506	class wxMemoryDC : public wxDC {
	507	public:
	508	wxMemoryDC();
	509
	510	void SelectObject(const wxBitmap& bitmap);
	511	}
	512
	513	%new wxMemoryDC* wxMemoryDCFromDC(wxDC* oldDC);
	514	%{ // Alternate 'constructor'
	515	wxMemoryDC* wxMemoryDCFromDC(wxDC* oldDC) {
	516	return new wxMemoryDC(oldDC);
	517	}
	518	%}
	519
	520
	521	//---------------------------------------------------------------------------
	522
	523	class wxScreenDC : public wxDC {
	524	public:
	525	wxScreenDC();
	526
	527	bool StartDrawingOnTop(wxWindow* window);
	528	%name(StartDrawingOnTopRect) bool StartDrawingOnTop(wxRect* rect = NULL);
	529	bool EndDrawingOnTop();
	530	};
	531
	532	//---------------------------------------------------------------------------
	533
	534	class wxClientDC : public wxDC {
	535	public:
	536	wxClientDC(wxWindow* win);
	537	};
	538
	539	//---------------------------------------------------------------------------
	540
	541	class wxPaintDC : public wxDC {
	542	public:
	543	wxPaintDC(wxWindow* win);
	544	};
	545
	546	//---------------------------------------------------------------------------
	547
	548	class wxWindowDC : public wxDC {
	549	public:
	550	wxWindowDC(wxWindow* win);
	551	};
	552
	553	//---------------------------------------------------------------------------
	554
	555	#ifndef __WXMSW__
	556	class wxPostScriptDC : public wxDC {
	557	public:
	558	wxPostScriptDC(const wxString& output, bool interactive = TRUE, wxWindow* win = NULL);
	559	};
	560	#endif
	561
	562	//---------------------------------------------------------------------------
	563
	564	#ifdef __WXMSW__
	565	class wxPrinterDC : public wxDC {
	566	public:
	567	wxPrinterDC(const wxString& driver, const wxString& device, const wxString& output,
	568	bool interactive = TRUE, int orientation = wxPORTRAIT);
	569	};
	570	#endif
	571
	572	//---------------------------------------------------------------------------
	573
	574	#ifdef __WXMSW__
	575	class wxMetaFileDC : public wxDC {
	576	public:
	577	wxMetaFileDC(const wxString& filename = wxPyEmptyStr);
	578	wxMetaFile* Close();
	579	};
	580	#endif
	581
	582	//---------------------------------------------------------------------------
	583	//---------------------------------------------------------------------------
	584
	585
	586	%readonly
	587	%{
	588	#if 0
	589	%}
	590	extern wxFont *wxNORMAL_FONT;
	591	extern wxFont *wxSMALL_FONT;
	592	extern wxFont *wxITALIC_FONT;
	593	extern wxFont *wxSWISS_FONT;
	594
	595	extern wxPen *wxRED_PEN;
	596	extern wxPen *wxCYAN_PEN;
	597	extern wxPen *wxGREEN_PEN;
	598	extern wxPen *wxBLACK_PEN;
	599	extern wxPen *wxWHITE_PEN;
	600	extern wxPen *wxTRANSPARENT_PEN;
	601	extern wxPen *wxBLACK_DASHED_PEN;
	602	extern wxPen *wxGREY_PEN;
	603	extern wxPen *wxMEDIUM_GREY_PEN;
	604	extern wxPen *wxLIGHT_GREY_PEN;
	605
	606	extern wxBrush *wxBLUE_BRUSH;
	607	extern wxBrush *wxGREEN_BRUSH;
	608	extern wxBrush *wxWHITE_BRUSH;
	609	extern wxBrush *wxBLACK_BRUSH;
	610	extern wxBrush *wxTRANSPARENT_BRUSH;
	611	extern wxBrush *wxCYAN_BRUSH;
	612	extern wxBrush *wxRED_BRUSH;
	613	extern wxBrush *wxGREY_BRUSH;
	614	extern wxBrush *wxMEDIUM_GREY_BRUSH;
	615	extern wxBrush *wxLIGHT_GREY_BRUSH;
	616
	617	extern wxColour *wxBLACK;
	618	extern wxColour *wxWHITE;
	619	extern wxColour *wxRED;
	620	extern wxColour *wxBLUE;
	621	extern wxColour *wxGREEN;
	622	extern wxColour *wxCYAN;
	623	extern wxColour *wxLIGHT_GREY;
	624
	625	extern wxCursor *wxSTANDARD_CURSOR;
	626	extern wxCursor *wxHOURGLASS_CURSOR;
	627	extern wxCursor *wxCROSS_CURSOR;
	628
	629	extern wxBitmap wxNullBitmap;
	630	extern wxIcon wxNullIcon;
	631	extern wxCursor wxNullCursor;
	632	extern wxPen wxNullPen;
	633	extern wxBrush wxNullBrush;
	634	extern wxPalette wxNullPalette;
	635	extern wxFont wxNullFont;
	636	extern wxColour wxNullColour;
	637
	638	%readwrite
	639	%{
	640	#endif
	641	%}
	642
	643	//---------------------------------------------------------------------------
	644
	645	class wxPalette {
	646	public:
	647	wxPalette(int LCOUNT, byte* LIST, byte* LIST, byte* LIST);
	648	~wxPalette();
	649
	650	int GetPixel(byte red, byte green, byte blue);
	651	bool GetRGB(int pixel, byte* OUTPUT, byte* OUTPUT, byte* OUTPUT);
	652	bool Ok();
	653	};
	654
	655	//---------------------------------------------------------------------------
	656
	657	enum {
	658	wxIMAGELIST_DRAW_NORMAL ,
	659	wxIMAGELIST_DRAW_TRANSPARENT,
	660	wxIMAGELIST_DRAW_SELECTED,
	661	wxIMAGELIST_DRAW_FOCUSED,
	662	wxIMAGE_LIST_NORMAL,
	663	wxIMAGE_LIST_SMALL,
	664	wxIMAGE_LIST_STATE
	665	};
	666
	667	class wxImageList {
	668	public:
	669	wxImageList(int width, int height, int mask=TRUE, int initialCount=1);
	670	~wxImageList();
	671
	672	#ifdef __WXMSW__
	673	int Add(const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap);
	674	%name(AddWithColourMask)int Add(const wxBitmap& bitmap, const wxColour& maskColour);
	675	%name(AddIcon)int Add(const wxIcon& icon);
	676	bool Replace(int index, const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap);
	677	%name(ReplaceIcon)bool Replace(int index, const wxIcon& icon);
	678	#else
	679	int Add(const wxBitmap& bitmap);
	680	bool Replace(int index, const wxBitmap& bitmap);
	681	#endif
	682
	683	bool Draw(int index, wxDC& dc, int x, int x, int flags = wxIMAGELIST_DRAW_NORMAL,
	684	const bool solidBackground = FALSE);
	685
	686	int GetImageCount();
	687	bool Remove(int index);
	688	bool RemoveAll();
	689	};
	690
	691
	692	//---------------------------------------------------------------------------
	693