from Carbon import Dlg, Evt, Events, Fm
from Carbon import Menu, Qd, Win, Windows
import FrameWork
import Wbase
import MacOS
import struct
import traceback
from types import InstanceType, StringType

if hasattr(Win, "FrontNonFloatingWindow"):
    MyFrontWindow = Win.FrontNonFloatingWindow
else:
    MyFrontWindow = Win.FrontWindow


class Window(FrameWork.Window, Wbase.SelectableWidget):

    windowkind = Windows.documentProc

    def __init__(self, possize, title="", minsize=None, maxsize=None,
                    tabbable=1, show=1, fontsettings=None):
        import W
        if fontsettings is None:
            fontsettings = W.getdefaultfont()
        self._fontsettings = fontsettings
        W.SelectableWidget.__init__(self, possize)
        self._globalbounds = l, t, r, b = self.getwindowbounds(possize, minsize)
        self._bounds = (0, 0, r - l, b - t)
        self._tabchain = []
        self._currentwidget = None
        self.title = title
        self._parentwindow = self
        self._tabbable = tabbable
        self._defaultbutton = None
        self._drawwidgetbounds = 0
        self._show = show
        self._lastrollover = None
        self.hasclosebox = 1
        # XXX the following is not really compatible with the
        #  new (system >= 7.5) window procs.
        if minsize:
            self._hasgrowbox = 1
            self.windowkind = self.windowkind | 8
            l, t = minsize
            if maxsize:
                r, b = maxsize[0] + 1, maxsize[1] + 1
            else:
                r, b = 32000, 32000
            self.growlimit = (l, t, r, b)
        else:
            self._hasgrowbox = 0
            if (self.windowkind == 0 or self.windowkind >= 8) and self.windowkind < 1000:
                self.windowkind = self.windowkind | 4
        FrameWork.Window.__init__(self, W.getapplication())

    def gettitle(self):
        return self.title

    def settitle(self, title):
        self.title = title
        if self.wid:
            self.wid.SetWTitle(title)

    def getwindowbounds(self, size, minsize = None):
        return windowbounds(size, minsize)

    def getcurrentwidget(self):
        return self._currentwidget

    def show(self, onoff):
        if onoff:
            self.wid.ShowWindow()
        else:
            self.wid.HideWindow()

    def isvisible(self):
        return self.wid.IsWindowVisible()

    def select(self):
        self.wid.SelectWindow()
        # not sure if this is the best place, I need it when
        # an editor gets selected, and immediately scrolled
        # to a certain line, waste scroll assumes everything
        # to be in tact.
        self.do_rawupdate(self.wid, "DummyEvent")

    def open(self):
        self.wid = Win.NewCWindow(self._globalbounds, self.title, self._show,
                self.windowkind, -1, self.hasclosebox, 0)
        self.SetPort()
        fontname, fontstyle, fontsize, fontcolor = self._fontsettings
        fnum = Fm.GetFNum(fontname)
        if fnum == 0:
            fnum = Fm.GetFNum("Geneva")
        Qd.TextFont(fnum)
        Qd.TextFace(fontstyle)
        Qd.TextSize(fontsize)
        if self._bindings.has_key("<open>"):
            callback = self._bindings["<open>"]
            callback()
        for w in self._widgets:
            w.forall_frombottom("open")
        self._maketabchain()
        if self._tabbable:
            self.bind('tab', self.nextwidget)
            self.bind('shifttab', self.previouswidget)
        else:
            self._hasselframes = 0
        if self._tabchain:
            self._tabchain[0].select(1)
        self.do_postopen()

    def close(self):
        if not self.wid:
            return  # we are already closed
        if self._bindings.has_key("<close>"):
            callback = self._bindings["<close>"]
            try:
                rv = callback()
            except:
                print 'error in <close> callback'
                traceback.print_exc()
            else:
                if rv:
                    return rv
        #for key in self._widgetsdict.keys():
        #       self._removewidget(key)
        self.forall_butself("close")
        Wbase.SelectableWidget.close(self)
        self._tabchain = []
        self._currentwidget = None
        self.wid.HideWindow()
        self.do_postclose()

    def domenu_close(self, *args):
        self.close()

    def getbounds(self):
        return self._globalbounds

    def setbounds(self, bounds):
        l, t, r, b = bounds
        self.move(l, t)
        self.resize(r-l, b-t)

    def move(self, x, y = None):
        """absolute move"""
        if y == None:
            x, y = x
        self.wid.MoveWindow(x, y, 0)

    def resize(self, x, y = None):
        if not self._hasgrowbox:
            return  # hands off!
        if y == None:
            x, y = x
        self.SetPort()
        self.GetWindow().InvalWindowRect(self.getgrowrect())
        self.wid.SizeWindow(x, y, 1)
        self._calcbounds()

    def test(self, point):
        return 1

    def draw(self, visRgn = None):
        if self._hasgrowbox:
            self.tempcliprect(self.getgrowrect())
            self.wid.DrawGrowIcon()
            self.restoreclip()

    def idle(self, *args):
        self.SetPort()
        point = Evt.GetMouse()
        widget = self.findwidget(point, 0)
        if self._bindings.has_key("<idle>"):
            callback = self._bindings["<idle>"]
            if callback():
                return
        if self._currentwidget is not None and hasattr(self._currentwidget, "idle"):
            if self._currentwidget._bindings.has_key("<idle>"):
                callback = self._currentwidget._bindings["<idle>"]
                if callback():
                    return
            if self._currentwidget.idle():
                return
        if widget is not None and hasattr(widget, "rollover"):
            if 1:   #self._lastrollover <> widget:
                if self._lastrollover:
                    self._lastrollover.rollover(point, 0)
                self._lastrollover = widget
                self._lastrollover.rollover(point, 1)
        else:
            if self._lastrollover:
                self._lastrollover.rollover(point, 0)
            self._lastrollover = None
            Wbase.SetCursor("arrow")

    def xxx___select(self, widget):
        if self._currentwidget == widget:
            return
        if self._bindings.has_key("<select>"):
            callback = self._bindings["<select>"]
            if callback(widget):
                return
        if widget is None:
            if self._currentwidget is not None:
                self._currentwidget.select(0)
        elif type(widget) == InstanceType and widget._selectable:
            widget.select(1)
        elif widget == -1 or widget == 1:
            if len(self._tabchain) <= 1:
                return
            temp = self._tabchain[(self._tabchain.index(self._currentwidget) + widget) % len(self._tabchain)]
            temp.select(1)
        else:
            raise TypeError, "Widget is not selectable"

    def setdefaultbutton(self, newdefaultbutton = None, *keys):
        if newdefaultbutton == self._defaultbutton:
            return
        if self._defaultbutton:
            self._defaultbutton._setdefault(0)
        if not newdefaultbutton:
            self.bind("return", None)
            self.bind("enter", None)
            return
        import Wcontrols
        if not isinstance(newdefaultbutton, Wcontrols.Button):
            raise TypeError, "widget is not a button"
        self._defaultbutton = newdefaultbutton
        self._defaultbutton._setdefault(1)
        if not keys:
            self.bind("return", self._defaultbutton.push)
            self.bind("enter", self._defaultbutton.push)
        else:
            for key in keys:
                self.bind(key, self._defaultbutton.push)

    def nextwidget(self):
        self.xxx___select(1)

    def previouswidget(self):
        self.xxx___select(-1)

    def drawwidgetbounds(self, onoff):
        self._drawwidgetbounds = onoff
        self.SetPort()
        self.GetWindow().InvalWindowRect(self._bounds)

    def _drawbounds(self):
        pass

    def _maketabchain(self):
        # XXX This has to change, it's no good when we are adding or deleting widgets.
        # XXX Perhaps we shouldn't keep a "tabchain" at all.
        self._hasselframes = 0
        self._collectselectablewidgets(self._widgets)
        if self._hasselframes and len(self._tabchain) > 1:
            self._hasselframes = 1
        else:
            self._hasselframes = 0

    def _collectselectablewidgets(self, widgets):
        import W
        for w in widgets:
            if w._selectable:
                self._tabchain.append(w)
                if isinstance(w, W.List):
                    self._hasselframes = 1
            self._collectselectablewidgets(w._widgets)

    def _calcbounds(self):
        self._possize = self.wid.GetWindowPort().GetPortBounds()[2:]
        w, h = self._possize
        self._bounds = (0, 0, w, h)
        self.wid.GetWindowContentRgn(scratchRegion)
        l, t, r, b = GetRgnBounds(scratchRegion)
        self._globalbounds = l, t, l + w, t + h
        for w in self._widgets:
            w._calcbounds()

    # FrameWork override methods
    def do_inDrag(self, partcode, window, event):
        where = event[3]
        self.wid.GetWindowContentRgn(scratchRegion)
        was_l, was_t, r, b = GetRgnBounds(scratchRegion)
        window.DragWindow(where, self.draglimit)
        self.wid.GetWindowContentRgn(scratchRegion)
        is_l, is_t, r, b = GetRgnBounds(scratchRegion)
        self._globalbounds = Qd.OffsetRect(self._globalbounds,
                                is_l - was_l, is_t - was_t)

    def do_char(self, char, event):
        import Wkeys
        (what, message, when, where, modifiers) = event
        key = char
        if Wkeys.keynames.has_key(key):
            key = Wkeys.keynames[key]
        if modifiers & Events.shiftKey:
            key = 'shift' + key
        if modifiers & Events.cmdKey:
            key = 'cmd' + key
        if modifiers & Events.controlKey:
            key = 'control' + key
        if self._bindings.has_key("<key>"):
            callback = self._bindings["<key>"]
            if Wbase.CallbackCall(callback, 0, char, event):
                return
        if self._bindings.has_key(key):
            callback = self._bindings[key]
            Wbase.CallbackCall(callback, 0, char, event)
        elif self._currentwidget is not None:
            if self._currentwidget._bindings.has_key(key):
                callback = self._currentwidget._bindings[key]
                Wbase.CallbackCall(callback, 0, char, event)
            else:
                if self._currentwidget._bindings.has_key("<key>"):
                    callback = self._currentwidget._bindings["<key>"]
                    if Wbase.CallbackCall(callback, 0, char, event):
                        return
                self._currentwidget.key(char, event)

    def do_contentclick(self, point, modifiers, event):
        widget = self.findwidget(point)
        if widget is not None:
            if self._bindings.has_key("<click>"):
                callback = self._bindings["<click>"]
                if Wbase.CallbackCall(callback, 0, point, modifiers):
                    return
            if widget._bindings.has_key("<click>"):
                callback = widget._bindings["<click>"]
                if Wbase.CallbackCall(callback, 0, point, modifiers):
                    return
            if widget._selectable:
                widget.select(1, 1)
            widget.click(point, modifiers)

    def do_update(self, window, event):
        Qd.EraseRgn(window.GetWindowPort().visRgn)
        self.forall_frombottom("draw", window.GetWindowPort().visRgn)
        if self._drawwidgetbounds:
            self.forall_frombottom("_drawbounds")

    def do_activate(self, onoff, event):
        if not onoff:
            if self._lastrollover:
                self._lastrollover.rollover((0, 0), 0)
                self._lastrollover = None
        self.SetPort()
        self.forall("activate", onoff)
        self.draw()

    def do_postresize(self, width, height, window):
        self.GetWindow().InvalWindowRect(self.getgrowrect())
        self._calcbounds()

    def do_inGoAway(self, partcode, window, event):
        where = event[3]
        closeall = event[4] & Events.optionKey
        if window.TrackGoAway(where):
            if not closeall:
                self.close()
            else:
                for window in self.parent._windows.values():
                    rv = window.close()
                    if rv and rv > 0:
                        return

    # utilities
    def tempcliprect(self, tempcliprect):
        tempclip = Qd.NewRgn()
        Qd.RectRgn(tempclip, tempcliprect)
        self.tempclip(tempclip)
        Qd.DisposeRgn(tempclip)

    def tempclip(self, tempclip):
        if not hasattr(self, "saveclip"):
            self.saveclip = []
        saveclip = Qd.NewRgn()
        Qd.GetClip(saveclip)
        self.saveclip.append(saveclip)
        Qd.SetClip(tempclip)

    def restoreclip(self):
        Qd.SetClip(self.saveclip[-1])
        Qd.DisposeRgn(self.saveclip[-1])
        del self.saveclip[-1]

    def getgrowrect(self):
        l, t, r, b = self.wid.GetWindowPort().GetPortBounds()
        return (r - 15, b - 15, r, b)

    def has_key(self, key):
        return self._widgetsdict.has_key(key)

    def __getattr__(self, attr):
        global _successcount, _failcount, _magiccount
        if self._widgetsdict.has_key(attr):
            _successcount = _successcount + 1
            return self._widgetsdict[attr]
        if self._currentwidget is None or (attr[:7] <> 'domenu_' and
                        attr[:4] <> 'can_' and attr <> 'insert'):
            _failcount = _failcount + 1
            raise AttributeError, attr
        # special case: if a domenu_xxx, can_xxx or insert method is asked for,
        # see if the active widget supports it
        _magiccount = _magiccount + 1
        return getattr(self._currentwidget, attr)

_successcount = 0
_failcount = 0
_magiccount = 0

class Dialog(Window):

    windowkind = Windows.movableDBoxProc

    # this __init__ seems redundant, but it's not: it has less args
    def __init__(self, possize, title = ""):
        Window.__init__(self, possize, title)

    def can_close(self, *args):
        return 0

    def getwindowbounds(self, size, minsize = None):
        screenbounds = sl, st, sr, sb = Qd.GetQDGlobalsScreenBits().bounds
        w, h = size
        l = sl + (sr - sl - w) / 2
        t = st + (sb - st - h) / 3
        return l, t, l + w, t + h


class ModalDialog(Dialog):

    def __init__(self, possize, title = ""):
        Dialog.__init__(self, possize, title)
        if title:
            self.windowkind = Windows.movableDBoxProc
        else:
            self.windowkind = Windows.dBoxProc

    def open(self):
        import W
        Dialog.open(self)
        self.app = W.getapplication()
        self.done = 0
        Menu.HiliteMenu(0)
        app = self.parent
        app.enablemenubar(0)
        try:
            self.mainloop()
        finally:
            app.enablemenubar(1)

    def close(self):
        if not self.wid:
            return  # we are already closed
        self.done = 1
        del self.app
        Dialog.close(self)

    def mainloop(self):
        if hasattr(MacOS, 'EnableAppswitch'):
            saveyield = MacOS.EnableAppswitch(-1)
        while not self.done:
            #self.do1event()
            self.do1event(  Events.keyDownMask +
                                    Events.autoKeyMask +
                                    Events.activMask +
                                    Events.updateMask +
                                    Events.mDownMask +
                                    Events.mUpMask,
                                    10)
        if hasattr(MacOS, 'EnableAppswitch'):
            MacOS.EnableAppswitch(saveyield)

    def do1event(self, mask = Events.everyEvent, wait = 0):
        ok, event = self.app.getevent(mask, wait)
        if Dlg.IsDialogEvent(event):
            if self.app.do_dialogevent(event):
                return
        if ok:
            self.dispatch(event)
        else:
            self.app.idle(event)

    def do_keyDown(self, event):
        self.do_key(event)

    def do_autoKey(self, event):
        if not event[-1] & Events.cmdKey:
            self.do_key(event)

    def do_key(self, event):
        (what, message, when, where, modifiers) = event
        #w = Win.FrontWindow()
        #if w <> self.wid:
        #       return
        c = chr(message & Events.charCodeMask)
        if modifiers & Events.cmdKey:
            self.app.checkmenus(self)
            result = Menu.MenuKey(ord(c))
            id = (result>>16) & 0xffff      # Hi word
            item = result & 0xffff          # Lo word
            if id:
                self.app.do_rawmenu(id, item, None, event)
                return
        self.do_char(c, event)

    def do_mouseDown(self, event):
        (what, message, when, where, modifiers) = event
        partcode, wid = Win.FindWindow(where)
        #
        # Find the correct name.
        #
        if FrameWork.partname.has_key(partcode):
            name = "do_" + FrameWork.partname[partcode]
        else:
            name = "do_%d" % partcode

        if name == "do_inDesk":
            if hasattr(MacOS, "HandleEvent"):
                MacOS.HandleEvent(event)
            else:
                print 'Unexpected inDesk event:', event
            return
        if wid == self.wid:
            try:
                handler = getattr(self, name)
            except AttributeError:
                handler = self.app.do_unknownpartcode
        else:
            #MacOS.HandleEvent(event)
            if name == 'do_inMenuBar':
                handler = getattr(self.parent, name)
            else:
                return
        handler(partcode, wid, event)

    def dispatch(self, event):
        (what, message, when, where, modifiers) = event
        if FrameWork.eventname.has_key(what):
            name = "do_" + FrameWork.eventname[what]
        else:
            name = "do_%d" % what
        try:
            handler = getattr(self, name)
        except AttributeError:
            try:
                handler = getattr(self.app, name)
            except AttributeError:
                handler = self.app.do_unknownevent
        handler(event)


def FrontWindowInsert(stuff):
    if not stuff:
        return
    if type(stuff) <> StringType:
        raise TypeError, 'string expected'
    import W
    app = W.getapplication()
    wid = MyFrontWindow()
    if wid and app._windows.has_key(wid):
        window = app._windows[wid]
        if hasattr(window, "insert"):
            try:
                window.insert(stuff)
                return
            except:
                pass
    import EasyDialogs
    if EasyDialogs.AskYesNoCancel(
                    "Can't find window or widget to insert text into; copy to clipboard instead?",
                    1) == 1:
        from Carbon import Scrap
        if hasattr(Scrap, 'PutScrap'):
            Scrap.ZeroScrap()
            Scrap.PutScrap('TEXT', stuff)
        else:
            Scrap.ClearCurrentScrap()
            sc = Scrap.GetCurrentScrap()
            sc.PutScrapFlavor('TEXT', 0, stuff)


# not quite based on the same function in FrameWork
_windowcounter = 0

def getnextwindowpos():
    global _windowcounter
    rows = 8
    l = 4 * (rows + 1 - (_windowcounter % rows) + _windowcounter / rows)
    t = 44 + 20 * (_windowcounter % rows)
    _windowcounter = _windowcounter + 1
    return l, t

def windowbounds(preferredsize, minsize=None):
    "Return sensible window bounds"

    global _windowcounter
    if len(preferredsize) == 4:
        bounds = l, t, r, b = preferredsize
        desktopRgn = Win.GetGrayRgn()
        tempRgn = Qd.NewRgn()
        Qd.RectRgn(tempRgn, bounds)
        union = Qd.UnionRgn(tempRgn, desktopRgn, tempRgn)
        equal = Qd.EqualRgn(tempRgn, desktopRgn)
        Qd.DisposeRgn(tempRgn)
        if equal:
            return bounds
        else:
            preferredsize = r - l, b - t
    if not minsize:
        minsize = preferredsize
    minwidth, minheight = minsize
    width, height = preferredsize

    sl, st, sr, sb = screenbounds = Qd.InsetRect(Qd.GetQDGlobalsScreenBits().bounds, 4, 4)
    l, t = getnextwindowpos()
    if (l + width) > sr:
        _windowcounter = 0
        l, t = getnextwindowpos()
    r = l + width
    b = t + height
    if (t + height) > sb:
        b = sb
        if (b - t) < minheight:
            b = t + minheight
    return l, t, r, b

scratchRegion = Qd.NewRgn()

# util -- move somewhere convenient???
def GetRgnBounds(the_Rgn):
    (t, l, b, r) = struct.unpack("hhhh", the_Rgn.data[2:10])
    return (l, t, r, b)