class ProcessMonitorUI: def __init__(self, window: ProcessMonitorWindow): self.window = window self.main_widget = QWidget(window) self.main_layout = QVBoxLayout() self.layout_connection = QHBoxLayout() self.txt_conenction = QLineEdit() self.btn_connect = QPushButton() self.layout_connection.addWidget(self.txt_conenction) self.layout_connection.addWidget(self.btn_connect) self.process_list = ProcessListWidget() self.tabs_output = ProcessOutputTabsWidget() self.splitter = QSplitter(Qt.Horizontal) self.splitter.setMinimumSize(680, 540) policy = QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding) policy.setHorizontalStretch(0) policy.setVerticalStretch(0) policy.setHeightForWidth(self.splitter.sizePolicy().hasHeightForWidth()) self.splitter.setSizePolicy(policy) self.splitter.setStretchFactor(0, 1) self.splitter.setStretchFactor(1, 0) self.main_layout.addLayout(self.layout_connection) self.splitter.addWidget(self.process_list) self.splitter.addWidget(self.tabs_output) self.main_layout.addWidget(self.splitter) self.main_widget.setLayout(self.main_layout) self.statusbar = QStatusBar(window) self.txt_conenction.setPlaceholderText("ws://127.0.0.1:8766") self.txt_conenction.setText("ws://127.0.0.1:8766") self.btn_connect.setText("Connect") window.setCentralWidget(self.main_widget) window.setStatusBar(self.statusbar) window.setWindowTitle("Process Monitor") window.setWindowIcon(window.style().standardIcon(QStyle.SP_BrowserReload)) self.set_disconnected_ui("Click on Connect to establish a connection") def set_disconnected_ui(self, msg: str): self.process_list.setDisabled(True) self.btn_connect.setDisabled(False) self.statusbar.showMessage(f"Disconnected. {msg}") def set_connected_ui(self): self.process_list.setDisabled(False) self.btn_connect.setDisabled(True) self.statusbar.showMessage("Connection established.") def handle_output(self, output: OutputEvent): self.tabs_output.append_output(output.uid, output.output)
class Window(QMainWindow): def __init__(self): super(Window, self).__init__() self.setWindowTitle("Status Bar") self.setGeometry(300, 300, 300, 300) self.createStatusBar() def createStatusBar(self): self.myStatus = QStatusBar() self.myStatus.showMessage("hello", 3000) self.setStatusBar(self.myStatus)
class SerialWindow(QWidget): def __init__(self, parent=None, port=None, baud=115200): QWidget.__init__(self, parent) self.alive = False self.console = Console(self) self.console.key_data_signal.connect(self.write_data) self.status_bar = QStatusBar(self) layout = QGridLayout(self) layout.addWidget(self.console) layout.addWidget(self.status_bar) ser = serial.serial_for_url(port, baudrate=baud, timeout=1) t = ReaderThread(ser, SerialProtocol) t.start() _, self.protocol = t.connect() self.protocol.bind_signals(self) def showStatusMessage(self, message): self.status_bar.showMessage(message) @Slot() def connected(self): self.showStatusMessage('opened') self.alive = True @Slot() def connect_losed(self): self.showStatusMessage('closed') self.alive = False @Slot(str) def ingoing_data(self, data): self.console.putData(data) @Slot(str, int) def write_data(self, data, is_binary=0): self.protocol.write_packet(data, is_binary) @Slot() def handle_error(self, error): self.showStatusMessage(error) pass
class MainWindow(QMainWindow): def __init__(self,application,parent=None): super(MainWindow,self).__init__(parent) #private attributes self.menuBar_ = QMenuBar() self.fileMenu_ = FileMenu(self) self.editMenu_ = EditMenu(self) self.toolbarDoc_ = QDockWidget(self) self.toolbarWidget_ = Toolbar(self) self.setGeometry(0,0,1280,720) #public attributes self.application = application self.contentTab = ContentTab() self.statusBar = QStatusBar() #menuBar self.menuBar_.addMenu(self.fileMenu_) self.menuBar_.addMenu(self.editMenu_) self.menuBar_.addAction("Help",self.helpFunc) self.setMenuBar(self.menuBar_) #statusBar self.statusBar.showMessage("status bar") self.setStatusBar(self.statusBar) #toolBar self.toolbarDoc_.setFeatures(QDockWidget.NoDockWidgetFeatures ) self.addDockWidget(Qt.LeftDockWidgetArea,self.toolbarDoc_) self.toolbarDoc_.setWidget(self.toolbarWidget_) #contentab self.setCentralWidget(self.contentTab) def helpFunc(self): """ Call the help tab To be added """ print("called helpFunc") def quit(self): """ Quit the application """ self.application.quit()
class xBanWindow(QMainWindow): """The main window of xban The main window serves three major purposes: - statusbar (sand the save button) - scrollable area """ def __init__(self, base_path, file, file_config, parent=None): super().__init__(parent) board = BanBoard(file, file_config) board_area = QScrollArea() board_area.setWidget(board) board_area.setWidgetResizable(True) self.setCentralWidget(board_area) self.stbar = QStatusBar() # add a save button at the right bottom corner save_btn = BanButton( "save", objectName="appBtn_save", toolTip="save xban file", shortcut="Ctrl+S", ) shadow = QGraphicsDropShadowEffect(self, blurRadius=10, offset=5, color=QColor("lightgrey")) save_btn.setGraphicsEffect(shadow) save_btn.pressed.connect(board.save_board) self.stbar.addPermanentWidget(save_btn) self.setStatusBar(self.stbar) log_handler = QLogHandler(self) root_logger = logging.getLogger() root_logger.addHandler(log_handler) log_handler.signal.log_msg.connect( partial(self.stbar.showMessage, timeout=1500)) self.stbar.showMessage(f"Initiate {file}", 1500) self.show() def closeEvent(self, event): """Auto save when close""" self.centralWidget().widget().save_board() super().closeEvent(event)
class MainWindow(QMainWindow): # Constructor function def __init__(self): super(MainWindow, self).__init__() self.initGUI() def initGUI(self): self.setWindowTitle("Main Window") self.setGeometry(300, 250, 400, 300) self.CreateStatusBar() self.show() def CreateStatusBar(self): self.myStatusBar = QStatusBar() self.myStatusBar.showMessage('Ready PySide2', 2000) self.setStatusBar(self.myStatusBar)
class Main_Window(QMainWindow): '''Our Main Class Window''' def __init__(self): '''Constructor Function''' QMainWindow.__init__(self) self.setWindowTitle("Login Window") #self.setWindowIcon(QIcon("company_logo.png")) self.setGeometry(350, 250, 550, 400) #self.setGeometry(x,y,w,h) self.setUp_GUI() def setUp_GUI(self): '''Generate all UI Elements''' #Menubar self.Create_MenuBar() #Statusbar self.Create_StatusBar() #Toolbar #Dock Widget #Central Widget self.Create_CentralWidget() return def Create_MenuBar(self): #Menu Bar Item Creation '''Function to Create Actual Menu Bar''' self.fileMenu = self.menuBar().addMenu("&File") self.editMenu = self.menuBar().addMenu("&Edit") self.helpMenu = self.menuBar().addMenu("&Help") def Create_StatusBar(self): '''Function to Create Status Bar''' self.myStatusBar = QStatusBar() self.myStatusBar.showMessage("Getting Ready", 2000) self.setStatusBar(self.myStatusBar) def Create_ToolBar(self): return def Create_DockWidget(self): return def Create_CentralWidget(self): self.Main_Layout = Layout_Main_Window() self.setCentralWidget(self.Main_Layout)
def ui_setup(self): """Initialize user interface of main window.""" loader = QUiLoader() file = QFile('./user_interface/form/main_window.ui') file.open(QFile.ReadOnly) self._window = loader.load(file) file.close() status_bar = QStatusBar(self._window) status_bar.showMessage(__copyright__) self._window.setStatusBar(status_bar) self._window.setWindowIcon( QIcon('./user_interface/media/bucketing_icon.jpeg')) self._window.setWindowTitle('PySide2 Project - Basic UI Framework') self._option_panel = OptionPanel() self._option_panel.add_button('DekBan', './user_interface/media/dekban.png') self._option_panel.add_button('Charlie', './user_interface/media/charlie.jpeg') self._option_panel.add_button('Simon', './user_interface/media/Simon.jpeg') # Add widget to main layout main_layout = self._window.main_layout main_layout.itemAtPosition(0, 0).setAlignment(QtCore.Qt.AlignCenter) main_layout.itemAtPosition(0, 1).setAlignment(QtCore.Qt.AlignVCenter) main_layout.addWidget(self._option_panel, 2, 0, 1, 1) # Add page widget to stack self._pages['item'] = ItemWidget() self._pages['text1'] = TextPage(text=PAUSE_TEXT) self._pages['text2'] = TextPage(text=STOP_TEXT) for index, name in enumerate(self._pages): print('pages {} : {} page'.format(index, name)) self._window.widget_stack.addWidget(self._pages[name].widget) self._window.widget_stack.setCurrentIndex(0) # Build up signal / slot self._option_panel.currentItemChanged.connect(self.set_page)
class Window(QMainWindow): def __init__(self): super().__init__() self.setWindowTitle( "Pyside2 Status Bar") # Configure le titre de la fenêtre self.setGeometry(300, 300, 500, 400) # Configure la taille de la fenêtre self.setIcon() self.createStatusBar() def setIcon(self): appIcon = QIcon("icon.png") self.setWindowIcon(appIcon) def createStatusBar(self): self.myStatus = QStatusBar() self.myStatus.showMessage("Status Bar Is Ready", 3000) self.setStatusBar(self.myStatus)
class MainWindow(QMainWindow): def __init__(self): QMainWindow.__init__(self) self.setWindowTitle("A Company Login Windows") self.setGeometry(300,250,400,300) #self.CreateStatusBar() self.CreateProgressBar() #self.showProgress() def CreateStatusBar(self): self.myStatusBar = QStatusBar() self.myStatusBar.showMessage('Ready',0) self.setStatusBar(self.myStatusBar) def CreateProgressBar(self): self.myStatusBar = QStatusBar() self.progressBar = QProgressBar() self.statusLabel = QLabel("Showing Progress") #self.finishLabel = QLabel("Finish Progress") self.progressBar.setMinimum(0) self.progressBar.setMaximum(100) self.progressBar.setValue(0) self.myStatusBar.addWidget(self.statusLabel,1) self.myStatusBar.addWidget(self.progressBar,2) #self.myStatusBar.addWidget(self.finishLabel,3) self.setStatusBar(self.myStatusBar) def showProgress(self): while(self.progressBar.value() < self.progressBar.maximum()): self.progressBar.setValue(self.progressBar.value() + 10) time.sleep(1) self.statusLabel.setText('Ready')
class MainWindow(QWidget): def __init__(self): super().__init__() layout = QVBoxLayout() layout.setMargin(0) layout.setSpacing(0) self.menu_bar = MenuBar() layout.addWidget(self.menu_bar) self.main_area = MainArea() layout.addWidget(self.main_area) self.status = QStatusBar() self.status.showMessage('Application Started') layout.addWidget(self.status) self.setLayout(layout) HyperController.sub.onconnected.connect(self.connected) def connected(self): HyperController.post_connection()
class ListenerView(QMainWindow): def __init__(self, *args): super(ListenerView, self).__init__(*args) self.layout = QVBoxLayout() self.setLayout(self.layout) self.window_branding() self.create_menu() self.create_main() self.create_status() self.create_container_view() self.create_audio_view() app = property(appref.app) def window_branding(self): """Setup our general branding for the window""" self.setWindowTitle(defaults.APP_NAME_HUMAN) self.setWindowIcon(icons.get_icon("microphone")) def create_menu(self): """Create the overall application menu""" self.menu = QMenuBar() app = self.app self.dictation_menu = self.menu.addMenu('&Dictation') self.dictation_menu.addAction(app.start_listening) self.dictation_menu.addAction(app.stop_listening) self.dictation_menu.addAction(app.reposition_overlay) self.setMenuBar(self.menu) def create_main(self): """Create our main central widgets""" self.mdi = QMdiArea(self) self.setCentralWidget(self.mdi) def create_status(self): """Create our listening status-bar""" self.status_bar = QStatusBar(self) self.setStatusBar(self.status_bar) self.status_bar.showMessage('%s is loading...' % (defaults.APP_NAME_HUMAN)) def create_audio_view(self): """Create the audio control view""" self.audio_dock = QDockWidget("Audio", self) self.audio_dock.setFloating(False) self.audio_view = audioview.ListenerAudio(self) self.audio_dock.setWidget(self.audio_view) self.addDockWidget( Qt.LeftDockWidgetArea, self.audio_dock, ) def create_container_view(self): """Create the container view""" self.container_dock = QDockWidget("Container", self) self.container_dock.setFloating(False) self.container_view = containersettings.ContainerSettings(self) self.container_dock.setWidget(self.container_view) self.addDockWidget( Qt.LeftDockWidgetArea, self.container_dock, )
class MetricsDialog(PluginDialog): ENABLE = True def __init__(self, conn=None, parent=None): super().__init__(parent) self.conn = conn self.tab_widget = QTabWidget() self.status_bar = QStatusBar() self.meta_view = DictWidget() self.stat_view = DictWidget() self.ann_view = DictWidget() self.tab_widget.addTab(self.meta_view, "Metadata") self.tab_widget.addTab(self.stat_view, "Variants") self.tab_widget.addTab(self.ann_view, "Annotations") self.buttons = QDialogButtonBox(QDialogButtonBox.Ok) self.buttons.accepted.connect(self.accept) self.setWindowTitle(self.tr("Project metrics")) v_layout = QVBoxLayout() v_layout.addWidget(self.tab_widget) v_layout.addWidget(self.status_bar) v_layout.addWidget(self.buttons) v_layout.setSpacing(0) self.setLayout(v_layout) self.resize(640, 480) # Async stuff self.metric_thread = None self.populate() def populate(self): """Async implementation to populate the view Notes: When closing the dialog window, the thread is not stopped. """ def compute_metrics(conn): """Async function""" meta_data = sql.get_metadatas(conn) stats_data = { "Variant count": get_variant_count(conn), "Snp count": get_snp_count(conn), "Indel count": get_indel_count(conn), "Transition count": get_variant_transition(conn), "Transversion count": get_variant_transversion(conn), "Sample count": get_sample_count(conn), } stats_data["Tr/tv ratio"] = round( stats_data["Transition count"] / stats_data["Transversion count"], 2) if sql.table_exists(conn, "annotations"): genes_data = get_gene_counts(conn) else: gene_data = {} return meta_data, stats_data, genes_data self.status_bar.showMessage("Loading ...") self.metric_thread = SqlThread(self.conn, compute_metrics) self.metric_thread.result_ready.connect(self.loaded) self.metric_thread.start() def loaded(self): """Called at the end of the thread and populate data""" meta_data, stats_data, genes_data = self.metric_thread.results self.stat_view.set_dict(stats_data) self.meta_view.set_dict(meta_data) self.ann_view.set_dict(genes_data) self.status_bar.showMessage("")
class ToolSpecificationWidget(QWidget): def __init__(self, toolbox, tool_specification=None): """A widget to query user's preferences for a new tool specification. Args: toolbox (ToolboxUI): QMainWindow instance tool_specification (ToolSpecification): If given, the form is pre-filled with this specification """ from ..ui.tool_specification_form import Ui_Form super().__init__(parent=toolbox, f=Qt.Window) # Inherit stylesheet from ToolboxUI # Setup UI from Qt Designer file self.ui = Ui_Form() self.ui.setupUi(self) # Class attributes self._toolbox = toolbox self._project = self._toolbox.project() # init models self.sourcefiles_model = QStandardItemModel() self.inputfiles_model = QStandardItemModel() self.inputfiles_opt_model = QStandardItemModel() self.outputfiles_model = QStandardItemModel() # Add status bar to form self.statusbar = QStatusBar(self) self.statusbar.setFixedHeight(20) self.statusbar.setSizeGripEnabled(False) self.statusbar.setStyleSheet(STATUSBAR_SS) self.ui.horizontalLayout_statusbar_placeholder.addWidget(self.statusbar) # init ui self.ui.treeView_sourcefiles.setModel(self.sourcefiles_model) self.ui.treeView_inputfiles.setModel(self.inputfiles_model) self.ui.treeView_inputfiles_opt.setModel(self.inputfiles_opt_model) self.ui.treeView_outputfiles.setModel(self.outputfiles_model) self.ui.treeView_sourcefiles.setStyleSheet(TREEVIEW_HEADER_SS) self.ui.treeView_inputfiles.setStyleSheet(TREEVIEW_HEADER_SS) self.ui.treeView_inputfiles_opt.setStyleSheet(TREEVIEW_HEADER_SS) self.ui.treeView_outputfiles.setStyleSheet(TREEVIEW_HEADER_SS) self.ui.comboBox_tooltype.addItem("Select type...") self.ui.comboBox_tooltype.addItems(TOOL_TYPES) # if a specification is given, fill the form with data from it if tool_specification: self.ui.lineEdit_name.setText(tool_specification.name) check_state = Qt.Checked if tool_specification.execute_in_work else Qt.Unchecked self.ui.checkBox_execute_in_work.setCheckState(check_state) self.ui.textEdit_description.setPlainText(tool_specification.description) self.ui.lineEdit_args.setText(" ".join(tool_specification.cmdline_args)) tool_types = [x.lower() for x in TOOL_TYPES] index = tool_types.index(tool_specification.tooltype) + 1 self.ui.comboBox_tooltype.setCurrentIndex(index) # Init lists self.main_program_file = "" self.sourcefiles = list(tool_specification.includes) if tool_specification else list() self.inputfiles = list(tool_specification.inputfiles) if tool_specification else list() self.inputfiles_opt = list(tool_specification.inputfiles_opt) if tool_specification else list() self.outputfiles = list(tool_specification.outputfiles) if tool_specification else list() self.def_file_path = tool_specification.def_file_path if tool_specification else None self.program_path = tool_specification.path if tool_specification else None self.definition = dict() # Get first item from sourcefiles list as the main program file try: self.main_program_file = self.sourcefiles.pop(0) self.ui.lineEdit_main_program.setText(os.path.join(self.program_path, self.main_program_file)) except IndexError: pass # sourcefiles list is empty # Populate lists (this will also create headers) self.populate_sourcefile_list(self.sourcefiles) self.populate_inputfiles_list(self.inputfiles) self.populate_inputfiles_opt_list(self.inputfiles_opt) self.populate_outputfiles_list(self.outputfiles) self.ui.lineEdit_name.setFocus() self.ui.label_mainpath.setText(self.program_path) # Add includes popup menu self.add_source_files_popup_menu = AddIncludesPopupMenu(self) self.ui.toolButton_add_source_files.setMenu(self.add_source_files_popup_menu) self.ui.toolButton_add_source_files.setStyleSheet('QToolButton::menu-indicator { image: none; }') # Add create new or add existing main program popup menu self.add_main_prgm_popup_menu = CreateMainProgramPopupMenu(self) self.ui.toolButton_add_main_program.setMenu(self.add_main_prgm_popup_menu) self.ui.toolButton_add_source_files.setStyleSheet('QToolButton::menu-indicator { image: none; }') self.ui.toolButton_add_cmdline_tag.setMenu(self._make_add_cmdline_tag_menu()) self.connect_signals() def connect_signals(self): """Connect signals to slots.""" self.ui.toolButton_add_source_files.clicked.connect(self.show_add_source_files_dialog) self.ui.toolButton_add_source_dirs.clicked.connect(self.show_add_source_dirs_dialog) self.ui.lineEdit_main_program.file_dropped.connect(self.set_main_program_path) self.ui.treeView_sourcefiles.files_dropped.connect(self.add_dropped_includes) self.ui.treeView_sourcefiles.doubleClicked.connect(self.open_includes_file) self.ui.toolButton_minus_source_files.clicked.connect(self.remove_source_files) self.ui.toolButton_plus_inputfiles.clicked.connect(self.add_inputfiles) self.ui.toolButton_minus_inputfiles.clicked.connect(self.remove_inputfiles) self.ui.toolButton_plus_inputfiles_opt.clicked.connect(self.add_inputfiles_opt) self.ui.toolButton_minus_inputfiles_opt.clicked.connect(self.remove_inputfiles_opt) self.ui.toolButton_plus_outputfiles.clicked.connect(self.add_outputfiles) self.ui.toolButton_minus_outputfiles.clicked.connect(self.remove_outputfiles) self.ui.pushButton_ok.clicked.connect(self.handle_ok_clicked) self.ui.pushButton_cancel.clicked.connect(self.close) # Enable removing items from QTreeViews by pressing the Delete key self.ui.treeView_sourcefiles.del_key_pressed.connect(self.remove_source_files_with_del) self.ui.treeView_inputfiles.del_key_pressed.connect(self.remove_inputfiles_with_del) self.ui.treeView_inputfiles_opt.del_key_pressed.connect(self.remove_inputfiles_opt_with_del) self.ui.treeView_outputfiles.del_key_pressed.connect(self.remove_outputfiles_with_del) def populate_sourcefile_list(self, items): """List source files in QTreeView. If items is None or empty list, model is cleared. """ self.sourcefiles_model.clear() self.sourcefiles_model.setHorizontalHeaderItem(0, QStandardItem("Additional source files")) # Add header if items is not None: for item in items: qitem = QStandardItem(item) qitem.setFlags(~Qt.ItemIsEditable) qitem.setData(QFileIconProvider().icon(QFileInfo(item)), Qt.DecorationRole) self.sourcefiles_model.appendRow(qitem) def populate_inputfiles_list(self, items): """List input files in QTreeView. If items is None or empty list, model is cleared. """ self.inputfiles_model.clear() self.inputfiles_model.setHorizontalHeaderItem(0, QStandardItem("Input files")) # Add header if items is not None: for item in items: qitem = QStandardItem(item) qitem.setData(QFileIconProvider().icon(QFileInfo(item)), Qt.DecorationRole) self.inputfiles_model.appendRow(qitem) def populate_inputfiles_opt_list(self, items): """List optional input files in QTreeView. If items is None or empty list, model is cleared. """ self.inputfiles_opt_model.clear() self.inputfiles_opt_model.setHorizontalHeaderItem(0, QStandardItem("Optional input files")) # Add header if items is not None: for item in items: qitem = QStandardItem(item) qitem.setData(QFileIconProvider().icon(QFileInfo(item)), Qt.DecorationRole) self.inputfiles_opt_model.appendRow(qitem) def populate_outputfiles_list(self, items): """List output files in QTreeView. If items is None or empty list, model is cleared. """ self.outputfiles_model.clear() self.outputfiles_model.setHorizontalHeaderItem(0, QStandardItem("Output files")) # Add header if items is not None: for item in items: qitem = QStandardItem(item) qitem.setData(QFileIconProvider().icon(QFileInfo(item)), Qt.DecorationRole) self.outputfiles_model.appendRow(qitem) @Slot(bool, name="browse_main_program") def browse_main_program(self, checked=False): """Open file browser where user can select the path of the main program file.""" # noinspection PyCallByClass, PyTypeChecker, PyArgumentList answer = QFileDialog.getOpenFileName(self, "Add existing main program file", APPLICATION_PATH, "*.*") file_path = answer[0] if not file_path: # Cancel button clicked return self.set_main_program_path(file_path) @Slot("QString", name="set_main_program_path") def set_main_program_path(self, file_path): """Set main program file and folder path.""" folder_path = os.path.split(file_path)[0] self.program_path = os.path.abspath(folder_path) # Update UI self.ui.lineEdit_main_program.setText(file_path) self.ui.label_mainpath.setText(self.program_path) @Slot() def new_main_program_file(self): """Creates a new blank main program file. Let's user decide the file name and path. Alternative version using only one getSaveFileName dialog. """ # noinspection PyCallByClass answer = QFileDialog.getSaveFileName(self, "Create new main program", APPLICATION_PATH) file_path = answer[0] if not file_path: # Cancel button clicked return # Remove file if it exists. getSaveFileName has asked confirmation for us. try: os.remove(file_path) except OSError: pass try: with open(file_path, "w"): pass except OSError: msg = "Please check directory permissions." # noinspection PyTypeChecker, PyArgumentList, PyCallByClass QMessageBox.information(self, "Creating file failed", msg) return main_dir = os.path.dirname(file_path) self.program_path = os.path.abspath(main_dir) # Update UI self.ui.lineEdit_main_program.setText(file_path) self.ui.label_mainpath.setText(self.program_path) @Slot(name="new_source_file") def new_source_file(self): """Let user create a new source file for this tool specification.""" path = self.program_path if self.program_path else APPLICATION_PATH # noinspection PyCallByClass, PyTypeChecker, PyArgumentList dir_path = QFileDialog.getSaveFileName(self, "Create source file", path, "*.*") file_path = dir_path[0] if file_path == '': # Cancel button clicked return # create file. NOTE: getSaveFileName does the 'check for existence' for us open(file_path, 'w').close() self.add_single_include(file_path) @Slot(bool, name="show_add_source_files_dialog") def show_add_source_files_dialog(self, checked=False): """Let user select source files for this tool specification.""" path = self.program_path if self.program_path else APPLICATION_PATH # noinspection PyCallByClass, PyTypeChecker, PyArgumentList answer = QFileDialog.getOpenFileNames(self, "Add source file", path, "*.*") file_paths = answer[0] if not file_paths: # Cancel button clicked return for path in file_paths: if not self.add_single_include(path): continue @Slot(bool, name="show_add_source_dirs_dialog") def show_add_source_dirs_dialog(self, checked=False): """Let user select a source directory for this tool specification. All files and sub-directories will be added to the source files. """ path = self.program_path if self.program_path else APPLICATION_PATH # noinspection PyCallByClass, PyTypeChecker, PyArgumentList answer = QFileDialog.getExistingDirectory(self, "Select a directory to add to source files", path) file_paths = list() for root, _, files in os.walk(answer): for file in files: file_paths.append(os.path.abspath(os.path.join(root, file))) for path in file_paths: if not self.add_single_include(path): continue @Slot("QVariant", name="add_dropped_includes") def add_dropped_includes(self, file_paths): """Adds dropped file paths to Source files list.""" for path in file_paths: if not self.add_single_include(path): continue def add_single_include(self, path): """Add file path to Source files list.""" dirname, file_pattern = os.path.split(path) # logging.debug("program path:{0}".format(self.program_path)) # logging.debug("{0}, {1}".format(dirname, file_pattern)) if not self.program_path: self.program_path = dirname self.ui.label_mainpath.setText(self.program_path) path_to_add = file_pattern else: # check if path is a descendant of main dir. common_prefix = os.path.commonprefix([os.path.abspath(self.program_path), os.path.abspath(path)]) # logging.debug("common_prefix:{0}".format(common_prefix)) if common_prefix != self.program_path: self.statusbar.showMessage( "Source file {0}'s location is invalid " "(should be in main directory)".format(file_pattern), 5000 ) return False path_to_add = os.path.relpath(path, self.program_path) if self.sourcefiles_model.findItems(path_to_add): self.statusbar.showMessage("Source file {0} already included".format(path_to_add), 5000) return False qitem = QStandardItem(path_to_add) qitem.setFlags(~Qt.ItemIsEditable) qitem.setData(QFileIconProvider().icon(QFileInfo(path_to_add)), Qt.DecorationRole) self.sourcefiles_model.appendRow(qitem) return True @busy_effect @Slot("QModelIndex", name="open_includes_file") def open_includes_file(self, index): """Open source file in default program.""" if not index: return if not index.isValid(): self._toolbox.msg_error.emit("Selected index not valid") return includes_file = self.sourcefiles_model.itemFromIndex(index).text() _, ext = os.path.splitext(includes_file) if ext in [".bat", ".exe"]: self._toolbox.msg_warning.emit( "Sorry, opening files with extension <b>{0}</b> not implemented. " "Please open the file manually.".format(ext) ) return url = "file:///" + os.path.join(self.program_path, includes_file) # noinspection PyCallByClass, PyTypeChecker, PyArgumentList res = QDesktopServices.openUrl(QUrl(url, QUrl.TolerantMode)) if not res: self._toolbox.msg_error.emit("Failed to open file: <b>{0}</b>".format(includes_file)) @Slot(name="remove_source_files_with_del") def remove_source_files_with_del(self): """Support for deleting items with the Delete key.""" self.remove_source_files() @Slot(bool, name="remove_source_files") def remove_source_files(self, checked=False): """Remove selected source files from include list. Do not remove anything if there are no items selected. """ indexes = self.ui.treeView_sourcefiles.selectedIndexes() if not indexes: # Nothing selected self.statusbar.showMessage("Please select the source files to remove", 3000) else: rows = [ind.row() for ind in indexes] rows.sort(reverse=True) for row in rows: self.sourcefiles_model.removeRow(row) if self.sourcefiles_model.rowCount() == 0: if self.ui.lineEdit_main_program.text().strip() == "": self.program_path = None self.ui.label_mainpath.clear() self.statusbar.showMessage("Selected source files removed", 3000) @Slot(bool, name="add_inputfiles") def add_inputfiles(self, checked=False): """Let user select input files for this tool specification.""" msg = ( "Add an input file or a directory required by your program. Wildcards " "<b>are not</b> supported.<br/><br/>" "Examples:<br/>" "<b>data.csv</b> -> File is copied to the same work directory as the main program.<br/>" "<b>input/data.csv</b> -> Creates subdirectory /input to work directory and " "copies file data.csv there.<br/>" "<b>output/</b> -> Creates an empty directory into the work directory.<br/><br/>" ) # noinspection PyCallByClass, PyTypeChecker, PyArgumentList answer = QInputDialog.getText(self, "Add input item", msg, flags=Qt.WindowTitleHint | Qt.WindowCloseButtonHint) file_name = answer[0] if not file_name: # Cancel button clicked return qitem = QStandardItem(file_name) qitem.setData(QFileIconProvider().icon(QFileInfo(file_name)), Qt.DecorationRole) self.inputfiles_model.appendRow(qitem) @Slot(name="remove_inputfiles_with_del") def remove_inputfiles_with_del(self): """Support for deleting items with the Delete key.""" self.remove_inputfiles() @Slot(bool, name="remove_inputfiles") def remove_inputfiles(self, checked=False): """Remove selected input files from list. Do not remove anything if there are no items selected. """ indexes = self.ui.treeView_inputfiles.selectedIndexes() if not indexes: # Nothing selected self.statusbar.showMessage("Please select the input files to remove", 3000) else: rows = [ind.row() for ind in indexes] rows.sort(reverse=True) for row in rows: self.inputfiles_model.removeRow(row) self.statusbar.showMessage("Selected input files removed", 3000) @Slot(bool, name="add_inputfiles_opt") def add_inputfiles_opt(self, checked=False): """Let user select optional input files for this tool specification.""" msg = ( "Add optional input files that may be utilized by your program. <br/>" "Wildcards are supported.<br/><br/>" "Examples:<br/>" "<b>data.csv</b> -> If found, file is copied to the same work directory as the main program.<br/>" "<b>*.csv</b> -> All found CSV files are copied to the same work directory as the main program.<br/>" "<b>input/data_?.dat</b> -> All found files matching the pattern 'data_?.dat' will be copied to <br/>" "input/ subdirectory under the same work directory as the main program.<br/><br/>" ) # noinspection PyCallByClass, PyTypeChecker, PyArgumentList answer = QInputDialog.getText( self, "Add optional input item", msg, flags=Qt.WindowTitleHint | Qt.WindowCloseButtonHint ) file_name = answer[0] if not file_name: # Cancel button clicked return qitem = QStandardItem(file_name) qitem.setData(QFileIconProvider().icon(QFileInfo(file_name)), Qt.DecorationRole) self.inputfiles_opt_model.appendRow(qitem) @Slot(name="remove_inputfiles_opt_with_del") def remove_inputfiles_opt_with_del(self): """Support for deleting items with the Delete key.""" self.remove_inputfiles_opt() @Slot(bool, name="remove_inputfiles_opt") def remove_inputfiles_opt(self, checked=False): """Remove selected optional input files from list. Do not remove anything if there are no items selected. """ indexes = self.ui.treeView_inputfiles_opt.selectedIndexes() if not indexes: # Nothing selected self.statusbar.showMessage("Please select the optional input files to remove", 3000) else: rows = [ind.row() for ind in indexes] rows.sort(reverse=True) for row in rows: self.inputfiles_opt_model.removeRow(row) self.statusbar.showMessage("Selected optional input files removed", 3000) @Slot(bool, name="add_outputfiles") def add_outputfiles(self, checked=False): """Let user select output files for this tool specification.""" msg = ( "Add output files that will be archived into the Tool results directory after the <br/>" "Tool specification has finished execution. Wildcards are supported.<br/><br/>" "Examples:<br/>" "<b>results.csv</b> -> File is copied from work directory into results.<br/> " "<b>*.csv</b> -> All CSV files will copied into results.<br/> " "<b>output/*.gdx</b> -> All GDX files from the work subdirectory /output will be copied into <br/>" "results /output subdirectory.<br/><br/>" ) # noinspection PyCallByClass, PyTypeChecker, PyArgumentList answer = QInputDialog.getText(self, "Add output item", msg, flags=Qt.WindowTitleHint | Qt.WindowCloseButtonHint) file_name = answer[0] if not file_name: # Cancel button clicked return qitem = QStandardItem(file_name) qitem.setData(QFileIconProvider().icon(QFileInfo(file_name)), Qt.DecorationRole) self.outputfiles_model.appendRow(qitem) @Slot(name="remove_outputfiles_with_del") def remove_outputfiles_with_del(self): """Support for deleting items with the Delete key.""" self.remove_outputfiles() @Slot(bool, name="remove_outputfiles") def remove_outputfiles(self, checked=False): """Remove selected output files from list. Do not remove anything if there are no items selected. """ indexes = self.ui.treeView_outputfiles.selectedIndexes() if not indexes: # Nothing selected self.statusbar.showMessage("Please select the output files to remove", 3000) else: rows = [ind.row() for ind in indexes] rows.sort(reverse=True) for row in rows: self.outputfiles_model.removeRow(row) self.statusbar.showMessage("Selected output files removed", 3000) @Slot() def handle_ok_clicked(self): """Checks that everything is valid, creates Tool spec definition dictionary and adds Tool spec to project.""" # Check that tool type is selected if self.ui.comboBox_tooltype.currentIndex() == 0: self.statusbar.showMessage("Tool type not selected", 3000) return self.definition["name"] = self.ui.lineEdit_name.text() self.definition["description"] = self.ui.textEdit_description.toPlainText() self.definition["tooltype"] = self.ui.comboBox_tooltype.currentText().lower() flags = Qt.MatchContains # Check that path of main program file is valid before saving it main_program = self.ui.lineEdit_main_program.text().strip() if not os.path.isfile(main_program): self.statusbar.showMessage("Main program file is not valid", 6000) return # Fix for issue #241 folder_path, file_path = os.path.split(main_program) self.program_path = os.path.abspath(folder_path) self.ui.label_mainpath.setText(self.program_path) self.definition["execute_in_work"] = self.ui.checkBox_execute_in_work.isChecked() self.definition["includes"] = [file_path] self.definition["includes"] += [i.text() for i in self.sourcefiles_model.findItems("", flags)] self.definition["inputfiles"] = [i.text() for i in self.inputfiles_model.findItems("", flags)] self.definition["inputfiles_opt"] = [i.text() for i in self.inputfiles_opt_model.findItems("", flags)] self.definition["outputfiles"] = [i.text() for i in self.outputfiles_model.findItems("", flags)] # Strip whitespace from args before saving it to JSON self.definition["cmdline_args"] = ToolSpecification.split_cmdline_args(self.ui.lineEdit_args.text()) for k in REQUIRED_KEYS: if not self.definition[k]: self.statusbar.showMessage("{} missing".format(k), 3000) return # Create new Tool specification short_name = self.definition["name"].lower().replace(" ", "_") self.def_file_path = os.path.join(self.program_path, short_name + ".json") if self.call_add_tool_specification(): self.close() def call_add_tool_specification(self): """Adds or updates Tool specification according to user's selections. If the name is the same as an existing tool specification, it is updated and auto-saved to the definition file. (User is editing an existing tool specification.) If the name is not in the tool specification model, creates a new tool specification and offer to save the definition file. (User is creating a new tool specification from scratch or spawning from an existing one). """ # Load tool specification path = self.program_path tool = self._project.load_tool_specification_from_dict(self.definition, path) if not tool: self.statusbar.showMessage("Adding Tool specification failed", 3000) return False # Check if a tool specification with this name already exists row = self._toolbox.tool_specification_model.tool_specification_row(tool.name) if row >= 0: # NOTE: Row 0 at this moment has 'No tool', but in the future it may change. Better be ready. old_tool = self._toolbox.tool_specification_model.tool_specification(row) def_file = old_tool.get_def_path() tool.set_def_path(def_file) if tool.__dict__ == old_tool.__dict__: # Nothing changed. We're done here. return True # logging.debug("Updating definition for tool specification '{}'".format(tool.name)) self._toolbox.update_tool_specification(row, tool) else: # noinspection PyCallByClass, PyTypeChecker, PyArgumentList answer = QFileDialog.getSaveFileName( self, "Save Tool specification file", self.def_file_path, "JSON (*.json)" ) if answer[0] == "": # Cancel button clicked return False def_file = os.path.abspath(answer[0]) tool.set_def_path(def_file) self._toolbox.add_tool_specification(tool) # Save path of main program file relative to definition file in case they differ def_path = os.path.dirname(def_file) if def_path != self.program_path: self.definition["includes_main_path"] = os.path.relpath(self.program_path, def_path) # Save file descriptor with open(def_file, "w") as fp: try: json.dump(self.definition, fp, indent=4) except ValueError: self.statusbar.showMessage("Error saving file", 3000) self._toolbox.msg_error.emit("Saving Tool specification file failed. Path:{0}".format(def_file)) return False return True def keyPressEvent(self, e): """Close Setup form when escape key is pressed. Args: e (QKeyEvent): Received key press event. """ if e.key() == Qt.Key_Escape: self.close() def closeEvent(self, event=None): """Handle close window. Args: event (QEvent): Closing event if 'X' is clicked. """ if event: event.accept() def _make_add_cmdline_tag_menu(self): """Constructs a popup menu for the '@@' button.""" menu = QMenu(self.ui.toolButton_add_cmdline_tag) action = menu.addAction(str(CmdlineTag.URL_INPUTS)) action.triggered.connect(self._add_cmdline_tag_url_inputs) action.setToolTip("Insert a tag that is replaced by all input database URLs.") action = menu.addAction(str(CmdlineTag.URL_OUTPUTS)) action.triggered.connect(self._add_cmdline_tag_url_outputs) action.setToolTip("Insert a tag that is replaced be all output database URLs.") action = menu.addAction(str(CmdlineTag.URL)) action.triggered.connect(self._add_cmdline_tag_data_store_url) action.setToolTip("Insert a tag that is replaced by the URL provided by Data Store '<data-store-name>'.") action = menu.addAction(str(CmdlineTag.OPTIONAL_INPUTS)) action.triggered.connect(self._add_cmdline_tag_optional_inputs) action.setToolTip("Insert a tag that is replaced by a list of optional input files.") return menu def _insert_spaces_around_tag_in_args_edit(self, tag_length, restore_cursor_to_tag_end=False): """ Inserts spaces before/after @@ around cursor position/selection Expects cursor to be at the end of the tag. """ args_edit = self.ui.lineEdit_args text = args_edit.text() cursor_position = args_edit.cursorPosition() if cursor_position == len(text) or (cursor_position < len(text) - 1 and not text[cursor_position].isspace()): args_edit.insert(" ") appended_spaces = 1 text = args_edit.text() else: appended_spaces = 0 tag_start = cursor_position - tag_length if tag_start > 1 and text[tag_start - 2 : tag_start] == CMDLINE_TAG_EDGE: args_edit.setCursorPosition(tag_start) args_edit.insert(" ") prepended_spaces = 1 else: prepended_spaces = 0 if restore_cursor_to_tag_end: args_edit.setCursorPosition(cursor_position + prepended_spaces) else: args_edit.setCursorPosition(cursor_position + appended_spaces + prepended_spaces) @Slot("QAction") def _add_cmdline_tag_url_inputs(self, _): """Inserts @@url_inputs@@ tag to command line arguments.""" tag = CmdlineTag.URL_INPUTS self.ui.lineEdit_args.insert(tag) self._insert_spaces_around_tag_in_args_edit(len(tag)) @Slot("QAction") def _add_cmdline_tag_url_outputs(self, _): """Inserts @@url_outputs@@ tag to command line arguments.""" tag = CmdlineTag.URL_OUTPUTS self.ui.lineEdit_args.insert(tag) self._insert_spaces_around_tag_in_args_edit(len(tag)) @Slot("QAction") def _add_cmdline_tag_data_store_url(self, _): """Inserts @@url:<data-store-name>@@ tag to command line arguments and selects '<data-store-name>'.""" args_edit = self.ui.lineEdit_args tag = CmdlineTag.URL args_edit.insert(tag) self._insert_spaces_around_tag_in_args_edit(len(tag), restore_cursor_to_tag_end=True) cursor_position = args_edit.cursorPosition() args_edit.setSelection(cursor_position - len(CMDLINE_TAG_EDGE + "<data-store_name>"), len("<data-store_name>")) @Slot("QAction") def _add_cmdline_tag_optional_inputs(self, _): """Inserts @@optional_inputs@@ tag to command line arguments.""" tag = CmdlineTag.OPTIONAL_INPUTS self.ui.lineEdit_args.insert(tag) self._insert_spaces_around_tag_in_args_edit(len(tag))
class MainWindow(QMainWindow): def __init__(self): QMainWindow.__init__(self) # 设置时间 self.__time = QDateTime() # 创建图形界面 self.__SetupUI() self.__ConfigureFileToolBar() self.__ConfigureTranslateToolBar() self.__ConfigureMainLayout() # 设置ComboBox的显示内容 self.__ConfigureComboBox() # 设置保存文件的信息 self.__currentPath = QDir.currentPath() self.__ConfigureSysIniFile() self.__ConfigureHistoryFile() salt = random.randint(1466000000, 1467000000) self.__salt = str(salt) self.__httpClient = None self.__statusBar.showMessage( self.__GetCurrentTime() + " - Please choose a file or enter data!", 2000) self.show() def __del__(self): self.__historyFile.close() def __SetupUI(self): self.__mainWidget = QWidget() self.setCentralWidget(self.__mainWidget) self.__fileToolBar = QToolBar("File") self.addToolBar(self.__fileToolBar) self.__translateToolBar = QToolBar("Translate") self.addToolBar(self.__translateToolBar) self.__statusBar = QStatusBar() self.setStatusBar(self.__statusBar) self.setWindowIcon(QIcon("./image/translate.png")) def __ConfigureFileToolBar(self): self.__openFileAction = QAction(QIcon("./image/open.png"), "Open File") self.__fileToolBar.addAction(self.__openFileAction) self.__openFileAction.triggered.connect( self.__on_triggered_openFileAction) self.__saveFileAction = QAction(QIcon("./image/save.png"), "Save File") self.__fileToolBar.addAction(self.__saveFileAction) self.__saveFileAction.triggered.connect( self.__on_triggered_saveFileAction) def __ConfigureTranslateToolBar(self): self.__translateAction = QAction(QIcon("./image/translate.png"), "Translate") self.__translateToolBar.addAction(self.__translateAction) self.__translateAction.triggered.connect( self.__on_triggered_translateAction) self.__clearAction = QAction(QIcon("./image/clear.png"), "Clear") self.__translateToolBar.addAction(self.__clearAction) self.__clearAction.triggered.connect(self.__on_triggered_clearAction) def __ConfigureMainLayout(self): self.__appIDLabel = QLabel("AppID:") self.__appIDLineEdit = QLineEdit(self) self.__appIDLineEdit.returnPressed.connect( self.__on_returnPressed_appIDLineEdit) self.__keyLabel = QLabel("Key:") self.__keyLineEdit = QLineEdit(self) self.__keyLineEdit.returnPressed.connect( self.__on_returnPressed_keyLineEdit) self.__fromLabel = QLabel("From:") self.__fromComboBox = QComboBox(self) self.__toLabel = QLabel("To:") self.__toComboBox = QComboBox(self) self.__srcLabel = QLabel("Src Text:") self.__srcTextEdit = QTextEdit(self) self.__translateLabel = QLabel("Translate Text:") self.__translateTextEdit = QTextEdit(self) self.__mainLayout = QGridLayout() self.__mainLayout.addWidget(self.__appIDLabel, 0, 0) self.__mainLayout.addWidget(self.__appIDLineEdit, 0, 1, 1, 3) self.__mainLayout.addWidget(self.__keyLabel, 1, 0) self.__mainLayout.addWidget(self.__keyLineEdit, 1, 1, 1, 3) self.__mainLayout.addWidget(self.__fromLabel, 2, 0) self.__mainLayout.addWidget(self.__fromComboBox, 2, 1) self.__mainLayout.addWidget(self.__toLabel, 2, 2) self.__mainLayout.addWidget(self.__toComboBox, 2, 3) self.__mainLayout.addWidget(self.__srcLabel, 3, 0) self.__mainLayout.addWidget(self.__srcTextEdit, 3, 1, 1, 3) self.__mainLayout.addWidget(self.__translateLabel, 4, 0) self.__mainLayout.addWidget(self.__translateTextEdit, 4, 1, 1, 3) self.__mainWidget.setLayout(self.__mainLayout) def __ConfigureComboBox(self): self.__fromComboBox.clear() self.__fromComboBox.addItem("English", "en") self.__fromComboBox.addItem("Chinese", "zh") self.__fromComboBox.addItem("Auto", "auto") self.__fromComboBox.setCurrentIndex(2) self.__toComboBox.clear() self.__toComboBox.addItem("English", "en") self.__toComboBox.addItem("Chinese", "zh") self.__toComboBox.setCurrentIndex(1) def __ConfigureSysIniFile(self): iniFile = QFile("info.ini") if iniFile.exists(): self.__infoSettings = QSettings("info.ini", QSettings.IniFormat) self.__appIDLineEdit.setText( self.__infoSettings.value("info/appid")) self.__keyLineEdit.setText(self.__infoSettings.value("info/key")) else: if iniFile.open(QFile.ReadWrite): self.__infoSettings = QSettings("info.ini", QSettings.IniFormat) self.__infoSettings.beginGroup("info") self.__infoSettings.setValue("appid", "00000000000000000") self.__infoSettings.setValue("key", "00000000000000000") self.__infoSettings.endGroup() iniFile.close() self.__appIDLineEdit.setText("00000000000000000") self.__keyLineEdit.setText("00000000000000000") def __ConfigureHistoryFile(self): self.__historyFile = QFile("history.txt") if self.__historyFile.open(QFile.ReadWrite or QFile.Append): self.__historyFileStream = QTextStream(self.__historyFile) else: self.__statusBar.showMessage( self.__GetCurrentTime() + " - History fie create failed!", 2000) def __GetCurrentTime(self, format="hh:mm:ss"): return self.__time.currentDateTime().toString(format) def __GetSign(self, srcData, appid, key): sign = appid + srcData + self.__salt + key mymd5 = hashlib.md5(sign.encode()).hexdigest() return mymd5 def __on_triggered_openFileAction(self): filePath = QFileDialog.getOpenFileName(self, "open", self.__currentPath, "* txt") if filePath[0].strip(): file = QFile(filePath[0]) if file.open(QFile.ReadOnly): readData = str(file.readAll()) fileData = readData[2:readData.__len__() - 1].replace( r"\r\n", r" ") self.__srcTextEdit.insertPlainText(fileData) else: self.__statusBar.showMessage( self.__GetCurrentTime() + " - open file failed!", 2000) else: self.__statusBar.showMessage( self.__GetCurrentTime() + " - Choose file failed!", 2000) return def __on_triggered_saveFileAction(self): self.__historyFile.close() self.__historyFile.open(QFile.ReadWrite or QFile.Append) self.__statusBar.showMessage( self.__GetCurrentTime() + " - Save file successful!", 2000) def __on_triggered_translateAction(self): srcData = self.__srcTextEdit.toPlainText() if srcData.strip(): self.__translateTextEdit.clear() self.__translateTextEdit.document().clear() dstData = srcData.replace("\n", " ") else: self.__statusBar.showMessage( self.__GetCurrentTime() + " - There is no data!", 2000) return myurl = "/api/trans/vip/translate" appid = self.__appIDLineEdit.text() key = self.__keyLineEdit.text() strFrom = self.__fromComboBox.currentData() strTo = self.__toComboBox.currentData() mymd5 = self.__GetSign(dstData, appid, key) myurl = myurl + "?appid=" + appid + "&q=" + urllib.parse.quote( srcData ) + "&from=" + strFrom + "&to=" + strTo + "&salt=" + self.__salt + "&sign=" + mymd5 httpClient = http.client.HTTPConnection("api.fanyi.baidu.com") httpClient.request("GET", myurl) response = httpClient.getresponse() jsonResponse = response.read().decode("utf-8") js = json.loads(jsonResponse) translate = str(js["trans_result"][0]["dst"]) self.__translateTextEdit.insertPlainText(translate) self.__historyFileStream << translate + "\r\n" self.__statusBar.showMessage( self.__GetCurrentTime() + " - Translate successful!", 2000) def __on_triggered_clearAction(self): self.__srcTextEdit.clear() self.__translateTextEdit.clear() self.__statusBar.showMessage( self.__GetCurrentTime() + " - Clear successful!", 2000) def __on_returnPressed_appIDLineEdit(self): appid = self.__appIDLineEdit.text() if not appid.strip(): self.__statusBar.showMessage( self.__GetCurrentTime() + " - There is no appid!", 2000) return self.__infoSettings.beginGroup("info") self.__infoSettings.setValue("appid", appid) self.__infoSettings.endGroup() self.__statusBar.showMessage( self.__GetCurrentTime() + " - Enter appid successful!", 2000) def __on_returnPressed_keyLineEdit(self): key = self.__keyLineEdit.text() if not key.strip(): self.__statusBar.showMessage( self.__GetCurrentTime() + " - There is no key!", 2000) return self.__infoSettings.beginGroup("info") self.__infoSettings.setValue("key", key) self.__infoSettings.endGroup() self.__statusBar.showMessage( self.__GetCurrentTime() + " - Enter key successful!", 2000)
class MainWindow(QMainWindow): """ Our Main Window class""" def __init__(self, fileName=None): """ Constructor Function""" QMainWindow.__init__(self) self.setWindowTitle("A Simple Text Editor") self.setWindowIcon(QIcon('appicon.png')) self.setGeometry(100, 100, 800, 600) self.textEdit = QTextEdit() self.setCentralWidget(self.textEdit) self.fileName = None self.filters = "Text files (*.txt)" def SetupComponents(self): """ Function to setup status bar, central widget, menu bar, tool bar""" self.myStatusBar = QStatusBar() self.setStatusBar(self.myStatusBar) self.myStatusBar.showMessage('Ready', 10000) self.CreateActions() self.CreateMenus() self.CreateToolBar() self.fileMenu.addAction(self.newAction) self.fileMenu.addAction(self.openAction) self.fileMenu.addAction(self.saveAction) self.fileMenu.addSeparator() self.fileMenu.addAction(self.exitAction) self.editMenu.addAction(self.cutAction) self.editMenu.addAction(self.copyAction) self.editMenu.addAction(self.pasteAction) self.editMenu.addSeparator() self.editMenu.addAction(self.undoAction) self.editMenu.addAction(self.redoAction) self.editMenu.addSeparator() self.editMenu.addAction(self.selectAllAction) self.formatMenu.addAction(self.fontAction) self.helpMenu.addAction(self.aboutAction) self.helpMenu.addSeparator() self.helpMenu.addAction(self.aboutQtAction) self.mainToolBar.addAction(self.newAction) self.mainToolBar.addAction(self.openAction) self.mainToolBar.addAction(self.saveAction) self.mainToolBar.addSeparator() self.mainToolBar.addAction(self.cutAction) self.mainToolBar.addAction(self.copyAction) self.mainToolBar.addAction(self.pasteAction) self.mainToolBar.addSeparator() self.mainToolBar.addAction(self.undoAction) self.mainToolBar.addAction(self.redoAction) # Slots called when the menu actions are triggered def newFile(self): self.textEdit.setText('') self.fileName = None def openFile(self): self.fileName, self.filterName = QFileDialog.getOpenFileName(self) self.textEdit.setText(open(self.fileName).read()) def saveFile(self): if (self.fileName == None or self.fileName == ''): self.fileName, self.filterName = QFileDialog.getSaveFileName( self, filter=self.filters) if (self.fileName != ''): file = open(self.fileName, 'w') file.write(self.textEdit.toPlainText()) self.statusBar().showMessage("File saved", 2000) def exitFile(self): self.close() def fontChange(self): (font, ok) = QFontDialog.getFont(QFont("Helvetica[Cronyx]", 10), self) if ok: self.textEdit.setCurrentFont(font) def aboutHelp(self): QMessageBox.about( self, "About Simple Text Editor", "A Simple Text Editor where you can edit and save files") def CreateActions(self): '''Function to create actions for menus''' self.newAction = QAction(QIcon('doc_write.png'), '&New', self, shortcut=QKeySequence.New, statusTip="Create a New File", triggered=self.newFile) self.openAction = QAction(QIcon('doc_write.png'), 'O&pen', self, shortcut=QKeySequence.Open, statusTip="Open an existing file", triggered=self.openFile) self.saveAction = QAction(QIcon('doc_write.png'), '&Save', self, shortcut=QKeySequence.Save, statusTip="Save the current file to disk", triggered=self.saveFile) self.exitAction = QAction(QIcon('doc_write.png'), 'E&xit', self, shortcut="Ctrl+Q", statusTip="Exit the Application", triggered=self.exitFile) self.cutAction = QAction( QIcon('doc_write.png'), 'C&ut', self, shortcut=QKeySequence.Cut, statusTip="Cut the current selection to clipboard", triggered=self.textEdit.cut) self.copyAction = QAction( QIcon('doc_write.png'), 'C&opy', self, shortcut=QKeySequence.Copy, statusTip="Copy the current selection to clipboard", triggered=self.textEdit.copy) self.pasteAction = QAction( QIcon('doc_write.png'), '&Paste', self, shortcut=QKeySequence.Paste, statusTip="Paste the clipboard's content in current location", triggered=self.textEdit.paste) self.selectAllAction = QAction(QIcon('doc_write.png'), 'Select All', self, statusTip="Select All", triggered=self.textEdit.selectAll) self.redoAction = QAction(QIcon('doc_write.png'), 'Redo', self, shortcut=QKeySequence.Redo, statusTip="Redo previous action", triggered=self.textEdit.redo) self.undoAction = QAction(QIcon('doc_write.png'), 'Undo', self, shortcut=QKeySequence.Undo, statusTip="Undo previous action", triggered=self.textEdit.undo) self.fontAction = QAction('F&ont', self, statusTip="Modify font properties", triggered=self.fontChange) self.aboutAction = QAction(QIcon('doc_write.png'), 'A&bout', self, statusTip="Displays info about text editor", triggered=self.aboutHelp) self.aboutQtAction = QAction( "About &Qt", self, statusTip="Show the Qt library's About box", triggered=qApp.aboutQt) def CreateMenus(self): self.fileMenu = self.menuBar().addMenu("&File") self.editMenu = self.menuBar().addMenu("&Edit") self.formatMenu = self.menuBar().addMenu("F&ormat") self.helpMenu = self.menuBar().addMenu("&Help") def CreateToolBar(self): self.mainToolBar = self.addToolBar('Main')
class MainWindow(QMainWindow): """Main Window of the application""" def __init__(self): super().__init__() self.schedule_object = None self.init_ui() self.setStyleSheet(WINDOW_STYLE) self.setWindowTitle("NRC a iCalendar") self.setWindowIcon(QIcon(get_path("assets", "icon.svg"))) self.clikboard = QClipboard() # Dialogo para guardar el archivo self.save_dialog = QFileDialog(self) self.save_dialog.setFileMode(QFileDialog.AnyFile) self.save_dialog.setNameFilter("iCalendar (*.ics)") self.save_dialog.setDefaultSuffix("ics") self.save_dialog.setAcceptMode(QFileDialog.AcceptSave) def init_ui(self): """Makes the layout""" # Barra de opciones y links de interés menu_bar = self.menuBar() options_menu = menu_bar.addMenu("&Opciones") act_allways_visible = options_menu.addAction("Siempre visible") act_allways_visible.setCheckable(True) act_allways_visible.toggled.connect(self.__allways_visible) uc_calendars_menu = menu_bar.addMenu("&Calendarios") for name, link in OTHER_CALENDARS: calendar_option = uc_calendars_menu.addAction(name) # TODO: Ni idea pq se necesita tener una variable `s`, sin esta no funciona calendar_option.triggered.connect( lambda s=None, l=link: self.__to_clipboard(l)) go_to_menu = menu_bar.addMenu("&Ir a") go_to_options = [ ("Feed del calendario de Canvas", "https://cursos.canvas.uc.cl/calendar"), ( "Importar calendario a Google", "https://calendar.google.com/calendar/a/uc.cl/r/settings/export", ), ] for name, link in go_to_options: new_option = go_to_menu.addAction(name) new_option.triggered.connect( lambda s=None, l=link: webbrowser.open(l)) # Main widget main_widget = QFrame() self.setCentralWidget(main_widget) main_layout = QVBoxLayout(main_widget) main_widget.setLayout(main_layout) main_layout.setSizeConstraint(QLayout.SetMinimumSize) # Lista de códigos a ingresar code_layout = QHBoxLayout() main_layout.addLayout(code_layout) self.code_list = [QLineEdit(main_widget) for i in range(6)] code_validator = QIntValidator(main_layout, 10**4, 10**5) for code in self.code_list: code.setObjectName("code_field") code.setAlignment(Qt.AlignCenter) code.setMaxLength(5) code.setValidator(code_validator) code.textEdited.connect(self.check_codes) code_layout.addWidget(code) self.get_button = QPushButton("Obtener horario", main_widget) self.get_button.clicked.connect(self.get_schedule) self.get_button.setCursor(Qt.PointingHandCursor) self.get_button.setDisabled(True) main_layout.addWidget(self.get_button) self.schedule_view = ScheduleView(8, 6, main_widget) main_layout.addWidget(self.schedule_view) self.save_button = QPushButton("Guardar horario", main_widget) self.save_button.clicked.connect(self.save_schedule) self.save_button.setCursor(Qt.PointingHandCursor) self.save_button.setDisabled(True) main_layout.addWidget(self.save_button) self.status_bar = QStatusBar(self) self.status_bar.showMessage("Ingrese los códigos NRC") self.setStatusBar(self.status_bar) self.adjustSize() def __allways_visible(self, option): flags = self.windowFlags() if option: self.setWindowFlags(flags | Qt.WindowStaysOnTopHint) else: self.setWindowFlags(flags ^ Qt.WindowStaysOnTopHint) self.show() def __to_clipboard(self, link): self.clikboard.setText(link) self.status_bar.showMessage( "URL del calendario copiado a portapapeles") def check_codes(self): """Check if the codes are valid""" at_least_one_valid = False for code in self.code_list: if valid_nrc(code.text()): at_least_one_valid = True elif code.text(): # TODO: cambiar el estilo al ser invalido y tener texto pass else: pass self.get_button.setDisabled(not at_least_one_valid) if at_least_one_valid: self.status_bar.clearMessage() else: self.status_bar.showMessage("Ingrese los códigos NRC") def get_schedule(self): """Get the schedule of Buscacursos UC""" valid_codes = list( filter(valid_nrc, map(QLineEdit.text, self.code_list))) if not valid_codes: return try: self.schedule_object = Schedule.get(valid_codes) except OSError: error_box = QMessageBox(QMessageBox.Critical, "Error", "No se ha podido importar el horario") error_box.exec_() else: self.show_schedule() def show_schedule(self): """Show the schedule in the table""" # Limpia el horario self.schedule_view.clearContents() # Si no hay módulos, se deshabilita la opción de guardar y termina if not self.schedule_object.courses: self.schedule_view.update_size() self.save_button.setDisabled(True) return # Si existen módulos, se muestran en el horario for i_row, row in enumerate(self.schedule_object.get_table()): for sub_row in row: for i_col, element in enumerate(sub_row): if not element: continue module_label = QLabel(self.schedule_view) module_label.setText(element.code) module_label.setObjectName(element.type_) module_label.setAlignment(Qt.AlignCenter) module_label.setFixedHeight(20) cell_frame = self.schedule_view.cellWidget(i_row, i_col) # Se crea un frame para los widgets si no existe if not cell_frame: cell_frame = QFrame(self.schedule_view) cell_layout = QVBoxLayout(cell_frame) cell_layout.setSpacing(0) cell_layout.setMargin(0) self.schedule_view.setCellWidget( i_row, i_col, cell_frame) cell_frame.layout().addWidget(module_label) self.schedule_view.update_size() self.save_button.setDisabled(False) def save_schedule(self): """Saves the schedule""" if self.save_dialog.exec_(): out_dir = self.save_dialog.selectedFiles()[0] with open(out_dir, mode="w", encoding="utf-8") as file: file.write(self.schedule_object.to_ics())
class NewProjectForm(QWidget): """Class for a new project widget. Attributes: toolbox (ToolboxUI): Parent widget. configs (ConfigurationParser): Configurations object """ def __init__(self, toolbox, configs): """Initialize class.""" super().__init__(parent=toolbox, f=Qt.Window) # Inherits stylesheet from parent self._toolbox = toolbox self._configs = configs # Set up the user interface from Designer. self.ui = ui.project_form.Ui_Form() self.ui.setupUi(self) # Add status bar to form self.statusbar = QStatusBar(self) self.statusbar.setFixedHeight(20) self.statusbar.setSizeGripEnabled(False) self.statusbar.setStyleSheet(STATUSBAR_SS) self.ui.horizontalLayout_statusbar_placeholder.addWidget( self.statusbar) # Class attributes self.name = '' # Project name self.description = '' # Project description self.connect_signals() self.ui.pushButton_ok.setDefault(True) self.ui.lineEdit_project_name.setFocus() # Ensure this window gets garbage-collected when closed self.setAttribute(Qt.WA_DeleteOnClose) def connect_signals(self): """Connect signals to slots.""" self.ui.lineEdit_project_name.textChanged.connect(self.name_changed) self.ui.pushButton_ok.clicked.connect(self.ok_clicked) self.ui.pushButton_cancel.clicked.connect(self.close) @Slot(name='name_changed') def name_changed(self): """Update label to show a preview of the project directory name.""" project_name = self.ui.lineEdit_project_name.text() default = "Project folder:" if project_name == '': self.ui.label_folder.setText(default) else: folder_name = project_name.lower().replace(' ', '_') msg = default + " " + folder_name self.ui.label_folder.setText(msg) @Slot(name='ok_clicked') def ok_clicked(self): """Check that project name is valid and create project.""" self.name = self.ui.lineEdit_project_name.text() self.description = self.ui.textEdit_description.toPlainText() if self.name == '': self.statusbar.showMessage("No project name given", 5000) return # Check for invalid characters for a folder name invalid_chars = ["<", ">", ":", "\"", "/", "\\", "|", "?", "*", "."] # "." is actually valid in a folder name but # this is to prevent creating folders like "...." if any((True for x in self.name if x in invalid_chars)): self.statusbar.showMessage( "Project name contains invalid character(s) for a folder name", 5000) return # Check if project with same name already exists short_name = self.name.lower().replace(' ', '_') project_folder = os.path.join(project_dir(self._configs), short_name) if os.path.isdir(project_folder): self.statusbar.showMessage("Project already exists", 5000) return # Create new project self.call_create_project() self.close() def call_create_project(self): """Call ToolboxUI method create_project().""" self._toolbox.create_project(self.name, self.description) def keyPressEvent(self, e): """Close project form when escape key is pressed. Args: e (QKeyEvent): Received key press event. """ if e.key() == Qt.Key_Escape: self.close() elif e.key() == Qt.Key_Enter or e.key() == Qt.Key_Return: self.ok_clicked() def closeEvent(self, event=None): """Handle close window. Args: event (QEvent): Closing event if 'X' is clicked. """ if event: event.accept()
class MainWindow(QMainWindow): def __init__(self): super().__init__() # SET => App Icon self.icon = QIcon("img/iconXLNK.png") # End self.tree_view = None self.file_system_model = None # SET => Window Icon self.setWindowIcon(self.icon) # End # WSET => Window Title self.setWindowTitle("XLNK | Data Manager") # End # Menus self.menu = self.menuBar() self.file_menu = self.menu.addMenu("&File") self.edit_menu = self.menu.addMenu("&Edit") self.view_menu = self.menu.addMenu("&View") self.help_menu = self.menu.addMenu("&Help") # End # =================== # Menu Button Actions # Exit QAction exit_action = QAction("Exit", self) exit_action.setShortcut(QKeySequence.Quit) exit_action.triggered.connect(self.close) self.file_menu.addAction(exit_action) # End # End # Tool Bar toolbar = QToolBar(self) self.addToolBar(toolbar) # delete action on toolbar delete_action_tb = QAction("DELETE TABLE ROW", self) delete_action_tb.setStatusTip("Obrisi Red U Tabeli") delete_action_tb.triggered.connect(self.delete_table_row_tb) toolbar.addAction(delete_action_tb) # Dock Widget dock_widget = QDockWidget("EXPLORER", self) # File System Model self.file_system_model = QFileSystemModel() self.file_system_model.setRootPath(QDir.currentPath()) # SET => Tree View MOdel self.tree_view = QTreeView() self.tree_view.setModel(self.file_system_model) self.tree_view.setRootIndex( self.file_system_model.index(QDir.currentPath() + "/data")) self.tree_view.clicked.connect(self.file_clicked_handler) dock_widget.setWidget(self.tree_view) dock_widget.setFloating(False) self.addDockWidget(Qt.LeftDockWidgetArea, dock_widget) # QLabel qlabel = QLabel(self) qlabel.setText("Welcome to XLNK.") # Central Widget self.clicked_file = None self.setCentralWidget(qlabel) self.showMaximized() # ToolBar Functions # TODO def delete_table_row_tb(self): print("Ugraditi funkciju za brisanje reda iz tabele.") def file_clicked_handler(self, index): index = self.tree_view.currentIndex() file_clicked_param = os.path.basename( self.file_system_model.filePath(index)) self.clicked_file = file_clicked_param self.status_bar = QStatusBar(self) self.status_bar.showMessage( "File Selected: {}".format(file_clicked_param), 3000) self.setStatusBar(self.status_bar) self.workspace_widget = WorkSpaceWidget(self, self.clicked_file) self.setCentralWidget(self.workspace_widget)
class MainWindow(QMainWindow): def __init__(self, *args, **kwargs): super(MainWindow, self).__init__(*args, **kwargs) self.available_cameras = QCameraInfo.availableCameras() if not self.available_cameras: pass #quit self.status = QStatusBar() self.setStatusBar(self.status) self.save_path = "" self.viewfinder = QCameraViewfinder() self.viewfinder.show() self.setCentralWidget(self.viewfinder) # Set the default camera. self.select_camera(0) # Setup tools camera_toolbar = QToolBar("Camera") camera_toolbar.setIconSize(QSize(14, 14)) self.addToolBar(camera_toolbar) photo_action = QAction(QIcon(os.path.join('images', 'camera-black.png')), "Take photo...", self) photo_action.setStatusTip("Take photo of current view") photo_action.triggered.connect(self.take_photo) camera_toolbar.addAction(photo_action) change_folder_action = QAction(QIcon(os.path.join('images', 'blue-folder-horizontal-open.png')), "Change save location...", self) change_folder_action.setStatusTip("Change folder where photos are saved.") change_folder_action.triggered.connect(self.change_folder) camera_toolbar.addAction(change_folder_action) camera_selector = QComboBox() camera_selector.addItems([c.description() for c in self.available_cameras]) camera_selector.currentIndexChanged.connect( self.select_camera ) camera_toolbar.addWidget(camera_selector) self.setWindowTitle("NSAViewer") self.show() def select_camera(self, i): self.camera = QCamera(self.available_cameras[i]) self.camera.setViewfinder(self.viewfinder) self.camera.setCaptureMode(QCamera.CaptureStillImage) self.camera.error.connect(lambda: self.alert(self.camera.errorString())) self.camera.start() self.capture = QCameraImageCapture(self.camera) self.capture.error.connect(lambda i, e, s: self.alert(s)) self.capture.imageCaptured.connect(lambda d, i: self.status.showMessage("Image %04d captured" % self.save_seq)) self.current_camera_name = self.available_cameras[i].description() self.save_seq = 0 def take_photo(self): timestamp = time.strftime("%d-%b-%Y-%H_%M_%S") self.capture.capture(os.path.join(self.save_path, "%s-%04d-%s.jpg" % ( self.current_camera_name, self.save_seq, timestamp ))) self.save_seq += 1 def change_folder(self): path = QFileDialog.getExistingDirectory(self, "Snapshot save location", "") if path: self.save_path = path self.save_seq = 0 def alert(self, s): """ Handle errors coming from QCamera dn QCameraImageCapture by displaying alerts. """ err = QErrorMessage(self) err.showMessage(s)
class MainWindow(QMainWindow): changePage = Signal(bool) def __init__(self): super().__init__() self.setWindowTitle('Petro-Explorer v1.0') win_icon = QIcon('icons/Logo.ico') self.setWindowIcon(win_icon) self.setStyleSheet('background-color: #363f49;') self.header = Header() self.navigation = Navigation() self.p_top_bar = PetrophysicsTopBar() self.s_top_bar = StatisticsTopBar() self.p_options_1 = PetrophysicsOptions(_mode='KCarman') self.p_options_2 = PetrophysicsOptions(_mode='TCoates') self.p_options_3 = PetrophysicsOptions(_mode='Winland') self.p_options_4 = PetrophysicsOptions(_mode='RQIFZI') self.p_options_5 = PetrophysicsOptions(_mode='Lucia') self.p_options_6 = PetrophysicsOptions(_mode='DParsons') self.s_options_1 = StatisticsOptions(_mode='Regression') self.s_options_2 = StatisticsOptions(_mode='Statistics') self.s_options_3 = StatisticsOptions(_mode='Histogram') self.s_options_4 = StatisticsOptions(_mode='Boxplot') self.sp_controls = SpreadsheetControls() self.plot_controls = PlotControls() self.plot_viewer = PlotViewer() self.spreadsheet = Spreadsheet() self.status_bar = QStatusBar() self.scroll_area_1 = QScrollArea() self.scroll_area_1.setWidget(self.spreadsheet) self.scroll_area_1.setWidgetResizable(True) self.scroll_area_2 = QScrollArea() self.scroll_area_2.setWidget(self.plot_viewer) self.scroll_area_2.setWidgetResizable(True) self.bar_widget = QWidget() self.bar_widget.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Maximum) self.central_widget = QWidget() self.options_widget = QWidget() self.docking_options = QDockWidget() self.docking_options.setWidget(self.options_widget) self.docking_options.setTitleBarWidget( DockWidgetRibbon(' Opções de cálculo')) self.docking_options2 = QDockWidget() self.docking_options2.setWidget(self.sp_controls) self.docking_options2.setTitleBarWidget( DockWidgetRibbon(' Controles de visualização')) self.setCentralWidget(self.central_widget) self.setStatusBar(self.status_bar) self.addToolBar(self.navigation) self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, self.docking_options) self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, self.docking_options2) self.connections() self.buildLayout() self.centralWidget().setStyleSheet('background-color: #2e3843') self.spreadsheet.setStyleSheet('background-color: white') self.status_bar.setStyleSheet('color: white') def buildLayout(self): stacked_layout_1 = QStackedLayout() # stacked_layout_1.addWidget(QWidget()) stacked_layout_1.addWidget(self.p_top_bar) stacked_layout_1.addWidget(self.s_top_bar) stacked_layout_2 = QStackedLayout() # stacked_layout_2.addWidget(QWidget()) stacked_layout_2.addWidget(self.p_options_1) stacked_layout_2.addWidget(self.p_options_2) stacked_layout_2.addWidget(self.p_options_3) stacked_layout_2.addWidget(self.p_options_4) stacked_layout_2.addWidget(self.p_options_5) stacked_layout_2.addWidget(self.p_options_6) stacked_layout_2.addWidget(self.s_options_1) stacked_layout_2.addWidget(self.s_options_2) stacked_layout_2.addWidget(self.s_options_3) stacked_layout_2.addWidget(self.s_options_4) self.stacked_layout_3 = QStackedLayout() self.stacked_layout_3.addWidget(self.scroll_area_1) self.stacked_layout_3.addWidget(self.scroll_area_2) central_widget_layout = QVBoxLayout() central_widget_layout.addWidget(self.bar_widget) central_widget_layout.addLayout(self.stacked_layout_3) self.central_widget.setLayout(central_widget_layout) self.bar_widget.setLayout(stacked_layout_1) self.options_widget.setLayout(stacked_layout_2) def connections(self): self.navigation.PetroAnalysis.connect( lambda: self.bar_widget.layout().setCurrentIndex(0)) self.navigation.StatsAnalysis.connect( lambda: self.bar_widget.layout().setCurrentIndex(1)) self.navigation.Save.connect(lambda: self.saveDialog()) self.navigation.Import.connect(lambda: self.importDialog()) self.navigation.About.connect(lambda: self.aboutDialog()) self.navigation.Help.connect(lambda: self.helpDialog()) self.navigation.header.HomePage.connect( lambda: self.changePage.emit(True)) self.navigation.ViewSheet.connect(lambda: self.displaySheet()) self.navigation.ViewPlot.connect(lambda: self.displayPltE()) self.navigation.New.connect(lambda: self.spreadsheet.addBlankSheet()) self.p_top_bar.KCarman.connect( lambda: self.options_widget.layout().setCurrentIndex(0)) self.p_top_bar.TCoates.connect( lambda: self.options_widget.layout().setCurrentIndex(1)) self.p_top_bar.Winland.connect( lambda: self.options_widget.layout().setCurrentIndex(2)) self.p_top_bar.DParsons.connect( lambda: self.options_widget.layout().setCurrentIndex(5)) self.p_top_bar.Lucia.connect( lambda: self.options_widget.layout().setCurrentIndex(4)) self.p_top_bar.RF.connect( lambda: self.options_widget.layout().setCurrentIndex(3)) self.s_top_bar.Regr.connect( lambda: self.options_widget.layout().setCurrentIndex(6)) self.s_top_bar.StatDesc.connect( lambda: self.options_widget.layout().setCurrentIndex(7)) self.s_top_bar.Boxplt.connect( lambda: self.options_widget.layout().setCurrentIndex(9)) self.s_top_bar.Hist.connect( lambda: self.options_widget.layout().setCurrentIndex(8)) self.s_options_1.run_button.clicked.connect(self.startRegr) self.s_options_2.run_button.clicked.connect(self.startStat) self.s_options_3.run_button.clicked.connect(self.startHist) self.s_options_4.run_button.clicked.connect(self.startBxpl) self.p_options_1.run.clicked.connect(self.startKCoz) self.p_options_2.run.clicked.connect(self.startTCoa) self.p_options_3.run.clicked.connect(self.startWinl) self.p_options_4.run.clicked.connect(self.startFZIR) self.p_options_5.run.clicked.connect(self.startLuci) self.p_options_6.run.clicked.connect(self.startDyks) self.sp_controls.AddColumn.connect( lambda: self.spreadsheet.addColumn()) self.sp_controls.AddRow.connect(lambda: self.spreadsheet.addRow()) self.sp_controls.DeleteRow.connect( lambda: self.spreadsheet.deleteRow()) self.sp_controls.DeleteColumn.connect( lambda: self.spreadsheet.deleteColumn()) self.plot_controls.run_button.clicked.connect(lambda: self.startPltE()) self.plot_controls.erasePlot.connect( lambda: self.plot_viewer.erasePlot()) self.plot_viewer.feedPlotControls.connect( self.plot_controls.fillFromJson) def startPltE(self): old_json = self.plot_viewer.json_data title = self.plot_controls.modify_title.text() xtype = self.plot_controls.modify_x_axis_type.currentText() ytype = self.plot_controls.modify_y_axis_type.currentText() xlabel = self.plot_controls.modify_x_axis_label.text() ylabel = self.plot_controls.modify_y_axis_label.text() if len(self.plot_controls.modify_lower_x_range.text()) > 0: lxrange = float(self.plot_controls.modify_lower_x_range.text()) else: lxrange = None if len(self.plot_controls.modify_upper_x_range.text()) > 0: uxrange = float(self.plot_controls.modify_upper_x_range.text()) else: uxrange = None if len(self.plot_controls.modify_lower_y_range.text()) > 0: lyrange = float(self.plot_controls.modify_lower_y_range.text()) else: lyrange = None if len(self.plot_controls.modify_upper_y_range.text()) > 0: uyrange = float(self.plot_controls.modify_upper_y_range.text()) else: uyrange = None if len(self.plot_controls.add_x_trace.text()) > 0 and len( self.plot_controls.add_y_trace.text()): trace_type = self.plot_controls.type_of_trace.currentText() x_trace = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info.index( self.plot_controls. add_x_trace.text( ))] y_trace = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info.index( self.plot_controls. add_y_trace.text( ))] trace_name = self.plot_controls.trace_name.text() else: trace_type = None x_trace = None y_trace = None trace_name = None io_operations_handler = HandlerThread() io_operations_handler.messageSent.connect(self.status_bar.showMessage) io_operations_handler.daemon = True io_operations_handler.hasFinished.connect( lambda: self.loadPltE(io_operations_handler.results)) io_operations_handler.loadParameters(f=pceManifold, _args=[ old_json, title, xtype, ytype, xlabel, ylabel, lxrange, uxrange, lyrange, uyrange, trace_type, x_trace, y_trace, trace_name ]) io_operations_handler.start() def loadPltE(self, results, typ='Regressão'): self.plot_viewer.loadPlot(results[0], results[1], _type=typ) self.displayPltE() def displayPltE(self): self.stacked_layout_3.setCurrentIndex(1) self.docking_options2.setWidget(self.plot_controls) #self.removeDockWidget(self.docking_options3) #self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, self.docking_options2) def loadSheet(self, df): self.spreadsheet.changeModel(data=df, header=list(df.keys())) self.displaySheet() def displaySheet(self): self.stacked_layout_3.setCurrentIndex(0) self.docking_options2.setWidget(self.sp_controls) self.status_bar.clearMessage() #self.removeDockWidget(self.docking_options2) #self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, self.docking_options3) def importDialog(self): func = None file_settings = QFileDialog().getOpenFileName( self, 'Importar Arquivo', filter= "Todos os arquivos (*);; Arquivo de Texto (*.txt);; Arquivo CSV (*.csv);; " "Planilha Excel (*.xlsx)") if ".txt" in file_settings[0]: func = Data.readTXT if ".csv" in file_settings[0]: func = Data.readCSV if ".xlsx" in file_settings[0]: func = Data.readExcel self.status_bar.showMessage('Importando arquivo. Aguarde.') io_operations_handler = HandlerThread() io_operations_handler.messageSent.connect(self.status_bar.showMessage) io_operations_handler.daemon = True io_operations_handler.hasFinished.connect( lambda: self.loadSheet(io_operations_handler.results)) io_operations_handler.loadParameters(f=func, _args=[ file_settings[0], ]) io_operations_handler.start() def saveDialog(self): func = None file_settings = QFileDialog().getSaveFileName( self, "Salvar Arquivo", filter="Arquivo de Texto (*.txt);; Arquivo CSV (*.csv);; " "Planilha Excel (*.xlsx)") if ".txt" in file_settings[0]: func = Data.toTXT if ".csv" in file_settings[0]: func = Data.toCSV if ".xlsx" in file_settings[0]: func = Data.toExcel io_operations_handler = HandlerThread() io_operations_handler.messageSent.connect(self.status_bar.showMessage) io_operations_handler.daemon = True io_operations_handler.loadParameters( f=func, _args=[self.spreadsheet.retrieveModel(), file_settings[0]]) io_operations_handler.start() def aboutDialog(self): icon = QIcon(r'icons/sobre.png') text = "O Petro-Explorer é um software desenvolvido no Laboratório de Exploração e Produção de Petróleo (" \ "LENEP) da UENF para análises petrofísicas e estatísticas de dados de rocha. " msg = QMessageBox() msg.setWindowTitle('Sobre Petro-Explorer') msg.setWindowIcon(icon) msg.setText(text) msg.exec_() def helpDialog(self): icon = QIcon(r'icons/ajuda.png') text = r"Para utilizar o Petro-Explorer de maneira correta siga os seguintes passos:" \ "\n1 - Clique no botão Novo na barra de navegação, isto irá limpar quaisquer dados de antigas análises.\n" \ "2 - Para começar a sua análise é preciso importar os dados, assim, clique no botão Importar para escolher o seu arquivo. Atente para o fato que somente três tipos de arquivo são suportados (i.e. *.txt, *.csv, *.xlsx). Depois da sua escolha, os dados devem aparecer na planilha do software.\n" \ "3 - Se você desejar realizar uma análise petrofísica, clique no botão de Análise Petrofísica na barra de navegação. Caso queira realizar uma análise estatística, clique no botão de Análise Estatística na barra de navegação.\n" \ "4 - Selecione na barra superior à planilha, a análise que desejas realizar sobre seus dados.\n" \ "5 - No canto direito da janela, selecione os parâmetros de sua análise assim como o destino de seus resultados. Clique no botão 'Começar Análise' para continuar.\n" \ "6 - Analise seus resultados na planilha, e, quando disponível, no gráfico também.\n" \ "7 - Quando terminar, clique no botão Salvar para salvar os resultados de suas análises no disco.\n" \ "8 - Caso queira realizar outra análise, clique no botão \"Novo\" e comece novamente.\n" msg = QMessageBox() msg.setWindowTitle('Ajuda') msg.setWindowIcon(icon) msg.setText(text) msg.exec_() def startRegr(self): xdata = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info. index(self.s_options_1. payload['x_column'])] ydata = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info. index(self.s_options_1. payload['y_column'])] _type = self.s_options_1.payload['calculate'] dgr = self.s_options_1.degree.value() io_operations_handler = HandlerThread() io_operations_handler.messageSent.connect(self.status_bar.showMessage) io_operations_handler.daemon = True io_operations_handler.hasFinished.connect( lambda: self.displayRegr(self.s_options_1.payload['output_column'], io_operations_handler.results)) io_operations_handler.loadParameters(f=regressionManifold, _args=[xdata, ydata, dgr, _type]) io_operations_handler.start() def startStat(self): xdata = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info. index(self.s_options_2. payload['x_column'])] mthd = self.s_options_2.payload['calculate'] qtl = self.s_options_2.quartile.value() pctl = self.s_options_2.percentile.value() io_operations_handler = HandlerThread() io_operations_handler.messageSent.connect(self.status_bar.showMessage) io_operations_handler.daemon = True io_operations_handler.hasFinished.connect( lambda: self.displayStat(self.s_options_2.payload['output_column'], io_operations_handler.results)) io_operations_handler.loadParameters(f=statisticsManifold, _args=[xdata, mthd, qtl, pctl]) io_operations_handler.start() def startHist(self): xdata = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info. index(self.s_options_3. payload['x_column'])] nbins = self.s_options_3.payload['y_column'] io_operations_handler = HandlerThread() io_operations_handler.messageSent.connect(self.status_bar.showMessage) io_operations_handler.daemon = True io_operations_handler.hasFinished.connect( lambda: self.displayHist(io_operations_handler.results)) io_operations_handler.loadParameters(f=histogramManifold, _args=[xdata, nbins]) io_operations_handler.start() def startBxpl(self): indexes = [] columns = self.s_options_4.payload['column_range'] for col in columns: indexes.append(self.spreadsheet.model.header_info.index(col)) xdata = self.spreadsheet.model.input_data[:, indexes] box_orientation = self.s_options_4.payload['y_column'] io_operations_handler = HandlerThread() io_operations_handler.messageSent.connect(self.status_bar.showMessage) io_operations_handler.daemon = True io_operations_handler.hasFinished.connect( lambda: self.displayBxpl(io_operations_handler.results)) io_operations_handler.loadParameters(f=boxplotManifold, _args=[xdata, box_orientation]) io_operations_handler.start() def startKCoz(self): #you need to ascertain if x corresponds to Permeability, y to Porosity and z to Swir/Svgr k = None phi = None svgr = None prp = self.p_options_1.payload['calculate'] if prp == 'Permeabilidade (mD)': phi = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info. index(self.p_options_1. payload['x_column'])] svgr = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info.index( self.p_options_1. payload['y_column'])] elif prp == 'SVgr (cm-1)': k = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info. index(self.p_options_1. payload['x_column'])] phi = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info. index(self.p_options_1. payload['y_column'])] else: k = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info. index(self.p_options_1. payload['x_column'])] phi = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info. index(self.p_options_1. payload['y_column'])] io_operations_handler = HandlerThread() io_operations_handler.messageSent.connect(self.status_bar.showMessage) io_operations_handler.daemon = True io_operations_handler.hasFinished.connect( lambda: self.displayKCoz(io_operations_handler.results)) io_operations_handler.loadParameters(f=kCarmanManifold, _args=[k, phi, svgr, prp]) io_operations_handler.start() def startTCoa(self): #you need to ascertain if x corresponds to Permeability, y to Porosity and z to Swir/Svgr prp = self.p_options_2.payload['calculate'] if prp == "Swir (%)": xdata = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info.index( self.p_options_2. payload['x_column'])] ydata = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info.index( self.p_options_2. payload['y_column'])] zdata = None else: xdata = None ydata = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info.index( self.p_options_2. payload['y_column'])] zdata = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info.index( self.p_options_2. payload['x_column'])] io_operations_handler = HandlerThread() io_operations_handler.messageSent.connect(self.status_bar.showMessage) io_operations_handler.daemon = True io_operations_handler.hasFinished.connect( lambda: self.displayTCoa(io_operations_handler.results)) io_operations_handler.loadParameters(f=tCoatesManifold, _args=[xdata, ydata, zdata, prp]) io_operations_handler.start() def startWinl(self): #you need to ascertain if x corresponds to Permeability, y to Porosity and z to Swir/Svgr if self.p_options_3.payload['x_column'] != '': xdata = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info.index( self.p_options_3. payload['x_column'])] else: xdata = [] if self.p_options_3.payload['y_column'] != '': ydata = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info.index( self.p_options_3. payload['y_column'])] else: ydata = [] io_operations_handler = HandlerThread() io_operations_handler.messageSent.connect(self.status_bar.showMessage) io_operations_handler.daemon = True io_operations_handler.hasFinished.connect( lambda: self.displayWinl(io_operations_handler.results)) io_operations_handler.loadParameters(f=winlandManifold, _args=[xdata, ydata]) io_operations_handler.start() def startFZIR(self): # you need to ascertain if x corresponds to Permeability, y to Porosity and z to Swir/Svgr if self.p_options_4.payload['x_column'] != '': xdata = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info.index( self.p_options_4. payload['x_column'])] else: xdata = None if self.p_options_4.payload['y_column'] != '': ydata = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info.index( self.p_options_4. payload['y_column'])] else: ydata = None if self.p_options_4.payload['z_column'] != '': zdata = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info.index( self.p_options_4. payload['z_column'])] else: zdata = None prp = self.p_options_4.payload['calculate'] un = self.p_options_4.payload['column_range'] io_operations_handler = HandlerThread() io_operations_handler.messageSent.connect(self.status_bar.showMessage) io_operations_handler.daemon = True io_operations_handler.hasFinished.connect( lambda: self.displayFZIR(io_operations_handler.results)) io_operations_handler.loadParameters( f=fzManifold, _args=[xdata, ydata, zdata, un, prp]) io_operations_handler.start() def startLuci(self): #you need to ascertain if x corresponds to Permeability, y to Porosity and z to Swir/Svgr if self.p_options_5.payload['x_column'] != '': xdata = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info.index( self.p_options_5. payload['x_column'])] else: xdata = [] if self.p_options_5.payload['y_column'] != '': ydata = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info.index( self.p_options_5. payload['y_column'])] else: ydata = [] io_operations_handler = HandlerThread() io_operations_handler.messageSent.connect(self.status_bar.showMessage) io_operations_handler.daemon = True io_operations_handler.hasFinished.connect( lambda: self.displayLuci(io_operations_handler.results)) io_operations_handler.loadParameters(f=luciaManifold, _args=[xdata, ydata]) io_operations_handler.start() def startDyks(self): #you need to ascertain if x corresponds to Permeability, y to Porosity and z to Swir/Svgr if self.p_options_6.payload['x_column'] != '': xdata = self.spreadsheet.model.input_data[:, self.spreadsheet.model. header_info.index( self.p_options_6. payload['x_column'])] else: xdata = [] prp = self.p_options_6.payload['calculate'] io_operations_handler = HandlerThread() io_operations_handler.messageSent.connect(self.status_bar.showMessage) io_operations_handler.daemon = True io_operations_handler.hasFinished.connect( lambda: self.displayDyks(io_operations_handler.results)) io_operations_handler.loadParameters(f=dParsonsManifold, _args=[xdata, prp]) io_operations_handler.start() def displayKCoz(self, content): content = list(content) content.insert(0, 'Resultados - Kozeny-Carman') self.spreadsheet.addColumn(content) def displayWinl(self, content): self.loadPltE(content[:2]) content[2].insert(0, 'R35 - Winland') content[3].insert(0, 'Ports - Winland') self.spreadsheet.addColumn(content[2]) self.spreadsheet.addColumn(content[3]) def displayTCoa(self, content): content.insert(0, 'Resultados - Timur Coates') self.spreadsheet.addColumn(content) def displayDyks(self, content): content.insert(0, 'Resultados - Dykstra-Parsons') self.spreadsheet.addColumn(content) self.p_options_6.results.setText( 'Atenção! Resultado pode ser diferente do coeficiente calculado através do gráfico de probabilidade. \n' + str(content[0]) + ': ' + str(content[1])) def displayLuci(self, results): self.loadPltE(results[:2]) results[2].insert(0, 'Resultados - RFN/Lucia') self.spreadsheet.addColumn(results[2]) def displayFZIR(self, results): results[0].insert(0, 'Resultados - RQI (μm)') self.spreadsheet.addColumn(results[0]) results[1].insert(0, 'Resultados - PhiZ') self.spreadsheet.addColumn(results[1]) self.loadPltE(results[2:]) def displayRegr(self, display_name, results): self.s_options_1.results.setText(str(results[0])) self.loadPltE(results[-2:]) def displayStat(self, display_name, results): self.s_options_2.results.setText(str(results)) def displayHist(self, results): self.loadPltE(results, 'Histograma') def displayBxpl(self, results): self.loadPltE(results, 'Boxplot')
class MainWindow(QMainWindow, Ui_MainWindow): def __init__(self, ui_demo=False): super(MainWindow, self).__init__() self.setupUi(self) self.grid_layout = QGridLayout() self.btnDetectClient.clicked.connect(self.detectClients) self.lineEditIpRange.returnPressed.connect(self.detectClients) self.btnSelectAllClients.clicked.connect(self.selectAllCLients) shortcut = QShortcut(QKeySequence(self.tr("Ctrl+A")), self) shortcut.activated.connect(self.selectAllCLients) self.btnUnselectClients.clicked.connect(self.unselectAllCLients) self.btnSelectExam.clicked.connect(self.selectExamByWizard) self.btnSelectExam.setEnabled(True) self.btnPrepareExam.clicked.connect(self.prepareExam) self.btnPrepareExam.setEnabled(False) self.btnGetExams.clicked.connect(self.retrieveExamFilesByWizard) self.btnGetExams.setEnabled(True) self.btnSaveExamLog.clicked.connect(self.saveExamLog) # self.btnSaveExamLog.setEnabled(False) self.actionBearbeiten.triggered.connect(self.openConfigDialog) self.actionAlle_Benutzer_benachrichtigen.triggered.connect( self.sendMessage) self.actionAlle_Clients_zur_cksetzen.triggered.connect( self.resetClients) self.actionAlle_Clients_rebooten.triggered.connect( self.rebootAllClients) self.actionAlle_Clients_herunterfahren.triggered.connect( self.shutdownAllClients) self.actionOnlineHelp.triggered.connect(self.openHelpUrl) self.actionOfflineHelp.triggered.connect(self.openHelpUrlOffline) self.actionSortClientByCandidateName.triggered.connect( self.sortButtonsByCandidateName) self.actionSortClientByComputerName.triggered.connect( self.sortButtonsByComputerName) self.actionVersionInfo.triggered.connect(self.showVersionInfo) self.actionDisplayIPs.triggered.connect(self.toggleClientIpDisplay) self.btnApplyCandidateNames.clicked.connect(self.applyCandidateNames) self.btnNameClients.clicked.connect(self.activateNameTab) self.btnBlockUsb.clicked.connect(self.blockUsb) self.btnBlockWebAccess.clicked.connect(self.blockWebAccess) self.appTitle = 'ECMan - Exam Client Manager' self.setWindowTitle(self.appTitle) self.logger = Logger(self.textEditLog) self.lb_directory = None self.advancedUi = False self.configure() self.show() if ui_demo is False: self.detectClients() else: self.clientFrame.setLayout(self.grid_layout) for i in range(6): self.addTestClient(i + 100) self.statusBar = QStatusBar() self.setStatusBar(self.statusBar) def sortButtonsByCandidateName(self): ''' sort LbClient-widgets by candidate name :return: nothing ''' clients = [ self.grid_layout.itemAt(i).widget() for i in range(self.grid_layout.count()) ] clients = sorted(clients, key=lambda client: client.computer.candidateName) self.arrangeClientButtons(clients) def sortButtonsByComputerName(self): ''' supposed to sort LbClient-widgets by candidate name :return: nothing ''' clients = [ self.grid_layout.itemAt(i).widget() for i in range(self.grid_layout.count()) ] clients = sorted(clients, key=lambda client: client.computer.getHostName()) self.arrangeClientButtons(clients) def toggleClientIpDisplay(self): clients = [ self.grid_layout.itemAt(i).widget() for i in range(self.grid_layout.count()) ] for client in clients: client.toggleShowIp() def arrangeClientButtons(self, clients): try: for i in reversed(range(self.grid_layout.count())): self.grid_layout.removeItem(self.grid_layout.itemAt(i)) except: pass self.clientFrame.setLayout(self.grid_layout) for button in clients: self.grid_layout.addWidget(button, self.grid_layout.count() / 4, self.grid_layout.count() % 4) self.clientFrame.setLayout(self.grid_layout) def activateNameTab(self): if self.textEditCandidates.toPlainText() == "": candidates = "\n".join( str(x + 1) for x in range(self.grid_layout.count())) self.textEditCandidates.setText(candidates) self.tabs.setCurrentWidget(self.tab_candidates) def openHelpUrl(self): webbrowser.open( self.config.get( "General", "wikiurl", fallback="https://github.com/greenorca/ECMan/wiki")) def openHelpUrlOffline(self): webbrowser.open("file://" + os.getcwd().replace("\\", "/") + "/help/Home.html") def checkOldLogFiles(self): """ dummy, """ pass def blockUsb(self): block = self.btnBlockUsb.text() == "USB blockieren" clients = [ self.grid_layout.itemAt(i).widget() for i in range(self.grid_layout.count()) if self.grid_layout.itemAt(i).widget().isSelected ] if block: for client in clients: client.blockUsbAccessThread() self.btnBlockUsb.setText("USB freigeben") else: for client in clients: client.allowUsbAccessThread() self.btnBlockUsb.setText("USB blockieren") def blockWebAccess(self): block = self.btnBlockWebAccess.text() == "Web blockieren" clients = [ self.grid_layout.itemAt(i).widget() for i in range(self.grid_layout.count()) if self.grid_layout.itemAt(i).widget().isSelected ] if block: for client in clients: client.blockInternetAccessThread() self.btnBlockWebAccess.setText("Web freigeben") else: for client in clients: client.allowInternetAccessThread() self.btnBlockWebAccess.setText("Web blockieren") def resetClients(self): """ resets remote files and configuration for all connected clients """ items = ["Ja, Namen zurücksetzen", "Nein, Namen beibehalten"] item, ok = QInputDialog().getItem( self, "LB-Status zurücksetzen", "USB-Sticks und Internet werden freigeben.\nDaten im Benutzerverzeichnis werden NICHT gelöscht.\nKandidaten-Namen zurücksetzen? ", items, 0, False) if ok is False: return resetCandidateName = True if item.startswith("Ja") else False clients = [ self.grid_layout.itemAt(i).widget() for i in range(self.grid_layout.count()) ] progressDialog = EcManProgressDialog(self, "Reset Clients") progressDialog.setMaxValue(self.grid_layout.count()) progressDialog.resetValue() progressDialog.open() self.worker = ResetClientsWorker(clients, resetCandidateName) self.worker.updateProgressSignal.connect(progressDialog.incrementValue) self.worker.start() def closeEvent(self, event): """ overrides closeEvent of base class, clean up """ print("cleaning up...") # try:* especially remove shares created on Windows hosts # for share in self.sharenames: # Thread(target=self.runLocalPowerShellAsRoot("Remove-SmbShare -Name {} -Force".format(share))).start() # except Exception: # pass # print("done cleaning up...") super(MainWindow, self).closeEvent(event) def selectAllCLients(self): """ marks / selects all connected client pcs """ for i in range(self.grid_layout.count()): self.grid_layout.itemAt(i).widget().select() def unselectAllCLients(self): """ unmarks / unselects all connected client pcs """ for i in range(self.grid_layout.count()): self.grid_layout.itemAt(i).widget().unselect() def shutdownAllClients(self): for i in range(self.grid_layout.count()): self.grid_layout.itemAt(i).widget().shutdownClient() def rebootAllClients(self): for i in range(self.grid_layout.count()): self.grid_layout.itemAt(i).widget().computer.reboot() self.grid_layout.itemAt(i).widget().deleteLater() # TODO TEST sven #for i in range(self.grid_layout.count()): # self.grid_layout.removeItem(self.grid_layout.itemAt(i)) def sendMessage(self): message, ok = QInputDialog.getText(self, "Eingabe", "Nachricht an Kandidaten eingeben") if ok: for i in range(self.grid_layout.count()): QThreadPool.globalInstance().start( SendMessageTask( self.grid_layout.itemAt(i).widget(), message)) def applyCandidateNames(self): """ reads candidate names from respective textEditField (line by line) and applies these names to (random) client pcs """ names = self.textEditCandidates.toPlainText().rstrip().splitlines() # cleanup and remove duplicate names names = [x.strip() for x in names] names = list(set(names)) clients = [ self.grid_layout.itemAt(i).widget() for i in range(self.grid_layout.count()) ] # select only the computers without candidate name if self.checkBox_OverwriteExisitingNames.checkState( ) != Qt.CheckState.Checked: clients = [ x for x in clients if x.computer.getCandidateName() == "" or x.computer.getCandidateName() is None ] if len(names) > len(clients): self.showMessageBox( "Fehler", "Nicht genug Prüfungs-PCs für alle {} Kandidaten".format( str(len(names))), messageType=QMessageBox.Warning) return progressDialog = EcManProgressDialog( self, "Fortschritt Kandidatennamen setzen") progressDialog.setMaxValue(len(names)) progressDialog.resetValue() self.worker = SetCandidateNamesWorker(clients, names) self.worker.updateProgressSignal.connect(progressDialog.incrementValue) self.worker.start() progressDialog.open() self.tabs.setCurrentWidget(self.tab_pcs) def configure(self): """ sets inial values for app """ self.port = 5986 self.server = None self.configFile = Path(str(Path.home()) + "/.ecman.conf") if not (self.configFile.exists()): result = self.openConfigDialog() if self.configFile.exists() or result == 1: self.readConfigFile() self.result_directory = "" self.sharenames = [ ] # dump all eventually created local Windows-Shares in this array self.debug = True # fetch own ip adddress s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) try: s.connect(('9.9.9.9', 1)) # connect() for UDP doesn't send packets self.ip_address = s.getsockname()[0] parts = self.ip_address.split(".")[0:-1] self.ipRange = ".".join(parts) + ".*" self.lineEditIpRange.setText(self.ipRange) self.appTitle = self.windowTitle() + " on " + self.ip_address self.setWindowTitle(self.appTitle) except Exception as ex: self.ipRange, ok = QInputDialog.getText( self, "Keine Verbindung zum Internet", "Möglicherweise gelingt der Sichtflug. Bitte geben Sie die lokale IP-Adresse ein:" ) self.log("no connection to internet:" + str(ex)) def readConfigFile(self): """ reads config file into class variables """ self.config = ConfigParser() self.config.read_file(open(str(self.configFile))) self.port = self.config.get("General", "winrm_port", fallback=5986) self.client_lb_user = self.config.get("Client", "lb_user", fallback="student") self.user = self.config.get("Client", "user", fallback="") self.passwd = self.config.get("Client", "pwd", fallback="") self.maxFiles = int( self.config.get("Client", "max_files", fallback="1000")) self.maxFileSize = int( self.config.get("Client", "max_filesize", fallback="1000")) * 1024 * 1024 # thats MB now... self.advancedUi = self.config.get('General', 'advanced_ui', fallback="False") == "True" pass def openConfigDialog(self): """ opens configuration dialog """ config_dialog = EcManConfigDialog(self) result = config_dialog.exec_() if result == 1: config_dialog.saveConfig() self.readConfigFile() return result def log(self, message): """ basic logging functionality TODO: improve... """ self.logger.log(message) def updateProgressBar(self, value): self.progressBar.setValue(value) if (value == self.progressBar.maximum()): self.enableButtons(True) self.progressBar.setEnabled(False) def enableButtons(self, enable): if type(enable) != bool: raise Exception("Invalid parameter, must be boolean") self.btnNameClients.setEnabled(enable) self.btnSelectAllClients.setEnabled(enable) self.btnUnselectClients.setEnabled(enable) self.btnPrepareExam.setEnabled(enable) self.btnGetExams.setEnabled(enable) self.btnSaveExamLog.setEnabled(enable) self.btnDetectClient.setEnabled(enable) self.btnBlockWebAccess.setEnabled(enable) self.btnBlockUsb.setEnabled(enable) def retrieveExamFilesByWizard(self): """ retrieve exam files for all clients """ # find all suitable clients (required array for later threading) clients = [ self.grid_layout.itemAt(i).widget() for i in range(self.grid_layout.count()) if self.grid_layout.itemAt(i).widget().isSelected and self.grid_layout.itemAt(i).widget().computer.state in [ Computer.State.STATE_DEPLOYED, Computer.State.STATE_FINISHED, Computer.State.STATE_RETRIVAL_FAIL ] ] if len(clients) == 0: self.showMessageBox("Achtung", "Keine Clients ausgewählt bzw. deployed") return unknownClients = [ c for c in clients if c.computer.getCandidateName() == "" or c.computer.getCandidateName() == None ] for unknown in unknownClients: unknown.computer.state = Computer.State.STATE_RETRIVAL_FAIL unknown._colorizeWidgetByClientState() if unknownClients != []: choice = QMessageBox.critical( self, "Achtung", "{} clients ohne gültigen Kandidatennamen.<br>Rückholung für alle anderen fortsetzen?" .format(str(len(unknownClients))), QMessageBox.Yes, QMessageBox.No) if choice == QMessageBox.No: return clients = [c for c in clients if c not in unknownClients] retVal = QMessageBox.StandardButton.Yes if self.result_directory != "": items = [ "Ergebnispfad neu auswählen", "Weiter mit bisherigem Verzeichnis" ] item, ok = QInputDialog().getItem( self, "Achtung", "LB-Ergebnisverzeichnis ist bereits ausgewählt.\nErneutes Abholen kann existierende Ergebnisse überschreiben.\nWas möchten Sie tun?", items, 0, False) if ok is False: return if self.result_directory == "" or item == "Ergebnispfad neu auswählen": if self.server is None or self.server.connect() is not True: self.server = self.getServerCredentialsByWizard() if self.server is None: return wizard = EcShareWizard( parent=self, server=self.server, wizardType=EcShareWizard.TYPE_RESULT_DESTINATION, advanced_Ui=self.advancedUi) wizard.setModal(True) result = wizard.exec_() print("I'm done, wizard result=" + str(result)) if result == 1: print("selected values: %s - %s - %s" % (wizard.field("username"), wizard.field("servername"), wizard.selectedPath)) self.result_directory = wizard.selectedPath else: print("Abbruch, kein Zielverzeichnis ausgewählt") return self.result_directory = self.result_directory.replace("/", "#") self.log("save result files into: " + self.result_directory.replace("#", "\\")) progressDialog = EcManProgressDialog( self, "Fortschritt Ergebnisse kopieren") progressDialog.setMaxValue(len(clients)) progressDialog.resetValue() progressDialog.open() self.log("starting to retrieve files") self.worker = RetrieveResultsWorker(clients, self.server.user, self.server.password, self.server.domain, self.result_directory, self.maxFiles, self.maxFileSize) self.worker.updateProgressSignal.connect(progressDialog.incrementValue) self.worker.start() self.btnSaveExamLog.setEnabled(True) def prepareExam(self): self.copyFilesToClient() pass def copyFilesToClient(self): """ copies selected exam folder to all connected clients that are selected and not in STATE_DEPLOYED or STATE_FINISHED """ if self.lb_directory == None or self.lb_directory == "": self.showMessageBox("Fehler", "Kein Prüfungsordner ausgewählt") return clients = [ self.grid_layout.itemAt(i).widget() for i in range(self.grid_layout.count()) if self.grid_layout.itemAt(i).widget().isSelected and self.grid_layout.itemAt(i).widget().computer.state not in [Computer.State.STATE_DEPLOYED, Computer.State.STATE_FINISHED] ] if len([x for x in clients if x.computer.candidateName == None]) > 0: self.showMessageBox("Warnung", "Bitte Kandidatenname für alle PCs vergeben") return if len(clients) == 0: self.showMessageBox( "Warnung", "Keine Client-PCs ausgewählt oder Prüfungen bereits aktiv") return progressDialog = EcManProgressDialog( self, "Fortschritt LB-Client-Deployment") progressDialog.setMaxValue(len(clients)) progressDialog.resetValue() progressDialog.open() self.worker = CopyExamsWorker( clients, self.server.user, self.server.password, self.server.domain, src=self.lb_directory, reset=(self.checkBoxWipeHomedir.checkState() == Qt.CheckState.Checked)) self.worker.updateProgressSignal.connect(progressDialog.incrementValue) self.worker.start() def detectClients(self): """ starts portscan to search for winrm enabled clients """ ip_range = self.lineEditIpRange.text() if not (ip_range.endswith('*')): self.showMessageBox( 'Eingabefehler', 'Gültiger IP-V4 Bereich endet mit * (z.B. 192.168.0.*)') return try: self.worker.exit() except Exception as ex: print("crashed on stopping existing scanner thread: " + str(ex)) self.ipRange = ip_range self.progressBar.setEnabled(True) self.progressBar.setValue(0) self.enableButtons(enable=False) self.clientCount = 0 # clear previous client buttons try: for i in reversed(range(self.grid_layout.count())): self.grid_layout.itemAt(i).widget().close() self.grid_layout.itemAt(i).widget().deleteLater() except: pass self.clientFrame.setLayout(self.grid_layout) self.progressBar.setMaximum(253) self.worker = ScannerWorker(self.ipRange, self.ip_address) self.worker.updateProgressSignal.connect(self.updateProgressBar) self.worker.addClientSignal.connect(self.addClient) self.worker.start() def addClient(self, ip): """ populate GUI with newly received client ips param ip: only last byte required param scan: wether or not scan the Client (set to False only for GUI testing) """ self.log("new client signal received: " + str(ip)) self.clientCount += 1 self.statusBar.showMessage( str(self.clientCount) + " clients detected", 0) clientIp = self.ipRange.replace("*", str(ip)) button = LbClient(clientIp, remoteAdminUser=self.user, passwd=self.passwd, candidateLogin=self.client_lb_user, parentApp=self) button.setMinimumHeight(50) # button.installEventFilter(self) self.grid_layout.addWidget(button, self.grid_layout.count() / 4, self.grid_layout.count() % 4) self.clientFrame.setLayout(self.grid_layout) # QtGui.qApp.processEvents() def addTestClient(self, ip): """ populate GUI with dummy buttons param ip: only last byte required """ self.log("new client signal received: " + str(ip)) clientIp = self.ipRange.replace("*", str(ip)) button = LbClient(clientIp, remoteAdminUser=self.user, passwd=self.passwd, candidateLogin=self.client_lb_user, parentApp=self, test=True) button.setMinimumHeight(50) # button.installEventFilter(self) self.grid_layout.addWidget(button, self.grid_layout.count() / 4, self.grid_layout.count() % 4) self.clientFrame.setLayout(self.grid_layout) # QtGui.qApp.processEvents() def getExamPath(self): return self.lb_directory def getServerCredentialsByWizard(self): """ open server config and login dialog, returns server object or None """ wizard = EcLoginWizard(parent=self, username=self.config.get("General", "username", fallback=""), domain=self.config.get("General", "domain", fallback=""), servername=self.config.get("General", "lb_server", fallback="")) wizard.setModal(True) result = wizard.exec_() print("I'm done, wizard result=" + str(result)) if result == 1: self.config["General"]["username"] = wizard.field("username") self.config["General"]["domain"] = wizard.field("domainname") self.config["General"]["servername"] = wizard.server.serverName self.saveConfig() return wizard.server return None def selectExamByWizard(self): """ provides ability to select serverName share plus logon credentials and lb directory using a wizard """ if self.server == None or self.server.connect() is False: self.server = self.getServerCredentialsByWizard() wizard = EcShareWizard(parent=self, server=self.server, wizardType=EcShareWizard.TYPE_LB_SELECTION, advanced_Ui=self.advancedUi) wizard.setModal(True) result = wizard.exec_() print("I'm done, wizard result=" + str(result)) if result == 1: self.lb_directory = wizard.selectedPath self.setWindowTitle(self.appTitle + " - LB-Verzeichnis::" + self.lb_directory.split("/")[-1]) self.log("setup LB directory: " + self.lb_directory.split("/")[-1]) self.btnPrepareExam.setEnabled(True) self.lblExamName.setText(self.lb_directory) else: self.log("no valid share selected") def saveExamLog(self): """ on demand, store all client logs as PDF """ if self.result_directory == None or len(self.result_directory) == 0: self.showMessageBox( "Fehler", "Ergebnispfad für Prüfungsdaten nicht gesetzt.<br>Bitte zuerst Prüfungsdaten abholen.", QMessageBox.Error) return clients = [ self.grid_layout.itemAt(i).widget() for i in range(self.grid_layout.count()) ] for client in clients: lb_dataDirectory = client.computer.lb_dataDirectory.split("#")[-1] pdfFileName = "protocol_" + date.today( ).__str__() + "_" + client.computer.getCandidateName().replace( " ", "_") + ".pdf" LogfileHandler(client.computer.logfile_name, client.computer.getCandidateName()). \ createPdf(pdfFileName) if not (self.server.connect()): self.showMessageBox( "Fehler", "Verbindung zum Server kann nicht aufgebaut werden.", QMessageBox.Error) return with open(pdfFileName, "rb") as file: sharename = self.result_directory.replace("##", "").split("#")[1] destination = "/".join( self.result_directory.replace( "##", "").split("#")[2:]) + "/" + lb_dataDirectory + "/" self.server.conn.storeFile(sharename, destination + pdfFileName, file) def __runLocalPowerShellAsRoot(self, command): """ maybe useful at some stage again # see https://docs.microsoft.com/en-us/windows/desktop/api/shellapi/nf-shellapi-shellexecutew#parameters :param command: :return: """ retval = ctypes.windll.shell32.ShellExecuteW( None, "runas", # runas admin, "C:\\WINDOWS\\system32\\WindowsPowerShell\\v1.0\\powershell.exe", # file to run command, # actual powershell command None, 0) # last param disables popup powershell window... if retval != 42: self.log("ReturnCode after creating smbShare: " + str(retval)) subprocess.run([ "C:\\WINDOWS\\system32\\WindowsPowerShell\\v1.0\\powershell.exe", "Get-SmbShare" ]) raise Exception("ReturnCode after running powershell: " + str(retval)) def __openFile(self): fname = QFileDialog.getOpenFileName(self, 'Open file', '/home') if fname[0]: f = open(fname[0], 'r') with f: data = f.read() doc = QTextDocument(data, None) self.textEditLog.setDocument(doc) def saveConfig(self): """ write to file what's currently set in config """ if not (self.configFile.exists()): self.configFile.touch() self.config.write(open(self.configFile, 'w')) def eventFilter(self, currentObject, event): """ unused, define mouseover events (with tooltips) for LbClient widgets """ if event.type() == QEvent.Enter: if isinstance(currentObject, LbClient): print("Mouseover event catched") currentObject.setOwnToolTip() return True else: self.log(str(type(currentObject)) + " not recognized") # elif event.type() == QEvent.Leave: # pass return False def showMessageBox(self, title, message, messageType=QMessageBox.Information): """ convinence wrapper """ msg = QMessageBox(messageType, title, message, parent=self) if messageType != QMessageBox.Information: msg.setStandardButtons(QMessageBox.Abort) return msg.exec_() def showVersionInfo(self): info = "<b>Offizielles Release:</b><br>" + version try: # latest release - make sure to save this file before building :-) modDate = time.localtime(os.path.getmtime(__file__)) info = info + "<br><br><b>Diese Version:</b><br>" + time.strftime( "%Y-%m-%d", modDate) except: pass self.showMessageBox("ECMan - Version", info)
class Main_Window(QMainWindow): '''Our Main Window Class''' def __init__(self): '''Constructure Function''' QMainWindow.__init__(self) self.setWindowTitle("A Sample Text Editor") self.setWindowIcon(QIcon('doc_open.png')) self.setGeometry(350, 250, 550, 400) # self.setGeometry(x,y,w,h) #self.setMinimumSize(250,250)# Size -> Width * Height #self.setMaximumSize(750,750) self.CreateStatusBar() #self.CreateProgressBar() #self.showProgress() self.setUpComponents() def setUpComponents(self): '''Setting Up Central Widget''' self.textEdit = QTextEdit("Enter your Text Here") self.setCentralWidget(self.textEdit) self.CreateActions() self.CreateMenus() self.CreateToolBar() self.fileMenu.addAction(self.newAction) self.fileMenu.addSeparator() self.fileMenu.addAction(self.exitAction) self.fileMenu.addAction(self.copyAction) self.fileMenu.addSeparator() self.fileMenu.addAction(self.pasteAction) self.fileMenu.addAction(self.aboutAction) self.mainToolbar.addAction(self.newAction) self.mainToolbar.addSeparator() self.mainToolbar.addAction(self.copyAction) self.mainToolbar.addAction(self.pasteAction) def CreateToolBar(self): '''Function to Create Toolbar''' self.mainToolbar = self.addToolBar('Main') #Slots Menu When Menu actions are Triggered def newFile(self): self.textEdit.setText('') def exitFile(self): self.close() def aboutHelp(self): QMessageBox.about(self, "About Simple Text Editor", "This Example Demonstrate the Use of Menu Bar") def CreateActions(self): '''Functions to Create actions for Menus''' self.newAction = QAction(QIcon('doc_open.png'), '&New', self, shortcut=QKeySequence.New, statusTip='Create a New File', triggered=self.newFile) self.exitAction = QAction(QIcon('doc_open.png'), 'E&xit', self, shortcut="Ctrl+Q", statusTip="Exit the Application", triggered=self.exitFile) self.copyAction = QAction(QIcon("doc_open.png"), 'C&opy', self, shortcut="Ctrl+c", statusTip="Copy", triggered=self.textEdit.copy) self.pasteAction = QAction(QIcon('paste.png'), '&Paste', self, shortcut="Ctrl+V", statusTip="Paste", triggered=self.textEdit.paste) self.aboutAction = QAction(QIcon('about.png'), 'A&bout', self, statusTip="Displays info about text editor", triggered=self.aboutHelp) def CreateMenus(self): #Actual Menu Bar Item Creation '''Function to Create actual menu bar''' self.fileMenu = self.menuBar().addMenu("&File") self.editMenu = self.menuBar().addMenu("&Edit") self.helpMenu = self.menuBar().addMenu("&Help") def showProgress(self): '''Function to Show Progress''' self.CreateProgressBar() while (self.progressbar.value() < self.progressbar.maximum()): self.progressbar.setValue(self.progressbar.value() + 10) time.sleep(0.5) self.myProgressMessage.setText("Ready") def CreateProgressBar(self): '''Function to Create Progrss Bar''' self.myProgressMessage = QLabel("In Progress") self.progressbar = QProgressBar() self.progressbar.setMinimum(0) self.progressbar.setMaximum(100) self.myProgressStatusBar = QStatusBar() self.progressbar.setValue(0) self.myProgressStatusBar.addWidget(self.myProgressMessage, 1) self.myProgressStatusBar.addWidget(self.progressbar, 2) self.setStatusBar(self.myProgressStatusBar) def CreateStatusBar(self): '''Function to Create Status Bar''' self.myStatusBar = QStatusBar() self.myStatusBar.showMessage("Getting Ready", 2000) self.setStatusBar(self.myStatusBar)
class main(QWidget): def __init__(self, app: QApplication): super().__init__() logging.basicConfig(format='%(asctime)s %(levelname)-8s %(message)s', level=logging.DEBUG, datefmt='%Y-%m-%d %H:%M:%S') logging.info("Application started") # Generic setup stuff self.app = app # Load Dark mode because it's 2021 styleStream = QFile( os.path.join(os.path.dirname(__file__), 'resources/qdarkstyle/style.qss')) styleStream.open(QIODevice.ReadOnly) self.ensurePolished() self.app.setStyleSheet(QTextStream(styleStream).readAll()) self.ui = mainwindow.Ui_main() self.ui.setupUi(self) # Add status bar manually because Qt Creator doesn't seem to support it self.statusBar = QStatusBar(self) styleString = ("font: Waree; font-size: 32px;") self.statusBar.setStyleSheet(styleString) self.ui.verticalLayout_2.addWidget(self.statusBar) self.statusBar.showMessage("Hello World!", 2000) # Static signal connections self.ui.button_qt.clicked.connect(self.app.aboutQt) # Make list of always visible buttons to pass to everything self.buttons = [ self.ui.button_rhs_0, self.ui.button_rhs_1, self.ui.button_rhs_2, self.ui.button_rhs_3, self.ui.button_rhs_4, self.ui.button_rhs_5 ] # Warning Handler self.warnings = WarningHandler(self.ui.tab_widget, self.ui.table_warnings, self.buttons, self.statusBar) # MQTT Stuff with MqttHandler(MQTT_ADDRESS, MQTT_PORT, self.warnings) as self.mqtt, NetworkHandler( self.ui.tabWidget_network, self.mqtt, self.warnings, self.buttons) as self.network: self.ui.label_mqttAddr.setText(MQTT_ADDRESS) self.ui.label_mqttPort.setText(str(MQTT_PORT)) # Info / Status Handler self.info = InfoHandler(self.ui, self.warnings) # Add callback for when tab is changed self.ui.tab_widget.currentChanged.connect(self.tabChangeDespatcher) # VFO Declaration self.vfoA = Vfo("A", self.mqtt, self.network, self.warnings, self.ui.button_A_rx, self.ui.button_A_tx, self.ui.label_A_fc, self.ui.label_A_bw, self.ui.button_A_mode, self.ui.button_A_freq) self.vfoB = Vfo("B", self.mqtt, self.network, self.warnings, self.ui.button_B_rx, self.ui.button_B_tx, self.ui.label_B_fc, self.ui.label_B_bw, self.ui.button_B_mode, self.ui.button_B_freq) # Doesn't count as change on startup so poke to ensure tab gets updated self.tabChangeDespatcher(self.ui.tab_widget.currentIndex()) self.showFullScreen() self.app.exec_() def keyPressEvent(self, event): if event.key() != 16777248: # Shift key logging.debug(f"Key {event.key()} ({event.text()}) pressed") if (event.text() == 'a'): self.vfoA.increment() elif (event.text() == 'A'): self.vfoA.decrement() elif (event.text() == 'G'): self.app.exit() # DEBUG def tabChangeDespatcher(self, tabId): logging.debug(f"Changing tab to {tabId}") for x in self.buttons: x.setText("") x.setEnabled(False) x.setCheckable(False) try: x.clicked.disconnect() except RuntimeError: pass try: x.toggled.disconnect() except RuntimeError: pass if (tabId == TAB_HOME): pass # @TODO elif (tabId == TAB_SETTINGS): pass # @TODO elif (tabId == TAB_INFO): self.info.tab_enabled() elif (tabId == TAB_WARNINGS): self.warnings.tab_enabled() elif (tabId == TAB_NETWORK): self.network.tab_enabled() else: raise NotImplementedError
class View(QMainWindow): def __init__(self, model, controller): super().__init__() self._model = model self._controller = controller self.segmentcursor = False self.togglecolors = {"#1f77b4": "m", "m": "#1f77b4"} ################################################################# # define GUI layout and connect input widgets to external slots # ################################################################# self.setWindowTitle("biopeaks") self.setGeometry(50, 50, 1750, 750) self.setWindowIcon(QIcon(":/python_icon.png")) # figure0 for signal self.figure0 = Figure() self.canvas0 = FigureCanvas(self.figure0) # Enforce minimum height, otherwise resizing with self.splitter causes # mpl to throw an error because figure is resized to height 0. The # widget can still be fully collapsed with self.splitter- self.canvas0.setMinimumHeight(1) # in pixels self.ax00 = self.figure0.add_subplot(1, 1, 1) self.ax00.set_frame_on(False) self.figure0.subplots_adjust(left=0.04, right=0.98, bottom=0.25) self.line00 = None self.scat = None self.segmentspan = None # figure1 for marker self.figure1 = Figure() self.canvas1 = FigureCanvas(self.figure1) self.canvas1.setMinimumHeight(1) self.ax10 = self.figure1.add_subplot(1, 1, 1, sharex=self.ax00) self.ax10.get_xaxis().set_visible(False) self.ax10.set_frame_on(False) self.figure1.subplots_adjust(left=0.04, right=0.98) self.line10 = None # figure2 for statistics self.figure2 = Figure() self.canvas2 = FigureCanvas(self.figure2) self.canvas2.setMinimumHeight(1) self.ax20 = self.figure2.add_subplot(3, 1, 1, sharex=self.ax00) self.ax20.get_xaxis().set_visible(False) self.ax20.set_frame_on(False) self.line20 = None self.ax21 = self.figure2.add_subplot(3, 1, 2, sharex=self.ax00) self.ax21.get_xaxis().set_visible(False) self.ax21.set_frame_on(False) self.line21 = None self.ax22 = self.figure2.add_subplot(3, 1, 3, sharex=self.ax00) self.ax22.get_xaxis().set_visible(False) self.ax22.set_frame_on(False) self.line22 = None self.figure2.subplots_adjust(left=0.04, right=0.98) # navigation bar self.navitools = CustomNavigationToolbar(self.canvas0, self) # peak editing self.editcheckbox = QCheckBox("editable", self) self.editcheckbox.stateChanged.connect(self._model.set_peakseditable) # peak saving batch self.savecheckbox = QCheckBox("save during batch processing", self) self.savecheckbox.stateChanged.connect(self._model.set_savebatchpeaks) # peak auto-correction batch self.correctcheckbox = QCheckBox("correct during batch processing", self) self.correctcheckbox.stateChanged.connect( self._model.set_correctbatchpeaks) # selecting stats for saving self.periodcheckbox = QCheckBox("period", self) self.periodcheckbox.stateChanged.connect( lambda: self.select_stats("period")) self.ratecheckbox = QCheckBox("rate", self) self.ratecheckbox.stateChanged.connect( lambda: self.select_stats("rate")) self.tidalampcheckbox = QCheckBox("tidal amplitude", self) self.tidalampcheckbox.stateChanged.connect( lambda: self.select_stats("tidalamp")) # channel selection self.sigchanmenulabel = QLabel("biosignal") self.sigchanmenu = QComboBox(self) self.sigchanmenu.addItem("A1") self.sigchanmenu.addItem("A2") self.sigchanmenu.addItem("A3") self.sigchanmenu.addItem("A4") self.sigchanmenu.addItem("A5") self.sigchanmenu.addItem("A6") self.sigchanmenu.currentTextChanged.connect(self._model.set_signalchan) # initialize with default value self._model.set_signalchan(self.sigchanmenu.currentText()) self.markerchanmenulabel = QLabel("marker") self.markerchanmenu = QComboBox(self) self.markerchanmenu.addItem("none") self.markerchanmenu.addItem("I1") self.markerchanmenu.addItem("I2") self.markerchanmenu.addItem("A1") self.markerchanmenu.addItem("A2") self.markerchanmenu.addItem("A3") self.markerchanmenu.addItem("A4") self.markerchanmenu.addItem("A5") self.markerchanmenu.addItem("A6") self.markerchanmenu.currentTextChanged.connect( self._model.set_markerchan) # initialize with default value self._model.set_markerchan(self.markerchanmenu.currentText()) # processing mode (batch or single file) self.batchmenulabel = QLabel("mode") self.batchmenu = QComboBox(self) self.batchmenu.addItem("single file") self.batchmenu.addItem("multiple files") self.batchmenu.currentTextChanged.connect(self._model.set_batchmode) self.batchmenu.currentTextChanged.connect(self.toggle_options) # initialize with default value self._model.set_batchmode(self.batchmenu.currentText()) self.toggle_options(self.batchmenu.currentText()) # modality selection self.modmenulabel = QLabel("modality") self.modmenu = QComboBox(self) self.modmenu.addItem("ECG") self.modmenu.addItem("PPG") self.modmenu.addItem("RESP") self.modmenu.currentTextChanged.connect(self._model.set_modality) self.modmenu.currentTextChanged.connect(self.toggle_options) # initialize with default value self._model.set_modality(self.modmenu.currentText()) self.toggle_options(self.modmenu.currentText()) # segment selection; this widget can be openend / set visible from # the menu and closed from within itself (see mapping of segmentermap); # it provides utilities to select a segment from the signal self.segmentermap = QSignalMapper(self) self.segmenter = QDockWidget("select a segment", self) # disable closing such that widget can only be closed by confirming # selection or custom button self.segmenter.setFeatures(QDockWidget.NoDockWidgetFeatures) # Limit number of decimals to four. regex = QRegExp("[0-9]*\.?[0-9]{4}") validator = QRegExpValidator(regex) self.startlabel = QLabel("start") self.startedit = QLineEdit() self.startedit.setValidator(validator) self.endlabel = QLabel("end") self.endedit = QLineEdit() self.endedit.setValidator(validator) segmentfromcursor = QAction(QIcon(":/mouse_icon.png"), "select with mouse", self) segmentfromcursor.triggered.connect(self.enable_segmentedit) self.startedit.addAction(segmentfromcursor, QLineEdit.TrailingPosition) self.endedit.addAction(segmentfromcursor, QLineEdit.TrailingPosition) self.previewedit = QPushButton("preview segment") lambdafn = lambda: self._model.set_segment( [self.startedit.text(), self.endedit.text()]) self.previewedit.clicked.connect(lambdafn) self.confirmedit = QPushButton("confirm segment") self.confirmedit.clicked.connect(self._controller.segment_signal) self.confirmedit.clicked.connect(self.segmentermap.map) self.segmentermap.setMapping(self.confirmedit, 0) self.abortedit = QPushButton("abort segmentation") self.abortedit.clicked.connect(self.segmentermap.map) # reset the segment to None self.segmentermap.setMapping(self.abortedit, 2) self.segmenterlayout = QFormLayout() self.segmenterlayout.addRow(self.startlabel, self.startedit) self.segmenterlayout.addRow(self.endlabel, self.endedit) self.segmenterlayout.addRow(self.previewedit) self.segmenterlayout.addRow(self.confirmedit) self.segmenterlayout.addRow(self.abortedit) self.segmenterwidget = QWidget() self.segmenterwidget.setLayout(self.segmenterlayout) self.segmenter.setWidget(self.segmenterwidget) self.segmenter.setVisible(False) self.segmenter.setAllowedAreas(Qt.RightDockWidgetArea) self.addDockWidget(Qt.RightDockWidgetArea, self.segmenter) # Set up dialog to gather user input for custom files. regex = QRegExp("[1-9][0-9]") validator = QRegExpValidator(regex) self.signallabel = QLabel("biosignal column") self.signaledit = QLineEdit() self.signaledit.setValidator(validator) self.markerlabel = QLabel("marker column") self.markeredit = QLineEdit() self.markeredit.setValidator(validator) regex = QRegExp("[0-9]{2}") validator = QRegExpValidator(regex) self.headerrowslabel = QLabel("number of header rows") self.headerrowsedit = QLineEdit() self.headerrowsedit.setValidator(validator) regex = QRegExp("[0-9]{5}") validator = QRegExpValidator(regex) self.sfreqlabel = QLabel("sampling rate") self.sfreqedit = QLineEdit() self.sfreqedit.setValidator(validator) self.separatorlabel = QLabel("column separator") self.separatormenu = QComboBox(self) self.separatormenu.addItem("comma") self.separatormenu.addItem("tab") self.separatormenu.addItem("colon") self.separatormenu.addItem("space") self.continuecustomfile = QPushButton("continue loading file") self.continuecustomfile.clicked.connect(self.set_customheader) self.customfiledialog = QDialog() self.customfiledialog.setWindowTitle("custom file info") self.customfiledialog.setWindowIcon(QIcon(":/file_icon.png")) self.customfiledialog.setWindowFlags( Qt.WindowCloseButtonHint ) # remove help button by only setting close button self.customfilelayout = QFormLayout() self.customfilelayout.addRow(self.signallabel, self.signaledit) self.customfilelayout.addRow(self.markerlabel, self.markeredit) self.customfilelayout.addRow(self.separatorlabel, self.separatormenu) self.customfilelayout.addRow(self.headerrowslabel, self.headerrowsedit) self.customfilelayout.addRow(self.sfreqlabel, self.sfreqedit) self.customfilelayout.addRow(self.continuecustomfile) self.customfiledialog.setLayout(self.customfilelayout) # set up menubar menubar = self.menuBar() # signal menu signalmenu = menubar.addMenu("biosignal") openSignal = signalmenu.addMenu("load") openEDF = QAction("EDF", self) openEDF.triggered.connect(lambda: self._model.set_filetype("EDF")) openEDF.triggered.connect(self._controller.get_fpaths) openSignal.addAction(openEDF) openOpenSignals = QAction("OpenSignals", self) openOpenSignals.triggered.connect( lambda: self._model.set_filetype("OpenSignals")) openOpenSignals.triggered.connect(self._controller.get_fpaths) openSignal.addAction(openOpenSignals) openCustom = QAction("Custom", self) openCustom.triggered.connect( lambda: self._model.set_filetype("Custom")) openCustom.triggered.connect(lambda: self.customfiledialog.exec_()) openSignal.addAction(openCustom) segmentSignal = QAction("select segment", self) segmentSignal.triggered.connect(self.segmentermap.map) self.segmentermap.setMapping(segmentSignal, 1) signalmenu.addAction(segmentSignal) self.segmentermap.mapped.connect(self.toggle_segmenter) saveSignal = QAction("save", self) saveSignal.triggered.connect(self._controller.get_wpathsignal) signalmenu.addAction(saveSignal) # peak menu peakmenu = menubar.addMenu("peaks") findPeaks = QAction("find", self) findPeaks.triggered.connect(self._controller.find_peaks) peakmenu.addAction(findPeaks) autocorrectPeaks = QAction("autocorrect", self) autocorrectPeaks.triggered.connect(self._controller.autocorrect_peaks) peakmenu.addAction(autocorrectPeaks) savePeaks = QAction("save", self) savePeaks.triggered.connect(self._controller.get_wpathpeaks) peakmenu.addAction(savePeaks) loadPeaks = QAction("load", self) loadPeaks.triggered.connect(self._controller.get_rpathpeaks) peakmenu.addAction(loadPeaks) # stats menu statsmenu = menubar.addMenu("statistics") calculateStats = QAction("calculate", self) calculateStats.triggered.connect(self._controller.calculate_stats) statsmenu.addAction(calculateStats) saveStats = QAction("save", self) saveStats.triggered.connect(self._controller.get_wpathstats) statsmenu.addAction(saveStats) # set up status bar to display error messages and current file path self.statusBar = QStatusBar() self.setStatusBar(self.statusBar) self.progressBar = QProgressBar(self) self.progressBar.setRange(0, 1) self.statusBar.addPermanentWidget(self.progressBar) self.currentFile = QLabel() self.statusBar.addPermanentWidget(self.currentFile) # set up the central widget containing the plot and navigationtoolbar self.centwidget = QWidget() self.setCentralWidget(self.centwidget) # connect canvas0 to keyboard and mouse input for peak editing; # only widgets (e.g. canvas) that currently have focus capture # keyboard input: "You must enable keyboard focus for a widget if # it processes keyboard events." self.canvas0.setFocusPolicy(Qt.ClickFocus) self.canvas0.setFocus() self.canvas0.mpl_connect("key_press_event", self._controller.edit_peaks) self.canvas0.mpl_connect("button_press_event", self.get_xcursor) # arrange the three figure canvases in splitter object self.splitter = QSplitter(Qt.Vertical) # setting opaque resizing to false is important, since resizing gets # very slow otherwise once axes are populated self.splitter.setOpaqueResize(False) self.splitter.addWidget(self.canvas0) self.splitter.addWidget(self.canvas1) self.splitter.addWidget(self.canvas2) self.splitter.setChildrenCollapsible(False) # define GUI layout self.vlayout0 = QVBoxLayout(self.centwidget) self.vlayout1 = QVBoxLayout() self.vlayoutA = QFormLayout() self.vlayoutB = QFormLayout() self.vlayoutC = QVBoxLayout() self.vlayoutD = QVBoxLayout() self.hlayout0 = QHBoxLayout() self.optionsgroupA = QGroupBox("processing options") self.vlayoutA.addRow(self.modmenulabel, self.modmenu) self.vlayoutA.addRow(self.batchmenulabel, self.batchmenu) self.optionsgroupA.setLayout(self.vlayoutA) self.optionsgroupB = QGroupBox("channels") self.vlayoutB.addRow(self.sigchanmenulabel, self.sigchanmenu) self.vlayoutB.addRow(self.markerchanmenulabel, self.markerchanmenu) self.optionsgroupB.setLayout(self.vlayoutB) self.optionsgroupC = QGroupBox("peaks") self.vlayoutC.addWidget(self.editcheckbox) self.vlayoutC.addWidget(self.savecheckbox) self.vlayoutC.addWidget(self.correctcheckbox) self.optionsgroupC.setLayout(self.vlayoutC) self.optionsgroupD = QGroupBox("select statistics for saving") self.vlayoutD.addWidget(self.periodcheckbox) self.vlayoutD.addWidget(self.ratecheckbox) self.vlayoutD.addWidget(self.tidalampcheckbox) self.optionsgroupD.setLayout(self.vlayoutD) self.vlayout1.addWidget(self.optionsgroupA) self.vlayout1.addWidget(self.optionsgroupB) self.vlayout1.addWidget(self.optionsgroupC) self.vlayout1.addWidget(self.optionsgroupD) self.optionsgroupwidget = QWidget() self.optionsgroupwidget.setLayout(self.vlayout1) self.optionsgroup = QDockWidget("configurations", self) self.optionsgroup.setAllowedAreas(Qt.LeftDockWidgetArea) self.toggleoptionsgroup = self.optionsgroup.toggleViewAction() self.toggleoptionsgroup.setText("show/hide configurations") menubar.addAction(self.toggleoptionsgroup) self.optionsgroup.setWidget(self.optionsgroupwidget) self.addDockWidget(Qt.LeftDockWidgetArea, self.optionsgroup) self.vlayout0.addWidget(self.splitter) self.hlayout0.addWidget(self.navitools) self.vlayout0.addLayout(self.hlayout0) ############################################## # connect output widgets to external signals # ############################################## self._model.signal_changed.connect(self.plot_signal) self._model.marker_changed.connect(self.plot_marker) self._model.peaks_changed.connect(self.plot_peaks) self._model.period_changed.connect(self.plot_period) self._model.rate_changed.connect(self.plot_rate) self._model.tidalamp_changed.connect(self.plot_tidalamp) self._model.path_changed.connect(self.display_path) self._model.segment_changed.connect(self.plot_segment) self._model.status_changed.connect(self.display_status) self._model.progress_changed.connect(self.display_progress) self._model.model_reset.connect(self.reset_plot) ########### # methods # ########### def plot_signal(self, value): self.ax00.clear() self.ax00.relim() # reset navitools history self.navitools.update() self.line00 = self.ax00.plot(self._model.sec, value, zorder=1) self.ax00.set_xlabel("seconds", fontsize="large", fontweight="heavy") self.canvas0.draw() # print("plot_signal listening") # print(self.ax0.collections, self.ax0.patches, self.ax0.artists) def plot_peaks(self, value): # self.scat is listed in ax.collections if self.ax00.collections: self.ax00.collections[0].remove() self.scat = self.ax00.scatter(self._model.sec[value], self._model.signal[value], c="m", zorder=2) self.canvas0.draw() # print("plot_peaks listening") # print(self.ax0.collections, self.ax0.patches, self.ax0.artists) def plot_segment(self, value): # If an invalid signal has been selected reset the segmenter interface. if value is None: self.toggle_segmenter(1) return if self.ax00.patches: # self.segementspan is listed in ax.patches self.ax00.patches[0].remove() self.segmentspan = self.ax00.axvspan(value[0], value[1], color="m", alpha=0.25) self.canvas0.draw() self.confirmedit.setEnabled(True) # print(self.ax0.collections, self.ax0.patches, self.ax0.artists) def plot_marker(self, value): self.ax10.clear() self.ax10.relim() self.line10 = self.ax10.plot(value[0], value[1]) self.canvas1.draw() # print("plot_marker listening") def plot_period(self, value): self.ax20.clear() self.ax20.relim() self.navitools.home() if self._model.savestats["period"]: self.line20 = self.ax20.plot(self._model.sec, value, c="m") else: self.line20 = self.ax20.plot(self._model.sec, value) self.ax20.set_ylim(bottom=min(value), top=max(value)) self.ax20.set_title("period", pad=0, fontweight="heavy") self.ax20.grid(True, axis="y") self.navitools.update() self.canvas2.draw() # print("plot_period listening") def plot_rate(self, value): self.ax21.clear() self.ax21.relim() self.navitools.home() if self._model.savestats["rate"]: self.line21 = self.ax21.plot(self._model.sec, value, c="m") else: self.line21 = self.ax21.plot(self._model.sec, value) self.ax21.set_ylim(bottom=min(value), top=max(value)) self.ax21.set_title("rate", pad=0, fontweight="heavy") self.ax21.grid(True, axis="y") self.navitools.update() self.canvas2.draw() # print("plot_rate listening") def plot_tidalamp(self, value): self.ax22.clear() self.ax22.relim() self.navitools.home() if self._model.savestats["tidalamp"]: self.line22 = self.ax22.plot(self._model.sec, value, c="m") else: self.line22 = self.ax22.plot(self._model.sec, value) self.ax22.set_ylim(bottom=min(value), top=max(value)) self.ax22.set_title("amplitude", pad=0, fontweight="heavy") self.ax22.grid(True, axis="y") self.navitools.update() self.canvas2.draw() # print("plot_tidalamp listening") def display_path(self, value): self.currentFile.setText(value) def display_status(self, status): # display status until new status is set self.statusBar.showMessage(status) def display_progress(self, value): # if value is 0, the progressbar indicates a busy state self.progressBar.setRange(0, value) def toggle_segmenter(self, value): if not self._model.loaded: return # Open segmenter when called from signalmenu or clear segmenter # upon selection of invalid segment. if value == 1: self.segmenter.setVisible(True) self.confirmedit.setEnabled(False) self.startedit.clear() self.endedit.clear() if self.ax00.patches: self.ax00.patches[0].remove() self.canvas0.draw() # Close segmenter after segment has been confirmed. elif value == 0: self.segmenter.setVisible(False) if self.ax00.patches: self.ax00.patches[0].remove() self.canvas0.draw() # Close segmenter after segmentation has been aborted (reset # segment). elif value == 2: self._model.set_segment([0, 0]) # This will reset the model to None self.segmenter.setVisible(False) if self.ax00.patches: self.ax00.patches[0].remove() self.canvas0.draw() def enable_segmentedit(self): # disable peak editing to avoid interference self.editcheckbox.setChecked(False) if self.startedit.hasFocus(): self.segmentcursor = "start" elif self.endedit.hasFocus(): self.segmentcursor = "end" def set_customheader(self): """Populate the customheader with inputs from the customfiledialog""" # Check if one of the mandatory fields is missing. mandatoryfields = self.signaledit.text() and self.headerrowsedit.text( ) and self.sfreqedit.text() if not mandatoryfields: self._model.status = ( "Please provide values for 'biosignal column'" ", 'number of header rows' and 'sampling" " rate'.") return seps = {"comma": ",", "tab": "\t", "colon": ":", "space": " "} self._model.customheader = dict.fromkeys( self._model.customheader, None ) # reset header here since it cannot be reset in controller.get_fpaths() self._model.customheader["signalidx"] = int(self.signaledit.text()) self._model.customheader["skiprows"] = int(self.headerrowsedit.text()) self._model.customheader["sfreq"] = int(self.sfreqedit.text()) self._model.customheader["separator"] = seps[ self.separatormenu.currentText()] if self.markeredit.text(): # not mandatory self._model.customheader["markeridx"] = int(self.markeredit.text()) self.customfiledialog.done(QDialog.Accepted) # close the dialog window self._controller.get_fpaths() # move on to file selection def get_xcursor(self, event): # event.button 1 corresponds to left mouse button if event.button != 1: return # limit number of decimal places to two if self.segmentcursor == "start": self.startedit.selectAll() self.startedit.insert("{:.2f}".format(event.xdata)) elif self.segmentcursor == "end": self.endedit.selectAll() self.endedit.insert("{:.2f}".format(event.xdata)) # disable segment cursor again after value has been set self.segmentcursor = False def select_stats(self, event): """ select or deselect statistics to be saved; toggle boolean with xor operator ^=, toggle color with dictionary """ self._model.savestats[event] ^= True line = None if event == "period": if self.line20: line = self.line20[0] elif event == "rate": if self.line21: line = self.line21[0] elif event == "tidalamp": if self.line22: line = self.line22[0] if line: line.set_color(self.togglecolors[line.get_color()]) self.canvas2.draw() def toggle_options(self, event): if event in ["ECG", "PPG"]: self.tidalampcheckbox.setEnabled(False) self.tidalampcheckbox.setChecked(False) self.ax22.set_visible(False) self.canvas2.draw() elif event == "RESP": self.tidalampcheckbox.setEnabled(True) self.ax22.set_visible(True) self.canvas2.draw() elif event == "multiple files": self.editcheckbox.setEnabled(False) self.editcheckbox.setChecked(False) self.savecheckbox.setEnabled(True) self.correctcheckbox.setEnabled(True) self.markerchanmenu.setEnabled(False) elif event == "single file": self.editcheckbox.setEnabled(True) self.markerchanmenu.setEnabled(True) self.savecheckbox.setEnabled(False) self.savecheckbox.setChecked(False) self.correctcheckbox.setEnabled(False) self.correctcheckbox.setChecked(False) def reset_plot(self): self.ax00.clear() self.ax00.relim() self.line00 = None self.scat = None self.segmentspan = None self.ax10.clear() self.ax10.relim() self.line10 = None self.ax20.clear() self.ax20.relim() self.line20 = None self.ax21.clear() self.ax21.relim() self.line21 = None self.ax22.clear() self.ax22.relim() self.line22 = None self.canvas0.draw() self.canvas1.draw() self.canvas2.draw() self.navitools.update() self.currentFile.clear()
class AddProjectItemWidget(QWidget): """A widget to query user's preferences for a new item. Attributes: toolbox (ToolboxUI): Parent widget x (int): X coordinate of new item y (int): Y coordinate of new item """ def __init__(self, toolbox, x, y, class_, spec=""): """Initialize class.""" from ..ui.add_project_item import Ui_Form # pylint: disable=import-outside-toplevel super().__init__(parent=toolbox, f=Qt.Window) # Setting parent inherits stylesheet self._toolbox = toolbox self._x = x self._y = y self._project = self._toolbox.project() # Set up the user interface from Designer. self.ui = Ui_Form() self.ui.setupUi(self) # Add status bar to form self.statusbar = QStatusBar(self) self.statusbar.setFixedHeight(20) self.statusbar.setSizeGripEnabled(False) self.statusbar.setStyleSheet(STATUSBAR_SS) self.ui.horizontalLayout_statusbar_placeholder.addWidget( self.statusbar) # Init if toolbox.supports_specifications(class_.item_type()): self.ui.comboBox_specification.setModel( toolbox.filtered_spec_factory_models[class_.item_type()]) if spec: self.ui.comboBox_specification.setCurrentText(spec) prefix = spec else: prefix = class_.item_type() self.ui.comboBox_specification.setCurrentIndex(-1) else: prefix = class_.item_type() self.ui.comboBox_specification.setEnabled(False) self.name = toolbox.propose_item_name(prefix) self.ui.lineEdit_name.setText(self.name) self.ui.lineEdit_name.selectAll() self.description = "" self.connect_signals() self.ui.lineEdit_name.setFocus() # Ensure this window gets garbage-collected when closed self.setAttribute(Qt.WA_DeleteOnClose) self.setWindowTitle(f"Add {class_.item_type()}") def connect_signals(self): """Connect signals to slots.""" self.ui.lineEdit_name.textChanged.connect( self.handle_name_changed) # Name -> folder name connection self.ui.pushButton_ok.clicked.connect(self.handle_ok_clicked) self.ui.pushButton_cancel.clicked.connect(self.close) @Slot() def handle_name_changed(self): """Update label to show upcoming folder name.""" name = self.ui.lineEdit_name.text() default = "Folder:" if name == "": self.ui.label_folder.setText(default) else: folder_name = name.lower().replace(" ", "_") msg = default + " " + folder_name self.ui.label_folder.setText(msg) @Slot() def handle_ok_clicked(self): """Check that given item name is valid and add it to project.""" self.name = self.ui.lineEdit_name.text() self.description = self.ui.lineEdit_description.text() if not self.name: # No name given self.statusbar.showMessage("Name missing", 3000) return # Check for invalid characters for a folder name if any((True for x in self.name if x in INVALID_CHARS)): self.statusbar.showMessage("Name not valid for a folder name", 3000) return # Check that name is not reserved if self._toolbox.project_item_model.find_item(self.name): msg = "Item '{0}' already exists".format(self.name) self.statusbar.showMessage(msg, 3000) return # Check that short name (folder) is not reserved short_name = self.name.lower().replace(" ", "_") if self._toolbox.project_item_model.short_name_reserved(short_name): msg = "Item using folder '{0}' already exists".format(short_name) self.statusbar.showMessage(msg, 3000) return # Create new Item self.call_add_item() self.close() def call_add_item(self): """Creates new Item according to user's selections. Must be reimplemented by subclasses. """ raise NotImplementedError() def keyPressEvent(self, e): """Close Setup form when escape key is pressed. Args: e (QKeyEvent): Received key press event. """ if e.key() == Qt.Key_Escape: self.close() elif e.key() == Qt.Key_Enter or e.key() == Qt.Key_Return: self.handle_ok_clicked() def closeEvent(self, event=None): """Handle close window. Args: event (QEvent): Closing event if 'X' is clicked. """ if event: event.accept() scene = self._toolbox.ui.graphicsView.scene() item_shadow = scene.item_shadow if item_shadow: scene.removeItem(item_shadow) scene.item_shadow = None
class Chrono(QMainWindow): def __init__(self, parent=None): super(Chrono, self).__init__(parent) self.createMenus() self.createSystemTrayIcon() self.timer = QTimer(self) self.timer.timeout.connect(self.tick) self.isRunning = False self.refresh_rate = 100 # ms self.progressBar = QProgressBar() self.progressBar.setValue(0) self.begin_time = self.end_time = 0 self.label = QLabel(" ") self.button = QPushButton() self.button.setIcon(self.style().standardIcon(QStyle.SP_MediaPause)) self.end_delay = self.begin_delay = 0 bottomLayout = QHBoxLayout() bottomLayout.addWidget(self.progressBar) bottomLayout.addWidget(self.button) self.button.clicked.connect(self.pause) mainLayout = QVBoxLayout() mainLayout.addWidget(self.label) mainLayout.addLayout(bottomLayout) centralWidget = QWidget() centralWidget.setLayout(mainLayout) self.setCentralWidget(centralWidget) self.statusBar = QStatusBar(self) self.setStatusBar(self.statusBar) self.notification = self.notification_popup = self.notification_tray = self.notification_sound = True self.notification_soundfile = os.path.dirname( sys.argv[0]) + '/notification.mp3' # os.path.dirname(__file__) + self.setWindowTitle(TITLE) self.resize(400, self.sizeHint().height()) self.setFixedHeight(self.sizeHint().height()) def createMenus(self): menus = QMenuBar() fileMenu = menus.addMenu("&Fichier") file_newMenu = fileMenu.addMenu( self.style().standardIcon(QStyle.SP_FileIcon), "Nouveau") file_newMenu.addAction("Date", self.createDateDialog, 'CTRL+D') file_newMenu.addAction("Durée", self.createDurationDialog, 'CTRL+N') fileMenu.addSeparator() fileMenu.addAction(self.style().standardIcon(QStyle.SP_BrowserStop), "Quitter", sys.exit, 'CTRL+Q') optionMenu = menus.addMenu("&Options") optionMenu.addAction( self.style().standardIcon(QStyle.SP_MessageBoxInformation), "Évènements", self.createNotificationPopup, 'CTRL+O') optionMenu.addAction( QAction("Rester au premier plan", optionMenu, triggered=self.stayOnTop, checkable=True)) aideMenu = menus.addMenu("&Aide") aideMenu.addAction( self.style().standardIcon(QStyle.SP_DialogHelpButton), "À propos", lambda: QMessageBox.information( self, "À propos", TITLE + " " + str(VERSION)), 'CTRL+H') aideMenu.addSeparator() aideMenu.addAction( self.style().standardIcon(QStyle.SP_TitleBarMenuButton), "À propos de Qt", QApplication.aboutQt, 'CTRL+A') self.setMenuBar(menus) def createSystemTrayIcon(self): self.tray = QSystemTrayIcon() self.tray.setIcon(QIcon(os.path.dirname(sys.argv[0]) + '/icon.svg')) # os.path.dirname(__file__) + self.tray.setToolTip(TITLE) self.tray.show() systemTrayMenu = QMenu() pauseAction = QAction(self.style().standardIcon(QStyle.SP_MediaPause), "Pause / Reprendre", systemTrayMenu) pauseAction.triggered.connect(self.pause) systemTrayMenu.addAction(pauseAction) systemTrayMenu.addSeparator() systemTrayMenu.addAction( self.style().standardIcon(QStyle.SP_BrowserStop), "Quitter", sys.exit) self.tray.setContextMenu(systemTrayMenu) self.tray.activated.connect(self.show) def stayOnTop(self): self.setWindowFlags(self.windowFlags() ^ Qt.WindowStaysOnTopHint) # self.windowFlags() | Qt.CustomizeWindowHint | Qt.Window | Qt.WindowStaysOnTopHint | Qt.X11BypassWindowManagerHint) # Qt.Dialog | Qt.WindowStaysOnTopHint | Qt.X11BypassWindowManagerHint) self.show() def createNotificationPopup(self): popup = QDialog(self) popup.setFixedSize(popup.sizeHint().height(), popup.sizeHint().width()) popup.setWindowTitle("Évènements") innerLayout = QVBoxLayout() GroupBox = QGroupBox("Activer les notifications") GroupBox.setCheckable(True) GroupBox.setChecked(self.notification) checkBox_popup = QCheckBox("Afficher une popup") checkBox_notification = QCheckBox("Afficher une notification") checkBox_sound = QCheckBox("Jouer un son") if self.notification_popup: checkBox_popup.setCheckState(Qt.Checked) if self.notification_tray: checkBox_notification.setCheckState(Qt.Checked) if self.notification_sound: checkBox_sound.setCheckState(Qt.Checked) innerLayout.addWidget(checkBox_popup) innerLayout.addWidget(checkBox_notification) innerLayout.addWidget(checkBox_sound) innerLayout.addStretch(1) GroupBox.setLayout(innerLayout) button = QPushButton("Ok") button.clicked.connect(lambda: self.changeNotificationSettings( popup, GroupBox, checkBox_popup, checkBox_notification, checkBox_sound)) outerLayout = QVBoxLayout() outerLayout.addWidget(GroupBox) outerLayout.addWidget(button) popup.setLayout(outerLayout) popup.exec_() def changeNotificationSettings(self, popup, GroupBox, checkBox_popup, checkBox_notification, checkBox_sound): self.notification, self.notification_popup, self.notification_tray, self.notification_sound = GroupBox.isChecked( ), checkBox_popup.isChecked(), checkBox_notification.isChecked( ), checkBox_sound.isChecked() if not any([ self.notification_popup, self.notification_tray, self.notification_sound ]): self.notification = False popup.close() def createDateDialog(self): popup = QDialog(self) popup.setFixedSize(270, 60) popup.setWindowTitle("Nouvelle date") layout = QHBoxLayout() prefix = QLabel("Heure cible: ") layout.addWidget(prefix) qline = QTimeEdit() qline.setDisplayFormat("hh:mm:ss") qline.setTime(QTime.currentTime()) layout.addWidget(qline) button = QPushButton("Ok") button.clicked.connect(lambda: self.createDate(popup, qline.time().hour(), qline.time().minute(), qline.time().second())) layout.addWidget(button) popup.setLayout(layout) popup.exec_() def createDurationDialog(self): popup = QDialog(self) popup.setFixedSize(150, 150) popup.setWindowTitle("Nouvelle durée") layout = QVBoxLayout() hourLayout = QHBoxLayout() hourLabel = QLabel("Heures:") hourSpin = QSpinBox() hourLayout.addWidget(hourLabel) hourLayout.addWidget(hourSpin) minuteLayout = QHBoxLayout() minuteLabel = QLabel("Minutes:") minuteSpin = QSpinBox() minuteLayout.addWidget(minuteLabel) minuteLayout.addWidget(minuteSpin) secondLayout = QHBoxLayout() secondLabel = QLabel("Secondes:") secondSpin = QSpinBox() secondLayout.addWidget(secondLabel) secondLayout.addWidget(secondSpin) layout.addLayout(hourLayout) layout.addLayout(minuteLayout) layout.addLayout(secondLayout) button = QPushButton("Ok") button.clicked.connect(lambda: self.createDuration( popup, hourSpin.value(), minuteSpin.value(), secondSpin.value())) layout.addWidget(button) popup.setLayout(layout) popup.exec_() def createDuration(self, popup: QDialog, hours: int, minutes: int, seconds: int): popup.close() self.begin_time = datetime.timestamp(datetime.now()) self.end_time = self.begin_time + seconds + minutes * 60 + hours * 3600 self.progressBar.setRange(0, 100) self.progressBar.setValue(0) self.isRunning = True self.timer.stop() self.timer.start(self.refresh_rate) def createDate(self, popup: QDialog, hours: int, minutes: int, seconds: int): popup.close() self.begin_time = datetime.timestamp(datetime.now()) now = datetime.now().time() target = time(hours, minutes, seconds) now_delta = timedelta(hours=now.hour, minutes=now.minute, seconds=now.second) target_delta = timedelta(hours=target.hour, minutes=target.minute, seconds=target.second) if target_delta == now_delta: self.end_time = self.begin_time + 60 * 60 * 24 else: d = target_delta - now_delta self.end_time = self.begin_time + d.seconds self.progressBar.setRange(0, 100) self.progressBar.setValue(0) self.isRunning = True self.timer.stop() self.timer.start(self.refresh_rate) def tick(self): self.progressBar.setValue( 100 * (datetime.timestamp(datetime.now()) - self.begin_time) / (self.end_time - self.begin_time)) seconds = int( ceil(self.end_time - datetime.timestamp(datetime.now())) % 60) minutes = int( ceil(self.end_time - datetime.timestamp(datetime.now())) / 60 % 60) hours = int( ceil(self.end_time - datetime.timestamp(datetime.now())) / 3600) self.label.setText(f'{hours:02}:{minutes:02}:{seconds:02}') self.setWindowTitle(f'{TITLE} - {hours:02}:{minutes:02}:{seconds:02}') self.tray.setToolTip(f'{hours:02}:{minutes:02}:{seconds:02}') if datetime.timestamp(datetime.now()) >= self.end_time: self.isRunning = False self.timer.stop() self.progressBar.setRange(0, 0) self.show() self.notify() def notify(self): if not self.notification: return if self.notification_tray: self.tray.showMessage( "Finished", "Le décompte est terminé", self.style().standardIcon(QStyle.SP_MessageBoxInformation)) if self.notification_sound: test = QMediaPlayer() test.setMedia(QUrl.fromLocalFile(self.notification_soundfile)) test.play() if self.notification_popup: QMessageBox.information(self, "Finished", "Le décompte est terminé") def pause(self): if not self.isRunning: return self.progressBar.setDisabled(self.timer.isActive()) if self.timer.isActive(): self.end_delay = self.end_time - datetime.timestamp(datetime.now()) self.begin_delay = datetime.timestamp( datetime.now()) - self.begin_time print(self.begin_time) print(self.end_time) print(self.end_delay) self.statusBar.showMessage("Pause") self.tray.setToolTip(self.tray.toolTip() + ' - Pause') self.timer.stop() self.button.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay)) else: self.begin_time = datetime.timestamp( datetime.now()) - self.begin_delay self.end_time = datetime.timestamp(datetime.now()) + self.end_delay print(self.begin_time) print(self.end_time) self.statusBar.clearMessage() self.timer.start() self.button.setIcon(self.style().standardIcon( QStyle.SP_MediaPause)) # Override def closeEvent(self, event): self.hide() event.ignore()
class Form(QMainWindow): def __init__(self, parent=None): super(Form, self).__init__(parent) self.setWindowTitle("Style Sheet Example") self.add_status_bar() # ADD TAB BAR self.tabs = QTabWidget() self.setCentralWidget(self.tabs) self.add_tab_1() self.tabs.addTab(QWidget(), 'Tab No.2') self.tabs.addTab(QWidget(), 'Tab No.3') # DISABLED self.tabs.addTab(QWidget(), 'Tab Disabled') self.tabs.setTabEnabled(3, False) def add_tab_1(self): t1 = QWidget() layout = QVBoxLayout(t1) self.tabs.addTab(t1, "Tab No.1") self.add_vertical_splitter(layout) self.add_horizontal_splitter(layout) def add_status_bar(self): self.myStatus = QStatusBar() self.myStatus.showMessage("This is a status bar message...") self.setStatusBar(self.myStatus) def add_vertical_splitter(self, layout): splitter = QSplitter() layout.addWidget(splitter) # ADD LEFT left_widget = QWidget(splitter) left = QVBoxLayout(left_widget) # NORMAL let = QLineEdit('Line Edit With Text') left.layout().addWidget(let) #PLACEHOLDER let = QLineEdit() let.setPlaceholderText('This is placeholder text...') left.layout().addWidget(let) # DISABLED let = QLineEdit('Line Edit Disabled') let.setEnabled(False) left.layout().addWidget(let) # ADD RIGHT right_widget = QWidget(splitter) right = QGridLayout(right_widget) # GROUP BOX grp = QGroupBox("Group Box") right.layout().addWidget(grp) grp_layout = QGridLayout(grp) btn = QPushButton('Set Style') btn.pressed.connect(self.set_style) grp_layout.addWidget(btn) def add_horizontal_splitter(self, layout): splitter = QSplitter() splitter.setOrientation(Qt.Orientation.Vertical) layout.addWidget(splitter) # ADD TOP top_widget = QWidget(splitter) top = QVBoxLayout(top_widget) # NORMAL btn = FillPushButton('Push Button') top.layout().addWidget(btn) #DISABLED btn = FillPushButton('Push Button Disabled') btn.setEnabled(False) top.layout().addWidget(btn) # ADD BOTTOM bottom_widget = QWidget(splitter) right = QGridLayout(bottom_widget) # NORMAL cbx = QCheckBox('Check Box') right.addWidget(cbx) #DISABLED cbx = QCheckBox('Check Box Disabled') cbx.setEnabled(False) right.addWidget(cbx) rob = QRadioButton('Radio Button') right.addWidget(rob) rob = QRadioButton('Radio Button Disabled') rob.setEnabled(False) right.addWidget(rob) def set_style(self): stylesheet_path = os.path.join(os.path.dirname(__file__), 'style_dark.qss') with open(stylesheet_path, 'r') as f: self.setStyleSheet(f.read())
class AddDataConnectionWidget(QWidget): """A widget that queries user's preferences for a new item. Attributes: toolbox (ToolboxUI): toolbox widget x (int): X coordinate of new item y (int): Y coordinate of new item """ def __init__(self, toolbox, x, y): """Initialize class.""" super().__init__( parent=toolbox, f=Qt.Window) # Setting the parent inherits the stylesheet self._toolbox = toolbox self._x = x self._y = y self._project = self._toolbox.project() # Set up the user interface from Designer. self.ui = ui.add_data_connection.Ui_Form() self.ui.setupUi(self) # Add status bar to form self.statusbar = QStatusBar(self) self.statusbar.setFixedHeight(20) self.statusbar.setSizeGripEnabled(False) self.statusbar.setStyleSheet(STATUSBAR_SS) self.ui.horizontalLayout_statusbar_placeholder.addWidget( self.statusbar) # Class attributes self.name = '' self.description = '' self.connect_signals() self.ui.lineEdit_name.setFocus() # Ensure this window gets garbage-collected when closed self.setAttribute(Qt.WA_DeleteOnClose) def connect_signals(self): """Connect signals to slots.""" self.ui.lineEdit_name.textChanged.connect( self.name_changed) # Name -> folder name connection self.ui.pushButton_ok.clicked.connect(self.ok_clicked) self.ui.pushButton_cancel.clicked.connect(self.close) @Slot(name='name_changed') def name_changed(self): """Update label to show upcoming folder name.""" name = self.ui.lineEdit_name.text() default = "Folder:" if name == '': self.ui.label_folder.setText(default) else: folder_name = name.lower().replace(' ', '_') msg = default + " " + folder_name self.ui.label_folder.setText(msg) @Slot(name='ok_clicked') def ok_clicked(self): """Check that given item name is valid and add it to project.""" self.name = self.ui.lineEdit_name.text() self.description = self.ui.lineEdit_description.text() if not self.name: # No name given self.statusbar.showMessage("Name missing", 3000) return # Check for invalid characters for a folder name if any((True for x in self.name if x in INVALID_CHARS)): self.statusbar.showMessage("Name not valid for a folder name", 3000) return # Check that name is not reserved if self._toolbox.project_item_model.find_item(self.name): msg = "Item '{0}' already exists".format(self.name) self.statusbar.showMessage(msg, 3000) return # Check that short name (folder) is not reserved short_name = self.name.lower().replace(' ', '_') if self._toolbox.project_item_model.short_name_reserved(short_name): msg = "Item using folder '{0}' already exists".format(short_name) self.statusbar.showMessage(msg, 3000) return # Create new Item self.call_add_item() self.close() def call_add_item(self): """Creates new Item according to user's selections.""" self._project.add_data_connection(self.name, self.description, list(), self._x, self._y, set_selected=True) def keyPressEvent(self, e): """Close Setup form when escape key is pressed. Args: e (QKeyEvent): Received key press event. """ if e.key() == Qt.Key_Escape: self.close() elif e.key() == Qt.Key_Enter or e.key() == Qt.Key_Return: self.ok_clicked() def closeEvent(self, event=None): """Handle close window. Args: event (QEvent): Closing event if 'X' is clicked. """ if event: event.accept() scene = self._toolbox.ui.graphicsView.scene() item_shadow = scene.item_shadow if item_shadow: scene.removeItem(item_shadow) scene.item_shadow = None
class ViewMainFrame(QMainWindow): def __init__(self, sig_quit: Signal, sig_config_mode_changed: Signal, sig_export_csv: Signal): """ Main application's frame :param sig_quit: signal to trigger when the application closes :param sig_config_mode_changed: signal to trigger when the configuration mode changes :param sig_export_csv: signal to emit with the filepath to perform the export to CSV """ QMainWindow.__init__(self) self.setWindowTitle( f"{tr('app_title')} | {AssetManager.getInstance().config('main', 'version')}" ) self.setContextMenuPolicy(Qt.PreventContextMenu) self.bdd_version: str = "" # For the about box self.reboot_requested = False # Widgets self.status_bar = QStatusBar() self.status_bar.setStyleSheet( "QStatusBar {background: lightgrey; color: black;}") self.maintoolbar = ViewMainToolBar() self.sidewidget = SideDockWidget() self.central_widget = CentralWidget(self.status_bar.showMessage, self.__active_tab_changed) self.sidewidget.dockLocationChanged.connect( self.on_side_widget_docked_state_changed) self.__config_mode = False # Config mode flag, should be initialized to False in all widgets self.__init_callbacks() # Layout self.setCentralWidget(self.central_widget) self.addDockWidget(Qt.LeftDockWidgetArea, self.sidewidget) self.addToolBar(Qt.RightToolBarArea, self.maintoolbar) self.setStatusBar(self.status_bar) # Signals self.sig_quit = sig_quit self.sig_config_mode_changed = sig_config_mode_changed self.sig_export_csv = sig_export_csv self.setStyleSheet( "QMainWindow {" + f"background-color: {AssetManager.getInstance().config('colors', 'main_bg')};" + "}") def restart(self): return QtCore.QCoreApplication.exit(EXIT_CODE_REBOOT) def set_bdd_version(self, bdd_version: str) -> None: """ Sets the current BDD version. Used in the About box """ self.bdd_version = bdd_version def __init_callbacks(self): """ Dispatches the callbacks from the toolbar to the handling widgets. Also init the signal triggered to enable or disable some buttons. """ self.maintoolbar.on_btn_perspective_clicked = self.central_widget.on_perspective_changed self.maintoolbar.on_btn_shuffle_clicked = self.central_widget.do_shuffle self.maintoolbar.on_config_mode = self.on_config_mode self.maintoolbar.on_export_csv = self.on_export_csv self.maintoolbar.on_edit_config = self.on_edit_config self.maintoolbar.open_about_box = lambda: AboutFrame(self.bdd_version ).exec_() self.central_widget.sig_enable_animation_btns = self.maintoolbar.sig_enable_animation_btns self.sidewidget.attributes( ).attributes_selection_changed = self.maintoolbar.enable_one_attributes_buttons def __active_tab_changed(self, is_view_classroom: bool) -> None: """ Triggered when the active tab changed. Updates main toolbar widgets :param is_view_classroom: View classroom or view table attributes """ self.maintoolbar.set_widgets(is_view_classroom) # Manually update buttons enable state given the number of selected attributes self.maintoolbar.enable_one_attributes_buttons( self.sidewidget.attributes().get_selected_rows_count() == 1) self.sidewidget.sidepanel.tabBar().setTabEnabled( 0, is_view_classroom) # Courses self.sidewidget.sidepanel.tabBar().setTabEnabled( 1, is_view_classroom) # Students def on_config_mode(self, is_in_config_mode: bool) -> None: """ Switches the current mode. If in config mode, almost all features are made available, whereas in 'secured' mode, some features will be inaccessible to prevent the user from doing critic modification actions. """ self.__config_mode = is_in_config_mode self.maintoolbar.lock_buttons(self.__config_mode) self.central_widget.classroom_tab.v_canvas.config_mode( self.__config_mode) self.sidewidget.courses().courses_toolbar.setVisible( self.__config_mode) self.sidewidget.attributes().attributes_toolbar.setVisible( self.__config_mode) self.sidewidget.students().students_toolbar.switch_config_mode( self.__config_mode) self.sig_config_mode_changed.emit() def get_config(self) -> bool: """ Getter for the config mode :return: True if the user is in Configuration mode """ return self.__config_mode def on_side_widget_docked_state_changed(self) -> None: """ Triggered when the side dockable widget has been docked or undocked """ if self.sidewidget.isFloating(): self.adjustSize() def on_export_csv(self) -> None: """ Displays a save dialog to select a file path for the export csv of the attributes table. Then signals this path to the controller """ file_path = QFileDialog.getSaveFileName(self, tr("export_dialog_title"), "untitled", "(*.csv)")[0] if file_path: self.sig_export_csv.emit(file_path) def on_edit_config(self) -> None: """ Displays the edition dialog for application settings """ dlg = SettingsEditionDialog() if dlg.exec_(): if dlg.restore_default(): AssetManager.getInstance().restore_default_settings() else: AssetManager.getInstance().save_config(dlg.new_config()) self.status_bar.showMessage(tr("acknowledge_changes"), 3000) self.repaint() if dlg.need_restart(): restart_confirm = VConfirmDialog(self, "need_restart") restart_confirm.ok_btn.setText(tr("restart_now")) restart_confirm.ok_btn.setFixedSize(QSize(105, 33)) restart_confirm.cancel_btn.setText(tr("restart_later")) restart_confirm.cancel_btn.setFixedSize(QSize(105, 33)) if restart_confirm.exec_(): self.reboot_requested = True self.close() self.restart() def closeEvent(self, event): """ Triggered on a close operation. Signals to the controller the event """ if self.reboot_requested: self.reboot_requested = False self.sig_quit.emit(EXIT_CODE_REBOOT) else: self.sig_quit.emit(0) event.accept()