Mac/Tools/IDE/Wwindows.py

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