wxPython/src/_gdicmn.i

/////////////////////////////////////////////////////////////////////////////
// Name:        _gdicmn.i
// Purpose:     SWIG interface for common GDI stuff and misc classes
//
// Author:      Robin Dunn
//
// Created:     13-Sept-2003
// RCS-ID:      $Id$
// Copyright:   (c) 2003 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

// Not a %module


//---------------------------------------------------------------------------
%newgroup


enum wxBitmapType
{
    wxBITMAP_TYPE_INVALID,          // should be == 0 for compatibility!
    wxBITMAP_TYPE_BMP,
    wxBITMAP_TYPE_ICO,
    wxBITMAP_TYPE_CUR,
    wxBITMAP_TYPE_XBM,
    wxBITMAP_TYPE_XBM_DATA,
    wxBITMAP_TYPE_XPM,
    wxBITMAP_TYPE_XPM_DATA,
    wxBITMAP_TYPE_TIF,
    wxBITMAP_TYPE_GIF,
    wxBITMAP_TYPE_PNG,
    wxBITMAP_TYPE_JPEG,
    wxBITMAP_TYPE_PNM,
    wxBITMAP_TYPE_PCX,
    wxBITMAP_TYPE_PICT,
    wxBITMAP_TYPE_ICON,
    wxBITMAP_TYPE_ANI,
    wxBITMAP_TYPE_IFF,
    wxBITMAP_TYPE_MACCURSOR,

//    wxBITMAP_TYPE_BMP_RESOURCE,
//    wxBITMAP_TYPE_RESOURCE = wxBITMAP_TYPE_BMP_RESOURCE,
//    wxBITMAP_TYPE_ICO_RESOURCE,
//    wxBITMAP_TYPE_CUR_RESOURCE,
//    wxBITMAP_TYPE_TIF_RESOURCE,
//    wxBITMAP_TYPE_GIF_RESOURCE,
//    wxBITMAP_TYPE_PNG_RESOURCE,
//    wxBITMAP_TYPE_JPEG_RESOURCE,
//    wxBITMAP_TYPE_PNM_RESOURCE,
//    wxBITMAP_TYPE_PCX_RESOURCE,
//    wxBITMAP_TYPE_PICT_RESOURCE,
//    wxBITMAP_TYPE_ICON_RESOURCE,
//    wxBITMAP_TYPE_MACCURSOR_RESOURCE,

    wxBITMAP_TYPE_ANY = 50
};

// Standard cursors
enum wxStockCursor
{
    wxCURSOR_NONE,          // should be 0
    wxCURSOR_ARROW,
    wxCURSOR_RIGHT_ARROW,
    wxCURSOR_BULLSEYE,
    wxCURSOR_CHAR,
    wxCURSOR_CROSS,
    wxCURSOR_HAND,
    wxCURSOR_IBEAM,
    wxCURSOR_LEFT_BUTTON,
    wxCURSOR_MAGNIFIER,
    wxCURSOR_MIDDLE_BUTTON,
    wxCURSOR_NO_ENTRY,
    wxCURSOR_PAINT_BRUSH,
    wxCURSOR_PENCIL,
    wxCURSOR_POINT_LEFT,
    wxCURSOR_POINT_RIGHT,
    wxCURSOR_QUESTION_ARROW,
    wxCURSOR_RIGHT_BUTTON,
    wxCURSOR_SIZENESW,
    wxCURSOR_SIZENS,
    wxCURSOR_SIZENWSE,
    wxCURSOR_SIZEWE,
    wxCURSOR_SIZING,
    wxCURSOR_SPRAYCAN,
    wxCURSOR_WAIT,
    wxCURSOR_WATCH,
    wxCURSOR_BLANK,
    wxCURSOR_DEFAULT, // standard X11 cursor
    wxCURSOR_COPY_ARROW , // MacOS Theme Plus arrow

// #ifdef __X__
//     // Not yet implemented for Windows
//     wxCURSOR_CROSS_REVERSE,
//     wxCURSOR_DOUBLE_ARROW,
//     wxCURSOR_BASED_ARROW_UP,
//     wxCURSOR_BASED_ARROW_DOWN,
// #endif // X11

    wxCURSOR_ARROWWAIT,

    wxCURSOR_MAX
};

%{
#ifndef __WXMAC__
#define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
#endif
%}

//---------------------------------------------------------------------------
%newgroup

DocStr( wxSize,
"wx.Size is a useful data structure used to represent the size of something.
It simply contians integer width and height proprtites.  In most places in
wxPython where a wx.Size is expected a (width,height) tuple can be used
instead.");

class wxSize
{
public:
    %name(width) int x;
    %name(height)int y;
    %pythoncode { x = width; y = height }

    DocCtorStr(
        wxSize(int w=0, int h=0),
        "Creates a size object.");

    ~wxSize();

//     %extend {
//         bool __eq__(const wxSize* other) { return other ? (*self == *other) : False; }
//         bool __ne__(const wxSize* other) { return other ? (*self != *other) : True;  }
//     }

    DocDeclStr(
        bool, operator==(const wxSize& sz),
        "Test for equality of wx.Size objects.");

    DocDeclStr(
        bool, operator!=(const wxSize& sz),
        "Test for inequality.");

    DocDeclStr(
        wxSize, operator+(const wxSize& sz),
        "Add sz's proprties to this and return the result.");

    DocDeclStr(
        wxSize, operator-(const wxSize& sz),
        "Subtract sz's properties from this and return the result.");

    DocDeclStr(
        void, IncTo(const wxSize& sz),
        "Increments this object so that both of its dimensions are not less\n"
        "than the corresponding dimensions of the size.");

    DocDeclStr(
        void, DecTo(const wxSize& sz),
        "Decrements this object so that both of its dimensions are not greater\n"
        "than the corresponding dimensions of the size.");

    DocDeclStr(
        void, Set(int w, int h),
        "Set both width and height.");

    void SetWidth(int w);
    void SetHeight(int h);
    int GetWidth() const;
    int GetHeight() const;


    DocDeclStr(
        bool , IsFullySpecified() const,
        "Returns True if both components of the size are non-default values.");


    DocDeclStr(
        void , SetDefaults(const wxSize& size),
        "Combine this size with the other one replacing the default
components of this object (i.e. equal to -1) with those of the
other.");


    //int GetX() const;
    //int GetY() const;

    %extend {
        DocAStr(Get,
               "Get() -> (width,height)",
               "Returns the width and height properties as a tuple.");
        PyObject* Get() {
            bool blocked = wxPyBeginBlockThreads();
            PyObject* tup = PyTuple_New(2);
            PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
            PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
            wxPyEndBlockThreads(blocked);
            return tup;
        }
    }
    %pythoncode {
    asTuple = Get
    def __str__(self):                   return str(self.Get())
    def __repr__(self):                  return 'wx.Size'+str(self.Get())
    def __len__(self):                   return len(self.Get())
    def __getitem__(self, index):        return self.Get()[index]
    def __setitem__(self, index, val):
        if index == 0: self.width = val
        elif index == 1: self.height = val
        else: raise IndexError
    def __nonzero__(self):               return self.Get() != (0,0)
    __safe_for_unpickling__ = True
    def __reduce__(self):                return (wx.Size, self.Get())
    }

};

//---------------------------------------------------------------------------
%newgroup

DocStr( wxRealPoint,
"A data structure for representing a point or position with floating point x
and y properties.  In wxPython most places that expect a wx.RealPoint can also
accept a (x,y) tuple.");
class wxRealPoint
{
public:
    double x;
    double y;

    DocCtorStr(
        wxRealPoint(double x=0.0, double y=0.0),
        "Create a wx.RealPoint object");

    ~wxRealPoint();

    DocDeclStr(
        bool, operator==(const wxRealPoint& pt),
        "Test for equality of wx.RealPoint objects.");

    DocDeclStr(
        bool, operator!=(const wxRealPoint& pt),
        "Test for inequality of wx.RealPoint objects.");


    DocDeclStr(
        wxRealPoint, operator+(const wxRealPoint& pt),
        "Add pt's proprties to this and return the result.");

    DocDeclStr(
        wxRealPoint, operator-(const wxRealPoint& pt),
        "Subtract pt's proprties from this and return the result");


    %extend {
        DocStr(Set, "Set both the x and y properties");
        void Set(double x, double y) {
            self->x = x;
            self->y = y;
        }

        DocAStr(Get,
               "Get() -> (x,y)",
               "Return the x and y properties as a tuple. ");
        PyObject* Get() {
            bool blocked = wxPyBeginBlockThreads();
            PyObject* tup = PyTuple_New(2);
            PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
            PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
            wxPyEndBlockThreads(blocked);
            return tup;
        }
    }

    %pythoncode {
    asTuple = Get
    def __str__(self):                   return str(self.Get())
    def __repr__(self):                  return 'wx.RealPoint'+str(self.Get())
    def __len__(self):                   return len(self.Get())
    def __getitem__(self, index):        return self.Get()[index]
    def __setitem__(self, index, val):
        if index == 0: self.x = val
        elif index == 1: self.y = val
        else: raise IndexError
    def __nonzero__(self):               return self.Get() != (0.0, 0.0)
    __safe_for_unpickling__ = True
    def __reduce__(self):                return (wx.RealPoint, self.Get())
    }
};


//---------------------------------------------------------------------------
%newgroup


DocStr(wxPoint,
"A data structure for representing a point or position with integer x and y
properties.  Most places in wxPython that expect a wx.Point can also accept a
(x,y) tuple.");

class wxPoint
{
public:
    int x, y;

    DocCtorStr(
        wxPoint(int x=0, int y=0),
        "Create a wx.Point object");

    ~wxPoint();


    DocDeclStr(
        bool, operator==(const wxPoint& pt),
        "Test for equality of wx.Point objects.");

    DocDeclStr(
        bool, operator!=(const wxPoint& pt),
        "Test for inequality of wx.Point objects.");


//     %nokwargs operator+;
//     %nokwargs operator-;
//     %nokwargs operator+=;
//     %nokwargs operator-=;

    DocDeclStr(
        wxPoint, operator+(const wxPoint& pt),
        "Add pt's proprties to this and return the result.");


    DocDeclStr(
        wxPoint, operator-(const wxPoint& pt),
        "Subtract pt's proprties from this and return the result");


    DocDeclStr(
        wxPoint&, operator+=(const wxPoint& pt),
        "Add pt to this object.");

    DocDeclStr(
        wxPoint&, operator-=(const wxPoint& pt),
        "Subtract pt from this object.");


//     DocDeclStr(
//         wxPoint, operator+(const wxSize& sz),
//         "Add sz to this Point and return the result.");

//     DocDeclStr(
//         wxPoint, operator-(const wxSize& sz),
//         "Subtract sz from this Point and return the result");


//     DocDeclStr(
//         wxPoint&, operator+=(const wxSize& sz),
//         "Add sz to this object.");

//     DocDeclStr(
//         wxPoint&, operator-=(const wxSize& sz),
//         "Subtract sz from this object.");


    %extend {
        DocStr(Set, "Set both the x and y properties");
        void Set(long x, long y) {
            self->x = x;
            self->y = y;
        }

        DocAStr(Get,
               "Get() -> (x,y)",
               "Return the x and y properties as a tuple. ");
        PyObject* Get() {
            bool blocked = wxPyBeginBlockThreads();
            PyObject* tup = PyTuple_New(2);
            PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
            PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
            wxPyEndBlockThreads(blocked);
            return tup;
        }
    }

    %pythoncode {
    asTuple = Get
    def __str__(self):                   return str(self.Get())
    def __repr__(self):                  return 'wx.Point'+str(self.Get())
    def __len__(self):                   return len(self.Get())
    def __getitem__(self, index):        return self.Get()[index]
    def __setitem__(self, index, val):
        if index == 0: self.x = val
        elif index == 1: self.y = val
        else: raise IndexError
    def __nonzero__(self):               return self.Get() != (0,0)
    __safe_for_unpickling__ = True
    def __reduce__(self):                return (wx.Point, self.Get())
    }
};

//---------------------------------------------------------------------------
%newgroup


DocStr(wxRect,
"A class for representing and manipulating rectangles.  It has x, y, width and
height properties.  In wxPython most palces that expect a wx.Rect can also
accept a (x,y,width,height) tuple.");

class wxRect
{
public:
    DocCtorStr(
        wxRect(int x=0, int y=0, int width=0, int height=0),
        "Create a new Rect object.");

    DocCtorStrName(
        wxRect(const wxPoint& topLeft, const wxPoint& bottomRight),
        "Create a new Rect object from Points representing two corners.",
        RectPP);

    DocCtorStrName(
        wxRect(const wxPoint& pos, const wxSize& size),
        "Create a new Rect from a position and size.",
         RectPS);

    ~wxRect();

    int GetX() const;
    void SetX(int x);

    int GetY();
    void SetY(int y);

    int GetWidth() const;
    void SetWidth(int w);

    int GetHeight() const;
    void SetHeight(int h);

    wxPoint GetPosition() const;
    void SetPosition( const wxPoint &p );

    wxSize GetSize() const;
    void SetSize( const wxSize &s );

    wxPoint GetTopLeft() const;
    void SetTopLeft(const wxPoint &p);
    wxPoint GetBottomRight() const;
    void SetBottomRight(const wxPoint &p);

//    wxPoint GetLeftTop() const;
//    void SetLeftTop(const wxPoint &p);
//    wxPoint GetRightBottom() const;
//    void SetRightBottom(const wxPoint &p);

    int GetLeft()   const;
    int GetTop()    const;
    int GetBottom() const;
    int GetRight()  const;

    void SetLeft(int left);
    void SetRight(int right);
    void SetTop(int top);
    void SetBottom(int bottom);

    %pythoncode {
        position = property(GetPosition, SetPosition)
        size = property(GetSize, SetSize)
        left = property(GetLeft, SetLeft)
        right = property(GetRight, SetRight)
        top = property(GetTop, SetTop)
        bottom = property(GetBottom, SetBottom)
    }

    DocDeclStr(
        wxRect&, Inflate(wxCoord dx, wxCoord dy),
        "Increase the rectangle size by dx in x direction and dy in y direction. Both\n"
        "(or one of) parameters may be negative to decrease the rectangle size.");

    DocDeclStr(
        wxRect&, Deflate(wxCoord dx, wxCoord dy),
        "Decrease the rectangle size by dx in x direction and dy in y direction. Both\n"
        "(or one of) parameters may be negative to increase the rectngle size. This\n"
        "method is the opposite of Inflate.");

    DocDeclStrName(
        void, Offset(wxCoord dx, wxCoord dy),
        "Moves the rectangle by the specified offset. If dx is positive, the rectangle\n"
        "is moved to the right, if dy is positive, it is moved to the bottom, otherwise\n"
        "it is moved to the left or top respectively.",
        OffsetXY);

    DocDeclStr(
        void, Offset(const wxPoint& pt),
        "Same as OffsetXY but uses dx,dy from Point");

    DocDeclStr(
        wxRect&, Intersect(const wxRect& rect),
        "Return the intersectsion of this rectangle and rect.");

    DocDeclStr(
        wxRect, operator+(const wxRect& rect) const,
        "Add the properties of rect to this rectangle and return the result.");

    DocDeclStr(
        wxRect&, operator+=(const wxRect& rect),
        "Add the properties of rect to this rectangle, updating this rectangle.");

    DocDeclStr(
        bool, operator==(const wxRect& rect) const,
        "Test for equality.");

    DocDeclStr(
        bool, operator!=(const wxRect& rect) const,
        "Test for inequality.");


    DocStr( Inside, "Return True if the point is (not strcitly) inside the rect.");
    %name(InsideXY)bool Inside(int x, int y) const;
    bool Inside(const wxPoint& pt) const;

    DocDeclStr(
        bool, Intersects(const wxRect& rect) const,
        "Returns True if the rectangles have a non empty intersection.");


    int x, y, width, height;


    %extend {
       DocStr(Set, "Set all rectangle properties.");
        void Set(int x=0, int y=0, int width=0, int height=0) {
            self->x = x;
            self->y = y;
            self->width = width;
            self->height = height;
        }

        DocAStr(Get,
               "Get() -> (x,y,width,height)",
               "Return the rectangle properties as a tuple.");
        PyObject* Get() {
            bool blocked = wxPyBeginBlockThreads();
            PyObject* tup = PyTuple_New(4);
            PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
            PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
            PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
            PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
            wxPyEndBlockThreads(blocked);
            return tup;
        }
    }

    %pythoncode {
    asTuple = Get
    def __str__(self):                   return str(self.Get())
    def __repr__(self):                  return 'wx.Rect'+str(self.Get())
    def __len__(self):                   return len(self.Get())
    def __getitem__(self, index):        return self.Get()[index]
    def __setitem__(self, index, val):
        if index == 0: self.x = val
        elif index == 1: self.y = val
        elif index == 2: self.width = val
        elif index == 3: self.height = val
        else: raise IndexError
    def __nonzero__(self):               return self.Get() != (0,0,0,0)
    __safe_for_unpickling__ = True
    def __reduce__(self):                return (wx.Rect, self.Get())
    }
};


DocAStr(wxIntersectRect,
       "IntersectRect(Rect r1, Rect r2) -> Rect",
       "Calculate and return the intersection of r1 and r2.");
%inline %{
    PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
        wxRegion  reg1(*r1);
        wxRegion  reg2(*r2);
        wxRect    dest(0,0,0,0);
        PyObject* obj;

        reg1.Intersect(reg2);
        dest = reg1.GetBox();

        if (dest != wxRect(0,0,0,0)) {
            bool blocked = wxPyBeginBlockThreads();
            wxRect* newRect = new wxRect(dest);
            obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), True);
            wxPyEndBlockThreads(blocked);
            return obj;
        }
        Py_INCREF(Py_None);
        return Py_None;
    }
%}

//---------------------------------------------------------------------------
%newgroup


DocStr(wxPoint2D,
      "wx.Point2Ds represent a point or a vector in a 2d coordinate system with floating point values.");

class wxPoint2D
{
public:
    DocStr(wxPoint2D, "Create a w.Point2D object.");
    wxPoint2D( double x=0.0 , double y=0.0 );
    %name(Point2DCopy) wxPoint2D( const wxPoint2D &pt );
    %name(Point2DFromPoint) wxPoint2D( const wxPoint &pt );

    DocDeclAStr(
        void, GetFloor( int *OUTPUT , int *OUTPUT ) const,
        "GetFloor() -> (x,y)",
        "Convert to integer");

    DocDeclAStr(
        void, GetRounded( int *OUTPUT , int *OUTPUT ) const,
        "GetRounded() -> (x,y)",
        "Convert to integer");

    double GetVectorLength() const;
    double GetVectorAngle() const ;
    void SetVectorLength( double length );
    void SetVectorAngle( double degrees );

    // LinkError: void SetPolarCoordinates( double angle , double length );
    // LinkError: void Normalize();
    %pythoncode {
    def SetPolarCoordinates(self, angle, length):
        self.SetVectorLength(length)
        self.SetVectorAngle(angle)
    def Normalize(self):
        self.SetVectorLength(1.0)
    }

    double GetDistance( const wxPoint2D &pt ) const;
    double GetDistanceSquare( const wxPoint2D &pt ) const;
    double GetDotProduct( const wxPoint2D &vec ) const;
    double GetCrossProduct( const wxPoint2D &vec ) const;

    DocDeclStr(
        wxPoint2D, operator-(),
        "the reflection of this point");

    wxPoint2D& operator+=(const wxPoint2D& pt);
    wxPoint2D& operator-=(const wxPoint2D& pt);

    wxPoint2D& operator*=(const wxPoint2D& pt);
    wxPoint2D& operator/=(const wxPoint2D& pt);

    DocDeclStr(
        bool, operator==(const wxPoint2D& pt) const,
        "Test for equality");

    DocDeclStr(
        bool, operator!=(const wxPoint2D& pt) const,
        "Test for inequality");

    %name(x)double m_x;
    %name(y)double m_y;

    %extend {
        void Set( double x=0 , double y=0 ) {
            self->m_x = x;
            self->m_y = y;
        }

        DocAStr(Get,
               "Get() -> (x,y)",
               "Return x and y properties as a tuple.");
        PyObject* Get() {
            bool blocked = wxPyBeginBlockThreads();
            PyObject* tup = PyTuple_New(2);
            PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
            PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
            wxPyEndBlockThreads(blocked);
            return tup;
        }
    }

    %pythoncode {
    asTuple = Get
    def __str__(self):                   return str(self.Get())
    def __repr__(self):                  return 'wx.Point2D'+str(self.Get())
    def __len__(self):                   return len(self.Get())
    def __getitem__(self, index):        return self.Get()[index]
    def __setitem__(self, index, val):
        if index == 0: self.x = val
        elif index == 1: self.y = val
        else: raise IndexError
    def __nonzero__(self):               return self.Get() != (0.0, 0.0)
    __safe_for_unpickling__ = True
    def __reduce__(self):                return (wx.Point2D, self.Get())
    }
};


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

%immutable;
const wxPoint     wxDefaultPosition;
const wxSize      wxDefaultSize;
%mutable;

//---------------------------------------------------------------------------
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: _gdicmn.i
	3	// Purpose: SWIG interface for common GDI stuff and misc classes
	4	//
	5	// Author: Robin Dunn
	6	//
	7	// Created: 13-Sept-2003
	8	// RCS-ID: $Id$
	9	// Copyright: (c) 2003 by Total Control Software
	10	// Licence: wxWindows license
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13	// Not a %module
	14
	15
	16	//---------------------------------------------------------------------------
	17	%newgroup
	18
	19
	20	enum wxBitmapType
	21	{
	22	wxBITMAP_TYPE_INVALID, // should be == 0 for compatibility!
	23	wxBITMAP_TYPE_BMP,
	24	wxBITMAP_TYPE_ICO,
	25	wxBITMAP_TYPE_CUR,
	26	wxBITMAP_TYPE_XBM,
	27	wxBITMAP_TYPE_XBM_DATA,
	28	wxBITMAP_TYPE_XPM,
	29	wxBITMAP_TYPE_XPM_DATA,
	30	wxBITMAP_TYPE_TIF,
	31	wxBITMAP_TYPE_GIF,
	32	wxBITMAP_TYPE_PNG,
	33	wxBITMAP_TYPE_JPEG,
	34	wxBITMAP_TYPE_PNM,
	35	wxBITMAP_TYPE_PCX,
	36	wxBITMAP_TYPE_PICT,
	37	wxBITMAP_TYPE_ICON,
	38	wxBITMAP_TYPE_ANI,
	39	wxBITMAP_TYPE_IFF,
	40	wxBITMAP_TYPE_MACCURSOR,
	41
	42	// wxBITMAP_TYPE_BMP_RESOURCE,
	43	// wxBITMAP_TYPE_RESOURCE = wxBITMAP_TYPE_BMP_RESOURCE,
	44	// wxBITMAP_TYPE_ICO_RESOURCE,
	45	// wxBITMAP_TYPE_CUR_RESOURCE,
	46	// wxBITMAP_TYPE_TIF_RESOURCE,
	47	// wxBITMAP_TYPE_GIF_RESOURCE,
	48	// wxBITMAP_TYPE_PNG_RESOURCE,
	49	// wxBITMAP_TYPE_JPEG_RESOURCE,
	50	// wxBITMAP_TYPE_PNM_RESOURCE,
	51	// wxBITMAP_TYPE_PCX_RESOURCE,
	52	// wxBITMAP_TYPE_PICT_RESOURCE,
	53	// wxBITMAP_TYPE_ICON_RESOURCE,
	54	// wxBITMAP_TYPE_MACCURSOR_RESOURCE,
	55
	56	wxBITMAP_TYPE_ANY = 50
	57	};
	58
	59	// Standard cursors
	60	enum wxStockCursor
	61	{
	62	wxCURSOR_NONE, // should be 0
	63	wxCURSOR_ARROW,
	64	wxCURSOR_RIGHT_ARROW,
	65	wxCURSOR_BULLSEYE,
	66	wxCURSOR_CHAR,
	67	wxCURSOR_CROSS,
	68	wxCURSOR_HAND,
	69	wxCURSOR_IBEAM,
	70	wxCURSOR_LEFT_BUTTON,
	71	wxCURSOR_MAGNIFIER,
	72	wxCURSOR_MIDDLE_BUTTON,
	73	wxCURSOR_NO_ENTRY,
	74	wxCURSOR_PAINT_BRUSH,
	75	wxCURSOR_PENCIL,
	76	wxCURSOR_POINT_LEFT,
	77	wxCURSOR_POINT_RIGHT,
	78	wxCURSOR_QUESTION_ARROW,
	79	wxCURSOR_RIGHT_BUTTON,
	80	wxCURSOR_SIZENESW,
	81	wxCURSOR_SIZENS,
	82	wxCURSOR_SIZENWSE,
	83	wxCURSOR_SIZEWE,
	84	wxCURSOR_SIZING,
	85	wxCURSOR_SPRAYCAN,
	86	wxCURSOR_WAIT,
	87	wxCURSOR_WATCH,
	88	wxCURSOR_BLANK,
	89	wxCURSOR_DEFAULT, // standard X11 cursor
	90	wxCURSOR_COPY_ARROW , // MacOS Theme Plus arrow
	91
	92	// #ifdef __X__
	93	// // Not yet implemented for Windows
	94	// wxCURSOR_CROSS_REVERSE,
	95	// wxCURSOR_DOUBLE_ARROW,
	96	// wxCURSOR_BASED_ARROW_UP,
	97	// wxCURSOR_BASED_ARROW_DOWN,
	98	// #endif // X11
	99
	100	wxCURSOR_ARROWWAIT,
	101
	102	wxCURSOR_MAX
	103	};
	104
	105	%{
	106	#ifndef __WXMAC__
	107	#define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
	108	#endif
	109	%}
	110
	111	//---------------------------------------------------------------------------
	112	%newgroup
	113
	114	DocStr( wxSize,
	115	"wx.Size is a useful data structure used to represent the size of something.
	116	It simply contians integer width and height proprtites. In most places in
	117	wxPython where a wx.Size is expected a (width,height) tuple can be used
	118	instead.");
	119
	120	class wxSize
	121	{
	122	public:
	123	%name(width) int x;
	124	%name(height)int y;
	125	%pythoncode { x = width; y = height }
	126
	127	DocCtorStr(
	128	wxSize(int w=0, int h=0),
	129	"Creates a size object.");
	130
	131	~wxSize();
	132
	133	// %extend {
	134	// bool __eq__(const wxSize* other) { return other ? (self == other) : False; }
	135	// bool __ne__(const wxSize* other) { return other ? (self != other) : True; }
	136	// }
	137
	138	DocDeclStr(
	139	bool, operator==(const wxSize& sz),
	140	"Test for equality of wx.Size objects.");
	141
	142	DocDeclStr(
	143	bool, operator!=(const wxSize& sz),
	144	"Test for inequality.");
	145
	146	DocDeclStr(
	147	wxSize, operator+(const wxSize& sz),
	148	"Add sz's proprties to this and return the result.");
	149
	150	DocDeclStr(
	151	wxSize, operator-(const wxSize& sz),
	152	"Subtract sz's properties from this and return the result.");
	153
	154	DocDeclStr(
	155	void, IncTo(const wxSize& sz),
	156	"Increments this object so that both of its dimensions are not less\n"
	157	"than the corresponding dimensions of the size.");
	158
	159	DocDeclStr(
	160	void, DecTo(const wxSize& sz),
	161	"Decrements this object so that both of its dimensions are not greater\n"
	162	"than the corresponding dimensions of the size.");
	163
	164	DocDeclStr(
	165	void, Set(int w, int h),
	166	"Set both width and height.");
	167
	168	void SetWidth(int w);
	169	void SetHeight(int h);
	170	int GetWidth() const;
	171	int GetHeight() const;
	172
	173
	174	DocDeclStr(
	175	bool , IsFullySpecified() const,
	176	"Returns True if both components of the size are non-default values.");
	177
	178
	179	DocDeclStr(
	180	void , SetDefaults(const wxSize& size),
	181	"Combine this size with the other one replacing the default
	182	components of this object (i.e. equal to -1) with those of the
	183	other.");
	184
	185
	186	//int GetX() const;
	187	//int GetY() const;
	188
	189	%extend {
	190	DocAStr(Get,
	191	"Get() -> (width,height)",
	192	"Returns the width and height properties as a tuple.");
	193	PyObject* Get() {
	194	bool blocked = wxPyBeginBlockThreads();
	195	PyObject* tup = PyTuple_New(2);
	196	PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
	197	PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
	198	wxPyEndBlockThreads(blocked);
	199	return tup;
	200	}
	201	}
	202	%pythoncode {
	203	asTuple = Get
	204	def __str__(self): return str(self.Get())
	205	def __repr__(self): return 'wx.Size'+str(self.Get())
	206	def __len__(self): return len(self.Get())
	207	def __getitem__(self, index): return self.Get()[index]
	208	def __setitem__(self, index, val):
	209	if index == 0: self.width = val
	210	elif index == 1: self.height = val
	211	else: raise IndexError
	212	def __nonzero__(self): return self.Get() != (0,0)
	213	__safe_for_unpickling__ = True
	214	def __reduce__(self): return (wx.Size, self.Get())
	215	}
	216
	217	};
	218
	219	//---------------------------------------------------------------------------
	220	%newgroup
	221
	222	DocStr( wxRealPoint,
	223	"A data structure for representing a point or position with floating point x
	224	and y properties. In wxPython most places that expect a wx.RealPoint can also
	225	accept a (x,y) tuple.");
	226	class wxRealPoint
	227	{
	228	public:
	229	double x;
	230	double y;
	231
	232	DocCtorStr(
	233	wxRealPoint(double x=0.0, double y=0.0),
	234	"Create a wx.RealPoint object");
	235
	236	~wxRealPoint();
	237
	238	DocDeclStr(
	239	bool, operator==(const wxRealPoint& pt),
	240	"Test for equality of wx.RealPoint objects.");
	241
	242	DocDeclStr(
	243	bool, operator!=(const wxRealPoint& pt),
	244	"Test for inequality of wx.RealPoint objects.");
	245
	246
	247	DocDeclStr(
	248	wxRealPoint, operator+(const wxRealPoint& pt),
	249	"Add pt's proprties to this and return the result.");
	250
	251	DocDeclStr(
	252	wxRealPoint, operator-(const wxRealPoint& pt),
	253	"Subtract pt's proprties from this and return the result");
	254
	255
	256	%extend {
	257	DocStr(Set, "Set both the x and y properties");
	258	void Set(double x, double y) {
	259	self->x = x;
	260	self->y = y;
	261	}
	262
	263	DocAStr(Get,
	264	"Get() -> (x,y)",
	265	"Return the x and y properties as a tuple. ");
	266	PyObject* Get() {
	267	bool blocked = wxPyBeginBlockThreads();
	268	PyObject* tup = PyTuple_New(2);
	269	PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
	270	PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
	271	wxPyEndBlockThreads(blocked);
	272	return tup;
	273	}
	274	}
	275
	276	%pythoncode {
	277	asTuple = Get
	278	def __str__(self): return str(self.Get())
	279	def __repr__(self): return 'wx.RealPoint'+str(self.Get())
	280	def __len__(self): return len(self.Get())
	281	def __getitem__(self, index): return self.Get()[index]
	282	def __setitem__(self, index, val):
	283	if index == 0: self.x = val
	284	elif index == 1: self.y = val
	285	else: raise IndexError
	286	def __nonzero__(self): return self.Get() != (0.0, 0.0)
	287	__safe_for_unpickling__ = True
	288	def __reduce__(self): return (wx.RealPoint, self.Get())
	289	}
	290	};
	291
	292
	293	//---------------------------------------------------------------------------
	294	%newgroup
	295
	296
	297	DocStr(wxPoint,
	298	"A data structure for representing a point or position with integer x and y
	299	properties. Most places in wxPython that expect a wx.Point can also accept a
	300	(x,y) tuple.");
	301
	302	class wxPoint
	303	{
	304	public:
	305	int x, y;
	306
	307	DocCtorStr(
	308	wxPoint(int x=0, int y=0),
	309	"Create a wx.Point object");
	310
	311	~wxPoint();
	312
	313
	314	DocDeclStr(
	315	bool, operator==(const wxPoint& pt),
	316	"Test for equality of wx.Point objects.");
	317
	318	DocDeclStr(
	319	bool, operator!=(const wxPoint& pt),
	320	"Test for inequality of wx.Point objects.");
	321
	322
	323
	324	// %nokwargs operator+;
	325	// %nokwargs operator-;
	326	// %nokwargs operator+=;
	327	// %nokwargs operator-=;
	328
	329	DocDeclStr(
	330	wxPoint, operator+(const wxPoint& pt),
	331	"Add pt's proprties to this and return the result.");
	332
	333
	334	DocDeclStr(
	335	wxPoint, operator-(const wxPoint& pt),
	336	"Subtract pt's proprties from this and return the result");
	337
	338
	339	DocDeclStr(
	340	wxPoint&, operator+=(const wxPoint& pt),
	341	"Add pt to this object.");
	342
	343	DocDeclStr(
	344	wxPoint&, operator-=(const wxPoint& pt),
	345	"Subtract pt from this object.");
	346
	347
	348
	349	// DocDeclStr(
	350	// wxPoint, operator+(const wxSize& sz),
	351	// "Add sz to this Point and return the result.");
	352
	353	// DocDeclStr(
	354	// wxPoint, operator-(const wxSize& sz),
	355	// "Subtract sz from this Point and return the result");
	356
	357
	358	// DocDeclStr(
	359	// wxPoint&, operator+=(const wxSize& sz),
	360	// "Add sz to this object.");
	361
	362	// DocDeclStr(
	363	// wxPoint&, operator-=(const wxSize& sz),
	364	// "Subtract sz from this object.");
	365
	366
	367
	368
	369	%extend {
	370	DocStr(Set, "Set both the x and y properties");
	371	void Set(long x, long y) {
	372	self->x = x;
	373	self->y = y;
	374	}
	375
	376	DocAStr(Get,
	377	"Get() -> (x,y)",
	378	"Return the x and y properties as a tuple. ");
	379	PyObject* Get() {
	380	bool blocked = wxPyBeginBlockThreads();
	381	PyObject* tup = PyTuple_New(2);
	382	PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
	383	PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
	384	wxPyEndBlockThreads(blocked);
	385	return tup;
	386	}
	387	}
	388
	389	%pythoncode {
	390	asTuple = Get
	391	def __str__(self): return str(self.Get())
	392	def __repr__(self): return 'wx.Point'+str(self.Get())
	393	def __len__(self): return len(self.Get())
	394	def __getitem__(self, index): return self.Get()[index]
	395	def __setitem__(self, index, val):
	396	if index == 0: self.x = val
	397	elif index == 1: self.y = val
	398	else: raise IndexError
	399	def __nonzero__(self): return self.Get() != (0,0)
	400	__safe_for_unpickling__ = True
	401	def __reduce__(self): return (wx.Point, self.Get())
	402	}
	403	};
	404
	405	//---------------------------------------------------------------------------
	406	%newgroup
	407
	408
	409	DocStr(wxRect,
	410	"A class for representing and manipulating rectangles. It has x, y, width and
	411	height properties. In wxPython most palces that expect a wx.Rect can also
	412	accept a (x,y,width,height) tuple.");
	413
	414	class wxRect
	415	{
	416	public:
	417	DocCtorStr(
	418	wxRect(int x=0, int y=0, int width=0, int height=0),
	419	"Create a new Rect object.");
	420
	421	DocCtorStrName(
	422	wxRect(const wxPoint& topLeft, const wxPoint& bottomRight),
	423	"Create a new Rect object from Points representing two corners.",
	424	RectPP);
	425
	426	DocCtorStrName(
	427	wxRect(const wxPoint& pos, const wxSize& size),
	428	"Create a new Rect from a position and size.",
	429	RectPS);
	430
	431	~wxRect();
	432
	433	int GetX() const;
	434	void SetX(int x);
	435
	436	int GetY();
	437	void SetY(int y);
	438
	439	int GetWidth() const;
	440	void SetWidth(int w);
	441
	442	int GetHeight() const;
	443	void SetHeight(int h);
	444
	445	wxPoint GetPosition() const;
	446	void SetPosition( const wxPoint &p );
	447
	448	wxSize GetSize() const;
	449	void SetSize( const wxSize &s );
	450
	451	wxPoint GetTopLeft() const;
	452	void SetTopLeft(const wxPoint &p);
	453	wxPoint GetBottomRight() const;
	454	void SetBottomRight(const wxPoint &p);
	455
	456	// wxPoint GetLeftTop() const;
	457	// void SetLeftTop(const wxPoint &p);
	458	// wxPoint GetRightBottom() const;
	459	// void SetRightBottom(const wxPoint &p);
	460
	461	int GetLeft() const;
	462	int GetTop() const;
	463	int GetBottom() const;
	464	int GetRight() const;
	465
	466	void SetLeft(int left);
	467	void SetRight(int right);
	468	void SetTop(int top);
	469	void SetBottom(int bottom);
	470
	471	%pythoncode {
	472	position = property(GetPosition, SetPosition)
	473	size = property(GetSize, SetSize)
	474	left = property(GetLeft, SetLeft)
	475	right = property(GetRight, SetRight)
	476	top = property(GetTop, SetTop)
	477	bottom = property(GetBottom, SetBottom)
	478	}
	479
	480	DocDeclStr(
	481	wxRect&, Inflate(wxCoord dx, wxCoord dy),
	482	"Increase the rectangle size by dx in x direction and dy in y direction. Both\n"
	483	"(or one of) parameters may be negative to decrease the rectangle size.");
	484
	485	DocDeclStr(
	486	wxRect&, Deflate(wxCoord dx, wxCoord dy),
	487	"Decrease the rectangle size by dx in x direction and dy in y direction. Both\n"
	488	"(or one of) parameters may be negative to increase the rectngle size. This\n"
	489	"method is the opposite of Inflate.");
	490
	491	DocDeclStrName(
	492	void, Offset(wxCoord dx, wxCoord dy),
	493	"Moves the rectangle by the specified offset. If dx is positive, the rectangle\n"
	494	"is moved to the right, if dy is positive, it is moved to the bottom, otherwise\n"
	495	"it is moved to the left or top respectively.",
	496	OffsetXY);
	497
	498	DocDeclStr(
	499	void, Offset(const wxPoint& pt),
	500	"Same as OffsetXY but uses dx,dy from Point");
	501
	502	DocDeclStr(
	503	wxRect&, Intersect(const wxRect& rect),
	504	"Return the intersectsion of this rectangle and rect.");
	505
	506	DocDeclStr(
	507	wxRect, operator+(const wxRect& rect) const,
	508	"Add the properties of rect to this rectangle and return the result.");
	509
	510	DocDeclStr(
	511	wxRect&, operator+=(const wxRect& rect),
	512	"Add the properties of rect to this rectangle, updating this rectangle.");
	513
	514	DocDeclStr(
	515	bool, operator==(const wxRect& rect) const,
	516	"Test for equality.");
	517
	518	DocDeclStr(
	519	bool, operator!=(const wxRect& rect) const,
	520	"Test for inequality.");
	521
	522
	523	DocStr( Inside, "Return True if the point is (not strcitly) inside the rect.");
	524	%name(InsideXY)bool Inside(int x, int y) const;
	525	bool Inside(const wxPoint& pt) const;
	526
	527	DocDeclStr(
	528	bool, Intersects(const wxRect& rect) const,
	529	"Returns True if the rectangles have a non empty intersection.");
	530
	531
	532	int x, y, width, height;
	533
	534
	535	%extend {
	536	DocStr(Set, "Set all rectangle properties.");
	537	void Set(int x=0, int y=0, int width=0, int height=0) {
	538	self->x = x;
	539	self->y = y;
	540	self->width = width;
	541	self->height = height;
	542	}
	543
	544	DocAStr(Get,
	545	"Get() -> (x,y,width,height)",
	546	"Return the rectangle properties as a tuple.");
	547	PyObject* Get() {
	548	bool blocked = wxPyBeginBlockThreads();
	549	PyObject* tup = PyTuple_New(4);
	550	PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
	551	PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
	552	PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
	553	PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
	554	wxPyEndBlockThreads(blocked);
	555	return tup;
	556	}
	557	}
	558
	559	%pythoncode {
	560	asTuple = Get
	561	def __str__(self): return str(self.Get())
	562	def __repr__(self): return 'wx.Rect'+str(self.Get())
	563	def __len__(self): return len(self.Get())
	564	def __getitem__(self, index): return self.Get()[index]
	565	def __setitem__(self, index, val):
	566	if index == 0: self.x = val
	567	elif index == 1: self.y = val
	568	elif index == 2: self.width = val
	569	elif index == 3: self.height = val
	570	else: raise IndexError
	571	def __nonzero__(self): return self.Get() != (0,0,0,0)
	572	__safe_for_unpickling__ = True
	573	def __reduce__(self): return (wx.Rect, self.Get())
	574	}
	575	};
	576
	577
	578	DocAStr(wxIntersectRect,
	579	"IntersectRect(Rect r1, Rect r2) -> Rect",
	580	"Calculate and return the intersection of r1 and r2.");
	581	%inline %{
	582	PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
	583	wxRegion reg1(*r1);
	584	wxRegion reg2(*r2);
	585	wxRect dest(0,0,0,0);
	586	PyObject* obj;
	587
	588	reg1.Intersect(reg2);
	589	dest = reg1.GetBox();
	590
	591	if (dest != wxRect(0,0,0,0)) {
	592	bool blocked = wxPyBeginBlockThreads();
	593	wxRect* newRect = new wxRect(dest);
	594	obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), True);
	595	wxPyEndBlockThreads(blocked);
	596	return obj;
	597	}
	598	Py_INCREF(Py_None);
	599	return Py_None;
	600	}
	601	%}
	602
	603	//---------------------------------------------------------------------------
	604	%newgroup
	605
	606
	607	DocStr(wxPoint2D,
	608	"wx.Point2Ds represent a point or a vector in a 2d coordinate system with floating point values.");
	609
	610	class wxPoint2D
	611	{
	612	public:
	613	DocStr(wxPoint2D, "Create a w.Point2D object.");
	614	wxPoint2D( double x=0.0 , double y=0.0 );
	615	%name(Point2DCopy) wxPoint2D( const wxPoint2D &pt );
	616	%name(Point2DFromPoint) wxPoint2D( const wxPoint &pt );
	617
	618	DocDeclAStr(
	619	void, GetFloor( int OUTPUT , int OUTPUT ) const,
	620	"GetFloor() -> (x,y)",
	621	"Convert to integer");
	622
	623	DocDeclAStr(
	624	void, GetRounded( int OUTPUT , int OUTPUT ) const,
	625	"GetRounded() -> (x,y)",
	626	"Convert to integer");
	627
	628	double GetVectorLength() const;
	629	double GetVectorAngle() const ;
	630	void SetVectorLength( double length );
	631	void SetVectorAngle( double degrees );
	632
	633	// LinkError: void SetPolarCoordinates( double angle , double length );
	634	// LinkError: void Normalize();
	635	%pythoncode {
	636	def SetPolarCoordinates(self, angle, length):
	637	self.SetVectorLength(length)
	638	self.SetVectorAngle(angle)
	639	def Normalize(self):
	640	self.SetVectorLength(1.0)
	641	}
	642
	643	double GetDistance( const wxPoint2D &pt ) const;
	644	double GetDistanceSquare( const wxPoint2D &pt ) const;
	645	double GetDotProduct( const wxPoint2D &vec ) const;
	646	double GetCrossProduct( const wxPoint2D &vec ) const;
	647
	648	DocDeclStr(
	649	wxPoint2D, operator-(),
	650	"the reflection of this point");
	651
	652	wxPoint2D& operator+=(const wxPoint2D& pt);
	653	wxPoint2D& operator-=(const wxPoint2D& pt);
	654
	655	wxPoint2D& operator*=(const wxPoint2D& pt);
	656	wxPoint2D& operator/=(const wxPoint2D& pt);
	657
	658	DocDeclStr(
	659	bool, operator==(const wxPoint2D& pt) const,
	660	"Test for equality");
	661
	662	DocDeclStr(
	663	bool, operator!=(const wxPoint2D& pt) const,
	664	"Test for inequality");
	665
	666	%name(x)double m_x;
	667	%name(y)double m_y;
	668
	669	%extend {
	670	void Set( double x=0 , double y=0 ) {
	671	self->m_x = x;
	672	self->m_y = y;
	673	}
	674
	675	DocAStr(Get,
	676	"Get() -> (x,y)",
	677	"Return x and y properties as a tuple.");
	678	PyObject* Get() {
	679	bool blocked = wxPyBeginBlockThreads();
	680	PyObject* tup = PyTuple_New(2);
	681	PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
	682	PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
	683	wxPyEndBlockThreads(blocked);
	684	return tup;
	685	}
	686	}
	687
	688	%pythoncode {
	689	asTuple = Get
	690	def __str__(self): return str(self.Get())
	691	def __repr__(self): return 'wx.Point2D'+str(self.Get())
	692	def __len__(self): return len(self.Get())
	693	def __getitem__(self, index): return self.Get()[index]
	694	def __setitem__(self, index, val):
	695	if index == 0: self.x = val
	696	elif index == 1: self.y = val
	697	else: raise IndexError
	698	def __nonzero__(self): return self.Get() != (0.0, 0.0)
	699	__safe_for_unpickling__ = True
	700	def __reduce__(self): return (wx.Point2D, self.Get())
	701	}
	702	};
	703
	704
	705	//---------------------------------------------------------------------------
	706
	707	%immutable;
	708	const wxPoint wxDefaultPosition;
	709	const wxSize wxDefaultSize;
	710	%mutable;
	711
	712	//---------------------------------------------------------------------------