X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/1b62f00d8e3ec5437ab780cb3d73d299cc61e20c..55f9f0cbc8dcf45f8d484b2f931c5c254d4404d1:/wxPython/src/misc.i

diff --git a/wxPython/src/misc.i b/wxPython/src/misc.i
index 74b104185d..1719b55c64 100644
--- a/wxPython/src/misc.i
+++ b/wxPython/src/misc.i
@@ -17,6 +17,7 @@
 #include <wx/resource.h>
 #include <wx/tooltip.h>
 #include <wx/busyinfo.h>
+#include <wx/geometry.h>
 %}
 
 //----------------------------------------------------------------------
@@ -28,13 +29,30 @@
 %import _defs.i
 
 
+//---------------------------------------------------------------------------
 %{
-    static wxString wxPyEmptyStr("");
+    // Put some wx default wxChar* values into wxStrings.
+    static const wxString wxPyEmptyString(wxT(""));
 %}
-
 //---------------------------------------------------------------------------
 
 
+class wxObject {
+public:
+
+    %addmethods {
+        wxString GetClassName() {
+            return self->GetClassInfo()->GetClassName();
+        }
+
+        void Destroy() {
+            delete self;
+        }
+    }
+};
+
+//---------------------------------------------------------------------------
+
 class wxSize {
 public:
     long x;
@@ -54,22 +72,46 @@ public:
 
     %addmethods {
         PyObject* asTuple() {
+            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();
             return tup;
         }
+
+        bool __eq__(PyObject* obj) {
+            wxSize  tmp;
+            wxSize* ptr = &tmp;
+            if (obj == Py_None)    return FALSE;
+            wxPyBLOCK_THREADS(bool success = wxSize_helper(obj, &ptr); PyErr_Clear());
+            if (! success)         return FALSE;
+            return *self == *ptr;
+        }
+        bool __ne__(PyObject* obj) {
+            wxSize  tmp;
+            wxSize* ptr = &tmp;
+            if (obj == Py_None)    return TRUE;
+            wxPyBLOCK_THREADS(bool success = wxSize_helper(obj, &ptr); PyErr_Clear());
+            if (! success)         return TRUE;
+            return *self != *ptr;
+        }
+
     }
 
     %pragma(python) addtoclass = "
     def __str__(self):                   return str(self.asTuple())
-    def __repr__(self):                  return str(self.asTuple())
-    def __len__(self):                   return len(self.asTuple()
+    def __repr__(self):                  return 'wxSize'+str(self.asTuple())
+    def __len__(self):                   return len(self.asTuple())
     def __getitem__(self, index):        return self.asTuple()[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.asTuple() != (0,0)
+    def __getinitargs__(self):           return ()
+    def __getstate__(self):              return self.asTuple()
+    def __setstate__(self, state):       self.Set(*state)
 "
 
 };
@@ -89,36 +131,54 @@ public:
             self->y = y;
         }
         PyObject* asTuple() {
+            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();
             return tup;
         }
 
-        wxRealPoint __add__(const wxRealPoint* p) {
-            if (! p) return *self;
-            return *self + *p;
+        wxRealPoint __add__(const wxRealPoint& p) {
+            return *self + p;
         }
 
-        wxRealPoint __sub__(const wxRealPoint* p) {
-            if (! p) return *self;
-            return *self - *p;
+        wxRealPoint __sub__(const wxRealPoint& p) {
+            return *self - p;
         }
 
-        int __cmp__(const wxRealPoint* p) {
-            if (! p) return 0;
-            return *self == *p;
+        bool __eq__(PyObject* obj) {
+            wxRealPoint  tmp;
+            wxRealPoint* ptr = &tmp;
+            if (obj == Py_None)    return FALSE;
+            wxPyBLOCK_THREADS(bool success = wxRealPoint_helper(obj, &ptr); PyErr_Clear());
+            if (! success)         return FALSE;
+            return *self == *ptr;
+        }
+        bool __ne__(PyObject* obj) {
+            wxRealPoint  tmp;
+            wxRealPoint* ptr = &tmp;
+            if (obj == Py_None)    return TRUE;
+            wxPyBLOCK_THREADS(bool success = wxRealPoint_helper(obj, &ptr); PyErr_Clear());
+            if (! success)         return TRUE;
+            return *self != *ptr;
         }
+
     }
+
     %pragma(python) addtoclass = "
     def __str__(self):                   return str(self.asTuple())
-    def __repr__(self):                  return str(self.asTuple())
-    def __len__(self):                   return len(self.asTuple()
+    def __repr__(self):                  return 'wxRealPoint'+str(self.asTuple())
+    def __len__(self):                   return len(self.asTuple())
     def __getitem__(self, index):        return self.asTuple()[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.asTuple() != (0.0, 0.0)
+    def __getinitargs__(self):           return ()
+    def __getstate__(self):              return self.asTuple()
+    def __setstate__(self, state):       self.Set(*state)
 "
 };
 
@@ -136,36 +196,54 @@ public:
             self->y = y;
         }
         PyObject* asTuple() {
+            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();
             return tup;
         }
 
-        wxPoint __add__(const wxPoint* p) {
-            if (! p) return *self;
-            return *self + *p;
+        wxPoint __add__(const wxPoint& p) {
+            return *self + p;
         }
 
-        wxPoint __sub__(const wxPoint* p) {
-            if (! p) return *self;
-            return *self - *p;
+        wxPoint __sub__(const wxPoint& p) {
+            return *self - p;
         }
 
-        int __cmp__(const wxPoint* p) {
-            if (! p) return 0;
-            return *self == *p;
+        bool __eq__(PyObject* obj) {
+            wxPoint  tmp;
+            wxPoint* ptr = &tmp;
+            if (obj == Py_None)    return FALSE;
+            wxPyBLOCK_THREADS(bool success = wxPoint_helper(obj, &ptr); PyErr_Clear());
+            if (! success)         return FALSE;
+            return *self == *ptr;
+        }
+        bool __ne__(PyObject* obj) {
+            wxPoint  tmp;
+            wxPoint* ptr = &tmp;
+            if (obj == Py_None)    return TRUE;
+            wxPyBLOCK_THREADS(bool success = wxPoint_helper(obj, &ptr); PyErr_Clear());
+            if (! success)         return TRUE;
+            return *self != *ptr;
         }
+
     }
+
     %pragma(python) addtoclass = "
     def __str__(self):                   return str(self.asTuple())
-    def __repr__(self):                  return str(self.asTuple())
-    def __len__(self):                   return len(self.asTuple()
+    def __repr__(self):                  return 'wxPoint'+str(self.asTuple())
+    def __len__(self):                   return len(self.asTuple())
     def __getitem__(self, index):        return self.asTuple()[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.asTuple() != (0,0)
+    def __getinitargs__(self):           return ()
+    def __getstate__(self):              return self.asTuple()
+    def __setstate__(self, state):       self.Set(*state)
 "
 };
 
@@ -173,7 +251,7 @@ public:
 
 class wxRect {
 public:
-    wxRect(int x=0, int y=0, int w=0, int h=0);
+    wxRect(int x=0, int y=0, int width=0, int height=0);
     // TODO: do this one too... wxRect(const wxPoint& pos, const wxSize& size);
     ~wxRect();
 
@@ -189,6 +267,8 @@ public:
 
     wxPoint GetPosition();
     wxSize GetSize();
+    void SetPosition( const wxPoint &p );
+    void SetSize( const wxSize &s );
 
     int  GetLeft();
     int  GetTop();
@@ -200,36 +280,62 @@ public:
     void SetTop(int top);
     void SetBottom(int bottom);
 
+    void Deflate(int dx, int dy);
     void Inflate(int dx, int dy);
-    bool Inside(int cx, int cy);
+    %name(InsideXY)bool Inside(int cx, int cy);
+    bool Inside(const wxPoint& pt);
+    bool Intersects(const wxRect& rect);
+    %name(OffsetXY) void Offset(int dx, int dy);
+    void Offset(const wxPoint& pt);
 
     int x, y, width, height;
 
     %addmethods {
+        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;
+        }
+
         PyObject* asTuple() {
+            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();
             return tup;
         }
 
-        wxRect __add__(const wxRect* rect) {
-            if (! rect) return *self;
-            return *self + *rect;
+        wxRect __add__(const wxRect& rect) {
+            return *self + rect;
         }
 
-        int __cmp__(const wxRect* rect) {
-            if (! rect) return 0;
-            return *self == *rect;
+        bool __eq__(PyObject* obj) {
+            wxRect  tmp;
+            wxRect* ptr = &tmp;
+            if (obj == Py_None)    return FALSE;
+            wxPyBLOCK_THREADS(bool success = wxRect_helper(obj, &ptr); PyErr_Clear());
+            if (! success)         return FALSE;
+            return *self == *ptr;
         }
+        bool __ne__(PyObject* obj) {
+            wxRect  tmp;
+            wxRect* ptr = &tmp;
+            if (obj == Py_None)    return TRUE;
+            wxPyBLOCK_THREADS(bool success = wxRect_helper(obj, &ptr); PyErr_Clear());
+            if (! success)         return TRUE;
+            return *self != *ptr;
+        }
+
     }
 
     %pragma(python) addtoclass = "
     def __str__(self):                   return str(self.asTuple())
-    def __repr__(self):                  return str(self.asTuple())
-    def __len__(self):                   return len(self.asTuple()
+    def __repr__(self):                  return 'wxRect'+str(self.asTuple())
+    def __len__(self):                   return len(self.asTuple())
     def __getitem__(self, index):        return self.asTuple()[index]
     def __setitem__(self, index, val):
         if index == 0: self.x = val
@@ -237,6 +343,10 @@ public:
         elif index == 2: self.width = val
         elif index == 3: self.height = val
         else: raise IndexError
+    def __nonzero__(self):               return self.asTuple() != (0,0,0,0)
+    def __getinitargs__(self):           return ()
+    def __getstate__(self):              return self.asTuple()
+    def __setstate__(self, state):       self.Set(*state)
 
     # override the __getattr__ made by SWIG
     def __getattr__(self, name):
@@ -290,13 +400,13 @@ public:
         dest = reg1.GetBox();
 
         if (dest != wxRect(0,0,0,0)) {
-            bool doSave = wxPyRestoreThread();
+            wxPyBeginBlockThreads();
             wxRect* newRect = new wxRect(dest);
-            obj = wxPyConstructObject((void*)newRect, "wxRect");
+            obj = wxPyConstructObject((void*)newRect, wxT("wxRect"));
             PyObject* one = PyInt_FromLong(1);
             PyObject_SetAttrString(obj, "thisown", one);
             Py_DECREF(one);
-            wxPySaveThread(doSave);
+            wxPyEndBlockThreads();
             return obj;
         }
         Py_INCREF(Py_None);
@@ -305,16 +415,119 @@ public:
 %}
 
 
+
+//---------------------------------------------------------------------------
+// wxPoint2Ds represent a point or a vector in a 2d coordinate system
+
+class wxPoint2DDouble
+{
+public:
+    double m_x;
+    double m_y;
+
+    %name(x)double m_x;
+    %name(y)double m_y;
+
+    wxPoint2DDouble( double x=0 , double y=0 );
+    %name(wxPoint2DDoubleCopy)wxPoint2DDouble( const wxPoint2DDouble &pt );
+    %name(wxPoint2DDoubleFromPoint)wxPoint2DDouble( const wxPoint &pt );
+
+    // two different conversions to integers, floor and rounding
+    void GetFloor( int* OUTPUT , int* OUTPUT ) const;
+    void GetRounded( int* OUTPUT , int* OUTPUT ) const;
+
+    double GetVectorLength() const;
+    double GetVectorAngle() const ;
+    void SetVectorLength( double length );
+    void SetVectorAngle( double degrees );
+    // LinkError: void SetPolarCoordinates( double angle , double length );
+    // LinkError: void Normalize();
+    %pragma(python) addtoclass = "
+    def SetPolarCoordinates(self, angle, length):
+        self.SetVectorLength(length)
+        self.SetVectorAngle(angle)
+    def Normalize(self):
+        self.SetVectorLength(1.0)
+    "
+
+    double GetDistance( const wxPoint2DDouble &pt ) const;
+    double GetDistanceSquare( const wxPoint2DDouble &pt ) const;
+    double GetDotProduct( const wxPoint2DDouble &vec ) const;
+    double GetCrossProduct( const wxPoint2DDouble &vec ) const;
+
+    %addmethods {
+        void Set( double x=0 , double y=0 ) {
+            self->m_x = x;
+            self->m_y = y;
+        }
+
+        // the reflection of this point
+        wxPoint2DDouble __neg__() { return -(*self); }
+
+        wxPoint2DDouble& __iadd__(const wxPoint2DDouble& pt) { return (*self) += pt; }
+        wxPoint2DDouble& __isub__(const wxPoint2DDouble& pt) { return (*self) -= pt; }
+        wxPoint2DDouble& __imul__(const wxPoint2DDouble& pt) { return (*self) *= pt; }
+        wxPoint2DDouble& __idiv__(const wxPoint2DDouble& pt) { return (*self) /= pt; }
+
+        // TODO:
+        //wxPoint2DDouble& operator*=(double n);
+        //wxPoint2DDouble& operator*=(int n);
+        //wxPoint2DDouble& operator/=(double n);
+        //wxPoint2DDouble& operator/=(int n);
+
+        bool __eq__(PyObject* obj) {
+            wxPoint2DDouble  tmp;
+            wxPoint2DDouble* ptr = &tmp;
+            if (obj == Py_None)    return FALSE;
+            wxPyBLOCK_THREADS(bool success = wxPoint2DDouble_helper(obj, &ptr); PyErr_Clear());
+            if (! success)         return FALSE;
+            return *self == *ptr;
+        }
+        bool __ne__(PyObject* obj) {
+            wxPoint2DDouble  tmp;
+            wxPoint2DDouble* ptr = &tmp;
+            if (obj == Py_None)    return TRUE;
+            wxPyBLOCK_THREADS(bool success = wxPoint2DDouble_helper(obj, &ptr); PyErr_Clear());
+            if (! success)         return TRUE;
+            return *self != *ptr;
+        }
+
+
+        PyObject* asTuple() {
+            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();
+            return tup;
+        }
+    }
+
+    %pragma(python) addtoclass = "
+    def __str__(self):                   return str(self.asTuple())
+    def __repr__(self):                  return 'wxPoint2DDouble'+str(self.asTuple())
+    def __len__(self):                   return len(self.asTuple())
+    def __getitem__(self, index):        return self.asTuple()[index]
+    def __setitem__(self, index, val):
+        if index == 0: self.m_x = val
+        elif index == 1: self.m_yt = val
+        else: raise IndexError
+    def __nonzero__(self):               return self.asTuple() != (0.0, 0.0)
+    def __getinitargs__(self):           return ()
+    def __getstate__(self):              return self.asTuple()
+    def __setstate__(self, state):       self.Set(*state)
+"
+};
+
+
 //---------------------------------------------------------------------------
 // Miscellaneous functions
 
 long wxNewId();
 void wxRegisterId(long id);
-%name(NewId) long wxNewId();
-%name(RegisterId) void wxRegisterId(long id);
+long wxGetCurrentId();
 
 void wxBell();
-void wxDisplaySize(int *OUTPUT, int *OUTPUT);
 void wxEndBusyCursor();
 
 long wxGetElapsedTime(bool resetTimer = TRUE);
@@ -324,23 +537,37 @@ long wxGetFreeMemory();
 void wxGetMousePosition(int* OUTPUT, int* OUTPUT);
 bool wxIsBusy();
 wxString wxNow();
-bool wxShell(const wxString& command = wxPyEmptyStr);
+bool wxShell(const wxString& command = wxPyEmptyString);
 void wxStartTimer();
 int wxGetOsVersion(int *OUTPUT, int *OUTPUT);
 wxString wxGetOsDescription();
 
+enum wxShutdownFlags
+{
+    wxSHUTDOWN_POWEROFF,    // power off the computer
+    wxSHUTDOWN_REBOOT       // shutdown and reboot
+};
+
+// Shutdown or reboot the PC
+bool wxShutdown(wxShutdownFlags wFlags);
+
+
 void wxSleep(int secs);
 void wxUsleep(unsigned long milliseconds);
 bool wxYield();
+bool wxYieldIfNeeded();
 void wxEnableTopLevelWindows(bool enable);
 
-%inline %{
-    char* wxGetResource(char *section, char *entry, char *file = NULL) {
-        char * retval;
+#ifdef wxUSE_RESOURCES
+inline %{
+    wxString wxGetResource(const wxString& section, const wxString& entry,
+                           const wxString& file = wxPyEmptyString) {
+        wxChar* retval;
         wxGetResource(section, entry, &retval, file);
         return retval;
     }
 %}
+#endif
 
 wxString wxStripMenuCodes(const wxString& in);
 
@@ -351,7 +578,12 @@ wxString wxGetFullHostName();
 wxString wxGetUserId();
 wxString wxGetUserName();
 wxString wxGetHomeDir();
+wxString wxGetUserHome(const wxString& user = wxPyEmptyString);
+
+unsigned long wxGetProcessId();
 
+// When wxApp gets the virtual method magic then enable this.
+// bool wxHandleFatalExceptions(bool doIt = TRUE);
 
 //----------------------------------------------------------------------
 
@@ -368,7 +600,7 @@ enum wxRelationship { wxUnconstrained = 0,
                       wxAbsolute };
 
 
-class wxIndividualLayoutConstraint {
+class wxIndividualLayoutConstraint : public wxObject {
 public:
 //    wxIndividualLayoutConstraint();
 //    ~wxIndividualLayoutConstraint();
@@ -386,7 +618,7 @@ public:
 };
 
 
-class wxLayoutConstraints {
+class wxLayoutConstraints : public wxObject {
 public:
     wxLayoutConstraints();
 
@@ -403,71 +635,6 @@ public:
 }
 
 
-//---------------------------------------------------------------------------
-// Regions, etc.
-
-enum wxRegionContain {
-	wxOutRegion, wxPartRegion, wxInRegion
-};
-
-
-class wxRegion {
-public:
-    wxRegion(long x=0, long y=0, long width=0, long height=0);
-    ~wxRegion();
-
-    void Clear();
-    wxRegionContain Contains(long x, long y);
-    %name(ContainsPoint)wxRegionContain Contains(const wxPoint& pt);
-    %name(ContainsRect)wxRegionContain Contains(const wxRect& rect);
-    %name(ContainsRectDim)wxRegionContain Contains(long x, long y, long w, long h);
-
-    wxRect GetBox();
-
-    bool Intersect(long x, long y, long width, long height);
-    %name(IntersectRect)bool Intersect(const wxRect& rect);
-    %name(IntersectRegion)bool Intersect(const wxRegion& region);
-
-    bool IsEmpty();
-
-    bool Union(long x, long y, long width, long height);
-    %name(UnionRect)bool Union(const wxRect& rect);
-    %name(UnionRegion)bool Union(const wxRegion& region);
-
-    bool Subtract(long x, long y, long width, long height);
-    %name(SubtractRect)bool Subtract(const wxRect& rect);
-    %name(SubtractRegion)bool Subtract(const wxRegion& region);
-
-    bool Xor(long x, long y, long width, long height);
-    %name(XorRect)bool Xor(const wxRect& rect);
-    %name(XorRegion)bool Xor(const wxRegion& region);
-};
-
-
-
-class wxRegionIterator {
-public:
-    wxRegionIterator(const wxRegion& region);
-    ~wxRegionIterator();
-
-    long GetX();
-    long GetY();
-    long GetW();
-    long GetWidth();
-    long GetH();
-    long GetHeight();
-    wxRect GetRect();
-    bool HaveRects();
-    void Reset();
-
-    %addmethods {
-        void Next() {
-            (*self) ++;
-        }
-    };
-};
-
-
 
 //---------------------------------------------------------------------------
 // Accelerator Entry and Table
@@ -484,7 +651,7 @@ public:
 };
 
 
-class wxAcceleratorTable {
+class wxAcceleratorTable : public wxObject {
 public:
     // Can also accept a list of 3-tuples
     wxAcceleratorTable(int LCOUNT, wxAcceleratorEntry* choices);
@@ -507,12 +674,13 @@ extern wxAcceleratorTable wxNullAcceleratorTable;
 
 //---------------------------------------------------------------------------
 
-class wxBusyInfo {
+class wxBusyInfo : public wxObject {
 public:
     wxBusyInfo(const wxString& message);
     ~wxBusyInfo();
 };
 
+
 //---------------------------------------------------------------------------