We have working PlayerInput abort/errback.

flexible.py

@@ -20,27 +20,44 @@ class PlayerInput(object):
         self.save = None
         self.deferred = None
         self.queue_game = game.queue_game
+        self.keep = {}
 
-        # default colors, and useful consts
+        # default colors
         self.c = merge(Style.BRIGHT + Fore.WHITE + Back.BLUE)
+        self.cp = merge(Style.BRIGHT + Fore.YELLOW + Back.BLUE)
+
+        # useful consts
         self.r = Style.RESET_ALL
         self.nl = "\n\r"
         self.bsb = "\b \b"
+
         self.keepalive = None
 
     def color(self, c):
         self.c = c
 
+    def colorp(self, cp):
+        self.cp = cp
+
     def alive(self):
         log.msg("PlayerInput.alive()")
         self.game.queue_player.put(" ")
 
-    def prompt(self, prompt, limit, default=""):
-        log.msg("PlayerInput({0}, {1}, {2}".format(prompt, limit, default))
-        self.prompt = prompt
+    def prompt(self, user_prompt, limit, **kw):
+        """ Generate prompt for user input.
+
+        prompt = text displayed.
+        limit = # of characters allowed.
+        default = (text to default to)
+
+        keywords:
+        abort_blank : Abort if they give us blank text.
+
+        """
+        log.msg("PlayerInput({0}, {1}, {2}".format(user_prompt, limit, kw))
         self.limit = limit
-        self.default = default
         self.input = ""
+        self.kw = kw
         assert self.save is None
         assert self.keepalive is None
 
@@ -57,7 +74,7 @@ class PlayerInput(object):
         self.game.to_player = False
 
         # Display prompt
-        self.queue_game.put(self.r + self.nl + self.c + prompt)
+        self.queue_game.put(self.r + self.nl + self.c + user_prompt + " " + self.cp)
         # Set "Background of prompt"
         self.queue_game.put(" " * limit + "\b" * limit)
 
@@ -78,7 +95,7 @@ class PlayerInput(object):
                     self.input = self.input[0:-1]
                 else:
                     self.queue_game.put("\a")
-            if ch == "\r":
+            elif ch == "\r":
                 self.queue_game.put(self.r + self.nl)
                 log.msg("Restore observer dispatch", self.save)
                 assert not self.save is None
@@ -91,11 +108,33 @@ class PlayerInput(object):
                 self.input = ""
                 assert not self.deferred is None
 
+                # If they gave us the keyword name, save the value as that name
+                if "name" in self.kw:
+                    self.keep[self.kw["name"]] = line
+
+                if "abort_blank" in self.kw and self.kw["abort_blank"]:
+                    # Abort on blank input
+                    if line.strip() == "":
+                        # Yes, input is blank, abort.
+                        log.msg("errback, abort_blank")
+                        reactor.callLater(
+                            0, self.deferred.errback, Exception("abort_blank")
+                        )
+                        self.deferred = None
+                        return
+
                 # Ok, use deferred.callback, or reactor.callLater?
                 # self.deferred.callback(line)
                 reactor.callLater(0, self.deferred.callback, line)
                 self.deferred = None
-            if ch.isprintable():
+                return
+            elif ch.isprintable():
+                # Printable, but is it acceptable?
+                if "digits" in self.kw:
+                    if not ch.isdigit():
+                        self.queue_game.put("\a")
+                        continue
+
                 if len(self.input) + 1 <= self.limit:
                     self.input += ch
                     self.queue_game.put(ch)
@@ -115,15 +154,17 @@ class ProxyMenu(object):
         self.c = merge(Style.BRIGHT + Fore.YELLOW + Back.BLUE)
         self.r = Style.RESET_ALL
         self.c1 = merge(Style.BRIGHT + Fore.BLUE)
-        self.c2 = merge(Style.NORMAL + Fore.BLUE)
+        self.c2 = merge(Style.NORMAL + Fore.CYAN)
 
         self.game = game
         self.queue_game = game.queue_game
         self.observer = game.observer
+
         # Yes, at this point we would activate
         self.prompt = game.buffer
         self.save = self.observer.save()
         self.observer.connect("player", self.player)
+
         # If we want it, it's here.
         self.defer = None
 
@@ -149,29 +190,12 @@ class ProxyMenu(object):
                 " " + self.c1 + ch + self.c2 + " - " + self.c1 + desc + self.nl
             )
 
-        self.queue_game.put(
-            " " + self.c1 + "D" + self.c2 + " - " + self.c1 + "Diagnostics" + self.nl
-        )
+        menu_item("D", "Diagnostics")
         menu_item("Q", "Quest")
         menu_item("T", "Display current Time")
-
-        self.queue_game.put(
-            " "
-            + self.c1
-            + "P"
-            + self.c2
-            + " - "
-            + self.c1
-            + "Port CIM Report"
-            + self.nl
-        )
-
-        self.queue_game.put(
-            " " + self.c1 + "S" + self.c2 + " - " + self.c1 + "Scripts" + self.nl
-        )
-        self.queue_game.put(
-            " " + self.c1 + "X" + self.c2 + " - " + self.c1 + "eXit" + self.nl
-        )
+        menu_item("P", "Port CIM Report")
+        menu_item("S", "Scripts")
+        menu_item("X", "eXit")
         self.queue_game.put("   " + self.c + "-=>" + self.r + " ")
 
     def awake(self):
@@ -198,17 +222,41 @@ class ProxyMenu(object):
         elif key == "Q":
             self.queue_game.put(self.c + key + self.r + self.nl)
 
-            # Ok, keepalive is stop(), and we are leaving this.
-            # So, when the PlayerInput is done, have it call welcome_back,
-            # which reinstates keepalive, and displays the menu.
+            # This is an example of chaining PlayerInput prompt calls.
 
             ask = PlayerInput(self.game)
-            d = ask.prompt("What is your quest? ", 20)
+            d = ask.prompt("What is your quest?", 20, name="quest", abort_blank=True)
 
             # Display the user's input
             d.addCallback(ask.output)
-            # To "return" to the ProxyMenu, call self.welcome_back
+
+            d.addCallback(
+                lambda ignore: ask.prompt(
+                    "What is your favorite color?", 5, name="color"
+                )
+            )
+            d.addCallback(ask.output)
+
+            d.addCallback(
+                lambda ignore: ask.prompt(
+                    "What is the meaning of the squirrel?",
+                    40,
+                    name="squirrel",
+                    digits=True,
+                )
+            )
+            d.addCallback(ask.output)
+
+            def show_values(show):
+                log.msg(show)
+
+            d.addCallback(lambda ignore: show_values(ask.keep))
             d.addCallback(self.welcome_back)
+
+            # On error, just return back
+            # This doesn't seem to be getting called.
+            # d.addErrback(lambda ignore: self.welcome_back)
+            d.addErrback(self.welcome_back)
             return
 
         elif key == "X":