Gecko [ lorencats.com ]

Name	Size	Permission
__pycache__	[ DIR ]	drwxr-xr-x
App.py	1.99 KB	-rw-r--r--
Box.py	3.11 KB	-rw-r--r--
ButtonGroup.py	10.2 KB	-rw-r--r--
CheckBox.py	4.63 KB	-rw-r--r--
Combo.py	10.54 KB	-rw-r--r--
ListBox.py	8.05 KB	-rw-r--r--
MenuBar.py	1.32 KB	-rw-r--r--
Picture.py	2.58 KB	-rw-r--r--
PushButton.py	5.2 KB	-rw-r--r--
RadioButton.py	1.7 KB	-rw-r--r--
Slider.py	2.59 KB	-rw-r--r--
Text.py	2.71 KB	-rw-r--r--
TextBox.py	3.7 KB	-rw-r--r--
Waffle.py	10.4 KB	-rw-r--r--
Window.py	1.03 KB	-rw-r--r--
__init__.py	715 B	-rw-r--r--
alerts.py	1.17 KB	-rw-r--r--
base.py	18.22 KB	-rw-r--r--
event.py	5.87 KB	-rw-r--r--
tkmixins.py	10.47 KB	-rw-r--r--
utilities.py	11.77 KB	-rw-r--r--

Code Editor : utilities.py

# this is to cater for Python 2, is it really needed?
try:
    from inspect import getfullargspec
except ImportError:
    from inspect import getargspec as getfullargspec

try:
    from PIL import Image, ImageTk
    PIL_AVAILABLE = True
except ImportError:
    PIL_AVAILABLE = False

from tkinter import PhotoImage, TclError

import sys

class GUIZeroException(Exception):
    pass

# holds details about the configuration guizero is using
class SystemConfig():
    def __init__(self):
        """
        Holds details about the system configuration guizero is using
        """
        self._platform = sys.platform
        if self._platform.startswith("linux"):
            self._platform = "linux"

if PIL_AVAILABLE:
            self._supported_image_types = ["GIF", "Animated GIF", "BMP", "ICO", "PNG", "JPG", "TIF"]
        else:
            self._supported_image_types = ["GIF", "PNG"]
            if self._platform == "darwin":
                #MacOS only supports GIF with PIL
                self._supported_image_types = ["GIF"]

@property
    def PIL_available(self):
        """
        Returns `True` if PIL (Python Imaging Library) is available.
        """
        return PIL_AVAILABLE

@property
    def supported_image_types(self):
        """
        Returns a list of images types supported by this system
        e.g. ('GIF', 'PNG', 'JPG')
        """
        return self._supported_image_types

@property
    def platform(self):
        """
        Returns the current platform ("linux", "darwin", "win32")
        """
        return self._platform

system_config = SystemConfig()

class GUIZeroImage():
    def __init__(self, image_source, width, height):
        """
        GUIZeroImage manages an "image" for guizero widgets, parsing its
        contents, sizing it accordingly and managing environment.

:param string image_source:
            The source of the image, a file path, PIL or
            Tk image object.

:param int width:
            The required width of the image, set to `None`, to keep the
            original image width

:param int height:
            The required height of the image, set to `None`, to keep the
            original image width.
        """
        self._image_source = image_source
        self._pil_image = None
        self._tk_image = None
        self._tk_frames = []
        self._width = width
        self._height = height
        self._current_frame = 0
        self._animation = False
        self._animation_running = False

# open the image
        self._setup_image()

@property
    def image_source(self):
        """
        Returns the original source of the image, be that a file path, PIL or
        Tk image object.
        """
        return self._image_source

@property
    def tk_image(self):
        """
        Returns the Tk PhotoImage object.
        """
        return self._tk_image

@property
    def pil_image(self):
        """
        Returns the PIL Image object.
        """
        return self._pil_image

@property
    def width(self):
        """
        Returns the image width.
        """
        return int(self._width)

@property
    def height(self):
        """
        Returns the image height.
        """
        return int(self._height)

@property
    def animation(self):
        """
        Returns `True` if the image contains more than 1 frame (i.e. is an
        animation)
        """
        return self._animation

@property
    def tk_frames(self):
        """
        Returns a list of frames as Tk PhotoImage objects which make up this
        image.
        """
        return self._tk_frames

def _setup_image(self):
        try:
            # open image
            self._open_image_source()

# size image
            self._size_image()

# open frames
            self._open_image_frames()

except Exception as e:
            error_text = "Image import error - '{}'\n".format(e)
            error_text += "Check the file path and image type is {}".format("/".join(system_config.supported_image_types))
            raise_error(error_text)

def _open_image_source(self):
        if system_config.PIL_available:
            if isinstance(self._image_source, str):
                # the source is a string, so try and open as a path
                self._pil_image = Image.open(self._image_source)
                self._tk_image = ImageTk.PhotoImage(self._pil_image)

elif Image.isImageType(self._image_source):
                # the source is a PIL Image
                self._pil_image = self._image_source
                self._tk_image = ImageTk.PhotoImage(self._pil_image)

elif isinstance(self._image_source, (PhotoImage, ImageTk.PhotoImage)):
                self._tk_image = self._image_source

else:
                raise Exception("Image must be a file path, PIL.Image or tkinter.PhotoImage")

else:
            if isinstance(self._image_source, str):
                self._tk_image = PhotoImage(file=self._image_source)

elif isinstance(self._image_source, PhotoImage):
                self._tk_image = self._image_source

else:
                raise Exception("Image must be a file path or tkinter.PhotoImage")

def _size_image(self):

# if there is no size, set it to the image width
        if self._width is None:
            self._width = self._tk_image.width()

if self._height is None:
            self._height = self._tk_image.height()

# does it need resizing?
        if self._width != self._tk_image.width() or self._height != self._tk_image.height():
            if self._pil_image:
                resized_image = self._pil_image.resize((self._width, self._height), Image.ANTIALIAS)
                self._tk_image = ImageTk.PhotoImage(resized_image)
            else:
                error_format("Image resizing - cannot scale the image as PIL is not available.")

def _open_image_frames(self):
        if self._pil_image:
            frame_count = 0
            try:
                while True:
                    self._pil_image.seek(frame_count)
                    tk_frame = ImageTk.PhotoImage(self._pil_image.resize((self._width, self._height), Image.ANTIALIAS))

try:
                        delay = self._pil_image.info['duration']
                    except:
                        delay = 100

self._tk_frames.append((tk_frame, delay))
                    frame_count += 1

except EOFError as e:
                # end of frames
                pass

if frame_count > 1:
                self._animation = True

class AnimationPlayer():
    def __init__(self, master, guizero_image, update_image_callback):
        """
        AnimationPlayer manages the playing of a animated gif for guizero
        widgets.

:param Widget master:
            The widget which is displaying the animation.

:param GUIZeroImage guizero_image:
            The image object which contains the animation.

:param function update_image_callback:
            A function which should be called when the Image needs updating.
            The function will be called and passed a reference to the next
            Tk PhotoImage object in the animation.
        """
        self._master = master
        self._guizero_image = guizero_image
        self._update_image_callback = update_image_callback
        self._current_frame = 0
        self._running = False
        self.start()

@property
    def running(self):
        """
        Returns `True` if the animation is running
        """
        return self._running

def start(self):
        """
        Starts the animation.
        """
        if not self._running:
            self._running = True
            self._show_frame()

def stop(self):
        """
        Stops the animation
        """
        self._running = False

def _show_frame(self):
        if self.running:
            # get the frame
            frame_data = self._guizero_image.tk_frames[self._current_frame]
            frame = frame_data[0]
            delay = frame_data[1]

# give it to the call back
            self._update_image_callback(frame)

# increment the frame
            self._current_frame += 1
            if self._current_frame == len(self._guizero_image.tk_frames):
                self._current_frame = 0

# call again after the delay
            self._master.after(delay, self._show_frame)

# Lambda-izer for making it easy to pass arguments with function calls
# without having to know what lambda does
def with_args( func_name, *args):
    return lambda: func_name(*args)

# Gets the number of args a function expects
def no_args_expected(func_name):
    args = getfullargspec(func_name).args
    if len(args) > 0:
        # if someone names the first arg of a class function to something
        # other than self, this will fail! or if they name the first argument
        # of a non class function to self this will fail!
        if args[0] == "self":
            return len(args) - 1
        else:
            return len(args)
    else:
        return 0

# Format errors in a pretty way
def error_format(message):
    print("------------------------------------------------------------")
    print("*** GUIZERO WARNING ***")
    print(message)
    print("------------------------------------------------------------")

# Raise error in a pretty way
def raise_error(message):
    error_message = "\n------------------------------------------------------------\n"
    error_message += "*** GUIZERO ERROR ***\n"
    error_message += message + "\n"
    error_message += "------------------------------------------------------------\n"
    raise GUIZeroException(error_message)

def deprecated(message):
    print("*** DEPRECATED: " + message)

def convert_color(color):
    """
    Converts a color from "color", (255, 255, 255) or "#ffffff" into a color tk 
    should understand.
    """
    if color is not None:

# is the color a string
        if isinstance(color, str):
            # strip the color of white space
            color = color.strip()

# if it starts with a # check it is a valid color
            if color[0] == "#":

# check its format
                if len(color) != 7:
                    raise ValueError("{} is not a valid # color, it must be in the format #ffffff.".format(color))
                else:
                    # split the color into its hex values
                    hex_colors = (color[1:3], color[3:5], color[5:7])

# check hex values are between 00 and ff
                    for hex_color in hex_colors:
                        try:
                            int_color = int(hex_color, 16)
                        except:
                            raise ValueError("{} is not a valid value, it must be hex 00 - ff".format(hex_color))

if not (0 <= int_color <= 255):
                            raise ValueError("{} is not a valid color value, it must be 00 - ff".format(hex_color))

# if the color is not a string, try and convert it
        else:
            # get the number of colors and check it is iterable
            try:
                no_of_colors = len(color)
            except:
                raise ValueError("A color must be a list or tuple of 3 values (red, green, blue)")

if no_of_colors != 3:
                raise ValueError("A color must contain 3 values (red, green, blue)")

# check the color values are between 0 and 255
            for c in color:
                if not (0 <= c <= 255):
                    raise ValueError("{} is not a valid color value, it must be 0 - 255")

# convert to #ffffff format
            color = "#{:02x}{:02x}{:02x}".format(color[0], color[1], color[2])

return color

${this.title}

Code Editor : utilities.py