Mac/Demo/waste/swed.py

   1 # A minimal text editor.
   2 #
   3 # To be done:
   4 # - Functionality: find, etc.
   5
   6 from Menu import DrawMenuBar
   7 from FrameWork import *
   8 import Win
   9 import Qd
  10 import Res
  11 import Fm
  12 import waste
  13 import WASTEconst
  14 import Scrap
  15 import os
  16 import macfs
  17 import MACFS
  18
  19 UNDOLABELS = [ # Indexed by WEGetUndoInfo() value
  20         None, "", "typing", "Cut", "Paste", "Clear", "Drag", "Style"]
  21
  22 # Style and size menu. Note that style order is important (tied to bit values)
  23 STYLES = [
  24         ("Bold", "B"), ("Italic", "I"), ("Underline", "U"), ("Outline", "O"),
  25         ("Shadow", ""), ("Condensed", ""), ("Extended", "")
  26         ]
  27 SIZES = [ 9, 10, 12, 14, 18, 24]
  28
  29 BIGREGION=Qd.NewRgn()
  30 Qd.SetRectRgn(BIGREGION, -16000, -16000, 16000, 16000)
  31
  32 class WasteWindow(ScrolledWindow):
  33         def open(self, path, name, data):
  34                 self.path = path
  35                 self.name = name
  36                 r = windowbounds(400, 400)
  37                 w = Win.NewWindow(r, name, 1, 0, -1, 1, 0x55555555)
  38                 self.wid = w
  39                 vr = 0, 0, r[2]-r[0]-15, r[3]-r[1]-15
  40                 dr = (0, 0, 10240, 0)
  41                 Qd.SetPort(w)
  42                 Qd.TextFont(4)
  43                 Qd.TextSize(9)
  44                 flags = WASTEconst.weDoAutoScroll | WASTEconst.weDoOutlineHilite | \
  45                                 WASTEconst.weDoUndo
  46                 self.ted = waste.WENew(dr, vr, flags)
  47                 self.ted.WEInstallTabHooks()
  48                 style, soup = self.getstylesoup()
  49                 self.ted.WEInsert(data, style, soup)
  50                 self.ted.WESetSelection(0,0)
  51                 self.ted.WECalText()
  52                 self.ted.WEResetModCount()
  53                 w.DrawGrowIcon()
  54                 self.scrollbars()
  55                 self.do_postopen()
  56                 self.do_activate(1, None)
  57
  58         def getstylesoup(self):
  59                 if not self.path:
  60                         return None, None
  61                 oldrf = Res.CurResFile()
  62                 try:
  63                         rf = Res.FSpOpenResFile(self.path, 1)
  64                 except Res.Error:
  65                         return None, None
  66                 try:
  67                         hstyle = Res.Get1Resource('styl', 128)
  68                         hstyle.DetachResource()
  69                 except Res.Error:
  70                         hstyle = None
  71                 try:
  72                         hsoup = Res.Get1Resource('SOUP', 128)
  73                         hsoup.DetachResource()
  74                 except Res.Error:
  75                         hsoup = None
  76                 Res.CloseResFile(rf)
  77                 Res.UseResFile(oldrf)
  78                 return hstyle, hsoup
  79
  80         def do_idle(self, event):
  81                 (what, message, when, where, modifiers) = event
  82                 Qd.SetPort(self.wid)
  83                 self.ted.WEIdle()
  84                 if self.ted.WEAdjustCursor(where, BIGREGION):
  85                         return
  86                 Qd.SetCursor(Qd.qd.arrow)
  87
  88         def getscrollbarvalues(self):
  89                 dr = self.ted.WEGetDestRect()
  90                 vr = self.ted.WEGetViewRect()
  91                 vx = self.scalebarvalue(dr[0], dr[2], vr[0], vr[2])
  92                 vy = self.scalebarvalue(dr[1], dr[3], vr[1], vr[3])
  93                 return vx, vy
  94
  95         def scrollbar_callback(self, which, what, value):
  96                 if which == 'y':
  97                         if what == 'set':
  98                                 height = self.ted.WEGetHeight(0, 0x3fffffff)
  99                                 cur = self.getscrollbarvalues()[1]
 100                                 delta = (cur-value)*height/32767
 101                         if what == '-':
 102                                 topline_off,dummy = self.ted.WEGetOffset((1,1))
 103                                 topline_num = self.ted.WEOffsetToLine(topline_off)
 104                                 delta = self.ted.WEGetHeight(topline_num, topline_num+1)
 105                         elif what == '--':
 106                                 delta = (self.ted.WEGetViewRect()[3]-10)
 107                                 if delta <= 0:
 108                                         delta = 10 # Random value
 109                         elif what == '+':
 110                                 # XXXX Wrong: should be bottom line size
 111                                 topline_off,dummy = self.ted.WEGetOffset((1,1))
 112                                 topline_num = self.ted.WEOffsetToLine(topline_off)
 113                                 delta = -self.ted.WEGetHeight(topline_num, topline_num+1)
 114                         elif what == '++':
 115                                 delta = -(self.ted.WEGetViewRect()[3]-10)
 116                                 if delta >= 0:
 117                                         delta = -10
 118                         self.ted.WEScroll(0, delta)
 119                 else:
 120                         if what == 'set':
 121                                 return # XXXX
 122                         vr = self.ted.WEGetViewRect()
 123                         winwidth = vr[2]-vr[0]
 124                         if what == '-':
 125                                 delta = winwidth/10
 126                         elif what == '--':
 127                                 delta = winwidth/2
 128                         elif what == '+':
 129                                 delta = -winwidth/10
 130                         elif what == '++':
 131                                 delta = -winwidth/2
 132                         self.ted.WEScroll(delta, 0)
 133                 # Pin the scroll
 134                 l, t, r, b = self.ted.WEGetDestRect()
 135                 vl, vt, vr, vb = self.ted.WEGetViewRect()
 136                 if t > 0 or l > 0:
 137                         dx = dy = 0
 138                         if t > 0: dy = -t
 139                         if l > 0: dx = -l
 140                         self.ted.WEScroll(dx, dy)
 141                 elif b < vb:
 142                         self.ted.WEScroll(0, b-vb)
 143
 144
 145         def do_activate(self, onoff, evt):
 146                 Qd.SetPort(self.wid)
 147                 ScrolledWindow.do_activate(self, onoff, evt)
 148                 if onoff:
 149                         self.ted.WEActivate()
 150                         self.parent.active = self
 151                         self.parent.updatemenubar()
 152                 else:
 153                         self.ted.WEDeactivate()
 154
 155         def do_update(self, wid, event):
 156                 region = wid.GetWindowPort().visRgn
 157                 if Qd.EmptyRgn(region):
 158                         return
 159                 Qd.EraseRgn(region)
 160                 self.ted.WEUpdate(region)
 161                 self.updatescrollbars()
 162
 163         def do_postresize(self, width, height, window):
 164                 l, t, r, b = self.ted.WEGetViewRect()
 165                 vr = (l, t, l+width-15, t+height-15)
 166                 self.ted.WESetViewRect(vr)
 167                 self.wid.InvalWindowRect(vr)
 168                 ScrolledWindow.do_postresize(self, width, height, window)
 169
 170         def do_contentclick(self, local, modifiers, evt):
 171                 (what, message, when, where, modifiers) = evt
 172                 self.ted.WEClick(local, modifiers, when)
 173                 self.updatescrollbars()
 174                 self.parent.updatemenubar()
 175
 176         def do_char(self, ch, event):
 177                 self.ted.WESelView()
 178                 (what, message, when, where, modifiers) = event
 179                 self.ted.WEKey(ord(ch), modifiers)
 180                 self.updatescrollbars()
 181                 self.parent.updatemenubar()
 182
 183         def close(self):
 184                 if self.ted.WEGetModCount():
 185                         save = EasyDialogs.AskYesNoCancel('Save window "%s" before closing?'%self.name, 1)
 186                         if save > 0:
 187                                 self.menu_save()
 188                         elif save < 0:
 189                                 return
 190                 if self.parent.active == self:
 191                         self.parent.active = None
 192                 self.parent.updatemenubar()
 193                 del self.ted
 194                 self.do_postclose()
 195
 196         def menu_save(self):
 197                 if not self.path:
 198                         self.menu_save_as()
 199                         return # Will call us recursively
 200                 #
 201                 # First save data
 202                 #
 203                 dhandle = self.ted.WEGetText()
 204                 data = dhandle.data
 205                 fp = open(self.path, 'wb')  # NOTE: wb, because data has CR for end-of-line
 206                 fp.write(data)
 207                 if data[-1] <> '\r': fp.write('\r')
 208                 fp.close()
 209                 #
 210                 # Now save style and soup
 211                 #
 212                 oldresfile = Res.CurResFile()
 213                 try:
 214                         rf = Res.FSpOpenResFile(self.path, 3)
 215                 except Res.Error:
 216                         Res.FSpCreateResFile(self.path, '????', 'TEXT', MACFS.smAllScripts)
 217                         rf = Res.FSpOpenResFile(self.path, 3)
 218                 styles = Res.Resource('')
 219                 soup = Res.Resource('')
 220                 self.ted.WECopyRange(0, 0x3fffffff, None, styles, soup)
 221                 styles.AddResource('styl', 128, '')
 222                 soup.AddResource('SOUP', 128, '')
 223                 Res.CloseResFile(rf)
 224                 Res.UseResFile(oldresfile)
 225
 226                 self.ted.WEResetModCount()
 227
 228         def menu_save_as(self):
 229                 fss, ok = macfs.StandardPutFile('Save as:')
 230                 if not ok: return
 231                 self.path = fss.as_pathname()
 232                 self.name = os.path.split(self.path)[-1]
 233                 self.wid.SetWTitle(self.name)
 234                 self.menu_save()
 235
 236         def menu_cut(self):
 237                 self.ted.WESelView()
 238                 self.ted.WECut()
 239                 Scrap.ZeroScrap()
 240                 self.ted.WECut()
 241                 self.updatescrollbars()
 242                 self.parent.updatemenubar()
 243
 244         def menu_copy(self):
 245                 Scrap.ZeroScrap()
 246                 self.ted.WECopy()
 247                 self.updatescrollbars()
 248                 self.parent.updatemenubar()
 249
 250         def menu_paste(self):
 251                 self.ted.WESelView()
 252                 self.ted.WEPaste()
 253                 self.updatescrollbars()
 254                 self.parent.updatemenubar()
 255
 256         def menu_clear(self):
 257                 self.ted.WESelView()
 258                 self.ted.WEDelete()
 259                 self.updatescrollbars()
 260                 self.parent.updatemenubar()
 261
 262         def menu_undo(self):
 263                 self.ted.WEUndo()
 264                 self.updatescrollbars()
 265                 self.parent.updatemenubar()
 266
 267         def menu_setfont(self, font):
 268                 font = Fm.GetFNum(font)
 269                 self.mysetstyle(WASTEconst.weDoFont, (font, 0, 0, (0,0,0)))
 270                 self.parent.updatemenubar()
 271
 272         def menu_modface(self, face):
 273                 self.mysetstyle(WASTEconst.weDoFace|WASTEconst.weDoToggleFace,
 274                         (0, face, 0, (0,0,0)))
 275
 276         def menu_setface(self, face):
 277                 self.mysetstyle(WASTEconst.weDoFace|WASTEconst.weDoReplaceFace,
 278                         (0, face, 0, (0,0,0)))
 279
 280         def menu_setsize(self, size):
 281                 self.mysetstyle(WASTEconst.weDoSize, (0, 0, size, (0,0,0)))
 282
 283         def menu_incsize(self, size):
 284                 self.mysetstyle(WASTEconst.weDoAddSize, (0, 0, size, (0,0,0)))
 285
 286         def mysetstyle(self, which, how):
 287                 self.ted.WESelView()
 288                 self.ted.WESetStyle(which, how)
 289                 self.parent.updatemenubar()
 290
 291         def have_selection(self):
 292                 start, stop = self.ted.WEGetSelection()
 293                 return start < stop
 294
 295         def can_paste(self):
 296                 return self.ted.WECanPaste()
 297
 298         def can_undo(self):
 299                 which, redo = self.ted.WEGetUndoInfo()
 300                 which = UNDOLABELS[which]
 301                 if which == None: return None
 302                 if redo:
 303                         return "Redo "+which
 304                 else:
 305                         return "Undo "+which
 306
 307         def getruninfo(self):
 308                 all = (WASTEconst.weDoFont | WASTEconst.weDoFace | WASTEconst.weDoSize)
 309                 dummy, mode, (font, face, size, color) = self.ted.WEContinuousStyle(all)
 310                 if not (mode & WASTEconst.weDoFont):
 311                         font = None
 312                 else:
 313                         font = Fm.GetFontName(font)
 314                 if not (mode & WASTEconst.weDoFace): fact = None
 315                 if not (mode & WASTEconst.weDoSize): size = None
 316                 return font, face, size
 317
 318 class Wed(Application):
 319         def __init__(self):
 320                 Application.__init__(self)
 321                 self.num = 0
 322                 self.active = None
 323                 self.updatemenubar()
 324                 waste.STDObjectHandlers()
 325
 326         def makeusermenus(self):
 327                 self.filemenu = m = Menu(self.menubar, "File")
 328                 self.newitem = MenuItem(m, "New window", "N", self.open)
 329                 self.openitem = MenuItem(m, "Open...", "O", self.openfile)
 330                 self.closeitem = MenuItem(m, "Close", "W", self.closewin)
 331                 m.addseparator()
 332                 self.saveitem = MenuItem(m, "Save", "S", self.save)
 333                 self.saveasitem = MenuItem(m, "Save as...", "", self.saveas)
 334                 m.addseparator()
 335                 self.quititem = MenuItem(m, "Quit", "Q", self.quit)
 336
 337                 self.editmenu = m = Menu(self.menubar, "Edit")
 338                 self.undoitem = MenuItem(m, "Undo", "Z", self.undo)
 339                 self.cutitem = MenuItem(m, "Cut", "X", self.cut)
 340                 self.copyitem = MenuItem(m, "Copy", "C", self.copy)
 341                 self.pasteitem = MenuItem(m, "Paste", "V", self.paste)
 342                 self.clearitem = MenuItem(m, "Clear", "", self.clear)
 343
 344                 self.makefontmenu()
 345
 346                 # Groups of items enabled together:
 347                 self.windowgroup = [self.closeitem, self.saveitem, self.saveasitem,
 348                         self.editmenu, self.fontmenu, self.facemenu, self.sizemenu]
 349                 self.focusgroup = [self.cutitem, self.copyitem, self.clearitem]
 350                 self.windowgroup_on = -1
 351                 self.focusgroup_on = -1
 352                 self.pastegroup_on = -1
 353                 self.undo_label = "never"
 354                 self.ffs_values = ()
 355
 356         def makefontmenu(self):
 357                 self.fontmenu = Menu(self.menubar, "Font")
 358                 self.fontnames = getfontnames()
 359                 self.fontitems = []
 360                 for n in self.fontnames:
 361                         m = MenuItem(self.fontmenu, n, "", self.selfont)
 362                         self.fontitems.append(m)
 363                 self.facemenu = Menu(self.menubar, "Style")
 364                 self.faceitems = []
 365                 for n, shortcut in STYLES:
 366                         m = MenuItem(self.facemenu, n, shortcut, self.selface)
 367                         self.faceitems.append(m)
 368                 self.facemenu.addseparator()
 369                 self.faceitem_normal = MenuItem(self.facemenu, "Normal", "N",
 370                         self.selfacenormal)
 371                 self.sizemenu = Menu(self.menubar, "Size")
 372                 self.sizeitems = []
 373                 for n in SIZES:
 374                         m = MenuItem(self.sizemenu, `n`, "", self.selsize)
 375                         self.sizeitems.append(m)
 376                 self.sizemenu.addseparator()
 377                 self.sizeitem_bigger = MenuItem(self.sizemenu, "Bigger", "+",
 378                         self.selsizebigger)
 379                 self.sizeitem_smaller = MenuItem(self.sizemenu, "Smaller", "-",
 380                         self.selsizesmaller)
 381
 382         def selfont(self, id, item, *rest):
 383                 if self.active:
 384                         font = self.fontnames[item-1]
 385                         self.active.menu_setfont(font)
 386                 else:
 387                         EasyDialogs.Message("No active window?")
 388
 389         def selface(self, id, item, *rest):
 390                 if self.active:
 391                         face = (1<<(item-1))
 392                         self.active.menu_modface(face)
 393                 else:
 394                         EasyDialogs.Message("No active window?")
 395
 396         def selfacenormal(self, *rest):
 397                 if self.active:
 398                         self.active.menu_setface(0)
 399                 else:
 400                         EasyDialogs.Message("No active window?")
 401
 402         def selsize(self, id, item, *rest):
 403                 if self.active:
 404                         size = SIZES[item-1]
 405                         self.active.menu_setsize(size)
 406                 else:
 407                         EasyDialogs.Message("No active window?")
 408
 409         def selsizebigger(self, *rest):
 410                 if self.active:
 411                         self.active.menu_incsize(2)
 412                 else:
 413                         EasyDialogs.Message("No active window?")
 414
 415         def selsizesmaller(self, *rest):
 416                 if self.active:
 417                         self.active.menu_incsize(-2)
 418                 else:
 419                         EasyDialogs.Message("No active window?")
 420
 421         def updatemenubar(self):
 422                 changed = 0
 423                 on = (self.active <> None)
 424                 if on <> self.windowgroup_on:
 425                         for m in self.windowgroup:
 426                                 m.enable(on)
 427                         self.windowgroup_on = on
 428                         changed = 1
 429                 if on:
 430                         # only if we have an edit menu
 431                         on = self.active.have_selection()
 432                         if on <> self.focusgroup_on:
 433                                 for m in self.focusgroup:
 434                                         m.enable(on)
 435                                 self.focusgroup_on = on
 436                                 changed = 1
 437                         on = self.active.can_paste()
 438                         if on <> self.pastegroup_on:
 439                                 self.pasteitem.enable(on)
 440                                 self.pastegroup_on = on
 441                                 changed = 1
 442                         on = self.active.can_undo()
 443                         if on <> self.undo_label:
 444                                 if on:
 445                                         self.undoitem.enable(1)
 446                                         self.undoitem.settext(on)
 447                                         self.undo_label = on
 448                                 else:
 449                                         self.undoitem.settext("Nothing to undo")
 450                                         self.undoitem.enable(0)
 451                                 changed = 1
 452                         if self.updatefontmenus():
 453                                 changed = 1
 454                 if changed:
 455                         DrawMenuBar()
 456
 457         def updatefontmenus(self):
 458                 info = self.active.getruninfo()
 459                 if info == self.ffs_values:
 460                         return 0
 461                 # Remove old checkmarks
 462                 if self.ffs_values == ():
 463                         self.ffs_values = (None, None, None)
 464                 font, face, size = self.ffs_values
 465                 if font <> None:
 466                         fnum = self.fontnames.index(font)
 467                         self.fontitems[fnum].check(0)
 468                 if face <> None:
 469                         for i in range(len(self.faceitems)):
 470                                 if face & (1<<i):
 471                                         self.faceitems[i].check(0)
 472                 if size <> None:
 473                         for i in range(len(self.sizeitems)):
 474                                 if SIZES[i] == size:
 475                                         self.sizeitems[i].check(0)
 476
 477                 self.ffs_values = info
 478                 # Set new checkmarks
 479                 font, face, size = self.ffs_values
 480                 if font <> None:
 481                         fnum = self.fontnames.index(font)
 482                         self.fontitems[fnum].check(1)
 483                 if face <> None:
 484                         for i in range(len(self.faceitems)):
 485                                 if face & (1<<i):
 486                                         self.faceitems[i].check(1)
 487                 if size <> None:
 488                         for i in range(len(self.sizeitems)):
 489                                 if SIZES[i] == size:
 490                                         self.sizeitems[i].check(1)
 491                 # Set outline/normal for sizes
 492                 if font:
 493                         exists = getfontsizes(font, SIZES)
 494                         for i in range(len(self.sizeitems)):
 495                                 if exists[i]:
 496                                         self.sizeitems[i].setstyle(0)
 497                                 else:
 498                                         self.sizeitems[i].setstyle(8)
 499
 500         #
 501         # Apple menu
 502         #
 503
 504         def do_about(self, id, item, window, event):
 505                 EasyDialogs.Message("A simple single-font text editor based on WASTE")
 506
 507         #
 508         # File menu
 509         #
 510
 511         def open(self, *args):
 512                 self._open(0)
 513
 514         def openfile(self, *args):
 515                 self._open(1)
 516
 517         def _open(self, askfile):
 518                 if askfile:
 519                         fss, ok = macfs.StandardGetFile('TEXT')
 520                         if not ok:
 521                                 return
 522                         path = fss.as_pathname()
 523                         name = os.path.split(path)[-1]
 524                         try:
 525                                 fp = open(path, 'rb') # NOTE binary, we need cr as end-of-line
 526                                 data = fp.read()
 527                                 fp.close()
 528                         except IOError, arg:
 529                                 EasyDialogs.Message("IOERROR: "+`arg`)
 530                                 return
 531                 else:
 532                         path = None
 533                         name = "Untitled %d"%self.num
 534                         data = ''
 535                 w = WasteWindow(self)
 536                 w.open(path, name, data)
 537                 self.num = self.num + 1
 538
 539         def closewin(self, *args):
 540                 if self.active:
 541                         self.active.close()
 542                 else:
 543                         EasyDialogs.Message("No active window?")
 544
 545         def save(self, *args):
 546                 if self.active:
 547                         self.active.menu_save()
 548                 else:
 549                         EasyDialogs.Message("No active window?")
 550
 551         def saveas(self, *args):
 552                 if self.active:
 553                         self.active.menu_save_as()
 554                 else:
 555                         EasyDialogs.Message("No active window?")
 556
 557
 558         def quit(self, *args):
 559                 for w in self._windows.values():
 560                         w.close()
 561                 if self._windows:
 562                         return
 563                 self._quit()
 564
 565         #
 566         # Edit menu
 567         #
 568
 569         def undo(self, *args):
 570                 if self.active:
 571                         self.active.menu_undo()
 572                 else:
 573                         EasyDialogs.Message("No active window?")
 574
 575         def cut(self, *args):
 576                 if self.active:
 577                         self.active.menu_cut()
 578                 else:
 579                         EasyDialogs.Message("No active window?")
 580
 581         def copy(self, *args):
 582                 if self.active:
 583                         self.active.menu_copy()
 584                 else:
 585                         EasyDialogs.Message("No active window?")
 586
 587         def paste(self, *args):
 588                 if self.active:
 589                         self.active.menu_paste()
 590                 else:
 591                         EasyDialogs.Message("No active window?")
 592
 593         def clear(self, *args):
 594                 if self.active:
 595                         self.active.menu_clear()
 596                 else:
 597                         EasyDialogs.Message("No active window?")
 598
 599         #
 600         # Other stuff
 601         #
 602
 603         def idle(self, event):
 604                 if self.active:
 605                         self.active.do_idle(event)
 606
 607 def getfontnames():
 608         names = []
 609         for i in range(256):
 610                 n = Fm.GetFontName(i)
 611                 if n: names.append(n)
 612         return names
 613
 614 def getfontsizes(name, sizes):
 615         exist = []
 616         num = Fm.GetFNum(name)
 617         for sz in sizes:
 618                 if Fm.RealFont(num, sz):
 619                         exist.append(1)
 620                 else:
 621                         exist.append(0)
 622         return exist
 623
 624 def main():
 625         App = Wed()
 626         App.mainloop()
 627
 628 if __name__ == '__main__':
 629         main()
 630