def analyze_selection(parameters=None): # A) calling ancestor if not ImmediateWithMemory.analyze_selection(): return False # B) validating if len(context.application.cache.nodes) == 0: return False # C) passed all tests: return True
def analyze_selection(parameters=None): # A) calling ancestor if not ImmediateWithMemory.analyze_selection(parameters): return False # B) validating if not isinstance(context.application.cache.node, Trajectory): return False # C) passed all tests: return True
def analyze_selection(parameters=None): # A) calling ancestor if not ImmediateWithMemory.analyze_selection(parameters): return False # B) validating cache = context.application.cache if len(cache.containers_with_children) + len(cache.referents_with_children) == 0: return False # C) passed all tests: return True
def analyze_selection(parameters=None): # A) calling ancestor if not ImmediateWithMemory.analyze_selection(parameters): return False # B) validating cache = context.application.cache if len(cache.translated_nodes) == 0: return False if cache.parent_of_translated_nodes is None: return False if cache.some_nodes_fixed: return False # C) passed all tests: return True
def analyze_selection(parameters=None): # A) calling ancestor if not ImmediateWithMemory.analyze_selection(parameters): return False # B) validating node = context.application.cache.node if not isinstance(node, GLTransformationMixin): return False if not isinstance(node.transformation, Rotation): return False if node.get_fixed(): return False # C) passed all tests: return True
def analyze_selection(parameters=None): # A) calling ancestor if not ImmediateWithMemory.analyze_selection(parameters): return False # B) validating and initialising destination = context.application.cache.drag_destination if parameters.child_index != -1: return False if not isinstance(destination, Reference): return False if not destination.check_target(context.application.cache.node): return False # C) passed all tests: return True
def analyze_selection(parameters=None): # A) calling ancestor if not ImmediateWithMemory.analyze_selection(parameters): return False # B) validating cache = context.application.cache if len(cache.nodes) == 0 or len(cache.nodes) > 2: return False for Class in cache.classes: if not issubclass(Class, GLFrameBase): return False if len(cache.nodes) == 2 and not isinstance(cache.parent, GLContainerMixin): return False # C) passed all tests: return True
def analyze_selection(parameters=None): # A) calling ancestor if not ImmediateWithMemory.analyze_selection(parameters): return False # B) validating and initialising destination = context.application.cache.drag_destination if not isinstance(destination, ContainerMixin): return False for Class in context.application.cache.classes: if not destination.check_add(Class): return False if context.application.cache.recursive_drag: return False # C) passed all tests: return True
def analyze_selection(parameters=None): # A) calling ancestor if not ImmediateWithMemory.analyze_selection(parameters): return False # B) validating universe = context.application.model.universe if sum(universe.cell.active) == 0: return False if hasattr(parameters, "repetitions_a") and not universe.cell.active[0]: return False if hasattr(parameters, "repetitions_b") and not universe.cell.active[1]: return False if hasattr(parameters, "repetitions_c") and not universe.cell.active[2]: return False # C) passed all tests: return True
def analyze_selection(parameters=None): # A) calling ancestor if not ImmediateWithMemory.analyze_selection(parameters): return False # B) validating cache = context.application.cache for Class in cache.classes: if not issubclass(Class, Spring): return False if cache.parent is None: return False spring_problem = cache.spring_problem if spring_problem is None: return False if len(spring_problem.frames) == 0: return False # C) passed all tests: return True
def analyze_selection(parameters=None): # A) calling ancestor if not ImmediateWithMemory.analyze_selection(parameters): return False # B) validating universe = context.application.model.universe if sum(universe.cell.active) == 0: return False if hasattr(parameters, "interval_a") and not universe.cell.active[0]: return False if hasattr(parameters, "interval_b") and not universe.cell.active[1]: return False if hasattr(parameters, "interval_c") and not universe.cell.active[2]: return False # C) passed all tests: return True
def analyze_selection(parameters=None): # A) calling ancestor if not ImmediateWithMemory.analyze_selection(parameters): return False cache = context.application.cache if len(cache.nodes) == 1: if not isinstance(cache.last, GLTransformationMixin) or \ not isinstance(cache.last.transformation, Rotation): return False if cache.last.get_fixed(): return False elif len(cache.nodes) == 2: if not ((isinstance(cache.last, GLTransformationMixin) and isinstance(cache.last.transformation, Translation)) or isinstance(cache.last, Vector)): return False if not isinstance(cache.next_to_last, GLTransformationMixin) or \ not isinstance(cache.next_to_last.transformation, Complete): return False if cache.last.get_fixed(): return False else: return False if cache.some_nodes_fixed: return False # C) passed all tests: return True
def analyze_selection(parameters=None): # A) calling ancestor if not ImmediateWithMemory.analyze_selection(parameters): return False if not AutoConnectMixin.analyze_selection(): return False # C) passed all tests: return True
def analyze_selection(parameters=None): if not ImmediateWithMemory.analyze_selection(parameters): return False if context.application.model.universe.cell_active.sum() != 2: return False return True
def analyze_selection(parameters=None): if not ImmediateWithMemory.analyze_selection(parameters): return False if context.application.model.universe.cell.active.sum() != 2: return False return True