def test_show_diagram(self): main_w = Application.get_service("main_window") element_factory = Application.get_service("element_factory") diagram = element_factory.create(UML.Diagram) main_w.open() self.component_registry.handle(DiagramShow(diagram)) self.assertEqual(self.get_current_diagram(), diagram)
def test_service_load(self): """Test loading services and querying utilities.""" Application.init(["undo_manager", "file_manager", "properties"]) self.assertTrue( Application.get_service("undo_manager") is not None, "Failed to load the undo manager service", ) self.assertTrue( Application.get_service("file_manager") is not None, "Failed to load the file manager service", ) self.assertTrue( component.queryUtility(IService, "undo_manager") is not None, "Failed to query the undo manager utility", ) self.assertTrue( component.queryUtility(IService, "file_manager") is not None, "Failed to query the file manager utility", ) Application.shutdown()
def launch(model=None): """Start the main application by initiating and running Application. The file_manager service is used here to load a Gaphor model if one was specified on the command line. Otherwise, a new model is created and the Gaphor GUI is started.""" # Make sure gui is loaded ASAP. # This prevents menu items from appearing at unwanted places. Application.essential_services.append('main_window') Application.init() main_window = Application.get_service('main_window') main_window.open() file_manager = Application.get_service('file_manager') if model: file_manager.load(model) else: file_manager.action_new() Application.run()
def setUp(self): Application.init(services=[ "event_manager", "component_registry", "element_factory", "main_window", "action_manager", "properties", "namespace", "diagrams", "toolbox", ]) main_window = Application.get_service("main_window") main_window.open() self.element_factory = Application.get_service("element_factory") self.diagram = self.element_factory.create(UML.Diagram) self.page = DiagramPage( self.diagram, Application.get_service("event_manager"), self.element_factory, Application.get_service("properties"), ) self.page.construct() assert self.page.diagram == self.diagram assert self.page.view.canvas == self.diagram.canvas assert len(self.element_factory.lselect()) == 1
def test_show_diagram(self): main_w = Application.get_service('main_window') element_factory = Application.get_service('element_factory') diagram = element_factory.create(UML.Diagram) main_w.open() self.assertEqual(main_w.get_current_diagram(), None) main_w.show_diagram(diagram)
def element_factory(): Application.init() element_factory = Application.get_service("element_factory") dist = importlib_metadata.distribution("gaphor") path = dist.locate_file("test-diagrams/issue_53.gaphor") load(path, element_factory) yield element_factory Application.get_service("element_factory").shutdown() Application.shutdown()
def setUp(self): Application.init(services=['adapter_loader', 'element_factory', 'main_window', 'properties_manager', 'action_manager', 'properties', 'element_dispatcher']) self.main_window = Application.get_service('main_window') self.element_factory = Application.get_service('element_factory') self.diagram = self.element_factory.create(UML.Diagram) self.comment = self.diagram.create(CommentItem, subject=self.element_factory.create(UML.Comment)) self.commentline = self.diagram.create(CommentLineItem) self.view = self.main_window.show_diagram(self.diagram).view
def _action_opening(action, obj, name): """ Open a new UI component if it is returned from the opening action. Otherwise do nothing. """ method = getattr(obj, name) ui_comp = method() if ui_comp: Application.get_service('main_window').create_item(ui_comp)
def setUp(self): Application.init(services=['element_factory', 'main_window', 'ui_manager', 'action_manager', 'properties', 'element_dispatcher']) main_window = Application.get_service('main_window') main_window.open() element_factory = Application.get_service('element_factory') self.element_factory = element_factory self.diagram = element_factory.create(UML.Diagram) self.tab = main_window.show_diagram(self.diagram) self.assertEquals(self.tab.diagram, self.diagram) self.assertEquals(self.tab.view.canvas, self.diagram.canvas) self.assertEquals(len(element_factory.lselect()), 1)
def setUp(self): Application.init(services=['element_factory', 'main_window', 'ui_manager', 'action_manager', 'properties', 'element_dispatcher']) main_window = Application.get_service('main_window') main_window.open() element_factory = Application.get_service('element_factory') self.element_factory = element_factory self.diagram = element_factory.create(uml2.Diagram) self.tab = main_window.show_diagram(self.diagram) self.assertEquals(self.tab.diagram, self.diagram) self.assertEquals(self.tab.view.canvas, self.diagram.canvas) self.assertEquals(len(element_factory.lselect()), 1)
def element_factory(): Application.init( services=["event_manager", "component_registry", "element_factory"]) event_manager = Application.get_service("event_manager") event_manager.subscribe(handler) clear_events() factory = Application.get_service("element_factory") yield factory del factory clear_events() Application.shutdown()
def test_service_load(): """Test loading services and querying utilities.""" Application.init() assert (Application.get_service("undo_manager") is not None), "Failed to load the undo manager service" assert (Application.get_service("file_manager") is not None), "Failed to load the file manager service" Application.shutdown()
def testDiagramLayout(self): elemfact = Application.get_service('element_factory') diagram_layout = Application.get_service('diagram_layout') diagram = elemfact.create(UML.Diagram) c1 = diagram.create(items.ClassItem, subject=elemfact.create(UML.Class)) c2 = diagram.create(items.ClassItem, subject=elemfact.create(UML.Class)) c2.matrix.translate(100, 100) c2.request_update() diagram_layout.layout_diagram(diagram)
def testDiagramLayout(self): elemfact = Application.get_service("element_factory") diagram_layout = Application.get_service("diagram_layout") diagram = elemfact.create(UML.Diagram) c1 = diagram.create(items.ClassItem, subject=elemfact.create(UML.Class)) c2 = diagram.create(items.ClassItem, subject=elemfact.create(UML.Class)) c2.matrix.translate(100, 100) c2.request_update() diagram_layout.layout_diagram(diagram)
def setUp(self): Application.init(services=['element_factory', 'main_window', 'action_manager', 'properties', 'element_dispatcher']) main_window = Application.get_service('main_window') element_factory = Application.get_service('element_factory') self.element_factory = element_factory self.diagram = element_factory.create(UML.Diagram) self.tab = DiagramTab(main_window) self.tab.set_diagram(self.diagram) self.assertEquals(self.tab.diagram, self.diagram) widget = self.tab.construct() main_window.add_tab(self.tab, widget, 'title') self.assertEquals(self.tab.view.canvas, self.diagram.canvas) self.assertEquals(len(element_factory.lselect()), 1)
def test_service_load(self): """ Load services. At lease the undo_manager should be available after that. """ Application.init(['undo_manager', 'file_manager', 'properties']) self.assertTrue(Application.get_service('undo_manager') is not None) self.assertTrue(Application.get_service('file_manager') is not None) # After that, services are also available as Utilities: self.assertTrue(component.queryUtility(IService, 'undo_manager') is not None) self.assertTrue(component.queryUtility(IService, 'file_manager') is not None) Application.shutdown()
def setUp(self): Application.init(services=[ 'file_manager', 'element_factory', 'properties', 'main_window', 'action_manager', 'ui_manager' ]) self.recent_files_backup = Application.get_service('properties').get( 'recent-files')
def application(): Application.init(services=[ "event_manager", "component_registry", "file_manager", "element_factory", "properties", "main_window", "action_manager", ]) recent_files_backup = Application.get_service("properties").get( "recent-files") yield Application Application.get_service("properties").set("recent-files", recent_files_backup) Application.shutdown()
def test_service_load(self): """Test loading services and querying utilities.""" Application.init(["undo_manager", "file_manager", "properties"]) self.assertTrue( Application.get_service("undo_manager") is not None, "Failed to load the undo manager service", ) self.assertTrue( Application.get_service("file_manager") is not None, "Failed to load the file manager service", ) Application.shutdown()
def setUp(self): Application.init(services=[ 'adapter_loader', 'element_factory', 'main_window', 'ui_manager', 'properties_manager', 'action_manager', 'properties', 'element_dispatcher' ]) self.main_window = Application.get_service('main_window') self.main_window.init() self.main_window.open() self.element_factory = Application.get_service('element_factory') self.diagram = self.element_factory.create(UML.Diagram) self.comment = self.diagram.create(CommentItem, subject=self.element_factory.create( UML.Comment)) self.commentline = self.diagram.create(CommentLineItem) self.view = self.main_window.show_diagram(self.diagram).view
def test_service_load(self): """Test loading services and querying utilities.""" Application.init(['undo_manager', 'file_manager', 'properties']) self.assertTrue(Application.get_service('undo_manager') is not None, 'Failed to load the undo manager service') self.assertTrue(Application.get_service('file_manager') is not None, 'Failed to load the file manager service') self.assertTrue(component.queryUtility(IService, 'undo_manager') is not None, ( 'Failed to query the undo manager utility')) self.assertTrue(component.queryUtility(IService, 'file_manager') is not None, ( 'Failed to query the file manager utility')) Application.shutdown()
def __get__(self, obj, class_=None): """ Resolve a dependency, but only if we're called from an object instance. """ if not obj: return self return Application.get_service(self._name)
def test_package_removal(element_factory): # Load the application element_factory = Application.get_service("element_factory") # Find all profile instances profiles = element_factory.lselect(lambda e: e.isKindOf(UML.Profile)) # Check there is 1 profile assert len(profiles) == 1 # Check the profile has 1 presentation assert len(profiles[0].presentation) == 1 # Unlink the presentation profiles[0].presentation[0].unlink() assert not element_factory.lselect(lambda e: e.isKindOf(UML.Profile)) classes = element_factory.lselect(lambda e: e.isKindOf(UML.Class)) assert len(classes) == 1 # Check if the link is really removed: assert not classes[0].appliedStereotype assert not element_factory.lselect(lambda e: e.isKindOf(UML.InstanceSpecification)) assert len(element_factory.lselect(lambda e: e.isKindOf(UML.Diagram))) == 3
def testPackageRemoval(self): # Load the application element_factory = Application.get_service('element_factory') # Find all profile instances profiles = element_factory.lselect(lambda e: e.isKindOf(UML.Profile)) # Check there is 1 profile self.assertEquals(1, len(profiles)) # Check the profile has 1 presentation self.assertEquals(1, len(profiles[0].presentation)) # Unlink the presentation profiles[0].presentation[0].unlink() self.assertFalse( element_factory.lselect(lambda e: e.isKindOf(UML.Profile))) classes = element_factory.lselect(lambda e: e.isKindOf(UML.Class)) self.assertEquals(1, len(classes)) # Check if the link is really removed: self.assertFalse(classes[0].appliedStereotype) self.assertFalse( element_factory.lselect( lambda e: e.isKindOf(UML.InstanceSpecification))) self.assertEquals( 3, len(element_factory.lselect(lambda e: e.isKindOf(UML.Diagram))))
def testPackageRemoval(self): # Load the application element_factory = Application.get_service("element_factory") # Find all profile instances profiles = element_factory.lselect(lambda e: e.isKindOf(UML.Profile)) # Check there is 1 profile self.assertEqual(1, len(profiles)) # Check the profile has 1 presentation self.assertEqual(1, len(profiles[0].presentation)) # Unlink the presentation profiles[0].presentation[0].unlink() self.assertFalse(element_factory.lselect(lambda e: e.isKindOf(UML.Profile))) classes = element_factory.lselect(lambda e: e.isKindOf(UML.Class)) self.assertEqual(1, len(classes)) # Check if the link is really removed: self.assertFalse(classes[0].appliedStereotype) self.assertFalse( element_factory.lselect(lambda e: e.isKindOf(UML.InstanceSpecification)) ) self.assertEqual( 3, len(element_factory.lselect(lambda e: e.isKindOf(UML.Diagram))) )
def test_connect_comment_and_actor(self): """Test connect/disconnect on comment and actor using comment-line. """ element_factory = Application.get_service("element_factory") diagram = element_factory.create(UML.Diagram) self.event_manager.handle(DiagramShow(diagram)) comment = diagram.create(CommentItem, subject=element_factory.create(UML.Comment)) line = diagram.create(CommentLineItem) view = self.get_diagram_view(diagram) assert view, "View should be available here" tool = ConnectHandleTool(view) # Connect one end to the Comment: handle = line.handles()[0] tool.grab_handle(line, handle) handle.pos = (0, 0) sink = tool.glue(line, handle, handle.pos) assert sink is not None assert sink.item is comment tool.connect(line, handle, handle.pos) cinfo = diagram.canvas.get_connection(handle) assert cinfo is not None, None assert cinfo.item is line assert cinfo.connected is comment # Connect the other end to the Actor: actor = diagram.create(ActorItem, subject=element_factory.create(UML.Actor)) handle = line.handles()[-1] tool.grab_handle(line, handle) handle.pos = (0, 0) sink = tool.glue(line, handle, handle.pos) assert sink, f"No sink at {handle.pos}" assert sink.item is actor tool.connect(line, handle, handle.pos) cinfo = view.canvas.get_connection(handle) assert cinfo.item is line assert cinfo.connected is actor # Try to connect far away from any item will only do a full disconnect self.assertEqual(len(comment.subject.annotatedElement), 1, comment.subject.annotatedElement) assert actor.subject in comment.subject.annotatedElement sink = tool.glue(line, handle, (500, 500)) assert sink is None, sink tool.connect(line, handle, (500, 500)) cinfo = view.canvas.get_connection(handle) assert cinfo is None
def test_iconnect_2(self): """Test connect/disconnect on comment and actor using comment-line. """ element_factory = Application.get_service("element_factory") diagram = element_factory.create(UML.Diagram) self.component_registry.handle(DiagramShow(diagram)) comment = diagram.create( CommentItem, subject=element_factory.create(UML.Comment) ) actor = diagram.create(ActorItem, subject=element_factory.create(UML.Actor)) line = diagram.create(CommentLineItem) view = self.get_diagram_view(diagram) assert view, "View should be available here" tool = ConnectHandleTool(view) # Connect one end to the Comment: handle = line.handles()[0] tool.grab_handle(line, handle) comment_bb = view.get_item_bounding_box(comment) handle.pos = (comment_bb.x1, comment_bb.y1) sink = tool.glue(line, handle, handle.pos) assert sink is not None assert sink.item is comment tool.connect(line, handle, handle.pos) cinfo = diagram.canvas.get_connection(handle) self.assertTrue(cinfo is not None, None) self.assertTrue(cinfo.item is line) self.assertTrue(cinfo.connected is comment) # Connect the other end to the Actor: handle = line.handles()[-1] tool.grab_handle(line, handle) actor_bb = view.get_item_bounding_box(actor) handle.pos = actor_bb.x1, actor_bb.y1 sink = tool.glue(line, handle, handle.pos) self.assertTrue(sink.item is actor) tool.connect(line, handle, handle.pos) cinfo = view.canvas.get_connection(handle) self.assertTrue(cinfo.item is line) self.assertTrue(cinfo.connected is actor) # Try to connect far away from any item will only do a full disconnect self.assertEqual( len(comment.subject.annotatedElement), 1, comment.subject.annotatedElement ) self.assertTrue(actor.subject in comment.subject.annotatedElement) sink = tool.glue(line, handle, (500, 500)) self.assertTrue(sink is None, sink) tool.connect(line, handle, (500, 500)) cinfo = view.canvas.get_connection(handle) self.assertTrue(cinfo is None)
def setUp(self): Application.init() element_factory = Application.get_service("element_factory") from gaphor.storage.storage import load dist = pkg_resources.get_distribution("gaphor") path = os.path.join(dist.location, "test-diagrams/issue_53.gaphor") load(path, element_factory)
def setUp(self): Application.init(services=self.services) self.element_factory = Application.get_service('element_factory') assert len(list(self.element_factory.select())) == 0, list( self.element_factory.select()) self.diagram = self.element_factory.create(UML.Diagram) assert len(list(self.element_factory.select())) == 1, list( self.element_factory.select())
def setUp(self): Application.init(services=[ 'adapter_loader', 'element_factory', 'main_window', 'ui_manager', 'properties_manager', 'action_manager', 'properties', 'element_dispatcher' ]) self.main_window = Application.get_service('main_window') self.main_window.open()
def setUp(self): Application.init(services=[ "element_factory", "main_window", "action_manager", "properties", "element_dispatcher", ]) main_window = Application.get_service("main_window") main_window.open() self.element_factory = Application.get_service("element_factory") self.diagram = self.element_factory.create(UML.Diagram) self.page = DiagramPage(self.diagram) self.page.construct() self.assertEqual(self.page.diagram, self.diagram) self.assertEqual(self.page.view.canvas, self.diagram.canvas) self.assertEqual(len(self.element_factory.lselect()), 1)
def setUp(self): Application.init() element_factory = Application.get_service('element_factory') from gaphor.storage.storage import load dist = pkg_resources.get_distribution('gaphor') path = os.path.join(dist.location, 'tests/issue_53.gaphor') load(path, element_factory)
def test_iconnect_2(self): """Test connect/disconnect on comment and actor using comment-line. """ element_factory = Application.get_service("element_factory") diagram = element_factory.create(UML.Diagram) self.component_registry.handle(DiagramShow(diagram)) comment = diagram.create(CommentItem, subject=element_factory.create(UML.Comment)) actor = diagram.create(ActorItem, subject=element_factory.create(UML.Actor)) line = diagram.create(CommentLineItem) view = self.get_diagram_view(diagram) assert view, "View should be available here" tool = ConnectHandleTool(view) # Connect one end to the Comment: handle = line.handles()[0] tool.grab_handle(line, handle) comment_bb = view.get_item_bounding_box(comment) handle.pos = (comment_bb.x1, comment_bb.y1) sink = tool.glue(line, handle, handle.pos) assert sink is not None assert sink.item is comment tool.connect(line, handle, handle.pos) cinfo = diagram.canvas.get_connection(handle) self.assertTrue(cinfo is not None, None) self.assertTrue(cinfo.item is line) self.assertTrue(cinfo.connected is comment) # Connect the other end to the Actor: handle = line.handles()[-1] tool.grab_handle(line, handle) actor_bb = view.get_item_bounding_box(actor) handle.pos = actor_bb.x1, actor_bb.y1 sink = tool.glue(line, handle, handle.pos) self.assertTrue(sink.item is actor) tool.connect(line, handle, handle.pos) cinfo = view.canvas.get_connection(handle) self.assertTrue(cinfo.item is line) self.assertTrue(cinfo.connected is actor) # Try to connect far away from any item will only do a full disconnect self.assertEqual(len(comment.subject.annotatedElement), 1, comment.subject.annotatedElement) self.assertTrue(actor.subject in comment.subject.annotatedElement) sink = tool.glue(line, handle, (500, 500)) self.assertTrue(sink is None, sink) tool.connect(line, handle, (500, 500)) cinfo = view.canvas.get_connection(handle) self.assertTrue(cinfo is None)
def load_generator(filename, factory): """ Load a file and create a model if possible. This function is a generator. It will yield values from 0 to 100 (%) to indicate its progression. """ if isinstance(filename, io.IOBase): log.info('Loading file from file descriptor') else: log.info('Loading file %s' % os.path.basename(filename)) try: # Use the incremental parser and yield the percentage of the file. loader = parser.GaphorLoader() for percentage in parser.parse_generator(filename, loader): pass if percentage: yield old_div(percentage, 2) else: yield percentage elements = loader.elements gaphor_version = loader.gaphor_version #elements = parser.parse(filename) #yield 100 except Exception as e: log.error('File could no be parsed', exc_info=True) raise try: component_registry = Application.get_service('component_registry') except NotInitializedError: component_registry = None try: factory.flush() gc.collect() log.info("Read %d elements from file" % len(elements)) if component_registry: component_registry.register_subscription_adapter( ElementChangedEventBlocker) try: for percentage in load_elements_generator(elements, factory, gaphor_version): if percentage: yield old_div(percentage, 2) + 50 else: yield percentage except Exception as e: raise finally: if component_registry: component_registry.unregister_subscription_adapter( ElementChangedEventBlocker) gc.collect() yield 100 except Exception as e: log.info('file %s could not be loaded' % filename) raise
def tearDown(self): """Finished with the test case. Unregister event handlers that store transaction events.""" component_registry = Application.get_service('component_registry') component_registry.unregister_handler(handle_begins, [TransactionBegin]) component_registry.unregister_handler(handle_commits, [TransactionCommit]) component_registry.unregister_handler(handle_rollback, [TransactionRollback])
def setUp(self): Application.init(services=[ "event_manager", "component_registry", "element_factory", "main_window", "properties_manager", "action_manager", "properties", "namespace", "diagrams", "toolbox", ]) self.component_registry = Application.get_service("component_registry") self.event_manager = Application.get_service("event_manager") self.main_window = Application.get_service("main_window") self.main_window.open()
def setUp(self): Application.init(services=[ "adapter_loader", "element_factory", "main_window", "properties_manager", "action_manager", "properties", "element_dispatcher", ]) self.main_window = Application.get_service("main_window") self.main_window.init() self.main_window.open() self.element_factory = Application.get_service("element_factory") self.diagram = self.element_factory.create(UML.Diagram) self.comment = self.diagram.create(CommentItem, subject=self.element_factory.create( UML.Comment)) self.commentline = self.diagram.create(CommentLineItem)
def setUp(self): Application.init(services=self.services) self.element_factory = Application.get_service("element_factory") assert len(list(self.element_factory.select())) == 0, list( self.element_factory.select() ) self.diagram = self.element_factory.create(UML.Diagram) assert len(list(self.element_factory.select())) == 1, list( self.element_factory.select() )
def test_show_diagram(self): main_w = MainWindow() element_factory = Application.get_service('element_factory') diagram = element_factory.create(UML.Diagram) ui_manager = gtk.UIManager() main_w.ui_manager = ui_manager main_w.construct() self.assertEqual(main_w.get_current_diagram(), None) main_w.show_diagram(diagram)
def setUp(self): Application.init( services=[ "element_factory", "main_window", "properties_manager", "action_manager", "properties", "element_dispatcher", ] ) self.main_window = Application.get_service("main_window") self.main_window.open() self.element_factory = Application.get_service("element_factory") self.diagram = self.element_factory.create(UML.Diagram) self.comment = self.diagram.create( CommentItem, subject=self.element_factory.create(UML.Comment) ) self.commentline = self.diagram.create(CommentLineItem)
def setUp(self): Application.init( services=[ "element_factory", "main_window", "action_manager", "properties", "element_dispatcher", ] ) main_window = Application.get_service("main_window") main_window.open() self.element_factory = Application.get_service("element_factory") self.diagram = self.element_factory.create(UML.Diagram) self.page = DiagramPage(self.diagram) self.page.construct() self.assertEqual(self.page.diagram, self.diagram) self.assertEqual(self.page.view.canvas, self.diagram.canvas) self.assertEqual(len(self.element_factory.lselect()), 1)
def setUp(self): Application.init(services=[ "file_manager", "element_factory", "properties", "main_window", "action_manager", ]) self.recent_files_backup = Application.get_service("properties").get( "recent-files")
def test_uml_associations(self): from zope import component from gaphor.UML.interfaces import IAssociationChangeEvent from gaphor.UML.properties import association, derivedunion from gaphor.UML import Element class A(Element): is_unlinked = False def unlink(self): self.is_unlinked = True Element.unlink(self) A.a1 = association('a1', A, upper=1) A.a2 = association('a2', A, upper=1) A.b1 = association('b1', A, upper='*') A.b2 = association('b2', A, upper='*') A.b3 = association('b3', A, upper=1) A.derived_a = derivedunion('derived_a', 0, 1, A.a1, A.a2) A.derived_b = derivedunion('derived_b', 0, '*', A.b1, A.b2, A.b3) events = [] @component.adapter(IAssociationChangeEvent) def handler(event, events=events): events.append(event) compreg = Application.get_service('component_registry') compreg.register_handler(handler) try: a = A() undo_manager = UndoManager() undo_manager.init(Application) undo_manager.begin_transaction() a.a1 = A() undo_manager.commit_transaction() assert len(events) == 1, events assert events[0].property is A.a1 assert undo_manager.can_undo() undo_manager.undo_transaction() assert not undo_manager.can_undo() assert undo_manager.can_redo() assert len(events) == 2, events assert events[1].property is A.a1 finally: compreg.unregister_handler(handler) undo_manager.shutdown()
def test_iconnect(self): """ Test basic glue functionality using CommentItem and CommentLine items. """ element_factory = Application.get_service('element_factory') diagram = element_factory.create(UML.Diagram) comment = diagram.create(CommentItem, subject=element_factory.create(UML.Comment)) #assert comment.height == 50 #assert comment.width == 100 actor = diagram.create(ActorItem, subject=element_factory.create(UML.Actor)) actor.matrix.translate(200, 200) diagram.canvas.update_matrix(actor) line = diagram.create(CommentLineItem) view = self.get_diagram_view(diagram) assert view, 'View should be available here' tool = ConnectHandleTool(view) # select handle: handle = line.handles()[-1] tool._grabbed_item = line tool._grabbed_handle = handle # Should glue to (238, 248) handle.pos = 245, 248 item = tool.glue(line, handle, (245, 248)) self.assertTrue(item is not None) self.assertEquals((238, 248), view.canvas.get_matrix_i2c(line).transform_point( handle.x, handle.y)) handle.pos = 245, 248 tool.connect(line, handle, (245, 248)) cinfo = diagram.canvas.get_connection(handle) self.assertTrue(cinfo.constraint is not None) self.assertTrue(cinfo.connected is actor, cinfo.connected) self.assertEquals( (238, 248), view.get_matrix_i2v(line).transform_point(handle.x, handle.y)) Connector(line, handle).disconnect() #tool.disconnect(line, handle) cinfo = diagram.canvas.get_connection(handle) self.assertTrue(cinfo is None)
def testLoadAll(self): from gaphor.application import Application Application.init() am = Application.get_service("action_manager") ui = am.ui_manager.get_ui() assert '<menuitem name="file-quit" action="file-quit"/>' in ui, ui # From filemanager: assert '<menuitem name="file-new" action="file-new"/>' in ui, ui # From Undomanager assert '<toolitem name="edit-undo" action="edit-undo"/>' in ui, ui
def test_uml_associations(self): from gaphor.UML.event import AssociationChangeEvent from gaphor.UML.properties import association, derivedunion from gaphor.UML import Element class A(Element): is_unlinked = False def unlink(self): self.is_unlinked = True Element.unlink(self) A.a1 = association("a1", A, upper=1) A.a2 = association("a2", A, upper=1) A.b1 = association("b1", A, upper="*") A.b2 = association("b2", A, upper="*") A.b3 = association("b3", A, upper=1) A.derived_a = derivedunion("derived_a", 0, 1, A.a1, A.a2) A.derived_b = derivedunion("derived_b", 0, "*", A.b1, A.b2, A.b3) events = [] @event_handler(AssociationChangeEvent) def handler(event, events=events): events.append(event) compreg = Application.get_service("component_registry") compreg.register_handler(handler) try: a = A(factory=self.element_factory) undo_manager = UndoManager() undo_manager.init(Application) undo_manager.begin_transaction() a.a1 = A(factory=self.element_factory) undo_manager.commit_transaction() assert len(events) == 1, events assert events[0].property is A.a1 assert undo_manager.can_undo() undo_manager.undo_transaction() assert not undo_manager.can_undo() assert undo_manager.can_redo() assert len(events) == 2, events assert events[1].property is A.a1 finally: compreg.unregister_handler(handler) undo_manager.shutdown()
def test_recent_files(self): fileman = Application.get_service('file_manager') properties = Application.get_service('properties') # ensure the recent_files list is empty: properties.set('recent-files', []) fileman.update_recent_files() for i in range(0, 9): a = fileman.action_group.get_action('file-recent-%d' % i) assert a assert a.get_property('visible') == False, '%s, %d' % (a.get_property('visible'), i) fileman.filename = 'firstfile' a = fileman.action_group.get_action('file-recent-%d' % 0) assert a assert a.get_property('visible') == True assert a.props.label == '_1. firstfile', a.props.label for i in range(1, 9): a = fileman.action_group.get_action('file-recent-%d' % i) assert a assert a.get_property('visible') == False
def test(self): factory = Application.get_service('element_factory') ns = NamespaceModel(factory) m = factory.create(UML.Package) m.name = 'm' assert ns._nodes.has_key(m) assert ns.path_from_element(m) == (1,) assert ns.element_from_path((1,)) is m a = factory.create(UML.Package) a.name = 'a' assert a in ns._nodes assert a in ns._nodes[None] assert m in ns._nodes assert ns.path_from_element(a) == (1,), ns.path_from_element(a) assert ns.path_from_element(m) == (2,), ns.path_from_element(m) a.package = m assert a in ns._nodes assert a not in ns._nodes[None] assert a in ns._nodes[m] assert m in ns._nodes assert a.package is m assert a in m.ownedMember assert a.namespace is m assert ns.path_from_element(a) == (1, 0), ns.path_from_element(a) c = factory.create(UML.Class) c.name = 'c' assert c in ns._nodes assert ns.path_from_element(c) == (1,), ns.path_from_element(c) assert ns.path_from_element(m) == (2,), ns.path_from_element(m) assert ns.path_from_element(a) == (2, 0), ns.path_from_element(a) c.package = m assert c in ns._nodes assert c not in ns._nodes[None] assert c in ns._nodes[m] c.package = a assert c in ns._nodes assert c not in ns._nodes[None] assert c not in ns._nodes[m] assert c in ns._nodes[a] c.unlink() assert c not in ns._nodes assert c not in ns._nodes[None] assert c not in ns._nodes[m] assert c not in ns._nodes[a]
def setUp(self): Application.init( services=[ "file_manager", "element_factory", "properties", "main_window", "action_manager", ] ) self.recent_files_backup = Application.get_service("properties").get( "recent-files" )
def setUp(self): Application.init( services=[ "element_factory", "main_window", "properties_manager", "action_manager", "properties", "element_dispatcher", ] ) self.main_window = Application.get_service("main_window") self.main_window.open()
def setUp(self): super(ElementDispatcherAsServiceTestCase, self).setUp() self.events = [] self.dispatcher = Application.get_service("element_dispatcher") element_factory = self.element_factory class A(Element): def __init__(self): super().__init__(factory=element_factory) A.one = association("one", A, lower=0, upper=1, composite=True) A.two = association("two", A, lower=0, upper=2, composite=True) self.A = A
def test_recent_files(self): fileman = Application.get_service("file_manager") properties = Application.get_service("properties") # ensure the recent_files list is empty: properties.set("recent-files", []) fileman.update_recent_files() for i in range(0, 9): a = fileman.action_group.get_action("file-recent-%d" % i) assert a assert a.get_property("visible") == False, "%s, %d" % ( a.get_property("visible"), i, ) fileman.filename = "firstfile" a = fileman.action_group.get_action("file-recent-%d" % 0) assert a assert a.get_property("visible") == True assert a.props.label == "_1. firstfile", a.props.label for i in range(1, 9): a = fileman.action_group.get_action("file-recent-%d" % i) assert a assert a.get_property("visible") == False
def setUp(self): """Initialize Gaphor services and register transaction event handlers.""" Application.init(services=['component_registry']) component_registry = Application.get_service('component_registry') component_registry.register_handler(handle_begins, [TransactionBegin]) component_registry.register_handler(handle_commits, [TransactionCommit]) component_registry.register_handler(handle_rollback, [TransactionRollback]) del begins[:] del commits[:] del rollbacks[:]
def test_iconnect(self): """ Test basic glue functionality using CommentItem and CommentLine items. """ element_factory = Application.get_service('element_factory') diagram = element_factory.create(UML.Diagram) comment = diagram.create(CommentItem, subject=element_factory.create(UML.Comment)) #assert comment.height == 50 #assert comment.width == 100 actor = diagram.create(ActorItem, subject=element_factory.create(UML.Actor)) actor.matrix.translate(200, 200) diagram.canvas.update_matrix(actor) line = diagram.create(CommentLineItem) view = self.get_diagram_view(diagram) assert view, 'View should be available here' tool = ConnectHandleTool(view) # select handle: handle = line.handles()[-1] tool._grabbed_item = line tool._grabbed_handle = handle # Should glue to (238, 248) handle.pos = 245, 248 item = tool.glue(line, handle, (245, 248)) self.assertTrue(item is not None) self.assertEquals((238, 248), view.canvas.get_matrix_i2c(line).transform_point(handle.x, handle.y)) handle.pos = 245, 248 tool.connect(line, handle, (245, 248)) cinfo = diagram.canvas.get_connection(handle) self.assertTrue(cinfo.constraint is not None) self.assertTrue(cinfo.connected is actor, cinfo.connected) self.assertEquals((238, 248), view.get_matrix_i2v(line).transform_point(handle.x, handle.y)) Connector(line, handle).disconnect() #tool.disconnect(line, handle) cinfo = diagram.canvas.get_connection(handle) self.assertTrue(cinfo is None)
def testPackageRemovalByRemovingTheDiagram(self): element_factory = Application.get_service('element_factory') diagram = element_factory.lselect(lambda e: e.isKindOf(UML.Diagram) and e.name == 'Stereotypes diagram')[0] self.assertTrue(diagram) diagram.unlink() self.assertFalse(element_factory.lselect(lambda e: e.isKindOf(UML.Profile))) classes = element_factory.lselect(lambda e: e.isKindOf(UML.Class)) self.assertEquals(1, len(classes)) # Check if the link is really removed: self.assertFalse(classes[0].appliedStereotype) self.assertFalse(element_factory.lselect(lambda e: e.isKindOf(UML.InstanceSpecification))) self.assertEquals(2, len(element_factory.lselect(lambda e: e.isKindOf(UML.Diagram))))