Mac/Demo/waste/wed.py

   1 # A minimal text editor.
   2 #
   3 # To be done:
   4 # - Functionality: find, etc.
   5
   6 from Carbon.Menu import DrawMenuBar
   7 from FrameWork import *
   8 from Carbon import Win
   9 from Carbon import Qd
  10 from Carbon import Res
  11 import waste
  12 import WASTEconst
  13 from Carbon import Scrap
  14 import os
  15 import macfs
  16
  17 UNDOLABELS = [ # Indexed by WEGetUndoInfo() value
  18         None, "", "typing", "Cut", "Paste", "Clear", "Drag", "Style"]
  19
  20 BIGREGION=Qd.NewRgn()
  21 Qd.SetRectRgn(BIGREGION, -16000, -16000, 16000, 16000)
  22
  23 class WasteWindow(ScrolledWindow):
  24         def open(self, path, name, data):
  25                 self.path = path
  26                 self.name = name
  27                 r = windowbounds(400, 400)
  28                 w = Win.NewWindow(r, name, 1, 0, -1, 1, 0)
  29                 self.wid = w
  30                 vr = 0, 0, r[2]-r[0]-15, r[3]-r[1]-15
  31                 dr = (0, 0, 10240, 0)
  32                 Qd.SetPort(w)
  33                 Qd.TextFont(4)
  34                 Qd.TextSize(9)
  35                 flags = WASTEconst.weDoAutoScroll | WASTEconst.weDoOutlineHilite | \
  36                         WASTEconst.weDoMonoStyled | WASTEconst.weDoUndo
  37                 self.ted = waste.WENew(dr, vr, flags)
  38                 self.tedtexthandle = Res.Resource(data)
  39                 self.ted.WEUseText(self.tedtexthandle)
  40                 self.ted.WECalText()
  41                 w.DrawGrowIcon()
  42                 self.scrollbars()
  43                 self.changed = 0
  44                 self.do_postopen()
  45                 self.do_activate(1, None)
  46
  47         def do_idle(self, event):
  48                 (what, message, when, where, modifiers) = event
  49                 Qd.SetPort(self.wid)
  50                 self.ted.WEIdle()
  51                 if self.ted.WEAdjustCursor(where, BIGREGION):
  52                         return
  53                 Qd.SetCursor(Qd.qd.arrow)
  54
  55         def getscrollbarvalues(self):
  56                 dr = self.ted.WEGetDestRect()
  57                 vr = self.ted.WEGetViewRect()
  58                 vx = self.scalebarvalue(dr[0], dr[2], vr[0], vr[2])
  59                 vy = self.scalebarvalue(dr[1], dr[3], vr[1], vr[3])
  60 ##              print dr, vr, vx, vy
  61                 return vx, vy
  62
  63         def scrollbar_callback(self, which, what, value):
  64                 if which == 'y':
  65                         if what == 'set':
  66                                 height = self.ted.WEGetHeight(0, 0x3fffffff)
  67                                 cur = self.getscrollbarvalues()[1]
  68                                 delta = (cur-value)*height/32767
  69                         if what == '-':
  70                                 topline_off,dummy = self.ted.WEGetOffset((1,1))
  71                                 topline_num = self.ted.WEOffsetToLine(topline_off)
  72                                 delta = self.ted.WEGetHeight(topline_num, topline_num+1)
  73                         elif what == '--':
  74                                 delta = (self.ted.WEGetViewRect()[3]-10)
  75                                 if delta <= 0:
  76                                         delta = 10 # Random value
  77                         elif what == '+':
  78                                 # XXXX Wrong: should be bottom line size
  79                                 topline_off,dummy = self.ted.WEGetOffset((1,1))
  80                                 topline_num = self.ted.WEOffsetToLine(topline_off)
  81                                 delta = -self.ted.WEGetHeight(topline_num, topline_num+1)
  82                         elif what == '++':
  83                                 delta = -(self.ted.WEGetViewRect()[3]-10)
  84                                 if delta >= 0:
  85                                         delta = -10
  86                         self.ted.WEScroll(0, delta)
  87 ##                      print 'SCROLL Y', delta
  88                 else:
  89                         if what == 'set':
  90                                 return # XXXX
  91                         vr = self.ted.WEGetViewRect()
  92                         winwidth = vr[2]-vr[0]
  93                         if what == '-':
  94                                 delta = winwidth/10
  95                         elif what == '--':
  96                                 delta = winwidth/2
  97                         elif what == '+':
  98                                 delta = -winwidth/10
  99                         elif what == '++':
 100                                 delta = -winwidth/2
 101                         self.ted.WEScroll(delta, 0)
 102                 # Pin the scroll
 103                 l, t, r, b = self.ted.WEGetDestRect()
 104                 vl, vt, vr, vb = self.ted.WEGetViewRect()
 105                 if t > 0 or l > 0:
 106                         dx = dy = 0
 107                         if t > 0: dy = -t
 108                         if l > 0: dx = -l
 109 ##                      print 'Extra scroll', dx, dy
 110                         self.ted.WEScroll(dx, dy)
 111                 elif b < vb:
 112 ##                      print 'Extra downscroll', b-vb
 113                         self.ted.WEScroll(0, b-vb)
 114
 115
 116         def do_activate(self, onoff, evt):
 117 ##              print "ACTIVATE", onoff
 118                 Qd.SetPort(self.wid)
 119                 ScrolledWindow.do_activate(self, onoff, evt)
 120                 if onoff:
 121                         self.ted.WEActivate()
 122                         self.parent.active = self
 123                         self.parent.updatemenubar()
 124                 else:
 125                         self.ted.WEDeactivate()
 126
 127         def do_update(self, wid, event):
 128                 region = wid.GetWindowPort().visRgn
 129                 if Qd.EmptyRgn(region):
 130                         return
 131                 Qd.EraseRgn(region)
 132                 self.ted.WEUpdate(region)
 133                 self.updatescrollbars()
 134
 135         def do_postresize(self, width, height, window):
 136                 l, t, r, b = self.ted.WEGetViewRect()
 137                 vr = (l, t, l+width-15, t+height-15)
 138                 self.ted.WESetViewRect(vr)
 139                 self.wid.InvalWindowRect(vr)
 140                 ScrolledWindow.do_postresize(self, width, height, window)
 141
 142         def do_contentclick(self, local, modifiers, evt):
 143                 (what, message, when, where, modifiers) = evt
 144                 self.ted.WEClick(local, modifiers, when)
 145                 self.updatescrollbars()
 146                 self.parent.updatemenubar()
 147
 148         def do_char(self, ch, event):
 149                 self.ted.WESelView()
 150                 (what, message, when, where, modifiers) = event
 151                 self.ted.WEKey(ord(ch), modifiers)
 152                 self.changed = 1
 153                 self.updatescrollbars()
 154                 self.parent.updatemenubar()
 155
 156         def close(self):
 157                 if self.changed:
 158                         save = EasyDialogs.AskYesNoCancel('Save window "%s" before closing?'%self.name, 1)
 159                         if save > 0:
 160                                 self.menu_save()
 161                         elif save < 0:
 162                                 return
 163                 if self.parent.active == self:
 164                         self.parent.active = None
 165                 self.parent.updatemenubar()
 166                 del self.ted
 167                 del self.tedtexthandle
 168                 self.do_postclose()
 169
 170         def menu_save(self):
 171                 if not self.path:
 172                         self.menu_save_as()
 173                         return # Will call us recursively
 174 ##              print 'Saving to ', self.path
 175                 dhandle = self.ted.WEGetText()
 176                 data = dhandle.data
 177                 fp = open(self.path, 'wb')  # NOTE: wb, because data has CR for end-of-line
 178                 fp.write(data)
 179                 if data[-1] <> '\r': fp.write('\r')
 180                 fp.close()
 181                 self.changed = 0
 182
 183         def menu_save_as(self):
 184                 fss, ok = macfs.StandardPutFile('Save as:')
 185                 if not ok: return
 186                 self.path = fss.as_pathname()
 187                 self.name = os.path.split(self.path)[-1]
 188                 self.wid.SetWTitle(self.name)
 189                 self.menu_save()
 190
 191         def menu_cut(self):
 192                 self.ted.WESelView()
 193                 if hasattr(Scrap, 'ZeroScrap'):
 194                         Scrap.ZeroScrap()
 195                 else:
 196                         Scrap.ClearCurrentScrap()
 197                 self.ted.WECut()
 198                 self.updatescrollbars()
 199                 self.parent.updatemenubar()
 200                 self.changed = 1
 201
 202         def menu_copy(self):
 203                 if hasattr(Scrap, 'ZeroScrap'):
 204                         Scrap.ZeroScrap()
 205                 else:
 206                         Scrap.ClearCurrentScrap()
 207                 self.ted.WECopy()
 208                 self.updatescrollbars()
 209                 self.parent.updatemenubar()
 210
 211         def menu_paste(self):
 212                 self.ted.WESelView()
 213                 self.ted.WEPaste()
 214                 self.updatescrollbars()
 215                 self.parent.updatemenubar()
 216                 self.changed = 1
 217
 218         def menu_clear(self):
 219                 self.ted.WESelView()
 220                 self.ted.WEDelete()
 221                 self.updatescrollbars()
 222                 self.parent.updatemenubar()
 223                 self.changed = 1
 224
 225         def menu_undo(self):
 226                 self.ted.WEUndo()
 227                 self.updatescrollbars()
 228                 self.parent.updatemenubar()
 229
 230         def have_selection(self):
 231                 start, stop = self.ted.WEGetSelection()
 232                 return start < stop
 233
 234         def can_paste(self):
 235                 return self.ted.WECanPaste()
 236
 237         def can_undo(self):
 238                 which, redo = self.ted.WEGetUndoInfo()
 239                 which = UNDOLABELS[which]
 240                 if which == None: return None
 241                 if redo:
 242                         return "Redo "+which
 243                 else:
 244                         return "Undo "+which
 245
 246 class Wed(Application):
 247         def __init__(self):
 248                 Application.__init__(self)
 249                 self.num = 0
 250                 self.active = None
 251                 self.updatemenubar()
 252
 253         def makeusermenus(self):
 254                 self.filemenu = m = Menu(self.menubar, "File")
 255                 self.newitem = MenuItem(m, "New window", "N", self.open)
 256                 self.openitem = MenuItem(m, "Open...", "O", self.openfile)
 257                 self.closeitem = MenuItem(m, "Close", "W", self.closewin)
 258                 m.addseparator()
 259                 self.saveitem = MenuItem(m, "Save", "S", self.save)
 260                 self.saveasitem = MenuItem(m, "Save as...", "", self.saveas)
 261                 m.addseparator()
 262                 self.quititem = MenuItem(m, "Quit", "Q", self.quit)
 263
 264                 self.editmenu = m = Menu(self.menubar, "Edit")
 265                 self.undoitem = MenuItem(m, "Undo", "Z", self.undo)
 266                 self.cutitem = MenuItem(m, "Cut", "X", self.cut)
 267                 self.copyitem = MenuItem(m, "Copy", "C", self.copy)
 268                 self.pasteitem = MenuItem(m, "Paste", "V", self.paste)
 269                 self.clearitem = MenuItem(m, "Clear", "", self.clear)
 270
 271                 # Groups of items enabled together:
 272                 self.windowgroup = [self.closeitem, self.saveitem, self.saveasitem, self.editmenu]
 273                 self.focusgroup = [self.cutitem, self.copyitem, self.clearitem]
 274                 self.windowgroup_on = -1
 275                 self.focusgroup_on = -1
 276                 self.pastegroup_on = -1
 277                 self.undo_label = "never"
 278
 279         def updatemenubar(self):
 280                 changed = 0
 281                 on = (self.active <> None)
 282                 if on <> self.windowgroup_on:
 283                         for m in self.windowgroup:
 284                                 m.enable(on)
 285                         self.windowgroup_on = on
 286                         changed = 1
 287                 if on:
 288                         # only if we have an edit menu
 289                         on = self.active.have_selection()
 290                         if on <> self.focusgroup_on:
 291                                 for m in self.focusgroup:
 292                                         m.enable(on)
 293                                 self.focusgroup_on = on
 294                                 changed = 1
 295                         on = self.active.can_paste()
 296                         if on <> self.pastegroup_on:
 297                                 self.pasteitem.enable(on)
 298                                 self.pastegroup_on = on
 299                                 changed = 1
 300                         on = self.active.can_undo()
 301                         if on <> self.undo_label:
 302                                 if on:
 303                                         self.undoitem.enable(1)
 304                                         self.undoitem.settext(on)
 305                                         self.undo_label = on
 306                                 else:
 307                                         self.undoitem.settext("Nothing to undo")
 308                                         self.undoitem.enable(0)
 309                                 changed = 1
 310                 if changed:
 311                         DrawMenuBar()
 312
 313         #
 314         # Apple menu
 315         #
 316
 317         def do_about(self, id, item, window, event):
 318                 EasyDialogs.Message("A simple single-font text editor based on WASTE")
 319
 320         #
 321         # File menu
 322         #
 323
 324         def open(self, *args):
 325                 self._open(0)
 326
 327         def openfile(self, *args):
 328                 self._open(1)
 329
 330         def _open(self, askfile):
 331                 if askfile:
 332                         fss, ok = macfs.StandardGetFile('TEXT')
 333                         if not ok:
 334                                 return
 335                         path = fss.as_pathname()
 336                         name = os.path.split(path)[-1]
 337                         try:
 338                                 fp = open(path, 'rb') # NOTE binary, we need cr as end-of-line
 339                                 data = fp.read()
 340                                 fp.close()
 341                         except IOError, arg:
 342                                 EasyDialogs.Message("IOERROR: "+`arg`)
 343                                 return
 344                 else:
 345                         path = None
 346                         name = "Untitled %d"%self.num
 347                         data = ''
 348                 w = WasteWindow(self)
 349                 w.open(path, name, data)
 350                 self.num = self.num + 1
 351
 352         def closewin(self, *args):
 353                 if self.active:
 354                         self.active.close()
 355                 else:
 356                         EasyDialogs.Message("No active window?")
 357
 358         def save(self, *args):
 359                 if self.active:
 360                         self.active.menu_save()
 361                 else:
 362                         EasyDialogs.Message("No active window?")
 363
 364         def saveas(self, *args):
 365                 if self.active:
 366                         self.active.menu_save_as()
 367                 else:
 368                         EasyDialogs.Message("No active window?")
 369
 370
 371         def quit(self, *args):
 372                 for w in self._windows.values():
 373                         w.close()
 374                 if self._windows:
 375                         return
 376                 self._quit()
 377
 378         #
 379         # Edit menu
 380         #
 381
 382         def undo(self, *args):
 383                 if self.active:
 384                         self.active.menu_undo()
 385                 else:
 386                         EasyDialogs.Message("No active window?")
 387
 388         def cut(self, *args):
 389                 if self.active:
 390                         self.active.menu_cut()
 391                 else:
 392                         EasyDialogs.Message("No active window?")
 393
 394         def copy(self, *args):
 395                 if self.active:
 396                         self.active.menu_copy()
 397                 else:
 398                         EasyDialogs.Message("No active window?")
 399
 400         def paste(self, *args):
 401                 if self.active:
 402                         self.active.menu_paste()
 403                 else:
 404                         EasyDialogs.Message("No active window?")
 405
 406         def clear(self, *args):
 407                 if self.active:
 408                         self.active.menu_clear()
 409                 else:
 410                         EasyDialogs.Message("No active window?")
 411
 412         #
 413         # Other stuff
 414         #
 415
 416         def idle(self, event):
 417                 if self.active:
 418                         self.active.do_idle(event)
 419                 else:
 420                         Qd.SetCursor(Qd.qd.arrow)
 421
 422 def main():
 423         App = Wed()
 424         App.mainloop()
 425
 426 if __name__ == '__main__':
 427         main()
 428