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

[Michael Rochester]

I have added a TabController widget that allows the creation of a tab container where each tab has a title and a singe child widget.

Unmerged revisions

357. By Michael Rochester on 2014-05-17

Created the TabController widget

356. By Sam Bull on 2014-04-20

Add ProgressBar widget.

=== modified file 'docs/conf.py'
--- docs/conf.py	2013-03-23 16:16:35 +0000
+++ docs/conf.py	2014-05-17 14:54:22 +0000
@@ -12,6 +12,7 @@
 # serve to show the default.
 
 import sys, os
+sys.path.insert(0, "..")
 
 # Initalise pygame for sgc to function properly
 import pygame

=== modified file 'docs/sgc.widgets.rst'
--- docs/sgc.widgets.rst	2013-03-22 17:46:43 +0000
+++ docs/sgc.widgets.rst	2014-05-17 14:54:22 +0000
@@ -116,6 +116,19 @@
 
         .. automethod:: config
 
+:mod:`progress` Module
+--------------------------
+
+.. automodule:: sgc.widgets.progress
+
+    .. autoclass:: sgc.widgets.progress.ProgressBar
+        :members:
+        :undoc-members:
+        :show-inheritance:
+        :exclude-members: update, groups, selected
+
+        .. automethod:: config
+
 :mod:`radio_button` Module
 --------------------------
 

=== modified file 'example/test.py'
--- example/test.py	2013-03-22 17:46:43 +0000
+++ example/test.py	2014-05-17 14:54:22 +0000
@@ -63,6 +63,10 @@
 input_box = sgc.InputBox(label="Input Box", default="default text...")
 input_box.config(pos=(30,120))
 input_box.add(order=0)
+# Create progress bar
+progress_bar = sgc.ProgressBar()
+progress_bar.config(pos=(400,120))
+progress_bar.add()
 # Change colour button, on_click event caught in event loop
 button = sgc.Button(label="Change\ncolour", pos=(40,200))
 # Create FPS counter
@@ -129,6 +133,8 @@
 label.rect.midtop = title.rect.midbottom
 label.add()
 
+progress_fraction = 0.
+
 while True:
     time = clock.tick(30)
     for event in pygame.event.get():
@@ -139,6 +145,7 @@
                 print "Button event"
             if event.widget is button and event.gui_type == "click":
                 button.config(col=[random.randrange(1,200) for x in range(3)])
+                progress_fraction = 0. if progress_fraction is False else False
             elif event.widget is input_box:
                 clear()
         elif event.type == KEYDOWN:
@@ -147,6 +154,12 @@
         elif event.type == QUIT:
             exit()
 
+    if progress_fraction is not False:
+        progress_fraction = (progress_fraction + .02) % 1
+        progress_bar.set_fraction(progress_fraction)
+    else:
+        progress_bar.pulse()
+
     # Cleanup removed windows
     for widget in dialogs:
         if not widget.active():

=== modified file 'sgc/__init__.py'
--- sgc/__init__.py	2013-03-23 16:16:35 +0000
+++ sgc/__init__.py	2014-05-17 14:54:22 +0000
@@ -31,11 +31,13 @@
 from widgets.fps_counter import FPSCounter
 from widgets.input_box import InputBox
 from widgets.label import Label
+from widgets.progress import ProgressBar
 from widgets.radio_button import Radio
 from widgets.scroll_box import ScrollBox
 from widgets.settings import Keys
 from widgets.scale import Scale
 from widgets.switch import Switch
+from widgets.tab_controller import TabController
 
 # Import Menu last, so it can import the other widgets from here.
 from widgets.menu import Menu

=== added file 'sgc/widgets/progress.py'
--- sgc/widgets/progress.py	1970-01-01 00:00:00 +0000
+++ sgc/widgets/progress.py	2014-05-17 14:54:22 +0000
@@ -0,0 +1,168 @@
+# Copyright 2013 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.
+
+"""
+Progress Bar widget. Indicates progress to the user with either a progress
+estimate or activity throbber.
+
+"""
+
+import pygame
+from pygame.locals import *
+from pygame import draw
+
+from _locals import *
+from base_widget import Simple
+
+
+class ProgressBar(Simple):
+    """
+    A Progress Bar.
+
+    Images:
+      'image': The background of the bar.
+      'bar': The image to be used for the percent bar
+          (bar will be cropped, not stretched).
+      'throbber': The image used for the 'activity' throbber.
+      'overlay': This image will always be displayed on top of the widget
+          regardless of mode, it is by default blank, however passing the
+          keyword 'text' to the config function will draw this text onto this
+          surface.
+    """
+
+    _default_size = (100, 20)
+    _extra_images = {"bar": ((1, -4), (1, -4)),
+                     "throbber": ((.2, -6), (1, -6)),
+                     "overlay": ((1, 0), (1, 0))}
+    _settings_default = {"col": (118, 45, 215), "font": Font["widget"],
+                         "text": "", "text_col": (10, 10, 10), "total_time": 1.,
+                         "pulse_duration": .1}
+    _surf_flags = SRCALPHA
+
+    _bar_fraction = 0.
+    _throbber_move_timer = 0
+    _activity_mode = False
+
+    def _config(self, **kwargs):
+        """
+          col: ``tuple`` (r,g,b) The color to be used for the bar, to avoid
+              saturation of the throbber use values below 200
+          pulse_duration: ``float`` time in seconds each pulse should last,
+              useful if your update loop is slower than the default of .25.
+          total_time: ``float`` time in seconds the throbber should take to
+              travel the full distance of the bar.
+          font: font to be used for the text.
+          text: ``str`` the text to be shown in the center of the widget.
+          text_col: the colour of the text.
+
+        """
+        for key in ("col", "font", "total_time",
+                    "pulse_duration", "text_col"):
+            if key in kwargs:
+                self._settings[key] = kwargs[key]
+
+        if "text" in kwargs:
+            self._settings["text"] = kwargs["text"]
+            overlay = self._images["overlay"]
+            overlay.image.fill((0, 0, 0, 0))
+            label = self._settings["font"].render(self._settings["text"], True,
+                                                  self._settings["text_col"])
+            overlay.image.blit(label, (overlay.rect.w / 2 -
+                                       label.get_rect().w / 2,
+                                       overlay.rect.h / 2 -
+                                       label.get_rect().h / 2))
+
+        if "total_time" in kwargs or "pulse_duration" in kwargs:
+            total_time_ms = self._settings["total_time"] * 1000.
+            self._throbber_velocity = self.rect.w / total_time_ms
+
+        if "init" in kwargs:
+            self._images["bar"]._show = False
+            self._images["throbber"]._show = False
+            self._images["throbber"].pos = [0, 3]
+
+            total_time_ms = self._settings["total_time"] * 1000.
+            self._throbber_velocity = self.rect.w / total_time_ms
+
+            self._throbber_x = 0
+
+    def _draw_base(self):
+        draw.rect(self._images["image"], (100, 100, 100),
+                  (0, 0, self.rect.w, self.rect.h))
+        draw.rect(self._images["image"], (240, 240, 240),
+                  (1, 1, self.rect.w - 2, self.rect.h - 2))
+
+    def _draw_bar(self, image, size):
+        draw.rect(image, self._settings["col"],
+                  (0, 0, size[0], size[1]))
+
+    def _draw_throbber(self, image, size):
+        brightened_color = [x + 20 for x in self._settings["col"]]
+        draw.rect(image, brightened_color, (0, 0, size[0], size[1]))
+
+    def _draw_overlay(self, image, size):
+        pass
+
+    def update(self, time):
+        if self._activity_mode:
+            self._images["bar"]._show = False
+            if self._throbber_move_timer > 0:
+                self._throbber_move_timer -= time
+                # Move throbber.
+                self._throbber_x += self._throbber_velocity * time
+                self._images["throbber"].rect.x = self._throbber_x
+                # If outside box, change direction and move back in.
+                left_edge = self._images["throbber"].rect.x - 3
+                right_edge = left_edge + self._images["throbber"].rect.w + 6
+                if left_edge < 0 or right_edge > self.rect.w:
+                    self._throbber_velocity = - self._throbber_velocity
+                    self._throbber_x += self._throbber_velocity * time
+                    self._images["throbber"].rect.x = self._throbber_x
+        else:
+            bar_rect = (0, 0, self.rect.w * self._bar_fraction, self.rect.h)
+            draw.rect(self.image, (100, 100, 100),
+                      (0, 0, self.rect.w, self.rect.h))
+            draw.rect(self.image, (240, 240, 240),
+                      (1, 1, self.rect.w - 2, self.rect.h - 2))
+            self.image.set_clip(bar_rect)
+            self.image.blit(self._images["bar"].image, (2, 2))
+            self.image.set_clip(None)
+
+    def pulse(self):
+        """
+        Moves the activity mode throbber.
+
+        The throbber will move for the number of seconds described by the
+        pulse_duration config argument.
+
+        Note: This will cause the Widget to change to activity mode if it
+        was in percent mode before.
+
+        """
+        if not self._activity_mode:
+            self._activity_mode = True
+            bar_rect = (0, 0, self.rect.w * self._bar_fraction, self.rect.h)
+            draw.rect(self.image, (100, 100, 100),
+                      (0, 0, self.rect.w, self.rect.h))
+            draw.rect(self.image, (240, 240, 240),
+                      (1, 1, self.rect.w - 2, self.rect.h - 2))
+            self._images["throbber"]._show = True
+        self._throbber_move_timer = self._settings["pulse_duration"] * 1000
+
+    @property
+    def fraction(self):
+        """Returns the current fraction the bar is at as a float."""
+        return self._bar_fraction
+
+    def set_fraction(self, fraction):
+        """
+        Sets the fraction the bar should be as a float.
+
+        Note: This will cause the widget to change to percent mode if it
+        was in activity mode before.
+        """
+        if self._activity_mode:
+            self._activity_mode = False
+            self._images["throbber"]._show = False
+        self._bar_fraction = min(max(fraction, 0.), 1.)

=== added file 'sgc/widgets/tab_controller.py'
--- sgc/widgets/tab_controller.py	1970-01-01 00:00:00 +0000
+++ sgc/widgets/tab_controller.py	2014-05-17 14:54:22 +0000
@@ -0,0 +1,285 @@
+# Copyright 2010-2014 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.
+
+"""
+Tabbed Container. A container that swaps the content in its area based upon the
+selected tab
+
+"""
+
+import pygame.mouse
+from pygame.locals import *
+from pygame import draw, gfxdraw
+
+from _locals import *
+from base_widget import Simple
+
+
+class TabController(Simple):
+    """
+    TabController
+
+    container that has multiple tabs and swaps content within its area.
+    """
+
+    _surf_flags = SRCALPHA
+    _can_focus = True
+    _extra_images = {"back": ((0, 1), (0, 20)), "front": ((0, 1), (0, 20))}
+    _settings_default = {"tab_col": (200, 200, 200), "col": (255, 255, 255),
+                         "font": Font["widget"], "text_col": (10, 10, 10),
+                         "max_width": 100, "min_width": 50}
+
+    _current_tab = False
+
+    def __len__(self):
+        return len(self._ordered_tabs)
+
+    def _config(self, **kwargs):
+        """
+          col: ``tuple`` (r,g,b) background color of the content area.
+          tab_col: ``tuple`` (r,g,b) color to be used in drawing front tabs
+          font: Font object the tab title will render with.
+          padding: ``int`` padding in content area
+          text_col: ``tuple`` (r,g,b) color to draw the tab titles with
+        """
+        for key in ("col", "tab_col", "font", "text_col",
+                    "max_width", "min_width"):
+            if key in kwargs:
+                self._settings[key] = kwargs[key]
+
+        if "init" in kwargs:
+            self._tab_widget = {}
+            self._tab_images = {}
+            self._tab_sizes = {}
+            self._ordered_tabs = []
+
+        self._images["back"]._show = False
+        self._images["front"]._show = False
+
+    def add_tab(self, tab_name, widget, pos=None):
+        """
+          Add a tab with a child widget.
+
+          tab_name: ``str`` The name of the tab that should be created.
+          widget: The widget to be placed in the content area of this tab.
+        """
+        if pos is None:
+            self._ordered_tabs.append(tab_name)
+        else:
+            self._ordered_tabs.insert(pos, tab_name)
+
+        widget.pos = (widget.pos[0] + 1, widget.pos[1] + 20)
+
+        self._tab_widget[tab_name] = widget
+        self._tab_widget[tab_name]._parent = self
+        if not self._current_tab:
+            self._current_tab = self._ordered_tabs[0]
+
+        cut_tab_name, tab_width = self._cut_string(tab_name,
+                                                   self._settings["max_width"])
+        if tab_width < self._settings["min_width"]:
+            tab_width = self._settings["min_width"]
+
+        tab_images = self._tab_images[tab_name] = {}
+
+        tab_images["back"] = pygame.Surface((tab_width + 1, 20))
+        self._draw_back(tab_images["back"], (tab_width, 20))
+
+        tab_images["front"] = pygame.Surface((tab_width + 1, 20))
+        self._draw_front(tab_images["front"], (tab_width, 20))
+
+        tab_title = self._settings["font"].render(cut_tab_name, True,
+                                                  self._settings["text_col"])
+
+        tab_images["back"].blit(tab_title, (5, 3))
+        tab_images["front"].blit(tab_title, (5, 3))
+
+        self._tab_sizes[tab_name] = tab_width
+
+    def _cut_string(self, s, w, ellipsis=True):
+        size = self._settings["font"].size(s)[0]
+        if size < w:
+            return s, size + 10
+        if ellipsis:
+            for i in range(len(s)):
+                size = self._settings["font"].size(s+"...")[0]
+                if size < w:
+                    return s+"...", size + 10
+                s = s[:-1]
+        else:
+            for i in range(len(s)):
+                size = self._settings["font"].size(s)[0]
+                if size < w:
+                    return s, size + 10
+                s = s[:-1]
+
+    def remove_tab(self, pos):
+        del self._tab_widget[self._ordered_tabs[pos]]
+        del self._tab_images[self._ordered_tabs[pos]]
+        del self._tab_sizes[self._ordered_tabs[pos]]
+        del self._ordered_tabs[pos]
+
+    def _draw_back(self, image, size):
+        image.fill((255, 255, 255))
+        self._gradientline(image, 200, 0, size[1], 2)
+        self._gradientline(image, 200, size[0], size[1], 2)
+        draw.line(image, (200, 200, 200), (0, size[1] - 1),
+                  (size[0], size[1] - 1))
+
+    def _draw_front(self, image, size):
+        image.fill(self._settings["col"])
+        draw.rect(image, self._settings["tab_col"],
+                  Rect(0, 0, size[0] + 1, 30))
+        draw.rect(image, self._settings["col"],
+                  Rect(1, 1, size[0] - 1, 30))
+
+    def _event(self, event):
+        if event.type == MOUSEBUTTONDOWN and event.button == 1:
+            internal_pos = [event.pos[0] - self.rect.x,
+                            event.pos[1] - self.rect.y]
+            #if and internal_pos[0] < 300 and\
+            #   internal_pos[0] > 0:
+            #    self._current_tab = self._ordered_tabs[internal_pos[0] / 100]
+            tab_hit = 0
+            if internal_pos[1] < 20 and internal_pos[1] > 0:
+                for tab in self._ordered_tabs:
+                    if (internal_pos[0] > tab_hit and
+                       internal_pos[0] < (tab_hit + self._tab_sizes[tab])):
+                        self._current_tab = tab
+                        break
+                    else:
+                        tab_hit += self._tab_sizes[tab]
+
+        if event.type == KEYDOWN:
+            if (pygame.key.get_mods() & KMOD_CTRL) and\
+               (pygame.key.get_mods() & KMOD_ALT):
+                if event.key == K_PAGEUP:
+                    self.previous_tab()
+                elif event.key == K_PAGEDOWN:
+                    self.next_tab()
+            elif event.key >= K_0 and\
+                 event.key <= K_9 and\
+                 (pygame.key.get_mods() & KMOD_ALT):
+                number = event.key - K_0
+                if number <= len(self._ordered_tabs) and number >= 1:
+                    self._current_tab = self._ordered_tabs[number-1]
+
+        # pass event to child widget.
+        if hasattr(event, "pos"):
+            internal_pos = [event.pos[0] - self.rect.x,
+                            event.pos[1] - self.rect.y]
+            if self._tab_widget[self._current_tab].rect.collidepoint(internal_pos):
+                self._tab_widget[self._current_tab]._event(event)
+        else:
+            self._tab_widget[self._current_tab]._event(event)
+
+    def update(self, time):
+        # fill content area with user defined color
+        self.image.fill(self._settings["col"],
+                        rect=Rect(0, 20, self.rect.w, self.rect.h))
+
+        # update content and blit into content area
+        if self._current_tab:
+            self._tab_widget[self._current_tab].update(time)
+            self.image.blit(self._tab_widget[self._current_tab].image,
+                            self._tab_widget[self._current_tab].pos)
+
+        # draw content area border
+        draw.rect(self.image, (200, 200, 200),
+                  Rect(0, 19, self.rect.w, self.rect.h - 19), 1)
+
+        # force transparency and Draw all tabs
+        self.image.fill((255, 255, 255, 0), rect=Rect(0, 0, self.rect.w, 19))
+
+        selected_tab_number = 0
+        selected_tab_pos = 0
+        tab_pos = 0
+        for i, tab in enumerate(self._ordered_tabs):
+            if tab == self._current_tab:
+                selected_tab_number = i
+                selected_tab_pos = tab_pos
+                tab_pos += self._tab_sizes[tab]
+            else:
+                self.image.blit(self._tab_images[tab]["back"], (tab_pos, 0))
+                tab_pos += self._tab_sizes[tab]
+
+        self.image.blit(self._tab_images[self._current_tab]["front"],
+                        (selected_tab_pos, 0))
+
+    def _gradientline(self, surface, color, x, start_y, end_y):
+        alpha_gradient = 255 / abs(start_y - end_y)
+        alpha = 255
+        for i in range(start_y - end_y):
+            pygame.gfxdraw.pixel(surface, x, start_y - i,
+                                 (color, color, color, alpha))
+            alpha -= alpha_gradient
+
+    def rename_tab(self, pos, tab_name):
+        if tab_name not in self._ordered_tabs:
+            self._tab_widget[tab_name] = self._tab_widget[self._ordered_tabs[pos]]
+            del self._tab_widget[self._ordered_tabs[pos]]
+            del self._tab_sizes[self._ordered_tabs[pos]]
+
+            del self._tab_images[self._ordered_tabs[pos]]
+            self._tab_images[tab_name] = {}
+
+            cut_tab_name, tab_width = self._cut_string(tab_name, self._settings["max_width"])
+            
+            if tab_width < self._settings["min_width"]:
+                tab_width = self._settings["min_width"]
+
+            self._tab_images[tab_name]["back"] =\
+                pygame.Surface((tab_width + 1, 20))
+            self._draw_back(self._tab_images[tab_name]["back"], (tab_width,
+                                                                 20))
+
+            self._tab_images[tab_name]["front"] =\
+                pygame.Surface((tab_width + 1, 20))
+            self._draw_front(self._tab_images[tab_name]["front"], (tab_width,
+                                                                   20))
+
+            tab_title =\
+                self._settings["font"].render(cut_tab_name, True,
+                                              self._settings["text_col"])
+
+            self._tab_images[tab_name]["back"].blit(tab_title, (5, 3))
+            self._tab_images[tab_name]["front"].blit(tab_title, (5, 3))
+
+            self._tab_sizes[tab_name] = self._settings["max_width"]
+
+            self._ordered_tabs[pos] = tab_name
+
+    def get_child(self, pos):
+        return self._tab_widget[self._ordered_tabs[pos]]
+
+    def get_tab_name(self, pos):
+        return self._ordered_tabs[pos]
+
+    def get_child_pos(self, child):
+        for i, w in enumerate(self._tab_widget.values()):
+            if w is child:
+                return i
+        return -1
+
+    def get_tab_name_pos(self, tab_name):
+        return self._ordered_tabs.index(tab_name)
+
+    def next_tab(self):
+        next = ((self._ordered_tabs.index(self._current_tab) + 1) %
+                len(self._ordered_tabs))
+        self._current_tab = self._ordered_tabs[next]
+
+    def previous_tab(self):
+        prev = ((self._ordered_tabs.index(self._current_tab) - 1) %
+                len(self._ordered_tabs))
+        self._current_tab = self._ordered_tabs[prev]
+
+    @property
+    def current_tab(self):
+        return self._ordered_tabs.index(self._current_tab)
+
+    @current_tab.setter
+    def current_tab(self, pos):
+        if pos >= 0 and pos < len(self._ordered_tabs):
+            self._current_tab = self._ordered_tabs[pos]