GuiSkeleton updated

photobooth/camera/__init__.py

@@ -62,19 +62,19 @@ class Camera:
     def run(self):
 
         for state in self._comm.iter(Workers.CAMERA):
-            self.handleEvent(state)
+            self.handleState(state)
 
-    def handleEvent(self, event):
+    def handleState(self, state):
 
-        if isinstance(event, StateMachine.GreeterState):
+        if isinstance(state, StateMachine.GreeterState):
             self.prepareCapture()
-        elif isinstance(event, StateMachine.CountdownState):
+        elif isinstance(state, StateMachine.CountdownState):
             self.capturePreview()
-        elif isinstance(event, StateMachine.CaptureState):
+        elif isinstance(state, StateMachine.CaptureState):
             self.capturePicture()
-        elif isinstance(event, StateMachine.AssembleState):
+        elif isinstance(state, StateMachine.AssembleState):
             self.assemblePicture()
-        elif isinstance(event, StateMachine.TeardownState):
+        elif isinstance(state, StateMachine.TeardownState):
             self.teardown()
 
     def setActive(self):

photobooth/gui/GuiSkeleton.py

@@ -17,7 +17,8 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 
-from . import GuiState
+# from . import GuiState
+from .. import StateMachine
 
 
 class GuiSkeleton:
@@ -27,161 +28,79 @@ class GuiSkeleton:
         super().__init__()
         self._comm = communicator
 
-    @property
+    def showError(self, state):
-    def idle(self):
 
-        return self._idle
+        raise NotImplementedError()
 
-    @idle.setter
+    def showWelcome(self, state):
-    def idle(self, handle):
 
-        if not callable(handle):
+        raise NotImplementedError()
-            raise ValueError('Function handle for "idle" must be callable')
 
-        self._idle = handle
+    def showStartup(self, state):
 
-    @property
+        raise NotImplementedError()
-    def trigger(self):
 
-        return self._trigger
+    def showSettings(self, state):
 
-    @trigger.setter
+        raise NotImplementedError()
-    def trigger(self, handle):
 
-        if not callable(handle):
+    def showIdle(self, state):
-            raise ValueError('Function handle for "trigger" must be callable')
 
-        self._trigger = handle
+        raise NotImplementedError()
 
-    @property
+    def showGreeter(self, state):
-    def greeter(self):
 
-        return self._greeter
+        raise NotImplementedError()
 
-    @greeter.setter
+    def showCountdown(self, state):
-    def greeter(self, handle):
 
-        if not callable(handle):
+        raise NotImplementedError()
-            raise ValueError('Function handle for "greeter" must be callable')
 
-        self._greeter = handle
+    def showCapture(self, state):
 
-    @property
+        raise NotImplementedError()
-    def countdown(self):
 
-        return self._countdown
+    def showAssemble(self, state):
 
-    @countdown.setter
+        raise NotImplementedError()
-    def countdown(self, handle):
 
-        if not callable(handle):
+    def showReview(self, state):
-            raise ValueError(('Function handle for "countdown" must be '
-                              'callable'))
 
-        self._countdown = handle
+        raise NotImplementedError()
 
-    @property
+    def showPostprocess(self, state):
-    def preview(self):
 
-        return self._preview
+        raise NotImplementedError()
 
-    @preview.setter
+    def teardown(self, state):
-    def preview(self, handle):
 
-        if not callable(handle):
+        raise NotImplementedError()
-            raise ValueError('Function handle for "preview" must be callable')
-
-        self._preview = handle
-
-    @property
-    def pose(self):
-
-        return self._pose
-
-    @pose.setter
-    def pose(self, handle):
-
-        if not callable(handle):
-            raise ValueError('Function handle for "pose" must be callable')
-
-        self._pose = handle
-
-    @property
-    def assemble(self):
-
-        return self._assemble
-
-    @assemble.setter
-    def assemble(self, handle):
-
-        if not callable(handle):
-            raise ValueError('Function handle for "assemble" must be callable')
-
-        self._assemble = handle
-
-    @property
-    def review(self):
-
-        return self._review
-
-    @review.setter
-    def review(self, handle):
-
-        if not callable(handle):
-            raise ValueError('Function handle for "review" must be callable')
-
-        self._review = handle
-
-    @property
-    def teardown(self):
-
-        return self._teardown
-
-    @teardown.setter
-    def teardown(self, handle):
-
-        if not callable(handle):
-            raise ValueError('Function handle for "teardown" must be callable')
-
-        self._teardown = handle
-
-    @property
-    def error(self):
-
-        return self._error
-
-    @error.setter
-    def error(self, handle):
-
-        if not callable(handle):
-            raise ValueError('Function handle for "error" must be callable')
-
-        self._error = handle
 
     def handleState(self, state):
 
-        if not isinstance(state, GuiState.GuiState):
+        if isinstance(state, StateMachine.CameraEvent):
-            raise ValueError('Not a GuiState object received')
+            self.updateCountdown(state)
-
+        elif isinstance(state, StateMachine.ErrorState):
-        if isinstance(state, GuiState.IdleState):
+            self.showError(state)
-            self.idle(state)
+        elif isinstance(state, StateMachine.WelcomeState):
-        elif isinstance(state, GuiState.TriggerState):
+            self.showWelcome(state)
-            self.trigger(state)
+        elif isinstance(state, StateMachine.StartupState):
-        elif isinstance(state, GuiState.GreeterState):
+            self.showStartup(state)
-            self.greeter(state)
+        elif isinstance(state, StateMachine.SettingsState):
-        elif isinstance(state, GuiState.CountdownState):
+            self.showSettings(state)
-            self.countdown(state)
+        elif isinstance(state, StateMachine.IdleState):
-        elif isinstance(state, GuiState.PreviewState):
+            self.showIdle(state)
-            self.preview(state)
+        elif isinstance(state, StateMachine.GreeterState):
-        elif isinstance(state, GuiState.PoseState):
+            self.showGreeter(state)
-            self.pose(state)
+        elif isinstance(state, StateMachine.CountdownState):
-        elif isinstance(state, GuiState.AssembleState):
+            self.showCountdown(state)
-            self.assemble(state)
+        elif isinstance(state, StateMachine.CaptureState):
-        elif isinstance(state, GuiState.ReviewState):
+            self.showCapture(state)
-            self.review(state)
+        elif isinstance(state, StateMachine.AssembleState):
-        elif isinstance(state, GuiState.TeardownState):
+            self.showAssemble(state)
+        elif isinstance(state, StateMachine.ReviewState):
+            self.showReview(state)
+        elif isinstance(state, StateMachine.PostprocessState):
+            self.showPostprocess(state)
+        elif isinstance(state, StateMachine.TeardownState):
             self.teardown(state)
-        elif isinstance(state, GuiState.ErrorState):
-            self.error(state)
-        else:
-            raise ValueError('Unknown state received')