Initial Implementation for display_segment update_method replace

mpf/config_spec.yaml

@@ -1498,7 +1498,7 @@ segment_display_player:
     action: single|enum(add,remove,flash,no_flash,flash_match,flash_mask,set_color)|add
     transition: ignore
     transition_out: ignore
-    flashing: single|enum(off,all,match,mask,not_set)|not_set
+    flashing: single|enum(off,all,match,mask,not_set)|off
     flash_mask: single|str|None
     key: single|str|None
     expire: single|ms_or_token|None

mpf/devices/segment_display/segment_display.py

@@ -51,7 +51,7 @@ class SegmentDisplay(SystemWideDevice):
 
     __slots__ = ["hw_display", "size", "virtual_connector", "_text_stack", "_current_placeholder",
                  "_current_text_stack_entry", "_transition_update_task", "_current_transition", "_default_color",
-                 "_current_state", "_current_placeholder_future"]
+                 "_current_state", "_current_placeholder_future", "_previous_text", "_previous_color", "_previous_transition_out"]
 
     config_section = 'segment_displays'
     collection = 'segment_displays'
@@ -73,6 +73,9 @@ def __init__(self, machine, name: str) -> None:
         self._current_transition = None             # type: Optional[TransitionRunner]
         self._default_color = None                  # type: Optional[RGBColor]
         self._current_state = None                  # type: Optional[SegmentDisplayState]
+        self._previous_text = None                  # Last text entry for transitions if update_method = replace
+        self._previous_color = None                 # Last color for transitions if update_method = replace
+        self._previous_transition_out = None        # Last transistion_out if update_method = replace
 
     async def _initialize(self):
         """Initialize display."""
@@ -145,7 +148,14 @@ def add_text_entry(self, text, color, flashing, flash_mask, transition, transiti
 
         This will replace texts with the same key.
         """
+
+        if len(color) == 0:
+            color = self._current_state.text.get_colors()
+
+
         if self.config['update_method'] == "stack":
+
+
             self._text_stack[key] = TextStackEntry(
                 text, color, flashing, flash_mask, transition, transition_out, priority, key)
             self._update_stack()
@@ -155,11 +165,56 @@ def add_text_entry(self, text, color, flashing, flash_mask, transition, transiti
             raise ValueError(f"Unknown update_method '{self.config['update_method']}' for segment display {self.name}")
 
         # For the replace-text update method, skip the stack and write straight to the display
-        new_text = TextTemplate(self.machine, text).evaluate({})
-        text = SegmentDisplayText.from_str(new_text, self.size, self.config['integrated_dots'],
-                                           self.config['integrated_commas'], self.config['use_dots_for_commas'],
-                                           color)
-        self._update_display(SegmentDisplayState(text, flashing, flash_mask))
+
+        ###############################
+        #Store current color and text as previous text/color of next run even if no transition in this step,
+        #the next step might have a transition, that the old text/color needs to be included into that transition
+        ###############################
+
+        # Handle new and previous text
+        if self._previous_text:
+            previous_text = self._previous_text
+        else:
+            previous_text = ""
+        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
+        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
+
+            #start transition
+            self._start_transition(transition_conf, previous_text, text,
+                                   previous_color, color,
+                                   self.config['default_transition_update_hz'], flashing, flash_mask)
+
+        else: #No transition configured
+            if transition_out:  #in case transition_out is set we need to preserve it for the next step
+                self._previous_transition_out = transition_out
+            new_text = TextTemplate(self.machine, text).evaluate({})
+            text = SegmentDisplayText.from_str(new_text, self.size, self.config['integrated_dots'],
+                                               self.config['integrated_commas'], self.config['use_dots_for_commas'],
+                                               color)
+            self._update_display(SegmentDisplayState(text, flashing, flash_mask))
 
     def add_text(self, text: str, priority: int = 0, key: str = None) -> None:
         """Add text to display stack.
@@ -171,7 +226,7 @@ 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":
-            self.info_log("Segment display 'remove' action is TBD.")
+            self.add_text_entry("", self._previous_color, FlashingType.NO_FLASH, "", None, None, 100, key)
             return
 
         if key in self._text_stack:
@@ -182,9 +237,8 @@ def remove_text_by_key(self, key: Optional[str]):
     def _start_transition(self, transition: TransitionBase, current_text: str, new_text: str,
                           current_colors: List[RGBColor], new_colors: List[RGBColor],
                           update_hz: float, flashing, flash_mask):
+
         """Start the specified transition."""
-        current_colors = self._expand_colors(current_colors, len(current_text))
-        new_colors = self._expand_colors(new_colors, len(new_text))
         if self._current_transition:
             self._stop_transition()
         self._current_transition = TransitionRunner(self.machine, transition, current_text, new_text,

mpf/devices/segment_display/segment_display_text.py

@@ -76,28 +76,36 @@ def _create_characters(cls, text: str, display_size: int, collapse_dots: bool, c
         """Create characters from text and color them.
 
         - Colors are used from the left to the right (starting with the first character).
-        - If colors are shorter than text the last color is repeated for text.
-        - The first color is used to pad the text to the left if text is shorter than the display - thus text is right
-          aligned.
         - 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
         """
         char_list = []
-        left_pad_color = colors[0] if colors else None
-        default_right_color = colors[len(colors) - 1] if colors else None
         uncolored_chars = cls._embed_dots_and_commas(text, collapse_dots, collapse_commas, use_dots_for_commas)
-        colors = colors[-len(uncolored_chars):]
-        for char_code, char_has_dot, char_has_comma in uncolored_chars:
-            color = colors.pop(0) if colors else default_right_color
-            char_list.append(DisplayCharacter(char_code, char_has_dot, char_has_comma, color))
 
-        # ensure list is the same size as the segment display (cut off on left or right justify characters)
-        current_length = len(char_list)
+        # 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
+
+        # 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)
         if current_length > display_size:
             for _ in range(current_length - display_size):
-                char_list.pop(0)
+                uncolored_chars.pop(0) # remove very left char of array if too long
         elif current_length < display_size:
             for _ in range(display_size - current_length):
-                char_list.insert(0, DisplayCharacter(SPACE_CODE, False, False, left_pad_color))
+                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))
 
         return char_list