def _get(params: Dict[str, Any], key: str, allowed_types: Optional[Union[Type, str, List[Type], Tuple[Type, ...]]] = None, default: Any = None) -> Any: """ Return a value from a dictionary. Custom types (str) - alignment – pygame-menu alignment (locals) - callable – Is callable type, same as ``"function"`` - color – Check color - color_image – Color or :py:class:`pygame_menu.baseimage.BaseImage` - color_image_none – Color, :py:class:`pygame_menu.baseimage.BaseImage`, or None - color_none – Color or None - cursor – Cursor object (pygame) - font – Font type - image – Value must be ``BaseImage`` - none – None only - position – pygame-menu position (locals) - position_vector – pygame-menu position (str or vector) - tuple2 – Only valid numeric tuples ``(x, y)`` or ``[x, y]`` - tuple2int – Only valid integer tuples ``(x, y)`` or ``[x, y]`` - tuple3 – Only valid numeric tuples ``(x, y, z)`` or ``[x, y, z]`` - tuple3int – Only valid integer tuples ``(x, y, z)`` or ``[x, y, z]`` - type – Type-class (bool, str, etc...) :param params: Parameters dictionary :param key: Key to look for :param allowed_types: List of allowed types :param default: Default value to return :return: The value associated to the key """ value = params.pop(key, default) if allowed_types is not None: other_types = [] # Contain other types to check from if not isinstance(allowed_types, VectorInstance): allowed_types = (allowed_types, ) for val_type in allowed_types: if val_type == 'alignment': assert_alignment(value) elif val_type == callable or val_type == 'function' or val_type == 'callable': assert is_callable(value), \ 'value must be callable type' elif val_type == 'color': value = assert_color(value) elif val_type == 'color_image': if not isinstance(value, BaseImage): value = assert_color(value) elif val_type == 'color_image_none': if not (value is None or isinstance(value, BaseImage)): value = assert_color(value) elif val_type == 'color_none': if value is not None: value = assert_color(value) elif val_type == 'cursor': assert_cursor(value) elif val_type == 'font': assert_font(value) elif val_type == 'image': assert isinstance(value, BaseImage), \ 'value must be BaseImage type' elif val_type == 'none': assert value is None elif val_type == 'position': assert_position(value) elif val_type == 'position_vector': assert_position_vector(value) elif val_type == 'type': assert isinstance(value, type), \ 'value is not type-class' elif val_type == 'tuple2': assert_vector(value, 2) elif val_type == 'tuple2int': assert_vector(value, 2, int) elif val_type == 'tuple3': assert_vector(value, 3) elif val_type == 'tuple3int': assert_vector(value, 3, int) else: # Unknown type assert isinstance(val_type, type), \ 'allowed type "{0}" is not a type-class'.format(val_type) other_types.append(val_type) # Check other types if len(other_types) > 0: others = tuple(other_types) assert isinstance(value, others), \ 'Theme.{} type shall be in {} types (got {})'.format(key, others, type(value)) return value
def validate(self) -> 'Theme': """ Validate the values of the theme. If there's a invalid parameter throws an ``AssertionError``. This function also converts all lists to tuples. This is done because lists are mutable. :return: Self reference """ if self._disable_validation: return self # Boolean asserts assert isinstance(self.scrollbar_shadow, bool) assert isinstance(self.title_bar_modify_scrollarea, bool) assert isinstance(self.title_close_button, bool) assert isinstance(self.title_font_antialias, bool) assert isinstance(self.title_font_shadow, bool) assert isinstance(self.widget_font_antialias, bool) assert isinstance(self.widget_font_background_color_from_menu, bool) assert isinstance(self.widget_font_shadow, bool) # Value type checks assert_alignment(self.widget_alignment) assert_cursor(self.scrollbar_cursor) assert_cursor(self.title_close_button_cursor) assert_cursor(self.widget_cursor) assert_font(self.title_font) assert_font(self.widget_font) assert_position(self.scrollbar_shadow_position) assert_position(self.title_font_shadow_position) assert_position(self.widget_font_shadow_position) assert_position_vector(self.widget_border_position) assert _check_menubar_style(self.title_bar_style) assert get_scrollbars_from_position( self.scrollarea_position) is not None # Check selection effect if None if self.widget_selection_effect is None: self.widget_selection_effect = NoneSelection() assert isinstance(self.cursor_switch_ms, NumberInstance) assert isinstance(self.fps, NumberInstance) assert isinstance(self.scrollbar_shadow_offset, int) assert isinstance(self.scrollbar_slider_pad, NumberInstance) assert isinstance(self.scrollbar_thick, int) assert isinstance(self.title, bool) assert isinstance(self.title_fixed, bool) assert isinstance(self.title_floating, bool) assert isinstance(self.title_font_shadow_offset, int) assert isinstance(self.title_font_size, int) assert isinstance(self.title_updates_pygame_display, bool) assert isinstance(self.widget_background_inflate_to_selection, bool) assert isinstance(self.widget_border_width, int) assert isinstance(self.widget_box_border_width, int) assert isinstance(self.widget_font_shadow_offset, int) assert isinstance(self.widget_font_size, int) assert isinstance(self.widget_padding, PaddingInstance) assert isinstance(self.widget_selection_effect, Selection) assert isinstance(self.widget_tab_size, int) # Format colors, this converts all color lists to tuples automatically, # if image, return the same object self.background_color = self._format_color_opacity( self.background_color) self.cursor_color = self._format_color_opacity(self.cursor_color) self.cursor_selection_color = self._format_color_opacity( self.cursor_selection_color) self.focus_background_color = self._format_color_opacity( self.focus_background_color) self.readonly_color = self._format_color_opacity(self.readonly_color) self.readonly_selected_color = self._format_color_opacity( self.readonly_selected_color) self.scrollbar_color = self._format_color_opacity(self.scrollbar_color) self.scrollbar_shadow_color = self._format_color_opacity( self.scrollbar_shadow_color) self.scrollbar_slider_color = self._format_color_opacity( self.scrollbar_slider_color) self.scrollbar_slider_hover_color = self._format_color_opacity( self.scrollbar_slider_hover_color) self.selection_color = self._format_color_opacity(self.selection_color) self.surface_clear_color = self._format_color_opacity( self.surface_clear_color) self.title_background_color = self._format_color_opacity( self.title_background_color) self.title_close_button_background_color = self._format_color_opacity( self.title_close_button_background_color) self.title_font_color = self._format_color_opacity( self.title_font_color) self.title_font_shadow_color = self._format_color_opacity( self.title_font_shadow_color) self.widget_background_color = self._format_color_opacity( self.widget_background_color, none=True) self.widget_border_color = self._format_color_opacity( self.widget_border_color) self.widget_box_arrow_color = self._format_color_opacity( self.widget_box_arrow_color) self.widget_box_background_color = self._format_color_opacity( self.widget_box_background_color) self.widget_box_border_color = self._format_color_opacity( self.widget_box_border_color) self.widget_font_background_color = self._format_color_opacity( self.widget_font_background_color, none=True) self.widget_font_color = self._format_color_opacity( self.widget_font_color) self.widget_font_shadow_color = self._format_color_opacity( self.widget_font_shadow_color) self.widget_url_color = self._format_color_opacity( self.widget_url_color) # List to tuple self.scrollarea_outer_margin = self._vec_to_tuple( self.scrollarea_outer_margin, 2, NumberInstance) self.title_offset = self._vec_to_tuple(self.title_offset, 2, NumberInstance) self.widget_background_inflate = self._vec_to_tuple( self.widget_background_inflate, 2, int) self.widget_border_inflate = self._vec_to_tuple( self.widget_border_inflate, 2, int) self.widget_box_arrow_margin = self._vec_to_tuple( self.widget_box_arrow_margin, 3, int) self.widget_box_inflate = self._vec_to_tuple(self.widget_box_inflate, 2, int) self.widget_box_margin = self._vec_to_tuple(self.widget_box_margin, 2, NumberInstance) self.widget_margin = self._vec_to_tuple(self.widget_margin, 2, NumberInstance) if isinstance(self.widget_padding, VectorInstance): self.widget_padding = self._vec_to_tuple(self.widget_padding) assert 2 <= len(self.widget_padding) <= 4, \ 'widget padding tuple length must be 2, 3 or 4' for p in self.widget_padding: assert isinstance(p, NumberInstance), \ 'each padding element must be numeric (integer or float)' assert p >= 0, \ 'all padding elements must be equal or greater than zero' else: assert self.widget_padding >= 0, 'padding cannot be a negative number' self.widget_offset = self._vec_to_tuple(self.widget_offset, 2, NumberInstance) # Check sizes assert self.scrollarea_outer_margin[0] >= 0 and self.scrollarea_outer_margin[1] >= 0, \ 'scroll area outer margin must be equal or greater than zero on both axis' assert self.widget_offset[0] >= 0 and self.widget_offset[1] >= 0, \ 'widget offset must be equal or greater than zero' assert self.widget_background_inflate[0] >= 0 and self.widget_background_inflate[1] >= 0, \ 'widget background inflate must be equal or greater than zero on both axis' assert self.widget_border_inflate[0] >= 0 and self.widget_border_inflate[1] >= 0, \ 'widget border inflate must be equal or greater than zero on both axis' assert self.widget_box_inflate[0] >= 0 and self.widget_box_inflate[1] >= 0, \ 'widget box inflate inflate must be equal or greater than zero on both axis' assert self.cursor_switch_ms > 0, 'cursor switch ms must be greater than zero' assert self.fps >= 0, 'fps must be equal or greater than zero' assert self.scrollbar_shadow_offset > 0, 'scrollbar shadow offset must be greater than zero' assert self.scrollbar_slider_pad >= 0, 'slider pad must be equal or greater than zero' assert self.scrollbar_thick > 0, 'scrollbar thickness must be greater than zero' assert self.title_font_size > 0, 'title font size must be greater than zero' assert self.widget_border_width >= 0, 'widget border width must be equal or greater than zero' assert self.widget_box_border_width >= 0, 'widget border box width must be equal or greater than zero' assert self.widget_font_shadow_offset > 0, 'widget font shadow offset must be greater than zero' assert self.widget_font_size > 0, 'widget font size must be greater than zero' assert self.widget_tab_size >= 0, 'widget tab size must be equal or greater than zero' # Color asserts assert self.focus_background_color[3] != 0, \ 'focus background color cannot be fully transparent, suggested opacity between 1 and 255' return self
def update_cell_style( self, column: Union[int, Vector2IntType], row: Union[int, Vector2IntType], align: Optional[str] = None, background_color: Optional[ColorInputType] = None, border_color: Optional[ColorInputType] = None, border_position: Optional[WidgetBorderPositionType] = None, border_width: Optional[int] = None, font: Optional[FontType] = None, font_color: Optional[ColorInputType] = None, font_size: Optional[int] = None, padding: Optional[PaddingType] = None, vertical_position: Optional[str] = None ) -> Union['Widget', List['Widget']]: """ Update cell style. If a parameter is ``None`` the default cell property will be used. :param column: Cell column position (counting from 1). If -1 update all column from the given row. Also, a 2-item list/tuple is accepted (from, to), ``to=-1`` is also accepted (last) :param row: Cell row position (counting from 1). If ``-1`` update all rows from the given column. Also, a 2-item list/tuple is accepted (from, to), ``to=-1`` is also accepted (last) :param align: Horizontal align of each cell. See :py:mod:`pygame_menu.locals` :param background_color: Background color :param border_color: Border color of each cell :param border_position: Border position of each cell. Valid only: north, south, east, and west. See :py:mod:`pygame_menu.locals` :param border_width: Border width in px of each cell :param font: Font name or path :param font_color: Font color :param font_size: Font size :param padding: Cell padding according to CSS rules. General shape: (top, right, bottom, left) :param vertical_position: Vertical position of each cell. Only valid: north, center, and south. See :py:mod:`pygame_menu.locals` :return: Cell widget """ if row == -1 or isinstance(row, VectorInstance): max_rows = len(self._rows) if row == -1: row = [] for i in range(max_rows): row.append(i + 1) else: assert_vector(row, 2, int) row_k = list(row) if row_k[1] == -1: row_k[1] = len(self._rows) assert 1 <= row_k[0] <= row_k[1] <= max_rows, \ f'(from, to) of rows vector must be increasing and between 1-{max_rows}' row = [row_k[0]] for i in range(row_k[1] - row_k[0]): row.append(row_k[0] + (i + 1)) if isinstance(column, VectorInstance) and column != [1, -1]: assert self.is_rectangular(), \ f'only rectangular tables (same number of columns for each row) ' \ f'accept a variable column different than -1 or [1, -1], but ' \ f'received "{column}"' updated_wid = [] for i in row: w = self.update_cell_style(column=column, row=i, align=align, background_color=background_color, border_color=border_color, border_position=border_position, border_width=border_width, font=font, font_color=font_color, font_size=font_size, padding=padding, vertical_position=vertical_position) if not isinstance(w, list): w = [w] for k in w: updated_wid.append(k) return updated_wid if column == -1 or isinstance(column, VectorInstance): assert isinstance(row, int) and 1 <= row <= len(self._rows), \ f'row index ({row}) cannot exceed the number of rows ({len(self._rows)})' max_columns = self._rows[row - 1].get_total_packed() if column == -1: column = [] for i in range(max_columns): column.append(i + 1) else: assert_vector(column, 2, int) column_k = list(column) if column_k[1] == -1: column_k[1] = max_columns assert 1 <= column_k[0] <= column_k[1] <= max_columns, \ f'(from, to) of column vector must be increasing and between 1-{max_columns} for row {row}' column = [column_k[0]] for i in range(column_k[1] - column_k[0]): column.append(column_k[0] + (i + 1)) updated_wid = [] for i in column: w = self.update_cell_style(column=i, row=row, align=align, background_color=background_color, border_color=border_color, border_position=border_position, border_width=border_width, font=font, font_color=font_color, font_size=font_size, padding=padding, vertical_position=vertical_position) if not isinstance(w, list): w = [w] for k in w: updated_wid.append(k) return updated_wid cell = self.get_cell(column, row) r = self._rows[row - 1] if align is None: align = cell.get_attribute('align') if background_color is None: background_color = cell.get_attribute('background_color') if border_color is None: border_color = cell.get_attribute('border_color') if border_position is None: border_position = cell.get_attribute('border_position') if border_width is None: border_width = cell.get_attribute('border_width') if padding is None: padding = cell.get_attribute('padding') if vertical_position is None: vertical_position = cell.get_attribute('vertical_position') self._check_cell_style(align=align, background_color=background_color, border_color=border_color, border_position=border_position, border_width=border_width, padding=padding, vertical_position=vertical_position) if background_color is not None: background_color = assert_color(background_color) if border_color is not None: border_color = assert_color(border_color) padding = parse_padding(padding) # Update background color if background_color != r._background_color: cell.set_background_color(background_color) else: cell.set_background_color(None) # Update font if font_color is None: font_color = cell._font_color assert_color(font_color) if font is None: font = cell._font_name assert_font(font) if font_size is None: font_size = cell._font_size try: cell.update_font({'color': font_color, 'name': font}) except AssertionError: pass try: if isinstance(font_size, int) and font_size > 0: cell.update_font({'size': font_size}) except AssertionError: pass if isinstance(border_position, str): border_position = [border_position] # Update cell cell.set_attribute('align', align) cell.set_attribute('background_color', background_color) cell.set_attribute('border_color', border_color) cell.set_attribute('border_position', border_position) cell.set_attribute('border_width', border_width) cell.set_attribute('padding', padding) cell.set_attribute('vertical_position', vertical_position) self._update_row_sizing() self._render() self.force_menu_surface_update() return cell
def _filter_widget_attributes(self, kwargs: Dict) -> Dict[str, Any]: attributes = {} # align align = kwargs.pop('align', self._theme.widget_alignment) assert isinstance(align, str) attributes['align'] = align # background_color background_is_color = False background_color = kwargs.pop('background_color', self._theme.widget_background_color) if background_color is not None: if isinstance(background_color, pygame_menu.BaseImage): pass else: background_color = assert_color(background_color) background_is_color = True attributes['background_color'] = background_color # background_inflate background_inflate = kwargs.pop('background_inflate', self._theme.widget_background_inflate) if background_inflate == 0: background_inflate = (0, 0) assert_vector(background_inflate, 2, int) assert background_inflate[0] >= 0 and background_inflate[1] >= 0, \ 'both background inflate components must be equal or greater than zero' attributes['background_inflate'] = background_inflate # border_color border_color = kwargs.pop('border_color', self._theme.widget_border_color) if border_color is not None: border_color = assert_color(border_color) attributes['border_color'] = border_color # border_inflate border_inflate = kwargs.pop('border_inflate', self._theme.widget_border_inflate) if border_inflate == 0: border_inflate = (0, 0) assert_vector(border_inflate, 2, int) assert isinstance(border_inflate[0], int) and border_inflate[0] >= 0 assert isinstance(border_inflate[1], int) and border_inflate[1] >= 0 attributes['border_inflate'] = border_inflate # border_position border_position = kwargs.pop('border_position', self._theme.widget_border_position) assert_position_vector(border_position) attributes['border_position'] = border_position # border_width border_width = kwargs.pop('border_width', self._theme.widget_border_width) assert isinstance(border_width, int) and border_width >= 0 attributes['border_width'] = border_width # cursor cursor = kwargs.pop('cursor', self._theme.widget_cursor) assert_cursor(cursor) attributes['cursor'] = cursor # floating status float_ = kwargs.pop('float', False) assert isinstance(float_, bool) attributes['float'] = float_ float_origin_position = kwargs.pop('float_origin_position', False) assert isinstance(float_origin_position, bool) attributes['float_origin_position'] = float_origin_position # font_antialias attributes['font_antialias'] = self._theme.widget_font_antialias # font_background_color font_background_color = kwargs.pop( 'font_background_color', self._theme.widget_font_background_color) if font_background_color is None and \ self._theme.widget_font_background_color_from_menu and \ not background_is_color: if not isinstance(self._theme.background_color, pygame_menu.BaseImage): font_background_color = assert_color( self._theme.background_color) attributes['font_background_color'] = font_background_color # font_color font_color = kwargs.pop('font_color', self._theme.widget_font_color) attributes['font_color'] = assert_color(font_color) # font_name font_name = kwargs.pop('font_name', self._theme.widget_font) assert_font(font_name) attributes['font_name'] = font_name # font_shadow font_shadow = kwargs.pop('font_shadow', self._theme.widget_font_shadow) assert isinstance(font_shadow, bool) attributes['font_shadow'] = font_shadow # font_shadow_color font_shadow_color = kwargs.pop('font_shadow_color', self._theme.widget_font_shadow_color) attributes['font_shadow_color'] = assert_color(font_shadow_color) # font_shadow_offset font_shadow_offset = kwargs.pop('font_shadow_offset', self._theme.widget_font_shadow_offset) assert isinstance(font_shadow_offset, int) attributes['font_shadow_offset'] = font_shadow_offset # font_shadow_position font_shadow_position = kwargs.pop( 'font_shadow_position', self._theme.widget_font_shadow_position) assert isinstance(font_shadow_position, str) attributes['font_shadow_position'] = font_shadow_position # font_size font_size = kwargs.pop('font_size', self._theme.widget_font_size) assert isinstance(font_size, int) assert font_size > 0, 'font size must be greater than zero' attributes['font_size'] = font_size # margin margin = kwargs.pop('margin', self._theme.widget_margin) if margin == 0: margin = (0, 0) assert_vector(margin, 2) attributes['margin'] = margin # padding padding = kwargs.pop('padding', self._theme.widget_padding) assert isinstance(padding, PaddingInstance) attributes['padding'] = padding # readonly_color readonly_color = kwargs.pop('readonly_color', self._theme.readonly_color) attributes['readonly_color'] = assert_color(readonly_color) # readonly_selected_color readonly_selected_color = kwargs.pop( 'readonly_selected_color', self._theme.readonly_selected_color) attributes['readonly_selected_color'] = assert_color( readonly_selected_color) # selection_color selection_color = kwargs.pop('selection_color', self._theme.selection_color) attributes['selection_color'] = assert_color(selection_color) # selection_effect selection_effect = kwargs.pop('selection_effect', self._theme.widget_selection_effect) if selection_effect is None: selection_effect = pygame_menu.widgets.NoneSelection() else: selection_effect = selection_effect.copy() assert isinstance(selection_effect, pygame_menu.widgets.core.Selection) selection_effect.set_color(attributes['selection_color']) attributes['selection_effect'] = selection_effect # shadow attributes['shadow_aa'] = kwargs.pop('shadow_aa', self._theme.widget_shadow_aa) attributes['shadow_color'] = kwargs.pop( 'shadow_color', self._theme.widget_shadow_color) attributes['shadow_radius'] = kwargs.pop( 'shadow_radius', self._theme.widget_shadow_radius) attributes['shadow_type'] = kwargs.pop('shadow_type', self._theme.widget_shadow_type) attributes['shadow_width'] = kwargs.pop( 'shadow_width', self._theme.widget_shadow_width) # tab_size attributes['tab_size'] = kwargs.pop('tab_size', self._theme.widget_tab_size) return attributes
def __init__(self, title: Any, toggleswitch_id: str = '', default_state: int = 0, infinite: bool = False, onchange: CallbackType = None, onselect: CallbackType = None, slider_color: ColorInputType = (255, 255, 255), slider_height_factor: NumberType = 1, slider_thickness: int = 25, slider_vmargin: NumberType = 0, state_color: Tuple[ColorInputType, ...] = ((178, 178, 178), (117, 185, 54)), state_text: Tuple[str, ...] = ('Off', 'On'), state_text_font: Optional[FontType] = None, state_text_font_color: Tuple[ColorInputType, ...] = ((255, 255, 255), (255, 255, 255)), state_text_font_size: Optional[int] = None, state_text_position: Tuple2NumberType = (0.5, 0.5), state_values: Tuple[Any, ...] = (False, True), state_width: Union[Tuple[int, ...], int] = 150, switch_border_color: ColorInputType = (40, 40, 40), switch_border_width: int = 1, switch_height: NumberType = 1.25, switch_margin: Tuple2NumberType = (25, 0), *args, **kwargs) -> None: super(ToggleSwitch, self).__init__(args=args, kwargs=kwargs, onchange=onchange, onselect=onselect, title=title, widget_id=toggleswitch_id) # Asserts assert isinstance(default_state, int) assert isinstance(state_values, tuple) assert isinstance(infinite, bool) self._total_states = len(state_values) assert 2 <= self._total_states, 'the minimum number of states is 2' assert 0 <= default_state < self._total_states, 'invalid default state value' if state_text_font is not None: assert_font(state_text_font) assert isinstance(state_text_font_size, (int, type(None))) if state_text_font_size is not None: assert state_text_font_size > 0, 'state text font size must be equal or greater than zero' assert_vector(state_text_position, 2) switch_border_color = assert_color(switch_border_color) assert isinstance(switch_border_width, int) and switch_border_width >= 0, \ 'border width must be equal or greater than zero' slider_color = assert_color(slider_color) assert slider_height_factor > 0, 'slider height factor cannot be negative' assert slider_thickness >= 0, 'slider thickness cannot be negative' assert isinstance(slider_vmargin, NumberInstance) assert_vector(switch_margin, 2) assert isinstance(switch_height, NumberInstance) and switch_height > 0, \ 'switch height factor cannot be zero or negative' assert isinstance(state_color, tuple) and len(state_color) == self._total_states new_state_color = [] for c in state_color: new_state_color.append(assert_color(c)) state_color = tuple(new_state_color) assert isinstance(state_text, tuple) and len(state_text) == self._total_states for c in state_text: assert isinstance(c, str), 'all states text must be string-type' assert isinstance( state_text_font_color, tuple) and len(state_text_font_color) == self._total_states new_state_text_font_color = [] for c in state_text_font_color: new_state_text_font_color.append(assert_color(c)) state_text_font_color = tuple(new_state_text_font_color) self._switch_width = 0 if isinstance(state_width, NumberInstance): state_width = [state_width] assert_vector(state_width, self._total_states - 1, int) for i in range(len(state_width)): assert isinstance(state_width[i], int), 'each state width must be an integer' assert state_width[ i] > 0, 'each state width must be greater than zero' self._switch_width += state_width[i] # Store properties self._switch_border_color = switch_border_color self._switch_border_width = switch_border_width self._infinite = infinite self._slider_color = slider_color self._slider_height_factor = slider_height_factor self._slider_thickness = slider_thickness self._slider_vmargin = slider_vmargin self._state = default_state self._state_color = state_color self._state_text = state_text self._state_text_font = state_text_font self._state_text_font_color = state_text_font_color self._state_text_font_size = state_text_font_size self._state_text_position = state_text_position self._state_values = state_values self._state_width = state_width self._switch_height_factor = float(switch_height) self._switch_margin = switch_margin # Compute state width accum self._state_width_accum = [0] accum = 0 for w in self._state_width: accum += w self._state_width_accum.append(accum - self._slider_thickness - 2 * self._switch_border_width) # Inner properties self._slider_height = 0 self._slider_pos = (0, 0) # to add to (rect.x, rect.y) self._state_font = None self._switch_font_rendered = [] # Stores font render for each state self._switch_height = 0 self._switch_pos = (0, 0) # horizontal pos, and delta to title
def __init__( self, title: Any, progressbar_id: str = '', default: NumberType = 0, width: int = 150, onselect: CallbackType = None, box_background_color: ColorInputType = (255, 255, 255), box_border_color: ColorInputType = (0, 0, 0), box_border_width: int = 1, box_margin: Tuple2IntType = (25, 0), box_progress_color: ColorInputType = (0, 255, 0), box_progress_padding: PaddingType = (1, 1), progress_text_align: str = ALIGN_CENTER, progress_text_enabled: bool = True, progress_text_font: Optional[FontType] = None, progress_text_font_color: ColorInputType = (0, 0, 0), progress_text_font_hfactor: float = 0.8, progress_text_format: ProgressBarTextFormatType = lambda x: str(round(x, 1)), progress_text_margin: Tuple2IntType = (0, 0), progress_text_placeholder: str = '{0} %', *args, **kwargs ) -> None: super(ProgressBar, self).__init__( args=args, kwargs=kwargs, onselect=onselect, title=title, widget_id=progressbar_id ) # Check the value assert isinstance(default, NumberInstance) assert 0 <= default <= 100, 'default value must range from 0 to 100' # Check fonts if progress_text_font is not None: assert_font(progress_text_font) assert isinstance(progress_text_font_hfactor, NumberInstance) assert progress_text_font_hfactor > 0, \ 'progress text font height factor must be greater than zero' # Check colors box_background_color = assert_color(box_background_color) box_border_color = assert_color(box_border_color) box_progress_color = assert_color(box_progress_color) progress_text_font_color = assert_color(progress_text_font_color) # Check dimensions and sizes assert isinstance(box_border_width, int) assert box_border_width >= 0, \ 'box border width must be equal or greater than zero' assert_vector(box_margin, 2, int) assert_vector(progress_text_margin, 2, int) assert isinstance(width, int) assert width > 0, 'width must be greater than zero' box_progress_padding = parse_padding(box_progress_padding) self._box_progress_padding = box_progress_padding # Check progress text assert isinstance(progress_text_enabled, bool) assert is_callable(progress_text_format) assert isinstance(progress_text_format(0), str) assert isinstance(progress_text_placeholder, str) assert_alignment(progress_text_align) # Store properties self._default_value = default self._box_background_color = box_background_color self._box_border_color = box_border_color self._box_border_width = box_border_width self._box_margin = box_margin self._box_progress_color = box_progress_color self._progress = default self._progress_text_align = progress_text_align self._progress_text_enabled = progress_text_enabled self._progress_text_font = progress_text_font self._progress_text_font_color = progress_text_font_color self._progress_text_font_height = 0 self._progress_text_font_height_factor = progress_text_font_hfactor self._progress_text_format = progress_text_format self._progress_text_margin = progress_text_margin self._progress_text_placeholder = progress_text_placeholder self._width = width