self.quititem = FrameWork.MenuItem(m, "Quit", "Q", self.quit)
def quit(self, *args):
- raise self
+ self._quit()
def showPICT(self, resid):
w = PICTwindow(self)
self.quititem = FrameWork.MenuItem(m, "Quit", "Q", self.quit)
def quit(self, *args):
- raise self
+ self._quit()
def showPICT(self, resid):
w = PICTwindow(self)
MiniApplication is a tiny replacement for <code>FrameWork.Application</code>,
suitable if your application does not need windows and such.
-<blockquote>Actually, Framework.Application has a problem for AE Servers,
-due to the way it expects to be quit through an exception, and raising an exception
-while inside an Apple Event handler is a very bad idea. This will be fixed.
-</blockquote>
-
AEServer is a bit of glue that does part of the appleevent decoding for you. You
call <code>installaehandler</code> passing it the class and id (4-char strings)
of the event you have a handler for and the handler callback routine. When the
You can test AEServer by double-clicking it. It will react to the standard
run/open/print/quit OSA commands. If it is running as a normal python script and you
-drag a file onto the interpreter the script will tell you what event i
s got. <p>
+drag a file onto the interpreter the script will tell you what event i
t got. <p>
<h2>A Minimal CGI script</h2>
menu bar and the main event loop and event dispatching. In the
<CODE>__init__</CODE> routine we first let the base class initialize
itself, then we create our modeless dialog and finally we jump into
-the main loop. The main loop continues until <CODE>self</CODE> is
-raised, which we will do when the user selects "quit". When we create
+the main loop. The main loop continues until we call <CODE>self._quit</CODE>,
+which we will do when the user selects "quit". When we create
the instance of <CODE>MyDialog</CODE> (which inherits
<CODE>DialogWindow</CODE>, which inherits <CODE>Window</CODE>) we pass
a reference to the application object, this reference is used to tell
The <CODE>makeusermenus()</CODE> method (which is called sometime
during the Application <CODE>__init__</CODE> routine) creates a File
menu with a Quit command (shortcut command-Q), which will callback to
-our quit() method. <CODE>Quit()</CODE>, in turn, raises 'self' which
-causes the mainloop to terminate. <p>
+our quit() method. <CODE>Quit()</CODE>, in turn, calls <CODE>_quit</CODE> which
+causes the mainloop to terminate
at a convenient time. <p>
Application provides a standard about box, but we override this by
providing our own <CODE>do_about()</CODE> method which shows an about
self.quititem = FrameWork.MenuItem(m, "Quit", "Q", self.quit)
def quit(self, *args):
- raise self
+ self._quit()
def do_about(self, *args):
f = Dlg.GetNewDialog(ID_ABOUT, -1)
self.quititem = FrameWork.MenuItem(m, "Quit", "Q", self.quit)
def quit(self, *args):
- raise self
+ self._quit()
def opendoc(self, *args):
fss, ok = macfs.StandardGetFile() # Any file type
Oh yes: the <code>quit</code> callback does a little magic too. It closes all windows, and only if this
succeeds it actually quits. This gives the user a chance to cancel the operation if some files are unsaved.
-Quitting itself is also a bit strange: you raise <code>self</code> to break out of the main loop. This bit
-of idiom was invented by Guido, so blame him:-). <p>
+<p>
Lastly, there is the <code>idle</code> method, called by the Application base class when no event
is available. It is forwarded to the active window, so it can blink the text caret. <p>
w.close()
if self._windows:
return
- raise self
+ self._quit()
#
# Edit menu
w.close()
if self._windows:
return
- raise self
+ self._quit()
#
# Edit menu
w.close()
if self._windows:
return
- raise self
+ self._quit()
#
# Edit menu
w.close()
if self._windows:
return
- raise self
+ self._quit()
#
# Edit menu
projects / thirdparty / Python / cpython.git / commitdiff
