class AddItemDialog(QDialog):
def __init__(self):
super(AddItemDialog, self).__init__()
self.setupUi(self)
def setupUi(self, AddItemDialog):
self.item_type_picker = QComboBox()
self.item_properties_switch = QStackedWidget()
for form in FORMS:
self.item_type_picker.addItem(form.__name__.split('_')[0],
FORMS.index(form))
self.item_properties_switch.addWidget(form())
self.item_type_picker.currentIndexChanged.connect(
self.item_properties_switch.setCurrentIndex)
self.add_button = QPushButton("Add")
mainLayout = QVBoxLayout(self)
mainLayout.addWidget(self.item_type_picker)
mainLayout.addWidget(self.item_properties_switch, 1)
mainLayout.addWidget(self.add_button)
self.add_button.clicked.connect(self.add_item)
self.setWindowIcon(QIcon(QPixmap('hotel_icon.jpg')))
self.layout().setSizeConstraint(QLayout.SetFixedSize)
self.setWindowTitle("Add Items")
def add_item(self):
self.item_properties_switch.currentWidget().add_button_click()
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.centralWidget = QStackedWidget()
self.setCentralWidget(self.centralWidget)
startWidget = StartWidget(self)
self.centralWidget.addWidget(startWidget)
self.setWindowTitle("Mountain King")
self.resize(210, 50)
def host(self):
hostWidget = HostWidget(self)
self.centralWidget.addWidget(hostWidget)
self.centralWidget.setCurrentWidget(hostWidget)
self.setWindowTitle("Hosting Mountain King")
self.resize(255, 50)
def join(self):
joinWidget = JoinWidget(self)
self.centralWidget.addWidget(joinWidget)
self.centralWidget.setCurrentWidget(joinWidget)
self.setWindowTitle("Joining Mountain King")
self.resize(255, 50)
class Window(QWidget):
"""
This part might be removed or included for main window application
"""
def __init__(self, algorithms):
super(Window, self).__init__()
self.stackedWidget = QStackedWidget()
self.orientationCombo = QComboBox()
for category in categories:
pass
for algorithm in algorithms:
self.orientationCombo.addItem(algorithm.get_name())
self.stackedWidget.addWidget(GroupOfSliders(algorithm))
layout = QBoxLayout(QBoxLayout.TopToBottom)
settings_layout = QBoxLayout(QBoxLayout.TopToBottom)
settings_layout.addWidget(self.stackedWidget)
select_layout = QBoxLayout(QBoxLayout.TopToBottom)
select_layout.addWidget(self.orientationCombo)
layout.addItem(settings_layout)
layout.addItem(select_layout)
self.setLayout(layout)
self.setWindowTitle(algorithm.get_name() + " Settings")
class FormComboWidget(QWidget):
def __init__(self, datalist, comment="", parent=None):
QWidget.__init__(self, parent)
layout = QVBoxLayout()
self.setLayout(layout)
self.combobox = QComboBox()
layout.addWidget(self.combobox)
self.stackwidget = QStackedWidget(self)
layout.addWidget(self.stackwidget)
self.combobox.currentIndexChanged[int].connect(self.stackwidget,setCurrentIndex)
self.widgetlist = []
for data, title, comment in datalist:
self.combobox.addItem(title)
widget = FormWidget(data, comment=comment, parent=self)
self.stackwidget.addWidget(widget)
self.widgetlist.append(widget)
def setup(self):
for widget in self.widgetlist:
widget.setup()
def get(self):
return [ widget.get() for widget in self.widgetlist]
def setCurrentIndex(self, index):
"""Change the current widget being displayed with an animation."""
old_widget = self.currentWidget()
new_widget = self.widget(index)
if old_widget != new_widget:
self.fader_widget = ui_tools.FaderWidget(self.currentWidget(),
self.widget(index))
QStackedWidget.setCurrentIndex(self, index)
class Root(QMainWindow):
task_list_index = 0
task_view_index = 1
def __init__(self):
super().__init__()
self.model = None
self.task_view = None
self.initUI()
def initUI(self):
# self.cal = QCalendarWidget(self)
# self.cal.setVerticalHeaderFormat(QCalendarWidget.NoVerticalHeader)
# self.cal.setGeometry(0, 0, 250, 250)
self.model = TaskModel()
self.central = QStackedWidget()
task_list = TaskList(self.model)
task_list.open.connect(self.task_open)
self.central.insertWidget(Root.task_list_index, task_list)
self.task_view = TaskView(self.model)
self.task_view.close.connect(self.task_view_close)
self.central.insertWidget(Root.task_view_index, self.task_view)
self.central.setCurrentIndex(Root.task_list_index)
self.setCentralWidget(self.central)
# QDialog flags:
# Qt.Dialog |
# Qt.WindowTitleHint |
# Qt.WindowSystemMenuHint |
# Qt.WindowContextHelpButtonHint |
# Qt.WindowCloseButtonHint
self.setWindowFlags(Qt.Dialog | Qt.WindowStaysOnTopHint)
self.setGeometry(700, 300, 250, 300)
self.setWindowTitle('Calendar')
@pyqtSlot(int)
def task_open(self, index):
self.task_view.set_task(index)
self.central.setCurrentIndex(Root.task_view_index)
@pyqtSlot()
def task_view_close(self):
self.central.setCurrentIndex(Root.task_list_index)
def keyPressEvent(self, event):
if event.key() == Qt.Key_Escape:
self.close()
class Window(QWidget):
def __init__(self, all_algorithms):
super(Window, self).__init__()
self.stackedWidget = QStackedWidget()
for item in algorithms:
widget = GuiElement(item)
self.stackedWidget.addWidget(widget)
layout = QHBoxLayout()
layout.addWidget(self.stackedWidget)
self.setLayout(layout)
self.setWindowTitle("Algorithm Settings")
class Window(QWidget):
def __init__(self, title):
super(Window, self).__init__()
self.horizontalSliders = SlidersGroup(title)
self.stackedWidget = QStackedWidget()
self.stackedWidget.addWidget(self.horizontalSliders)
layout = QHBoxLayout()
layout.addWidget(self.stackedWidget)
self.setLayout(layout)
self.setWindowTitle("Algorithm Settings: ")
def initUI(self):
# create menus
menu.GuiMenu()
menu.WidgetMenu()
menu.SettingsMenu()
menu.LoggingMenu()
# main layout
mainVLayout = QVBoxLayout()
elementHLayouts = []
# top element: toolbar, status
t = QLabel("Toolbar")
s = QLabel("Status")
toolbarStatusHLayout = QHBoxLayout()
toolbarStatusHLayout.addWidget(t)
toolbarStatusHLayout.addWidget(s)
elementHLayouts.append(toolbarStatusHLayout)
# mid element: menu buttons
menubuttonsHLayout = QHBoxLayout()
stackedButtonsWidget = QStackedWidget()
buttonGroup = QButtonGroup(self)
buttonGroup.setExclusive(True)
for m in menu.Menu.menus:
btn = QPushButton(m.name)
btn.setCheckable(True)
btn.pressed.connect(lambda m=m: stackedButtonsWidget.setCurrentWidget(m))
menubuttonsHLayout.addWidget(btn)
buttonGroup.addButton(btn)
stackedButtonsWidget.addWidget(m)
elementHLayouts.append(menubuttonsHLayout)
# bot element: menu specific widgets
menuwidgetsHLayout = QHBoxLayout()
menuwidgetsHLayout.addWidget(stackedButtonsWidget)
elementHLayouts.append(menuwidgetsHLayout)
# click first button for defined initial state
if len(buttonGroup.buttons()) > 0:
buttonGroup.buttons()[0].click()
for l in elementHLayouts:
mainVLayout.addLayout(l)
self.setLayout(mainVLayout)
def __init__(self, ref_templates, parent=None):
super().__init__(parent)
# Variables sections.
# NB: Sorted.
self._types = ["book", "bookSection", "conferencePaper", "document",
"forumPost", "journalArticle", "patent", "report",
"thesis", "webpage"]
templates_subset = OrderedDict([(k, v) for k, v in ref_templates.items()
if k in self._types])
# Own configuration section.
# TODO Better layout configuration.
self.setMinimumSize(QSize(800, 1000))
# Widgets section.
# TODO Prevent edition of the reference type for an existing reference?
self._types_edit = QComboBox()
self._types_edit.addItems(self._types)
self._types_widgets = self._templates_widgets(templates_subset)
types_forms = self._templates_forms(self._types_widgets)
forms_stack = QStackedWidget()
for x in types_forms:
forms_stack.addWidget(x)
# NB: The first button with the accept role is made the default button.
ok_cancel = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
# Layouts section.
layout = QFormLayout()
layout.addRow(self.ITEM_TYPE_FIELD + ":", self._types_edit)
layout.addRow(forms_stack)
layout.addRow(ok_cancel)
# NB: Don't use AllNonFixedFieldsGrow because it expands the QComboBox.
layout.setFieldGrowthPolicy(QFormLayout.ExpandingFieldsGrow)
utils.configure_form_layout(layout)
self.setLayout(layout)
# Signals section.
self._types_edit.currentIndexChanged.connect(forms_stack.setCurrentIndex)
ok_cancel.accepted.connect(self.accept)
ok_cancel.rejected.connect(self.reject)
def __init__(self, algorithms):
super(Window, self).__init__()
self.stackedWidget = QStackedWidget()
self.orientationCombo = QComboBox()
for category in categories:
pass
for algorithm in algorithms:
self.orientationCombo.addItem(algorithm.get_name())
self.stackedWidget.addWidget(GroupOfSliders(algorithm))
layout = QBoxLayout(QBoxLayout.TopToBottom)
settings_layout = QBoxLayout(QBoxLayout.TopToBottom)
settings_layout.addWidget(self.stackedWidget)
select_layout = QBoxLayout(QBoxLayout.TopToBottom)
select_layout.addWidget(self.orientationCombo)
layout.addItem(settings_layout)
layout.addItem(select_layout)
self.setLayout(layout)
self.setWindowTitle(algorithm.get_name() + " Settings")
def __init__(self, parent=None):
super().__init__(parent)
# Register signals connections
layout = QHBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
self.__buttons = []
self.__action_number = 1
self.__buttons_visibility = {}
self.__current_widget = None
self.__last_index = -1
self._stack_widgets = QStackedWidget()
layout.addWidget(self._stack_widgets)
# Buttons Widget
self.buttons_widget = QWidget()
self.buttons_widget.setObjectName("tools_dock")
self.buttons_widget.setFixedHeight(26)
self.buttons_widget.setLayout(QHBoxLayout())
self.buttons_widget.layout().setContentsMargins(2, 2, 5, 2)
self.buttons_widget.layout().setSpacing(10)
IDE.register_service("tools_dock", self)
_ToolsDock.__created = True
def __init__(self):
super(Window, self).__init__()
self.horizontalSliders = SlidersGroup(Qt.Horizontal,
"Horizontal")
self.verticalSliders = SlidersGroup(Qt.Vertical, "Vertical")
self.stackedWidget = QStackedWidget()
self.stackedWidget.addWidget(self.horizontalSliders)
self.stackedWidget.addWidget(self.verticalSliders)
self.createControls("Controls")
self.horizontalSliders.valueChanged.connect(self.verticalSliders.setValue)
self.verticalSliders.valueChanged.connect(self.valueSpinBox.setValue)
self.valueSpinBox.valueChanged.connect(self.horizontalSliders.setValue)
layout = QHBoxLayout()
layout.addWidget(self.controlsGroup)
layout.addWidget(self.stackedWidget)
self.setLayout(layout)
self.minimumSpinBox.setValue(0)
self.maximumSpinBox.setValue(20)
self.valueSpinBox.setValue(5)
self.setWindowTitle("Sliders")
def initUI(self):
# self.cal = QCalendarWidget(self)
# self.cal.setVerticalHeaderFormat(QCalendarWidget.NoVerticalHeader)
# self.cal.setGeometry(0, 0, 250, 250)
self.model = TaskModel()
self.central = QStackedWidget()
task_list = TaskList(self.model)
task_list.open.connect(self.task_open)
self.central.insertWidget(Root.task_list_index, task_list)
self.task_view = TaskView(self.model)
self.task_view.close.connect(self.task_view_close)
self.central.insertWidget(Root.task_view_index, self.task_view)
self.central.setCurrentIndex(Root.task_list_index)
self.setCentralWidget(self.central)
# QDialog flags:
# Qt.Dialog |
# Qt.WindowTitleHint |
# Qt.WindowSystemMenuHint |
# Qt.WindowContextHelpButtonHint |
# Qt.WindowCloseButtonHint
self.setWindowFlags(Qt.Dialog | Qt.WindowStaysOnTopHint)
self.setGeometry(700, 300, 250, 300)
self.setWindowTitle('Calendar')
def __init__(self, QWidget_parent=None):
super(XTabWidget, self).__init__(QWidget_parent)
# setup self frame
self.setFrameShadow(QFrame.Raised)
# self.setFrameShape(QFrame.StyledPanel)
self.setFrameShape(QFrame.NoFrame)
# layouts
self._layout = QVBoxLayout()
self._layout.setContentsMargins(0, 0, 0, 0)
self._layout.setSpacing(2)
self._layout_top = QHBoxLayout()
self._layout_top.setContentsMargins(0, 0, 0, 0)
# stacked widget
self._stack = QStackedWidget(self)
# tab bar
self._tabbar = QTabBar(self)
self._tabbar.setTabsClosable(True)
self._tabbar.setMovable(False)
self._tabbar.setExpanding(False)
self._tabbar.setShape(QTabBar.RoundedNorth)
self._tabbar.currentChanged.connect(self.on_tab_current_changed)
self._tabbar.tabCloseRequested.connect(self.on_tab_close_requested)
# button "add"
self._btn_add = QPushButton('+', self)
self._btn_add.setMaximumSize(QSize(22, 22))
self._btn_add.clicked.connect(self.on_btn_add_clicked)
# complete layout
self._layout_top.addWidget(self._btn_add, 0, Qt.AlignVCenter)
self._layout_top.addWidget(self._tabbar, 1, Qt.AlignVCenter)
self._layout.addLayout(self._layout_top)
self._layout.addWidget(self._stack)
self.setLayout(self._layout)
def __init__(self):
super(Posttid, self).__init__()
# Set up the main window ui including parameters such as window size and global font
self.set_up_window()
# Load in the saved email and requests
self.data, self.email, self.requests = self.load()
# Set up each individual window screen
self.central_widget = QStackedWidget()
self.settings_widget = SettingsWindow(self.email, self.requests, parent=self)
self.status_widget = StatusWindow(parent=self)
self.central_widget.addWidget(self.status_widget)
self.central_widget.addWidget(self.settings_widget)
self.setCentralWidget(self.central_widget)
# Start a new background thread to run the requests
self.worker = Worker()
self.worker.set_values(self.email, self.requests)
self.worker.missing_email_signal.connect(self.log.missing_email)
self.worker.connect_signal.connect(self.log.connection)
self.worker.reconnect_signal.connect(self.log.reconnect)
self.worker.request_signal.connect(self.log.request_found)
self.worker.connectionerror_signal.connect(self.log.no_connection)
self.worker.subreddit_noexist_signal.connect(self.log.subreddit_noexists)
self.worker.status_condition_signal.connect(self.status_widget.set_status)
self.worker.timeout_signal.connect(self.log.timeout)
self.worker.httperror_signal.connect(self.log.http)
self.worker.test_inside_loop.connect(self.log.inside_loop)
self.worker.test_query_requests.connect(self.log.query_requests)
self.worker.start()
# Stop the worker thread when accessing the settings window
self.status_widget.settings.clicked.connect(self.worker.terminate)
def __init__(self):
super(Window, self).__init__()
global current_state
current_state = dict(screen_data)
self.createControls()
self.createCommandBox()
self.brightnessSliders = SlidersGroup(self.commandBox)
self.stackedWidget = QStackedWidget()
self.stackedWidget.addWidget(self.brightnessSliders)
layout = QBoxLayout(QBoxLayout.TopToBottom)
layout.addWidget(self.stackedWidget)
layout.addWidget(self.commandBoxGroup)
layout.addWidget(self.controlsGroup)
self.setLayout(layout)
self.setWindowTitle("Brightness editor")
self.resize(850, 500)
command = "# get display names and brightness values\n" + \
get_brightness_command + "\n" + \
"# results (formatted): " + str(screen_data)
if primary != None:
command += " primary: " + screen_data[primary][0]
self.commandBox.document().setPlainText(command)
def __init__(self, parent=None):
"""Initialize the preferences dialog with a list box and a content layout."""
super(PreferencesDialog, self).__init__(parent)
self.setWindowTitle('Preferences')
settings_icon = utilities.resource_filename('mosaic.images', 'md_settings.png')
self.setWindowIcon(QIcon(settings_icon))
self.resize(600, 450)
self.contents = QListWidget()
self.contents.setFixedWidth(175)
self.pages = QStackedWidget()
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok)
self.dialog_media_library = MediaLibrary()
self.dialog_playback = Playback()
self.dialog_view_options = ViewOptions()
self.pages.addWidget(self.dialog_media_library)
self.pages.addWidget(self.dialog_playback)
self.pages.addWidget(self.dialog_view_options)
self.list_items()
stack_layout = QVBoxLayout()
stack_layout.addWidget(self.pages)
stack_layout.addWidget(self.button_box)
layout = QHBoxLayout()
layout.addWidget(self.contents)
layout.addLayout(stack_layout)
self.setLayout(layout)
self.contents.currentItemChanged.connect(self.change_page)
self.button_box.accepted.connect(self.accept)
def __init__(self):
super(TableWidget, self).__init__()
# vbox = QVBoxLayout(self)
# vbox.setContentsMargins(0, 0, 0, 0)
self._tabs = QTabWidget()
self._tabs.setAutoFillBackground(True)
p = self._tabs.palette()
p.setColor(p.Window, QColor("white"))
self._tabs.setPalette(p)
self._other_tab = QTabWidget()
self._other_tab.setAutoFillBackground(True)
self._other_tab.setPalette(p)
self.addWidget(self._tabs)
self.addWidget(self._other_tab)
self.setSizes([1, 1])
self._other_tab.hide()
self.relations = {}
# Stack
self.stacked = QStackedWidget()
self._tabs.addTab(self.stacked, "Workspace")
self.stacked_result = QStackedWidget()
self._tabs.addTab(self.stacked_result, self.tr("Resultados"))
btn_split = QToolButton()
btn_split.setToolTip(self.tr("Click para dividir la pantalla"))
btn_split.setAutoRaise(True)
btn_split.setIcon(QIcon(":img/split"))
self._tabs.setCornerWidget(btn_split)
btn_split.clicked.connect(self._split)
btn_split = QToolButton()
btn_split.setToolTip(self.tr("Click para juntar las pantallas"))
btn_split.setAutoRaise(True)
btn_split.setIcon(QIcon(":img/split"))
btn_split.clicked.connect(self._unsplit)
self._other_tab.setCornerWidget(btn_split)
# self.setContextMenuPolicy(Qt.CustomContextMenu)
# self.customContextMenuRequested.connect(self._show_menu)
lateral_widget = Pireal.get_service("lateral_widget")
lateral_widget.resultClicked.connect(self._on_result_list_clicked)
lateral_widget.resultSelectionChanged.connect(
lambda index: self.stacked_result.setCurrentIndex(index))
def __init__(self, parent):
super(ScorePartsWidget, self).__init__(parent)
self.typesLabel = QLabel()
self.typesView = QTreeView(
selectionMode=QTreeView.ExtendedSelection,
selectionBehavior=QTreeView.SelectRows,
animated=True,
headerHidden=True)
self.scoreLabel = QLabel()
self.scoreView = widgets.treewidget.TreeWidget(
selectionMode=QTreeView.ExtendedSelection,
selectionBehavior=QTreeView.SelectRows,
headerHidden=True,
animated=True,
dragDropMode=QTreeView.InternalMove)
self.addButton = QPushButton(icon = icons.get("list-add"))
self.removeButton = QPushButton(icon = icons.get("list-remove"))
self.upButton = QToolButton(icon = icons.get("go-up"))
self.downButton = QToolButton(icon = icons.get("go-down"))
self.partSettings = QStackedWidget()
w = QWidget()
self.addWidget(w)
layout = QVBoxLayout(spacing=0)
w.setLayout(layout)
layout.addWidget(self.typesLabel)
layout.addWidget(self.typesView)
layout.addWidget(self.addButton)
w = QWidget()
self.addWidget(w)
layout = QVBoxLayout(spacing=0)
w.setLayout(layout)
layout.addWidget(self.scoreLabel)
layout.addWidget(self.scoreView)
box = QHBoxLayout(spacing=0)
layout.addLayout(box)
box.addWidget(self.removeButton)
box.addWidget(self.upButton)
box.addWidget(self.downButton)
self.addWidget(self.partSettings)
self.typesView.setModel(parts.model())
app.translateUI(self)
# signal connections
self.addButton.clicked.connect(self.slotAddButtonClicked)
self.removeButton.clicked.connect(self.slotRemoveButtonClicked)
self.typesView.doubleClicked.connect(self.slotDoubleClicked)
self.scoreView.currentItemChanged.connect(self.slotCurrentItemChanged)
self.upButton.clicked.connect(self.scoreView.moveSelectedChildrenUp)
self.downButton.clicked.connect(self.scoreView.moveSelectedChildrenDown)
def create_widgets(self):
"""Creates central widgets."""
self.stack = QStackedWidget(self)
self.setCentralWidget(self.stack)
self.view = View(self)
self.stack.addWidget(self.view)
self.glwidget = GLWidget(self)
self.worker.video.set_widget(self)
self.stack.addWidget(self.glwidget)
self.stack.setCurrentWidget(self.view)
def addApplet(self, appletId: int, applet) -> None:
"""
Adds applet to toolbox if it is available in interactive mode
"""
if applet.interactive:
# We need new id before we added item, to handle currentChangedSignal
newToolbarId = self._toolbox.count()
self._toolbarIdByAppletId[appletId] = newToolbarId
self._appletIdByToolbarId[newToolbarId] = appletId
widget = applet.getMultiLaneGui().appletDrawer()
assert isinstance(widget, QWidget), f"Not a widget: {widget}"
stackedWidget = QStackedWidget()
stackedWidget.addWidget(widget)
self._toolbox.addItem(stackedWidget, applet.name)
else:
self._toolbarIdByAppletId[appletId] = None
def __init__(self):
super(MainWindow, self).__init__()
self.centralWidget = QStackedWidget()
self.setCentralWidget(self.centralWidget)
startWidget = StartWidget(self)
self.centralWidget.addWidget(startWidget)
self.setWindowTitle("Mountain King")
self.resize(210, 50)
def __init__(self):
super(TableWidget, self).__init__()
vbox = QVBoxLayout(self)
vbox.setContentsMargins(0, 0, 0, 0)
self.relations = {}
# Stack
self.stacked = QStackedWidget()
vbox.addWidget(self.stacked)
def __init__(self, mainWindow):
""" list of opened documents as it is displayed in the Opened Files Explorer.
List accessed and modified by enki.core.openedfilemodel.OpenedFileModel class
"""
QStackedWidget.__init__(self, mainWindow)
mainWindow.setFocusProxy(self)
self.sortedDocuments = [] # not protected, because available for OpenedFileModel
self._oldCurrentDocument = None
# create opened files explorer
# openedFileExplorer is not protected, because it is available for OpenedFileModel
self.openedFileExplorer = enki.core.openedfilemodel.OpenedFileExplorer(self)
mainWindow.addDockWidget(Qt.LeftDockWidgetArea, self.openedFileExplorer)
self.currentChanged.connect(self._onStackedLayoutIndexChanged)
self.currentDocumentChanged.connect(self._updateMainWindowTitle)
core.project().changed.connect(self._updateMainWindowTitle)
self.currentDocumentChanged.connect(self._onCurrentDocumentChanged)
def __init__(self, settings_object, parent=None):
super().__init__(parent)
# The settings object should not be changed directly. Use enqueue_change() to set values and call
# commit_changes() to write them to file when the user clicks either the "Ok" or "Apply" button.
self.settings_object = settings_object
self.pending_changes = {}
# A list of different settings groups, categorized by the application they apply to.
self.category_list = QListWidget()
self.category_list.setSpacing(3)
self.category_list.setMaximumWidth(100)
handlebar_category = QListWidgetItem(self.category_list)
handlebar_category.setText('General')
handbrake_category = QListWidgetItem(self.category_list)
handbrake_category.setText('Encoder')
handbrake_category = QListWidgetItem(self.category_list)
handbrake_category.setText('Output')
self.category_pages = QStackedWidget()
self.category_pages.addWidget(GeneralSettingsPage(self, settings_object))
self.category_pages.addWidget(EncoderSettingsPage(self, settings_object))
self.category_pages.addWidget(OutputSettingsPage(self, settings_object))
self.category_list.setCurrentRow(0)
self.category_list.currentItemChanged.connect(self.change_category)
category_layout = QHBoxLayout()
category_layout.addWidget(self.category_list)
category_layout.addWidget(self.category_pages)
ok_button = QPushButton('Ok')
cancel_button = QPushButton('Cancel')
self.apply_button = QPushButton('Apply')
self.apply_button.setEnabled(False)
ok_button.clicked.connect(self.commit_changes_and_close)
cancel_button.clicked.connect(self.close)
self.apply_button.clicked.connect(self.commit_changes)
button_bar_layout = QHBoxLayout()
button_bar_layout.addStretch(1)
button_bar_layout.addWidget(ok_button)
button_bar_layout.addWidget(cancel_button)
button_bar_layout.addWidget(self.apply_button)
main_layout = QVBoxLayout()
main_layout.addLayout(category_layout)
main_layout.addLayout(button_bar_layout)
self.setLayout(main_layout)
self.setWindowTitle('Configure Settings')
self.resize(600, 300)
class SpectateBattle(QWidget):
def __init__(self):
super(SpectateBattle, self).__init__()
self.exitButton = QPushButton('Exit to menu')
self.exitButton.clicked.connect(self.interruptBattle)
self.menu = BotBattleMenu()
self.menu.startButton.clicked.connect(self.startBattle)
self.battle = None
self.stack = QStackedWidget()
self.stack.addWidget(self.menu)
layout = QVBoxLayout()
layout.addWidget(self.stack)
layout.addWidget(self.exitButton)
self.setLayout(layout)
def startBattle(self):
bot1 = game.players.ai.select_bot(self.menu.bot1Level)
bot2 = game.players.ai.select_bot(self.menu.bot2Level)
self.battle = BotBattle(bot1, bot2)
self.stack.addWidget(self.battle)
self.stack.setCurrentWidget(self.battle)
def interruptBattle(self):
if self.battle:
self.battle.interrupt()
class MultiPlayer(QWidget):
def __init__(self):
super(MultiPlayer, self).__init__()
self.exitButton = QPushButton('Exit to menu')
self.exitButton.clicked.connect(self.exit)
self.menu = MultiPlayerMenu()
self.menu.connectButton.clicked.connect(self.connect)
self.menu.hostButton.clicked.connect(self.host)
self.menu.hotseatButton.clicked.connect(self.hotseat)
self.stack = QStackedWidget()
self.stack.addWidget(self.menu)
layout = QVBoxLayout()
layout.addWidget(self.stack)
layout.addWidget(self.exitButton)
self.setLayout(layout)
self.clientGame = None
self.serverGame = None
self.hotseatGame = None
def host(self):
name = self.menu.nameField.text()
port = self.menu.portSpinBox.value()
self.serverGame = ServerGame(name, port)
self.showGame(self.serverGame)
def connect(self):
name = self.menu.nameField.text()
ip = self.menu.ipField.text()
port = self.menu.portSpinBox.value()
self.clientGame = ClientGame(name, ip, port)
self.showGame(self.clientGame)
def hotseat(self):
self.hotseatGame = HotSeatGame()
self.showGame(self.hotseatGame)
def showGame(self, game):
self.stack.addWidget(game)
self.stack.setCurrentWidget(game)
def exit(self):
self.stack.setCurrentWidget(self.menu)
if self.serverGame:
self.serverGame.end()
if self.clientGame:
self.clientGame.end()
def _setupUi(self):
self.resize(483, 423)
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setSpacing(0)
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.horizontalLayout = QHBoxLayout()
self.horizontalLayout.setSpacing(0)
self.filterBar = RadioBox(self)
sizePolicy = QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.filterBar.sizePolicy().hasHeightForWidth())
self.filterBar.setSizePolicy(sizePolicy)
self.horizontalLayout.addWidget(self.filterBar)
self.horizontalLayout.addItem(horizontalSpacer())
self.reconciliationButton = QPushButton(tr("Reconciliation"))
self.reconciliationButton.setCheckable(True)
self.horizontalLayout.addWidget(self.reconciliationButton)
self.verticalLayout.addLayout(self.horizontalLayout)
self.splitterView = QSplitter()
self.splitterView.setOrientation(Qt.Vertical)
self.splitterView.setChildrenCollapsible(False)
self.tableView = TableView(self)
self.tableView.setAcceptDrops(True)
self.tableView.setEditTriggers(QAbstractItemView.DoubleClicked|QAbstractItemView.EditKeyPressed)
self.tableView.setDragEnabled(True)
self.tableView.setDragDropMode(QAbstractItemView.InternalMove)
self.tableView.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tableView.setSortingEnabled(True)
self.tableView.horizontalHeader().setHighlightSections(False)
self.tableView.horizontalHeader().setMinimumSectionSize(18)
self.tableView.verticalHeader().setVisible(False)
self.tableView.verticalHeader().setDefaultSectionSize(18)
self.splitterView.addWidget(self.tableView)
self.graphView = QStackedWidget(self)
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.graphView.sizePolicy().hasHeightForWidth())
self.graphView.setSizePolicy(sizePolicy)
self.graphView.setMinimumSize(0, 200)
self.lineGraphView = LineGraphView()
self.graphView.addWidget(self.lineGraphView)
self.barGraphView = BarGraphView()
self.graphView.addWidget(self.barGraphView)
self.splitterView.addWidget(self.graphView)
self.graphView.setCurrentIndex(1)
self.splitterView.setStretchFactor(0, 1)
self.splitterView.setStretchFactor(1, 0)
self.verticalLayout.addWidget(self.splitterView)
def __init__(self, parent=None):
super(FilterDialog, self).__init__(parent)
self.accepted.connect(self.createFilter)
self.contentsWidget = QListWidget()
self.contentsWidget.setViewMode(QListView.IconMode)
self.contentsWidget.setIconSize(QSize(96, 84))
self.contentsWidget.setMovement(QListView.Static)
self.contentsWidget.setMaximumWidth(128)
self.contentsWidget.setSpacing(12)
self.basicFilterPage = BasicFilterPage()
self.timeFilterPage = DateTimeFilterPage()
self.locationFilterPage = LocationFilterPage()
self.pagesWidget = QStackedWidget()
self.pagesWidget.addWidget(self.basicFilterPage)
self.pagesWidget.addWidget(self.timeFilterPage)
self.pagesWidget.addWidget(self.locationFilterPage)
self.pagesWidget.setMinimumHeight(360)
rejectButton = QPushButton("Storno")
rejectButton.clicked.connect(self.reject)
acceptButton = QPushButton("OK")
acceptButton.clicked.connect(self.accept)
self.createIcons()
self.contentsWidget.setCurrentRow(0)
horizontalLayout = QHBoxLayout()
horizontalLayout.addWidget(self.contentsWidget)
horizontalLayout.addWidget(self.pagesWidget, 1)
buttonsLayout = QHBoxLayout()
buttonsLayout.addStretch(1)
buttonsLayout.addWidget(acceptButton)
buttonsLayout.addWidget(rejectButton)
layout = QVBoxLayout()
layout.addLayout(horizontalLayout)
layout.addStretch(1)
layout.addSpacing(12)
layout.addLayout(buttonsLayout)
self.setLayout(layout)
self.setMinimumWidth(450)
self.setWindowTitle("Filtrování výsledků")
class Application(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.pipeShape = QComboBox()
self.pipeShape.addItem("circular")
self.pipeShape.addItem("rectangular")
self.pipeShape.addItem("trapezoidal")
self.circleDiameter = QLineEdit()
self.rectWidth = QLineEdit()
self.rectDepth = QLineEdit()
self.rectOpen = QRadioButton("Open")
self.rectClosed = QRadioButton("Closed")
self.rectOpen.setChecked(True)
self.trapWidth = QLineEdit()
self.trapDepth = QLineEdit()
self.trapSide = QLineEdit()
self.trapOpen = QRadioButton("Open")
self.trapClosed = QRadioButton("Closed")
self.trapOpen.setChecked(True)
self.lengthEdit = QLineEdit()
self.lengthEdit.setFixedWidth(125)
self.usInvert = QLineEdit()
self.usInvert.setFixedWidth(125)
self.dsInvert = QLineEdit()
self.dsInvert.setFixedWidth(125)
self.Ks = QLineEdit()
self.Ks.setFixedWidth(125)
self.Ks.setText("3.0")
self.kinvisc = QLineEdit()
self.kinvisc.setFixedWidth(125)
self.kinvisc.setText("1.141e-06")
self.dsK = QLineEdit()
self.dsK.setFixedWidth(125)
self.dsK.setText("0.0")
self.usK = QLineEdit()
self.usK.setFixedWidth(125)
self.usK.setText("0.0")
self.flow = QLineEdit()
self.myFunc = QPushButton("Calculate", self)
self.myFunc.clicked.connect(self.calculate)
self.result = QTextEdit()
self.stack1 = QWidget()
self.stack2 = QWidget()
self.stack3 = QWidget()
self.stack1UI()
self.stack2UI()
self.stack3UI()
self.stack = QStackedWidget(self)
self.stack.addWidget(self.stack1)
self.stack.addWidget(self.stack2)
self.stack.addWidget(self.stack3)
layout = QVBoxLayout()
layout.addWidget(QLabel("Select Pipe Shape:"))
layout.addWidget(self.pipeShape)
layout.addWidget(self.stack)
layoutFlow = QHBoxLayout()
layoutFlow.addWidget(QLabel("Flow Rate:"))
layoutFlow.addWidget(QLabel("m3/s"))
layoutFlow.addWidget(self.flow)
layout.addLayout(layoutFlow)
layout.addWidget(self.myFunc)
layout.addWidget(self.result)
layout1 = QVBoxLayout()
layout2 = QHBoxLayout()
layout2.addWidget(QLabel("Length"))
layout2.addWidget(self.lengthEdit)
layout2.addWidget(QLabel("m"))
layout2.addStretch()
layout3 = QHBoxLayout()
layout3.addWidget(QLabel("Upstream IL"))
layout3.addWidget(self.usInvert)
layout3.addWidget(QLabel("m"))
layout4 = QHBoxLayout()
layout4.addWidget(QLabel("Downstream IL"))
layout4.addWidget(self.dsInvert)
layout4.addWidget(QLabel("m"))
layout5 = QHBoxLayout()
layout5.addWidget(QLabel("Ks"))
layout5.addWidget(self.Ks)
layout5.addWidget(QLabel("mm"))
layout6 = QHBoxLayout()
layout6.addWidget(QLabel("kinematic visc"))
layout6.addWidget(self.kinvisc)
layout6.addWidget(QLabel("m2/s"))
layout7 = QHBoxLayout()
layout7.addWidget(QLabel("Upstream K"))
layout7.addWidget(self.usK)
layout7.addWidget(QLabel("no."))
layout8 = QHBoxLayout()
layout8.addWidget(QLabel("Downstream K"))
layout8.addWidget(self.dsK)
layout8.addWidget(QLabel("no."))
layout1.addLayout(layout2)
layout1.addLayout(layout3)
layout1.addLayout(layout4)
layout1.addLayout(layout5)
layout1.addLayout(layout6)
layout1.addLayout(layout7)
layout1.addLayout(layout8)
layout1.setAlignment(Qt.AlignTop)
topLayout = QHBoxLayout(self)
topLayout.addLayout(layout)
topLayout.addLayout(layout1)
self.setLayout(topLayout)
self.pipeShape.currentIndexChanged.connect(self.stack.setCurrentIndex)
self.setGeometry(100, 100, 670, 500)
self.show()
def stack1UI(self):
layout = QHBoxLayout()
layout.addWidget(QLabel("Diameter"))
layout.addWidget(self.circleDiameter)
layout.addWidget(QLabel("m"))
layout.setAlignment(Qt.AlignTop)
self.stack1.setLayout(layout)
def stack2UI(self):
layout = QVBoxLayout()
layout1 = QHBoxLayout()
layout2 = QHBoxLayout()
layout3 = QHBoxLayout()
layout1.addWidget(QLabel("Width"))
layout1.addWidget(self.rectWidth)
layout1.addWidget(QLabel("m"))
layout2.addWidget(QLabel("Depth"))
layout2.addWidget(self.rectDepth)
layout2.addWidget(QLabel("m"))
layout3.addWidget(self.rectOpen)
layout3.addWidget(self.rectClosed)
layout.addLayout(layout1)
layout.addLayout(layout2)
layout.addLayout(layout3)
layout.setAlignment(Qt.AlignTop)
self.stack2.setLayout(layout)
def stack3UI(self):
layout = QVBoxLayout()
layout1 = QHBoxLayout()
layout2 = QHBoxLayout()
layout3 = QHBoxLayout()
layout4 = QHBoxLayout()
layout1.addWidget(QLabel("Width"))
layout1.addWidget(self.trapWidth)
layout1.addWidget(QLabel("m"))
layout2.addWidget(QLabel("Depth"))
layout2.addWidget(self.trapDepth)
layout2.addWidget(QLabel("m"))
layout3.addWidget(QLabel("Side Slope"))
layout3.addWidget(self.trapSide)
layout3.addWidget(QLabel("unit"))
layout4.addWidget(self.trapOpen)
layout4.addWidget(self.trapClosed)
layout.addLayout(layout1)
layout.addLayout(layout2)
layout.addLayout(layout3)
layout.addLayout(layout4)
layout.setAlignment(Qt.AlignTop)
self.stack3.setLayout(layout)
def calculate(self):
try:
flow = float(self.flow.text())
kinvisc = float(self.kinvisc.text())
length = float(self.lengthEdit.text())
usIL = float(self.usInvert.text())
dsIL = float(self.dsInvert.text())
Ks = float(self.Ks.text()) / 1000.0
usK = float(self.usK.text())
dsK = float(self.dsK.text())
conduit = channel.Channel()
conduit.setValues(flow, 0.8, 2, 100.0, 1.0, 0.9, 0.003, kinvisc)
conduit.calculate()
resultText = "critical depth:\t %0.3f" % conduit.crit_depth
resultText += "\nnormal depth:\t %0.3f" % conduit.norm_depth
resultText += "\nds water depth:\t %0.3f" % conduit.water[0]
resultText += "\nus water depth:\t %0.3f" % conduit.water[-1]
resultText += "\nds water level:\t %0.3f" % conduit.head[0]
resultText += "\nus water level:\t %0.3f" % conduit.head[-1]
resultText += "\nds energy level:\t %0.3f" % conduit.energy[0]
resultText += "\nus energy level:\t %0.3f" % conduit.energy[-1]
self.result.setText(str(resultText))
except ValueError:
pass
except:
print("error")
pass
def __init__(self):
super().__init__()
# init the main window
self.title = 'Epif Object Classifier'
self.setWindowTitle(self.title)
self.left = 10
self.top = 10
self.width = 1500
self.height = 750
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
# Create the map canvas and set the canvas to be the main widget
self.canvasframe = QFrame()
self.canvasframe.setFrameShape(QFrame.StyledPanel)
self.canvasframe.setFrameShadow(QFrame.Raised)
self.setCentralWidget(self.canvasframe)
self.canvas = map_canvas()
self.canvas.show()
self.framelayout = QVBoxLayout(self.canvasframe)
self.framelayout.addWidget(self.canvas)
# create map canvas actions and set icons
actionZoomIn = QAction("Zoom in", self)
actionZoomOut = QAction("Zoom out", self)
actionPan = QAction("Pan", self)
actionZoomIn.setCheckable(True)
actionZoomOut.setCheckable(True)
actionPan.setCheckable(True)
actionPanPixmap = QIcon(QPixmap(':/icons/pan.png'))
actionZoomInPixmap = QIcon(QPixmap(':/icons/Zoom-In-icon.png'))
actionZoomOutPixmap = QPixmap(':/icons/Zoom-Out-icon.png')
actionsave = QIcon(QPixmap(':/icons/save.png'))
actionsaveas = QIcon(QPixmap(':/icons/saveas.png'))
actionnew = QIcon(QPixmap(':/icons/newproject.png'))
actionloadproject = QIcon(QPixmap(':/icons/openproject.png'))
actionpolygonize = QIcon(QPixmap(':/icons/polygon.png'))
actionrasterize = QIcon(QPixmap(':/icons/raster.png'))
actionconfusion = QIcon(QPixmap(':/icons/matrix.png'))
actionZoomIn.setIcon(QIcon(actionZoomInPixmap))
actionZoomOut.setIcon(QIcon(actionZoomOutPixmap))
actionPan.setIcon(QIcon(actionPanPixmap))
actionZoomIn.triggered.connect(self.zoomIn)
actionZoomOut.triggered.connect(self.zoomOut)
actionPan.triggered.connect(self.pan)
# create map canvas tool bar
self.toolbar = self.addToolBar("Canvas actions")
self.toolbar.addAction(actionZoomIn)
self.toolbar.addAction(actionZoomOut)
self.toolbar.addAction(actionPan)
# create the map tools
self.toolPan = QgsMapToolPan(self.canvas)
self.toolPan.setAction(actionPan)
self.toolZoomIn = QgsMapToolZoom(self.canvas, False) # false = in
self.toolZoomIn.setAction(actionZoomIn)
self.toolZoomOut = QgsMapToolZoom(self.canvas, True) # true = out
self.toolZoomOut.setAction(actionZoomOut)
#init the file tree widget and set as a dock widget
self.treewidget = filetree()
self.tree = QDockWidget("Select Data", self)
self.tree.setWidget(self.treewidget)
self.tree.setFloating(False)
self.addDockWidget(Qt.LeftDockWidgetArea, self.tree)
# init a menue bar and its actions
self.menuebar = QMenuBar()
self.setMenuBar(self.menuebar)
filemenue = self.menuebar.addMenu('Project')
classificationmenue = self.menuebar.addMenu('Classification')
toolsmenue = self.menuebar.addMenu('Tools')
self.supervised = QAction('supervised')
self.training = QAction("Training set", self)
self.unsupervised = QAction('unsupernised')
self.poligonize = QAction(actionpolygonize, 'Polygonize')
self.rasterize = QAction(actionrasterize, 'Rasterize')
self.confusiomatrix = QAction(actionconfusion, 'Confusionmatrix')
self.newprojectaction = QAction(actionnew, 'New project')
self.loadprojectaction = QAction(actionloadproject, 'Load project')
self.saveprojectasaction = QAction(actionsaveas, 'Save project as')
self.saveaction = QAction(actionsave, 'Save')
classificationmenue.addAction(self.supervised)
classificationmenue.addAction(self.unsupervised)
classificationmenue.addAction(self.training)
toolsmenue.addAction(self.poligonize)
toolsmenue.addAction(self.rasterize)
toolsmenue.addAction(self.confusiomatrix)
filemenue.addAction(self.loadprojectaction)
filemenue.addAction(self.saveprojectasaction)
filemenue.addAction(self.newprojectaction)
filemenue.addAction(self.saveaction)
# create a layerpanel
self.layerpanel = LayersPanel(self.canvas)
self.layerpanelDock = QDockWidget("Layers", self)
self.layerpanelDock.setObjectName("layers")
self.layerpanelDock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
self.layerpanelDock.setWidget(self.layerpanel)
self.layerpanelDock.setContentsMargins(9, 9, 9, 9)
self.addDockWidget(Qt.LeftDockWidgetArea, self.layerpanelDock)
#set the supervised classification window widget
self.supervised_classification = supervised_classification_ui()
self.StackedWidget = QStackedWidget()
self.StackedWidget.addWidget(self.supervised_classification.step1)
self.StackedWidget.addWidget(self.supervised_classification.step2)
self.StackedWidget.addWidget(self.supervised_classification.step3)
self.StackedWidget.setCurrentWidget(
self.supervised_classification.step1)
self.StackedWidget_dock = QDockWidget('classification', self)
self.StackedWidget_dock.setWidget(self.StackedWidget)
self.addDockWidget(Qt.RightDockWidgetArea, self.StackedWidget_dock)
# set the unsupervised classification window widget
# set polygonize widget
polygonizewidget = Polygonize_ui()
polygonizewidget.legendwidget = self.layerpanel
self.StackedWidget.addWidget(polygonizewidget)
# set rasterize widget
rastrizewidget = Rasterize_ui()
rastrizewidget.legendwidget = self.layerpanel
rastrizewidget.legendwidget = self.layerpanel
self.StackedWidget.addWidget(rastrizewidget)
# set confusion matrix widget
confusionmatrixwidget = Confusion_matrix_ui()
self.StackedWidget.addWidget(confusionmatrixwidget)
self.StackedWidget.addWidget(confusionmatrixwidget.resultsgroup)
self.threadpool = QThreadPool()
self.massage = QMessageBox(text='Running')
self.StackedWidget_dock.setVisible(False)
# set the widget for creating training set
self.trainniwidget = create_training_set(self.canvas)
self.StackedWidget.addWidget(self.trainniwidget)
# connect signals and slots
self.poligonize.triggered.connect(
lambda: self.StackedWidget.setCurrentWidget(polygonizewidget))
self.poligonize.triggered.connect(
lambda: self.StackedWidget_dock.setWindowTitle('Polygonize'))
self.rasterize.triggered.connect(
lambda: self.StackedWidget.setCurrentWidget(rastrizewidget))
self.rasterize.triggered.connect(
lambda: self.StackedWidget_dock.setWindowTitle('Rasterize'))
self.confusiomatrix.triggered.connect(
lambda: self.StackedWidget.setCurrentWidget(confusionmatrixwidget))
self.confusiomatrix.triggered.connect(
lambda: self.StackedWidget_dock.setWindowTitle('Confusion Matrix'))
confusionmatrixwidget.done.connect(
lambda: self.StackedWidget.setCurrentWidget(confusionmatrixwidget.
resultsgroup))
self.supervised.triggered.connect(
lambda: self.StackedWidget_dock.setWindowTitle(
'Supervised classification'))
self.supervised.triggered.connect(
lambda: self.StackedWidget.setCurrentWidget(
self.supervised_classification.step1))
self.supervised.triggered.connect(
lambda: self.StackedWidget_dock.setVisible(True))
self.poligonize.triggered.connect(
lambda: self.StackedWidget_dock.setVisible(True))
self.rasterize.triggered.connect(
lambda: self.StackedWidget_dock.setVisible(True))
self.confusiomatrix.triggered.connect(
lambda: self.StackedWidget_dock.setVisible(True))
self.training.triggered.connect(
lambda: self.StackedWidget_dock.setVisible(True))
self.training.triggered.connect(
lambda: self.StackedWidget.setCurrentWidget(self.trainniwidget))
self.training.triggered.connect(
lambda: self.trainniwidget.create_layer())
self.supervised_classification.step1next.clicked.connect(
lambda: self.StackedWidget.setCurrentWidget(
self.supervised_classification.step2))
self.supervised_classification.step2back.clicked.connect(
lambda: self.StackedWidget.setCurrentWidget(
self.supervised_classification.step1))
self.supervised_classification.step2next.clicked.connect(
lambda: self.StackedWidget.setCurrentWidget(
self.supervised_classification.step3))
self.supervised_classification.step3back.clicked.connect(
lambda: self.StackedWidget.setCurrentWidget(
self.supervised_classification.step2))
self.loadprojectaction.triggered.connect(self.openproject)
self.saveprojectasaction.triggered.connect(self.saveproject)
self.newprojectaction.triggered.connect(self.newproject)
self.saveaction.triggered.connect(self.save)
def __init__(self):
super(Multitool, self).__init__()
self.statusbar = self.statusBar()
self.statusBar().showMessage('Ready')
self.trayActions()
self.trayMenu()
self.trayIcon.setIcon(QIcon('icons/biohazard.svg'))
self.trayIcon.show()
self.stack1 = QWidget() # Mouse Clicker
self.stack2 = QWidget() # Screenshot
self.stack3 = QWidget() # Player
self.stack4 = QWidget() # Calculator
self.stack5 = QWidget() # Camera
self.stack6 = QWidget() # Tetrix
self.stack1UI() # Mouse Clicker
self.stack2UI() # Screenshot
self.stack3UI() # Player
self.stack4UI() # Calculator
self.stack5UI() # Camera
self.stack6UI() # Tetrix
self.Stack = QStackedWidget(self)
self.Stack.addWidget(self.stack1) # Mouse Clicker
self.Stack.addWidget(self.stack2) # Screenshot
self.Stack.addWidget(self.stack3) # Player
self.Stack.addWidget(self.stack4) # Calculator
self.Stack.addWidget(self.stack5) # Camera
self.Stack.addWidget(self.stack6) # Tetrix
# General actions starts -------------------------------------
exitAction = QAction(QIcon('icons/exit.png'), '&Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(QApplication.instance().quit)
newMultitoolAction = QAction(QIcon('icons/new.png'), '&New Multitool',
self)
newMultitoolAction.setShortcut('Ctrl+N')
newMultitoolAction.setStatusTip('New Multitool')
newMultitoolAction.triggered.connect(self.newMultitoolWindow)
aboutAction = QAction(QIcon('icons/biohazard.svg'), 'About', self)
aboutAction.setStatusTip('About')
aboutAction.triggered.connect(self.about)
viewStatAction = QAction('View statusbar', self, checkable=True)
viewStatAction.setStatusTip('View statusbar')
viewStatAction.setChecked(True)
viewStatAction.triggered.connect(self.toggleStatBar)
viewToolbarAction = QAction('View toolbar', self, checkable=True)
viewToolbarAction.setStatusTip('View toolbar')
viewToolbarAction.setChecked(True)
viewToolbarAction.triggered.connect(self.toggleToolBar)
minimizeToTrayAction = QAction('Minimize to Tray',
self,
checkable=True)
minimizeToTrayAction.setStatusTip('Minimize to Tray')
minimizeToTrayAction.setChecked(False)
minimizeToTrayAction.triggered.connect(self.minimizeToTray)
# General actions ends ---------------------------------------
# Widgets actions starts -------------------------------------
mouseClickerAction = QAction(QIcon('icons/mouse.png'), 'Mouse Clicker',
self)
mouseClickerAction.setStatusTip('Mouse Clicker')
mouseClickerAction.triggered.connect(lambda: self.display(0))
screeenShotAction = QAction(QIcon('icons/screenshot.png'),
'ScreenShot', self)
screeenShotAction.setStatusTip('ScreenShot')
screeenShotAction.triggered.connect(lambda: self.display(1))
playerAction = QAction(QIcon('icons/player.jpeg'), 'Player', self)
playerAction.setStatusTip('Player')
playerAction.triggered.connect(lambda: self.display(2))
calculatorAction = QAction(QIcon('icons/calc.ico'), 'Calculator', self)
calculatorAction.setStatusTip('Calculator')
calculatorAction.triggered.connect(lambda: self.display(3))
cameraAction = QAction(QIcon('icons/camera.jpeg'), 'Camera', self)
cameraAction.setStatusTip('Camera')
cameraAction.triggered.connect(lambda: self.display(4))
tetrixAction = QAction(QIcon('icons/tetrix.png'), 'Tetrix', self)
tetrixAction.setStatusTip('Tetrix')
tetrixAction.triggered.connect(lambda: self.display(5))
# Widget actions ends ----------------------------------------
# Menu bar creation starts -----------------------------------
menubar = self.menuBar()
fileMenu = menubar.addMenu('&File')
fileMenu.addAction(newMultitoolAction)
fileMenu.addAction(exitAction)
viewMenu = menubar.addMenu('View')
viewMenu.addAction(viewStatAction)
viewMenu.addAction(viewToolbarAction)
viewMenu.addAction(minimizeToTrayAction)
viewMenuWidget = QMenu('List widget', self)
viewMenuWidget.addAction(mouseClickerAction)
viewMenuWidget.addAction(screeenShotAction)
viewMenuWidget.addAction(playerAction)
viewMenuWidget.addAction(calculatorAction)
viewMenuWidget.addAction(cameraAction)
viewMenu.addMenu(viewMenuWidget)
gamesMenu = menubar.addMenu('&Games')
gamesMenu.addAction(tetrixAction)
helpMenu = menubar.addMenu('&Help')
helpMenu.addAction(aboutAction)
# Menu bar creation ends -------------------------------------
# Toolbar creation starts -------------------------------------
self.toolbar1 = self.addToolBar('File')
self.toolbar1.addAction(newMultitoolAction)
self.toolbar2 = self.addToolBar('Widgets')
self.toolbar2.addAction(mouseClickerAction)
self.toolbar2.addAction(screeenShotAction)
self.toolbar2.addAction(playerAction)
self.toolbar2.addAction(calculatorAction)
self.toolbar2.addAction(cameraAction)
self.toolbar3 = self.addToolBar('Games')
self.toolbar3.addAction(tetrixAction)
self.toolbar4 = self.addToolBar('Exit')
self.toolbar4.addAction(exitAction)
# Toolbar creation ends -------------------------------------
self.setCentralWidget(self.Stack)
self.setGeometry(300, 300, 700, 400)
self.setWindowTitle('Multitool')
self.setWindowIcon(QIcon('icons/biohazard.svg'))
self.show()
def __init__(self, main_panel_widget=None, top_panel=None):
if main_panel_widget is None:
main_panel_widget = QStackedWidget()
main_panel_widget.setMinimumSize(800, 600)
super().__init__(main_panel_widget, top_panel)
class MainWindow(QMainWindow):
""" Set up interface main window"""
def __init__(self, parent=None):
super().__init__(parent)
self.setWindowTitle("Smart Garden")
self.central_widget = QStackedWidget()
self.setCentralWidget(self.central_widget)
self.setFixedSize(520, 350)
self.start_window()
def start_window(self):
self.addThings_widget = AddThings(self)
self.addThings_widget.garden_button.clicked.connect(self.adding_garden)
self.addThings_widget.plant_button.clicked.connect(self.adding_plant)
self.addThings_widget.device_button.clicked.connect(self.adding_device)
self.central_widget.addWidget(self.addThings_widget)
self.central_widget.setCurrentWidget(self.addThings_widget)
def adding_garden(self):
self.add_garden_widget = AddGarden(self)
self.central_widget.addWidget(self.add_garden_widget)
self.central_widget.setCurrentWidget(self.add_garden_widget)
self.add_garden_widget.back_button.clicked.connect(self.start_window)
def adding_plant(self):
self.add_plant_widget = AddPlant(self)
self.central_widget.addWidget(self.add_plant_widget)
self.central_widget.setCurrentWidget(self.add_plant_widget)
self.add_plant_widget.back_button.clicked.connect(self.start_window)
def adding_device(self):
self.add_device_widget = AddDevice(self)
self.central_widget.addWidget(self.add_device_widget)
self.central_widget.setCurrentWidget(self.add_device_widget)
self.add_device_widget.back_button.clicked.connect(self.start_window)
class switchUI(QWidget):
"""
class documentation
variables:
methods:
"""
CONTROL = 0
CONFIGURATION = 1
SETTINGS = 2
def __init__(self, parent=None):
super(switchUI, self).__init__(parent)
self.setGeometry(0, 0, 600, 400)
self.initUI()
self.initConfig()
def __str__(self):
return "switchUI(): smart lights zone control switch"
def __repr__(self):
return "switchUI()"
def initUI(self):
self.stack = QStackedWidget(self)
self.control = ControlWidget(self)
self.config = ConfigWidget(self)
self.settings = SettingsWidget(self)
self.stack.addWidget(self.control)
self.stack.addWidget(self.config)
self.stack.addWidget(self.settings)
lyt = QVBoxLayout(self)
lyt.addWidget(self.stack)
lyt.setContentsMargins(0, 0, 0, 0)
self.stack.setCurrentIndex(self.CONTROL) # control screen
self.control.configure.connect(self.configure)
self.config.done.connect(self.doneConfiguring)
self.settings.done.connect(self.doneSettings)
self.show()
def initConfig(self):
# we should check if a config file exists
# read if exists
# create defaults if no file exists
self.settings = {
'All': [True, True, True, True, True, True, True, True],
'Min': [False, False, False, False, True, False, False, False],
'TV': [True, False, True, False, False, False, False, False],
'Mood': [True, True, True, True, False, True, False, False]
}
self.activeKey = 'All'
def configure(self, key):
print('** configure "{}"'.format(key))
if (key.lower() == 'settings'):
self.stack.setCurrentIndex(self.SETTINGS)
else:
self.activeKey = key
self.activeSetting = self.settings[key][:]
self.stack.setCurrentIndex(self.CONFIGURATION)
self.stack.currentWidget().initSettings(self.activeSetting)
def doneConfiguring(self, state):
if (state):
self.settings[self.activeKey] = self.activeSetting[:]
self.stack.setCurrentIndex(self.CONTROL)
self.stack.currentWidget().setActiveButton(self.activeKey)
print('*** status {} : {} ***'.format(
'changed' if state else 'unchanged',
self.settings[self.activeKey]))
def doneSettings(self):
self.stack.setCurrentIndex(self.CONTROL)
class MinWindow(Winform):
def __init__(self, parent=None):
super(MinWindow, self).__init__(parent)
self.setWindowTitle('主窗口')
self.resize(900, 600)
self.center()
# 创建主窗口
self.create_main_frame()
self.add_button()
# 创建菜单
self.create_menu()
# 画出图像
self.on_draw()
# 绑定所有事件
self.events_all_siganl_connect()
def save_plot(self):
# 保存当前matplotlib图像
file_choices = "PNG (*.png)|*.png"
# path = QFileDialog.getSaveFileName(self,
# 'Save file', '',
# file_choices)
# path = self.get_current_path()
self.stack_tabWidget.currentWidget().mpl_nav_toolbar.save_figure()
# if path:
# print('保存啊')
# # self.stack_tabWidget.currentWidget()
# self.stack_tabWidget.currentWidget().mpl_nav_toolbar.save_figure()
# print('保存了啊')
# self.statusBar().showMessage('Saved to %s' % path, 2000)
pass
def create_menu(self):
# 添加菜单栏
self.setCentralWidget(self.centralwidget)
# 添加菜单栏
self.main_menubar = QtWidgets.QMenuBar()
self.main_menubar.setGeometry(QtCore.QRect(0, 0, 800, 23))
self.main_menubar.setObjectName("main_menubar")
self.menu = QtWidgets.QMenu(self.main_menubar)
self.menu.setObjectName("menu")
self.file_menu = QtWidgets.QMenu(self.main_menubar)
self.file_menu.setObjectName("file_menu")
self.save_menu = QtWidgets.QMenu(self.main_menubar)
self.save_menu.setObjectName("save_menu")
self.setMenuBar(self.main_menubar)
self.statusbar = QtWidgets.QStatusBar()
self.statusbar.setObjectName("statusbar")
self.setStatusBar(self.statusbar)
# 添加状态栏
self.show_status_bar()
# self.statusbar.showMessage("这是状态栏")
self.plot_save_action = QtWidgets.QAction()
self.plot_save_action.setObjectName("plot_save_action")
# 给自己添加绑定事件
# self.plot_save_action.set
_translate = QtCore.QCoreApplication.translate
self.menu.setTitle(_translate("MainWindow", "菜单"))
self.file_menu.setTitle(_translate("MainWindow", "保存"))
self.save_menu.setTitle(_translate("MainWindow", "保存图片"))
self.plot_save_action.setText(_translate("MainWindow", "保存图片"))
# self.file_menu.addAction(self.plot_save_action)
self.main_menubar.addAction(self.menu.menuAction())
self.main_menubar.addAction(self.file_menu.menuAction())
self.main_menubar.addAction(self.save_menu.menuAction())
self.retranslateUi()
# 给菜单按钮添加绑定事件
# QtCore.QMetaObject.connectSlotsByName(self)
save_file_action = self.create_action("&保存图像",
shortcut="Ctrl+S",
slot=self.save_plot,
tip="Save the plot")
quit_action = self.create_action("&Quit",
slot=self.close,
shortcut="Ctrl+Q",
tip="Close the application")
self.add_actions(self.file_menu, (save_file_action, None, quit_action))
pass
def create_main_frame(self):
# 窗口布局
# 添加主窗口
self.setObjectName("MainWindow")
self.centralwidget = QtWidgets.QWidget()
self.centralwidget.setObjectName("centralwidget")
self.setCentralWidget(self.centralwidget)
self.main_widget = QtWidgets.QWidget(self.centralwidget)
self.main_widget.setGeometry(QtCore.QRect(10, 20, 761, 481))
self.main_widget.setObjectName("main_widget")
# 此区域存放图像
self.stack_tabWidget = QtWidgets.QTabWidget(self.main_widget)
self.stack_tabWidget.setGeometry(QtCore.QRect(30, 60, 721, 401))
self.stack_tabWidget.setObjectName("stack_tabWidget")
# 此区域存放图像的工具栏
self.toolbar_stackedWidget = QStackedWidget(self.main_widget)
self.toolbar_stackedWidget.setGeometry(QtCore.QRect(20, 0, 791, 71))
self.toolbar_stackedWidget.setObjectName("toolbar_stackedWidget")
def on_draw(self):
# 添加图像
self.draw_all_stack_tab()
# 添加工具栏
self.set_all_stack_tab_toolbar()
pass
def create_status_bar(self):
pass
def create_action(self,
text,
slot=None,
shortcut=None,
icon=None,
tip=None,
checkable=False,
signal="triggered()"):
action = QAction(text, self)
if icon is not None:
# action.setIcon(QIcon(":/%s.png" % button_icon))
pass
if shortcut is not None:
action.setShortcut(shortcut)
if tip is not None:
action.setToolTip(tip)
action.setStatusTip(tip)
if slot is not None:
action.triggered.connect(slot)
if checkable:
action.setCheckable(True)
return action
def add_actions(self, target, actions):
for action in actions:
if action is None:
target.addSeparator()
else:
target.addAction(action)
def add_button(self):
self.save_pushButton = QtWidgets.QPushButton(self.centralwidget)
self.save_pushButton.setGeometry(QtCore.QRect(800, 160, 75, 23))
self.save_pushButton.setObjectName("save_pushButton")
pass
def on_about(self):
# 弹出关于此软件的信息
msg = """ A demo of using PyQt with matplotlib:
* Use the matplotlib navigation bar
* Add values to the text box and press Enter (or click "Draw")
* Show or hide the grid
* Drag the slider to modify the width of the bars
* Save the plot to a file using the File menu
* Click on a bar to receive an informative message
"""
QMessageBox.about(self, "About the demo", msg.strip())
def retranslateUi(self):
# 设置各个菜单的名字
_translate = QtCore.QCoreApplication.translate
self.setWindowTitle(_translate("MainWindow", "曲线翻页"))
# self.stack_tabWidget.setTabText(self.stack_tabWidget.indexOf(self.tab), _translate("MainWindow", "Tab 1"))
# self.stack_tabWidget.setTabText(self.stack_tabWidget.indexOf(self.tab_2), _translate("MainWindow", "Tab 2"))
self.menu.setTitle(_translate("MainWindow", "菜单"))
self.file_menu.setTitle(_translate("MainWindow", "保存"))
self.save_menu.setTitle(_translate("MainWindow", "状态"))
self.plot_save_action.setText(_translate("MainWindow", "保存图片"))
self.save_pushButton.setText(_translate("MainWindow", "点击保存"))
def draw_all_stack_tab(self):
# 绘制所有图像
# 添加到stack_tabWidget上
# 创建matplot画布
self.tab1 = PlotCanvas(self, width=9, height=6, dpi=100)
self.tab2 = PlotCanvas(self, width=9, height=6, dpi=100)
self.tab3 = PlotCanvas(self, width=9, height=6, dpi=100)
# mpl.draw_one_line()
# 加载数据
# 在不同的画布上画出来
# 将所有f分页加入到tabWidget上
lines = load_all_lines()
self.tab1.draw_one_line(lines[0])
self.tab2.draw_one_line(lines[1])
self.tab3.draw_one_line(lines[2])
# 将所有的tab添加到stack_tabWidget上
self.stack_tabWidget.addTab(self.tab1, 'td=0.12')
self.stack_tabWidget.addTab(self.tab2, 'td=0.144')
self.stack_tabWidget.addTab(self.tab3, 'td=0.176')
pass
def set_all_stack_tab_toolbar(self):
# 添加图像的工具栏 所有的工具栏用容器toolbar_stackedWidget保存
self.add_stack_toolbar()
self.tab1_ntb = NavigationToolbar(self.tab1,
self.toolbar_page1) # 添加完整的 toolbar
self.tab2_ntb = NavigationToolbar(self.tab2,
self.toolbar_page2) # 添加完整的 toolbar
self.tab3_ntb = NavigationToolbar(self.tab3,
self.toolbar_page3) # 添加完整的 toolbar
self.tab1.mpl_nav_toolbar = self.tab1_ntb
self.tab2.mpl_nav_toolbar = self.tab2_ntb
self.tab3.mpl_nav_toolbar = self.tab3_ntb
# log('设置了的')
pass
def show_status_bar(self):
# 添加状态栏
self.status_text = QLabel(" demo 状态栏")
self.statusbar.addWidget(self.status_text, 1)
def add_stack_toolbar(self):
# 添加matplotlib的工具栏
# toolbar_stackedWidget
# 创建QStackedWidget容器 将matplotlib所有图像的工具栏叠加放在一起
# self.toolbar_stackedWidget = QStackedWidget()
# 创建不同的 QWidget保存单个matplotlib图像的工具栏
self.toolbar_page1 = QtWidgets.QWidget()
self.toolbar_page1.setObjectName("toolbar_page1")
self.toolbar_page2 = QtWidgets.QWidget()
self.toolbar_page2.setObjectName("toolbar_page2")
self.toolbar_page3 = QtWidgets.QWidget()
self.toolbar_page3.setObjectName("toolbar_page3")
# 初始化空白toolbar区域
# 添加三个空页
self.toolbar_stackedWidget.addWidget(self.toolbar_page1)
self.toolbar_stackedWidget.addWidget(self.toolbar_page2)
self.toolbar_stackedWidget.addWidget(self.toolbar_page3)
pass
def events_all_siganl_connect(self):
# 连接所有的事件
# 切换tabWidget图像 显示 当前图像的toolbar
self.stack_tabWidget.currentChanged.connect(
self.event_change_toolbar_page)
# 点击按钮 保存当前图像
self.save_pushButton.clicked.connect(self.save_plot)
pass
def event_change_toolbar_page(self):
# 切换当前td图像触发
# 在toolbar_stackedWidget区域显示当前图像的matplotlib工具栏
# 获取当前的tab
# log('点击了当前的widget')
c = self.stack_tabWidget.currentIndex()
# 设置当前stackWidget的当前
self.toolbar_stackedWidget.setCurrentIndex(c)
# log("toolbar_stackedWidget 当前页面是({})".format(c))
# 设置当前的tool stackWidget的page
pass
def get_current_path(self):
# 获取当前文件目录
paths = sys.path
current_file = os.path.basename(__file__)
for path in paths:
try:
if current_file in os.listdir(path):
self.current_path = path
break
except (FileExistsError, FileNotFoundError) as e:
print(e)
class ConfigDialog(QDialog):
def __init__(self, parent=None):
super(ConfigDialog, self).__init__(parent)
self.msg_box = MessageBox()
self.ejabberd = EjabberdPage()
self.lider_page = LiderPage()
self.contentsWidget = QListWidget()
self.contentsWidget.setViewMode(QListView.IconMode)
self.contentsWidget.setIconSize(QSize(64, 64))
self.contentsWidget.setMovement(QListView.Static)
self.contentsWidget.setMaximumWidth(128)
self.contentsWidget.setMinimumWidth(128)
self.contentsWidget.setMinimumHeight(700)
self.contentsWidget.setSpacing(12)
self.pagesWidget = QStackedWidget()
self.pagesWidget.setMinimumHeight(800)
self.pagesWidget.setMinimumWidth(1024)
self.pagesWidget.addWidget(SettingsPage())
# self.pagesWidget.addWidget(DatabasePage())
# self.pagesWidget.addWidget(OpenLdapPage())
# self.pagesWidget.addWidget(EjabberdPage())
# self.pagesWidget.addWidget(LiderPage())
# self.pagesWidget.addWidget(LiderConsolePage())
# self.pagesWidget.addWidget(AhenkPage())
# self.pagesWidget.addWidget(WatchLog())
closeButton = QPushButton("Kapat")
aboutButton = QPushButton("Hakkında")
# self.createIcons()
self.contentsWidget.setCurrentRow(0)
closeButton.clicked.connect(self.close_page)
aboutButton.clicked.connect(self.about_lider_installer)
horizontalLayout = QHBoxLayout()
# horizontalLayout.addWidget(self.contentsWidget)
horizontalLayout.addWidget(self.pagesWidget, 1)
buttonsLayout = QHBoxLayout()
buttonsLayout.addStretch(0)
buttonsLayout.addWidget(aboutButton)
buttonsLayout.addStretch(1)
buttonsLayout.addWidget(closeButton)
mainLayout = QVBoxLayout()
mainLayout.addLayout(horizontalLayout)
mainLayout.addStretch(1)
mainLayout.addSpacing(12)
mainLayout.addLayout(buttonsLayout)
self.setLayout(mainLayout)
self.setWindowTitle("Lider Ahenk Kurulum Uygulaması")
self.setWindowIcon(QIcon(":/images/liderahenk-32.png"))
def close_page(self):
for proc in psutil.process_iter():
# check whether the process name matches
if proc.name() == "xterm":
proc.kill()
self.close()
def about_lider_installer(self):
self.msg_box.about(
"Lider Ahenk Merkezi Yönetim Sistemi Kurulum Uygulaması\nDaha fazla bilgi için...\nwww.liderahenk.org\nVersiyon: 2.0"
)
def changePage(self, current, previous):
if not current:
current = previous
self.pagesWidget.setCurrentIndex(self.contentsWidget.row(current))
def createIcons(self):
vagrantButton = QListWidgetItem(self.contentsWidget)
vagrantButton.setIcon(QIcon(':/images/settings.png'))
vagrantButton.setText("Sunucu\nAyarları")
vagrantButton.setTextAlignment(Qt.AlignHCenter)
vagrantButton.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
# dbButton = QListWidgetItem(self.contentsWidget)
# dbButton.setIcon(QIcon(':/images/database.png'))
# dbButton.setText("Veritabanı")
# dbButton.setTextAlignment(Qt.AlignHCenter)
# dbButton.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
#
# ldapButton = QListWidgetItem(self.contentsWidget)
# ldapButton.setIcon(QIcon(':/images/ldap.png'))
# ldapButton.setText("OpenLDAP")
# ldapButton.setTextAlignment(Qt.AlignHCenter)
# ldapButton.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
#
# xmppButton = QListWidgetItem(self.contentsWidget)
# xmppButton.setIcon(QIcon(':/images/ejabberd.png'))
# xmppButton.setText("Ejabberd")
# xmppButton.setTextAlignment(Qt.AlignHCenter)
# xmppButton.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
# liderButton = QListWidgetItem(self.contentsWidget)
# liderButton.setIcon(QIcon(':/images/liderahenk.png'))
# liderButton.setText("Lider Kur")
# liderButton.setTextAlignment(Qt.AlignHCenter)
# liderButton.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
# consoleButton = QListWidgetItem(self.contentsWidget)
# consoleButton.setIcon(QIcon(':/images/lider_console.png'))
# consoleButton.setText("Lider\nArayüz")
# consoleButton.setTextAlignment(Qt.AlignHCenter)
# consoleButton.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
# ahenkButton = QListWidgetItem(self.contentsWidget)
# ahenkButton.setIcon(QIcon(':/images/ahenk.png'))
# ahenkButton.setText("Ahenk Kur")
# ahenkButton.setTextAlignment(Qt.AlignHCenter)
# ahenkButton.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
#
# logButton = QListWidgetItem(self.contentsWidget)
# logButton.setIcon(QIcon(':/images/log.png'))
# logButton.setText("Log")
# logButton.setTextAlignment(Qt.AlignHCenter)
# logButton.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.contentsWidget.currentItemChanged.connect(self.changePage)
class LeftTabWidget(QWidget):
'''左侧选项栏'''
pointlist = [] #########
def __init__(self):
super(LeftTabWidget, self).__init__()
self.setObjectName('LeftTabWidget')
self.setWindowTitle('LeftTabWidget')
self.list_style = ('''
QListWidget, QListView, QTreeWidget, QTreeView {
outline: 0px;
}
QListWidget {
min-width: 200px;
max-width: 200px;
color: White;
background:#454545;
}
QListWidget::Item:selected {
background: lightGray;
border-left: 5px solid #EE9A00;
color: black
}
HistoryPanel:hover {
background: rgb(52, 52, 52);
}
''')
#####################################################ZL
self.left = 200
self.top = 200
self.width = 1000
self.height = 800
self.setGeometry(self.left, self.top, self.width, self.height)
#####################################################ZL
self.main_layout = QHBoxLayout(self, spacing=0) #窗口的整体布局
self.main_layout.setContentsMargins(0, 0, 0, 0)
self.left_widget = QListWidget() #左侧选项列表
self.left_widget.setStyleSheet(self.list_style)
self.main_layout.addWidget(self.left_widget)
self.right_widget = QStackedWidget()
self.main_layout.addWidget(self.right_widget)
self._setup_ui()
f = open('/home/robot/waypoints.xml', 'r') #############
pointlist = re.findall(r"(?<=<Name>).+?(?=</Name>)", f.read(),
re.S) ########
f.close() #######
self.comboBox2.addItems(pointlist) ######
def _setup_ui(self):
'''加载界面ui'''
self.left_widget.currentRowChanged.connect(
self.right_widget.setCurrentIndex) #list和右侧窗口的index对应绑定
self.left_widget.setFrameShape(QListWidget.NoFrame) #去掉边框
self.left_widget.setVerticalScrollBarPolicy(
Qt.ScrollBarAlwaysOff) #隐藏滚动条
self.left_widget.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
list_str = [
'功能选择', '扫地', '导航', '取物', '关于MOSS', '使用方法', '注意事项', '硬件设置',
'联系与帮助', '遇到问题', '联系lzz'
]
for i in range(11):
self.item = QListWidgetItem(list_str[i],
self.left_widget) #左侧选项的添加
self.item.setFont(QFont("等线", 11))
if i == 0 or i == 4 or i == 8:
self.item.setBackground(QColor('#EE9A00'))
self.item.setFont(QFont("等线", 13, QFont.Bold))
if i == 0:
self.item.setIcon(
qtawesome.icon('fa.hand-pointer-o', color='white'))
elif i == 4:
self.item.setIcon(qtawesome.icon('fa.tags', color='white'))
elif i == 8:
self.item.setIcon(
qtawesome.icon('fa.envelope', color='white'))
self.item.setSizeHint(QSize(60, 65))
self.item.setTextAlignment(Qt.AlignCenter) #居中显示
if i == 1:
self.centralWidget1 = QtWidgets.QWidget()
self.centralWidget1.setStyleSheet(
'''background:black;border-width:0;''')
self.layout1 = QtWidgets.QGridLayout() # 创建左侧部件的网格布局层
self.centralWidget1.setLayout(self.layout1)
self.edit1_1 = QtWidgets.QLineEdit()
self.edit1_1.setPlaceholderText("请输入速度(两位小数,0.0-1.0)")
self.edit1_1.setStyleSheet(
'''color:white;background:transparent;border-width:0;
border-style:outset;border-bottom:1px solid white;
font-size:20px; font-family:等线;'''
)
self.vel_reg = QRegExp(r"^(0)|(0\.[0-9])|(1)|(1\.0)$")
self.vel_validator = QRegExpValidator(self.vel_reg,
self.edit1_1)
self.edit1_1.setValidator(self.vel_validator)
self.edit1_2 = QtWidgets.QLineEdit()
self.edit1_2.setPlaceholderText("请输入时间(三位整数)")
self.edit1_2.setStyleSheet(
'''color:white;background:transparent;border-width:0;
border-style:outset;border-bottom:1px solid white;
font-size:20px; font-family:等线;'''
)
self.time_reg = QRegExp("^[0-9]{3}$")
self.time_validator = QRegExpValidator(self.time_reg,
self.edit1_2)
self.edit1_2.setValidator(self.time_validator)
self.label1_1 = QtWidgets.QLabel() #设置label
self.label1_1.setTextFormat(QtCore.Qt.AutoText)
self.label1_1.setText("速度")
self.label1_1.setStyleSheet(
'''color:white;font-size:23px; font-family:等线;''')
self.label1_1.setAlignment(Qt.AlignCenter)
self.label1_2 = QtWidgets.QLabel()
self.label1_2.setTextFormat(QtCore.Qt.AutoText)
self.label1_2.setText("时间")
self.label1_2.setStyleSheet(
'''color:white;font-size:23px; font-family:等线;''')
self.label1_2.setAlignment(Qt.AlignCenter)
self.label1_3 = QtWidgets.QLabel()
self.label1_3.setTextFormat(QtCore.Qt.AutoText)
self.label1_3.setText("扫地")
self.label1_3.setStyleSheet(
'''color:white;font-size:23px;background:rgb(100,100,100,80;background:#454545);
font-family:等线;''')
self.label1_3.setAlignment(Qt.AlignCenter)
self.button1 = QtWidgets.QPushButton()
self.button1.setText("开始")
self.button1.setFixedSize(100, 40)
self.button1.setStyleSheet(
'''QPushButton{background:#EE9A00;border-radius:10px;font-family:等线;
font-size:18px;color:white}QPushButton:hover{background:#EEDC82;}'''
)
self.button1.clicked.connect(self.button1_1click)
self.layout1.setColumnStretch(0, 2)
self.layout1.setColumnStretch(1, 2)
self.layout1.setColumnStretch(2, 2)
self.layout1.setColumnStretch(3, 2)
self.layout1.setColumnStretch(5, 2)
self.layout1.setColumnStretch(6, 2)
self.layout1.setColumnStretch(7, 2)
self.layout1.setColumnStretch(8, 2)
self.layout1.setColumnStretch(4, 1)
self.layout1.addWidget(self.label1_3, 0, 0, 1, 9)
self.layout1.addWidget(self.label1_1, 4, 2, 2, 2)
self.layout1.addWidget(self.label1_2, 6, 2, 2, 2)
self.layout1.addWidget(self.edit1_1, 4, 4, 2, 3)
self.layout1.addWidget(self.edit1_2, 6, 4, 2, 3)
self.layout1.addWidget(self.button1, 9, 4, 2, 2)
self.right_widget.addWidget(self.centralWidget1)
elif i == 2:
self.centralWidget2 = QtWidgets.QWidget()
self.centralWidget2.setStyleSheet(
'''background:black;border-width:0;''')
self.layout2 = QtWidgets.QGridLayout() # 创建左侧部件的网格布局层
self.centralWidget2.setLayout(self.layout2)
self.button2_1 = QtWidgets.QPushButton(self.centralWidget2)
#self.button2_1.setGeometry(QtCore.QRect(210, 110, 100, 60))
self.button2_1.setObjectName("button1")
self.button2_1.setText("构建地图")
self.button2_1.clicked.connect(self.button2_1click)
self.button2_1.setFixedSize(200, 80)
self.button2_1.setStyleSheet(
'''QPushButton{background:#EE9A00;border-radius:20px;font-family:等线;
font-size:18px;color:white}QPushButton:hover{background:#EEDC82;}'''
)
self.button2_2 = QtWidgets.QPushButton(self.centralWidget2)
#self.button2_2.setGeometry(QtCore.QRect(350, 110, 100, 60))
self.button2_2.setObjectName("button2")
self.button2_2.setText("保存地图")
self.button2_2.clicked.connect(self.button2_2click)
self.button2_2.setFixedSize(200, 80)
self.button2_2.setStyleSheet(
'''QPushButton{background:#EE9A00;border-radius:20px;font-family:等线;
font-size:18px;color:white}QPushButton:hover{background:#EEDC82;}'''
)
self.button2_3 = QtWidgets.QPushButton(self.centralWidget2)
#self.button2_3.setGeometry(QtCore.QRect(210, 210, 100, 60))
self.button2_3.setObjectName("button3")
self.button2_3.setText("设立航点")
self.button2_3.clicked.connect(self.button2_3click)
self.button2_3.setFixedSize(200, 80)
self.button2_3.setStyleSheet(
'''QPushButton{background:#EE9A00;border-radius:20px;font-family:等线;
font-size:18px;color:white}QPushButton:hover{background:#EEDC82;}'''
)
self.button2_4 = QtWidgets.QPushButton(self.centralWidget2)
#self.button2_4.setGeometry(QtCore.QRect(350, 210, 100, 60))
self.button2_4.setObjectName("button4")
self.button2_4.setText("保存航点")
self.button2_4.clicked.connect(self.button2_4click)
self.button2_4.setFixedSize(200, 80)
self.button2_4.setStyleSheet(
'''QPushButton{background:#EE9A00;border-radius:20px;font-family:等线;
font-size:18px;color:white}QPushButton:hover{background:#EEDC82;}'''
)
self.button2_5 = QtWidgets.QPushButton(self.centralWidget2)
#self.button2_5.setGeometry(QtCore.QRect(210, 310, 240, 60))
self.button2_5.setObjectName("button5")
self.button2_5.setText("开始导航")
self.button2_5.clicked.connect(self.button2_5click)
self.button2_5.setFixedSize(466, 80)
self.button2_5.setStyleSheet(
'''QPushButton{background:#EE9A00;border-radius:20px;font-family:等线;
font-size:18px;color:white}QPushButton:hover{background:#EEDC82;}'''
)
self.comboBox2 = QtWidgets.QComboBox(self.centralWidget2)
#self.comboBox2.setGeometry(QtCore.QRect(210, 410, 100, 30))
self.comboBox2.setObjectName("comboBox")
#self.comboBox2.addItems(self.pointlist)
self.comboBox2.setFixedSize(200, 50)
self.comboBox2.setStyleSheet(
'''QComboBox{background:#EE9A00;border-radius:10px;font-family:等线;
font-size:18px;color:white}QComboBox:hover{background:#EEDC82;}'''
)
self.button2_6 = QtWidgets.QPushButton(self.centralWidget2)
#self.button2_6.setGeometry(QtCore.QRect(350, 410, 100, 30))
self.button2_6.setObjectName("button6")
self.button2_6.setText("G O !")
self.button2_6.clicked.connect(self.button2_6click)
self.button2_6.setFixedSize(200, 50)
self.button2_6.setStyleSheet(
'''QPushButton{background:#EE9A00;border-radius:20px;font-family:等线;
font-size:18px;color:white}QPushButton:hover{background:#EEDC82;}'''
)
self.label2_1 = QtWidgets.QLabel()
self.label2_1.setTextFormat(QtCore.Qt.AutoText)
self.label2_1.setText("导航")
self.label2_1.setStyleSheet(
'''color:white;font-size:23px;background:rgb(100,100,100,100);
font-family:等线;''')
self.label2_1.setAlignment(Qt.AlignCenter)
self.layout2.setColumnStretch(0, 1)
self.layout2.setColumnStretch(1, 1)
self.layout2.setColumnStretch(2, 1)
self.layout2.setColumnStretch(3, 1)
self.layout2.setColumnStretch(4, 1)
self.layout2.setColumnStretch(5, 1)
self.layout2.setColumnStretch(6, 1)
self.layout2.setColumnStretch(7, 1)
self.layout2.setColumnStretch(8, 1)
self.layout2.setColumnStretch(9, 1)
self.layout2.setColumnStretch(10, 1)
self.layout2.setColumnStretch(11, 1)
self.layout2.setColumnStretch(12, 1)
self.layout2.addWidget(self.label2_1, 0, 0, 1, 13)
self.layout2.addWidget(self.button2_1, 2, 3, 2, 3)
self.layout2.addWidget(self.button2_2, 2, 7, 2, 3)
self.layout2.addWidget(self.button2_3, 6, 3, 2, 3)
self.layout2.addWidget(self.button2_4, 6, 7, 2, 3)
self.layout2.addWidget(self.button2_5, 10, 3, 2, 7)
self.layout2.addWidget(self.button2_6, 14, 7, 2, 3)
self.layout2.addWidget(self.comboBox2, 14, 3, 2, 3)
self.right_widget.addWidget(self.centralWidget2)
else:
self.centralWidget0 = QtWidgets.QWidget()
self.centralWidget0.setStyleSheet(
'''background:white;border-width:0;''')
self.right_widget.addWidget(self.centralWidget0)
def button1_1click(self):
vel = 0
time = 0
if self.edit1_1.text() == "":
vel = 0.5
else:
vel = float(self.edit1_1.text())
if self.edit1_2.text() == "":
time = 60
else:
time = int(self.edit1_2.text())
self.setConfig(vel, time)
os.system(free_walk_cmd)
def setConfig(self, vel, time):
vel_pattern = re.compile(vel_config)
time_pattern = re.compile(time_config)
with open(config_path, "w") as f:
f.truncate()
f.write(str(vel))
f.write("\n")
f.write(str(time))
def button2_1click(self):
print("roslaunch wpb_home_tutorials gmapping.launch")
#os.system("roslaunch wpb_home_tutorials gmapping.launch")
os.system(
"gnome-terminal -e 'bash -c \"roslaunch wpb_home_tutorials gmapping.launch\"'"
)
#os.system("gnome-terminal -e 'bash -c \"ls\"'")
#os.system("gnome-terminal -e 'bash -c \"roslaunch wpb_home_tutorials gmapping.launch; exec bash\"'")
def button2_2click(self):
print("rosrun map_server map_saver -f map")
os.system(
"gnome-terminal -e 'bash -c \"rosrun map_server map_saver -f map&&cp /home/robot/catkin_ws/src/team_201/map.yaml /home/robot/catkin_ws/src/wpb_home/wpb_home_tutorials/maps/map.yaml&&cp /home/robot/catkin_ws/src/team_201/map.pgm /home/robot/catkin_ws/src/wpb_home/wpb_home_tutorials/maps/map.pgm\"'"
) ##yidong
#save in the main dir
#print("移动指令")
#may be we do not need to really change the map path, because we can change the map path in some launch files
#such as, in add_waypoint.launch, we can change
#args="$(find wpb_home_tutorials)/maps/map.yaml"/>
#into
#args="/home/robot/map.yaml"/>
def button2_3click(self):
print("roslaunch waterplus_map_tools add_waypoint.launch")
os.system(
"gnome-terminal -e 'bash -c \"roslaunch waterplus_map_tools add_waypoint.launch\"'"
)
###???????????????????????????????????
def button2_4click(self):
print("rosrun waterplus_map_tools wp_saver")
os.system(
"gnome-terminal -e 'bash -c \"cd /home/robot/&&rosrun waterplus_map_tools wp_saver\"'"
)
time.sleep(2)
#os.system("rosrun waterplus_map_tools wp_saver")
#os.system("gnome-terminal -e 'bash -c \"rosrun waterplus_map_tools wp_saver; exec bash\"'")
#save waypoints.xml into /home/robot/
self.comboBox2.clear()
f = open('/home/robot/waypoints.xml', 'r')
pointlist = re.findall(r"(?<=<Name>).+?(?=</Name>)", f.read(), re.S)
print(pointlist)
self.comboBox2.addItems(pointlist)
f.close()
def button2_5click(self):
print("roslaunch wpb_home_apps 6_path_plan.launch")
os.system(
"gnome-terminal -e 'bash -c \"roslaunch wpb_home_apps 6_path_plan.launch; exec bash\"'"
)
def button2_6click(self):
print(self.comboBox2.currentIndex() + 1)
#get to the chosed point
pointoutput = open('/home/robot/point.txt', 'w')
pointoutput.write(str(self.comboBox2.currentIndex() + 1))
pointoutput.close()
class DiyWindow(QMainWindow):
def __init__(self):
super().__init__()
self.initUi()
def initUi(self):
# 状态栏
self.statusBar()
# 功能Action
single_rec_act = QAction(QIcon('./0.png'), '文字识别', self)
single_rec_act.setShortcut('Ctrl+F')
single_rec_act.setStatusTip('对单个文字进行识别')
single_rec_act.triggered.connect(self.changeLayout)
single_info_act = QAction(QIcon('./1_1.png'), '单字信息', self)
single_info_act.setShortcut('Ctrl+S')
single_info_act.setStatusTip('单个文字的信息')
single_info_act.triggered.connect(self.changeLayout)
rubbing_info_act = QAction(QIcon('./2_1.png'), '拓片信息', self)
rubbing_info_act.setShortcut('Ctrl+R')
rubbing_info_act.setStatusTip('整个拓片的信息')
rubbing_info_act.triggered.connect(self.changeLayout)
# 菜单栏
menubar = self.menuBar()
fileMenu = menubar.addMenu('功能')
fileMenu.addAction(single_rec_act)
fileMenu.addAction(single_info_act)
fileMenu.addAction(rubbing_info_act)
# 工具栏
toolbar = self.addToolBar('功能')
toolbar.addAction(single_rec_act)
toolbar.addAction(single_info_act)
toolbar.addAction(rubbing_info_act)
# 需要的变量
self.path = ""
self.color = QColor(255, 255, 255)
# 初始化第一个功能布局：文字识别
self.initLayout0()
# 初始化第二个功能布局：单字信息
self.initLayout1()
# 初始化第三个功能布局：拓片信息
self.initLayout2()
self.stacked = QStackedWidget()
self.stacked.addWidget(self.layout0)
self.stacked.addWidget(self.layout1)
self.stacked.addWidget(self.layout2)
self.setCentralWidget(self.stacked)
self.setGeometry(100, 100, 600, 450)
self.setFixedSize(600, 450)
self.setWindowTitle('金文识别')
self.setWindowIcon(QIcon('./4.png'))
self.center()
self.show()
def initLayout0(self):
# 布局
grid = QGridLayout()
self.lf = QLabel("金文图片")
self.lf.setAlignment(Qt.AlignCenter)
self.lf.setStyleSheet(
"QLabel { background-color: %s }" % self.color.name())
btn0 = QPushButton("选择图片")
btn0.setStyleSheet(
"QPushButton { height: 50 }")
btn1 = QPushButton("识别")
btn1.setStyleSheet(
"QPushButton { height: 50 }")
l0_l = QLabel("Top-1")
l0_l.setAlignment(Qt.AlignCenter)
self.l0_c = QLabel()
self.l0_c.setAlignment(Qt.AlignCenter)
self.l0_c.setStyleSheet(
"QLabel { background-color: %s }" % self.color.name())
l1_l = QLabel("Top-2")
l1_l.setAlignment(Qt.AlignCenter)
self.l1_c = QLabel()
self.l1_c.setAlignment(Qt.AlignCenter)
self.l1_c.setStyleSheet(
"QLabel { background-color: %s }" % self.color.name())
l2_l = QLabel("Top-3")
l2_l.setAlignment(Qt.AlignCenter)
self.l2_c = QLabel()
self.l2_c.setAlignment(Qt.AlignCenter)
self.l2_c.setStyleSheet(
"QLabel { background-color: %s }" % self.color.name())
l3_l = QLabel("Top-4")
l3_l.setAlignment(Qt.AlignCenter)
self.l3_c = QLabel()
self.l3_c.setAlignment(Qt.AlignCenter)
self.l3_c.setStyleSheet(
"QLabel { background-color: %s }" % self.color.name())
l4_l = QLabel("Top-5")
l4_l.setAlignment(Qt.AlignCenter)
self.l4_c = QLabel()
self.l4_c.setAlignment(Qt.AlignCenter)
self.l4_c.setStyleSheet(
"QLabel { background-color: %s }" % self.color.name())
grid.addWidget(self.lf, 1, 1, 10, 1)
grid.addWidget(l0_l, 1, 2)
grid.addWidget(self.l0_c, 1, 3)
grid.addWidget(l1_l, 2, 2)
grid.addWidget(self.l1_c, 2, 3)
grid.addWidget(l2_l, 3, 2)
grid.addWidget(self.l2_c, 3, 3)
grid.addWidget(l3_l, 4, 2)
grid.addWidget(self.l3_c, 4, 3)
grid.addWidget(l4_l, 5, 2)
grid.addWidget(self.l4_c, 5, 3)
grid.addWidget(btn0, 6, 3, 2, 1)
grid.addWidget(btn1, 8, 3, 2, 1)
grid.setColumnStretch(1, 10)
grid.setColumnStretch(2, 1)
grid.setColumnStretch(3, 5)
grid.setColumnStretch(4, 4)
self.layout0 = QWidget()
self.layout0.setLayout(grid)
# 事件
btn0.clicked.connect(self.selectImg)
btn1.clicked.connect(self.predictImg)
def selectImg(self):
fname = QFileDialog.getOpenFileName(self, '选择图片')
if fname[0]:
self.path = fname[0]
self.statusBar().showMessage("图片路径: " + self.path)
pixmap = QPixmap(self.path)
scaled_pixmap = pixmap.scaled(int(self.lf.width()), int(
self.lf.height()), aspectRatioMode=Qt.KeepAspectRatio)
self.lf.setPixmap(scaled_pixmap)
else:
QMessageBox.information(self, "Info.", "请选择图片^_^")
def predictImg(self):
pass
def initLayout1(self):
# 布局
grid = QGridLayout()
self.ls = QLabel("金文图片")
self.ls.setAlignment(Qt.AlignCenter)
self.ls.setStyleSheet(
"QLabel { background-color: %s }" % self.color.name())
btn = QPushButton("选择单字图片显示信息")
btn.setStyleSheet(
"QPushButton { height: 50 }")
l5_l = QLabel("总号")
l5_l.setAlignment(Qt.AlignCenter)
self.l5_c = QLabel()
self.l5_c.setAlignment(Qt.AlignCenter)
self.l5_c.setStyleSheet(
"QLabel { background-color: %s }" % self.color.name())
l6_l = QLabel("字形出处")
l6_l.setAlignment(Qt.AlignCenter)
self.l6_c = QLabel()
self.l6_c.setAlignment(Qt.AlignCenter)
self.l6_c.setStyleSheet(
"QLabel { background-color: %s }" % self.color.name())
l7_l = QLabel("拓片情况")
l7_l.setAlignment(Qt.AlignCenter)
self.l7_c = QLabel()
self.l7_c.setAlignment(Qt.AlignCenter)
self.l7_c.setStyleSheet(
"QLabel { background-color: %s }" % self.color.name())
l8_l = QLabel("铭中句号")
l8_l.setAlignment(Qt.AlignCenter)
self.l8_c = QTextBrowser()
self.l8_c.setStyleSheet(
"QTextBrowser { background-color: %s; border: none }" % self.color.name())
l9_l = QLabel("释文表")
l9_l.setAlignment(Qt.AlignCenter)
self.l9_c = QTextBrowser()
self.l9_c.setStyleSheet(
"QTextBrowser { background-color: %s; border: none }" % self.color.name())
grid.addWidget(self.ls, 1, 1, 10, 1)
grid.addWidget(l5_l, 1, 2)
grid.addWidget(self.l5_c, 1, 3)
grid.addWidget(l6_l, 2, 2)
grid.addWidget(self.l6_c, 2, 3)
grid.addWidget(l7_l, 3, 2)
grid.addWidget(self.l7_c, 3, 3)
grid.addWidget(l8_l, 4, 2)
grid.addWidget(self.l8_c, 4, 3, 2, 1)
grid.addWidget(l9_l, 6, 2)
grid.addWidget(self.l9_c, 6, 3, 2, 1)
grid.addWidget(btn, 8, 3, 2, 1)
grid.setColumnStretch(1, 10)
grid.setColumnStretch(2, 2)
grid.setColumnStretch(3, 6)
grid.setColumnStretch(4, 2)
for i in range(1, 11):
grid.setRowStretch(i, 1)
self.layout1 = QWidget()
self.layout1.setLayout(grid)
# 事件
btn.clicked.connect(self.showSingleInfo)
def showSingleInfo(self):
pass
def initLayout2(self):
# 布局
grid = QGridLayout()
btn = QPushButton("ok")
grid.addWidget(btn, 1, 1)
self.layout2 = QWidget()
self.layout2.setLayout(grid)
# 事件
btn.clicked.connect(self.showRubbingInfo)
def showRubbingInfo(self):
pass
def changeLayout(self):
sender = self.sender()
tmp_str = sender.text()
self.statusBar().showMessage(tmp_str)
if tmp_str == '文字识别':
self.stacked.setCurrentIndex(0)
if tmp_str == '单字信息':
self.stacked.setCurrentIndex(1)
if tmp_str == '拓片信息':
self.stacked.setCurrentIndex(2)
def center(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def keyPressEvent(self, e):
if e.key() == Qt.Key_Escape:
self.close()
class App(QDialog):
def __init__(self):
super().__init__()
self.left = 10
self.top = 10
self.width = 800
self.height = 600
self.initUI()
def initUI(self):
self.setGeometry(self.left, self.top, self.width, self.height)
self.createSidebar()
self.createContent()
self.windowLayout = QHBoxLayout(self)
self.windowLayout.addWidget(self.sidebar)
self.windowLayout.addWidget(self.content)
self.addMenu(MenuChat())
#self.addMenu(MenuTraffic())
#self.addMenu(MenuFirewall())
self.addMenu(MenuExit())
self.content.setCurrentIndex(0)
self.show()
def addMenu(self, menu):
menuButton = QPushButton(menu.name)
menuButton.setSizePolicy(
QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum))
self.sidebarLayout.addWidget(menuButton)
contentIndex = self.content.addWidget(menu.widget)
def onClick():
self.content.setCurrentIndex(contentIndex)
menu.onClick()
menuButton.clicked.connect(onClick)
def createSidebar(self):
self.menuStack = QStackedWidget()
sidebar = QWidget()
sidebarLayout = QVBoxLayout()
sidebar.setLayout(sidebarLayout)
sidebar.setSizePolicy(
QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum))
#layout.setColumnStretch(1, 4)
#layout.setColumnStretch(2, 4)
self.sidebarLayout = sidebarLayout
self.sidebar = sidebar
def createContent(self):
self.content = QStackedWidget()
self.content.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding))
class View:
"""View of the main application. Creates the GUI and abstracts some common
behaviour around the screen elements.
"""
def __init__(self, control):
"""Sets a given control and creates the screen elements.
:param control: The control to this view (implementing application logic).
"""
self.control = control
self.__initializeWindow(control.name)
def open(self):
"""Show the application window.
"""
self.window.show()
@closingTagging
def setNull(self):
"""Abstraction around setting the null view as the current widget.
"""
self.nullView.open()
self.views.setCurrentWidget(self.nullView)
@closingTagging
def setTagging(self):
"""Abstraction around setting the tagging view as the current widget.
"""
preprocessing = Preprocessing(self.control)
self.taggingControl.open(preprocessing)
self.views.setCurrentWidget(self.taggingView)
def refreshTagging(self):
"""Abstraction around refreshing the tagging control.
"""
self.taggingControl.refresh()
def closeTagging(self):
"""Abstraction around closing the tagging control.
:raises UserCancel: Raised if the user aborts the closing process.
"""
self.taggingControl.close()
def __initializeWindow(self, name):
"""Create the main window.
"""
self.window = QMainWindow()
self.window.setWindowTitle(name)
self.window.setMinimumWidth(800)
self.window.setMinimumHeight(600)
self.window.closeEvent = self.control.closeEvent
self.__initializeIcon()
self.__initializeMenu()
self.__initializeShortcuts()
self.__initializeCentralWidget()
def __initializeIcon(self):
"""Sets an icon to the window.
"""
path = os.path.dirname(os.path.realpath(__file__))
iconObject = QIcon(path + os.path.sep + "icons/ToyIcon.bmp")
self.window.setWindowIcon(iconObject)
def __initializeCentralWidget(self):
"""Create the central widget of the window, which is a stacked widget
with which one can switch between different views. Creates two views:
One for the null screen and one for the tagging screen.
"""
self.views = QStackedWidget()
self.taggingControl = TaggingControl(self, self.control.settings)
self.taggingView = TaggingView(self, self.taggingControl,
self.control.settings)
self.taggingControl.view = self.taggingView
self.nullView = NullView(self)
self.views.addWidget(self.taggingView)
self.views.addWidget(self.nullView)
self.window.setCentralWidget(self.views)
def __initializeMenu(self):
"""Builds the menu bar and connects the handler-methods of the control
to the respective events.
"""
applicationMenuBar = self.window.menuBar()
fileMenu = applicationMenuBar.addMenu('File')
openFile = QAction('Open', self.window)
openFile.triggered.connect(self.control.onOpenFile)
fileMenu.addAction(openFile)
self.saveFile = QAction('Save', self.window)
fileMenu.addAction(self.saveFile)
self.clearFile = QAction('Clear', self.window)
self.clearFile.triggered.connect(self.control.onClearFile)
fileMenu.addAction(self.clearFile)
self.reloadFile = QAction('Reload', self.window)
self.reloadFile.triggered.connect(self.control.onReloadFile)
fileMenu.addAction(self.reloadFile)
userMenu = applicationMenuBar.addMenu('User')
settings = QAction('Settings', self.window)
settings.triggered.connect(self.control.settings.asDialog)
userMenu.addAction(settings)
def __initializeShortcuts(self):
"""Registers keyboard shortcuts for the most common functionality.
"""
openFile = QShortcut(QKeySequence("Ctrl+O"), self.window)
openFile.activated.connect(self.control.onOpenFile)
openSettings = QShortcut(QKeySequence("Ctrl+Q"), self.window)
openSettings.activated.connect(self.control.settings.asDialog)
openSettings = QShortcut(QKeySequence("Ctrl+R"), self.window)
openSettings.activated.connect(self.control.onReloadFile)
class CollapsibleTabWidget(QWidget):
Horizontal = 0
Vertical = 1
doCollapse = pyqtSignal()
def __init__(self, orientation=0, parent=None):
super(CollapsibleTabWidget, self).__init__(parent=parent)
self.frameLayout = None
self.verticalLayout = None
self.tabBar = None
self.tabBarWidget = QWidget(self)
self.orientation = orientation
# self.orientation = self.Vertical
self.splitter = None
self.splitterPos = None
self.splitterLower = None
self.stackTitle = None
self.stackWidget = None
self.tabBarList = []
# local data
if self.orientation == self.Horizontal:
self.initHorizontalUI()
self.titleBarIcon = TitleBar.down
elif self.orientation == self.Vertical:
self.initVerticalUI()
self.titleBarIcon = TitleBar.left
self.tabBarWidget.setStyleSheet('background-color: #B2B2B2;')
self.stackTitle.setStyleSheet('background-color: #B2B2B2;')
def initHorizontalUI(self):
self.frameLayout = QVBoxLayout(self)
self.tabBar = QHBoxLayout(self)
self.tabBarWidget.setLayout(self.tabBar)
self.tabBar.setAlignment(Qt.AlignLeft)
self.verticalLayout = QVBoxLayout(self)
# fill stack
self.stackTitle = QStackedWidget(self)
self.stackWidget = QStackedWidget(self)
self.verticalLayout.addWidget(self.stackTitle)
self.verticalLayout.addWidget(self.stackWidget)
# finish
self.frameLayout.addLayout(self.verticalLayout)
self.frameLayout.addWidget(self.tabBarWidget)
self.setLayout(self.frameLayout)
self.tabBarWidget.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Maximum)
def initVerticalUI(self):
self.frameLayout = QHBoxLayout(self)
self.verticalLayout = QVBoxLayout(self)
# tab bar
self.tabBar = QVBoxLayout(self)
self.tabBarWidget.setLayout(self.tabBar)
self.tabBar.setAlignment(Qt.AlignTop)
# fill stack
self.stackTitle = QStackedWidget(self)
self.stackWidget = QStackedWidget(self)
self.verticalLayout.addWidget(self.stackTitle)
self.verticalLayout.addWidget(self.stackWidget)
self.stackWidget.addWidget(QLabel('asdf', self))
# finish
self.frameLayout.addWidget(self.tabBarWidget)
self.frameLayout.addLayout(self.verticalLayout)
self.setLayout(self.frameLayout)
self.tabBarWidget.setSizePolicy(QSizePolicy.Maximum,
QSizePolicy.Expanding)
def setOrientation(self, orient):
self.orientation = orient
def onTabClicked(self, index):
pass
def addTab(self, widget: QWidget, title: str):
titleBar = TitleBar(title, self)
titleBar.setButtonOrient(self.titleBarIcon)
titleBar.CollapseButton.clicked.connect(self.collapseStacks)
self.stackTitle.addWidget(titleBar)
self.stackWidget.addWidget(widget)
tabButton = customPushButton(title, len(self.tabBarList),
self.orientation, self)
self.tabBarList.append(tabButton)
tabButton.clicked.connect(self.collapseStacks)
tabButton.clicked_index.connect(self.setCurStack)
self.tabBar.addWidget(tabButton, 0, Qt.AlignLeft)
self.stackTitle.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.stackTitle.setFixedHeight(titleBar.Height)
def collapseStacks(self):
if self.stackWidget.isVisible():
self.splitterPos = self.splitter.sizes()
self.stackTitle.hide()
self.stackWidget.hide()
if self.orientation == self.Horizontal:
self.splitter.setSizes([10000, 0])
if self.orientation == self.Vertical:
self.splitter.setSizes([0, 10000])
self.splitter.handle(1).setDisabled(True)
else:
self.splitter.setSizes(self.splitterPos)
self.stackTitle.show()
self.stackWidget.show()
self.splitter.handle(1).setDisabled(False)
self.doCollapse.emit()
def setCurStack(self, index):
self.stackTitle.setCurrentIndex(index)
self.stackWidget.setCurrentIndex(index)
def setSplitter(self, splitter: QSplitter):
self.splitter = splitter
self.splitter.splitterMoved.connect(self.setSplitterRate)
def setSplitterRate(self, pos, index):
self.splitterLower = self.splitter.sizes()[1]
class MainWindow(QtWidgets.QMainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.label3 = QtWidgets.QLabel()
self.label3.setGeometry(QtCore.QRect(10, 210, 500, 23))
self.label3.setObjectName("label3")
self.btn_Action = QtWidgets.QPushButton()
self.btn_Action.setGeometry(QtCore.QRect(220, 200, 75, 23))
self.btn_Action.setObjectName("btn_Action")
self.gridLayout3 = QtWidgets.QGridLayout()
self.gridLayout3.addWidget(self.label3, 0, 3, 7, 8)
self.gridLayout3.addWidget(self.btn_Action, 0, 3, 3, 3)
self.btn_Action.setText("View Chart")
self.label3.setText('File Uploaded, check console for its contents')
self.stacked_widget = QStackedWidget()
self.stacked_widget.currentChanged.connect(self.set_button_state)
self.btn_Action.clicked.connect(self.next_page)
widget = QtWidgets.QWidget()
self.setCentralWidget(widget)
hbox = QHBoxLayout()
hbox.addStretch(1)
hbox.addWidget(self.btn_Action)
vbox = QVBoxLayout()
vbox.addWidget(self.stacked_widget)
vbox.addLayout(hbox)
#add the to the main window
self.toolbar = QToolBar("Edit", self)
h = HomeScreen(self)
h.pushButton.clicked.connect(self.file_open)
self.insert_page(h.centralwidget)
self.addToolBar(self.toolbar)
#start with the toolbar hidden
self.toolbar.toggleViewAction().setChecked(True)
self.toolbar.toggleViewAction().trigger()
# create main layout
widget.setLayout(vbox)
def file_open(self):
name, _ = QtWidgets.QFileDialog.getOpenFileName(
None,
'Open File',
options=QtWidgets.QFileDialog.DontUseNativeDialog)
classObj = FileOpen.openFile(name)
#print(classObj)
#chart = Chart('pie1', classObj, self)
#self.insert_page(chart.chartview)
navigation = Navigation(classObj, self)
#self.addToolBar(navigation.toolbar)
self.insert_page(navigation.horizontalGroupBox)
#chart = Chart('pie1', classObj, self)
'''name, _ = QtWidgets.QFileDialog.getOpenFileName(None, 'Open File', options=QtWidgets.QFileDialog.DontUseNativeDialog)
file = open(name, 'r')
with file as json_file:
text = json.load(json_file)
#self.label3.setText('File Uploaded, check console for its contents')
#chart = Chart('Alloys', text, self)
#self.insert_page(chart.chartview)
navigation = Navigation(text, self)
self.addToolBar(navigation.toolbar)
self.insert_page(navigation.horizontalGroupBox)'''
def set_button_state(self, index):
#self.prev_button.setEnabled(index > 0)
n_pages = len(self.stacked_widget)
self.btn_Action.setEnabled(index % n_pages < n_pages - 1)
def insert_page(self, widget, index=-1):
self.stacked_widget.insertWidget(index, widget)
self.set_button_state(self.stacked_widget.currentIndex())
def next_page(self):
new_index = self.stacked_widget.currentIndex() + 1
if new_index < len(self.stacked_widget):
self.stacked_widget.setCurrentIndex(new_index)
self.toolbar.toggleViewAction().trigger()
def initUI(self):
# -- Windows Title Bar --
self.setWindowTitle('Security-HQ') # 윈도우 타이틀
# -- Status Bar --
self.statusBar().showMessage('Ready') #상태바 인스턴스 생성 및 표시
self.statusBar().showMessage(
self.date.toString(Qt.DefaultLocaleLongDate)) # 현재 날짜 표시
# -- Menu Bar --
# 메뉴바 엑션 설정 및 메뉴 명칭, 단축,
# 종료 action
exitAction = QAction(QIcon('icon/exit.png'), 'Exit',
self) # 아이콘표시, Exit 표시
exitAction.setShortcut('Ctrl+Q') # 단축키
exitAction.setStatusTip('Exit Application') # 상태바 표시
exitAction.triggered.connect(
qApp.quit) # 어플리케이션 종료설정 QApplication quit()
# 종료 action
saveAction = QAction(QIcon('icon/save.png'), 'Save',
self) # 아이콘표시, Exit 표시
saveAction.setShortcut('Ctrl+S') # 단축키
saveAction.setStatusTip('Save Application') # 상태바 표시
# saveAction.triggered.connect(self.showDialog4) #
# 종료 action
editAction = QAction(QIcon('icon/edit.png'), 'Edit',
self) # 아이콘표시, Exit 표시
editAction.setShortcut('Ctrl+E') # 단축키
editAction.setStatusTip('Edit Application') # 상태바 표시
editAction.triggered.connect(
qApp.quit) # 어플리케이션 종료설정 QApplication quit()
# 종료 action
printAction = QAction(QIcon('icon/print.png'), 'Print',
self) # 아이콘표시, Exit 표시
printAction.setShortcut('Ctrl+P') # 단축키
printAction.setStatusTip('Print Application') # 상태바 표시
printAction.triggered.connect(
qApp.quit) # 어플리케이션 종료설정 QApplication quit()
menubar = self.menuBar() # 메뉴 인스턴스 생성
menubar.setNativeMenuBar(False) # Mac 에서도 윈도우와 동일한 결과 나오게 하기위해
# -- 파일메뉴 최초
fileMenu = menubar.addMenu('&파일') # 메뉴 인스턴스에 실제 메뉴 추가
# -- 편집메뉴 최초
editMenu = menubar.addMenu('&편집') # 메뉴 인스턴스에 실제 메뉴 추가
# -- 파일메뉴 하위
fileMenu.addAction(saveAction) # 정의된 하위 메뉴 추가
fileMenu.addAction(printAction) # 정의된 하위 메뉴 추가
fileMenu.addAction(exitAction) # 정의된 하위 메뉴 추가
# -- 편집메뉴 하위
editMenu.addAction(editAction)
# -- Tool Bar --
# 파일 툴바
self.fileToolbar = self.addToolBar('Exit')
self.fileToolbar.addAction(exitAction)
self.fileToolbar.addAction(saveAction)
self.fileToolbar.addAction(printAction)
#편집 툴바
self.editToolbar = self.addToolBar('Edit')
self.editToolbar.addAction(editAction)
self.combo = QComboBox(self)
self.combo.addItem("Item 1")
self.combo.addItem("Item 2")
self.combo.addItem("Item 3")
# self.combo.currentIndexChanged.connect(self.setSomething)
self.fileToolbar.addWidget(self.combo)
self.combo.setMinimumSize(self.combo.sizeHint().width(),
self.fileToolbar.iconSize().height())
self.fileToolbar.setAllowedAreas(Qt.TopToolBarArea
| Qt.BottomToolBarArea)
dockWidgetLeft = QWidget()
dockWidgetRight = QWidget()
dockWidgetBottom = QWidget()
dockWidgetTree = QTreeWidget()
self.dockWidget = QDockWidget("메뉴")
self.dockWidget.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
self.dockWidget.setObjectName("dockWidget")
self.dockWidget.setFeatures(QDockWidget.DockWidgetClosable
| QDockWidget.DockWidgetMovable)
self.dockWidgetContents = QWidget()
self.dockWidgetContents.setObjectName("dockWidgetContents")
self.treeWidget = QTreeWidget(self.dockWidgetContents)
self.treeWidget.setObjectName("verticalLayout")
self.treeWidget.headerItem().setText(0, "1")
self.treeWidget.header().setVisible(False)
self.treeWidget.setAlternatingRowColors(True)
for i in range(3):
parent = QTreeWidgetItem(self.treeWidget)
parent.setText(0, "Parent {}".format(i))
# parent.setFlags(parent.flags() | Qt.ItemIsTristate | Qt.ItemIsUserCheckable)
parent.setFlags(parent.flags())
for x in range(5):
child = QTreeWidgetItem(parent)
# child.setFlags(child.flags() | Qt.ItemIsUserCheckable)
child.setFlags(child.flags())
child.setText(0, "Child {}".format(x))
# child.setCheckState(0, Qt.Unchecked)
# self.treeWidget.itemClicked.connect(self.login)
self.verticalLayout = QVBoxLayout(self.dockWidgetContents)
self.verticalLayout.setContentsMargins(4, 4, 4, 4)
self.verticalLayout.setObjectName("verticalLayout")
self.verticalLayout.addWidget(self.treeWidget)
self.dockWidget.setWidget(self.dockWidgetContents)
self.addDockWidget(Qt.LeftDockWidgetArea, self.dockWidget)
self.dockingWidgetLeft = QDockWidget("Icon panel") # 타이틀 설정
self.dockingWidgetLeft.setObjectName("IconPanel")
self.dockingWidgetLeft.setWidget(dockWidgetLeft) # 래핑할 위젯 설정
self.dockingWidgetLeft.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
self.dockingWidgetLeft.setFloating(True)
self.dockingWidgetLeft.widget().setMinimumSize(QSize(80, 150))
self.addDockWidget(Qt.LeftDockWidgetArea,
self.dockingWidgetLeft) # 초기 위치 및 도킹위젯을 메인윈도의
self.dockingWidgetRight = QDockWidget("속성 창") # 타이틀 설정
self.dockingWidgetRight.setObjectName("IconPanel")
self.dockingWidgetRight.setWidget(dockWidgetRight) # 래핑할 위젯 설정
self.dockingWidgetRight.setAllowedAreas(Qt.RightDockWidgetArea)
self.dockingWidgetRight.setFloating(True)
self.dockingWidgetRight.widget().setMinimumSize(QSize(200, 200))
self.addDockWidget(Qt.RightDockWidgetArea,
self.dockingWidgetRight) # 초기 위치 및 도킹위젯을 메인윈도의
self.dockingWidgetBottom = QDockWidget("알람 콘솔") # 타이틀 설정
self.dockingWidgetBottom.setObjectName("IconPanel")
self.dockingWidgetBottom.setWidget(dockWidgetBottom) # 래핑할 위젯 설정
self.dockingWidgetBottom.setAllowedAreas(Qt.BottomDockWidgetArea)
self.dockingWidgetBottom.setFloating(True)
self.dockingWidgetBottom.widget().setMinimumSize(QSize(80, 60))
self.addDockWidget(Qt.BottomDockWidgetArea,
self.dockingWidgetBottom) # 초기 위치 및 도킹위젯을 메인윈도의
self.central_widget = QStackedWidget()
self.setCentralWidget(self.central_widget)
# Dashboard = DashBoardWidget(self)
# Dashboard.button.clicked.connect(self.login2)
# self.central_widget.addWidget(Dashboard)
# self.setDockOptions(self.AnimatedDocks | self.AllowNestedDocks)
self.statusBar()
# 윈도우 표시 정의
self.setGeometry(0, 0, 1024, 768) # 윈도우 위치 및 크기
self.center() #위도우 위치를 중앙에 이동시킴
self.show() #보여줌
class MainWindow(QWidget):
toLock = 0
def __init__(self, btnChecker):
super().__init__()
self.setWindowTitle('Modedoor Kiosk 30.10')
self.showFullScreen()
self.isLocked = 0
label = QLabel()
labelPixmap = QPixmap('../resources/SAFEBANNER.png')
label.setPixmap(labelPixmap)
label.setAlignment(Qt.AlignCenter)
# Optional, resize window to image size
self.resize(labelPixmap.width(), labelPixmap.height())
self.settingsButton = modules.buttonizer.Buttonizer(
"Settings", 150, 110, True, Icons.settingsIcon, 50, 50)
self.doorButton = modules.buttonizer.Buttonizer(
"Control", 150, 110, True, Icons.doorIcon, 50, 50)
self.lockButton = modules.buttonizer.Buttonizer(
"UnLocked", 170, 110, True, Icons.lockIcon, 100, 50)
self.controlStack = QWidget()
self.settingStack = QWidget()
self.lockStack = QWidget()
self.settingStackUI()
self.controlStackUI(btnChecker)
self.lockStackUI()
self.Stack = QStackedWidget(self)
self.Stack.addWidget(self.controlStack)
self.Stack.addWidget(self.settingStack)
self.Stack.addWidget(self.lockStack)
hbox = QHBoxLayout()
hbox.setSpacing(0.5)
hbox.addWidget(self.doorButton)
hbox.addWidget(self.lockButton)
hbox.addWidget(self.settingsButton)
vbox = QVBoxLayout()
vbox.addSpacing(2)
vbox.addLayout(hbox)
vbox.addWidget(self.Stack)
vbox.addWidget(label)
self.settingsButton.clicked.connect(partial(self.display, 1))
self.doorButton.clicked.connect(partial(self.display, 0))
self.lockButton.clicked.connect(partial(self.display, 2))
self.setLayout(vbox)
self.setGeometry(0, 0, 1024, 600)
self.show()
def controlStackUI(self, btnChecker):
grid = QGridLayout()
MainWindow.openButton = modules.buttonizer.Buttonizer(
"", 140, 140, False, Icons.openIcon, 140, 140)
MainWindow.halfOpen = modules.buttonizer.Buttonizer(
"", 140, 140, False, Icons.halfOpenIcon, 140, 140)
MainWindow.halfClose = modules.buttonizer.Buttonizer(
"", 140, 140, False, Icons.halfCloseIcon, 140, 140)
MainWindow.closeButton = modules.buttonizer.Buttonizer(
"", 140, 140, False, Icons.closeIcon, 140, 140)
MainWindow.stopButton = modules.buttonizer.Buttonizer(
"", 140, 140, False, Icons.stopIcon, 140, 140)
MainWindow.openButton.clicked.connect(
partial(btnChecker.check, MainWindow.openButton, "openButton"))
MainWindow.closeButton.clicked.connect(
partial(btnChecker.check, MainWindow.closeButton, "closeButton"))
MainWindow.stopButton.clicked.connect(
partial(btnChecker.check, MainWindow.stopButton, "stopButton"))
grid.addWidget(MainWindow.openButton, 1, 0)
grid.addWidget(MainWindow.closeButton, 1, 1)
grid.addWidget(MainWindow.stopButton, 1, 2)
grid.addWidget(MainWindow.halfOpen, 1, 3)
grid.addWidget(MainWindow.halfClose, 1, 4)
oImage = QImage("../resources/background.png")
sImage = oImage.scaled(QSize(700, 500)) # resize Image to widgets size
palette = QPalette()
palette.setBrush(10, QBrush(sImage)) # 10 = Windowrole
self.setPalette(palette)
self.controlStack.setLayout(grid)
def settingStackUI(self):
layout = QVBoxLayout(self)
topVlayout = QVBoxLayout()
topVlayout.setSpacing(0)
self.labelMin = QLabel()
self.labelHour = QLabel()
self.labelMin.setText("57")
self.labelHour.setText("19")
self.labelMin.setStyleSheet("color:black;font-size:34px")
self.labelHour.setStyleSheet("color:black;font-size:34px")
self.labelMin.setFixedSize(100, 100)
self.labelHour.setFixedSize(100, 100)
labelTag = QLabel("SET HOUR")
labelTag.setStyleSheet("color:black;font-size:34px")
labelTag2 = QLabel(":")
labelTag2.setStyleSheet("color:black;font-size:34px")
labelTag2.setFixedSize(100, 100)
labelTag1 = QLabel("SET MINUTE:")
labelTag1.setStyleSheet("color:black;font-size:34px")
sliderMin = QSlider(Qt.Horizontal)
sliderMin.setValue(15)
sliderMin.setTickInterval(1)
sliderMin.setMaximum(59)
sliderMin.setMinimum(00)
sliderMin.setFixedSize(500, 90)
sliderMin.valueChanged.connect(self.updateMin)
sliderMin.setStyleSheet("color:white")
sliderHour = QSlider(Qt.Horizontal)
sliderHour.setValue(15)
sliderHour.setMaximum(23)
sliderHour.setMinimum(00)
sliderHour.setFixedSize(500, 90)
sliderHour.valueChanged.connect(self.updateHour)
sliderHour.setStyleSheet("color:white")
layoutH = QHBoxLayout()
layoutH1 = QHBoxLayout()
layoutH2 = QHBoxLayout()
layoutV = QVBoxLayout()
layoutH2.addWidget(self.labelHour)
layoutH2.addWidget(labelTag2)
layoutH2.addWidget(self.labelMin)
layoutH.addWidget(labelTag)
layoutH.addWidget(sliderHour)
layoutH1.addWidget(labelTag1)
layoutH1.addWidget(sliderMin)
layoutV.addLayout(layoutH2)
layoutV.addLayout(layoutH1)
layoutV.addLayout(layoutH)
numpad = QGridLayout()
save = QPushButton("Save")
numpad_layout = QVBoxLayout()
numpad.setSpacing(5)
numpad.setAlignment(Qt.AlignLeft)
number1 = QPushButton('1')
number2 = QPushButton('2')
number3 = QPushButton('3')
number4 = QPushButton('4')
number5 = QPushButton('5')
number6 = QPushButton('6')
number7 = QPushButton('7')
number8 = QPushButton('8')
number9 = QPushButton('9')
number1.setFixedSize(100, 100)
number2.setFixedSize(100, 100)
number3.setFixedSize(100, 100)
number4.setFixedSize(100, 100)
number5.setFixedSize(100, 100)
number6.setFixedSize(100, 100)
number7.setFixedSize(100, 100)
number8.setFixedSize(100, 100)
number9.setFixedSize(100, 100)
numpad.addWidget(number1, 0, 0)
numpad.addWidget(number2, 0, 1)
numpad.addWidget(number3, 0, 2)
numpad.addWidget(number4, 1, 0)
numpad.addWidget(number5, 1, 1)
numpad.addWidget(number6, 1, 2)
numpad.addWidget(number7, 2, 0)
numpad.addWidget(number8, 2, 1)
numpad.addWidget(number9, 2, 2)
numpad_layout.addLayout(numpad)
numpad_layout.addWidget(save)
self.tabs = QTabWidget()
self.tab1 = QWidget()
self.tab2 = QWidget()
# Add tabs
self.tabs.addTab(self.tab1, "Time")
self.tabs.addTab(self.tab2, "Password")
# Create first tab
self.tab1.setLayout(layoutV)
self.tab2.setLayout(numpad_layout)
# Add tabs to widget
layout.addWidget(self.tabs)
self.settingStack.setLayout(layout)
def lockStackUI(self):
pass
def lockUnlock(self, toLock):
try:
f = open('password.txt', 'r')
except:
lay = QHBoxLayout()
lay.setAlignment(Qt.AlignCenter)
warn = QLabel(
"YOU HAVE TO SPECIFY PASSWORD TO LOCK!.\n \t GO TO SETTINGS"
)
warn.setStyleSheet("color:red;font-size:30px")
lay.addWidget(warn)
self.lockStack.setLayout(lay)
else:
if toLock == 0:
self.settingsButton.setHidden(True)
self.doorButton.setHidden(True)
MainWindow.toLock = 1
self.lockButton.setIcon(Icons.lockIcon1)
else:
self.settingsButton.setHidden(False)
self.doorButton.setHidden(False)
self.Stack.setCurrentIndex(0)
self.lockButton.setText("Unlocked")
self.lockButton.setIcon(Icons.lockIcon)
MainWindow.toLock = 0
def display(self, i):
self.Stack.setCurrentIndex(i)
if i == 1:
self.settingsButton.setIcon(Icons.settingsIcon1)
self.doorButton.setIcon(Icons.doorIcon)
self.lockButton.setIcon(Icons.lockIcon)
elif i == 0:
self.settingsButton.setIcon(Icons.settingsIcon)
self.doorButton.setIcon(Icons.doorIcon1)
self.lockButton.setIcon(Icons.lockIcon)
elif i == 2:
self.settingsButton.setIcon(Icons.settingsIcon)
self.doorButton.setIcon(Icons.doorIcon)
self.lockUnlock(MainWindow.toLock)
def updateMin(self, min):
min = str(min)
min = min.zfill(2)
self.labelMin.setText(min)
def updateHour(self, hour):
print(hour)
event = str(hour)
event = event.zfill(2)
self.labelHour.setText(event)
@staticmethod
def numLen(num):
return len(str(abs(num)))
class MainWindow(QMainWindow):
screen = None
width, height = None, None
picture = None
login_form = None
user_page = None
pages = None
def __init__(self):
super().__init__()
if sys.platform != 'linux':
my_app_id = 'InnoUI.DMD_project.ez_A_for_course.101' # arbitrary string
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(
my_app_id)
self.setWindowIcon(QIcon("./images/main_logo.png"))
size = QDesktopWidget().screenGeometry(-1)
self.width = size.width() // 5
self.picture = QPixmap("./images/main_logo.png").scaledToWidth(
self.width - self.width // 20)
self.height = self.picture.height() + size.height() // 16
self.setFixedSize(self.width, self.height)
self.setWindowTitle('DmD2')
self.pages = QStackedWidget()
qr = self.frameGeometry()
center = QDesktopWidget().availableGeometry().center()
qr.moveCenter(center)
self.move(qr.topLeft())
self.init_ui()
def login(self, login, password):
try:
backend.login(login, password)
except AssertionError as exception:
QToolTip.showText(
self.mapToGlobal(self.login_form.geometry().center()),
'Invalid credentials')
return
self.user_page = levels[backend.user.user_info['role']](self,
backend.user)
self.pages.addWidget(self.user_page)
self.pages.setCurrentWidget(self.user_page)
self.repaint()
self.setMaximumSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX)
self.resize(self.width * 2, self.height * 2)
qr = self.frameGeometry()
center = QDesktopWidget().availableGeometry().center()
qr.moveCenter(center)
self.move(qr.topLeft())
def logout(self):
backend.logout()
self.pages.setCurrentWidget(self.login_form)
self.repaint()
self.setFixedSize(self.width, self.height)
qr = self.frameGeometry()
center = QDesktopWidget().availableGeometry().center()
qr.moveCenter(center)
self.move(qr.topLeft())
self.pages.removeWidget(self.user_page)
def init_ui(self):
self.login_form = LoginForm(self.width, self.height, self.picture)
self.user_page = BasePage(self)
self.pages.addWidget(self.login_form)
self.pages.setCurrentWidget(self.login_form)
self.setCentralWidget(self.pages)
self.login_form.button.clicked.connect(
lambda: self.login(self.login_form.login_field.text(),
self.login_form.password_field.text()))
self.show()
class MainWindow(QWidget):
def __init__(self, title="Raven"):
super().__init__()
# self.window_width = 350
# self.window_height = 600
# self.setFixedSize(self.window_width, self.window_height)
self.showMaximized()
self.setWindowTitle(title)
self.init_ui()
def init_ui(self):
bottom_bar = BottomWidget(self)
bottom_bar.home_click_listener.connect(self.on_home_click)
bottom_bar.logout_click_listener.connect(self.on_logout_click)
self.fragment = QStackedWidget()
layout = QVBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
layout.addWidget(self.fragment)
bottom_bar.on_back_press_listener.connect(self.on_back_press)
layout.addWidget(bottom_bar)
self.setLayout(layout)
# self.add_screen(LoginWidget("Login Screen"))
# self.add_screen(CameraWidget())
self.add_screen(AttendenceOptionWidget())
def add_screen(self, screen: base_widget):
screen.add_screen_listener.connect(self.add_screen)
screen.on_back_press_listener.connect(self.on_back_press)
self.fragment.addWidget(screen)
self.fragment.setCurrentIndex(self.fragment.count() - 1)
self.updateUi()
def on_back_press(self):
if self.fragment.count() > 1:
widget = self.fragment.currentWidget()
self.fragment.removeWidget(widget)
widget.deleteLater()
self.updateUi()
def updateUi(self):
widget: base_widget = self.fragment.currentWidget()
self.setWindowTitle(widget.title)
def on_home_click(self):
self.remove_all_screen()
def remove_all_screen(self):
while self.fragment.count() > 1:
widget = self.fragment.currentWidget()
self.fragment.removeWidget(widget)
widget.deleteLater()
self.updateUi()
def on_logout_click(self):
print("On Logout Click")
class Multitool(QMainWindow, QWidget):
def __init__(self):
super(Multitool, self).__init__()
self.statusbar = self.statusBar()
self.statusBar().showMessage('Ready')
self.trayActions()
self.trayMenu()
self.trayIcon.setIcon(QIcon('icons/biohazard.svg'))
self.trayIcon.show()
self.stack1 = QWidget() # Mouse Clicker
self.stack2 = QWidget() # Screenshot
self.stack3 = QWidget() # Player
self.stack4 = QWidget() # Calculator
self.stack5 = QWidget() # Camera
self.stack6 = QWidget() # Tetrix
self.stack1UI() # Mouse Clicker
self.stack2UI() # Screenshot
self.stack3UI() # Player
self.stack4UI() # Calculator
self.stack5UI() # Camera
self.stack6UI() # Tetrix
self.Stack = QStackedWidget(self)
self.Stack.addWidget(self.stack1) # Mouse Clicker
self.Stack.addWidget(self.stack2) # Screenshot
self.Stack.addWidget(self.stack3) # Player
self.Stack.addWidget(self.stack4) # Calculator
self.Stack.addWidget(self.stack5) # Camera
self.Stack.addWidget(self.stack6) # Tetrix
# General actions starts -------------------------------------
exitAction = QAction(QIcon('icons/exit.png'), '&Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(QApplication.instance().quit)
newMultitoolAction = QAction(QIcon('icons/new.png'), '&New Multitool',
self)
newMultitoolAction.setShortcut('Ctrl+N')
newMultitoolAction.setStatusTip('New Multitool')
newMultitoolAction.triggered.connect(self.newMultitoolWindow)
aboutAction = QAction(QIcon('icons/biohazard.svg'), 'About', self)
aboutAction.setStatusTip('About')
aboutAction.triggered.connect(self.about)
viewStatAction = QAction('View statusbar', self, checkable=True)
viewStatAction.setStatusTip('View statusbar')
viewStatAction.setChecked(True)
viewStatAction.triggered.connect(self.toggleStatBar)
viewToolbarAction = QAction('View toolbar', self, checkable=True)
viewToolbarAction.setStatusTip('View toolbar')
viewToolbarAction.setChecked(True)
viewToolbarAction.triggered.connect(self.toggleToolBar)
minimizeToTrayAction = QAction('Minimize to Tray',
self,
checkable=True)
minimizeToTrayAction.setStatusTip('Minimize to Tray')
minimizeToTrayAction.setChecked(False)
minimizeToTrayAction.triggered.connect(self.minimizeToTray)
# General actions ends ---------------------------------------
# Widgets actions starts -------------------------------------
mouseClickerAction = QAction(QIcon('icons/mouse.png'), 'Mouse Clicker',
self)
mouseClickerAction.setStatusTip('Mouse Clicker')
mouseClickerAction.triggered.connect(lambda: self.display(0))
screeenShotAction = QAction(QIcon('icons/screenshot.png'),
'ScreenShot', self)
screeenShotAction.setStatusTip('ScreenShot')
screeenShotAction.triggered.connect(lambda: self.display(1))
playerAction = QAction(QIcon('icons/player.jpeg'), 'Player', self)
playerAction.setStatusTip('Player')
playerAction.triggered.connect(lambda: self.display(2))
calculatorAction = QAction(QIcon('icons/calc.ico'), 'Calculator', self)
calculatorAction.setStatusTip('Calculator')
calculatorAction.triggered.connect(lambda: self.display(3))
cameraAction = QAction(QIcon('icons/camera.jpeg'), 'Camera', self)
cameraAction.setStatusTip('Camera')
cameraAction.triggered.connect(lambda: self.display(4))
tetrixAction = QAction(QIcon('icons/tetrix.png'), 'Tetrix', self)
tetrixAction.setStatusTip('Tetrix')
tetrixAction.triggered.connect(lambda: self.display(5))
# Widget actions ends ----------------------------------------
# Menu bar creation starts -----------------------------------
menubar = self.menuBar()
fileMenu = menubar.addMenu('&File')
fileMenu.addAction(newMultitoolAction)
fileMenu.addAction(exitAction)
viewMenu = menubar.addMenu('View')
viewMenu.addAction(viewStatAction)
viewMenu.addAction(viewToolbarAction)
viewMenu.addAction(minimizeToTrayAction)
viewMenuWidget = QMenu('List widget', self)
viewMenuWidget.addAction(mouseClickerAction)
viewMenuWidget.addAction(screeenShotAction)
viewMenuWidget.addAction(playerAction)
viewMenuWidget.addAction(calculatorAction)
viewMenuWidget.addAction(cameraAction)
viewMenu.addMenu(viewMenuWidget)
gamesMenu = menubar.addMenu('&Games')
gamesMenu.addAction(tetrixAction)
helpMenu = menubar.addMenu('&Help')
helpMenu.addAction(aboutAction)
# Menu bar creation ends -------------------------------------
# Toolbar creation starts -------------------------------------
self.toolbar1 = self.addToolBar('File')
self.toolbar1.addAction(newMultitoolAction)
self.toolbar2 = self.addToolBar('Widgets')
self.toolbar2.addAction(mouseClickerAction)
self.toolbar2.addAction(screeenShotAction)
self.toolbar2.addAction(playerAction)
self.toolbar2.addAction(calculatorAction)
self.toolbar2.addAction(cameraAction)
self.toolbar3 = self.addToolBar('Games')
self.toolbar3.addAction(tetrixAction)
self.toolbar4 = self.addToolBar('Exit')
self.toolbar4.addAction(exitAction)
# Toolbar creation ends -------------------------------------
self.setCentralWidget(self.Stack)
self.setGeometry(300, 300, 700, 400)
self.setWindowTitle('Multitool')
self.setWindowIcon(QIcon('icons/biohazard.svg'))
self.show()
def toggleStatBar(self, state):
if state:
self.statusbar.show()
else:
self.statusbar.hide()
def toggleToolBar(self, state):
if state:
self.toolbar1.show()
self.toolbar2.show()
self.toolbar3.show()
self.toolbar4.show()
else:
self.toolbar1.hide()
self.toolbar2.hide()
self.toolbar3.hide()
self.toolbar4.hide()
def minimizeToTray(self, state):
if state:
self.hide()
self.trayIcon.showMessage("Tray Program",
"Application was minimized to tray",
QSystemTrayIcon.Information, 2000)
def newMultitoolWindow(self):
self.__init__()
self.setGeometry(350, 350, 700, 400)
# Stacked widgets added to layout start----------------------
def stack1UI(self):
self.layout = QHBoxLayout()
self.layout.addWidget(MouseClicker())
self.stack1.setLayout(self.layout)
def stack2UI(self):
self.layout = QHBoxLayout()
self.layout.addWidget(Screenshot())
self.stack2.setLayout(self.layout)
def stack3UI(self):
self.layout = QHBoxLayout()
self.layout.addWidget(Player(sys.argv[1:]))
self.stack3.setLayout(self.layout)
def stack4UI(self):
self.layout = QHBoxLayout()
self.layout.addWidget(Calculator())
self.stack4.setLayout(self.layout)
def stack5UI(self):
self.layout = QHBoxLayout()
self.layout.addWidget(Camera())
self.stack5.setLayout(self.layout)
def stack6UI(self):
self.layout = QHBoxLayout()
self.layout.addWidget(TetrixWindow())
self.stack6.setLayout(self.layout)
def display(self, i):
self.Stack.setCurrentIndex(i)
# Stacked widgets added to layout end------------------------
def trayActions(self):
self.minimizeAction = QAction(QIcon('icons/minimize.png'),
"Mi&nimize",
self,
triggered=self.hide)
self.maximizeAction = QAction(QIcon('icons/maximize.jpeg'),
"Ma&ximize",
self,
triggered=self.showMaximized)
self.restoreAction = QAction(QIcon('icons/restore.png'),
"&Restore",
self,
triggered=self.showNormal)
self.quitAction = QAction(QIcon('icons/exit.png'),
"&Quit",
self,
triggered=QApplication.instance().quit)
def trayMenu(self):
self.trayIconMenu = QMenu(self)
self.trayIconMenu.addAction(self.minimizeAction)
self.trayIconMenu.addAction(self.maximizeAction)
self.trayIconMenu.addAction(self.restoreAction)
self.trayIconMenu.addSeparator()
self.trayIconMenu.addAction(self.quitAction)
self.trayIcon = QSystemTrayIcon(self)
self.trayIcon.setContextMenu(self.trayIconMenu)
# When closing from title bar close button, it will minimize to tray
def closeEvent(self, event):
reply = QMessageBox.question(self, 'Message',
"This action will minimize to tray.",
QMessageBox.Yes | QMessageBox.Cancel,
QMessageBox.Cancel)
if reply == QMessageBox.Yes:
self.hide()
self.trayIcon.showMessage("Tray Program",
"Application was minimized to tray",
QSystemTrayIcon.Information, 2000)
event.accept()
else:
self.show()
event.ignore()
def about(self):
pixmap = QPixmap('icons/biohazard.svg')
msg = QMessageBox(
QMessageBox.Information, 'About Multitool',
"<b>Aplication name:</b> Multitool" +
"<br> <b>Version:</b> V0.7 beta" +
"<br><b>Description:</b> This application puts together many" +
"<br>widgets into a single application." +
"<br><b>Details:</b> Programmed and designed with Python 3.5 and PyQt5."
+ "<br><b>Programmer & Designer:</b> Fernando Daniel Jaime" +
"<br><b>License:</b> GNU General Public License V3.0")
pixmap = pixmap.scaled(120, 110)
msg.setIconPixmap(pixmap)
msg.exec_()
def keyPressEvent(self, event):
if event.key() == Qt.Key_Escape:
reply = QMessageBox.question(self, 'Message',
"Are you sure to quit?",
QMessageBox.Yes | QMessageBox.Cancel,
QMessageBox.Cancel)
if reply == QMessageBox.Yes:
self.statusBar().showMessage('Quiting...')
QApplication.instance().quit()
else:
event.ignore()
# Multitool context menu
def contextMenuEvent(self, event):
cmenu = QMenu(self)
quitAct = cmenu.addAction(QIcon('icons/exit.png'), "Quit")
cmenu.addSeparator()
newMultitoolAction = cmenu.addAction(QIcon('icons/new.png'),
"New Multitool")
minimizeAction = cmenu.addAction(QIcon('icons/minimize.png'),
"Minimize to tray")
action = cmenu.exec_(self.mapToGlobal(event.pos()))
if action == quitAct:
QApplication.instance().quit()
if action == newMultitoolAction:
self.__init__()
self.setGeometry(350, 350, 700, 400)
if action == minimizeAction:
self.hide()
self.trayIcon.showMessage("Tray Program",
"Application was minimized to tray",
QSystemTrayIcon.Information, 2000)
class LeftTabWidget(QWidget):
def __init__(self, *args, **kwargs):
super(LeftTabWidget, self).__init__(*args, **kwargs)
self.resize(1000, 800)
#左右布局(左边一个QListWidget + 右边QStackedWidget)
layout = QHBoxLayout(self, spacing=0)
layout.setContentsMargins(0, 0, 0, 0)
# 左侧列表
self.listWidget = QListWidget(self)
layout.addWidget(self.listWidget)
# 右侧层叠窗口
self.stackedWidget = QStackedWidget(self)
layout.addWidget(self.stackedWidget)
self.initUi()
def initUi(self):
# 初始化界面
# 通过QListWidget的当前item变化来切换QStackedWidget中的序号
self.listWidget.currentRowChanged.connect(
self.stackedWidget.setCurrentIndex)
# 去掉边框
self.listWidget.setFrameShape(QListWidget.NoFrame)
# 隐藏滚动条
self.listWidget.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.listWidget.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.listWidget.setFixedWidth(180)
# 这里就用一般的文本配合图标模式了(也可以直接用Icon模式,setViewMode)
item1 = QListWidgetItem(str('已创建'), self.listWidget)
item1.setSizeHint(QSize(200, 100))
item1.setTextAlignment(Qt.AlignCenter)
item2 = QListWidgetItem(str('已发布'), self.listWidget)
item2.setSizeHint(QSize(200, 100))
item2.setTextAlignment(Qt.AlignCenter)
item3 = QListWidgetItem(str('已开奖'), self.listWidget)
item3.setSizeHint(QSize(200, 100))
item3.setTextAlignment(Qt.AlignCenter)
# 再模拟20个右侧的页面(就不和上面一起循环放了)
for i in range(4):
label = QLabel('我是页面 %d' % i, self)
label.setAlignment(Qt.AlignCenter)
# 设置label的背景颜色(这里随机)
# 这里加了一个margin边距(方便区分QStackedWidget和QLabel的颜色)
label.setStyleSheet('background: rgb(27,111,175);')
self.stackedWidget.addWidget(label)
class object_classifier_app(QMainWindow):
def __init__(self):
super().__init__()
# init the main window
self.title = 'Epif Object Classifier'
self.setWindowTitle(self.title)
self.left = 10
self.top = 10
self.width = 1500
self.height = 750
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
# Create the map canvas and set the canvas to be the main widget
self.canvasframe = QFrame()
self.canvasframe.setFrameShape(QFrame.StyledPanel)
self.canvasframe.setFrameShadow(QFrame.Raised)
self.setCentralWidget(self.canvasframe)
self.canvas = map_canvas()
self.canvas.show()
self.framelayout = QVBoxLayout(self.canvasframe)
self.framelayout.addWidget(self.canvas)
# create map canvas actions and set icons
actionZoomIn = QAction("Zoom in", self)
actionZoomOut = QAction("Zoom out", self)
actionPan = QAction("Pan", self)
actionZoomIn.setCheckable(True)
actionZoomOut.setCheckable(True)
actionPan.setCheckable(True)
actionPanPixmap = QIcon(QPixmap(':/icons/pan.png'))
actionZoomInPixmap = QIcon(QPixmap(':/icons/Zoom-In-icon.png'))
actionZoomOutPixmap = QPixmap(':/icons/Zoom-Out-icon.png')
actionsave = QIcon(QPixmap(':/icons/save.png'))
actionsaveas = QIcon(QPixmap(':/icons/saveas.png'))
actionnew = QIcon(QPixmap(':/icons/newproject.png'))
actionloadproject = QIcon(QPixmap(':/icons/openproject.png'))
actionpolygonize = QIcon(QPixmap(':/icons/polygon.png'))
actionrasterize = QIcon(QPixmap(':/icons/raster.png'))
actionconfusion = QIcon(QPixmap(':/icons/matrix.png'))
actionZoomIn.setIcon(QIcon(actionZoomInPixmap))
actionZoomOut.setIcon(QIcon(actionZoomOutPixmap))
actionPan.setIcon(QIcon(actionPanPixmap))
actionZoomIn.triggered.connect(self.zoomIn)
actionZoomOut.triggered.connect(self.zoomOut)
actionPan.triggered.connect(self.pan)
# create map canvas tool bar
self.toolbar = self.addToolBar("Canvas actions")
self.toolbar.addAction(actionZoomIn)
self.toolbar.addAction(actionZoomOut)
self.toolbar.addAction(actionPan)
# create the map tools
self.toolPan = QgsMapToolPan(self.canvas)
self.toolPan.setAction(actionPan)
self.toolZoomIn = QgsMapToolZoom(self.canvas, False) # false = in
self.toolZoomIn.setAction(actionZoomIn)
self.toolZoomOut = QgsMapToolZoom(self.canvas, True) # true = out
self.toolZoomOut.setAction(actionZoomOut)
#init the file tree widget and set as a dock widget
self.treewidget = filetree()
self.tree = QDockWidget("Select Data", self)
self.tree.setWidget(self.treewidget)
self.tree.setFloating(False)
self.addDockWidget(Qt.LeftDockWidgetArea, self.tree)
# init a menue bar and its actions
self.menuebar = QMenuBar()
self.setMenuBar(self.menuebar)
filemenue = self.menuebar.addMenu('Project')
classificationmenue = self.menuebar.addMenu('Classification')
toolsmenue = self.menuebar.addMenu('Tools')
self.supervised = QAction('supervised')
self.training = QAction("Training set", self)
self.unsupervised = QAction('unsupernised')
self.poligonize = QAction(actionpolygonize, 'Polygonize')
self.rasterize = QAction(actionrasterize, 'Rasterize')
self.confusiomatrix = QAction(actionconfusion, 'Confusionmatrix')
self.newprojectaction = QAction(actionnew, 'New project')
self.loadprojectaction = QAction(actionloadproject, 'Load project')
self.saveprojectasaction = QAction(actionsaveas, 'Save project as')
self.saveaction = QAction(actionsave, 'Save')
classificationmenue.addAction(self.supervised)
classificationmenue.addAction(self.unsupervised)
classificationmenue.addAction(self.training)
toolsmenue.addAction(self.poligonize)
toolsmenue.addAction(self.rasterize)
toolsmenue.addAction(self.confusiomatrix)
filemenue.addAction(self.loadprojectaction)
filemenue.addAction(self.saveprojectasaction)
filemenue.addAction(self.newprojectaction)
filemenue.addAction(self.saveaction)
# create a layerpanel
self.layerpanel = LayersPanel(self.canvas)
self.layerpanelDock = QDockWidget("Layers", self)
self.layerpanelDock.setObjectName("layers")
self.layerpanelDock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
self.layerpanelDock.setWidget(self.layerpanel)
self.layerpanelDock.setContentsMargins(9, 9, 9, 9)
self.addDockWidget(Qt.LeftDockWidgetArea, self.layerpanelDock)
#set the supervised classification window widget
self.supervised_classification = supervised_classification_ui()
self.StackedWidget = QStackedWidget()
self.StackedWidget.addWidget(self.supervised_classification.step1)
self.StackedWidget.addWidget(self.supervised_classification.step2)
self.StackedWidget.addWidget(self.supervised_classification.step3)
self.StackedWidget.setCurrentWidget(
self.supervised_classification.step1)
self.StackedWidget_dock = QDockWidget('classification', self)
self.StackedWidget_dock.setWidget(self.StackedWidget)
self.addDockWidget(Qt.RightDockWidgetArea, self.StackedWidget_dock)
# set the unsupervised classification window widget
# set polygonize widget
polygonizewidget = Polygonize_ui()
polygonizewidget.legendwidget = self.layerpanel
self.StackedWidget.addWidget(polygonizewidget)
# set rasterize widget
rastrizewidget = Rasterize_ui()
rastrizewidget.legendwidget = self.layerpanel
rastrizewidget.legendwidget = self.layerpanel
self.StackedWidget.addWidget(rastrizewidget)
# set confusion matrix widget
confusionmatrixwidget = Confusion_matrix_ui()
self.StackedWidget.addWidget(confusionmatrixwidget)
self.StackedWidget.addWidget(confusionmatrixwidget.resultsgroup)
self.threadpool = QThreadPool()
self.massage = QMessageBox(text='Running')
self.StackedWidget_dock.setVisible(False)
# set the widget for creating training set
self.trainniwidget = create_training_set(self.canvas)
self.StackedWidget.addWidget(self.trainniwidget)
# connect signals and slots
self.poligonize.triggered.connect(
lambda: self.StackedWidget.setCurrentWidget(polygonizewidget))
self.poligonize.triggered.connect(
lambda: self.StackedWidget_dock.setWindowTitle('Polygonize'))
self.rasterize.triggered.connect(
lambda: self.StackedWidget.setCurrentWidget(rastrizewidget))
self.rasterize.triggered.connect(
lambda: self.StackedWidget_dock.setWindowTitle('Rasterize'))
self.confusiomatrix.triggered.connect(
lambda: self.StackedWidget.setCurrentWidget(confusionmatrixwidget))
self.confusiomatrix.triggered.connect(
lambda: self.StackedWidget_dock.setWindowTitle('Confusion Matrix'))
confusionmatrixwidget.done.connect(
lambda: self.StackedWidget.setCurrentWidget(confusionmatrixwidget.
resultsgroup))
self.supervised.triggered.connect(
lambda: self.StackedWidget_dock.setWindowTitle(
'Supervised classification'))
self.supervised.triggered.connect(
lambda: self.StackedWidget.setCurrentWidget(
self.supervised_classification.step1))
self.supervised.triggered.connect(
lambda: self.StackedWidget_dock.setVisible(True))
self.poligonize.triggered.connect(
lambda: self.StackedWidget_dock.setVisible(True))
self.rasterize.triggered.connect(
lambda: self.StackedWidget_dock.setVisible(True))
self.confusiomatrix.triggered.connect(
lambda: self.StackedWidget_dock.setVisible(True))
self.training.triggered.connect(
lambda: self.StackedWidget_dock.setVisible(True))
self.training.triggered.connect(
lambda: self.StackedWidget.setCurrentWidget(self.trainniwidget))
self.training.triggered.connect(
lambda: self.trainniwidget.create_layer())
self.supervised_classification.step1next.clicked.connect(
lambda: self.StackedWidget.setCurrentWidget(
self.supervised_classification.step2))
self.supervised_classification.step2back.clicked.connect(
lambda: self.StackedWidget.setCurrentWidget(
self.supervised_classification.step1))
self.supervised_classification.step2next.clicked.connect(
lambda: self.StackedWidget.setCurrentWidget(
self.supervised_classification.step3))
self.supervised_classification.step3back.clicked.connect(
lambda: self.StackedWidget.setCurrentWidget(
self.supervised_classification.step2))
self.loadprojectaction.triggered.connect(self.openproject)
self.saveprojectasaction.triggered.connect(self.saveproject)
self.newprojectaction.triggered.connect(self.newproject)
self.saveaction.triggered.connect(self.save)
def zoomIn(self):
"""canvas zoom in tool"""
self.canvas.setMapTool(self.toolZoomIn)
def zoomOut(self):
"""canvas zoom out tool"""
self.canvas.setMapTool(self.toolZoomOut)
def pan(self):
"""canvas pan tool"""
self.canvas.setMapTool(self.toolPan)
def saveproject(self):
"""save the project as..."""
savedfile = QFileDialog.getSaveFileName(self, "Save project", ".",
"(*.qgs)")[0] + '.qgs'
try:
self.layerpanel.project.setFileName(savedfile)
self.layerpanel.project.write()
except:
pass
def openproject(self):
"""open a dialog ro select a project file to open"""
file = QFileDialog.getOpenFileName(self, "Open project", ".",
"(*.qgs)")[0]
fileinfo = QFileInfo(file)
projectfile = fileinfo.filePath()
print(projectfile)
try:
self.layerpanel.project.read(projectfile)
except:
pass
def newproject(self):
"""create a new empty project"""
self.layerpanel.project.clear()
def save(self):
"""save the changes in the project, if the project is not associated with a project file, a dialog for
creating a project will open"""
write = self.layerpanel.project.write()
if write is True:
pass
else:
self.saveproject()
def main(argv):
"""runing thr appplication"""
# create Qt application
app = QApplication(argv)
# Initialize qgis libraries
QgsApplication.setPrefixPath(qgis_prefix, True)
QgsApplication.initQgis()
# create main window
wnd = object_classifier_app()
# Move the app window to upper left
wnd.move(100, 100)
wnd.show()
# run!
retval = app.exec_()
# exit
QgsApplication.exitQgis()
sys.exit(retval)
class View_Menu(QWidget):
#Initialiaze the first page for class View_Menu_First_Page()
def __init__(self,parent=None):
super(View_Menu,self).__init__(parent)
self.resize(800,600)
self.stackedwidget = QStackedWidget(self)
self.stackedwidget.setGeometry(QtCore.QRect(0,0 , 800, 600))
self.stackedwidget.setObjectName("stackwidget")
self.add_first_page()
#function to show first page
def add_first_page(self):
self.first_page = View_Menu_First_Page()
self.stackedwidget.addWidget(self.first_page)
self.stackedwidget.setCurrentIndex(0)
self.first_page.label_malay.clicked.connect(lambda:self.add_second_page(self.first_page.Malay_link_click())) #only can use lambda: to make use of return value form functions
self.first_page.label_mcdonalds.clicked.connect(lambda:self.add_second_page(self.first_page.MC_link_click())) #only can use lambda: to make use of return value form functions
self.first_page.label_kfc.clicked.connect(lambda:self.add_second_page(self.first_page.KFC_link_click())) #only can use lambda: to make use of return value form functions
self.first_page.label_subway.clicked.connect(lambda:self.add_second_page(self.first_page.Subway_link_click())) #only can use lambda: to make use of return value form functions
#function to show second page
def add_second_page(self,store):
self.second_page = View_Menu_Second_Page(store)
self.stackedwidget.addWidget(self.second_page)
self.stackedwidget.setCurrentIndex(1)
if self.second_page.label.text() == "Mcdonalds":
self.second_page.BlueButton.clicked.connect(lambda:self.add_third_page(self.first_page.MC_link_click(),self.second_page.submit_click()))
#function to show third page
def add_third_page(self,store,date_and_time):
self.third_page = View_Menu_Third_Page(store,date_and_time)
self.stackedwidget.addWidget(self.third_page)
self.stackedwidget.setCurrentIndex(2)
self.third_page.BlueButton_2.clicked.connect(self.go_back)
def go_back(self):
self.stackedwidget.setCurrentIndex(0)
self.stackedwidget.removeWidget(self.second_page)
self.stackedwidget.removeWidget(self.third_page)
def initUI(self):
self.pipeShape = QComboBox()
self.pipeShape.addItem("circular")
self.pipeShape.addItem("rectangular")
self.pipeShape.addItem("trapezoidal")
self.circleDiameter = QLineEdit()
self.rectWidth = QLineEdit()
self.rectDepth = QLineEdit()
self.rectOpen = QRadioButton("Open")
self.rectClosed = QRadioButton("Closed")
self.rectOpen.setChecked(True)
self.trapWidth = QLineEdit()
self.trapDepth = QLineEdit()
self.trapSide = QLineEdit()
self.trapOpen = QRadioButton("Open")
self.trapClosed = QRadioButton("Closed")
self.trapOpen.setChecked(True)
self.lengthEdit = QLineEdit()
self.lengthEdit.setFixedWidth(125)
self.usInvert = QLineEdit()
self.usInvert.setFixedWidth(125)
self.dsInvert = QLineEdit()
self.dsInvert.setFixedWidth(125)
self.Ks = QLineEdit()
self.Ks.setFixedWidth(125)
self.Ks.setText("3.0")
self.kinvisc = QLineEdit()
self.kinvisc.setFixedWidth(125)
self.kinvisc.setText("1.141e-06")
self.dsK = QLineEdit()
self.dsK.setFixedWidth(125)
self.dsK.setText("0.0")
self.usK = QLineEdit()
self.usK.setFixedWidth(125)
self.usK.setText("0.0")
self.flow = QLineEdit()
self.myFunc = QPushButton("Calculate", self)
self.myFunc.clicked.connect(self.calculate)
self.result = QTextEdit()
self.stack1 = QWidget()
self.stack2 = QWidget()
self.stack3 = QWidget()
self.stack1UI()
self.stack2UI()
self.stack3UI()
self.stack = QStackedWidget(self)
self.stack.addWidget(self.stack1)
self.stack.addWidget(self.stack2)
self.stack.addWidget(self.stack3)
layout = QVBoxLayout()
layout.addWidget(QLabel("Select Pipe Shape:"))
layout.addWidget(self.pipeShape)
layout.addWidget(self.stack)
layoutFlow = QHBoxLayout()
layoutFlow.addWidget(QLabel("Flow Rate:"))
layoutFlow.addWidget(QLabel("m3/s"))
layoutFlow.addWidget(self.flow)
layout.addLayout(layoutFlow)
layout.addWidget(self.myFunc)
layout.addWidget(self.result)
layout1 = QVBoxLayout()
layout2 = QHBoxLayout()
layout2.addWidget(QLabel("Length"))
layout2.addWidget(self.lengthEdit)
layout2.addWidget(QLabel("m"))
layout2.addStretch()
layout3 = QHBoxLayout()
layout3.addWidget(QLabel("Upstream IL"))
layout3.addWidget(self.usInvert)
layout3.addWidget(QLabel("m"))
layout4 = QHBoxLayout()
layout4.addWidget(QLabel("Downstream IL"))
layout4.addWidget(self.dsInvert)
layout4.addWidget(QLabel("m"))
layout5 = QHBoxLayout()
layout5.addWidget(QLabel("Ks"))
layout5.addWidget(self.Ks)
layout5.addWidget(QLabel("mm"))
layout6 = QHBoxLayout()
layout6.addWidget(QLabel("kinematic visc"))
layout6.addWidget(self.kinvisc)
layout6.addWidget(QLabel("m2/s"))
layout7 = QHBoxLayout()
layout7.addWidget(QLabel("Upstream K"))
layout7.addWidget(self.usK)
layout7.addWidget(QLabel("no."))
layout8 = QHBoxLayout()
layout8.addWidget(QLabel("Downstream K"))
layout8.addWidget(self.dsK)
layout8.addWidget(QLabel("no."))
layout1.addLayout(layout2)
layout1.addLayout(layout3)
layout1.addLayout(layout4)
layout1.addLayout(layout5)
layout1.addLayout(layout6)
layout1.addLayout(layout7)
layout1.addLayout(layout8)
layout1.setAlignment(Qt.AlignTop)
topLayout = QHBoxLayout(self)
topLayout.addLayout(layout)
topLayout.addLayout(layout1)
self.setLayout(topLayout)
self.pipeShape.currentIndexChanged.connect(self.stack.setCurrentIndex)
self.setGeometry(100, 100, 670, 500)
self.show()
class FontWindow(BaseWindow):
def __init__(self, font, parent=None):
super().__init__(parent)
self._font = None
self._infoWindow = None
self._featuresWindow = None
self._groupsWindow = None
self._kerningWindow = None
self._metricsWindow = None
self.toolBar = ToolBar(self)
self.toolBar.setTools(t()
for t in QApplication.instance().drawingTools())
self.glyphCellView = GlyphCellView(self)
self.glyphCellView.glyphActivated.connect(self.openGlyphTab)
self.glyphCellView.glyphsDropped.connect(self._orderChanged)
self.glyphCellView.selectionChanged.connect(self._selectionChanged)
self.glyphCellView.setAcceptDrops(True)
self.glyphCellView.setCellRepresentationName("SimpleFont.GlyphCell")
self.glyphCellView.setFrameShape(self.glyphCellView.NoFrame)
self.glyphCellView.setFocus()
self.tabWidget = TabWidget(self)
self.tabWidget.setAutoHide(True)
self.tabWidget.setHeroFirstTab(True)
self.tabWidget.addTab(self.tr("Font"))
self.stackWidget = QStackedWidget(self)
self.stackWidget.addWidget(self.glyphCellView)
self.tabWidget.currentTabChanged.connect(self._tabChanged)
self.tabWidget.tabRemoved.connect(
lambda index: self.stackWidget.removeWidget(
self.stackWidget.widget(index)))
self.stackWidget.currentChanged.connect(self._widgetChanged)
self.propertiesView = PropertiesView(font, self)
self.propertiesView.hide()
self.statusBar = StatusBar(self)
self.statusBar.setMinimumSize(32)
self.statusBar.setMaximumSize(128)
self.statusBar.sizeChanged.connect(self._sizeChanged)
self.setFont_(font)
app = QApplication.instance()
app.dispatcher.addObserver(self, "_drawingToolRegistered",
"drawingToolRegistered")
app.dispatcher.addObserver(self, "_drawingToolUnregistered",
"drawingToolUnregistered")
app.dispatcher.addObserver(self, "_glyphViewGlyphsChanged",
"glyphViewGlyphsChanged")
layout = QHBoxLayout(self)
layout.addWidget(self.toolBar)
vLayout = QVBoxLayout()
vLayout.addWidget(self.tabWidget)
pageWidget = PageWidget()
pageWidget.addWidget(self.stackWidget)
pageWidget.addWidget(self.statusBar)
vLayout.addWidget(pageWidget)
layout.addLayout(vLayout)
layout.addWidget(self.propertiesView)
layout.setContentsMargins(0, 2, 0, 0)
layout.setSpacing(2)
elements = [
("Ctrl+D", self.deselect),
(platformSpecific.closeKeySequence(), self.closeGlyphTab),
# XXX: does this really not warrant widget focus?
(QKeySequence.Delete, self.delete),
("Shift+" + QKeySequence(QKeySequence.Delete).toString(),
self.delete),
("Z", lambda: self.zoom(1)),
("X", lambda: self.zoom(-1)),
]
e = platformSpecific.altDeleteSequence()
if e is not None:
elements.append((e, self.delete))
e = platformSpecific.altRedoSequence()
if e is not None:
elements.append((e, self.redo))
for keys, callback in elements:
shortcut = QShortcut(QKeySequence(keys), self)
shortcut.activated.connect(callback)
self.installEventFilter(PreviewEventFilter(self))
self.readSettings()
self.propertiesView.activeLayerModified.connect(
self._activeLayerModified)
self.statusBar.sizeChanged.connect(self.writeSettings)
def readSettings(self):
geometry = settings.fontWindowGeometry()
if geometry:
self.restoreGeometry(geometry)
cellSize = settings.glyphCellSize()
self.statusBar.setSize(cellSize)
hidden = settings.propertiesHidden()
if not hidden:
self.properties()
def writeSettings(self):
settings.setFontWindowGeometry(self.saveGeometry())
settings.setGlyphCellSize(self.glyphCellView.cellSize()[0])
settings.setPropertiesHidden(self.propertiesView.isHidden())
def menuBar(self):
return self.layout().menuBar()
def setMenuBar(self, menuBar):
self.layout().setMenuBar(menuBar)
def setupMenu(self, menuBar):
app = QApplication.instance()
fileMenu = menuBar.fetchMenu(Entries.File)
fileMenu.fetchAction(Entries.File_New)
fileMenu.fetchAction(Entries.File_Open)
fileMenu.fetchMenu(Entries.File_Open_Recent)
if not platformSpecific.mergeOpenAndImport():
fileMenu.fetchAction(Entries.File_Import)
fileMenu.addSeparator()
fileMenu.fetchAction(Entries.File_Save, self.saveFile)
fileMenu.fetchAction(Entries.File_Save_As, self.saveFileAs)
fileMenu.fetchAction(Entries.File_Save_All)
fileMenu.fetchAction(Entries.File_Reload, self.reloadFile)
fileMenu.addSeparator()
fileMenu.fetchAction(Entries.File_Export, self.exportFile)
fileMenu.fetchAction(Entries.File_Exit)
editMenu = menuBar.fetchMenu(Entries.Edit)
self._undoAction = editMenu.fetchAction(Entries.Edit_Undo, self.undo)
self._redoAction = editMenu.fetchAction(Entries.Edit_Redo, self.redo)
editMenu.addSeparator()
cut = editMenu.fetchAction(Entries.Edit_Cut, self.cut)
copy = editMenu.fetchAction(Entries.Edit_Copy, self.copy)
copyComponent = editMenu.fetchAction(Entries.Edit_Copy_As_Component,
self.copyAsComponent)
paste = editMenu.fetchAction(Entries.Edit_Paste, self.paste)
self._clipboardActions = (cut, copy, copyComponent, paste)
editMenu.fetchAction(Entries.Edit_Select_All, self.selectAll)
# editMenu.fetchAction(Entries.Edit_Deselect, self.deselect)
editMenu.fetchAction(Entries.Edit_Find, self.findGlyph)
editMenu.addSeparator()
editMenu.fetchAction(Entries.Edit_Settings)
viewMenu = menuBar.fetchMenu(Entries.View)
viewMenu.fetchAction(Entries.View_Zoom_In, lambda: self.zoom(1))
viewMenu.fetchAction(Entries.View_Zoom_Out, lambda: self.zoom(-1))
viewMenu.fetchAction(Entries.View_Reset_Zoom, self.resetZoom)
viewMenu.addSeparator()
viewMenu.fetchAction(Entries.View_Next_Tab, lambda: self.tabOffset(1))
viewMenu.fetchAction(Entries.View_Previous_Tab,
lambda: self.tabOffset(-1))
viewMenu.fetchAction(Entries.View_Next_Glyph,
lambda: self.glyphOffset(1))
viewMenu.fetchAction(Entries.View_Previous_Glyph,
lambda: self.glyphOffset(-1))
viewMenu.fetchAction(Entries.View_Layer_Up,
lambda: self.layerOffset(-1))
viewMenu.fetchAction(Entries.View_Layer_Down,
lambda: self.layerOffset(1))
viewMenu.addSeparator()
viewMenu.fetchAction(Entries.View_Show_Points)
viewMenu.fetchAction(Entries.View_Show_Metrics)
viewMenu.fetchAction(Entries.View_Show_Images)
viewMenu.fetchAction(Entries.View_Show_Guidelines)
fontMenu = menuBar.fetchMenu(Entries.Font)
fontMenu.fetchAction(Entries.Font_Font_Info, self.fontInfo)
fontMenu.fetchAction(Entries.Font_Font_Features, self.fontFeatures)
fontMenu.addSeparator()
fontMenu.fetchAction(Entries.Font_Add_Glyphs, self.addGlyphs)
fontMenu.fetchAction(Entries.Font_Sort, self.sortGlyphs)
# glyphMenu = menuBar.fetchMenu(self.tr("&Glyph"))
# self._layerAction = glyphMenu.fetchAction(
# self.tr("&Layer Actions…"), self.layerActions, "L")
menuBar.fetchMenu(Entries.Scripts)
windowMenu = menuBar.fetchMenu(Entries.Window)
windowMenu.fetchAction(Entries.Window_Groups, self.groups)
windowMenu.fetchAction(Entries.Window_Kerning, self.kerning)
windowMenu.fetchAction(Entries.Window_Metrics, self.metrics)
windowMenu.fetchAction(Entries.Window_Scripting)
windowMenu.fetchAction(Entries.Window_Properties, self.properties)
windowMenu.addSeparator()
action = windowMenu.fetchAction(Entries.Window_Output)
action.setEnabled(app.outputWindow is not None)
helpMenu = menuBar.fetchMenu(Entries.Help)
helpMenu.fetchAction(Entries.Help_Documentation)
helpMenu.fetchAction(Entries.Help_Report_An_Issue)
helpMenu.addSeparator()
helpMenu.fetchAction(Entries.Help_About)
self._updateGlyphActions()
# --------------
# Custom methods
# --------------
def font_(self):
return self._font
def setFont_(self, font):
if self._font is not None:
self._font.removeObserver(self, "Font.Changed")
self._font.removeObserver(self, "Font.GlyphOrderChanged")
self._font.removeObserver(self, "Font.SortDescriptorChanged")
self._font = font
self.setWindowTitle(self.fontTitle())
if font is None:
return
self._updateGlyphsFromGlyphOrder()
font.addObserver(self, "_fontChanged", "Font.Changed")
font.addObserver(self, "_glyphOrderChanged", "Font.GlyphOrderChanged")
font.addObserver(self, "_sortDescriptorChanged",
"Font.SortDescriptorChanged")
def fontTitle(self):
if self._font is None:
return None
path = self._font.path or self._font.binaryPath
if path is not None:
return os.path.basename(path.rstrip(os.sep))
return self.tr("Untitled")
def isGlyphTab(self):
return bool(self.stackWidget.currentIndex())
def openGlyphTab(self, glyph):
# if a tab with this glyph exists already, switch to it
for index in range(self.stackWidget.count()):
if not index:
continue
view = self.stackWidget.widget(index)
if list(view.glyphs()) == [glyph]:
self.tabWidget.setCurrentTab(index)
return
# spawn
widget = GlyphCanvasView(self)
widget.setInputNames([glyph.name])
widget.activeGlyphChanged.connect(self._selectionChanged)
widget.glyphNamesChanged.connect(self._namesChanged)
widget.pointSizeModified.connect(self.statusBar.setSize)
widget.toolModified.connect(self.toolBar.setCurrentTool)
# add
self.tabWidget.addTab(_textForGlyphs([glyph]))
self.stackWidget.addWidget(widget)
# activate
self.tabWidget.setCurrentTab(-1)
def closeGlyphTab(self):
index = self.stackWidget.currentIndex()
if index:
self.tabWidget.removeTab(index)
def maybeSaveBeforeExit(self):
if self._font.dirty:
ret = CloseMessageBox.getCloseDocument(self, self.fontTitle())
if ret == QMessageBox.Save:
self.saveFile()
return True
elif ret == QMessageBox.Discard:
return True
return False
return True
# -------------
# Notifications
# -------------
# app
def _drawingToolRegistered(self, notification):
toolClass = notification.data["tool"]
index = self.stackWidget.currentIndex()
parent = self.stackWidget.currentWidget() if index else None
self.toolBar.addTool(toolClass(parent=parent))
def _drawingToolUnregistered(self, notification):
toolClass = notification.data["tool"]
for tool in self.toolBar.tools():
if isinstance(tool, toolClass):
self.toolBar.removeTool(tool)
return
raise ValueError(
"couldn't find tool to unregister: {}".format(toolClass))
def _glyphViewGlyphsChanged(self, notification):
self._updateGlyphActions()
# widgets
def _activeLayerModified(self):
if self.isGlyphTab():
widget = self.stackWidget.currentWidget()
index = self.sender().currentIndex().row()
layers = self._font.layers
layer = layers[layers.layerOrder[index]]
currentGlyph = widget.activeGlyph()
# XXX: adjust TLayer.get and use it
if currentGlyph.name in layer:
glyph = layer[currentGlyph.name]
else:
glyph = layer.newGlyph(currentGlyph.name)
widget.setActiveGlyph(glyph)
def _namesChanged(self):
sender = self.sender()
index = self.stackWidget.indexOf(sender)
self.tabWidget.setTabName(index, _textForGlyphs(sender.glyphs()))
def _sizeChanged(self):
size = self.statusBar.size()
if self.isGlyphTab():
widget = self.stackWidget.currentWidget()
widget.setPointSize(size)
else:
self.glyphCellView.setCellSize(size)
def _tabChanged(self, index):
self.statusBar.setShouldPropagateSize(not index)
# we need to hide, then setParent, then show
self.stackWidget.currentWidget().hide()
newWidget = self.stackWidget.widget(index)
if index:
for tool in self.toolBar.tools():
tool.setParent(newWidget)
self.stackWidget.setCurrentIndex(index)
newWidget.setFocus(Qt.OtherFocusReason)
def _toolChanged(self, tool):
widget = self.stackWidget.currentWidget()
ok = widget.setCurrentTool(tool)
# the glyph view NAKed the change (in mouseDown)
# set back the current tool in the toolbar
if not ok:
self.toolBar.setCurrentTool(widget.currentTool())
def _widgetChanged(self, index):
# update current glyph
self._updateCurrentGlyph()
# update undo/redo
self._updateGlyphActions()
# update slider
if self.isGlyphTab():
lo, hi, unit = 0, 900000, " pt"
widget = self.stackWidget.currentWidget()
size = widget.pointSize()
else:
lo, hi, unit = 32, 128, None
size = self.glyphCellView.cellSize()[0]
self.statusBar.setMinimumSize(lo)
self.statusBar.setMaximumSize(hi)
self.statusBar.setSize(size)
self.statusBar.setUnit(unit)
self.statusBar.setTextVisible(not self.isGlyphTab())
# update and connect setCurrentTool
try:
self.toolBar.currentToolChanged.disconnect()
except TypeError:
pass
if not index:
return
widget = self.stackWidget.currentWidget()
widget.setCurrentTool(self.toolBar.currentTool())
self.toolBar.currentToolChanged.connect(self._toolChanged)
def _orderChanged(self):
# TODO: reimplement when we start showing glyph subsets
glyphs = self.glyphCellView.glyphs()
self._font.glyphOrder = [glyph.name for glyph in glyphs]
def _selectionChanged(self):
if self.isGlyphTab():
activeGlyph = self.stackWidget.currentWidget().activeGlyph()
else:
activeGlyph = self.glyphCellView.lastSelectedGlyph()
# selection text
# TODO: this should probably be internal to the label
selection = self.glyphCellView.selection()
if selection is not None:
count = len(selection)
if count == 1:
glyph = self.glyphCellView.glyphsForIndexes(selection)[0]
text = "%s " % glyph.name
else:
text = ""
if count:
text = self.tr("{0}(%n selected)".format(text), n=count)
else:
text = ""
self.statusBar.setText(text)
# currentGlyph
app = QApplication.instance()
app.setCurrentGlyph(activeGlyph)
# actions
self._updateGlyphActions()
# defcon
def _fontChanged(self, notification):
font = notification.object
self.setWindowModified(font.dirty)
def _glyphOrderChanged(self, notification):
self._updateGlyphsFromGlyphOrder()
def _updateGlyphsFromGlyphOrder(self):
font = self._font
glyphOrder = font.glyphOrder
if glyphOrder:
glyphCount = 0
glyphs = []
for glyphName in glyphOrder:
if glyphName in font:
glyph = font[glyphName]
glyphCount += 1
else:
glyph = font.get(glyphName, asTemplate=True)
glyphs.append(glyph)
if glyphCount < len(font):
# if some glyphs in the font are not present in the glyph
# order, loop again to add them at the end
for glyph in font:
if glyph not in glyphs:
glyphs.append(glyph)
font.disableNotifications(observer=self)
font.glyphOrder = [glyph.name for glyph in glyphs]
font.enableNotifications(observer=self)
else:
glyphs = list(font)
font.disableNotifications(observer=self)
font.glyphOrder = [glyph.name for glyph in glyphs]
font.enableNotifications(observer=self)
self.glyphCellView.setGlyphs(glyphs)
def _sortDescriptorChanged(self, notification):
font = notification.object
descriptors = notification.data["newValue"]
if descriptors is None:
return
if descriptors[0]["type"] == "glyphSet":
glyphNames = descriptors[0]["glyphs"]
else:
glyphNames = font.unicodeData.sortGlyphNames(
font.keys(), descriptors)
font.glyphOrder = glyphNames
# ------------
# Menu methods
# ------------
# File
def saveFile(self, path=None, ufoFormatVersion=3):
if path is None and self._font.path is None:
self.saveFileAs()
else:
if path is None:
path = self._font.path
self._font.save(path, ufoFormatVersion)
def saveFileAs(self):
fileFormats = OrderedDict([
(self.tr("UFO Font version 3 {}").format("(*.ufo)"), 3),
(self.tr("UFO Font version 2 {}").format("(*.ufo)"), 2),
])
state = settings.saveFileDialogState()
path = self._font.path or self._font.binaryPath
if path:
directory = os.path.dirname(path)
else:
directory = None if state else QStandardPaths.standardLocations(
QStandardPaths.DocumentsLocation)[0]
# TODO: switch to directory dlg on platforms that need it
dialog = QFileDialog(self, self.tr("Save File"), directory,
";;".join(fileFormats.keys()))
if state:
dialog.restoreState(state)
dialog.setAcceptMode(QFileDialog.AcceptSave)
if directory:
dialog.setDirectory(directory)
ok = dialog.exec_()
settings.setSaveFileDialogState(dialog.saveState())
if ok:
nameFilter = dialog.selectedNameFilter()
path = dialog.selectedFiles()[0]
if not os.path.basename(path).endswith(".ufo"):
path += ".ufo"
self.saveFile(path, fileFormats[nameFilter])
app = QApplication.instance()
app.setCurrentFile(self._font.path)
self.setWindowTitle(self.fontTitle())
# return ok
def reloadFile(self):
font = self._font
path = font.path or font.binaryPath
if not font.dirty or path is None:
return
if not ReloadMessageBox.getReloadDocument(self, self.fontTitle()):
return
if font.path is not None:
font.reloadInfo()
font.reloadKerning()
font.reloadGroups()
font.reloadFeatures()
font.reloadLib()
font.reloadGlyphs(font.keys())
font.dirty = False
else:
# TODO: we should do this in-place
font_ = font.__class__().new()
font_.extract(font.binaryPath)
self.setFont_(font_)
def exportFile(self):
params, ok = ExportDialog.getExportParameters(self, self._font)
if not ok:
return
baseName = params['baseName']
directory = params['exportDirectory']
compression = set(map(str.lower, params['compression']))
for format in map(str.lower, params['formats']):
fileName = "{}.{}".format(baseName, format)
path = os.path.join(directory, fileName)
try:
self._font.export(path, format, compression=compression)
except Exception as e:
msg = self.tr("This font’s feature file contains an error."
) if isinstance(e, FeatureLibError) else None
errorReports.showCriticalException(e, message=msg)
# Edit
def undo(self):
widget = self.stackWidget.currentWidget()
if self.isGlyphTab():
glyph = widget.activeGlyph()
else:
glyph = widget.lastSelectedGlyph()
glyph.undo()
def redo(self):
widget = self.stackWidget.currentWidget()
if self.isGlyphTab():
glyph = widget.activeGlyph()
else:
glyph = widget.lastSelectedGlyph()
glyph.redo()
def cut(self):
self.copy()
widget = self.stackWidget.currentWidget()
if self.isGlyphTab():
glyph = widget.activeGlyph()
deleteUISelection(glyph)
else:
glyphs = widget.glyphs()
for index in widget.selection():
glyph = glyphs[index]
glyph.clear()
def copy(self):
font = self._font
widget = self.stackWidget.currentWidget()
clipboard = QApplication.clipboard()
mimeData = QMimeData()
if self.isGlyphTab():
glyph = widget.activeGlyph()
copyGlyph = glyph.getRepresentation("SimpleFont.FilterSelection")
packGlyphs = (copyGlyph, )
else:
glyphs = self.glyphCellView.glyphs()
packGlyphs = (glyphs[index]
for index in sorted(self.glyphCellView.selection()))
svgGlyphs = []
pickled = []
for i, glyph in enumerate(packGlyphs):
pickled.append(glyph.serialize(blacklist=("name", "unicodes")))
pen = SVGPathPen(font)
glyph.draw(pen)
col = i % 5
row = i // 5
g = '<g transform="matrix(1,0,0,-1,%f,%f)"><path d="%s"/></g>' % (
font.info.unitsPerEm * col, font.info.unitsPerEm * row,
pen.getCommands())
svgGlyphs.append(g)
mimeData.setData("application/x-simplefont-glyph-data",
pickle.dumps(pickled))
svg = """\
<?xml version="1.0" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN"
"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
<svg version="1.0" xmlns="http://www.w3.org/2000/svg">
%s
</svg>
""" % "\n".join(svgGlyphs)
mimeData.setData("image/svg+xml", svg.encode("utf-8"))
clipboard.setMimeData(mimeData)
def copyAsComponent(self):
if self.isGlyphTab():
pass
else:
glyphs = self.glyphCellView.glyphs()
pickled = []
for index in self.glyphCellView.selection():
glyph = glyphs[index]
componentGlyph = glyph.__class__()
componentGlyph.width = glyph.width
component = componentGlyph.instantiateComponent()
component.baseGlyph = glyph.name
pickled.append(componentGlyph.serialize())
clipboard = QApplication.clipboard()
mimeData = QMimeData()
mimeData.setData("application/x-simplefont-glyph-data",
pickle.dumps(pickled))
clipboard.setMimeData(mimeData)
def paste(self):
isGlyphTab = self.isGlyphTab()
widget = self.stackWidget.currentWidget()
if isGlyphTab:
glyphs = (widget.activeGlyph(), )
else:
selection = self.glyphCellView.selection()
glyphs = widget.glyphsForIndexes(selection)
clipboard = QApplication.clipboard()
mimeData = clipboard.mimeData()
if mimeData.hasFormat("application/x-simplefont-glyph-data"):
data = pickle.loads(
mimeData.data("application/x-simplefont-glyph-data"))
if len(data) == len(glyphs):
for pickled, glyph in zip(data, glyphs):
if isGlyphTab:
pasteGlyph = glyph.__class__()
pasteGlyph.deserialize(pickled)
# TODO: if we serialize selected state, we don't need
# to do this
pasteGlyph.selected = True
if len(pasteGlyph) or len(pasteGlyph.components) or \
len(pasteGlyph.anchors):
glyph.beginUndoGroup()
glyph.holdNotifications()
count = len(glyph)
pen = glyph.getPointPen()
# contours, components
pasteGlyph.drawPoints(pen)
for contour in glyph[count:]:
contour.selected = True
# anchors
for anchor in pasteGlyph.anchors:
glyph.appendAnchor(dict(anchor))
# guidelines
for guideline in pasteGlyph.guidelines:
glyph.appendGuideline(dict(guideline))
glyph.releaseHeldNotifications()
glyph.endUndoGroup()
else:
glyph.deserialize(pickled)
return
if mimeData.hasFormat("image/svg+xml"):
if len(glyphs) == 1:
glyph = glyphs[0]
try:
svgPath = SVGPath.fromstring(
mimeData.data("image/svg+xml"))
except:
pass
else:
glyph.beginUndoGroup()
if not isGlyphTab:
glyph.clear()
svgPath.draw(glyph.getPen())
glyph.endUndoGroup()
return
if mimeData.hasText():
if len(glyphs) == 1:
glyph = glyphs[0]
otherGlyph = glyph.__class__()
text = mimeData.text()
try:
readGlyphFromString(text, otherGlyph,
otherGlyph.getPointPen())
except:
try:
svgPath = SVGPath.fromstring(text)
svgPath.draw(otherGlyph.getPen())
except:
return
glyph.beginUndoGroup()
if not isGlyphTab:
glyph.clear()
otherGlyph.drawPoints(glyph.getPointPen())
glyph.endUndoGroup()
def selectAll(self):
widget = self.stackWidget.currentWidget()
if self.isGlyphTab():
glyph = widget.activeGlyph()
if glyph.selected:
for anchor in glyph.anchors:
anchor.selected = True
for component in glyph.components:
component.selected = True
else:
glyph.selected = True
else:
widget.selectAll()
def deselect(self):
widget = self.stackWidget.currentWidget()
if self.isGlyphTab():
glyph = widget.activeGlyph()
for anchor in glyph.anchors:
anchor.selected = False
for component in glyph.components:
component.selected = False
glyph.selected = False
else:
widget.setSelection(set())
def delete(self):
modifiers = QApplication.keyboardModifiers()
widget = self.stackWidget.currentWidget()
if self.isGlyphTab():
glyph = widget.activeGlyph()
# TODO: fuse more the two methods, they're similar and delete is
# Cut except not putting in the clipboard
if modifiers & Qt.AltModifier:
deleteUISelection(glyph)
else:
preserveShape = not modifiers & Qt.ShiftModifier
removeUIGlyphElements(glyph, preserveShape)
else:
erase = modifiers & Qt.ShiftModifier
if self._proceedWithDeletion(erase):
glyphs = widget.glyphsForIndexes(widget.selection())
for glyph in glyphs:
font = glyph.font
for layer in font.layers:
if glyph.name in layer:
defaultLayer = layer[glyph.name] == glyph
if defaultLayer and not erase:
# TODO: clear in glyph.template setter?
glyph.clear()
glyph.template = True
else:
del layer[glyph.name]
def findGlyph(self):
widget = self.stackWidget.currentWidget()
if self.isGlyphTab():
glyph = widget.activeGlyph()
newGlyph, ok = FindDialog.getNewGlyph(self, glyph)
if ok and newGlyph is not None:
widget.setActiveGlyph(newGlyph)
else:
pass # XXX
# View
def zoom(self, step):
if self.isGlyphTab():
widget = self.stackWidget.currentWidget()
newScale = widget.scale() * pow(1.2, step)
widget.zoom(newScale)
self.statusBar.setSize(widget.pointSize())
else:
value = self.statusBar.size()
newValue = value + 10 * step
self.statusBar.setSize(newValue)
def resetZoom(self):
widget = self.stackWidget.currentWidget()
if self.isGlyphTab():
widget.fitScaleBBox()
else:
settings.removeGlyphCellSize()
cellSize = settings.glyphCellSize()
self.statusBar.setSize(cellSize)
def tabOffset(self, value):
tab = self.tabWidget.currentTab()
newTab = (tab + value) % len(self.tabWidget.tabs())
self.tabWidget.setCurrentTab(newTab)
def glyphOffset(self, value):
widget = self.stackWidget.currentWidget()
if self.isGlyphTab():
currentGlyph = widget.activeGlyph()
font = currentGlyph.font
glyphOrder = font.glyphOrder
# should be enforced in fontView already
if not (glyphOrder and len(glyphOrder)):
return
index = glyphOrder.index(currentGlyph.name)
newIndex = (index + value) % len(glyphOrder)
glyph = font[glyphOrder[newIndex]]
widget.setActiveGlyph(glyph)
else:
lastSelectedCell = widget.lastSelectedCell()
if lastSelectedCell is None:
return
newIndex = lastSelectedCell + value
if newIndex < 0 or newIndex >= len(widget.glyphs()):
return
widget.setSelection({newIndex})
def layerOffset(self, value):
widget = self.stackWidget.currentWidget()
if self.isGlyphTab():
currentGlyph = widget.activeGlyph()
layerSet, layer = currentGlyph.layerSet, currentGlyph.layer
if None in (layerSet, layer):
return
index = layerSet.layerOrder.index(layer.name)
newIndex = (index + value) % len(layerSet)
layer_ = layerSet[layerSet.layerOrder[newIndex]]
if layer_ == layer:
return
# XXX: fix get
# glyph = layer_.get(currentGlyph.name)
if currentGlyph.name in layer_:
glyph = layer_[currentGlyph.name]
else:
glyph = layer_.newGlyph(currentGlyph.name)
widget.setActiveGlyph(glyph)
# Font
def fontInfo(self):
# If a window is already opened, bring it to the front, else spawn one.
# TODO: see about using widget.setAttribute(Qt.WA_DeleteOnClose)
# otherwise it seems we're just leaking memory after each close...
# (both raise_ and show allocate memory instead of using the hidden
# widget it seems)
if self._infoWindow is not None and self._infoWindow.isVisible():
self._infoWindow.raise_()
else:
self._infoWindow = FontInfoWindow(self._font, self)
self._infoWindow.show()
def fontFeatures(self):
# TODO: see up here
if self._featuresWindow is not None and self._featuresWindow.isVisible(
):
self._featuresWindow.raise_()
else:
self._featuresWindow = FontFeaturesWindow(self._font, self)
self._featuresWindow.show()
def addGlyphs(self):
glyphs = self.glyphCellView.glyphs()
newGlyphNames, params, ok = AddGlyphsDialog.getNewGlyphNames(
self, glyphs)
if ok:
sortFont = params.pop("sortFont")
for name in newGlyphNames:
glyph = self._font.get(name, **params)
if glyph is not None:
glyphs.append(glyph)
self.glyphCellView.setGlyphs(glyphs)
if sortFont:
# TODO: when the user add chars from a glyphSet and no others,
# should we try to sort according to that glyphSet?
# The above would probably warrant some rearchitecturing.
# kick-in the sort mechanism
self._font.sortDescriptor = self._font.sortDescriptor
def sortGlyphs(self):
sortDescriptor, ok = SortDialog.getDescriptor(
self, self._font.sortDescriptor)
if ok:
self._font.sortDescriptor = sortDescriptor
# Window
def groups(self):
# TODO: see up here
if self._groupsWindow is not None and self._groupsWindow.isVisible():
self._groupsWindow.raise_()
else:
self._groupsWindow = GroupsWindow(self._font, self)
self._groupsWindow.show()
def kerning(self):
# TODO: see up here
if self._kerningWindow is not None and self._kerningWindow.isVisible():
self._kerningWindow.raise_()
else:
self._kerningWindow = KerningWindow(self._font, self)
self._kerningWindow.show()
def metrics(self):
# TODO: see up here
if self._metricsWindow is not None and self._metricsWindow.isVisible():
self._metricsWindow.raise_()
else:
self._metricsWindow = MetricsWindow(self._font)
# XXX: need proper, fast windowForFont API!
self._metricsWindow._fontWindow = self
self.destroyed.connect(self._metricsWindow.close)
self._metricsWindow.show()
# TODO: default string kicks-in on the window before this. Figure out
# how to make a clean interface
selection = self.glyphCellView.selection()
if selection:
glyphs = self.glyphCellView.glyphsForIndexes(selection)
self._metricsWindow.setGlyphs(glyphs)
def properties(self):
shouldBeVisible = self.propertiesView.isHidden()
self.propertiesView.setVisible(shouldBeVisible)
self.writeSettings()
# update methods
def _setGlyphPreview(self, value):
index = self.stackWidget.currentIndex()
if index:
widget = self.stackWidget.currentWidget()
widget.setPreviewEnabled(value)
def _updateCurrentGlyph(self):
# TODO: refactor this pattern...
widget = self.stackWidget.currentWidget()
if self.isGlyphTab():
glyph = widget.activeGlyph()
else:
glyph = widget.lastSelectedGlyph()
if glyph is not None:
app = QApplication.instance()
app.setCurrentGlyph(glyph)
def _updateGlyphActions(self):
if not hasattr(self, "_undoAction"):
return
widget = self.stackWidget.currentWidget()
if self.isGlyphTab():
currentGlyph = widget.activeGlyph()
else:
currentGlyph = widget.lastSelectedGlyph()
# disconnect eventual signal of previous glyph
objects = (
(self._undoAction, self.undo),
(self._redoAction, self.redo),
)
for action, slot in objects:
try:
action.disconnect()
except TypeError:
pass
action.triggered.connect(slot)
# now update status
if currentGlyph is None:
self._undoAction.setEnabled(False)
self._redoAction.setEnabled(False)
else:
undoManager = currentGlyph.undoManager
self._undoAction.setEnabled(currentGlyph.canUndo())
undoManager.canUndoChanged.connect(self._undoAction.setEnabled)
self._redoAction.setEnabled(currentGlyph.canRedo())
undoManager.canRedoChanged.connect(self._redoAction.setEnabled)
# and other actions
for action in self._clipboardActions:
action.setEnabled(currentGlyph is not None)
# helper
def _proceedWithDeletion(self, erase=False):
if not self.glyphCellView.selection():
return
tr = self.tr("Delete") if erase else self.tr("Clear")
text = self.tr("Do you want to %s selected glyphs?") % tr.lower()
closeDialog = QMessageBox(QMessageBox.Question, "",
self.tr("%s glyphs") % tr,
QMessageBox.Yes | QMessageBox.No, self)
closeDialog.setInformativeText(text)
closeDialog.setModal(True)
ret = closeDialog.exec_()
if ret == QMessageBox.Yes:
return True
return False
# ----------
# Qt methods
# ----------
def setWindowTitle(self, title):
if platformSpecific.appNameInTitle():
title += " – SimpleFont"
super().setWindowTitle("[*]{}".format(title))
def sizeHint(self):
return QSize(1270, 800)
def moveEvent(self, event):
self.writeSettings()
resizeEvent = moveEvent
def showEvent(self, event):
app = QApplication.instance()
data = dict(
font=self._font,
window=self,
)
app.postNotification("fontWindowWillOpen", data)
super().showEvent(event)
app.postNotification("fontWindowOpened", data)
def closeEvent(self, event):
ok = self.maybeSaveBeforeExit()
if ok:
app = QApplication.instance()
data = dict(
font=self._font,
window=self,
)
app.postNotification("fontWindowWillClose", data)
self._font.removeObserver(self, "Font.Changed")
app = QApplication.instance()
app.dispatcher.removeObserver(self, "drawingToolRegistered")
app.dispatcher.removeObserver(self, "drawingToolUnregistered")
app.dispatcher.removeObserver(self, "glyphViewGlyphsChanged")
event.accept()
else:
event.ignore()
def event(self, event):
if event.type() == QEvent.WindowActivate:
app = QApplication.instance()
app.setCurrentFontWindow(self)
self._updateCurrentGlyph()
return super().event(event)
def paintEvent(self, event):
painter = QPainter(self)
painter.fillRect(event.rect(), QColor(212, 212, 212))
def configure_gui(self):
self.stack = QStackedWidget(self)
self.setCentralWidget(self.stack)
self.stack.setContentsMargins(0, 0, 5, 0)
def __init__(self, font, parent=None):
super().__init__(parent)
self._font = None
self._infoWindow = None
self._featuresWindow = None
self._groupsWindow = None
self._kerningWindow = None
self._metricsWindow = None
self.toolBar = ToolBar(self)
self.toolBar.setTools(t()
for t in QApplication.instance().drawingTools())
self.glyphCellView = GlyphCellView(self)
self.glyphCellView.glyphActivated.connect(self.openGlyphTab)
self.glyphCellView.glyphsDropped.connect(self._orderChanged)
self.glyphCellView.selectionChanged.connect(self._selectionChanged)
self.glyphCellView.setAcceptDrops(True)
self.glyphCellView.setCellRepresentationName("SimpleFont.GlyphCell")
self.glyphCellView.setFrameShape(self.glyphCellView.NoFrame)
self.glyphCellView.setFocus()
self.tabWidget = TabWidget(self)
self.tabWidget.setAutoHide(True)
self.tabWidget.setHeroFirstTab(True)
self.tabWidget.addTab(self.tr("Font"))
self.stackWidget = QStackedWidget(self)
self.stackWidget.addWidget(self.glyphCellView)
self.tabWidget.currentTabChanged.connect(self._tabChanged)
self.tabWidget.tabRemoved.connect(
lambda index: self.stackWidget.removeWidget(
self.stackWidget.widget(index)))
self.stackWidget.currentChanged.connect(self._widgetChanged)
self.propertiesView = PropertiesView(font, self)
self.propertiesView.hide()
self.statusBar = StatusBar(self)
self.statusBar.setMinimumSize(32)
self.statusBar.setMaximumSize(128)
self.statusBar.sizeChanged.connect(self._sizeChanged)
self.setFont_(font)
app = QApplication.instance()
app.dispatcher.addObserver(self, "_drawingToolRegistered",
"drawingToolRegistered")
app.dispatcher.addObserver(self, "_drawingToolUnregistered",
"drawingToolUnregistered")
app.dispatcher.addObserver(self, "_glyphViewGlyphsChanged",
"glyphViewGlyphsChanged")
layout = QHBoxLayout(self)
layout.addWidget(self.toolBar)
vLayout = QVBoxLayout()
vLayout.addWidget(self.tabWidget)
pageWidget = PageWidget()
pageWidget.addWidget(self.stackWidget)
pageWidget.addWidget(self.statusBar)
vLayout.addWidget(pageWidget)
layout.addLayout(vLayout)
layout.addWidget(self.propertiesView)
layout.setContentsMargins(0, 2, 0, 0)
layout.setSpacing(2)
elements = [
("Ctrl+D", self.deselect),
(platformSpecific.closeKeySequence(), self.closeGlyphTab),
# XXX: does this really not warrant widget focus?
(QKeySequence.Delete, self.delete),
("Shift+" + QKeySequence(QKeySequence.Delete).toString(),
self.delete),
("Z", lambda: self.zoom(1)),
("X", lambda: self.zoom(-1)),
]
e = platformSpecific.altDeleteSequence()
if e is not None:
elements.append((e, self.delete))
e = platformSpecific.altRedoSequence()
if e is not None:
elements.append((e, self.redo))
for keys, callback in elements:
shortcut = QShortcut(QKeySequence(keys), self)
shortcut.activated.connect(callback)
self.installEventFilter(PreviewEventFilter(self))
self.readSettings()
self.propertiesView.activeLayerModified.connect(
self._activeLayerModified)
self.statusBar.sizeChanged.connect(self.writeSettings)
import sys
from PyQt5.QtWidgets import QApplication, QStackedWidget
from PyQt5 import QtGui
from Login.View.ViewLogin import ViewLogin
if __name__ == '__main__':
app = QApplication(sys.argv)
widget = QStackedWidget()
Vista_login = ViewLogin(widget)
widget.addWidget(Vista_login)
widget.setStyleSheet("background-color: rgb(254, 235, 156)")
widget.setWindowTitle("Cinema")
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap("images/biglietto.png"), QtGui.QIcon.Normal,
QtGui.QIcon.Off)
widget.setWindowIcon(icon)
# Spostamento widget al centro (fissare dimensione login al max per mantenere tutto al centro)
widget.show()
centerPoint = QtGui.QScreen.availableGeometry(app.primaryScreen()).center()
fg = widget.frameGeometry()
fg.moveCenter(centerPoint)
widget.move(fg.topLeft())
sys.exit(app.exec())
class DataSelectionGui(QWidget):
"""
Manages all GUI elements in the data selection applet.
This class itself is the central widget and also owns/manages the applet drawer widgets.
"""
###########################################
### AppletGuiInterface Concrete Methods ###
###########################################
def centralWidget(self):
return self
def appletDrawer(self):
return self._drawer
def menus(self):
return []
def viewerControlWidget(self):
return self._viewerControlWidgetStack
def setImageIndex(self, imageIndex):
if imageIndex is not None:
self.laneSummaryTableView.selectRow(imageIndex)
for detailWidget in self._detailViewerWidgets:
detailWidget.selectRow(imageIndex)
def stopAndCleanUp(self):
self._cleaning_up = True
for editor in list(self.volumeEditors.values()):
self.viewerStack.removeWidget(editor)
self._viewerControlWidgetStack.removeWidget(
editor.viewerControlWidget())
editor.stopAndCleanUp()
self.volumeEditors.clear()
def imageLaneAdded(self, laneIndex):
if len(self.laneSummaryTableView.selectedIndexes()) == 0:
self.laneSummaryTableView.selectRow(laneIndex)
# We don't have any real work to do because this gui initiated the lane addition in the first place
if self.guiMode != GuiMode.Batch:
if (len(self.topLevelOperator.DatasetGroup) != laneIndex + 1):
import warnings
warnings.warn(
"DataSelectionGui.imageLaneAdded(): length of dataset multislot out of sync with laneindex [%s != %s + 1]"
% (len(self.topLevelOperator.DatasetGroup), laneIndex))
def imageLaneRemoved(self, laneIndex, finalLength):
# There's nothing to do here because the GUI already
# handles operator resizes via slot callbacks.
pass
def allowLaneSelectionChange(self):
return False
###########################################
###########################################
class UserCancelledError(Exception):
# This exception type is raised when the user cancels the
# addition of dataset files in the middle of the process somewhere.
# It isn't an error -- it's used for control flow.
pass
def __init__(self,
parentApplet,
dataSelectionOperator,
serializer,
instructionText,
guiMode=GuiMode.Normal,
max_lanes=None,
show_axis_details=False):
"""
Constructor.
:param dataSelectionOperator: The top-level operator. Must be of type :py:class:`OpMultiLaneDataSelectionGroup`.
:param serializer: The applet's serializer. Must be of type :py:class:`DataSelectionSerializer`
:param instructionText: A string to display in the applet drawer.
:param guiMode: Either ``GuiMode.Normal`` or ``GuiMode.Batch``. Currently, there is no difference between normal and batch mode.
:param max_lanes: The maximum number of lanes that the user is permitted to add to this workflow. If ``None``, there is no maximum.
"""
super(DataSelectionGui, self).__init__()
self._cleaning_up = False
self.parentApplet = parentApplet
self._max_lanes = max_lanes
self._default_h5_volumes = {}
self.show_axis_details = show_axis_details
self._viewerControls = QWidget()
self.topLevelOperator = dataSelectionOperator
self.guiMode = guiMode
self.serializer = serializer
self.threadRouter = ThreadRouter(self)
self._initCentralUic()
self._initAppletDrawerUic(instructionText)
self._viewerControlWidgetStack = QStackedWidget(self)
def handleImageRemove(multislot, index, finalLength):
# Remove the viewer for this dataset
datasetSlot = self.topLevelOperator.DatasetGroup[index]
if datasetSlot in list(self.volumeEditors.keys()):
editor = self.volumeEditors[datasetSlot]
self.viewerStack.removeWidget(editor)
self._viewerControlWidgetStack.removeWidget(
editor.viewerControlWidget())
editor.stopAndCleanUp()
self.topLevelOperator.DatasetGroup.notifyRemove(
bind(handleImageRemove))
opWorkflow = self.topLevelOperator.parent
assert hasattr(opWorkflow.shell, 'onSaveProjectActionTriggered'), \
"This class uses the IlastikShell.onSaveProjectActionTriggered function. Did you rename it?"
def _initCentralUic(self):
"""
Load the GUI from the ui file into this class and connect it with event handlers.
"""
# Load the ui file into this class (find it in our own directory)
localDir = os.path.split(__file__)[0] + '/'
uic.loadUi(localDir + "/dataSelection.ui", self)
self._initTableViews()
self._initViewerStack()
self.splitter.setSizes([150, 850])
def _initAppletDrawerUic(self, instructionText):
"""
Load the ui file for the applet drawer, which we own.
"""
localDir = os.path.split(__file__)[0] + '/'
self._drawer = uic.loadUi(localDir + "/dataSelectionDrawer.ui")
self._drawer.instructionLabel.setText(instructionText)
def _initTableViews(self):
self.fileInfoTabWidget.setTabText(0, "Summary")
self.laneSummaryTableView.setModel(
DataLaneSummaryTableModel(self, self.topLevelOperator))
self.laneSummaryTableView.dataLaneSelected.connect(self.showDataset)
self.laneSummaryTableView.addFilesRequested.connect(self.addFiles)
self.laneSummaryTableView.addStackRequested.connect(self.addStack)
self.laneSummaryTableView.removeLanesRequested.connect(
self.handleRemoveLaneButtonClicked)
# These two helper functions enable/disable an 'add files' button for a given role
# based on the the max lane index for that role and the overall permitted max_lanes
def _update_button_status(viewer, role_index):
if self._max_lanes:
viewer.setEnabled(
self._findFirstEmptyLane(role_index) < self._max_lanes)
def _handle_lane_added(button, role_index, lane_slot, lane_index):
def _handle_role_slot_added(role_slot, added_slot_index, *args):
if added_slot_index == role_index:
role_slot.notifyReady(
bind(_update_button_status, button, role_index))
role_slot.notifyUnready(
bind(_update_button_status, button, role_index))
lane_slot[lane_index].notifyInserted(_handle_role_slot_added)
self._retained = [] # Retain menus so they don't get deleted
self._detailViewerWidgets = []
for roleIndex, role in enumerate(
self.topLevelOperator.DatasetRoles.value):
detailViewer = DatasetDetailedInfoTableView(self)
detailViewer.setModel(
DatasetDetailedInfoTableModel(self, self.topLevelOperator,
roleIndex))
self._detailViewerWidgets.append(detailViewer)
# Button
detailViewer.addFilesRequested.connect(
partial(self.addFiles, roleIndex))
detailViewer.addStackRequested.connect(
partial(self.addStack, roleIndex))
detailViewer.addPrecomputedVolumeRequested.connect(
partial(self.addPrecomputedVolume, roleIndex))
detailViewer.addRemoteVolumeRequested.connect(
partial(self.addDvidVolume, roleIndex))
# Monitor changes to each lane so we can enable/disable the 'add lanes' button for each tab
self.topLevelOperator.DatasetGroup.notifyInserted(
bind(_handle_lane_added, detailViewer, roleIndex))
self.topLevelOperator.DatasetGroup.notifyRemoved(
bind(_update_button_status, detailViewer, roleIndex))
# While we're at it, do the same for the buttons in the summary table, too
self.topLevelOperator.DatasetGroup.notifyInserted(
bind(_handle_lane_added,
self.laneSummaryTableView.addFilesButtons[roleIndex],
roleIndex))
self.topLevelOperator.DatasetGroup.notifyRemoved(
bind(_update_button_status,
self.laneSummaryTableView.addFilesButtons[roleIndex],
roleIndex))
# Context menu
detailViewer.replaceWithFileRequested.connect(
partial(self.handleReplaceFile, roleIndex))
detailViewer.replaceWithStackRequested.connect(
partial(self.addStack, roleIndex))
detailViewer.editRequested.connect(
partial(self.editDatasetInfo, roleIndex))
detailViewer.resetRequested.connect(
partial(self.handleClearDatasets, roleIndex))
# Drag-and-drop
detailViewer.addFilesRequestedDrop.connect(
partial(self.addFileNames, roleIndex=roleIndex))
# Selection handling
def showFirstSelectedDataset(_roleIndex, lanes):
if lanes:
self.showDataset(lanes[0], _roleIndex)
detailViewer.dataLaneSelected.connect(
partial(showFirstSelectedDataset, roleIndex))
self.fileInfoTabWidget.insertTab(roleIndex, detailViewer, role)
self.fileInfoTabWidget.currentChanged.connect(self.handleSwitchTabs)
self.fileInfoTabWidget.setCurrentIndex(0)
def handleSwitchTabs(self, tabIndex):
if tabIndex < len(self._detailViewerWidgets):
roleIndex = tabIndex # If summary tab is moved to the front, change this line.
detailViewer = self._detailViewerWidgets[roleIndex]
selectedLanes = detailViewer.selectedLanes
if selectedLanes:
self.showDataset(selectedLanes[0], roleIndex)
def _initViewerStack(self):
self.volumeEditors = {}
self.viewerStack.addWidget(QWidget())
def handleRemoveLaneButtonClicked(self):
"""
The user clicked the "Remove" button.
Remove the currently selected row(s) from both the GUI and the top-level operator.
"""
# Figure out which lanes to remove
selectedIndexes = self.laneSummaryTableView.selectedIndexes()
rows = set()
for modelIndex in selectedIndexes:
rows.add(modelIndex.row())
# Don't remove the last row, which is just buttons.
rows.discard(self.laneSummaryTableView.model().rowCount() - 1)
# Remove in reverse order so row numbers remain consistent
for row in reversed(sorted(rows)):
# Remove lanes from the operator.
# The table model will notice the changes and update the rows accordingly.
finalSize = len(self.topLevelOperator.DatasetGroup) - 1
self.topLevelOperator.DatasetGroup.removeSlot(row, finalSize)
@threadRouted
def showDataset(self, laneIndex, roleIndex=None):
if self._cleaning_up:
return
if laneIndex == -1:
self.viewerStack.setCurrentIndex(0)
return
assert threading.current_thread().name == "MainThread"
if laneIndex >= len(self.topLevelOperator.DatasetGroup):
return
datasetSlot = self.topLevelOperator.DatasetGroup[laneIndex]
# Create if necessary
if datasetSlot not in list(self.volumeEditors.keys()):
class DatasetViewer(LayerViewerGui):
def moveToTop(self, roleIndex):
opLaneView = self.topLevelOperatorView
if not opLaneView.DatasetRoles.ready():
return
datasetRoles = opLaneView.DatasetRoles.value
if roleIndex >= len(datasetRoles):
return
roleName = datasetRoles[roleIndex]
try:
layerIndex = [l.name
for l in self.layerstack].index(roleName)
except ValueError:
return
else:
self.layerstack.selectRow(layerIndex)
self.layerstack.moveSelectedToTop()
def setupLayers(self):
opLaneView = self.topLevelOperatorView
if not opLaneView.DatasetRoles.ready():
return []
layers = []
datasetRoles = opLaneView.DatasetRoles.value
for roleIndex, slot in enumerate(opLaneView.ImageGroup):
if slot.ready():
roleName = datasetRoles[roleIndex]
layer = self.createStandardLayerFromSlot(slot)
layer.name = roleName
layers.append(layer)
return layers
opLaneView = self.topLevelOperator.getLane(laneIndex)
layerViewer = DatasetViewer(self.parentApplet,
opLaneView,
crosshair=False)
# Maximize the x-y view by default.
layerViewer.volumeEditorWidget.quadview.ensureMaximized(2)
self.volumeEditors[datasetSlot] = layerViewer
self.viewerStack.addWidget(layerViewer)
self._viewerControlWidgetStack.addWidget(
layerViewer.viewerControlWidget())
# Show the right one
viewer = self.volumeEditors[datasetSlot]
displayedRole = self.fileInfoTabWidget.currentIndex()
viewer.moveToTop(displayedRole)
self.viewerStack.setCurrentWidget(viewer)
self._viewerControlWidgetStack.setCurrentWidget(
viewer.viewerControlWidget())
def handleReplaceFile(self, roleIndex, startingLane):
self.addFiles(roleIndex, startingLane)
def addFiles(self, roleIndex, startingLane=None):
"""
The user clicked the "Add File" button.
Ask him to choose a file (or several) and add them to both
the GUI table and the top-level operator inputs.
"""
# Find the directory of the most recently opened image file
mostRecentImageFile = PreferencesManager().get('DataSelection',
'recent image')
mostRecentImageFile = str(mostRecentImageFile)
if mostRecentImageFile is not None:
defaultDirectory = os.path.split(mostRecentImageFile)[0]
else:
defaultDirectory = os.path.expanduser('~')
# Launch the "Open File" dialog
fileNames = self.getImageFileNamesToOpen(self, defaultDirectory)
# If the user didn't cancel
if len(fileNames) > 0:
PreferencesManager().set('DataSelection', 'recent image',
fileNames[0])
try:
self.addFileNames(fileNames, roleIndex, startingLane)
except Exception as ex:
log_exception(logger)
QMessageBox.critical(self, "Error loading file", str(ex))
@classmethod
def getImageFileNamesToOpen(cls, parent_window, defaultDirectory):
"""
Launch an "Open File" dialog to ask the user for one or more image files.
"""
extensions = OpDataSelection.SupportedExtensions
filter_strs = ["*." + x for x in extensions]
filters = ["{filt} ({filt})".format(filt=x) for x in filter_strs]
filt_all_str = "Image files (" + ' '.join(filter_strs) + ')'
fileNames = []
if ilastik_config.getboolean("ilastik", "debug"):
# use Qt dialog in debug mode (more portable?)
file_dialog = QFileDialog(parent_window, "Select Images")
file_dialog.setOption(QFileDialog.DontUseNativeDialog, True)
# do not display file types associated with a filter
# the line for "Image files" is too long otherwise
file_dialog.setNameFilters([filt_all_str] + filters)
#file_dialog.setNameFilterDetailsVisible(False)
# select multiple files
file_dialog.setFileMode(QFileDialog.ExistingFiles)
file_dialog.setDirectory(defaultDirectory)
if file_dialog.exec_():
fileNames = file_dialog.selectedFiles()
else:
# otherwise, use native dialog of the present platform
fileNames, _filter = QFileDialog.getOpenFileNames(
parent_window, "Select Images", defaultDirectory, filt_all_str)
return fileNames
def _findFirstEmptyLane(self, roleIndex):
opTop = self.topLevelOperator
# Determine the number of files this role already has
# Search for the last valid value.
firstNewLane = 0
for laneIndex, slot in reversed(
list(
zip(list(range(len(opTop.DatasetGroup))),
opTop.DatasetGroup))):
if slot[roleIndex].ready():
firstNewLane = laneIndex + 1
break
return firstNewLane
def addFileNames(self, fileNames, roleIndex, startingLane=None, rois=None):
"""
Add the given filenames to both the GUI table and the top-level operator inputs.
If startingLane is None, the filenames will be *appended* to the role's list of files.
If rois is provided, it must be a list of (start,stop) tuples (one for each fileName)
"""
# What lanes will we touch?
startingLane, endingLane = self._determineLaneRange(
fileNames, roleIndex, startingLane)
if startingLane is None:
# Something went wrong.
return
# If we're only adding new lanes, NOT modifying existing lanes...
adding_only = startingLane == len(self.topLevelOperator)
# Create a list of DatasetInfos
try:
infos = self._createDatasetInfos(roleIndex, fileNames, rois)
except DataSelectionGui.UserCancelledError:
return
# If no exception was thrown so far, set up the operator now
loaded_all = self._configureOpWithInfos(roleIndex, startingLane,
endingLane, infos)
if loaded_all:
# Now check the resulting slots.
# If they should be copied to the project file, say so.
self._reconfigureDatasetLocations(roleIndex, startingLane,
endingLane)
self._checkDataFormatWarnings(roleIndex, startingLane, endingLane)
# If we succeeded in adding all images, show the first one.
self.showDataset(startingLane, roleIndex)
# Notify the workflow that we just added some new lanes.
if adding_only:
workflow = self.parentApplet.topLevelOperator.parent
workflow.handleNewLanesAdded()
# Notify the workflow that something that could affect applet readyness has occurred.
self.parentApplet.appletStateUpdateRequested()
self.updateInternalPathVisiblity()
def _determineLaneRange(self, fileNames, roleIndex, startingLane=None):
"""
Determine which lanes should be configured if the user wants to add the
given fileNames to the specified role, starting at startingLane.
If startingLane is None, assume the user wants to APPEND the
files to the role's slots.
"""
if startingLane is None or startingLane == -1:
startingLane = len(self.topLevelOperator.DatasetGroup)
endingLane = startingLane + len(fileNames) - 1
else:
assert startingLane < len(self.topLevelOperator.DatasetGroup)
max_files = len(self.topLevelOperator.DatasetGroup) - \
startingLane
if len(fileNames) > max_files:
msg = "You selected {num_selected} files for {num_slots} "\
"slots. To add new files use the 'Add new...' option "\
"in the context menu or the button in the last row."\
.format(num_selected=len(fileNames),
num_slots=max_files)
QMessageBox.critical(self, "Too many files", msg)
return (None, None)
endingLane = min(startingLane + len(fileNames) - 1,
len(self.topLevelOperator.DatasetGroup))
if self._max_lanes and endingLane >= self._max_lanes:
msg = "You may not add more than {} file(s) to this workflow. Please try again.".format(
self._max_lanes)
QMessageBox.critical(self, "Too many files", msg)
return (None, None)
return (startingLane, endingLane)
def _createDatasetInfos(self, roleIndex, filePaths, rois):
"""
Create a list of DatasetInfos for the given filePaths and rois
rois may be None, in which case it is ignored.
"""
if rois is None:
rois = [None] * len(filePaths)
assert len(rois) == len(filePaths)
infos = []
for filePath, roi in zip(filePaths, rois):
info = self._createDatasetInfo(roleIndex, filePath, roi)
infos.append(info)
return infos
def _createDatasetInfo(self, roleIndex, filePath, roi):
"""
Create a DatasetInfo object for the given filePath and roi.
roi may be None, in which case it is ignored.
"""
cwd = self.topLevelOperator.WorkingDirectory.value
datasetInfo = DatasetInfo(filePath, cwd=cwd)
datasetInfo.subvolume_roi = roi # (might be None)
absPath, relPath = getPathVariants(filePath, cwd)
# If the file is in a totally different tree from the cwd,
# then leave the path as absolute. Otherwise, override with the relative path.
if relPath is not None and len(os.path.commonprefix([cwd, absPath
])) > 1:
datasetInfo.filePath = relPath
h5Exts = ['.ilp', '.h5', '.hdf5']
if os.path.splitext(datasetInfo.filePath)[1] in h5Exts:
datasetNames = self.getPossibleInternalPaths(absPath)
if len(datasetNames) == 0:
raise RuntimeError("HDF5 file %s has no image datasets" %
datasetInfo.filePath)
elif len(datasetNames) == 1:
datasetInfo.filePath += str(datasetNames[0])
else:
# If exactly one of the file's datasets matches a user's previous choice, use it.
if roleIndex not in self._default_h5_volumes:
self._default_h5_volumes[roleIndex] = set()
previous_selections = self._default_h5_volumes[roleIndex]
possible_auto_selections = previous_selections.intersection(
datasetNames)
if len(possible_auto_selections) == 1:
datasetInfo.filePath += str(
list(possible_auto_selections)[0])
else:
# Ask the user which dataset to choose
dlg = H5VolumeSelectionDlg(datasetNames, self)
if dlg.exec_() == QDialog.Accepted:
selected_index = dlg.combo.currentIndex()
selected_dataset = str(datasetNames[selected_index])
datasetInfo.filePath += selected_dataset
self._default_h5_volumes[roleIndex].add(
selected_dataset)
else:
raise DataSelectionGui.UserCancelledError()
# Allow labels by default if this gui isn't being used for batch data.
datasetInfo.allowLabels = (self.guiMode == GuiMode.Normal)
return datasetInfo
def _configureOpWithInfos(self, roleIndex, startingLane, endingLane,
infos):
"""
Attempt to configure the specified role and lanes of the
top-level operator with the given DatasetInfos.
Returns True if all lanes were configured successfully, or False if something went wrong.
"""
opTop = self.topLevelOperator
originalSize = len(opTop.DatasetGroup)
# Resize the slot if necessary
if len(opTop.DatasetGroup) < endingLane + 1:
opTop.DatasetGroup.resize(endingLane + 1)
# Configure each subslot
for laneIndex, info in zip(list(range(startingLane, endingLane + 1)),
infos):
try:
self.topLevelOperator.DatasetGroup[laneIndex][
roleIndex].setValue(info)
except DatasetConstraintError as ex:
return_val = [False]
# Give the user a chance to fix the problem
self.handleDatasetConstraintError(info, info.filePath, ex,
roleIndex, laneIndex,
return_val)
if return_val[0]:
# Successfully repaired graph.
continue
else:
# Not successfully repaired. Roll back the changes
opTop.DatasetGroup.resize(originalSize)
return False
except OpDataSelection.InvalidDimensionalityError as ex:
opTop.DatasetGroup.resize(originalSize)
QMessageBox.critical(self,
"Dataset has different dimensionality",
ex.message)
return False
except Exception as ex:
msg = "Wasn't able to load your dataset into the workflow. See error log for details."
log_exception(logger, msg)
QMessageBox.critical(self, "Dataset Load Error", msg)
opTop.DatasetGroup.resize(originalSize)
return False
return True
def _reconfigureDatasetLocations(self, roleIndex, startingLane,
endingLane):
"""
Check the metadata for the given slots.
If the data is stored a format that is poorly optimized for 3D access,
then configure it to be copied to the project file.
Finally, save the project if we changed something.
"""
save_needed = False
opTop = self.topLevelOperator
for lane_index in range(startingLane, endingLane + 1):
output_slot = opTop.ImageGroup[lane_index][roleIndex]
if output_slot.meta.prefer_2d and 'z' in output_slot.meta.axistags:
shape = numpy.array(output_slot.meta.shape)
total_volume = numpy.prod(shape)
# Only copy to the project file if the total volume is reasonably small
if total_volume < 0.5e9:
info_slot = opTop.DatasetGroup[lane_index][roleIndex]
info = info_slot.value
info.location = DatasetInfo.Location.ProjectInternal
info_slot.setValue(info, check_changed=False)
save_needed = True
if save_needed:
logger.info(
"Some of your data cannot be accessed efficiently in 3D in its current format."
" It will now be copied to the project file.")
opWorkflow = self.topLevelOperator.parent
opWorkflow.shell.onSaveProjectActionTriggered()
def _checkDataFormatWarnings(self, roleIndex, startingLane, endingLane):
warn_needed = False
opTop = self.topLevelOperator
for lane_index in range(startingLane, endingLane + 1):
output_slot = opTop.ImageGroup[lane_index][roleIndex]
if output_slot.meta.inefficient_format:
warn_needed = True
if warn_needed:
QMessageBox.warning(
self, "Inefficient Data Format",
"Your data cannot be accessed efficiently in its current format. "
"Check the console output for details.\n"
"(For HDF5 files, be sure to enable chunking on your dataset.)"
)
@threadRouted
def handleDatasetConstraintError(self,
info,
filename,
ex,
roleIndex,
laneIndex,
return_val=[False]):
if ex.unfixable:
msg = ("Can't use dataset:\n\n" + filename + "\n\n" +
"because it violates a constraint of the {} component.\n\n".
format(ex.appletName) + ex.message + "\n\n")
QMessageBox.warning(self, "Can't use dataset", msg)
return_val[0] = False
else:
assert isinstance(ex, DatasetConstraintError)
accepted = True
while isinstance(ex, DatasetConstraintError) and accepted:
msg = (
f"Can't use given properties for dataset:\n\n{filename}\n\nbecause it violates a constraint of "
f"the {ex.appletName} component.\n\n{ex.message}\n\nIf possible, fix this problem by adjusting "
f"the applet settings and or the dataset properties in the next window(s)."
)
QMessageBox.warning(self, "Dataset Needs Correction", msg)
for dlg in ex.fixing_dialogs:
dlg()
accepted, ex = self.repairDatasetInfo(info, roleIndex,
laneIndex)
# The success of this is 'returned' via our special out-param
# (We can't return a value from this method because it is @threadRouted.
return_val[0] = accepted and ex is None # successfully repaired
def repairDatasetInfo(self, info, roleIndex, laneIndex):
"""Open the dataset properties editor and return True if the new properties are acceptable."""
defaultInfos = {}
defaultInfos[laneIndex] = info
editorDlg = DatasetInfoEditorWidget(
self,
self.topLevelOperator,
roleIndex, [laneIndex],
defaultInfos,
show_axis_details=self.show_axis_details)
dlg_state, ex = editorDlg.exec_()
return (dlg_state == QDialog.Accepted), ex
@classmethod
def getPossibleInternalPaths(cls, absPath, min_ndim=2, max_ndim=5):
datasetNames = []
# Open the file as a read-only so we can get a list of the internal paths
with h5py.File(absPath, 'r') as f:
# Define a closure to collect all of the dataset names in the file.
def accumulateDatasetPaths(name, val):
if type(val) == h5py._hl.dataset.Dataset and min_ndim <= len(
val.shape) <= max_ndim:
datasetNames.append('/' + name)
# Visit every group/dataset in the file
f.visititems(accumulateDatasetPaths)
return datasetNames
def addStack(self, roleIndex, laneIndex):
"""
The user clicked the "Import Stack Files" button.
"""
stackDlg = StackFileSelectionWidget(self)
stackDlg.exec_()
if stackDlg.result() != QDialog.Accepted:
return
files = stackDlg.selectedFiles
sequence_axis = stackDlg.sequence_axis
if len(files) == 0:
return
cwd = self.topLevelOperator.WorkingDirectory.value
info = DatasetInfo(os.path.pathsep.join(files), cwd=cwd)
originalNumLanes = len(self.topLevelOperator.DatasetGroup)
if laneIndex is None or laneIndex == -1:
laneIndex = len(self.topLevelOperator.DatasetGroup)
if len(self.topLevelOperator.DatasetGroup) < laneIndex + 1:
self.topLevelOperator.DatasetGroup.resize(laneIndex + 1)
def importStack():
self.parentApplet.busy = True
self.parentApplet.appletStateUpdateRequested()
# Serializer will update the operator for us, which will propagate to the GUI.
try:
self.serializer.importStackAsLocalDataset(info, sequence_axis)
try:
self.topLevelOperator.DatasetGroup[laneIndex][
roleIndex].setValue(info)
except DatasetConstraintError as ex:
# Give the user a chance to repair the problem.
filename = files[0] + "\n...\n" + files[-1]
return_val = [False]
self.parentApplet.busy = False # required for possible fixing dialogs from DatasetConstraintError
self.parentApplet.appletStateUpdateRequested()
self.handleDatasetConstraintError(info, filename, ex,
roleIndex, laneIndex,
return_val)
if not return_val[0]:
# Not successfully repaired. Roll back the changes and give up.
self.topLevelOperator.DatasetGroup.resize(
originalNumLanes)
finally:
self.parentApplet.busy = False
self.parentApplet.appletStateUpdateRequested()
req = Request(importStack)
req.notify_finished(
lambda result: self.showDataset(laneIndex, roleIndex))
req.notify_failed(
partial(self.handleFailedStackLoad, files, originalNumLanes))
req.submit()
@threadRouted
def handleFailedStackLoad(self, files, originalNumLanes, exc, exc_info):
msg = "Failed to load stack due to the following error:\n{}".format(
exc)
msg += "\nAttempted stack files were:\n"
msg += "\n".join(files)
log_exception(logger, msg, exc_info)
QMessageBox.critical(self, "Failed to load image stack", msg)
self.topLevelOperator.DatasetGroup.resize(originalNumLanes)
def handleClearDatasets(self, roleIndex, selectedRows):
for row in selectedRows:
self.topLevelOperator.DatasetGroup[row][roleIndex].disconnect()
# Remove all operators that no longer have any connected slots
laneIndexes = list(range(len(self.topLevelOperator.DatasetGroup)))
for laneIndex, multislot in reversed(
list(zip(laneIndexes, self.topLevelOperator.DatasetGroup))):
any_ready = False
for slot in multislot:
any_ready |= slot.ready()
if not any_ready:
self.topLevelOperator.DatasetGroup.removeSlot(
laneIndex,
len(self.topLevelOperator.DatasetGroup) - 1)
# Notify the workflow that something that could affect applet readyness has occurred.
self.parentApplet.appletStateUpdateRequested()
def editDatasetInfo(self, roleIndex, laneIndexes):
editorDlg = DatasetInfoEditorWidget(
self,
self.topLevelOperator,
roleIndex,
laneIndexes,
show_axis_details=self.show_axis_details)
editorDlg.exec_()
self.parentApplet.appletStateUpdateRequested()
def updateInternalPathVisiblity(self):
for view in self._detailViewerWidgets:
model = view.model()
view.setColumnHidden(DatasetDetailedInfoColumn.InternalID,
not model.hasInternalPaths())
def addPrecomputedVolume(self, roleIndex, laneIndex):
# add history...
history = []
browser = PrecomputedVolumeBrowser(history=history, parent=self)
if browser.exec_() == PrecomputedVolumeBrowser.Rejected:
return
precomputed_url = browser.selected_url
self.addFileNames([precomputed_url], roleIndex, laneIndex)
def addDvidVolume(self, roleIndex, laneIndex):
recent_hosts_pref = PreferencesManager.Setting("DataSelection",
"Recent DVID Hosts")
recent_hosts = recent_hosts_pref.get()
if not recent_hosts:
recent_hosts = ["localhost:8000"]
recent_hosts = [
h for h in recent_hosts if h
] # There used to be a bug where empty strings could be saved. Filter those out.
recent_nodes_pref = PreferencesManager.Setting("DataSelection",
"Recent DVID Nodes")
recent_nodes = recent_nodes_pref.get() or {}
from .dvidDataSelectionBrowser import DvidDataSelectionBrowser
browser = DvidDataSelectionBrowser(recent_hosts,
recent_nodes,
parent=self)
if browser.exec_() == DvidDataSelectionBrowser.Rejected:
return
if None in browser.get_selection():
QMessageBox.critical("Couldn't use your selection.")
return
rois = None
hostname, repo_uuid, volume_name, node_uuid, typename = browser.get_selection(
)
dvid_url = 'http://{hostname}/api/node/{node_uuid}/{volume_name}'.format(
**locals())
subvolume_roi = browser.get_subvolume_roi()
# Relocate host to top of 'recent' list, and limit list to 10 items.
try:
i = recent_hosts.index(hostname)
del recent_hosts[i]
except ValueError:
pass
finally:
recent_hosts.insert(0, hostname)
recent_hosts = recent_hosts[:10]
# Save pref
recent_hosts_pref.set(recent_hosts)
recent_nodes[hostname] = node_uuid
recent_nodes_pref.set(recent_nodes)
if subvolume_roi is None:
self.addFileNames([dvid_url], roleIndex, laneIndex)
else:
start, stop = subvolume_roi
self.addFileNames([dvid_url], roleIndex, laneIndex,
[(start, stop)])
class SimpleTictactoe(QDialog):
"""
With this class simple tictactoe game-app is created.
"""
def __init__(self):
"""
constructor
"""
super().__init__()
self.title = "Simple Tictactoe"
self.left, self.top, self.width, self.height = 50, 50, -1, -1
self.initGUI()
def initGUI(self):
"""
initializes GUI
:return:
"""
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.setWindowModality(Qt.ApplicationModal)
self.addComponents()
self.registerEvents()
def addComponents(self):
"""
sets the mainLayout for this class and adds components into it.
:return:
"""
self.mainLayout = QVBoxLayout()
# comboChooser
self.widgetChooser = QWidget()
self.layoutChooser = QHBoxLayout()
self.widgetChooser.setLayout(self.layoutChooser)
self.mainLayout.addWidget(self.widgetChooser)
self.lblChooser = QLabel("Choose the tictactoe row x column: ")
self.comboChooser = QComboBox()
self.comboChooser.addItems(
["Tictactoe 3x3", "Tictactoe 5x5", "Tictactoe 7x7"])
self.layoutChooser.addWidget(self.lblChooser)
self.layoutChooser.addWidget(self.comboChooser)
self.setLayout(self.mainLayout)
self.tictactoe3 = TictactoeWidget()
self.tictactoe5 = TictactoeWidget(5, 5)
self.tictactoe7 = TictactoeWidget(7, 7)
# self.tictactoe9 = TictactoeWidget(9, 9)
# self.tictactoe11 = TictactoeWidget(11, 11)
# self.tictactoe13 = TictactoeWidget(13, 13)
# stackedWidget
self.stackedWidget = QStackedWidget()
self.mainLayout.addWidget(self.stackedWidget)
self.stackedWidget.addWidget(self.tictactoe3)
self.stackedWidget.addWidget(self.tictactoe5)
self.stackedWidget.addWidget(self.tictactoe7)
# self.stackedWidget.addWidget(self.tictactoe9)
# self.stackedWidget.addWidget(self.tictactoe11)
# self.stackedWidget.addWidget(self.tictactoe13)
def registerEvents(self):
"""
registers events
:return:
"""
self.comboChooser.currentIndexChanged.connect(
self.onCurrentIndexChanged)
@pyqtSlot()
def onCurrentIndexChanged(self):
"""
Slot for signal-slot handling .
Gets invoked when in comboChooser currentIndexChanged event
is triggered.
:return:
"""
currentIndex = self.sender().currentIndex()
self.stackedWidget.setCurrentIndex(currentIndex)
def createContent(self):
self.content = QStackedWidget()
self.content.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding))
