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

[Michael Rochester]

Added toggle button and changed __init__ to load it.

This branch was pulled prior to the Radio_button merge so the radio button is not in this branch.

During testing I substantially changed examples/test.py, this file does not need to be merged, I have left it in only to make reviewing the code easyer.

[Sam Bull (dreamsorcerer)]

review: Approve

=== modified file 'sgc/example/test.py'
--- sgc/example/test.py	2012-03-26 13:13:32 +0000
+++ sgc/example/test.py	2012-03-26 15:04:29 +0000
@@ -27,7 +27,7 @@
 
 ver_no = "0.1.2"
 
-screen = sgc.surface.Screen((640,480))  #, flags=OPENGL
+screen = sgc.surface.Screen((940,480))  #, flags=OPENGL
 clock = pygame.time.Clock()
 pygame.scrap.init()
 
@@ -54,6 +54,18 @@
 title.rect.center = (screen.rect.w/2, 40)
 title.add()
 
+toggle2 = sgc.widgets.Toggle(label="Default", pos=(50,300))
+toggle2.add(10)
+toggle1 = sgc.widgets.Toggle(label="col@#FF0000 & active@True", pos=(50,400), 
+                             col=(255,0,0), active=True)
+toggle1.add(11)
+toggle3 = sgc.widgets.Toggle(label="label_col@#00FF00", pos=(300,300),
+                             label_col=(0,255,0))
+toggle3.add(12)
+
+
+
+
 # Create input_box
 input_box = sgc.widgets.InputBox(label="Input Box", default="default text...")
 input_box.config(pos=(30,120))

=== modified file 'sgc/widgets/__init__.py'
--- sgc/widgets/__init__.py	2012-03-25 19:16:35 +0000
+++ sgc/widgets/__init__.py	2012-03-26 15:04:29 +0000
@@ -36,3 +36,4 @@
 from radio_button import Radio
 from scroll_box import ScrollBox
 from settings import Keys
+from toggle import Toggle

=== added file 'sgc/widgets/toggle.py'
--- sgc/widgets/toggle.py	1970-01-01 00:00:00 +0000
+++ sgc/widgets/toggle.py	2012-03-26 15:04:29 +0000
@@ -0,0 +1,239 @@
+#!/usr/bin/env python
+
+# Copyright (C) 2012  Michael Rochester
+
+"""
+Toggle Button widget, allows the user to change a boolean setting.
+
+"""
+
+import pygame
+from pygame.locals import *
+
+from _locals import *
+from _locals import focus
+from base_widget import Simple
+
+class Toggle(Simple):
+
+    """
+    A clickable check box button
+
+    Images:
+      'image': The default, background, unactive button state.
+      'active': The active, background, state
+      'handle': The image used for the handle
+
+    """
+
+    _can_focus = True
+    _available_images = ("active", "handle")
+    # Max_x: the max left and right pos for the handle
+    # Handlep_x: the x axis location for the handle, if None 'slide' mode not active
+    # mouse_x: (defined later) the position of the last event in 'slide' mode
+    _settings_default = {"active": False, "label": "", "col":(118, 45, 215),
+                         "label_col": Font.col, "max_x":(0,0),
+                          "handle_x":None}
+
+    _draw_rect = False
+
+
+    def _config(self, **kwargs):
+        """
+          label: ``str`` Text to be displayed to the right of the button
+          col: ``tuple`` (r,g,b) The colour used for the 'active' image
+          label_col: ``tuple`` (r,g,b) The colour for the buttons label
+          active: ``bool`` Sets the active state to the value of itself (False is default)
+        """
+        # Label to the right of the button
+        if "label" in kwargs:
+            # Save string as new label
+            self._settings["label"] = kwargs["label"]
+        # Colour of 'over' image
+        if "col" in kwargs:
+            self._settings["col"] = kwargs["col"]
+        # Colour of label
+        if "label_col" in kwargs:
+            self._settings["label_col"] = kwargs["label_col"]
+        # Set as active.
+        if "active" in kwargs:
+            self._settings["active"] = kwargs["active"]
+        self._draw()
+
+    def _draw(self, draw):
+
+        self._settings["size"] = (155,50) # A ratio of 3.1:1
+
+        # Calculate the handle size
+        self._settings["handlesize"] = ((self._settings["size"][0]-
+                                        (self._settings["size"][1]/10*3))/2,
+                                        self._settings["size"][1]-
+                                        self._settings["size"][1]/5)
+
+        # Calculate the max left and right pos for the handle
+        self._settings["max_x"] = (self._settings["size"][1]/10,
+                                   (self._settings["size"][0]-
+                                   self._settings["size"][1]/10)-
+                                   self._settings["handlesize"][0])
+        # Render the lables
+        label = Simple(Font["widget"].render(self._settings["label"], True,
+                                             self._settings["label_col"]))
+        label_on = Simple(Font["widget"].render("ON", True,
+                                             (255,255,255)))
+        label_off = Simple(Font["widget"].render("OFF", True,
+                                             (255,255,255)))
+        # Set size of widget based upon size of button and label
+        if not hasattr(self, "image"):
+            self._create_base_images((self._settings["size"][0] + 10 +
+                                      label.rect.w,
+                                      max(label.rect.height,
+                                      self._settings["size"][1])))
+
+
+
+        # Draw handle
+        self._images["handle"].fill(0)                   # Set to transparent
+        draw.rect(self._images["handle"], (149,150,120), # Base rectangle
+                  (0,0,self._settings["handlesize"][0],
+                   self._settings["handlesize"][1]))
+        for x in range(3):                               # Grips
+            draw.line(self._images["handle"], (169,170,140),
+                      ((self._settings["handlesize"][0]/6)*(x+2),
+                        self._settings["handlesize"][1]-
+                        self._settings["handlesize"][1]/5),
+                      ((self._settings["handlesize"][0]/6)*(x+2),
+                        self._settings["handlesize"][1]/5))
+
+
+
+        # Set colours for use in loop
+        colour = {"image":(55,54,45), "active":self._settings["col"]}
+        for img in ["image","active"]:  # Draw other images
+            self._images[img].fill(0)   # Set to transparent
+
+            draw.rect(self._images[img], colour[img],  # Base rectangle
+                  (0,0,self._settings["size"][0],self._settings["size"][1]))
+
+            # Blit all text
+            self._images[img].blit(label.image, 
+                                     (self._settings["size"][0]+ 10,
+                                      self._settings["size"][1]/2-
+                                      label.rect.h/2))
+
+
+            self._images[img].blit(label_on.image, 
+                                   (self._settings["handlesize"][0]/2+
+                                    self._settings["size"][1]/10-
+                                    label_on.rect.w/2,
+                                    self._settings["size"][1]/2-
+                                    label_on.rect.h/2))
+
+
+            self._images[img].blit(label_off.image, 
+                                   (self._settings["size"][0]-
+                                    self._settings["handlesize"][0]/2-
+                                    self._settings["size"][1]/10-
+                                    label_off.rect.w/2,
+                                    self._settings["size"][1]/2-
+                                    label_off.rect.h/2))
+            # Rerender text for new colour
+            label_on = Simple(Font["widget"].render("ON", True,
+                                             (0,0,1)))
+            label_off = Simple(Font["widget"].render("OFF", True,
+                                             (0,0,1)))
+
+        self._draw_button()
+
+    def _event(self, event):
+        """Respond to events."""
+        if event.type == MOUSEMOTION and event.buttons[0] == 1 and\
+           self._settings["mouse_x"] is not None:
+            if self._settings["handle_x"] is None :    # If not in slide mode
+                # If moved enough to go into slide mode
+                if abs(self._settings["mouse_x"] - event.pos[0]) > 5:
+                    self._settings["handle_x"] = self._settings["max_x"][0]\
+                        if self._settings["active"] is False else \
+                        self._settings["max_x"][1]
+                    self._settings["mouse_x"] = event.pos[0] 
+            else:                                        # If in slide mode
+                # Move handle
+                self._settings["handle_x"] += event.pos[0] - \
+                                                self._settings["mouse_x"]
+                self._settings["mouse_x"] = event.pos[0]
+                # Ensure handle is not past max possitions
+                if self._settings["handle_x"] > self._settings["max_x"][1]:
+                    self._settings["handle_x"] = self._settings["max_x"][1]
+
+                if self._settings["handle_x"] < self._settings["max_x"][0]:
+                    self._settings["handle_x"] = self._settings["max_x"][0]
+
+                self._draw_button()     # Redraw for new handle
+
+        if event.type == MOUSEBUTTONDOWN and event.button == 1:
+            # If mouse down on the handle
+            if Rect(self._settings["max_x"][1 if self._settings["active"]
+                                               else 0],
+                    self._settings["size"][1]/10,
+                    self._settings["handlesize"][0],
+                    self._settings["handlesize"][1]).collidepoint(
+                                    (event.pos[0]-self.pos_abs[0],
+                                     event.pos[1]-self.pos_abs[1])):
+                self._settings["mouse_x"] = event.pos[0]
+            else:
+                self._settings["mouse_x"] = None
+        if event.type == MOUSEBUTTONUP and event.button == 1:
+            if self._settings["handle_x"] is not None: # If in slide mode
+                # Determine if dropped in on/off position
+                self._settings["active"] = False if \
+                    self._settings["handle_x"]-self._settings["max_x"][0] < \
+                    self._settings["max_x"][1]-self._settings["handle_x"] \
+                    else True
+                self._settings["handle_x"] = None  # Stop slide mode
+                # Redraw in final position
+                self._draw_button()
+            else:    # If not in slide mode
+                if self.rect_abs.collidepoint(event.pos):
+                    # Flip switch
+                    self._settings["active"] = not self._settings["active"]
+                    self._draw_button()
+
+        elif event.type == KEYUP:
+            if event.key in (13,32):  # Enter or space key
+                self._settings["active"] = not self._settings["active"]
+                self._draw_button()
+        
+    def _focus_enter(self, focus):
+        """Draw rectangle when focus is gained from keyboard."""
+        if focus == 1:
+            self._draw_rect = True
+            self._draw_button()
+
+    def _focus_exit(self):
+        """Stop drawing rectangle when focus is lost."""
+        self._draw_rect = False
+        self._draw_button()
+
+    def _draw_button(self):
+        """Draw the button."""
+        if self._settings["active"] is False:
+            self.image = self._images["image"].copy()
+        else:
+            self.image = self._images["active"].copy()
+            
+        if self._settings["handle_x"] is not None:
+            self.image.blit(self._images["handle"],
+                    (self._settings["handle_x"],self._settings["size"][1]/10))
+        elif self._settings["active"] is False:
+            self.image.blit(self._images["handle"],
+                            (self._settings["max_x"][0],self._settings["size"][1]/10))
+        else:
+            self.image.blit(self._images["handle"], 
+                            (self._settings["max_x"][1],self._settings["size"][1]/10))
+
+        # Draw dotted rectangle to show keyboard focus
+        if self._draw_rect:
+            self._dotted_rect()
+    
+    @property
+    def active(self):
+        return self._settings["active"]