class E5SideBar(QWidget):
"""
Class implementing a sidebar with a widget area, that is hidden or shown,
if the current tab is clicked again.
"""
Version = 1
North = 0
East = 1
South = 2
West = 3
def __init__(self, orientation=None, delay=200, parent=None):
"""
Constructor
@param orientation orientation of the sidebar widget (North, East,
South, West)
@param delay value for the expand/shrink delay in milliseconds
(integer)
@param parent parent widget (QWidget)
"""
super(E5SideBar, self).__init__(parent)
self.__tabBar = QTabBar()
self.__tabBar.setDrawBase(True)
self.__tabBar.setShape(QTabBar.RoundedNorth)
self.__tabBar.setUsesScrollButtons(True)
self.__tabBar.setDrawBase(False)
self.__stackedWidget = QStackedWidget(self)
self.__stackedWidget.setContentsMargins(0, 0, 0, 0)
self.__autoHideButton = QToolButton()
self.__autoHideButton.setCheckable(True)
self.__autoHideButton.setIcon(
UI.PixmapCache.getIcon("autoHideOff.png"))
self.__autoHideButton.setChecked(True)
self.__autoHideButton.setToolTip(
self.tr("Deselect to activate automatic collapsing"))
self.barLayout = QBoxLayout(QBoxLayout.LeftToRight)
self.barLayout.setContentsMargins(0, 0, 0, 0)
self.layout = QBoxLayout(QBoxLayout.TopToBottom)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.setSpacing(0)
self.barLayout.addWidget(self.__autoHideButton)
self.barLayout.addWidget(self.__tabBar)
self.layout.addLayout(self.barLayout)
self.layout.addWidget(self.__stackedWidget)
self.setLayout(self.layout)
# initialize the delay timer
self.__actionMethod = None
self.__delayTimer = QTimer(self)
self.__delayTimer.setSingleShot(True)
self.__delayTimer.setInterval(delay)
self.__delayTimer.timeout.connect(self.__delayedAction)
self.__minimized = False
self.__minSize = 0
self.__maxSize = 0
self.__bigSize = QSize()
self.splitter = None
self.splitterSizes = []
self.__hasFocus = False
# flag storing if this widget or any child has the focus
self.__autoHide = False
self.__tabBar.installEventFilter(self)
self.__orientation = E5SideBar.North
if orientation is None:
orientation = E5SideBar.North
self.setOrientation(orientation)
self.__tabBar.currentChanged[int].connect(
self.__stackedWidget.setCurrentIndex)
e5App().focusChanged.connect(self.__appFocusChanged)
self.__autoHideButton.toggled[bool].connect(self.__autoHideToggled)
def setSplitter(self, splitter):
"""
Public method to set the splitter managing the sidebar.
@param splitter reference to the splitter (QSplitter)
"""
self.splitter = splitter
self.splitter.splitterMoved.connect(self.__splitterMoved)
self.splitter.setChildrenCollapsible(False)
index = self.splitter.indexOf(self)
self.splitter.setCollapsible(index, False)
def __splitterMoved(self, pos, index):
"""
Private slot to react on splitter moves.
@param pos new position of the splitter handle (integer)
@param index index of the splitter handle (integer)
"""
if self.splitter:
self.splitterSizes = self.splitter.sizes()
def __delayedAction(self):
"""
Private slot to handle the firing of the delay timer.
"""
if self.__actionMethod is not None:
self.__actionMethod()
def setDelay(self, delay):
"""
Public method to set the delay value for the expand/shrink delay in
milliseconds.
@param delay value for the expand/shrink delay in milliseconds
(integer)
"""
self.__delayTimer.setInterval(delay)
def delay(self):
"""
Public method to get the delay value for the expand/shrink delay in
milliseconds.
@return value for the expand/shrink delay in milliseconds (integer)
"""
return self.__delayTimer.interval()
def __cancelDelayTimer(self):
"""
Private method to cancel the current delay timer.
"""
self.__delayTimer.stop()
self.__actionMethod = None
def shrink(self):
"""
Public method to record a shrink request.
"""
self.__delayTimer.stop()
self.__actionMethod = self.__shrinkIt
self.__delayTimer.start()
def __shrinkIt(self):
"""
Private method to shrink the sidebar.
"""
self.__minimized = True
self.__bigSize = self.size()
if self.__orientation in [E5SideBar.North, E5SideBar.South]:
self.__minSize = self.minimumSizeHint().height()
self.__maxSize = self.maximumHeight()
else:
self.__minSize = self.minimumSizeHint().width()
self.__maxSize = self.maximumWidth()
if self.splitter:
self.splitterSizes = self.splitter.sizes()
self.__stackedWidget.hide()
if self.__orientation in [E5SideBar.North, E5SideBar.South]:
self.setFixedHeight(self.__tabBar.minimumSizeHint().height())
else:
self.setFixedWidth(self.__tabBar.minimumSizeHint().width())
self.__actionMethod = None
def expand(self):
"""
Public method to record a expand request.
"""
self.__delayTimer.stop()
self.__actionMethod = self.__expandIt
self.__delayTimer.start()
def __expandIt(self):
"""
Private method to expand the sidebar.
"""
self.__minimized = False
self.__stackedWidget.show()
self.resize(self.__bigSize)
if self.__orientation in [E5SideBar.North, E5SideBar.South]:
minSize = max(self.__minSize, self.minimumSizeHint().height())
self.setMinimumHeight(minSize)
self.setMaximumHeight(self.__maxSize)
else:
minSize = max(self.__minSize, self.minimumSizeHint().width())
self.setMinimumWidth(minSize)
self.setMaximumWidth(self.__maxSize)
if self.splitter:
self.splitter.setSizes(self.splitterSizes)
self.__actionMethod = None
def isMinimized(self):
"""
Public method to check the minimized state.
@return flag indicating the minimized state (boolean)
"""
return self.__minimized
def isAutoHiding(self):
"""
Public method to check, if the auto hide function is active.
@return flag indicating the state of auto hiding (boolean)
"""
return self.__autoHide
def eventFilter(self, obj, evt):
"""
Public method to handle some events for the tabbar.
@param obj reference to the object (QObject)
@param evt reference to the event object (QEvent)
@return flag indicating, if the event was handled (boolean)
"""
if obj == self.__tabBar:
if evt.type() == QEvent.MouseButtonPress:
pos = evt.pos()
for i in range(self.__tabBar.count()):
if self.__tabBar.tabRect(i).contains(pos):
break
if i == self.__tabBar.currentIndex():
if self.isMinimized():
self.expand()
else:
self.shrink()
return True
elif self.isMinimized():
self.expand()
elif evt.type() == QEvent.Wheel:
if qVersion() >= "5.0.0":
delta = evt.angleDelta().y()
else:
delta = evt.delta()
if delta > 0:
self.prevTab()
else:
self.nextTab()
return True
return QWidget.eventFilter(self, obj, evt)
def addTab(self, widget, iconOrLabel, label=None):
"""
Public method to add a tab to the sidebar.
@param widget reference to the widget to add (QWidget)
@param iconOrLabel reference to the icon or the label text of the tab
(QIcon, string)
@param label the labeltext of the tab (string) (only to be
used, if the second parameter is a QIcon)
"""
if label:
index = self.__tabBar.addTab(iconOrLabel, label)
self.__tabBar.setTabToolTip(index, label)
else:
index = self.__tabBar.addTab(iconOrLabel)
self.__tabBar.setTabToolTip(index, iconOrLabel)
self.__stackedWidget.addWidget(widget)
if self.__orientation in [E5SideBar.North, E5SideBar.South]:
self.__minSize = self.minimumSizeHint().height()
else:
self.__minSize = self.minimumSizeHint().width()
def insertTab(self, index, widget, iconOrLabel, label=None):
"""
Public method to insert a tab into the sidebar.
@param index the index to insert the tab at (integer)
@param widget reference to the widget to insert (QWidget)
@param iconOrLabel reference to the icon or the labeltext of the tab
(QIcon, string)
@param label the labeltext of the tab (string) (only to be
used, if the second parameter is a QIcon)
"""
if label:
index = self.__tabBar.insertTab(index, iconOrLabel, label)
self.__tabBar.setTabToolTip(index, label)
else:
index = self.__tabBar.insertTab(index, iconOrLabel)
self.__tabBar.setTabToolTip(index, iconOrLabel)
self.__stackedWidget.insertWidget(index, widget)
if self.__orientation in [E5SideBar.North, E5SideBar.South]:
self.__minSize = self.minimumSizeHint().height()
else:
self.__minSize = self.minimumSizeHint().width()
def removeTab(self, index):
"""
Public method to remove a tab.
@param index the index of the tab to remove (integer)
"""
self.__stackedWidget.removeWidget(self.__stackedWidget.widget(index))
self.__tabBar.removeTab(index)
if self.__orientation in [E5SideBar.North, E5SideBar.South]:
self.__minSize = self.minimumSizeHint().height()
else:
self.__minSize = self.minimumSizeHint().width()
def clear(self):
"""
Public method to remove all tabs.
"""
while self.count() > 0:
self.removeTab(0)
def prevTab(self):
"""
Public slot used to show the previous tab.
"""
ind = self.currentIndex() - 1
if ind == -1:
ind = self.count() - 1
self.setCurrentIndex(ind)
self.currentWidget().setFocus()
def nextTab(self):
"""
Public slot used to show the next tab.
"""
ind = self.currentIndex() + 1
if ind == self.count():
ind = 0
self.setCurrentIndex(ind)
self.currentWidget().setFocus()
def count(self):
"""
Public method to get the number of tabs.
@return number of tabs in the sidebar (integer)
"""
return self.__tabBar.count()
def currentIndex(self):
"""
Public method to get the index of the current tab.
@return index of the current tab (integer)
"""
return self.__stackedWidget.currentIndex()
def setCurrentIndex(self, index):
"""
Public slot to set the current index.
@param index the index to set as the current index (integer)
"""
self.__tabBar.setCurrentIndex(index)
self.__stackedWidget.setCurrentIndex(index)
if self.isMinimized():
self.expand()
def currentWidget(self):
"""
Public method to get a reference to the current widget.
@return reference to the current widget (QWidget)
"""
return self.__stackedWidget.currentWidget()
def setCurrentWidget(self, widget):
"""
Public slot to set the current widget.
@param widget reference to the widget to become the current widget
(QWidget)
"""
self.__stackedWidget.setCurrentWidget(widget)
self.__tabBar.setCurrentIndex(self.__stackedWidget.currentIndex())
if self.isMinimized():
self.expand()
def indexOf(self, widget):
"""
Public method to get the index of the given widget.
@param widget reference to the widget to get the index of (QWidget)
@return index of the given widget (integer)
"""
return self.__stackedWidget.indexOf(widget)
def isTabEnabled(self, index):
"""
Public method to check, if a tab is enabled.
@param index index of the tab to check (integer)
@return flag indicating the enabled state (boolean)
"""
return self.__tabBar.isTabEnabled(index)
def setTabEnabled(self, index, enabled):
"""
Public method to set the enabled state of a tab.
@param index index of the tab to set (integer)
@param enabled enabled state to set (boolean)
"""
self.__tabBar.setTabEnabled(index, enabled)
def orientation(self):
"""
Public method to get the orientation of the sidebar.
@return orientation of the sidebar (North, East, South, West)
"""
return self.__orientation
def setOrientation(self, orient):
"""
Public method to set the orientation of the sidebar.
@param orient orientation of the sidebar (North, East, South, West)
"""
if orient == E5SideBar.North:
self.__tabBar.setShape(QTabBar.RoundedNorth)
self.__tabBar.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Preferred)
self.barLayout.setDirection(QBoxLayout.LeftToRight)
self.layout.setDirection(QBoxLayout.TopToBottom)
self.layout.setAlignment(self.barLayout, Qt.AlignLeft)
elif orient == E5SideBar.East:
self.__tabBar.setShape(QTabBar.RoundedEast)
self.__tabBar.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Expanding)
self.barLayout.setDirection(QBoxLayout.TopToBottom)
self.layout.setDirection(QBoxLayout.RightToLeft)
self.layout.setAlignment(self.barLayout, Qt.AlignTop)
elif orient == E5SideBar.South:
self.__tabBar.setShape(QTabBar.RoundedSouth)
self.__tabBar.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Preferred)
self.barLayout.setDirection(QBoxLayout.LeftToRight)
self.layout.setDirection(QBoxLayout.BottomToTop)
self.layout.setAlignment(self.barLayout, Qt.AlignLeft)
elif orient == E5SideBar.West:
self.__tabBar.setShape(QTabBar.RoundedWest)
self.__tabBar.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Expanding)
self.barLayout.setDirection(QBoxLayout.TopToBottom)
self.layout.setDirection(QBoxLayout.LeftToRight)
self.layout.setAlignment(self.barLayout, Qt.AlignTop)
self.__orientation = orient
def tabIcon(self, index):
"""
Public method to get the icon of a tab.
@param index index of the tab (integer)
@return icon of the tab (QIcon)
"""
return self.__tabBar.tabIcon(index)
def setTabIcon(self, index, icon):
"""
Public method to set the icon of a tab.
@param index index of the tab (integer)
@param icon icon to be set (QIcon)
"""
self.__tabBar.setTabIcon(index, icon)
def tabText(self, index):
"""
Public method to get the text of a tab.
@param index index of the tab (integer)
@return text of the tab (string)
"""
return self.__tabBar.tabText(index)
def setTabText(self, index, text):
"""
Public method to set the text of a tab.
@param index index of the tab (integer)
@param text text to set (string)
"""
self.__tabBar.setTabText(index, text)
def tabToolTip(self, index):
"""
Public method to get the tooltip text of a tab.
@param index index of the tab (integer)
@return tooltip text of the tab (string)
"""
return self.__tabBar.tabToolTip(index)
def setTabToolTip(self, index, tip):
"""
Public method to set the tooltip text of a tab.
@param index index of the tab (integer)
@param tip tooltip text to set (string)
"""
self.__tabBar.setTabToolTip(index, tip)
def tabWhatsThis(self, index):
"""
Public method to get the WhatsThis text of a tab.
@param index index of the tab (integer)
@return WhatsThis text of the tab (string)
"""
return self.__tabBar.tabWhatsThis(index)
def setTabWhatsThis(self, index, text):
"""
Public method to set the WhatsThis text of a tab.
@param index index of the tab (integer)
@param text WhatsThis text to set (string)
"""
self.__tabBar.setTabWhatsThis(index, text)
def widget(self, index):
"""
Public method to get a reference to the widget associated with a tab.
@param index index of the tab (integer)
@return reference to the widget (QWidget)
"""
return self.__stackedWidget.widget(index)
def saveState(self):
"""
Public method to save the state of the sidebar.
@return saved state as a byte array (QByteArray)
"""
if len(self.splitterSizes) == 0:
if self.splitter:
self.splitterSizes = self.splitter.sizes()
self.__bigSize = self.size()
if self.__orientation in [E5SideBar.North, E5SideBar.South]:
self.__minSize = self.minimumSizeHint().height()
self.__maxSize = self.maximumHeight()
else:
self.__minSize = self.minimumSizeHint().width()
self.__maxSize = self.maximumWidth()
data = QByteArray()
stream = QDataStream(data, QIODevice.WriteOnly)
stream.setVersion(QDataStream.Qt_4_6)
stream.writeUInt16(self.Version)
stream.writeBool(self.__minimized)
stream << self.__bigSize
stream.writeUInt16(self.__minSize)
stream.writeUInt16(self.__maxSize)
stream.writeUInt16(len(self.splitterSizes))
for size in self.splitterSizes:
stream.writeUInt16(size)
stream.writeBool(self.__autoHide)
return data
def restoreState(self, state):
"""
Public method to restore the state of the sidebar.
@param state byte array containing the saved state (QByteArray)
@return flag indicating success (boolean)
"""
if state.isEmpty():
return False
if self.__orientation in [E5SideBar.North, E5SideBar.South]:
minSize = self.layout.minimumSize().height()
maxSize = self.maximumHeight()
else:
minSize = self.layout.minimumSize().width()
maxSize = self.maximumWidth()
data = QByteArray(state)
stream = QDataStream(data, QIODevice.ReadOnly)
stream.setVersion(QDataStream.Qt_4_6)
stream.readUInt16() # version
minimized = stream.readBool()
if minimized and not self.__minimized:
self.shrink()
stream >> self.__bigSize
self.__minSize = max(stream.readUInt16(), minSize)
self.__maxSize = max(stream.readUInt16(), maxSize)
count = stream.readUInt16()
self.splitterSizes = []
for i in range(count):
self.splitterSizes.append(stream.readUInt16())
self.__autoHide = stream.readBool()
self.__autoHideButton.setChecked(not self.__autoHide)
if not minimized:
self.expand()
return True
#######################################################################
## methods below implement the autohide functionality
#######################################################################
def __autoHideToggled(self, checked):
"""
Private slot to handle the toggling of the autohide button.
@param checked flag indicating the checked state of the button
(boolean)
"""
self.__autoHide = not checked
if self.__autoHide:
self.__autoHideButton.setIcon(
UI.PixmapCache.getIcon("autoHideOn.png"))
else:
self.__autoHideButton.setIcon(
UI.PixmapCache.getIcon("autoHideOff.png"))
def __appFocusChanged(self, old, now):
"""
Private slot to handle a change of the focus.
@param old reference to the widget, that lost focus (QWidget or None)
@param now reference to the widget having the focus (QWidget or None)
"""
self.__hasFocus = self.isAncestorOf(now)
if self.__autoHide and not self.__hasFocus and not self.isMinimized():
self.shrink()
elif self.__autoHide and self.__hasFocus and self.isMinimized():
self.expand()
def enterEvent(self, event):
"""
Protected method to handle the mouse entering this widget.
@param event reference to the event (QEvent)
"""
if self.__autoHide and self.isMinimized():
self.expand()
else:
self.__cancelDelayTimer()
def leaveEvent(self, event):
"""
Protected method to handle the mouse leaving this widget.
@param event reference to the event (QEvent)
"""
if self.__autoHide and not self.__hasFocus and not self.isMinimized():
self.shrink()
else:
self.__cancelDelayTimer()
def shutdown(self):
"""
Public method to shut down the object.
This method does some preparations so the object can be deleted
properly. It disconnects from the focusChanged signal in order to
avoid trouble later on.
"""
e5App().focusChanged.disconnect(self.__appFocusChanged)
class MainView(base, form):
def __init__(self, pipeline, parent=None):
super(base, self).__init__(parent)
self.setupUi(self)
self.pipeline = pipeline
self.pip_widgets = []
self.default_pips = []
self.draw_ui()
self.connect_ui()
def register_observers(self):
pass
def connect_ui(self):
"""
This function connects the ui using signals from the
ui elements and its method counterparts.
"""
self.input_btn.clicked.connect(self.set_input_url)
self.output_btn.clicked.connect(self.set_output_url)
self.save_btn.clicked.connect(self.save_pipeline)
self.load_favorite_pipelines()
self.fav_pips_combo_box.activated.connect(self.select_default_pip)
self.run_btn.clicked.connect(self.run)
self.delete_btn.clicked.connect(self.trash_pipeline)
self.add_btn.clicked.connect(lambda: self.add_pipe_entry_new())
def draw_ui(self):
"""
This function draws all additional UI elements. If you want the
application to display any additional things like a button you can
either add it in the QtDesigner or declare it here.
"""
# *TODO* Create these ones with Qt Designer and put them into select_cat_alg_vbox_layout. I failed
self.ComboxCategories = QComboBox()
self.stackedWidgetComboxesAlgorithms = QStackedWidget()
self.select_cat_alg_vbox_layout.addWidget(self.ComboxCategories)
self.select_cat_alg_vbox_layout.addWidget(self.stackedWidgetComboxesAlgorithms)
self.ComboxCategories.hide()
"""
This function is concerned with drawing all non static elements into the
GUI.
"""
"""self.set_pip_title("A. Junius2")
self.set_preset(["A.Junius", "test", "test", "test"])
self.add_pip_entry("../assets/images/P.png", "Preprocessing - adaptive trehsold watershed")
self.add_pip_entry("../assets/images/P.png", "Preprocessing - adaptive trehsold watershed")
self.add_pip_entry("../assets/images/P.png", "Preprocessing - adaptive trehsold watershed")
self.add_pip_entry("../assets/images/P.png", "Preprocessing - adaptive trehsold watershed")
self.add_pip_entry("../assets/images/P.png", "Preprocessing - adaptive trehsold watershed")
self.add_pip_entry("../assets/images/P.png", "Preprocessing - adaptive trehsold watershed")
self.add_pip_entry("../assets/images/P.png", "Preprocessing - adaptive trehsold watershed")
self.add_cat_image("../assets/images/seg_fav.jpeg", "Preprocessing")
self.add_cat_image("../assets/images/wing.jpeg", "Preprocessing")
self.add_cat_image("../assets/images/wing.jpeg", "Preprocessing")
self.add_cat_image("../assets/images/wing.jpeg", "Preprocessing")
self.add_cat_image("../assets/images/wing.jpeg", "Preprocessing")
self.add_cat_image("../assets/images/wing.jpeg", "Preprocessing")
self.add_cat_image("../assets/images/wing.jpeg", "Preprocessing")
self.main_image_label.setPixmap(QtGui.QPixmap("wing.jpeg"))
category_combo_box = ComboBoxWidget("type")
category_combo_box.add_item("Preprocessing", "../assets/images/P.png")
category_combo_box.add_item("Segmentation", "../assets/images/S.png")
category_combo_box.add_item("Graph Detection", "../assets/images/D.png")
category_combo_box.add_item("Graph Filtering", "../assets/images/F.png")
alg_combo_box = ComboBoxWidget("algorithm")
alg_combo_box.add_item("Otsus")
alg_combo_box.add_item("Guo Hall")
alg_combo_box.add_item("Adaptive Treshold")
slider_1 = SliderWidget("slider1das", 0, 10, 1, 4, True)
slider_2 = SliderWidget("slider1", 0, 10, 2, 4, False)
slider_3 = SliderWidget("sliderböadsad", 0, 10, 1, 4, True)
slider_4 = SliderWidget("sliderböadsad", 0, 10, 1, 4, True)
slider_5 = SliderWidget("sliderböadsad", 0, 10, 1, 4, True)
checkbox_1 = CheckBoxWidget("checkbox1", True)
self.setting_widget_vbox_layout.addWidget(category_combo_box)
self.setting_widget_vbox_layout.addWidget(alg_combo_box)
self.setting_widget_vbox_layout.addWidget(slider_1)
self.setting_widget_vbox_layout.addWidget(slider_2)
self.setting_widget_vbox_layout.addWidget(slider_3)
self.setting_widget_vbox_layout.addWidget(slider_4)
self.setting_widget_vbox_layout.addWidget(slider_5)
self.setting_widget_vbox_layout.addWidget(checkbox_1)
self.setting_widget_vbox_layout.setAlignment(Qt.AlignTop)"""
def set_pip_title(self, title):
"""
Sets the title of the current selected pipeline in the ui.
Args:
| *title*: the title of the pipeline
| *label_ref*: the reference to the label.
"""
self.current_pip_label.setText(title)
def load_dark_theme(self, application):
"""
This function is called to load the white theme with
all its icons for the buttons and the css file.
Args:
application: the cureent app instance
"""
# load buttons
pixmap_icon = QtGui.QPixmap("./assets/images/add_white.png")
q_icon = QtGui.QIcon(pixmap_icon)
self.add_btn.setIcon(q_icon)
pixmap_icon = QtGui.QPixmap("./assets/images/trash_white.png")
q_icon = QtGui.QIcon(pixmap_icon)
self.delete_btn.setIcon(q_icon)
pixmap_icon = QtGui.QPixmap("./assets/images/diskette_white.png")
q_icon = QtGui.QIcon(pixmap_icon)
self.save_btn.setIcon(q_icon)
pixmap_icon = QtGui.QPixmap("./assets/images/up-arrow_white.png")
q_icon = QtGui.QIcon(pixmap_icon)
self.input_btn.setIcon(q_icon)
pixmap_icon = QtGui.QPixmap("./assets/images/folder_white.png")
q_icon = QtGui.QIcon(pixmap_icon)
self.output_btn.setIcon(q_icon)
@pyqtSlot(int)
def select_default_pip(self, index):
"""
This is the slot for the Pipeline combobox in the ui
Args:
index: index of the option currently selected
"""
# delete current pipeline
self.trash_pipeline()
# get url and name
name, url = self.default_pips[index - 1]
# parse the json in the model
self.pipeline.load_pipeline_json(url)
print("PARSER" + str(self.pipeline.executed_cats[0].active_algorithm))
print("PARSER" + str(self.pipeline.executed_cats[1].active_algorithm))
# set the title
self.set_pip_title(name)
# Create an entry in the pipeline widget for every step in the pipeline
for i in range(0, len(self.pipeline.executed_cats)):
self.add_pipe_entry_new(i)
self.scroll_down_pip()
"""for widget in alg_widgets:
self.setting_widget_vbox_layout.addWidget(widget)"""
def trash_pipeline(self):
"""
This method clears the complete pipeline while users clicked the trash
button.
"""
# remove all entries in the pipeline list
while self.pip_widget_vbox_layout.count():
child = self.pip_widget_vbox_layout.takeAt(0)
child.widget().deleteLater()
while self.stackedWidget_Settings.currentWidget() is not None:
self.stackedWidget_Settings.removeWidget(self.stackedWidget_Settings.currentWidget())
self.settings_collapsable.setTitle("")
# remove the pipeline name
self.set_pip_title("")
# remove all entries int the executed_cats of the model pipeline
del self.pipeline.executed_cats[:]
# remove all widgets
del self.pip_widgets[:]
# remove category algorith dropdown
self.remove_cat_alg_dropdown()
# remove all entries from the pipeline model
del self.pipeline.executed_cats[:]
@pyqtSlot()
def run(self):
"""
This method runs the the pipeline by calling the process methode
in pipeline
"""
self.pipeline.process()
@pyqtSlot()
def set_input_url(self):
"""
This method sets the url for the input image in the pipeline.
"""
url = QtWidgets.QFileDialog.getOpenFileNames()
if url[0]:
print(url[0])
print(url[0][0])
self.lineEdit.setText(url[0][0])
self.pipeline.set_input(url[0][0])
@pyqtSlot()
def set_output_url(self):
"""
This method sets the url for the output folder in the pipeline.
Args:
url: the url to the output folder a user selected in the ui
"""
url = QtWidgets.QFileDialog.getExistingDirectory()
if url:
print(url)
print(url)
self.custom_line_edit.setText(url)
self.pipeline.set_output_dir(url)
def load_favorite_pipelines(self):
"""
Scans the directory for default pipelines to display all available items
"""
self.fav_pips_combo_box.addItem("Please Select")
# scan the directory for default pipelines
for file in os.listdir("./_default_pipelines"):
if file.endswith(".json"):
name = file.split(".")[0]
url = os.path.abspath("./_default_pipelines" + "/" + file)
self.default_pips.append([name, url])
self.fav_pips_combo_box.addItem(name)
@pyqtSlot()
def save_pipeline(self):
"""
Saves the pipeline as a json at the users file system.
"""
url = str(QtWidgets.QFileDialog.getSaveFileName()[0])
split_list = url.split("/")
name = split_list[len(split_list) - 1].split(".")[0]
del split_list[len(split_list) - 1]
url = url.replace(name, "")
self.pipeline.save_pipeline_json(name, url)
@pyqtSlot(int)
def remove_pip_entry(self, pipe_entry_widget, settings_widget, cat=None):
"""
Removes the pip entry at the given position in the ui
Args:
pipeline_index (object):
settings_widget:
position: position at which the pip entry gets removed
"""
# remove pipeline entry widget from ui
self.pip_widget_vbox_layout.removeWidget(pipe_entry_widget)
pipe_entry_widget.deleteLater()
# remove it settings widgets from ui
if settings_widget is not None:
if self.stackedWidget_Settings.currentWidget() == settings_widget:
self.stackedWidget_Settings.hide()
self.remove_cat_alg_dropdown()
self.settings_collapsable.setTitle("Settings")
self.stackedWidget_Settings.removeWidget(settings_widget)
# remove in model
if cat is not None:
print("Remove entry at pos " + str(self.pipeline.get_index(cat)) + " " + str(cat))
self.pipeline.delete_category(self.pipeline.get_index(cat))
def change_pip_entry_alg(self, position, new_category, new_algorithm, pipe_entry_widget, settings_widget):
"""
Changes the selected algorithm of the pipeline entry at the position.
Afterwards create all widgets for this algorithm instance
Args:
position: the position of the pipeline entry
algorithm: the selected algorithm for this category
"""
print("Position to be changed:" + str(position))
print("Pipeline length: " + str(len(self.pipeline.executed_cats)))
old_cat = self.pipeline.executed_cats[position]
old_alg = old_cat.active_algorithm
print("Old Cat found in pipeline: " + str(old_cat))
print("Old Alg: found in pipeline:" + str(old_alg))
print("New Category given:" + str(new_category))
print("New Algorithm given:" + str(new_algorithm))
# set in model
self.pipeline.change_category(new_category, position)
self.pipeline.change_algorithm(new_algorithm, position)
new_cat = self.pipeline.executed_cats[position]
new_alg = new_cat.active_algorithm
# change settings widgets
self.remove_pip_entry(pipe_entry_widget, settings_widget)
(new_pipe_entry_widget, new_settings_widget) = self.add_pipe_entry_new(position)
self.stackedWidget_Settings.show()
self.stackedWidget_Settings.setCurrentIndex(position)
self.settings_collapsable.setTitle(new_alg.get_name() + " Settings")
self.remove_cat_alg_dropdown()
self.create_cat_alg_dropdown(position, new_pipe_entry_widget, new_settings_widget)
self.set_cat_alg_dropdown(new_cat, new_alg)
print("New Cat found in pipeline: " + str(new_cat))
print("New Alg found in pipeline: " + str(new_alg))
def load_settings_widgets_from_pipeline_groupbox(self, position):
"""
Extracts all widgets from a single algorithm and returns a QBoxLayout
Args:
alg: the alg instance we extract from
Returns: a QBoxLayout containing all widgets for this particular alg.
"""
alg = self.pipeline.executed_cats[position].active_algorithm
print("alg " + str(alg))
print("cat " + str(self.pipeline.executed_cats[position]))
empty_flag = True
groupOfSliders = QGroupBox()
sp = QSizePolicy()
sp.setVerticalPolicy(QSizePolicy.Preferred)
# groupOfSliders.setSizePolicy(sp)
groupOfSliderssLayout = QBoxLayout(QBoxLayout.TopToBottom)
groupOfSliderssLayout.setContentsMargins(0, -0, -0, 0)
groupOfSliderssLayout.setAlignment(Qt.AlignTop)
groupOfSliderssLayout.setSpacing(0)
print("Build Slider @ "+ str(position))
# create integer sliders
for slider in alg.integer_sliders:
empty_flag = False
print("slider.value " + str(slider.value))
print("slider " + str(slider))
#print(alg.get_name() + ": add slider (int).")
groupOfSliderssLayout.addWidget(
SliderWidget(slider.name, slider.lower, slider.upper, slider.step_size, slider.value,
slider.set_value, False))
# create float sliders
for slider in alg.float_sliders:
empty_flag = False
#print(alg.get_name() + ": add slider (float).")
groupOfSliderssLayout.addWidget(
SliderWidget(slider.name, slider.lower, slider.upper, slider.step_size, slider.value,
slider.set_value, True), 0, Qt.AlignTop)
# create checkboxes
for checkbox in alg.checkboxes:
empty_flag = False
#print(alg.get_name() + ": add checkbox.")
groupOfSliderssLayout.addWidget(CheckBoxWidget(checkbox.name, checkbox.value, checkbox.set_value), 0,
Qt.AlignTop)
# create dropdowns
for combobox in alg.drop_downs:
empty_flag = False
#print(alg.get_name() + ": add combobox.")
groupOfSliderssLayout.addWidget(
ComboBoxWidget(combobox.name, combobox.options, combobox.set_value, combobox.value), 0, Qt.AlignTop)
if empty_flag:
label = QLabel()
label.setText("This algorithm has no Settings.")
groupOfSliderssLayout.addWidget(label, 0, Qt.AlignHCenter)
groupOfSliders.setLayout(groupOfSliderssLayout)
return groupOfSliders
def create_cat_alg_dropdown(self, cat_position, pipe_entry_widget, settings_widget):
"""
Args:
last_cat (object):
"""
layout = self.select_cat_alg_vbox_layout
cat = self.pipeline.executed_cats[cat_position]
last_cat = None
# Show only allowed categories in dropdown
if len(self.pipeline.executed_cats) > 1:
last_cat = self.pipeline.executed_cats[cat_position - 1]
# Combobox for selecting Category
self.ComboxCategories.show()
self.ComboxCategories.setFixedHeight(30)
self.ComboxCategories.addItem("<Please Select Category>")
self.stackedWidgetComboxesAlgorithms = QStackedWidget()
self.stackedWidgetComboxesAlgorithms.setFixedHeight(30)
self.stackedWidgetComboxesAlgorithms.hide()
def setCurrentIndexCat(index):
#print("Set Cat")
if self.ComboxCategories.currentIndex() == 0:
self.stackedWidgetComboxesAlgorithms.hide()
else:
self.stackedWidgetComboxesAlgorithms.show()
self.stackedWidgetComboxesAlgorithms.setCurrentIndex(index - 1)
for category_name in self.pipeline.report_available_cats(last_cat):
# Add Category to combobox
self.ComboxCategories.addItem(category_name)
tmp1 = QComboBox()
tmp1.addItem("<Please Select Algorithm>")
tmp1.setFixedHeight(30)
category = self.pipeline.get_category(category_name)
#self.current_index = -1
def setCurrentIndexAlg(index):
if self.ComboxCategories.currentIndex() == 0 or self.stackedWidgetComboxesAlgorithms.currentWidget().currentIndex() == 0:
pass
else: #self.current_index != index:
self.change_pip_entry_alg(self.pipeline.get_index(cat), self.ComboxCategories.currentText(),
self.stackedWidgetComboxesAlgorithms.currentWidget().currentText(),
pipe_entry_widget, settings_widget)
#self.current_index = index
tmp1.activated.connect(setCurrentIndexAlg)
for algorithm_name in self.pipeline.get_all_algorithm_list(category):
tmp1.addItem(algorithm_name)
self.stackedWidgetComboxesAlgorithms.addWidget(tmp1)
layout.addWidget(self.ComboxCategories)
layout.addWidget(self.stackedWidgetComboxesAlgorithms)
self.ComboxCategories.activated.connect(setCurrentIndexCat)
def set_cat_alg_dropdown(self, category, algorithm):
indexC = self.ComboxCategories.findText(category.get_name())
#print("IndexC " + str(indexC))
self.ComboxCategories.setCurrentIndex(indexC)
self.stackedWidgetComboxesAlgorithms.show()
self.stackedWidgetComboxesAlgorithms.setCurrentIndex(indexC - 1)
indexA = self.stackedWidgetComboxesAlgorithms.currentWidget().findText(algorithm.get_name())
#print("IndexA " + str(indexA))
self.stackedWidgetComboxesAlgorithms.currentWidget().setCurrentIndex(indexA)
def remove_cat_alg_dropdown(self):
"""
Returns:
object:
"""
self.ComboxCategories.clear()
while self.stackedWidgetComboxesAlgorithms.currentWidget() is not None:
self.stackedWidgetComboxesAlgorithms.removeWidget(self.stackedWidgetComboxesAlgorithms.currentWidget())
while self.select_cat_alg_vbox_layout.count():
child = self.select_cat_alg_vbox_layout.takeAt(0)
child.widget().hide()
def scroll_down_pip(self):
self.pip_scroll.verticalScrollBar().setSliderPosition(self.pip_scroll.verticalScrollBar().maximum())
def add_pipe_entry_new(self, position=None):
"""
Creates a entry in the ui pipeline with a given position in pipeline.
It also creates the corresponding settings widget.
"""
# create an widget that displays the pip entry in the ui and connect the remove button
pip_main_widget = QWidget()
pip_main_widget.setFixedHeight(70)
pip_main_widget.setFixedWidth(300)
pip_main_layout = QHBoxLayout()
pip_main_widget.setLayout(pip_main_layout)
new_marker = False
if position is None:
position = len(self.pipeline.executed_cats)
cat = self.pipeline.new_category(position)
label = "<Click to specify new step>"
icon = None
new_marker = True
else:
cat = self.pipeline.executed_cats[position]
alg = cat.active_algorithm
label = alg.get_name()
icon = cat.get_icon()
new_marker = False
pixmap = QPixmap(icon)
pixmap_scaled_keeping_aspec = pixmap.scaled(30, 30, QtCore.Qt.KeepAspectRatio)
pixmap_label = QtWidgets.QLabel()
pixmap_label.setPixmap(pixmap_scaled_keeping_aspec)
pip_up_down = QWidget()
pip_up_down.setFixedHeight(70)
pip_up_down_layout = QVBoxLayout()
pip_up_down.setLayout(pip_up_down_layout)
up_btn = QToolButton()
dw_btn = QToolButton()
up_btn.setArrowType(Qt.UpArrow)
up_btn.setFixedHeight(25)
dw_btn.setArrowType(Qt.DownArrow)
dw_btn.setFixedHeight(25)
pip_up_down_layout.addWidget(up_btn)
pip_up_down_layout.addWidget(dw_btn)
string_label = QLabel()
string_label.setText(label)
string_label.setFixedWidth(210)
btn = QtWidgets.QPushButton()
btn.setFixedSize(20, 20)
pixmap_icon = QtGui.QPixmap("./assets/images/delete_x_white.png")
q_icon = QtGui.QIcon(pixmap_icon)
btn.setIcon(q_icon)
pip_main_layout.addWidget(pip_up_down, Qt.AlignVCenter)
pip_main_layout.addWidget(pixmap_label, Qt.AlignVCenter)
pip_main_layout.addWidget(string_label, Qt.AlignLeft)
pip_main_layout.addWidget(btn, Qt.AlignVCenter)
self.pip_widget_vbox_layout.insertWidget(position, pip_main_widget)
# Create the corresponding settings widget and connect it
self.settings_collapsable.setTitle("Settings")
self.stackedWidget_Settings.hide()
settings_main_widget = None
if not new_marker:
settings_main_widget = self.load_settings_widgets_from_pipeline_groupbox(position)
self.stackedWidget_Settings.insertWidget(position, settings_main_widget)
def show_settings():
# Set background color while widget is selected. Doesn't work because of theme? *TODO*
p = pip_main_widget.palette()
p.setColor(pip_main_widget.backgroundRole(), Qt.red)
pip_main_widget.setPalette(p)
if not new_marker:
self.stackedWidget_Settings.show()
self.stackedWidget_Settings.setCurrentIndex(self.pipeline.get_index(cat))
self.settings_collapsable.setTitle(alg.get_name() + " Settings")
else:
self.stackedWidget_Settings.hide()
# Create drop down for cats and algs
self.remove_cat_alg_dropdown()
self.create_cat_alg_dropdown(self.pipeline.get_index(cat), pip_main_widget, settings_main_widget)
if not new_marker:
self.set_cat_alg_dropdown(cat, alg)
# Connect Button to remove step from pipeline
def delete_button_clicked():
self.remove_cat_alg_dropdown()
self.remove_pip_entry(pip_main_widget, settings_main_widget, cat)
self.clickable(pixmap_label).connect(show_settings)
self.clickable(string_label).connect(show_settings)
btn.clicked.connect(delete_button_clicked)
return (pip_main_widget, settings_main_widget)
def add_pip_entry_empty(self):
"""
Creates an blank entry in the ui pipeline since the user still needs to specify
a type and an algorithm of the category.
It also creates the corresponding settings widget.
"""
# create an widget that displays the pip entry in the ui and connect the remove button
pip_main_widget = QWidget()
pip_main_widget.setFixedHeight(70)
pip_main_widget.setFixedWidth(300)
pip_main_layout = QHBoxLayout()
pip_main_widget.setLayout(pip_main_layout)
label = "<Click to specify new step>"
icon = None
pixmap = QPixmap(icon)
pixmap_scaled_keeping_aspec = pixmap.scaled(30, 30, QtCore.Qt.KeepAspectRatio)
pixmap_label = QtWidgets.QLabel()
pixmap_label.setPixmap(pixmap_scaled_keeping_aspec)
pip_up_down = QWidget()
pip_up_down.setFixedHeight(70)
pip_up_down_layout = QVBoxLayout()
pip_up_down.setLayout(pip_up_down_layout)
up_btn = QToolButton()
dw_btn = QToolButton()
up_btn.setArrowType(Qt.UpArrow)
up_btn.setFixedHeight(25)
dw_btn.setArrowType(Qt.DownArrow)
dw_btn.setFixedHeight(25)
pip_up_down_layout.addWidget(up_btn)
pip_up_down_layout.addWidget(dw_btn)
string_label = QLabel()
string_label.setText(label)
string_label.setFixedWidth(210)
btn = QtWidgets.QPushButton()
btn.setFixedSize(20, 20)
pixmap_icon = QtGui.QPixmap("./assets/images/delete_x_white.png")
q_icon = QtGui.QIcon(pixmap_icon)
btn.setIcon(q_icon)
pip_main_layout.addWidget(pip_up_down, Qt.AlignVCenter)
pip_main_layout.addWidget(pixmap_label, Qt.AlignVCenter)
pip_main_layout.addWidget(string_label, Qt.AlignLeft)
pip_main_layout.addWidget(btn, Qt.AlignVCenter)
cat_position = len(self.pipeline.executed_cats)
self.pip_widget_vbox_layout.insertWidget(cat_position, pip_main_widget)
index = self.pip_widget_vbox_layout.indexOf(pip_main_widget)
#print(index)
# Create the corresponding empty settings widget and connect it
# settings = self.load_widgets_from_cat_groupbox(cat_position) *TODO* EMPTY
self.settings_collapsable.setTitle("Settings")
self.stackedWidget_Settings.hide()
# Add new step to pipeline
new_category = self.pipeline.new_category(cat_position)
print("Create new entry " + str(new_category))
print("Pipeline length: " + str(len(self.pipeline.executed_cats)) + ".")
settings_main_widget = None
# Connect pipeline entry with corresponding settings widget
def show_settings():
#print("click")
self.stackedWidget_Settings.show()
self.remove_cat_alg_dropdown()
# Create drop down for cats and algs
self.create_cat_alg_dropdown(self.pipeline.get_index(new_category), pip_main_widget, settings_main_widget)
self.stackedWidget_Settings.hide()
# Connect Button to remove step from pipeline
def delete_button_clicked():
self.remove_cat_alg_dropdown()
self.remove_pip_entry(pip_main_widget, settings_main_widget, new_category)
self.clickable(pixmap_label).connect(show_settings)
self.clickable(string_label).connect(show_settings)
btn.clicked.connect(delete_button_clicked)
self.scroll_down_pip()
def add_pip_entry(self, cat_position):
"""
Creates a entry in the ui pipeline with a given position in pipeline.
It also creates the corresponding settings widget.
"""
# create an widget that displays the pip entry in the ui and connect the remove button
pip_main_widget = QWidget()
pip_main_widget.setFixedHeight(70)
pip_main_widget.setFixedWidth(300)
pip_main_layout = QHBoxLayout()
pip_main_widget.setLayout(pip_main_layout)
cat = self.pipeline.executed_cats[cat_position]
alg = cat.active_algorithm
label = alg.get_name()
icon = cat.get_icon()
pixmap = QPixmap(icon)
pixmap_scaled_keeping_aspec = pixmap.scaled(30, 30, QtCore.Qt.KeepAspectRatio)
pixmap_label = QtWidgets.QLabel()
pixmap_label.setPixmap(pixmap_scaled_keeping_aspec)
pip_up_down = QWidget()
pip_up_down.setFixedHeight(70)
pip_up_down_layout = QVBoxLayout()
pip_up_down.setLayout(pip_up_down_layout)
up_btn = QToolButton()
dw_btn = QToolButton()
up_btn.setArrowType(Qt.UpArrow)
up_btn.setFixedHeight(25)
dw_btn.setArrowType(Qt.DownArrow)
dw_btn.setFixedHeight(25)
pip_up_down_layout.addWidget(up_btn)
pip_up_down_layout.addWidget(dw_btn)
string_label = QLabel()
string_label.setText(label)
string_label.setFixedWidth(210)
btn = QtWidgets.QPushButton()
btn.setFixedSize(20, 20)
pixmap_icon = QtGui.QPixmap("./assets/images/delete_x_white.png")
q_icon = QtGui.QIcon(pixmap_icon)
btn.setIcon(q_icon)
pip_main_layout.addWidget(pip_up_down, Qt.AlignVCenter)
pip_main_layout.addWidget(pixmap_label, Qt.AlignVCenter)
pip_main_layout.addWidget(string_label, Qt.AlignLeft)
pip_main_layout.addWidget(btn, Qt.AlignVCenter)
self.pip_widget_vbox_layout.insertWidget(cat_position, pip_main_widget)
index = self.pip_widget_vbox_layout.indexOf(pip_main_widget)
#print(index)
# Create the corresponding settings widget and connect it
settings_main_widget = self.load_settings_widgets_from_pipeline_groupbox(cat_position)
self.settings_collapsable.setTitle("Settings")
self.stackedWidget_Settings.hide()
self.stackedWidget_Settings.insertWidget(cat_position, settings_main_widget)
#print("Read from pipeline entry " + str(cat))
#print("Pipeline length: " + str(len(self.pipeline.executed_cats)) + ".")
def show_settings():
# Set background color while widget is selected. Doesn't work because of theme? *TODO*
p = pip_main_widget.palette()
p.setColor(pip_main_widget.backgroundRole(), Qt.red)
pip_main_widget.setPalette(p)
self.stackedWidget_Settings.show()
self.stackedWidget_Settings.setCurrentIndex(self.pipeline.get_index(cat))
self.settings_collapsable.setTitle(alg.get_name() + " Settings")
self.remove_cat_alg_dropdown()
# Create drop down for cats and algs
self.create_cat_alg_dropdown(self.pipeline.get_index(cat), pip_main_widget, settings_main_widget)
#print(cat)
#print(alg)
self.set_cat_alg_dropdown(cat, alg)
# Connect Button to remove step from pipeline
def delete_button_clicked():
self.remove_pip_entry(pip_main_widget, settings_main_widget, cat)
self.clickable(pixmap_label).connect(show_settings)
self.clickable(string_label).connect(show_settings)
btn.clicked.connect(delete_button_clicked)
return (pip_main_widget, settings_main_widget)
# https://wiki.python.org/moin/PyQt/Making%20non-clickable%20widgets%20clickable
def clickable(self, widget):
"""
Convert any widget to a clickable widget.
"""
class Filter(QObject):
clicked = pyqtSignal()
def eventFilter(self, obj, event):
if obj == widget:
if event.type() == QEvent.MouseButtonPress:
if obj.rect().contains(event.pos()):
self.clicked.emit()
# The developer can opt for .emit(obj) to get the object within the slot.
return True
return False
filter = Filter(widget)
widget.installEventFilter(filter)
return filter.clicked
class AccountCreationPresenter(QWidget):
"""
Handles data-validation, saving, and transitions between frames
"""
should_load_main_app = pyqtSignal(Account) # Signal to reload LandingWindow
def __init__(self, parent: QObject):
super().__init__(parent)
self.__layout_manager = QVBoxLayout(self)
self.__slide_stack = QStackedWidget() # Stores the various frames for creating an account
self.__proceed_btn = QPushButton("Get Started") # Changes to say next or finish, slide-depending
# Connect events
self.__proceed_btn.clicked.connect(self.__proceed_btn_was_clicked)
self.__setup_ui()
@QtCore.pyqtSlot()
def __proceed_btn_was_clicked(self):
curr_idx = self.__slide_stack.currentIndex()
if curr_idx == 0 and self.__slide_stack.isHidden():
# Get Started, must show
self.__slide_stack.show()
self.__proceed_btn.setText("Next")
elif self.__slide_stack.currentWidget().is_valid():
if curr_idx + 1 == self.__slide_stack.count() - 1:
# Second to last slide\
self.__proceed_btn.setText("Finish")
self.__slide_stack.setCurrentIndex(curr_idx + 1)
elif curr_idx == self.__slide_stack.count() - 1:
# Last slide
# Save account data to global
account = Account()
for i in range(self.__slide_stack.count()):
self.__slide_stack.widget(i).fill_account_details(account)
write_to_data_file(DataType.USER, FileName.GLOBAL, account, False)
# Port-forward, if approved
self.hide()
self.should_load_main_app.emit(account)
else:
self.__slide_stack.setCurrentIndex(curr_idx + 1)
def __setup_ui(self):
# Create frames and populate stack
self.__slide_stack.addWidget(AccountDetailsFrame(self.__slide_stack))
self.__slide_stack.addWidget(NetworkDetailsFrame(self.__slide_stack))
self.__slide_stack.hide()
# Set up welcome top-half
content_frame = QFrame()
content_frame.setFrameShape(QFrame.StyledPanel)
content_frame.setFrameShadow(QFrame.Raised)
content_frame.setObjectName("create-account-top")
content_layout = QVBoxLayout(content_frame)
# # Create labels
welcome_lbl = QLabel('Welcome to UChat.')
welcome_lbl.setObjectName('create-account-welcome')
sub_lbl = QLabel('A secure and stateless, peer-to-peer messaging client')
sub_lbl.setObjectName('sub-lbl')
#
# # Create separation line
line = QFrame()
line.setFixedHeight(1)
line.setObjectName("line")
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
# Configure proceed button
self.__proceed_btn.setFixedSize(QSize(85, 35))
# # Layout
content_layout.addWidget(welcome_lbl)
content_layout.addWidget(sub_lbl)
content_layout.addSpacing(10)
content_layout.addWidget(line)
content_layout.addWidget(self.__slide_stack)
self.__layout_manager.addWidget(content_frame)
self.__layout_manager.addSpacing(35)
self.__layout_manager.addWidget(self.__proceed_btn)
self.__layout_manager.addStretch()
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 E5SideBar(QWidget):
"""
Class implementing a sidebar with a widget area, that is hidden or shown,
if the current tab is clicked again.
"""
Version = 1
North = 0
East = 1
South = 2
West = 3
def __init__(self, orientation=None, delay=200, parent=None):
"""
Constructor
@param orientation orientation of the sidebar widget (North, East,
South, West)
@param delay value for the expand/shrink delay in milliseconds
(integer)
@param parent parent widget (QWidget)
"""
super(E5SideBar, self).__init__(parent)
self.__tabBar = QTabBar()
self.__tabBar.setDrawBase(True)
self.__tabBar.setShape(QTabBar.RoundedNorth)
self.__tabBar.setUsesScrollButtons(True)
self.__tabBar.setDrawBase(False)
self.__stackedWidget = QStackedWidget(self)
self.__stackedWidget.setContentsMargins(0, 0, 0, 0)
self.__autoHideButton = QToolButton()
self.__autoHideButton.setCheckable(True)
self.__autoHideButton.setIcon(
UI.PixmapCache.getIcon("autoHideOff.png"))
self.__autoHideButton.setChecked(True)
self.__autoHideButton.setToolTip(
self.tr("Deselect to activate automatic collapsing"))
self.barLayout = QBoxLayout(QBoxLayout.LeftToRight)
self.barLayout.setContentsMargins(0, 0, 0, 0)
self.layout = QBoxLayout(QBoxLayout.TopToBottom)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.setSpacing(0)
self.barLayout.addWidget(self.__autoHideButton)
self.barLayout.addWidget(self.__tabBar)
self.layout.addLayout(self.barLayout)
self.layout.addWidget(self.__stackedWidget)
self.setLayout(self.layout)
# initialize the delay timer
self.__actionMethod = None
self.__delayTimer = QTimer(self)
self.__delayTimer.setSingleShot(True)
self.__delayTimer.setInterval(delay)
self.__delayTimer.timeout.connect(self.__delayedAction)
self.__minimized = False
self.__minSize = 0
self.__maxSize = 0
self.__bigSize = QSize()
self.splitter = None
self.splitterSizes = []
self.__hasFocus = False
# flag storing if this widget or any child has the focus
self.__autoHide = False
self.__tabBar.installEventFilter(self)
self.__orientation = E5SideBar.North
if orientation is None:
orientation = E5SideBar.North
self.setOrientation(orientation)
self.__tabBar.currentChanged[int].connect(
self.__stackedWidget.setCurrentIndex)
e5App().focusChanged[QWidget, QWidget].connect(self.__appFocusChanged)
self.__autoHideButton.toggled[bool].connect(self.__autoHideToggled)
def setSplitter(self, splitter):
"""
Public method to set the splitter managing the sidebar.
@param splitter reference to the splitter (QSplitter)
"""
self.splitter = splitter
self.splitter.splitterMoved.connect(self.__splitterMoved)
self.splitter.setChildrenCollapsible(False)
index = self.splitter.indexOf(self)
self.splitter.setCollapsible(index, False)
def __splitterMoved(self, pos, index):
"""
Private slot to react on splitter moves.
@param pos new position of the splitter handle (integer)
@param index index of the splitter handle (integer)
"""
if self.splitter:
self.splitterSizes = self.splitter.sizes()
def __delayedAction(self):
"""
Private slot to handle the firing of the delay timer.
"""
if self.__actionMethod is not None:
self.__actionMethod()
def setDelay(self, delay):
"""
Public method to set the delay value for the expand/shrink delay in
milliseconds.
@param delay value for the expand/shrink delay in milliseconds
(integer)
"""
self.__delayTimer.setInterval(delay)
def delay(self):
"""
Public method to get the delay value for the expand/shrink delay in
milliseconds.
@return value for the expand/shrink delay in milliseconds (integer)
"""
return self.__delayTimer.interval()
def __cancelDelayTimer(self):
"""
Private method to cancel the current delay timer.
"""
self.__delayTimer.stop()
self.__actionMethod = None
def shrink(self):
"""
Public method to record a shrink request.
"""
self.__delayTimer.stop()
self.__actionMethod = self.__shrinkIt
self.__delayTimer.start()
def __shrinkIt(self):
"""
Private method to shrink the sidebar.
"""
self.__minimized = True
self.__bigSize = self.size()
if self.__orientation in [E5SideBar.North, E5SideBar.South]:
self.__minSize = self.minimumSizeHint().height()
self.__maxSize = self.maximumHeight()
else:
self.__minSize = self.minimumSizeHint().width()
self.__maxSize = self.maximumWidth()
if self.splitter:
self.splitterSizes = self.splitter.sizes()
self.__stackedWidget.hide()
if self.__orientation in [E5SideBar.North, E5SideBar.South]:
self.setFixedHeight(self.__tabBar.minimumSizeHint().height())
else:
self.setFixedWidth(self.__tabBar.minimumSizeHint().width())
self.__actionMethod = None
def expand(self):
"""
Public method to record a expand request.
"""
self.__delayTimer.stop()
self.__actionMethod = self.__expandIt
self.__delayTimer.start()
def __expandIt(self):
"""
Private method to expand the sidebar.
"""
self.__minimized = False
self.__stackedWidget.show()
self.resize(self.__bigSize)
if self.__orientation in [E5SideBar.North, E5SideBar.South]:
minSize = max(self.__minSize, self.minimumSizeHint().height())
self.setMinimumHeight(minSize)
self.setMaximumHeight(self.__maxSize)
else:
minSize = max(self.__minSize, self.minimumSizeHint().width())
self.setMinimumWidth(minSize)
self.setMaximumWidth(self.__maxSize)
if self.splitter:
self.splitter.setSizes(self.splitterSizes)
self.__actionMethod = None
def isMinimized(self):
"""
Public method to check the minimized state.
@return flag indicating the minimized state (boolean)
"""
return self.__minimized
def isAutoHiding(self):
"""
Public method to check, if the auto hide function is active.
@return flag indicating the state of auto hiding (boolean)
"""
return self.__autoHide
def eventFilter(self, obj, evt):
"""
Public method to handle some events for the tabbar.
@param obj reference to the object (QObject)
@param evt reference to the event object (QEvent)
@return flag indicating, if the event was handled (boolean)
"""
if obj == self.__tabBar:
if evt.type() == QEvent.MouseButtonPress:
pos = evt.pos()
for i in range(self.__tabBar.count()):
if self.__tabBar.tabRect(i).contains(pos):
break
if i == self.__tabBar.currentIndex():
if self.isMinimized():
self.expand()
else:
self.shrink()
return True
elif self.isMinimized():
self.expand()
elif evt.type() == QEvent.Wheel:
if qVersion() >= "5.0.0":
delta = evt.angleDelta().y()
else:
delta = evt.delta()
if delta > 0:
self.prevTab()
else:
self.nextTab()
return True
return QWidget.eventFilter(self, obj, evt)
def addTab(self, widget, iconOrLabel, label=None):
"""
Public method to add a tab to the sidebar.
@param widget reference to the widget to add (QWidget)
@param iconOrLabel reference to the icon or the label text of the tab
(QIcon, string)
@param label the labeltext of the tab (string) (only to be
used, if the second parameter is a QIcon)
"""
if label:
index = self.__tabBar.addTab(iconOrLabel, label)
self.__tabBar.setTabToolTip(index, label)
else:
index = self.__tabBar.addTab(iconOrLabel)
self.__tabBar.setTabToolTip(index, iconOrLabel)
self.__stackedWidget.addWidget(widget)
if self.__orientation in [E5SideBar.North, E5SideBar.South]:
self.__minSize = self.minimumSizeHint().height()
else:
self.__minSize = self.minimumSizeHint().width()
def insertTab(self, index, widget, iconOrLabel, label=None):
"""
Public method to insert a tab into the sidebar.
@param index the index to insert the tab at (integer)
@param widget reference to the widget to insert (QWidget)
@param iconOrLabel reference to the icon or the labeltext of the tab
(QIcon, string)
@param label the labeltext of the tab (string) (only to be
used, if the second parameter is a QIcon)
"""
if label:
index = self.__tabBar.insertTab(index, iconOrLabel, label)
self.__tabBar.setTabToolTip(index, label)
else:
index = self.__tabBar.insertTab(index, iconOrLabel)
self.__tabBar.setTabToolTip(index, iconOrLabel)
self.__stackedWidget.insertWidget(index, widget)
if self.__orientation in [E5SideBar.North, E5SideBar.South]:
self.__minSize = self.minimumSizeHint().height()
else:
self.__minSize = self.minimumSizeHint().width()
def removeTab(self, index):
"""
Public method to remove a tab.
@param index the index of the tab to remove (integer)
"""
self.__stackedWidget.removeWidget(self.__stackedWidget.widget(index))
self.__tabBar.removeTab(index)
if self.__orientation in [E5SideBar.North, E5SideBar.South]:
self.__minSize = self.minimumSizeHint().height()
else:
self.__minSize = self.minimumSizeHint().width()
def clear(self):
"""
Public method to remove all tabs.
"""
while self.count() > 0:
self.removeTab(0)
def prevTab(self):
"""
Public slot used to show the previous tab.
"""
ind = self.currentIndex() - 1
if ind == -1:
ind = self.count() - 1
self.setCurrentIndex(ind)
self.currentWidget().setFocus()
def nextTab(self):
"""
Public slot used to show the next tab.
"""
ind = self.currentIndex() + 1
if ind == self.count():
ind = 0
self.setCurrentIndex(ind)
self.currentWidget().setFocus()
def count(self):
"""
Public method to get the number of tabs.
@return number of tabs in the sidebar (integer)
"""
return self.__tabBar.count()
def currentIndex(self):
"""
Public method to get the index of the current tab.
@return index of the current tab (integer)
"""
return self.__stackedWidget.currentIndex()
def setCurrentIndex(self, index):
"""
Public slot to set the current index.
@param index the index to set as the current index (integer)
"""
self.__tabBar.setCurrentIndex(index)
self.__stackedWidget.setCurrentIndex(index)
if self.isMinimized():
self.expand()
def currentWidget(self):
"""
Public method to get a reference to the current widget.
@return reference to the current widget (QWidget)
"""
return self.__stackedWidget.currentWidget()
def setCurrentWidget(self, widget):
"""
Public slot to set the current widget.
@param widget reference to the widget to become the current widget
(QWidget)
"""
self.__stackedWidget.setCurrentWidget(widget)
self.__tabBar.setCurrentIndex(self.__stackedWidget.currentIndex())
if self.isMinimized():
self.expand()
def indexOf(self, widget):
"""
Public method to get the index of the given widget.
@param widget reference to the widget to get the index of (QWidget)
@return index of the given widget (integer)
"""
return self.__stackedWidget.indexOf(widget)
def isTabEnabled(self, index):
"""
Public method to check, if a tab is enabled.
@param index index of the tab to check (integer)
@return flag indicating the enabled state (boolean)
"""
return self.__tabBar.isTabEnabled(index)
def setTabEnabled(self, index, enabled):
"""
Public method to set the enabled state of a tab.
@param index index of the tab to set (integer)
@param enabled enabled state to set (boolean)
"""
self.__tabBar.setTabEnabled(index, enabled)
def orientation(self):
"""
Public method to get the orientation of the sidebar.
@return orientation of the sidebar (North, East, South, West)
"""
return self.__orientation
def setOrientation(self, orient):
"""
Public method to set the orientation of the sidebar.
@param orient orientation of the sidebar (North, East, South, West)
"""
if orient == E5SideBar.North:
self.__tabBar.setShape(QTabBar.RoundedNorth)
self.__tabBar.setSizePolicy(
QSizePolicy.Expanding, QSizePolicy.Preferred)
self.barLayout.setDirection(QBoxLayout.LeftToRight)
self.layout.setDirection(QBoxLayout.TopToBottom)
self.layout.setAlignment(self.barLayout, Qt.AlignLeft)
elif orient == E5SideBar.East:
self.__tabBar.setShape(QTabBar.RoundedEast)
self.__tabBar.setSizePolicy(
QSizePolicy.Preferred, QSizePolicy.Expanding)
self.barLayout.setDirection(QBoxLayout.TopToBottom)
self.layout.setDirection(QBoxLayout.RightToLeft)
self.layout.setAlignment(self.barLayout, Qt.AlignTop)
elif orient == E5SideBar.South:
self.__tabBar.setShape(QTabBar.RoundedSouth)
self.__tabBar.setSizePolicy(
QSizePolicy.Expanding, QSizePolicy.Preferred)
self.barLayout.setDirection(QBoxLayout.LeftToRight)
self.layout.setDirection(QBoxLayout.BottomToTop)
self.layout.setAlignment(self.barLayout, Qt.AlignLeft)
elif orient == E5SideBar.West:
self.__tabBar.setShape(QTabBar.RoundedWest)
self.__tabBar.setSizePolicy(
QSizePolicy.Preferred, QSizePolicy.Expanding)
self.barLayout.setDirection(QBoxLayout.TopToBottom)
self.layout.setDirection(QBoxLayout.LeftToRight)
self.layout.setAlignment(self.barLayout, Qt.AlignTop)
self.__orientation = orient
def tabIcon(self, index):
"""
Public method to get the icon of a tab.
@param index index of the tab (integer)
@return icon of the tab (QIcon)
"""
return self.__tabBar.tabIcon(index)
def setTabIcon(self, index, icon):
"""
Public method to set the icon of a tab.
@param index index of the tab (integer)
@param icon icon to be set (QIcon)
"""
self.__tabBar.setTabIcon(index, icon)
def tabText(self, index):
"""
Public method to get the text of a tab.
@param index index of the tab (integer)
@return text of the tab (string)
"""
return self.__tabBar.tabText(index)
def setTabText(self, index, text):
"""
Public method to set the text of a tab.
@param index index of the tab (integer)
@param text text to set (string)
"""
self.__tabBar.setTabText(index, text)
def tabToolTip(self, index):
"""
Public method to get the tooltip text of a tab.
@param index index of the tab (integer)
@return tooltip text of the tab (string)
"""
return self.__tabBar.tabToolTip(index)
def setTabToolTip(self, index, tip):
"""
Public method to set the tooltip text of a tab.
@param index index of the tab (integer)
@param tip tooltip text to set (string)
"""
self.__tabBar.setTabToolTip(index, tip)
def tabWhatsThis(self, index):
"""
Public method to get the WhatsThis text of a tab.
@param index index of the tab (integer)
@return WhatsThis text of the tab (string)
"""
return self.__tabBar.tabWhatsThis(index)
def setTabWhatsThis(self, index, text):
"""
Public method to set the WhatsThis text of a tab.
@param index index of the tab (integer)
@param text WhatsThis text to set (string)
"""
self.__tabBar.setTabWhatsThis(index, text)
def widget(self, index):
"""
Public method to get a reference to the widget associated with a tab.
@param index index of the tab (integer)
@return reference to the widget (QWidget)
"""
return self.__stackedWidget.widget(index)
def saveState(self):
"""
Public method to save the state of the sidebar.
@return saved state as a byte array (QByteArray)
"""
if len(self.splitterSizes) == 0:
if self.splitter:
self.splitterSizes = self.splitter.sizes()
self.__bigSize = self.size()
if self.__orientation in [E5SideBar.North, E5SideBar.South]:
self.__minSize = self.minimumSizeHint().height()
self.__maxSize = self.maximumHeight()
else:
self.__minSize = self.minimumSizeHint().width()
self.__maxSize = self.maximumWidth()
data = QByteArray()
stream = QDataStream(data, QIODevice.WriteOnly)
stream.setVersion(QDataStream.Qt_4_6)
stream.writeUInt16(self.Version)
stream.writeBool(self.__minimized)
stream << self.__bigSize
stream.writeUInt16(self.__minSize)
stream.writeUInt16(self.__maxSize)
stream.writeUInt16(len(self.splitterSizes))
for size in self.splitterSizes:
stream.writeUInt16(size)
stream.writeBool(self.__autoHide)
return data
def restoreState(self, state):
"""
Public method to restore the state of the sidebar.
@param state byte array containing the saved state (QByteArray)
@return flag indicating success (boolean)
"""
if state.isEmpty():
return False
if self.__orientation in [E5SideBar.North, E5SideBar.South]:
minSize = self.layout.minimumSize().height()
maxSize = self.maximumHeight()
else:
minSize = self.layout.minimumSize().width()
maxSize = self.maximumWidth()
data = QByteArray(state)
stream = QDataStream(data, QIODevice.ReadOnly)
stream.setVersion(QDataStream.Qt_4_6)
stream.readUInt16() # version
minimized = stream.readBool()
if minimized and not self.__minimized:
self.shrink()
stream >> self.__bigSize
self.__minSize = max(stream.readUInt16(), minSize)
self.__maxSize = max(stream.readUInt16(), maxSize)
count = stream.readUInt16()
self.splitterSizes = []
for i in range(count):
self.splitterSizes.append(stream.readUInt16())
self.__autoHide = stream.readBool()
self.__autoHideButton.setChecked(not self.__autoHide)
if not minimized:
self.expand()
return True
#######################################################################
## methods below implement the autohide functionality
#######################################################################
def __autoHideToggled(self, checked):
"""
Private slot to handle the toggling of the autohide button.
@param checked flag indicating the checked state of the button
(boolean)
"""
self.__autoHide = not checked
if self.__autoHide:
self.__autoHideButton.setIcon(
UI.PixmapCache.getIcon("autoHideOn.png"))
else:
self.__autoHideButton.setIcon(
UI.PixmapCache.getIcon("autoHideOff.png"))
def __appFocusChanged(self, old, now):
"""
Private slot to handle a change of the focus.
@param old reference to the widget, that lost focus (QWidget or None)
@param now reference to the widget having the focus (QWidget or None)
"""
self.__hasFocus = self.isAncestorOf(now)
if self.__autoHide and not self.__hasFocus and not self.isMinimized():
self.shrink()
elif self.__autoHide and self.__hasFocus and self.isMinimized():
self.expand()
def enterEvent(self, event):
"""
Protected method to handle the mouse entering this widget.
@param event reference to the event (QEvent)
"""
if self.__autoHide and self.isMinimized():
self.expand()
else:
self.__cancelDelayTimer()
def leaveEvent(self, event):
"""
Protected method to handle the mouse leaving this widget.
@param event reference to the event (QEvent)
"""
if self.__autoHide and not self.__hasFocus and not self.isMinimized():
self.shrink()
else:
self.__cancelDelayTimer()
def shutdown(self):
"""
Public method to shut down the object.
This method does some preparations so the object can be deleted
properly. It disconnects from the focusChanged signal in order to
avoid trouble later on.
"""
e5App().focusChanged[QWidget, QWidget].disconnect(
self.__appFocusChanged)
class Manager(QWidget, Widget2, Widget1):
def __init__(self):
super().__init__()
self.all_map = dict()
hbox1 = QHBoxLayout()
self.ladel_name = QLabel('путь до файла с логами')
self.main_name = QLineEdit()
self.ladel_name1 = QLabel('имя файла')
self.names1 = QLineEdit()
hbox2 = QHBoxLayout()
hbox2.addWidget(self.ladel_name1)
hbox2.addWidget(self.names1)
self.end_button = QPushButton('проверка сгенерированного файла')
self.Left_Bar()
self.names1.hide()
self.ladel_name1.hide()
self.stack2UI()
self.stack1UI()
self.Stack = QStackedWidget()
self.Stack.addWidget(self.stack1)
self.Stack.addWidget(self.stack2)
hbox = QHBoxLayout()
self.vbox = QVBoxLayout()
hbox1.addWidget(self.ladel_name)
hbox1.addWidget(self.main_name)
self.vbox.addLayout(hbox1)
self.vbox.addLayout(hbox2)
hbox.addWidget(self.leftlist)
hbox.addWidget(self.Stack)
self.vbox.addLayout(hbox)
self.vbox.addWidget(self.end_button)
self.setLayout(self.vbox)
self.Stack.setCurrentIndex(0)
self.leftlist.currentRowChanged.connect(self.display) # отображение одного из виджетов из стеквиджет
self.end_button.clicked.connect(self.check_all)
self.setGeometry(10, 10, 700, 500)
self.setWindowTitle('devops manager')
self.show()
def check_all(self):
self.leftlist.hide()
self.Stack.hide()
self.write_button = QPushButton('write')
self.main_name.hide()
self.ladel_name.hide()
self.end_button.hide()
self.names1.show()
self.ladel_name1.show()
self.tttt = QTextEdit()
temp_main_name = self.main_name.text()
self.all_text = temp_main_name + ' {\n'
for i,j in self.all_map.items():
if i == 'check time':
self.all_text += j
self.all_text += '\n'
else:
self.all_text += i;
self.all_text += ' '
self.all_text += j;
self.all_text += '\n'
self.all_text += '}'
self.tttt.setText(self.all_text)
self.vbox.addWidget(self.tttt)
self.vbox.addWidget(self.write_button)
self.write_button.clicked.connect(self.write_in_file)
def write_in_file(self):
ptr = os.getcwd()
names = self.names1.text()
path = os.path.join(ptr, names)
print(path)
f = open(path, 'w')
f.write(self.all_text)
f.close()
sys.exit()
def description(self, str_list):
if str_list == 'rotate':
self.leftlist.setToolTip('указывает сколько старых логов нужно хранить, в параметрах передается количество')
elif str_list == 'create':
self.leftlist.setToolTip('указывает, что необходимо создать пустой лог файл после перемещения старого')
elif str_list == 'dateext':
self.leftlist.setToolTip('добавляет дату ротации перед заголовком старого лога')
elif str_list == 'compress':
self.leftlist.setToolTip('указывает, что лог необходимо сжимать')
elif str_list == 'delaycompress':
self.leftlist.setToolTip('не сжимать последний и предпоследний журнал')
elif str_list == 'extension':
self.leftlist.setToolTip(' сохранять оригинальный лог файл после ротации, если у него указанное расширение')
elif str_list == 'mail':
self.leftlist.setToolTip('отправлять Email после завершения ротации')
elif str_list == 'maxage':
self.leftlist.setToolTip('выполнять ротацию журналов, если они старше, чем указано')
elif str_list == 'missingok':
self.leftlist.setToolTip('не выдавать ошибки, если лог файла не существует')
elif str_list == 'olddir':
self.leftlist.setToolTip('перемещать старые логи в отдельную папку')
elif str_list == 'start':
self.leftlist.setToolTip('номер, с которого будет начата нумерация старых логов')
elif str_list == 'size':
self.leftlist.setToolTip('размер лога, когда он будет перемещен')
else:
self.leftlist.setToolTip('')
def display(self, i):
self.Stack.setCurrentIndex(i) # возврат текущего индекса из списка левого меню
if i == 0:
self.Stack.setCurrentIndex(0)
else:
self.Stack.setCurrentIndex(1)
p = self.leftlist.currentItem()
self.description(p.text())
def Left_Bar(self):
self.leftlist = QListWidget()
self.leftlist.insertItem(0, 'check time')
self.leftlist.insertItem(1, 'rotate')
self.leftlist.insertItem(2, 'create')
self.leftlist.insertItem(3, 'dateext')
self.leftlist.insertItem(4, 'compress')
self.leftlist.insertItem(5, 'extension')
self.leftlist.insertItem(6, 'delaycompress')
self.leftlist.insertItem(7, 'mail')
self.leftlist.insertItem(8, 'missingok')
self.leftlist.insertItem(9, 'olddir')
self.leftlist.insertItem(10, 'start')
self.leftlist.insertItem(11, 'size')
self.leftlist.insertItem(12, 'maxage')
self.leftlist.setCurrentRow(0)
class Toolbox(QWidget):
"""A side-oriented widget similar to a TabWidget that can be collapsed and
expanded.
A Toolbox is designed to be a container for sets of controls, grouped into
'pages' and accessible by a TabBar, in the same way as a TabWidget.
A page is normally a QWidget with a layout that contains controls.
A widget can be added as a new tab using :meth:`addTab`.
The Toolbox has slots for triggering its collapse and expansion, both in an
animated mode (soft slide) and a 'quick' mode which skips the animation.
Commonly the collapse/expand slots are connected to the tabBar's
:meth:`tabBarDoubleClicked` signal. Normally in the DataLogger a Toolbox is
created and then added to a :class:`~cued_datalogger.api.toolbox.MasterToolbox`,
which connects the relevant signals for collapsing and expanding the
Toolbox.
Attributes
----------
tabBar : QTabBar
tabPages : QStackedWidget
The stack of widgets that form the pages of the tabs.
collapse_animation : QPropertyAnimation
The animation that controls how the Toolbox collapses.
"""
sig_collapsed_changed = pyqtSignal()
def __init__(self, widget_side='left', parent=None):
self.parent = parent
self.widget_side = widget_side
super().__init__(parent)
self.layout = QHBoxLayout()
self.layout.setSpacing(0)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
# # Create the tab bar
self.tabBar = QTabBar(self)
self.tabBar.setTabsClosable(False)
self.tabBar.setMovable(False)
self.tabBar.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
# # Create the Stacked widget for the pages
self.tabPages = QStackedWidget(self)
# # Link the signals so that changing tab leads to a change of page
self.tabBar.currentChanged.connect(self.changePage)
# # Add them to the splitter (self)
# Right side orientation
if self.widget_side == 'right':
self.tabBar.setShape(QTabBar.RoundedWest)
self.layout.addWidget(self.tabBar)
self.layout.addWidget(self.tabPages)
# Left side orientation
else:
self.tabBar.setShape(QTabBar.RoundedEast)
self.layout.addWidget(self.tabPages)
self.layout.addWidget(self.tabBar)
self.setLayout(self.layout)
self.collapsed = False
self.expanded_width = self.sizeHint().width()
def addTab(self, widget, title):
"""Add a new tab, with the page widget *widget* and tab title
*title*."""
self.tabBar.addTab(title)
self.tabPages.addWidget(widget)
def removeTab(self, title):
"""Remove the tab with title *title*."""
for tab_num in range(self.tabBar.count()):
if self.tabBar.tabText(tab_num) == title:
self.tabBar.removeTab(tab_num)
self.tabPages.removeWidget(self.tabPages.widget(tab_num))
def toggle_collapse(self):
"""If collapsed, expand the widget so the pages are visible. If not
collapsed, collapse the widget so that only the tabBar is showing."""
# If collapsed, expand
if self.collapsed:
self.expand()
# If expanded, collapse:
else:
self.collapse()
def expand(self):
"""Expand the widget so that the pages are visible."""
self.tabPages.show()
self.sig_collapsed_changed.emit()
self.collapsed = False
def collapse(self):
"""Collapse the widget so that only the tab bar is visible."""
self.tabPages.hide()
self.sig_collapsed_changed.emit()
self.collapsed = True
def changePage(self, index):
"""Set the current page to *index*."""
self.tabBar.setCurrentIndex(index)
self.tabPages.setCurrentIndex(index)
if self.tabPages.currentWidget():
self.tabPages.currentWidget().resize(self.tabPages.size())
def clear(self):
"""Remove all tabs and pages."""
for i in range(self.tabBar.count()):
# Remove the tab and page at position 0
self.tabBar.removeTab(0)
self.tabPages.removeWidget(self.tabPages.currentWidget())
class MainWindow(QMainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.settings = QSettings()
self.is_visible = True
self.is_expanded = True
self.is_move_action = False
self.should_confirm_close = False
self.setWindowFlags(Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint
| Qt.Tool)
self.setAttribute(Qt.WA_NoSystemBackground, True)
self.setAttribute(Qt.WA_TranslucentBackground, True)
self.setAttribute(Qt.WA_QuitOnClose)
self.setWindowIcon(QIcon(join(config.ASSETS_DIR, "droptopus.png")))
self.setWindowTitle("Droptopus")
self.miniwin = MiniWindow(self)
self.frame = DropFrame(self)
self.frame.show()
self.readSettings()
self.content = QStackedWidget()
self.setCentralWidget(self.content)
self.content.addWidget(self.frame)
self.content.addWidget(self.miniwin)
self.setAcceptDrops(True)
self.setMouseTracking(True)
self.collapse()
def contextMenuEvent(self, event):
menu = QMenu(self)
label = ("Expand", "Collapse")[self.is_expanded]
expand_action = menu.addAction(label)
about_action = menu.addAction("About")
menu.addSeparator()
quit_action = menu.addAction("Quit")
action = menu.exec_(self.mapToGlobal(event.pos()))
if action == expand_action:
if self.is_expanded:
self.collapse()
else:
self.expand()
elif action == about_action:
self.showAbout()
elif action == quit_action:
self.should_confirm_close = True
self.close()
def expand(self):
if self.is_expanded:
return
self.is_expanded = True
self.setAcceptDrops(False)
self.content.hide()
expanded = self.frame.sizeHint()
self.setMinimumSize(expanded)
self.content.setCurrentWidget(self.frame)
self.content.show()
self.resize(expanded)
# on OSX the window will not automatically stay inside the screen like on Linux
# we have to do it manually
screen_rect = QDesktopWidget().screenGeometry()
window_rect = self.frameGeometry()
intersection = window_rect & screen_rect
dx = window_rect.width() - intersection.width()
dy = window_rect.height() - intersection.height()
unseen = window_rect & intersection
if dx != 0 or dy != 0:
if window_rect.left() > screen_rect.left():
dx = dx * -1
if window_rect.bottom() > screen_rect.bottom():
dy = dy * -1
self.move(window_rect.left() + dx, window_rect.top() + dy)
def collapse(self):
if not self.is_expanded:
return
self.is_expanded = False
self.setAcceptDrops(True)
self.content.hide()
mini = self.miniwin.sizeHint()
self.setMinimumSize(mini)
self.move(self.anchor)
self.content.setCurrentWidget(self.miniwin)
self.content.show()
self.resize(mini)
def showAbout(self):
about = AboutDialog(self)
about.setModal(True)
about.show()
def mouseReleaseEvent(self, event):
self.is_move_action = False
def mousePressEvent(self, event):
if not event.button() == Qt.LeftButton:
return
self.is_move_action = True
self.offset = event.pos()
def mouseMoveEvent(self, event):
if not self.is_move_action:
return
x = event.globalX()
y = event.globalY()
x_w = self.offset.x()
y_w = self.offset.y()
self.move(x - x_w, y - y_w)
if self.content.currentWidget() == self.miniwin:
self.anchor = self.pos()
def writeSettings(self):
self.settings.beginGroup("MainWindow")
self.settings.setValue("anchor", self.anchor)
self.settings.endGroup()
def readSettings(self):
self.settings.beginGroup("MainWindow")
saved_anchor = self.settings.value("anchor", None)
if saved_anchor != None:
self.anchor = saved_anchor
else:
rect = QDesktopWidget().screenGeometry()
mini = self.miniwin.sizeHint()
self.anchor = QPoint(rect.right() - mini.width(),
rect.bottom() - mini.height())
self.settings.endGroup()
def userReallyWantsToQuit(self):
if not self.should_confirm_close:
return True
reply = QMessageBox.question(
self,
"Close Droptopus",
"Are you sure you want to close the application?",
QMessageBox.Yes,
QMessageBox.No,
)
return reply == QMessageBox.Yes
def closeEvent(self, event):
if self.userReallyWantsToQuit():
self.writeSettings()
event.accept()
else:
event.ignore()
# def dragMoveEvent(self, event):
# super(MainWindow, self).dragMoveEvent(event)
def dragEnterEvent(self, event):
if not self.is_expanded:
QTimer.singleShot(200, self.expand)
else:
super(MainWindow, self).dragEnterEvent(event)
def mouseDoubleClickEvent(self, event):
if self.is_expanded:
self.collapse()
else:
self.expand()
def event(self, evt):
et = evt.type()
if et == events.COLLAPSE_WINDOW:
evt.accept()
self.collapse()
return True
if evt.type() == events.RELOAD_WIDGETS:
evt.accept()
if self.is_expanded:
self.resize(self.sizeHint())
if et == events.EXPAND_WINDOW:
evt.accept()
self.expand()
return True
elif et == events.CLOSE_WINDOW:
evt.accept()
self.should_confirm_close = True
self.close()
return True
return super(MainWindow, self).event(evt)
