Mac/Tools/IDE/Wwindows.py

   1 import Qd
   2 import Win
   3 import Evt
   4 import Fm
   5 import FrameWork
   6 import Windows
   7 import Events
   8 import Wbase
   9 import Dlg
  10 import MacOS
  11 import Menu
  12 import struct
  13 import traceback
  14
  15 from types import *
  16
  17
  18 class Window(FrameWork.Window, Wbase.SelectableWidget):
  19
  20         windowkind = Windows.documentProc
  21
  22         def __init__(self, possize, title="", minsize=None, maxsize=None,
  23                         tabbable=1, show=1, fontsettings=None):
  24                 import W
  25                 if fontsettings is None:
  26                         fontsettings = W.getdefaultfont()
  27                 self._fontsettings = fontsettings
  28                 W.SelectableWidget.__init__(self, possize)
  29                 self._globalbounds = l, t, r, b = self.getwindowbounds(possize, minsize)
  30                 self._bounds = (0, 0, r - l, b - t)
  31                 self._tabchain = []
  32                 self._currentwidget = None
  33                 self.title = title
  34                 self._parentwindow = self
  35                 self._tabbable = tabbable
  36                 self._defaultbutton = None
  37                 self._drawwidgetbounds = 0
  38                 self._show = show
  39                 self._lastrollover = None
  40                 self.hasclosebox = 1
  41                 # XXX the following is not really compatible with the
  42                 #  new (system >= 7.5) window procs.
  43                 if minsize:
  44                         self._hasgrowbox = 1
  45                         self.windowkind = self.windowkind | 8
  46                         l, t = minsize
  47                         if maxsize:
  48                                 r, b = maxsize[0] + 1, maxsize[1] + 1
  49                         else:
  50                                 r, b = 32000, 32000
  51                         self.growlimit = (l, t, r, b)
  52                 else:
  53                         self._hasgrowbox = 0
  54                         if (self.windowkind == 0 or self.windowkind >= 8) and self.windowkind < 1000:
  55                                 self.windowkind = self.windowkind | 4
  56                 FrameWork.Window.__init__(self, W.getapplication())
  57
  58         def gettitle(self):
  59                 return self.title
  60
  61         def settitle(self, title):
  62                 self.title = title
  63                 if self.wid:
  64                         self.wid.SetWTitle(title)
  65
  66         def getwindowbounds(self, size, minsize = None):
  67                 return windowbounds(size, minsize)
  68
  69         def getcurrentwidget(self):
  70                 return self._currentwidget
  71
  72         def show(self, onoff):
  73                 if onoff:
  74                         self.wid.ShowWindow()
  75                 else:
  76                         self.wid.HideWindow()
  77
  78         def isvisible(self):
  79                 return self.wid.IsWindowVisible()
  80
  81         def select(self):
  82                 self.wid.SelectWindow()
  83                 # not sure if this is the best place, I need it when
  84                 # an editor gets selected, and immediately scrolled
  85                 # to a certain line, waste scroll assumes everything
  86                 # to be in tact.
  87                 self.do_rawupdate(self.wid, "DummyEvent")
  88
  89         def open(self):
  90                 self.wid = Win.NewCWindow(self._globalbounds, self.title, self._show,
  91                         self.windowkind, -1, self.hasclosebox, 0)
  92                 self.SetPort()
  93                 fontname, fontstyle, fontsize, fontcolor = self._fontsettings
  94                 fnum = Fm.GetFNum(fontname)
  95                 if fnum == 0:
  96                         fnum = Fm.GetFNum("Geneva")
  97                 Qd.TextFont(fnum)
  98                 Qd.TextFace(fontstyle)
  99                 Qd.TextSize(fontsize)
 100                 if self._bindings.has_key("<open>"):
 101                         callback = self._bindings["<open>"]
 102                         callback()
 103                 for w in self._widgets:
 104                         w.forall_frombottom("open")
 105                 self._maketabchain()
 106                 if self._tabbable:
 107                         self.bind('tab', self.nextwidget)
 108                         self.bind('shifttab', self.previouswidget)
 109                 else:
 110                         self._hasselframes = 0
 111                 if self._tabchain:
 112                         self._tabchain[0].select(1)
 113                 self.do_postopen()
 114
 115         def close(self):
 116                 if not self.wid:
 117                         return  # we are already closed
 118                 if self._bindings.has_key("<close>"):
 119                         callback = self._bindings["<close>"]
 120                         try:
 121                                 rv = callback()
 122                         except:
 123                                 print 'error in <close> callback'
 124                                 traceback.print_exc()
 125                         else:
 126                                 if rv:
 127                                         return rv
 128                 #for key in self._widgetsdict.keys():
 129                 #       self._removewidget(key)
 130                 self.forall_butself("close")
 131                 Wbase.SelectableWidget.close(self)
 132                 self._tabchain = []
 133                 self._currentwidget = None
 134                 self.wid.HideWindow()
 135                 self.do_postclose()
 136
 137         def domenu_close(self, *args):
 138                 self.close()
 139
 140         def getbounds(self):
 141                 return self._globalbounds
 142
 143         def setbounds(self, bounds):
 144                 l, t, r, b = bounds
 145                 self.move(l, t)
 146                 self.resize(r-l, b-t)
 147
 148         def move(self, x, y = None):
 149                 """absolute move"""
 150                 if y == None:
 151                         x, y = x
 152                 self.wid.MoveWindow(x, y, 0)
 153
 154         def resize(self, x, y = None):
 155                 if not self._hasgrowbox:
 156                         return  # hands off!
 157                 if y == None:
 158                         x, y = x
 159                 self.SetPort()
 160                 self.GetWindow().InvalWindowRect(self.getgrowrect())
 161                 self.wid.SizeWindow(x, y, 1)
 162                 self._calcbounds()
 163
 164         def test(self, point):
 165                 return 1
 166
 167         def draw(self, visRgn = None):
 168                 if self._hasgrowbox:
 169                         self.tempcliprect(self.getgrowrect())
 170                         self.wid.DrawGrowIcon()
 171                         self.restoreclip()
 172
 173         def idle(self, *args):
 174                 self.SetPort()
 175                 point = Evt.GetMouse()
 176                 widget = self.findwidget(point, 0)
 177                 if self._bindings.has_key("<idle>"):
 178                         callback = self._bindings["<idle>"]
 179                         if callback():
 180                                 return
 181                 if self._currentwidget is not None and hasattr(self._currentwidget, "idle"):
 182                         if self._currentwidget._bindings.has_key("<idle>"):
 183                                 callback = self._currentwidget._bindings["<idle>"]
 184                                 if callback():
 185                                         return
 186                         if self._currentwidget.idle():
 187                                 return
 188                 if widget is not None and hasattr(widget, "rollover"):
 189                         if 1:   #self._lastrollover <> widget:
 190                                 if self._lastrollover:
 191                                         self._lastrollover.rollover(point, 0)
 192                                 self._lastrollover = widget
 193                                 self._lastrollover.rollover(point, 1)
 194                 else:
 195                         if self._lastrollover:
 196                                 self._lastrollover.rollover(point, 0)
 197                         self._lastrollover = None
 198                         Wbase.SetCursor("arrow")
 199
 200         def xxx___select(self, widget):
 201                 if self._currentwidget == widget:
 202                         return
 203                 if self._bindings.has_key("<select>"):
 204                         callback = self._bindings["<select>"]
 205                         if callback(widget):
 206                                 return
 207                 if widget is None:
 208                         if self._currentwidget is not None:
 209                                 self._currentwidget.select(0)
 210                 elif type(widget) == InstanceType and widget._selectable:
 211                         widget.select(1)
 212                 elif widget == -1 or widget == 1:
 213                         if len(self._tabchain) <= 1:
 214                                 return
 215                         temp = self._tabchain[(self._tabchain.index(self._currentwidget) + widget) % len(self._tabchain)]
 216                         temp.select(1)
 217                 else:
 218                         raise TypeError, "Widget is not selectable"
 219
 220         def setdefaultbutton(self, newdefaultbutton = None, *keys):
 221                 if newdefaultbutton == self._defaultbutton:
 222                         return
 223                 if self._defaultbutton:
 224                         self._defaultbutton._setdefault(0)
 225                 if not newdefaultbutton:
 226                         self.bind("return", None)
 227                         self.bind("enter", None)
 228                         return
 229                 import Wcontrols
 230                 if not isinstance(newdefaultbutton, Wcontrols.Button):
 231                         raise TypeError, "widget is not a button"
 232                 self._defaultbutton = newdefaultbutton
 233                 self._defaultbutton._setdefault(1)
 234                 if not keys:
 235                         self.bind("return", self._defaultbutton.push)
 236                         self.bind("enter", self._defaultbutton.push)
 237                 else:
 238                         for key in keys:
 239                                 self.bind(key, self._defaultbutton.push)
 240
 241         def nextwidget(self):
 242                 self.xxx___select(1)
 243
 244         def previouswidget(self):
 245                 self.xxx___select(-1)
 246
 247         def drawwidgetbounds(self, onoff):
 248                 self._drawwidgetbounds = onoff
 249                 self.SetPort()
 250                 self.GetWindow().InvalWindowRect(self._bounds)
 251
 252         def _drawbounds(self):
 253                 pass
 254
 255         def _maketabchain(self):
 256                 # XXX This has to change, it's no good when we are adding or deleting widgets.
 257                 # XXX Perhaps we shouldn't keep a "tabchain" at all.
 258                 self._hasselframes = 0
 259                 self._collectselectablewidgets(self._widgets)
 260                 if self._hasselframes and len(self._tabchain) > 1:
 261                         self._hasselframes = 1
 262                 else:
 263                         self._hasselframes = 0
 264
 265         def _collectselectablewidgets(self, widgets):
 266                 import W
 267                 for w in widgets:
 268                         if w._selectable:
 269                                 self._tabchain.append(w)
 270                                 if isinstance(w, W.List):
 271                                         self._hasselframes = 1
 272                         self._collectselectablewidgets(w._widgets)
 273
 274         def _calcbounds(self):
 275                 self._possize = self.wid.GetWindowPort().portRect[2:]
 276                 w, h = self._possize
 277                 self._bounds = (0, 0, w, h)
 278                 self.wid.GetWindowContentRgn(scratchRegion)
 279                 l, t, r, b = GetRgnBounds(scratchRegion)
 280                 self._globalbounds = l, t, l + w, t + h
 281                 for w in self._widgets:
 282                         w._calcbounds()
 283
 284         # FrameWork override methods
 285         def do_inDrag(self, partcode, window, event):
 286                 where = event[3]
 287                 self.wid.GetWindowContentRgn(scratchRegion)
 288                 was_l, was_t, r, b = GetRgnBounds(scratchRegion)
 289                 window.DragWindow(where, self.draglimit)
 290                 self.wid.GetWindowContentRgn(scratchRegion)
 291                 is_l, is_t, r, b = GetRgnBounds(scratchRegion)
 292                 self._globalbounds = Qd.OffsetRect(self._globalbounds,
 293                                         is_l - was_l, is_t - was_t)
 294
 295         def do_char(self, char, event):
 296                 import Wkeys
 297                 (what, message, when, where, modifiers) = event
 298                 key = char
 299                 if Wkeys.keynames.has_key(key):
 300                         key = Wkeys.keynames[key]
 301                 if modifiers & Events.shiftKey:
 302                         key = 'shift' + key
 303                 if modifiers & Events.cmdKey:
 304                         key = 'cmd' + key
 305                 if modifiers & Events.controlKey:
 306                         key = 'control' + key
 307                 if self._bindings.has_key("<key>"):
 308                         callback = self._bindings["<key>"]
 309                         if Wbase.CallbackCall(callback, 0, char, event):
 310                                 return
 311                 if self._bindings.has_key(key):
 312                         callback = self._bindings[key]
 313                         Wbase.CallbackCall(callback, 0, char, event)
 314                 elif self._currentwidget is not None:
 315                         if self._currentwidget._bindings.has_key(key):
 316                                 callback = self._currentwidget._bindings[key]
 317                                 Wbase.CallbackCall(callback, 0, char, event)
 318                         else:
 319                                 if self._currentwidget._bindings.has_key("<key>"):
 320                                         callback = self._currentwidget._bindings["<key>"]
 321                                         if Wbase.CallbackCall(callback, 0, char, event):
 322                                                 return
 323                                 self._currentwidget.key(char, event)
 324
 325         def do_contentclick(self, point, modifiers, event):
 326                 widget = self.findwidget(point)
 327                 if widget is not None:
 328                         if self._bindings.has_key("<click>"):
 329                                 callback = self._bindings["<click>"]
 330                                 if Wbase.CallbackCall(callback, 0, point, modifiers):
 331                                         return
 332                         if widget._bindings.has_key("<click>"):
 333                                 callback = widget._bindings["<click>"]
 334                                 if Wbase.CallbackCall(callback, 0, point, modifiers):
 335                                         return
 336                         if widget._selectable:
 337                                 widget.select(1, 1)
 338                         widget.click(point, modifiers)
 339
 340         def do_update(self, window, event):
 341                 Qd.EraseRgn(window.GetWindowPort().visRgn)
 342                 self.forall_frombottom("draw", window.GetWindowPort().visRgn)
 343                 if self._drawwidgetbounds:
 344                         self.forall_frombottom("_drawbounds")
 345
 346         def do_activate(self, onoff, event):
 347                 if not onoff:
 348                         if self._lastrollover:
 349                                 self._lastrollover.rollover((0, 0), 0)
 350                                 self._lastrollover = None
 351                 self.SetPort()
 352                 self.forall("activate", onoff)
 353                 self.draw()
 354
 355         def do_postresize(self, width, height, window):
 356                 self.GetWindow().InvalWindowRect(self.getgrowrect())
 357                 self._calcbounds()
 358
 359         def do_inGoAway(self, partcode, window, event):
 360                 where = event[3]
 361                 closeall = event[4] & Events.optionKey
 362                 if window.TrackGoAway(where):
 363                         if not closeall:
 364                                 self.close()
 365                         else:
 366                                 for window in self.parent._windows.values():
 367                                         rv = window.close()
 368                                         if rv and rv > 0:
 369                                                 return
 370
 371         # utilities
 372         def tempcliprect(self, tempcliprect):
 373                 tempclip = Qd.NewRgn()
 374                 Qd.RectRgn(tempclip, tempcliprect)
 375                 self.tempclip(tempclip)
 376                 Qd.DisposeRgn(tempclip)
 377
 378         def tempclip(self, tempclip):
 379                 if not hasattr(self, "saveclip"):
 380                         self.saveclip = []
 381                 saveclip = Qd.NewRgn()
 382                 Qd.GetClip(saveclip)
 383                 self.saveclip.append(saveclip)
 384                 Qd.SetClip(tempclip)
 385
 386         def restoreclip(self):
 387                 Qd.SetClip(self.saveclip[-1])
 388                 Qd.DisposeRgn(self.saveclip[-1])
 389                 del self.saveclip[-1]
 390
 391         def getgrowrect(self):
 392                 l, t, r, b = self.wid.GetWindowPort().portRect
 393                 return (r - 15, b - 15, r, b)
 394
 395         def has_key(self, key):
 396                 return self._widgetsdict.has_key(key)
 397
 398         def __getattr__(self, attr):
 399                 global _successcount, _failcount, _magiccount
 400                 if self._widgetsdict.has_key(attr):
 401                         _successcount = _successcount + 1
 402                         return self._widgetsdict[attr]
 403                 if self._currentwidget is None or (attr[:7] <> 'domenu_' and
 404                                 attr[:4] <> 'can_' and attr <> 'insert'):
 405                         _failcount = _failcount + 1
 406                         raise AttributeError, attr
 407                 # special case: if a domenu_xxx, can_xxx or insert method is asked for,
 408                 # see if the active widget supports it
 409                 _magiccount = _magiccount + 1
 410                 return getattr(self._currentwidget, attr)
 411
 412 _successcount = 0
 413 _failcount = 0
 414 _magiccount = 0
 415
 416 class Dialog(Window):
 417
 418         windowkind = Windows.movableDBoxProc
 419
 420         # this __init__ seems redundant, but it's not: it has less args
 421         def __init__(self, possize, title = ""):
 422                 Window.__init__(self, possize, title)
 423
 424         def can_close(self, *args):
 425                 return 0
 426
 427         def getwindowbounds(self, size, minsize = None):
 428                 screenbounds = sl, st, sr, sb = Qd.qd.screenBits.bounds
 429                 w, h = size
 430                 l = sl + (sr - sl - w) / 2
 431                 t = st + (sb - st - h) / 3
 432                 return l, t, l + w, t + h
 433
 434
 435 class ModalDialog(Dialog):
 436
 437         def __init__(self, possize, title = ""):
 438                 Dialog.__init__(self, possize, title)
 439                 if title:
 440                         self.windowkind = Windows.movableDBoxProc
 441                 else:
 442                         self.windowkind = Windows.dBoxProc
 443
 444         def open(self):
 445                 import W
 446                 Dialog.open(self)
 447                 self.app = W.getapplication()
 448                 self.done = 0
 449                 Menu.HiliteMenu(0)
 450                 app = self.parent
 451                 app.enablemenubar(0)
 452                 try:
 453                         self.mainloop()
 454                 finally:
 455                         app.enablemenubar(1)
 456
 457         def close(self):
 458                 if not self.wid:
 459                         return  # we are already closed
 460                 self.done = 1
 461                 del self.app
 462                 Dialog.close(self)
 463
 464         def mainloop(self):
 465                 saveyield = MacOS.EnableAppswitch(-1)
 466                 while not self.done:
 467                         #self.do1event()
 468                         self.do1event(  Events.keyDownMask +
 469                                                 Events.autoKeyMask +
 470                                                 Events.activMask +
 471                                                 Events.updateMask +
 472                                                 Events.mDownMask +
 473                                                 Events.mUpMask,
 474                                                 10)
 475                 MacOS.EnableAppswitch(saveyield)
 476
 477         def do1event(self, mask = Events.everyEvent, wait = 0):
 478                 ok, event = self.app.getevent(mask, wait)
 479                 if Dlg.IsDialogEvent(event):
 480                         if self.app.do_dialogevent(event):
 481                                 return
 482                 if ok:
 483                         self.dispatch(event)
 484                 else:
 485                         self.app.idle(event)
 486
 487         def do_keyDown(self, event):
 488                 self.do_key(event)
 489
 490         def do_autoKey(self, event):
 491                 if not event[-1] & Events.cmdKey:
 492                         self.do_key(event)
 493
 494         def do_key(self, event):
 495                 (what, message, when, where, modifiers) = event
 496                 w = Win.FrontWindow()
 497                 if w <> self.wid:
 498                         return
 499                 c = chr(message & Events.charCodeMask)
 500                 if modifiers & Events.cmdKey:
 501                         self.app.checkmenus(self)
 502                         result = Menu.MenuKey(ord(c))
 503                         id = (result>>16) & 0xffff      # Hi word
 504                         item = result & 0xffff          # Lo word
 505                         if id:
 506                                 self.app.do_rawmenu(id, item, None, event)
 507                                 return
 508                 self.do_char(c, event)
 509
 510         def do_mouseDown(self, event):
 511                 (what, message, when, where, modifiers) = event
 512                 partcode, wid = Win.FindWindow(where)
 513                 #
 514                 # Find the correct name.
 515                 #
 516                 if FrameWork.partname.has_key(partcode):
 517                         name = "do_" + FrameWork.partname[partcode]
 518                 else:
 519                         name = "do_%d" % partcode
 520
 521                 if name == "do_inDesk":
 522                         MacOS.HandleEvent(event)
 523                         return
 524                 if wid == self.wid:
 525                         try:
 526                                 handler = getattr(self, name)
 527                         except AttributeError:
 528                                 handler = self.app.do_unknownpartcode
 529                 else:
 530                         #MacOS.HandleEvent(event)
 531                         if name == 'do_inMenuBar':
 532                                 handler = getattr(self.parent, name)
 533                         else:
 534                                 return
 535                 handler(partcode, wid, event)
 536
 537         def dispatch(self, event):
 538                 (what, message, when, where, modifiers) = event
 539                 if FrameWork.eventname.has_key(what):
 540                         name = "do_" + FrameWork.eventname[what]
 541                 else:
 542                         name = "do_%d" % what
 543                 try:
 544                         handler = getattr(self, name)
 545                 except AttributeError:
 546                         try:
 547                                 handler = getattr(self.app, name)
 548                         except AttributeError:
 549                                 handler = self.app.do_unknownevent
 550                 handler(event)
 551
 552
 553 def FrontWindowInsert(stuff):
 554         if not stuff:
 555                 return
 556         if type(stuff) <> StringType:
 557                 raise TypeError, 'string expected'
 558         import W
 559         app = W.getapplication()
 560         wid = Win.FrontWindow()
 561         if wid and app._windows.has_key(wid):
 562                 window = app._windows[wid]
 563                 if hasattr(window, "insert"):
 564                         try:
 565                                 window.insert(stuff)
 566                                 return
 567                         except:
 568                                 pass
 569         import EasyDialogs
 570         if EasyDialogs.AskYesNoCancel(
 571                         "Can't find window or widget to insert text into; copy to clipboard instead?",
 572                         1) == 1:
 573                 import Scrap
 574                 Scrap.ZeroScrap()
 575                 Scrap.PutScrap('TEXT', stuff)
 576
 577
 578 # not quite based on the same function in FrameWork
 579 _windowcounter = 0
 580
 581 def getnextwindowpos():
 582         global _windowcounter
 583         rows = 8
 584         l = 4 * (rows + 1 - (_windowcounter % rows) + _windowcounter / rows)
 585         t = 44 + 20 * (_windowcounter % rows)
 586         _windowcounter = _windowcounter + 1
 587         return l, t
 588
 589 def windowbounds(preferredsize, minsize=None):
 590         "Return sensible window bounds"
 591
 592         global _windowcounter
 593         if len(preferredsize) == 4:
 594                 bounds = l, t, r, b = preferredsize
 595                 desktopRgn = Win.GetGrayRgn()
 596                 tempRgn = Qd.NewRgn()
 597                 Qd.RectRgn(tempRgn, bounds)
 598                 union = Qd.UnionRgn(tempRgn, desktopRgn, tempRgn)
 599                 equal = Qd.EqualRgn(tempRgn, desktopRgn)
 600                 Qd.DisposeRgn(tempRgn)
 601                 if equal:
 602                         return bounds
 603                 else:
 604                         preferredsize = r - l, b - t
 605         if not minsize:
 606                 minsize = preferredsize
 607         minwidth, minheight = minsize
 608         width, height = preferredsize
 609
 610         sl, st, sr, sb = screenbounds = Qd.InsetRect(Qd.qd.screenBits.bounds, 4, 4)
 611         l, t = getnextwindowpos()
 612         if (l + width) > sr:
 613                 _windowcounter = 0
 614                 l, t = getnextwindowpos()
 615         r = l + width
 616         b = t + height
 617         if (t + height) > sb:
 618                 b = sb
 619                 if (b - t) < minheight:
 620                         b = t + minheight
 621         return l, t, r, b
 622
 623 scratchRegion = Qd.NewRgn()
 624
 625 # util -- move somewhere convenient???
 626 def GetRgnBounds(the_Rgn):
 627         (t, l, b, r) = struct.unpack("hhhh", the_Rgn.data[2:10])
 628         return (l, t, r, b)