1 files changed, 91 insertions, 5 deletions
diff --git a/grc/base/Block.py b/grc/base/Block.py
index b367e60e69..5e8a7179ac 100644
--- a/grc/base/Block.py
+++ b/grc/base/Block.py
@@ -19,12 +19,17 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 
 from . import odict
 from . Constants import ADVANCED_PARAM_TAB, DEFAULT_PARAM_TAB
+from . Constants import BLOCK_FLAG_THROTTLE, BLOCK_FLAG_DISABLE_BYPASS
+from . Constants import BLOCK_ENABLED, BLOCK_BYPASSED, BLOCK_DISABLED
 from Element import Element
 
 from Cheetah.Template import Template
 from UserDict import UserDict
 from itertools import imap
 
+from .. gui import Messages
+
+
 class TemplateArg(UserDict):
     """
     A cheetah template argument created from a param.
@@ -46,11 +51,16 @@ class TemplateArg(UserDict):
     def __call__(self):
         return self._param.get_evaluated()
 
-def _get_keys(lst): return [elem.get_key() for elem in lst]
+
+def _get_keys(lst):
+    return [elem.get_key() for elem in lst]
+
+
 def _get_elem(lst, key):
     try: return lst[_get_keys(lst).index(key)]
     except ValueError: raise ValueError, 'Key "%s" not found in %s.'%(key, _get_keys(lst))
 
+
 class Block(Element):
 
     def __init__(self, flow_graph, n):
@@ -73,6 +83,10 @@ class Block(Element):
         self._name = n.find('name')
         self._key = n.find('key')
         self._category = n.find('category') or ''
+        self._flags = n.find('flags') or ''
+        # Backwards compatibility
+        if n.find('throttle') and BLOCK_FLAG_THROTTLE not in self._flags:
+            self._flags += BLOCK_FLAG_THROTTLE
         self._grc_source = n.find('grc_source') or ''
         self._block_wrapper_path = n.find('block_wrapper_path')
         self._bussify_sink = n.find('bus_sink')
@@ -143,6 +157,10 @@ class Block(Element):
                                      and (self._key != "pad_sink"))
         is_variable = self._key.startswith('variable')
 
+        # Disable blocks that are virtual/pads or variables
+        if not is_not_virtual_or_pad or is_variable:
+            self._flags += BLOCK_FLAG_DISABLE_BYPASS
+
         if is_not_virtual_or_pad and not is_variable:
             self.get_params().append(self.get_parent().get_parent().Param(
                 block=self,
@@ -197,7 +215,6 @@ class Block(Element):
                          })
                 ))
 
-
     def back_ofthe_bus(self, portlist):
         portlist.sort(key=lambda p: p._type == 'bus')
 
@@ -205,6 +222,35 @@ class Block(Element):
         buslist = [p for p in ports if p._type == 'bus']
         return buslist or ports
 
+    # Main functions to get and set the block state
+    # Also kept get_enabled and set_enabled to keep compatibility
+    def get_state(self):
+        """
+        Gets the block's current state.
+
+        Returns:
+            ENABLED - 0
+            BYPASSED - 1
+            DISABLED - 2
+        """
+        try: return int(eval(self.get_param('_enabled').get_value()))
+        except: return BLOCK_ENABLED
+
+    def set_state(self, state):
+        """
+        Sets the state for the block.
+
+        Args:
+            ENABLED - 0
+            BYPASSED - 1
+            DISABLED - 2
+        """
+        if state in [BLOCK_ENABLED, BLOCK_BYPASSED, BLOCK_DISABLED]:
+            self.get_param('_enabled').set_value(str(state))
+        else:
+            self.get_param('_enabled').set_value(str(BLOCK_ENABLED))
+
+    # Enable/Disable Aliases
     def get_enabled(self):
         """
         Get the enabled state of the block.
@@ -212,8 +258,7 @@ class Block(Element):
         Returns:
             true for enabled
         """
-        try: return eval(self.get_param('_enabled').get_value())
-        except: return True
+        return not (self.get_state() == BLOCK_DISABLED)
 
     def set_enabled(self, enabled):
         """
@@ -221,8 +266,45 @@ class Block(Element):
 
         Args:
             enabled: true for enabled
+
+        Returns:
+            True if block changed state
+        """
+        old_state = self.get_state()
+        new_state = BLOCK_ENABLED if enabled else BLOCK_DISABLED
+        self.set_state(new_state)
+        return old_state != new_state
+
+    # Block bypassing
+    def get_bypassed(self):
+        """
+        Check if the block is bypassed
         """
-        self.get_param('_enabled').set_value(str(enabled))
+        return self.get_state() == BLOCK_BYPASSED
+
+    def set_bypassed(self):
+        """
+        Bypass the block
+
+        Returns:
+            True if block chagnes state
+        """
+        if self.get_state() != BLOCK_BYPASSED and self.can_bypass():
+            self.set_state(BLOCK_BYPASSED)
+            return True
+        return False
+
+    def can_bypass(self):
+        """ Check the number of sinks and sources and see if this block can be bypassed """
+        # Check to make sure this is a single path block
+        # Could possibly support 1 to many blocks
+        if len(self.get_sources()) != 1 or len(self.get_sinks()) != 1:
+            return False
+        if not (self.get_sources()[0].get_type() == self.get_sinks()[0].get_type()):
+            return False
+        if self.bypass_disabled():
+            return False
+        return True
 
     def __str__(self): return 'Block - %s - %s(%s)'%(self.get_id(), self.get_name(), self.get_key())
 
@@ -240,6 +322,10 @@ class Block(Element):
     def get_block_wrapper_path(self): return self._block_wrapper_path
     def get_comment(self): return self.get_param('comment').get_value()
 
+    def get_flags(self): return self._flags
+    def throtteling(self): return BLOCK_FLAG_THROTTLE in self._flags
+    def bypass_disabled(self): return BLOCK_FLAG_DISABLE_BYPASS in self._flags
+
     ##############################################
     # Access Params
     ##############################################