AuroraMiddleware/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

All the Window and GDI (pen, bitmap, etc.) classes and also many

Browse Source 
toplevel functions will now check that a wx.App object has already
been created and will raise a wx.PyNoAppError exception if not.


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@27565 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robin Dunn 2004-06-01 21:38:05 +00:00
parent 68da5113e3
commit ab1f7d2aa9
79 changed files with 433 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
wxPython/contrib/activex/activex.i
View File

@ -515,6 +515,8 @@ specified by the TypeInfo.
", "");
MustHaveApp(wxActiveXWindow);
class wxActiveXWindow : public wxWindow
{
public:
@ -1053,6 +1055,8 @@ public:
%feature("noautodoc") wxIEHtmlWindowBase::GetText;
MustHaveApp(wxIEHtmlWindowBase);
class wxIEHtmlWindowBase : public wxActiveXWindow {
public:

15
wxPython/contrib/gizmos/gizmos.i
View File

@ -139,6 +139,8 @@ public:
*/
MustHaveApp(wxDynamicSashWindow);
class wxDynamicSashWindow : public wxWindow {
public:
%pythonAppend wxDynamicSashWindow "self._setOORInfo(self)"
@ -177,6 +179,7 @@ enum {
// This class provides a composite control that lets the
// user easily enter list of strings
MustHaveApp(wxEditableListBox);
class wxEditableListBox : public wxPanel
{
public:
@ -227,6 +230,8 @@ public:
typedef wxTreeCtrl wxPyTreeCtrl;
%}
MustHaveApp(wxRemotelyScrolledTreeCtrl);
class wxRemotelyScrolledTreeCtrl: public wxPyTreeCtrl
{
public:
@ -298,6 +303,8 @@ public:
%}
MustHaveApp(wxPyTreeCompanionWindow);
%name(TreeCompanionWindow) class wxPyTreeCompanionWindow: public wxWindow
{
public:
@ -323,6 +330,8 @@ public:
* than the usual one.
*/
MustHaveApp(wxThinSplitterWindow);
class wxThinSplitterWindow: public wxSplitterWindow
{
public:
@ -346,6 +355,8 @@ public:
* scroll appropriately.
*/
MustHaveApp(wxSplitterScrolledWindow);
class wxSplitterScrolledWindow: public wxScrolledWindow
{
public:
@ -375,6 +386,8 @@ enum wxLEDValueAlign
};
MustHaveApp(wxLEDNumberCtrl);
class wxLEDNumberCtrl : public wxControl
{
public:
@ -501,6 +514,8 @@ IMPLEMENT_ABSTRACT_CLASS(wxPyTreeListCtrl, wxTreeListCtrl)
MustHaveApp(wxPyTreeListCtrl);
%name(TreeListCtrl) class wxPyTreeListCtrl : public wxControl
{
public:

4
wxPython/contrib/glcanvas/glcanvas.i
View File

@ -43,6 +43,8 @@ class wxPalette;
//---------------------------------------------------------------------------
MustHaveApp(wxGLContext);
class wxGLContext : public wxObject {
public:
#ifndef __WXMAC__
@ -118,6 +120,8 @@ enum {
MustHaveApp(wxGLCanvas);
class wxGLCanvas : public wxWindow {
public:
%pythonAppend wxGLCanvas "self._setOORInfo(self)"

2
wxPython/contrib/iewin/iewin.i
View File

@ -78,6 +78,8 @@ enum wxIEHtmlRefreshLevel {
};
MustHaveApp(wxIEHtmlWin);
class wxIEHtmlWin : public wxWindow /* wxActiveX */
{
public:

2
wxPython/contrib/ogl/_oglcanvas.i
View File

@ -99,6 +99,8 @@ public:
%}
MustHaveApp(wxPyShapeCanvas);
class wxPyShapeCanvas : public wxScrolledWindow {
public:
%pythonAppend wxPyShapeCanvas "self._setOORandCallbackInfo(PyShapeCanvas)"

5
wxPython/contrib/xrc/_xmlres.i
View File

@ -44,9 +44,8 @@ class wxXmlResource : public wxObject
{
public:
%pythonAppend wxXmlResource(const wxString& filemask, int flags) "self.InitAllHandlers()"
%pythonAppend wxXmlResource(int flags) "val.InitAllHandlers()"
%pythonAppend wxXmlResource(const wxString& filemask, int flags) "self.InitAllHandlers()"
%pythonAppend wxXmlResource(int flags) "val.InitAllHandlers()"
// Ctors.
// Flags: wxXRC_USE_LOCALE

4
wxPython/docs/CHANGES.txt
View File

@ -95,6 +95,10 @@ MigrationGuide_ file for details.
EVT_STC_POSCHANGED has been removed as it has been deprecated in
Scintilla for several releases now.
All the Window and GDI (pen, bitmap, etc.) classes and also many
toplevel functions will now check that a wx.App object has already
been created and will raise a wx.PyNoAppError exception if not.

5
wxPython/docs/MigrationGuide.txt
View File

@ -52,6 +52,11 @@ Also, you will probably not be able to do any kind of GUI or bitmap
operation unless you first have created an app object, (even on
Windows where most anything was possible before.)
**[Changed in 2.5.2.0]** All the Window and GDI (pen, bitmap, etc.)
classes and also many toplevel functions will now check that a wx.App
object has already been created and will raise a wx.PyNoAppError
exception if not.
SWIG 1.3

2
wxPython/include/wx/wxPython/wxPython.h
View File

@ -133,6 +133,8 @@ inline wxPyCoreAPI* wxPyGetCoreAPIPtr()
#define wxPyInstance_Check(a) (wxPyGetCoreAPIPtr()->p_wxPyInstance_Check(a))
#define wxPySwigInstance_Check(a) (wxPyGetCoreAPIPtr()->p_wxPySwigInstance_Check(a))
#define wxPyCheckForApp() (wxPyGetCoreAPIPtr()->p_wxPyCheckForApp())
//----------------------------------------------------------------------
#endif

6
wxPython/include/wx/wxPython/wxPython_int.h
View File

@ -187,7 +187,9 @@ bool wxPoint2D_helper(PyObject* source, wxPoint2D** obj);
bool wxPySimple_typecheck(PyObject* source, const wxChar* classname, int seqLen);
bool wxColour_typecheck(PyObject* source);
bool wxPyCheckForApp();
template<class T>
bool wxPyTwoIntItem_helper(PyObject* source, T** obj, const wxChar* name)
{
@ -428,7 +430,9 @@ struct wxPyCoreAPI {
bool (*p_wxPyInstance_Check)(PyObject* obj);
bool (*p_wxPySwigInstance_Check)(PyObject* obj);
bool (*p_wxPyCheckForApp)();
};
#ifdef wxPyUSE_EXPORTED_API

4
wxPython/src/_artprov.i
View File

@ -186,6 +186,10 @@ identical bitmap for different client values!
of the categories above)
");
MustHaveApp(wxPyArtProvider);
MustHaveApp(wxPyArtProvider::GetBitmap);
MustHaveApp(wxPyArtProvider::GetIcon);
%name(ArtProvider) class wxPyArtProvider /*: public wxObject*/
{
public:

4
wxPython/src/_bitmap.i
View File

@ -65,6 +65,8 @@ converted to a wx.Bitmap, so any image file format supported by
");
MustHaveApp(wxBitmap);
class wxBitmap : public wxGDIObject
{
public:
@ -306,6 +308,8 @@ A mask may be associated with a `wx.Bitmap`. It is used in
`wx.MemoryDC` with a `wx.Bitmap` selected into it that contains a
mask.", "");
MustHaveApp(wxMask);
class wxMask : public wxObject {
public:

2
wxPython/src/_brush.i
View File

@ -33,6 +33,8 @@ a `wx.DC`. It has a colour and a style.", "
:see: `wx.BrushList`, `wx.DC`, `wx.DC.SetBrush`
");
MustHaveApp(wxBrush);
class wxBrush : public wxGDIObject {
public:
DocCtorStr(

4
wxPython/src/_button.i
View File

@ -58,6 +58,8 @@ Events
:see: `wx.BitmapButton`
");
MustHaveApp(wxButton);
class wxButton : public wxControl
{
public:
@ -143,6 +145,8 @@ Events
:see: `wx.Button`, `wx.Bitmap`
");
MustHaveApp(wxBitmapButton);
class wxBitmapButton : public wxButton
{
public:

2
wxPython/src/_checkbox.i
View File

@ -78,6 +78,8 @@ Events
MustHaveApp(wxCheckBox);
class wxCheckBox : public wxControl
{
public:

2
wxPython/src/_choice.i
View File

@ -34,6 +34,8 @@ Events
");
MustHaveApp(wxChoice);
class wxChoice : public wxControlWithItems
{
public:

20
wxPython/src/_cmndlgs.i
View File

@ -80,6 +80,8 @@ integer between 0 and 15. The default custom colours are all white.", "");
DocStr(wxColourDialog,
"This class represents the colour chooser dialog.", "");
MustHaveApp(wxColourDialog);
class wxColourDialog : public wxDialog {
public:
%pythonAppend wxColourDialog "self._setOORInfo(self)"
@ -113,6 +115,8 @@ Window Styles
==================== ==========================================
");
MustHaveApp(wxDirDialog);
class wxDirDialog : public wxDialog {
public:
%pythonAppend wxDirDialog "self._setOORInfo(self)"
@ -198,6 +202,8 @@ Window Styles
MustHaveApp(wxFileDialog);
class wxFileDialog : public wxDialog {
public:
%pythonAppend wxFileDialog "self._setOORInfo(self)"
@ -334,6 +340,8 @@ enum { wxCHOICEDLG_STYLE };
DocStr(wxMultiChoiceDialog,
"A simple dialog with a multi selection listbox.", "");
MustHaveApp(wxMultiChoiceDialog);
class wxMultiChoiceDialog : public wxDialog
{
public:
@ -374,6 +382,8 @@ integers.", "");
DocStr(wxSingleChoiceDialog,
"A simple dialog with a single selection listbox.", "");
MustHaveApp(wxSingleChoiceDialog);
class wxSingleChoiceDialog : public wxDialog {
public:
%pythonAppend wxSingleChoiceDialog "self._setOORInfo(self)"
@ -418,6 +428,8 @@ public:
DocStr(wxTextEntryDialog,
"A dialog with text control, [ok] and [cancel] buttons", "");
MustHaveApp(wxTextEntryDialog);
class wxTextEntryDialog : public wxDialog {
public:
%pythonAppend wxTextEntryDialog "self._setOORInfo(self)"
@ -528,6 +540,8 @@ DocStr(wxFontDialog,
:see: `wx.FontData`
", "");
MustHaveApp(wxFontDialog);
class wxFontDialog : public wxDialog {
public:
%pythonAppend wxFontDialog "self._setOORInfo(self)"
@ -575,6 +589,8 @@ Window Styles
");
MustHaveApp(wxMessageDialog);
class wxMessageDialog : public wxDialog {
public:
%pythonAppend wxMessageDialog "self._setOORInfo(self)"
@ -625,6 +641,8 @@ Window Styles
");
MustHaveApp(wxProgressDialog);
class wxProgressDialog : public wxFrame {
public:
%pythonAppend wxProgressDialog "self._setOORInfo(self)"
@ -841,6 +859,8 @@ Window Styles
===================== =========================================
");
MustHaveApp(wxFindReplaceDialog);
class wxFindReplaceDialog : public wxDialog {
public:
%pythonAppend wxFindReplaceDialog "self._setOORInfo(self)"

2
wxPython/src/_combobox.i
View File

@ -56,6 +56,8 @@ Events
MustHaveApp(wxComboBox);
#ifdef __WXMSW__
class wxComboBox : public wxChoice
#else

2
wxPython/src/_control.i
View File

@ -27,6 +27,8 @@ DocStr(wxControl,
A control is generally a small window which processes user input
and/or displays one or more item of data.", "");
MustHaveApp(wxControl);
class wxControl : public wxWindow
{
public:

4
wxPython/src/_core_api.i
View File

@ -206,7 +206,9 @@ static wxPyCoreAPI API = {
wxPyCBInputStream_create,
wxPyInstance_Check,
wxPySwigInstance_Check
wxPySwigInstance_Check,
wxPyCheckForApp
};

4
wxPython/src/_cshelp.i
View File

@ -133,6 +133,8 @@ There are a couple of ways to invoke this behaviour implicitly:
:see: `wx.ContextHelpButton`
", "");
MustHaveApp(wxContextHelp);
class wxContextHelp : public wxObject {
public:
DocCtorStr(
@ -178,6 +180,8 @@ similar buttons.
:see: `wx.ContextHelp`, `wx.ContextHelpButton`
", "");
MustHaveApp(wxContextHelpButton);
class wxContextHelpButton : public wxBitmapButton {
public:
%pythonAppend wxContextHelpButton "self._setOORInfo(self)"

2
wxPython/src/_cursor.i
View File

@ -61,6 +61,8 @@ Stock Cursor IDs
");
MustHaveApp(wxCursor);
class wxCursor : public wxGDIObject
{
public:

23
wxPython/src/_dc.i
View File

@ -626,6 +626,8 @@ static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
//---------------------------------------------------------------------------
%newgroup
MustHaveApp(wxMemoryDC);
class wxMemoryDC : public wxDC {
public:
wxMemoryDC();
@ -643,6 +645,8 @@ public:
%}
MustHaveApp(wxBufferedDC);
class wxBufferedDC : public wxMemoryDC
{
public:
@ -680,6 +684,7 @@ public:
MustHaveApp(wxBufferedPaintDC);
// Creates a double buffered wxPaintDC, optionally allowing the
// user to specify their own buffer to use.
@ -696,6 +701,8 @@ public:
//---------------------------------------------------------------------------
%newgroup
MustHaveApp(wxScreenDC);
class wxScreenDC : public wxDC {
public:
wxScreenDC();
@ -708,6 +715,8 @@ public:
//---------------------------------------------------------------------------
%newgroup
MustHaveApp(wxClientDC);
class wxClientDC : public wxDC {
public:
wxClientDC(wxWindow* win);
@ -716,6 +725,8 @@ public:
//---------------------------------------------------------------------------
%newgroup
MustHaveApp(wxPaintDC);
class wxPaintDC : public wxDC {
public:
wxPaintDC(wxWindow* win);
@ -724,6 +735,8 @@ public:
//---------------------------------------------------------------------------
%newgroup
MustHaveApp(wxWindowDC);
class wxWindowDC : public wxDC {
public:
wxWindowDC(wxWindow* win);
@ -732,6 +745,8 @@ public:
//---------------------------------------------------------------------------
%newgroup
MustHaveApp(wxMirrorDC);
class wxMirrorDC : public wxDC
{
public:
@ -751,6 +766,8 @@ public:
#include <wx/dcps.h>
%}
MustHaveApp(wxPostScriptDC);
class wxPostScriptDC : public wxDC {
public:
wxPostScriptDC(const wxPrintData& printData);
@ -769,6 +786,10 @@ public:
%newgroup
MustHaveApp(wxMetaFile);
MustHaveApp(wxMetaFileDC);
#if defined(__WXMSW__) || defined(__WXMAC__)
%{
@ -843,6 +864,8 @@ public:
//---------------------------------------------------------------------------
MustHaveApp(wxPrinterDC);
#if defined(__WXMSW__) || defined(__WXMAC__)
class wxPrinterDC : public wxDC {

35
wxPython/src/_defs.i
View File

@ -11,17 +11,40 @@
/////////////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------------
// Globally turn on the autodoc feature
%feature("autodoc", "1"); // 0 == no param types, 1 == show param types
//---------------------------------------------------------------------------
// Tell SWIG to wrap all the wrappers with our thread protection by default
%exception {
PyThreadState* __tstate = wxPyBeginAllowThreads();
$action
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
// This one can be used to add a check for an existing wxApp before the real
// work is done. An exception is raised if there isn't one.
%define MustHaveApp(name)
%exception name {
if (!wxPyCheckForApp()) SWIG_fail;
PyThreadState* __tstate = wxPyBeginAllowThreads();
$action
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
%enddef
//---------------------------------------------------------------------------
// some type definitions to simplify things for SWIG
// typedef int wxWindowID;
// typedef int wxCoord;
// typedef int wxInt32;
// typedef unsigned int wxUint32;
typedef int wxEventType;
typedef unsigned int size_t;
typedef unsigned int time_t;
@ -31,10 +54,6 @@ typedef unsigned char byte;
#define wxCoord int
#define wxInt32 int
#define wxUint32 unsigned int
//#define wxEventType int
//#define size_t unsigned int
//#define time_t unsigned int
//#define byte unsigned char
//----------------------------------------------------------------------

4
wxPython/src/_dirctrl.i
View File

@ -54,6 +54,8 @@ public:
MustHaveApp(wxGenericDirCtrl);
class wxGenericDirCtrl: public wxControl
{
public:
@ -136,6 +138,8 @@ leaf), done is set to True.
MustHaveApp(wxDirFilterListCtrl);
class wxDirFilterListCtrl: public wxChoice
{
public:

2
wxPython/src/_dragimg.i
View File

@ -24,6 +24,8 @@
MustHaveApp(wxGenericDragImage);
%name (DragImage) class wxGenericDragImage : public wxObject
{
public:

6
wxPython/src/_font.i
View File

@ -430,6 +430,10 @@ public:
%newgroup
MustHaveApp(wxFont);
MustHaveApp(wxFont::GetDefaultEncoding);
MustHaveApp(wxFont::SetDefaultEncoding);
class wxFont : public wxGDIObject {
public:
%pythonPrepend wxFont "if kwargs.has_key('faceName'): kwargs['face'] = kwargs['faceName'];del kwargs['faceName']"
@ -533,6 +537,8 @@ IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEnc
%}
MustHaveApp(wxPyFontEnumerator);
%name(FontEnumerator) class wxPyFontEnumerator {
public:
%pythonAppend wxPyFontEnumerator "self._setCallbackInfo(self, FontEnumerator, 0)"

46
wxPython/src/_functions.i
View File

@ -27,11 +27,15 @@ long wxNewId();
void wxRegisterId(long id);
long wxGetCurrentId();
MustHaveApp(wxBell);
void wxBell();
MustHaveApp(wxEndBusyCursor);
void wxEndBusyCursor();
long wxGetElapsedTime(bool resetTimer = True);
MustHaveApp(wxGetMousePosition);
DocDeclA(
void, wxGetMousePosition(int* OUTPUT, int* OUTPUT),
"GetMousePosition() -> (x,y)");
@ -63,6 +67,7 @@ enum wxShutdownFlags
};
// Shutdown or reboot the PC
MustHaveApp(wxShutdown);
bool wxShutdown(wxShutdownFlags wFlags);
@ -88,6 +93,7 @@ void wxTrap();
// Dialog Functions
MustHaveApp(wxFileSelector);
wxString wxFileSelector(const wxString& message = wxPyFileSelectorPromptStr,
const wxString& default_path = wxPyEmptyString,
const wxString& default_filename = wxPyEmptyString,
@ -101,24 +107,28 @@ wxString wxFileSelector(const wxString& message = wxPyFileSelectorPromptStr,
// Ask for filename to load
MustHaveApp(wxLoadFileSelector);
wxString wxLoadFileSelector(const wxString& what,
const wxString& extension,
const wxString& default_name = wxPyEmptyString,
wxWindow *parent = NULL);
// Ask for filename to save
MustHaveApp(wxSaveFileSelector);
wxString wxSaveFileSelector(const wxString& what,
const wxString& extension,
const wxString& default_name = wxPyEmptyString,
wxWindow *parent = NULL);
MustHaveApp(wxDirSelector);
wxString wxDirSelector(const wxString& message = wxPyDirSelectorPromptStr,
const wxString& defaultPath = wxPyEmptyString,
long style = wxDD_DEFAULT_STYLE,
const wxPoint& pos = wxDefaultPosition,
wxWindow *parent = NULL);
MustHaveApp(wxGetTextFromUser);
wxString wxGetTextFromUser(const wxString& message,
const wxString& caption = wxPyEmptyString,
const wxString& default_value = wxPyEmptyString,
@ -126,6 +136,7 @@ wxString wxGetTextFromUser(const wxString& message,
int x = -1, int y = -1,
bool centre = True);
MustHaveApp(wxGetPasswordFromUser);
wxString wxGetPasswordFromUser(const wxString& message,
const wxString& caption = wxPyEmptyString,
const wxString& default_value = wxPyEmptyString,
@ -140,6 +151,7 @@ wxString wxGetPasswordFromUser(const wxString& message,
// bool centre = True, int width=150, int height=200);
MustHaveApp(wxGetSingleChoice);
wxString wxGetSingleChoice(const wxString& message, const wxString& caption,
int choices, wxString* choices_array,
wxWindow *parent = NULL,
@ -147,6 +159,7 @@ wxString wxGetSingleChoice(const wxString& message, const wxString& caption,
bool centre = True,
int width=150, int height=200);
MustHaveApp(wxGetSingleChoiceIndex);
int wxGetSingleChoiceIndex(const wxString& message, const wxString& caption,
int choices, wxString* choices_array,
wxWindow *parent = NULL,
@ -155,12 +168,14 @@ int wxGetSingleChoiceIndex(const wxString& message, const wxString& caption,
int width=150, int height=200);
MustHaveApp(wxMessageBox);
int wxMessageBox(const wxString& message,
const wxString& caption = wxPyEmptyString,
int style = wxOK | wxCENTRE,
wxWindow *parent = NULL,
int x = -1, int y = -1);
MustHaveApp(wxGetNumberFromUser);
long wxGetNumberFromUser(const wxString& message,
const wxString& prompt,
const wxString& caption,
@ -171,38 +186,60 @@ long wxGetNumberFromUser(const wxString& message,
// GDI Functions
MustHaveApp(wxColourDisplay);
bool wxColourDisplay();
MustHaveApp(wxDisplayDepth);
int wxDisplayDepth();
MustHaveApp(wxGetDisplayDepth);
int wxGetDisplayDepth();
MustHaveApp(wxDisplaySize);
DocDeclA(
void, wxDisplaySize(int* OUTPUT, int* OUTPUT),
"DisplaySize() -> (width, height)");
MustHaveApp(wxGetDisplaySize);
wxSize wxGetDisplaySize();
MustHaveApp(wxDisplaySizeMM);
DocDeclA(
void, wxDisplaySizeMM(int* OUTPUT, int* OUTPUT),
"DisplaySizeMM() -> (width, height)");
MustHaveApp(wxGetDisplaySizeMM);
wxSize wxGetDisplaySizeMM();
MustHaveApp(wxClientDisplayRect);
DocDeclA(
void, wxClientDisplayRect(int *OUTPUT, int *OUTPUT, int *OUTPUT, int *OUTPUT),
"ClientDisplayRect() -> (x, y, width, height)");
MustHaveApp(wxGetClientDisplayRect);
wxRect wxGetClientDisplayRect();
MustHaveApp(wxSetCursor);
void wxSetCursor(wxCursor& cursor);
// Miscellaneous functions
MustHaveApp(wxBeginBusyCursor);
void wxBeginBusyCursor(wxCursor *cursor = wxHOURGLASS_CURSOR);
MustHaveApp(wxGetActiveWindow);
wxWindow * wxGetActiveWindow();
MustHaveApp(wxGenericFindWindowAtPoint);
wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt);
MustHaveApp(wxFindWindowAtPoint);
wxWindow* wxFindWindowAtPoint(const wxPoint& pt);
MustHaveApp(wxGetTopLevelParent);
wxWindow* wxGetTopLevelParent(wxWindow *win);
//bool wxSpawnBrowser(wxWindow *parent, wxString href);
@ -210,6 +247,7 @@ wxWindow* wxGetTopLevelParent(wxWindow *win);
MustHaveApp(wxGetKeyState);
DocDeclStr(
bool , wxGetKeyState(wxKeyCode key),
"Get the state of a key (true if pressed or toggled on, false if not.)
@ -221,6 +259,8 @@ toggle keys. On some platforms those may be the only keys that work.
//---------------------------------------------------------------------------
MustHaveApp(wxWakeUpMainThread);
#if defined(__WXMSW__) || defined(__WXMAC__)
void wxWakeUpMainThread();
#else
@ -229,10 +269,15 @@ void wxWakeUpMainThread();
%}
#endif
MustHaveApp(wxMutexGuiEnter);
void wxMutexGuiEnter();
MustHaveApp(wxMutexGuiLeave);
void wxMutexGuiLeave();
MustHaveApp(wxMutexGuiLocker);
class wxMutexGuiLocker {
public:
wxMutexGuiLocker();
@ -240,6 +285,7 @@ public:
};
MustHaveApp(wxThread);
%inline %{
bool wxThread_IsMain() {
#ifdef WXP_WITH_THREAD

2
wxPython/src/_gauge.i
View File

@ -29,6 +29,8 @@ enum {
//---------------------------------------------------------------------------
MustHaveApp(wxGauge);
class wxGauge : public wxControl {
public:
%pythonAppend wxGauge "self._setOORInfo(self)"

2
wxPython/src/_gdicmn.i
View File

@ -576,6 +576,8 @@ bottom, otherwise it is moved to the left or top respectively.", "",
};
MustHaveApp(wxIntersectRect);
DocAStr(wxIntersectRect,
"IntersectRect(Rect r1, Rect r2) -> Rect",
"Calculate and return the intersection of r1 and r2.", "");

2
wxPython/src/_gdiobj.i
View File

@ -15,6 +15,8 @@
//---------------------------------------------------------------------------
%newgroup
MustHaveApp(wxGDIObject);
class wxGDIObject : public wxObject {
public:
wxGDIObject();

2
wxPython/src/_icon.i
View File

@ -20,6 +20,8 @@
//---------------------------------------------------------------------------
MustHaveApp(wxIcon);
class wxIcon : public wxGDIObject
{
public:

6
wxPython/src/_image.i
View File

@ -90,7 +90,8 @@ public:
else
return new wxImage;
}
MustHaveApp(wxImage(const wxBitmap &bitmap));
%name(ImageFromBitmap) wxImage(const wxBitmap &bitmap) {
return new wxImage(bitmap.ConvertToImage());
}
@ -312,6 +313,9 @@ success flag and rgb values.", "");
static wxString GetImageExtWildcard();
MustHaveApp(ConvertToBitmap);
MustHaveApp(ConvertToMonoBitmap);
%extend {
wxBitmap ConvertToBitmap() {
wxBitmap bitmap(*self);

2
wxPython/src/_imaglist.i
View File

@ -33,6 +33,8 @@ enum {
};
MustHaveApp(wxImageList);
// wxImageList is used for wxListCtrl, wxTreeCtrl. These controls refer to
// images for their items by an index into an image list.

2
wxPython/src/_joystick.i
View File

@ -103,6 +103,8 @@ public:
%}
MustHaveApp(wxJoystick);
class wxJoystick /* : public wxObject */
{
public:

4
wxPython/src/_listbox.i
View File

@ -26,6 +26,8 @@ MAKE_CONST_WXSTRING(ListBoxNameStr);
//---------------------------------------------------------------------------
%newgroup
MustHaveApp(wxListBox);
class wxListBox : public wxControlWithItems
{
public:
@ -137,6 +139,8 @@ public:
%newgroup
MustHaveApp(wxCheckListBox);
// wxCheckListBox: a listbox whose items may be checked
class wxCheckListBox : public wxListBox
{

6
wxPython/src/_listctrl.i
View File

@ -17,8 +17,8 @@
%{
#include <wx/listctrl.h>
%}
MAKE_CONST_WXSTRING2(ListCtrlNameStr, _T("wxListCtrl"));
//---------------------------------------------------------------------------
@ -398,6 +398,8 @@ IMP_PYCALLBACK_LISTATTR_LONG(wxPyListCtrl, wxListCtrl, OnGetItemAttr);
MustHaveApp(wxPyListCtrl);
%name(ListCtrl)class wxPyListCtrl : public wxControl {
public:
@ -778,6 +780,8 @@ details in the second return value (see wxLIST_HITTEST_... flags.)", "");
%newgroup
MustHaveApp(wxListView);
// wxListView: a class which provides a little better API for list control
class wxListView : public wxPyListCtrl
{

6
wxPython/src/_mdi.i
View File

@ -33,6 +33,8 @@
MustHaveApp(wxMDIParentFrame);
class wxMDIParentFrame : public wxFrame {
public:
%pythonAppend wxMDIParentFrame "self._setOORInfo(self)"
@ -78,6 +80,8 @@ public:
//---------------------------------------------------------------------------
MustHaveApp(wxMDIChildFrame);
class wxMDIChildFrame : public wxFrame {
public:
%pythonAppend wxMDIChildFrame "self._setOORInfo(self)"
@ -109,6 +113,8 @@ public:
//---------------------------------------------------------------------------
MustHaveApp(wxMDIClientWindow);
class wxMDIClientWindow : public wxWindow {
public:
%pythonAppend wxMDIClientWindow "self._setOORInfo(self)"

4
wxPython/src/_menu.i
View File

@ -17,6 +17,8 @@
%newgroup
MustHaveApp(wxMenu);
class wxMenu : public wxEvtHandler
{
public:
@ -203,6 +205,8 @@ public:
//---------------------------------------------------------------------------
%newgroup
MustHaveApp(wxMenuBar);
class wxMenuBar : public wxWindow
{
public:

11
wxPython/src/_misc.i
View File

@ -19,6 +19,9 @@
#ifndef __WXX11__
MustHaveApp(wxToolTip);
class wxToolTip : public wxObject {
public:
wxToolTip(const wxString &tip);
@ -35,6 +38,8 @@ public:
//---------------------------------------------------------------------------
MustHaveApp(wxCaret);
class wxCaret {
public:
wxCaret(wxWindow* window, const wxSize& size);
@ -79,6 +84,8 @@ public:
//---------------------------------------------------------------------------
MustHaveApp(wxBusyCursor);
class wxBusyCursor {
public:
wxBusyCursor(wxCursor* cursor = wxHOURGLASS_CURSOR);
@ -87,6 +94,8 @@ public:
//---------------------------------------------------------------------------
MustHaveApp(wxWindowDisabler);
class wxWindowDisabler {
public:
wxWindowDisabler(wxWindow *winToSkip = NULL);
@ -95,6 +104,8 @@ public:
//---------------------------------------------------------------------------
MustHaveApp(wxBusyInfo);
class wxBusyInfo : public wxObject {
public:
wxBusyInfo(const wxString& message);

6
wxPython/src/_notebook.i
View File

@ -22,6 +22,8 @@ MAKE_CONST_WXSTRING(NOTEBOOK_NAME);
// TODO: Virtualize this class so other book controls can be derived in Python
MustHaveApp(wxBookCtrl);
// Common base class for wxList/Tree/Notebook
class wxBookCtrl : public wxControl
{
@ -160,6 +162,8 @@ enum {
MustHaveApp(wxNotebook);
class wxNotebook : public wxBookCtrl {
public:
%pythonAppend wxNotebook "self._setOORInfo(self)"
@ -286,6 +290,8 @@ enum
MustHaveApp(wxListbook);
// wxListCtrl and wxNotebook combination
class wxListbook : public wxBookCtrl
{

2
wxPython/src/_palette.i
View File

@ -19,6 +19,8 @@
//---------------------------------------------------------------------------
MustHaveApp(wxPalette);
class wxPalette : public wxGDIObject {
public:
wxPalette(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue);

4
wxPython/src/_panel.i
View File

@ -22,6 +22,8 @@
%newgroup
MustHaveApp(wxPanel);
class wxPanel : public wxWindow
{
public:
@ -57,6 +59,8 @@ public:
// derive from it and wxPanel. But what to do about wxGTK where this
// is not True?
MustHaveApp(wxScrolledWindow);
class wxScrolledWindow : public wxPanel
{
public:

2
wxPython/src/_pen.i
View File

@ -29,6 +29,8 @@
%newgroup
MustHaveApp(wxPen);
class wxPen : public wxGDIObject {
public:
wxPen(wxColour& colour, int width=1, int style=wxSOLID);

5
wxPython/src/_popupwin.i
View File

@ -23,9 +23,12 @@
#ifndef __WXMAC__
%newgroup;
MustHaveApp(wxPopupWindow);
// wxPopupWindow: a special kind of top level window used for popup menus,
// combobox popups and such.
MustHaveApp(wxPopupWindow);
class wxPopupWindow : public wxWindow {
public:
%pythonAppend wxPopupWindow "self._setOORInfo(self)"
@ -73,9 +76,11 @@ IMP_PYCALLBACK_BOOL_(wxPyPopupTransientWindow, wxPopupTransientWindow, CanDismis
%}
MustHaveApp(wxPyPopupTransientWindow);
// wxPopupTransientWindow: a wxPopupWindow which disappears automatically
// when the user clicks mouse outside it or if it loses focus in any other way
%name(PopupTransientWindow) class wxPyPopupTransientWindow : public wxPopupWindow
{
public:

22
wxPython/src/_printfw.i
View File

@ -149,6 +149,8 @@ public:
MustHaveApp(wxPageSetupDialog);
class wxPageSetupDialog : public wxDialog {
public:
%pythonAppend wxPageSetupDialog "self._setOORInfo(self)"
@ -217,6 +219,8 @@ public:
};
MustHaveApp(wxPrintDialog);
class wxPrintDialog : public wxDialog {
public:
%pythonAppend wxPrintDialog "self._setOORInfo(self)"
@ -243,6 +247,8 @@ enum wxPrinterError
};
MustHaveApp(wxPrinter);
class wxPrinter : public wxObject {
public:
wxPrinter(wxPrintDialogData* data = NULL);
@ -323,6 +329,8 @@ IMP_PYCALLBACK_BOOL_INT(wxPyPrintout, wxPrintout, HasPage);
%}
MustHaveApp(wxPyPrintout);
// Now define the custom class for SWIGging
%name(Printout) class wxPyPrintout : public wxObject {
public:
@ -377,6 +385,8 @@ public:
MustHaveApp(wxPreviewCanvas);
class wxPreviewCanvas: public wxScrolledWindow
{
public:
@ -391,6 +401,8 @@ public:
};
MustHaveApp(wxPreviewFrame);
class wxPreviewFrame : public wxFrame {
public:
%pythonAppend wxPreviewFrame "self._setOORInfo(self)"
@ -430,6 +442,8 @@ enum {
wxID_PREVIEW_GOTO
};
MustHaveApp(wxPreviewControlBar);
class wxPreviewControlBar: public wxPanel
{
public:
@ -458,6 +472,8 @@ public:
//---------------------------------------------------------------------------
MustHaveApp(wxPrintPreview);
class wxPrintPreview : public wxObject {
public:
%nokwargs wxPrintPreview;
@ -592,6 +608,8 @@ IMP_PYCALLBACK_VOID_ (wxPyPrintPreview, wxPrintPreview, DetermineScaling)
%}
MustHaveApp(wxPyPrintPreview);
class wxPyPrintPreview : public wxPrintPreview
{
public:
@ -650,6 +668,8 @@ IMP_PYCALLBACK_VOID_(wxPyPreviewFrame, wxPreviewFrame, CreateControlBar);
%}
MustHaveApp(wxPyPreviewFrame);
class wxPyPreviewFrame : public wxPreviewFrame
{
public:
@ -704,6 +724,8 @@ IMP_PYCALLBACK_VOID_INT(wxPyPreviewControlBar, wxPreviewControlBar, SetZoomContr
%}
MustHaveApp(wxPyPreviewControlBar);
class wxPyPreviewControlBar : public wxPreviewControlBar
{
public:

2
wxPython/src/_process.i
View File

@ -159,6 +159,8 @@ enum
};
MustHaveApp(wxExecute);
long wxExecute(const wxString& command,
int flags = wxEXEC_ASYNC,
wxPyProcess *process = NULL);

1
wxPython/src/_pycontrol.i
View File

@ -99,6 +99,7 @@ IMP_PYCALLBACK_VIZATTR_(wxPyControl, wxControl, GetDefaultAttributes);
%}
// And now the one for SWIG to see
MustHaveApp(wxPyControl);
class wxPyControl : public wxControl
{
public:

3
wxPython/src/_pywindows.i
View File

@ -129,6 +129,7 @@ IMP_PYCALLBACK_VIZATTR_(wxPyWindow, wxWindow, GetDefaultAttributes);
%}
// And now the one for SWIG to see
MustHaveApp(wxPyWindow);
class wxPyWindow : public wxWindow
{
public:
@ -273,6 +274,7 @@ IMP_PYCALLBACK_VIZATTR_(wxPyPanel, wxPanel, GetDefaultAttributes);
%}
// And now the one for SWIG to see
MustHaveApp(wxPyPanel);
class wxPyPanel : public wxPanel
{
public:
@ -409,6 +411,7 @@ IMP_PYCALLBACK_VIZATTR_(wxPyScrolledWindow, wxScrolledWindow, GetDefaultAttribut
%}
// And now the one for SWIG to see
MustHaveApp(wxPyScrolledWindow);
class wxPyScrolledWindow : public wxScrolledWindow
{
public:

4
wxPython/src/_radio.i
View File

@ -21,6 +21,8 @@ MAKE_CONST_WXSTRING(RadioButtonNameStr);
//---------------------------------------------------------------------------
%newgroup
MustHaveApp(wxRadioBox);
class wxRadioBox : public wxControl
{
public:
@ -94,6 +96,8 @@ public:
//---------------------------------------------------------------------------
%newgroup
MustHaveApp(wxRadioButton);
class wxRadioButton : public wxControl
{
public:

4
wxPython/src/_region.i
View File

@ -41,6 +41,8 @@ enum wxRegionContain
MustHaveApp(wxRegion);
class wxRegion : public wxGDIObject {
public:
wxRegion(wxCoord x=0, wxCoord y=0, wxCoord width=0, wxCoord height=0);
@ -108,6 +110,8 @@ public:
MustHaveApp(wxRegionIterator);
class wxRegionIterator : public wxObject {
public:
wxRegionIterator(const wxRegion& region);

4
wxPython/src/_sashwin.i
View File

@ -48,6 +48,8 @@ enum wxSashEdgePosition {
// wxSashWindow allows any of its edges to have a sash which can be dragged
// to resize the window. The actual content window will be created as a child
// of wxSashWindow.
MustHaveApp(wxSashWindow);
class wxSashWindow: public wxWindow
{
public:
@ -234,6 +236,8 @@ public:
// This is window that can remember alignment/orientation, does its own layout,
// and can provide sashes too. Useful for implementing docked windows with sashes in
// an IDE-style interface.
MustHaveApp(wxSashLayoutWindow);
class wxSashLayoutWindow: public wxSashWindow
{
public:

2
wxPython/src/_scrolbar.i
View File

@ -20,6 +20,8 @@ MAKE_CONST_WXSTRING(ScrollBarNameStr);
//---------------------------------------------------------------------------
%newgroup
MustHaveApp(wxScrollBar);
class wxScrollBar : public wxControl {
public:
%pythonAppend wxScrollBar "self._setOORInfo(self)"

6
wxPython/src/_settings.i
View File

@ -148,6 +148,12 @@ enum wxSystemScreenType
//---------------------------------------------------------------------------
MustHaveApp(wxSystemSettings::GetColour);
MustHaveApp(wxSystemSettings::GetFont);
MustHaveApp(wxSystemSettings::GetMetric);
MustHaveApp(wxSystemSettings::HasFeature);
MustHaveApp(wxSystemSettings::GetScreenType);
MustHaveApp(wxSystemSettings::SetScreenType);
class wxSystemSettings
{

2
wxPython/src/_slider.i
View File

@ -25,6 +25,8 @@ MAKE_CONST_WXSTRING(SliderNameStr);
//---------------------------------------------------------------------------
%newgroup
MustHaveApp(wxSlider);
class wxSlider : public wxControl {
public:
%pythonPrepend wxSlider "if kwargs.has_key('point'): kwargs['pos'] = kwargs['point'];del kwargs['point']"

4
wxPython/src/_sound.i
View File

@ -71,6 +71,10 @@ public:
MustHaveApp(wxSound);
MustHaveApp(wxSound::Play);
MustHaveApp(wxSound::Stop);
class wxSound /*: public wxObject*/
{
public:

3
wxPython/src/_spin.i
View File

@ -38,6 +38,7 @@ enum {
// wxSP_VERTICAL: vertical spin button (the default)
// wxSP_ARROW_KEYS: arrow keys increment/decrement value
// wxSP_WRAP: value wraps at either end
MustHaveApp(wxSpinButton);
class wxSpinButton : public wxControl
{
public:
@ -80,6 +81,8 @@ public:
// a spin ctrl is a text control with a spin button which is usually used to
// prompt the user for a numeric input
MustHaveApp(wxSpinCtrl);
class wxSpinCtrl : public wxControl
{
public:

2
wxPython/src/_splitter.i
View File

@ -104,6 +104,8 @@ Events
MustHaveApp(wxSplitterWindow);
class wxSplitterWindow: public wxWindow
{
public:

8
wxPython/src/_statctrls.i
View File

@ -23,6 +23,8 @@ MAKE_CONST_WXSTRING(StaticTextNameStr);
//---------------------------------------------------------------------------
%newgroup
MustHaveApp(wxStaticBox);
class wxStaticBox : public wxControl {
public:
%pythonAppend wxStaticBox "self._setOORInfo(self)"
@ -50,6 +52,8 @@ public:
%newgroup
MustHaveApp(wxStaticLine);
class wxStaticLine : public wxControl {
public:
%pythonAppend wxStaticLine "self._setOORInfo(self)"
@ -82,6 +86,8 @@ public:
//---------------------------------------------------------------------------
%newgroup
MustHaveApp(wxStaticText);
class wxStaticText : public wxControl {
public:
%pythonAppend wxStaticText "self._setOORInfo(self)"
@ -107,6 +113,8 @@ public:
//---------------------------------------------------------------------------
%newgroup
MustHaveApp(wxStaticBitmap);
class wxStaticBitmap : public wxControl {
public:
%pythonAppend wxStaticBitmap "self._setOORInfo(self)"

1
wxPython/src/_statusbar.i
View File

@ -24,6 +24,7 @@
// wxStatusBar: a window near the bottom of the frame used for status info
MustHaveApp(wxStatusBar);
class wxStatusBar : public wxWindow
{
public:

2
wxPython/src/_stockobjs.i
View File

@ -99,6 +99,8 @@ public:
//---------------------------------------------------------------------------
MustHaveApp(wxColourDatabase);
class wxColourDatabase : public wxObject {
public:
wxColourDatabase();

2
wxPython/src/_taskbar.i
View File

@ -56,6 +56,8 @@ enum {
MustHaveApp(wxTaskBarIcon);
class wxTaskBarIcon : public wxEvtHandler
{
public:

1
wxPython/src/_textctrl.i
View File

@ -161,6 +161,7 @@ public:
// wxTextCtrl: a single or multiple line text zone where user can enter and
// edit text
MustHaveApp(wxTextCtrl);
class wxTextCtrl : public wxControl
{
public:

2
wxPython/src/_tglbtn.i
View File

@ -50,6 +50,8 @@ public:
}
MustHaveApp(wxToggleButton);
class wxToggleButton : public wxControl
{
public:

3
wxPython/src/_timer.i
View File

@ -53,6 +53,8 @@ void wxPyTimer::base_Notify() {
MustHaveApp(wxPyTimer);
%name(Timer) class wxPyTimer : public wxEvtHandler
{
public:
@ -130,6 +132,7 @@ public:
// wxTimerRunner: starts the timer in its ctor, stops in the dtor
MustHaveApp(wxTimerRunner);
class wxTimerRunner
{
public:

2
wxPython/src/_tipdlg.i
View File

@ -81,11 +81,13 @@ public:
// not, the dialog on startup depending on its value, not this class).
//
// The function returns True if this checkbox is checked, False otherwise.
MustHaveApp(wxShowTip);
bool wxShowTip(wxWindow *parent, wxTipProvider *tipProvider, bool showAtStartup = True);
// a function which returns an implementation of wxTipProvider using the
// specified text file as the source of tips (each line is a tip).
%newobject wxCreateFileTipProvider;
MustHaveApp(wxCreateFileTipProvider);
wxTipProvider* wxCreateFileTipProvider(const wxString& filename, size_t currentTip);

2
wxPython/src/_tipwin.i
View File

@ -23,6 +23,8 @@
%newgroup;
MustHaveApp(wxTipWindow);
class wxTipWindow :
#ifndef __WXMAC__
public wxPyPopupTransientWindow

2
wxPython/src/_toolbar.i
View File

@ -384,6 +384,8 @@ public:
MustHaveApp(wxToolBar);
class wxToolBar : public wxToolBarBase {
public:
%pythonAppend wxToolBar "self._setOORInfo(self)"

10
wxPython/src/_toplvl.i
View File

@ -145,6 +145,8 @@ public:
// is accounted for in client size calculations - all others should be taken
// care of manually.
MustHaveApp(wxFrame);
class wxFrame : public wxTopLevelWindow {
public:
%pythonAppend wxFrame "self._setOORInfo(self)"
@ -255,6 +257,8 @@ public:
//---------------------------------------------------------------------------
%newgroup
MustHaveApp(wxDialog);
class wxDialog : public wxTopLevelWindow {
public:
%pythonAppend wxDialog "self._setOORInfo(self)"
@ -311,6 +315,8 @@ public:
%newgroup
MustHaveApp(wxMiniFrame);
class wxMiniFrame : public wxFrame {
public:
%pythonAppend wxMiniFrame "self._setOORInfo(self)"
@ -345,6 +351,8 @@ enum {
};
MustHaveApp(wxSplashScreenWindow);
class wxSplashScreenWindow: public wxWindow
{
public:
@ -361,6 +369,8 @@ public:
};
MustHaveApp(wxSplashScreen);
class wxSplashScreen : public wxFrame {
public:
%pythonAppend wxSplashScreen "self._setOORInfo(self)"

2
wxPython/src/_treectrl.i
View File

@ -309,6 +309,8 @@ IMPLEMENT_ABSTRACT_CLASS(wxPyTreeCtrl, wxTreeCtrl);
MustHaveApp(wxPyTreeCtrl);
%name(TreeCtrl)class wxPyTreeCtrl : public wxControl {
public:
%pythonAppend wxPyTreeCtrl "self._setOORInfo(self);self._setCallbackInfo(self, TreeCtrl)"

5
wxPython/src/_vscroll.i
View File

@ -125,6 +125,8 @@ IMP_PYCALLBACK_COORD_const (wxPyVScrolledWindow, wxVScrolledWindow, Est
of the window and not its entire client area.
*/
MustHaveApp(wxPyVScrolledWindow);
%name(VScrolledWindow) class wxPyVScrolledWindow : public wxPanel
{
public:
@ -282,6 +284,8 @@ IMP_PYCALLBACK__DCRECTSIZET_const (wxPyVListBox, wxVListBox, OnDrawBackground
It emits the same events as wxListBox and the same event macros may be used
with it.
*/
MustHaveApp(wxPyVListBox);
%name(VListBox) class wxPyVListBox : public wxPyVScrolledWindow
{
public:
@ -478,6 +482,7 @@ IMP_PYCALLBACK_STRING_SIZET (wxPyHtmlListBox, wxHtmlListBox, OnGetItemMarkup
// wxHtmlListBox is a listbox whose items are wxHtmlCells
MustHaveApp(wxPyHtmlListBox);
%name(HtmlListBox) class wxPyHtmlListBox : public wxPyVListBox
{
public:

8
wxPython/src/_window.i
View File

@ -187,6 +187,10 @@ Extra Styles
");
MustHaveApp(wxWindow);
MustHaveApp(wxWindow::FindFocus);
MustHaveApp(wxWindow::GetCapture);
MustHaveApp(wxWindow::GetClassDefaultAttributes);
class wxWindow : public wxEvtHandler
{
@ -1850,6 +1854,10 @@ non-None, the search will be limited to the given window
hierarchy. The search is recursive in both cases.", "");
MustHaveApp(wxFindWindowById);
MustHaveApp(wxFindWindowByName);
MustHaveApp(wxFindWindowByLabel);
%inline %{
wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
return wxWindow::FindWindowById(id, parent);

2
wxPython/src/calendar.i
View File

@ -211,6 +211,8 @@ event.
");
MustHaveApp(wxCalendarCtrl);
class wxCalendarCtrl : public wxControl
{
public:

2
wxPython/src/grid.i
View File

@ -1546,6 +1546,8 @@ typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
MustHaveApp(wxGrid);
class wxGrid : public wxScrolledWindow
{
public:

33
wxPython/src/helpers.cpp
View File

@ -79,6 +79,7 @@ wxMutex* wxPyTMutex = NULL;
static PyObject* wxPython_dict = NULL;
static PyObject* wxPyAssertionError = NULL;
static PyObject* wxPyNoAppError = NULL;
PyObject* wxPyPtrTypeMap = NULL;
@ -567,7 +568,8 @@ PyObject* __wxPySetDictionary(PyObject* /* self */, PyObject* args)
return NULL;
if (!PyDict_Check(wxPython_dict)) {
PyErr_SetString(PyExc_TypeError, "_wxPySetDictionary must have dictionary object!");
PyErr_SetString(PyExc_TypeError,
"_wxPySetDictionary must have dictionary object!");
return NULL;
}
@ -580,6 +582,12 @@ PyObject* __wxPySetDictionary(PyObject* /* self */, PyObject* args)
PyExc_AssertionError, NULL);
PyDict_SetItemString(wxPython_dict, "PyAssertionError", wxPyAssertionError);
// Create an exception object to use when the app object hasn't been created yet
wxPyNoAppError = PyErr_NewException("wx._core.PyNoAppError",
PyExc_RuntimeError, NULL);
PyDict_SetItemString(wxPython_dict, "PyNoAppError", wxPyNoAppError);
#ifdef __WXMOTIF__
#define wxPlatform "__WXMOTIF__"
@ -636,7 +644,12 @@ PyObject* __wxPySetDictionary(PyObject* /* self */, PyObject* args)
_AddInfoString("gtk1");
#endif
#endif
#ifdef __WXDEBUG__
_AddInfoString("wx-assertions-on");
#else
_AddInfoString("wx-assertions-off");
#endif
#undef _AddInfoString
PyObject* PlatInfoTuple = PyList_AsTuple(PlatInfo);
@ -823,6 +836,22 @@ void wxPy_ReinitStockObjects(int pass)
//---------------------------------------------------------------------------
// Check for existence of a wxApp, setting an exception if there isn't one.
// This doesn't need to aquire the GIL because it should only be called from
// an %exception before the lock is released.
bool wxPyCheckForApp() {
if (wxTheApp != NULL)
return true;
else {
PyErr_SetString(wxPyNoAppError, "The wx.App object must be created first!");
return false;
}
}
//---------------------------------------------------------------------------
void wxPyClientData_dtor(wxPyClientData* self) {
if (! wxPyDoingCleanup) { // Don't do it during cleanup as Python
// may have already garbage collected the object...

12
wxPython/src/html.i
View File

@ -785,6 +785,8 @@ wxHtmlOpeningStatus wxPyHtmlWindow::OnOpeningURL(wxHtmlURLType type,
MustHaveApp(wxPyHtmlWindow);
%name(HtmlWindow) class wxPyHtmlWindow : public wxScrolledWindow {
public:
%pythonAppend wxPyHtmlWindow "self._setCallbackInfo(self, HtmlWindow); self._setOORInfo(self)"
@ -919,6 +921,8 @@ public:
%newgroup
MustHaveApp(wxHtmlDCRenderer);
class wxHtmlDCRenderer : public wxObject {
public:
wxHtmlDCRenderer();
@ -956,6 +960,8 @@ enum {
};
MustHaveApp(wxHtmlPrintout);
class wxHtmlPrintout : public wxPyPrintout {
public:
wxHtmlPrintout(const wxString& title = wxPyHtmlPrintoutTitleStr);
@ -991,6 +997,8 @@ public:
MustHaveApp(wxHtmlEasyPrinting);
class wxHtmlEasyPrinting : public wxObject {
public:
wxHtmlEasyPrinting(const wxString& name = wxPyHtmlPrintingTitleStr,
@ -1104,6 +1112,8 @@ public:
//---------------------------------------------------------------------------
MustHaveApp(wxHtmlHelpFrame);
class wxHtmlHelpFrame : public wxFrame {
public:
%pythonAppend wxHtmlHelpFrame "self._setOORInfo(self)"
@ -1141,6 +1151,8 @@ enum {
};
MustHaveApp(wxHtmlHelpController);
class wxHtmlHelpController : public wxEvtHandler {
public:
%pythonAppend wxHtmlHelpController "self._setOORInfo(self)"

3
wxPython/src/misc.i
View File

@ -17,8 +17,7 @@
%{
#include "wx/wxPython/wxPython.h"
#include "wx/wxPython/pyclasses.h"
#include "wx/wxPython/pyistream.h"
#include "wx/wxPython/pyistream.h"
%}
//---------------------------------------------------------------------------

11
wxPython/src/my_typemaps.i
View File

@ -11,17 +11,6 @@
/////////////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------------
// Tell SWIG to wrap all the wrappers with our thread protection
%exception {
PyThreadState* __tstate = wxPyBeginAllowThreads();
$action
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
//----------------------------------------------------------------------
// Typemaps to convert a list of items to an int (size) and an array

6
wxPython/src/wizard.i
View File

@ -84,6 +84,7 @@ public:
//
// Other than GetNext/Prev() functions, wxWizardPage is just a panel and may be
// used as such (i.e. controls may be placed directly on it &c).
MustHaveApp(wxWizardPage);
class wxWizardPage : public wxPanel
{
public:
@ -198,6 +199,8 @@ IMP_PYCALLBACK_VOID_WXWINBASE(wxPyWizardPage, wxWizardPage, RemoveChild);
MustHaveApp(wxPyWizardPage);
class wxPyWizardPage : public wxWizardPage {
public:
@ -275,6 +278,7 @@ public:
// OTOH, it is also possible to dynamicly decide which page to return (i.e.
// depending on the user's choices) as the wizard sample shows - in order to do
// this, you must derive from wxWizardPage directly.
MustHaveApp(wxWizardPageSimple);
class wxWizardPageSimple : public wxWizardPage
{
public:
@ -307,6 +311,8 @@ public:
//----------------------------------------------------------------------
MustHaveApp(wxWizard);
class wxWizard : public wxDialog
{
public: