mainly feedback from last PR, plus improved clear context

Author: worldpeace-germany

mpf/config_players/segment_display_player.py

@@ -106,12 +106,23 @@ def _remove(self, instance_dict, key, display):
             del instance_dict[display][key]
 
     def clear_context(self, context):
-        """Remove all texts."""
-        instance_dict = self._get_instance_dict(context)
-        for display, keys in instance_dict.items():
-            for key in dict(keys).keys():
-                self._remove(instance_dict=instance_dict,
-                             key=key, display=display)
+
+        ##############
+        # Remove all texts. Ignore what keys are available, that will be checked later in the segment display code.
+        # Especially important for update_method replace since there are no keys.
+        ##############
+
+        instance_dict = self._get_instance_dict(context) # key of the dict is the display, the value is another dict
+
+        for display, keys_dict in instance_dict.items(): # keys_dict key is the show key, the value is a boolean (with yet unknown usage)
+            if(keys_dict): #depending on the situation the keys_dict might be empty, still need to clear the display
+                for key in dict(keys_dict).keys():
+                    display.clear_segment_display(key)
+                    if instance_dict[display][key] is not True:
+                        self.delay.remove(instance_dict[display][key])
+                    del instance_dict[display][key]
+            else:
+                display.clear_segment_display(None)
 
         self._reset_instance_dict(context)
 

mpf/devices/segment_display/segment_display.py

@@ -89,8 +89,14 @@ async def _initialize(self):
 
         self.size = self.config['size']
         self._default_color = [RGBColor(color) for color in self.config["default_color"][0:self.size]]
-        if len(self._default_color) < self.size:
-            self._default_color += [RGBColor("white")] * (self.size - len(self._default_color))
+
+        if (len(self._default_color)) == 1:
+            self._default_color = self._default_color * self.size
+        elif len(self._default_color) != self.size:
+            self.warning_log("The amount of colors you specified for your text has to be either equal to "
+                "the amount of digits in your display or equals 1. Your display has a size of %s and the "
+                "amount of colors specified is %s. All display colors will be set to white.", self.size, len(self._default_color))
+            self._default_color = [RGBColor("white")] * self.size
 
         # configure hardware
         try:
@@ -148,11 +154,9 @@ def add_text_entry(self, text, color, flashing, flash_mask, transition, transiti
 
         This will replace texts with the same key.
         """
-
-        if len(color) == 0:
+        if not color:
             color = self._current_state.text.get_colors()
 
-
         if self.config['update_method'] == "stack":
 
 
@@ -172,35 +176,19 @@ def add_text_entry(self, text, color, flashing, flash_mask, transition, transiti
         ###############################
 
         # Handle new and previous text
-        if self._previous_text:
-            previous_text = self._previous_text
-        else:
-            previous_text = ""
+        previous_text = self._previous_text or ""
         self._previous_text = text  # Save the new text as the next previous text
 
         # Handle new and previous color
-        if self._previous_color:
-            previous_color = self._previous_color
-        else:
-            previous_color = self._default_color
+        previous_color = self._previous_color or self._default_color
         self._previous_color = color  # Save the new color as the next previous color
 
         if transition or self._previous_transition_out:
-            if transition: #if transition exists, then ignore transition_out of previous text/color
-                transition_conf = TransitionManager.get_transition(self.size,
-                                                                   self.config['integrated_dots'],
-                                                                   self.config['integrated_commas'],
-                                                                   self.config['use_dots_for_commas'],
-                                                                   transition)
-            elif self._previous_transition_out:
-                transition_conf = TransitionManager.get_transition(self.size,
-                                                                   self.config['integrated_dots'],
-                                                                   self.config['integrated_commas'],
-                                                                   self.config['use_dots_for_commas'],
-                                                                   self._previous_transition_out)
-                self._previous_transition_out = None # Once the transistion_out is played removed it that is not played in the next step again
-            if transition_out:  #in case transition_out is set we need to preserve it for the next step but only after the previous transition_out is in this step's config
-                self._previous_transition_out = transition_out
+            transition_conf = TransitionManager.get_transition(self.size,
+                                                       self.config['integrated_dots'],
+                                                       self.config['integrated_commas'],
+                                                       self.config['use_dots_for_commas'],
+                                                       transition or self._previous_transition_out)
 
             #start transition
             self._start_transition(transition_conf, previous_text, text,
@@ -216,6 +204,12 @@ def add_text_entry(self, text, color, flashing, flash_mask, transition, transiti
                                                color)
             self._update_display(SegmentDisplayState(text, flashing, flash_mask))
 
+        ###############################
+        # Once the transistion_out is played, removed it that is not played in the next step again, but in case transition_out is set in the current step
+        # then we need to preserve it for the next step but only after the previous step's transition_out is in this step's config (or the transition of the current step)
+        ###############################
+        self._previous_transition_out = transition_out or None
+
     def add_text(self, text: str, priority: int = 0, key: str = None) -> None:
         """Add text to display stack.
 
@@ -225,13 +219,23 @@ def add_text(self, text: str, priority: int = 0, key: str = None) -> None:
 
     def remove_text_by_key(self, key: Optional[str]):
         """Remove entry from text stack."""
-        if self.config['update_method'] != "stack":
+        if self.config['update_method'] == "stack":
+            if key in self._text_stack:
+                del self._text_stack[key]
+                self._update_stack()
+        else: # must be update_method replace, send empyt text since no key in that case
             self.add_text_entry("", self._previous_color, FlashingType.NO_FLASH, "", None, None, 100, key)
-            return
 
-        if key in self._text_stack:
-            del self._text_stack[key]
-            self._update_stack()
+
+    def clear_segment_display(self, key: Optional[str]):
+        """Clear segment dispaly if context is removed from player."""
+
+        if self.config['update_method'] == "replace":
+            self._stop_transition()
+            self._previous_transition_out = None
+
+        self.remove_text_by_key(key)
+
 
     # pylint: disable=too-many-arguments
     def _start_transition(self, transition: TransitionBase, current_text: str, new_text: str,

mpf/devices/segment_display/segment_display_text.py

@@ -74,25 +74,19 @@ def _embed_dots_and_commas(cls, text: str, collapse_dots: bool, collapse_commas:
     def _create_characters(cls, text: str, display_size: int, collapse_dots: bool, collapse_commas: bool,
                            use_dots_for_commas: bool, colors: List[Optional[RGBColor]]) -> List[DisplayCharacter]:
         """Create characters from text and color them.
-
-        - Colors are used from the left to the right (starting with the first character).
         - Dots and commas are embedded on the fly.
         - Text will be right aligned on the display, thus if text is shorter than display spaces will be padded before the text
-        - Provided colors are assumed to be for the text itself, thus the list of colors is "right aligned" too
-        - If list of colors is less than the display size the list will be extended with white as default color on the left endswith
-          so that the provided colors are for the text and not being used for invisible spaces
+        - If list of colors is less than the display size then all white will be used, if only one color is given that will be used for the full display
         """
         char_list = []
         uncolored_chars = cls._embed_dots_and_commas(text, collapse_dots, collapse_commas, use_dots_for_commas)
 
         # Adujust the color array if needed
-        color_length = len(colors)
-        if color_length > display_size:
-            for _ in range(color_length - display_size):
-                colors.pop(0) # remove very left color of array if too long
-        elif color_length < display_size:
-            for _ in range(display_size - color_length):
-                colors.append(RGBColor("white")) # add default color on the left of the array if too few colors
+        if (len(colors)) == 1:
+            colors = colors * display_size
+        elif len(colors) != display_size:
+            #TODO: Log that colors were adjusted to white as default
+            colors = [RGBColor("white")] * display_size
 
         # ensure list is the same size as the segment display (cut off on left if too long or right justify characters if too short)
         current_length = len(uncolored_chars)
@@ -103,9 +97,9 @@ def _create_characters(cls, text: str, display_size: int, collapse_dots: bool, c
             for _ in range(display_size - current_length):
                 uncolored_chars.insert(0, (SPACE_CODE, False, False))
 
-        for _ in range(len(uncolored_chars)):
-            color = colors[_]
-            char_list.append(DisplayCharacter(uncolored_chars[_][0], uncolored_chars[_][1], uncolored_chars[_][2], color))
+        for i, char in enumerate(uncolored_chars):
+            color = colors[i]
+            char_list.append(DisplayCharacter(char[0], char[1], char[2], color)) #0: char code 1: char_has_dot 2: char_has_comma
 
         return char_list