300 lines
9.0 KiB
Python
300 lines
9.0 KiB
Python
#!/usr/bin/env python
|
|
|
|
# Copyright (C) 2010-2012 Sam Bull
|
|
|
|
"""
|
|
Base widget, all widgets inherit from this.
|
|
|
|
"""
|
|
|
|
import pygame
|
|
from pygame.locals import Rect
|
|
|
|
from _locals import *
|
|
from _locals import (has_focus, is_active, add_widget, remove_widget_order,
|
|
set_cursor, remove_cursor)
|
|
try:
|
|
import opengl
|
|
except ImportError:
|
|
print "OpenGL widgets disabled."
|
|
|
|
class Simple(pygame.sprite.Sprite):
|
|
|
|
"""
|
|
Widget foundations all widgets should inherit from.
|
|
This can also be used as a simple widget that does nothing, such as
|
|
displaying an image.
|
|
|
|
Attributes:
|
|
image: The current surface that will be drawn to the screen.
|
|
rect: The ``pygame.Rect`` used for the widget's position and size.
|
|
rect_abs: A ``pygame.Rect`` using the absolute screen position.
|
|
pos: The widget's position. Can be retrieved or assigned as a shortcut
|
|
for rect.topleft. Also a shortcut for setting pos through config().
|
|
pos_abs: The widget's absolute screen position.
|
|
|
|
"""
|
|
|
|
# Widget settings
|
|
_can_focus = False
|
|
_modal = False
|
|
_layered = False # Layered updates for dialog windows etc.
|
|
_default_size = None
|
|
_parent = None
|
|
_available_images = ()
|
|
_extra_images = {}
|
|
_settings_default = {}
|
|
|
|
_fade = None # Alpha level when fading
|
|
_fade_up = True
|
|
_custom_image = False
|
|
|
|
def __init__(self, surf=None, **kwargs):
|
|
"""
|
|
Args:
|
|
surf: The surface that should be drawn to screen, of type:
|
|
pygame.Surface: Use an existing surface.
|
|
tuple,list: Contains size as (width,height), creates a new surface.
|
|
str: Contains file name to load an image.
|
|
dict: Contains multiple images to be loaded. The documentation will
|
|
specify if a widget uses multiple images and what names to use.
|
|
kwargs: Any number of keyword arguments matching those for config().
|
|
|
|
"""
|
|
pygame.sprite.Sprite.__init__(self)
|
|
|
|
# Implicitly pass attributes into _draw()
|
|
# Used to reduce complexity for widget developers
|
|
draw = self._draw
|
|
self._draw = lambda d=self.get_draw(): draw(d)
|
|
|
|
# Initialise attributes
|
|
self._images = {}
|
|
self._available_images = ("image",) + self._available_images
|
|
self._settings = self._settings_default.copy()
|
|
self.rect = Rect((0,0), (0,0))
|
|
|
|
# Use default size if none specified
|
|
if surf is None:
|
|
surf = self._default_size
|
|
|
|
# Create base surfaces if not None.
|
|
# If None, widget is expected to call this function later.
|
|
if surf is not None:
|
|
self._create_base_images(surf)
|
|
|
|
self.config(init=None, **kwargs)
|
|
|
|
|
|
def config(self, **kwargs):
|
|
"""
|
|
Update widget configuration and redraw the widget.
|
|
|
|
Keyword Args:
|
|
pos: ``tuple`` (x,y) Position to set widget to.
|
|
|
|
"""
|
|
if "pos" in kwargs:
|
|
self.rect.topleft = kwargs["pos"]
|
|
self._config(**kwargs)
|
|
self._draw()
|
|
|
|
def _config(self, **kwargs):
|
|
"""Widgets should overload for custom widget configuration."""
|
|
pass
|
|
|
|
def add(self, order=None, fade=True):
|
|
"""
|
|
Add widget to screen.
|
|
|
|
Args:
|
|
order: Integer representing the order widget should receive focus
|
|
when user presses TAB. The widget with the lowest order will
|
|
receive focus first, then moving up with increasing values.
|
|
fade: True if widget should fade in, False if not.
|
|
|
|
"""
|
|
added = add_widget(self, order)
|
|
|
|
# Fade widget in
|
|
if fade:
|
|
self._fade_up = True
|
|
if added and self._fade is None: self._fade = 1
|
|
self.image.set_alpha(self._fade)
|
|
else:
|
|
self._fade = None
|
|
self.image.set_alpha(255)
|
|
|
|
def remove(self, fade=True):
|
|
"""
|
|
Remove widget from screen.
|
|
|
|
Args:
|
|
fade: True if widget should fade out.
|
|
|
|
"""
|
|
if fade: # Fade widget out
|
|
self._fade_up = False
|
|
if self._fade == None: self._fade = 250
|
|
else: # Remove widget immediately
|
|
self.kill()
|
|
remove_widget_order(self)
|
|
|
|
def active(self):
|
|
"""Return True if widget is active (onscreen)."""
|
|
return is_active(self)
|
|
|
|
def has_focus(self):
|
|
"""Return True if this widget has focus."""
|
|
return has_focus(self)
|
|
|
|
def get_draw(self):
|
|
"""
|
|
Return appropriate draw module for pygame or OpenGL.
|
|
|
|
Use like:
|
|
``draw = self.get_draw()``
|
|
``draw.rect(self.image, ...)``
|
|
|
|
"""
|
|
if not get_screen()._opengl:
|
|
return pygame.draw
|
|
else:
|
|
return opengl.draw
|
|
|
|
def update(self, time):
|
|
"""Placeholder for function that updates the widget per frame."""
|
|
pass
|
|
|
|
def _event(self, event):
|
|
"""Placeholder for function that receives event for the widget."""
|
|
pass
|
|
|
|
def _draw(self, draw):
|
|
"""Widgets should overload to draw default images."""
|
|
pass
|
|
|
|
def _create_base_images(self, surf, parent=None):
|
|
"""
|
|
Creates the base surfaces to draw on, or uses existing images.
|
|
|
|
If self._default_size is None, widget is expected to call this
|
|
function manually when no size is given.
|
|
|
|
"""
|
|
Image = opengl.OpenGLImage if get_screen()._opengl else pygame.Surface
|
|
def create_image(surf):
|
|
"""Return a created surface."""
|
|
if isinstance(surf, pygame.Surface):
|
|
surf.set_colorkey(0)
|
|
self._custom_image = True
|
|
return surf
|
|
elif isinstance(surf, (tuple,list)):
|
|
self._custom_image = False
|
|
if isinstance(surf[0], (tuple,list)):
|
|
surf = (self.rect.w * surf[0][0] + surf[0][1],
|
|
self.rect.h * surf[1][0] + surf[1][1])
|
|
surf = Image(surf)
|
|
surf.set_colorkey(0)
|
|
return surf
|
|
elif isinstance(surf, str):
|
|
self._custom_image = True
|
|
return pygame.image.load(surf).convert_alpha()
|
|
|
|
# Create base images
|
|
if isinstance(surf, dict):
|
|
for img in surf:
|
|
assert (img in self._available_images or
|
|
img in self._extra_images), "Incorrect image."
|
|
self._images[img] = create_image(surf[img])
|
|
else:
|
|
self._images["image"] = create_image(surf)
|
|
|
|
# Copy other images, if any have not been supplied.
|
|
assert "image" in self._images, "Must supply 'image'"
|
|
for count, name in enumerate(self._available_images):
|
|
if name not in self._images:
|
|
img = self._images[self._available_images[count-1]]
|
|
self._images[name] = img.copy()
|
|
|
|
self.image = self._images["image"].copy()
|
|
self.rect.size = self.image.get_size()
|
|
|
|
# Set up extra images
|
|
for name in self._extra_images:
|
|
if name not in self._images:
|
|
self._images[name] = create_image(self._extra_images[name])
|
|
|
|
def _change_focus(self, forward=True):
|
|
"""
|
|
Called when focus should be changed. Container widget
|
|
should override this function.
|
|
|
|
Args:
|
|
forward: True if toggling focus forwards, False if backwards.
|
|
|
|
Returns:
|
|
True if widget should change focus from this widget.
|
|
|
|
"""
|
|
return True
|
|
|
|
def _focus_enter(self, focus=0):
|
|
"""
|
|
Called when the widget gains focus.
|
|
|
|
Args:
|
|
focus: 1 if focused by keyboard, 2 if by mouse.
|
|
|
|
"""
|
|
pass
|
|
|
|
def _focus_exit(self):
|
|
"""Called when the widget loses focus."""
|
|
pass
|
|
|
|
def _dotted_rect(self, col=(255,255,255)):
|
|
"""Draw a dotted rectangle to show keyboard focus."""
|
|
self.image.lock()
|
|
for i in range(0, self.rect.w, 3):
|
|
# Draw horizontal lines
|
|
self.image.set_at((i, 0), col)
|
|
self.image.set_at((i, self.rect.h-1), col)
|
|
for i in range(0, self.rect.h, 2):
|
|
# Draw vertical lines
|
|
self.image.set_at((0, i), col)
|
|
self.image.set_at((self.rect.w-1, i), col)
|
|
self.image.unlock()
|
|
|
|
def _set_cursor(self, size, hotspot, xormasks, andmasks):
|
|
set_cursor(self, size, hotspot, xormasks, andmasks)
|
|
|
|
def _remove_cursor(self):
|
|
remove_cursor(self)
|
|
|
|
|
|
# --PROPERTIES--
|
|
|
|
@property
|
|
def rect_abs(self):
|
|
if self._parent is None:
|
|
return self.rect
|
|
else:
|
|
p_abs = self._parent.pos_abs
|
|
p = (self.rect.x + p_abs[0], self.rect.y + p_abs[1])
|
|
return Rect(p, self.rect.size)
|
|
|
|
@property
|
|
def pos(self):
|
|
return self.rect.topleft
|
|
@pos.setter
|
|
def pos(self, value):
|
|
self.rect.topleft = value
|
|
@property
|
|
def pos_abs(self):
|
|
if self._parent is None:
|
|
return self.rect.topleft
|
|
else:
|
|
p_abs = self._parent.pos_abs
|
|
return (self.rect.x + p_abs[0], self.rect.y + p_abs[1])
|