Exemplo n.º 1
0
class ProgressBar(ABox):
    """The ProgressBar is a pychan widget. It can be used in xml files like this:
	<ProgressBar />
	It is used to display a ProgressBar with a certain progress ;). Set the
	widgets progress attribute to set the progress. Pretty straight forward.
	The progress is a value from 0 to 100. Think of it as percent.
	"""
    ATTRIBUTES = ABox.ATTRIBUTES + [
        IntAttr('progress'),
        Attr('fill'),
        Attr('background'),
    ]

    def __init__(self, progress=0, fill=None, background=None, **kwargs):
        super().__init__(**kwargs)
        if self.max_size == Widget.DEFAULT_MAX_SIZE:
            self.max_size = (100, 16)
        self.__progress = progress
        self.__fill = fill
        self.__background = background
        self.tiles = None
        self.bg_icon = None

    def _set_progress(self, progress):
        self.__progress = progress
        if self.bg_icon is None:
            self.background = "content/gui/images/background/bar_bg.png"
        if self.tiles is None:
            self.fill = "content/gui/images/background/widgets/progressbar_fill.png"
        self.tiles.size = (int(self.max_size[0] * progress / 100.0),
                           self.max_size[1])
        self.adaptLayout()

    def _get_progress(self):
        return self.__progress

    def _set_fill_image(self, image):
        self.__fill = image
        self.tiles = Icon(image=image, scale=True)
        self.addChild(self.tiles)

    def _get_fill_image(self):
        return self.__fill

    def _set_background(self, background):
        self.__background = background
        self.bg_icon = Icon(image=background, scale=True)
        self.bg_icon.min_size = self.bg_icon.size = self.max_size
        self.addChild(self.bg_icon)

    def _get_background(self):
        return self.__background

    progress = property(_get_progress, _set_progress)
    fill = property(_get_fill_image, _set_fill_image)
    background = property(_get_background, _set_background)
Exemplo n.º 2
0
class TilingProgressBar(ProgressBar):
    """ProgressBar that tiles its fill image instead of stretching.

	Also supports distinct left and right border/frame images which count
	towards the displayed progress value and fill images of width > 1px.
	"""
    ATTRIBUTES = ProgressBar.ATTRIBUTES + [Attr('left'), Attr('right')]

    def __init__(self, left=None, right=None, **kwargs):
        super().__init__(**kwargs)
        self.__left = left
        self.__right = right
        self.tiles = TilingHBox()
        self.addChild(self.tiles)
        self.tiles_width = 1
        self.left_width = 0
        self.right_width = 0

    def _get_progress(self):
        return self.__progress

    def _set_progress(self, progress):
        self.__progress = progress
        fill_width = (progress / 100.0) * (self.max_size[0] / self.tiles_width)
        self.tiles.amount = int(
            fill_width) - self.left_width - self.right_width
        self.adaptLayout()

    def _get_left_image(self):
        return self.__left

    def _set_left_image(self, image):
        self.__left = image
        self.left_width = Icon(image=image).size[0]
        self.tiles.start_img = image

    def _get_fill_image(self):
        return self.__fill

    def _set_fill_image(self, image):
        self.__fill = image
        self.tiles_width = Icon(image=image).size[0]
        self.tiles.tiles_img = image

    def _get_right_image(self):
        return self.__right

    def _set_right_image(self, image):
        self.__right = image
        self.right_width = Icon(image=image).size[0]
        self.tiles.final_img = image

    progress = property(_get_progress, _set_progress)
    left = property(_get_left_image, _set_left_image)
    fill = property(_get_fill_image, _set_fill_image)
    right = property(_get_right_image, _set_right_image)
Exemplo n.º 3
0
class ToggleImageButton(tooltip.TooltipButton):
    """The ToggleImageButton is an extended ImageButton (Think decorator pattern).
	It adds one extra attribute inactive_image. You can then set the button active
	or inactive (only in code for now). Setting the ToggleImageButton to inactive
	will change all images (up, down and hover) to the inactive image. If you
	set it active again, everything will be reset.

	@param inactive_image The image that is to be used as inactive image.
	"""

    ATTRIBUTES = pychan.widgets.ImageButton.ATTRIBUTES + [
        Attr('inactive_image')
    ] + [UnicodeAttr('tooltip')]

    # These two constants are used to describe the state of the widget.
    ACTIVE = 0
    INACTIVE = 1

    def __init__(self, inactive_image="", **kwargs):
        self.state = None
        super(ToggleImageButton, self).__init__(**kwargs)
        self.state = self.ACTIVE
        self.inactive_image = inactive_image

    def toggle(self):
        if self.state == self.ACTIVE:
            self.set_inactive()
        else:
            self.set_active()

    def set_active(self):
        """Sets the button active. Restores up, down and hover image to
		previous state."""
        if self.state != self.ACTIVE:
            self.up_image, self.down_image, self.hover_image = self.old_images
            self.state = self.ACTIVE

    def set_inactive(self):
        """Sets the button inactive. Overrides up, down and hover image with
		inactive image."""
        if self.state != self.INACTIVE:
            self.old_images = (self.up_image, self.down_image,
                               self.hover_image)
            self.up_image = self.inactive_image
            self.down_image = self.inactive_image
            self.hover_image = self.inactive_image
            self.state = self.INACTIVE

    def _get_inactive_image(self):
        return self.__inactiveimage

    def _set_inactive_image(self, inactive_image):
        self.__inactiveimage = inactive_image

    inactive_image = property(_get_inactive_image, _set_inactive_image)
Exemplo n.º 4
0
class MainmenuButton(ImageButton):
    """For use in main menu. bw: whether to use greyscale or color."""

    ATTRIBUTES = ImageButton.ATTRIBUTES + [Attr('icon')]
    ICON = "content/gui/icons/mainmenu/{icon}{bw}.png"

    def __init__(self, icon='door', **kwargs):
        super(MainmenuButton, self).__init__(is_focusable=False, **kwargs)
        self.icon = icon

    def _get_icon(self):
        return self.__icon

    def _set_icon(self, icon):
        self.__icon = icon
        self.up_image = self.ICON.format(icon=icon, bw='_bw')
        self.hover_image = self.down_image = self.ICON.format(icon=icon, bw='')

    icon = property(_get_icon, _set_icon)
Exemplo n.º 5
0
class ImageButton(FifeImageButton):
    """Extends ImageButton functionality by providing a new path= attribute.
	Unless manually overridden, specifying path="path/to/file" (note: no .png
	extension) will interpret that as these attributes:

	      up_image = "content/gui/path/to/file.png"
	    down_image = "content/gui/path/to/file_d.png"
	   hover_image = "content/gui/path/to/file_h.png"
	inactive_image = "content/gui/path/to/file_bw.png" ("black/white")

	Other possible names also checked are
	      up_image = "content/gui/path/to/file_u.png" ("up", for tabwidget)
	inactive_image = "content/gui/path/to/file_gr.png" ("grayscale")

	If some of those files could not be found, we use up_image instead.
	Sets is_focusable to False unless overridden.

	You can set the button active or inactive (only in code for now).
	Setting to inactive will change *all* images (up, down and hover) to the
	inactive image. If you set it active again, everything will be reset.
	"""
    ATTRIBUTES = FifeImageButton.ATTRIBUTES + [
        Attr('path'), Attr('inactive_image')
    ]
    IMAGE = "content/gui/{path}{{mode}}.png"
    # These two constants are used to describe the toggle state of the widget.
    ACTIVE = 0
    INACTIVE = 1

    def __init__(self,
                 path='',
                 inactive_image=None,
                 is_focusable=False,
                 **kwargs):
        super(ImageButton, self).__init__(is_focusable=is_focusable, **kwargs)
        self.old_images = (None, None, None)
        if path:
            # initializing from python, not xml, so path is available here
            # and should be set
            self.path = path
        if inactive_image:
            self.inactive_image = inactive_image
        self.state = self.ACTIVE

    def toggle(self):
        if self.is_active:
            self.set_inactive()
        else:
            self.set_active()

    def set_active(self):
        """Sets the button active. Restores up, down and hover image to
		previous state."""
        if self.is_active:
            return
        self.up_image, self.down_image, self.hover_image = self.old_images
        self.state = self.ACTIVE

    def set_inactive(self):
        """Sets the button inactive. Overrides up, down and hover image with
		inactive image."""
        if not self.is_active:
            # running this with inactive state would overwrite all elements
            # of old_images with inactive_image
            return
        # store old images to be reloaded when button is set active again
        self.old_images = (self.up_image, self.down_image, self.hover_image)
        self.up_image = self.down_image = self.hover_image = self.inactive_image
        self.state = self.INACTIVE

    @property
    def is_active(self):
        return (self.state == self.ACTIVE)

    def _get_path(self):
        return self.__path

    def _set_path(self, path):
        self.__path = path
        image_path = self.IMAGE.format(path=path)
        try:
            self.up_image = image_path.format(mode='')
        except RuntimeError:
            # RuntimeError: _[NotFound]_ , Something was searched, but not found
            #TODO Temporarily try to find _u for the tabwidget
            self.up_image = image_path.format(mode='_u')
        try:
            self.hover_image = image_path.format(mode='_h')
        except RuntimeError:
            # By default, guichan/pychan will set hover_image to be the same as
            # up_image even if it is not explicitly set here (the following line
            # just reading `pass` instead of setting hover_image to up_image).
            # This however is stored internally in a way that would segfault FIFE
            # when trying to restore images from self.old_images that were set
            # like that implicitly (see #2000).
            self.hover_image = self.up_image
        try:
            self.down_image = image_path.format(mode='_d')
        except RuntimeError:
            self.down_image = self.up_image

        # Since inactive_image is no image attribute in pychan, it would
        # not be validated upon setting self.inactive_image (which works
        # for ImageButton.{up,down,hover}_image and Icon.image).
        # Instead, we try to load an Icon with that image and manually
        # set inactive_image to the path that worked, if there is any.
        try:
            image = image_path.format(mode='_bw')
            Icon(image=image).hide(
            )  # hide will remove Icon from widgets of pychan.internals.manager
            self.inactive_image = image
        except RuntimeError:
            try:
                image = image_path.format(mode='_gr')
                Icon(image=image).hide(
                )  # hide will remove Icon from widgets of pychan.internals.manager
                self.inactive_image = image
            except RuntimeError:
                self.inactive_image = self.up_image

    path = property(_get_path, _set_path)