class KeywordConfigurationWidget(ConfigurationWidget): def __init__(self): ConfigurationWidget.__init__(self) self.keyIndexCombo = QComboBox() self.addRow("Key index:", self.keyIndexCombo) self.connect(self.keyIndexCombo, SIGNAL("currentIndexChanged(QString)"), self.applyConfiguration) def setKeyIndexList(self, list): self.disconnect(self.keyIndexCombo, SIGNAL("currentIndexChanged(QString)"), self.applyConfiguration) self.keyIndexCombo.clear() self.keyIndexCombo.addItems(list) self.connect(self.keyIndexCombo, SIGNAL("currentIndexChanged(QString)"), self.applyConfiguration) def setParameter(self, parameter): self.parameter = parameter self.applyConfiguration(False) def applyConfiguration(self, emit=True): user_data = {"state": self.getState(), "key_index": self.getKeyIndex()} self.parameter.setUserData(user_data) self.emitConfigurationChanged(emit) def getKeyIndex(self): return str(self.keyIndexCombo.currentText())
class StartSession(preferences.Group): def __init__(self, page): super(StartSession, self).__init__(page) grid = QGridLayout() self.setLayout(grid) def changed(): self.changed.emit() self.combo.setEnabled(self.custom.isChecked()) self.none = QRadioButton(toggled=changed) self.lastused = QRadioButton(toggled=changed) self.custom = QRadioButton(toggled=changed) self.combo = QComboBox(currentIndexChanged=changed) grid.addWidget(self.none, 0, 0, 1, 2) grid.addWidget(self.lastused, 1, 0, 1, 2) grid.addWidget(self.custom, 2, 0, 1, 1) grid.addWidget(self.combo, 2, 1, 1, 1) app.translateUI(self) def translateUI(self): self.setTitle( _("Session to load if Frescobaldi is started without arguments")) self.none.setText(_("Start with no session")) self.lastused.setText(_("Start with last used session")) self.custom.setText(_("Start with session:")) def loadSettings(self): s = QSettings() s.beginGroup("session") startup = s.value("startup", "none", type("")) if startup == "lastused": self.lastused.setChecked(True) elif startup == "custom": self.custom.setChecked(True) else: self.none.setChecked(True) sessionNames = sessions.sessionNames() self.combo.clear() self.combo.addItems(sessionNames) custom = s.value("custom", "", type("")) if custom in sessionNames: self.combo.setCurrentIndex(sessionNames.index(custom)) def saveSettings(self): s = QSettings() s.beginGroup("session") s.setValue("custom", self.combo.currentText()) if self.custom.isChecked(): startup = "custom" elif self.lastused.isChecked(): startup = "lastused" else: startup = "none" s.setValue("startup", startup)
class StartSession(preferences.Group): def __init__(self, page): super(StartSession, self).__init__(page) grid = QGridLayout() self.setLayout(grid) def changed(): self.changed.emit() self.combo.setEnabled(self.custom.isChecked()) self.none = QRadioButton(toggled=changed) self.lastused = QRadioButton(toggled=changed) self.custom = QRadioButton(toggled=changed) self.combo = QComboBox(currentIndexChanged=changed) grid.addWidget(self.none, 0, 0, 1, 2) grid.addWidget(self.lastused, 1, 0, 1, 2) grid.addWidget(self.custom, 2, 0, 1, 1) grid.addWidget(self.combo, 2, 1, 1, 1) app.translateUI(self) def translateUI(self): self.setTitle(_("Session to load if Frescobaldi is started without arguments")) self.none.setText(_("Start with no session")) self.lastused.setText(_("Start with last used session")) self.custom.setText(_("Start with session:")) def loadSettings(self): s = QSettings() s.beginGroup("session") startup = s.value("startup", "none", type("")) if startup == "lastused": self.lastused.setChecked(True) elif startup == "custom": self.custom.setChecked(True) else: self.none.setChecked(True) sessionNames = sessions.sessionNames() self.combo.clear() self.combo.addItems(sessionNames) custom = s.value("custom", "", type("")) if custom in sessionNames: self.combo.setCurrentIndex(sessionNames.index(custom)) def saveSettings(self): s = QSettings() s.beginGroup("session") s.setValue("custom", self.combo.currentText()) if self.custom.isChecked(): startup = "custom" elif self.lastused.isChecked(): startup = "lastused" else: startup = "none" s.setValue("startup", startup)
class DropDownRadioBooleanFilter(QWidget, Control): """Container for multiple boolean filters """ def __init__(self, tree, dataset, master, parent=None): QWidget.__init__(self, parent) Control.__init__(self, tree, dataset, master) self.setLayout(QHBoxLayout()) self.cb = QComboBox(self) self.layout().addWidget(self.cb) rblayout = QVBoxLayout() self.radioButtons = [QRadioButton("Only", self), QRadioButton("Excluded", self) ] for b in self.radioButtons: rblayout.addWidget(b) self.radioButtons[0].setChecked(True) self.layout().addLayout(rblayout) self.options = [] self.setOptions(tree.subelements_top("Option")) def setOptions(self, options): self.cb.clear() self.options = [] for option in options: self.cb.addItem(option.displayName) self.options.append(option) for op, rb in zip(self.options[0].subelements_top("Option"), self.radioButtons): rb.setText(op.displayName) rb.setChecked(getattr(op, "default", "false") == "true") def value(self): return {"excluded": "0" if self.radioButtons[0].isChecked() else "1"} def query(self): filter = self.options[self.cb.currentIndex()] filter = biomart.FilterDescription( self.tree.registry, "FilterDescription", filter.attributes, filter.children) return [("Filter", filter, self.value())] def setControlValue(self, name, value): for i, option in enumerate(self.options): if option.internalName == name: self.cb.setCurrentIndex(i) if value == "Only": self.radioButtons[0].setChecked(True)
class DropDownIdListFilter(QWidget, Control): """Container for multiple id list filters """ def __init__(self, tree, dataset, master, parent=None): QWidget.__init__(self, parent) Control.__init__(self, tree, dataset, master) self.setLayout(QVBoxLayout()) self.setContentsMargins(0, 0, 0, 0) self.cb = QComboBox() self.idsEdit = QPlainTextEdit() self.layout().addWidget(self.cb) self.layout().addWidget(self.idsEdit) self.options = [] self.setOptions(tree.subelements_top("Option")) def setOptions(self, options): self.cb.clear() self.options = [] for option in options: self.cb.addItem(option.displayName) self.options.append(option) def value(self): return str(self.idsEdit.toPlainText()).split() def query(self): filter = self.options[self.cb.currentIndex()] filter = biomart.FilterDescription( self.tree.registry, "FilterDescription", filter.attributes, filter.children) return [("Filter", filter, self.value())] def setControlValue(self, name, value): if isinstance(value, list): value = "\n".join(value) for i, op in enumerate(self.options): if name == op.internalName: self.cb.setCurrentIndex(i) self.idsEdit.setPlainText(value)
class RecentPathsWComboMixin(RecentPathsWidgetMixin): """ Adds file combo handling to :obj:`RecentPathsWidgetMixin`. The mixin constructs a combo box `self.file_combo` and provides a method `set_file_list` for updating its content. The mixin also overloads the inherited `add_path` and `select_file` to call `set_file_list`. """ def __init__(self): super().__init__() self.file_combo = \ QComboBox(self, sizeAdjustPolicy=QComboBox.AdjustToContents) def add_path(self, filename): """Add (or move) a file name to the top of recent paths""" super().add_path(filename) self.set_file_list() def select_file(self, n): """Move the n-th file to the top of the list""" super().select_file(n) self.set_file_list() def set_file_list(self): """ Sets the items in the file list combo """ self._check_init() self.file_combo.clear() if not self.recent_paths: self.file_combo.addItem("(none)") self.file_combo.model().item(0).setEnabled(False) else: for i, recent in enumerate(self.recent_paths): self.file_combo.addItem(recent.basename) self.file_combo.model().item(i).setToolTip(recent.abspath) def workflowEnvChanged(self, key, value, oldvalue): super().workflowEnvChanged(key, value, oldvalue) if key == "basedir": self.set_file_list()
class RecentPathsWComboMixin(RecentPathsWidgetMixin): """ Adds file combo handling to :obj:`RecentPathsWidgetMixin`. The mixin constructs a combo box `self.file_combo` and provides a method `set_file_list` for updating its content. The mixin also overloads the inherited `add_path` and `select_file` to call `set_file_list`. """ def __init__(self): super().__init__() self.file_combo = \ QComboBox(self, sizeAdjustPolicy=QComboBox.AdjustToContents) def add_path(self, filename): """Add (or move) a file name to the top of recent paths""" super().add_path(filename) self.set_file_list() def select_file(self, n): """Move the n-th file to the top of the list""" super().select_file(n) self.set_file_list() def set_file_list(self): """ Sets the items in the file list combo """ self._check_init() self.file_combo.clear() if not self.recent_paths: self.file_combo.addItem("(none)") self.file_combo.model().item(0).setEnabled(False) else: for i, recent in enumerate(self.recent_paths): self.file_combo.addItem(recent.basename) self.file_combo.model().item(i).setToolTip(recent.abspath) def workflowEnvChanged(self, key, value, oldvalue): super().workflowEnvChanged(key, value, oldvalue) if key == "basedir": self.set_file_list()
class ConnectedComponentParamEditorWidget(QWidget): def __init__(self, parent=None): super(ConnectedComponentParamEditorWidget, self).__init__(parent) hbox = QHBoxLayout() hbox.addWidget(QLabel('Scene : ')) self._sceneQCB = QComboBox(self) self._sceneQCB.setMaxVisibleItems(5) hbox.addWidget(self._sceneQCB) self._sceneQCB.clear() self.setLayout(hbox) def initSceneQCB(self): try: self._sceneQCB.currentIndexChanged.disconnect(self.changeScene) except TypeError: pass sceneOfCC = self._selectedConnectedComponent.scene() self._sceneQCB.clear() i = 0 for scene in self.parent().parent().scenes(): self._sceneQCB.addItem(scene.getName()) if scene == sceneOfCC: self._sceneQCB.setCurrentIndex(i) i += 1 self._sceneQCB.currentIndexChanged.connect(self.changeScene) def setSelectedConnectedComponent(self, cc): self._selectedConnectedComponent = cc self.initSceneQCB() def changeScene(self, sceneIndex): self._sceneQCB.clear() self._selectedConnectedComponent.scene().changeConnectedComponentSceneByIndex( self._selectedConnectedComponent, sceneIndex)
class LayerSelectionPage(QFrame): #TODO. Filtering, (visible) row selection, multi selection colparams = ((0,65,'Name'), (1,235,'Title'), (2,350,'Keywords')) XFER_BW = 40 def __init__(self, parent=None): super(LayerSelectionPage, self).__init__(parent) self.parent = parent #convenience link self.confconn_link = self.parent.parent.confconn #flag top prevent read read action on keyword delete. New logic makes this redundant #self.keywordbypass = False QToolTip.setFont(QFont('SansSerif', 10)) #label filterlabel = QLabel('Filter') availablelabel = QLabel('Available Layers') selectionlabel = QLabel('Layer Selections') keywordlabel = QLabel('Keyword') explainlabel = QLabel("Edit Group assignments using this dialog or to simply initialise the Layer-Config just click 'Finish'") #selection buttons chooseallbutton = QPushButton('>>') chooseallbutton.setFixedWidth(self.XFER_BW) chooseallbutton.clicked.connect(self.doChooseAllClickAction) choosebutton = QPushButton('>') choosebutton.setFixedWidth(self.XFER_BW) choosebutton.clicked.connect(self.doChooseClickAction) rejectbutton = QPushButton('<') rejectbutton.setFixedWidth(self.XFER_BW) rejectbutton.clicked.connect(self.doRejectClickAction) rejectallbutton = QPushButton('<<') rejectallbutton.setFixedWidth(self.XFER_BW) rejectallbutton.clicked.connect(self.doRejectAllClickAction) #operation buttons finishbutton = QPushButton('Finish') finishbutton.setToolTip('Finish and Close layer selection dialog') finishbutton.clicked.connect(self.parent.close) resetbutton = QPushButton('Reset') resetbutton.font() resetbutton.setToolTip('Read Layer from LDS GetCapabilities request. Overwrites current Layer Config') resetbutton.clicked.connect(self.doResetClickAction) self.available_sfpm = LDSSFPAvailableModel(self) self.selection_sfpm = LDSSFPSelectionModel(self) self.available_sfpm.setSourceModel(self.parent.available_model) self.selection_sfpm.setSourceModel(self.parent.selection_model) #textedits filteredit = QLineEdit('') filteredit.setToolTip('Filter Available-Layers pane (filter operates across Name and Title fields and accepts Regex expressions)') filteredit.textChanged.connect(self.available_sfpm.setActiveFilter) self.keywordcombo = QComboBox() self.keywordcombo.setToolTip('Select or Add a unique identifier to be saved in layer config (keyword)') self.keywordcombo.addItems(list(self.confconn_link.assigned)) self.keywordcombo.setEditable(True) self.keywordcombo.activated.connect(self.doKeyComboChangeAction) lgindex = self.confconn_link.getLayerGroupIndex(self.confconn_link.lgval,col=1) lgentry = self.confconn_link.lglist[lgindex] if LU.assessNone(lgindex) else None #keywordedit = self.keywordcombo.lineEdit().text().toUtf8().data().decode('utf8')# for writing #if no entry or layer indicated then blank self.keywordcombo.lineEdit().setText('' if lgentry is None or lgentry[0]==LORG.LAYER else lgentry[1])#self.confconn_link.lgval)#TODO. group only #header headmodel = QStandardItemModel() headmodel.setHorizontalHeaderLabels([i[2] for i in self.colparams][:self.parent.available_model.columnCount()]) headview1 = QHeaderView(Qt.Horizontal) headview1.setModel(headmodel) headview1.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) headview2 = QHeaderView(Qt.Horizontal) headview2.setModel(headmodel) headview2.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) #table self.available = QTableView() self.available.setSelectionBehavior(QAbstractItemView.SelectRows) self.available.setSelectionMode(QAbstractItemView.MultiSelection) self.selection = QTableView() self.selection.setSelectionBehavior(QAbstractItemView.SelectRows) self.selection.setSelectionMode(QAbstractItemView.MultiSelection) #interesting, must set model after selection attributes but before headers else row selections/headers don't work properly self.available.setModel(self.available_sfpm) self.selection.setModel(self.selection_sfpm) self.available.setSortingEnabled(True) self.available.setHorizontalHeader(headview1) self.selection.setSortingEnabled(True) self.selection.setHorizontalHeader(headview2) for cp in self.colparams: self.available.setColumnWidth(cp[0],cp[1]) self.selection.setColumnWidth(cp[0],cp[1]) self.available.verticalHeader().setVisible(False) self.available.horizontalHeader().setVisible(True) self.selection.verticalHeader().setVisible(False) self.selection.horizontalHeader().setVisible(True) #layout vbox00 = QVBoxLayout() vbox00.addWidget(availablelabel) vbox00.addWidget(self.available) vbox01 = QVBoxLayout() vbox01.addWidget(chooseallbutton) vbox01.addWidget(choosebutton) vbox01.addWidget(rejectbutton) vbox01.addWidget(rejectallbutton) vbox02 = QVBoxLayout() vbox02.addWidget(selectionlabel) vbox02.addWidget(self.selection) vbox10 = QVBoxLayout() vbox10.addWidget(filterlabel) vbox10.addWidget(filteredit) hbox12 = QHBoxLayout() hbox12.addWidget(keywordlabel) hbox12.addStretch(1) #hbox12.addWidget(inspbutton) #hbox12.addWidget(addbutton) #hbox12.addWidget(delbutton) vbox12 = QVBoxLayout() vbox12.addLayout(hbox12) vbox12.addWidget(self.keywordcombo) #00|01|02 #10|11|12 grid0 = QGridLayout() grid0.addLayout(vbox00,1,0) grid0.addLayout(vbox01,1,1) grid0.addLayout(vbox02,1,2) grid0.addLayout(vbox10,0,0) grid0.addLayout(vbox12,0,2) hbox2 = QHBoxLayout() hbox2.addWidget(resetbutton) hbox2.addStretch(1) hbox2.addWidget(explainlabel) hbox2.addWidget(finishbutton) #gbox1.setLayout(hbox2) vbox3 = QVBoxLayout() vbox3.addLayout(grid0) #vbox3.addLayout(hbox3) #vbox3.addWidget(line0) vbox3.addLayout(hbox2) self.setLayout(vbox3) def doChooseAllClickAction(self): '''Moves the lot to Selected''' #ktext = LU.recode(self.keywordcombo.lineEdit().text().toUtf8().data()) ktext = LU.recode(LQ.readWidgetText(self.keywordcombo.lineEdit().text())) if not self.checkKeyword(ktext): return #------------------------------ self.parent.signalModels(self.parent.STEP.PRE) #self.parent.selection_model.mdata += self.parent.available_model.mdata self.parent.selection_model.initData(self.confconn_link.complete) self.parent.available_model.initData([]) self.parent.signalModels(self.parent.STEP.POST) #------------------------------ self.parent.writeKeysToLayerConfig(ktext) #self.confconn_link.setupAssignedLayerList() if self.keywordcombo.findText(ktext) == -1: self.keywordcombo.addItem(ktext) def doChooseClickAction(self): '''Takes available selected and moves to selection''' #ktext = LU.recode(self.keywordcombo.lineEdit().text().toUtf8().data()) ktext = LU.recode(LQ.readWidgetText(self.keywordcombo.lineEdit().text())) #ktext = str(self.keywordcombo.lineEdit().text()) if not self.checkKeyword(ktext): return #------------------------------ select = self.available.selectionModel() if select.hasSelection(): self.transferSelectedRows(select.selectedRows(),self.available_sfpm,self.selection_sfpm) #------------------------------ self.parent.writeKeysToLayerConfig(ktext) #self.confconn_link.assigned = self.confconn_link.setupAssignedLayerList() # -1 to indicate no index since 0,1,... are valid if self.keywordcombo.findText(ktext) == -1: self.keywordcombo.addItem(ktext) else: ldslog.warn('L2R > Transfer action without selection') #TRACE# #pdb.set_trace() self.available.clearSelection() def transferSelectedRows(self,indices,from_model,to_model): tlist = [] for proxymodelindex in indices: transfer = from_model.getData(proxymodelindex) tlist.append((proxymodelindex,transfer),) to_model.addData([t[1] for t in tlist]) from_model.delData([t[0] for t in tlist]) return tlist def doRejectClickAction(self): '''Takes available selected and moves to selection''' #ktext = LU.recode(self.keywordcombo.lineEdit().text().toUtf8().data()) ktext = LU.recode(LQ.readWidgetText(self.keywordcombo.lineEdit().text())) if not self.checkKeyword(ktext): return #------------------------------ select = self.selection.selectionModel() if select.hasSelection(): tlist = self.transferSelectedRows(select.selectedRows(),self.selection_sfpm,self.available_sfpm) #------------------------------ kindex = self.keywordcombo.findText(ktext) remainder = self.parent.deleteKeysFromLayerConfig([ll[1][0] for ll in tlist],ktext) if remainder > 0 and kindex == -1: #items+newkey -> add self.parent.writeKeysToLayerConfig(ktext) self.keywordcombo.addItem(ktext) elif remainder == 0 and kindex > -1: #empty+oldkey -> del self.keywordcombo.removeItem(kindex) self.keywordcombo.clearEditText() else: ldslog.warn('R2L < Transfer action without selection') #TRACE# #pdb.set_trace() self.selection.clearSelection() def doRejectAllClickAction(self): #ktext = LU.recode(self.keywordcombo.lineEdit().text().toUtf8().data()) ktext = LU.recode(LQ.readWidgetText(self.keywordcombo.lineEdit().text())) if not self.checkKeyword(ktext): return #------------------------------ self.parent.deleteKeysFromLayerConfig([ll[0] for ll in self.parent.selection_model.mdata],ktext) #------------------------------ self.parent.signalModels(self.parent.STEP.PRE) #self.parent.available_model.mdata += self.parent.selection_model.mdata self.parent.available_model.initData(self.confconn_link.complete) self.parent.selection_model.initData([]) self.parent.signalModels(self.parent.STEP.POST) #------------------------------ #self.confconn_link.setupAssignedLayerList() #self.keywordbypass = True self.keywordcombo.removeItem(self.keywordcombo.findText(ktext)) self.keywordcombo.clearEditText() def doKeyComboChangeAction(self): '''Reset the available pane and if there is anything in the keyword box use this to init the selection pane''' #HACK #if self.keywordbypass: # self.keywordbypass = False # return #------------------------------ #ktext = LU.recode(self.keywordcombo.lineEdit().text().toUtf8().data()) ktext = LU.recode(LQ.readWidgetText(self.keywordcombo.lineEdit().text())) #------------------------------ av_sl = self.parent.splitData(ktext,self.confconn_link.complete) #av_sl = self.parent.splitData(ktext,self.confconn_link.complete) self.parent.signalModels(self.parent.STEP.PRE) self.parent.available_model.initData(av_sl[0]) self.parent.selection_model.initData(av_sl[1]) self.parent.signalModels(self.parent.STEP.POST) def doResetClickAction(self): '''Dumps the LC and rebuilds from a fresh read of the caps doc''' #int warning (QWidget parent, QString title, QString text, QString button0Text, QString button1Text = QString(), QString button2Text = QString(), int defaultButtonNumber = 0, int escapeButtonNumber = -1) ans = QMessageBox.warning(self, "Reset","This action will overwrite your Layer Configuration using the current LDS settings (potentially adding new or removing layers). Continue?","Continue","Cancel") if ans: #Cancel ldslog.warn('Cancelling Reset operation') return #Continue ldslog.warn('Reset Layer Config') self.parent.resetLayers() self.keywordcombo.clear() def checkKeyword(self,ktext): '''Checks keyword isn't null and isn't part of the LDS supplied keywords''' if LU.assessNone(ktext) is None: QMessageBox.about(self, "Keyword Required","Please enter a Keyword to assign Layer(s) to") return False if ktext in self.confconn_link.reserved: QMessageBox.about(self, "Reserved Keyword","'{}' is a reserved keyword, please select again".format(ktext)) return False return True
class AdvancedVisualizationForm(QWidget): def __init__(self, mainwindow, result_manager): QWidget.__init__(self, mainwindow) #mainwindow is an OpusGui self.mainwindow = mainwindow self.result_manager = result_manager self.toolboxBase = self.result_manager.mainwindow.toolboxBase self.inGui = False self.logFileKey = 0 self.xml_helper = ResultsManagerXMLHelper(toolboxBase=self.toolboxBase) self.result_generator = OpusResultGenerator( toolboxBase=self.toolboxBase) self.result_generator.guiElement = self self.tabIcon = QIcon(':/Images/Images/cog.png') self.tabLabel = 'Advanced Visualization' self.widgetLayout = QVBoxLayout(self) self.widgetLayout.setAlignment(Qt.AlignTop) self.resultsGroupBox = QGroupBox(self) self.widgetLayout.addWidget(self.resultsGroupBox) self.dataGroupBox = QGroupBox(self) self.widgetLayout.addWidget(self.dataGroupBox) self.optionsGroupBox = QGroupBox(self) self.widgetLayout.addWidget(self.optionsGroupBox) self._setup_definition_widget() self._setup_buttons() self._setup_tabs() def _setup_buttons(self): # Add Generate button... self.pbn_go = QPushButton(self.resultsGroupBox) self.pbn_go.setObjectName('pbn_go') self.pbn_go.setText(QString('Go!')) QObject.connect(self.pbn_go, SIGNAL('released()'), self.on_pbn_go_released) self.widgetLayout.addWidget(self.pbn_go) self.pbn_set_esri_storage_location = QPushButton(self.optionsGroupBox) self.pbn_set_esri_storage_location.setObjectName( 'pbn_set_esri_storage_location') self.pbn_set_esri_storage_location.setText(QString('...')) self.pbn_set_esri_storage_location.hide() QObject.connect(self.pbn_set_esri_storage_location, SIGNAL('released()'), self.on_pbn_set_esri_storage_location_released) def _setup_tabs(self): # Add a tab widget and layer in a tree view and log panel self.tabWidget = QTabWidget(self.resultsGroupBox) # Log panel self.logText = QTextEdit(self.resultsGroupBox) self.logText.setReadOnly(True) self.logText.setLineWidth(0) self.tabWidget.addTab(self.logText, 'Log') # Finally add the tab to the model page self.widgetLayout.addWidget(self.tabWidget) # def _setup_definition_widget(self): #### setup results group box #### self.gridlayout = QGridLayout(self.resultsGroupBox) self.gridlayout.setObjectName('gridlayout') self.lbl_results = QLabel(self.resultsGroupBox) self.lbl_results.setObjectName('lbl_results') self.lbl_results.setText(QString('Results')) self.gridlayout.addWidget(self.lbl_results, 0, 0, 1, 3) self._setup_co_results() self.gridlayout.addWidget(self.co_results, 0, 3, 1, 10) self.pbn_add = QPushButton(self.resultsGroupBox) self.pbn_add.setObjectName('pbn_add') self.pbn_add.setText(QString('+')) QObject.connect(self.pbn_add, SIGNAL('released()'), self.on_pbn_add_released) self.gridlayout.addWidget(self.pbn_add, 0, 14, 1, 1) self.lw_indicators = QListWidget(self.resultsGroupBox) self.lw_indicators.setObjectName('lw_indicators') self.gridlayout.addWidget(self.lw_indicators, 1, 1, 1, 13) self.pbn_remove = QPushButton(self.resultsGroupBox) self.pbn_remove.setObjectName('pbn_remove') self.pbn_remove.setText(QString('-')) QObject.connect(self.pbn_remove, SIGNAL('released()'), self.on_pbn_remove_released) self.gridlayout.addWidget(self.pbn_remove, 1, 14, 1, 1) #### setup data group box #### self.gridlayout2 = QGridLayout(self.dataGroupBox) self.gridlayout2.setObjectName('gridlayout2') self._setup_co_result_style() self.gridlayout2.addWidget(self.co_result_style, 1, 0, 1, 2) self.lbl_result_style_sep = QLabel(self.resultsGroupBox) self.lbl_result_style_sep.setObjectName('lbl_result_style_sep') self.lbl_result_style_sep.setText(QString('<center>as</center>')) self.gridlayout2.addWidget(self.lbl_result_style_sep, 1, 2, 1, 1) self._setup_co_result_type() self.gridlayout2.addWidget(self.co_result_type, 1, 3, 1, 2) ##### setup options group box #### self.gridlayout3 = QGridLayout(self.optionsGroupBox) self.gridlayout3.setObjectName('gridlayout3') self.le_esri_storage_location = QLineEdit(self.optionsGroupBox) self.le_esri_storage_location.setObjectName('le_esri_storage_location') self.le_esri_storage_location.setText('[set path]') self.le_esri_storage_location.hide() self.optionsGroupBox.hide() QObject.connect(self.co_result_style, SIGNAL('currentIndexChanged(int)'), self.on_co_result_style_changed) QObject.connect(self.co_result_type, SIGNAL('currentIndexChanged(int)'), self.on_co_result_type_changed) def _setup_co_results(self): self.co_results = QComboBox(self.resultsGroupBox) self.co_results.setObjectName('co_results') self.co_results.addItem(QString('[select]')) results = self.xml_helper.get_available_results() for result in results: name = '%i.%s' % (result['run_id'], result['indicator_name']) self.co_results.addItem(QString(name)) def _setup_co_result_style(self): available_styles = [ 'visualize', 'export', ] self.co_result_style = QComboBox(self.dataGroupBox) self.co_result_style.setObjectName('co_result_style') for dataset in available_styles: self.co_result_style.addItem(QString(dataset)) def _setup_co_result_type(self): available_types = [ 'Table (per year, spans indicators)', 'Chart (per indicator, spans years)', 'Map (per indicator per year)', 'Chart (per indicator, spans years)', ] self.co_result_type = QComboBox(self.dataGroupBox) self.co_result_type.setObjectName('co_result_type') for dataset in available_types: self.co_result_type.addItem(QString(dataset)) def on_pbnRemoveModel_released(self): self.result_manager.removeTab(self) self.result_manager.updateGuiElements() def on_pbn_add_released(self): cur_selected = self.co_results.currentText() for i in range(self.lw_indicators.count()): if self.lw_indicators.item(i).text() == cur_selected: return self.lw_indicators.addItem(cur_selected) def on_pbn_remove_released(self): selected_idxs = self.lw_indicators.selectedIndexes() for idx in selected_idxs: self.lw_indicators.takeItem(idx.row()) def on_co_result_style_changed(self, ind): available_viz_types = [ 'Table (per year, spans indicators)', 'Chart (per indicator, spans years)', 'Map (per indicator per year)', 'Chart (per indicator, spans years)', ] available_export_types = ['ESRI table (for loading in ArcGIS)'] txt = self.co_result_style.currentText() if txt == 'visualize': available_types = available_viz_types else: available_types = available_export_types self.co_result_type.clear() for result_type in available_types: r_type = QString(result_type) self.co_result_type.addItem(r_type) def on_co_result_type_changed(self, ind): self.gridlayout3.removeWidget(self.le_esri_storage_location) self.gridlayout3.removeWidget(self.pbn_set_esri_storage_location) self.optionsGroupBox.hide() self.pbn_set_esri_storage_location.hide() self.le_esri_storage_location.hide() txt = self.co_result_type.currentText() print txt if txt == 'ESRI table (for loading in ArcGIS)': self.pbn_set_esri_storage_location.show() self.le_esri_storage_location.show() self.gridlayout3.addWidget(self.le_esri_storage_location, 0, 1, 1, 6) self.gridlayout3.addWidget(self.pbn_set_esri_storage_location, 0, 7, 1, 1) self.optionsGroupBox.show() def on_pbn_set_esri_storage_location_released(self): print 'pbn_set_esri_storage_location released' from opus_core.misc import directory_path_from_opus_path start_dir = directory_path_from_opus_path('opus_gui.projects') configDialog = QFileDialog() filter_str = QString("*.gdb") fd = configDialog.getExistingDirectory( self, QString("Please select an ESRI geodatabase (*.gdb)..." ), #, *.sde, *.mdb)..."), QString(start_dir), QFileDialog.ShowDirsOnly) if len(fd) != 0: fileName = QString(fd) fileNameInfo = QFileInfo(QString(fd)) fileNameBaseName = fileNameInfo.completeBaseName() self.le_esri_storage_location.setText(fileName) def on_pbn_go_released(self): # Fire up a new thread and run the model print 'Go button pressed' # References to the GUI elements for status for this run... #self.statusLabel = self.runStatusLabel #self.statusLabel.setText(QString('Model initializing...')) indicator_names = [] for i in range(self.lw_indicators.count()): indicator_names.append(str(self.lw_indicators.item(i).text())) if indicator_names == []: print 'no indicators selected' return indicator_type = str(self.co_result_type.currentText()) indicator_type = { #'Map (per indicator per year)':'matplotlib_map', 'Map (per indicator per year)': 'mapnik_map', 'Chart (per indicator, spans years)': 'matplotlib_chart', 'Table (per indicator, spans years)': 'table_per_attribute', 'Table (per year, spans indicators)': 'table_per_year', 'ESRI table (for loading in ArcGIS)': 'table_esri' }[indicator_type] kwargs = {} if indicator_type == 'table_esri': storage_location = str(self.le_esri_storage_location.text()) if not os.path.exists(storage_location): print 'Warning: %s does not exist!!' % storage_location kwargs['storage_location'] = storage_location self.result_manager.addIndicatorForm(indicator_type=indicator_type, indicator_names=indicator_names, kwargs=kwargs) def runUpdateLog(self): self.logFileKey = self.result_generator._get_current_log( self.logFileKey) def runErrorFromThread(self, errorMessage): QMessageBox.warning(self.mainwindow, 'Warning', errorMessage)
class SimulationPanel(QWidget): def __init__(self): QWidget.__init__(self) layout = QVBoxLayout() self._simulation_mode_combo = QComboBox() addHelpToWidget(self._simulation_mode_combo, "run/simulation_mode") self._simulation_mode_combo.currentIndexChanged.connect(self.toggleSimulationMode) simulation_mode_layout = QHBoxLayout() simulation_mode_layout.addSpacing(10) simulation_mode_layout.addWidget(QLabel("Simulation mode:"), 0, Qt.AlignVCenter) simulation_mode_layout.addWidget(self._simulation_mode_combo, 0, Qt.AlignVCenter) simulation_mode_layout.addSpacing(20) self.run_button = QToolButton() self.run_button.setIconSize(QSize(32, 32)) self.run_button.setText("Start Simulation") self.run_button.setIcon(resourceIcon("ide/gear_in_play")) self.run_button.clicked.connect(self.runSimulation) self.run_button.setToolButtonStyle(Qt.ToolButtonTextBesideIcon) addHelpToWidget(self.run_button, "run/start_simulation") simulation_mode_layout.addWidget(self.run_button) simulation_mode_layout.addStretch(1) layout.addSpacing(5) layout.addLayout(simulation_mode_layout) layout.addSpacing(10) self._simulation_stack = QStackedWidget() self._simulation_stack.setLineWidth(1) self._simulation_stack.setFrameStyle(QFrame.StyledPanel) layout.addWidget(self._simulation_stack) self._simulation_widgets = OrderedDict() """ :type: OrderedDict[BaseRunModel,SimulationConfigPanel]""" self.addSimulationConfigPanel(EnsembleExperimentPanel()) self.addSimulationConfigPanel(EnsembleSmootherPanel()) self.addSimulationConfigPanel(IteratedEnsembleSmootherPanel(advanced_option=True)) self.addSimulationConfigPanel(MultipleDataAssimilationPanel()) self.setLayout(layout) def addSimulationConfigPanel(self, panel): assert isinstance(panel, SimulationConfigPanel) panel.toggleAdvancedOptions(False) self._simulation_stack.addWidget(panel) simulation_model = panel.getSimulationModel() self._simulation_widgets[simulation_model] = panel if not panel.is_advanced_option: self._simulation_mode_combo.addItem(str(simulation_model), simulation_model) panel.simulationConfigurationChanged.connect(self.validationStatusChanged) def getActions(self): return [] def toggleAdvancedOptions(self, show_advanced): current_model = self.getCurrentSimulationModel() self._simulation_mode_combo.clear() for model, panel in self._simulation_widgets.iteritems(): if show_advanced or not panel.is_advanced_option: self._simulation_mode_combo.addItem(str(model), model) old_index = self._simulation_mode_combo.findText(str(current_model)) self._simulation_mode_combo.setCurrentIndex(old_index if old_index > -1 else 0) def toggleAdvancedMode(self, show_advanced): for panel in self._simulation_widgets.values(): panel.toggleAdvancedOptions(show_advanced) self.toggleAdvancedOptions(show_advanced) def getCurrentSimulationModel(self): data = self._simulation_mode_combo.itemData(self._simulation_mode_combo.currentIndex(), Qt.UserRole) return data.toPyObject() def getSimulationArguments(self): """ @rtype: dict[str,object]""" simulation_widget = self._simulation_widgets[self.getCurrentSimulationModel()] return simulation_widget.getSimulationArguments() def runSimulation(self): case_name = getCurrentCaseName() message = "Are you sure you want to use case '%s' for initialization of the initial ensemble when running the simulations?" % case_name start_simulations = QMessageBox.question(self, "Start simulations?", message, QMessageBox.Yes | QMessageBox.No ) if start_simulations == QMessageBox.Yes: run_model = self.getCurrentSimulationModel() arguments = self.getSimulationArguments() dialog = RunDialog(run_model, arguments, self) dialog.startSimulation() dialog.exec_() ERT.emitErtChange() # simulations may have added new cases. def toggleSimulationMode(self): current_model = self.getCurrentSimulationModel() if current_model is not None: widget = self._simulation_widgets[self.getCurrentSimulationModel()] self._simulation_stack.setCurrentWidget(widget) self.validationStatusChanged() def validationStatusChanged(self): widget = self._simulation_widgets[self.getCurrentSimulationModel()] self.run_button.setEnabled(widget.isConfigurationValid())
class HydraulicsDialog(QDialog): def __init__(self, parent, params, new_proj=False): QDialog.__init__(self, parent) self.parent = parent self.params = params self.new_proj = new_proj self.setMinimumWidth(min_width) # self.setMinimumHeight(min_height) # Build dialog self.setWindowTitle('Options - Hydraulics') # TODO: softcode self.setWindowModality(QtCore.Qt.ApplicationModal) self.fra_form = QFrame(self) fra_form_lay = QFormLayout(self.fra_form) fra_form_lay.setContentsMargins(10, 10, 10, 10) self.lbl_units = QLabel('Units system:') # TODO: softocode self.cbo_units = QComboBox() fra_form_lay.addRow(self.lbl_units, self.cbo_units) self.lbl_flow_units = QLabel('Flow units:') # TODO: softocode self.cbo_flow_units = QComboBox() fra_form_lay.addRow(self.lbl_flow_units, self.cbo_flow_units) self.lbl_headloss = QLabel('Head loss:') # TODO: softocode self.cbo_headloss = QComboBox() fra_form_lay.addRow(self.lbl_headloss, self.cbo_headloss) self.chk_hydraulics = QCheckBox('Hydraulics:') # TODO: softcode self.cbo_hydraulics = QComboBox() fra_form_lay.addRow(self.chk_hydraulics, self.cbo_hydraulics) self.txt_hydraulics_file = QLineEdit() fra_form_lay.addRow(None, self.txt_hydraulics_file) self.btn_hydraulics_file = QPushButton('File...') # TODO: softcode fra_form_lay.addRow(None, self.btn_hydraulics_file) self.lbl_viscosity = QLabel('Viscosity:') # TODO: softocode self.txt_viscosity = QLineEdit() fra_form_lay.addRow(self.lbl_viscosity, self.txt_viscosity) self.lbl_diffusivity = QLabel('Diffusivity:') # TODO: softocode self.txt_diffusivity = QLineEdit() fra_form_lay.addRow(self.lbl_diffusivity, self.txt_diffusivity) self.lbl_spec_gravity = QLabel('Specific gravity:') # TODO: softocode self.txt_spec_gravity = QLineEdit() fra_form_lay.addRow(self.lbl_spec_gravity, self.txt_spec_gravity) self.lbl_max_trials = QLabel('Max trials:') # TODO: softocode self.txt_max_trials = QLineEdit() fra_form_lay.addRow(self.lbl_max_trials, self.txt_max_trials) self.lbl_accuracy = QLabel('Accuracy:') # TODO: softocode self.txt_accuracy = QLineEdit() fra_form_lay.addRow(self.lbl_accuracy, self.txt_accuracy) self.lbl_unbalanced = QLabel('Unbalanced:') # TODO: softcode self.fra_unbalanced = QFrame(self) fra_unbalanced_lay = QHBoxLayout(self.fra_unbalanced) fra_unbalanced_lay.setContentsMargins(0, 0, 0, 0) self.cbo_unbalanced = QComboBox() self.txt_unbalanced = QLineEdit() fra_unbalanced_lay.addWidget(self.cbo_unbalanced) fra_unbalanced_lay.addWidget(self.txt_unbalanced) fra_form_lay.addRow(self.lbl_unbalanced, self.fra_unbalanced) self.lbl_pattern = QLabel('Pattern:') # TODO: softocode self.cbo_pattern = QComboBox() fra_form_lay.addRow(self.lbl_pattern, self.cbo_pattern) self.lbl_demand_mult = QLabel('Demand multiplier:') # TODO: softocode self.txt_demand_mult = QLineEdit() fra_form_lay.addRow(self.lbl_demand_mult, self.txt_demand_mult) self.lbl_emitter_exp = QLabel('Emitter exponent:') # TODO: softocode self.txt_emitter_exp = QLineEdit() fra_form_lay.addRow(self.lbl_emitter_exp, self.txt_emitter_exp) self.lbl_tolerance = QLabel('Tolerance:') # TODO: softocode self.txt_tolerance = QLineEdit() fra_form_lay.addRow(self.lbl_tolerance, self.txt_tolerance) # Buttons self.fra_buttons = QFrame(self) fra_buttons_lay = QHBoxLayout(self.fra_buttons) self.btn_Cancel = QPushButton('Cancel') self.btn_Ok = QPushButton('OK') fra_buttons_lay.addWidget(self.btn_Ok) fra_buttons_lay.addWidget(self.btn_Cancel) # Add to main fra_main_lay = QVBoxLayout(self) fra_main_lay.setContentsMargins(0, 0, 0, 0) fra_main_lay.addWidget(self.fra_form) fra_main_lay.addWidget(self.fra_buttons) self.setup() def setup(self): # Fill units system combo box for unit in self.params.options.units_sys: self.cbo_units.addItem(self.params.options.units_sys_text[unit], unit) # Fill flow units combo box for fu in Options.units_flow[self.params.options.units]: self.cbo_flow_units.addItem(Options.units_flow_text[fu], fu) self.cbo_units.activated.connect(self.cbo_units_activated) # self.cbo_flow_units.activated.connect(self.cbo_flow_units_activated) for key, value in self.params.options.headlosses_text.iteritems(): self.cbo_headloss.addItem(value, key) self.cbo_headloss.activated.connect(self.cbo_headloss_activated) self.chk_hydraulics.stateChanged.connect(self.chk_hydraulics_changed) self.btn_hydraulics_file.clicked.connect(self.btn_hydraulics_clicked) self.cbo_hydraulics.addItem( self.params.options.hydraulics.action_names[ self.params.options.hydraulics.action_use], self.params.options.hydraulics.action_use) self.cbo_hydraulics.addItem( self.params.options.hydraulics.action_names[ self.params.options.hydraulics.action_save], self.params.options.hydraulics.action_save) self.txt_hydraulics_file.setReadOnly(True) # - Unbalanced for id, text in self.params.options.unbalanced.unb_text.iteritems(): self.cbo_unbalanced.addItem(text, id) self.cbo_unbalanced.activated.connect(self.cbo_unbalanced_changed) self.txt_unbalanced.setValidator(RegExValidators.get_pos_int_no_zero()) self.txt_unbalanced.setText('1') # - Pattern self.cbo_pattern.addItem('None (=1.0)', None) for pattern_id, pattern in self.params.patterns.iteritems(): self.cbo_pattern.addItem(pattern_id, pattern) # Buttons self.btn_Cancel.clicked.connect(self.btn_cancel_clicked) self.btn_Ok.clicked.connect(self.btn_ok_clicked) # Validators self.txt_viscosity.setValidator(RegExValidators.get_pos_decimals()) self.txt_diffusivity.setValidator(RegExValidators.get_pos_decimals()) self.txt_spec_gravity.setValidator(RegExValidators.get_pos_decimals()) self.txt_max_trials.setValidator(RegExValidators.get_pos_int_no_zero()) self.txt_accuracy.setValidator(RegExValidators.get_pos_decimals()) self.txt_demand_mult.setValidator(RegExValidators.get_pos_decimals()) self.txt_emitter_exp.setValidator(RegExValidators.get_pos_decimals()) self.txt_tolerance.setValidator(RegExValidators.get_pos_decimals()) def show(self): super(HydraulicsDialog, self).show() self.cbo_units.setCurrentIndex( self.cbo_units.findData(self.params.options.units)) self.cbo_flow_units.setCurrentIndex( self.cbo_flow_units.findData(self.params.options.flow_units)) self.cbo_headloss.setCurrentIndex( self.cbo_headloss.findData(self.params.options.headloss)) self.chk_hydraulics.setChecked( self.params.options.hydraulics.use_hydraulics) self.btn_hydraulics_file.setEnabled(self.chk_hydraulics.isChecked()) self.cbo_hydraulics.setEnabled(self.chk_hydraulics.isChecked()) self.txt_hydraulics_file.setEnabled(self.chk_hydraulics.isChecked()) if self.params.options.hydraulics.action is not None: self.cbo_hydraulics.setCurrentIndex( self.cbo_hydraulics.findData( self.params.options.hydraulics.action)) if self.params.options.hydraulics.file is not None: self.txt_hydraulics_file.setText( self.params.options.hydraulics.file) self.txt_viscosity.setText(str(self.params.options.viscosity)) self.txt_diffusivity.setText(str(self.params.options.diffusivity)) self.txt_spec_gravity.setText(str(self.params.options.spec_gravity)) self.txt_max_trials.setText(str(self.params.options.trials)) self.txt_accuracy.setText(str(self.params.options.accuracy)) self.cbo_unbalanced.setCurrentIndex( self.cbo_unbalanced.findData( self.params.options.unbalanced.unbalanced)) self.txt_unbalanced.setEnabled(self.cbo_unbalanced.currentIndex() != 0) self.txt_unbalanced.setText(str(self.params.options.unbalanced.trials)) # Patterns if self.params.options.pattern is not None: if self.params.options.pattern is None: self.cbo_pattern.setCurrentIndex(0) else: for i in range(self.cbo_pattern.count()): if self.params.options.pattern.id == self.cbo_pattern.itemText( i): self.cbo_pattern.setCurrentIndex(i) break self.txt_demand_mult.setText(str(self.params.options.demand_mult)) self.txt_emitter_exp.setText(str(self.params.options.emitter_exp)) self.txt_tolerance.setText(str(self.params.options.tolerance)) def cbo_units_activated(self): self.params.options.units = self.cbo_units.itemData( self.cbo_units.currentIndex()) # Parameters combo box self.cbo_flow_units.clear() for fu in Options.units_flow[self.params.options.units]: self.cbo_flow_units.addItem(Options.units_flow_text[fu], fu) def cbo_headloss_activated(self): # Warning if not self.new_proj: QMessageBox.warning( self, Parameters.plug_in_name, u'Head loss units changed: the head loss values already present might need to be reviewed.', QMessageBox.Ok) def chk_hydraulics_changed(self): self.btn_hydraulics_file.setEnabled(self.chk_hydraulics.isChecked()) self.cbo_hydraulics.setEnabled(self.chk_hydraulics.isChecked()) self.txt_hydraulics_file.setEnabled(self.chk_hydraulics.isChecked()) def btn_hydraulics_clicked(self): file_dialog = QFileDialog(self, 'Select hydraulics file') file_dialog.setLabelText(QFileDialog.Accept, 'Select') file_dialog.setLabelText(QFileDialog.Reject, 'Cancel') file_dialog.setFileMode(QFileDialog.AnyFile) file_dialog.exec_() hydraulics_file_path = file_dialog.selectedFiles() if not hydraulics_file_path or hydraulics_file_path[ 0] is None or hydraulics_file_path[0] == '': return self.txt_hydraulics_file.setText(hydraulics_file_path[0]) def cbo_unbalanced_changed(self): self.txt_unbalanced.setEnabled( self.cbo_unbalanced.itemData(self.cbo_unbalanced.currentIndex()) == self.params.options.unbalanced.unb_continue) def btn_cancel_clicked(self): self.setVisible(False) def btn_ok_clicked(self): if not self.check_params(): return # Update parameters and options self.params.options.units = self.cbo_units.itemData( self.cbo_units.currentIndex()) self.params.options.flow_units = self.cbo_flow_units.itemData( self.cbo_flow_units.currentIndex()) self.params.options.headloss = self.cbo_headloss.itemData( self.cbo_headloss.currentIndex()) self.params.options.hydraulics.use_hydraulics = self.chk_hydraulics.isChecked( ) if self.params.options.hydraulics.action is not None: self.params.options.hydraulics.action = self.cbo_hydraulics.itemData( self.cbo_hydraulics.currentIndex()) self.params.options.hydraulics.file = self.txt_hydraulics_file.text( ) self.params.options.viscosity = float(self.txt_viscosity.text()) self.params.options.diffusivity = float(self.txt_diffusivity.text()) self.params.options.spec_gravity = float(self.txt_spec_gravity.text()) self.params.options.trials = float(self.txt_max_trials.text()) self.params.options.accuracy = float(self.txt_accuracy.text()) self.params.options.unbalanced.unbalanced = self.cbo_unbalanced.itemData( self.cbo_unbalanced.currentIndex()) self.params.options.unbalanced.trials = int(self.txt_unbalanced.text()) self.params.options.pattern = self.cbo_pattern.itemData( self.cbo_pattern.currentIndex()) self.params.options.demand_mult = float(self.txt_demand_mult.text()) self.params.options.emitter_exp = float(self.txt_emitter_exp.text()) self.params.options.tolerance = float(self.txt_tolerance.text()) # Junctions self.parent.lbl_junction_demand.setText( pre_l('Demand', Options.units_flow[self.params.options.units] [0])) # TODO: softcode self.parent.lbl_junction_deltaz.setText( pre_l('Delta Z', Options.units_deltaz[ self.params.options.units])) # TODO: softcode # Reservoirs self.parent.lbl_reservoir_deltaz.setText( pre_l('Delta Z', Options.units_deltaz[ self.params.options.units])) # TODO: softcode self.parent.lbl_reservoir_pressure_head.setText( pre_l('Pressure head', Options.units_deltaz[ self.params.options.units])) # TODO: softcode # Tanks self.parent.lbl_tank_deltaz.setText( pre_l('Delta Z', Options.units_deltaz[ self.params.options.units])) # TODO: softcode self.parent.lbl_tank_level_init.setText( pre_l('Level init.', Options.units_deltaz[ self.params.options.units])) # TODO: softcode self.parent.lbl_tank_level_min.setText( pre_l('Level min', Options.units_deltaz[ self.params.options.units])) # TODO: softcode self.parent.lbl_tank_level_max.setText( pre_l('Level max', Options.units_deltaz[ self.params.options.units])) # TODO: softcode self.parent.lbl_tank_diameter.setText( pre_l('Diameter', Options.units_diameter_tanks[ self.params.options.units])) # TODO: softcode self.parent.lbl_tank_vol_min.setText( pre_l('Volume min', Options.units_volume[ self.params.options.units])) # TODO: softcode # Pipes self.parent.lbl_pipe_demand.setText( pre_l('Demand', Options.units_flow[self.params.options.units] [0])) # TODO: softcode self.parent.lbl_pipe_diameter.setText( pre_l('Diameter', Options.units_diameter_pipes[ self.params.options.units])) # TODO: softcode self.parent.lbl_pipe_roughness_val.setText( pre_l( 'Value', Options.units_roughness[self.params.options.units][ self.params.options.headloss])) # TODO: softcode self.params.options.headloss_units = self.cbo_headloss.itemData( self.cbo_headloss.currentIndex()) self.parent.update_roughness_params( self.parent.cbo_pipe_roughness.itemData( self.parent.cbo_pipe_roughness.currentIndex())[ self.params.options.headloss]) # self.parent.lbl_pipe_roughness.setText( # pre_l( # 'Roughness', # self.params.options.units_roughness[self.params.options.units][self.params.options.headloss_units])) # Pumps self.parent.lbl_pump_head.setText( pre_l('Head', self.params.options.units_deltaz[self.params.options.units])) self.parent.lbl_pump_power.setText( pre_l('Power', self.params.options.units_power[self.params.options.units])) # Valves valve_type = self.parent.cbo_valve_type.itemData( self.parent.cbo_valve_type.currentIndex()) # Pressure valves if valve_type == Valve.type_psv or valve_type == Valve.type_prv or valve_type == Valve.type_pbv: self.parent.lbl_valve_setting.setText( pre_l( 'Pressure', self.params.options.units_pressure[ self.params.options.units])) # FCV valve: Flow if valve_type == Valve.type_fcv: self.parent.lbl_valve_setting.setText( pre_l('Flow', self.params.options.flow_units)) # Throttle control valve elif valve_type == Valve.type_tcv: self.parent.lbl_valve_setting.setText(pre_l('Loss coeff.', '-')) # self.parent.lbl_valve_diameter.setText(pre_l('Pressure', self.params.options.units_diameter_pipes[self.params.options.units])) # Flow units units = self.cbo_flow_units.itemData( self.cbo_flow_units.currentIndex()) self.parent.lbl_junction_demand.setText(pre_l('Demand', units)) # TODO: softcode self.parent.lbl_pipe_demand.setText(pre_l('Demand', units)) # TODO: softcode self.setVisible(False) def check_params(self): if self.chk_hydraulics.isChecked(): if not os.path.isfile(self.txt_hydraulics_file.text()): QMessageBox.warning( self, Parameters.plug_in_name, u'Hydraulics option slected, but no valid file specified.', QMessageBox.Ok) return False return True
class Widget(QWidget): def __init__(self, dockwidget): super(Widget, self).__init__(dockwidget) self._document = None self._fileSelector = QComboBox(editable=True, insertPolicy=QComboBox.NoInsert) widgets.drag.ComboDrag(self._fileSelector).role = Qt.UserRole self._fileSelector.lineEdit().setReadOnly(True) self._fileSelector.lineEdit().setFocusPolicy(Qt.NoFocus) self._stopButton = QToolButton() self._playButton = QToolButton() self._timeSlider = QSlider(Qt.Horizontal, tracking=False, singleStep=500, pageStep=5000, invertedControls=True) self._display = Display() self._tempoFactor = QSlider(Qt.Vertical, minimum=-50, maximum=50, singleStep=1, pageStep=5) grid = QGridLayout(spacing=0) self.setLayout(grid) grid.addWidget(self._fileSelector, 0, 0, 1, 3) grid.addWidget(self._stopButton, 1, 0) grid.addWidget(self._playButton, 1, 1) grid.addWidget(self._timeSlider, 1, 2) grid.addWidget(self._display, 2, 0, 1, 3) grid.addWidget(self._tempoFactor, 0, 3, 3, 1) # size policy of combo p = self._fileSelector.sizePolicy() p.setHorizontalPolicy(QSizePolicy.Ignored) self._fileSelector.setSizePolicy(p) # size policy of combo popup p = self._fileSelector.view().sizePolicy() p.setHorizontalPolicy(QSizePolicy.MinimumExpanding) self._fileSelector.view().setSizePolicy(p) self._player = player.Player() self._outputCloseTimer = QTimer(interval=60000, singleShot=True, timeout=self.closeOutput) self._timeSliderTicker = QTimer(interval=200, timeout=self.updateTimeSlider) self._fileSelector.activated[int].connect(self.slotFileSelected) self._tempoFactor.valueChanged.connect(self.slotTempoChanged) self._timeSlider.valueChanged.connect(self.slotTimeSliderChanged) self._timeSlider.sliderMoved.connect(self.slotTimeSliderMoved) self._player.beat.connect(self.updateDisplayBeat) self._player.time.connect(self.updateDisplayTime) self._player.stateChanged.connect(self.slotPlayerStateChanged) self.slotPlayerStateChanged(False) dockwidget.mainwindow().currentDocumentChanged.connect( self.loadResults) app.documentLoaded.connect(self.slotUpdatedFiles) app.jobFinished.connect(self.slotUpdatedFiles) app.aboutToQuit.connect(self.stop) midihub.aboutToRestart.connect(self.slotAboutToRestart) midihub.settingsChanged.connect(self.clearMidiSettings, -100) midihub.settingsChanged.connect(self.readMidiSettings) app.documentClosed.connect(self.slotDocumentClosed) app.translateUI(self) self.readMidiSettings() d = dockwidget.mainwindow().currentDocument() if d: self.loadResults(d) def translateUI(self): self._tempoFactor.setToolTip(_("Tempo")) def slotAboutToRestart(self): self.stop() self._player.set_output(None) def clearMidiSettings(self): """Called first when settings are changed.""" self.stop() self._outputCloseTimer.stop() self._player.set_output(None) def readMidiSettings(self): """Called after clearMidiSettings(), and on first init.""" pass def openOutput(self): """Called when playing starts. Ensures an output port is opened.""" self._outputCloseTimer.stop() if not self._player.output(): p = QSettings().value("midi/player/output_port", midihub.default_output(), type("")) o = midihub.output_by_name(p) if o: self._player.set_output(output.Output(o)) def closeOutput(self): """Called when the output close timer fires. Closes the output.""" self._player.set_output(None) def slotPlayerStateChanged(self, playing): ac = self.parentWidget().actionCollection # setDefaultAction also adds the action for b in self._stopButton, self._playButton: while b.actions(): b.removeAction(b.actions()[0]) if playing: self._timeSliderTicker.start() self._stopButton.setDefaultAction(ac.midi_stop) self._playButton.setDefaultAction(ac.midi_pause) else: self._timeSliderTicker.stop() self.updateTimeSlider() self._stopButton.setDefaultAction(ac.midi_restart) self._playButton.setDefaultAction(ac.midi_play) # close the output if the preference is set if QSettings().value("midi/close_outputs", False, bool): self._outputCloseTimer.start() def play(self): """Starts the MIDI player, opening an output if necessary.""" if not self._player.is_playing() and not self._player.has_events(): self.restart() self.openOutput() if not self._player.output(): self._display.statusMessage(_("No output found!")) self._player.start() def stop(self): """Stops the MIDI player.""" self._player.stop() def restart(self): """Restarts the MIDI player. If another file is in the file selector, or the file was updated, the new file is loaded. """ self._player.seek(0) self.updateTimeSlider() self._display.reset() if self._document: files = midifiles.MidiFiles.instance(self._document) index = self._fileSelector.currentIndex() if files and (files.song(index) is not self._player.song()): self.loadSong(index) def slotTempoChanged(self, value): """Called when the user drags the tempo.""" # convert -50 to 50 to 0.5 to 2.0 factor = 2**(value / 50.0) self._player.set_tempo_factor(factor) self._display.setTempo("{0}%".format(int(factor * 100))) def slotTimeSliderChanged(self, value): self._player.seek(value) self._display.setTime(value) if self._player.song(): self._display.setBeat(*self._player.song().beat(value)[1:]) def slotTimeSliderMoved(self, value): self._display.setTime(value) if self._player.song(): self._display.setBeat(*self._player.song().beat(value)[1:]) def updateTimeSlider(self): if not self._timeSlider.isSliderDown(): with qutil.signalsBlocked(self._timeSlider): self._timeSlider.setMaximum(self._player.total_time()) self._timeSlider.setValue(self._player.current_time()) def updateDisplayBeat(self, measnum, beat, num, den): if not self._timeSlider.isSliderDown(): self._display.setBeat(measnum, beat, num, den) def updateDisplayTime(self, time): if not self._timeSlider.isSliderDown(): self._display.setTime(time) def slotUpdatedFiles(self, document): """Called when there are new MIDI files.""" if document == self.parentWidget().mainwindow().currentDocument(): self.loadResults(document) def loadResults(self, document): self._document = document files = midifiles.MidiFiles.instance(document) self._fileSelector.setModel(files.model()) if files: self._fileSelector.setCurrentIndex(files.current) if not self._player.is_playing(): self.loadSong(files.current) def loadSong(self, index): files = midifiles.MidiFiles.instance(self._document) self._player.set_song(files.song(index)) m, s = divmod(self._player.total_time() // 1000, 60) name = self._fileSelector.currentText() self.updateTimeSlider() self._display.reset() self._display.statusMessage(_("midi lcd screen", "LOADED"), name, _("midi lcd screen", "TOTAL"), "{0}:{1:02}".format(m, s)) def slotFileSelected(self, index): if self._document: self._player.stop() files = midifiles.MidiFiles.instance(self._document) if files: files.current = index self.restart() def slotDocumentClosed(self, document): if document == self._document: self._document = None self._fileSelector.clear() self._player.stop() self._player.clear() self.updateTimeSlider() self._display.reset()
class ResolutionSettingWidget(QWidget): def __init__(self, app, parent = None): super(ResolutionSettingWidget,self).__init__(parent) self.setStyleSheet("font-size : 16px;") self.app = app CDLL("libjson-c.so", mode=RTLD_GLOBAL) self.jytcapi = cdll.LoadLibrary('../lib/libjytcapi.so') self.jytcapi.jyinittcapi() self.resolutionLabel = QLabel(self.tr("Resolution setting")) self.resolutionCombox = QComboBox() self.resolutionCombox.setFixedSize(300, 30) self.saveBtn = QPushButton(self.tr("Save")) self.saveBtn.setStyleSheet("background: rgb(7,87,198); color: white; width: 90px; height: 30px;font-size : 16px;") gridLayout = QGridLayout() gridLayout.setSpacing(15) gridLayout.setMargin(10) gridLayout.addWidget(self.resolutionLabel, 0, 0, 1, 1) gridLayout.addWidget(self.resolutionCombox, 0, 1, 1, 1) topLayout = QHBoxLayout() topLayout.addStretch() topLayout.addSpacing(50) topLayout.addLayout(gridLayout) topLayout.addStretch(1) bottomHLayout = QHBoxLayout() bottomHLayout.addStretch() bottomHLayout.addWidget(self.saveBtn) bottomHLayout.addStretch() vLayout = QVBoxLayout() vLayout.addStretch() vLayout.addSpacing(50) vLayout.addLayout(topLayout) vLayout.addStretch(2) vLayout.addSpacing(10) vLayout.addLayout(bottomHLayout) self.setLayout(vLayout) self.updateResolutionCombox() self.timer = QTimer() self.timer.setSingleShot(True) self.connect(self.timer,SIGNAL("timeout()"),self.resetScreenResolution); self.connect(self.saveBtn, SIGNAL("clicked()"),self.slotSave) def updateWindow(self): self.resolutionLabel.setText(self.tr(self.tr("Resolution setting"))) self.saveBtn.setText(self.tr("Save")) def getCmdExecValue(self, cmd): statusOutput = commands.getstatusoutput(cmd) monitorList = statusOutput[1].split("\n") return monitorList def getCmdExecValueT(self, cmd): """得到命令执行的结果""" statusOutput = commands.getstatusoutput(cmd) monitorList = statusOutput[1].split("\n") return monitorList def showCurrentScreenResolution(self, curResolutionValue): """显示当前屏幕的分辨率""" count = self.resolutionCombox.count() for i in range(count): if self.resolutionCombox.itemText(i) == curResolutionValue: self.resolutionCombox.setCurrentIndex(i) return self.resolutionCombox.setCurrentIndex(-1) def getCurrentScreenResolution(self, screenName): currentSolution = "10" reSolution = "auto" solutionMap = {"0":"800x600","1":"1024x768","2":"1280x720","3":"1440x900","4":"1600x1020","5":"1920x1080","6":"1280x1024","7":"1366x768","8":"1600x900","10":"auto"} cmd = "../lib/ccr_jytcapi current_display" value = self.getCmdExecValueT(cmd) for i in range(len(value)): LogRecord.instance().logger.info("#".join(value)) if len(value[i].split(":"))==2 and value[i].split(":")[0]=="res" and value[i].split(":")[1] !="auto": currentSolution = value[i].split(":")[1] break if solutionMap.has_key(currentSolution): reSolution = solutionMap[currentSolution] return reSolution def updateResolutionCombox(self): """更新分辨率下拉框的内容""" #得到屏幕支持的分辨率 self.resolutionCombox.clear() resolutionmMap = self.getScreenResolution() if resolutionmMap: screenName = resolutionmMap.keys()[0] for resolution in resolutionmMap[screenName]: if resolution == "800x600": pass else: self.resolutionCombox.addItem(resolution) self.resolutionCombox.setItemData(0, screenName, Qt.UserRole + 1); #获取当前屏幕的分辨率 self.curResolutionValue = self.getCurrentScreenResolution(screenName) #显示当前屏幕的分辨率 self.showCurrentScreenResolution(self.curResolutionValue) def getScreenResolution(self): """得到屏幕支持的分辨率""" #获得显示器名称,连接状态及行号 Monitors = self.getCmdExecValueT("../lib/ccr_jytcapi display"); #根据组合列表把显示器名称和支持的分辨率放入到一个字典中 resolutionMap = {} resolutionList = [] count = len(Monitors) for i in range(count): if len(Monitors[i].split(":"))<2: continue valueName = Monitors[i].split(":")[0] valueValue = Monitors[i].split(":")[1] if valueName == "value": resolutionList.append(valueValue) resolutionMap["monitorName"] = resolutionList return resolutionMap def slotSave(self): language = StoreInfoParser.instance().getLanguage() m_pTranslator = QTranslator() exePath = "./" if language == "chinese": QmName = "zh_CN.qm" else: QmName = "en_US.qm" if(m_pTranslator.load(QmName, exePath)): QCoreApplication.instance().installTranslator(m_pTranslator) """改变当前的分辨率""" screenName = self.resolutionCombox.itemData(0, Qt.UserRole + 1).toString() if not screenName.isEmpty() and not screenName.isNull(): self.curResolutionValue = self.getCurrentScreenResolution(str(screenName)) if self.curResolutionValue: reScreen = self.resolutionCombox.currentText() if reScreen == "800x600": pass else: pass #弹出提示框,默认为取消 rb = MessageBox(self.tr("making sure set the resolution to current"), self).exec_() if rb == QDialog.Accepted: self.jytcapi.jysetdispconf(str(reScreen)) elif rb == QDialog.Rejected: pass def resetScreenResolution(self): """还原分辨率""" #关闭提示窗口 children = self.children() count = len(children) for i in range(count): if isinstance(children[i], MessageBox): children[i].close() #还原之前的分辨率 if self.jytcapi.jysetdispconf(self.curResolutionValue) != 0: # QMessageBox.information(None,u"错误",u'还原分辨率失败') InfoHintDialog(self.tr("reserve failed")).exec_() return #刷新分辨率下拉框 self.updateResolutionCombox() if QString(self.curResolutionValue).contains("x"): width = self.curResolutionValue.split("x")[0] height = self.curResolutionValue.split("x")[1] self.emit(SIGNAL("resizePosition"), width, height) #刷新屏幕 self.app.slotRefreshVMList() def writeConfigFile(self, curResolution): """记录修改后的配置文件""" StoreInfoParser.instance().setResolutionValue(curResolution)
class MainWindow(QMainWindow): def __init__(self, parent=None): super(MainWindow, self).__init__(parent) self.setWindowTitle('Address Book') self.resize(704, 459) self.db_file = self.database_file() self.db = database.Database(self.db_file) dialog = dialogs.UserPanelDlg(self) if dialog.exec_(): self.user = dialog.user else: self.close() self.categComboBox = QComboBox() self.cont_numLabel = QLabel() self.contactsListWidget = QListWidget() self.searchLineEdit = QLineEdit() widgets = ((QLabel('Category:'), self.categComboBox), (self.cont_numLabel, None), (self.contactsListWidget,), (QLabel('Search:'), self.searchLineEdit)) vlayout1 = QVBoxLayout() for i in widgets: hlayout = pyqttools.add_to_layout(QHBoxLayout(), i) vlayout1.addLayout(hlayout) addToolButton = QToolButton() addToolButton.setIcon(QIcon(':addcontact.jpeg')) addToolButton.setIconSize(QSize(45, 45)) self.showLabel = QLabel() self.showLabel.setFrameShape(QFrame.StyledPanel) self.showLabel.setAlignment(Qt.AlignLeading|Qt.AlignLeft|Qt.AlignTop) self.editButton = QPushButton('Edit') self.delButton = QPushButton('Delete') widgets = ((None, addToolButton, None), (self.showLabel,), (None, self.editButton, self.delButton)) vlayout2 = QVBoxLayout() for i in widgets: hlayout = pyqttools.add_to_layout(QHBoxLayout(), i) vlayout2.addLayout(hlayout) f_layout = pyqttools.add_to_layout(QHBoxLayout(), (vlayout1, vlayout2)) Widget = QWidget() Widget.setLayout(f_layout) self.setCentralWidget(Widget) self.statusBar = self.statusBar() self.userLabel = QLabel() self.statusBar.addPermanentWidget(self.userLabel) c_action = pyqttools.create_action panelAction = c_action(self, 'User panel', triggered=self.user_panel) quitAction = c_action(self, 'Quit', 'Ctrl+Q',triggered=self.close) add_contactAction = c_action(self, 'Add contact', 'Ctrl+N', triggered=self.add_contact) delete_allAction = c_action(self, 'Delete all contacts', triggered=self.delete_all) delete_categAction = c_action(self, 'Delete categories', triggered=self.delete_categories) backupAction = c_action(self, 'Backup', triggered=self.backup) restoreAction = c_action(self, 'Restore', triggered=self.restore) aboutAction = c_action(self, 'About', 'Ctrl+?', triggered=self.about) fileMenu = self.menuBar().addMenu('File') contactsMenu = self.menuBar().addMenu('Contacts') deleteMenu = self.menuBar().addMenu(self.tr('Delete')) backupMenu = self.menuBar().addMenu(self.tr('Backup')) helpMenu = self.menuBar().addMenu('Help') pyqttools.add_actions(fileMenu, [panelAction, None, quitAction]) pyqttools.add_actions(contactsMenu, [add_contactAction]) pyqttools.add_actions(deleteMenu,[delete_allAction,delete_categAction]) pyqttools.add_actions(backupMenu, [backupAction, restoreAction]) pyqttools.add_actions(helpMenu, [aboutAction]) addToolButton.clicked.connect(self.add_contact) self.editButton.clicked.connect(self.edit_contact) self.delButton.clicked.connect(self.delete_contact) self.categComboBox.currentIndexChanged.connect(self.fill_ListWidget) self.contactsListWidget.currentRowChanged.connect(self.show_contact) self.searchLineEdit.textEdited.connect(self.search) self.fill_categComboBox() self.refresh_userLabel() def fill_categComboBox(self): categories = ['All'] categories.extend([i[1] for i in self.db.get_categories(self.user)]) self.categComboBox.currentIndexChanged.disconnect(self.fill_ListWidget) self.categComboBox.clear() self.categComboBox.addItems(categories) self.categComboBox.currentIndexChanged.connect(self.fill_ListWidget) self.fill_ListWidget() def fill_ListWidget(self): self.showLabel.clear() self.contactsListWidget.clear() if self.categComboBox.currentIndex() != 0: self.searchLineEdit.clear() category = self.categComboBox.currentText() if category == 'All': contacts = self.db.get_all_contacts(self.user) else: categ_id = self.db.get_category_id(category, self.user) if categ_id is None: return contacts = self.db.get_contacts(categ_id) for i in contacts: self.contactsListWidget.addItem(MyListItem(i[1]+' '+i[2], i[0])) self.contactsListWidget.setCurrentRow(0) self.refresh_contacts_number() self.set_buttons_enabled() def refresh_userLabel(self): self.userLabel.setText('User: '******'Contacts Numer: {0}'.format(self.contactsListWidget.count()) self.cont_numLabel.setText(text) def set_buttons_enabled(self): enable = bool(self.contactsListWidget) self.editButton.setEnabled(enable) self.delButton.setEnabled(enable) def user_panel(self): dialog = dialogs.UserPanelDlg(self) if dialog.exec_(): self.user = dialog.user self.fill_categComboBox() self.refresh_userLabel() def show_contact(self): try: _id = self.contactsListWidget.currentItem()._id except AttributeError: return _id, name, surname, mail, address, tel, categ_id = \ self.db.get_contact_from_id(_id)[0] category = self.db.get_category_from_id(categ_id) text = '' data = (name, surname, mail, address, tel, category) labs = ('Name', 'Surname', 'e-mail', 'Address', 'Telephone', 'Category') for i, y in zip(labs, data): text += '''<p style=\' margin-top:0px; margin-bottom:0px; \'> <span style=\' font-weight:600;\'>{0}:</span> {1} </p>\n'''\ .format(i, y) self.showLabel.setText(text) def add_contact(self): categories = [i[1] for i in self.db.get_categories(self.user)] dialog = dialogs.AddorEditContactDlg(categories) if dialog.exec_(): data = dialog.values if data[-1] not in categories: self.db.addto_categories(data[-1], self.user) categ_id = self.db.get_category_id(data[-1], self.user) data[-1] = categ_id self.db.addto_contacts(data) self.fill_categComboBox() def edit_contact(self): _id = self.contactsListWidget.currentItem()._id data = list(self.db.get_contact_from_id(_id)[0]) categ = self.db.get_category_from_id(data[-1]) data[-1] = categ categories = [i[1] for i in self.db.get_categories(self.user)] dialog = dialogs.AddorEditContactDlg(categories, True, data) if dialog.exec_(): new_data = dialog.values if new_data[-1] not in categories: self.db.addto_categories(new_data[-1], self.user) categ_id = self.db.get_category_id(new_data[-1], self.user) new_data[-1] = categ_id self.db.edit_contact(new_data, _id) self.fill_categComboBox() def delete_contact(self): reply = QMessageBox.question(self, 'Address Book - Delete Contact', 'Are you sure that you want to delete this contact?', QMessageBox.Yes|QMessageBox.Cancel) if reply == QMessageBox.Yes: _id = self.contactsListWidget.currentItem()._id self.db.delete_contact(_id) self.fill_ListWidget() def delete_all(self): reply = QMessageBox.question(self, 'Address Book - Delete Contact', 'Are you sure that you want to delete all contacts?', QMessageBox.Yes|QMessageBox.Cancel) if reply == QMessageBox.Yes: self.db.delete_all_contacts() self.fill_ListWidget() def delete_categories(self): categories = [i[1] for i in self.db.get_categories(self.user)] dialogs.DelCategoriesDlg(categories, self).exec_() self.fill_categComboBox() def search(self): self.categComboBox.setCurrentIndex(0) self.showLabel.clear() self.contactsListWidget.clear() txt = self.searchLineEdit.text() if all(i == ' ' for i in txt): self.fill_ListWidget() return must_appear = [] contacts = self.db.get_all_contacts(self.user) if not ' ' in txt: for i in contacts: if txt.lower() in i[1].lower() or txt.lower() in i[2].lower(): must_appear.append(i) else: try: first, last = txt.split() except ValueError: return for i in contacts: _bool = bool(first.lower() in i[1].lower() or first.lower() in i[2].lower() or last.lower() in i[1].lower() or last.lower() in i[2].lower()) if _bool: must_appear.append(i) for i in must_appear: item = MyListItem(i[1] + ' ' + i[2], i[0]) self.contactsListWidget.addItem(item) self.contactsListWidget.setCurrentRow(0) self.refresh_contacts_number() self.set_buttons_enabled() def backup(self): fname = QFileDialog.getSaveFileName(self,'Address Book - Backup','.db') if fname: try: shutil.copy(self.db_file, fname) except IOError: pass def restore(self): reply = QMessageBox.question(self, 'Address Book - Restore', 'All current contacts will be deleted.\nAre you sure that you want' ' to continue?', QMessageBox.Yes|QMessageBox.Cancel) if reply == QMessageBox.Yes: fname = QFileDialog.getOpenFileName(self, 'Address Book - Restore') if fname: msg = 'Succesful restore!' try: os.remove(self.db_file) shutil.copy(fname, self.db_file) except (OSError, IOError): msg = 'Restore failed!' QMessageBox.information(self, 'Addess Book - Restore', msg) self.db = database.Database(self.db_file) self.fill_categComboBox() def database_file(self): _file = 'addressbook.db' if not platform.platform().startswith('Windows'): folder = os.getenv('HOME') + os.sep + '.addressbook' if not os.path.exists(folder): os.mkdir(folder) _file = folder + os.sep + _file return _file def about(self): link = 'http://wiki.ubuntu-gr.org/Address%20Book' QMessageBox.about(self, self.tr('About') + ' FF Multi Converter', '''<b> Address Book {0} </b> <p>Gui application to organize your contacts! <p>Copyright © 2012 Ilias Stamatis <br>License: GNU GPL3 <p><a href='{1}'>http://wiki.ubuntu-gr.org/Address Book</a> <p>Python {2} - Qt {3} - PyQt {4} on {5}''' .format(__version__, link, platform.python_version()[:5], QT_VERSION_STR, PYQT_VERSION_STR, platform.system())) def close(self): self.db.close() sys.exit()
class MainWindowStart(QMainWindow, MainWindow_Pro.Ui_MainWindow): def __init__(self, parent=None): super(MainWindowStart, self).__init__(parent) # Mappers for connecting buttons and labels self.myMapper = QSignalMapper(self) self.myMapper_StyleSheet = QSignalMapper(self) # Load UI self.setupUi(self) self.regex_edits = QRegExp(r"(^[0]+$|^$)") self._filter = Filter() self.filename = QString() self.edit1_delayh.installEventFilter(self._filter) self.sizeLabel = QLabel() self.sizeLabel.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken) self.statusBar1.addPermanentWidget(self.sizeLabel) self.statusBar1.setSizeGripEnabled(False) self.create_connections() self.assign_shortcuts() self.create_tool_bar() self.update_devices_list() # self.button_stop.clicked.connect(self.stop_all) # List of valve pushbuttons self.valve_list = [ self.valve1, self.valve2, self.valve3, self.valve4, self.valve5, self.valve6, self.valve7, self.valve8 ] # GroupBoxes for grouping labels and buttons on each row, used for applying StyleSheets self.group_boxes = [ self.groupbox1, self.groupbox2, self.groupbox3, self.groupbox4, self.groupbox5, self.groupbox6, self.groupbox7, self.groupbox8 ] # List of lineEdits self.lineEdits_list = [ (self.edit1_delayh, self.edit1_delaym, self.edit1_delays, self.edit1_onh, self.edit1_onm, self.edit1_ons, self.edit1_offh, self.edit1_offm, self.edit1_offs, self.edit1_totalh, self.edit1_totalm, self.edit1_totals), (self.edit2_delayh, self.edit2_delaym, self.edit2_delays, self.edit2_onh, self.edit2_onm, self.edit2_ons, self.edit2_offh, self.edit2_offm, self.edit2_offs, self.edit2_totalh, self.edit2_totalm, self.edit2_totals), (self.edit3_delayh, self.edit3_delaym, self.edit3_delays, self.edit3_onh, self.edit3_onm, self.edit3_ons, self.edit3_offh, self.edit3_offm, self.edit3_offs, self.edit3_totalh, self.edit3_totalm, self.edit3_totals), (self.edit4_delayh, self.edit4_delaym, self.edit4_delays, self.edit4_onh, self.edit4_onm, self.edit4_ons, self.edit4_offh, self.edit4_offm, self.edit4_offs, self.edit4_totalh, self.edit4_totalm, self.edit4_totals), (self.edit5_delayh, self.edit5_delaym, self.edit5_delays, self.edit5_onh, self.edit5_onm, self.edit5_ons, self.edit5_offh, self.edit5_offm, self.edit5_offs, self.edit5_totalh, self.edit5_totalm, self.edit5_totals), (self.edit6_delayh, self.edit6_delaym, self.edit6_delays, self.edit6_onh, self.edit6_onm, self.edit6_ons, self.edit6_offh, self.edit6_offm, self.edit6_offs, self.edit6_totalh, self.edit6_totalm, self.edit6_totals), (self.edit7_delayh, self.edit7_delaym, self.edit7_delays, self.edit7_onh, self.edit7_onm, self.edit7_ons, self.edit7_offh, self.edit7_offm, self.edit7_offs, self.edit7_totalh, self.edit7_totalm, self.edit7_totals), (self.edit8_delayh, self.edit8_delaym, self.edit8_delays, self.edit8_onh, self.edit8_onm, self.edit8_ons, self.edit8_offh, self.edit8_offm, self.edit8_offs, self.edit8_totalh, self.edit8_totalm, self.edit8_totals) ] for index, editLabels in enumerate(self.lineEdits_list, 1): for index2, lineedits in enumerate(editLabels, 0): # Apply mapper (GUIObject, objectIndex) self.myMapper_StyleSheet.setMapping( self.lineEdits_list[index - 1][index2], index - 1) # Connect mapper to signal (self.lineEdits_list[index - 1][index2]).textChanged.connect( self.myMapper_StyleSheet.map) # Set event Filter, for detecting when Focus changes self.lineEdits_list[index - 1][index2].installEventFilter( self._filter) # Set Mappers for buttons (1..8) self.myMapper.setMapping(self.valve_list[index - 1], index) # Connect mapper to signal for detecting clicks on buttons (self.valve_list[index - 1]).clicked.connect(self.myMapper.map) # Connect to signal for enabling labelEdits self.myMapper.mapped['int'].connect(self.enable_fields) # Connect to signal for changing color of groupbox used for visual indication self.myMapper_StyleSheet.mapped['int'].connect(self.valve_color_status) # Create Keyboard Shortcuts def assign_shortcuts(self): self.actionArchivo_Nuevo.setShortcut(QKeySequence.New) self.action_Abrir.setShortcut(QKeySequence.Open) self.action_Guardar.setShortcut(QKeySequence.Save) self.actionGuardar_Como.setShortcut(QKeySequence.SaveAs) self.action_Limpiar.setShortcut('Ctrl+L') self.actionVAL_508_Ayuda.setShortcut(QKeySequence.HelpContents) self.action_Salir.setShortcut(QKeySequence.Close) # self.actionPreferencias.setShortcut(QKeySequence.Preferences) self.action_Detener_USB.setShortcut('Ctrl+Shift+C') self.action_Ejecutar.setShortcut('Ctrl+Shift+X') self.action_Para_Valvulas.setShortcut('Ctrl+Shift+P') # Create connections to signals def create_connections(self): self.actionArchivo_Nuevo.triggered.connect(self.new_file) self.action_Abrir.triggered.connect(self.open_file) self.action_Guardar.triggered.connect(self.save_file) self.actionGuardar_Como.triggered.connect(self.save_file_as) self.action_Limpiar.triggered.connect(self.clean_fields) self.action_Salir.triggered.connect(self.close) self.actionVAL_508_Ayuda.triggered.connect(self.show_help) self.actionAcerca_de_VAL_508.triggered.connect(self.show_about) self.action_Detener_USB.triggered.connect(self.stop_usb) self.action_Ejecutar.triggered.connect(self.execute) self.action_Para_Valvulas.triggered.connect(self.stop_all) # Creation of About Dialog def show_about(self): about = aboutdialog.AboutDialog(self) about.show() # Creation of Help Form def show_help(self): form = helpform.HelpForm('Help.html', self) form.show() def new_file(self): self.filename = QString() self.clean_fields() # Close connection to arduino before closing Program def closeEvent(self, QCloseEvent): try: self.thread_connection.serial_connection.close() logging.debug("Thread running and killed at closing program") except AttributeError: logging.debug("Thread was not running when closing program OK") def clean_fields(self): for index, editLabels in enumerate(self.lineEdits_list, 1): for index2, lineedits in enumerate(editLabels, 0): self.lineEdits_list[index - 1][index2].setText('0') def save_file_as(self): filename_copy = self.filename logging.info("Current filename: %s" % self.filename) my_home = os.path.expanduser('~') self.filename = QFileDialog.getSaveFileName( self, self.tr('Guardar como'), os.path.join(my_home, "archivo.txt"), "", "", QFileDialog.DontUseNativeDialog) logging.info("Filename to save: %s" % self.filename) if not self.filename.isNull(): if self.filename.endsWith(QString('.txt')): self.write_data_to_file('w') else: self.filename.append(QString('.txt')) messageBox = QMessageBox(self) messageBox.setStyleSheet( 'QMessageBox QLabel {font: bold 14pt "Cantarell";}') messageBox.setWindowTitle(self.tr('Advertencia')) messageBox.setText( self.tr(u"El archivo ya existe, ¿Reemplazar?")) messageBox.setStandardButtons(QMessageBox.Yes | QMessageBox.No) messageBox.setIconPixmap(QPixmap(':/broken_file.png')) if messageBox.exec_() == QMessageBox.Yes: self.write_data_to_file('w') else: try: while True: self.filename = QFileDialog.getSaveFileName( self, self.tr('Guardar como'), os.path.join(my_home, "archivo.txt"), "", "", QFileDialog.DontUseNativeDialog) if self.filename.isNull(): raise Saved_Canceled() else: messageBox = QMessageBox(self) messageBox.setStyleSheet( 'QMessageBox QLabel {font: bold 14pt "Cantarell";}' ) messageBox.setWindowTitle( self.tr('Advertencia')) messageBox.setText( self.tr( u"El archivo ya existe, ¿Reemplazar?")) messageBox.setStandardButtons(QMessageBox.Yes | QMessageBox.No) messageBox.setIconPixmap( QPixmap(':/broken_file.png')) if messageBox.exec_() == QMessageBox.Yes: self.write_data_to_file('w') raise Saved_Accepted() except Saved_Canceled: self.filename = filename_copy except Saved_Accepted: pass logging.info("Current filename after operation: %s" % self.filename) def save_file(self): if self.filename.isNull(): self.save_file_as() else: self.write_data_to_file('w') # Colect data for arduino def execute(self): string_data = '' list_strings = [] if str(self.arduino_combobox.currentText()): self.statusBar1.showMessage(self.tr('Conectando...')) # Gather all the contents of each row of valves and create a list of lists with them for elem_edit in self.lineEdits_list: # delay string_data = string_data + str( ((int(elem_edit[0].text()) * 3600) + (int(elem_edit[1].text()) * 60) + (int(elem_edit[2].text()))) * 1000) + ';' # ON string_data = string_data + str( ((int(elem_edit[3].text()) * 3600) + (int(elem_edit[4].text()) * 60) + (int(elem_edit[5].text()))) * 1000) + ';' # OFF string_data = string_data + str( ((int(elem_edit[6].text()) * 3600) + (int(elem_edit[7].text()) * 60) + (int(elem_edit[8].text()))) * 1000) + ';' # Total string_data = string_data + str( ((int(elem_edit[9].text()) * 3600) + (int(elem_edit[10].text()) * 60) + (int(elem_edit[11].text()))) * 1000) + ';' list_strings.append(string_data) string_data = '' # Start QThread for communicating with arduino self.thread_connection = Arduino_Communication( str(self.arduino_combobox.currentText()), list_strings) self.thread_connection.start() self.action_Ejecutar.setEnabled(False) self.action_Para_Valvulas.setEnabled(False) # Connect to current QThread instance in order to know the status of it's termination # This line used only when stopping current task self.thread_connection.finished.connect(self.finished_thread) self.thread_connection.connection_exit_status.connect( self.finished_thread) else: messageBox = QMessageBox(self) messageBox.setStyleSheet( 'QMessageBox QLabel {font: bold 14pt "Cantarell";}') messageBox.setWindowTitle(self.tr('Advertencia')) messageBox.setText(self.tr("Arduino no seleccionado")) messageBox.setStandardButtons(QMessageBox.Ok) messageBox.setIconPixmap(QPixmap(':/usb_error.png')) messageBox.exec_() # Inform QThread to stop sending data to arduino def stop_usb(self): if str(self.arduino_combobox.currentText()): try: self.statusBar1.showMessage(self.tr(u'Conexión detenida')) if self.thread_connection.isRunning(): mutex.lock() self.thread_connection.kill_serial = True mutex.unlock() except AttributeError: logging.debug("Thread not running \'disconnected! \'") else: messageBox = QMessageBox(self) messageBox.setStyleSheet( 'QMessageBox QLabel {font: bold 14pt "Cantarell";}') messageBox.setWindowTitle(self.tr('Advertencia')) messageBox.setText(self.tr("Arduino no seleccionado")) messageBox.setStandardButtons(QMessageBox.Ok) messageBox.setIconPixmap(QPixmap(':/usb_error.png')) messageBox.exec_() def enable_fields(self, index): hours_reg = QRegExp(r"0*[0-9]{1,3}") sec_reg = QRegExp(r"(0*[0-9])|(0*[0-5][0-9])") for counter, line_edit in enumerate(self.lineEdits_list[index - 1]): line_edit.setEnabled(self.valve_list[index - 1].isChecked()) if counter % 3 == 0: line_edit.setValidator(QRegExpValidator(hours_reg, self)) else: line_edit.setValidator(QRegExpValidator(sec_reg, self)) def valve_color_status(self, index): logging.info("Checking color from valve button") for edit in self.lineEdits_list[index]: if edit.text().contains(self.regex_edits): self.group_boxes[index].setStyleSheet('''QGroupBox { border: 2px solid; border-color: rgba(255, 255, 255, 0);}''' ) else: self.group_boxes[index].setStyleSheet( '''QGroupBox {background-color: rgba(103, 255, 126, 150); border: 2px solid; border-color: rgba(255, 255, 255, 255);}''' ) break def create_tool_bar(self): self.label_arduino = QLabel(self.tr('Dispositivos: ')) self.toolBar.addWidget(self.label_arduino) self.arduino_combobox = QComboBox() self.arduino_combobox.setToolTip(self.tr('Seleccionar Arduino')) self.arduino_combobox.setFocusPolicy(Qt.NoFocus) # Update List of Arduino devices self.reload = QAction(QIcon(":/reload.png"), self.tr("&Refrescar"), self) self.reload.setShortcut(QKeySequence.Refresh) self.reload.setToolTip(self.tr('Refrescar Dispositivos')) self.reload.triggered.connect(self.update_devices_list) self.toolBar.addWidget(self.arduino_combobox) self.toolBar.addAction(self.reload) # Update current usb devices connected to PC def update_devices_list(self): device_list = serial.tools.list_ports.comports() current_arduino = self.arduino_combobox.currentText() self.arduino_combobox.clear() for device_index, device in enumerate(sorted(device_list)): self.arduino_combobox.addItem(device.device) if device.device == current_arduino: self.arduino_combobox.setCurrentIndex(device_index) # Stop current arduino task def stop_all(self): if str(self.arduino_combobox.currentText()): self.thread_connection = Arduino_Communication( str(self.arduino_combobox.currentText())) self.thread_connection.start() self.action_Ejecutar.setEnabled(False) self.action_Para_Valvulas.setEnabled(False) self.action_Detener_USB.setEnabled(False) self.thread_connection.finished.connect(self.finished_thread) self.thread_connection.connection_exit_status.connect( self.finished_thread) else: messageBox = QMessageBox(self) messageBox.setStyleSheet( 'QMessageBox QLabel {font: bold 14pt "Cantarell";}') messageBox.setWindowTitle(self.tr('Advertencia')) messageBox.setText(self.tr("Arduino no seleccionado")) messageBox.setStandardButtons(QMessageBox.Ok) messageBox.setIconPixmap(QPixmap(':/usb_error.png')) messageBox.exec_() def open_file(self): try: my_home = os.path.expanduser('~') file_name = QFileDialog.getOpenFileName( self, self.tr('Abrir archivo'), my_home, '*.txt', '*.txt', QFileDialog.DontUseNativeDialog) logging.warning("file_name type: %s" % type(file_name)) list_values = [] if not file_name.isNull(): with open(file_name) as fp: for line in fp: list_values.extend([line.replace('\n', '')]) logging.info("List Content: %s" % list_values) count = 0 for elems in self.lineEdits_list: for inner_elem in elems: if not unicode(list_values[count]).isdigit(): raise Uncompatible_Data() inner_elem.setText(list_values[count]) count = count + 1 self.filename = file_name except (IOError, OSError): messageBox = QMessageBox(self) messageBox.setStyleSheet( 'QMessageBox QLabel {font: bold 14pt "Cantarell";}') messageBox.setWindowTitle(self.tr('Error')) messageBox.setText(self.tr('No se pudo abrir el archivo')) messageBox.setStandardButtons(QMessageBox.Ok) messageBox.setIconPixmap(QPixmap(':/broken_file.png')) messageBox.exec_() except (IndexError, Uncompatible_Data): messageBox = QMessageBox(self) messageBox.setStyleSheet( 'QMessageBox QLabel {font: bold 14pt "Cantarell";}') messageBox.setWindowTitle(self.tr('Error')) messageBox.setText(self.tr('Formato Incompatible')) messageBox.setStandardButtons(QMessageBox.Ok) messageBox.setIconPixmap(QPixmap(':/broken_file.png')) messageBox.exec_() # Inform the user if we were able to send data successfully to arduino def finished_thread(self, error=None, message=''): if error == 'error': messageBox = QMessageBox(self) messageBox.setStyleSheet( 'QMessageBox QLabel {font: bold 14pt "Cantarell";}') messageBox.setWindowTitle(self.tr('Error')) messageBox.setText(message) messageBox.setStandardButtons(QMessageBox.Ok) messageBox.setIconPixmap(QPixmap(':/usb_error.png')) messageBox.exec_() return elif error == 'success': messageBox = QMessageBox(self) messageBox.setStyleSheet( 'QMessageBox QLabel {font: bold 14pt "Cantarell";}') messageBox.setWindowTitle(self.tr(u'Éxito')) messageBox.setText(message) messageBox.setStandardButtons(QMessageBox.Ok) messageBox.setIconPixmap(QPixmap(':/usb_success.png')) messageBox.exec_() return elif error == 'stopped': messageBox = QMessageBox(self) messageBox.setStyleSheet( 'QMessageBox QLabel {font: bold 14pt "Cantarell";}') messageBox.setWindowTitle(self.tr(u'Éxito')) messageBox.setText(message) messageBox.setStandardButtons(QMessageBox.Ok) messageBox.setIconPixmap(QPixmap(':/success_general.png')) messageBox.exec_() return self.action_Ejecutar.setEnabled(True) self.action_Para_Valvulas.setEnabled(True) self.action_Detener_USB.setEnabled(True) self.statusBar1.showMessage(self.tr('Finalizado')) # Save data to disk def write_data_to_file(self, open_mode): progressDialog = QProgressDialog() progressDialog.setModal(True) progressDialog.setLabelText(self.tr('Guardando...')) progressDialog.setMaximum(8) progressDialog.setCancelButton(None) progressDialog.show() try: # File is closed automatically even on error with open(unicode(self.filename), open_mode) as file_obj: for count, elem_edit in enumerate(self.lineEdits_list, 1): file_obj.write(''.join([str(elem_edit[0].text()), '\n'])) file_obj.write(''.join([str(elem_edit[1].text()), '\n'])) file_obj.write(''.join([str(elem_edit[2].text()), '\n'])) file_obj.write(''.join([str(elem_edit[3].text()), '\n'])) file_obj.write(''.join([str(elem_edit[4].text()), '\n'])) file_obj.write(''.join([str(elem_edit[5].text()), '\n'])) file_obj.write(''.join([str(elem_edit[6].text()), '\n'])) file_obj.write(''.join([str(elem_edit[7].text()), '\n'])) file_obj.write(''.join([str(elem_edit[8].text()), '\n'])) file_obj.write(''.join([str(elem_edit[9].text()), '\n'])) file_obj.write(''.join([str(elem_edit[10].text()), '\n'])) file_obj.write(''.join([str(elem_edit[11].text()), '\n'])) progressDialog.setValue(count) except (IOError, OSError): progressDialog.close() messageBox = QMessageBox(self) messageBox.setStyleSheet( 'QMessageBox QLabel {font: bold 14pt "Cantarell";}') messageBox.setWindowTitle(self.tr('Error')) messageBox.setText(self.tr('Error al guardar')) messageBox.setStandardButtons(QMessageBox.Ok) messageBox.setIcon(QMessageBox.Critical) messageBox.exec_() else: self.statusBar1.showMessage(self.tr('Guardado'), 3000)
class MusicPreviewWidget(QWidget): def __init__(self, parent=None): super(MusicPreviewWidget, self).__init__(parent) self._lastbuildtime = 10.0 self._running = None self._current = None self._chooserLabel = QLabel() self._chooser = QComboBox(self, activated=self.selectDocument) self._log = log.Log() self._view = popplerview.View() self._progress = widgets.progressbar.TimedProgressBar() self._stack = QStackedLayout() self._top = QWidget() layout = QVBoxLayout() self.setLayout(layout) layout.addWidget(self._top) layout.addLayout(self._stack) layout.addWidget(self._progress) top = QHBoxLayout() top.setContentsMargins(0, 0, 0, 0) top.setSpacing(2) self._top.setLayout(top) top.addWidget(self._chooserLabel) top.addWidget(self._chooser) top.addStretch(1) self._stack.addWidget(self._log) self._stack.addWidget(self._view) self._top.hide() app.aboutToQuit.connect(self.cleanup) app.translateUI(self) def translateUI(self): self._chooserLabel.setText(_("Document:")) def preview(self, text, title=None): """Runs LilyPond on the given text and shows the resulting PDF.""" j = self._running = MusicPreviewJob(text, title) j.done.connect(self._done) self._log.clear() self._log.connectJob(j) j.start() self._progress.start(self._lastbuildtime) def _done(self, success): self._progress.stop(False) pdfs = self._running.resultfiles() self.setDocuments(pdfs) if not pdfs: self._stack.setCurrentWidget(self._log) return self._lastbuildtime = self._running.elapsed_time() self._stack.setCurrentWidget(self._view) if self._current: self._current.cleanup() self._current = self._running # keep the tempdir self._running = None def setDocuments(self, pdfs): """Loads the given PDF path names in the UI.""" self._documents = [popplertools.Document(name) for name in pdfs] self._chooser.clear() self._chooser.addItems([d.name() for d in self._documents]) self._top.setVisible(len(self._documents) > 1) if pdfs: self._chooser.setCurrentIndex(0) self.selectDocument(0) else: self._view.clear() def selectDocument(self, index): doc = self._documents[index].document() if doc: self._view.load(doc) def cleanup(self): if self._running: self._running.abort() self._running.cleanup() self._running = None if self._current: self._current.cleanup() self._current = None self._stack.setCurrentWidget(self._log) self._top.hide() self._view.clear() def print_(self): """Prints the currently displayed document.""" if self._documents: doc = self._documents[self._chooser.currentIndex()] import popplerprint popplerprint.printDocument(doc, self)
class FilteringModule(PreprocessorModule): DEFAULT_SETTINGS = { 'is_enabled': True, 'methods': [True, False, False], 'recent_sw_files': [], 'min_df': None, 'max_df': None, } English, Custom, DocumentFrequency = 0, 1, 2 filtering_values = { English: 'english', Custom: [], DocumentFrequency: (None, None), } filter_names = { English: 'English stop words', Custom: 'Custom stop words', DocumentFrequency: 'Filter by token frequency', } filtering_methods = [True, False, False] dlgFormats = 'Only text files (*.txt)' recent_sw_files = [] def __init__(self, data): data = data or self.DEFAULT_SETTINGS PreprocessorModule.__init__(self, 'Token filtering', True, data.get('is_enabled')) self.group = QButtonGroup(self, exclusive=False) # --- English --- cb = QCheckBox(self, text=self.filter_names[self.English]) self.add_to_content_area(cb) self.group.addButton(cb, self.English) # --- Custom --- cb = QCheckBox(self, text=self.filter_names[self.Custom]) self.add_to_content_area(cb) self.group.addButton(cb, self.Custom) # File browser. file_browser_layout = QHBoxLayout() file_browser_layout.setContentsMargins(20, 0, 0, 0) self.sw_file_combo = QComboBox() self.sw_file_combo.setMinimumWidth(200) file_browser_layout.addWidget(self.sw_file_combo) self.sw_file_combo.activated[int].connect(self.select_file) self.browse_button = QPushButton(self) self.browse_button.clicked.connect(self.browse_file) self.browse_button.setIcon(self.style().standardIcon( QStyle.SP_DirOpenIcon)) self.browse_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) file_browser_layout.addWidget(self.browse_button) # Reload button self.reload_button = QPushButton(self) self.reload_button.clicked.connect(self.on_reload_button_clicked) self.reload_button.setIcon(self.style().standardIcon( QStyle.SP_BrowserReload)) self.reload_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) file_browser_layout.addWidget(self.reload_button) self.add_layout_to_content_area(file_browser_layout) # --- DF --- df_info_text = """ Remove all tokens that appear in less than 'min-df' documents. Remove all tokens that appear in more than 'max-df' documents. Values can be either integers or floats (ratio of documents). """ cb = QCheckBox(self, text=self.filter_names[self.DocumentFrequency]) self.add_to_content_area(cb) self.group.addButton(cb, self.DocumentFrequency) df_info_text = QLabel(df_info_text) df_info_text.setContentsMargins(0, 0, 0, 0) df_info_text.setStyleSheet(""" font-size: 11px; font-style: italic; """) self.add_to_content_area(df_info_text) # Min/Max-Df setter. df_setter_layout = QHBoxLayout() df_setter_layout.setContentsMargins(20, 0, 0, 0) self.min_df_input = QLineEdit() self.min_df_input.textChanged.connect(self.update_df_parameters) self.max_df_input = QLineEdit() self.max_df_input.textChanged.connect(self.update_df_parameters) df_setter_layout.addWidget(QLabel('Min-df:')) df_setter_layout.addWidget(self.min_df_input) df_setter_layout.addWidget(QLabel('Max-df:')) df_setter_layout.addWidget(self.max_df_input) self.add_layout_to_content_area(df_setter_layout) self.group.buttonClicked.connect(self.group_button_clicked) # Restore the widget to its previous state. self.restore_data(data) def str_to_num(self, s): if not s: return None try: return int(s) except ValueError: pass # Not an int. Continue. try: return float(s) except ValueError: # Not a float either. self.send_message( 'Input "{}" cannot be cast into a number.'.format(s)) return None def send_message(self, message): # Sends a message with the "message" signal, to the main widget. self.error_signal.emit(message) # --- File selection. def select_file(self, n): if n < len(self.recent_sw_files): name = self.recent_sw_files[n] del self.recent_sw_files[n] self.recent_sw_files.insert(0, name) if len(self.recent_sw_files) > 0: self.set_file_list() self.open_file(self.recent_sw_files[0]) def set_file_list(self): self.sw_file_combo.clear() if not self.recent_sw_files: self.sw_file_combo.addItem('(none)') else: for file in self.recent_sw_files: self.sw_file_combo.addItem(os.path.split(file)[1]) def browse_file(self): # Opens the file browser, starting at the home directory. start_file = os.path.expanduser('~/') # Get the file path from the browser window. path = QFileDialog.getOpenFileName(self, 'Open a stop words source', start_file, self.dlgFormats) if not path: return if path in self.recent_sw_files: self.recent_sw_files.remove(path) self.recent_sw_files.insert(0, path) self.set_file_list() self.open_file(path) def update_df_parameters(self): min_df = None if not self.min_df_input.text( ) else self.min_df_input.text() max_df = None if not self.max_df_input.text( ) else self.max_df_input.text() self.filtering_values[self.DocumentFrequency] = (min_df, max_df) self.notify_on_change() def open_file(self, path): try: with open(path) as f: # Read most recent. self.filtering_values[self.Custom] = [ sw.strip() for sw in f.read().splitlines() ] self.notify_on_change() except Exception: # Raise an exception otherwise. self.send_message('Could not open "{}".'.format(path)) def on_reload_button_clicked(self): if self.recent_sw_files: self.select_file(0) # END File selection. def group_button_clicked(self): self.filtering_methods = [ ch_box.isChecked() for ch_box in self.group.buttons() ] self.enable_choice_settings() # Emit the signal. self.notify_on_change() def enable_choice_settings(self): self.sw_file_combo.setEnabled(self.filtering_methods[1]) self.browse_button.setEnabled(self.filtering_methods[1]) self.reload_button.setEnabled(self.filtering_methods[1]) self.min_df_input.setEnabled(self.filtering_methods[2]) self.max_df_input.setEnabled(self.filtering_methods[2]) def get_pp_setting(self): flag_english = self.filtering_methods[0] flag_custom = self.filtering_methods[1] flag_df = self.filtering_methods[2] if flag_english and flag_custom: # Use custom. stop_words = { 'stop_words': stopwords.words('english') + self.filtering_values[self.Custom] } elif flag_english and not flag_custom: stop_words = {'stop_words': 'english'} elif flag_custom: stop_words = {'stop_words': self.filtering_values[self.Custom]} else: stop_words = {} if flag_df: stop_words.update({ 'min_df': self.str_to_num(self.min_df_input.text()), 'max_df': self.str_to_num(self.max_df_input.text()), }) return stop_words def restore_data(self, data): self.recent_sw_files = data.get('recent_sw_files') self.min_df_input.setText(data.get('min_df')) self.max_df_input.setText(data.get('max_df')) self.filtering_methods = data.get('methods') for flag, ch_box in zip(self.filtering_methods, self.group.buttons()): ch_box.setChecked(flag) self.enable_choice_settings() # Enable the settings if set. self.set_file_list() # Fill the combo box with the recent sw files. self.select_file(0) # Select the first file. def export_data(self): return { 'is_enabled': self.enabled, 'methods': self.filtering_methods, 'recent_sw_files': self.recent_sw_files, 'min_df': self.min_df_input.text(), 'max_df': self.max_df_input.text(), }
class Dialog(QDialog): def __init__(self, mainwindow): super(Dialog, self).__init__(mainwindow) self._document = None layout = QGridLayout() self.setLayout(layout) self.versionLabel = QLabel() self.versionCombo = QComboBox() self.outputLabel = QLabel() self.outputCombo = QComboBox() self.resolutionLabel = QLabel() self.resolutionCombo = QComboBox(editable=True) self.antialiasLabel = QLabel() self.antialiasSpin = QSpinBox(minimum=1, maximum=128, value=1) self.modeLabel = QLabel() self.modeCombo = QComboBox() self.englishCheck = QCheckBox() self.deleteCheck = QCheckBox() self.commandLineLabel = QLabel() self.commandLine = QTextEdit(acceptRichText=False) self.buttons = QDialogButtonBox( QDialogButtonBox.Ok | QDialogButtonBox.Cancel) self.buttons.button(QDialogButtonBox.Ok).setIcon(icons.get("lilypond-run")) userguide.addButton(self.buttons, "engrave_custom") self.resolutionCombo.addItems(['100', '200', '300', '600', '1200']) self.resolutionCombo.setCurrentIndex(2) self.modeCombo.addItems(['preview', 'publish', 'debug']) layout.addWidget(self.versionLabel, 0, 0) layout.addWidget(self.versionCombo, 0, 1, 1, 3) layout.addWidget(self.outputLabel, 1, 0) layout.addWidget(self.outputCombo, 1, 1, 1, 3) layout.addWidget(self.resolutionLabel, 2, 0) layout.addWidget(self.resolutionCombo, 2, 1) layout.addWidget(self.antialiasLabel, 2, 2, Qt.AlignRight) layout.addWidget(self.antialiasSpin, 2, 3) layout.addWidget(self.modeLabel, 3, 0) layout.addWidget(self.modeCombo, 3, 1, 1, 3) layout.addWidget(self.englishCheck, 4, 0, 1, 4) layout.addWidget(self.deleteCheck, 5, 0, 1, 4) layout.addWidget(self.commandLineLabel, 6, 0, 1, 4) layout.addWidget(self.commandLine, 7, 0, 1, 4) layout.addWidget(widgets.Separator(), 8, 0, 1, 4) layout.addWidget(self.buttons, 9, 0, 1, 4) app.translateUI(self) qutil.saveDialogSize(self, "engrave/custom/dialog/size", QSize(480, 260)) self.buttons.accepted.connect(self.accept) self.buttons.rejected.connect(self.reject) model = listmodel.ListModel(formats, display=lambda f: f.title(), icon=lambda f: icons.file_type(f.type)) self.outputCombo.setModel(model) s = QSettings() s.beginGroup("lilypond_settings") self.englishCheck.setChecked( s.value("no_translation", False, bool)) self.deleteCheck.setChecked( s.value("delete_intermediate_files", True, bool)) if s.value("default_output_target", "pdf", type("")) == "svg": self.outputCombo.setCurrentIndex(3) self.loadLilyPondVersions() self.selectLilyPondInfo(lilypondinfo.preferred()) app.settingsChanged.connect(self.loadLilyPondVersions) app.jobFinished.connect(self.slotJobFinished) self.outputCombo.currentIndexChanged.connect(self.makeCommandLine) self.modeCombo.currentIndexChanged.connect(self.makeCommandLine) self.deleteCheck.toggled.connect(self.makeCommandLine) self.resolutionCombo.editTextChanged.connect(self.makeCommandLine) self.antialiasSpin.valueChanged.connect(self.makeCommandLine) self.makeCommandLine() panelmanager.manager(mainwindow).layoutcontrol.widget().optionsChanged.connect(self.makeCommandLine) def translateUI(self): self.setWindowTitle(app.caption(_("Engrave custom"))) self.versionLabel.setText(_("LilyPond Version:")) self.outputLabel.setText(_("Output Format:")) self.resolutionLabel.setText(_("Resolution:")) self.antialiasLabel.setText(_("Antialias Factor:")) self.modeLabel.setText(_("Engraving mode:")) self.modeCombo.setItemText(0, _("Preview")) self.modeCombo.setItemText(1, _("Publish")) self.modeCombo.setItemText(2, _("Layout Control")) self.englishCheck.setText(_("Run LilyPond with English messages")) self.deleteCheck.setText(_("Delete intermediate output files")) self.commandLineLabel.setText(_("Command line:")) self.buttons.button(QDialogButtonBox.Ok).setText(_("Run LilyPond")) self.outputCombo.update() def slotJobFinished(self, doc): if doc == self._document: self.buttons.button(QDialogButtonBox.Ok).setEnabled(True) self._document = None def setDocument(self, doc): self.selectLilyPondInfo(command.info(doc)) if jobmanager.isRunning(doc): self._document = doc self.buttons.button(QDialogButtonBox.Ok).setEnabled(False) def loadLilyPondVersions(self): infos = lilypondinfo.infos() or [lilypondinfo.default()] infos.sort(key = lambda i: i.version() or (999,)) self._infos = infos index = self.versionCombo.currentIndex() self.versionCombo.clear() for i in infos: icon = 'lilypond-run' if i.version() else 'dialog-error' self.versionCombo.addItem(icons.get(icon), i.prettyName()) self.versionCombo.setCurrentIndex(index) def selectLilyPondInfo(self, info): if info in self._infos: self.versionCombo.setCurrentIndex(self._infos.index(info)) def makeCommandLine(self): """Reads the widgets and builds a command line.""" f = formats[self.outputCombo.currentIndex()] self.resolutionCombo.setEnabled('resolution' in f.widgets) self.antialiasSpin.setEnabled('antialias' in f.widgets) cmd = ["$lilypond"] if self.modeCombo.currentIndex() == 0: # preview mode cmd.append('-dpoint-and-click') elif self.modeCombo.currentIndex() == 1: # publish mode cmd.append('-dno-point-and-click') else: # debug mode args = panelmanager.manager(self.parent()).layoutcontrol.widget().preview_options() cmd.extend(args) if self.deleteCheck.isChecked(): cmd.append('-ddelete-intermediate-files') else: cmd.append('-dno-delete-intermediate-files') d = { 'version': self._infos[self.versionCombo.currentIndex()].version, 'resolution': self.resolutionCombo.currentText(), 'antialias': self.antialiasSpin.value(), } cmd.append("$include") cmd.extend(f.options(d)) cmd.append("$filename") self.commandLine.setText(' '.join(cmd)) def getJob(self, document): """Returns a Job to start.""" filename, includepath = documentinfo.info(document).jobinfo(True) i = self._infos[self.versionCombo.currentIndex()] cmd = [] for t in self.commandLine.toPlainText().split(): if t == '$lilypond': cmd.append(i.abscommand() or i.command) elif t == '$filename': cmd.append(filename) elif t == '$include': cmd.extend('-I' + path for path in includepath) else: cmd.append(t) j = job.Job() j.directory = os.path.dirname(filename) j.command = cmd if self.englishCheck.isChecked(): j.environment['LANG'] = 'C' j.setTitle("{0} {1} [{2}]".format( os.path.basename(i.command), i.versionString(), document.documentName())) return j
class ItemEntriesFrame(QFrame): read_block = pyqtSignal(int, int) # start_addr, num_bytes poke_block = pyqtSignal(int, QByteArray, bool) # start_addr, raw_bytes, is_ascii log = pyqtSignal(str, str) # msg, color MISSING_ITEM_NAME = '[NOT IN DB]' def __init__(self, type_val, addr_start, addr_end, label, id2name, idx2id, names, parent=None): super(ItemEntriesFrame, self).__init__(parent) self.type_val = type_val self.code_offset = 0 self.addr_start = addr_start self.addr_end = addr_end self.max_num_slots = (addr_end - addr_start) / 3 / 4 + 1 self.label = label self.id2name = id2name self.idx2id = idx2id self.names = names self.slots_cache = [ ] # tuple: (addr_hex, addr_val, slot_number, cur_val) self.cur_slot_idx = -1 self.lbl_label = QLabel(self.label, self) self.btn_read_slots = QPushButton(' Cache Slots', self) self.btn_read_slots.setIcon(QIcon('img/flaticon/data110.png')) self.btn_read_slots.setStyleSheet('background-color: white') self.btn_read_slots.clicked.connect(self.onReadSlots) self.btn_search_cache = QPushButton(' Search ID', self) self.btn_search_cache.setIcon(QIcon('img/flaticon/magnifier13.png')) self.btn_search_cache.setToolTip( 'Find slot in cache with specified item ID') self.btn_search_cache.setStyleSheet('background-color: white') self.btn_search_cache.clicked.connect(self.onSearchCacheForID) self.btn_read = QPushButton(self) self.btn_read.setIcon(QIcon('img/flaticon/open135.png')) self.btn_read.setToolTip('Read item slot value from memory') self.btn_read.setStyleSheet('background-color: white') self.btn_read.clicked.connect(self.onReadSlot) self.cmb_slots = QComboBox(self) self.cmb_slots.setStyleSheet('background-color: white') self.cmb_slots.currentIndexChanged[int].connect(self.onChangeSlot) self.cmb_slots.setDisabled(True) self.cmb_names = QComboBox(self) self.cmb_names.setEditable(True) self.cmb_names.addItems(self.names) self.cmb_names.lineEdit().setText(ItemEntriesFrame.MISSING_ITEM_NAME) self.cmb_names.currentIndexChanged[int].connect(self.fetchID) self.txt_id = QLineEdit(self) self.txt_id.setPlaceholderText('ID (hex)') self.txt_id.setMaxLength(3) self.txt_id.textChanged.connect(self.fetchName) self.btn_rename = QPushButton(' Fix Name', self) self.btn_rename.setIcon(QIcon('img/flaticon/cloud-storage3.png')) self.btn_rename.setToolTip( 'Add/Correct Item Name for %s (type: %02X)' % (self.label, type_val)) self.btn_rename.setStyleSheet('background-color: white') self.btn_rename.clicked.connect(self.onRename) self.txt_amount = QLineEdit(self) self.txt_amount.setPlaceholderText('Amount') self.txt_amount.setMaxLength(3) self.btn_poke = QPushButton(self) self.btn_poke.setIcon(QIcon('img/flaticon/draw39.png')) self.btn_poke.setToolTip('Poke new value for item slot') self.btn_poke.setStyleSheet('background-color: white') self.btn_poke.clicked.connect(self.onPokeSlot) self.layout = QGridLayout(self) self.layout.addWidget(self.lbl_label, 0, 0) self.layout.addWidget(self.btn_read_slots, 0, 1) self.layout.addWidget(self.btn_search_cache, 0, 2) self.layout.addWidget(self.cmb_slots, 0, 3) self.layout.addWidget(self.btn_read, 0, 4) self.layout.addWidget(self.cmb_names, 1, 0) self.layout.addWidget(self.txt_id, 1, 1) self.layout.addWidget(self.btn_rename, 1, 2) self.layout.addWidget(self.txt_amount, 1, 3) self.layout.addWidget(self.btn_poke, 1, 4) self.layout.setColumnStretch(0, 7) self.layout.setColumnStretch(1, 3) self.layout.setColumnStretch(2, 3) self.layout.setColumnStretch(3, 3) self.layout.setColumnStretch(4, 1) self.layout.setContentsMargins(0, 2, 0, 2) icon_height = self.lbl_label.height() * 8 / 15 icon_size = QSize(icon_height, icon_height) self.btn_read_slots.setIconSize(icon_size) self.btn_search_cache.setIconSize(icon_size) self.btn_rename.setIconSize(icon_size) self.btn_read.setIconSize(icon_size) self.btn_poke.setIconSize(icon_size) btn_size = QSize(icon_height * 1.5, icon_height * 1.5) self.btn_read.setFixedSize(btn_size) self.btn_poke.setFixedSize(btn_size) self.updateUI() def updateUI(self): # Disable editing if cache missing if not (0 <= self.cur_slot_idx < len(self.slots_cache)): self.cmb_names.lineEdit().setText( ItemEntriesFrame.MISSING_ITEM_NAME) self.cmb_names.setDisabled(True) self.txt_id.setText('') self.txt_id.setDisabled(True) return # Validate current value cur_val = self.slots_cache[self.cur_slot_idx][3] (type_val, id_val, amount) = parse_item_word(cur_val) if type_val != self.type_val and type_val != 0: cur_addr = self.slots_cache[ self.cur_slot_idx][1] + self.code_offset self.log.emit( 'Cache error: val(0x%08X)=%08X, type (%02X) != expected (%02X)' % (cur_addr, cur_val, type_val, self.type_val), 'red') return # Update UI self.txt_id.setDisabled(False) self.txt_id.setText('%03X' % id_val) self.cmb_names.setDisabled(False) self.fetchName() self.txt_amount.setText(str(amount)) def setAlternateBGColor(self): self.setStyleSheet( 'ItemEntriesFrame { background-color:rgb(248,248,248) }') @pyqtSlot(int) def onSetCodeOffset(self, signed_offset): self.code_offset = signed_offset @pyqtSlot() def onRename(self): id_txt = str(self.txt_id.text()) if len(id_txt) != 3: return dialog = FixItemNameDialog('%02X' % self.type_val, id_txt, self) dialog.log.connect(self.log) dialog.exec_() @pyqtSlot() def onReadSlots(self): self.read_block.emit(self.addr_start + self.code_offset, self.max_num_slots * 4 * 3) @pyqtSlot(int, int, QByteArray) def onBlockRead(self, addr_start_w_code_offset, num_bytes, raw_bytes): # Determine whether block has cache or single slot if (addr_start_w_code_offset == (self.addr_start + self.code_offset) ) and (num_bytes == self.max_num_slots * 4 * 3): self.onCacheRead(addr_start_w_code_offset, raw_bytes) elif num_bytes == 4: # Assume read slot # Ignore if no cache if not (0 <= self.cur_slot_idx < len(self.slots_cache)): return self.onSlotRead(addr_start_w_code_offset, raw_bytes) def onCacheRead(self, addr_start_w_code_offset, raw_bytes): slot_bytes = str(raw_bytes) self.slots_cache = [] slots_txt = [] for slot_i in xrange(self.max_num_slots): byte_offset = slot_i * 3 * 4 cur_slot_bytes = slot_bytes[byte_offset:(byte_offset + 4)] if len(cur_slot_bytes) != 4: continue cur_slot_val = struct.unpack('>I', cur_slot_bytes)[0] (type_val, id_val, amount) = parse_item_word(cur_slot_val) if type_val == 0 or amount == 0: continue elif type_val != self.type_val: self.log.emit( 'val(%08X)=%08X, type_val(%02X) unexpected(%02X)' % (addr_start_w_code_offset + byte_offset, cur_slot_val, type_val, self.type_val), 'red') continue else: addr_val = addr_start_w_code_offset + byte_offset - self.code_offset # remove code_offset since it may change later addr_hex = '%08X' % addr_val slot_number = slot_i + 1 self.slots_cache.append( (addr_hex, addr_val, slot_number, cur_slot_val)) slots_txt.append('Slot %03d' % slot_number) # Update UI self.log.emit( 'Found %d %s slots in memory' % (len(self.slots_cache), self.label), 'black') self.cmb_slots.clear() if len(self.slots_cache) <= 0: self.cmb_slots.setDisabled(True) self.cur_slot_idx = -1 else: self.cmb_slots.setDisabled(False) self.cmb_slots.addItems(slots_txt) self.cur_slot_idx = 0 self.updateUI() def onSlotRead(self, addr_word_w_code_offset, raw_bytes): addr_cur_slot = self.slots_cache[ self.cur_slot_idx][1] + self.code_offset if addr_word_w_code_offset == addr_cur_slot: cur_cache = self.slots_cache[self.cur_slot_idx] new_val = struct.unpack('>I', str(raw_bytes))[0] new_cache = (cur_cache[0], cur_cache[1], cur_cache[2], new_val) self.slots_cache[self.cur_slot_idx] = new_cache self.updateUI() else: # Update cached value of other slots addr_first_slot = self.slots_cache[0][1] + self.code_offset addr_last_slot = self.slots_cache[-1][1] + self.code_offset if (addr_first_slot <= addr_word_w_code_offset <= addr_last_slot) and \ ((addr_word_w_code_offset - addr_first_slot) % 12 == 0): for slot_i in xrange(len(self.slots_cache)): addr_cur_slot = self.slots_cache[slot_i][ 1] + self.code_offset if addr_word_w_code_offset == addr_cur_slot: cur_cache = self.slots_cache[slot_i] new_val = struct.unpack('>I', str(raw_bytes))[0] new_cache = (cur_cache[0], cur_cache[1], cur_cache[2], new_val) self.slots_cache[slot_i] = new_cache return @pyqtSlot() def onSearchCacheForID(self): # Stop if no cache if not (0 <= self.cur_slot_idx < len(self.slots_cache)): self.log.emit('Must cache slots before searching', 'red') return # Fetch and validate target ID try: target_id_val = int(str(self.txt_id.text()), 16) if target_id_val < 0 or target_id_val > Item.MAX_ID_VAL: self.log.emit('Item ID out of [0, 0x%03X] range' % Item.MAX_ID_VAL) return except ValueError: self.log.emit('Failed to parse item ID, expecting XXX', 'red') return # Search ID in cache for cand_slot_idx in xrange(len(self.slots_cache)): (type_val, id_val, amount) = parse_item_word(self.slots_cache[cand_slot_idx][3]) if id_val == target_id_val and type_val == self.type_val: self.cur_slot_idx = cand_slot_idx self.cmb_slots.setCurrentIndex(self.cur_slot_idx) self.updateUI() return self.log.emit( 'Did not find ID=%03X in %d cached %s slots' % (target_id_val, len(self.slots_cache), self.label), 'red') @pyqtSlot(int) def onChangeSlot(self, new_slot_idx): # Validate new_slot_idx if not (0 <= new_slot_idx < len(self.slots_cache)): return # Update slot idx and read value from memory self.cur_slot_idx = new_slot_idx self.cmb_names.lineEdit().setText(ItemEntriesFrame.MISSING_ITEM_NAME) self.cmb_names.setDisabled(True) self.txt_id.setText('') self.txt_id.setDisabled(True) self.onReadSlot() @pyqtSlot() def fetchName(self): try: id_val = int(str(self.txt_id.text()), 16) except ValueError: return name = self.MISSING_ITEM_NAME if id_val in self.id2name: name = self.id2name[id_val] self.cmb_names.lineEdit().setText(name) @pyqtSlot(int) def fetchID(self, cmb_idx): if cmb_idx < 0 or cmb_idx >= len(self.idx2id): self.txt_id.setText('') else: self.txt_id.setText(self.idx2id[cmb_idx]) @pyqtSlot() def onReadSlot(self): try: if not (0 <= self.cur_slot_idx < len(self.slots_cache)): raise ValueError('must cache slots before reading') addr_cur_slot = self.slots_cache[ self.cur_slot_idx][1] + self.code_offset self.read_block.emit(addr_cur_slot, 4) except ValueError, e: cur_slot_num = self.slots_cache[self.cur_slot_idx][2] self.log.emit( 'READ %s Slot %03d failed: %s' % (self.label, cur_slot_num, str(e)), 'red') except BaseException, e: cur_slot_num = self.slots_cache[self.cur_slot_idx][2] self.log.emit( 'READ %s Slot %03d failed: %s' % (self.label, cur_slot_num, str(e)), 'red') traceback.print_exc()
class MusicPreviewWidget(QWidget): def __init__(self, parent=None): super(MusicPreviewWidget, self).__init__(parent) self._lastbuildtime = 10.0 self._running = None self._current = None self._chooserLabel = QLabel() self._chooser = QComboBox(self, activated=self.selectDocument) self._log = log.Log() self._view = popplerview.View() self._progress = widgets.progressbar.TimedProgressBar() self._stack = QStackedLayout() self._top = QWidget() layout = QVBoxLayout() self.setLayout(layout) layout.addWidget(self._top) layout.addLayout(self._stack) layout.addWidget(self._progress) top = QHBoxLayout() top.setContentsMargins(0, 0, 0, 0) top.setSpacing(2) self._top.setLayout(top) top.addWidget(self._chooserLabel) top.addWidget(self._chooser) top.addStretch(1) self._stack.addWidget(self._log) self._stack.addWidget(self._view) self._top.hide() app.aboutToQuit.connect(self.cleanup) app.translateUI(self) def translateUI(self): self._chooserLabel.setText(_("Document:")) def preview(self, text, title=None): """Runs LilyPond on the given text and shows the resulting PDF.""" j = self._running = MusicPreviewJob(text, title) j.done.connect(self._done) self._log.clear() self._log.connectJob(j) j.start() self._progress.start(self._lastbuildtime) def _done(self, success): self._progress.stop(False) pdfs = self._running.resultfiles() self.setDocuments(pdfs) if not pdfs: self._stack.setCurrentWidget(self._log) return self._lastbuildtime = self._running.elapsed_time() self._stack.setCurrentWidget(self._view) if self._current: self._current.cleanup() self._current = self._running # keep the tempdir self._running = None def setDocuments(self, pdfs): """Loads the given PDF path names in the UI.""" self._documents = [popplertools.Document(name) for name in pdfs] self._chooser.clear() self._chooser.addItems([d.name() for d in self._documents]) self._top.setVisible(len(self._documents) > 1) if pdfs: self._chooser.setCurrentIndex(0) self.selectDocument(0) else: self._view.clear() def selectDocument(self, index): doc = self._documents[index].document() if doc: self._view.load(doc) def cleanup(self): if self._running: self._running.abort() self._running.cleanup() self._running = None if self._current: self._current.cleanup() self._current = None self._stack.setCurrentWidget(self._log) self._top.hide() self._view.clear() def print_(self): """Prints the currently displayed document.""" if self._documents: doc = self._documents[self._chooser.currentIndex()] import popplerprint popplerprint.printDocument(doc, self)
class ImportWindow(QWidget): def __init__(self, parent, doc): QWidget.__init__(self, parent, Qt.Window) self._setupUi() self.doc = doc self.model = ImportWindowModel(document=doc.model) self.swapOptionsComboBox = ComboboxModel(model=self.model.swap_type_list, view=self.swapOptionsComboBoxView) self.table = ImportTable(model=self.model.import_table, view=self.tableView) self.model.view = self self._setupColumns() # Can only be done after the model has been connected self.tabView.tabCloseRequested.connect(self.tabCloseRequested) self.tabView.currentChanged.connect(self.currentTabChanged) self.targetAccountComboBox.currentIndexChanged.connect(self.targetAccountChanged) self.importButton.clicked.connect(self.importClicked) self.swapButton.clicked.connect(self.swapClicked) def _setupUi(self): self.setWindowTitle(tr("Import")) self.resize(557, 407) self.verticalLayout = QtGui.QVBoxLayout(self) self.tabView = QTabBar(self) self.tabView.setMinimumSize(QtCore.QSize(0, 20)) self.verticalLayout.addWidget(self.tabView) self.targetAccountLayout = QtGui.QHBoxLayout() self.targetAccountLabel = QtGui.QLabel(tr("Target Account:")) self.targetAccountLayout.addWidget(self.targetAccountLabel) self.targetAccountComboBox = QComboBox(self) self.targetAccountComboBox.setMinimumSize(QtCore.QSize(150, 0)) self.targetAccountLayout.addWidget(self.targetAccountComboBox) spacerItem = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum) self.targetAccountLayout.addItem(spacerItem) self.groupBox = QGroupBox(tr("Are some fields wrong? Fix them!")) self.gridLayout = QtGui.QGridLayout(self.groupBox) self.swapOptionsComboBoxView = QComboBox(self.groupBox) self.gridLayout.addWidget(self.swapOptionsComboBoxView, 0, 0, 1, 2) self.applyToAllCheckBox = QtGui.QCheckBox(tr("Apply to all accounts")) self.gridLayout.addWidget(self.applyToAllCheckBox, 1, 0, 1, 1) self.swapButton = QPushButton(tr("Fix")) self.gridLayout.addWidget(self.swapButton, 1, 1, 1, 1) self.targetAccountLayout.addWidget(self.groupBox) self.verticalLayout.addLayout(self.targetAccountLayout) self.tableView = TableView(self) self.tableView.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers) self.tableView.setDragEnabled(True) self.tableView.setDragDropMode(QtGui.QAbstractItemView.InternalMove) self.tableView.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection) self.tableView.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows) self.tableView.horizontalHeader().setHighlightSections(False) self.tableView.horizontalHeader().setMinimumSectionSize(18) self.tableView.verticalHeader().setVisible(False) self.tableView.verticalHeader().setDefaultSectionSize(18) self.verticalLayout.addWidget(self.tableView) self.horizontalLayout = QtGui.QHBoxLayout() spacerItem1 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum) self.horizontalLayout.addItem(spacerItem1) self.importButton = QPushButton(tr("Import")) self.horizontalLayout.addWidget(self.importButton) self.verticalLayout.addLayout(self.horizontalLayout) self.tabView.setTabsClosable(True) self.tabView.setDrawBase(False) self.tabView.setDocumentMode(True) self.tabView.setUsesScrollButtons(True) def _setupColumns(self): # Can't set widget alignment in a layout in the Designer l = self.targetAccountLayout l.setAlignment(self.targetAccountLabel, Qt.AlignTop) l.setAlignment(self.targetAccountComboBox, Qt.AlignTop) #--- Event Handlers def currentTabChanged(self, index): self.model.selected_pane_index = index def importClicked(self): self.model.import_selected_pane() def swapClicked(self): applyToAll = self.applyToAllCheckBox.isChecked() self.model.perform_swap(applyToAll) def tabCloseRequested(self, index): self.model.close_pane(index) self.tabView.removeTab(index) def targetAccountChanged(self, index): self.model.selected_target_account_index = index self.table.updateColumnsVisibility() #--- model --> view def close(self): self.hide() def close_selected_tab(self): self.tabView.removeTab(self.tabView.currentIndex()) def refresh_target_accounts(self): # We disconnect the combobox because we don't want the clear() call to set the selected # target index in the model. self.targetAccountComboBox.currentIndexChanged.disconnect(self.targetAccountChanged) self.targetAccountComboBox.clear() self.targetAccountComboBox.addItems(self.model.target_account_names) self.targetAccountComboBox.currentIndexChanged.connect(self.targetAccountChanged) def refresh_tabs(self): while self.tabView.count(): self.tabView.removeTab(0) for pane in self.model.panes: self.tabView.addTab(pane.name) def set_swap_button_enabled(self, enabled): self.swapButton.setEnabled(enabled) def show(self): # For non-modal dialogs, show() is not enough to bring the window at the forefront, we have # to call raise() as well QWidget.show(self) self.raise_() def update_selected_pane(self): index = self.model.selected_pane_index if index != self.tabView.currentIndex(): # this prevents infinite loops self.tabView.setCurrentIndex(index) self.targetAccountComboBox.setCurrentIndex(self.model.selected_target_account_index) self.table.updateColumnsVisibility()
class FindInFilesDialog(QDialog): """Dialog to configure and trigger the search in the files.""" def __init__(self, result_widget, parent): super(FindInFilesDialog, self).__init__(parent) self._find_thread = FindInFilesThread() self.setWindowTitle(translations.TR_FIND_IN_FILES) self.resize(400, 300) #MAIN LAYOUT main_vbox = QVBoxLayout(self) self.pattern_line_edit = QLineEdit() self.pattern_line_edit.setPlaceholderText(translations.TR_FIND + "...") self.dir_name_root = None self.user_home = os.path.expanduser('~') self.dir_combo = QComboBox() self.dir_combo.addItem(self.user_home) self.dir_combo.setEditable(True) self.open_button = QPushButton(QIcon(":img/find"), translations.TR_OPEN) self.filters_line_edit = QLineEdit("*.py") self.filters_line_edit.setPlaceholderText("*.py") self.filters_line_edit.setCompleter( QCompleter([ "*{}".format(item) for item in settings.SUPPORTED_EXTENSIONS ])) self.replace_line = QLineEdit() self.replace_line.setEnabled(False) self.replace_line.setPlaceholderText(translations.TR_TEXT_FOR_REPLACE + "...") self.check_replace = QCheckBox(translations.TR_REPLACE) self.case_checkbox = QCheckBox(translations.TR_CASE_SENSITIVE) self.type_checkbox = QCheckBox(translations.TR_REGULAR_EXPRESSION) self.recursive_checkbox = QCheckBox(translations.TR_RECURSIVE) self.recursive_checkbox.setCheckState(Qt.Checked) self.phrase_radio = QRadioButton(translations.TR_SEARCH_BY_PHRASE) self.phrase_radio.setChecked(True) self.words_radio = QRadioButton( translations.TR_SEARCH_FOR_ALL_THE_WORDS) self.find_button = QPushButton(translations.TR_FIND + "!") self.find_button.setMaximumWidth(150) self.cancel_button = QPushButton(translations.TR_CANCEL) self.cancel_button.setMaximumWidth(150) self.result_widget = result_widget hbox = QHBoxLayout() hbox.addWidget(self.find_button) hbox.addWidget(self.cancel_button) #main section find_group_box = QGroupBox(translations.TR_MAIN) grid = QGridLayout() grid.addWidget(QLabel(translations.TR_TEXT), 0, 0) grid.addWidget(self.pattern_line_edit, 0, 1) grid.addWidget(QLabel(translations.TR_DIRECTORY), 1, 0) grid.addWidget(self.dir_combo, 1, 1) grid.addWidget(self.open_button, 1, 2) grid.addWidget(QLabel(translations.TR_FILTER), 2, 0) grid.addWidget(self.filters_line_edit, 2, 1) grid.addWidget(self.check_replace, 3, 0) grid.addWidget(self.replace_line, 3, 1) find_group_box.setLayout(grid) #add main section to MAIN LAYOUT main_vbox.addWidget(find_group_box) #options sections options_group_box = QGroupBox(translations.TR_OPTIONS) gridOptions = QGridLayout() gridOptions.addWidget(self.case_checkbox, 0, 0) gridOptions.addWidget(self.type_checkbox, 1, 0) gridOptions.addWidget(self.recursive_checkbox, 2, 0) gridOptions.addWidget(self.phrase_radio, 0, 1) gridOptions.addWidget(self.words_radio, 1, 1) options_group_box.setLayout(gridOptions) #add options sections to MAIN LAYOUT main_vbox.addWidget(options_group_box) #add buttons to MAIN LAYOUT main_vbox.addLayout(hbox) #Focus self.pattern_line_edit.setFocus() self.open_button.setFocusPolicy(Qt.NoFocus) #signal self.connect(self.open_button, SIGNAL("clicked()"), self._select_dir) self.connect(self.find_button, SIGNAL("clicked()"), self._find_in_files) self.connect(self.cancel_button, SIGNAL("clicked()"), self._kill_thread) self.connect(self._find_thread, SIGNAL("found_pattern(PyQt_PyObject)"), self._found_match) self.connect(self._find_thread, SIGNAL("finished()"), self._find_thread_finished) self.connect(self.type_checkbox, SIGNAL("stateChanged(int)"), self._change_radio_enabled) self.connect(self.check_replace, SIGNAL("stateChanged(int)"), self._replace_activated) self.connect(self.words_radio, SIGNAL("clicked(bool)"), self._words_radio_pressed) def _replace_activated(self): """If replace is activated, display the replace widgets.""" self.replace_line.setEnabled(self.check_replace.isChecked()) self.phrase_radio.setChecked(True) def _words_radio_pressed(self, value): """If search by independent words is activated, replace is not.""" self.replace_line.setEnabled(not value) self.check_replace.setChecked(not value) self.words_radio.setChecked(True) def _change_radio_enabled(self, val): """Control the state of the radio buttons.""" enabled = not self.type_checkbox.isChecked() self.phrase_radio.setEnabled(enabled) self.words_radio.setEnabled(enabled) def show(self, actual_project=None, actual=None): """Display the dialog and load the projects.""" self.dir_combo.clear() self.dir_name_root = actual_project if \ actual_project else [self.user_home] self.dir_combo.addItems(self.dir_name_root) if actual: index = self.dir_combo.findText(actual) self.dir_combo.setCurrentIndex(index) super(FindInFilesDialog, self).show() self.pattern_line_edit.setFocus() def reject(self): """Close the dialog and hide the tools dock.""" self._kill_thread() tools_dock = IDE.get_service('tools_dock') if tools_dock: tools_dock.hide() super(FindInFilesDialog, self).reject() def _find_thread_finished(self): """Wait on thread finished.""" self.emit(SIGNAL("finished()")) self._find_thread.wait() def _select_dir(self): """When a new folder is selected, add to the combo if needed.""" dir_name = QFileDialog.getExistingDirectory( self, translations.TR_OPEN, self.dir_combo.currentText(), QFileDialog.ShowDirsOnly) index = self.dir_combo.findText(dir_name) if index >= 0: self.dir_combo.setCurrentIndex(index) else: self.dir_combo.insertItem(0, dir_name) self.dir_combo.setCurrentIndex(0) def _found_match(self, result): """Update the tree for each match found.""" file_name = result[0] items = result[1] self.result_widget.update_result(self.dir_combo.currentText(), file_name, items) def _kill_thread(self): """Kill the thread.""" if self._find_thread.isRunning(): self._find_thread.cancel() self.accept() def _find_in_files(self): """Trigger the search on the files.""" self.emit(SIGNAL("findStarted()")) self._kill_thread() self.result_widget.clear() pattern = self.pattern_line_edit.text() dir_name = self.dir_combo.currentText() filters = re.split("[,;]", self.filters_line_edit.text()) #remove the spaces in the words Ex. (" *.foo"--> "*.foo") filters = [f.strip() for f in filters] case_sensitive = self.case_checkbox.isChecked() type_ = QRegExp.RegExp if \ self.type_checkbox.isChecked() else QRegExp.FixedString recursive = self.recursive_checkbox.isChecked() by_phrase = True if self.phrase_radio.isChecked() or self.type_checkbox.isChecked(): regExp = QRegExp(pattern, case_sensitive, type_) elif self.words_radio.isChecked(): by_phrase = False type_ = QRegExp.RegExp pattern = '|'.join([word.strip() for word in pattern.split()]) regExp = QRegExp(pattern, case_sensitive, type_) #save a reference to the root directory where we find self.dir_name_root = dir_name self._find_thread.find_in_files(dir_name, filters, regExp, recursive, by_phrase)
class SchemeSelector(QWidget): currentChanged = pyqtSignal() changed = pyqtSignal() def __init__(self, parent=None): super(SchemeSelector, self).__init__(parent) layout = QHBoxLayout() layout.setContentsMargins(0, 0, 0, 0) self.setLayout(layout) self.label = QLabel(_("Scheme:")) self.scheme = QComboBox() self.label.setBuddy(self.scheme) self.add = QPushButton(icons.get('list-add'), '') self.remove = QPushButton(icons.get('list-remove'), '') layout.addWidget(self.label) layout.addWidget(self.scheme) layout.addWidget(self.add) layout.addWidget(self.remove) self.scheme.currentIndexChanged.connect(self.slotSchemeChanged) self.add.clicked.connect(self.addClicked) self.remove.clicked.connect(self.removeClicked) app.translateUI(self) def translateUI(self): self.label.setText(_("Scheme:")) self.add.setText(_("New Scheme", "&New...")) self.remove.setText(_("&Remove")) def slotSchemeChanged(self, index): """Called when the Scheme combobox is changed by the user.""" self.remove.setEnabled(bool(index)) self.currentChanged.emit() self.changed.emit() def schemes(self): """Returns the list with internal names of currently available schemes.""" return self._schemes def currentScheme(self): """Returns the internal name of the currently selected scheme""" return self._schemes[self.scheme.currentIndex()] def removeClicked(self): index = self.scheme.currentIndex() if index == 0: return # default can not be removed self._schemesToRemove.add(self._schemes[index]) del self._schemes[index] del self._schemeNames[index] self.scheme.removeItem(index) def addClicked(self): name, ok = QInputDialog.getText(self, app.caption("Add Scheme"), _("Please enter a name for the new scheme:")) if not ok: return num, key = 1, 'user1' while key in self._schemes or key in self._schemesToRemove: num += 1 key = 'user{0}'.format(num) self._schemes.append(key) self._schemeNames.append(name) self.scheme.addItem(name) self.scheme.setCurrentIndex(self.scheme.count() - 1) def loadSettings(self, currentKey, namesGroup): # dont mark schemes for removal anymore self._schemesToRemove = set() s = QSettings() cur = s.value(currentKey, "default") # load the names for the shortcut schemes s.beginGroup(namesGroup) self._schemes = ["default"] self._schemeNames = [_("Default")] for key in s.childKeys(): self._schemes.append(key) self._schemeNames.append(s.value(key, key)) block = self.scheme.blockSignals(True) self.scheme.clear() self.scheme.addItems(self._schemeNames) # find out index index = self._schemes.index(cur) if cur in self._schemes else 0 self.remove.setEnabled(bool(index)) self.scheme.setCurrentIndex(index) self.scheme.blockSignals(block) self.currentChanged.emit() def saveSettings(self, currentKey, namesGroup, removePrefix=None): # first save new scheme names s = QSettings() s.beginGroup(namesGroup) for scheme, name in zip(self._schemes, self._schemeNames)[1:]: s.setValue(scheme, name) # then remove removed schemes for scheme in self._schemesToRemove: s.remove(scheme) s.endGroup() if removePrefix: for scheme in self._schemesToRemove: s.remove("{0}/{1}".format(removePrefix, scheme)) # then save current scheme = self.currentScheme() s.setValue(currentKey, scheme) # clean up self._schemesToRemove = set()
class IdeaBonus(QWidget): costChanged = pyqtSignal() def __init__(self, initialIndex=0, allowNone=True, parent=None): super().__init__(parent=parent) self.allowNone = allowNone layout = QHBoxLayout() self.bonusTypeSelect = QComboBox() if allowNone: self.bonusTypeSelect.addItems(eu4cd.ideaoptions.bonusTypes) else: self.bonusTypeSelect.addItems(eu4cd.ideaoptions.bonusTypes[1:]) layout.addWidget(self.bonusTypeSelect) self.bonusValueSelect = QComboBox() layout.addWidget(self.bonusValueSelect) self.setLayout(layout) self.bonusTypeSelect.currentIndexChanged.connect(self.resetBonusValue) self.bonusValueSelect.currentIndexChanged.connect( self.handleCostChanged) # TODO: clean this up self.resetBonusValue(0) self.setBonusTypeIndex(initialIndex) def resetBonusValue(self, selectIndex): if self.allowNone: index = selectIndex else: index = selectIndex + 1 options, self.values, self.costs = eu4cd.ideaoptions.generateOptions( index) defaultIndex = eu4cd.ideaoptions.getClosestValueIndex( self.values, eu4cd.ideaoptions.bonusNormalValues[index]) self.bonusValueSelect.clear() self.bonusValueSelect.addItems(options) self.bonusValueSelect.setCurrentIndex(defaultIndex) def getBonusTypeIndex(self): if self.allowNone: return self.bonusTypeSelect.currentIndex() else: return self.bonusTypeSelect.currentIndex() + 1 def setBonusTypeIndex(self, index): if self.allowNone: self.bonusTypeSelect.setCurrentIndex(index) else: self.bonusTypeSelect.setCurrentIndex(max(index - 1, 0)) def getType(self): return eu4cd.ideaoptions.bonusTypes[self.getBonusTypeIndex()] def getValue(self): return self.values[self.bonusValueSelect.currentIndex()] def getCost(self): return self.costs[self.bonusValueSelect.currentIndex()] def handleCostChanged(self): self.costChanged.emit()
class OWImpute(OWWidget): name = "Impute" description = "Imputes missing values in the data table." icon = "icons/Impute.svg" priority = 2130 inputs = [("Data", Orange.data.Table, "set_data"), ("Learner", Orange.classification.Learner, "set_learner")] outputs = [("Data", Orange.data.Table)] METHODS = METHODS settingsHandler = settings.DomainContextHandler() default_method = settings.Setting(1) variable_methods = settings.ContextSetting({}) autocommit = settings.Setting(True) want_main_area = False def __init__(self, parent=None): super().__init__(parent) self.modified = False box = group_box(self.tr("Default method"), layout=layout(Qt.Vertical)) self.controlArea.layout().addWidget(box) bgroup = QButtonGroup() for i, m in enumerate(self.METHODS[1:-1], 1): b = radio_button(m.name, checked=i == self.default_method, group=bgroup, group_id=i) box.layout().addWidget(b) self.defbggroup = bgroup bgroup.buttonClicked[int].connect(self.set_default_method) box = group_box(self.tr("Individual attribute settings"), layout=layout(Qt.Horizontal)) self.controlArea.layout().addWidget(box) self.varview = QtGui.QListView( selectionMode=QtGui.QListView.ExtendedSelection ) self.varview.setItemDelegate(DisplayFormatDelegate()) self.varmodel = itemmodels.VariableListModel() self.varview.setModel(self.varmodel) self.varview.selectionModel().selectionChanged.connect( self._on_var_selection_changed ) self.selection = self.varview.selectionModel() box.layout().addWidget(self.varview) method_layout = layout(Qt.Vertical, margins=0) box.layout().addLayout(method_layout) methodbox = group_box(layout=layout(Qt.Vertical)) bgroup = QButtonGroup() for i, m in enumerate(self.METHODS): b = radio_button(m.name, group=bgroup, group_id=i) methodbox.layout().addWidget(b) assert self.METHODS[-1].short == "value" self.value_stack = value_stack = QStackedLayout() self.value_combo = QComboBox(activated=self._on_value_changed) self.value_line = QLineEdit(editingFinished=self._on_value_changed) self.value_line.setValidator(QDoubleValidator()) value_stack.addWidget(self.value_combo) value_stack.addWidget(self.value_line) methodbox.layout().addLayout(value_stack) bgroup.buttonClicked[int].connect( self.set_method_for_current_selection ) reset_button = push_button("Restore all to default", clicked=self.reset_var_methods, default=False, autoDefault=False) method_layout.addWidget(methodbox) method_layout.addStretch(2) method_layout.addWidget(reset_button) self.varmethodbox = methodbox self.varbgroup = bgroup commitbox = group_box("Commit", layout=layout(margins=0)) cwidget = commit_widget( button_text="Commit", button_default=True, check_text="Commit on any change", checked=self.autocommit, clicked=self.commit ) def toggle_auto_commit(b): self.autocommit = b if self.modified: self.commit() cwidget.auto_commit_check.toggled[bool].connect(toggle_auto_commit) commitbox.layout().addWidget(cwidget) self.addAction(cwidget.commit_action) self.controlArea.layout().addWidget(commitbox) self.data = None self.learner = None def set_default_method(self, index): """ Set the current selected default imputation method. """ if self.default_method != index: self.default_method = index self.defbggroup.button(index).setChecked(True) self._invalidate() def set_data(self, data): self.closeContext() self.clear() self.data = data if data is not None: self.varmodel[:] = data.domain.variables self.openContext(data.domain) self.restore_state(self.variable_methods) itemmodels.select_row(self.varview, 0) self.commit() def set_learner(self, learner): self.learner = learner if self.data is not None and \ any(state.model.short == "model" for state in map(self.state_for_column, range(len(self.data.domain)))): self.commit() def restore_state(self, state): for i, var in enumerate(self.varmodel): key = variable_key(var) if key in state: index = self.varmodel.index(i) self.varmodel.setData(index, state[key], Qt.UserRole) def clear(self): self.varmodel[:] = [] self.variable_methods = {} self.data = None self.modified = False def state_for_column(self, column): """ #:: int -> State Return the effective imputation state for `column`. :param int column: :rtype State: """ var = self.varmodel[column] state = self.variable_methods.get(variable_key(var), None) if state is None or state.method == METHODS[0]: state = State(METHODS[self.default_method], ()) return state def imputer_for_column(self, column): state = self.state_for_column(column) data = self.data var = data.domain[column] method, params = state if method.short == "leave": return None elif method.short == "avg": return column_imputer_average(var, data) elif method.short == "model": learner = self.learner if self.learner is not None else MeanLearner() return column_imputer_by_model(var, data, learner=learner) elif method.short == "random": return column_imputer_random(var, data) elif method.short == "value": return column_imputer_defaults(var, data, float(params[0])) elif method.short == "as_value": return column_imputer_as_value(var, data) else: assert False def commit(self): if self.data is not None: states = [self.state_for_column(i) for i in range(len(self.varmodel))] # Columns to filter unknowns by dropping rows. filter_columns = [i for i, state in enumerate(states) if state.method.short == "drop"] impute_columns = [i for i, state in enumerate(states) if state.method.short not in ["drop", "leave"]] imputers = [(self.varmodel[i], self.imputer_for_column(i)) for i in impute_columns] data = self.data if imputers: table_imputer = ImputerModel(data.domain, dict(imputers)) data = table_imputer(data) if filter_columns: filter_ = data_filter.IsDefined(filter_columns) data = filter_(data) else: data = None self.send("Data", data) self.modified = False def _invalidate(self): self.modified = True if self.autocommit: self.commit() def _on_var_selection_changed(self): indexes = self.selection.selectedIndexes() vars = [self.varmodel[index.row()] for index in indexes] defstate = State(METHODS[0], ()) states = [self.variable_methods.get(variable_key(var), defstate) for var in vars] all_cont = all(isinstance(var, Orange.data.ContinuousVariable) for var in vars) states = list(unique(states)) method = None params = () state = None if len(states) == 1: state = states[0] method, params = state mindex = METHODS.index(method) self.varbgroup.button(mindex).setChecked(True) elif self.varbgroup.checkedButton() is not None: self.varbgroup.setExclusive(False) self.varbgroup.checkedButton().setChecked(False) self.varbgroup.setExclusive(True) values, enabled, stack_index = [], False, 0 value, value_index = "0.0", 0 if all_cont: enabled, stack_index = True, 1 if method is not None and method.short == "value": value = params[0] elif len(vars) == 1 and \ isinstance(vars[0], Orange.data.DiscreteVariable): values, enabled, stack_index = vars[0].values, True, 0 if method is not None and method.short == "value": try: value_index = values.index(params[0]) except IndexError: pass self.value_stack.setCurrentIndex(stack_index) self.value_stack.setEnabled(enabled) if stack_index == 0: self.value_combo.clear() self.value_combo.addItems(values) self.value_combo.setCurrentIndex(value_index) else: self.value_line.setText(value) def _on_value_changed(self): # The "fixed" value in the widget has been changed by the user. index = self.varbgroup.checkedId() self.set_method_for_current_selection(index) def set_method_for_current_selection(self, methodindex): indexes = self.selection.selectedIndexes() self.set_method_for_indexes(indexes, methodindex) def set_method_for_indexes(self, indexes, methodindex): method = METHODS[methodindex] params = (None,) if method.short == "value": if self.value_stack.currentIndex() == 0: value = self.value_combo.currentIndex() else: value = self.value_line.text() params = (value, ) elif method.short == "model": params = ("model", ) state = State(method, params) for index in indexes: self.varmodel.setData(index, state, Qt.UserRole) var = self.varmodel[index.row()] self.variable_methods[variable_key(var)] = state self._invalidate() def reset_var_methods(self): indexes = map(self.varmodel.index, range(len(self.varmodel))) self.set_method_for_indexes(indexes, 0)
class ExportPanel(QWidget): updateExportButton = pyqtSignal(str, bool) runExport = pyqtSignal(dict) def __init__(self, parent=None): QWidget.__init__(self, parent) self.setMinimumWidth(500) self.setMinimumHeight(200) self._dynamic = False self.setWindowTitle("Export data") self.activateWindow() layout = QFormLayout() current_case = getCurrentCaseName() self._case_model = AllCasesModel() self._case_combo = QComboBox() self._case_combo.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLength) self._case_combo.setMinimumContentsLength(20) self._case_combo.setModel(self._case_model) self._case_combo.setCurrentIndex(self._case_model.indexOf(current_case)) layout.addRow("Select case:", self._case_combo) self._export_keyword_model = ExportKeywordModel() self._kw_model = self._export_keyword_model.getKeyWords() self._keywords = QComboBox() self._keywords.addItems(self._kw_model) layout.addRow("Select keyword:", self._keywords) self._active_realizations_model = ActiveRealizationsModel() self._active_realizations_field = StringBox(self._active_realizations_model, "config/simulation/active_realizations") self._active_realizations_field.setValidator(RangeStringArgument()) self._active_realizations_field.getValidationSupport().validationChanged.connect(self.validateExportDialog) layout.addRow("Active realizations:", self._active_realizations_field) file_name_button = QToolButton() file_name_button.setText("Browse") file_name_button.clicked.connect(self.selectFileDirectory) self._defaultPath = QDir.currentPath() + "/export" self._file_name = QLineEdit() self._file_name.setEnabled(False) self._file_name.setText(self._defaultPath) self._file_name.textChanged.connect(self.validateExportDialog) self._file_name.setMinimumWidth(250) file_name_layout = QHBoxLayout() file_name_layout.addWidget(self._file_name) file_name_layout.addWidget(file_name_button) layout.addRow("Select directory to save files to:", file_name_layout) self._gen_kw_file_types = ["Parameter list", "Template based"] self._field_kw_file_types = ["Eclipse GRDECL", "RMS roff"] self._gen_data_file_types = ["Gen data"] self._file_type_model = self._field_kw_file_types self._file_type_combo = QComboBox() self._file_type_combo.setSizeAdjustPolicy(QComboBox.AdjustToContents) self._file_type_combo.addItems(self._file_type_model) layout.addRow("Select file format:", self._file_type_combo) self._report_step = QLineEdit() layout.addRow("Report step:", self._report_step) self._gen_data_report_step_model = [] self._gen_data_report_step = QComboBox() layout.addRow("Report step:", self._gen_data_report_step) self.setLayout(layout) self._keywords.currentIndexChanged.connect(self.keywordSelected) self.keywordSelected() def selectFileDirectory(self): directory = QFileDialog().getExistingDirectory(self, "Directory", self._file_name.text(), QFileDialog.ShowDirsOnly) if str(directory).__len__() > 0: self._file_name.setText(str(directory)) def updateFileExportType(self, keyword): self._file_type_combo.clear() if self._export_keyword_model.isGenKw(keyword): self._file_type_model = self._gen_kw_file_types elif self._export_keyword_model.isGenParamKw(keyword): self._file_type_model = self._gen_data_file_types elif self._export_keyword_model.isGenDataKw(keyword): self._file_type_model = self._gen_data_file_types else: self._file_type_model = self._field_kw_file_types self._file_type_combo.addItems(self._file_type_model) def export(self): keyword = self._kw_model[self._keywords.currentIndex()] try: report_step = self.getReportStep(keyword) except IndexError as e: QMessageBox.question(self, 'Error', e.args[0], QMessageBox.NoButton) return all_cases = self._case_model.getAllItems() selected_case = all_cases[self._case_combo.currentIndex()] path = self._file_name.text() iactive = self._active_realizations_model.getActiveRealizationsMask() file_type_key = self._file_type_model[self._file_type_combo.currentIndex()] values = {"keyword": keyword, "report_step": report_step, "iactive": iactive, "file_type_key": file_type_key, "path": path, "selected_case": selected_case} self.runExport.emit(values) def getReportStep(self, key): report_step = 0 if self._dynamic: report_step = self._report_step.text() if self._export_keyword_model.isGenParamKw(key): return report_step if self._export_keyword_model.isGenDataKw(key): lst = self._gen_data_report_step_model idx = self._gen_data_report_step.currentIndex() if lst and len(lst) > idx: report_step = lst[idx] else: raise IndexError('No such model step: %d. Valid range: [0, %d)' % (idx, len(lst))) return report_step def keywordSelected(self): key = self._kw_model[self._keywords.currentIndex()] self.updateFileExportType(key) self._dynamic = False if self._export_keyword_model.isFieldKw(key): self._dynamic = self._export_keyword_model.isDynamicField(key) self._report_step.setVisible(self._dynamic) self.layout().labelForField(self._report_step).setVisible(self._dynamic) self._gen_data_report_step.setVisible(self._export_keyword_model.isGenDataKw(key)) self.layout().labelForField(self._gen_data_report_step).setVisible(self._export_keyword_model.isGenDataKw(key)) if self._export_keyword_model.isGenDataKw(key): data = self._export_keyword_model.getGenDataReportSteps(key) self._gen_data_report_step_model = data self._gen_data_report_step.clear() self._gen_data_report_step.addItems(self._gen_data_report_step_model) def setSelectedCase(self, selected_case): self._case_combo.setCurrentIndex(self._case_model.indexOf(selected_case)) def validateExportDialog(self): validRealizations = False if self._active_realizations_field.isValid(): validRealizations = True path = str(self._file_name.text()) validPath = len(path) > 0 if validRealizations and validPath: self.updateExportButton.emit("export", True) else: self.updateExportButton.emit("export", False)
class LDSControls(QFrame): STATIC_IMG = ('error_static.png','linz_static.png','busy_static.png','clean_static.png') ANIM_IMG = ('error.gif','linz.gif','layer.gif','clean.gif') IMG_SPEED = 100 IMG_WIDTH = 64 IMG_HEIGHT = 64 MAX_WD = 450 GD_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../../bin/gdal/gdal-data')) STATUS = LU.enum('ERROR','IDLE','BUSY','CLEAN') def __init__(self,parent): super(LDSControls, self).__init__() self.parent = parent self.initConf() self.initEPSG() self.initUI() def initConf(self): '''Read files in conf dir ending in conf''' self.cflist = ConfigInitialiser.getConfFiles() #self.imgset = self.STATIC_IMG if ConfigWrapper().readDSProperty('Misc','indicator')=='static' else self.ANIM_IMG #self.imgset = self.STATIC_IMG if self.parent.confconn.tp.src.confwrap.readDSProperty('Misc','indicator')=='static' else self.ANIM_IMG sep = self.parent.confconn.reg.openEndPoint(self.parent.confconn.SRCNAME,self.parent.confconn.uconf) self.imgset = self.STATIC_IMG if sep.confwrap.readDSProperty('Misc','indicator')=='static' else self.ANIM_IMG self.parent.confconn.reg.closeEndPoint(self.parent.confconn.SRCNAME) def initEPSG(self): '''Read GDAL EPSG files, splitting by NZ(RSR) and RestOfTheWorld''' gcsf = gdal.FindFile('gdal','gcs.csv') if not gcsf: gcsf = os.path.join(self.GD_PATH,'gcs.csv') pcsf = gdal.FindFile('gdal','pcs.csv') if not pcsf: pcsf = os.path.join(self.GD_PATH,'pcs.csv') gcs = ConfigInitialiser.readCSV(gcsf) pcs = ConfigInitialiser.readCSV(pcsf) self.nzlsr = [(e[0],e[0]+' - '+e[3]) for e in gcs if 'NZGD' in e[1] or 'RSRGD' in e[1]] \ + [(e[0],e[0]+' - '+e[1]) for e in pcs if 'NZGD' in e[1] or 'RSRGD' in e[1]] self.rowsr = [(e[0],e[0]+' - '+e[3]) for e in gcs if 'NZGD' not in e[1] and 'RSRGD' not in e[1]] \ + [(e[0],e[0]+' - '+e[1]) for e in pcs if 'NZGD' not in e[1] and 'RSRGD' not in e[1]] def initUI(self): # 0 1 2 3 4 5 6 7 8 #'destname','lgselect','layer','uconf','group','epsg','fd','td','int' #self.rdest,rlgselect,self.rlayer,ruconf,self.rgroup,repsg,rfd,rtd,rint = readlist QToolTip.setFont(QFont('SansSerif', 10)) #labels destLabel = QLabel('Destination') lgLabel = QLabel('Group/Layer') epsgLabel = QLabel('EPSG') fromDateLabel = QLabel('From Date') toDateLabel = QLabel('To Date') confLabel = QLabel('User Config') self.view = QLabel() self.view.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) self.view.setAlignment(Qt.AlignCenter) self.confcombo = QComboBox(self) self.confcombo.setToolTip('Enter your user config name (file) here') self.confcombo.addItems(self.cflist) self.confcombo.setEditable(False) #self.confcombo.currentIndexChanged.connect(self.doLGEditUpdate) #combos self.lgcombo = QComboBox(self) self.lgcombo.setMaximumWidth(self.MAX_WD) self.lgcombo.setDuplicatesEnabled(False) #self.lgcombo.setInsertPolicy(QComboBox.InsertAlphabetically)#?doesnt seem to work self.lgcombo.setToolTip('Select either Layer or Group entry') self.lgcombo.setEditable(False) self.sepindex = None #self.updateLGValues() self.epsgcombo = QComboBox(self) self.epsgcombo.setMaximumWidth(self.MAX_WD) self.epsgcombo.setToolTip('Setting an EPSG number here determines the output SR of the layer') self.epsgcombo.addItems([i[1] for i in self.nzlsr]) self.epsgcombo.insertSeparator(len(self.nzlsr)) self.epsgcombo.addItems([i[1] for i in self.rowsr]) self.epsgcombo.setEditable(True) self.epsgcombo.setEnabled(False) self.destlist = self.getConfiguredDestinations() self.destcombo = QComboBox(self) self.destcombo.setToolTip('Choose the desired output type') self.destcombo.setEditable(False) self.destcombo.addItems(self.destlist) #date selection self.fromdateedit = QDateEdit() self.fromdateedit.setCalendarPopup(True) self.fromdateedit.setEnabled(False) self.todateedit = QDateEdit() self.todateedit.setCalendarPopup(True) self.todateedit.setEnabled(False) #check boxes self.epsgenable = QCheckBox() self.epsgenable.setCheckState(False) self.epsgenable.clicked.connect(self.doEPSGEnable) self.fromdateenable = QCheckBox() self.fromdateenable.setCheckState(False) self.fromdateenable.clicked.connect(self.doFromDateEnable) self.todateenable = QCheckBox() self.todateenable.setCheckState(False) self.todateenable.clicked.connect(self.doToDateEnable) self.progressbar = QProgressBar() self.progressbar.setRange(0,100) self.progressbar.setVisible(True) self.progressbar.setMinimumWidth(self.MAX_WD) #buttons self.initbutton = QPushButton("waiting") self.initbutton.setToolTip('Initialise the Layer Configuration') self.initbutton.clicked.connect(self.doInitClickAction) self.cleanbutton = QPushButton("Clean") self.cleanbutton.setToolTip('Clean the selected layer/group from local storage') self.cleanbutton.clicked.connect(self.doCleanClickAction) self.replicatebutton = QPushButton("Replicate") self.replicatebutton.setToolTip('Execute selected replication') self.replicatebutton.clicked.connect(self.doReplicateClickAction) self.cancelbutton = QPushButton("Close") self.cancelbutton.setToolTip('Close the LDS Replicate application') self.cancelbutton.clicked.connect(self.parent.close) #set dialog values using GPR self.updateGUIValues(self.parent.gvs) #set onchange here otherwise we get circular initialisation self.destcombo.currentIndexChanged.connect(self.doDestChanged) self.confcombo.currentIndexChanged.connect(self.doConfChanged) self.lgcombo.currentIndexChanged.connect(self.doLGComboChanged) self.setStatus(self.STATUS.IDLE) #grid grid = QGridLayout() grid.setSpacing(10) #placement section ------------------------------------ #---------+---------+--------+---------+-------- # dest LB | | dest DD # grp LB | | grp DD # conf LB | | conf DD # epsg L | epsg CB | epsg DD # f dt L | f dt CB | f dt DD # t td L | t td CB | t td DD # icon | <- progress -> # layer B | <- . -> |repl B | clean B | close B #---------+---------+--------+---------+-------- grid.addWidget(destLabel, 1, 0) grid.addWidget(self.destcombo, 1, 2) #grid.addWidget(layerLabel, 2, 0) grid.addWidget(lgLabel, 2, 0) grid.addWidget(self.lgcombo, 2, 2) grid.addWidget(confLabel, 3, 0) grid.addWidget(self.confcombo, 3, 2) #grid.addWidget(groupLabel, 4, 0) #grid.addWidget(self.groupEdit, 4, 2) grid.addWidget(epsgLabel, 5, 0) grid.addWidget(self.epsgenable, 5, 1) grid.addWidget(self.epsgcombo, 5, 2) grid.addWidget(fromDateLabel, 6, 0) grid.addWidget(self.fromdateenable, 6, 1) grid.addWidget(self.fromdateedit, 6, 2) grid.addWidget(toDateLabel, 7, 0) grid.addWidget(self.todateenable, 7, 1) grid.addWidget(self.todateedit, 7, 2) hbox3 = QHBoxLayout() hbox3.addWidget(self.view) hbox3.addStretch(1) hbox3.addWidget(self.progressbar) #hbox3.addLayout(vbox2) #hbox3.addLayout(vbox3) hbox4 = QHBoxLayout() hbox4.addWidget(self.initbutton) hbox4.addStretch(1) hbox4.addWidget(self.replicatebutton) hbox4.addWidget(self.cleanbutton) hbox4.addWidget(self.cancelbutton) vbox = QVBoxLayout() #vbox.addStretch(1) vbox.addLayout(grid) vbox.addLayout(hbox3) vbox.addLayout(hbox4) self.setLayout(vbox) #def setProgress(self,pct): # self.progressbar.setValue(pct) def setStatus(self,status,message='',tooltip=None): '''Sets indicator icon and statusbar message''' self.parent.statusbar.showMessage(message) self.parent.statusbar.setToolTip(tooltip if tooltip else '') #progress loc = os.path.abspath(os.path.join(IMG_LOC,self.imgset[status])) #loc = os.path.abspath(os.path.join(os.path.dirname(__file__),self.parent.IMG_LOC,self.imgset[status])) self.progressbar.setVisible(status in (self.STATUS.BUSY, self.STATUS.CLEAN)) #icon anim = QMovie(loc, QByteArray(), self) anim.setScaledSize(QSize(self.IMG_WIDTH,self.IMG_HEIGHT)) anim.setCacheMode(QMovie.CacheAll) anim.setSpeed(self.IMG_SPEED) self.view.clear() self.view.setMovie(anim) anim.start() self.view.repaint() QApplication.processEvents(QEventLoop.AllEvents) def mainWindowEnable(self,enable=True): cons = (self.lgcombo, self.confcombo, self.destcombo, self.initbutton, self.replicatebutton, self.cleanbutton, self.cancelbutton, self.epsgenable,self.fromdateenable,self.todateenable, self.parent.menubar) for c in cons: c.setEnabled(enable) if enable: self.epsgcombo.setEnabled(self.epsgenable.checkState()) self.fromdateedit.setEnabled(self.fromdateenable.checkState()) self.todateedit.setEnabled(self.todateenable.checkState()) else: self.epsgcombo.setEnabled(False) self.fromdateedit.setEnabled(False) self.todateedit.setEnabled(False) QApplication.restoreOverrideCursor() if enable else QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) def refreshLGCombo(self): '''Re index LG combobox since a refreshLG call (new dest?) will usually mean new groups''' self.lgcombo.clear() self.lgcombo.addItems([i[2] for i in self.parent.confconn.lglist]) #NOTE the separator consumes an index, if not clearing the combobox selectively remove the old sepindex (assumes g preceeds l) #if self.sepindex: # self.lgcombo.removeItem(self.sepindex) self.sepindex = [i[0] for i in self.parent.confconn.lglist].count(LORG.GROUP) self.lgcombo.insertSeparator(self.sepindex) def updateLGValues(self,uconf,lgval,dest): '''Sets the values displayed in the Layer/Group combo''' #because we cant seem to sort combobox entries and want groups at the top, clear and re-add #TRACE# #pdb.set_trace() sf = None try: self.parent.confconn.initConnections(uconf,lgval,dest) except Exception as e: sf=1 ldslog.error('Error Updating UC Values. '+str(e)) if sf: self.setStatus(self.STATUS.ERROR,'Error Updating UC Values', str(e)) else: self.setStatus(self.STATUS.IDLE) self.refreshLGCombo() def centre(self): qr = self.frameGeometry() cp = QDesktopWidget().availableGeometry().center() qr.moveCenter(cp) self.move(qr.topLeft()) def gprParameters(self,rdest): '''Zip default and GPR values''' return [x if LU.assessNone(x) else y for x,y in zip(self.parent.gpr.readsec(rdest),self.parent.DEF_RVALS[1:])] def getLCE(self,ln): '''Read layer parameters''' dep = self.parent.confconn.reg.openEndPoint(self.parent.confconn.destname,self.parent.confconn.uconf) #sep = self.parent.confconn.reg.openEndPoint('WFS',self.parent.confconn.uconf) self.parent.confconn.reg.setupLayerConfig(self.parent.confconn.tp,None,dep,initlc=False) lce = dep.getLayerConf().readLayerParameters(ln) #self.parent.confconn.reg.closeEndPoint('WFS') self.parent.confconn.reg.closeEndPoint(self.parent.confconn.destname) sep,dep = None,None return lce def doDestChanged(self): '''Read the destname parameter and fill dialog with matching GPR values''' rdest = str(self.destlist[self.destcombo.currentIndex()]) rvals = self.gprParameters(rdest) self.updateGUIValues([rdest]+rvals) def doConfChanged(self): '''Read the user conf parameter and fill dialog with matching GPR values''' rdest = str(self.destlist[self.destcombo.currentIndex()]) rlg,_,rep,rfd,rtd = self.gprParameters(rdest) ruc = str(self.cflist[self.confcombo.currentIndex()]) self.updateGUIValues((rdest,rlg,ruc,rep,rfd,rtd)) def doLGComboChanged(self): '''Read the layer/group value and change epsg to layer or gpr match''' #get a matching LG entry and test whether its a layer or group #lgi = self.parent.confconn.getLayerGroupIndex(self.lgcombo.currentText().toUtf8().data()) lgi = self.parent.confconn.getLayerGroupIndex(LQ.readWidgetText(self.lgcombo.currentText())) #lgi can be none if we init a new group, in which case we use the GPR value if lgi: lge = self.parent.confconn.lglist[lgi] lce = self.getLCE(lge[1]) if lge[0]==LORG.LAYER else None else: lce = None #look for filled layer conf epsg OR use prefs stored in gpr if lce and LU.assessNone(lce.epsg): epsgval = lce.epsg else: rdest = str(self.destlist[self.destcombo.currentIndex()]) _,_,epsgval,_,_ = self.gprParameters(rdest) epsgindex = [i[0] for i in self.nzlsr+[(0,0)]+self.rowsr].index(epsgval) if self.epsgcombo.currentIndex() != epsgindex: self.epsgcombo.setCurrentIndex(int(epsgindex)) def updateGUIValues(self,readlist): '''Fill dialog values from provided list''' #TODO. Remove circular references when setCurrentIndex() triggers do###Changed() #Read user input rdest,self.rlgval,ruconf,repsg,rfd,rtd = readlist #-------------------------------------------------------------------- #Destination Menu selecteddest = LU.standardiseDriverNames(rdest) if selecteddest not in self.destlist: self.destlist = self.getConfiguredDestinations() self.destcombo.addItem(selecteddest) destindex = self.destlist.index(selecteddest) if selecteddest else 0 if self.destcombo.currentIndex() != destindex: self.destcombo.setCurrentIndex(destindex) #InitButton self.initbutton.setText('Layer Select') #Config File confindex = 0 if LU.assessNone(ruconf): ruconf = ruconf.split('.')[0] if ruconf not in self.cflist: self.cflist += [ruconf,] self.confcombo.addItem(ruconf) confindex = self.cflist.index(ruconf) if self.confcombo.currentIndex() != confindex: self.confcombo.setCurrentIndex(confindex) #self.confEdit.setText(ruconf if LU.assessNone(ruconf) else '') #Layer/Group Selection self.updateLGValues(ruconf,self.rlgval,rdest) lgindex = None if LU.assessNone(self.rlgval): #index of list value lgindex = self.parent.confconn.getLayerGroupIndex(self.rlgval,col=1) if LU.assessNone(lgindex): #advance by 1 for sep lgindex += 1 if lgindex>self.sepindex else 0 else: #using the separator index sets the combo to blank lgindex = self.sepindex if self.lgcombo.currentIndex() != lgindex: self.lgcombo.setCurrentIndex(lgindex) #self.doLGEditUpdate() #EPSG # user > layerconf #useepsg = LU.precedence(repsg, lce.epsg if lce else None, None) epsgindex = [i[0] for i in self.nzlsr+[(None,None)]+self.rowsr].index(repsg) if self.epsgcombo.currentIndex() != epsgindex: self.epsgcombo.setCurrentIndex(epsgindex) #epsgedit = self.epsgcombo.lineEdit() #epsgedit.setText([e[1] for e in self.nzlsr+self.rowsr if e[0]==repsg][0]) #epsgedit.setText([e for e in self.nzlsr+self.rowsr if re.match('^\s*(\d+).*',e).group(1)==repsg][0]) #To/From Dates if LU.assessNone(rfd): self.fromdateedit.setDate(QDate(int(rfd[0:4]),int(rfd[5:7]),int(rfd[8:10]))) else: early = DataStore.EARLIEST_INIT_DATE self.fromdateedit.setDate(QDate(int(early[0:4]),int(early[5:7]),int(early[8:10]))) if LU.assessNone(rtd): self.todateedit.setDate(QDate(int(rtd[0:4]),int(rtd[5:7]),int(rtd[8:10]))) else: today = DataStore.getCurrent() self.todateedit.setDate(QDate(int(today[0:4]),int(today[5:7]),int(today[8:10]))) #Internal/External CheckBox # if LU.assessNone(rint): # self.internalTrigger.setChecked(rint.lower()==DataStore.CONF_INT) # else: # self.internalTrigger.setChecked(DataStore.DEFAULT_CONF==DataStore.CONF_INT) def getConfiguredDestinations(self): defml = ['',]+DataStore.DRIVER_NAMES.values() return [d for d in self.parent.gpr.getDestinations() if d in defml] def doEPSGEnable(self): self.epsgcombo.setEnabled(self.epsgenable.isChecked()) def doFromDateEnable(self): self.fromdateedit.setEnabled(self.fromdateenable.isChecked()) def doToDateEnable(self): self.todateedit.setEnabled(self.todateenable.isChecked()) def readParameters(self): '''Read values out of dialogs''' destination = LU.assessNone(str(self.destlist[self.destcombo.currentIndex()])) #lgindex = self.parent.confconn.getLayerGroupIndex(self.lgcombo.currentText().toUtf8().data()) lgindex = self.parent.confconn.getLayerGroupIndex(LQ.readWidgetText(self.lgcombo.currentText())) #NB need to test for None explicitly since zero is a valid index lgval = self.parent.confconn.lglist[lgindex][1] if LU.assessNone(lgindex) else None #uconf = LU.standardiseUserConfigName(str(self.confcombo.lineEdit().text())) #uconf = str(self.confcombo.lineEdit().text()) uconf = str(self.cflist[self.confcombo.currentIndex()]) ee = self.epsgenable.isChecked() epsg = None if ee is False else re.match('^\s*(\d+).*',str(self.epsgcombo.lineEdit().text())).group(1) fe = self.fromdateenable.isChecked() te = self.todateenable.isChecked() fd = None if fe is False else str(self.fromdateedit.date().toString('yyyy-MM-dd')) td = None if te is False else str(self.todateedit.date().toString('yyyy-MM-dd')) return destination,lgval,uconf,epsg,fe,te,fd,td def doInitClickAction(self): '''Initialise the LC on LC-button-click, action''' try: try: self.setStatus(self.STATUS.BUSY,'Opening Layer-Config Editor') self.progressbar.setValue(0) self.parent.runLayerConfigAction() finally: self.setStatus(self.STATUS.IDLE,'Ready') except Exception as e: self.setStatus(self.STATUS.ERROR,'Error in Layer-Config',str(sys.exc_info()))#e)) def doCleanClickAction(self): '''Set clean anim and run clean''' #lgo = self.lgcombo.currentText().toUtf8().data() lgo = LQ.readWidgetText(self.lgcombo.currentText()) try: self.setStatus(self.STATUS.CLEAN,'Running Clean '+lgo) self.progressbar.setValue(0) self.runReplicationScript(True) except Exception as e: self.setStatus(self.STATUS.ERROR,'Failed Clean of '+lgo,str(sys.exc_info()))#e)) def doReplicateClickAction(self): '''Set busy anim and run repl''' lgo = self.lgcombo.currentText()#.toUtf8().data()#only used for error messages try: self.setStatus(self.STATUS.BUSY,'Running Replicate '+lgo) self.progressbar.setValue(0) self.runReplicationScript(False) except Exception as e: self.setStatus(self.STATUS.ERROR,'Failed Replication of '+lgo,str(sys.exc_info()))#e)) def runReplicationScript(self,clean=False): '''Run the layer/group repliction script''' destination,lgval,uconf,epsg,fe,te,fd,td = self.readParameters() uconf_path = LU.standardiseUserConfigName(uconf) destination_path = LU.standardiseLayerConfigName(destination) destination_driver = LU.standardiseDriverNames(destination) if not os.path.exists(uconf_path): self.userConfMessage(uconf_path) return elif not MainFileReader(uconf_path).hasSection(destination_driver): self.userConfMessage(uconf_path,destination_driver) return #----------------------------------------------------- #'destname','layer','uconf','group','epsg','fd','td','int' self.parent.gpr.write((destination_driver,lgval,uconf,epsg,fd,td)) ldslog.info(u'dest={0}, lg={1}, conf={2}, epsg={3}'.format(destination_driver,lgval,uconf,epsg)) ldslog.info('fd={0}, td={1}, fe={2}, te={3}'.format(fd,td,fe,te)) lgindex = self.parent.confconn.getLayerGroupIndex(lgval,col=1) #lorg = self.parent.confconn.lglist[lgindex][0] #----------don't need lorg in TP anymore but it is useful for sorting/counting groups #self.parent.confconn.tp.setLayerOrGroup(lorg) self.parent.confconn.tp.setLayerGroupValue(lgval) if self.fromdateenable.isChecked(): self.parent.confconn.tp.setFromDate(fd) if self.todateenable.isChecked(): self.parent.confconn.tp.setToDate(td) self.parent.confconn.tp.setUserConf(uconf) if self.epsgenable: self.parent.confconn.tp.setEPSG(epsg) #because clean state persists in TP if clean: self.parent.confconn.tp.setCleanConfig() else: self.parent.confconn.tp.clearCleanConfig() #(re)initialise the data source since uconf may have changed #>>#self.parent.confconn.tp.src = self.parent.confconn.initSourceWrapper() #-------------------------- ###ep = self.parent.confconn.reg.openEndPoint(self.parent.confconn.destname,self.parent.confconn.uconf) ###self.parent.confconn.reg.closeEndPoint(self.parent.confconn.destname) ###ep = None #Open ProcessRunner and run with TP(proc)/self(gui) instances #HACK temp add of dest_drv to PR call try: #TODO. Test for valid LC first self.tpr = ProcessRunner(self,destination_driver) except Exception as e: ldslog.error('Cannot create ProcessRunner {}. NB Possible missing Layer Config {}'.format(str(e),destination_path)) self.layerConfMessage(destination_path) return #If PR has been successfully created we must vave a valid dst self.tpr.start() def quitProcessRunner(self): self.tpr.join() self.tpr.quit() self.trp = None def userConfMessage(self,uconf,secname=None): ucans = QMessageBox.warning(self, 'User Config Missing/Incomplete', 'Specified User-Config file, '+str(uconf)+' does not exist' if secname is None else 'User-Config file does not contain '+str(secname)+' section', 'Back','Initialise User Config') if not ucans: #Retry ldslog.warn('Retry specifying UC') #self.confcombo.setCurrentIndex(0) return #Init ldslog.warn('Reset User Config Wizard') self.parent.runWizardAction() def layerConfMessage(self,dest): lcans = QMessageBox.warning(self, 'Layer Config Missing', 'Required Layer-Config file, '+str(dest)+' does not exist', 'Back','Run Layer Select') if not lcans: #Retry ldslog.warn('Retry specifying LC') #self.destcombo.setCurrentIndex(0) return #Init ldslog.warn('Reset Layer Config') self.doInitClickAction()
class RunsDialog(QtHelper.EnhancedQDialog): """ Runs several dialog """ RefreshRepository = pyqtSignal(str) def __init__(self, dialogName, parent = None, iRepo=None, lRepo=None, rRepo=None): """ Constructor """ QtHelper.EnhancedQDialog.__init__(self, parent) self.name = self.tr("Prepare a group of runs") self.projectReady = False self.iRepo = iRepo self.lRepo = lRepo self.rRepo = rRepo self.createDialog() self.createConnections() def createDialog(self): """ Create qt dialog """ self.setWindowTitle( self.name ) mainLayout = QHBoxLayout() layoutTests = QHBoxLayout() layoutRepoTest = QVBoxLayout() self.prjCombo = QComboBox(self) self.prjCombo.setEnabled(False) self.repoTests = QTreeWidget(self) self.repoTests.setFrameShape(QFrame.NoFrame) if USE_PYQT5: self.repoTests.header().setSectionResizeMode(QHeaderView.Stretch) else: self.repoTests.header().setResizeMode(QHeaderView.Stretch) self.repoTests.setHeaderHidden(True) self.repoTests.setContextMenuPolicy(Qt.CustomContextMenu) self.repoTests.setIndentation(10) layoutRepoTest.addWidget(self.prjCombo) layoutRepoTest.addWidget(self.repoTests) self.testsList = QListWidget(self) layoutTests.addLayout( layoutRepoTest ) layoutTests.addWidget( self.testsList ) mainLayout.addLayout( layoutTests ) buttonLayout = QVBoxLayout() self.okButton = QPushButton(self.tr("Execute All"), self) self.okButton.setEnabled(False) self.cancelButton = QPushButton(self.tr("Cancel"), self) self.upButton = QPushButton(self.tr("UP"), self) self.upButton.setEnabled(False) self.downButton = QPushButton(self.tr("DOWN"), self) self.downButton.setEnabled(False) self.clearButton = QPushButton(self.tr("Remove All"), self) self.delButton = QPushButton(self.tr("Remove"), self) self.delButton.setEnabled(False) self.runSimultaneous = QCheckBox(self.tr("Simultaneous Run")) self.schedImmed = QRadioButton(self.tr("Run Immediately")) self.schedImmed.setChecked(True) self.schedAt = QRadioButton(self.tr("Run At:")) self.schedAtDateTimeEdit = QDateTimeEdit(QDateTime.currentDateTime()) self.schedAtDateTimeEdit.setEnabled(False) buttonLayout.addWidget(self.okButton) buttonLayout.addWidget(self.runSimultaneous) buttonLayout.addWidget(self.schedImmed) buttonLayout.addWidget(self.schedAt) buttonLayout.addWidget(self.schedAtDateTimeEdit) buttonLayout.addWidget( self.upButton ) buttonLayout.addWidget( self.downButton ) buttonLayout.addWidget( self.delButton ) buttonLayout.addWidget( self.clearButton ) buttonLayout.addWidget(self.cancelButton) mainLayout.addLayout(buttonLayout) self.setMinimumHeight(400) self.setMinimumWidth(750) self.setLayout(mainLayout) def initProjects(self, projects=[], defaultProject=1): """ Initialize projects """ # init date and time self.schedAtDateTimeEdit.setDateTime(QDateTime.currentDateTime()) self.projectReady = False self.repoTests.clear() self.prjCombo.clear() self.testsList.clear() self.prjCombo.setEnabled(True) # insert data pname = '' for p in projects: self.prjCombo.addItem ( p['name'] ) if defaultProject == p['project_id']: pname = p['name'] for i in xrange(self.prjCombo.count()): item_text = self.prjCombo.itemText(i) if str(pname) == str(item_text): self.prjCombo.setCurrentIndex(i) self.projectReady = True self.RefreshRepository.emit(pname) def initializeTests(self, listing): """ Initialize tests """ self.repoTests.clear() self.testRoot = self.rRepo.Item(repo = self.iRepo.remote(), parent = self.repoTests, txt = "Root", type = QTreeWidgetItem.UserType+10, isRoot = True ) self.testRoot.setSelected(True) self.createRepository(listing=listing, parent=self.testRoot,fileincluded=True) self.repoTests.sortItems(0, Qt.AscendingOrder) self.hideItems(hideTsx=False, hideTpx=False, hideTcx=True, hideTdx=True, hideTxt=True, hidePy=True, hideTux=False, hidePng=True, hideTgx=False, hideTax=False) def createRepository(self, listing, parent, fileincluded=True): """ Create repository @param listing: @type listing: list @param parent: @type parent: @param fileincluded: @type fileincluded: boolean """ try: for dct in listing: if dct["type"] == "folder": item = self.rRepo.Item(repo = self.iRepo.remote(), parent = parent, txt = dct["name"], propertiesFile=dct ) self.createRepository( dct["content"] , item, fileincluded ) else: if fileincluded: if dct["type"] == "file": pname = self.iRepo.remote().getProjectName(dct["project"]) # {'modification': 1342259500, 'type': 'file', 'name': '__init__.py', 'size': '562 } item = self.rRepo.Item(repo = self.iRepo.remote(), parent = parent, txt = dct["name"] , propertiesFile=dct, type = QTreeWidgetItem.UserType+0, projectId=dct["project"], projectName=pname ) except Exception as e: self.error( "unable to create tree for runs: %s" % e ) def onProjectChanged(self, projectItem): """ Called when the project changed on the combo box """ if self.projectReady: item_text = self.prjCombo.itemText(projectItem) self.RefreshRepository.emit(item_text) def createConnections (self): """ create qt connections * ok * cancel """ self.prjCombo.currentIndexChanged.connect(self.onProjectChanged) self.okButton.clicked.connect( self.acceptClicked ) self.cancelButton.clicked.connect( self.reject ) self.upButton.clicked.connect(self.upTest) self.downButton.clicked.connect(self.downTest) self.clearButton.clicked.connect(self.clearList) self.delButton.clicked.connect(self.delTest) self.testsList.itemClicked.connect(self.onItemSelected) self.testsList.itemSelectionChanged.connect(self.onItemSelectionChanged) self.schedAt.toggled.connect(self.onSchedAtActivated) self.repoTests.itemDoubleClicked.connect( self.onTestDoucleClicked ) def onSchedAtActivated(self, toggled): """ On sched at button activated """ if toggled: self.schedAtDateTimeEdit.setEnabled(True) else: self.schedAtDateTimeEdit.setEnabled(False) def onItemSelectionChanged(self): """ Called on item selection changed """ self.onItemSelected(itm=None) def onItemSelected(self, itm): """ Call on item selected """ selectedItems = self.testsList.selectedItems() if len(selectedItems): self.delButton.setEnabled(True) self.upButton.setEnabled(True) self.downButton.setEnabled(True) else: self.delButton.setEnabled(False) self.upButton.setEnabled(False) self.downButton.setEnabled(False) if not self.testsList.count(): self.okButton.setEnabled(False) def upTest(self): """ Up test """ currentRow = self.testsList.currentRow() currentItem = self.testsList.takeItem(currentRow) self.testsList.insertItem(currentRow - 1, currentItem) def downTest(self): """ Down test """ currentRow = self.testsList.currentRow() currentItem = self.testsList.takeItem(currentRow) self.testsList.insertItem(currentRow + 1, currentItem) def delTest(self): """ Del test """ currentRow = self.testsList.currentRow() currentItem = self.testsList.takeItem(currentRow) def clearList(self): """ Clear test """ self.testsList.clear() self.delButton.setEnabled(False) self.upButton.setEnabled(False) self.downButton.setEnabled(False) self.okButton.setEnabled(False) def iterateTree(self, item, hideTsx, hideTpx, hideTcx, hideTdx, hideTxt, hidePy, hideTux, hidePng, hideTgx, hideTax): """ Iterate tree """ child_count = item.childCount() for i in range(child_count): subitem = item.child(i) subchild_count = subitem.childCount() if subchild_count > 0: self.iterateTree(item=subitem, hideTsx=hideTsx, hideTpx=hideTpx, hideTcx=hideTcx, hideTdx=hideTdx, hideTxt=hideTxt, hidePy=hidePy, hideTux=hideTux, hidePng=hidePng, hideTgx=hideTgx, hideTax=hideTax) else: if hideTux and subitem.getExtension() == self.rRepo.EXTENSION_TUX: subitem.setHidden (True) elif hideTpx and subitem.getExtension() == self.rRepo.EXTENSION_TPX: subitem.setHidden (True) elif hideTgx and subitem.getExtension() == self.rRepo.EXTENSION_TGX: subitem.setHidden (True) elif hideTcx and subitem.getExtension() == self.rRepo.EXTENSION_TCX: subitem.setHidden (True) elif hideTsx and subitem.getExtension() == self.rRepo.EXTENSION_TSX: subitem.setHidden (True) elif hideTdx and subitem.getExtension() == self.rRepo.EXTENSION_TDX: subitem.setHidden (True) elif hideTxt and subitem.getExtension() == self.rRepo.EXTENSION_TXT: subitem.setHidden (True) elif hidePy and subitem.getExtension() == self.rRepo.EXTENSION_PY: subitem.setHidden (True) elif hidePng and subitem.getExtension() == self.rRepo.EXTENSION_PNG: subitem.setHidden (True) elif hideTax and subitem.getExtension() == self.rRepo.EXTENSION_TAx: subitem.setHidden (True) else: subitem.setHidden(False) def hideItems(self, hideTsx=False, hideTpx=False, hideTcx=False, hideTdx=False, hideTxt=False, hidePy=False, hideTux=False, hidePng=False, hideTgx=False, hideTax=False): """ Hide items """ root = self.repoTests.invisibleRootItem() self.iterateTree(item=root, hideTsx=hideTsx, hideTpx=hideTpx, hideTcx=hideTcx, hideTdx=hideTdx, hideTxt=hideTxt, hidePy=hidePy, hideTux=hideTux, hidePng=hidePng, hideTgx=hideTgx, hideTax=hideTax) def onTestDoucleClicked(self, testItem): """ On tests double clicked """ if testItem.type() != QTreeWidgetItem.UserType+0: return self.okButton.setEnabled(True) currentProject = self.prjCombo.currentText() testName = "%s:%s" % (str(currentProject),testItem.getPath(withFileName = True)) testItem = QListWidgetItem(testName ) if testName.endswith(self.rRepo.EXTENSION_TUX): testItem.setIcon(QIcon(":/tux.png")) if testName.endswith(self.rRepo.EXTENSION_TSX): testItem.setIcon(QIcon(":/tsx.png")) if testName.endswith(self.rRepo.EXTENSION_TPX): testItem.setIcon(QIcon(":/tpx.png")) if testName.endswith(self.rRepo.EXTENSION_TGX): testItem.setIcon(QIcon(":/tgx.png")) if testName.endswith(self.rRepo.EXTENSION_TAX): testItem.setIcon(QIcon(":/tax.png")) self.testsList.addItem( testItem ) def acceptClicked (self): """ Called on accept button """ self.accept() def getTests(self): """ Returns all tests in the list """ tests = [] for i in xrange(self.testsList.count()): testItem = self.testsList.item(i) tests.append( str(testItem.text()) ) runSimultaneous = False if self.runSimultaneous.isChecked(): runSimultaneous = True if self.schedImmed.isChecked(): runAt = (0,0,0,0,0,0) return (tests, False, runAt, runSimultaneous) else: pydt = self.schedAtDateTimeEdit.dateTime().toPyDateTime() runAt = (pydt.year, pydt.month, pydt.day, pydt.hour, pydt.minute, pydt.second) return (tests, True, runAt, runSimultaneous)
class Mplayer(QDialog): REVENIR, PAS_PRECEDENT_SUIVANT, PRECEDENT_SUIVANT, CURSEUR_SUR_UNE_LIGNE,\ CURSEUR_A_PART, PARCOURIR, PAS_PARCOURIR, LIST, RATIO = range(9) HAUTEUR, LARGEUR = range(2) def __init__(self, cheminVideo=[], taille=(250,225), choixWidget=(RATIO, REVENIR, PAS_PRECEDENT_SUIVANT,CURSEUR_SUR_UNE_LIGNE,PAS_PARCOURIR,LIST), debutFin=(0,0), cheminMPlayer=None, barreTaches=None, facteurLimitant=HAUTEUR, cheminParcourir=None, parent=None): """widget mplayer""" QDialog.__init__(self, parent) #=== Paramètres généraux ===# self.setAttribute(Qt.WA_DeleteOnClose) self.setWindowTitle(_(u"Player vidéo")) #On réduit la marge pour gagner de l'espace self.setContentsMargins(0,0,0,0) self.systeme = os.name ### Quand EKD windows est installé, le chemin des dépendances sont ########### ### positionnées dans les variables d'environnement donc pas besoin de ####### ### collecter le chemin des ces dépendances ################################## self.cheminMPlayer = "mplayer" ############################################################################## # liste de chemins vidéos if type(cheminVideo) != list : self.listeVideos=[cheminVideo] else : self.listeVideos = cheminVideo # est-ce que la vidéo est lue? self.estLue=False # est-ce que la vidéo est en pause? self.estEnPause=False self.debutFin = debutFin # Nom du fichier courant (le self n'est pas encore utile) txtParDefaut = u"Pas de fichier lu" if self.listeVideos.__len__()!=0: self.fichierCourant = [txtParDefaut, self.listeVideos[0]] else: self.fichierCourant = [txtParDefaut, ""] # Barre des tâches de la fenêtre self.barreTaches = barreTaches # Taille de la vidéo self.tailleLargeur=taille[0] self.tailleHauteur=taille[1] # paramètres des boutons-icones iconTaille=22 flat=1 # Pour récupérer le temps courant depuis certains cadre self.temps = 0 self.dureeTimer = 10 # temps en ms ############################################################################################################################### #Pour être plus précis lors de la lecture, on prend comme unité la miliseconde. ###################### ## Il faut donc utiliser une echelle 1000 fois plus grande pour les unités du slider self.echelle=1000 ############################################################################################################################### # Permet de récupérer la durée de la vidéo depuis une instance de la classe # Sert dans certains cadres self.dureeVideo = 0 # Chemin sur lequel peut s'ouvrir la boite de dialogue de fichier # associée au bouton parcourir self.cheminPourBoutonParcourir = cheminParcourir self.taille = taille debug("self.taille avant lecture : %s %s" % (self.taille, type(self.taille))) #=== Widgets ===# self.icone_lire=QIcon("Icones" + os.sep + "player_play.png") self.icone_pause=QIcon("Icones" + os.sep + "player_pause.png") self.icone_arret=QIcon("Icones" + os.sep + "player_stop.png") if Mplayer.REVENIR in choixWidget: self.bout_revenir = QPushButton(u"Revenir") self.bout_revenir.setIcon(QIcon("Icones" + os.sep + "revenir.png")) if Mplayer.PARCOURIR in choixWidget: self.bout_ouvVideo = QPushButton(u"Parcourir...") if Mplayer.PRECEDENT_SUIVANT in choixWidget: self.bout_prec = QPushButton(QIcon("Icones" + os.sep + "player_rew.png"),"") self.bout_prec.setIconSize(QSize(iconTaille, iconTaille)) self.bout_prec.setFlat(flat) self.bout_suivant = QPushButton(QIcon("Icones" + os.sep + "player_fwd.png"),"") self.bout_suivant.setIconSize(QSize(iconTaille, iconTaille)) self.bout_suivant.setFlat(flat) self.LISTW=False if Mplayer.LIST in choixWidget : self.LISTW = True self.listFichiers = QComboBox() self.listFichiers.hide() self.setListeVideo() self.bout_LectPause = QPushButton(self.icone_lire,"") self.bout_LectPause.setIconSize(QSize(iconTaille, iconTaille)) self.bout_LectPause.setFlat(flat) self.bout_Arret = QPushButton(self.icone_arret,"") self.bout_Arret.setIconSize(QSize(iconTaille, iconTaille)) self.bout_Arret.setFlat(flat) # widget qui contiendra la vidéo self.cibleVideo = DisplayVid(self) # par défaut le widget-cible est noir color = QColor(0, 0, 0) self.cibleVideo.setAutoFillBackground(True) self.cibleVideo.setPalette(QPalette(color)) self.cibleVideo.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) self.cibleVideo.setFixedHeight(self.taille[1]) self.cibleVideo.setToolTip(self.fichierCourant[0]) #Choix de l'aspect ratio de la vidéo if Mplayer.RATIO in choixWidget : self.conf = QGroupBox() self.conf.setContentsMargins(0,0,0,0) self.conf.setMinimumSize(QSize(self.tailleLargeur, 0)) self.conf.setObjectName("conf") self.verticalLayout = QHBoxLayout(self.conf) self.verticalLayout.setObjectName("verticalLayout") self.choicenorm = QRadioButton(self.conf) self.choicenorm.setObjectName("choicenorm") self.verticalLayout.addWidget(self.choicenorm) self.choicewide = QRadioButton(self.conf) self.choicewide.setObjectName("choicewide") self.verticalLayout.addWidget(self.choicewide) self.choiceone = QRadioButton(self.conf) self.choiceone.setObjectName("choiceone") self.verticalLayout.addWidget(self.choiceone) self.choicenorm.setText("4:3") self.choicewide.setText("16:9") self.choiceone.setText("w:h") # Checked le ratio de la vidéo if self.listeVideos.__len__()!=0: self.changeRatio(self.listeVideos[0]) else : self.setRatio(4.0/3.0) if Mplayer.RATIO in choixWidget : self.choicenorm.setChecked(True) self.slider = QSlider(Qt.Horizontal) self.slider.setEnabled(True) self.mplayerProcess = QProcess(self) self.timer = QTimer(self) self.tempsChrono = TracerChrono() #=== mise-en-page/plan ===# mhbox = QHBoxLayout() vbox = QVBoxLayout() vbox.addWidget(self.cibleVideo) if Mplayer.RATIO in choixWidget : vbox.addWidget(self.conf) hbox = QHBoxLayout() if Mplayer.REVENIR in choixWidget: hbox.addWidget(self.bout_revenir) if Mplayer.PARCOURIR in choixWidget: hbox.addWidget(self.bout_ouvVideo) hbox.addWidget(self.bout_LectPause) hbox.addWidget(self.bout_Arret) if Mplayer.PRECEDENT_SUIVANT in choixWidget: hbox.addWidget(self.bout_prec) hbox.addWidget(self.bout_suivant) hbox.addWidget(self.tempsChrono) if Mplayer.CURSEUR_A_PART not in choixWidget: hbox.addWidget(self.slider) vbox.addLayout(hbox) if Mplayer.CURSEUR_A_PART in choixWidget: hbox.setAlignment(Qt.AlignLeft) hbox = QHBoxLayout() hbox.addWidget(self.slider) vbox.addLayout(hbox) # Liste fichier dans combobox if self.LISTW : hbox = QHBoxLayout() hbox.addWidget(self.listFichiers) vbox.addLayout(hbox) mhbox.addLayout(vbox) self.setLayout(mhbox) #=== connexion des widgets à des fonctions ===# if Mplayer.REVENIR in choixWidget: self.connect(self.bout_revenir, SIGNAL('clicked()'), SLOT('close()')) if Mplayer.PARCOURIR in choixWidget: self.connect(self.bout_ouvVideo, SIGNAL('clicked()'), self.ouvrirVideo) if Mplayer.PRECEDENT_SUIVANT in choixWidget: self.connect(self.bout_prec, SIGNAL('clicked()'), self.precedent) self.connect(self.bout_suivant, SIGNAL('clicked()'), self.suivant) #Ajouté le 08/11/2009 - Liste des fichiers dans une combobox if self.LISTW : self.connect(self.listFichiers, SIGNAL('currentIndexChanged(int)'), self.changeVideo) self.connect(self.bout_LectPause, SIGNAL('clicked()'), self.lectPause) self.connect(self.bout_Arret, SIGNAL('clicked()'), self.arretMPlayer) self.connect(self.mplayerProcess, SIGNAL('readyReadStandardOutput()'), self.recupSortie) self.connect(self.mplayerProcess, SIGNAL('finished(int,QProcess::ExitStatus)'), self.finVideo) self.connect(self.timer, SIGNAL('timeout()'), self.sonderTempsActuel) self.connect(self.slider, SIGNAL('sliderMoved(int)'), self.changerTempsCurseur) self.connect(self.cibleVideo, SIGNAL('changeSize'), self.sizeMplayer) if Mplayer.RATIO in choixWidget : self.connect(self.choicenorm, SIGNAL("clicked(bool)"), self.defRatio) self.connect(self.choicewide, SIGNAL("clicked(bool)"), self.defRatio) self.connect(self.choiceone, SIGNAL("clicked(bool)"), self.defRatio) def setListeVideo(self) : self.referenceVideo = [] self.listFichiers.clear() for vid in self.listeVideos : self.referenceVideo.append(vid) self.listFichiers.addItem(os.path.basename(vid)) if self.listeVideos.__len__() > 1 : self.listFichiers.show() def setAudio(self,au) : if au : self.cibleVideo.hide() if "conf" in self.__dict__ : self.conf.hide() else : self.cibleVideo.show() if "conf" in self.__dict__ : self.conf.show() def changeVideo(self, index) : self.arretMPlayer() if index >= 0 : # Condition ajoutée pour éviter une erreure de dépassement de range dans la liste. self.listeVideos = self.referenceVideo[index] self.listFichiers.setCurrentIndex(index) def defRatio(self, state=0) : if state : if self.choicenorm.isChecked() : self.setRatio(4.0/3.0) if self.choicewide.isChecked() : self.setRatio(16.0/9.0) if self.choiceone.isChecked() : try : dim=getVideoSize(unicode(self.listeVideos[0])) self.setRatio(dim[0]/dim[1]) except : None self.defRatio() else : self.adjustSize() def setRatio(self,ratio) : self.ratio = ratio self.sizeMplayer() def changeRatio(self,video) : rv = getVideoRatio(video) if rv[0]==0.0 and type(rv[1])==float : rat = rv[1] else : rat = rv[0] if rat > 1.7 : if "choicewide" in self.__dict__ : self.choicewide.setChecked(True) self.setRatio(16.0/9.0) elif rat > 1.3 and rat <= 1.7 : if "choicenorm" in self.__dict__ : self.choicenorm.setChecked(True) self.setRatio(4.0/3.0) elif rat < 1.3 and rat != 0.0 : if "choiceone" in self.__dict__ : self.choiceone.setChecked(True) dim=getVideoSize(video) self.setRatio(dim[0]/dim[1]) else : if "choicenorm" in self.__dict__ : self.choicenorm.setChecked(True) self.setRatio(4.0/3.0) def sizeMplayer(self) : self.cibleVideo.setFixedHeight(int(self.cibleVideo.width()/self.ratio)) def ouvrirVideo(self): """Ouverture de la boîte de dialogue de fichiers""" txt = u"Fichiers vidéo" if self.cheminPourBoutonParcourir: chemin = self.cheminPourBoutonParcourir else: try: chemin = EkdConfig.get('general','video_input_path').decode("UTF8") except: chemin = os.path.expanduser('~') liste=QFileDialog.getOpenFileNames(None, u"Ouvrir", chemin, "%s (*.avi *.mpg *.mpeg *.mjpeg *.flv *.mp4 *.ogg *.vob *.mov *.wmv *.3gp *.h264)\n*" %txt) if not liste: return self.listeVideos = liste self.changeRatio(unicode(self.listeVideos[0])) chemin = unicode(self.listeVideos[0]) EkdConfig.set('general','video_input_path',os.path.dirname(chemin).encode("UTF8")) def setVideos(self, videos) : '''Définie proprement la liste des vidéos à jouer''' if type(videos) != list : self.listeVideos = [videos] else : self.listeVideos = videos if self.LISTW and videos.__len__() > 1 : self.setListeVideo() elif self.LISTW : self.listFichiers.hide() def demarrerMPlayer(self): """démarrage de mplayer avec les arguments choisis""" if self.estLue: return True args = QStringList() # Liste Qt qui contiendra les options de mplayer # Ajout d'options à liste: args << "-option" # mplayer fonctionnera comme un terminal dans ce script args << "-slave" # on ne veut pas avoir des commentaires sans grand intérêt args << "-quiet" # Sous linux, aucun driver n'a été nécessaire et pas de manip pour Wid :) if self.systeme=='posix': # try - except? # la fenêtre de mplayer restera attaché à la fenêtre # wid prend en valeur le nombre identifiant le widget (celui qui contiendra la vidéo) args << "-wid" << QString.number(self.cibleVideo.winId()) # Objet QString car args est une liste de ch de caractères settings = QSettings() videoOutput = settings.value("vo", QVariant('')).toString() if videoOutput: args << '-vo' << videoOutput # Sous windows else: # reinterpret_cast<qlonglong> obligatoire, winId() ne se laissant pas convertir gentiment ;) args << "-wid" << self.cibleVideo.winId().__hex__() args << "-vo" << "directx:noaccel" #args << "-vo" << "gl" # alternative # chemin de la vidéo args << self.listeVideos if PYQT_VERSION_STR >= "4.1.0": # mode de canal: on fusionne le canal de sortie normal (stdout) et celui des erreurs (stderr) self.mplayerProcess.setProcessChannelMode(QProcess.MergedChannels) # démarrage de mplayer (en tenant compte des arguments définis ci-dessus) # comme un nouveau processus self.mplayerProcess.start(self.cheminMPlayer, args) # au cas où mplayer ne démarrerait pas au bout de 3 sec (ex. problème de codec) if not self.mplayerProcess.waitForStarted(3000): QMessageBox.critical(self, u"Avertissement", u"Bogue au lancement de la vidéo avec mplayer") return False # donne le temps toutes les x secondes self.timer.start(self.dureeTimer) self.estLue = True return True def recupSortie(self): """récupère les lignes d'information émises par QProcess (mplayerProcess) et en tire les conséquences""" while self.mplayerProcess.canReadLine(): # renvoie True si une ligne complète peut être lue à partir du système # stocker l'ensemble des bits d'une ligne tampon=QByteArray(self.mplayerProcess.readLine()) # readline: lit une ligne ascii à partir du système # On vérifie si on a eu des réponses if tampon.startsWith("Playing"): # On récupère les infos de base ('$ mplayer -input cmdlist' pour avoir la liste complète - file:///usr/share/doc/mplayer-doc/tech/slave.txt.gz pour plus de détails) self.mplayerProcess.write("get_video_resolution\n") # récupère la résolution de la vidéo self.mplayerProcess.write("get_time_length\n") # Nouveau fichier chargé -> on récupère son nom ind = tampon.length() - 2 # suppression du '.' à la fin tampon.remove(ind,ind) tampon.remove(0, 8) # vire Playing tampon.replace(QByteArray("\n"), QByteArray("")) tampon.replace(QByteArray("\r"), QByteArray("")) try: # Tour de passe-passe pour ne pas avoir de problème d'accents # Condition pour détection windows if os.name == 'nt': self.fichierCourant[1]=unicode(QString(tampon)) # Condition pour détection Linux ou MacOSX elif os.name in ['posix', 'mac']: self.fichierCourant[1]=unicode(QString(tampon)).encode("Latin1").decode("UTF8") except UnicodeEncodeError, e: debug(e) self.fichierCourant[1]="?" self.cibleVideo.setToolTip(self.fichierCourant[1]) if self.barreTaches is not None: self.barreTaches.showMessage(self.fichierCourant[1]) # réponse à get_video_resolution : ANS_VIDEO_RESOLUTION='<width> x <height>' if tampon.startsWith("ANS_VIDEO_RESOLUTION"): # retourne True si l'ensemble de bits démarre avec "..." debug("tampon : %s" % tampon) # ex. -> ANS_VIDEO_RESOLUTION='352 x 288' tampon.remove(0, 21) # suppression des 21 1er caract -> '352 x 288' tampon.replace(QByteArray("'"), QByteArray("")) # -> 352 x 288 tampon.replace(QByteArray(" "), QByteArray("")) # -> 352x288 tampon.replace(QByteArray("\n"), QByteArray("")) # -> 352x288 # retour chariot unix tampon.replace(QByteArray("\r"), QByteArray("")) # -> 352x288 # retour chariot windows #print "-----tampon.indexOf('x') :", tampon.indexOf('x'), type(tampon.indexOf('x')) sepIndex = tampon.indexOf('x') # récupère la position de 'x' # 3 <type 'int'> #print "-----tampon.left(sepIndex).toInt():", tampon.left(sepIndex).toInt(), type(tampon.left(sepIndex).toInt()) resX = tampon.left(sepIndex).toInt()[0] # -> 352 # (352, True) <type 'tuple'> #print "-----tampon.mid(sepIndex+1).toInt() :", tampon.mid(sepIndex+1).toInt(), type(tampon.mid(sepIndex+1).toInt()) resY = tampon.mid(sepIndex+1).toInt()[0] # -> 288 # (288, True) <type 'tuple'> # on définit les nouvelles dimensions de l'image du widget-mplayer. # try pour éviter les bogues sur les fichiers audio (sans dimension d'image)!!! #try: if resX!=0 or resY!=0: debug( "ratio : %s - %s" % (self.ratio, type(self.ratio))) else: debug("fichier audio") # réponse à get_time_length : ANS_LENGTH=xx.yy elif tampon.startsWith("ANS_LENGTH"): debug("tampon : %s" % tampon) # -> ANS_LENGTH=279.38 tampon.remove(0, 11) # vire ANS_LENGTH= tampon.replace(QByteArray("'"), QByteArray("")) tampon.replace(QByteArray(" "), QByteArray("")) tampon.replace(QByteArray("\n"), QByteArray("")) tampon.replace(QByteArray("\r"), QByteArray("")) # -> 279.38 #print "-----tampon.toFloat() :", tampon.toFloat(), type(tampon.toFloat()) tempsMax = tampon.toFloat()[0] # (279.3800048828125, True) <type 'tuple'> self.dureeVideo = tempsMax ## Modifié le 28/05/2009 : On augmente la précision du slider #self.slider.setMaximum(tempsMax) # déf du domaine de valeur du curseur self.slider.setMaximum(tempsMax*self.echelle) # ATTENTION J'AI COMMENTE CETTE LIGNE !!! #self.slider.setMaximum(tempsMax) # réponse à get_time_pos : ANS_TIME_POSITION=xx.y elif tampon.startsWith("ANS_TIME_POSITION"): #print "tampon :",tampon # -> ANS_TIME_POSITION=1.4 (temps courant) tampon.remove(0, 18) # vire ANS_TIME_POSITION= tampon.replace(QByteArray("'"), QByteArray("")) tampon.replace(QByteArray(" "), QByteArray("")) tampon.replace(QByteArray("\n"), QByteArray("")) tampon.replace(QByteArray("\r"), QByteArray("")) #print "-----tampon.toFloat() :", tampon.toFloat(), type(tampon.toFloat()) tempsCourant = tampon.toFloat()[0] # (1.3999999761581421, True) <type 'tuple'> # récupération du temps courant: utile dans certains cadres self.temps = tempsCourant # Programmer un arrêt. Utile pour les aperçus temps = float("%.1f" %self.temps) if self.debutFin!=(0,0) and self.debutFin[1]==temps: self.arretMPlayer() return self.slider.setValue(tempsCourant*self.echelle) ############################################################################# self.changerTempsChrono(tempsCourant) # modifier le chrono du bouton
class OutputAnalyserDialog(QDialog): def __init__(self, iface, parent, params): QDialog.__init__(self, parent) self.iface = iface self.parent = parent self.params = params self.output_reader = None self.tool = None self.element_ids_nodes = None self.element_ids_links = None self.nodes_lay = None self.links_lay = None self.setWindowTitle(Parameters.plug_in_name) # Selection changed listeners self.params.junctions_vlay.selectionChanged.connect( self.feature_sel_changed) self.params.reservoirs_vlay.selectionChanged.connect( self.feature_sel_changed) self.params.tanks_vlay.selectionChanged.connect( self.feature_sel_changed) self.params.pipes_vlay.selectionChanged.connect( self.feature_sel_changed) self.params.pumps_vlay.selectionChanged.connect( self.feature_sel_changed) self.params.valves_vlay.selectionChanged.connect( self.feature_sel_changed) # self.setMinimumWidth(min_width) # self.setMinimumHeight(min_height) fra_main_lay = QVBoxLayout(self) self.fra_out_file = QFrame(self) fra_out_file_lay = QHBoxLayout(self.fra_out_file) self.lbl_out_file = QLabel('Simulation output file:') self.txt_out_file = QLineEdit('') self.txt_out_file.setReadOnly(True) self.btn_out_file = QToolButton() self.btn_out_file.setText('...') self.btn_out_file.clicked.connect(self.btn_out_file_clicked) fra_out_file_lay.addWidget(self.lbl_out_file) fra_out_file_lay.addWidget(self.txt_out_file) fra_out_file_lay.addWidget(self.btn_out_file) self.tab_widget = QTabWidget(self) # Graphs tab --------------------------------------------------------------------------------------------------- self.tab_graphs = QWidget() tab_graphs_lay = QHBoxLayout(self.tab_graphs) # Left frame self.fra_graphs_left = QFrame() self.fra_graphs_left.setMaximumWidth(100) fra_graphs_left_lay = QVBoxLayout(self.fra_graphs_left) self.btn_sel_element = QPushButton('Pick') self.btn_sel_element.clicked.connect(self.btn_sel_element_clicked) fra_graphs_left_lay.addWidget(self.btn_sel_element) # Nodes self.grb_nodes = QGroupBox(u'Nodes') lay_grb_nodes = QVBoxLayout(self.grb_nodes) self.chk_node_demand = QCheckBox('Demand') lay_grb_nodes.addWidget(self.chk_node_demand) self.chk_node_head = QCheckBox('Head') lay_grb_nodes.addWidget(self.chk_node_head) self.chk_node_pressure = QCheckBox('Pressure') lay_grb_nodes.addWidget(self.chk_node_pressure) self.chk_node_quality = QCheckBox('Quality') lay_grb_nodes.addWidget(self.chk_node_quality) fra_graphs_left_lay.addWidget(self.grb_nodes) # Links self.grb_links = QGroupBox(u'Links') lay_grb_links = QVBoxLayout(self.grb_links) self.chk_link_flow = QCheckBox('Flow') lay_grb_links.addWidget(self.chk_link_flow) self.chk_link_velocity = QCheckBox('Velocity') lay_grb_links.addWidget(self.chk_link_velocity) self.chk_link_headloss = QCheckBox('Headloss') lay_grb_links.addWidget(self.chk_link_headloss) self.chk_link_quality = QCheckBox('Quality') lay_grb_links.addWidget(self.chk_link_quality) fra_graphs_left_lay.addWidget(self.grb_links) self.btn_draw_graph = QPushButton('Draw') self.btn_draw_graph.clicked.connect(self.draw_graphs) fra_graphs_left_lay.addWidget(self.btn_draw_graph) self.spacer = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding) fra_graphs_left_lay.addItem(self.spacer) tab_graphs_lay.addWidget(self.fra_graphs_left) # Right frame self.fra_graphs_right = QFrame() fra_graphs_right_lay = QVBoxLayout(self.fra_graphs_right) fra_graphs_right_lay.setContentsMargins(0, 0, 0, 0) self.static_canvas = StaticMplCanvas(self.fra_graphs_right, width=5, height=4, dpi=100) fra_graphs_right_lay.addWidget(self.static_canvas) tab_graphs_lay.addWidget(self.fra_graphs_right) # lay.addWidget(self.button) self.tab_widget.addTab(self.tab_graphs, 'Graphs') # Maps tab ----------------------------------------------------------------------------------------------------- self.tab_maps = QWidget() tab_maps_lay = QHBoxLayout(self.tab_maps) # Left frame self.fra_maps_left = QFrame() self.fra_maps_left.setMaximumWidth(200) fra_maps_left_lay = QVBoxLayout(self.fra_maps_left) self.grb_maps = QGroupBox(u'Variable') grb_maps_lay = QVBoxLayout(self.grb_maps) self.rad_maps_node_demand = QRadioButton(u'Node demand') grb_maps_lay.addWidget(self.rad_maps_node_demand) self.rad_maps_node_head = QRadioButton(u'Node head') grb_maps_lay.addWidget(self.rad_maps_node_head) self.rad_maps_node_pressure = QRadioButton(u'Node pressure') grb_maps_lay.addWidget(self.rad_maps_node_pressure) self.rad_maps_node_quality = QRadioButton(u'Node quality') grb_maps_lay.addWidget(self.rad_maps_node_quality) self.rad_maps_link_flow = QRadioButton(u'Link flow') grb_maps_lay.addWidget(self.rad_maps_link_flow) self.rad_maps_link_velocity = QRadioButton(u'Link velocity') grb_maps_lay.addWidget(self.rad_maps_link_velocity) self.rad_maps_link_headloss = QRadioButton(u'Link headloss') grb_maps_lay.addWidget(self.rad_maps_link_headloss) self.rad_maps_link_quality = QRadioButton(u'Link quality') grb_maps_lay.addWidget(self.rad_maps_link_quality) fra_maps_left_lay.addWidget(self.grb_maps) fra_maps_left_lay.addItem(self.spacer) tab_maps_lay.addWidget(self.fra_maps_left) # Right maps frame self.fra_maps_right = QFrame() fra_maps_right_lay = QVBoxLayout(self.fra_maps_right) self.fra_maps_right_time = QFrame() fra_maps_right_time_lay = QFormLayout(self.fra_maps_right_time) self.lbl_map_times = QLabel(u'Period [h]:') self.cbo_map_times = QComboBox() fra_maps_right_time_lay.addRow(self.lbl_map_times, self.cbo_map_times) fra_maps_right_lay.addWidget(self.fra_maps_right_time) self.btn_draw_map = QPushButton(u'Draw map') self.btn_draw_map.clicked.connect(self.draw_maps) fra_maps_right_lay.addWidget(self.btn_draw_map) fra_maps_right_lay.addItem(self.spacer) tab_maps_lay.addWidget(self.fra_maps_right) self.tab_widget.addTab(self.tab_maps, 'Maps') # # Add to main fra_main_lay.addWidget(self.fra_out_file) fra_main_lay.addWidget(self.tab_widget) self.setup() self.initialize() # self.read_outputs() # Set size self.setMinimumWidth(self.tab_graphs.width()) self.setMinimumHeight(self.tab_graphs.height()) def setup(self): pass def btn_out_file_clicked(self): config_file = ConfigFile(Parameters.config_file_path) out_file = QFileDialog.getOpenFileName(self, 'Select out file', config_file.get_last_out_file(), 'Out files (*.out)') if out_file is None or out_file == '': return config_file.set_last_out_file(out_file) self.txt_out_file.setText(out_file) self.read_outputs() if self.output_reader is None: return # Fill times combo self.cbo_map_times.clear() for period_s in self.output_reader.period_results.iterkeys(): text = self.seconds_to_string( period_s, self.output_reader.sim_duration_secs, self.output_reader.report_time_step_secs) self.cbo_map_times.addItem(text, period_s) def initialize(self): # Graphs self.grb_nodes.setEnabled(False) self.grb_links.setEnabled(False) # Maps self.rad_maps_node_demand.setChecked(True) def feature_sel_changed(self): is_nodes = False sel_junctions = self.params.junctions_vlay.selectedFeatureCount() sel_reservoirs = self.params.reservoirs_vlay.selectedFeatureCount() sel_tanks = self.params.tanks_vlay.selectedFeatureCount() if sel_junctions > 0 or sel_reservoirs > 0 or sel_tanks > 0: is_nodes = True self.grb_nodes.setEnabled(is_nodes) is_links = False sel_pipes = self.params.pipes_vlay.selectedFeatureCount() sel_pumps = self.params.pumps_vlay.selectedFeatureCount() sel_valves = self.params.valves_vlay.selectedFeatureCount() if sel_pipes > 0 or sel_pumps > 0 or sel_valves > 0: is_links = True self.grb_links.setEnabled(is_links) def read_outputs(self): try: QApplication.setOverrideCursor(Qt.WaitCursor) self.output_reader = BinaryOutputReader() self.output_reader.read(self.txt_out_file.text()) QApplication.restoreOverrideCursor() # Check if output compatible with loaded project compatible = True out_nodes_nr = self.output_reader.nodes_nr out_tanks_reservs_nr = self.output_reader.tanks_reservs_nr out_juncts_nr = out_nodes_nr - out_tanks_reservs_nr out_links_nr = self.output_reader.links_nr out_pumps_nr = self.output_reader.pumps_nr out_valves_nr = self.output_reader.valves_nr out_pipes_nr = out_links_nr - out_pumps_nr - out_valves_nr if out_juncts_nr != self.params.junctions_vlay.featureCount(): compatible = False if out_tanks_reservs_nr != ( self.params.reservoirs_vlay.featureCount() + self.params.tanks_vlay.featureCount()): compatible = False if out_pipes_nr != self.params.pipes_vlay.featureCount(): compatible = False if out_valves_nr != self.params.valves_vlay.featureCount(): compatible = False if out_pumps_nr != self.params.pumps_vlay.featureCount(): compatible = False if not compatible: message = 'The out file appears to incompatible with the actual project layers.' QMessageBox.warning(self, Parameters.plug_in_name, message, QMessageBox.Ok) self.output_reader = None self.txt_out_file.setText('') else: # Message after reading completed message = 'Out file loaded: ' + str( out_nodes_nr) + ' nodes, ' + str( out_links_nr) + ' links found.' # Clear refs to output layer self.params.out_lay_node_demand = None self.params.out_lay_node_head = None self.params.out_lay_node_pressure = None self.params.out_lay_node_quality = None self.params.out_lay_link_flow = None self.params.out_lay_link_velocity = None self.params.out_lay_link_headloss = None self.params.out_lay_link_quality = None QMessageBox.information(self, Parameters.plug_in_name, message, QMessageBox.Ok) finally: # self.iface.messageBar().pushWarning( # Parameters.plug_in_name, # 'Error while reading output file.') # TODO: softcode # self.output_reader = None # self.txt_out_file.setText('') QApplication.restoreOverrideCursor() def btn_sel_element_clicked(self): if self.output_reader is None: self.iface.messageBar().pushMessage( Parameters.plug_in_name, 'Please select the simulation out file.', QgsMessageBar.WARNING, 5) # TODO: softcode return self.tool = SelectTool(self, self.params) self.iface.mapCanvas().setMapTool(self.tool) cursor = QCursor() cursor.setShape(Qt.ArrowCursor) self.iface.mapCanvas().setCursor(cursor) def draw_graphs(self): # Get selected features self.element_ids_nodes = [] for junction_feat in self.params.junctions_vlay.selectedFeatures(): self.element_ids_nodes.append( junction_feat.attribute(Junction.field_name_eid)) for reservoir_feat in self.params.reservoirs_vlay.selectedFeatures(): self.element_ids_nodes.append( reservoir_feat.attribute(Reservoir.field_name_eid)) for tank_feat in self.params.tanks_vlay.selectedFeatures(): self.element_ids_nodes.append( tank_feat.attribute(Tank.field_name_eid)) self.element_ids_links = [] for pipe_feat in self.params.pipes_vlay.selectedFeatures(): self.element_ids_links.append( pipe_feat.attribute(Pipe.field_name_eid)) for pump_feat in self.params.pumps_vlay.selectedFeatures(): self.element_ids_links.append( pump_feat.attribute(Pump.field_name_eid)) for valve_feat in self.params.valves_vlay.selectedFeatures(): self.element_ids_links.append( valve_feat.attribute(Valve.field_name_eid)) # Build values dictionaries xs = self.output_reader.report_times ys_d_d = {} params_count = 0 # Nodes if self.grb_nodes.isEnabled(): if self.chk_node_demand.isChecked(): params_count += 1 ys_d = {} for element_id in self.element_ids_nodes: ys_d[element_id] = [ self.output_reader.node_demands_d[element_id], self.params.options.flow_units ] ys_d_d[OutputParamCodes.NODE_DEMAND] = ys_d if self.chk_node_head.isChecked(): params_count += 1 ys_d = {} for element_id in self.element_ids_nodes: ys_d[element_id] = [ self.output_reader.node_heads_d[element_id], Options.units_diameter_tanks[self.params.options.units] ] ys_d_d[OutputParamCodes.NODE_HEAD] = ys_d if self.chk_node_pressure.isChecked(): params_count += 1 ys_d = {} for element_id in self.element_ids_nodes: ys_d[element_id] = [ self.output_reader.node_pressures_d[element_id], Options.units_pressure[self.params.options.units] ] ys_d_d[OutputParamCodes.NODE_PRESSURE] = ys_d if self.chk_node_quality.isChecked(): params_count += 1 ys_d = {} for element_id in self.element_ids_nodes: ys_d[element_id] = [ self.output_reader.node_qualities_d[element_id], Quality.quality_units_text[ self.params.options.quality.mass_units] ] ys_d_d[OutputParamCodes.NODE_QUALITY] = ys_d # Links if self.grb_links.isEnabled(): if self.chk_link_flow.isChecked(): params_count += 1 ys_d = {} for element_id in self.element_ids_links: ys_d[element_id] = [ self.output_reader.link_flows_d[element_id], self.params.options.flow_units ] ys_d_d[OutputParamCodes.LINK_FLOW] = ys_d if self.chk_link_velocity.isChecked(): params_count += 1 ys_d = {} for element_id in self.element_ids_links: ys_d[element_id] = [ self.output_reader.link_velocities_d[element_id], Options.units_velocity[self.params.options.units] ] ys_d_d[OutputParamCodes.LINK_VELOCITY] = ys_d if self.chk_link_headloss.isChecked(): params_count += 1 ys_d = {} for element_id in self.element_ids_links: ys_d[element_id] = [ self.output_reader.link_headlosses_d[element_id], Options.units_diameter_tanks[self.params.options.units] ] ys_d_d[OutputParamCodes.LINK_HEADLOSS] = ys_d if self.chk_link_quality.isChecked(): params_count += 1 ys_d = {} for element_id in self.element_ids_links: ys_d[element_id] = [ self.output_reader.link_qualities_d[element_id], Quality.quality_units_text[ self.params.options.quality.mass_units] ] ys_d_d[OutputParamCodes.LINK_QUALITY] = ys_d if ys_d_d: self.static_canvas.draw_output_line(xs, ys_d_d, params_count) def draw_maps(self): """ Draws layers with all the attributes :return: """ report_time = self.cbo_map_times.itemText( self.cbo_map_times.currentIndex()) if self.rad_maps_node_demand.isChecked( ): # ------------------------------------------------------------------- lay_name = u'Node demand' lay_id = self.draw_map(LayerType.NODE, self.params.out_lay_node_demand_id, lay_name, self.output_reader.node_demands_d, report_time) self.params.out_lay_node_demand_id = lay_id elif self.rad_maps_node_head.isChecked(): lay_name = u'Node head' lay_id = self.draw_map(LayerType.NODE, self.params.out_lay_node_head_id, lay_name, self.output_reader.node_heads_d, report_time) self.params.out_lay_node_head_id = lay_id elif self.rad_maps_node_pressure.isChecked(): lay_name = u'Node pressure' lay_id = self.draw_map(LayerType.NODE, self.params.out_lay_node_pressure_id, lay_name, self.output_reader.node_pressures_d, report_time) self.params.out_lay_node_pressure_id = lay_id elif self.rad_maps_node_quality.isChecked(): lay_name = u'Node quality' lay_id = self.draw_map(LayerType.NODE, self.params.out_lay_node_quality_id, lay_name, self.output_reader.node_qualities_d, report_time) self.params.out_lay_node_quality_id = lay_id elif self.rad_maps_link_flow.isChecked( ): # ------------------------------------------------------------------- lay_name = u'Link flow' lay_id = self.draw_map(LayerType.LINK, self.params.out_lay_link_flow_id, lay_name, self.output_reader.link_flows_d, report_time) self.params.out_lay_link_flow_id = lay_id elif self.rad_maps_link_velocity.isChecked(): lay_name = u'Link velocity' lay_id = self.draw_map(LayerType.LINK, self.params.out_lay_link_velocity_id, lay_name, self.output_reader.link_velocities_d, report_time) self.params.out_lay_link_velocity_id = lay_id elif self.rad_maps_link_headloss.isChecked(): lay_name = u'Link headloss' lay_id = self.draw_map(LayerType.LINK, self.params.out_lay_link_headloss_id, lay_name, self.output_reader.link_headlosses_d, report_time) self.params.out_lay_link_headloss_id = lay_id elif self.rad_maps_link_quality.isChecked(): lay_name = u'Link quality' lay_id = self.draw_map(LayerType.LINK, self.params.out_lay_link_quality_id, lay_name, self.output_reader.link_qualities_d, report_time) self.params.out_lay_link_quality_id = lay_id def draw_map(self, lay_type, lay_id, lay_name, dataset, report_time): try: QApplication.setOverrideCursor(Qt.WaitCursor) lay_name += ' ' + report_time lay = LayerUtils.get_lay_from_id(lay_id) if lay is None: if lay_type == LayerType.NODE: lay = self.create_out_node_layer(lay_name, dataset) ns = NodeSymbology() lay.setRendererV2( ns.make_graduated_sym_renderer(lay, report_time)) elif lay_type == LayerType.LINK: lay = self.create_out_link_layer(lay_name, dataset) ls = LinkSymbology() lay.setRendererV2( ls.make_flow_sym_renderer(lay, report_time)) lay_id = lay.id() QgsMapLayerRegistry.instance().addMapLayer(lay) self.params.out_layers.append(lay) else: lay.setLayerName(lay_name) lay.triggerRepaint() QApplication.restoreOverrideCursor() finally: QApplication.restoreOverrideCursor() return lay_id def btn_cancel_clicked(self): self.setVisible(False) def btn_ok_clicked(self): pass def create_out_node_layer(self, lay_name, values_d): return self.create_out_layer(lay_name, values_d, LayerType.NODE) def create_out_link_layer(self, lay_name, values_d): return self.create_out_layer(lay_name, values_d, LayerType.LINK) def create_out_layer(self, lay_name, values_d, lay_type): field_name_vars = [] periods = self.output_reader.period_results.keys() for period_s in periods: text = self.seconds_to_string( period_s, self.output_reader.sim_duration_secs, self.output_reader.report_time_step_secs) field_name_vars.append(text) if lay_type == LayerType.NODE: new_lay = MemoryDS.create_nodes_lay(self.params, field_name_vars, lay_name, self.params.crs) elif lay_type == LayerType.LINK: new_lay = MemoryDS.create_links_lay(self.params, field_name_vars, lay_name, self.params.crs) with edit(new_lay): # Update attributes for feat in new_lay.getFeatures(): fid = feat.id() eid = feat.attribute(Node.field_name_eid) values = values_d[eid] for p in range(len(periods)): new_lay.changeAttributeValue(fid, p + 1, values[p]) return new_lay def seconds_to_string(self, period_s, duration_s, interval_s): day = int(math.floor(period_s / 86400)) hour = period_s / 3600 - day * 24 minute = period_s / 60 - day * 24 * 60 - hour * 60 second = period_s - day * 86400 - hour * 3600 - minute * 60 text = '' if duration_s >= 86400: # We need days text += str(day) + 'd' if duration_s >= 3600: # We need hours text += '{:02}'.format(hour) + 'H' text += '{:02}'.format(minute) + 'm' if second > 0: text += '{:02}'.format(second) + 's' return text
class QuantOSLoginEngine(QWidget): """风控引擎的管理组件""" #---------------------------------------------------------------------- def __init__(self, gateway, setting, parent=None): """Constructor""" super(QuantOSLoginEngine, self).__init__(parent) self.setting = setting self.gateway = gateway self.connectionMap = {} self.initUi() #---------------------------------------------------------------------- def initUi(self): """初始化界面""" self.setWindowTitle(u'登录') # 设置界面 self.userName = QLineEdit() self.password = QTextEdit() self.comboStrategy = QComboBox() grid = QGridLayout() grid.addWidget(LoginLine(), 1, 0, 1, 2) grid.addWidget(QLabel(u'用户名'), 2, 0) grid.addWidget(self.userName, 2, 1) grid.addWidget(QLabel(u'令牌'), 3, 0) grid.addWidget(self.password, 3, 1) grid.addWidget(LoginLine(), 4, 0, 1, 2) grid.addWidget(QLabel(u'策略'), 5, 0) grid.addWidget(self.comboStrategy, 5, 1) grid.addWidget(LoginLine(), 6, 0, 1, 2) self.buttonCancel = QPushButton(u'取消') self.buttonConfirm = QPushButton(u'确认') hbox = QHBoxLayout() hbox.addWidget(self.buttonConfirm) hbox.addWidget(self.buttonCancel) self.buttonConfirm.setDefault(True) vbox = QVBoxLayout() vbox.addLayout(grid) vbox.addLayout(hbox) self.setLayout(vbox) # 设为固定大小 self.setFixedSize(self.sizeHint()) self.buttonCancel.clicked.connect(self.close) self.buttonConfirm.clicked.connect(self.login) self.userName.returnPressed.connect(self.password.setFocus) # init username & token username = self.setting['username'] token = self.setting['token'] self.userName.setText(username) self.password.setText(token) def login(self): selectedStrat = self.comboStrategy.currentText() if selectedStrat is not None and len(selectedStrat) > 0: username = str(self.userName.text()).strip() password = str(self.password.toPlainText()).strip() if len(username) <= 0 or len(password) <= 0: QMessageBox.warning(self, u'登录', u'输入用户名和密码') else: self.close() self.gateway.login(username, password, selectedStrat) else: self.connect() def connect(self): userName = str(self.userName.text()).strip() password = str(self.password.toPlainText()).strip() if len(userName) <= 0 or len(password) <= 0: QMessageBox.warning(self, u'获取策略', u'输入用户名和密码') else: strategyList = self.gateway.getStrategyList(userName, password) if strategyList is not None and len(strategyList) > 0: self.comboStrategy.clear() strategyList_sl = [] for strategy in strategyList: strategyList_sl.append(str(strategy)) strategyList_sl.sort() self.comboStrategy.addItems(strategyList_sl) self.userName.setEnabled(False) self.password.setEnabled(False) else: QMessageBox.warning(self, u'获取策略', u'无法获取相关策略') self.comboStrategy.clear() self.comboStrategy.setFocus()
class Plugin(QObject): def __init__(self, iface): QObject.__init__(self) self.__iface = iface self.__shortcuts = [] self.__current_section = QComboBox() self.__current_section.setMinimumWidth(150) self.__current_graph = QComboBox() self.__current_graph.setMinimumWidth(150) self.__toolbar = None self.__axis_layer = None self.__menu = None self.__log_strati = None def initGui(self): for keyseq, slot in ( (Qt.CTRL + Qt.ALT + Qt.Key_K, self.__create_group), (Qt.CTRL + Qt.ALT + Qt.Key_S, self.__select_next_group), (Qt.CTRL + Qt.ALT + Qt.Key_N, self.__next_section), (Qt.CTRL + Qt.ALT + Qt.Key_B, self.__previous_section) ): short = QShortcut(QKeySequence(keyseq), self.__iface.mainWindow()) short.setContext(Qt.ApplicationShortcut) short.activated.connect(slot) self.__shortcuts.append(short) self.__menu = QMenu("Albion") self.__menu.aboutToShow.connect(self.__create_menu_entries) self.__iface.mainWindow().menuBar().addMenu(self.__menu) self.__toolbar = QToolBar('Albion') self.__iface.addToolBar(self.__toolbar) self.__toolbar.addAction(icon('log_strati.svg'), 'stratigraphic log').triggered.connect(self.__log_strati_clicked) self.__toolbar.addWidget(self.__current_graph) self.__current_graph.currentIndexChanged[unicode].connect(self.__current_graph_changed) self.__toolbar.addWidget(self.__current_section) self.__current_section.currentIndexChanged[unicode].connect(self.__current_section_changed) self.__toolbar.addAction(icon('previous_line.svg'), 'previous section (Ctrl+Alt+b)').triggered.connect(self.__previous_section) self.__toolbar.addAction(icon('next_line.svg'), 'next section (Ctrl+Alt+n)').triggered.connect(self.__next_section) self.__toolbar.addAction(icon('line_from_selected.svg'), 'create temporary section').triggered.connect(self.__section_from_selection) self.__viewer3d = QDockWidget('3D') self.__viewer3d.setWidget(Viewer3d()) self.__iface.addDockWidget(Qt.LeftDockWidgetArea, self.__viewer3d) self.__iface.mainWindow().tabifyDockWidget( self.__iface.mainWindow().findChild(QDockWidget, "Layers"), self.__viewer3d) self.__viewer3d_ctrl = QToolBar('3D controls') self.__viewer3d_ctrl.addWidget(ViewerControls(self.__viewer3d.widget())) self.__iface.addToolBar(self.__viewer3d_ctrl) QgsProject.instance().readProject.connect(self.__qgis__project__loaded) self.__qgis__project__loaded() # case of reload def unload(self): for s in self.__shortcuts: s.setParent(None) self.__toolbar and self.__toolbar.setParent(None) self.__menu and self.__menu.setParent(None) self.__viewer3d and self.__viewer3d.setParent(None) self.__viewer3d_ctrl and self.__viewer3d_ctrl.setParent(None) def __add_menu_entry(self, name, callback, enabled=True, help_str=''): act = self.__menu.addAction(name) if callback is not None: act.triggered.connect(callback) act.setEnabled(enabled) act.setToolTip(help_str) else: act.setEnabled(False) act.setToolTip("NOT INMPLEMENTED "+help_str) return act def __create_menu_entries(self): self.__menu.clear() self.__add_menu_entry('New &Project', self.__new_project) self.__add_menu_entry('Import Project', self.__import_project) self.__add_menu_entry('Upgrade Project', self.__upgrade_project) self.__menu.addSeparator() self.__add_menu_entry('&Import Data', self.__import_data, self.project is not None, "Import data from directory. The data files are in ") self.__menu.addSeparator() self.__add_menu_entry('Create cells', self.__create_cells, self.project is not None and self.project.has_collar, "Create Delaunay triangulation of collar layer.") self.__add_menu_entry('Refresh all edges', self.__refresh_all_edge, self.project is not None and self.project.has_cell, "Refresh materialized view of all cell edges used by graph possible edges.") self.__menu.addSeparator() #self.__add_menu_entry(u'Create section views 0° and 90°', self.__create_section_view_0_90, # False and self.project is not None and self.project.has_hole, # "Create section views (i.e. cut directions) to work West-East and South-North for this project") #self.__add_menu_entry(u'Create section views -45° and 45°', None, # False and self.project is not None and self.project.has_hole, # "Create section views (i.e. cut directions) to work SE-NW and SW-NE for this project") # #self.__menu.addSeparator() self.__add_menu_entry('Create sections', self.__create_sections, self.project is not None and self.project.has_group_cell, "Once cell groups have been defined, create section lines.") self.__menu.addSeparator() self.__add_menu_entry('Compute &Mineralization', self.__compute_mineralization, self.project is not None and self.project.has_radiometry, "") self.__menu.addSeparator() self.__add_menu_entry('New &Graph', self.__new_graph, self.project is not None, "Create a new grap.h") self.__add_menu_entry('Delete Graph', self.__delete_graph, self.project is not None) self.__menu.addSeparator() self.__add_menu_entry('Create volumes', self.__create_volumes, self.project is not None and bool(self.__current_graph.currentText()), "Create volumes associated with current graph.") self.__menu.addSeparator() self.__add_menu_entry('Create terminations', self.__create_terminations, self.project is not None and bool(self.__current_graph.currentText()), "Create terminations associated with current graph.") self.__menu.addSeparator() self.__add_menu_entry('Toggle axis', self.__toggle_axis) self.__menu.addSeparator() self.__add_menu_entry('Export Project', self.__export_project, self.project is not None) self.__add_menu_entry('Export Sections', None, self.project is not None and self.project.has_section, "Export triangulated section in .obj or .dxf format") self.__add_menu_entry('Export Volume', self.__export_volume, self.project is not None and bool(self.__current_graph.currentText()), "Export volume of current graph in .obj or .dxf format") self.__menu.addSeparator() self.__menu.addAction('Help').triggered.connect(self.open_help) def __current_graph_changed(self, graph_id): if self.project is None: return self.__viewer3d.widget().set_graph(graph_id) def __getattr__(self, name): if name == "project": project_name = QgsProject.instance().readEntry("albion", "project_name", "")[0] return Project(project_name) if project_name else None else: raise AttributeError(name) def __refresh_all_edge(self): if self.project is None: return self.project.refresh_all_edge() def __create_terminations(self): if self.project is None: return self.project.create_terminations(self.__current_graph.currentText()) self.__viewer3d.widget().refresh_data() self.__refresh_layers('section') def __create_volumes(self): if self.project is None: return self.project.create_volumes(self.__current_graph.currentText()) self.__viewer3d.widget().refresh_data() def __next_section(self): if self.project is None: return self.project.next_section(self.__current_section.currentText()) self.__refresh_layers('section') self.__viewer3d.widget().scene.update('section') self.__viewer3d.widget().update() def __previous_section(self): if self.project is None: return self.project.previous_section(self.__current_section.currentText()) self.__refresh_layers('section') self.__viewer3d.widget().scene.update('section') self.__viewer3d.widget().update() def __refresh_layers(self, name=None): for layer in self.__iface.mapCanvas().layers(): if name is None or layer.name().find(name) != -1: layer.triggerRepaint() def __current_section_changed(self, section_id): layers = QgsMapLayerRegistry.instance().mapLayersByName(u"group_cell") if len(layers): layers[0].setSubsetString("section_id='{}'".format(section_id)) self.__refresh_layers('section') def __select_next_group(self): if self.project and self.__iface.activeLayer() and self.__iface.activeLayer().name() == u"cell": self.__iface.activeLayer().removeSelection() self.__iface.activeLayer().selectByExpression( "id in ({})".format(",".join(project.next_group_ids()))) def __create_group(self): if self.project and self.__iface.activeLayer() and self.__iface.activeLayer().name() == u"cell": if self.__iface.activeLayer().selectedFeatureCount(): section = self.__current_section.currentText() self.project.create_group(section, [f['id'] for f in self.__iface.activeLayer().selectedFeatures()]) self.__iface.activeLayer().removeSelection() self.__refresh_layers('group_cell') def __qgis__project__loaded(self): if self.project is None: return self.__current_graph.clear() self.__current_section.clear() self.__current_section.addItems(self.project.sections()) self.__current_graph.addItems(self.project.graphs()) layers = QgsMapLayerRegistry.instance().mapLayersByName('section.anchor') if len(layers): layers[0].editingStopped.connect(self.__update_section_list) self.__viewer3d.widget().resetScene(self.project) def __update_section_list(self): self.__current_section.clear() self.__current_section.addItems(self.project.sections()) def __upgrade_project(self): project_name, ok = QInputDialog.getText(self.__iface.mainWindow(), "Database name", "Database name:", QLineEdit.Normal, '') if not ok: return Project(project_name).update() def __new_project(self): # @todo open dialog to configure project name and srid fil = QFileDialog.getSaveFileName(None, u"New project name (no space, plain ascii)", QgsProject.instance().readEntry("albion", "last_dir", "")[0], "QGIS poject file (*.qgs)") if not fil: return fil = fil if len(fil)>4 and fil[-4:]=='.qgs' else fil+'.qgs' fil = fil.replace(' ','_') try: fil.decode('ascii') except UnicodeDecodeError: self.__iface.messageBar().pushError('Albion:', "project name may only contain asci character (no accent)") return srid, ok = QInputDialog.getText(self.__iface.mainWindow(), "Project SRID", "Project SRID EPSG:", QLineEdit.Normal, '32632') if not ok: return srid = int(srid) project_name = str(os.path.split(fil)[1][:-4]) if Project.exists(project_name): if QMessageBox.Yes != QMessageBox(QMessageBox.Information, "Delete existing DB", "Database {} exits, to you want to delete it ?".format(project_name), QMessageBox.Yes|QMessageBox.No).exec_(): return Project.delete(project_name) self.__iface.messageBar().pushInfo('Albion:', "creating project...") Project.create(project_name, srid) # load template open(fil, 'w').write( open(resource('template_project.qgs')).read().replace('template_project', project_name)) self.__iface.newProject() QgsProject.instance().setFileName(fil) QgsProject.instance().read() QgsProject.instance().writeEntry("albion", "project_name", project_name) QgsProject.instance().writeEntry("albion", "srid", srid) QgsProject.instance().write() self.__qgis__project__loaded() def __import_data(self): if self.project is None: return if not QgsProject.instance().readEntry("albion", "conn_info", "")[0]: return dir_ = QFileDialog.getExistingDirectory(None, u"Data directory", QgsProject.instance().readEntry("albion", "last_dir", "")[0]) if not dir_: return QgsProject.instance().writeEntry("albion", "last_dir", dir_), progressMessageBar = self.__iface.messageBar().createMessage("Loading {}...".format(dir_)) progress = QProgressBar() progress.setAlignment(Qt.AlignLeft|Qt.AlignVCenter) progressMessageBar.layout().addWidget(progress) self.__iface.messageBar().pushWidget(progressMessageBar, self.__iface.messageBar().INFO) self.project.import_data(dir_, ProgressBar(progress)) self.project.triangulate() self.project.create_section_view_0_90(4) self.__iface.messageBar().clearWidgets() collar = QgsMapLayerRegistry.instance().mapLayersByName('collar')[0] collar.reload() collar.updateExtents() self.__iface.setActiveLayer(collar) QApplication.instance().processEvents() while self.__iface.mapCanvas().isDrawing(): QApplication.instance().processEvents() self.__iface.zoomToActiveLayer() self.__iface.actionSaveProject().trigger() self.__viewer3d.widget().resetScene(self.project) self.__current_section.clear() self.__current_section.addItems(self.project.sections()) def __new_graph(self): if self.project is None: return graph, ok = QInputDialog.getText(self.__iface.mainWindow(), "Graph", "Graph name:", QLineEdit.Normal, 'test_graph') if not ok: return parent, ok = QInputDialog.getText(self.__iface.mainWindow(), "Parent Graph", "Parent Graph name:", QLineEdit.Normal, '') if not ok: return self.project.new_graph(graph, parent) self.__current_graph.addItem(graph) self.__current_graph.setCurrentIndex(self.__current_graph.findText(graph)) def __delete_graph(self): if self.project is None: return graph, ok = QInputDialog.getText(self.__iface.mainWindow(), "Graph", "Graph name:", QLineEdit.Normal, self.__current_graph.currentText()) if not ok: return self.__current_graph.removeItem(self.__current_graph.findText(graph)) def __toggle_axis(self): if self.__axis_layer: pass QgsMapLayerRegistry.instance().removeMapLayer(self.__axis_layer.id()) self.__axis_layer = None else: self.__axis_layer = AxisLayer(self.__iface.mapCanvas().mapSettings().destinationCrs()) QgsMapLayerRegistry.instance().addMapLayer(self.__axis_layer) self.__refresh_layers() def __create_cells(self): if self.project is None: return self.project.triangulate() self.__refresh_layers('cells') def __create_sections(self): if self.project is None: return self.project.create_sections() def __compute_mineralization(self): MineralizationDialog(self.project).exec_() def __export_volume(self): if self.project is None: return fil = QFileDialog.getSaveFileName(None, u"Export volume for current graph", QgsProject.instance().readEntry("albion", "last_dir", "")[0], "File formats (*.dxf *.obj)") if not fil: return QgsProject.instance().writeEntry("albion", "last_dir", os.path.dirname(fil)), if fil[-4:] == '.obj': self.project.export_obj(self.__current_graph.currentText(), fil) elif fil[-4:] == '.dxf': self.project.export_dxf(self.__current_graph.currentText(), fil) else: self.__iface.messageBar().pushWarning('Albion', 'unsupported extension for volume export') def __import_project(self): fil = QFileDialog.getOpenFileName(None, u"Import project from file", QgsProject.instance().readEntry("albion", "last_dir", "")[0], "File formats (*.zip)") if not fil: return QgsProject.instance().writeEntry("albion", "last_dir", os.path.dirname(fil)), if fil[-4:] != '.zip': self.__iface.messageBar().pushWarning('Albion', 'unsupported extension for import') project_name = os.path.split(fil)[1][:-4] dir_ = tempfile.gettempdir() with zipfile.ZipFile(fil, "r") as z: z.extractall(dir_) dump = find_in_dir(dir_, '.dump') prj = find_in_dir(dir_, '.qgs') self.__iface.messageBar().pushInfo('Albion', 'loading {} from {}'.format(project_name, dump)) if Project.exists(project_name): if QMessageBox.Yes != QMessageBox(QMessageBox.Information, "Delete existing DB", "Database {} exits, to you want to delete it ?".format(project_name), QMessageBox.Yes|QMessageBox.No).exec_(): return Project.delete(project_name) project = Project.import_(project_name, dump) QgsProject.instance().read(QFileInfo(prj)) def __export_project(self): if self.project is None: return fil = QFileDialog.getSaveFileName(None, u"Export project", QgsProject.instance().readEntry("albion", "last_dir", "")[0], "Data files(*.zip)") if not fil: return QgsProject.instance().writeEntry("albion", "last_dir", os.path.dirname(fil)), if os.path.exists(fil): os.remove(fil) with zipfile.ZipFile(fil, 'w') as project: dump = tempfile.mkstemp()[1] self.project.export(dump) project.write(dump, self.project.name+'.dump') project.write(QgsProject.instance().fileName(), os.path.split(QgsProject.instance().fileName())[1]) def __create_section_view_0_90(self): if self.project is None: return self.project.create_section_view_0_90() def __log_strati_clicked(self): #@todo switch behavior when in section view -> ortho self.__click_tool = QgsMapToolEmitPoint(self.__iface.mapCanvas()) self.__iface.mapCanvas().setMapTool(self.__click_tool) self.__click_tool.canvasClicked.connect(self.__map_log_clicked) def __map_log_clicked(self, point, button): self.__click_tool.setParent(None) self.__click_tool = None if self.project is None: self.__log_strati and self.__log_strati.setParent(None) self.__log_strati = None return if self.__log_strati is None: self.__log_strati = QDockWidget('Stratigraphic Log') self.__log_strati.setWidget(BoreHoleWindow(self.project)) self.__iface.addDockWidget(Qt.LeftDockWidgetArea, self.__log_strati) self.__iface.mainWindow().tabifyDockWidget( self.__iface.mainWindow().findChild(QDockWidget, "Layers"), self.__log_strati) res = self.project.closest_hole_id(point.x(), point.y()) if res: self.__log_strati.widget().scene.set_current_id(res) self.__log_strati.show() self.__log_strati.raise_() def __section_from_selection(self): if self.project is None: return if self.__iface.activeLayer() and self.__iface.activeLayer().name() == u"collar" \ and self.__iface.activeLayer().selectedFeatures(): collar = self.__iface.activeLayer() selection = collar.selectedFeatures() if len(selection) < 2: return def align(l): assert len(l) >= 2 res = numpy.array(l[:2]) for p in l[2:]: u, v = res[0] - res[1], p - res[1] if numpy.dot(u,v) < 0: res[1] = p elif numpy.dot(u, u) < numpy.dot(v,v): res[0] = p # align with ref direction sqrt2 = math.sqrt(2.)/2 l = l[numpy.argsort(numpy.dot(l-res[0], res[1]-res[0]))] d = numpy.array(l[-1] - l[0]) dr = numpy.array([(0,1),(sqrt2, sqrt2),(1,0), (sqrt2, -sqrt2)]) i = numpy.argmax(numpy.abs(dr.dot(d))) return l if (dr.dot(d))[i] > 0 else l[::-1] line = LineString(align(numpy.array([f.geometry().asPoint() for f in selection]))) collar.removeSelection() self.project.set_section_geom(self.__current_section.currentText(), line) self.__refresh_layers('section') self.__viewer3d.widget().scene.update('section') self.__viewer3d.widget().update() def open_help(self): QDesktopServices.openUrl(QUrl.fromLocalFile(os.path.join(os.path.dirname(__file__), 'doc', 'build', 'html', 'index.html')))
class OWImpute(OWWidget): name = "Impute" description = "Imputes missing values in the data table." icon = "icons/Impute.svg" priority = 2130 inputs = [("Data", Orange.data.Table, "set_data"), ("Learner", Orange.classification.Fitter, "set_fitter")] outputs = [("Data", Orange.data.Table)] METHODS = METHODS settingsHandler = settings.DomainContextHandler() default_method = settings.Setting(1) variable_methods = settings.ContextSetting({}) autocommit = settings.Setting(False) want_main_area = False def __init__(self, parent=None): super().__init__(parent) self.modified = False box = group_box(self.tr("Default method"), layout=layout(Qt.Vertical)) self.controlArea.layout().addWidget(box) bgroup = QButtonGroup() for i, m in enumerate(self.METHODS[1:-1], 1): b = radio_button(m.name, checked=i == self.default_method, group=bgroup, group_id=i) box.layout().addWidget(b) self.defbggroup = bgroup bgroup.buttonClicked[int].connect(self.set_default_method) box = group_box(self.tr("Individual attribute settings"), layout=layout(Qt.Horizontal)) self.controlArea.layout().addWidget(box) self.varview = QtGui.QListView( selectionMode=QtGui.QListView.ExtendedSelection ) self.varview.setItemDelegate(DisplayFormatDelegate()) self.varmodel = itemmodels.VariableListModel() self.varview.setModel(self.varmodel) self.varview.selectionModel().selectionChanged.connect( self._on_var_selection_changed ) self.selection = self.varview.selectionModel() box.layout().addWidget(self.varview) method_layout = layout(Qt.Vertical, margins=0) box.layout().addLayout(method_layout) methodbox = group_box(layout=layout(Qt.Vertical)) bgroup = QButtonGroup() for i, m in enumerate(self.METHODS): b = radio_button(m.name, group=bgroup, group_id=i) methodbox.layout().addWidget(b) assert self.METHODS[-1].short == "value" self.value_stack = value_stack = QStackedLayout() self.value_combo = QComboBox(activated=self._on_value_changed) self.value_line = QLineEdit(editingFinished=self._on_value_changed) self.value_line.setValidator(QDoubleValidator()) value_stack.addWidget(self.value_combo) value_stack.addWidget(self.value_line) methodbox.layout().addLayout(value_stack) bgroup.buttonClicked[int].connect( self.set_method_for_current_selection ) reset_button = push_button("Restore all to default", clicked=self.reset_var_methods, default=False, autoDefault=False) method_layout.addWidget(methodbox) method_layout.addStretch(2) method_layout.addWidget(reset_button) self.varmethodbox = methodbox self.varbgroup = bgroup commitbox = group_box("Commit", layout=layout(margins=0)) cwidget = commit_widget( button_text="Commit", button_default=True, check_text="Commit on any change", checked=self.autocommit, clicked=self.commit ) def toggle_auto_commit(b): self.autocommit = b if self.modified: self.commit() cwidget.auto_commit_check.toggled[bool].connect(toggle_auto_commit) commitbox.layout().addWidget(cwidget) self.addAction(cwidget.commit_action) self.controlArea.layout().addWidget(commitbox) self.data = None self.fitter = None def set_default_method(self, index): """ Set the current selected default imputation method. """ if self.default_method != index: self.default_method = index self.defbggroup.button(index).setChecked(True) self._invalidate() def set_data(self, data): self.closeContext() self.clear() self.data = data if data is not None: self.varmodel[:] = data.domain.variables self.openContext(data.domain) self.restore_state(self.variable_methods) itemmodels.select_row(self.varview, 0) self.commit() def set_fitter(self, fitter): self.fitter = fitter if self.data is not None and \ any(state.model.short == "model" for state in map(self.state_for_column, range(len(self.data.domain)))): self.commit() def restore_state(self, state): for i, var in enumerate(self.varmodel): key = variable_key(var) if key in state: index = self.varmodel.index(i) self.varmodel.setData(index, state[key], Qt.UserRole) def clear(self): self.varmodel[:] = [] self.variable_methods = {} self.data = None self.modified = False def state_for_column(self, column): """ #:: int -> State Return the effective imputation state for `column`. :param int column: :rtype State: """ var = self.varmodel[column] state = self.variable_methods.get(variable_key(var), None) if state is None or state.method == METHODS[0]: state = State(METHODS[self.default_method], ()) return state def imputer_for_column(self, column): state = self.state_for_column(column) data = self.data var = data.domain[column] method, params = state if method.short == "leave": return None elif method.short == "avg": return column_imputer_average(var, data) elif method.short == "model": fitter = self.fitter if self.fitter is not None else MeanFitter() return column_imputer_by_model(var, data, fitter=fitter) elif method.short == "random": return column_imputer_random(var, data) elif method.short == "value": return column_imputer_defaults(var, data, float(params[0])) elif method.short == "as_value": return column_imputer_as_value(var, data) else: assert False def commit(self): if self.data is not None: states = [self.state_for_column(i) for i in range(len(self.varmodel))] # Columns to filter unknowns by dropping rows. filter_columns = [i for i, state in enumerate(states) if state.method.short == "drop"] impute_columns = [i for i, state in enumerate(states) if state.method.short not in ["drop", "leave"]] imputers = [(self.varmodel[i], self.imputer_for_column(i)) for i in impute_columns] data = self.data if imputers: table_imputer = ImputerModel(data.domain, dict(imputers)) data = table_imputer(data) if filter_columns: filter_ = data_filter.IsDefined(filter_columns) data = filter_(data) else: data = None self.send("Data", data) self.modified = False def _invalidate(self): self.modified = True if self.autocommit: self.commit() def _on_var_selection_changed(self): indexes = self.selection.selectedIndexes() vars = [self.varmodel[index.row()] for index in indexes] defstate = State(METHODS[0], ()) states = [self.variable_methods.get(variable_key(var), defstate) for var in vars] all_cont = all(isinstance(var, Orange.data.ContinuousVariable) for var in vars) states = list(unique(states)) method = None params = () state = None if len(states) == 1: state = states[0] method, params = state mindex = METHODS.index(method) self.varbgroup.button(mindex).setChecked(True) elif self.varbgroup.checkedButton() is not None: self.varbgroup.setExclusive(False) self.varbgroup.checkedButton().setChecked(False) self.varbgroup.setExclusive(True) values, enabled, stack_index = [], False, 0 value, value_index = "0.0", 0 if all_cont: enabled, stack_index = True, 1 if method is not None and method.short == "value": value = params[0] elif len(vars) == 1 and \ isinstance(vars[0], Orange.data.DiscreteVariable): values, enabled, stack_index = vars[0].values, True, 0 if method is not None and method.short == "value": try: value_index = values.index(params[0]) except IndexError: pass self.value_stack.setCurrentIndex(stack_index) self.value_stack.setEnabled(enabled) if stack_index == 0: self.value_combo.clear() self.value_combo.addItems(values) self.value_combo.setCurrentIndex(value_index) else: self.value_line.setText(value) def _on_value_changed(self): # The "fixed" value in the widget has been changed by the user. index = self.varbgroup.checkedId() self.set_method_for_current_selection(index) def set_method_for_current_selection(self, methodindex): indexes = self.selection.selectedIndexes() self.set_method_for_indexes(indexes, methodindex) def set_method_for_indexes(self, indexes, methodindex): method = METHODS[methodindex] params = (None,) if method.short == "value": if self.value_stack.currentIndex() == 0: value = self.value_combo.currentIndex() else: value = self.value_line.text() params = (value, ) elif method.short == "model": params = ("model", ) state = State(method, params) for index in indexes: self.varmodel.setData(index, state, Qt.UserRole) var = self.varmodel[index.row()] self.variable_methods[variable_key(var)] = state self._invalidate() def reset_var_methods(self): indexes = map(self.varmodel.index, range(len(self.varmodel))) self.set_method_for_indexes(indexes, 0)
class FindInFilesDialog(QDialog, object): """ find in files dialog implementation """ inProject = 0 inDirectory = 1 inOpenFiles = 2 def __init__(self, where, what="", dirPath="", filters=[], parent=None): QDialog.__init__(self, parent) mainWindow = GlobalData().mainWindow self.editorsManager = mainWindow.editorsManagerWidget.editorsManager self.__cancelRequest = False self.__inProgress = False self.searchRegexp = None self.searchResults = [] # Avoid pylint complains self.findCombo = None self.caseCheckBox = None self.wordCheckBox = None self.regexpCheckBox = None self.projectRButton = None self.openFilesRButton = None self.dirRButton = None self.dirEditCombo = None self.dirSelectButton = None self.filterCombo = None self.fileLabel = None self.progressBar = None self.findButton = None self.__createLayout() self.setWindowTitle("Find in files") # Restore the combo box values project = GlobalData().project if project.fileName != "": self.findFilesWhat = project.findFilesWhat self.findFilesDirs = project.findFilesDirs self.findFilesMasks = project.findFilesMasks else: settings = Settings() self.findFilesWhat = settings.findFilesWhat self.findFilesDirs = settings.findFilesDirs self.findFilesMasks = settings.findFilesMasks self.findCombo.addItems(self.findFilesWhat) self.findCombo.setEditText("") self.dirEditCombo.addItems(self.findFilesDirs) self.dirEditCombo.setEditText("") self.filterCombo.addItems(self.findFilesMasks) self.filterCombo.setEditText("") if where == self.inProject: self.setSearchInProject(what, filters) elif where == self.inDirectory: self.setSearchInDirectory(what, dirPath, filters) else: self.setSearchInOpenFiles(what, filters) return def __createLayout(self): """ Creates the dialog layout """ self.resize(600, 300) self.setSizeGripEnabled(True) verticalLayout = QVBoxLayout(self) gridLayout = QGridLayout() # Combo box for the text to search findLabel = QLabel(self) findLabel.setText("Find text:") self.findCombo = QComboBox(self) self.__tuneCombo(self.findCombo) self.findCombo.lineEdit().setToolTip( "Regular expression to search for") self.findCombo.editTextChanged.connect(self.__someTextChanged) gridLayout.addWidget(findLabel, 0, 0, 1, 1) gridLayout.addWidget(self.findCombo, 0, 1, 1, 1) verticalLayout.addLayout(gridLayout) # Check boxes horizontalCBLayout = QHBoxLayout() self.caseCheckBox = QCheckBox(self) self.caseCheckBox.setText("Match &case") horizontalCBLayout.addWidget(self.caseCheckBox) self.wordCheckBox = QCheckBox(self) self.wordCheckBox.setText("Match whole &word") horizontalCBLayout.addWidget(self.wordCheckBox) self.regexpCheckBox = QCheckBox(self) self.regexpCheckBox.setText("Regular &expression") horizontalCBLayout.addWidget(self.regexpCheckBox) verticalLayout.addLayout(horizontalCBLayout) # Files groupbox filesGroupbox = QGroupBox(self) filesGroupbox.setTitle("Find in") sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth( filesGroupbox.sizePolicy().hasHeightForWidth()) filesGroupbox.setSizePolicy(sizePolicy) gridLayoutFG = QGridLayout(filesGroupbox) self.projectRButton = QRadioButton(filesGroupbox) self.projectRButton.setText("&Project") gridLayoutFG.addWidget(self.projectRButton, 0, 0) self.projectRButton.clicked.connect(self.__projectClicked) self.openFilesRButton = QRadioButton(filesGroupbox) self.openFilesRButton.setText("&Opened files only") gridLayoutFG.addWidget(self.openFilesRButton, 1, 0) self.openFilesRButton.clicked.connect(self.__openFilesOnlyClicked) self.dirRButton = QRadioButton(filesGroupbox) self.dirRButton.setText("&Directory tree") gridLayoutFG.addWidget(self.dirRButton, 2, 0) self.dirRButton.clicked.connect(self.__dirClicked) self.dirEditCombo = QComboBox(filesGroupbox) self.__tuneCombo(self.dirEditCombo) self.dirEditCombo.lineEdit().setToolTip("Directory to search in") gridLayoutFG.addWidget(self.dirEditCombo, 2, 1) self.dirEditCombo.editTextChanged.connect(self.__someTextChanged) self.dirSelectButton = QPushButton(filesGroupbox) self.dirSelectButton.setText("...") gridLayoutFG.addWidget(self.dirSelectButton, 2, 2) self.dirSelectButton.clicked.connect(self.__selectDirClicked) filterLabel = QLabel(filesGroupbox) filterLabel.setText("Files filter:") gridLayoutFG.addWidget(filterLabel, 3, 0) self.filterCombo = QComboBox(filesGroupbox) self.__tuneCombo(self.filterCombo) self.filterCombo.lineEdit().setToolTip("File names regular expression") gridLayoutFG.addWidget(self.filterCombo, 3, 1) self.filterCombo.editTextChanged.connect(self.__someTextChanged) verticalLayout.addWidget(filesGroupbox) # File label self.fileLabel = FitPathLabel(self) self.fileLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Fixed) verticalLayout.addWidget(self.fileLabel) # Progress bar self.progressBar = QProgressBar(self) self.progressBar.setValue(0) self.progressBar.setOrientation(Qt.Horizontal) verticalLayout.addWidget(self.progressBar) # Buttons at the bottom buttonBox = QDialogButtonBox(self) buttonBox.setOrientation(Qt.Horizontal) buttonBox.setStandardButtons(QDialogButtonBox.Cancel) self.findButton = buttonBox.addButton("Find", QDialogButtonBox.AcceptRole) self.findButton.setDefault(True) self.findButton.clicked.connect(self.__process) verticalLayout.addWidget(buttonBox) buttonBox.rejected.connect(self.__onClose) return @staticmethod def __tuneCombo(comboBox): " Sets the common settings for a combo box " sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth( \ comboBox.sizePolicy().hasHeightForWidth() ) comboBox.setSizePolicy(sizePolicy) comboBox.setEditable(True) comboBox.setInsertPolicy(QComboBox.InsertAtTop) comboBox.setAutoCompletion(False) comboBox.setDuplicatesEnabled(False) return def __onClose(self): " Triggered when the close button is clicked " self.__cancelRequest = True if not self.__inProgress: self.close() return def setSearchInProject(self, what="", filters=[]): " Set search ready for the whole project " if GlobalData().project.fileName == "": # No project loaded, fallback to opened files self.setSearchInOpenFiles(what, filters) return # Select the project radio button self.projectRButton.setEnabled(True) self.projectRButton.setChecked(True) self.dirEditCombo.setEnabled(False) self.dirSelectButton.setEnabled(False) openedFiles = self.editorsManager.getTextEditors() self.openFilesRButton.setEnabled(len(openedFiles) != 0) self.setFilters(filters) self.findCombo.setEditText(what) self.findCombo.lineEdit().selectAll() self.findCombo.setFocus() # Check searchability self.__testSearchability() return def setSearchInOpenFiles(self, what="", filters=[]): " Sets search ready for the opened files " openedFiles = self.editorsManager.getTextEditors() if len(openedFiles) == 0: # No opened files, fallback to search in dir self.setSearchInDirectory(what, "", filters) return # Select the radio buttons self.projectRButton.setEnabled(GlobalData().project.fileName != "") self.openFilesRButton.setEnabled(True) self.openFilesRButton.setChecked(True) self.dirEditCombo.setEnabled(False) self.dirSelectButton.setEnabled(False) self.setFilters(filters) self.findCombo.setEditText(what) self.findCombo.lineEdit().selectAll() self.findCombo.setFocus() # Check searchability self.__testSearchability() return def setSearchInDirectory(self, what="", dirPath="", filters=[]): " Sets search ready for the given directory " # Select radio buttons self.projectRButton.setEnabled(GlobalData().project.fileName != "") openedFiles = self.editorsManager.getTextEditors() self.openFilesRButton.setEnabled(len(openedFiles) != 0) self.dirRButton.setEnabled(True) self.dirRButton.setChecked(True) self.dirEditCombo.setEnabled(True) self.dirSelectButton.setEnabled(True) self.dirEditCombo.setEditText(dirPath) self.setFilters(filters) self.findCombo.setEditText(what) self.findCombo.lineEdit().selectAll() self.findCombo.setFocus() # Check searchability self.__testSearchability() return def setFilters(self, filters): " Sets up the filters " # Set filters if provided if filters: self.filterCombo.setEditText(";".join(filters)) else: self.filterCombo.setEditText("") return def __testSearchability(self): " Tests the searchability and sets the Find button status " startTime = time.time() if self.findCombo.currentText().strip() == "": self.findButton.setEnabled(False) self.findButton.setToolTip("No text to search") return if self.dirRButton.isChecked(): dirname = self.dirEditCombo.currentText().strip() if dirname == "": self.findButton.setEnabled(False) self.findButton.setToolTip("No directory path") return if not os.path.isdir(dirname): self.findButton.setEnabled(False) self.findButton.setToolTip("Path is not a directory") return # Now we need to match file names if there is a filter filtersText = self.filterCombo.currentText().strip() if filtersText == "": self.findButton.setEnabled(True) self.findButton.setToolTip("Find in files") return # Need to check the files match try: filterRe = re.compile(filtersText, re.IGNORECASE) except: self.findButton.setEnabled(False) self.findButton.setToolTip( "Incorrect files " \ "filter regular expression" ) return matched = False tooLong = False if self.projectRButton.isChecked(): # Whole project for fname in GlobalData().project.filesList: if fname.endswith(sep): continue matched = filterRe.match(fname) if matched: break # Check the time, it might took too long if time.time() - startTime > 0.1: tooLong = True break elif self.openFilesRButton.isChecked(): # Opened files openedFiles = self.editorsManager.getTextEditors() for record in openedFiles: matched = filterRe.match(record[1]) if matched: break # Check the time, it might took too long if time.time() - startTime > 0.1: tooLong = True break else: # Search in the dir if not dirname.endswith(sep): dirname += sep matched, tooLong = self.__matchInDir(dirname, filterRe, startTime) if matched: self.findButton.setEnabled(True) self.findButton.setToolTip("Find in files") else: if tooLong: self.findButton.setEnabled(True) self.findButton.setToolTip("Find in files") else: self.findButton.setEnabled(False) self.findButton.setToolTip("No files matched to search in") return @staticmethod def __matchInDir(path, filterRe, startTime): " Provides the 'match' and 'too long' statuses " matched = False tooLong = False for item in os.listdir(path): if time.time() - startTime > 0.1: tooLong = True return matched, tooLong if os.path.isdir(path + item): dname = path + item + sep matched, tooLong = FindInFilesDialog.__matchInDir( dname, filterRe, startTime) if matched or tooLong: return matched, tooLong continue if filterRe.match(path + item): matched = True return matched, tooLong return matched, tooLong def __projectClicked(self): " project radio button clicked " self.dirEditCombo.setEnabled(False) self.dirSelectButton.setEnabled(False) self.__testSearchability() return def __openFilesOnlyClicked(self): " open files only radio button clicked " self.dirEditCombo.setEnabled(False) self.dirSelectButton.setEnabled(False) self.__testSearchability() return def __dirClicked(self): " dir radio button clicked " self.dirEditCombo.setEnabled(True) self.dirSelectButton.setEnabled(True) self.dirEditCombo.setFocus() self.__testSearchability() return def __someTextChanged(self, text): " Text to search, filter or dir name has been changed " self.__testSearchability() return def __selectDirClicked(self): " The user selects a directory " dirName = QFileDialog.getExistingDirectory( self, "Select directory to search in", self.dirEditCombo.currentText(), QFileDialog.Options(QFileDialog.ShowDirsOnly)) if dirName: self.dirEditCombo.setEditText(os.path.normpath(dirName)) self.__testSearchability() return def __projectFiles(self, filterRe): " Project files list respecting the mask " mainWindow = GlobalData().mainWindow files = [] for fname in GlobalData().project.filesList: if fname.endswith(sep): continue if filterRe is None or filterRe.match(fname): widget = mainWindow.getWidgetForFileName(fname) if widget is None: # Do not check for broken symlinks if isFileSearchable(fname, False): files.append(ItemToSearchIn(fname, "")) else: if widget.getType() in \ [ MainWindowTabWidgetBase.PlainTextEditor ]: files.append(ItemToSearchIn(fname, widget.getUUID())) QApplication.processEvents() if self.__cancelRequest: raise Exception("Cancel request") return files def __openedFiles(self, filterRe): " Currently opened editor buffers " files = [] openedFiles = self.editorsManager.getTextEditors() for record in openedFiles: uuid = record[0] fname = record[1] if filterRe is None or filterRe.match(fname): files.append(ItemToSearchIn(fname, uuid)) QApplication.processEvents() if self.__cancelRequest: raise Exception("Cancel request") return files def __dirFiles(self, path, filterRe, files): " Files recursively for the dir " for item in os.listdir(path): QApplication.processEvents() if self.__cancelRequest: raise Exception("Cancel request") if os.path.isdir(path + item): if item in [".svn", ".cvs"]: # It does not make sense to search in revision control dirs continue anotherDir, isLoop = resolveLink(path + item) if not isLoop: self.__dirFiles(anotherDir + sep, filterRe, files) continue if not os.path.isfile(path + item): continue realItem, isLoop = resolveLink(path + item) if isLoop: continue if filterRe is None or filterRe.match(realItem): found = False for itm in files: if itm.fileName == realItem: found = True break if not found: mainWindow = GlobalData().mainWindow widget = mainWindow.getWidgetForFileName(realItem) if widget is None: if isFileSearchable(realItem): files.append(ItemToSearchIn(realItem, "")) else: if widget.getType() in \ [ MainWindowTabWidgetBase.PlainTextEditor ]: files.append( ItemToSearchIn(realItem, widget.getUUID())) return def __buildFilesList(self): " Builds the list of files to search in " filtersText = self.filterCombo.currentText().strip() if filtersText != "": filterRe = re.compile(filtersText, re.IGNORECASE) else: filterRe = None if self.projectRButton.isChecked(): return self.__projectFiles(filterRe) if self.openFilesRButton.isChecked(): return self.__openedFiles(filterRe) dirname = os.path.realpath(self.dirEditCombo.currentText().strip()) files = [] self.__dirFiles(dirname + sep, filterRe, files) return files def __process(self): " Search process " # Add entries to the combo box if required regexpText = self.findCombo.currentText() if regexpText in self.findFilesWhat: self.findFilesWhat.remove(regexpText) self.findFilesWhat.insert(0, regexpText) if len(self.findFilesWhat) > 32: self.findFilesWhat = self.findFilesWhat[:32] self.findCombo.clear() self.findCombo.addItems(self.findFilesWhat) filtersText = self.filterCombo.currentText().strip() if filtersText in self.findFilesMasks: self.findFilesMasks.remove(filtersText) self.findFilesMasks.insert(0, filtersText) if len(self.findFilesMasks) > 32: self.findFilesMasks = self.findFilesMasks[:32] self.filterCombo.clear() self.filterCombo.addItems(self.findFilesMasks) if self.dirRButton.isChecked(): dirText = self.dirEditCombo.currentText().strip() if dirText in self.findFilesDirs: self.findFilesDirs.remove(dirText) self.findFilesDirs.insert(0, dirText) if len(self.findFilesDirs) > 32: self.findFilesDirs = self.findFilesDirs[:32] self.dirEditCombo.clear() self.dirEditCombo.addItems(self.findFilesDirs) # Save the combo values for further usage if GlobalData().project.fileName != "": GlobalData().project.setFindInFilesHistory(self.findFilesWhat, self.findFilesDirs, self.findFilesMasks) else: Settings().findFilesWhat = self.findFilesWhat Settings().findFilesDirs = self.findFilesDirs Settings().findFilesMasks = self.findFilesMasks self.__inProgress = True numberOfMatches = 0 self.searchResults = [] self.searchRegexp = None # Form the regexp to search if not self.regexpCheckBox.isChecked(): regexpText = re.escape(regexpText) if self.wordCheckBox.isChecked(): regexpText = "\\b%s\\b" % regexpText flags = re.UNICODE | re.LOCALE if not self.caseCheckBox.isChecked(): flags |= re.IGNORECASE try: self.searchRegexp = re.compile(regexpText, flags) except: logging.error("Invalid search expression") self.close() return QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) self.fileLabel.setPath('Building list of files to search in...') QApplication.processEvents() try: files = self.__buildFilesList() except Exception, exc: if "Cancel request" in str(exc): QApplication.restoreOverrideCursor() self.close() return else: QApplication.restoreOverrideCursor() logging.error(str(exc)) self.close() return QApplication.restoreOverrideCursor() QApplication.processEvents() if len(files) == 0: self.fileLabel.setPath('No files to search in') return self.progressBar.setRange(0, len(files)) index = 1 for item in files: if self.__cancelRequest: self.__inProgress = False self.close() return self.fileLabel.setPath( 'Matches: ' + str( numberOfMatches ) + \ ' Processing: ' + item.fileName ) item.search(self.searchRegexp) found = len(item.matches) if found > 0: numberOfMatches += found self.searchResults.append(item) self.progressBar.setValue(index) index += 1 QApplication.processEvents() if numberOfMatches == 0: if len(files) == 1: self.fileLabel.setPath("No matches in 1 file.") else: self.fileLabel.setPath( "No matches in " + \ str( len( files ) ) + " files." ) self.__inProgress = False else: self.close() return
class ComboChoice(HelpedWidget): """ A combo box widget for choices. List of objects retrieved from model str(item) is used for presentation getValue and setValue uses the same object as from the list """ def __init__(self, model, combo_label="Choice", help_link=""): HelpedWidget.__init__(self, combo_label, help_link) assert model is not None and isinstance(model, ChoiceModelMixin) self.model = model model.observable().attach(ChoiceModelMixin.CURRENT_CHOICE_CHANGED_EVENT, self.getCurrentFromModel) model.observable().attach(ChoiceModelMixin.CHOICE_LIST_CHANGED_EVENT, self.updateChoicesFromModel) self.combo = QComboBox() self.combo.addItem("Fail!") self.addWidget(self.combo) self.addStretch() self.choice_list = None """ @type: list """ self.connect(self.combo, SIGNAL('currentIndexChanged(int)'), self.selectionChanged) self.updateChoicesFromModel() self.getCurrentFromModel() def selectionChanged(self, index): assert 0 <= index < len(self.choice_list), "Should not happen! Index out of range: 0 <= %i < %i" % (index, len(self.choice_list)) item = self.choice_list[index] self.model.setCurrentChoice(item) def getCurrentFromModel(self): new_value = self.model.getCurrentChoice() if self.choice_list is None: self.updateChoicesFromModel() if new_value in self.choice_list: index = self.choice_list.index(new_value) if not index == self.combo.currentIndex(): self.combo.setCurrentIndex(index) else: self.combo.setCurrentIndex(0) #sys.stderr.write("AssertionError: ComboBox can not be set to: " + str(new_value) + "\n") # raise AssertionError("ComboBox can not be set to: " + str(new_value)) def updateChoicesFromModel(self): block = self.combo.signalsBlocked() self.combo.blockSignals(True) self.choice_list = self.model.getChoices() self.combo.clear() for choice in self.choice_list: self.combo.addItem(str(choice)) self.combo.blockSignals(block)
class ProfileWizard(StandaloneWizardPage): """Wizard for the creation of a new database profile. .. attribute:: languages .. attribute:: dialects A list of languages allowed in the profile selection, an empty list will allow all languages """ languages = [] dialects = [] def __init__(self, profiles, parent=None): super(ProfileWizard, self).__init__(parent) self._connection_valid = False self.network_reply = None self.profiles = profiles self.setWindowTitle(_('Profile Wizard')) self.set_banner_logo_pixmap(art.Icon('tango/22x22/categories/preferences-system.png').getQPixmap()) self.set_banner_title(_('Create New/Edit Profile')) self.set_banner_subtitle(_('Please enter the database settings')) self.banner_widget().setStyleSheet('background-color: white;') self.manager = QtNetwork.QNetworkAccessManager( self ) self.manager.finished.connect( self.update_network_status ) #self.manager.networkAccessibleChanged.connect( self.network_accessible_changed ) self.manager.proxyAuthenticationRequired.connect( self.proxy_authentication_required ) self.create_labels_and_widgets() self.create_buttons() self.set_tab_order() self.set_widgets_values() # note: connections come after labels and widgets are created # and have default values self.connect_widgets() self.connect_buttons() timer = QtCore.QTimer(self) timer.timeout.connect( self.new_network_request ) timer.setInterval( 3000 ) timer.start() self.new_network_request() def create_labels_and_widgets(self): assert object_thread( self ) self.profile_label = QLabel(_('Profile Name:')) self.dialect_label = QLabel(_('Driver:')) self.host_label = QLabel(_('Server Host:')) self.port_label = QLabel(_('Port:')) self.database_name_label = QLabel(_('Database Name:')) self.username_label = QLabel(_('Username:'******'Password:'******'Media Location:')) self.language_label = QLabel(_('Language:')) self.proxy_host_label = QLabel(_('Proxy Host:')) self.proxy_port_label = QLabel(_('Port:')) self.proxy_username_label = QLabel(_('Proxy Username:'******'Proxy Password:'******'Media location path '\ 'is not accessible.')) self.not_accessible_media_path_label.setStyleSheet('color: red') self.not_writable_media_path_label = QLabel(_('Media location path '\ 'is not writable.')) self.not_writable_media_path_label.setStyleSheet('color: red') layout = QGridLayout() layout.addWidget(self.profile_label, 0, 0, Qt.AlignRight) layout.addWidget(self.dialect_label, 1, 0, Qt.AlignRight) layout.addWidget(self.host_label, 2, 0, Qt.AlignRight) layout.addWidget(self.port_label, 2, 3, Qt.AlignRight) layout.addWidget(self.database_name_label, 3, 0, Qt.AlignRight) layout.addWidget(self.username_label, 4, 0, Qt.AlignRight) layout.addWidget(self.password_label, 5, 0, Qt.AlignRight) layout.addWidget(self.media_location_label, 7, 0, Qt.AlignRight) layout.addWidget(self.language_label, 8, 0, Qt.AlignRight) layout.addWidget(self.proxy_host_label, 10, 0, Qt.AlignRight) layout.addWidget(self.proxy_port_label, 10, 3, Qt.AlignRight) layout.addWidget(self.proxy_username_label, 11, 0, Qt.AlignRight) layout.addWidget(self.proxy_password_label, 12, 0, Qt.AlignRight) self.profile_editor = QComboBox(self) self.profile_editor.setEditable(True) # 32767 is Qt max length for string # should be more than enough for folders # http://doc.qt.nokia.com/latest/qlineedit.html#maxLength-prop self.dialect_editor = ChoicesEditor(parent=self) self.host_editor = TextLineEditor(self, length=32767) self.host_editor.set_value('') self.port_editor = TextLineEditor(self) self.port_editor.setFixedWidth(60) self.port_editor.set_value('') self.database_name_editor = TextLineEditor(self, length=32767) self.database_name_editor.set_value('') self.username_editor = TextLineEditor(self) self.username_editor.set_value('') self.password_editor = TextLineEditor(self) self.password_editor.setEchoMode(QLineEdit.Password) self.password_editor.set_value('') self.media_location_editor = TextLineEditor(self, length=32767) self.media_location_editor.set_value('') self.language_editor = LanguageEditor(languages=self.languages, parent=self) # # try to find a default language # system_language = QtCore.QLocale.system().name() if self.languages: if system_language in self.languages: self.language_editor.set_value( system_language ) else: self.language_editor.set_value( self.languages[0] ) else: self.language_editor.set_value( system_language ) self.proxy_host_editor = TextLineEditor(self, length=32767) self.proxy_host_editor.set_value('') self.proxy_port_editor = TextLineEditor(self) self.proxy_port_editor.setFixedWidth(60) self.proxy_port_editor.set_value('') self.proxy_username_editor = TextLineEditor(self) self.proxy_username_editor.set_value('') self.proxy_password_editor = TextLineEditor(self) self.proxy_password_editor.set_value('') self.proxy_password_editor.setEchoMode(QLineEdit.Password) layout.addWidget(self.profile_editor, 0, 1, 1, 1) layout.addWidget(self.dialect_editor, 1, 1, 1, 1) layout.addWidget(self.host_editor, 2, 1, 1, 1) layout.addWidget(self.port_editor, 2, 4, 1, 1) layout.addWidget(self.database_name_editor, 3, 1, 1, 1) layout.addWidget(self.username_editor, 4, 1, 1, 1) layout.addWidget(self.password_editor, 5, 1, 1, 1) layout.addWidget(HSeparator(), 6, 0, 1, 5) layout.addWidget(self.media_location_editor, 7, 1, 1, 1) layout.addWidget(self.language_editor, 8, 1, 1, 1) layout.addWidget(HSeparator(), 9, 0, 1, 5) layout.addWidget(self.proxy_host_editor, 10, 1, 1, 1) layout.addWidget(self.proxy_port_editor, 10, 4, 1, 1) layout.addWidget(self.proxy_username_editor, 11, 1, 1, 1) layout.addWidget(self.proxy_password_editor, 12, 1, 1, 1) layout.addWidget(self.network_status_label, 13, 1, 1, 4) self.main_widget().setLayout(layout) def set_widgets_values(self): self.dialect_editor.clear() self.profile_editor.clear() if self.dialects: dialects = self.dialects else: import sqlalchemy.dialects dialects = [name for _importer, name, is_package in \ pkgutil.iter_modules(sqlalchemy.dialects.__path__) \ if is_package] self.dialect_editor.set_choices([(dialect, dialect.capitalize()) \ for dialect in dialects]) self.profile_editor.insertItems(1, [''] + \ [item for item in fetch_profiles()]) self.profile_editor.setFocus() self.update_wizard_values() def connect_widgets(self): self.profile_editor.editTextChanged.connect(self.update_wizard_values) # self.dialect_editor.currentIndexChanged.connect(self.update_wizard_values) def create_buttons(self): self.more_button = QPushButton(_('More')) self.more_button.setCheckable(True) self.more_button.setAutoDefault(False) self.cancel_button = QPushButton(_('Cancel')) self.ok_button = QPushButton(_('OK')) layout = QHBoxLayout() layout.setDirection(QBoxLayout.RightToLeft) layout.addWidget(self.cancel_button) layout.addWidget(self.ok_button) layout.addStretch() layout.addWidget(self.more_button) self.buttons_widget().setLayout(layout) self.browse_button = QPushButton(_('Browse')) self.main_widget().layout().addWidget(self.browse_button, 7, 2, 1, 3) self.setup_extension() def setup_extension(self): self.extension = QWidget() self.load_button = QPushButton(_('Load profiles')) self.save_button = QPushButton(_('Save profiles')) extension_buttons_layout = QHBoxLayout() extension_buttons_layout.setContentsMargins(0, 0, 0, 0) extension_buttons_layout.addWidget(self.load_button) extension_buttons_layout.addWidget(self.save_button) extension_buttons_layout.addStretch() extension_layout = QVBoxLayout() extension_layout.setContentsMargins(0, 0, 0, 0) extension_layout.addWidget(HSeparator()) extension_layout.addLayout(extension_buttons_layout) self.extension.setLayout(extension_layout) self.main_widget().layout().addWidget(self.extension, 15, 0, 1, 5) self.extension.hide() def set_tab_order(self): all_widgets = [self.profile_editor, self.dialect_editor, self.host_editor, self.port_editor, self.database_name_editor, self.username_editor, self.password_editor, self.media_location_editor, self.browse_button, self.language_editor, self.proxy_host_editor, self.proxy_port_editor, self.proxy_username_editor, self.proxy_password_editor, self.ok_button, self.cancel_button] i = 1 while i != len(all_widgets): self.setTabOrder(all_widgets[i-1], all_widgets[i]) i += 1 def connect_buttons(self): self.cancel_button.pressed.connect(self.reject) self.ok_button.pressed.connect(self.proceed) self.browse_button.pressed.connect(self.fill_media_location) self.more_button.toggled.connect(self.extension.setVisible) self.save_button.pressed.connect(self.save_profiles_to_file) self.load_button.pressed.connect(self.load_profiles_from_file) def proceed(self): if self.is_connection_valid(): profilename, info = self.collect_info() if profilename in self.profiles: self.profiles[profilename].update(info) else: self.profiles[profilename] = info store_profiles(self.profiles) use_chosen_profile(profilename) self.accept() def is_connection_valid(self): profilename, info = self.collect_info() mt = SignalSlotModelThread(lambda:None) mt.start() progress = ProgressDialog(_('Verifying database settings')) mt.post(lambda:self.test_connection( info ), progress.finished, progress.exception) progress.exec_() return self._connection_valid def test_connection(self, profile): self._connection_valid = False connection_string = connection_string_from_profile( profile ) engine = create_engine(connection_string, pool_recycle=True) try: connection = engine.raw_connection() cursor = connection.cursor() cursor.close() connection.close() self._connection_valid = True except Exception, e: self._connection_valid = False raise UserException( _('Could not connect to database, please check host and port'), resolution = _('Verify driver, host and port or contact your system administrator'), detail = unicode(e) )
class AddWordWidget(QDialog): def __init__(self, parent=None): super(AddWordWidget, self).__init__(parent=parent) self.setWindowTitle('Add word') self.create_layout() self.create_connections() def create_layout(self): hbox = QHBoxLayout() vbox = QVBoxLayout() vbox.addWidget(QLabel("Dictionary")) vbox.addWidget(QLabel("Original")) vbox.addWidget(QLabel("Translation")) vbox.addWidget(QLabel("Phoneme")) vbox.addWidget(QLabel("Parts of Speech")) vbox.addWidget(QLabel("Synonyms")) vbox.addWidget(QLabel("Antonyms")) hbox.addLayout(vbox) vbox = QVBoxLayout() self.dictionaries = Dictionary.objects.all() self.dictionary = QComboBox() self.dictionary.addItems([d.name for d in self.dictionaries]) vbox.addWidget(self.dictionary) self.original = QLineEdit() vbox.addWidget(self.original) self.translation = QLineEdit() vbox.addWidget(self.translation) self.phoneme = QLineEdit() vbox.addWidget(self.phoneme) self.pos = QComboBox() self.pos.addItems([p.strip() for p in self.dictionaries[0].pos.split(',') if len(p) > 0]) vbox.addWidget(self.pos) self.synonyms = QLineEdit() vbox.addWidget(self.synonyms) self.antonyms = QLineEdit() vbox.addWidget(self.antonyms) hbox.addLayout(vbox) vbox = QVBoxLayout() vbox.addLayout(hbox) vbox.addWidget(QLabel("Description")) self.description = QTextEdit() vbox.addWidget(self.description) self.add_button = QPushButton("&Add") self.close_button = QPushButton("&Close") hbox = QHBoxLayout() hbox.addStretch() hbox.addWidget(self.add_button) hbox.addWidget(self.close_button) vbox.addLayout(hbox) self.status = QLabel('Add a new word to a dictionary.') vbox.addWidget(self.status) self.setLayout(vbox) def create_connections(self): self.connect(self.dictionary, SIGNAL("currentIndexChanged(int)"), self.change_pos) self.connect(self.close_button, SIGNAL("clicked()"), self.close) self.connect(self.add_button, SIGNAL("clicked()"), self.add_word) def change_pos(self, index): current_dict = self.dictionaries[index] self.pos.clear() self.pos.addItems([p.strip() for p in current_dict.pos.split(',') if len(p) > 0]) def get_texts(self): current_dict = self.dictionaries[self.dictionary.currentIndex()].abbrev original = unicode(self.original.text()).strip() translation = unicode(self.translation.text()).strip() phoneme = unicode(self.phoneme.text()).strip() pos = unicode(self.pos.currentText()).strip() synonyms = unicode(self.synonyms.text()).strip() antonyms = unicode(self.antonyms.text()).strip() description = unicode(self.description.toPlainText()).strip() if not all([original, translation, pos]): self.status.setText('There was an error inserting the word. Please' ' try again.') QMessageBox.critical(self, "Error", "You must enter at least " "'Original', 'Translation' and 'Parts of " "Speech'.") return None return dict(dictionary=current_dict, original=original, translation=translation, phoneme=phoneme, pos=pos, synonyms=synonyms, antonyms=antonyms, description=description) def clear_texts(self): self.translation.clear() self.phoneme.clear() self.synonyms.clear() self.antonyms.clear() self.description.clear() self.original.setFocus() def add_word(self): self.status.clear() texts = self.get_texts() if not texts: return word = Word(**texts) word.save() self.clear_texts() self.status.setText('Word %s has been added successfully.' % word.original) self.words_widget.load_words() def save_word(self): self.status.clear() texts = self.get_texts() if not texts: return word = self.word word.dictionary = texts['dictionary'] word.original = texts['original'] word.translation = texts['translation'] word.phoneme = texts['phoneme'] word.pos = texts['pos'] word.synonyms = texts['synonyms'] word.antonyms = texts['antonyms'] word.description = texts['description'] word.save() self.status.setText('Word %s has been saved successfully' % word.original) self.words_widget.load_words() def get_word(self): return self._word def set_word(self, word): self._word = word self.setWindowTitle("Edit %s" % word.original) self.add_button.setText("&Save") self.disconnect(self.add_button, SIGNAL("clicked()"), self.add_word) if word.exported: self.add_button.setEnabled(False) self.status.setText('This word has been exported already. ' 'You cannot save the changes to it.') else: self.connect(self.add_button, SIGNAL("clicked()"), self.save_word) self.status.setText('Edit this word and save to your dictionary.') for i, d in enumerate(self.dictionaries): if d.abbrev == word.dictionary: self.dictionary.setCurrentIndex(i) break self.original.setText(word.original) self.translation.setText(word. translation) self.phoneme.setText(word.phoneme) self.synonyms.setText(word.synonyms) self.antonyms.setText(word.antonyms) self.description.setText(word.description) for i in range(self.pos.count()): if self.pos.itemText(i) == word.pos: self.pos.setCurrentIndex(i) break word = property(get_word, set_word)
class AdvancedVisualizationForm(QWidget): def __init__(self, mainwindow, result_manager): QWidget.__init__(self, mainwindow) #mainwindow is an OpusGui self.mainwindow = mainwindow self.result_manager = result_manager self.toolboxBase = self.result_manager.mainwindow.toolboxBase self.inGui = False self.logFileKey = 0 self.xml_helper = ResultsManagerXMLHelper(toolboxBase = self.toolboxBase) self.result_generator = OpusResultGenerator( toolboxBase = self.toolboxBase) self.result_generator.guiElement = self self.tabIcon = QIcon(':/Images/Images/cog.png') self.tabLabel = 'Advanced Visualization' self.widgetLayout = QVBoxLayout(self) self.widgetLayout.setAlignment(Qt.AlignTop) self.resultsGroupBox = QGroupBox(self) self.widgetLayout.addWidget(self.resultsGroupBox) self.dataGroupBox = QGroupBox(self) self.widgetLayout.addWidget(self.dataGroupBox) self.optionsGroupBox = QGroupBox(self) self.widgetLayout.addWidget(self.optionsGroupBox) self._setup_definition_widget() self._setup_buttons() self._setup_tabs() def _setup_buttons(self): # Add Generate button... self.pbn_go = QPushButton(self.resultsGroupBox) self.pbn_go.setObjectName('pbn_go') self.pbn_go.setText(QString('Go!')) QObject.connect(self.pbn_go, SIGNAL('released()'), self.on_pbn_go_released) self.widgetLayout.addWidget(self.pbn_go) self.pbn_set_esri_storage_location = QPushButton(self.optionsGroupBox) self.pbn_set_esri_storage_location.setObjectName('pbn_set_esri_storage_location') self.pbn_set_esri_storage_location.setText(QString('...')) self.pbn_set_esri_storage_location.hide() QObject.connect(self.pbn_set_esri_storage_location, SIGNAL('released()'), self.on_pbn_set_esri_storage_location_released) def _setup_tabs(self): # Add a tab widget and layer in a tree view and log panel self.tabWidget = QTabWidget(self.resultsGroupBox) # Log panel self.logText = QTextEdit(self.resultsGroupBox) self.logText.setReadOnly(True) self.logText.setLineWidth(0) self.tabWidget.addTab(self.logText,'Log') # Finally add the tab to the model page self.widgetLayout.addWidget(self.tabWidget) # def _setup_definition_widget(self): #### setup results group box #### self.gridlayout = QGridLayout(self.resultsGroupBox) self.gridlayout.setObjectName('gridlayout') self.lbl_results = QLabel(self.resultsGroupBox) self.lbl_results.setObjectName('lbl_results') self.lbl_results.setText(QString('Results')) self.gridlayout.addWidget(self.lbl_results,0,0,1,3) self._setup_co_results() self.gridlayout.addWidget(self.co_results,0,3,1,10) self.pbn_add = QPushButton(self.resultsGroupBox) self.pbn_add.setObjectName('pbn_add') self.pbn_add.setText(QString('+')) QObject.connect(self.pbn_add, SIGNAL('released()'), self.on_pbn_add_released) self.gridlayout.addWidget(self.pbn_add, 0, 14, 1, 1) self.lw_indicators = QListWidget(self.resultsGroupBox) self.lw_indicators.setObjectName('lw_indicators') self.gridlayout.addWidget(self.lw_indicators,1,1,1,13) self.pbn_remove = QPushButton(self.resultsGroupBox) self.pbn_remove.setObjectName('pbn_remove') self.pbn_remove.setText(QString('-')) QObject.connect(self.pbn_remove, SIGNAL('released()'), self.on_pbn_remove_released) self.gridlayout.addWidget(self.pbn_remove, 1, 14, 1, 1) #### setup data group box #### self.gridlayout2 = QGridLayout(self.dataGroupBox) self.gridlayout2.setObjectName('gridlayout2') self._setup_co_result_style() self.gridlayout2.addWidget(self.co_result_style,1,0,1,2) self.lbl_result_style_sep = QLabel(self.resultsGroupBox) self.lbl_result_style_sep.setObjectName('lbl_result_style_sep') self.lbl_result_style_sep.setText(QString('<center>as</center>')) self.gridlayout2.addWidget(self.lbl_result_style_sep,1,2,1,1) self._setup_co_result_type() self.gridlayout2.addWidget(self.co_result_type,1,3,1,2) ##### setup options group box #### self.gridlayout3 = QGridLayout(self.optionsGroupBox) self.gridlayout3.setObjectName('gridlayout3') self.le_esri_storage_location = QLineEdit(self.optionsGroupBox) self.le_esri_storage_location.setObjectName('le_esri_storage_location') self.le_esri_storage_location.setText('[set path]') self.le_esri_storage_location.hide() self.optionsGroupBox.hide() QObject.connect(self.co_result_style, SIGNAL('currentIndexChanged(int)'), self.on_co_result_style_changed) QObject.connect(self.co_result_type, SIGNAL('currentIndexChanged(int)'), self.on_co_result_type_changed) def _setup_co_results(self): self.co_results = QComboBox(self.resultsGroupBox) self.co_results.setObjectName('co_results') self.co_results.addItem(QString('[select]')) results = self.xml_helper.get_available_results() for result in results: name = '%i.%s'%(result['run_id'],result['indicator_name']) self.co_results.addItem(QString(name)) def _setup_co_result_style(self): available_styles = [ 'visualize', 'export', ] self.co_result_style = QComboBox(self.dataGroupBox) self.co_result_style.setObjectName('co_result_style') for dataset in available_styles: self.co_result_style.addItem(QString(dataset)) def _setup_co_result_type(self): available_types = [ 'Table (per year, spans indicators)', 'Chart (per indicator, spans years)', 'Map (per indicator per year)', 'Chart (per indicator, spans years)', ] self.co_result_type = QComboBox(self.dataGroupBox) self.co_result_type.setObjectName('co_result_type') for dataset in available_types: self.co_result_type.addItem(QString(dataset)) def on_pbnRemoveModel_released(self): self.result_manager.removeTab(self) self.result_manager.updateGuiElements() def on_pbn_add_released(self): cur_selected = self.co_results.currentText() for i in range(self.lw_indicators.count()): if self.lw_indicators.item(i).text() == cur_selected: return self.lw_indicators.addItem(cur_selected) def on_pbn_remove_released(self): selected_idxs = self.lw_indicators.selectedIndexes() for idx in selected_idxs: self.lw_indicators.takeItem(idx.row()) def on_co_result_style_changed(self, ind): available_viz_types = [ 'Table (per year, spans indicators)', 'Chart (per indicator, spans years)', 'Map (per indicator per year)', 'Chart (per indicator, spans years)', ] available_export_types = [ 'ESRI table (for loading in ArcGIS)' ] txt = self.co_result_style.currentText() if txt == 'visualize': available_types = available_viz_types else: available_types = available_export_types self.co_result_type.clear() for result_type in available_types: r_type = QString(result_type) self.co_result_type.addItem(r_type) def on_co_result_type_changed(self, ind): self.gridlayout3.removeWidget(self.le_esri_storage_location) self.gridlayout3.removeWidget(self.pbn_set_esri_storage_location) self.optionsGroupBox.hide() self.pbn_set_esri_storage_location.hide() self.le_esri_storage_location.hide() txt = self.co_result_type.currentText() print txt if txt == 'ESRI table (for loading in ArcGIS)': self.pbn_set_esri_storage_location.show() self.le_esri_storage_location.show() self.gridlayout3.addWidget(self.le_esri_storage_location,0,1,1,6) self.gridlayout3.addWidget(self.pbn_set_esri_storage_location,0,7,1,1) self.optionsGroupBox.show() def on_pbn_set_esri_storage_location_released(self): print 'pbn_set_esri_storage_location released' from opus_core.misc import directory_path_from_opus_path start_dir = directory_path_from_opus_path('opus_gui.projects') configDialog = QFileDialog() filter_str = QString("*.gdb") fd = configDialog.getExistingDirectory(self,QString("Please select an ESRI geodatabase (*.gdb)..."), #, *.sde, *.mdb)..."), QString(start_dir), QFileDialog.ShowDirsOnly) if len(fd) != 0: fileName = QString(fd) fileNameInfo = QFileInfo(QString(fd)) fileNameBaseName = fileNameInfo.completeBaseName() self.le_esri_storage_location.setText(fileName) def on_pbn_go_released(self): # Fire up a new thread and run the model print 'Go button pressed' # References to the GUI elements for status for this run... #self.statusLabel = self.runStatusLabel #self.statusLabel.setText(QString('Model initializing...')) indicator_names = [] for i in range(self.lw_indicators.count()): indicator_names.append(str(self.lw_indicators.item(i).text())) if indicator_names == []: print 'no indicators selected' return indicator_type = str(self.co_result_type.currentText()) indicator_type = { #'Map (per indicator per year)':'matplotlib_map', 'Map (per indicator per year)':'mapnik_map', 'Chart (per indicator, spans years)':'matplotlib_chart', 'Table (per indicator, spans years)':'table_per_attribute', 'Table (per year, spans indicators)':'table_per_year', 'ESRI table (for loading in ArcGIS)':'table_esri' }[indicator_type] kwargs = {} if indicator_type == 'table_esri': storage_location = str(self.le_esri_storage_location.text()) if not os.path.exists(storage_location): print 'Warning: %s does not exist!!'%storage_location kwargs['storage_location'] = storage_location self.result_manager.addIndicatorForm(indicator_type = indicator_type, indicator_names = indicator_names, kwargs = kwargs) def runUpdateLog(self): self.logFileKey = self.result_generator._get_current_log(self.logFileKey) def runErrorFromThread(self,errorMessage): QMessageBox.warning(self.mainwindow, 'Warning', errorMessage)
class ReferencedTableEditor(QWidget): referenced_table_changed = pyqtSignal(str) def __init__(self, parent=None): QWidget.__init__(self, parent) self.setupUi() self.cbo_ref_table.setInsertPolicy(QComboBox.InsertAlphabetically) self.cbo_ref_table.currentIndexChanged[str].connect(self._on_ref_table_changed) def setupUi(self): self.setObjectName("ReferencedTableEditor") self.gridLayout = QGridLayout(self) self.gridLayout.setVerticalSpacing(10) self.gridLayout.setObjectName("gridLayout") self.label_2 = QLabel(self) self.label_2.setMaximumSize(QSize(100, 16777215)) self.label_2.setObjectName("label_2") self.gridLayout.addWidget(self.label_2, 1, 0, 1, 1) self.cbo_source_field = QComboBox(self) self.cbo_source_field.setMinimumSize(QSize(0, 30)) self.cbo_source_field.setObjectName("cbo_source_field") self.gridLayout.addWidget(self.cbo_source_field, 2, 1, 1, 1) self.label = QLabel(self) self.label.setObjectName("label") self.gridLayout.addWidget(self.label, 2, 0, 1, 1) self.label_3 = QLabel(self) self.label_3.setObjectName("label_3") self.gridLayout.addWidget(self.label_3, 3, 0, 1, 1) self.cbo_referencing_col = QComboBox(self) self.cbo_referencing_col.setMinimumSize(QSize(0, 30)) self.cbo_referencing_col.setObjectName("cbo_referencing_col") self.gridLayout.addWidget(self.cbo_referencing_col, 3, 1, 1, 1) self.cbo_ref_table = QComboBox(self) self.cbo_ref_table.setMinimumSize(QSize(0, 30)) self.cbo_ref_table.setObjectName("cbo_ref_table") self.gridLayout.addWidget(self.cbo_ref_table, 1, 1, 1, 1) self.label_2.setText(QApplication.translate("ReferencedTableEditor", "References")) self.label.setText(QApplication.translate("ReferencedTableEditor", "Data source field")) self.label_3.setText(QApplication.translate("ReferencedTableEditor", "Referencing")) #Connect signals QMetaObject.connectSlotsByName(self) self.cbo_ref_table.currentIndexChanged[str].connect(self._load_source_table_fields) @pyqtSlot(str) def on_data_source_changed(self,data_source_name): """ Loads data source fields for the given data source name. """ self.load_data_source_fields(data_source_name) def _on_ref_table_changed(self, table): """ Raise signal when the referenced table changes. :param table: Selected table name. :type table: str """ self.referenced_table_changed.emit(table) def properties(self): """ :returns: Returns the user-defined mapping of linked table and column pairings. :rtype: LinkedTableProps """ l_table = self.cbo_ref_table.currentText() s_field = self.cbo_source_field.currentText() l_field = self.cbo_referencing_col.currentText() return LinkedTableProps(linked_table=l_table, source_field=s_field, linked_field=l_field) def set_properties(self, table_props): """ Sets the combo selection based on the text in the linked table object properties. :param table_props: Object containing the linked table information. :type table_props: LinkedTableProps """ setComboCurrentIndexWithText(self.cbo_ref_table, table_props.linked_table) setComboCurrentIndexWithText(self.cbo_referencing_col, table_props.linked_field) setComboCurrentIndexWithText(self.cbo_source_field, table_props.source_field) def load_data_source_fields(self, data_source_name): """ Load fields/columns of the given data source. """ if data_source_name == "": self.clear() return columns_names = table_column_names(data_source_name) if len(columns_names) == 0: return self.cbo_source_field.clear() self.cbo_source_field.addItem("") self.cbo_source_field.addItems(columns_names) def clear(self): """ Resets combo box selections. """ self._reset_combo_index(self.cbo_ref_table) self._reset_combo_index(self.cbo_referencing_col) self._reset_combo_index(self.cbo_source_field) def _reset_combo_index(self, combo): if combo.count > 0: combo.setCurrentIndex(0) def reset_referenced_table(self): self._reset_combo_index(self.cbo_ref_table) def load_link_tables(self, reg_exp=None, source=TABLES|VIEWS): self.cbo_ref_table.clear() self.cbo_ref_table.addItem("") ref_tables = [] #Table source if (TABLES & source) == TABLES: ref_tables.extend(pg_tables()) #View source if (VIEWS & source) == VIEWS: ref_tables.extend(pg_views()) source_tables = [] for t in ref_tables: if not reg_exp is None: if reg_exp.exactMatch(t): source_tables.append(t) else: source_tables.append(t) self.cbo_ref_table.addItems(source_tables) def _load_source_table_fields(self, sel): self.cbo_referencing_col.clear() if not sel: return columns_names = table_column_names(sel) self.cbo_referencing_col.clear() self.cbo_referencing_col.addItem("") self.cbo_referencing_col.addItems(columns_names)
class LayerSelectionPage(QFrame): #TODO. Filtering, (visible) row selection, multi selection colparams = ((0, 65, 'Name'), (1, 235, 'Title'), (2, 350, 'Keywords')) XFER_BW = 40 def __init__(self, parent=None): super(LayerSelectionPage, self).__init__(parent) self.parent = parent #convenience link self.confconn_link = self.parent.parent.confconn #flag top prevent read read action on keyword delete. New logic makes this redundant #self.keywordbypass = False QToolTip.setFont(QFont('SansSerif', 10)) #label filterlabel = QLabel('Filter') availablelabel = QLabel('Available Layers') selectionlabel = QLabel('Layer Selections') keywordlabel = QLabel('Keyword') explainlabel = QLabel( "Edit Group assignments using this dialog or to simply initialise the Layer-Config just click 'Finish'" ) #selection buttons chooseallbutton = QPushButton('>>') chooseallbutton.setFixedWidth(self.XFER_BW) chooseallbutton.clicked.connect(self.doChooseAllClickAction) choosebutton = QPushButton('>') choosebutton.setFixedWidth(self.XFER_BW) choosebutton.clicked.connect(self.doChooseClickAction) rejectbutton = QPushButton('<') rejectbutton.setFixedWidth(self.XFER_BW) rejectbutton.clicked.connect(self.doRejectClickAction) rejectallbutton = QPushButton('<<') rejectallbutton.setFixedWidth(self.XFER_BW) rejectallbutton.clicked.connect(self.doRejectAllClickAction) #operation buttons finishbutton = QPushButton('Finish') finishbutton.setToolTip('Finish and Close layer selection dialog') finishbutton.clicked.connect(self.parent.close) resetbutton = QPushButton('Reset') resetbutton.font() resetbutton.setToolTip( 'Read Layer from LDS GetCapabilities request. Overwrites current Layer Config' ) resetbutton.clicked.connect(self.doResetClickAction) self.available_sfpm = LDSSFPAvailableModel(self) self.selection_sfpm = LDSSFPSelectionModel(self) self.available_sfpm.setSourceModel(self.parent.available_model) self.selection_sfpm.setSourceModel(self.parent.selection_model) #textedits filteredit = QLineEdit('') filteredit.setToolTip( 'Filter Available-Layers pane (filter operates across Name and Title fields and accepts Regex expressions)' ) filteredit.textChanged.connect(self.available_sfpm.setActiveFilter) self.keywordcombo = QComboBox() self.keywordcombo.setToolTip( 'Select or Add a unique identifier to be saved in layer config (keyword)' ) self.keywordcombo.addItems(list(self.confconn_link.assigned)) self.keywordcombo.setEditable(True) self.keywordcombo.activated.connect(self.doKeyComboChangeAction) lgindex = self.confconn_link.getLayerGroupIndex( self.confconn_link.lgval, col=1) lgentry = self.confconn_link.lglist[lgindex] if LU.assessNone( lgindex) else None #keywordedit = self.keywordcombo.lineEdit().text().toUtf8().data().decode('utf8')# for writing #if no entry or layer indicated then blank self.keywordcombo.lineEdit().setText( '' if lgentry is None or lgentry[0] == LORG.LAYER else lgentry[1]) #self.confconn_link.lgval)#TODO. group only #header headmodel = QStandardItemModel() headmodel.setHorizontalHeaderLabels([ i[2] for i in self.colparams ][:self.parent.available_model.columnCount()]) headview1 = QHeaderView(Qt.Horizontal) headview1.setModel(headmodel) headview1.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) headview2 = QHeaderView(Qt.Horizontal) headview2.setModel(headmodel) headview2.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) #table self.available = QTableView() self.available.setSelectionBehavior(QAbstractItemView.SelectRows) self.available.setSelectionMode(QAbstractItemView.MultiSelection) self.selection = QTableView() self.selection.setSelectionBehavior(QAbstractItemView.SelectRows) self.selection.setSelectionMode(QAbstractItemView.MultiSelection) #interesting, must set model after selection attributes but before headers else row selections/headers don't work properly self.available.setModel(self.available_sfpm) self.selection.setModel(self.selection_sfpm) self.available.setSortingEnabled(True) self.available.setHorizontalHeader(headview1) self.selection.setSortingEnabled(True) self.selection.setHorizontalHeader(headview2) for cp in self.colparams: self.available.setColumnWidth(cp[0], cp[1]) self.selection.setColumnWidth(cp[0], cp[1]) self.available.verticalHeader().setVisible(False) self.available.horizontalHeader().setVisible(True) self.selection.verticalHeader().setVisible(False) self.selection.horizontalHeader().setVisible(True) #layout vbox00 = QVBoxLayout() vbox00.addWidget(availablelabel) vbox00.addWidget(self.available) vbox01 = QVBoxLayout() vbox01.addWidget(chooseallbutton) vbox01.addWidget(choosebutton) vbox01.addWidget(rejectbutton) vbox01.addWidget(rejectallbutton) vbox02 = QVBoxLayout() vbox02.addWidget(selectionlabel) vbox02.addWidget(self.selection) vbox10 = QVBoxLayout() vbox10.addWidget(filterlabel) vbox10.addWidget(filteredit) hbox12 = QHBoxLayout() hbox12.addWidget(keywordlabel) hbox12.addStretch(1) #hbox12.addWidget(inspbutton) #hbox12.addWidget(addbutton) #hbox12.addWidget(delbutton) vbox12 = QVBoxLayout() vbox12.addLayout(hbox12) vbox12.addWidget(self.keywordcombo) #00|01|02 #10|11|12 grid0 = QGridLayout() grid0.addLayout(vbox00, 1, 0) grid0.addLayout(vbox01, 1, 1) grid0.addLayout(vbox02, 1, 2) grid0.addLayout(vbox10, 0, 0) grid0.addLayout(vbox12, 0, 2) hbox2 = QHBoxLayout() hbox2.addWidget(resetbutton) hbox2.addStretch(1) hbox2.addWidget(explainlabel) hbox2.addWidget(finishbutton) #gbox1.setLayout(hbox2) vbox3 = QVBoxLayout() vbox3.addLayout(grid0) #vbox3.addLayout(hbox3) #vbox3.addWidget(line0) vbox3.addLayout(hbox2) self.setLayout(vbox3) def doChooseAllClickAction(self): '''Moves the lot to Selected''' #ktext = LU.recode(self.keywordcombo.lineEdit().text().toUtf8().data()) ktext = LU.recode( LQ.readWidgetText(self.keywordcombo.lineEdit().text())) if not self.checkKeyword(ktext): return #------------------------------ self.parent.signalModels(self.parent.STEP.PRE) #self.parent.selection_model.mdata += self.parent.available_model.mdata self.parent.selection_model.initData(self.confconn_link.complete) self.parent.available_model.initData([]) self.parent.signalModels(self.parent.STEP.POST) #------------------------------ self.parent.writeKeysToLayerConfig(ktext) #self.confconn_link.setupAssignedLayerList() if self.keywordcombo.findText(ktext) == -1: self.keywordcombo.addItem(ktext) def doChooseClickAction(self): '''Takes available selected and moves to selection''' #ktext = LU.recode(self.keywordcombo.lineEdit().text().toUtf8().data()) ktext = LU.recode( LQ.readWidgetText(self.keywordcombo.lineEdit().text())) #ktext = str(self.keywordcombo.lineEdit().text()) if not self.checkKeyword(ktext): return #------------------------------ select = self.available.selectionModel() if select.hasSelection(): self.transferSelectedRows(select.selectedRows(), self.available_sfpm, self.selection_sfpm) #------------------------------ self.parent.writeKeysToLayerConfig(ktext) #self.confconn_link.assigned = self.confconn_link.setupAssignedLayerList() # -1 to indicate no index since 0,1,... are valid if self.keywordcombo.findText(ktext) == -1: self.keywordcombo.addItem(ktext) else: ldslog.warn('L2R > Transfer action without selection') #TRACE# #pdb.set_trace() self.available.clearSelection() def transferSelectedRows(self, indices, from_model, to_model): tlist = [] for proxymodelindex in indices: transfer = from_model.getData(proxymodelindex) tlist.append((proxymodelindex, transfer), ) to_model.addData([t[1] for t in tlist]) from_model.delData([t[0] for t in tlist]) return tlist def doRejectClickAction(self): '''Takes available selected and moves to selection''' #ktext = LU.recode(self.keywordcombo.lineEdit().text().toUtf8().data()) ktext = LU.recode( LQ.readWidgetText(self.keywordcombo.lineEdit().text())) if not self.checkKeyword(ktext): return #------------------------------ select = self.selection.selectionModel() if select.hasSelection(): tlist = self.transferSelectedRows(select.selectedRows(), self.selection_sfpm, self.available_sfpm) #------------------------------ kindex = self.keywordcombo.findText(ktext) remainder = self.parent.deleteKeysFromLayerConfig( [ll[1][0] for ll in tlist], ktext) if remainder > 0 and kindex == -1: #items+newkey -> add self.parent.writeKeysToLayerConfig(ktext) self.keywordcombo.addItem(ktext) elif remainder == 0 and kindex > -1: #empty+oldkey -> del self.keywordcombo.removeItem(kindex) self.keywordcombo.clearEditText() else: ldslog.warn('R2L < Transfer action without selection') #TRACE# #pdb.set_trace() self.selection.clearSelection() def doRejectAllClickAction(self): #ktext = LU.recode(self.keywordcombo.lineEdit().text().toUtf8().data()) ktext = LU.recode( LQ.readWidgetText(self.keywordcombo.lineEdit().text())) if not self.checkKeyword(ktext): return #------------------------------ self.parent.deleteKeysFromLayerConfig( [ll[0] for ll in self.parent.selection_model.mdata], ktext) #------------------------------ self.parent.signalModels(self.parent.STEP.PRE) #self.parent.available_model.mdata += self.parent.selection_model.mdata self.parent.available_model.initData(self.confconn_link.complete) self.parent.selection_model.initData([]) self.parent.signalModels(self.parent.STEP.POST) #------------------------------ #self.confconn_link.setupAssignedLayerList() #self.keywordbypass = True self.keywordcombo.removeItem(self.keywordcombo.findText(ktext)) self.keywordcombo.clearEditText() def doKeyComboChangeAction(self): '''Reset the available pane and if there is anything in the keyword box use this to init the selection pane''' #HACK #if self.keywordbypass: # self.keywordbypass = False # return #------------------------------ #ktext = LU.recode(self.keywordcombo.lineEdit().text().toUtf8().data()) ktext = LU.recode( LQ.readWidgetText(self.keywordcombo.lineEdit().text())) #------------------------------ av_sl = self.parent.splitData(ktext, self.confconn_link.complete) #av_sl = self.parent.splitData(ktext,self.confconn_link.complete) self.parent.signalModels(self.parent.STEP.PRE) self.parent.available_model.initData(av_sl[0]) self.parent.selection_model.initData(av_sl[1]) self.parent.signalModels(self.parent.STEP.POST) def doResetClickAction(self): '''Dumps the LC and rebuilds from a fresh read of the caps doc''' #int warning (QWidget parent, QString title, QString text, QString button0Text, QString button1Text = QString(), QString button2Text = QString(), int defaultButtonNumber = 0, int escapeButtonNumber = -1) ans = QMessageBox.warning( self, "Reset", "This action will overwrite your Layer Configuration using the current LDS settings (potentially adding new or removing layers). Continue?", "Continue", "Cancel") if ans: #Cancel ldslog.warn('Cancelling Reset operation') return #Continue ldslog.warn('Reset Layer Config') self.parent.resetLayers() self.keywordcombo.clear() def checkKeyword(self, ktext): '''Checks keyword isn't null and isn't part of the LDS supplied keywords''' if LU.assessNone(ktext) is None: QMessageBox.about(self, "Keyword Required", "Please enter a Keyword to assign Layer(s) to") return False if ktext in self.confconn_link.reserved: QMessageBox.about( self, "Reserved Keyword", "'{}' is a reserved keyword, please select again".format( ktext)) return False return True
class SimpleConnectWidget(QWidget): """ this widget displays a combobox with a list of instruments which the user can connect to, it also has a refresh button """ def __init__(self, parent=None): super(SimpleConnectWidget, self).__init__(parent) # main layout of the form is the verticallayout self.verticalLayout = QVBoxLayout() self.verticalLayout.setObjectName("verticalLayout") # moved the script stuff to a separate widget that lives in the toolbar self.labelLayout = QHBoxLayout() self.labelLayout.setObjectName("labelLayout") self.portLabel = QLabel(self) self.portLabel.setText("Availiable Ports") self.instrLabel = QLabel(self) self.instrLabel.setText("Instruments") self.labelLayout.addWidget(self.portLabel) self.labelLayout.addWidget(self.instrLabel) self.verticalLayout.addLayout(self.labelLayout) self.ports = QComboBox(self) self.ports.addItems(refresh_device_port_list()) self.ports.setObjectName("cbb_ports") self.instruments = QComboBox(self) self.instruments.addItems(utils.list_drivers(interface="real")[0]) self.ports.setObjectName("cbb_instrs") self.cbbLayout = QHBoxLayout() self.cbbLayout.setObjectName("cbbLayout") self.cbbLayout.addWidget(self.ports) self.cbbLayout.addWidget(self.instruments) self.verticalLayout.addLayout(self.cbbLayout) self.connectButton = QPushButton(self) self.connectButton.setText("Connect the instrument") self.connectButton.setObjectName("connectButton") self.refreshButton = QPushButton(self) self.refreshButton.setText("refresh the port list") self.refreshButton.setObjectName("refreshButton") self.verticalLayout.addWidget(self.connectButton) self.verticalLayout.addWidget(self.refreshButton) self.headerTextEdit = QPlainTextEdit("") fontsize = self.headerTextEdit.fontMetrics() pal = QPalette() textc = QColor(245, 245, 240) pal.setColor(QPalette.Base, textc) self.headerTextEdit.setPalette(pal) # d3d3be # self.headerTextEdit.ba self.headerTextEdit.setFixedHeight(fontsize.lineSpacing() * 8) self.verticalLayout.addWidget(self.headerTextEdit) # moved the start stop button to the toolbar only self.setLayout(self.verticalLayout) self.connect(self.connectButton, SIGNAL('clicked()'), self.on_connectButton_clicked) self.connect(self.refreshButton, SIGNAL('clicked()'), self.on_refreshButton_clicked) def on_connectButton_clicked(self): """Connect a given instrument through a given port""" port = self.ports.currentText() instrument_name = self.instruments.currentText() # load the module which contains the instrument's driver if __name__ == "__main__": class_inst = import_module(instrument_name) else: class_inst = import_module("." + instrument_name, package=utils.LABDRIVER_PACKAGE_NAME) msg = "" # msg.append("example") # msg.append("</span>") self.headerTextEdit.appendHtml(msg) # self.headerTextEdit.appendPlainText(msg) try: i = class_inst.Instrument(port) self.headerTextEdit.appendPlainText("%s" % (i.identify())) self.headerTextEdit.appendHtml( "The connection to the instrument %s through the port %s <span style=\" color:#009933;\" >WORKED</span>\n" % (instrument_name, port)) i.close() except: self.headerTextEdit.appendHtml( "The connection to the instrument %s through the port %s <span style=\" color:#ff0000;\" >FAILED</span>\n" % (instrument_name, port)) def on_refreshButton_clicked(self): """Refresh the list of the availiable ports""" self.ports.clear() self.ports.addItems(refresh_device_port_list())
class FindInFilesDialog(QDialog): """Dialog to configure and trigger the search in the files.""" def __init__(self, result_widget, parent): super(FindInFilesDialog, self).__init__(parent) self._find_thread = FindInFilesThread() self.setWindowTitle(translations.TR_FIND_IN_FILES) self.resize(400, 300) #MAIN LAYOUT main_vbox = QVBoxLayout(self) self.pattern_line_edit = QLineEdit() self.pattern_line_edit.setPlaceholderText(translations.TR_FIND + "...") self.dir_name_root = None self.user_home = os.path.expanduser('~') self.dir_combo = QComboBox() self.dir_combo.addItem(self.user_home) self.dir_combo.setEditable(True) self.open_button = QPushButton(QIcon(":img/find"), translations.TR_OPEN) self.filters_line_edit = QLineEdit("*.py") self.filters_line_edit.setPlaceholderText("*.py") self.filters_line_edit.setCompleter(QCompleter( ["*{}".format(item) for item in settings.SUPPORTED_EXTENSIONS])) self.replace_line = QLineEdit() self.replace_line.setEnabled(False) self.replace_line.setPlaceholderText( translations.TR_TEXT_FOR_REPLACE + "...") self.check_replace = QCheckBox(translations.TR_REPLACE) self.case_checkbox = QCheckBox(translations.TR_CASE_SENSITIVE) self.type_checkbox = QCheckBox(translations.TR_REGULAR_EXPRESSION) self.recursive_checkbox = QCheckBox(translations.TR_RECURSIVE) self.recursive_checkbox.setCheckState(Qt.Checked) self.phrase_radio = QRadioButton(translations.TR_SEARCH_BY_PHRASE) self.phrase_radio.setChecked(True) self.words_radio = QRadioButton( translations.TR_SEARCH_FOR_ALL_THE_WORDS) self.find_button = QPushButton(translations.TR_FIND + "!") self.find_button.setMaximumWidth(150) self.cancel_button = QPushButton(translations.TR_CANCEL) self.cancel_button.setMaximumWidth(150) self.result_widget = result_widget hbox = QHBoxLayout() hbox.addWidget(self.find_button) hbox.addWidget(self.cancel_button) #main section find_group_box = QGroupBox(translations.TR_MAIN) grid = QGridLayout() grid.addWidget(QLabel(translations.TR_TEXT), 0, 0) grid.addWidget(self.pattern_line_edit, 0, 1) grid.addWidget(QLabel(translations.TR_DIRECTORY), 1, 0) grid.addWidget(self.dir_combo, 1, 1) grid.addWidget(self.open_button, 1, 2) grid.addWidget(QLabel(translations.TR_FILTER), 2, 0) grid.addWidget(self.filters_line_edit, 2, 1) grid.addWidget(self.check_replace, 3, 0) grid.addWidget(self.replace_line, 3, 1) find_group_box.setLayout(grid) #add main section to MAIN LAYOUT main_vbox.addWidget(find_group_box) #options sections options_group_box = QGroupBox(translations.TR_OPTIONS) gridOptions = QGridLayout() gridOptions.addWidget(self.case_checkbox, 0, 0) gridOptions.addWidget(self.type_checkbox, 1, 0) gridOptions.addWidget(self.recursive_checkbox, 2, 0) gridOptions.addWidget(self.phrase_radio, 0, 1) gridOptions.addWidget(self.words_radio, 1, 1) options_group_box.setLayout(gridOptions) #add options sections to MAIN LAYOUT main_vbox.addWidget(options_group_box) #add buttons to MAIN LAYOUT main_vbox.addLayout(hbox) #Focus self.pattern_line_edit.setFocus() self.open_button.setFocusPolicy(Qt.NoFocus) #signal self.connect(self.open_button, SIGNAL("clicked()"), self._select_dir) self.connect(self.find_button, SIGNAL("clicked()"), self._find_in_files) self.connect(self.cancel_button, SIGNAL("clicked()"), self._kill_thread) self.connect(self._find_thread, SIGNAL("found_pattern(PyQt_PyObject)"), self._found_match) self.connect(self._find_thread, SIGNAL("finished()"), self._find_thread_finished) self.connect(self.type_checkbox, SIGNAL("stateChanged(int)"), self._change_radio_enabled) self.connect(self.check_replace, SIGNAL("stateChanged(int)"), self._replace_activated) self.connect(self.words_radio, SIGNAL("clicked(bool)"), self._words_radio_pressed) def _replace_activated(self): """If replace is activated, display the replace widgets.""" self.replace_line.setEnabled(self.check_replace.isChecked()) self.phrase_radio.setChecked(True) def _words_radio_pressed(self, value): """If search by independent words is activated, replace is not.""" self.replace_line.setEnabled(not value) self.check_replace.setChecked(not value) self.words_radio.setChecked(True) def _change_radio_enabled(self, val): """Control the state of the radio buttons.""" enabled = not self.type_checkbox.isChecked() self.phrase_radio.setEnabled(enabled) self.words_radio.setEnabled(enabled) def show(self, actual_project=None, actual=None): """Display the dialog and load the projects.""" self.dir_combo.clear() self.dir_name_root = actual_project if \ actual_project else [self.user_home] self.dir_combo.addItems(self.dir_name_root) if actual: index = self.dir_combo.findText(actual) self.dir_combo.setCurrentIndex(index) super(FindInFilesDialog, self).show() self.pattern_line_edit.setFocus() def reject(self): """Close the dialog and hide the tools dock.""" self._kill_thread() tools_dock = IDE.get_service('tools_dock') if tools_dock: tools_dock.hide() super(FindInFilesDialog, self).reject() def _find_thread_finished(self): """Wait on thread finished.""" self.emit(SIGNAL("finished()")) self._find_thread.wait() def _select_dir(self): """When a new folder is selected, add to the combo if needed.""" dir_name = QFileDialog.getExistingDirectory(self, translations.TR_OPEN, self.dir_combo.currentText(), QFileDialog.ShowDirsOnly) index = self.dir_combo.findText(dir_name) if index >= 0: self.dir_combo.setCurrentIndex(index) else: self.dir_combo.insertItem(0, dir_name) self.dir_combo.setCurrentIndex(0) def _found_match(self, result): """Update the tree for each match found.""" file_name = result[0] items = result[1] self.result_widget.update_result( self.dir_combo.currentText(), file_name, items) def _kill_thread(self): """Kill the thread.""" if self._find_thread.isRunning(): self._find_thread.cancel() self.accept() def _find_in_files(self): """Trigger the search on the files.""" self.emit(SIGNAL("findStarted()")) self._kill_thread() self.result_widget.clear() pattern = self.pattern_line_edit.text() dir_name = self.dir_combo.currentText() filters = re.split("[,;]", self.filters_line_edit.text()) #remove the spaces in the words Ex. (" *.foo"--> "*.foo") filters = [f.strip() for f in filters] case_sensitive = self.case_checkbox.isChecked() type_ = QRegExp.RegExp if \ self.type_checkbox.isChecked() else QRegExp.FixedString recursive = self.recursive_checkbox.isChecked() by_phrase = True if self.phrase_radio.isChecked() or self.type_checkbox.isChecked(): regExp = QRegExp(pattern, case_sensitive, type_) elif self.words_radio.isChecked(): by_phrase = False type_ = QRegExp.RegExp pattern = '|'.join( [word.strip() for word in pattern.split()]) regExp = QRegExp(pattern, case_sensitive, type_) #save a reference to the root directory where we find self.dir_name_root = dir_name self._find_thread.find_in_files(dir_name, filters, regExp, recursive, by_phrase)
class I4CheckWindow(QWidget): def __init__(self, parent=None): QWidget.__init__(self, parent) self.setup_model() self.tableview = QTableView() self.tableview.setSelectionMode(QAbstractItemView.NoSelection) self.tableview.setEditTriggers(QAbstractItemView.DoubleClicked) self.cbdelegate = CheckBoxDelegate() self.tableview.setItemDelegate(self.cbdelegate) self.tableview.setAutoScroll(False) self.tableview.setModel(self.model) self.tableview.sortByColumn(0, Qt.AscendingOrder) self.adjust_headers() #self.model.setHeaderData(0, Qt.Horizontal, u"") #self.model.setHeaderData(1, Qt.Horizontal, u"Title") self.radio_all = QRadioButton("All") self.radio_all.setChecked(True) self.radio_need = QRadioButton("Need") self.connect(self.radio_all, SIGNAL("toggled(bool)"), self.set_show_all) label = QLabel("DB:") label.setFixedWidth(40) label.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter) self.db_combo = QComboBox() self.populate_db_combo() self.connect( self.db_combo, SIGNAL("currentIndexChanged(int)"), self.db_index_changed) self.new_button = QPushButton("New") self.connect(self.new_button, SIGNAL("clicked()"), self.new_item) self.box = QVBoxLayout(self) self.box.addWidget(self.tableview) self.button_box = QHBoxLayout() self.button_box.setSpacing(0) self.button_box.addWidget(self.new_button) self.button_box.addWidget(self.radio_all) self.button_box.addWidget(self.radio_need) self.button_box.addWidget(label) self.button_box.addWidget(self.db_combo) self.box.addLayout(self.button_box) # self.setStyleSheet(""" # QComboBox { # font-size: 16px; # } # """) self.dwim_after_load() def dwim_after_load(self): if self.model.need_anything(): self.radio_need.setChecked(True) return self.radio_all.setChecked(True) if self.model.model.rowCount() == 0: edit_index = self.model.new() self.tableview.setCurrentIndex(edit_index) self.tableview.scrollTo(edit_index) self.tableview.edit(edit_index) def adjust_headers(self): log.debug("adjust_sizes()") self.tableview.horizontalHeader().setResizeMode(0, QHeaderView.Stretch) self.tableview.setColumnWidth(0, 1) self.tableview.verticalHeader().setDefaultSectionSize(ITEM_HEIGHT) self.tableview.verticalHeader().hide() self.tableview.horizontalHeader().hide() def setup_model(self): self.model = CheckListModel() def new_item(self): index = self.model.new() self.tableview.setCurrentIndex(index) self.tableview.resizeRowToContents(index.row()) self.tableview.scrollTo(index) self.tableview.edit(index) def set_show_all(self, show_all): if self.model.show_all == show_all: return self.model.set_show_all(show_all) self.tableview.resizeRowsToContents() def save(self): self.model.save() def checkout(self): if QMessageBox.question( self, "Checkout", "Are you sure you want to check out?", QMessageBox.Yes | QMessageBox.No, QMessageBox.No) == \ QMessageBox.Yes: self.model.checkout() def reset_items(self): if QMessageBox.question( self, "Checkout", "Are you sure you want to reset the list?", QMessageBox.Yes | QMessageBox.No, QMessageBox.No) == \ QMessageBox.Yes: self.model.reset_items() self.radio_all.setChecked(True) def delete_database(self): if QMessageBox.question( self, "Delete database", "Are you sure you want to delete the current database?", QMessageBox.Yes | QMessageBox.No, QMessageBox.No) == \ QMessageBox.Yes: self.model.delete_database() self.populate_db_combo() self.dwim_after_load() _loading_db_combo = False def populate_db_combo(self): self._loading_db_combo = True try: self.db_combo.clear() for db_name in self.model.databases: self.db_combo.addItem(re.sub("\\.org$", "", db_name), db_name) self.db_combo.addItem("New database...", "") self.db_combo.setCurrentIndex( self.model.databases.index(self.model.current_db)) finally: self._loading_db_combo = False def db_index_changed(self, index): if self._loading_db_combo: return db_name = str(self.db_combo.itemData(index).toPyObject()) if db_name == self.model.current_db: return self.model.save() if db_name: self.model.load(db_name) self.dwim_after_load() return db_name, ok = QInputDialog.getText( self, "New Database", "Enter database name") if ok: if not re.match(r"^[\w-]+$", db_name): QMessageBox.critical( self, "Error", "Database name must contain only the following chars: " "A-Z a-z 0-9 _ -") ok = False elif db_name in self.model.databases: QMessageBox.critical( self, "Error", "Database '%s' already exists" % db_name) ok = False if not ok: self.db_combo.setCurrentIndex( self.model.databases.index(self.model.current_db)) return db_name = str(db_name) + ".org" self.model.load(db_name) self.populate_db_combo() self.dwim_after_load()
class AdvancedObjectWidget(QWidget): def __init__(self, index, currentTemplate="classic.html", parent=None, entryTemplate = None): QWidget.__init__(self, parent) w = 24 h = 24 self.entryModel = None # Standard pixmaps used by the widget self.reloadPixmap = pixmapFromTheme( "view-refresh", ":/icons/32/view-refresh", w, h) self.savePixmap = pixmapFromTheme( "document-save", ":/icons/32/document-save",w, h) self.addPixmap = pixmapFromTheme( "list-add", ":/icons/32/list-add", w, h) self.deleteSmallPixmap = pixmapFromTheme( "list-remove", ":/icons/32/list-remove", w, h) self.treeIndex = index self.setLayout(QVBoxLayout(self)) self.layout().setSpacing(0) self.layout().setContentsMargins(0, 0, 0, 0) self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) # create the widget containing the data self.textBrowser = QTextBrowser() self.textBrowser.setOpenLinks(False) self.textBrowser.setWordWrapMode(QTextOption.WrapAnywhere) self.layout().addWidget(self.textBrowser) self.textBrowser.anchorClicked.connect(self.anchorClicked) self.currentDocument = '' self.addingToComboBox = False # create the combobox containing the different views self.comboBox = QComboBox() self.currentTemplate = currentTemplate self.errorTemplate = "error.html" self.usedTemplates = [] # FIXED: Need a more robust way for locating the path used in # the TemplateFactory for locating the template view # files # >>> with base.util.Paths.getLumaRoot this should work. # Probably needs some validation testing on platforms # other than Linux # Another issue occured when running Luma after a installation # from a source distribution. Because the site-packages is only # intended for pure python modules, the html templates is not # installed, resulting in an Exception when trying to view an # entry in the Browser plugin. The setup.py script is modified # such that the needed html templates is copied into a folder # in the path returned by `base.util.Paths.getConfigPrefix`. s = QtCore.QSettings() configPrefix = s.value('application/config_prefix').toString() templatesPath = os.path.join(unicode(configPrefix).encode('utf-8'), 'browser-templates') # If we run Luma from a development environment the isntalled # templatesPath do most likely not exist. We therefore use the # directory in the repository if not os.path.isdir(templatesPath): templatesPath = unicode( os.path.join( getLumaRoot(), 'plugins', 'browser', 'templates') ) self.templateFactory = TemplateFactory(templatesPath) self.htmlParser = HtmlParser(self.textBrowser) self.str_RELOAD= QtCore.QCoreApplication.translate("AdvancedObjectWidget", "Reload") self.str_SAVE = QtCore.QCoreApplication.translate("AdvancedObjectWidget", "Save entry") self.str_SAVE_CONTINUE = QtCore.QCoreApplication.translate("AdvancedObjectWidget", "Do you want to save the entry before continuing?") self.str_SAVE_FAILED = QtCore.QCoreApplication.translate("AdvancedObjectWidget", "Saving failed, continue anyway?") self.str_DELETE = QtCore.QCoreApplication.translate("AdvancedObjectWidget", "Delete object") self.str_DELETE_CONFIRM = QtCore.QCoreApplication.translate("AdvancedObjectWidget", "Do you really want to delete the object?") self.str_ADD = QtCore.QCoreApplication.translate("AdvancedObjectWidget", "Add attribute") self.str_SWITCH_VIEWS = QtCore.QCoreApplication.translate("AdvancedObjectWidget", "Switch between views") self.str_REASON = QtCore.QCoreApplication.translate("AdvancedObjectWidget", "Reason:") self.str_EXPORT_BINARY = QtCore.QCoreApplication.translate("AdvancedObjectWidget", "Export binary attribute to file") self.str_EXPORT_BINARY_EXCEPT = QtCore.QCoreApplication.translate("AdvancedObjectWidget", "Could not export binary data to file.") self.str_SELECT_ANOTHER_FILE = QtCore.QCoreApplication.translate("AdvancedObjectWidget", "Please select another filename.") self.str_NO_TEMPLATE = QtCore.QCoreApplication.translate("AdvancedObjectWidget", "No templates available") self.str_MISSING_ENTRY = QtCore.QCoreApplication.translate("AdvancedObjectWidget", "Did'nt receive a ldap-object, it might have been deleted") self.str_ENTRY_INVALID = QtCore.QCoreApplication.translate("AdvancedObjectWidget", "The ldap object is not valid\nClick Yes to view the object anyway\nNo to view the errors \nIgnore to view the object and ignore this message in later attempts.") self.buildToolBar() ############################################################################### @staticmethod def smartObjectCopy(smartObject): return SmartDataObject(copy.deepcopy([smartObject.dn, smartObject.data]), copy.deepcopy(smartObject.serverMeta)) ############################################################################### def getSmartObject(self): return self.entryModel.getSmartObject() ############################################################################### def initModel(self, smartObject, create=False, entryTemplate = None): """ sets up the model, and connects it to this object """ if not create: # use a copy of the smartObject smartObject = AdvancedObjectWidget.smartObjectCopy(smartObject) self.baseDN = smartObject.getDN() self.entryModel = EntryModel(smartObject, self, entryTemplate) self.htmlParser.setModel(self.entryModel) self.entryModel.modelChangedSignal.connect(self.modelChanged) success, exceptionMsg, exceptionObject = self.entryModel.initModel(create) if not success: errorMsg = "%s<br><br>%s: %s" % (exceptionMsg, self.str_REASON, str(exceptionObject)) QMessageBox.critical(self, self.trUtf8(""), self.trUtf8(errorMsg)) ############################################################################### def loadTemplates(self): """ Loads all templates that matches with the current objectclasses """ self.usedTemplates = [] objectClasses = self.getSmartObject().getObjectClasses() newIndex = -1 i = 0 for objectClass, fileName in self.templateFactory.getTemplateList(): if objectClass == '' or objectClass in objectClasses: if fileName == self.currentTemplate: newIndex = i self.usedTemplates.append(fileName) i += 1 if newIndex == -1: newIndex = 0 self.currentTemplate = self.usedTemplates[newIndex] #TODO do this properly, signals ignored self.addingToComboBox = True self.comboBox.clear() self.comboBox.addItems(self.usedTemplates) self.comboBox.setCurrentIndex(newIndex) self.addingToComboBox = False ############################################################################### @pyqtSlot(bool) def modelChanged(self, reload): if reload: item = None if self.treeIndex and self.treeIndex.isValid(): row = self.treeIndex.row() column = self.treeIndex.column() # QPersistenIndex doesn't have internalPointer() # so we aquire a QModelIndex which does item = self.treeIndex.sibling(row,column).internalPointer() if not(self.entryModel.VALID): if item == None or not(item.serverParent.ignoreItemErrors): result = QMessageBox.question(self, self.trUtf8(""), self.str_ENTRY_INVALID, QMessageBox.Yes | QMessageBox.No | QMessageBox.Ignore, QMessageBox.No) if result == QMessageBox.No: self.currentTemplate = self.errorTemplate elif result == QMessageBox.Ignore: if not(item == None): item.serverParent.ignoreItemErrors = True self.displayValues() ############################################################################### def displayValues(self): # Something went wrong. We have no data object. # This might happen if we want to refresh an item and # it might be deleted already. if None == self.entryModel.getSmartObject(): QMessageBox.critical(self, self.str_MISSING_ENTRY) self.enableToolButtons(False) return self.loadTemplates() if self.currentTemplate == None: selt.textBrowser.setHtml(self.str_NO_TEMPLATE) return htmlTemplate = self.templateFactory.getTemplateFile(self.currentTemplate) self.currentDocument = self.htmlParser.parseHtml(htmlTemplate) self.textBrowser.setHtml(self.currentDocument) self.enableToolButtons(True) ############################################################################### def enableToolButtons(self, enable): if None == self.entryModel: self.saveButton.setEnabled(False) self.deleteObjectButton.setEnabled(False) self.reloadButton.setEnabled(True) self.addAttributeButton.setEnabled(False) return if self.entryModel.EDITED and not self.entryModel.CREATE: self.saveButton.setEnabled(enable) else: self.saveButton.setEnabled(False) if self.entryModel.ISLEAF: self.deleteObjectButton.setEnabled(enable) else: self.deleteObjectButton.setEnabled(False) if self.entryModel.CREATE: self.reloadButton.setEnabled(False) else: self.reloadButton.setEnabled(enable) self.addAttributeButton.setEnabled(enable) ############################################################################### def buildToolBar(self): self.toolBar = QToolBar() self.toolBar.layout().setContentsMargins(0, 0, 0, 0) # Reload button self.reloadButton = QToolButton(self.toolBar) self.reloadButton.setIcon(QIcon(self.reloadPixmap)) self.reloadButton.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)) self.reloadButton.setAutoRaise(True) self.reloadButton.setBackgroundRole(self.backgroundRole()) self.reloadButton.setToolTip(self.str_RELOAD) self.connect(self.reloadButton, SIGNAL("clicked()"), self.refreshView) self.toolBar.addWidget(self.reloadButton) # Save button self.saveButton = QToolButton(self.toolBar) self.saveButton.setIcon(QIcon(self.savePixmap)) self.saveButton.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)) self.saveButton.setAutoRaise(True) self.saveButton.setBackgroundRole(self.backgroundRole()) self.saveButton.setToolTip(self.str_SAVE) self.connect(self.saveButton, SIGNAL("clicked()"), self.saveObject) self.toolBar.addWidget(self.saveButton) self.toolBar.addSeparator() # Add attribute button self.addAttributeButton = QToolButton(self.toolBar) self.addAttributeButton.setIcon(QIcon(self.addPixmap)) self.addAttributeButton.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)) self.addAttributeButton.setAutoRaise(True) self.addAttributeButton.setBackgroundRole(self.backgroundRole()) self.addAttributeButton.setToolTip(self.str_ADD) self.connect(self.addAttributeButton, SIGNAL("clicked()"), self.addAttribute) self.toolBar.addWidget(self.addAttributeButton) # Delete button self.deleteObjectButton = QToolButton(self.toolBar) self.deleteObjectButton.setIcon(QIcon(self.deleteSmallPixmap)) self.deleteObjectButton.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)) self.deleteObjectButton.setAutoRaise(True) self.deleteObjectButton.setBackgroundRole(self.backgroundRole()) self.deleteObjectButton.setToolTip(self.str_DELETE) self.connect(self.deleteObjectButton, SIGNAL("clicked()"), self.deleteObject) self.toolBar.addWidget(self.deleteObjectButton) self.comboBox.setToolTip(self.str_SWITCH_VIEWS) self.connect(self.comboBox, SIGNAL("currentIndexChanged(int)"), self.changeView) self.toolBar.addWidget(self.comboBox) self.enableToolButtons(False) self.layout().insertWidget(0, self.toolBar) ############################################################################### @pyqtSlot("int") def changeView(self, index): """ change between different views """ if index == -1 or self.addingToComboBox: return self.currentTemplate = self.usedTemplates[index] self.displayValues() ############################################################################### def aboutToChange(self): """ Asks the user whether changes should be saved returns True if changes were saved, or discarded """ if not self.entryModel.EDITED: return True result = QMessageBox.warning(self, self.str_SAVE, self.str_SAVE_CONTINUE, QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel, QMessageBox.Cancel) # TODO add exception message if result == QMessageBox.Save: if not self.saveObject(): # Saving failed result = QMessageBox.question(None, self.trUtf8(""), self.str_SAVE_FAILED, QMessageBox.Ok | QMessageBox.Cancel, QMessageBox.Cancel) return not(result == QMessageBox.Cancel) ############################################################################### # TODO: add logging for each error @pyqtSlot() def refreshView(self): """ Refreshes the LDAP data from server and displays values. """ if self.aboutToChange(): success, exceptionMsg, exceptionObject = self.entryModel.reloadModel() if not success: errorMsg = "%s<br><br>%s: %s" % (exceptionMsg, self.str_REASON, str(exceptionObject)) QMessageBox.critical(self, self.trUtf8(""), self.trUtf8(errorMsg)) else: self.displayValues() ############################################################################### # TODO: add logging for each error @pyqtSlot() def saveObject(self): success, exceptionMsg, exceptionObject = self.entryModel.saveModel() if not success: # Saving failed errorMsg = "%s<br><br>%s: %s" % (exceptionMsg, self.str_REASON, str(exceptionObject)) QMessageBox.critical(self, self.trUtf8(""), self.trUtf8(errorMsg)) return False else: # update the smartObject in the tree if self.entryModel.CREATE: pass elif self.treeIndex and self.treeIndex.isValid(): row = self.treeIndex.row() column = self.treeIndex.column() # QPersistenIndex doesn't have internalPointer() # so we aquire a QModelIndex which does index = self.treeIndex.sibling(row,column) index.internalPointer().itemData = self.getSmartObject() return True ############################################################################### @pyqtSlot() def addAttribute(self): """ Add attributes to the current object. """ dialog = AddAttributeWizard(self) dialog.setData(self.smartObjectCopy(self.entryModel.getSmartObject())) dialog.exec_() if dialog.result() == QDialog.Rejected: return attribute = str(dialog.attributeBox.currentText()) showAll = dialog.enableAllBox.isChecked() if dialog.binaryBox.isChecked(): attributeSet = set([attribute + ";binary"]) else: attributeSet = set([attribute]) if showAll and not(attribute.lower() in dialog.possibleAttributes): objectClass = str(dialog.classBox.currentItem().text()) self.entryModel.addObjectClass(objectClass) serverSchema = ObjectClassAttributeInfo(self.entryModel.smartObject.getServerMeta()) mustAttributes = serverSchema.getAllMusts([objectClass]) mustAttributes = mustAttributes.difference(set(self.entryModel.smartObject.getAttributeList())) attributeSet = mustAttributes.union(set([attribute])) for x in attributeSet: self.entryModel.addAttributeValue(x, None) self.displayValues() ############################################################################### # TODO: add logging for each error, remove tab and node from parent @pyqtSlot() def deleteObject(self): buttonClicked = QMessageBox.critical(self, self.str_DELETE, self.str_DELETE_CONFIRM, QMessageBox.Yes, QMessageBox.No) if not (buttonClicked == QMessageBox.Yes): return # If we have an index, use it tell the item to delete itself # so that the view is updated if self.treeIndex and self.treeIndex.isValid(): row = self.treeIndex.row() column = self.treeIndex.column() # QPersistenIndex doesn't have internalPointer() # so we aquire a QModelIndex which does index = self.treeIndex.sibling(row,column) success, message = index.model().deleteItem(index) if success: self.enableToolButtons(False) self.deleteLater() else: errorMsg = "%s" % (message) QMessageBox.critical(self, self.trUtf8(""), self.trUtf8(errorMsg)) # if not, we just delete it ourselves since there's not view on the object else: success, message, exceptionObject = self.entryModel.deleteObject() if success: self.enableToolButtons(False) self.deleteLater() else: errorMsg = "%s<br><br>%s: %s" % (message, self.str_REASON, str(exceptionObject)) QMessageBox.critical(self, self.trUtf8(""), self.trUtf8(errorMsg)) ############################################################################### @pyqtSlot("QUrl") def anchorClicked(self, url): """ Called when an anchor (<a href=".." /> is clicked """ nameString = unicode(url.toString()) tmpList = nameString.split("__") if tmpList[0] in self.entryModel.getSmartObject().getObjectClasses(): self.entryModel.deleteObjectClass(tmpList[0]) else: if not len(tmpList) == 3: return attributeName, index, operation = tmpList[0], int(tmpList[1]), tmpList[2] if operation == "edit": self.editAttribute(attributeName, index) elif operation == "delete": self.deleteAttribute(attributeName, index) elif operation == "export": self.exportAttribute(attributeName, index) ############################################################################### def editAttribute(self, attributeName, index): smartObject = self.entryModel.getSmartObject() oldDN = smartObject.getDN() addAttribute = False if attributeName == 'RDN': # TODO correct this, used on creation? oldValue = oldDN smartObject.setDN(self.baseDN) else: if smartObject.hasAttribute(attributeName): addValue = False oldValue = smartObject.getAttributeValue(attributeName, index) if oldValue == None: oldValue = '' else: addValue = True oldValue = '' dialog = getEditorWidget(self, smartObject, attributeName, index) dialog.exec_() if dialog.result() == QDialog.Accepted: # TODO check attribute types newValue = dialog.getValue() if not (newValue == None): if attributeName == 'RDN': self.entryModel.setDN(newValue) if dialog.addAttributeBox.isChecked(): addAttribute = unicode(dialog.attributeBox.currentText()) addValue = unicode(dialog.valueEdit.text()) self.entryModel.addAttributeValue(addAttribute, [addValue]) else: if addValue: self.entryModel.addAttributeValue(attributeName, [newValue]) else: self.entryModel.editAttribute(attributeName, index, newValue) else: if attributeName == 'RDN': smartObject.setDN(oldDN.decode('utf-8')) ############################################################################### def deleteAttribute(self, attributeName, index): self.entryModel.deleteAttribute(attributeName, index) ############################################################################### def exportAttribute(self, attributeName, index): """ Show the dialog for exporting binary attribute data. """ value = self.getSmartObject().getAttributeValue(attributeName, index) fileName = unicode(QFileDialog.getSaveFileName(\ self, self.str_EXPORT_BINARY, QString(""), "All files (*)", None)) if unicode(fileName) == "": return try: fileHandler = open(fileName, "w") fileHandler.write(value) fileHandler.close() SAVED = True except IOError, e: msg = "%s %s:\n\n%s\n\n%s" % (self.str_EXPORT_BINARY_EXCEPT, self.str_REASON, str(e), self.str_SELECT_ANOTHER_FILE) result = QMessageBox.warning(\ self, self.str_EXPORT_BINARY, msg, QMessageBox.Cancel | QMessageBox.Ok, QMessageBox.Cancel)
class ActionBar(QFrame): """ SIGNALS: @changeCurrent(PyQt_PyObject) @runFile(QString) @reopenTab(QString) @recentTabsModified() """ def __init__(self, main_combo=False): super(ActionBar, self).__init__() self.setObjectName("actionbar") hbox = QHBoxLayout(self) hbox.setContentsMargins(1, 1, 1, 1) hbox.setSpacing(1) self.lbl_checks = QLabel('') self.lbl_checks.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) self.lbl_checks.setFixedWidth(48) self.lbl_checks.setVisible(False) hbox.addWidget(self.lbl_checks) self.combo = ComboFiles() self.combo.setIconSize(QSize(16, 16)) #model = QStandardItemModel() #self.combo.setModel(model) #self.combo.view().setDragDropMode(QAbstractItemView.InternalMove) self.combo.setMaximumWidth(300) self.combo.setObjectName("combotab") self.connect(self.combo, SIGNAL("currentIndexChanged(int)"), self.current_changed) self.combo.setToolTip(translations.TR_COMBO_FILE_TOOLTIP) self.combo.setContextMenuPolicy(Qt.CustomContextMenu) self.connect(self.combo, SIGNAL( "customContextMenuRequested(const QPoint &)"), self._context_menu_requested) hbox.addWidget(self.combo) self.symbols_combo = QComboBox() self.symbols_combo.setIconSize(QSize(16, 16)) self.symbols_combo.setObjectName("combo_symbols") self.connect(self.symbols_combo, SIGNAL("activated(int)"), self.current_symbol_changed) hbox.addWidget(self.symbols_combo) self.code_navigator = CodeNavigator() hbox.addWidget(self.code_navigator) self._pos_text = "Line: %d, Col: %d" self.lbl_position = QLabel(self._pos_text % (0, 0)) self.lbl_position.setObjectName("position") self.lbl_position.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) hbox.addWidget(self.lbl_position) self.btn_close = QPushButton( self.style().standardIcon(QStyle.SP_DialogCloseButton), '') self.btn_close.setIconSize(QSize(16, 16)) if main_combo: self.btn_close.setObjectName('navigation_button') self.btn_close.setToolTip(translations.TR_CLOSE_FILE) self.connect(self.btn_close, SIGNAL("clicked()"), self.about_to_close_file) else: self.btn_close.setObjectName('close_split') self.btn_close.setToolTip(translations.TR_CLOSE_SPLIT) self.connect(self.btn_close, SIGNAL("clicked()"), self.close_split) self.btn_close.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) hbox.addWidget(self.btn_close) def resizeEvent(self, event): super(ActionBar, self).resizeEvent(event) if event.size().width() < 350: self.symbols_combo.hide() self.code_navigator.hide() self.lbl_position.hide() else: self.symbols_combo.show() self.code_navigator.show() self.lbl_position.show() def add_item(self, text, neditable): """Add a new item to the combo and add the neditable data.""" self.combo.addItem(text, neditable) self.combo.setCurrentIndex(self.combo.count() - 1) def get_editables(self): editables = [] for index in range(self.combo.count()): neditable = self.combo.itemData(index) editables.append(neditable) return editables def add_symbols(self, symbols): """Add the symbols to the symbols's combo.""" self.symbols_combo.clear() for symbol in symbols: data = symbol[1] if data[1] == 'f': icon = QIcon(":img/function") else: icon = QIcon(":img/class") self.symbols_combo.addItem(icon, data[0]) def set_current_symbol(self, index): self.symbols_combo.setCurrentIndex(index) def update_item_icon(self, neditable, icon): index = self.combo.findData(neditable) self.combo.setItemIcon(index, icon) def update_item_text(self, neditable, text): index = self.combo.findData(neditable) self.combo.setItemText(index, text) def current_changed(self, index): """Change the current item in the combo.""" neditable = self.combo.itemData(index) self.emit(SIGNAL("changeCurrent(PyQt_PyObject, int)"), neditable, index) def current_symbol_changed(self, index): """Change the current symbol in the combo.""" self.emit(SIGNAL("goToSymbol(int)"), index) def update_line_col(self, line, col): """Update the line and column position.""" self.lbl_position.setText(self._pos_text % (line, col)) def _context_menu_requested(self, point): """Display context menu for the combo file.""" if self.combo.count() == 0: # If there is not an Editor opened, don't show the menu return menu = QMenu() actionAdd = menu.addAction(translations.TR_ADD_TO_PROJECT) actionRun = menu.addAction(translations.TR_RUN_FILE) menuSyntax = menu.addMenu(translations.TR_CHANGE_SYNTAX) self._create_menu_syntax(menuSyntax) menu.addSeparator() actionClose = menu.addAction(translations.TR_CLOSE_FILE) actionCloseAll = menu.addAction(translations.TR_CLOSE_ALL_FILES) actionCloseAllNotThis = menu.addAction( translations.TR_CLOSE_OTHER_FILES) menu.addSeparator() actionSplitH = menu.addAction(translations.TR_SPLIT_VERTICALLY) actionSplitV = menu.addAction(translations.TR_SPLIT_HORIZONTALLY) menu.addSeparator() actionCopyPath = menu.addAction( translations.TR_COPY_FILE_PATH_TO_CLIPBOARD) actionShowFileInExplorer = menu.addAction( translations.TR_SHOW_FILE_IN_EXPLORER) actionReopen = menu.addAction(translations.TR_REOPEN_FILE) actionUndock = menu.addAction(translations.TR_UNDOCK_EDITOR) if len(settings.LAST_OPENED_FILES) == 0: actionReopen.setEnabled(False) #Connect actions self.connect(actionSplitH, SIGNAL("triggered()"), lambda: self._split(False)) self.connect(actionSplitV, SIGNAL("triggered()"), lambda: self._split(True)) self.connect(actionRun, SIGNAL("triggered()"), self._run_this_file) self.connect(actionAdd, SIGNAL("triggered()"), self._add_to_project) self.connect(actionClose, SIGNAL("triggered()"), self.about_to_close_file) self.connect(actionCloseAllNotThis, SIGNAL("triggered()"), self._close_all_files_except_this) self.connect(actionCloseAll, SIGNAL("triggered()"), self._close_all_files) self.connect(actionCopyPath, SIGNAL("triggered()"), self._copy_file_location) self.connect(actionShowFileInExplorer, SIGNAL("triggered()"), self._show_file_in_explorer) self.connect(actionReopen, SIGNAL("triggered()"), self._reopen_last_tab) self.connect(actionUndock, SIGNAL("triggered()"), self._undock_editor) menu.exec_(QCursor.pos()) def _create_menu_syntax(self, menuSyntax): """Create Menu with the list of syntax supported.""" syntax = list(settings.SYNTAX.keys()) syntax.sort() for syn in syntax: menuSyntax.addAction(syn) self.connect(menuSyntax, SIGNAL("triggered(QAction*)"), self._reapply_syntax) def _reapply_syntax(self, syntaxAction): #TODO if [self.currentIndex(), syntaxAction] != self._resyntax: self._resyntax = [self.currentIndex(), syntaxAction] self.emit(SIGNAL("syntaxChanged(QWidget, QString)"), self.currentWidget(), syntaxAction.text()) def set_current_file(self, neditable): index = self.combo.findData(neditable) self.combo.setCurrentIndex(index) def set_current_by_index(self, index): self.combo.setCurrentIndex(index) def about_to_close_file(self, index=None): """Close the NFile object.""" if index is None: index = self.combo.currentIndex() neditable = self.combo.itemData(index) if neditable: neditable.nfile.close() def close_split(self): self.emit(SIGNAL("closeSplit()")) def close_file(self, neditable): """Receive the confirmation to close the file.""" index = self.combo.findData(neditable) self.combo.removeItem(index) return index def _run_this_file(self): """Execute the current file.""" neditable = self.combo.itemData(self.combo.currentIndex()) self.emit(SIGNAL("runFile(QString)"), neditable.file_path) def _add_to_project(self): """Emit a signal to let someone handle the inclusion of the file inside a project.""" neditable = self.combo.itemData(self.combo.currentIndex()) self.emit(SIGNAL("addToProject(QString)"), neditable.file_path) def _show_file_in_explorer(self): '''Triggered when the "Show File in Explorer" context menu action is selected. Emits the "showFileInExplorer(QString)" signal with the current file's full path as argument.''' neditable = self.combo.itemData(self.combo.currentIndex()) self.emit(SIGNAL("showFileInExplorer(QString)"), neditable.file_path) def _reopen_last_tab(self): self.emit(SIGNAL("reopenTab(QString)"), settings.LAST_OPENED_FILES.pop()) self.emit(SIGNAL("recentTabsModified()")) def _undock_editor(self): self.emit(SIGNAL("undockEditor()")) def _split(self, orientation): self.emit(SIGNAL("splitEditor(bool)"), orientation) def _copy_file_location(self): """Copy the path of the current opened file to the clipboard.""" neditable = self.combo.itemData(self.combo.currentIndex()) QApplication.clipboard().setText(neditable.file_path, QClipboard.Clipboard) def _close_all_files(self): """Close all the files opened.""" for i in range(self.combo.count()): self.about_to_close_file(0) def _close_all_files_except_this(self): """Close all the files except the current one.""" neditable = self.combo.itemData(self.combo.currentIndex()) for i in reversed(list(range(self.combo.count()))): ne = self.combo.itemData(i) if ne is not neditable: self.about_to_close_file(i)
class RangeByStrSettingUI(QDialog): def __init__(self, iface, parent=None): super(RangeByStrSettingUI, self).__init__() self.iface = iface self.parent = parent self.iface.mapCanvas().currentLayerChanged[QgsMapLayer].connect(self.LayerChanged) self.color_btn_list = [] # 保存各范围所设置的颜色按钮 self.delete_btn_list = [] # 保存各范围所设置的删除按钮 self.value_widget_list = [] self.setting_list = [] # 保存参数设置 self.setWindowTitle(u"分类显示") layer_label = QLabel(u"选择图层:") self.layer_combo = QComboBox() layers_name = getAllLayerName(self.iface) self.layer_combo.addItems(layers_name) self.layer = getLayerByName(self.layer_combo.currentText(), self.iface) self.connect(self.layer_combo, SIGNAL('currentIndexChanged(int)'), self.layerListener) field_label = QLabel(u"选择字段:") self.field_combo = QComboBox() if self.layer != None: fields_list = [] for field in self.layer.pendingFields(): fields_list.append(field.name().strip()) self.field_combo.addItems(fields_list) ok = QPushButton(u"确定") cancel = QPushButton(u"取消") self.connect(ok, SIGNAL('clicked()'), self.run) self.connect(cancel, SIGNAL('clicked()'), self.accept) # 选择图层、字段Widget source_grid = QGridLayout() source_grid.setSpacing(10) source_grid.addWidget(layer_label, 0, 1) source_grid.addWidget(self.layer_combo, 0, 2) source_grid.addWidget(field_label, 1, 1) source_grid.addWidget(self.field_combo, 1, 2) source_widget = QWidget() source_widget.setLayout(source_grid) # 参数设置窗口(带滚动条) self.setting_Widget = QWidget() self.setting_Widget.setMinimumSize(380, 800) self.scroll_vbox = QVBoxLayout() self.scroll_vbox.setSpacing(15) self.setting_vbox = QVBoxLayout() self.setting_vbox.setSpacing(5) value_widget = self.createAValue() self.setting_vbox.addWidget(value_widget) self.add_range_btn = QPushButton(u"添加") self.connect(self.add_range_btn, SIGNAL("clicked()"), self.add_value_box) self.scroll_vbox.addLayout(self.setting_vbox) self.scroll_vbox.addWidget(self.add_range_btn) self.scroll_vbox.addStretch(1) self.setting_Widget.setLayout(self.scroll_vbox) self.scroll = QScrollArea() self.scroll.setWidget(self.setting_Widget) self.scroll.setAutoFillBackground(True) self.scroll.setWidgetResizable(True) # 确定/取消 按钮 Widget btn_hbox = QHBoxLayout() btn_hbox.setSpacing(15) btn_hbox.addStretch(1) btn_hbox.addWidget(ok) btn_hbox.addWidget(cancel) btn_hbox.addStretch(1) btn_widget = QWidget() btn_widget.setLayout(btn_hbox) vbox = QVBoxLayout() vbox.setSpacing(15) vbox.addWidget(source_widget) vbox.addWidget(self.scroll) vbox.addWidget(btn_widget) self.setLayout(vbox) self.setFixedSize(430, 500) # 生成一个范围设置控件组(Wigget) def createAValue(self, color_value=u"yellow", value=u""): delete_btn = QPushButton(self) delete_icon = QIcon(os.path.join(cmd_folder, u"..", u'images', u'delete.png')) delete_btn.setIcon(delete_icon) delete_btn.setIconSize(QSize(25, 25)) delete_btn.setFixedSize(30, 30) delete_btn.setFocusPolicy(Qt.NoFocus) self.connect(delete_btn, SIGNAL("clicked()"), self.delete_value_box) color = QColor(color_value) color_btn = QPushButton(self) color_btn.setStyleSheet('QWidget {background-color:%s}' % color.name()) color_btn.clicked.connect(self.colordialog) value_edit = QLineEdit(value) # 搜索值 label1 = QLabel(u" : ") value_widget = QWidget() value_box = QHBoxLayout() value_box.setSpacing(10) value_box.addWidget(delete_btn) value_box.addWidget(color_btn) value_box.addWidget(label1) value_box.addWidget(value_edit) value_box.setStretchFactor(color_btn, 1.5) value_box.setStretchFactor(value_edit, 1) value_widget.setLayout(value_box) self.color_btn_list.append(color_btn) self.delete_btn_list.append(delete_btn) self.value_widget_list.append(value_widget) self.setting_list.append([color, value_edit]) return value_widget # 新增一个可设置的范围 def add_value_box(self): new_value_widget = self.createAValue() # 重新布局 self.setting_vbox.addWidget(new_value_widget) # 删除一组范围设置 def delete_value_box(self): delete_index = None delete_button = self.sender() # 获取信号来源 for (index, button) in enumerate(self.delete_btn_list): if button is delete_button: delete_index = index # 删除 widget if delete_index != None: value_widget = self.value_widget_list[delete_index] self.setting_vbox.removeWidget(value_widget) value_widget.deleteLater() del self.value_widget_list[delete_index] del self.color_btn_list[delete_index] del self.delete_btn_list[delete_index] del self.setting_list[delete_index] # 颜色设置对话框 def colordialog(self): col = QColorDialog.getColor() button = self.sender() # 获取信号来源 if col.isValid(): button.setStyleSheet('QWidget{background-color:%s}' % col.name()) for b in self.color_btn_list: if button is b: bindex = self.color_btn_list.index(b) self.setting_list[bindex][0] = col def layerListener(self): # 先清空原有的字段选择combobox self.field_combo.clear() # 获取所选图层名字 layer_name = self.layer_combo.currentText() self.layer = getLayerByName(layer_name, self.iface) # 获取所选图层的所有字段 if self.layer: fields_list = [] for field in self.layer.pendingFields(): fields_list.append(field.name().strip()) self.field_combo.addItems(fields_list) def run(self): # 先检查是否选中了图层 if not self.layer: self.accept() QMessageBox.critical(self, u"错误", u"<b>无法选中图层! <\b>") return False # 检查范围设置是否规范 setting_list = [] # 保存处理过的范围设置list (每个范围用元组保存) for (color, value_edit) in self.setting_list: value = value_edit.text().strip() # 如果上下限其中有一个为空,则提示错误 if not value: QMessageBox.critical(self, u"错误", u"<b>分类范围上下限不能为空! <\b>") return False setting_list.append((color, value)) field = self.field_combo.currentText().strip() # 获取所设置的字段 # 显示图例 self.accept() legend = RangeByStrLegend(self.iface, self) legend.showLegend(self.layer, field, setting_list) if not legend.isVisible(): legend.show() legend.exec_() def LayerChanged(self, currentlayer): if currentlayer != self.layer: self.iface.messageBar().pushMessage(u'提示', u'切换图层,分析停止', QgsMessageBar.INFO, 4) self.close()
class FindInFilesDialog(QDialog): def __init__(self, result_widget, parent): QDialog.__init__(self, parent) self._find_thread = FindInFilesThread() self.setWindowTitle("Find in files") self.resize(400, 300) #MAIN LAYOUT main_vbox = QVBoxLayout(self) self.pattern_line_edit = QLineEdit() self.dir_name_root = None self.user_home = os.path.expanduser('~') self.dir_combo = QComboBox() self.dir_combo.addItem(self.user_home) self.dir_combo.setEditable(True) self.open_button = QPushButton(QIcon(resources.IMAGES['find']), self.tr("Open")) self.filters_line_edit = QLineEdit("*.py") self.replace_line = QLineEdit() self.replace_line.setEnabled(False) self.check_replace = QCheckBox(self.tr("Replace: ")) self.case_checkbox = QCheckBox(self.tr("C&ase sensitive")) self.type_checkbox = QCheckBox(self.tr("R&egular Expression")) self.recursive_checkbox = QCheckBox(self.tr("Rec&ursive")) self.recursive_checkbox.setCheckState(Qt.Checked) self.phrase_radio = QRadioButton( self.tr("Search by Phrase (Exact Match).")) self.phrase_radio.setChecked(True) self.words_radio = QRadioButton( self.tr("Search for all the words " "(anywhere in the document, not together).")) self.find_button = QPushButton(self.tr("Find!")) self.find_button.setMaximumWidth(150) self.cancel_button = QPushButton(self.tr("Cancel")) self.cancel_button.setMaximumWidth(150) self.result_widget = result_widget hbox = QHBoxLayout() hbox.addWidget(self.find_button) hbox.addWidget(self.cancel_button) #main section find_group_box = QGroupBox(self.tr("Main")) grid = QGridLayout() grid.addWidget(QLabel(self.tr("Text: ")), 0, 0) grid.addWidget(self.pattern_line_edit, 0, 1) grid.addWidget(QLabel(self.tr("Directory: ")), 1, 0) grid.addWidget(self.dir_combo, 1, 1) grid.addWidget(self.open_button, 1, 2) grid.addWidget(QLabel(self.tr("Filter: ")), 2, 0) grid.addWidget(self.filters_line_edit, 2, 1) grid.addWidget(self.check_replace, 3, 0) grid.addWidget(self.replace_line, 3, 1) find_group_box.setLayout(grid) #add main section to MAIN LAYOUT main_vbox.addWidget(find_group_box) #options sections options_group_box = QGroupBox(self.tr("Options")) gridOptions = QGridLayout() gridOptions.addWidget(self.case_checkbox, 0, 0) gridOptions.addWidget(self.type_checkbox, 1, 0) gridOptions.addWidget(self.recursive_checkbox, 2, 0) gridOptions.addWidget(self.phrase_radio, 0, 1) gridOptions.addWidget(self.words_radio, 1, 1) options_group_box.setLayout(gridOptions) #add options sections to MAIN LAYOUT main_vbox.addWidget(options_group_box) #add buttons to MAIN LAYOUT main_vbox.addLayout(hbox) #Focus self.pattern_line_edit.setFocus() self.open_button.setFocusPolicy(Qt.NoFocus) #signal self.connect(self.open_button, SIGNAL("clicked()"), self._select_dir) self.connect(self.find_button, SIGNAL("clicked()"), self._find_in_files) self.connect(self.cancel_button, SIGNAL("clicked()"), self._kill_thread) self.connect(self._find_thread, SIGNAL("found_pattern(PyQt_PyObject)"), self._found_match) self.connect(self._find_thread, SIGNAL("finished()"), self._find_thread_finished) self.connect(self.type_checkbox, SIGNAL("stateChanged(int)"), self._change_radio_enabled) self.connect(self.check_replace, SIGNAL("stateChanged(int)"), self._replace_activated) self.connect(self.words_radio, SIGNAL("clicked(bool)"), self._words_radio_pressed) def _replace_activated(self): self.replace_line.setEnabled(self.check_replace.isChecked()) self.phrase_radio.setChecked(True) def _words_radio_pressed(self, value): self.replace_line.setEnabled(not value) self.check_replace.setChecked(not value) self.words_radio.setChecked(True) def _change_radio_enabled(self, val): enabled = not self.type_checkbox.isChecked() self.phrase_radio.setEnabled(enabled) self.words_radio.setEnabled(enabled) def show(self, actual_project=None, actual=None): self.dir_combo.clear() self.dir_name_root = actual_project if \ actual_project else [self.user_home] self.dir_combo.addItems(self.dir_name_root) if actual: index = self.dir_combo.findText(actual) self.dir_combo.setCurrentIndex(index) super(FindInFilesDialog, self).show() self.pattern_line_edit.setFocus() def reject(self): self._kill_thread() # Crazy hack to avoid circular imports self.result_widget.parent().parent().parent().hide() super(FindInFilesDialog, self).reject() def _find_thread_finished(self): self.emit(SIGNAL("finished()")) self._find_thread.wait() def _select_dir(self): dir_name = QFileDialog.getExistingDirectory( self, self.tr("Open Directory"), self.dir_combo.currentText(), QFileDialog.ShowDirsOnly) index = self.dir_combo.findText(dir_name) if index >= 0: self.dir_combo.setCurrentIndex(index) else: self.dir_combo.insertItem(0, dir_name) self.dir_combo.setCurrentIndex(0) def _found_match(self, result): file_name = result[0] items = result[1] self.result_widget.update_result(self.dir_combo.currentText(), file_name, items) def _kill_thread(self): if self._find_thread.isRunning(): self._find_thread.cancel() self.accept() def _find_in_files(self): self.emit(SIGNAL("findStarted()")) self._kill_thread() self.result_widget.clear() pattern = self.pattern_line_edit.text() dir_name = self.dir_combo.currentText() filters = re.split("[,;]", self.filters_line_edit.text()) # Version of PyQt API 1 # filters = self.filters_line_edit.text().split(QRegExp("[,;]"), # QString.SkipEmptyParts) #remove the spaces in the words Ex. (" *.foo"--> "*.foo") filters = [f.strip() for f in filters] case_sensitive = self.case_checkbox.isChecked() type_ = QRegExp.RegExp if \ self.type_checkbox.isChecked() else QRegExp.FixedString recursive = self.recursive_checkbox.isChecked() by_phrase = True if self.phrase_radio.isChecked() or self.type_checkbox.isChecked(): regExp = QRegExp(pattern, case_sensitive, type_) elif self.words_radio.isChecked(): by_phrase = False type_ = QRegExp.RegExp pattern = '|'.join([word.strip() for word in pattern.split()]) regExp = QRegExp(pattern, case_sensitive, type_) #save a reference to the root directory where we find self.dir_name_root = dir_name self._find_thread.find_in_files(dir_name, filters, regExp, recursive, by_phrase)
class ImageTab(QWidget): def __init__(self, parent): super(ImageTab, self).__init__(parent) self.parent = parent self.name = 'Images' self.formats = config.image_formats self.extra_img = config.image_extra_formats validator = QRegExpValidator(QRegExp(r'^[1-9]\d*'), self) converttoQL = QLabel(self.tr('Convert to:')) self.extQCB = QComboBox() self.extQCB.addItems(self.formats) commandQL = QLabel(self.tr('Extra options:')) self.commandQLE = QLineEdit() hlayout2 = utils.add_to_layout( 'h', converttoQL, self.extQCB, commandQL, self.commandQLE) sizeQL = QLabel( '<html><p align="center">' + self.tr('Image Size:') + '</p></html>') self.widthQLE = utils.create_LineEdit((50, 16777215), validator, 4) self.heightQLE = utils.create_LineEdit((50, 16777215), validator, 4) label = QLabel('<html><p align="center">x</p></html>') label.setMaximumWidth(25) hlayout1 = utils.add_to_layout('h', self.widthQLE, label,self.heightQLE) sizelayout = utils.add_to_layout('v', sizeQL, hlayout1) self.imgaspectQChB = QCheckBox(self.tr("Maintain aspect ratio")) self.autocropQChB = QCheckBox(self.tr("Auto-crop")) vlayout = utils.add_to_layout('v', self.imgaspectQChB,self.autocropQChB) rotateQL = QLabel( "<html><div align='center'>" + self.tr("Rotate") + ":</div><br>(" + self.tr("degrees - clockwise") + ")</html>") self.rotateQLE = utils.create_LineEdit((100, 16777215), validator, 3) self.vflipQChB = QCheckBox(self.tr('Vertical flip')) self.hflipQChB = QCheckBox(self.tr('Horizontal flip')) vlayout2 = utils.add_to_layout('v', self.vflipQChB, self.hflipQChB) hlayout3 = utils.add_to_layout( 'h', sizelayout, vlayout, rotateQL, self.rotateQLE, vlayout2, None) final_layout = utils.add_to_layout('v', hlayout2, hlayout3) self.setLayout(final_layout) def clear(self): """Clear self.widthQLE and self.heightQLE.""" self.widthQLE.clear() self.heightQLE.clear() self.commandQLE.clear() self.rotateQLE.clear() self.imgaspectQChB.setChecked(False) self.autocropQChB.setChecked(False) self.vflipQChB.setChecked(False) self.hflipQChB.setChecked(False) def fill_extension_combobox(self, extraformats): extraformats = [i for i in extraformats.split("\n")] if extraformats else [] self.extQCB.clear() self.extQCB.addItems(sorted(self.formats + extraformats)) def ok_to_continue(self): """ Check if everything is ok with imagetab to continue conversion. Check if: - ImageMagick is missing. - Either none or both size lineEdits are active at a time. Return True if all tests pass, else False. """ width = self.widthQLE.text() height = self.heightQLE.text() if not self.parent.imagemagick: QMessageBox.warning(self, 'FF Multi Converter - ' + self.tr( 'Error!'), self.tr('ImageMagick is not installed.\nYou will ' 'not be able to convert image files until you install it.')) return False if (width and not height) or (not width and height): QMessageBox.warning(self, 'FF Multi Converter - ' + self.tr( 'Error!'), self.tr('The size LineEdit may not be empty.')) if width and not height: self.heightQLE.setFocus() else: self.widthQLE.setFocus() return False return True def set_default_command(self): """Set the default value to self.commandQLE.""" self.clear() self.commandQLE.setText(self.parent.default_command_image)
class NewDocument(preferences.Group): def __init__(self, page): super(NewDocument, self).__init__(page) grid = QGridLayout() self.setLayout(grid) def changed(): self.changed.emit() self.combo.setEnabled(self.template.isChecked()) self.emptyDocument = QRadioButton(toggled=changed) self.lilyVersion = QRadioButton(toggled=changed) self.template = QRadioButton(toggled=changed) self.combo = QComboBox(currentIndexChanged=changed) grid.addWidget(self.emptyDocument, 0, 0, 1, 2) grid.addWidget(self.lilyVersion, 1, 0, 1, 2) grid.addWidget(self.template, 2, 0, 1, 1) grid.addWidget(self.combo, 2, 1, 1, 1) self.loadCombo() app.translateUI(self) def translateUI(self): self.setTitle(_("When creating new documents")) self.emptyDocument.setText(_("Create an empty document")) self.lilyVersion.setText(_("Create a document that contains the LilyPond version statement")) self.template.setText(_("Create a document from a template:")) from snippet import snippets for i, name in enumerate(self._names): self.combo.setItemText(i, snippets.title(name)) def loadCombo(self): from snippet import snippets self._names = [name for name in snippets.names() if snippets.get(name).variables.get('template')] self.combo.clear() self.combo.addItems([''] * len(self._names)) def loadSettings(self): s = QSettings() ndoc = s.value("new_document", "empty", type("")) template = s.value("new_document_template", "", type("")) if template in self._names: self.combo.setCurrentIndex(self._names.index(template)) if ndoc == "template": self.template.setChecked(True) elif ndoc == "version": self.lilyVersion.setChecked(True) else: self.emptyDocument.setChecked(True) def saveSettings(self): s = QSettings() if self._names and self.template.isChecked(): s.setValue("new_document", "template") s.setValue("new_document_template", self._names[self.combo.currentIndex()]) elif self.lilyVersion.isChecked(): s.setValue("new_document", "version") else: s.setValue("new_document", "empty")
class ParamWidget(QWidget): def __init__(self, dataset, title = '', settings = None, settingskey = None, parent = None): super(ParamWidget, self).__init__(parent = parent) self.settings = settings self.settingskey = settingskey self.mainLayout = QVBoxLayout() self.setLayout(self.mainLayout) if self.settings is not None and self.settingskey is not None: stored_list = self.settings.getValueOrDefault('storedParameters/'+self.settingskey, [ ]) h = QHBoxLayout() self.mainLayout.addLayout(h) h.addStretch(1) self.comboParam = QComboBox() h.addWidget(self.comboParam, 3) self.refreshCombo() self.comboParam.currentIndexChanged.connect(self.comboParamChanged) buttonSave = QPushButton(QIcon(':/list-add.png') ,'') buttonSave.setMaximumSize(25,25) h.addWidget(buttonSave) buttonSave.clicked.connect(self.saveNewParam) buttonDel = QPushButton(QIcon(':/list-remove.png') ,'') buttonDel.setMaximumSize(25,25) h.addWidget(buttonDel) buttonDel.clicked.connect(self.delSavedParam) self.params = DataSetEditGroupBox(title,dataset, show_button = False) self.mainLayout.addWidget( self.params ) self.default_dict = self.to_dict() def to_dict(self): self.params.set() ds = self.params.dataset d = OrderedDict() for item in ds._items: if type(item) is ChoiceItem: val = None ind = getattr(ds, item._name) choices = item.get_prop_value("data", item, "choices") for choice in choices: if choice[0] == ind: val = choice[1] else: val = getattr(ds, item._name) d[item._name] = val return d def update(self, d): ds = self.params.dataset for item in ds._items: if item._name in d: if type(item) is ChoiceItem: choices = item.get_prop_value("data", item, "choices") choices = [ c[1] for c in choices ] ind = choices.index(d[item._name]) setattr(ds, item._name, ind) else: setattr(ds, item._name, d[item._name]) self.params.getInstance() def reset(self): self.update(self.default_dict) def refreshCombo(self): stored_list = self.settings['storedParameters/'+self.settingskey] self.comboParam.clear() list_name = [ l[0] for l in stored_list ] self.comboParam.addItems(['Default' , ]+list_name ) def comboParamChanged(self, pos) : if pos <= 0 : self.reset() else : stored_list = self.settings['storedParameters/'+self.settingskey] self.update(stored_list[pos-1][1]) def saveNewParam( self ) : class Parameters(DataSet): name = StringItem('name', default = '') dia = ParamDialog(Parameters, title = 'key') ok = dia.exec_() if ok != QDialog.Accepted: return name = dia.to_dict()['name'] stored_list = self.settings['storedParameters/'+self.settingskey] stored_list += [ [ name , self.to_dict() ] ] self.settings['storedParameters/'+self.settingskey] = stored_list self.refreshCombo() self.comboParam.setCurrentIndex(len(stored_list)) def delSavedParam( self) : pos = self.comboParam.currentIndex() if pos == 0: return stored_list = self.settings['storedParameters/'+self.settingskey] del stored_list[pos-1] self.settings['storedParameters/'+self.settingskey] = stored_list self.refreshCombo() self.comboParam.setCurrentIndex(0)
class Browser(QWidget): """LilyPond documentation browser widget.""" def __init__(self, dockwidget): super(Browser, self).__init__(dockwidget) layout = QVBoxLayout(spacing=0) layout.setContentsMargins(0, 0, 0, 0) self.setLayout(layout) self.toolbar = tb = QToolBar() self.webview = QWebView(contextMenuPolicy=Qt.CustomContextMenu) self.chooser = QComboBox(sizeAdjustPolicy=QComboBox.AdjustToContents) self.search = SearchEntry(maximumWidth=200) layout.addWidget(self.toolbar) layout.addWidget(self.webview) ac = dockwidget.actionCollection ac.help_back.triggered.connect(self.webview.back) ac.help_forward.triggered.connect(self.webview.forward) ac.help_home.triggered.connect(self.showHomePage) ac.help_print.triggered.connect(self.slotPrint) self.webview.page().setNetworkAccessManager( lilydoc.network.accessmanager()) self.webview.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks) self.webview.page().linkClicked.connect(self.openUrl) self.webview.page().setForwardUnsupportedContent(True) self.webview.page().unsupportedContent.connect(self.slotUnsupported) self.webview.urlChanged.connect(self.slotUrlChanged) self.webview.customContextMenuRequested.connect( self.slotShowContextMenu) tb.addAction(ac.help_back) tb.addAction(ac.help_forward) tb.addSeparator() tb.addAction(ac.help_home) tb.addAction(ac.help_print) tb.addSeparator() tb.addWidget(self.chooser) tb.addWidget(self.search) self.chooser.activated[int].connect(self.showHomePage) self.search.textEdited.connect(self.slotSearchChanged) self.search.returnPressed.connect(self.slotSearchReturnPressed) dockwidget.mainwindow().iconSizeChanged.connect( self.updateToolBarSettings) dockwidget.mainwindow().toolButtonStyleChanged.connect( self.updateToolBarSettings) app.settingsChanged.connect(self.readSettings) self.readSettings() self.loadDocumentation() self.showInitialPage() app.settingsChanged.connect(self.loadDocumentation) app.translateUI(self) def readSettings(self): s = QSettings() s.beginGroup("documentation") ws = self.webview.page().settings() family = s.value("fontfamily", self.font().family(), type("")) size = s.value("fontsize", 16, int) ws.setFontFamily(QWebSettings.StandardFont, family) ws.setFontSize(QWebSettings.DefaultFontSize, size) fixed = textformats.formatData('editor').font ws.setFontFamily(QWebSettings.FixedFont, fixed.family()) ws.setFontSize(QWebSettings.DefaultFixedFontSize, fixed.pointSizeF() * 96 / 72) def keyPressEvent(self, ev): if ev.text() == "/": self.search.setFocus() else: super(Browser, self).keyPressEvent(ev) def translateUI(self): try: self.search.setPlaceholderText(_("Search...")) except AttributeError: pass # not in Qt 4.6 def showInitialPage(self): """Shows the preferred start page. If a local documentation instance already has a suitable version, just loads it. Otherwise connects to the allLoaded signal, that is emitted when all the documentation instances have loaded their version information and then shows the start page (if another page wasn't yet loaded). """ if self.webview.url().isEmpty(): docs = lilydoc.manager.docs() version = lilypondinfo.preferred().version() index = -1 if version: for num, doc in enumerate(docs): if doc.version() is not None and doc.version() >= version: index = num # a suitable documentation is found break if index == -1: # nothing found (or LilyPond version not available), # wait for loading or show the most recent version if not lilydoc.manager.loaded(): lilydoc.manager.allLoaded.connect(self.showInitialPage) return index = len(docs) - 1 self.chooser.setCurrentIndex(index) self.showHomePage() def loadDocumentation(self): """Puts the available documentation instances in the combobox.""" i = self.chooser.currentIndex() self.chooser.clear() for doc in lilydoc.manager.docs(): v = doc.versionString() if doc.isLocal(): t = _("(local)") else: t = _("({hostname})").format(hostname=doc.url().host()) self.chooser.addItem("{0} {1}".format(v or _("<unknown>"), t)) self.chooser.setCurrentIndex(i) if not lilydoc.manager.loaded(): lilydoc.manager.allLoaded.connect(self.loadDocumentation, -1) return def updateToolBarSettings(self): mainwin = self.parentWidget().mainwindow() self.toolbar.setIconSize(mainwin.iconSize()) self.toolbar.setToolButtonStyle(mainwin.toolButtonStyle()) def showManual(self): """Invoked when the user presses F1.""" self.slotHomeFrescobaldi() # TEMP def slotUrlChanged(self): ac = self.parentWidget().actionCollection ac.help_back.setEnabled(self.webview.history().canGoBack()) ac.help_forward.setEnabled(self.webview.history().canGoForward()) def openUrl(self, url): if url.path().endswith(('.ily', '.lyi', '.ly')): self.sourceViewer().showReply(lilydoc.network.get(url)) else: self.webview.load(url) def slotUnsupported(self, reply): helpers.openUrl(reply.url()) def slotSearchChanged(self): text = self.search.text() if not text.startswith(':'): self.webview.page().findText(text, QWebPage.FindWrapsAroundDocument) def slotSearchReturnPressed(self): text = self.search.text() if not text.startswith(':'): self.slotSearchChanged() else: pass # TODO: implement full doc search def sourceViewer(self): try: return self._sourceviewer except AttributeError: from . import sourceviewer self._sourceviewer = sourceviewer.SourceViewer(self) return self._sourceviewer def showHomePage(self): """Shows the homepage of the LilyPond documentation.""" i = self.chooser.currentIndex() if i < 0: i = 0 doc = lilydoc.manager.docs()[i] url = doc.home() if doc.isLocal(): path = url.toLocalFile() langs = lilydoc.network.langs() if langs: for lang in langs: if os.path.exists(path + '.' + lang + '.html'): path += '.' + lang break url = QUrl.fromLocalFile(path + '.html') self.webview.load(url) def slotPrint(self): printer = QPrinter() dlg = QPrintDialog(printer, self) dlg.setWindowTitle(app.caption(_("Print"))) if dlg.exec_(): self.webview.print_(printer) def slotShowContextMenu(self, pos): hit = self.webview.page().currentFrame().hitTestContent(pos) menu = QMenu() if hit.linkUrl().isValid(): a = self.webview.pageAction(QWebPage.CopyLinkToClipboard) a.setIcon(icons.get("edit-copy")) a.setText(_("Copy &Link")) menu.addAction(a) menu.addSeparator() a = menu.addAction(icons.get("window-new"), _("Open Link in &New Window")) a.triggered.connect( (lambda url: lambda: self.slotNewWindow(url))(hit.linkUrl())) else: if hit.isContentSelected(): a = self.webview.pageAction(QWebPage.Copy) a.setIcon(icons.get("edit-copy")) a.setText(_("&Copy")) menu.addAction(a) menu.addSeparator() a = menu.addAction(icons.get("window-new"), _("Open Document in &New Window")) a.triggered.connect((lambda url: lambda: self.slotNewWindow(url))( self.webview.url())) if menu.actions(): menu.exec_(self.webview.mapToGlobal(pos)) def slotNewWindow(self, url): helpers.openUrl(url)
class ExportPanel(QWidget): updateExportButton = pyqtSignal(str, bool) runExport = pyqtSignal(dict) def __init__(self, parent=None): QWidget.__init__(self, parent) self.setMinimumWidth(500) self.setMinimumHeight(200) self._dynamic = False self.setWindowTitle("Export data") self.activateWindow() layout = QFormLayout() current_case = getCurrentCaseName() self._case_model = AllCasesModel() self._case_combo = QComboBox() self._case_combo.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLength) self._case_combo.setMinimumContentsLength(20) self._case_combo.setModel(self._case_model) self._case_combo.setCurrentIndex(self._case_model.indexOf(current_case)) layout.addRow("Select case:", self._case_combo) self._export_keyword_model = ExportKeywordModel() self._kw_model = self._export_keyword_model.getKeyWords() self._keywords = QComboBox() self._keywords.addItems(self._kw_model) layout.addRow("Select keyword:", self._keywords) self._active_realizations_model = ActiveRealizationsModel() self._active_realizations_field = StringBox(self._active_realizations_model, "config/simulation/active_realizations") self._active_realizations_field.setValidator(RangeStringArgument()) self._active_realizations_field.getValidationSupport().validationChanged.connect(self.validateExportDialog) layout.addRow("Active realizations:", self._active_realizations_field) file_name_button = QToolButton() file_name_button.setText("Browse") file_name_button.clicked.connect(self.selectFileDirectory) self._defaultPath = QDir.currentPath() + "/export" self._file_name = QLineEdit() self._file_name.setEnabled(False) self._file_name.setText(self._defaultPath) self._file_name.textChanged.connect(self.validateExportDialog) self._file_name.setMinimumWidth(250) file_name_layout = QHBoxLayout() file_name_layout.addWidget(self._file_name) file_name_layout.addWidget(file_name_button) layout.addRow("Select directory to save files to:", file_name_layout) self._gen_kw_file_types = ["Parameter list", "Template based"] self._field_kw_file_types = ["Eclipse GRDECL", "RMS roff"] self._gen_data_file_types = ["Gen data"] self._file_type_model = self._field_kw_file_types self._file_type_combo = QComboBox() self._file_type_combo.setSizeAdjustPolicy(QComboBox.AdjustToContents) self._file_type_combo.addItems(self._file_type_model) layout.addRow("Select file format:", self._file_type_combo) self._report_step = QLineEdit() layout.addRow("Report step:", self._report_step) self._gen_data_report_step_model = [] self._gen_data_report_step = QComboBox() layout.addRow("Report step:", self._gen_data_report_step) self.setLayout(layout) self._keywords.currentIndexChanged.connect(self.keywordSelected) self.keywordSelected() def selectFileDirectory(self): directory = QFileDialog().getExistingDirectory(self, "Directory", self._file_name.text(), QFileDialog.ShowDirsOnly) if str(directory).__len__() > 0: self._file_name.setText(str(directory)) def updateFileExportType(self, keyword): self._file_type_combo.clear() if self._export_keyword_model.isGenKw(keyword): self._file_type_model = self._gen_kw_file_types elif self._export_keyword_model.isGenParamKw(keyword): self._file_type_model = self._gen_data_file_types elif self._export_keyword_model.isGenDataKw(keyword): self._file_type_model = self._gen_data_file_types else: self._file_type_model = self._field_kw_file_types self._file_type_combo.addItems(self._file_type_model) def export(self): keyword = self._kw_model[self._keywords.currentIndex()] report_step = self.getReportStep(keyword) all_cases = self._case_model.getAllItems() selected_case = all_cases[self._case_combo.currentIndex()] path = self._file_name.text() iactive = self._active_realizations_model.getActiveRealizationsMask() file_type_key = self._file_type_model[self._file_type_combo.currentIndex()] values = {"keyword": keyword, "report_step": report_step, "iactive": iactive, "file_type_key": file_type_key, "path": path, "selected_case": selected_case} self.runExport.emit(values) def getReportStep(self, key): report_step = 0 if self._dynamic: report_step = self._report_step.text() if self._export_keyword_model.isGenParamKw(key): return report_step if self._export_keyword_model.isGenDataKw(key): lst = self._gen_data_report_step_model idx = self._gen_data_report_step.currentIndex() if lst and len(lst) > idx: report_step = lst[idx] else: raise IndexError('No such model step: %d. Valid range: [0, %d)' % (idx, len(lst))) return report_step def keywordSelected(self): key = self._kw_model[self._keywords.currentIndex()] self.updateFileExportType(key) self._dynamic = False if self._export_keyword_model.isFieldKw(key): self._dynamic = self._export_keyword_model.isDynamicField(key) self._report_step.setVisible(self._dynamic) self.layout().labelForField(self._report_step).setVisible(self._dynamic) self._gen_data_report_step.setVisible(self._export_keyword_model.isGenDataKw(key)) self.layout().labelForField(self._gen_data_report_step).setVisible(self._export_keyword_model.isGenDataKw(key)) if self._export_keyword_model.isGenDataKw(key): data = self._export_keyword_model.getGenDataReportSteps(key) self._gen_data_report_step_model = data self._gen_data_report_step.clear() self._gen_data_report_step.addItems(self._gen_data_report_step_model) def setSelectedCase(self, selected_case): self._case_combo.setCurrentIndex(self._case_model.indexOf(selected_case)) def validateExportDialog(self): validRealizations = False if self._active_realizations_field.isValid(): validRealizations = True path = str(self._file_name.text()) validPath = len(path) > 0 if validRealizations and validPath: self.updateExportButton.emit("export", True) else: self.updateExportButton.emit("export", False)
class FindInFilesDialog(QDialog): def __init__(self, result_widget, parent): QDialog.__init__(self, parent) self._find_thread = FindInFilesThread() self.setWindowTitle("Find in files") self.resize(400, 300) #MAIN LAYOUT main_vbox = QVBoxLayout(self) self.pattern_line_edit = QLineEdit() self.dir_name_root = None self.user_home = os.path.expanduser('~') self.dir_combo = QComboBox() self.dir_combo.addItem(self.user_home) self.dir_combo.setEditable(True) self.open_button = QPushButton(QIcon(resources.IMAGES['find']), self.tr("Open")) self.filters_line_edit = QLineEdit("*.py") self.replace_line = QLineEdit() self.replace_line.setEnabled(False) self.check_replace = QCheckBox(self.tr("Replace: ")) self.case_checkbox = QCheckBox(self.tr("C&ase sensitive")) self.type_checkbox = QCheckBox(self.tr("R&egular Expression")) self.recursive_checkbox = QCheckBox(self.tr("Rec&ursive")) self.recursive_checkbox.setCheckState(Qt.Checked) self.phrase_radio = QRadioButton( self.tr("Search by Phrase (Exact Match).")) self.phrase_radio.setChecked(True) self.words_radio = QRadioButton( self.tr("Search for all the words " "(anywhere in the document, not together).")) self.find_button = QPushButton(self.tr("Find!")) self.find_button.setMaximumWidth(150) self.cancel_button = QPushButton(self.tr("Cancel")) self.cancel_button.setMaximumWidth(150) self.result_widget = result_widget hbox = QHBoxLayout() hbox.addWidget(self.find_button) hbox.addWidget(self.cancel_button) #main section find_group_box = QGroupBox(self.tr("Main")) grid = QGridLayout() grid.addWidget(QLabel(self.tr("Text: ")), 0, 0) grid.addWidget(self.pattern_line_edit, 0, 1) grid.addWidget(QLabel(self.tr("Directory: ")), 1, 0) grid.addWidget(self.dir_combo, 1, 1) grid.addWidget(self.open_button, 1, 2) grid.addWidget(QLabel(self.tr("Filter: ")), 2, 0) grid.addWidget(self.filters_line_edit, 2, 1) grid.addWidget(self.check_replace, 3, 0) grid.addWidget(self.replace_line, 3, 1) find_group_box.setLayout(grid) #add main section to MAIN LAYOUT main_vbox.addWidget(find_group_box) #options sections options_group_box = QGroupBox(self.tr("Options")) gridOptions = QGridLayout() gridOptions.addWidget(self.case_checkbox, 0, 0) gridOptions.addWidget(self.type_checkbox, 1, 0) gridOptions.addWidget(self.recursive_checkbox, 2, 0) gridOptions.addWidget(self.phrase_radio, 0, 1) gridOptions.addWidget(self.words_radio, 1, 1) options_group_box.setLayout(gridOptions) #add options sections to MAIN LAYOUT main_vbox.addWidget(options_group_box) #add buttons to MAIN LAYOUT main_vbox.addLayout(hbox) #Focus self.pattern_line_edit.setFocus() self.open_button.setFocusPolicy(Qt.NoFocus) #signal self.connect(self.open_button, SIGNAL("clicked()"), self._select_dir) self.connect(self.find_button, SIGNAL("clicked()"), self._find_in_files) self.connect(self.cancel_button, SIGNAL("clicked()"), self._kill_thread) self.connect(self._find_thread, SIGNAL("found_pattern(PyQt_PyObject)"), self._found_match) self.connect(self._find_thread, SIGNAL("finished()"), self._find_thread_finished) self.connect(self.type_checkbox, SIGNAL("stateChanged(int)"), self._change_radio_enabled) self.connect(self.check_replace, SIGNAL("stateChanged(int)"), self._replace_activated) self.connect(self.words_radio, SIGNAL("clicked(bool)"), self._words_radio_pressed) def _replace_activated(self): self.replace_line.setEnabled(self.check_replace.isChecked()) self.phrase_radio.setChecked(True) def _words_radio_pressed(self, value): self.replace_line.setEnabled(not value) self.check_replace.setChecked(not value) self.words_radio.setChecked(True) def _change_radio_enabled(self, val): enabled = not self.type_checkbox.isChecked() self.phrase_radio.setEnabled(enabled) self.words_radio.setEnabled(enabled) def show(self, actual_project=None, actual=None): self.dir_combo.clear() self.dir_name_root = actual_project if \ actual_project else [self.user_home] self.dir_combo.addItems(self.dir_name_root) if actual: index = self.dir_combo.findText(actual) self.dir_combo.setCurrentIndex(index) super(FindInFilesDialog, self).show() self.pattern_line_edit.setFocus() def reject(self): self._kill_thread() # Crazy hack to avoid circular imports self.result_widget.parent().parent().parent().hide() super(FindInFilesDialog, self).reject() def _find_thread_finished(self): self.emit(SIGNAL("finished()")) self._find_thread.wait() def _select_dir(self): dir_name = QFileDialog.getExistingDirectory(self, self.tr("Open Directory"), self.dir_combo.currentText(), QFileDialog.ShowDirsOnly) index = self.dir_combo.findText(dir_name) if index >= 0: self.dir_combo.setCurrentIndex(index) else: self.dir_combo.insertItem(0, dir_name) self.dir_combo.setCurrentIndex(0) def _found_match(self, result): file_name = result[0] items = result[1] self.result_widget.update_result( self.dir_combo.currentText(), file_name, items) def _kill_thread(self): if self._find_thread.isRunning(): self._find_thread.cancel() self.accept() def _find_in_files(self): self.emit(SIGNAL("findStarted()")) self._kill_thread() self.result_widget.clear() pattern = self.pattern_line_edit.text() dir_name = self.dir_combo.currentText() filters = re.split("[,;]", self.filters_line_edit.text()) # Version of PyQt API 1 # filters = self.filters_line_edit.text().split(QRegExp("[,;]"), # QString.SkipEmptyParts) #remove the spaces in the words Ex. (" *.foo"--> "*.foo") filters = [f.strip() for f in filters] case_sensitive = self.case_checkbox.isChecked() type_ = QRegExp.RegExp if \ self.type_checkbox.isChecked() else QRegExp.FixedString recursive = self.recursive_checkbox.isChecked() by_phrase = True if self.phrase_radio.isChecked() or self.type_checkbox.isChecked(): regExp = QRegExp(pattern, case_sensitive, type_) elif self.words_radio.isChecked(): by_phrase = False type_ = QRegExp.RegExp pattern = '|'.join( [word.strip() for word in pattern.split()]) regExp = QRegExp(pattern, case_sensitive, type_) #save a reference to the root directory where we find self.dir_name_root = dir_name self._find_thread.find_in_files(dir_name, filters, regExp, recursive, by_phrase)
class ComboChoice(HelpedWidget): """ A combo box widget for choices. List of objects retrieved from model str(item) is used for presentation getValue and setValue uses the same object as from the list """ def __init__(self, model, combo_label="Choice", help_link=""): HelpedWidget.__init__(self, combo_label, help_link) assert model is not None and isinstance(model, ChoiceModelMixin) self.model = model model.observable().attach( ChoiceModelMixin.CURRENT_CHOICE_CHANGED_EVENT, self.getCurrentFromModel) model.observable().attach(ChoiceModelMixin.CHOICE_LIST_CHANGED_EVENT, self.updateChoicesFromModel) self.combo = QComboBox() self.combo.setSizeAdjustPolicy(QComboBox.AdjustToContents) self.combo.addItem("Fail!") self.addWidget(self.combo) self.addStretch() self.choice_list = None """ @type: list """ self.connect(self.combo, SIGNAL('currentIndexChanged(int)'), self.selectionChanged) self.updateChoicesFromModel() self.getCurrentFromModel() def selectionChanged(self, index): assert 0 <= index < len( self.choice_list ), "Should not happen! Index out of range: 0 <= %i < %i" % ( index, len(self.choice_list)) item = self.choice_list[index] self.model.setCurrentChoice(item) def getCurrentFromModel(self): new_value = self.model.getCurrentChoice() if self.choice_list is None: self.updateChoicesFromModel() if new_value in self.choice_list: index = self.choice_list.index(new_value) if not index == self.combo.currentIndex(): self.combo.setCurrentIndex(index) else: self.combo.setCurrentIndex(0) #sys.stderr.write("AssertionError: ComboBox can not be set to: " + str(new_value) + "\n") # raise AssertionError("ComboBox can not be set to: " + str(new_value)) def updateChoicesFromModel(self): block = self.combo.signalsBlocked() self.combo.blockSignals(True) self.choice_list = self.model.getChoices() self.combo.clear() for choice in self.choice_list: self.combo.addItem(str(choice)) self.combo.blockSignals(block) def cleanup(self): self.model.observable().detach( ChoiceModelMixin.CURRENT_CHOICE_CHANGED_EVENT, self.getCurrentFromModel) self.model.observable().detach( ChoiceModelMixin.CHOICE_LIST_CHANGED_EVENT, self.updateChoicesFromModel)
class ActionBar(QFrame): """ SIGNALS: @changeCurrent(PyQt_PyObject) @runFile(QString) @reopenTab(QString) @recentTabsModified() """ def __init__(self, main_combo=False): super(ActionBar, self).__init__() self.setObjectName("actionbar") hbox = QHBoxLayout(self) hbox.setContentsMargins(1, 1, 1, 1) hbox.setSpacing(1) self.lbl_checks = QLabel('') self.lbl_checks.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) self.lbl_checks.setFixedWidth(48) self.lbl_checks.setVisible(False) hbox.addWidget(self.lbl_checks) self.combo = QComboBox() self.combo.setIconSize(QSize(16, 16)) #model = QStandardItemModel() #self.combo.setModel(model) #self.combo.view().setDragDropMode(QAbstractItemView.InternalMove) self.combo.setMaximumWidth(300) self.combo.setObjectName("combotab") self.connect(self.combo, SIGNAL("currentIndexChanged(int)"), self.current_changed) self.combo.setToolTip(translations.TR_COMBO_FILE_TOOLTIP) self.combo.setContextMenuPolicy(Qt.CustomContextMenu) self.connect(self.combo, SIGNAL( "customContextMenuRequested(const QPoint &)"), self._context_menu_requested) hbox.addWidget(self.combo) self.symbols_combo = QComboBox() self.symbols_combo.setIconSize(QSize(16, 16)) self.symbols_combo.setObjectName("combo_symbols") self.connect(self.symbols_combo, SIGNAL("activated(int)"), self.current_symbol_changed) hbox.addWidget(self.symbols_combo) self.code_navigator = CodeNavigator() hbox.addWidget(self.code_navigator) self._pos_text = "Line: %d, Col: %d" self.lbl_position = QLabel(self._pos_text % (0, 0)) self.lbl_position.setObjectName("position") self.lbl_position.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) hbox.addWidget(self.lbl_position) self.btn_close = QPushButton( self.style().standardIcon(QStyle.SP_DialogCloseButton), '') self.btn_close.setIconSize(QSize(16, 16)) if main_combo: self.btn_close.setObjectName('navigation_button') self.btn_close.setToolTip(translations.TR_CLOSE_FILE) self.connect(self.btn_close, SIGNAL("clicked()"), self.about_to_close_file) else: self.btn_close.setObjectName('close_split') self.btn_close.setToolTip(translations.TR_CLOSE_SPLIT) self.connect(self.btn_close, SIGNAL("clicked()"), self.close_split) self.btn_close.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) hbox.addWidget(self.btn_close) def resizeEvent(self, event): super(ActionBar, self).resizeEvent(event) if event.size().width() < 350: self.symbols_combo.hide() self.code_navigator.hide() self.lbl_position.hide() else: self.symbols_combo.show() self.code_navigator.show() self.lbl_position.show() def add_item(self, text, neditable): """Add a new item to the combo and add the neditable data.""" self.combo.addItem(text, neditable) self.combo.setCurrentIndex(self.combo.count() - 1) def get_editables(self): editables = [] for index in range(self.combo.count()): neditable = self.combo.itemData(index) editables.append(neditable) return editables def add_symbols(self, symbols): """Add the symbols to the symbols's combo.""" self.symbols_combo.clear() for symbol in symbols: data = symbol[1] if data[1] == 'f': icon = QIcon(":img/function") else: icon = QIcon(":img/class") self.symbols_combo.addItem(icon, data[0]) def set_current_symbol(self, index): self.symbols_combo.setCurrentIndex(index) def update_item_icon(self, neditable, icon): index = self.combo.findData(neditable) self.combo.setItemIcon(index, icon) def update_item_text(self, neditable, text): index = self.combo.findData(neditable) self.combo.setItemText(index, text) def current_changed(self, index): """Change the current item in the combo.""" neditable = self.combo.itemData(index) self.emit(SIGNAL("changeCurrent(PyQt_PyObject, int)"), neditable, index) def current_symbol_changed(self, index): """Change the current symbol in the combo.""" self.emit(SIGNAL("goToSymbol(int)"), index) def update_line_col(self, line, col): """Update the line and column position.""" self.lbl_position.setText(self._pos_text % (line, col)) def _context_menu_requested(self, point): """Display context menu for the combo file.""" if self.combo.count() == 0: # If there is not an Editor opened, don't show the menu return menu = QMenu() actionAdd = menu.addAction(translations.TR_ADD_TO_PROJECT) actionRun = menu.addAction(translations.TR_RUN_FILE) menuSyntax = menu.addMenu(translations.TR_CHANGE_SYNTAX) self._create_menu_syntax(menuSyntax) menu.addSeparator() actionClose = menu.addAction(translations.TR_CLOSE_FILE) actionCloseAll = menu.addAction(translations.TR_CLOSE_ALL_FILES) actionCloseAllNotThis = menu.addAction( translations.TR_CLOSE_OTHER_FILES) menu.addSeparator() actionSplitH = menu.addAction(translations.TR_SPLIT_VERTICALLY) actionSplitV = menu.addAction(translations.TR_SPLIT_HORIZONTALLY) menu.addSeparator() actionCopyPath = menu.addAction( translations.TR_COPY_FILE_PATH_TO_CLIPBOARD) actionReopen = menu.addAction(translations.TR_REOPEN_FILE) actionUndock = menu.addAction(translations.TR_UNDOCK_EDITOR) if len(settings.LAST_OPENED_FILES) == 0: actionReopen.setEnabled(False) #Connect actions self.connect(actionSplitH, SIGNAL("triggered()"), lambda: self._split(False)) self.connect(actionSplitV, SIGNAL("triggered()"), lambda: self._split(True)) self.connect(actionRun, SIGNAL("triggered()"), self._run_this_file) self.connect(actionAdd, SIGNAL("triggered()"), self._add_to_project) self.connect(actionClose, SIGNAL("triggered()"), self.about_to_close_file) self.connect(actionCloseAllNotThis, SIGNAL("triggered()"), self._close_all_files_except_this) self.connect(actionCloseAll, SIGNAL("triggered()"), self._close_all_files) self.connect(actionCopyPath, SIGNAL("triggered()"), self._copy_file_location) self.connect(actionReopen, SIGNAL("triggered()"), self._reopen_last_tab) self.connect(actionUndock, SIGNAL("triggered()"), self._undock_editor) menu.exec_(QCursor.pos()) def _create_menu_syntax(self, menuSyntax): """Create Menu with the list of syntax supported.""" syntax = list(settings.SYNTAX.keys()) syntax.sort() for syn in syntax: menuSyntax.addAction(syn) self.connect(menuSyntax, SIGNAL("triggered(QAction*)"), self._reapply_syntax) def _reapply_syntax(self, syntaxAction): #TODO if [self.currentIndex(), syntaxAction] != self._resyntax: self._resyntax = [self.currentIndex(), syntaxAction] self.emit(SIGNAL("syntaxChanged(QWidget, QString)"), self.currentWidget(), syntaxAction.text()) def set_current_file(self, neditable): index = self.combo.findData(neditable) self.combo.setCurrentIndex(index) def set_current_by_index(self, index): self.combo.setCurrentIndex(index) def about_to_close_file(self, index=None): """Close the NFile object.""" if index is None: index = self.combo.currentIndex() neditable = self.combo.itemData(index) if neditable: neditable.nfile.close() def close_split(self): self.emit(SIGNAL("closeSplit()")) def close_file(self, neditable): """Receive the confirmation to close the file.""" index = self.combo.findData(neditable) self.combo.removeItem(index) return index def _run_this_file(self): """Execute the current file.""" neditable = self.combo.itemData(self.combo.currentIndex()) self.emit(SIGNAL("runFile(QString)"), neditable.file_path) def _add_to_project(self): """Emit a signal to let someone handle the inclusion of the file inside a project.""" neditable = self.combo.itemData(self.combo.currentIndex()) self.emit(SIGNAL("addToProject(QString)"), neditable.file_path) def _reopen_last_tab(self): self.emit(SIGNAL("reopenTab(QString)"), settings.LAST_OPENED_FILES.pop()) self.emit(SIGNAL("recentTabsModified()")) def _undock_editor(self): self.emit(SIGNAL("undockEditor()")) def _split(self, orientation): self.emit(SIGNAL("splitEditor(bool)"), orientation) def _copy_file_location(self): """Copy the path of the current opened file to the clipboard.""" neditable = self.combo.itemData(self.combo.currentIndex()) QApplication.clipboard().setText(neditable.file_path, QClipboard.Clipboard) def _close_all_files(self): """Close all the files opened.""" for i in range(self.combo.count()): self.about_to_close_file(0) def _close_all_files_except_this(self): """Close all the files except the current one.""" neditable = self.combo.itemData(self.combo.currentIndex()) for i in reversed(list(range(self.combo.count()))): ne = self.combo.itemData(i) if ne is not neditable: self.about_to_close_file(i)
class dlg_main(QDialog): def __init__(self): QDialog.__init__(self) self.dlg_csv_error = dlg_csv_error(self) self.dlg_csv_error.initGui() self.kukaku_dict = OrderedDict() self.kukaku_dict[u"第1次地域区画"] = 4 self.kukaku_dict[u"第2次地域区画"] = 6 self.kukaku_dict[u"第3次地域区画"] = 8 self.kukaku_dict[u"5倍地域メッシュ"] = 7 self.kukaku_dict[u"2倍地域メッシュ"] = 9 self.kukaku_dict[u"2分の1地域メッシュ"] = 9 self.kukaku_dict[u"4分の1地域メッシュ"] = 10 self.kukaku_dict[u"8分の1地域メッシュ"] = 11 self.kukaku_dict[u"10分の1細分地域メッシュ"] = 10 self.dat_str = np.array([]) self.table_header = np.array([]) self.csv_dat_str = np.array([]) self.EF_dia = myFileDialog(self) self.f_len = np.vectorize(lambda x: len(x)) def initGui(self): self.VBL_main = QVBoxLayout() self.HBL_selectfile = QHBoxLayout() self.Lab_selectfile = QLabel(u"ファイル名") self.LiE_selectfile = QLineEdit() self.PuB_selectfile = QPushButton() self.PuB_selectfile.setText(u"参照") self.HBL_selectfile.addWidget(self.Lab_selectfile) self.HBL_selectfile.addWidget(self.LiE_selectfile) self.HBL_selectfile.addWidget(self.PuB_selectfile) self.VBL_main.addLayout(self.HBL_selectfile) self.HBL_layername = QHBoxLayout() self.Lab_layername = QLabel(u"レイヤ名") self.LiE_layername = QLineEdit() self.HBL_layername.addWidget(self.Lab_layername) self.HBL_layername.addWidget(self.LiE_layername) self.VBL_main.addLayout(self.HBL_layername) self.GrL_config = QGridLayout() self.Lab_recopt_title = QLabel(u"レコードオプション") self.GrL_config.addWidget(self.Lab_recopt_title, 0, 0) self.HBL_recopt = QHBoxLayout() self.Lab_recopt = QLabel(u"無視するヘッダー行") self.SpB_recopt = QSpinBox() self.ChB_recopt = QCheckBox() self.ChB_recopt.setText(u"最初のレコードはフィールド名を保持している") self.HBL_recopt.addWidget(self.Lab_recopt) self.HBL_recopt.addWidget(self.SpB_recopt) self.HBL_recopt.addWidget(self.ChB_recopt) self.GrL_config.addLayout(self.HBL_recopt,0,1) self.Lab_mesh_titile = QLabel(u"メッシュ定義") self.GrL_config.addWidget(self.Lab_mesh_titile,1,0) self.HBL_mesh = QHBoxLayout() self.Lab_mesh_field = QLabel(u"メッシュコード列") self.CoB_mesh_field = QComboBox() self.Lab_mesh_category = QLabel(u"地域メッシュ区画") self.CoB_mesh_category = QComboBox() self.CoB_mesh_category.addItems(self.kukaku_dict.keys()) self.HBL_mesh.addWidget(self.Lab_mesh_field) self.HBL_mesh.addWidget(self.CoB_mesh_field) self.HBL_mesh.addWidget(self.Lab_mesh_category) self.HBL_mesh.addWidget(self.CoB_mesh_category) self.GrL_config.addLayout(self.HBL_mesh,1,1) self.Lab_crs_title = QLabel(u"測地系") self.GrL_config.addWidget(self.Lab_crs_title,2,0) self.CoB_crs = QComboBox() self.CoB_crs.addItems([u"世界測地系(EPSG:4612)",u"日本測地系(EPSG:4301)"]) self.GrL_config.addWidget(self.CoB_crs,2,1) self.VBL_main.addLayout(self.GrL_config) self.model_content = QStandardItemModel() self.TB_content = QTableView() self.TB_content.setModel(self.model_content) self.VBL_main.addWidget(self.TB_content) self.DBB_main = QDialogButtonBox() self.DBB_main.setStandardButtons(QDialogButtonBox.Cancel|QDialogButtonBox.Ok) self.VBL_main.addWidget(self.DBB_main) self.setLayout(self.VBL_main) self.ChB_recopt.setChecked(True) self.ChB_recopt.stateChanged.connect(self.update_csv_str) self.SpB_recopt.valueChanged.connect(self.update_csv_str) self.PuB_selectfile.clicked.connect(self.EF_dia.open) self.DBB_main.accepted.connect(self.accept) self.DBB_main.rejected.connect(self.reject) def update_csv_str(self): if len(self.dat_str) == 0: pass else: if self.ChB_recopt.checkState() == 0: csv_header = np.array(["field_{0}".format(x) for x in np.arange(0,self.dat_str.shape[1])]) self.csv_dat_str = self.dat_str[(self.SpB_recopt.value()):,] else: csv_header = self.dat_str[self.SpB_recopt.value(),] self.csv_dat_str =self.dat_str[(self.SpB_recopt.value()+1):,] self.clear() self.table_header = np.array([hstr if hstr != u"" else 'field_{0}'.format(i) for i,hstr in enumerate(csv_header)]) load_table(self.model_content, self.table_header, np.arange(0,11), self.csv_dat_str) self.CoB_mesh_field.addItems(self.table_header) def clear(self): self.model_content.clear() self.CoB_mesh_field.clear() def accept(self): if len(self.LiE_selectfile.text()) == 0: QMessageBox.warning(self,u"警告",u"ファイルを選択してください") elif len(self.LiE_layername.text()) == 0: QMessageBox.warning(self,u"警告",u"レイヤ名を入力してください") else: self.csv_meshid_str = self.csv_dat_str[:,self.CoB_mesh_field.currentIndex()] if self.check_decimal(): self.dlg_csv_error.LB_caution.setText(u"以下のデータのメッシュコードに空白\nまたは数値以外の文字が含まれています") load_table(self.dlg_csv_error.model_content,self.table_header, self.e_ind, self.csv_dat_str) self.dlg_csv_error.show() elif self.check_digit(): str = u"以下のデータのメッシュコードの桁数が不正です\n" str += u'{0}コードは{1}桁の整数です。'.format(self.CoB_mesh_category.currentText(), self.kukaku_dict[self.CoB_mesh_category.currentText()]) self.dlg_csv_error.LB_caution.setText(str) load_table(self.dlg_csv_error.model_content,self.table_header, self.e_ind, self.csv_dat_str) self.dlg_csv_error.show() elif self.check_unique(): str = u'以下のデータのメッシュコードが重複しています' self.dlg_csv_error.LB_caution.setText(str) load_table(self.dlg_csv_error.model_content,self.table_header, self.e_ind, self.csv_dat_str) self.dlg_csv_error.show() else: self.create_tmp_csv() self.load_wkt_csv() return QDialog.accept(self) def check_decimal(self): e_ind = np.where(~def_c.isdecimal(self.csv_meshid_str))[0] if len(e_ind) > 0: self.e_ind = e_ind return True else: return False def check_digit(self): digit_arr = self.f_len(self.csv_meshid_str) e_ind = np.where( digit_arr != self.kukaku_dict[self.CoB_mesh_category.currentText()])[0] if len(e_ind) > 0: self.e_ind = e_ind return True else: return False def check_unique(self): u,c = np.unique(self.csv_meshid_str,return_counts=True) tf = c > 1 if tf.any(): self.e_ind = np.where(np.in1d(self.csv_meshid_str, u[tf]))[0] return True else: return False def create_tmp_csv(self): m_wkt = mesh_wkt(self.CoB_mesh_category.currentText()) infile_qstr = self.LiE_selectfile.text() self.outfile_qstr = self.LiE_selectfile.text().replace(".","_wkt.") in_fp = open(infile_qstr,"r") out_fp = open(self.outfile_qstr,"wb") reader = csv.reader(in_fp) writer = csv.writer(out_fp) n_skip = self.SpB_recopt.value() if n_skip > 0: for i in range(0,n_skip): next(reader,None) if self.ChB_recopt.checkState() == 2: header = next(reader,None) header.insert(0,"wkt") writer.writerow(header) for hrow in csv.reader(in_fp): hrow.insert(0,m_wkt.res_wkt(hrow[self.CoB_mesh_field.currentIndex()])) writer.writerow(hrow) in_fp.close() out_fp.close() def load_wkt_csv(self): uri = QUrl.fromLocalFile(self.outfile_qstr) uri.addQueryItem("type","csv") uri.addQueryItem("delimiter",",") uri.addQueryItem("wktField","1") uri.addQueryItem("encoding",self.EF_dia.encoding()) if self.ChB_recopt.checkState() == 2: uri.addQueryItem("useHeader","yes") else: uri.addQueryItem("useHeader","no") if self.CoB_crs.currentIndex() == 0: uri.addQueryItem("crs","EPSG:4612") elif self.CoB_crs.currentIndex() == 0: uri.addQueryItem("crs","EPSG:4301") self.vlayer = QgsVectorLayer(uri.toString(),self.LiE_layername.text(),"delimitedtext") if self.vlayer.isValid(): QgsMapLayerRegistry.instance().addMapLayer( self.vlayer )