"A sort of application framework for the Mac"

DEBUG=0

from warnings import warnpy3k

warnpy3k("In 3.x, the FrameWork module is removed.", stacklevel=2)

import MacOS

import traceback

from Carbon.AE import *

from Carbon.AppleEvents import *

from Carbon.Ctl import *

from Carbon.Controls import *

from Carbon.Dlg import *

from Carbon.Dialogs import *

from Carbon.Evt import *

from Carbon.Events import *

from Carbon.Help import *

from Carbon.Menu import *

from Carbon.Menus import *

from Carbon.Qd import *

from Carbon.QuickDraw import *

#from Carbon.Res import *

#from Carbon.Resources import *

#from Carbon.Snd import *

#from Carbon.Sound import *

from Carbon.Win import *

from Carbon.Windows import *

import types

import EasyDialogs

try:

    MyFrontWindow = FrontNonFloatingWindow

except NameError:

    MyFrontWindow = FrontWindow

kHighLevelEvent = 23    # Don't know what header file this should come from

SCROLLBARWIDTH = 16         # Again, not a clue...

# Trick to forestall a set of SIOUX menus being added to our menubar

SIOUX_APPLEMENU_ID=32000

# Map event 'what' field to strings

eventname = {}

eventname[1] = 'mouseDown'

eventname[2] = 'mouseUp'

eventname[3] = 'keyDown'

eventname[4] = 'keyUp'

eventname[5] = 'autoKey'

eventname[6] = 'updateEvt'

eventname[7] = 'diskEvt'

eventname[8] = 'activateEvt'

eventname[15] = 'osEvt'

eventname[23] = 'kHighLevelEvent'

# Map part codes returned by WhichWindow() to strings

partname = {}

partname[0] = 'inDesk'

partname[1] = 'inMenuBar'

partname[2] = 'inSysWindow'

partname[3] = 'inContent'

partname[4] = 'inDrag'

partname[5] = 'inGrow'

partname[6] = 'inGoAway'

partname[7] = 'inZoomIn'

partname[8] = 'inZoomOut'

#

# The useable portion of the screen

#       ## but what happens with multiple screens? jvr

screenbounds = GetQDGlobalsScreenBits().bounds

screenbounds = screenbounds[0]+4, screenbounds[1]+4, \

    screenbounds[2]-4, screenbounds[3]-4

next_window_x = 16          # jvr

next_window_y = 44          # jvr

def windowbounds(width, height):

    "Return sensible window bounds"

    global next_window_x, next_window_y

    r, b = next_window_x+width, next_window_y+height

    if r > screenbounds[2]:

        next_window_x = 16

    if b > screenbounds[3]:

        next_window_y = 44

    l, t = next_window_x, next_window_y

    r, b = next_window_x+width, next_window_y+height

    next_window_x, next_window_y = next_window_x + 8, next_window_y + 20    # jvr

    return l, t, r, b

_watch = None

def setwatchcursor():

    global _watch

    if _watch is None:

        _watch = GetCursor(4).data

    SetCursor(_watch)

def setarrowcursor():

    SetCursor(GetQDGlobalsArrow())

class Application:

    "Application framework -- your application should be a derived class"

    def __init__(self, nomenubar=0):

        self._doing_asyncevents = 0

        self.quitting = 0

        self.needmenubarredraw = 0

        self._windows = {}

        self._helpmenu = None

        if nomenubar:

            self.menubar = None

        else:

            self.makemenubar()

    def __del__(self):

        if self._doing_asyncevents:

            self._doing_asyncevents = 0

            MacOS.SetEventHandler()

    def makemenubar(self):

        self.menubar = MenuBar(self)

        AppleMenu(self.menubar, self.getabouttext(), self.do_about)

        self.makeusermenus()

    def makeusermenus(self):

        self.filemenu = m = Menu(self.menubar, "File")

        self._quititem = MenuItem(m, "Quit", "Q", self._quit)

    def gethelpmenu(self):

        if self._helpmenu is None:

            self._helpmenu = HelpMenu(self.menubar)

        return self._helpmenu

    def _quit(self, *args):

        self.quitting = 1

    def cleanup(self):

        for w in self._windows.values():

            w.do_close()

        return self._windows == {}

    def appendwindow(self, wid, window):

        self._windows[wid] = window

    def removewindow(self, wid):

        del self._windows[wid]

    def getabouttext(self):

        return "About %s..." % self.__class__.__name__

    def do_about(self, id, item, window, event):

        EasyDialogs.Message("Hello, world!" + "\015(%s)" % self.__class__.__name__)

    # The main event loop is broken up in several simple steps.

    # This is done so you can override each individual part,

    # if you have a need to do extra processing independent of the

    # event type.

    # Normally, however, you'd just define handlers for individual

    # events.

    schedparams = (0, 0)    # By default disable Python's event handling

    default_wait = None         # By default we wait GetCaretTime in WaitNextEvent

    def mainloop(self, mask = everyEvent, wait = None):

        self.quitting = 0

        if hasattr(MacOS, 'SchedParams'):

            saveparams = MacOS.SchedParams(*self.schedparams)

        try:

            while not self.quitting:

                try:

                    self.do1event(mask, wait)

                except (Application, SystemExit):

                    # Note: the raising of "self" is old-fashioned idiom to

                    # exit the mainloop. Calling _quit() is better for new

                    # applications.

                    break

        finally:

            if hasattr(MacOS, 'SchedParams'):

                MacOS.SchedParams(*saveparams)

    def dopendingevents(self, mask = everyEvent):

        """dopendingevents - Handle all pending events"""

        while self.do1event(mask, wait=0):

            pass

    def do1event(self, mask = everyEvent, wait = None):

        ok, event = self.getevent(mask, wait)

        if IsDialogEvent(event):

            if self.do_dialogevent(event):

                return

        if ok:

            self.dispatch(event)

        else:

            self.idle(event)

    def idle(self, event):

        pass

    def getevent(self, mask = everyEvent, wait = None):

        if self.needmenubarredraw:

            DrawMenuBar()

            self.needmenubarredraw = 0

        if wait is None:

            wait = self.default_wait

            if wait is None:

                wait = GetCaretTime()

        ok, event = WaitNextEvent(mask, wait)

        return ok, event

    def dispatch(self, event):

        # The following appears to be double work (already done in do1event)

        # but we need it for asynchronous event handling

        if IsDialogEvent(event):

            if self.do_dialogevent(event):

                return

        (what, message, when, where, modifiers) = event

        if eventname.has_key(what):

            name = "do_" + eventname[what]

        else:

            name = "do_%d" % what

        try:

            handler = getattr(self, name)

        except AttributeError:

            handler = self.do_unknownevent

        handler(event)

    def asyncevents(self, onoff):

        """asyncevents - Set asynchronous event handling on or off"""

        if MacOS.runtimemodel == 'macho':

            raise 'Unsupported in MachoPython'

        old = self._doing_asyncevents

        if old:

            MacOS.SetEventHandler()

            MacOS.SchedParams(*self.schedparams)

        if onoff:

            MacOS.SetEventHandler(self.dispatch)

            doint, dummymask, benice, howoften, bgyield = \

                   self.schedparams

            MacOS.SchedParams(doint, everyEvent, benice,

                      howoften, bgyield)

        self._doing_asyncevents = onoff

        return old

    def do_dialogevent(self, event):

        gotone, dlg, item = DialogSelect(event)

        if gotone:

            window = dlg.GetDialogWindow()

            if self._windows.has_key(window):

                self._windows[window].do_itemhit(item, event)

            else:

                print 'Dialog event for unknown dialog'

            return 1

        return 0

    def do_mouseDown(self, event):

        (what, message, when, where, modifiers) = event

        partcode, wid = FindWindow(where)

        #

        # Find the correct name.

        #

        if partname.has_key(partcode):

            name = "do_" + partname[partcode]

        else:

            name = "do_%d" % partcode

        if wid is None:

            # No window, or a non-python window

            try:

                handler = getattr(self, name)

            except AttributeError:

                # Not menubar or something, so assume someone

                # else's window

                if hasattr(MacOS, 'HandleEvent'):

                    MacOS.HandleEvent(event)

                return

        elif self._windows.has_key(wid):

            # It is a window. Hand off to correct window.

            window = self._windows[wid]

            try:

                handler = getattr(window, name)

            except AttributeError:

                handler = self.do_unknownpartcode

        else:

            # It is a python-toolbox window, but not ours.

            handler = self.do_unknownwindow

        handler(partcode, wid, event)

    def do_inSysWindow(self, partcode, window, event):

        if hasattr(MacOS, 'HandleEvent'):

            MacOS.HandleEvent(event)

    def do_inDesk(self, partcode, window, event):

        if hasattr(MacOS, 'HandleEvent'):

            MacOS.HandleEvent(event)

    def do_inMenuBar(self, partcode, window, event):

        if not self.menubar:

            if hasattr(MacOS, 'HandleEvent'):

                MacOS.HandleEvent(event)

            return

        (what, message, when, where, modifiers) = event

        result = MenuSelect(where)

        id = (result>>16) & 0xffff      # Hi word

        if id >= 0x8000:

            id = -65536 + id

        item = result & 0xffff      # Lo word

        self.do_rawmenu(id, item, window, event)

    def do_rawmenu(self, id, item, window, event):

        try:

            self.do_menu(id, item, window, event)

        finally:

            HiliteMenu(0)

    def do_menu(self, id, item, window, event):

        if hasattr(MacOS, 'OutputSeen'):

            MacOS.OutputSeen()

        self.menubar.dispatch(id, item, window, event)

    def do_unknownpartcode(self, partcode, window, event):

        (what, message, when, where, modifiers) = event

        if DEBUG: print "Mouse down at global:", where

        if DEBUG: print "\tUnknown part code:", partcode

        if DEBUG: print "\tEvent:", self.printevent(event)

        if hasattr(MacOS, 'HandleEvent'):

            MacOS.HandleEvent(event)

    def do_unknownwindow(self, partcode, window, event):

        if DEBUG: print 'Unknown window:', window

        if hasattr(MacOS, 'HandleEvent'):

            MacOS.HandleEvent(event)

    def do_keyDown(self, event):

        self.do_key(event)

    def do_autoKey(self, event):

        if not event[-1] & cmdKey:

            self.do_key(event)

    def do_key(self, event):

        (what, message, when, where, modifiers) = event

        c = chr(message & charCodeMask)

        if self.menubar:

            result = MenuEvent(event)

            id = (result>>16) & 0xffff      # Hi word

            item = result & 0xffff      # Lo word

            if id:

                self.do_rawmenu(id, item, None, event)

                return

            # Otherwise we fall-through

        if modifiers & cmdKey:

            if c == '.':

                raise self

            else:

                if not self.menubar:

                    if hasattr(MacOS, 'HandleEvent'):

                        MacOS.HandleEvent(event)

                return

        else:

            # See whether the front window wants it

            w = MyFrontWindow()

            if w and self._windows.has_key(w):

                window = self._windows[w]

                try:

                    do_char = window.do_char

                except AttributeError:

                    do_char = self.do_char

                do_char(c, event)

            # else it wasn't for us, sigh...

    def do_char(self, c, event):

        if DEBUG: print "Character", repr(c)

    def do_updateEvt(self, event):

        (what, message, when, where, modifiers) = event

        wid = WhichWindow(message)

        if wid and self._windows.has_key(wid):

            window = self._windows[wid]

            window.do_rawupdate(wid, event)

        else:

            if hasattr(MacOS, 'HandleEvent'):

                MacOS.HandleEvent(event)

    def do_activateEvt(self, event):

        (what, message, when, where, modifiers) = event

        wid = WhichWindow(message)

        if wid and self._windows.has_key(wid):

            window = self._windows[wid]

            window.do_activate(modifiers & 1, event)

        else:

            if hasattr(MacOS, 'HandleEvent'):

                MacOS.HandleEvent(event)

    def do_osEvt(self, event):

        (what, message, when, where, modifiers) = event

        which = (message >> 24) & 0xff

        if which == 1:  # suspend/resume

            self.do_suspendresume(event)

        else:

            if DEBUG:

                print 'unknown osEvt:',

                self.printevent(event)

    def do_suspendresume(self, event):

        (what, message, when, where, modifiers) = event

        wid = MyFrontWindow()

        if wid and self._windows.has_key(wid):

            window = self._windows[wid]

            window.do_activate(message & 1, event)

    def do_kHighLevelEvent(self, event):

        (what, message, when, where, modifiers) = event

        if DEBUG:

            print "High Level Event:",

            self.printevent(event)

        try:

            AEProcessAppleEvent(event)

        except:

            pass

            #print "AEProcessAppleEvent error:"

            #traceback.print_exc()

    def do_unknownevent(self, event):

        if DEBUG:

            print "Unhandled event:",

            self.printevent(event)

    def printevent(self, event):

        (what, message, when, where, modifiers) = event

        nicewhat = repr(what)

        if eventname.has_key(what):

            nicewhat = eventname[what]

        print nicewhat,

        if what == kHighLevelEvent:

            h, v = where

            print repr(ostypecode(message)), hex(when), repr(ostypecode(h | (v<<16))),

        else:

            print hex(message), hex(when), where,

        print hex(modifiers)

class MenuBar:

    """Represent a set of menus in a menu bar.

    Interface:

    - (constructor)

    - (destructor)

    - addmenu

    - addpopup (normally used internally)

    - dispatch (called from Application)

    """

    nextid = 1      # Necessarily a class variable

    def getnextid(self):

        id = MenuBar.nextid

        MenuBar.nextid = id+1

        return id

    def __init__(self, parent=None):

        self.parent = parent

        ClearMenuBar()

        self.bar = GetMenuBar()

        self.menus = {}

    # XXX necessary?

    def close(self):

        self.parent = None

        self.bar = None

        self.menus = None

    def addmenu(self, title, after = 0, id=None):

        if id is None:

            id = self.getnextid()

        if DEBUG: print 'Newmenu', title, id # XXXX

        m = NewMenu(id, title)

        m.InsertMenu(after)

        if after >= 0:

            if self.parent:

                self.parent.needmenubarredraw = 1

            else:

                DrawMenuBar()

        return id, m

    def delmenu(self, id):

        if DEBUG: print 'Delmenu', id # XXXX

        DeleteMenu(id)

    def addpopup(self, title = ''):

        return self.addmenu(title, -1)

# Useless:

#       def install(self):

#           if not self.bar: return

#           SetMenuBar(self.bar)

#           if self.parent:

#               self.parent.needmenubarredraw = 1

#           else:

#               DrawMenuBar()

    def fixmenudimstate(self):

        for m in self.menus.keys():

            menu = self.menus[m]

            if menu.__class__ == FrameWork.AppleMenu:

                continue

            for i in range(len(menu.items)):

                label, shortcut, callback, kind = menu.items[i]

                if type(callback) == types.StringType:

                    wid = MyFrontWindow()

                    if wid and self.parent._windows.has_key(wid):

                        window = self.parent._windows[wid]

                        if hasattr(window, "domenu_" + callback):

                            menu.menu.EnableMenuItem(i + 1)

                        elif hasattr(self.parent, "domenu_" + callback):

                            menu.menu.EnableMenuItem(i + 1)

                        else:

                            menu.menu.DisableMenuItem(i + 1)

                    elif hasattr(self.parent, "domenu_" + callback):

                        menu.menu.EnableMenuItem(i + 1)

                    else: