Example #1
0
class PulldownMenu(Frame):

    # if using indentation then should use list as stack only
    # in other words only delete or insert at end

    # entries entries must have attribute text_attr or if this is
    # None then assume that entries entries themselves provide name

    def __init__(self,
                 parent,
                 callback=None,
                 entries=None,
                 text_attr=None,
                 colors=None,
                 outline='#602000',
                 fill='#B05848',
                 label_color='#501000',
                 selected_index=-1,
                 indent='',
                 extra='',
                 sticky='w',
                 do_initial_callback=True,
                 force_callback=False,
                 *args,
                 **kw):

        if (entries is None):
            entries = []

        Frame.__init__(self, parent, sticky=sticky, *args, **kw)

        self.text_attr = text_attr

        #indentation and extra string for popup information
        self.indent = indent
        self.extra = extra

        self.callback = callback
        self.do_initial_callback = do_initial_callback
        self.force_callback = force_callback

        frame = Frame(self)
        #frame = parent
        self.frame = frame
        self.bg = frame.cget('bg')
        self.outline = outline
        self.fill = fill
        self.label_color = label_color

        self.menu = Menu(parent, tearoff=0, borderwidth=1, activeborderwidth=1)
        self.menu.images = []
        self.label = Label(self, foreground=label_color)

        self.first_pass = True
        #self.entries = entries
        self.entries = []
        self.colors = []
        self.setup(entries, selected_index, colors=colors)

        s = 10
        self.canvas = Canvas(self, width=s, height=s, background=self.bg)

        self.label.bind("<Button-1>", self.labelPopup)
        # below does not work for some reason
        #self.bind("<Button-1>", self.labelPopup)

        # below does not work any more since can have submenus and
        # no way to reach those with below since involves leaving menu
        #self.menu.bind("<Leave>", self.popdown)
        self.menu.bind("<Leave>", self.leave)
        self.menu.bind("<Button-1>", self.buttonPress)
        self.poppedUpSubmenu = False

        self.canvas.bind("<Button-1>", self.canvasPopup)
        self.canvas.bind("<Configure>", self.resizeCallback)

        self.label.grid(row=0, column=0, sticky=Tkinter.W)
        self.canvas.grid(row=0, column=1, sticky=Tkinter.E, padx=2)

    def leave(self, event):

        if (not self.poppedUpSubmenu):
            x = event.x
            y = event.y
            x1 = self.menu.winfo_width()
            y1 = self.menu.winfo_height()

            if (x < 0) or (y < 0) or (x >= x1) or (y >= y1):
                self.popdown()

    def buttonPress(self, event):

        if (event.widget != self.menu):
            return

        for n in range(len(self.entries) - 1, -1, -1):
            if event.y >= self.menu.yposition(n):
                break
        else:
            return

        item = self.entries[n]
        if (isinstance(item, {}.__class__) and item['kind'] == 'cascade'):
            self.poppedUpSubmenu = True
        else:
            self.poppedUpSubmenu = False

    def resizeCallback(self, *event):

        w = self.canvas.winfo_width() / 2
        h = self.canvas.winfo_height() / 2
        self.canvas.delete('all')
        self.canvas.create_polygon(1,
                                   1,
                                   w,
                                   2 * h - 1,
                                   2 * w - 1,
                                   1,
                                   fill=self.fill,
                                   outline=self.outline)

    def getEntry(self, entry_index, entries=None):

        if not entries:
            entries = self.entries

        if type(entry_index) == types.TupleType:
            e = entry_index[0]
            if len(entry_index) > 1:
                items = entries[e]['submenu']
                entry = self.getEntry(entry_index[1:], items)
            else:
                entry = entries[e]['label']
        elif (entry_index >= 0):
            entry = entries[entry_index]
        else:
            entry = None

        return entry

    def getEntryText(self, entry_index, entries=None):

        if not entries:
            entries = self.entries

        if type(entry_index) in (types.TupleType, types.ListType):
            e = entry_index[0]
            if len(entry_index) > 1:
                items = entries[e]['submenu']
                text = self.getEntryText(entry_index[1:], items)
            else:
                text = entries[e]['label']
        elif (entry_index != -1):
            #print 'getEntryText', entry_index, entries
            entry = entries[entry_index]
            if (self.text_attr):
                text = getattr(entry, self.text_attr)
            else:
                text = entry
        else:
            text = ''

        # TBD: for now text returned should not be unicode
        text = str(text)
        # below did not work for one person (Chinese characters??) but above did
        ###text = text.encode('utf-8')

        return text

    def setup(self, entries, selected_index, first_pass=True, colors=None):

        #print 'setup', entries, selected_index
        if first_pass is not None:
            self.first_pass = first_pass

        self.clearMenuItems()
        if (entries):
            e = list(entries)
        else:
            e = [No_entries_label]

        self.entries = e
        self.colors = colors or [None] * len(e)

        if type(selected_index) in (types.TupleType, types.ListType):
            if (not selected_index or selected_index[0] >= len(entries)):
                selected_index = -1
        else:
            if (selected_index >= len(entries)):
                selected_index = -1

        if (selected_index == -1):
            selected_index = 0

        self.selected_index = -1  # changed in setSelectedIndex()
        self.setMenuItems()
        self.setSelectedIndex(selected_index)

    def substituteCascadeCallbacks(self, item, selected_index):

        if (item['kind'] == 'cascade'):
            n = 0
            for subitem in item['submenu']:
                self.substituteCascadeCallbacks(subitem, selected_index + [n])
                n = n + 1
        else:
            callback = item.get('command')
            if (callback):
                label = item['label']
                item['command'] = lambda: self.cascadeCallback(
                    callback, label, tuple(selected_index))

    def cascadeCallback(self, callback, label, selected_index):

        self.selected_index = selected_index
        self.setLabel(selected_index)
        callback(selected_index, label)

    def setMenuItems(self):

        self.menu.images = []
        for n in range(len(self.entries)):
            columnbreak = 0
            if n and n % 20 == 0:
                columnbreak = 1
            item = self.entries[n]
            color = None
            if n < len(self.colors):
                color = self.colors[n]

            if isinstance(item, {}.__class__):
                if (item['kind'] == 'cascade'):
                    self.substituteCascadeCallbacks(item, [n])
            else:
                t = (self.indent * n) + self.extra + str(self.getEntryText(n))
                command = lambda n=n: self.setSelectedIndex(n)
                if color:
                    image = self.makeColorTile(color)
                    item = {
                        'kind': 'command',
                        'accelerator': t,
                        'command': command,
                        'image': image,
                        'columnbreak': columnbreak
                    }
                else:
                    item = {
                        'kind': 'command',
                        'label': t,
                        'command': command,
                        'columnbreak': columnbreak
                    }
            self.menu.addMenuItem(item)

    def clearMenuItems(self):

        if self.entries:
            self.menu.delete(0, len(self.entries))

    # below assumes entry_index is integer not tuple
    def insert(self, entry_index, entry, make_selected=False, color=None):

        if (self.haveNoEntries()):
            if (entry_index != 0):
                return
        elif ((entry_index < 0) or (entry_index >= len(self.entries))):
            return

        self.clearMenuItems()
        self.checkForNone()
        self.entries.insert(entry_index, entry)
        self.colors.insert(entry_index, color)
        self.setMenuItems()

        if (make_selected or (self.selected_index == -1)):
            self.setSelectedIndex(entry_index, force_callback=True)
        else:
            self.setSelectedIndex(self.selected_index)

    # below assumes entry is integer not tuple
    def append(self, entry, make_selected=False, color=None):

        self.clearMenuItems()
        self.checkForNone()
        self.entries.append(entry)
        self.colors.append(color)
        self.setMenuItems()

        if (make_selected or (self.selected_index == -1)):
            self.setSelectedIndex(len(self.entries) - 1, force_callback=True)
        else:
            self.setSelectedIndex(self.selected_index)

    def checkForNone(self):

        if (self.haveNoEntries()):
            self.entries = []
            self.colors = []
            self.menu.delete(0)

    def haveNoEntries(self):

        if (len(self.entries) == 1 and self.entries[0] == No_entries_label):
            return True
        else:
            return False

    def baseIndex(self, ind):

        if type(ind) == types.TupleType:
            ind = ind[0]

        return ind

    # below assumes entry_index is integer not tuple
    def delete(self, entry_index, n=1):

        if (self.haveNoEntries()):
            return

        if ((entry_index < 0) or (entry_index >= len(self.entries))):
            return

        self.clearMenuItems()

        n1 = entry_index
        n2 = n1 + n

        m = self.baseIndex(self.selected_index)

        del self.entries[n1:n2]
        del self.colors[n1:n2]

        if (not self.entries):
            self.entries = [No_entries_label]
            self.colors = [None]

        self.setMenuItems()

        if ((m >= n1) and (m < n2)):
            if (n1 == 0):
                selected_index = 0
            else:
                selected_index = n1 - 1
            self.setSelectedIndex(selected_index, force_callback=True)

    def replace(self, entries, selected_index=-1, colors=None):

        self.menu.delete(0, len(self.entries))
        self.setup(entries, selected_index, first_pass=False, colors=colors)

    def popdown(self, *event):

        self.menu.unpost()

    def setLabel(self, selected_index):

        text = self.getEntryText(selected_index)
        if (not text):
            text = self.extra  # arbitrary

        self.label.set(text=text)

    def labelPopup(self, event):

        self.poppedUpSubmenu = False

        s = self.baseIndex(self.selected_index)
        x = event.x_root - event.x + 2
        y = event.y_root - event.y - \
            max(0, s) * (self.label.winfo_height() + 1)
        self.menu.post(x, y)

    def canvasPopup(self, event):

        s = self.baseIndex(self.selected_index)
        x = event.x_root - event.x - self.label.winfo_width() + 2
        y = event.y_root - event.y - \
            max(0, s) * (self.label.winfo_height() + 1) + \
            self.canvas.winfo_height() - self.label.winfo_height()
        self.menu.post(x, y)

    def getSelectedIndex(self):

        return self.selected_index

    def setSelectedIndex(self, selected_index, force_callback=False):

        if (force_callback or self.force_callback or \
            (selected_index != self.selected_index)):

            #print 'setSelectedIndex', self.entries, selected_index, self.selected_index, self.first_pass
            self.selected_index = selected_index
            self.setLabel(selected_index)

            if (self.callback):
                if (self.haveNoEntries()):
                    if (not self.first_pass):
                        self.callback(-1, None)
                elif (selected_index != -1):
                    if (not self.first_pass or self.do_initial_callback):
                        self.callback(selected_index,
                                      self.entries[selected_index])

        self.first_pass = False

    def get(self):

        return self.getSelected()

    def getSelected(self):

        ind = self.getSelectedIndex()

        if (ind == -1):
            return None
        else:
            return self.getEntry(ind)

    def set(self, selected):

        self.setSelected(selected)

    def findEntryIndex(self, entry, entries=None):

        #print 'findEntryIndex1', entry, entries
        if (entries):
            noEntries = True
        else:
            noEntries = False
            entries = self.entries
            try:
                ind = entries.index(entry)
                return ind
            except:
                pass

        #print 'findEntryIndex2', entry, entries
        for n in range(len(entries)):
            e = entries[n]
            #print 'findEntryIndex3', entry, e
            if e == entry:
                if noEntries:
                    return [n]
                else:
                    return n
            elif type(e) == types.DictType:
                if (len(entries) > 1):
                    try:
                        ind = self.findEntryIndex(entry, e['submenu'])
                        return [n] + ind
                    except:
                        pass
                else:
                    if (entry == e['label']):
                        return [n]

        raise 'unknown entry "%s"' % entry

    # selects first item found in entries which matches
    def setSelected(self, selected):

        #print 'setSelected1', selected, type(selected), self.entries
        try:
            selected_index = self.findEntryIndex(selected)
        except:
            #selected_index = -1
            return

        #print 'setSelected2', selected_index
        self.setSelectedIndex(selected_index)

    def makeColorTile(self, color):

        image = Tkinter.PhotoImage()
        self.menu.images.append(image)

        if type(color) == type([]):
            colors = [scaleColor(self.menu, c, 1.0) for c in color]
        else:
            colors = [
                scaleColor(self.menu, color, 1.0),
            ]

        cols = max(8, len(colors))

        for x in range(cols):
            i = x % len(colors)
            c = colors[i]

            for y in range(16):
                image.put('{%s %s}' % (c, c), to=(2 * x, y))

        return image
Example #2
0
class PulldownList(Frame):

    # if using indentation then should use list as stack only
    # in other words only delete or insert at end

    # There is a 1:1 correspondance between the ordered lists of texts and
    # list of objects

    # categories is the category name for each text/object
    # objects with the same category will go under a submenu
    # of that name

    def __init__(self,
                 parent,
                 callback=None,
                 texts=None,
                 objects=None,
                 categories=None,
                 colors=None,
                 index=0,
                 prefix='',
                 indent='',
                 initCallback=False,
                 forceCallback=False,
                 numbering=False,
                 arrowLine='#602000',
                 arrowFill='#B05848',
                 labelColor='#501000',
                 menuBg='#F0F0FF',
                 sticky='w',
                 *args,
                 **kw):

        Frame.__init__(self, parent, sticky=sticky, *args, **kw)

        self.callback = callback
        self.texts = texts or []
        self.objects = objects or []
        self.categories = categories or []
        self.colors = colors or []
        self.prefix = prefix
        self.indent = indent
        self.initCallback = initCallback
        self.numbering = numbering
        self.arrowLine = arrowLine
        self.arrowFill = arrowFill
        self.labelColor = labelColor

        # Current selection
        self.index = None
        self.object = NullText

        self.rows = []
        self.bg = self.cget('bg')
        self.label = Label(self, foreground=labelColor)
        self.canvas = Canvas(self, width=12, height=12, background=self.bg)
        self.menu = Menu(self.canvas,
                         tearoff=False,
                         bg=menuBg,
                         relief='solid',
                         borderwidth=1,
                         activeborderwidth=1)

        self.menu.images = []  # Photoimage has to remain referenced

        self.setup(self.texts, self.objects, index, self.colors,
                   self.categories)

        self.label.bind("<Button-1>", self._labelClick)
        self.menu.bind("<Leave>", self._leave)
        self.canvas.bind("<Button-1>", self._canvasClick)
        self.canvas.bind("<Configure>", self._resizeCallback)

        self.grid_columnconfigure(0, weight=1)
        self.label.grid(row=0, column=0, sticky='w')
        self.canvas.grid(row=0, column=1, sticky='w', padx=2)

    #
    # Retrieval
    #

    def get(self):

        return (self.getText(), self.getObject())

    def getSelected(self):

        return self.get()

    def getObject(self):

        return self._fetch(self.index, self.objects)

    def getText(self):

        return self._fetch(self.index, self.texts)

    def getSelectedIndex(self):

        return self.index

    #
    # Setting selected
    #

    def set(self, item):
        # Works with an object or a text

        index = None

        if item in self.texts:
            index = list(self.texts).index(item)

        elif item in self.objects:
            index = list(self.objects).index(item)

        if index is not None:
            self.setIndex(index)

    def setSelected(self, item):

        self.set(item)

    def setIndex(self, index, doCallback=False):

        self.index = index

        if self.objects:
            obj = self.objects[index]

            if obj is not self.object:
                self.object = obj

                if (doCallback
                        or self.initCallback) and self.texts and self.callback:
                    self.callback(obj)

        self._updateLabel()

    #
    # Bulk configuration
    #

    def clear(self):

        self.setup([], [], 0)

    def setup(self, texts, objects, index, colors=None, categories=None):

        self.texts = texts
        nTexts = len(texts)

        if not objects:
            objects = texts

        while len(objects) < nTexts:
            objects.append(None)

        self.objects = objects

        if colors is None:
            self.colors = [None] * nTexts
        else:
            while len(colors) < nTexts:
                colors.append(None)
            self.colors = colors

        if categories is None:
            self.categories = [None] * nTexts

        else:
            while len(categories) < nTexts:
                categories.append(None)
            self.categories = categories

        self._setMenuItems()

        self.setIndex(index or 0)

    #
    # In-place/minor configuration
    #

    def insert(self,
               index,
               text,
               object=None,
               color=None,
               category=None,
               select=False):

        index = max(0, min(len(self.texts), index))

        self.texts.insert(index, text)
        self.objects.insert(index, object)
        self.colors.insert(index, color)
        self.categories.insert(index, category)

        self._setMenuItems()

        if select:
            self.setIndex(index)

    def append(self,
               text,
               object=None,
               color=None,
               category=None,
               select=False):

        self.insert(len(self.texts),
                    text,
                    object=None,
                    color=None,
                    category=None,
                    select=False)

    def delete(self, index, howMany=1):

        if index < 0:
            return
        elif index >= len(self.texts):
            return

        end = min(index + howMany, len(self.texts))

        self._clearMenu()

        del self.texts[index:end]
        del self.objects[index:end]
        del self.colors[index:end]
        del self.categories[index:end]

        self._setMenuItems()

        index = min(len(self.texts) - 1, self.index)

        self.setIndex(index)

    #
    # Internal methods
    #

    def _leave(self, event):

        x = event.x
        y = event.y
        x1 = self.menu.winfo_width()
        y1 = self.menu.winfo_height()

        if (x < 0) or (y < 0) or (x >= x1) or (y >= y1):
            self._popdown()

    def _resizeCallback(self, *event):

        c = self.canvas
        w = c.winfo_width() - 1
        h = c.winfo_height() - 1
        c.delete('all')
        c.create_rectangle(0,
                           0,
                           10,
                           2,
                           fill=self.arrowFill,
                           outline=self.arrowLine)
        c.create_polygon(0,
                         4,
                         0,
                         6,
                         5,
                         11,
                         10,
                         6,
                         10,
                         4,
                         fill=self.arrowFill,
                         outline=self.arrowLine)

    def _fetch(self, index, array):

        if index is None:
            return None

        if index < 0:
            index += len(array)

        if index < 0:
            return None

        elif index >= len(array):
            return None

        else:
            return array[index]

    def _setMenuItems(self):
        self._clearMenu()
        self.menu.images = []  # Clear photoimages

        if not self.texts and not self.menu.entrycget(1, 'label'):

            item = {'kind': 'command', 'label': NullText, 'command': None}
            self.menu.addMenuItem(item)
            self.rows = [0]

            return

        topList = []
        categoryDict = {}

        for i in range(len(self.texts)):
            text = self.texts[i]
            color = self.colors[i]
            category = self.categories[i]

            if category:
                if categoryDict.get(category) is None:
                    categoryDict[category] = []
                    topList.append((None, category, None, category))

                categoryDict[category].append((i, text, color))

            else:
                topList.append((i, text, color, None))

        row = 0
        for index, text, color, cat in topList:
            columnbreak = 0
            if row and row % 20 == 0:
                columnbreak = 1

            if cat:
                string = (self.indent * row) + self.prefix + text
                items = []

                rowB = 0
                for index2, text2, color2 in categoryDict.get(cat, []):
                    columnbreakB = 0
                    if rowB and rowB % 20 == 0:
                        columnbreakB = 1

                    if self.numbering:
                        number = '%d%. ' % (index2 + 1)
                    else:
                        number = ''

                    string2 = number + self.prefix + text2
                    command = lambda n=index2: self.setIndex(n, True)
                    if color2:
                        image = self._makeColorTile(color2)
                        item2 = {
                            'kind': 'command',
                            'accelerator': string2,
                            'command': command,
                            'image': image,
                            'columnbreak': columnbreakB
                        }
                    else:
                        item2 = {
                            'kind': 'command',
                            'label': string2,
                            'command': command,
                            'columnbreak': columnbreakB
                        }

                    items.append(item2)
                    self.rows.append(row)
                    rowB += 1

                item = {
                    'kind': 'cascade',
                    'label': string,
                    'submenu': items,
                    'columnbreak': columnbreak
                }

            else:

                if self.numbering:
                    number = '%d%. ' % (index + 1)
                else:
                    number = ''

                string = (self.indent * row) + number + self.prefix + text
                command = lambda n=index: self.setIndex(n, True)

                if color:
                    image = self._makeColorTile(color)
                    item = {
                        'kind': 'command',
                        'accelerator': string,
                        'command': command,
                        'image': image,
                        'columnbreak': columnbreak
                    }
                else:
                    item = {
                        'kind': 'command',
                        'label': string,
                        'command': command,
                        'columnbreak': columnbreak
                    }

            self.menu.addMenuItem(item)
            self.rows.append(row)

            row += 1

    def _clearMenu(self):

        self.menu.delete(0, 'end')
        self.index = 0
        self.rows = []

    def _popdown(self, *event):

        self.menu.unpost()

    def _labelClick(self, event):

        s = self.rows[self.index]
        #x = event.x_root - event.x + 2 + self.label.winfo_width()
        x = event.x_root - 2
        y = event.y_root - event.y - max(0,
                                         s) * (self.label.winfo_height() + 1)
        self.menu.post(x, y)

    def _canvasClick(self, event):

        s = self.rows[self.index]
        x = event.x_root - event.x + 2
        y = event.y_root - event.y - max(0,
                                         s) * (self.label.winfo_height() + 1)
        self.menu.post(x, y)

    def _updateLabel(self):

        if self.texts:
            text = self.texts[self.index] or NullText
        else:
            text = NullText

        self.label.set(text=text)

    def _makeColorTile(self, color):

        image = Tkinter.PhotoImage()
        self.menu.images.append(image)

        if type(color) == type([]):
            colors = [scaleColor(self.menu, c, 1.0) for c in color]
        else:
            colors = [
                scaleColor(self.menu, color, 1.0),
            ]

        cols = max(8, len(colors))

        for x in range(cols):
            i = x % len(colors)
            c = colors[i]

            for y in range(16):
                image.put('{%s %s}' % (c, c), to=(2 * x, y))

        return image