Beispiel #1
0
class LUIKeyMarker(LUIObject):
    def __init__(self, parent=None, key=u"A"):
        LUIObject.__init__(self)
        self.bgLeft = LUISprite(self, "Keymarker_Left", "skin")
        self.bgMid = LUISprite(self, "Keymarker", "skin")
        self.bgRight = LUISprite(self, "Keymarker_Right", "skin")

        self.label = LUILabel(parent=self, text=key, shadow=True)
        self.label.centered = (True, True)
        self.label.margin = (-3, 0, 0, -1)
        self.margin = (-1, 0, 0, -1)

        self.set_key(key)

        if parent is not None:
            self.parent = parent

        self.fit_to_children()

    def set_key(self, key):
        self.label.set_text(key)
        self.width = self.label.width + self.bgLeft.width + self.bgRight.width + 7
        self.bgMid.width = self.width - self.bgLeft.width - self.bgRight.width
        self.bgMid.left = self.bgLeft.width
        self.bgRight.left = self.bgMid.width + self.bgMid.left

        self.fit_to_children()
Beispiel #2
0
    def _render_options(self, options):
        visible = min(4, len(options))
        offsetTop = 6
        self.layout.height = visible * 30 + offsetTop + 11
        self.container.height = visible * 30 + offsetTop + 1
        self.layout.update_layout()
        self.container.remove_all_children()
        
        currentY = offsetTop
        for optId, optVal in options:
            optContainer = LUIObject(self.container, x=0, y=currentY, w=self.container.width - 30, h=30)

            optBg = LUISprite(optContainer, "blank", "skin")
            optBg.width = self.container.width
            optBg.height = optContainer.height
            optBg.color = (0,0,0,0)
            optBg.bind("mouseover", self._on_opt_over)
            optBg.bind("mouseout", self._on_opt_out)
            optBg.bind("click", partial(self._on_opt_click, optId))
            optBg.solid = True

            optLabel = LUILabel(parent=optContainer, text=unicode(optVal), shadow=True)
            optLabel.top = 5
            optLabel.left = 8

            if optId == self.selectbox.get_selected_option():
                optLabel.color = (0.6, 0.9, 0.4, 1.0)

            divider = LUISprite(optContainer, "SelectdropDivider", "skin")
            divider.top = 30 - divider.height / 2
            divider.width = self.container.width

            currentY += 30
Beispiel #3
0
class LUIKeyMarker(LUIObject):
    def __init__(self, parent=None, key=u"A"):
        LUIObject.__init__(self)
        self.bgLeft = LUISprite(self, "Keymarker_Left", "skin")
        self.bgMid = LUISprite(self, "Keymarker", "skin")
        self.bgRight = LUISprite(self, "Keymarker_Right", "skin")

        self.label = LUILabel(parent=self, text=key, shadow=True)
        self.label.centered = (True, True)
        self.label.margin = (-3, 0, 0, -1)
        self.margin = (-1, 0, 0, -1)

        self.set_key(key)

        if parent is not None:
            self.parent = parent

        self.fit_to_children()

    def set_key(self, key):
        self.label.set_text(key)
        self.width = self.label.width + self.bgLeft.width + self.bgRight.width + 7
        self.bgMid.width = self.width - self.bgLeft.width - self.bgRight.width
        self.bgMid.left = self.bgLeft.width
        self.bgRight.left = self.bgMid.width + self.bgMid.left

        self.fit_to_children()
Beispiel #4
0
    def _render_options(self, options):
        """ Internal method to update the options """
        num_visible_options = min(30, len(options))
        offset_top = 6
        self._layout.height = num_visible_options * 30 + offset_top + 11
        self._container.height = num_visible_options * 30 + offset_top + 1
        self._container.remove_all_children()

        current_y = offset_top
        for opt_id, opt_val in options:
            opt_container = LUIObject(self._container, x=0, y=current_y, w=self._container.width - 30, h=30)

            opt_bg = LUISprite(opt_container, "blank", "skin")
            opt_bg.width = self._container.width
            opt_bg.height = opt_container.height
            opt_bg.color = (0,0,0,0)
            opt_bg.bind("mouseover", self._on_opt_over)
            opt_bg.bind("mouseout", self._on_opt_out)
            opt_bg.bind("mousedown", lambda *args: self.request_focus())
            opt_bg.bind("click", partial(self._on_opt_click, opt_id))
            opt_bg.solid = True

            opt_label = LUILabel(parent=opt_container, text=unicode(opt_val))
            opt_label.top = 8
            opt_label.left = 8

            if opt_id == self._selectbox.selected_option:
                opt_label.color = (0.6, 0.9, 0.4, 1.0)

            divider = LUISprite(opt_container, "SelectdropDivider", "skin")
            divider.top = 30 - divider.height / 2
            divider.width = self._container.width

            current_y += 30
Beispiel #5
0
    def __init__(self, parent=None, width=200, value=50, show_label=True):
        """ Constructs a new progress bar. If show_label is True, a label indicating
        the current progress is shown """
        LUIObject.__init__(self)
        self.set_width(width)

        self._bg_layout = LUIHorizontalStretchedLayout(parent=self,
                                                       prefix="ProgressbarBg",
                                                       width="100%")

        self._fg_left = LUISprite(self, "ProgressbarFg_Left", "skin")
        self._fg_mid = LUISprite(self, "ProgressbarFg", "skin")
        self._fg_right = LUISprite(self, "ProgressbarFg_Right", "skin")
        self._fg_finish = LUISprite(self, "ProgressbarFg_Finish", "skin")

        self._show_label = show_label
        self._progress_pixel = 0
        self._fg_finish.right = 0

        if self._show_label:
            self._progress_label = LUILabel(parent=self, text=u"33 %")
            self._progress_label.centered = (True, True)

        self.set_value(value)
        self._update_progress()

        if parent is not None:
            self.parent = parent
Beispiel #6
0
class LUIProgressbar(LUIObject):
    def __init__(self, parent=None, width=200, value=50, show_label=True):
        LUIObject.__init__(self, x=0, y=0, w=width, h=0)

        self.bgLeft = LUISprite(self, "ProgressbarBg_Left", "skin")
        self.bgMid = LUISprite(self, "ProgressbarBg", "skin")
        self.bgRight = LUISprite(self, "ProgressbarBg_Right", "skin")

        self.bgMid.width = self.width - self.bgLeft.width - self.bgRight.width
        self.bgMid.left = self.bgLeft.width
        self.bgRight.left = self.bgMid.width + self.bgMid.left

        self.fgLeft = LUISprite(self, "ProgressbarFg_Left", "skin")
        self.fgMid = LUISprite(self, "ProgressbarFg", "skin")
        self.fgRight = LUISprite(self, "ProgressbarFg_Right", "skin")
        self.fgFinish = LUISprite(self, "ProgressbarFg_Finish", "skin")

        self.showLabel = show_label
        self.progressPixel = 0
        self.fgFinish.right = 0

        self.fit_to_children()

        if self.showLabel:
            self.progressLabel = LUILabel(parent=self, text=u"33 %", shadow=True)
            self.progressLabel.centered = (True, False)
            self.progressLabel.top = -1

        self.set_value(value)
        self._update_progress()

        if parent is not None:
            self.parent = parent

    def set_value(self, val):
        val = max(0, min(100, val))
        self.progressPixel = int(val / 100.0 * self.width)
        self._update_progress()

    def _update_progress(self):
        self.fgFinish.hide()

        if self.progressPixel <= self.fgLeft.width + self.fgRight.width:
            self.fgMid.hide()
            self.fgRight.left = self.fgLeft.width
        else:
            self.fgMid.show()
            self.fgMid.left = self.fgLeft.width
            self.fgMid.width = self.progressPixel - self.fgRight.width - self.fgLeft.width
            self.fgRight.left = self.fgMid.left + self.fgMid.width

            if self.progressPixel >= self.width - self.fgRight.width:
                self.fgFinish.show()
                self.fgFinish.right = -(self.width - self.progressPixel)
                self.fgFinish.clip_bounds = (0, self.width - self.progressPixel, 0, 0)

        if self.showLabel:
            percentage = self.progressPixel / self.width * 100.0
            self.progressLabel.set_text(unicode(int(percentage)) + u" %")
Beispiel #7
0
class LUICheckbox(LUIObject):

    """ This is a simple checkbox, including a Label. The checkbox can either
    be checked or unchecked. """

    def __init__(self, checked=False, label=u"Checkbox", **kwargs):
        """ Constructs a new checkbox with the given label and state. """
        LUIObject.__init__(self, x=0, y=0, w=0, h=0, solid=True)
        LUIInitialState.init(self, kwargs)
        self.checkboxSprite = LUISprite(self, "Checkbox_Default", "skin")
        self.label = LUILabel(parent=self, text=label, shadow=True, left=self.checkboxSprite.width + 6)
        self.label.top = self.label.height - self.checkboxSprite.height
        self.label.bind("resized", self._on_label_resized)
        self.fit_to_children()

        self.checked = checked
        self._update_sprite()

    def _on_label_resized(self, event):
        """ Internal handler when the text of the label got changed """
        self.fit_to_children()

    def on_click(self, event):
        """ Internal onclick handler. Do not override """
        self.checked = not self.checked
        self.trigger_event("changed")
        self._update_sprite()

    def on_mousedown(self, event):
        """ Internal mousedown handler. Do not override """
        self.checkboxSprite.color = (0.86,0.86,0.86,1.0)

    def on_mouseup(self, event):
        """ Internal on_mouseup handler. Do not override """
        self.checkboxSprite.color = (1,1,1,1)

    def get_checked(self):
        """ Returns a boolean wheter the checkbox is currently checked """
        return self.checked

    def toggle_checked(self):
        """ Toggles the checkbox state """
        self.set_checked(not self.get_checked())

    def set_checked(self, checked):
        """ Sets the checkbox state """
        self.checked = checked
        self._update_sprite()
        
    def get_label(self):
        """ Returns a handle to the label, so it can be modified (e.g. change 
            its text) """
        return self.label

    def _update_sprite(self):
        """ Internal method to update the sprites """
        img = "Checkbox_Checked" if self.checked else "Checkbox_Default"
        self.checkboxSprite.set_texture(img, "skin")
Beispiel #8
0
    def __init__(self,
                 parent=None,
                 width=200,
                 placeholder=u"Enter some text ..",
                 value=u"",
                 **kwargs):
        """ Constructs a new input field. An input field always needs a width specified """
        LUIObject.__init__(self, x=0, y=0, solid=True)
        self.set_width(width)
        self._layout = LUIHorizontalStretchedLayout(parent=self,
                                                    prefix="InputField",
                                                    width="100%")

        # Container for the text
        self._text_content = LUIObject(self)
        self._text_content.margin = (5, 7, 5, 7)
        self._text_content.clip_bounds = (0, 0, 0, 0)
        self._text_content.set_size("100%", "100%")

        # Scroller for the text, so we can move right and left
        self._text_scroller = LUIObject(parent=self._text_content)
        self._text_scroller.center_vertical = True
        self._text = LUILabel(parent=self._text_scroller, text=u"")

        # Cursor for the current position
        self._cursor = LUISprite(self._text_scroller,
                                 "blank",
                                 "skin",
                                 x=0,
                                 y=0,
                                 w=2,
                                 h=15)
        self._cursor.color = (0.5, 0.5, 0.5)
        self._cursor.margin.top = 2
        self._cursor.z_offset = 20
        self._cursor_index = 0
        self._cursor.hide()
        self._value = value

        # Placeholder text, shown when out of focus and no value exists
        self._placeholder = LUILabel(parent=self._text_content,
                                     text=placeholder,
                                     shadow=False,
                                     center_vertical=True,
                                     alpha=0.2)

        # Various states
        self._tickrate = 1.0
        self._tickstart = 0.0

        self._render_text()

        if parent is not None:
            self.parent = parent

        LUIInitialState.init(self, kwargs)
Beispiel #9
0
    def __init__(self, parent=None, width=200, value=50, show_label=True):
        LUIObject.__init__(self, x=0, y=0, w=width, h=0)

        self.bgLeft = LUISprite(self, "ProgressbarBg_Left", "skin")
        self.bgMid = LUISprite(self, "ProgressbarBg", "skin")
        self.bgRight = LUISprite(self, "ProgressbarBg_Right", "skin")

        self.bgMid.width = self.width - self.bgLeft.width - self.bgRight.width
        self.bgMid.left = self.bgLeft.width
        self.bgRight.left = self.bgMid.width + self.bgMid.left

        self.fgLeft = LUISprite(self, "ProgressbarFg_Left", "skin")
        self.fgMid = LUISprite(self, "ProgressbarFg", "skin")
        self.fgRight = LUISprite(self, "ProgressbarFg_Right", "skin")
        self.fgFinish = LUISprite(self, "ProgressbarFg_Finish", "skin")

        self.showLabel = show_label
        self.progressPixel = 0
        self.fgFinish.right = 0

        self.fit_to_children()

        if self.showLabel:
            self.progressLabel = LUILabel(parent=self, text=u"33 %", shadow=True)
            self.progressLabel.centered = (True, False)
            self.progressLabel.top = -1

        self.set_value(value)
        self._update_progress()

        if parent is not None:
            self.parent = parent
Beispiel #10
0
    def __init__(self, parent=None, width=100.0, filled=False, min_value=0, max_value=1.0, precision=2, value=None):
        LUIObject.__init__(self, x=0, y=0, w=width, h=0)
        LUICallback.__init__(self)

        max_numbers_before = max(len(str(int(max_value))), len(str(int(min_value))))
        number_space_required = max_numbers_before

        if precision > 0:
            number_space_required += 1 + precision

        pixels_per_number = 7
        self.precision = precision

        self.slider = LUISlider(self, width=width - pixels_per_number * number_space_required - 5, filled=filled, min_value=min_value, max_value=max_value, value=value)
        self.label = LUILabel(parent=self, shadow=True, text=u"1.23")
        self.label.right = 0
        self.label.top = self.label.height - self.slider.height
        self.label.color = (1,1,1,0.5)

        self.slider.add_change_callback(self._on_slider_changed)
        self.slider.add_change_callback(self._trigger_callback)
        self._on_slider_changed(self.slider, self.slider.get_value())

        if parent is not None:
            self.parent = parent

        self.fit_to_children()
Beispiel #11
0
    def __init__(self, parent=None, width=100.0, filled=False, min_value=0, max_value=1.0, precision=2, value=None):
        LUIObject.__init__(self, x=0, y=0, w=width, h=0)
        LUICallback.__init__(self)

        max_numbers_before = max(len(str(int(max_value))), len(str(int(min_value))))
        number_space_required = max_numbers_before

        if precision > 0:
            number_space_required += 1 + precision

        pixels_per_number = 7
        self.precision = precision

        self.slider = LUISlider(
            self,
            width=width - pixels_per_number * number_space_required - 5,
            filled=filled,
            min_value=min_value,
            max_value=max_value,
            value=value,
        )
        self.label = LUILabel(parent=self, shadow=True, text=u"1.23")
        self.label.right = 0
        self.label.top = self.label.height - self.slider.height
        self.label.color = (1, 1, 1, 0.5)

        self.slider.add_change_callback(self._on_slider_changed)
        self.slider.add_change_callback(self._trigger_callback)
        self._on_slider_changed(self.slider, self.slider.get_value())

        if parent is not None:
            self.parent = parent

        self.fit_to_children()
Beispiel #12
0
 def __init__(self,
              parent=None,
              group=None,
              value=None,
              active=False,
              label=u"Radiobox",
              **kwargs):
     """ Constructs a new radiobox. group should be a handle to a LUIRadioboxGroup.
     value will be the value returned by group.value, in case the box was
     selected. By default, the radiobox is not active. """
     assert group is not None, "LUIRadiobox needs a LUIRadioboxGroup!"
     LUIObject.__init__(self, x=0, y=0, solid=True)
     self._sprite = LUISprite(self, "Radiobox_Default", "skin")
     self._label = LUILabel(parent=self,
                            text=label,
                            margin=(0, 0, 0, 23),
                            center_vertical=True)
     self._value = value
     self._active = False
     self._hovered = False
     self._group = group
     self._group.register_box(self)
     if active:
         self.set_active()
     if parent:
         self.parent = parent
     LUIInitialState.init(self, kwargs)
Beispiel #13
0
 def __init__(self, parent=None, key=u"A", instruction=u"Instruction"):
     LUIObject.__init__(self)
     self.marker = LUIKeyMarker(parent=self, key=key)
     self.instructionLabel = LUILabel(parent=self, text=instruction, shadow=True)
     self.instructionLabel.centered = (False, True)
     self.instructionLabel.margin.top = -4
     self.set_key(key)
Beispiel #14
0
    def __init__(self, parent=None, width=200, value=50, show_label=True):
        """ Constructs a new progress bar. If show_label is True, a label indicating
        the current progress is shown """
        LUIObject.__init__(self)
        self.set_width(width)

        self._bg_layout = LUIHorizontalStretchedLayout(
            parent=self, prefix="ProgressbarBg", width="100%")

        self._fg_left = LUISprite(self, "ProgressbarFg_Left", "skin")
        self._fg_mid = LUISprite(self, "ProgressbarFg", "skin")
        self._fg_right = LUISprite(self, "ProgressbarFg_Right", "skin")
        self._fg_finish = LUISprite(self, "ProgressbarFg_Finish", "skin")

        self._show_label = show_label
        self._progress_pixel = 0
        self._fg_finish.right = 0

        if self._show_label:
            self._progress_label = LUILabel(parent=self, text=u"33 %")
            self._progress_label.centered = (True, True)

        self.set_value(value)
        self._update_progress()

        if parent is not None:
            self.parent = parent
Beispiel #15
0
    def __init__(self, parent=None, key=u"A"):
        LUIObject.__init__(self)
        self.bgLeft = LUISprite(self, "Keymarker_Left", "skin")
        self.bgMid = LUISprite(self, "Keymarker", "skin")
        self.bgRight = LUISprite(self, "Keymarker_Right", "skin")

        self.label = LUILabel(parent=self, text=key, shadow=True)
        self.label.centered = (True, True)
        self.label.margin = (-3, 0, 0, -1)
        self.margin = (-1, 0, 0, -1)

        self.set_key(key)

        if parent is not None:
            self.parent = parent

        self.fit_to_children()
Beispiel #16
0
 def add(self, header, frame):
     # header
     if isinstance(header, str):
         header = LUILabel(text = header)
     self.header_bar.add(header, "?")
     self.header_to_frame[header] = frame
     header.solid = True
     header.bind("click", self._change_to_tab)
     # Frame
     frame.parent = self.main_frame
     frame.width = "100%"
     frame.height = "100%"
     # Put frame in front
     if self.current_frame is None:
         self.current_frame = frame
         self.current_frame.show()
     else:
         frame.hide()
Beispiel #17
0
 def add(self, header, frame):
     # header
     if isinstance(header, str):
         header = LUILabel(text=header)
     self.header_bar.add(header, "?")
     self.header_to_frame[header] = frame
     header.solid = True
     header.bind("click", self._change_to_tab)
     # Frame
     frame.parent = self.main_frame
     frame.width = "100%"
     frame.height = "100%"
     # Put frame in front
     if self.current_frame is None:
         self.current_frame = frame
         self.current_frame.show()
     else:
         frame.hide()
Beispiel #18
0
    def __init__(self, parent=None, width=200, placeholder=u"Enter some text ..", value=u""):
        LUIObject.__init__(self, x=0, y=0, w=width, h=0)
        LUICallback.__init__(self)

        self.bgLeft = LUISprite(self, "InputField_Left", "skin")
        self.bgMid = LUISprite(self, "InputField", "skin")
        self.bgRight = LUISprite(self, "InputField_Right", "skin")

        self.textContent = LUIObject(self)
        self.textContent.margin = (5, 8, 5, 8)
        self.textContent.clip_bounds = (0, 0, 0, 0)
        self.textContent.height = self.bgMid.height - 10
        self.textContent.width = self.width - 16

        self.textScroller = LUIObject(parent=self.textContent, x=0, y=0)
        self.text = LUILabel(parent=self.textScroller, text=u"", shadow=True)

        self.cursor = LUISprite(self.textScroller, "blank", "skin", x=0, y=0, w=2, h=15.0)
        self.cursor.color = (0.5, 0.5, 0.5)
        self.cursor.margin_top = 3
        self.cursor.z_offset = 20
        self.cursor_index = 0
        self.cursor.hide()

        self.value = value

        self.placeholder = LUILabel(parent=self.textContent, text=placeholder, shadow=False)
        self.placeholder.color = (1, 1, 1, 0.5)

        self.bgMid.width = self.width - self.bgLeft.width - self.bgRight.width
        self.bgMid.left = self.bgLeft.width
        self.bgRight.left = self.bgMid.width + self.bgMid.left

        if len(self.value) > 0:
            self.placeholder.hide()

        self.tickrate = 1.0
        self.tickstart = 0.0

        self.fit_to_children()
        self._render_text()

        if parent is not None:
            self.parent = parent
Beispiel #19
0
 def add(self, *args, **kwargs):
     """ Appends a new text. The arguments are equal to the arguments of
     LUILabel. The arguments shouldn't contain information about the
     placement like top_left, or center_vertical, since the labels are
     placed at explicit positions. """
     self._last_size = kwargs.get("font_size", 14)
     label = LUILabel(parent=self, left=self._cursor.x, top=self._cursor.y,
                      *args, **kwargs)
     # This is a bit of a hack, we should use a horizontal layout, but we
     # don't for performance reasons.
     self._cursor.x += label.text_handle.width
Beispiel #20
0
    def __init__(self, checked=False, label=u"Checkbox", **kwargs):
        """ Constructs a new checkbox with the given label and state. """
        LUIObject.__init__(self, x=0, y=0, w=0, h=0, solid=True)
        LUIInitialState.init(self, kwargs)
        self.checkboxSprite = LUISprite(self, "Checkbox_Default", "skin")
        self.label = LUILabel(parent=self, text=label, shadow=True, left=self.checkboxSprite.width + 6)
        self.label.top = self.label.height - self.checkboxSprite.height
        self.label.bind("resized", self._on_label_resized)
        self.fit_to_children()

        self.checked = checked
        self._update_sprite()
Beispiel #21
0
    def __init__(self, parent=None, width=200, placeholder=u"Enter some text ..", value=u"", **kwargs):
        """ Constructs a new input field. An input field always needs a width specified """
        LUIObject.__init__(self, x=0, y=0, solid=True)
        self.set_width(width)
        self._layout = LUIHorizontalStretchedLayout(parent=self, prefix="InputField", width="100%")

        # Container for the text
        self._text_content = LUIObject(self)
        self._text_content.margin = (5, 7, 5, 7)
        self._text_content.clip_bounds = (0,0,0,0)
        self._text_content.set_size("100%", "100%")

        # Scroller for the text, so we can move right and left
        self._text_scroller = LUIObject(parent=self._text_content)
        self._text_scroller.center_vertical = True
        self._text = LUILabel(parent=self._text_scroller, text=u"")

        # Cursor for the current position
        self._cursor = LUISprite(self._text_scroller, "blank", "skin", x=0, y=0, w=2, h=15)
        self._cursor.color = (0.5, 0.5, 0.5)
        self._cursor.margin.top = 2
        self._cursor.z_offset = 20
        self._cursor_index = 0
        self._cursor.hide()
        self._value = value

        # Placeholder text, shown when out of focus and no value exists
        self._placeholder = LUILabel(parent=self._text_content, text=placeholder, shadow=False,
            center_vertical=True, alpha=0.2)

        # Various states
        self._tickrate = 1.0
        self._tickstart = 0.0

        self._render_text()

        if parent is not None:
            self.parent = parent

        LUIInitialState.init(self, kwargs)
Beispiel #22
0
    def _render_options(self, options):
        """ Internal method to update the options """
        num_visible_options = min(30, len(options))
        offset_top = 6
        self._layout.height = num_visible_options * 30 + offset_top + 11
        self._container.height = num_visible_options * 30 + offset_top + 1
        self._container.remove_all_children()

        current_y = offset_top
        for opt_id, opt_val in options:
            opt_container = LUIObject(self._container,
                                      x=0,
                                      y=current_y,
                                      w=self._container.width - 30,
                                      h=30)

            opt_bg = LUISprite(opt_container, "blank", "skin")
            opt_bg.width = self._container.width
            opt_bg.height = opt_container.height
            opt_bg.color = (0, 0, 0, 0)
            opt_bg.bind("mouseover", self._on_opt_over)
            opt_bg.bind("mouseout", self._on_opt_out)
            opt_bg.bind("mousedown", lambda *args: self.request_focus())
            opt_bg.bind("click", partial(self._on_opt_click, opt_id))
            opt_bg.solid = True

            opt_label = LUILabel(parent=opt_container,
                                 text=opt_val.encode('utf-8'))
            opt_label.top = 8
            opt_label.left = 8

            if opt_id == self._selectbox.selected_option:
                opt_label.color = (0.6, 0.9, 0.4, 1.0)

            divider = LUISprite(opt_container, "SelectdropDivider", "skin")
            divider.top = 30 - divider.height / 2
            divider.width = self._container.width

            current_y += 30
Beispiel #23
0
 def __init__(self, checked=False, label=u"Checkbox", **kwargs):
     """ Constructs a new checkbox with the given label and state. By default,
     the checkbox is not checked. """
     LUIObject.__init__(self, x=0, y=0, solid=True)
     self._checked = checked
     self._checkbox_sprite = LUISprite(self, "Checkbox_Default", "skin")
     self._label = LUILabel(parent=self,
                            text=label,
                            margin=(0, 0, 0, 25),
                            center_vertical=True,
                            alpha=0.4)
     self._hovered = False
     LUIInitialState.init(self, kwargs)
Beispiel #24
0
 def add(self, *args, **kwargs):
     """ Appends a new text. The arguments are equal to the arguments of
     LUILabel. The arguments shouldn't contain information about the placement
     like top_left, or center_vertical. """
     if "font_size" in kwargs:
         self._last_size = kwargs["font_size"]
     else:
         self._last_size = 14
     label = LUILabel(parent=self,
                      left=self._cursor.x,
                      top=self._cursor.y,
                      *args,
                      **kwargs)
     # This is a bit of a hack, we should use a horizontal layout, but we don't
     # for performance reasons.
     self._cursor.x += label.text_handle.width
Beispiel #25
0
    def __init__(self, parent=None, group=None, value=None, text=u"Radiobox"):
        LUIObject.__init__(self)
        LUICallback.__init__(self)

        self.radiobox = LUIRadiobox(parent=self, group=group, value=value)
        self.label = LUILabel(parent=self, text=text, shadow=True)
        self.label.bind("click", self.radiobox.on_click)
        self.label.bind("mousedown", self.radiobox.on_mousedown)
        self.label.bind("mouseup", self.radiobox.on_mouseup)
        self.radiobox.add_change_callback(self._trigger_callback)

        if parent is not None:
            self.parent = parent

        self.label.left = self.radiobox.width + 6
        self.label.top = self.label.height - self.radiobox.height
        self.fit_to_children()
Beispiel #26
0
    def __init__(self, parent=None, key=u"A"):
        LUIObject.__init__(self)
        self.bgLeft = LUISprite(self, "Keymarker_Left", "skin")
        self.bgMid = LUISprite(self, "Keymarker", "skin")
        self.bgRight = LUISprite(self, "Keymarker_Right", "skin")

        self.label = LUILabel(parent=self, text=key, shadow=True)
        self.label.centered = (True, True)
        self.label.margin = (-3, 0, 0, -1)
        self.margin = (-1, 0, 0, -1)

        self.set_key(key)

        if parent is not None:
            self.parent = parent

        self.fit_to_children()
Beispiel #27
0
    def __init__(self, group=None, value=None, active=False, label=u"Radiobox", **kwargs):
        LUIObject.__init__(self, x=0, y=0, w=0, h=0, solid=True)
        LUIInitialState.init(self, kwargs)

        self.sprite = LUISprite(self, "Radiobox_Default", "skin")
        self.label = LUILabel(parent=self, text=label, shadow=True, left=self.sprite.width+6)
        self.label.top = self.label.height - self.sprite.height
        self.label.bind("resized", self._on_label_resized)

        self.fit_to_children()
        self.group = group
        self.group.register_box(self)
        self.active = False
        self.value = value

        if active:
            self.set_active()
Beispiel #28
0
    def __init__(self, width=200, options=None, selectedOption=None, **kwargs):
        LUIObject.__init__(self, x=0, y=0, w=width+4, h=0, solid=True)
        LUIInitialState.init(self, kwargs)
        LUICallback.__init__(self)

        # The selectbox has a small border, to correct this we move it
        self.margin_left = -2

        self.bgLeft = LUISprite(self, "Selectbox_Left", "skin")
        self.bgMid = LUISprite(self, "Selectbox", "skin")
        self.bgRight = LUISprite(self, "Selectbox_Right", "skin")

        self.bgMid.width = self.width - self.bgLeft.width - self.bgRight.width
        self.bgMid.left = self.bgLeft.width
        self.bgRight.left = self.bgMid.width + self.bgMid.left

        self.bgRight.z_offset = 1

        self.labelContainer = LUIObject(self, x=10, y=6, w=width - 20 - self.bgRight.width, h=self.bgMid.height - 6)
        self.labelContainer.clip_bounds = (0,0,0,0)

        self.label = LUILabel(parent=self.labelContainer, text=u"Select an option ..", shadow=True)

        self.bgRight.bind("mouseover", self._knob_mouseover)
        self.bgRight.bind("mouseout", self._knob_mouseout)
        self.bgRight.bind("click", self.on_click)
        self.bgRight.bind("click", self.on_click)

        self.fit_to_children()

        self.dropMenu = UISelectdrop(parent=self, width=width)
        self.dropMenu.top = self.bgMid.height - 7
        self.dropMenu.topmost = True

        self.dropOpen = False
        self.dropMenu.hide()

        self.options = []
        self.currentOptionId = None

        if options is not None:
            self.options = options

        self._select_option(selectedOption)
Beispiel #29
0
    def __init__(self, text=u"Button", template="ButtonDefault", **kwargs):
        """ Constructs a new button. The template controls which sprites to use.
        If the template is "ButtonDefault" for example, the sprites
        "ButtonDefault_Left", "ButtonDefault" and "ButtonDefault_Right" will
        be used. The sprites used when the button is pressed should be named
        "ButtonDefaultFocus_Left" and so on then.

        If an explicit width is set on the button, the button will stick to
        that width, otherwise it will automatically resize to fit the label """
        LUIObject.__init__(self, x=0, y=0, solid=True)
        self._template = template
        self._layout = LUIHorizontalStretchedLayout(parent=self,
                                                    prefix=self._template,
                                                    width="100%")
        self._label = LUILabel(parent=self, text=text)
        self._label.z_offset = 1
        self._label.center_vertical = True
        self._label.margin = 0, 20, 0, 20
        self.margin.left = -1
        LUIInitialState.init(self, kwargs)
Beispiel #30
0
    def __init__(self,
                 width=200,
                 options=None,
                 selected_option=None,
                 **kwargs):
        """ Constructs a new selectbox with a given width """
        LUIObject.__init__(self, x=0, y=0, w=width + 4, solid=True)
        LUIInitialState.init(self, kwargs)

        # The selectbox has a small border, to correct this we move it
        self.margin.left = -2

        self._bg_layout = LUIHorizontalStretchedLayout(parent=self,
                                                       prefix="Selectbox",
                                                       width="100%")

        self._label_container = LUIObject(self, x=10, y=0)
        self._label_container.set_size("100%", "100%")
        self._label_container.clip_bounds = (0, 0, 0, 0)
        self._label = LUILabel(parent=self._label_container,
                               text=u"Select an option ..")
        self._label.center_vertical = True

        self._drop_menu = LUISelectdrop(parent=self, width=width)
        self._drop_menu.top = self._bg_layout._sprite_right.height - 7
        self._drop_menu.topmost = True

        self._drop_open = False
        self._drop_menu.hide()

        self._options = []
        self._current_option_id = None

        if options is not None:
            self._options = options

        self._select_option(selected_option)
Beispiel #31
0
f = DemoFramework()
f.prepare_demo("LUILabel")

# Constructor

f.add_constructor_parameter("text", "u'Label'")
f.add_constructor_parameter("shadow", "True")
f.add_constructor_parameter("font_size", "14")
f.add_constructor_parameter("font", "'label'")

# Functions
f.add_public_function("get_text", [], "string")
f.add_public_function("set_text", [("text", "string")])

f.add_property("text", "string")
f.add_property("text_handle", "LUIText")

# Events
f.construct_sourcecode("LUILabel")

# Create a new label
label = LUILabel(parent=f.get_widget_node(), text="This is a fancy label")

f.set_actions({
        "Set Random Text": lambda: label.set_text(unicode(random.randint(100, 10000))),
        "Set Random Color": lambda: label.set_color(random.random(), random.random(), random.random(), 1)
    })

run()
Beispiel #32
0
class LUISelectbox(LUIObject, LUICallback):

    def __init__(self, width=200, options=None, selectedOption=None, **kwargs):
        LUIObject.__init__(self, x=0, y=0, w=width+4, h=0, solid=True)
        LUIInitialState.init(self, kwargs)
        LUICallback.__init__(self)

        # The selectbox has a small border, to correct this we move it
        self.margin_left = -2

        self.bgLeft = LUISprite(self, "Selectbox_Left", "skin")
        self.bgMid = LUISprite(self, "Selectbox", "skin")
        self.bgRight = LUISprite(self, "Selectbox_Right", "skin")

        self.bgMid.width = self.width - self.bgLeft.width - self.bgRight.width
        self.bgMid.left = self.bgLeft.width
        self.bgRight.left = self.bgMid.width + self.bgMid.left

        self.bgRight.z_offset = 1

        self.labelContainer = LUIObject(self, x=10, y=6, w=width - 20 - self.bgRight.width, h=self.bgMid.height - 6)
        self.labelContainer.clip_bounds = (0,0,0,0)

        self.label = LUILabel(parent=self.labelContainer, text=u"Select an option ..", shadow=True)

        self.bgRight.bind("mouseover", self._knob_mouseover)
        self.bgRight.bind("mouseout", self._knob_mouseout)
        self.bgRight.bind("click", self.on_click)
        self.bgRight.bind("click", self.on_click)

        self.fit_to_children()

        self.dropMenu = UISelectdrop(parent=self, width=width)
        self.dropMenu.top = self.bgMid.height - 7
        self.dropMenu.topmost = True

        self.dropOpen = False
        self.dropMenu.hide()

        self.options = []
        self.currentOptionId = None

        if options is not None:
            self.options = options

        self._select_option(selectedOption)

    def get_selected_option(self):
        return self.currentOptionId

    def _render_options(self):
        self.dropMenu._render_options(self.options)

    def set_options(self, options):
        self.options = options
        self.currentOptionId = None
        self._render_options()

    def _select_option(self, optid):
        self.label.color = (1,1,1,1)
        for optID, optVal in self.options:
            if optID == optid:
                self.label.set_text(optVal)
                self.currentOptionId = optID
                return
        self.label.color = (1,1,1,0.5)

    def _knob_mouseover(self, event):
        self.bgRight.color = (0.9,0.9,0.9,1.0)

    def _knob_mouseout(self, event):
        self.bgRight.color = (1,1,1,1.0)

    def on_click(self, event):
        self.request_focus()
        if self.dropOpen:
            self._close_drop()
        else:
            self._open_drop()

    def on_mousedown(self, event):
        self.bgLeft.color = (0.9,0.9,0.9,1.0)
        self.bgMid.color = (0.9,0.9,0.9,1.0)

    def on_mouseup(self, event):
        self.bgLeft.color = (1,1,1,1.0)
        self.bgMid.color = (1,1,1,1.0)

    def _open_drop(self):
        if not self.dropOpen:
            self._render_options()
            self.dropMenu.show()
            self.request_focus()

            self.dropOpen = True

    def _close_drop(self):
        if self.dropOpen:
            self.dropMenu.hide()

            self.dropOpen = False

    def _on_option_selected(self, optid):
        self._select_option(optid)
        self._close_drop()

    def on_blur(self, event):
        self._close_drop()
Beispiel #33
0
class LUIInputField(LUIObject):

    """ Simple input field, accepting text input. This input field supports
    entering text and navigating. Selecting text is (currently) not supported.

    The input field also supports various keyboard shortcuts:

        [pos1]                  Move to the beginning of the text
        [end]                   Move to the end of the text
        [arrow_left]            Move one character to the left
        [arrow_right]           Move one character to the right
        [ctrl] + [arrow_left]   Move to the left, skipping over words
        [ctrl] + [arrow_right]  Move to the right, skipping over words
        [escape]                Un-focus input element

    """

    re_skip = re.compile("\W*\w+\W")

    def __init__(self, parent=None, width=200, placeholder=u"Enter some text ..", value=u"", **kwargs):
        """ Constructs a new input field. An input field always needs a width specified """
        LUIObject.__init__(self, x=0, y=0, solid=True)
        self.set_width(width)
        self._layout = LUIHorizontalStretchedLayout(parent=self, prefix="InputField", width="100%")

        # Container for the text
        self._text_content = LUIObject(self)
        self._text_content.margin = (5, 7, 5, 7)
        self._text_content.clip_bounds = (0,0,0,0)
        self._text_content.set_size("100%", "100%")

        # Scroller for the text, so we can move right and left
        self._text_scroller = LUIObject(parent=self._text_content)
        self._text_scroller.center_vertical = True
        self._text = LUILabel(parent=self._text_scroller, text=u"")

        # Cursor for the current position
        self._cursor = LUISprite(self._text_scroller, "blank", "skin", x=0, y=0, w=2, h=15)
        self._cursor.color = (0.5, 0.5, 0.5)
        self._cursor.margin.top = 2
        self._cursor.z_offset = 20
        self._cursor_index = 0
        self._cursor.hide()
        self._value = value

        # Placeholder text, shown when out of focus and no value exists
        self._placeholder = LUILabel(parent=self._text_content, text=placeholder, shadow=False,
            center_vertical=True, alpha=0.2)

        # Various states
        self._tickrate = 1.0
        self._tickstart = 0.0

        self._render_text()

        if parent is not None:
            self.parent = parent

        LUIInitialState.init(self, kwargs)

    @property
    def value(self):
        """ Returns the value of the input field """
        return self._value

    @value.setter
    def value(self, new_value):
        """ Sets the value of the input field """
        self._value = unicode(new_value)
        self._render_text()
        self.trigger_event("changed", self._value)

    def clear(self):
        """ Clears the input value """
        self.value = u""

    @property
    def cursor_pos(self):
        """ Set the cursor position """
        return self._cursor_index

    @cursor_pos.setter
    def cursor_pos(self, pos):
        """ Set the cursor position """
        if pos >= 0:
            self._cursor_index = max(0, min(len(self._value), pos))
        else:
            self._cursor_index = max(len(self._value) + pos + 1, 0)
        self._reset_cursor_tick()
        self._render_text()

    def on_tick(self, event):
        """ Tick handler, gets executed every frame """
        frame_time = globalClock.get_frame_time() - self._tickstart
        show_cursor = frame_time % self._tickrate < 0.5 * self._tickrate
        if show_cursor:
            self._cursor.color = (0.5, 0.5, 0.5, 1)
        else:
            self._cursor.color = (1, 1, 1, 0)

    def on_click(self, event):
        """ Internal on click handler """
        self.request_focus()

    def on_mousedown(self, event):
        """ Internal mousedown handler """
        local_x_offset = self._text.text_handle.get_relative_pos(event.coordinates).x
        self.cursor_pos = self._text.text_handle.get_char_index(local_x_offset)

    def _reset_cursor_tick(self):
        """ Internal method to reset the cursor tick """
        self._tickstart = globalClock.get_frame_time()

    def on_focus(self, event):
        """ Internal focus handler """
        self._cursor.show()
        self._placeholder.hide()
        self._reset_cursor_tick()
        self._layout.color = (0.9, 0.9, 0.9, 1)

    def on_keydown(self, event):
        """ Internal keydown handler. Processes the special keys, and if none are
        present, redirects the event """
        key_name = event.message
        if key_name == "backspace":
            self._value = self._value[:max(0, self._cursor_index - 1)] + self._value[self._cursor_index:]
            self.cursor_pos -= 1
            self.trigger_event("changed", self._value)
        elif key_name == "delete":
            post_value = self._value[min(len(self._value), self._cursor_index + 1):]
            self._value = self._value[:self._cursor_index] + post_value
            self.cursor_pos = self._cursor_index
            self.trigger_event("changed", self._value)
        elif key_name == "arrow_left":
            if event.get_modifier_state("alt") or event.get_modifier_state("ctrl"):
                self.cursor_skip_left()
            else:
                self.cursor_pos -= 1
        elif key_name == "arrow_right":
            if event.get_modifier_state("alt") or event.get_modifier_state("ctrl"):
                self.cursor_skip_right()
            else:
                self.cursor_pos += 1
        elif key_name == "escape":
            self.blur()
        elif key_name == "home":
            self.cursor_pos = 0
        elif key_name == "end":
            self.cursor_pos = len(self.value)

        self.trigger_event(key_name, self._value)

    def on_keyrepeat(self, event):
        """ Internal keyrepeat handler """
        self.on_keydown(event)

    def on_textinput(self, event):
        """ Internal textinput handler """
        self._value = self._value[:self._cursor_index] + event.message + \
            self._value[self._cursor_index:]
        self.cursor_pos = self._cursor_index + len(event.message)
        self.trigger_event("changed", self._value)

    def on_blur(self, event):
        """ Internal blur handler """
        self._cursor.hide()
        if len(self._value) < 1:
            self._placeholder.show()

        self._layout.color = (1, 1, 1, 1)

    def _render_text(self):
        """ Internal method to render the text """
        self._text.set_text(self._value)
        self._cursor.left = self._text.left + \
            self._text.text_handle.get_char_pos(self._cursor_index) + 1
        max_left = self.width - 15

        if self._value:
            self._placeholder.hide()
        else:
            if not self.focused:
                self._placeholder.show()

        # Scroll if the cursor is outside of the clip bounds
        rel_pos = self.get_relative_pos(self._cursor.get_abs_pos()).x
        if rel_pos >= max_left:
            self._text_scroller.left = min(0, max_left - self._cursor.left)
        if rel_pos <= 0:
            self._text_scroller.left = min(0, - self._cursor.left - rel_pos)

    def cursor_skip_left(self):
        """ Moves the cursor to the left, skipping the previous word """
        left_hand_str = ''.join(reversed(self.value[0:self.cursor_pos]))
        match = self.re_skip.match(left_hand_str)
        if match is not None:
            self.cursor_pos -= match.end() - 1
        else:
            self.cursor_pos = 0

    def cursor_skip_right(self):
        """ Moves the cursor to the right, skipping the next word """
        right_hand_str = self.value[self.cursor_pos:]
        match = self.re_skip.match(right_hand_str)
        if match is not None:
            self.cursor_pos += match.end() - 1
        else:
            self.cursor_pos = len(self.value)
Beispiel #34
0
class LUIInputField(LUIObject, LUICallback):
    def __init__(self, parent=None, width=200, placeholder=u"Enter some text ..", value=u""):
        LUIObject.__init__(self, x=0, y=0, w=width, h=0)
        LUICallback.__init__(self)

        self.bgLeft = LUISprite(self, "InputField_Left", "skin")
        self.bgMid = LUISprite(self, "InputField", "skin")
        self.bgRight = LUISprite(self, "InputField_Right", "skin")

        self.textContent = LUIObject(self)
        self.textContent.margin = (5, 8, 5, 8)
        self.textContent.clip_bounds = (0, 0, 0, 0)
        self.textContent.height = self.bgMid.height - 10
        self.textContent.width = self.width - 16

        self.textScroller = LUIObject(parent=self.textContent, x=0, y=0)
        self.text = LUILabel(parent=self.textScroller, text=u"", shadow=True)

        self.cursor = LUISprite(self.textScroller, "blank", "skin", x=0, y=0, w=2, h=15.0)
        self.cursor.color = (0.5, 0.5, 0.5)
        self.cursor.margin_top = 3
        self.cursor.z_offset = 20
        self.cursor_index = 0
        self.cursor.hide()

        self.value = value

        self.placeholder = LUILabel(parent=self.textContent, text=placeholder, shadow=False)
        self.placeholder.color = (1, 1, 1, 0.5)

        self.bgMid.width = self.width - self.bgLeft.width - self.bgRight.width
        self.bgMid.left = self.bgLeft.width
        self.bgRight.left = self.bgMid.width + self.bgMid.left

        if len(self.value) > 0:
            self.placeholder.hide()

        self.tickrate = 1.0
        self.tickstart = 0.0

        self.fit_to_children()
        self._render_text()

        if parent is not None:
            self.parent = parent

    def _set_cursor_pos(self, pos):
        self.cursor_index = max(0, min(len(self.value), pos))
        self._reset_cursor_tick()

    def on_tick(self, event):
        frametime = globalClock.getFrameTime() - self.tickstart
        show_cursor = frametime % self.tickrate < 0.5 * self.tickrate
        if show_cursor:
            self.cursor.color = (0.5, 0.5, 0.5, 1)
        else:
            self.cursor.color = (1, 1, 1, 0)

    def _add_text(self, text):
        self.value = self.value[: self.cursor_index] + text + self.value[self.cursor_index :]
        self._set_cursor_pos(self.cursor_index + len(text))
        self._render_text()

    def on_click(self, event):
        self.request_focus()

    def on_mousedown(self, event):
        local_x_offset = self.text.text.get_relative_pos(event.coordinates).x
        self._set_cursor_pos(self.text.text.get_char_index(local_x_offset))
        self._render_text()

    def _reset_cursor_tick(self):
        self.tickstart = globalClock.getFrameTime()

    def on_focus(self, event):
        self.cursor.show()
        self.placeholder.hide()
        self._reset_cursor_tick()

        self.bgLeft.color = (0.9, 0.9, 0.9, 1)
        self.bgMid.color = (0.9, 0.9, 0.9, 1)
        self.bgRight.color = (0.9, 0.9, 0.9, 1)

    def on_keydown(self, event):
        key_name = event.get_message()
        if key_name == "backspace":
            self.value = self.value[: max(0, self.cursor_index - 1)] + self.value[self.cursor_index :]
            self._set_cursor_pos(self.cursor_index - 1)
            self._trigger_callback(self.value)
            self._render_text()
        elif key_name == "delete":
            self.value = self.value[: self.cursor_index] + self.value[min(len(self.value), self.cursor_index + 1) :]
            self._set_cursor_pos(self.cursor_index)
            self._trigger_callback(self.value)
            self._render_text()
        elif key_name == "arrow_left":
            self._set_cursor_pos(self.cursor_index - 1)
            self._render_text()
        elif key_name == "arrow_right":
            self._set_cursor_pos(self.cursor_index + 1)
            self._render_text()

    def on_keyrepeat(self, event):
        self.on_keydown(event)

    def on_textinput(self, event):
        self._add_text(event.get_message())
        self._trigger_callback(self.value)

    def on_blur(self, event):
        self.cursor.hide()
        if len(self.value) < 1:
            self.placeholder.show()

        self.bgLeft.color = (1, 1, 1, 1)
        self.bgMid.color = (1, 1, 1, 1)
        self.bgRight.color = (1, 1, 1, 1)

    def get_value(self):
        return self.value

    def set_value(self, value):
        self.value = value
        # QUESTION: Should we trigger a callback when the user changes the value hisself?
        self._trigger_callback(self.value)
        self._render_text()

    def _render_text(self):
        self.text.set_text(self.value)
        self.cursor.left = self.text.left + self.text.text.get_char_pos(self.cursor_index) + 1
        max_left = self.width - 20

        # Scroll if the cursor is outside of the clip bounds
        relX = self.get_relative_pos(self.cursor.get_abs_pos()).x
        if relX >= max_left:
            self.textScroller.left = min(0, max_left - self.cursor.left)
        if relX <= 0:
            self.textScroller.left = min(0, -self.cursor.left - relX)
Beispiel #35
0
class LUIProgressbar(LUIObject):

    """ A simple progress bar """

    def __init__(self, parent=None, width=200, value=50, show_label=True):
        """ Constructs a new progress bar. If show_label is True, a label indicating
        the current progress is shown """
        LUIObject.__init__(self)
        self.set_width(width)

        self._bg_layout = LUIHorizontalStretchedLayout(
            parent=self, prefix="ProgressbarBg", width="100%")

        self._fg_left = LUISprite(self, "ProgressbarFg_Left", "skin")
        self._fg_mid = LUISprite(self, "ProgressbarFg", "skin")
        self._fg_right = LUISprite(self, "ProgressbarFg_Right", "skin")
        self._fg_finish = LUISprite(self, "ProgressbarFg_Finish", "skin")

        self._show_label = show_label
        self._progress_pixel = 0
        self._fg_finish.right = 0

        if self._show_label:
            self._progress_label = LUILabel(parent=self, text=u"33 %")
            self._progress_label.centered = (True, True)

        self.set_value(value)
        self._update_progress()

        if parent is not None:
            self.parent = parent

    def get_value(self):
        """ Returns the current value of the progress bar """
        return (self._progress_pixel / self.width * 100.0)

    def set_value(self, val):
        """ Sets the value of the progress bar """
        val = max(0, min(100, val))
        self._progress_pixel = int(val / 100.0 * self.width)
        self._update_progress()

    value = property(get_value, set_value)

    def _update_progress(self):
        """ Internal method to update the progressbar """
        self._fg_finish.hide()

        if self._progress_pixel <= self._fg_left.width + self._fg_right.width:
            self._fg_mid.hide()
            self._fg_right.left = self._fg_left.width
        else:
            self._fg_mid.show()
            self._fg_mid.left = self._fg_left.width
            self._fg_mid.width = self._progress_pixel - self._fg_right.width - self._fg_left.width
            self._fg_right.left = self._fg_mid.left + self._fg_mid.width

            if self._progress_pixel >= self.width - self._fg_right.width:
                self._fg_finish.show()
                self._fg_finish.right = - (self.width - self._progress_pixel)
                self._fg_finish.clip_bounds = (0, self.width - self._progress_pixel, 0, 0)

        if self._show_label:
            percentage = self._progress_pixel / self.width * 100.0
            self._progress_label.set_text(unicode(int(percentage)) + u" %")
Beispiel #36
0
f.add_constructor_parameter("show_label", "False")

# Functions
f.add_public_function("get_value", [], "float")
f.add_public_function("set_value", [("value", "float")])

f.add_property("value", "float")

# Events
f.construct_sourcecode("LUIProgressbar")

# Create the checkbox
layout = LUIVerticalLayout(parent=f.get_widget_node(), spacing=10)

LUILabel(parent=layout.cell(),
         text="This is a progressbar:",
         color=(1, 1, 1, 0.4))
bar = LUIProgressbar(parent=layout.cell(), width=200.0)

LUILabel(parent=layout.cell(),
         text="You can control it with this slider:",
         color=(1, 1, 1, 0.4))
slider = LUISlider(parent=layout.cell(), width=200.0, filled=True)
slider.bind("changed", lambda event: bar.set_value(slider.value * 100.0))

f.set_actions({
    "Set to 30%": lambda: bar.set_value(30),
})

run()
Beispiel #37
0
    def __init__(self, parent=None):
        LUIPopup.__init__(self, parent=parent, width=240, height=146)
        LUICallback.__init__(self)

        self.field = LUIObject(self.content, x=0, y=0, w=128, h=128)

        self.fieldBG = LUISprite(self.field, "blank", "skin")
        self.fieldBG.size = (128, 128)
        self.fieldBG.color = (0.2, 0.6, 1.0)
        self.fieldFG = LUISprite(self.field, "ColorpickerFieldOverlay", "skin")
        self.fieldFG.pos = (-2, 0)

        self.fieldBG.bind("mousedown", self._start_field_dragging)
        self.fieldBG.bind("mouseup", self._stop_field_dragging)

        self.fieldHandle = LUISprite(self.field, "ColorpickerFieldHandle",
                                     "skin")
        self.fieldHandle.bind("mousedown", self._start_field_dragging)
        self.fieldHandle.bind("mouseup", self._stop_field_dragging)

        self.fieldDragging = False

        self.hueSlider = LUIObject(self.content, x=140, y=0, w=40, h=128)
        self.hueSliderFG = LUISprite(self.hueSlider, "ColorpickerHueSlider",
                                     "skin")

        self.hueHandle = LUISprite(self.hueSlider, "ColorpickerHueHandle",
                                   "skin")
        self.hueHandle.left = (self.hueSliderFG.width -
                               self.hueHandle.width) / 2.0
        self.hueHandle.top = 50

        self.hueDragging = False
        self.hueSlider.bind("mousedown", self._start_hue_dragging)
        self.hueSlider.bind("mouseup", self._stop_hue_dragging)

        self.labels = LUIVerticalLayout(self.content, width=40)
        self.labels.pos = (177, 42)

        colors = [u"R", u"G", u"B"]
        self.colorLabels = []

        for color in colors:
            label = LUILabel(text=color, shadow=True)
            label.color = (1, 1, 1, 0.3)

            valueLabel = LUILabel(text=u"255", shadow=True)
            valueLabel.right = 0
            self.labels.add(label, valueLabel)
            self.colorLabels.append(valueLabel)

        self.activeColor = LUIObject(self.content, x=177, y=0)
        self.activeColorBG = LUISprite(self.activeColor, "blank", "skin")
        self.activeColorFG = LUISprite(self.activeColor,
                                       "ColorpickerActiveColorOverlay", "skin")

        self.activeColorBG.size = (40, 40)
        self.activeColorBG.pos = (2, 0)
        self.activeColorBG.color = (0.2, 0.6, 1.0, 1.0)

        self.closeButton = LUIButton(parent=self.content,
                                     text=u"Done",
                                     width=45,
                                     template="ButtonGreen")
        self.closeButton.left = 177
        self.closeButton.top = 98
        self.closeButton.bind("click", self._close_popup)

        self._set_hue(0.5)
        self._set_sat_val(0.5, 0.5)

        self.widget = parent
Beispiel #38
0
    skin = LUIMetroSkin()
    base.win.set_clear_color(Vec4(1))
else:
    skin = LUIDefaultSkin()
    base.win.set_clear_color(Vec4(0.1, 0.0, 0.0, 1))

skin.load()

# Initialize LUI
region = LUIRegion.make("LUI", base.win)
handler = LUIInputHandler()
base.mouseWatcher.attach_new_node(handler)
region.set_input_handler(handler)

# Title
title_label = LUILabel(parent=region.root, text="LUI Console Example", font_size=40,
                       font="header", pos=(25, 17))

# Container
container = LUIFrame(parent = region.root, width=700, height=500,
    style=LUIFrame.FS_sunken, margin=30, top=50)

text_container = LUIScrollableRegion(parent=container, width=675, height=440,
    padding=0)

base.win.set_clear_color(Vec4(0.1, 0.1, 0.1, 1.0))
layout = LUIVerticalLayout(parent=text_container.content_node)

def send_command(event):
    """ Called when the user presses enter in the input field, submits the
    command and prints something on the console """
    label = LUIFormattedLabel()
Beispiel #39
0
# Constructor
f.add_constructor_parameter("filled", "False")
f.add_constructor_parameter("min_value", "0.0")
f.add_constructor_parameter("max_value", "0.0")
f.add_constructor_parameter("value", "None")

# Functions
f.add_public_function("get_value", [], "float")
f.add_public_function("set_value", [("value", "float")])

f.add_property("value", "float")

# Events
f.add_event("changed")
f.construct_sourcecode("LUISlider")

# Create the checkbox
layout = LUIVerticalLayout(parent=f.get_widget_node(), spacing=10)

LUILabel(parent=layout.cell(), text="This is a filled slider:", color=(1, 1, 1, 0.4))
slider = LUISlider(parent=layout.cell(), width=200.0)

LUILabel(parent=layout.cell(), text="This is a regular slider:", color=(1, 1, 1, 0.4))
slider_nofill = LUISlider(parent=layout.cell(), width=200.0, filled=False)

f.set_actions({
        "Set to 30%": lambda: slider.set_value(0.3),
    })

run()
Beispiel #40
0
 def add_event(self, event_name):
     label = LUILabel(text=event_name)
     label.color = (1, 1, 1, 0.5)
     self._events_layout.add(label)
     self.update_layouts()
Beispiel #41
0
# label_tl = LUILabel(parent=container, text="Top Left", top_left=(0,0))
# label_tr = LUILabel(parent=container, text="Top Right", top_right=(0,0))
# label_bl = LUILabel(parent=container, text="Bottom Left", bottom_left=(0,0))
# label_br = LUILabel(parent=container, text="Bottom Right", bottom_right=(0,0))

# button = LUIButton(parent=container, top_left=(0, 0), text="Well this one .. is a long button! (A really long one!) ............ really long!")
# button.bind("click", lambda event: button.set_text("Hello!"))
container.size = 300, 300
# group = LUIRadioboxGroup()
# box = LUIRadiobox(parent=container, group=group, top=50)
# box2 = LUICheckbox(parent=container, top=100)

layout = LUIVerticalLayout(parent=container)
# layout.height = 280
# layout.width = 300

LUILabel(parent=layout.cell(), text="Hello")
LUILabel(parent=layout.cell(), text="World")
LUILabel(parent=layout.cell(100), text="100px row")
LUILabel(parent=layout.cell(), text="Next")
LUIButton(parent=layout.cell(), text="SomeButton")
LUILabel(parent=layout.cell('*'), text="Fill column")
LUILabel(parent=layout.cell(), text="Last column")

for i in range(5):
    base.graphicsEngine.render_frame()

region.root.ls()

s.run()
Beispiel #42
0
# Constructor
f.add_constructor_parameter("width", "200")
f.add_constructor_parameter("height", "200")
f.add_constructor_parameter("innerPadding", "5")
f.add_constructor_parameter("scrollable", "False")
f.add_constructor_parameter("style", "UIFrame.Raised")

# Functions

# Events
f.construct_sourcecode("LUIFrame")

# Construct a new frame
frame = LUIFrame(parent=f.get_widget_node())

layout = LUIVerticalLayout(parent=frame, spacing=5)
layout.add(LUILabel(text="This is some frame ..", color=(0.2, 0.6, 1.0, 1.0), font_size=20))
layout.add(LUILabel(text="It can contain arbitrary elements."))
layout.add(LUILabel(text="For example this button:"))
layout.add(LUIButton(text="Fancy button"))

# frame.fit_to_children()

f.set_actions({
        "Resize to 300x160": lambda: frame.set_size(300, 160),
        "Fit to children": lambda: frame.clear_size(),
    })

run()
Beispiel #43
0
 def add_event(self, event_name):
     label = LUILabel(text=event_name)
     label.color = (1,1,1,0.5)
     self.eventsLayout.add_row(label)
     self.update_layouts()
Beispiel #44
0
from DemoFramework import DemoFramework
from LUILabel import LUILabel

import random

f = DemoFramework()
f.prepare_demo("LUILabel")

# Constructor

f.add_constructor_parameter("text", "u'Label'")
f.add_constructor_parameter("shadow", "True")
f.add_constructor_parameter("font_size", "14")
f.add_constructor_parameter("font", "'label'")

# Functions
f.add_public_function("get_text", [], "string")
f.add_public_function("set_text", [("text", "string")])

# Events
f.construct_sourcecode("LUILabel")

# Create a new label
label = LUILabel(parent=f.get_widget_node(), text="This is a fancy label")

f.set_actions({
        "Set Random Text": lambda: label.set_text(unicode(random.randint(100, 10000))),
    })

run()
Beispiel #45
0
    def __init__(self, parent=None):
        LUIPopup.__init__(self, parent=parent, width=240, height=146)
        LUICallback.__init__(self)

        self.field = LUIObject(self.content, x=0, y=0, w=128, h=128)

        self.fieldBG = LUISprite(self.field, "blank", "skin")
        self.fieldBG.size = (128, 128)
        self.fieldBG.color = (0.2, 0.6, 1.0)
        self.fieldFG = LUISprite(self.field, "ColorpickerFieldOverlay", "skin")
        self.fieldFG.pos = (-2, 0)

        self.fieldBG.bind("mousedown", self._start_field_dragging)
        self.fieldBG.bind("mouseup", self._stop_field_dragging)

        self.fieldHandle = LUISprite(self.field, "ColorpickerFieldHandle", "skin")
        self.fieldHandle.bind("mousedown", self._start_field_dragging)
        self.fieldHandle.bind("mouseup", self._stop_field_dragging)

        self.fieldDragging = False

        self.hueSlider = LUIObject(self.content, x=140, y=0, w=40, h=128)
        self.hueSliderFG = LUISprite(self.hueSlider, "ColorpickerHueSlider", "skin")

        self.hueHandle = LUISprite(self.hueSlider, "ColorpickerHueHandle", "skin")
        self.hueHandle.left = (self.hueSliderFG.width - self.hueHandle.width) / 2.0
        self.hueHandle.top = 50

        self.hueDragging = False
        self.hueSlider.bind("mousedown", self._start_hue_dragging)
        self.hueSlider.bind("mouseup", self._stop_hue_dragging)

        self.labels = LUIVerticalLayout(self.content, width=40)
        self.labels.pos = (177, 42)

        colors = [u"R", u"G", u"B"]
        self.colorLabels = []

        for color in colors:
            label = LUILabel(text=color, shadow=True)
            label.color = (1, 1, 1, 0.3)

            valueLabel = LUILabel(text=u"255", shadow=True)
            valueLabel.right = 0
            self.labels.add_row(label, valueLabel)
            self.colorLabels.append(valueLabel)

        self.activeColor = LUIObject(self.content, x=177, y=0)
        self.activeColorBG = LUISprite(self.activeColor, "blank", "skin")
        self.activeColorFG = LUISprite(self.activeColor, "ColorpickerActiveColorOverlay", "skin")

        self.activeColorBG.size = (40, 40)
        self.activeColorBG.pos = (2, 0)
        self.activeColorBG.color = (0.2, 0.6, 1.0, 1.0)

        self.closeButton = LUIButton(parent=self.content, text=u"Done", width=45, template="ButtonMagic")
        self.closeButton.left = 177
        self.closeButton.top = 98
        self.closeButton.bind("click", self._close_popup)

        self._set_hue(0.5)
        self._set_sat_val(0.5, 0.5)

        self.widget = parent
Beispiel #46
0
class LUIInputField(LUIObject):

    """ Simple input field """

    def __init__(self, parent=None, width=200, placeholder=u"Enter some text ..", value=u"", **kwargs):
        """ Constructs a new input field. An input field always needs a width specified """
        LUIObject.__init__(self, x=0, y=0, solid=True)
        self.set_width(width)
        self._layout = LUIHorizontalStretchedLayout(parent=self, prefix="InputField", width="100%")

        # Container for the text
        self._text_content = LUIObject(self)
        self._text_content.margin = (5, 7, 5, 7)
        self._text_content.clip_bounds = (0,0,0,0)
        self._text_content.set_size("100%", "100%")

        # Scroller for the text, so we can move right and left
        self._text_scroller = LUIObject(parent=self._text_content)
        self._text_scroller.center_vertical = True
        self._text = LUILabel(parent=self._text_scroller, text=u"")

        # Cursor for the current position
        self._cursor = LUISprite(self._text_scroller, "blank", "skin", x=0, y=0, w=2, h=15)
        self._cursor.color = (0.5, 0.5, 0.5)
        self._cursor.margin.top = 2
        self._cursor.z_offset = 20
        self._cursor_index = 0
        self._cursor.hide()
        self._value = value

        # Placeholder text, shown when out of focus and no value exists
        self._placeholder = LUILabel(parent=self._text_content, text=placeholder, shadow=False,
            center_vertical=True, alpha=0.2)

        # Various states
        self._tickrate = 1.0
        self._tickstart = 0.0

        self._render_text()

        if parent is not None:
            self.parent = parent

        LUIInitialState.init(self, kwargs)

    def get_value(self):
        """ Returns the value of the input field """
        return self._value

    def set_value(self, value):
        """ Sets the value of the input field """
        self._value = unicode(value)
        self.trigger_event("changed", self._value)
        self._render_text()

    value = property(get_value, set_value)

    def clear(self):
        """ Clears the input value """
        self.value = u""

    def _set_cursor_pos(self, pos):
        """ Internal method to set the cursor position """
        self._cursor_index = max(0, min(len(self._value), pos))
        self._reset_cursor_tick()

    def on_tick(self, event):
        """ Tick handler, gets executed every frame """
        frametime = globalClock.get_frame_time() - self._tickstart
        show_cursor = frametime % self._tickrate < 0.5 * self._tickrate
        if show_cursor:
            self._cursor.color = (0.5,0.5,0.5,1)
        else:
            self._cursor.color = (1,1,1,0)

    def _add_text(self, text):
        """ Internal method to append text """
        self._value = self._value[:self._cursor_index] + text + self._value[self._cursor_index:]
        self._set_cursor_pos(self._cursor_index + len(text))
        self._render_text()

    def on_click(self, event):
        """ Internal on click handler """
        self.request_focus()

    def on_mousedown(self, event):
        """ Internal mousedown handler """
        local_x_offset = self._text.text_handle.get_relative_pos(event.coordinates).x
        self._set_cursor_pos(self._text.text_handle.get_char_index(local_x_offset))
        self._render_text()

    def _reset_cursor_tick(self):
        """ Internal method to reset the cursor tick """
        self._tickstart = globalClock.getFrameTime()

    def on_focus(self, event):
        """ Internal focus handler """
        self._cursor.show()
        self._placeholder.hide()
        self._reset_cursor_tick()

        self._layout.color  = (0.9,0.9,0.9,1)

    def on_keydown(self, event):
        """ Internal keydown handler """
        key_name = event.message
        if key_name == "backspace":
            self._value = self._value[:max(0, self._cursor_index - 1)] + self._value[self._cursor_index:]
            self._set_cursor_pos(self._cursor_index - 1)
            self.trigger_event("changed", self._value)
            self._render_text()
        elif key_name == "delete":
            self._value = self._value[:self._cursor_index] + self._value[min(len(self._value), self._cursor_index + 1):]
            self._set_cursor_pos(self._cursor_index)
            self.trigger_event("changed", self._value)
            self._render_text()
        elif key_name == "arrow_left":
            self._set_cursor_pos(self._cursor_index - 1)
            self._render_text()
        elif key_name == "arrow_right":
            self._set_cursor_pos(self._cursor_index + 1)
            self._render_text()

        self.trigger_event(key_name, self._value)

    def on_keyrepeat(self, event):
        """ Internal keyrepeat handler """
        self.on_keydown(event)

    def on_textinput(self, event):
        """ Internal textinput handler """
        self._add_text(event.message)
        self.trigger_event("changed", self._value)

    def on_blur(self, event):
        """ Internal blur handler """
        self._cursor.hide()
        if len(self._value) < 1:
            self._placeholder.show()

        self._layout.color = (1,1,1,1)

    def _render_text(self):
        """ Internal method to render the text """
        self._text.set_text(self._value)
        self._cursor.left = self._text.left + self._text.text_handle.get_char_pos(self._cursor_index) + 1
        max_left = self.width - 15

        if self._value:
            self._placeholder.hide()
        else:
            if not self.focused:
                self._placeholder.show()

        # Scroll if the cursor is outside of the clip bounds
        rel_pos = self.get_relative_pos(self._cursor.get_abs_pos()).x
        if rel_pos >= max_left:
            self._text_scroller.left = min(0, max_left - self._cursor.left)
        if rel_pos <= 0:
            self._text_scroller.left = min(0, - self._cursor.left - rel_pos)
Beispiel #47
0
# Constructor

f.add_constructor_parameter("text", "Label")
f.add_constructor_parameter("shadow", "True")
f.add_constructor_parameter("font_size", "14")
f.add_constructor_parameter("font", "'label'")

# Functions
f.add_public_function("get_text", [], "string")
f.add_public_function("set_text", [("text", "string")])

f.add_property("text", "string")
f.add_property("text_handle", "LUIText")

# Events
f.construct_sourcecode("LUILabel")

# Create a new label
label = LUILabel(parent=f.get_widget_node(), text="This is a fancy label")

f.set_actions({
    "Set Random Text":
    lambda: label.set_text(str(random.randint(100, 10000))),
    "Set Random Color":
    lambda: label.set_color(random.random(), random.random(), random.random(),
                            1)
})

run()
Beispiel #48
0
class LUIInputField(LUIObject):
    """ Simple input field, accepting text input. This input field supports
    entering text and navigating. Selecting text is (currently) not supported.

    The input field also supports various keyboard shortcuts:

        [pos1]                  Move to the beginning of the text
        [end]                   Move to the end of the text
        [arrow_left]            Move one character to the left
        [arrow_right]           Move one character to the right
        [ctrl] + [arrow_left]   Move to the left, skipping over words
        [ctrl] + [arrow_right]  Move to the right, skipping over words
        [escape]                Un-focus input element

    """

    re_skip = re.compile("\W*\w+\W")

    def __init__(self,
                 parent=None,
                 width=200,
                 placeholder=u"Enter some text ..",
                 value=u"",
                 **kwargs):
        """ Constructs a new input field. An input field always needs a width specified """
        LUIObject.__init__(self, x=0, y=0, solid=True)
        self.set_width(width)
        self._layout = LUIHorizontalStretchedLayout(parent=self,
                                                    prefix="InputField",
                                                    width="100%")

        # Container for the text
        self._text_content = LUIObject(self)
        self._text_content.margin = (5, 7, 5, 7)
        self._text_content.clip_bounds = (0, 0, 0, 0)
        self._text_content.set_size("100%", "100%")

        # Scroller for the text, so we can move right and left
        self._text_scroller = LUIObject(parent=self._text_content)
        self._text_scroller.center_vertical = True
        self._text = LUILabel(parent=self._text_scroller, text=u"")

        # Cursor for the current position
        self._cursor = LUISprite(self._text_scroller,
                                 "blank",
                                 "skin",
                                 x=0,
                                 y=0,
                                 w=2,
                                 h=15)
        self._cursor.color = (0.5, 0.5, 0.5)
        self._cursor.margin.top = 2
        self._cursor.z_offset = 20
        self._cursor_index = 0
        self._cursor.hide()
        self._value = value

        # Placeholder text, shown when out of focus and no value exists
        self._placeholder = LUILabel(parent=self._text_content,
                                     text=placeholder,
                                     shadow=False,
                                     center_vertical=True,
                                     alpha=0.2)

        # Various states
        self._tickrate = 1.0
        self._tickstart = 0.0

        self._render_text()

        if parent is not None:
            self.parent = parent

        LUIInitialState.init(self, kwargs)

    @property
    def value(self):
        """ Returns the value of the input field """
        return self._value

    @value.setter
    def value(self, new_value):
        """ Sets the value of the input field """
        if sys.version_info[0] < 3:
            self._value = unicode(new_value)
        else:
            self._value = str(new_value)
        self._render_text()
        self.trigger_event("changed", self._value)

    def clear(self):
        """ Clears the input value """
        self.value = u""

    @property
    def cursor_pos(self):
        """ Set the cursor position """
        return self._cursor_index

    @cursor_pos.setter
    def cursor_pos(self, pos):
        """ Set the cursor position """
        if pos >= 0:
            self._cursor_index = max(0, min(len(self._value), pos))
        else:
            self._cursor_index = max(len(self._value) + pos + 1, 0)
        self._reset_cursor_tick()
        self._render_text()

    def on_tick(self, event):
        """ Tick handler, gets executed every frame """
        frame_time = globalClock.get_frame_time() - self._tickstart
        show_cursor = frame_time % self._tickrate < 0.5 * self._tickrate
        if show_cursor:
            self._cursor.color = (0.5, 0.5, 0.5, 1)
        else:
            self._cursor.color = (1, 1, 1, 0)

    def on_click(self, event):
        """ Internal on click handler """
        self.request_focus()

    def on_mousedown(self, event):
        """ Internal mousedown handler """
        local_x_offset = self._text.text_handle.get_relative_pos(
            event.coordinates).x
        self.cursor_pos = self._text.text_handle.get_char_index(local_x_offset)

    def _reset_cursor_tick(self):
        """ Internal method to reset the cursor tick """
        self._tickstart = globalClock.get_frame_time()

    def on_focus(self, event):
        """ Internal focus handler """
        self._cursor.show()
        self._placeholder.hide()
        self._reset_cursor_tick()
        self._layout.color = (0.9, 0.9, 0.9, 1)

    def on_keydown(self, event):
        """ Internal keydown handler. Processes the special keys, and if none are
        present, redirects the event """
        key_name = event.message
        if key_name == "backspace":
            self._value = self._value[:max(0, self._cursor_index -
                                           1)] + self._value[self.
                                                             _cursor_index:]
            self.cursor_pos -= 1
            self.trigger_event("changed", self._value)
        elif key_name == "delete":
            post_value = self._value[min(len(self._value), self._cursor_index +
                                         1):]
            self._value = self._value[:self._cursor_index] + post_value
            self.cursor_pos = self._cursor_index
            self.trigger_event("changed", self._value)
        elif key_name == "arrow_left":
            if event.get_modifier_state("alt") or event.get_modifier_state(
                    "ctrl"):
                self.cursor_skip_left()
            else:
                self.cursor_pos -= 1
        elif key_name == "arrow_right":
            if event.get_modifier_state("alt") or event.get_modifier_state(
                    "ctrl"):
                self.cursor_skip_right()
            else:
                self.cursor_pos += 1
        elif key_name == "escape":
            self.blur()
        elif key_name == "home":
            self.cursor_pos = 0
        elif key_name == "end":
            self.cursor_pos = len(self.value)

        self.trigger_event(key_name, self._value)

    def on_keyrepeat(self, event):
        """ Internal keyrepeat handler """
        self.on_keydown(event)

    def on_textinput(self, event):
        """ Internal textinput handler """
        self._value = self._value[:self._cursor_index] + event.message + \
            self._value[self._cursor_index:]
        self.cursor_pos = self._cursor_index + len(event.message)
        self.trigger_event("changed", self._value)

    def on_blur(self, event):
        """ Internal blur handler """
        self._cursor.hide()
        if len(self._value) < 1:
            self._placeholder.show()

        self._layout.color = (1, 1, 1, 1)

    def _render_text(self):
        """ Internal method to render the text """
        self._text.set_text(self._value)
        self._cursor.left = self._text.left + \
            self._text.text_handle.get_char_pos(self._cursor_index) + 1
        max_left = self.width - 15

        if self._value:
            self._placeholder.hide()
        else:
            if not self.focused:
                self._placeholder.show()

        # Scroll if the cursor is outside of the clip bounds
        rel_pos = self.get_relative_pos(self._cursor.get_abs_pos()).x
        if rel_pos >= max_left:
            self._text_scroller.left = min(0, max_left - self._cursor.left)
        if rel_pos <= 0:
            self._text_scroller.left = min(0, -self._cursor.left - rel_pos)

    def cursor_skip_left(self):
        """ Moves the cursor to the left, skipping the previous word """
        left_hand_str = ''.join(reversed(self.value[0:self.cursor_pos]))
        match = self.re_skip.match(left_hand_str)
        if match is not None:
            self.cursor_pos -= match.end() - 1
        else:
            self.cursor_pos = 0

    def cursor_skip_right(self):
        """ Moves the cursor to the right, skipping the next word """
        right_hand_str = self.value[self.cursor_pos:]
        match = self.re_skip.match(right_hand_str)
        if match is not None:
            self.cursor_pos += match.end() - 1
        else:
            self.cursor_pos = len(self.value)
Beispiel #49
0
class LUIProgressbar(LUIObject):
    """ A simple progress bar """
    def __init__(self, parent=None, width=200, value=50, show_label=True):
        """ Constructs a new progress bar. If show_label is True, a label indicating
        the current progress is shown """
        LUIObject.__init__(self)
        self.set_width(width)

        self._bg_layout = LUIHorizontalStretchedLayout(parent=self,
                                                       prefix="ProgressbarBg",
                                                       width="100%")

        self._fg_left = LUISprite(self, "ProgressbarFg_Left", "skin")
        self._fg_mid = LUISprite(self, "ProgressbarFg", "skin")
        self._fg_right = LUISprite(self, "ProgressbarFg_Right", "skin")
        self._fg_finish = LUISprite(self, "ProgressbarFg_Finish", "skin")

        self._show_label = show_label
        self._progress_pixel = 0
        self._fg_finish.right = 0

        if self._show_label:
            self._progress_label = LUILabel(parent=self, text=u"33 %")
            self._progress_label.centered = (True, True)

        self.set_value(value)
        self._update_progress()

        if parent is not None:
            self.parent = parent

    def get_value(self):
        """ Returns the current value of the progress bar """
        return (self._progress_pixel / self.width * 100.0)

    def set_value(self, val):
        """ Sets the value of the progress bar """
        val = max(0, min(100, val))
        self._progress_pixel = int(val / 100.0 * self.width)
        self._update_progress()

    value = property(get_value, set_value)

    def _update_progress(self):
        """ Internal method to update the progressbar """
        self._fg_finish.hide()

        if self._progress_pixel <= self._fg_left.width + self._fg_right.width:
            self._fg_mid.hide()
            self._fg_right.left = self._fg_left.width
        else:
            self._fg_mid.show()
            self._fg_mid.left = self._fg_left.width
            self._fg_mid.width = self._progress_pixel - self._fg_right.width - self._fg_left.width
            self._fg_right.left = self._fg_mid.left + self._fg_mid.width

            if self._progress_pixel >= self.width - self._fg_right.width:
                self._fg_finish.show()
                self._fg_finish.right = -(self.width - self._progress_pixel)
                self._fg_finish.clip_bounds = (0, self.width -
                                               self._progress_pixel, 0, 0)

        if self._show_label:
            percentage = self._progress_pixel / self.width * 100.0
            self._progress_label.set_text(unicode(int(percentage)) + u" %")
Beispiel #50
0
class LUIRadiobox(LUIObject):

    """ A radiobox which can be used in combination with a LUIRadioboxGroup """

    def __init__(self, group=None, value=None, active=False, label=u"Radiobox", **kwargs):
        LUIObject.__init__(self, x=0, y=0, w=0, h=0, solid=True)
        LUIInitialState.init(self, kwargs)

        self.sprite = LUISprite(self, "Radiobox_Default", "skin")
        self.label = LUILabel(parent=self, text=label, shadow=True, left=self.sprite.width+6)
        self.label.top = self.label.height - self.sprite.height
        self.label.bind("resized", self._on_label_resized)

        self.fit_to_children()
        self.group = group
        self.group.register_box(self)
        self.active = False
        self.value = value

        if active:
            self.set_active()

    def _on_label_resized(self, event):
        """ Internal handler when the text of the label got changed """
        self.fit_to_children()

    def on_click(self, event):
        """ Internal onclick handler. Do not override. """
        self.set_active()

    def set_active(self):
        """ Internal function to set the radiobox active """
        if self.group is not None:
            self.group.set_active(self)
        else:
            self._update_state(True)

    def get_value(self):
        """ Returns the value of the radiobox """
        return self.value

    def get_label(self):
        """ Returns a handle to the label, so it can be modified (e.g. change 
            its text) """
        return self.label

    def _update_state(self, active):
        """ Internal method to update the state of the radiobox. Called by the
        LUIRadioboxGroup """
        self.active = active
        self.trigger_event("changed")
        self._update_sprite()

    def on_mousedown(self, event):
        """ Internal onmousedown handler. Do not override. """
        self.color = (0.86,0.86,0.86,1.0)

    def on_mouseup(self, event):
        """ Internal onmouseup handler. Do not override. """
        self.color = (1,1,1,1)

    def _update_sprite(self):
        """ Internal function to update the sprite of the radiobox """
        img = "Radiobox_Active" if self.active else "Radiobox_Default"
        self.sprite.set_texture(img, "skin")
Beispiel #51
0
    def prepare_demo(self, demo_title=u"Some Demo"):

        # Background
        self._background = LUISprite(self._root, "res/DemoBackground.png")
        # Make the background solid and recieve events
        self._background.solid = True

        # Logo
        self._logo = LUISprite(self._root, "res/LUILogo.png")
        self._logo.top_left = 15, 20

        # Title
        self._title_label = LUILabel(parent=self._root,
                                     text=demo_title,
                                     font_size=40,
                                     font="header",
                                     pos=(120, 27))
        self._subtitle_label = LUILabel(parent=self._root,
                                        text="Widget Demo",
                                        font_size=14,
                                        font="default",
                                        pos=(121, 70),
                                        alpha=0.3)

        # Right bar

        self._right_bar = LUIVerticalLayout(parent=self._root)
        self._left_bar = LUIVerticalLayout(parent=self._root)
        self._right_bar.width = 350
        self._right_bar.pos = (410, 120)
        self._right_bar.spacing = 10
        self._left_bar.width = 350
        self._left_bar.pos = (20, 120)
        self._left_bar.spacing = 10

        # Public functions
        self._public_functions = LUIFrame(width=340, style=LUIFrame.FS_sunken)
        self._functions_label = LUILabel(text=U"Additional Public functions")
        self._functions_layout = LUIVerticalLayout(
            parent=self._public_functions)
        self._functions_layout.add(self._functions_label, 30)

        # Events
        self._events = LUIFrame(width=340, style=LUIFrame.FS_sunken)
        self._events_label = LUILabel(text=U"Additional Events")
        self._events_layout = LUIVerticalLayout(parent=self._events)
        self._events_layout.add(self._events_label, 30)

        # Actions
        self._actions = LUIFrame(width=340, style=LUIFrame.FS_sunken)
        self._actions_label = LUILabel(parent=self._actions,
                                       text=U"Demo-Actions")
        self._actions_select = LUISelectbox(parent=self._actions,
                                            width=225,
                                            top=30)
        self._actions_btn = LUIButton(parent=self._actions,
                                      right=0,
                                      top=30,
                                      text=u"Execute",
                                      template="ButtonGreen")
        self._actions_btn.bind("click", self._exec_action)

        # Properties
        self._properties = LUIFrame(width=340, style=LUIFrame.FS_sunken)
        self._properties_label = LUILabel(text=u"Additional Properties")
        self._properties_layout = LUIVerticalLayout(parent=self._properties)
        self._properties_layout.add(self._properties_label, 30)

        self._right_bar.add(self._actions)
        self._right_bar.add(self._public_functions)
        self._right_bar.add(self._properties)
        self._right_bar.add(self._events)

        # Widget
        self._widget_container = LUIFrame(width=360,
                                          height=250,
                                          style=LUIFrame.FS_sunken)
        self._widget_label = LUILabel(parent=self._widget_container,
                                      text=u"Widget Demo")
        self._left_bar.add(self._widget_container)

        # Source Code
        self._source_container = LUIFrame(width=360,
                                          height=190,
                                          style=LUIFrame.FS_sunken)
        self._source_label = LUILabel(parent=self._source_container,
                                      text=u"Default Constructor")
        self._copy_code_button = LUIButton(parent=self._source_container,
                                           text=u"Copy to Clipboard",
                                           template="ButtonGreen",
                                           bottom_right=(0, 0))
        self._source_content = LUIObject(self._source_container)
        self._source_content.top = 40
        self._left_bar.add(self._source_container)

        self._widget_node = LUIObject(self._widget_container, x=0, y=40)
Beispiel #52
0
class LUIInputField(LUIObject):
    """ Simple input field """
    def __init__(self,
                 parent=None,
                 width=200,
                 placeholder=u"Enter some text ..",
                 value=u"",
                 **kwargs):
        """ Constructs a new input field. An input field always needs a width specified """
        LUIObject.__init__(self, x=0, y=0, solid=True)
        self.set_width(width)
        self._layout = LUIHorizontalStretchedLayout(parent=self,
                                                    prefix="InputField",
                                                    width="100%")

        # Container for the text
        self._text_content = LUIObject(self)
        self._text_content.margin = (5, 7, 5, 7)
        self._text_content.clip_bounds = (0, 0, 0, 0)
        self._text_content.set_size("100%", "100%")

        # Scroller for the text, so we can move right and left
        self._text_scroller = LUIObject(parent=self._text_content)
        self._text_scroller.center_vertical = True
        self._text = LUILabel(parent=self._text_scroller, text=u"")

        # Cursor for the current position
        self._cursor = LUISprite(self._text_scroller,
                                 "blank",
                                 "skin",
                                 x=0,
                                 y=0,
                                 w=2,
                                 h=15)
        self._cursor.color = (0.5, 0.5, 0.5)
        self._cursor.margin.top = 2
        self._cursor.z_offset = 20
        self._cursor_index = 0
        self._cursor.hide()
        self._value = value

        # Placeholder text, shown when out of focus and no value exists
        self._placeholder = LUILabel(parent=self._text_content,
                                     text=placeholder,
                                     shadow=False,
                                     center_vertical=True,
                                     alpha=0.2)

        # Various states
        self._tickrate = 1.0
        self._tickstart = 0.0

        self._render_text()

        if parent is not None:
            self.parent = parent

        LUIInitialState.init(self, kwargs)

    def get_value(self):
        """ Returns the value of the input field """
        return self._value

    def set_value(self, value):
        """ Sets the value of the input field """
        self._value = unicode(value)
        self.trigger_event("changed", self._value)
        self._render_text()

    value = property(get_value, set_value)

    def clear(self):
        """ Clears the input value """
        self.value = u""

    def _set_cursor_pos(self, pos):
        """ Internal method to set the cursor position """
        self._cursor_index = max(0, min(len(self._value), pos))
        self._reset_cursor_tick()

    def on_tick(self, event):
        """ Tick handler, gets executed every frame """
        frametime = globalClock.get_frame_time() - self._tickstart
        show_cursor = frametime % self._tickrate < 0.5 * self._tickrate
        if show_cursor:
            self._cursor.color = (0.5, 0.5, 0.5, 1)
        else:
            self._cursor.color = (1, 1, 1, 0)

    def _add_text(self, text):
        """ Internal method to append text """
        self._value = self._value[:self._cursor_index] + text + self._value[
            self._cursor_index:]
        self._set_cursor_pos(self._cursor_index + len(text))
        self._render_text()

    def on_click(self, event):
        """ Internal on click handler """
        self.request_focus()

    def on_mousedown(self, event):
        """ Internal mousedown handler """
        local_x_offset = self._text.text_handle.get_relative_pos(
            event.coordinates).x
        self._set_cursor_pos(
            self._text.text_handle.get_char_index(local_x_offset))
        self._render_text()

    def _reset_cursor_tick(self):
        """ Internal method to reset the cursor tick """
        self._tickstart = globalClock.getFrameTime()

    def on_focus(self, event):
        """ Internal focus handler """
        self._cursor.show()
        self._placeholder.hide()
        self._reset_cursor_tick()

        self._layout.color = (0.9, 0.9, 0.9, 1)

    def on_keydown(self, event):
        """ Internal keydown handler """
        key_name = event.message
        if key_name == "backspace":
            self._value = self._value[:max(0, self._cursor_index -
                                           1)] + self._value[self.
                                                             _cursor_index:]
            self._set_cursor_pos(self._cursor_index - 1)
            self.trigger_event("changed", self._value)
            self._render_text()
        elif key_name == "delete":
            self._value = self._value[:self._cursor_index] + self._value[
                min(len(self._value), self._cursor_index + 1):]
            self._set_cursor_pos(self._cursor_index)
            self.trigger_event("changed", self._value)
            self._render_text()
        elif key_name == "arrow_left":
            self._set_cursor_pos(self._cursor_index - 1)
            self._render_text()
        elif key_name == "arrow_right":
            self._set_cursor_pos(self._cursor_index + 1)
            self._render_text()

        self.trigger_event(key_name, self._value)

    def on_keyrepeat(self, event):
        """ Internal keyrepeat handler """
        self.on_keydown(event)

    def on_textinput(self, event):
        """ Internal textinput handler """
        self._add_text(event.message)
        self.trigger_event("changed", self._value)

    def on_blur(self, event):
        """ Internal blur handler """
        self._cursor.hide()
        if len(self._value) < 1:
            self._placeholder.show()

        self._layout.color = (1, 1, 1, 1)

    def _render_text(self):
        """ Internal method to render the text """
        self._text.set_text(self._value)
        self._cursor.left = self._text.left + self._text.text_handle.get_char_pos(
            self._cursor_index) + 1
        max_left = self.width - 15

        if self._value:
            self._placeholder.hide()
        else:
            if not self.focused:
                self._placeholder.show()

        # Scroll if the cursor is outside of the clip bounds
        rel_pos = self.get_relative_pos(self._cursor.get_abs_pos()).x
        if rel_pos >= max_left:
            self._text_scroller.left = min(0, max_left - self._cursor.left)
        if rel_pos <= 0:
            self._text_scroller.left = min(0, -self._cursor.left - rel_pos)