Merge lp:~codeforger/simplegc/SelectableList into lp:simplegc

[Michael Rochester]

Adds a multiselectable list.

Unmerged revisions

357. By Michael Rochester on 2013-05-30

cleaned the branch and made all the requested tweaks.

=== modified file 'sgc/__init__.py'
--- sgc/__init__.py	2013-03-23 16:16:35 +0000
+++ sgc/__init__.py	2013-05-30 17:30:38 +0000
@@ -31,6 +31,7 @@
 from widgets.fps_counter import FPSCounter
 from widgets.input_box import InputBox
 from widgets.label import Label
+from widgets.list import List
 from widgets.radio_button import Radio
 from widgets.scroll_box import ScrollBox
 from widgets.settings import Keys

=== added file 'sgc/widgets/list.py'
--- sgc/widgets/list.py	1970-01-01 00:00:00 +0000
+++ sgc/widgets/list.py	2013-05-30 17:30:38 +0000
@@ -0,0 +1,518 @@
+# Copyright 2010-2012 the SGC project developers.
+# See the LICENSE file at the top-level directory of this distribution
+# and at http://program.sambull.org/sgc/license.html.
+
+"""
+Selectable List. A container widget that provides a multiselectable list.
+
+"""
+
+import sgc
+from sgc.locals import *
+
+import pygame.mouse
+from pygame.locals import *
+from pygame import draw
+
+from _locals import *
+from base_widget import Simple
+
+
+class List(Simple):
+
+    """
+    List
+
+    A multicolumn list of text that can be multiselectable.
+    """
+
+    _can_focus = True
+    _settings_default = {"col": (10, 10, 10),
+                         "font": Font["widget"],
+                         "padding": 3,
+                         "offset": 0,
+                         "mult": False,
+                         "colwidth": [100],
+                         "headfont": Font["widget"],
+                         "header": False}
+
+    _strings = pygame.cursors.sizer_x_strings
+    _cursor = pygame.cursors.compile(_strings)
+    _size = (len(_strings[0]), len(_strings))
+    _hotspot = (_size[0] / 2, _size[1] / 2)
+    _cursor = (_size, _hotspot) + _cursor
+
+    _cursor_set = False
+
+    _move = False # Contains the index of the column being
+                       # resized.
+    _mouse = False # Contains mouse position of last event.
+
+    _resize = False # True if widget is resizing column.
+
+
+    _focused = False # True if element has focus (draws dotted
+                          # line)
+    _focus = 0 # Currently focused element (draws dotted line)
+
+    _sort_column = False # Index of column that is currently sorted
+    _sort_state = None # "top", "bottom" or none to denote current
+                           # sort direction.
+
+    _lastclick = [[0, 0]] # stores the index of the last clicked
+                               # item and the time it was clicked, used
+                               # to check for double clicks.
+
+    def _config(self, **kwargs):
+        """
+          colwidth: A sequence of ints that describes the width of each
+                       column.
+          multi_selection: ``bool`` Enable the ability to select more
+                         than one record at once.
+          col: ``tuple`` (r,g,b) Text colour.
+          font: Font object the label will render with.
+          padding: ``int`` Vertical padding on list elements.
+          content: The content to be displayed in the list. A sequence
+              containing each row. Multi-column list will be another sequence
+              for each row.
+              For example: (("row0col0", "row0col1"), ("row1-0", "row1-1"))
+          header: The header text of each column, nust be a seqauence of
+                  strings.
+          headfont: The font to be used for the header.
+        """
+
+        if "multi_selection" in kwargs:
+            self._settings["mult"] = kwargs["multi_selection"]
+        if "padding" in kwargs:
+            self._settings["padding"] = kwargs["padding"]
+        if "init" in kwargs:
+            self._lbls = [] # List of Label widgets that make up the content.
+            self._selected = [] # Currently selected items
+
+        if "content" in kwargs:
+
+            self._columns = []
+            self._content = list(kwargs["content"])
+            if not isinstance(self._content[0], list):
+                for i, x in enumerate(self._content):
+                    self._content[i] = [x]
+        if "col" in kwargs:
+            self._settings["col"] = kwargs["col"]
+        if "font" in kwargs:
+            self._settings["font"] = kwargs["font"]
+        if "colwidth" in kwargs:
+            self._settings["colwidth"] = [c for c in kwargs["colwidth"]]
+        elif self._settings["colwidth"][0] == 100:
+            l = len(self._content[0])
+            self._settings["colwidth"] = [100 for c in range(l)]
+        self.colpos = [0]
+        for x in range(len(self._settings["colwidth"])):
+            self.colpos.append((self.colpos[x] +
+                                self._settings["colwidth"][x]))
+        if "headfont" in kwargs:
+            self._setting["headfont"] = kwargs["headfont"]
+        if "header" in kwargs:
+            self._settings["header"] = kwargs["header"]
+            font_height = self._settings["headfont"].get_ascent() +\
+                          self._settings["headfont"].get_descent() + 6
+            self._settings["offset"] = font_height
+        if "content" in kwargs:
+            #    not isinstance(list,self._content[0])) or\
+            #    len(self._content[0] == 1:
+            self._texth = self._settings["font"].get_ascent() + \
+                         self._settings["font"].get_descent() + \
+                         (self._settings["padding"] * 2)
+            w = []
+            self._contain = None
+            for x in (range(len(self._content[0]))):
+                labels = []
+                p = 0
+                for y in range(len(self._content)):
+                    lbl = sgc.Label(pos=(0, p), col=self._settings["col"],
+                                    text=self._content[y][x],
+                                    font=self._settings["font"])
+                    p += self._texth
+                    lbl._parent = self._contain
+                    labels.append(lbl)
+                    w.append(lbl)
+                self._lbls.append(labels)
+                if self._settings["colwidth"]:
+                    column = sgc.Container((self._settings["colwidth"][x] -
+                                                self._settings["padding"] * 2,
+                                            len(self._content) * self._texth),
+                                            widgets=labels)
+                else:
+                    column = sgc.Container(widgets=labels)
+                self._columns.append(column)
+
+            self._contain = sgc.HBox(border=self._settings["padding"],
+                                    widgets=self._columns)
+            self._contain._parent = self
+            if not hasattr(self, "image"):
+                self._create_base_images((self._contain.image.get_width(),
+                                          self._contain.image.get_height()))
+            self._scroll = sgc.ScrollBox((self.rect.w,
+                                         self.rect.h -
+                                            self._settings["offset"]),
+                                         pos=(0, self._settings["offset"]),
+                                         widget=self._contain)
+            self._contain._parent = self._scroll
+            self._scroll._parent = self
+            self._anchor = False
+
+    def _draw_final(self):
+        if self._settings["header"]:
+            self._header = sgc.Simple((self.colpos[-1] + 10,
+                                      self._settings["offset"]))
+            for p, header in enumerate(self._settings["header"]):
+                lbl = sgc.Label((self._settings["colwidth"][p],
+                                 self._settings["offset"]),
+                                 pos=(0, 0),
+                                 text=header,
+                                 col=(10, 10, 10),
+                                 font=self._settings["headfont"])
+                draw.rect(self._header.image, (255, 255, 255),
+                          ((self.colpos[p], 0),
+                          (self.colpos[p] + self._settings["colwidth"][p],
+                          self._settings["offset"])), 0)
+                self._header.image.blit(lbl.image, (self.colpos[p] + 3, 1))
+                draw.line(self._header.image, (150, 150, 150),
+                          (self.colpos[p], 0),
+                          (self.colpos[p], self._settings["offset"]))
+
+        draw.line(self._images["image"], (150, 150, 150),
+                  (1, 0), (self.image.get_width()-2, 0))
+        draw.line(self._images["image"], (150, 150, 150),
+                  (1, self.image.get_height() - 1),
+                  (self.image.get_width() - 2, self.image.get_height() - 1))
+        draw.line(self._images["image"], (150, 150, 150),
+                  (0, 1), (0, self.image.get_height() - 2))
+        draw.line(self._images["image"], (150, 150, 150),
+                  (self.image.get_width() - 1, 1),
+                  (self.image.get_width() - 1, self.image.get_height() - 2))
+        if self._sort_state != None:
+            if self._sort_state == "top":
+                draw.line(self._header.image, (150, 150, 150),
+                          (self.colpos[self._sort_column + 1] - 15, 3),
+                          (self.colpos[self._sort_column + 1] - 10,
+                           self._settings["offset"] - 3))
+                draw.line(self._header.image, (150, 150, 150),
+                          (self.colpos[self._sort_column + 1] - 5, 3),
+                          (self.colpos[self._sort_column + 1] - 10,
+                           self._settings["offset"] - 3))
+            else:
+                draw.line(self._header.image, (150, 150, 150),
+                          (self.colpos[self._sort_column + 1] - 15,
+                           self._settings["offset"] - 3),
+                          (self.colpos[self._sort_column + 1] - 10, 3))
+                draw.line(self._header.image, (150, 150, 150),
+                          (self.colpos[self._sort_column + 1] - 5,
+                           self._settings["offset"] - 3),
+                          (self.colpos[self._sort_column + 1] - 10, 3))
+
+    def update(self, time):
+        self.image.fill((255, 255, 255))
+        self._scroll.update(time)
+
+        w = (self.image.get_width())
+        for sel in self._selected:
+            selection = Simple((w, self._texth))
+            selection.pos = (0, (sel - 1) * self._texth +
+                                self._settings["padding"] +
+                                self._settings["offset"] +
+                                self._contain.rect.y)
+            selection.image.fill(self._settings["col"])
+            selection.image.set_alpha(100)
+            self.image.blit(selection.image, selection.pos)
+        if self._focused:
+            focus = Simple((w, self._texth))
+            focus.pos = (0, (self._focus - 1) * self._texth +
+                            self._settings["padding"] +
+                            self._settings["offset"] +
+                            self._contain.rect.y)
+            focus.image.fill(Color(255, 255, 0))
+            focus.image.set_colorkey(Color(255, 255, 0))
+            self._dotted_rect(focus.image)
+            self.image.blit(focus.image, focus.pos)
+
+        self.image.blit(self._scroll.image, (0, self._settings["offset"]))
+        if self._settings["header"]:
+            self.image.blit(self._header.image,
+                            (self._scroll._settings["widget"].pos[0], 0))
+
+    def _event(self, event):
+        if event.type == MOUSEBUTTONDOWN and event.button == 1:
+            if (self._collide_resize(event.pos) is not False):
+                self._move = self._collide_resize(event.pos)
+                self._mouse = event.pos[0]
+            elif self._collide_head(event.pos) is not False:
+                old_sort_col = self._sort_column
+                self._sort_column = self._collide_head(event.pos)
+                if old_sort_col != self._sort_column:
+                    self._sort_state = None
+                if self._sort_state == None:
+                    self._sort_state = "top"
+                    self.orr_content = list(self._content)
+                    self._content.sort(key=lambda data: data[self._sort_column])
+                elif self._sort_state == "top":
+                    self._sort_state = "bottom"
+                    self._content.reverse()
+                else:
+                    self._sort_state = None
+                    self._content = self.orr_content
+                self.config(content=self._content)
+                self._scroll = sgc.ScrollBox((self.rect.w,
+                                             self.rect.h -
+                                                self._settings["offset"]),
+                                             pos=(0, self._settings["offset"]),
+                                             widget=self._contain)
+                self._scroll._parent = self
+                self._draw_final()
+            else:
+                sel = self._colide_item(event.pos)
+                self._lastclick = [self._lastclick[-1],
+                                   [sel, pygame.time.get_ticks()]]
+
+                if sel > 0 and sel < len(self._content) + 1:
+                    if (self._lastclick[0][0] == self._lastclick[1][0] and
+                       (self._lastclick[1][1] - self._lastclick[0][1]) < 500):
+                        self.on_confirm()
+                    else:
+                        if (pygame.key.get_mods() & KMOD_CTRL and
+                            self._settings["mult"]):
+                            if sel in self._selected:
+                                self._selected.remove(sel)
+                            else:
+                                self._selected.append(sel)
+                        elif (pygame.key.get_mods() & KMOD_SHIFT
+                              and self._settings["mult"] and self._anchor):
+                            self._selected = []
+                            for new in range(abs(self._anchor - sel) + 1):
+                                lowest_selected = min(self._anchor, sel)
+                                self._selected.append(new + lowest_selected)
+                        else:
+                            self._anchor = sel
+                            self._selected = [sel]
+                        self._focus = sel
+                        self._focused = False
+                        self.on_select()
+                self._scroll._event(event)
+        elif event.type == MOUSEBUTTONUP:
+            if self._resize is not False and self._mouse is not False:
+                self._scroll = sgc.ScrollBox((self.rect.w,
+                                             self.rect.h -
+                                                self._settings["offset"]),
+                                             pos=(0, self._settings["offset"]),
+                                             widget=self._contain)
+                self._scroll._parent = self
+            self._mouse = False
+            self._resize = False
+            self._scroll._event(event)
+        elif event.type == MOUSEMOTION:
+            if self._collide_resize(event.pos) is False and\
+               self._cursor_set == True:
+                self._remove_cursor()
+                self._cursor_set = False
+            elif self._collide_resize(event.pos) is not False and\
+                 self._cursor_set == False:
+                self._set_cursor(*List._cursor)
+                self._cursor_set = True
+            if self._resize is not False and self._mouse is not False:
+                dif = event.pos[0] - self._mouse
+                self._mouse = event.pos[0]
+                self._settings["colwidth"][self._move] += dif
+                if self._settings["colwidth"][self._move] < 0:
+                    self._settings["colwidth"][self._move] = 0
+                self.config(columnwidth=self._settings["colwidth"],
+                            content=self._content)
+                self._contain._create_base_images((self._contain.rect.w,
+                                                  self._contain.rect.h))
+            elif self._mouse is not False:
+                if abs(event.pos[0] - self._mouse) > 4:
+                    self._resize = True
+            self._scroll._event(event)
+        else:
+            self._scroll._event(event)
+        if event.type == KEYDOWN:
+            if event.key == K_SPACE or event.key == K_RETURN:
+                if pygame.key.get_mods() & KMOD_CTRL:
+                    if self._focused:
+                        if self._focus not in self._selected:
+                            self._selected.append(self._focus)
+                        else:
+                            self._selected.remove(self._focus)
+                        self.on_select()
+                else:
+                    self.on_confirm()
+
+            if event.key == K_UP:
+                if (pygame.key.get_mods() & KMOD_SHIFT
+                  and self._settings["mult"] and self._anchor):
+                    selrange = [min(self._selected), max(self._selected)]
+                    if selrange[1] == self._anchor and selrange[0] != 1:
+                        selrange[0] -= 1
+                    elif selrange[0] != selrange[1] and\
+                         selrange[1] != self._anchor:
+                        selrange[1] -= 1
+                    self._selected = []
+                    for x in range(selrange[0], selrange[1] + 1):
+                        self._selected.append(x)
+                    self.on_select()
+                elif pygame.key.get_mods() & KMOD_CTRL:
+                    if self._focus != 1:
+                        self._focus -= 1
+                    self._focused = True
+                else:
+                    if self._anchor != 1:
+                        self._selected = [self._anchor - 1]
+                    else:
+                        self._selected = [1]
+                    self._anchor = self._selected[0]
+                    self.on_select()
+
+            elif event.key == K_DOWN:
+                if (pygame.key.get_mods() & KMOD_SHIFT and\
+                   self._settings["mult"] and self._anchor):
+                    selrange = [min(self._selected), max(self._selected)]
+                    if selrange[0] == self._anchor and\
+                       selrange[1] != len(self._content):
+                        selrange[1] += 1
+                    elif selrange[1] != selrange[0] and\
+                         selrange[0] != self._anchor:
+                        selrange[0] += 1
+                    self._selected = []
+                    for x in range(selrange[0], selrange[1] + 1):
+                        self._selected.append(x)
+                    self.on_select()
+                elif pygame.key.get_mods() & KMOD_CTRL:
+                    if self._focus != len(self._content):
+                        self._focus += 1
+                    self._focused = True
+                else:
+                    if self._anchor != len(self._content):
+                        self._selected = [self._anchor + 1]
+                    self._anchor = self._selected[0]
+                    self.on_select()
+            elif event.key == K_HOME:
+                self._selected = [1]
+                self._anchor = self._selected[0]
+                self.on_select()
+            elif event.key == K_END:
+                self._selected = [len(self._content)]
+                self._anchor = self._selected[0]
+                self.on_select()
+            elif event.key == K_PAGEUP:
+                self._selected = [self._selected[0] -
+                                 (self.rect.bottom / self._texth - 3)]
+                if self._selected[0] < 1:
+                    self._selected = [1]
+                self._anchor = self._selected[0]
+                self.on_select()
+            elif event.key == K_PAGEDOWN:
+                self._selected = [self._selected[0] +
+                                 self.rect.bottom / self._texth - 3]
+                if self._selected[0] > len(self._content):
+                    self._selected = [len(self._content)]
+                self._anchor = self._selected[0]
+                self.on_select()
+            elif event.key == K_BACKSLASH and\
+                 pygame.key.get_mods() & KMOD_CTRL:
+                self._anchor = 1
+                self._selected = []
+                self.on_select()
+
+    def _collide_resize(self, pos):
+        for p, x in enumerate(self.colpos[1:], 1):
+            if isinstance(x, list):
+                x = x[0]
+            if (pos[0] - self.pos_abs[0] >=
+                    self._scroll._settings["widget"].pos[0] + x - 2 and
+                pos[0] - self.pos_abs[0] <=
+                    self._scroll._settings["widget"].pos[0] + x + 2 and
+                pos[1] < self.pos_abs[1] + self._settings["offset"] and
+                pos[1] > self.pos_abs[1]):
+                return p - 1
+        return False
+
+    def _collide_head(self, pos):
+        for p, x in enumerate(self.colpos[1:], 1):
+            if isinstance(x, list):
+                x = x[0]
+            if (pos[0] - self.pos_abs[0] <=
+                    self._scroll._settings["widget"].pos[0] + x and
+                pos[1] < self.pos_abs[1] + self._settings["offset"] and
+                pos[1] > self.pos_abs[1]):
+                return p - 1
+        return False
+
+    def _dotted_rect(self, image, col=(0, 0, 0)):
+        image.lock()
+        for i in range(0, self.rect.w, 3):
+            # Draw horizontal lines
+            image.set_at((i, 0), col)
+            image.set_at((i, self._texth - 1), col)
+        for i in range(0, self._texth, 2):
+            # Draw vertical lines
+            image.set_at((0, i), col)
+            image.set_at((self.rect.w - 1, i), col)
+        image.unlock()
+
+    def _colide_item(self, pos):
+        if isinstance(self._lbls[0], list):
+            for i, x in enumerate(self._lbls[0]):
+                if(pos[1] < x.rect_abs.bottom):
+                    return i + 1
+            return -1
+        else:
+            for i, x in enumerate(self._lbls):
+                if(pos[1] < x.rect_abs.bottom):
+                    return i + 1
+            return -1
+
+    def on_select(self):
+        """
+        Called when the selection is changed. Even when the new selection is
+        the same as the old one.
+
+        Emits an event with attribute 'gui_type' == "select".
+
+        Override this function to use as a callback handler.
+
+        """
+        pygame.event.post(self._create_event("select"))
+
+    def on_confirm(self):
+        """
+        Called when an item is double clicked, or the enter key is pressed with
+        a selection.
+
+        Emits an event with attribute 'gui_type' == "confirm".
+
+        Override this function to use as a callback handler.
+
+        """
+        pygame.event.post(self._create_event("confirm"))
+
+    def _focus_enter(self, focus):
+        """Draw rectangle when focus is gained from keyboard."""
+        self._scroll._focus_enter(focus)
+
+    def _focus_exit(self):
+        """Stop drawing rectangle when focus is lost."""
+        self._scroll._focus_exit()
+
+    @property
+    def selected_text(self):
+        """
+            A property function that will return a list of strings from the
+            selected rows.
+        """
+        return [self._content[x-1] for x in self._selected]
+
+    @property
+    def selected_pos(self):
+        """
+            A property function that will retrun a list of the indexes of the
+            selected rows.
+        """
+        return [x-1 for x in self._selected]