home *** CD-ROM | disk | FTP | other *** search
/ MacHack 2000 / MacHack 2000.toast / pc / The Hacks / MacHacksBug / Python 1.5.2c1 / Mac / Tools / IDE / Wlists.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2000-06-23  |  23.0 KB  |  535 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 1.5)
  3.  
  4. import Wbase
  5. import Wkeys
  6. import Scrap
  7. import string
  8. import Evt
  9. import Events
  10. import Qd
  11. import Win
  12. import Lists
  13.  
  14. class List(Wbase.SelectableWidget):
  15.     '''Standard list widget.'''
  16.     LDEF_ID = 0
  17.     
  18.     def __init__(self, possize, items = None, callback = None, flags = 0, cols = 1, typingcasesens = 0):
  19.         if items is None:
  20.             items = []
  21.         
  22.         self.items = items
  23.         Wbase.SelectableWidget.__init__(self, possize)
  24.         self._selected = 0
  25.         self._enabled = 1
  26.         self._list = None
  27.         self._cols = cols
  28.         self._callback = callback
  29.         self._flags = flags
  30.         self.typingcasesens = typingcasesens
  31.         self.lasttyping = ''
  32.         self.lasttime = Evt.TickCount()
  33.         self.timelimit = 30
  34.         self.setitems(items)
  35.         self.drawingmode = 0
  36.  
  37.     
  38.     def open(self):
  39.         self.setdrawingmode(0)
  40.         self.createlist()
  41.         self.setdrawingmode(1)
  42.  
  43.     
  44.     def createlist(self):
  45.         import List
  46.         self._calcbounds()
  47.         self.SetPort()
  48.         rect = self._bounds
  49.         rect = (rect[0] + 1, rect[1] + 1, rect[2] - 16, rect[3] - 1)
  50.         self._list = List.LNew(rect, (0, 0, self._cols, 0), (0, 0), self.LDEF_ID, self._parentwindow.wid, 0, 1, 0, 1)
  51.         if self.drawingmode:
  52.             self._list.LSetDrawingMode(0)
  53.         
  54.         self._list.selFlags = self._flags
  55.         self.setitems(self.items)
  56.         if hasattr(self, '_sel'):
  57.             self.setselection(self._sel)
  58.             del self._sel
  59.         
  60.  
  61.     
  62.     def adjust(self, oldbounds):
  63.         self.SetPort()
  64.         if self._selected:
  65.             Win.InvalRect(Qd.InsetRect(oldbounds, -3, -3))
  66.             Win.InvalRect(Qd.InsetRect(self._bounds, -3, -3))
  67.         else:
  68.             Win.InvalRect(oldbounds)
  69.             Win.InvalRect(self._bounds)
  70.         if oldbounds[:2] == self._bounds[:2]:
  71.             Qd.RectRgn(self._parentwindow.wid.GetWindowPort().visRgn, (0, 0, 0, 0))
  72.             (l, t, r, b) = self._bounds
  73.             width = r - l - 17
  74.             height = b - t - 2
  75.             self._list.LSize(width, height)
  76.             (l, t, r, b) = self._list.LRect((0, 0))
  77.             cellheight = b - t
  78.             self._list.LCellSize((width, cellheight))
  79.             self._parentwindow.wid.CalcVis()
  80.         else:
  81.             sel = self.getselection()
  82.             topcell = self.gettopcell()
  83.             self._list = None
  84.             self.setdrawingmode(0)
  85.             self.createlist()
  86.             self.setselection(sel)
  87.             self.settopcell(topcell)
  88.             self.setdrawingmode(1)
  89.  
  90.     
  91.     def close(self):
  92.         self._list = None
  93.         self._callback = None
  94.         self.items = []
  95.         Wbase.SelectableWidget.close(self)
  96.  
  97.     
  98.     def set(self, items):
  99.         self.setitems(items)
  100.  
  101.     
  102.     def setitems(self, items):
  103.         self.items = items
  104.         the_list = self._list
  105.         if not (self._parent) or not (self._list):
  106.             return None
  107.         
  108.         self.setdrawingmode(0)
  109.         topcell = self.gettopcell()
  110.         the_list.LDelRow(0, 1)
  111.         the_list.LAddRow(len(self.items), 0)
  112.         self_itemrepr = self.itemrepr
  113.         set_cell = the_list.LSetCell
  114.         for i in range(len(items)):
  115.             set_cell(self_itemrepr(items[i]), (0, i))
  116.         
  117.         self.settopcell(topcell)
  118.         self.setdrawingmode(1)
  119.  
  120.     
  121.     def click(self, point, modifiers):
  122.         if not (self._enabled):
  123.             return None
  124.         
  125.         isdoubleclick = self._list.LClick(point, modifiers)
  126.         if self._callback:
  127.             Wbase.CallbackCall(self._callback, 0, isdoubleclick)
  128.         
  129.         return 1
  130.  
  131.     
  132.     def key(self, char, event):
  133.         (what, message, when, where, modifiers) = event
  134.         sel = self.getselection()
  135.         newselection = []
  136.         if char == Wkeys.uparrowkey:
  137.             if len(sel) >= 1 and min(sel) > 0:
  138.                 newselection = [
  139.                     min(sel) - 1]
  140.             else:
  141.                 newselection = [
  142.                     0]
  143.         elif char == Wkeys.downarrowkey:
  144.             if len(sel) >= 1 and max(sel) < len(self.items) - 1:
  145.                 newselection = [
  146.                     max(sel) + 1]
  147.             else:
  148.                 newselection = [
  149.                     len(self.items) - 1]
  150.         else:
  151.             modifiers = 0
  152.             if self.lasttime + self.timelimit < Evt.TickCount():
  153.                 self.lasttyping = ''
  154.             
  155.             if self.typingcasesens:
  156.                 self.lasttyping = self.lasttyping + char
  157.             else:
  158.                 self.lasttyping = self.lasttyping + string.lower(char)
  159.             self.lasttime = Evt.TickCount()
  160.             i = self.findmatch(self.lasttyping)
  161.             newselection = [
  162.                 i]
  163.         if modifiers & Events.shiftKey and not (self._list.selFlags & Lists.lOnlyOne):
  164.             newselection = newselection + sel
  165.         
  166.         self.setselection(newselection)
  167.         self._list.LAutoScroll()
  168.         self.click((-1, -1), 0)
  169.  
  170.     
  171.     def findmatch(self, tag):
  172.         lower = string.lower
  173.         items = self.items
  174.         typingcasesens = self.typingcasesens
  175.         taglen = len(tag)
  176.         match = '\xff' * 100
  177.         match_i = -1
  178.         for i in range(len(items)):
  179.             item = str(items[i])
  180.             if item <= item:
  181.                 pass
  182.             elif item < match:
  183.                 match = item
  184.                 match_i = i
  185.             
  186.         
  187.         if match_i >= 0:
  188.             return match_i
  189.         else:
  190.             return len(items) - 1
  191.  
  192.     
  193.     def domenu_copy(self, *args):
  194.         sel = self.getselection()
  195.         selitems = []
  196.         for i in sel:
  197.             selitems.append(str(self.items[i]))
  198.         
  199.         text = string.join(selitems, '\r')
  200.  
  201.     
  202.     def can_copy(self, *args):
  203.         return len(self.getselection()) != 0
  204.  
  205.     
  206.     def domenu_selectall(self, *args):
  207.         self.selectall()
  208.  
  209.     
  210.     def can_selectall(self, *args):
  211.         return not (self._list.selFlags & Lists.lOnlyOne)
  212.  
  213.     
  214.     def selectall(self):
  215.         if not (self._list.selFlags & Lists.lOnlyOne):
  216.             self.setselection(range(len(self.items)))
  217.             self._list.LAutoScroll()
  218.             self.click((-1, -1), 0)
  219.         
  220.  
  221.     
  222.     def getselection(self):
  223.         if not (self._parent) or not (self._list):
  224.             if hasattr(self, '_sel'):
  225.                 return self._sel
  226.             
  227.             return []
  228.         
  229.         items = []
  230.         point = (0, 0)
  231.         while 1:
  232.             (ok, point) = self._list.LGetSelect(1, point)
  233.             if not ok:
  234.                 break
  235.             
  236.             items.append(point[1])
  237.             point = (point[0], point[1] + 1)
  238.         return items
  239.  
  240.     
  241.     def setselection(self, selection):
  242.         if not (self._parent) or not (self._list):
  243.             self._sel = selection
  244.             return None
  245.         
  246.         set_sel = self._list.LSetSelect
  247.         for i in range(len(self.items)):
  248.             pass
  249.         
  250.         self._list.LAutoScroll()
  251.  
  252.     
  253.     def getselectedobjects(self):
  254.         sel = self.getselection()
  255.         objects = []
  256.         for i in sel:
  257.             objects.append(self.items[i])
  258.         
  259.         return objects
  260.  
  261.     
  262.     def setselectedobjects(self, objects):
  263.         sel = []
  264.         for o in objects:
  265.             
  266.             try:
  267.                 sel.append(self.items.index(o))
  268.             except:
  269.                 0
  270.                 objects
  271.  
  272.         
  273.         self.setselection(sel)
  274.  
  275.     
  276.     def gettopcell(self):
  277.         (l, t, r, b) = self._bounds
  278.         t = t + 1
  279.         (cl, ct, cr, cb) = self._list.LRect((0, 0))
  280.         cellheight = cb - ct
  281.         return (t - ct) / cellheight
  282.  
  283.     
  284.     def settopcell(self, topcell):
  285.         top = self.gettopcell()
  286.         diff = topcell - top
  287.         self._list.LScroll(0, diff)
  288.  
  289.     
  290.     def draw(self, visRgn = None):
  291.         if self._visible:
  292.             if not visRgn:
  293.                 visRgn = self._parentwindow.wid.GetWindowPort().visRgn
  294.             
  295.             self._list.LUpdate(visRgn)
  296.             Qd.FrameRect(self._bounds)
  297.             if self._selected and self._activated:
  298.                 self.drawselframe(1)
  299.             
  300.         
  301.  
  302.     
  303.     def select(self, onoff, isclick = 0):
  304.         if Wbase.SelectableWidget.select(self, onoff):
  305.             return None
  306.         
  307.         self.SetPort()
  308.         self.drawselframe(onoff)
  309.  
  310.     
  311.     def activate(self, onoff):
  312.         self._activated = onoff
  313.         if self._visible:
  314.             self._list.LActivate(onoff)
  315.             if self._selected:
  316.                 self.drawselframe(onoff)
  317.             
  318.         
  319.  
  320.     
  321.     def get(self):
  322.         return self.items
  323.  
  324.     
  325.     def itemrepr(self, item):
  326.         return str(item)[:255]
  327.  
  328.     
  329.     def __getitem__(self, index):
  330.         return self.items[index]
  331.  
  332.     
  333.     def __setitem__(self, index, item):
  334.         if self._parent and self._list:
  335.             self._list.LSetCell(self.itemrepr(item), (0, index))
  336.         
  337.         self.items[index] = item
  338.  
  339.     
  340.     def __delitem__(self, index):
  341.         if self._parent and self._list:
  342.             self._list.LDelRow(1, index)
  343.         
  344.         del self.items[index]
  345.  
  346.     
  347.     def __getslice__(self, a, b):
  348.         return self.items[a:b]
  349.  
  350.     
  351.     def __delslice__(self, a, b):
  352.         if b - a:
  353.             if self._parent and self._list:
  354.                 self._list.LDelRow(b - a, a)
  355.             
  356.             del self.items[a:b]
  357.         
  358.  
  359.     
  360.     def __setslice__(self, a, b, items):
  361.         pass
  362.  
  363.     
  364.     def __len__(self):
  365.         return len(self.items)
  366.  
  367.     
  368.     def append(self, item):
  369.         if self._parent and self._list:
  370.             index = len(self.items)
  371.             self._list.LAddRow(1, index)
  372.             self._list.LSetCell(self.itemrepr(item), (0, index))
  373.         
  374.         self.items.append(item)
  375.  
  376.     
  377.     def remove(self, item):
  378.         index = self.items.index(item)
  379.         self.__delitem__(index)
  380.  
  381.     
  382.     def index(self, item):
  383.         return self.items.index(item)
  384.  
  385.     
  386.     def insert(self, index, item):
  387.         if index < 0:
  388.             index = 0
  389.         
  390.         if self._parent and self._list:
  391.             self._list.LAddRow(1, index)
  392.             self._list.LSetCell(self.itemrepr(item), (0, index))
  393.         
  394.         self.items.insert(index, item)
  395.  
  396.     
  397.     def setdrawingmode(self, onoff):
  398.         if onoff:
  399.             self.drawingmode = self.drawingmode - 1
  400.             if self.drawingmode == 0 and self._list is not None:
  401.                 self._list.LSetDrawingMode(1)
  402.                 if self._visible:
  403.                     bounds = (l, t, r, b) = Qd.InsetRect(self._bounds, 1, 1)
  404.                     (cl, ct, cr, cb) = self._list.LRect((0, len(self.items) - 1))
  405.                     if cb < b:
  406.                         self.SetPort()
  407.                         Qd.EraseRect((l, cb, cr, b))
  408.                     
  409.                     self._list.LUpdate(self._parentwindow.wid.GetWindowPort().visRgn)
  410.                     Win.ValidRect(bounds)
  411.                 
  412.             
  413.         elif self.drawingmode == 0 and self._list is not None:
  414.             self._list.LSetDrawingMode(0)
  415.         
  416.         self.drawingmode = self.drawingmode + 1
  417.  
  418.  
  419.  
  420. class TwoLineList(List):
  421.     LDEF_ID = 468
  422.     
  423.     def createlist(self):
  424.         import List
  425.         self._calcbounds()
  426.         self.SetPort()
  427.         rect = self._bounds
  428.         rect = (rect[0] + 1, rect[1] + 1, rect[2] - 16, rect[3] - 1)
  429.         self._list = List.LNew(rect, (0, 0, 1, 0), (0, 28), self.LDEF_ID, self._parentwindow.wid, 0, 1, 0, 1)
  430.         self.set(self.items)
  431.  
  432.  
  433.  
  434. class ResultsWindow:
  435.     """Simple results window. The user cannot make this window go away completely:
  436. \tclosing it will just hide it. It will remain in the windows list. The owner of this window
  437. \tshould call the done() method to indicate it's done with it.
  438. \t"""
  439.     
  440.     def __init__(self, possize = None, title = 'Results', callback = None):
  441.         import W
  442.         if possize is None:
  443.             possize = (500, 200)
  444.         
  445.         self.w = W.Window(possize, title, minsize = (200, 100))
  446.         self.w.results = W.TwoLineList((-1, -1, 1, -14), callback = None)
  447.         self.w.bind('<close>', self.hide)
  448.         self.w.open()
  449.         self._done = 0
  450.  
  451.     
  452.     def done(self):
  453.         self._done = 1
  454.         if not self.w.isvisible():
  455.             self.w.close()
  456.         
  457.  
  458.     
  459.     def hide(self):
  460.         if not (self._done):
  461.             self.w.show(0)
  462.             return -1
  463.         
  464.  
  465.     
  466.     def append(self, msg):
  467.         if not self.w.isvisible():
  468.             self.w.show(1)
  469.             self.w.select()
  470.         
  471.         msg = string.replace(msg, '\n', '\r')
  472.         self.w.results.append(msg)
  473.         self.w.results.setselection([
  474.             len(self.w.results) - 1])
  475.  
  476.     
  477.     def __getattr__(self, attr):
  478.         return getattr(self.w.results, attr)
  479.  
  480.  
  481.  
  482. class MultiList(List):
  483.     '''XXX Experimantal!!!'''
  484.     
  485.     def setitems(self, items):
  486.         self.items = items
  487.         if not (self._parent) or not (self._list):
  488.             return None
  489.         
  490.         self._list.LDelRow(0, 1)
  491.         self.setdrawingmode(0)
  492.         self._list.LAddRow(len(self.items), 0)
  493.         self_itemrepr = self.itemrepr
  494.         set_cell = self._list.LSetCell
  495.         for i in range(len(items)):
  496.             row = items[i]
  497.             for j in range(len(row)):
  498.                 item = row[j]
  499.                 set_cell(self_itemrepr(item), (j, i))
  500.             
  501.         
  502.         self.setdrawingmode(1)
  503.  
  504.     
  505.     def getselection(self):
  506.         if not (self._parent) or not (self._list):
  507.             if hasattr(self, '_sel'):
  508.                 return self._sel
  509.             
  510.             return []
  511.         
  512.         items = []
  513.         point = (0, 0)
  514.         while 1:
  515.             (ok, point) = self._list.LGetSelect(1, point)
  516.             if not ok:
  517.                 break
  518.             
  519.             items.append(point[1])
  520.             point = (point[0], point[1] + 1)
  521.         return items
  522.  
  523.     
  524.     def setselection(self, selection):
  525.         if not (self._parent) or not (self._list):
  526.             self._sel = selection
  527.             return None
  528.         
  529.         set_sel = self._list.LSetSelect
  530.         for i in range(len(self.items)):
  531.             pass
  532.         
  533.  
  534.  
  535.