def __init__(self, main_window):
super().__init__(main_window)
self.setWindowTitle(_("Add-ons"))
self.__processes = AddOnProcessManager(self)
self.__main_window = main_window
button_box = QDialogButtonBox(QDialogButtonBox.Close)
button_box.button(QDialogButtonBox.Close).setText(_("Close"))
button_box.rejected.connect(self.reject)
layout = QVBoxLayout()
self.__tabs = QTabWidget()
self.__tabs.addTab(InstalledAddOnList(self.__processes),
_("Installed Add-ons"))
self.__tabs.addTab(OnlineAddOnList(self.__processes),
_("Online Add-ons"))
self.__has_update_tab = False
self.__refresh_update_tab()
layout.addWidget(self.__tabs)
layout.addWidget(button_box)
self.setLayout(layout)
Application().event_dispatcher.subscribe(AddOnInstalledEvent,
self.__addon_list_changed)
Application().event_dispatcher.subscribe(AddOnUninstalledEvent,
self.__addon_list_changed)
Application().event_dispatcher.subscribe(AddOnUpdatedEvent,
self.__addon_list_changed)
def __init__(self, main_window):
super().__init__()
self.__main_window = main_window
self.setTabPosition(QTabWidget.South)
Application().event_dispatcher.subscribe(LanguageChangedEvent,
self.__language_changed)
Application().event_dispatcher.subscribe(ItemSelectedEvent,
self.__item_selected)
Application().event_dispatcher.subscribe(ObjectDataChangedEvent,
self.__object_changed)
Application().event_dispatcher.subscribe(ProjectChangedEvent,
self.__project_changed)
Application().event_dispatcher.subscribe(ElementDeletedEvent,
self.__element_deleted)
Application().event_dispatcher.subscribe(ConnectionDeletedEvent,
self.__connection_deleted)
Application().event_dispatcher.subscribe(DiagramDeletedEvent,
self.__diagram_deleted)
Application().event_dispatcher.subscribe(SelectionChangedEvent,
self.__selection_changed)
Application().event_dispatcher.subscribe(ChangedCurrentTabEvent,
self.__tab_changed)
Application().event_dispatcher.subscribe(CloseSolutionEvent,
self.__solution_closed)
self.__item = None
self.__dialog = None
self.__select_item(None)
def qt_main(args):
SPECIALS.init()
if hasattr(Qt, 'AA_DisableWindowContextHelpButton'):
QApplication.setAttribute(Qt.AA_DisableWindowContextHelpButton)
QApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
app = QApplication(args)
Application().use_args(args[1:])
Application().use_thread_manager(QTThreadManager())
Application().use_ruler(QTRuler())
Application().start()
install_exception_hook()
splash = SplashScreen()
splash.start()
SPECIALS.before_start()
no = app.exec_()
SPECIALS.after_quit()
Application().stop()
return no
class SplashScreen(QSplashScreen):
def __init__(self):
super().__init__(QPixmap(os.path.join(GRAPHICS, "splash", "splash.png")))
self.__init_application()
self.__timer = QTimer(self)
self.__timer.timeout.connect(self.__timer_event)
self.__timeout = time() + SPLASH_TIMEOUT / 1000
def start(self):
self.__timer.start(100)
self.__timer_event()
self.show()
def __init_application(self):
self.__starter = Application().addons.local.start_all()
def __timer_event(self):
if self.__timeout < time() and self.__starter.finished:
self.__timer.stop()
main_window = UmlFriMainWindow()
main_window.showMaximized()
self.finish(main_window)
Application().init_after_main_window_shown()
else:
self.__starter.do()
def drawContents(self, painter):
qfont = QFont("Arial")
qfont.setPixelSize(12)
painter.setPen(QPen(QColor(255, 255, 255)))
painter.setFont(qfont)
painter.drawText(300, 150, "Version: {0}".format(Application().about.version))
def __align_action(self, checked=False, horizontal=None, vertical=None):
tab = Application().tabs.current_tab
if tab is not None:
command = AlignSelectionCommand(tab.drawing_area.selection,
horizontal=horizontal,
vertical=vertical)
Application().commands.execute(command)
def __edit_duplicate_action(self, checked=False):
drawing_area = Application().tabs.current_tab.drawing_area
command = DuplicateSnippetCommand(drawing_area.diagram,
Application().clipboard)
Application().commands.execute(command)
drawing_area.selection.select(command.element_visuals)
def new_project(self):
dialog = NewProjectDialog.open_dialog(self)
if dialog:
if dialog.new_solution and Application().unsaved:
if not self.__check_save(_("New Project")):
return
Application().new_project(dialog.selected_template, dialog.new_solution, dialog.project_name)
def __init__(self, main_window):
super().__init__()
self.__main_window = main_window
self.__background = QPixmap()
self.__background.load(os.path.join(GRAPHICS, "startpage", "startpage.png"))
layout = QHBoxLayout()
layout.setSpacing(50)
layout.setContentsMargins(100, 250, 100, 0)
layout.setAlignment(Qt.AlignLeft | Qt.AlignTop)
self.__actions_frame = StartPageFrame()
layout.addWidget(self.__actions_frame)
self.__new_project = self.__actions_frame.add_frame_action()
self.__new_project.set_action_callback(self.__main_window.new_project)
self.__open_project = self.__actions_frame.add_frame_action()
self.__open_project.set_action_callback(self.__main_window.open_solution)
self.__recent_files_frame = StartPageFrame()
layout.addWidget(self.__recent_files_frame)
self.setLayout(layout)
Application().event_dispatcher.subscribe(LanguageChangedEvent, self.__language_changed)
Application().event_dispatcher.subscribe(RecentFilesChangedEvent, self.__recent_files_changed)
self.__reload_texts()
self.__reload_recent_files()
def __init__(self, tab_bar, tab_index, tab_widget):
super().__init__()
self.__tab_bar = tab_bar
self.__tab_index = tab_index
self.__tab_widget = tab_widget
if isinstance(tab_widget, StartPage):
if tab_bar.count() == 1:
can_close = False
else:
can_close = True
self.__tab = None
else:
self.__tab = Application().tabs.get_tab_for(tab_widget.diagram)
can_close = True
if self.__tab is None:
self._add_menu_item(None, _("Lock Tab"), None)
else:
if self.__tab.locked:
self._add_menu_item(None, _("Unlock Tab"), None,
self.__unlock_tab)
else:
self._add_menu_item(None, _("Lock Tab"), None, self.__lock_tab)
self.addSeparator()
if can_close:
self._add_menu_item(None, _("Close Tab"), QKeySequence.Close,
self.__close_tab)
self._add_menu_item(None, _("Close All Tabs"), None,
self.__close_all_tabs)
else:
self._add_menu_item(None, _("Close Tab"), QKeySequence.Close)
self._add_menu_item(None, _("Close All Tabs"), None)
def __tab_close_requested(self, index):
widget = self.widget(index)
if isinstance(widget, (ScrolledCanvasWidget, CanvasWidget)):
tab = Application().tabs.get_tab_for(widget.diagram)
if tab is None:
return
if tab.locked:
message_box = QMessageBox(self)
message_box.setWindowModality(Qt.WindowModal)
message_box.setIcon(QMessageBox.Warning)
message_box.setWindowTitle(_("Closing Locked Tab"))
message_box.setText(
_("The tab you have just requested to be closed is locked."
))
message_box.setInformativeText(
_("Do you really want to close it?"))
message_box.setStandardButtons(QMessageBox.Yes
| QMessageBox.No)
message_box.setDefaultButton(QMessageBox.No)
message_box.button(QMessageBox.Yes).setText(_("Yes"))
message_box.button(QMessageBox.No).setText(_("No"))
resp = message_box.exec_()
if resp == QMessageBox.No:
return
tab.close()
elif isinstance(widget, StartPage):
self.removeTab(self.indexOf(widget))
self.__handle_last_tab()
def reload(self):
self.clear()
if Application().solution is None:
return
for project in Application().solution.children:
self.__reload_project(project)
def apply_settings(self):
if self.__use_system.isChecked():
Application().language.change_language(None)
else:
selected_no = self.__language_selector.currentIndex()
Application().language.change_language(
AVAILABLE_LANGUAGES[selected_no][0])
def __edit_cut_action(self, checked=False):
drawing_area = Application().tabs.current_tab.drawing_area
drawing_area.copy_snippet()
command = HideElementsCommand(drawing_area.diagram,
drawing_area.selection.selected_elements)
Application().commands.execute(command)
def __init__(self, processes):
super().__init__()
self.__processes = processes
Application().event_dispatcher.subscribe(AddOnInstalledEvent,
self.__addon_installed)
Application().event_dispatcher.subscribe(AddOnUninstalledEvent,
self.__addon_uninstalled)
def __init__(self, processes):
super().__init__()
self.__processes = processes
Application().event_dispatcher.subscribe(AddOnStateChangedEvent, self.__addon_state_changed)
Application().event_dispatcher.subscribe(AddOnInstalledEvent, self.__addon_list_changed)
Application().event_dispatcher.subscribe(AddOnUninstalledEvent, self.__addon_list_changed)
Application().event_dispatcher.subscribe(AddOnUpdatedEvent, self.__addon_list_changed)
def __init__(self):
self.__clipboard = QApplication.clipboard()
self.__last_snippet = Application().clipboard
self.__serialized = None
self.__clipboard.changed.connect(self.__qt_clipboard_changed)
Application().event_dispatcher.subscribe(
ClipboardSnippetChangedEvent, self.__umlfri_clipboard_changed)
self.__synchronize_from_qt()
def __redo_menu_show(self):
self.__redo_menu.clear()
for no, cmd in enumerate(
Application().commands.get_redo_stack(UNDO_REDO_COUNT)):
action = self.__redo_menu.addAction(cmd.description)
action.triggered.connect(partial(self.__redo_action, no + 1))
if Application().commands.redo_stack_size > UNDO_REDO_COUNT:
self.__redo_menu.addAction("...").setEnabled(False)
def __init__(self, main_window):
super().__init__()
self.__main_window = main_window
self.__shortcuts = {}
self.__new = self.__add_toolbar_item(QKeySequence.New, "document-new",
self.__new_action)
self.__open = self.__add_toolbar_item(QKeySequence.Open,
"document-open",
self.__open_action)
self.__save = self.__add_toolbar_item(QKeySequence.Save,
"document-save",
self.__save_action)
self.addSeparator()
self.__cut = self.__add_toolbar_item(QKeySequence.Cut, "edit-cut",
self.__cut_action)
self.__copy = self.__add_toolbar_item(QKeySequence.Copy, "edit-copy",
self.__copy_action)
self.__paste = self.__add_toolbar_item(QKeySequence.Paste,
"edit-paste",
self.__paste_action)
self.addSeparator()
self.__undo_menu = QMenu()
self.__redo_menu = QMenu()
self.__undo_menu.aboutToShow.connect(self.__undo_menu_show)
self.__redo_menu.aboutToShow.connect(self.__redo_menu_show)
self.__undo = self.__add_toolbar_item(QKeySequence.Undo, "edit-undo",
partial(self.__undo_action, 1),
self.__undo_menu)
self.__redo = self.__add_toolbar_item(QKeySequence.Redo, "edit-redo",
partial(self.__redo_action, 1),
self.__redo_menu)
self.addSeparator()
self.__zoom_in = self.__add_toolbar_item(QKeySequence.ZoomIn,
"zoom-in",
self.__zoom_in_action)
self.__zoom_out = self.__add_toolbar_item(QKeySequence.ZoomOut,
"zoom-out",
self.__zoom_out_action)
Application().event_dispatcher.subscribe(LanguageChangedEvent,
self.__language_changed)
self.__reload_texts()
Application().event_dispatcher.subscribe(None, self.__event_dispatched)
self.__refresh_enable()
def __reload_window_title(self):
title = _("UML .FRI 2")
if Application().solution_name is not None:
title += " [{0}]".format(Application().solution_name)
elif Application().solution is not None:
title += " [{0}]".format(_("unsaved"))
if Application().change_status:
title += "*"
self.setWindowTitle(title)
def __init__(self, processes):
super().__init__(check_boxes=True, show_prev_version=True)
self.__processes = processes
Application().event_dispatcher.subscribe(AddOnInstalledEvent,
self.__addon_list_changed)
Application().event_dispatcher.subscribe(AddOnUninstalledEvent,
self.__addon_list_changed)
Application().event_dispatcher.subscribe(AddOnUpdatedEvent,
self.__addon_list_changed)
def __delete_object(self):
if self.__drawing_area.selection.selected_elements:
command = DeleteElementsCommand(
tuple(element.object for element in
self.__drawing_area.selection.selected_elements))
Application().commands.execute(command)
elif self.__drawing_area.selection.selected_connection:
command = DeleteConnectionCommand(
self.__drawing_area.selection.selected_connection)
Application().commands.execute(command)
def __hide_object(self):
if self.__drawing_area.selection.selected_elements:
command = HideElementsCommand(
self.__drawing_area.diagram,
self.__drawing_area.selection.selected_elements)
Application().commands.execute(command)
elif self.__drawing_area.selection.selected_connection:
command = HideConnectionCommand(
self.__drawing_area.diagram,
self.__drawing_area.selection.selected_connection)
Application().commands.execute(command)
def __tab_changed(self, index):
if self.__ignore_change_tab:
return
if index >= 0:
widget = self.widget(index)
if isinstance(widget, (ScrolledCanvasWidget, CanvasWidget)):
Application().tabs.select_tab(widget.diagram)
else:
Application().tabs.select_tab(None)
def __init__(self, main_window):
super().__init__(main_window)
self.setWindowTitle(_("New Project"))
self.__main_window = main_window
button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
button_box.button(QDialogButtonBox.Ok).setText(_("Ok"))
button_box.button(QDialogButtonBox.Cancel).setText(_("Cancel"))
button_box.accepted.connect(self.accept)
button_box.rejected.connect(self.reject)
self.__ok_button = button_box.button(QDialogButtonBox.Ok)
layout = QVBoxLayout()
self.__templates = QListWidget()
self.__templates.setViewMode(QListWidget.IconMode)
self.__templates.setMovement(QListWidget.Static)
self.__templates.itemSelectionChanged.connect(self.__selection_changed)
self.__templates.itemDoubleClicked.connect(self.__selection_double_clicked)
self.__description = QLabel()
self.__description.setBackgroundRole(QPalette.Base)
self.__description.setAutoFillBackground(True)
self.__description.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
self.__description.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.__description.setAlignment(Qt.AlignTop)
self.__description.setWordWrap(True)
self.__project_name = QLineEdit()
self.__project_name.setText(_("Project"))
self.__project_name.textChanged.connect(self.__name_changed)
project_name_layout = QFormLayout()
project_name_layout.addRow(_("Project &name:"), self.__project_name)
self.__new_solution = QCheckBox(_("Create a new &solution"))
self.__new_solution.setChecked(True)
if Application().solution is None:
self.__new_solution.setEnabled(False)
layout.addWidget(self.__templates)
layout.addWidget(self.__description)
layout.addLayout(project_name_layout)
layout.addWidget(self.__new_solution)
layout.addWidget(button_box)
self.setLayout(layout)
for template in Application().templates:
self.__templates.addItem(TemplateItem(template))
self.__templates.setCurrentRow(0)
def __synchronize_from_qt(self):
mime_data = self.__clipboard.mimeData()
if mime_data.hasFormat(self.UMLFRI_CLIPBOARD_FORMAT):
serialized = mime_data.data(self.UMLFRI_CLIPBOARD_FORMAT).data()
if serialized == self.__serialized:
return False
self.__serialized = serialized
self.__last_snippet = Snippet.deserialize(
serialized.decode('utf8'))
Application().clipboard = self.__last_snippet
else:
Application().clipboard = None
def __create_used_libraries_tab(self):
versions_layout = QFormLayout()
for depencency, version in Application().about.dependency_versions:
versions_layout.addRow(_("{0} version").format(depencency), QLabel(version))
versions_widget = QWidget()
versions_widget.setLayout(versions_layout)
return versions_widget
def __init__(self, main_window):
super().__init__(main_window)
if os.name == 'nt':
self.setWindowTitle(_("Options"))
else:
self.setWindowTitle(_("Preferences"))
layout = QVBoxLayout()
self.__tabs = QTabWidget()
layout.addWidget(self.__tabs)
for tab_class in self.__tab_classes:
self.__tabs.addTab(tab_class(self), "")
self.__button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel
| QDialogButtonBox.Apply)
self.__button_box.button(QDialogButtonBox.Apply).clicked.connect(
self.__apply_clicked)
self.__button_box.accepted.connect(self.__accept_clicked)
self.__button_box.rejected.connect(self.reject)
layout.addWidget(self.__button_box)
self.setLayout(layout)
Application().event_dispatcher.subscribe(LanguageChangedEvent,
self.__language_changed)
self.__reload_texts()
def dropMimeData(self, parent, index, data, action):
if not isinstance(parent, ProjectTreeItem):
return False
if not isinstance(data, ProjectMimeData):
return False
if isinstance(data.model_object, ElementObject) and isinstance(
parent.model_object, ElementObject):
index -= parent.model_object.diagram_count
if data.model_object.parent is parent.model_object:
if parent.model_object.get_child_index(data.model_object) < index:
index -= 1
if index < 0:
index = 0
if isinstance(
data.model_object,
ElementObject) and index > parent.model_object.children_count:
index = parent.model_object.children_count
elif isinstance(data.model_object,
Diagram) and index > parent.model_object.diagram_count:
index = parent.model_object.diagram_count
command = MoveNodeCommand(data.model_object, parent.model_object,
index)
Application().commands.execute(command)
return True
def mouseDoubleClickEvent(self, event):
pos = event.pos()
point = Point(pos.x(), pos.y())
self.__drawing_area.ensure_selection_at(point)
visual = self.__drawing_area.selection.get_lonely_selected_visual()
if visual is None:
return
if not visual.object.has_ufl_dialog:
return
self.__drawing_area.set_action(None)
self.unsetCursor()
if not isinstance(visual, ElementVisual):
PropertiesDialog.open_for(self.__main_window, visual.object)
elif visual.object.type.default_action == DefaultElementAction.properties:
PropertiesDialog.open_for(self.__main_window, visual.object)
elif visual.object.type.default_action == DefaultElementAction.subdiagram:
for diagram in visual.object.diagrams:
if diagram is not self.__drawing_area.diagram:
Application().tabs.select_tab(diagram)
break
else:
PropertiesDialog.open_for(self.__main_window, visual.object)
def __z_order_top(self):
if self.__drawing_area.selection.is_element_selected:
command = ChangeZOrderCommand(
self.__drawing_area.diagram,
self.__drawing_area.selection.selected_elements,
ZOrderDirection.top)
Application().commands.execute(command)
