+bool wxPyApp::OnInitGui() {
+ bool rval=true;
+ wxApp::OnInitGui(); // in this case always call the base class version
+ wxPyBlock_t blocked = wxPyBeginBlockThreads();
+ if (wxPyCBH_findCallback(m_myInst, "OnInitGui"))
+ rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
+ wxPyEndBlockThreads(blocked);
+ return rval;
+}
+
+
+int wxPyApp::OnExit() {
+ int rval=0;
+ wxPyBlock_t blocked = wxPyBeginBlockThreads();
+ if (wxPyCBH_findCallback(m_myInst, "OnExit"))
+ rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
+ wxPyEndBlockThreads(blocked);
+ wxApp::OnExit(); // in this case always call the base class version
+ return rval;
+}
+
+
+
+void wxPyApp::ExitMainLoop() {
+ bool found;
+ wxPyBlock_t blocked = wxPyBeginBlockThreads();
+ if ((found = wxPyCBH_findCallback(m_myInst, "ExitMainLoop")))
+ wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
+ wxPyEndBlockThreads(blocked);
+ if (! found)
+ wxApp::ExitMainLoop();
+}
+
+
+#ifdef __WXDEBUG__
+void wxPyApp::OnAssert(const wxChar *file,
+ int line,
+ const wxChar *cond,
+ const wxChar *msg) {
+
+ // if we're not fully initialized then just log the error
+ if (! m_startupComplete) {
+ wxString buf;
+ buf.Alloc(4096);
+ buf.Printf(wxT("%s(%d): assert \"%s\" failed"),
+ file, line, cond);
+ if (msg != NULL) {
+ buf += wxT(": ");
+ buf += msg;
+ }
+ wxLogDebug(buf);
+ return;
+ }
+
+ // If the OnAssert is overloaded in the Python class then call it...
+ bool found;
+ wxPyBlock_t blocked = wxPyBeginBlockThreads();
+ if ((found = wxPyCBH_findCallback(m_myInst, "OnAssert"))) {
+ PyObject* fso = wx2PyString(file);
+ PyObject* cso = wx2PyString(file);
+ PyObject* mso;
+ if (msg != NULL)
+ mso = wx2PyString(file);
+ else {
+ mso = Py_None; Py_INCREF(Py_None);
+ }
+ wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiOO)", fso, line, cso, mso));
+ Py_DECREF(fso);
+ Py_DECREF(cso);
+ Py_DECREF(mso);
+ }
+ wxPyEndBlockThreads(blocked);
+
+ // ...otherwise do our own thing with it
+ if (! found) {
+ // ignore it?
+ if (m_assertMode & wxPYAPP_ASSERT_SUPPRESS)
+ return;
+
+ // turn it into a Python exception?
+ if (m_assertMode & wxPYAPP_ASSERT_EXCEPTION) {
+ wxString buf;
+ buf.Alloc(4096);
+ buf.Printf(wxT("C++ assertion \"%s\" failed in %s(%d)"), cond, file, line);
+ if (msg != NULL) {
+ buf += wxT(": ");
+ buf += msg;
+ }
+
+ // set the exception
+ wxPyBlock_t blocked = wxPyBeginBlockThreads();
+ PyObject* s = wx2PyString(buf);
+ PyErr_SetObject(wxPyAssertionError, s);
+ Py_DECREF(s);
+ wxPyEndBlockThreads(blocked);
+
+ // Now when control returns to whatever API wrapper was called from
+ // Python it should detect that an exception is set and will return
+ // NULL, signalling the exception to Python.
+ }
+
+ // Send it to the normal log destination, but only if
+ // not _DIALOG because it will call this too
+ if ( (m_assertMode & wxPYAPP_ASSERT_LOG) && !(m_assertMode & wxPYAPP_ASSERT_DIALOG)) {
+ wxString buf;
+ buf.Alloc(4096);
+ buf.Printf(wxT("%s(%d): assert \"%s\" failed"),
+ file, line, cond);
+ if (msg != NULL) {
+ buf += wxT(": ");
+ buf += msg;
+ }
+ wxLogDebug(buf);
+ }
+
+ // do the normal wx assert dialog?
+ if (m_assertMode & wxPYAPP_ASSERT_DIALOG)
+ wxApp::OnAssert(file, line, cond, msg);
+ }
+}
+#endif
+
+ // For catching Apple Events
+void wxPyApp::MacOpenFile(const wxString &fileName)
+{
+ wxPyBlock_t blocked = wxPyBeginBlockThreads();
+ if (wxPyCBH_findCallback(m_myInst, "MacOpenFile")) {
+ PyObject* s = wx2PyString(fileName);
+ wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s));
+ Py_DECREF(s);
+ }
+ wxPyEndBlockThreads(blocked);
+}
+
+void wxPyApp::MacPrintFile(const wxString &fileName)
+{
+ wxPyBlock_t blocked = wxPyBeginBlockThreads();
+ if (wxPyCBH_findCallback(m_myInst, "MacPrintFile")) {
+ PyObject* s = wx2PyString(fileName);
+ wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s));
+ Py_DECREF(s);
+ }
+ wxPyEndBlockThreads(blocked);
+}
+
+void wxPyApp::MacNewFile()
+{
+ wxPyBlock_t blocked = wxPyBeginBlockThreads();
+ if (wxPyCBH_findCallback(m_myInst, "MacNewFile"))
+ wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
+ wxPyEndBlockThreads(blocked);
+}
+
+void wxPyApp::MacReopenApp()
+{
+ wxPyBlock_t blocked = wxPyBeginBlockThreads();
+ if (wxPyCBH_findCallback(m_myInst, "MacReopenApp"))
+ wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
+ wxPyEndBlockThreads(blocked);
+}
+
+
+/*static*/
+bool wxPyApp::GetMacSupportPCMenuShortcuts() {
+#ifdef __WXMAC__
+ return s_macSupportPCMenuShortcuts;
+#else
+ return 0;
+#endif
+}
+
+/*static*/
+long wxPyApp::GetMacAboutMenuItemId() {
+#ifdef __WXMAC__
+ return s_macAboutMenuItemId;
+#else
+ return 0;
+#endif
+}
+
+/*static*/
+long wxPyApp::GetMacPreferencesMenuItemId() {
+#ifdef __WXMAC__
+ return s_macPreferencesMenuItemId;
+#else
+ return 0;
+#endif
+}
+
+/*static*/
+long wxPyApp::GetMacExitMenuItemId() {
+#ifdef __WXMAC__
+ return s_macExitMenuItemId;
+#else
+ return 0;
+#endif
+}
+
+/*static*/
+wxString wxPyApp::GetMacHelpMenuTitleName() {
+#ifdef __WXMAC__
+ return s_macHelpMenuTitleName;
+#else
+ return wxEmptyString;
+#endif
+}
+
+/*static*/
+void wxPyApp::SetMacSupportPCMenuShortcuts(bool val) {
+#ifdef __WXMAC__
+ s_macSupportPCMenuShortcuts = val;
+#endif
+}
+
+/*static*/
+void wxPyApp::SetMacAboutMenuItemId(long val) {
+#ifdef __WXMAC__
+ s_macAboutMenuItemId = val;
+#endif
+}
+
+/*static*/
+void wxPyApp::SetMacPreferencesMenuItemId(long val) {
+#ifdef __WXMAC__
+ s_macPreferencesMenuItemId = val;
+#endif
+}
+
+/*static*/
+void wxPyApp::SetMacExitMenuItemId(long val) {
+#ifdef __WXMAC__
+ s_macExitMenuItemId = val;
+#endif
+}
+
+/*static*/
+void wxPyApp::SetMacHelpMenuTitleName(const wxString& val) {
+#ifdef __WXMAC__
+ s_macHelpMenuTitleName = val;
+#endif
+}
+
+
+// This finishes the initialization of wxWindows and then calls the OnInit
+// that should be present in the derived (Python) class.
+void wxPyApp::_BootstrapApp()
+{
+ static bool haveInitialized = false;
+ bool result;
+ wxPyBlock_t blocked;
+ PyObject* retval = NULL;
+ PyObject* pyint = NULL;
+
+
+ // Only initialize wxWidgets once
+ if (! haveInitialized) {
+
+ // Get any command-line args passed to this program from the sys module
+ int argc = 0;
+ char** argv = NULL;
+ blocked = wxPyBeginBlockThreads();
+
+ PyObject* sysargv = PySys_GetObject("argv");
+ PyObject* executable = PySys_GetObject("executable");
+
+ if (sysargv != NULL && executable != NULL) {
+ argc = PyList_Size(sysargv) + 1;
+ argv = new char*[argc+1];
+ argv[0] = strdup(PyString_AsString(executable));
+ int x;
+ for(x=1; x<argc; x++) {
+ PyObject *pyArg = PyList_GetItem(sysargv, x-1);
+ argv[x] = strdup(PyString_AsString(pyArg));
+ }
+ argv[argc] = NULL;
+ }
+ wxPyEndBlockThreads(blocked);
+
+ // Initialize wxWidgets
+ result = wxEntryStart(argc, argv);
+ // wxApp takes ownership of the argv array, don't delete it here
+
+ blocked = wxPyBeginBlockThreads();
+ if (! result) {
+ PyErr_SetString(PyExc_SystemError,
+ "wxEntryStart failed, unable to initialize wxWidgets!"
+#ifdef __WXGTK__
+ " (Is DISPLAY set properly?)"
+#endif
+ );
+ goto error;
+ }
+
+ // On wxGTK the locale will be changed to match the system settings,
+ // but Python before 2.4 needs to have LC_NUMERIC set to "C" in order
+ // for the floating point conversions and such to work right.
+#if defined(__WXGTK__) && PY_VERSION_HEX < 0x02040000
+ setlocale(LC_NUMERIC, "C");
+#endif
+
+// wxSystemOptions::SetOption(wxT("mac.textcontrol-use-mlte"), 1);
+
+ wxPyEndBlockThreads(blocked);
+ haveInitialized = true;
+ }
+ else {
+ this->argc = 0;
+ this->argv = NULL;
+ }
+
+
+ // It's now ok to generate exceptions for assertion errors.
+ wxPythonApp->SetStartupComplete(true);
+
+
+ // Call the Python wxApp's OnPreInit and OnInit functions
+ blocked = wxPyBeginBlockThreads();
+ if (wxPyCBH_findCallback(m_myInst, "OnPreInit")) {
+ PyObject* method = m_myInst.GetLastFound();
+ PyObject* argTuple = PyTuple_New(0);
+ retval = PyEval_CallObject(method, argTuple);
+ m_myInst.clearRecursionGuard(method);
+ Py_DECREF(argTuple);
+ Py_DECREF(method);
+ if (retval == NULL)
+ goto error;
+ }
+ if (wxPyCBH_findCallback(m_myInst, "OnInit")) {
+
+ PyObject* method = m_myInst.GetLastFound();
+ PyObject* argTuple = PyTuple_New(0);
+ retval = PyEval_CallObject(method, argTuple);
+ m_myInst.clearRecursionGuard(method);
+ Py_DECREF(argTuple);
+ Py_DECREF(method);
+ if (retval == NULL)
+ goto error;
+
+ pyint = PyNumber_Int(retval);
+ if (! pyint) {
+ PyErr_SetString(PyExc_TypeError, "OnInit should return a boolean value");
+ goto error;
+ }
+ result = PyInt_AS_LONG(pyint);
+ }
+ else {
+ // Is it okay if there is no OnInit? Probably so...
+ result = true;
+ }
+
+ if (! result) {
+ PyErr_SetString(PyExc_SystemExit, "OnInit returned false, exiting...");
+ }
+
+ error:
+ Py_XDECREF(retval);
+ Py_XDECREF(pyint);
+
+ wxPyEndBlockThreads(blocked);
+};
projects / wxWidgets.git / blobdiff