class ShowSettingsDialog(QDialog): """ Dialog class for plugin settings """ def __init__(self, iface, memoryPointsLayer, memoryLinesLayer, importConfigTable, importUriDb, importSchemaDb, controlConfigTable, controlUriDb, controlSchemaDb, mntUrl, refLayers, adjLayers, levelAtt, levelVal, drawdowmLayer, pipeDiam, moreTools): """ Constructor :param iface: interface :param memoryPointsLayer: working memory points layer :param memoryLinesLayer: working memory lines layer :param importConfigTable: config table selected for import :param importUriDb: database for import :param importSchemaDb: db schema for import :param controlConfigTable: config table selected for control :param controlUriDb: database for control :param controlSchemaDb: db schema for control :param mntUrl: url to get mnt :param refLayers: reference layers for drawdown :param adjLayers: adjustement layers for drawdown :param levelAtt: level attribute for drawdown :param levelVal: level value for drawdown :param drawdowmLayer: line layer for drawdown :param pipeDiam: pipe diameter for drawdown :param moreTools: if more tools or not """ QDialog.__init__(self) self.__iface = iface self.__memoryPointsLayer = memoryPointsLayer self.__memoryLinesLayer = memoryLinesLayer self.__importConfigTable = importConfigTable self.__importUriDb = importUriDb self.__importSchemaDb = importSchemaDb self.__controlConfigTable = controlConfigTable self.__controlUriDb = controlUriDb self.__controlSchemaDb = controlSchemaDb self.__mntUrl = mntUrl self.__refLayers = refLayers self.__adjLayers = adjLayers self.__levelAtt = levelAtt self.__levelVal = levelVal self.__drawdowmLayer = drawdowmLayer self.__pipeDiam = pipeDiam self.setWindowTitle(QCoreApplication.translate("VDLTools", "Settings")) self.__pointsLayers = [] self.__linesLayers = [] self.__refAvailableLayers = [] self.__drawdownLayers = [] self.__tables = [] self.__schemas = [] self.__pipeDiamFields = [] self.__levelAttFields = [] self.__dbs = DBConnector.getUsedDatabases() self.__refLabels = [] self.__refChecks = [] self.__adjChecks = [] for layer in list(QgsMapLayerRegistry.instance().mapLayers().values()): if layer is not None and layer.type() == QgsMapLayer.VectorLayer: if layer.providerType() == "memory": if layer.geometryType() == QGis.Point: self.__pointsLayers.append(layer) if layer.geometryType() == QGis.Line: self.__linesLayers.append(layer) if QGis.fromOldWkbType( layer.wkbType()) == QgsWKBTypes.LineStringZ: self.__drawdownLayers.append(layer) if QGis.fromOldWkbType(layer.wkbType()) == QgsWKBTypes.PointZ: self.__refAvailableLayers.append(layer) self.resize(600, 500) self.__layout = QGridLayout() self.__scrollLayout = QGridLayout() line = 0 intersectLabel = QLabel( QCoreApplication.translate("VDLTools", "Intersect ")) self.__scrollLayout.addWidget(intersectLabel, line, 0) line += 1 pointLabel = QLabel( QCoreApplication.translate("VDLTools", "Working points layer : ")) self.__scrollLayout.addWidget(pointLabel, line, 1) self.__pointCombo = QComboBox() self.__pointCombo.setMinimumHeight(20) self.__pointCombo.setMinimumWidth(50) self.__pointCombo.addItem("") for layer in self.__pointsLayers: self.__pointCombo.addItem(layer.name()) self.__scrollLayout.addWidget(self.__pointCombo, line, 2) self.__pointCombo.currentIndexChanged.connect(self.__pointComboChanged) if self.__memoryPointsLayer is not None: if self.__memoryPointsLayer in self.__pointsLayers: self.__pointCombo.setCurrentIndex( self.__pointsLayers.index(self.__memoryPointsLayer) + 1) line += 1 lineLabel = QLabel( QCoreApplication.translate("VDLTools", "Working lines layer : ")) self.__scrollLayout.addWidget(lineLabel, line, 1) self.__lineCombo = QComboBox() self.__lineCombo.setMinimumHeight(20) self.__lineCombo.setMinimumWidth(50) self.__lineCombo.addItem("") for layer in self.__linesLayers: self.__lineCombo.addItem(layer.name()) self.__scrollLayout.addWidget(self.__lineCombo, line, 2) self.__lineCombo.currentIndexChanged.connect(self.__lineComboChanged) if self.__memoryLinesLayer is not None: if self.__memoryLinesLayer in self.__linesLayers: self.__lineCombo.setCurrentIndex( self.__linesLayers.index(self.__memoryLinesLayer) + 1) line += 1 profilesLabel = QLabel( QCoreApplication.translate("VDLTools", "Profiles ")) self.__scrollLayout.addWidget(profilesLabel, line, 0) line += 1 mntLabel = QLabel( QCoreApplication.translate("VDLTools", "Url for MNT : ")) self.__scrollLayout.addWidget(mntLabel, line, 1) self.__mntText = QLineEdit() if self.__mntUrl is None or self.__mntUrl == "None": self.__mntText.insert( 'https://map.lausanne.ch/prod/wsgi/profile.json') else: self.__mntText.insert(self.__mntUrl) self.__mntText.setMinimumHeight(20) self.__mntText.setMinimumWidth(100) self.__scrollLayout.addWidget(self.__mntText, line, 2) line += 1 ddLabel = QLabel(QCoreApplication.translate("VDLTools", "Drawdown ")) self.__scrollLayout.addWidget(ddLabel, line, 0) line += 1 self.__scrollLayout.addWidget( QLabel(QCoreApplication.translate("VDLTools", "Layer")), line, 1) namesLayout = QHBoxLayout() namesWidget = QWidget() namesLayout.addWidget( QLabel(QCoreApplication.translate("VDLTools", "Reference"))) namesLayout.addWidget( QLabel(QCoreApplication.translate("VDLTools", "Adjustable"))) namesLayout.setContentsMargins(0, 0, 0, 0) namesWidget.setLayout(namesLayout) self.__scrollLayout.addWidget(namesWidget, line, 2) line += 1 for layer in self.__refAvailableLayers: refLabel = QLabel(" - " + layer.name()) self.__refLabels.append(refLabel) self.__scrollLayout.addWidget(refLabel, line, 1) checksLayout = QHBoxLayout() checksLayout.setContentsMargins(0, 0, 0, 0) checksWidget = QWidget() refCheck = QCheckBox() self.__refChecks.append(refCheck) refCheck.stateChanged.connect(self.__refBoxesChanged) checksLayout.addWidget(refCheck) adjCheck = QCheckBox() self.__adjChecks.append(adjCheck) checksLayout.addWidget(adjCheck) checksWidget.setLayout(checksLayout) self.__scrollLayout.addWidget(checksWidget, line, 2) line += 1 levelAttLabel = QLabel( QCoreApplication.translate("VDLTools", "Code(s) on pipe : ")) self.__scrollLayout.addWidget(levelAttLabel, line, 1) self.__levelAttCombo = QComboBox() self.__levelAttCombo.setMinimumHeight(20) self.__levelAttCombo.setMinimumWidth(50) self.__levelAttCombo.addItem("") self.__scrollLayout.addWidget(self.__levelAttCombo, line, 2) self.__levelAttCombo.currentIndexChanged.connect( self.__levelAttComboChanged) i = 0 for layer in self.__refAvailableLayers: if layer in self.__refLayers: self.__refChecks[i].setChecked(True) if layer in self.__adjLayers: self.__adjChecks[i].setChecked(True) i += 1 line += 1 levelValLabel = QLabel( QCoreApplication.translate("VDLTools", "Point code attribute : ")) self.__scrollLayout.addWidget(levelValLabel, line, 1) self.__levelValText = QLineEdit() if self.__levelVal is not None and self.__levelVal != "None": self.__levelValText.insert(self.__levelVal) self.__levelValText.setMinimumHeight(20) self.__levelValText.setMinimumWidth(100) self.__scrollLayout.addWidget(self.__levelValText, line, 2) line += 1 drawdownLabel = QLabel( QCoreApplication.translate("VDLTools", "drawdown layer : ")) self.__scrollLayout.addWidget(drawdownLabel, line, 1) self.__drawdownCombo = QComboBox() self.__drawdownCombo.setMinimumHeight(20) self.__drawdownCombo.setMinimumWidth(50) self.__drawdownCombo.addItem("") for layer in self.__drawdownLayers: self.__drawdownCombo.addItem(layer.name()) self.__scrollLayout.addWidget(self.__drawdownCombo, line, 2) line += 1 pipeDiamLabel = QLabel( QCoreApplication.translate("VDLTools", "Pipe diameter attribute [cm] : ")) self.__scrollLayout.addWidget(pipeDiamLabel, line, 1) self.__pipeDiamCombo = QComboBox() self.__pipeDiamCombo.setMinimumHeight(20) self.__pipeDiamCombo.setMinimumWidth(50) self.__pipeDiamCombo.addItem("") self.__scrollLayout.addWidget(self.__pipeDiamCombo, line, 2) self.__drawdownCombo.currentIndexChanged.connect( self.__drawdownComboChanged) self.__pipeDiamCombo.currentIndexChanged.connect( self.__pipeDiamComboChanged) if self.__drawdowmLayer is not None: if self.__drawdowmLayer in self.__drawdownLayers: self.__drawdownCombo.setCurrentIndex( self.__drawdownLayers.index(self.__drawdowmLayer) + 1) line += 1 controlLabel = QLabel( QCoreApplication.translate("VDLTools", "Control ")) self.__scrollLayout.addWidget(controlLabel, line, 0) line += 1 controlDbLabel = QLabel( QCoreApplication.translate("VDLTools", "Control database : ")) self.__scrollLayout.addWidget(controlDbLabel, line, 1) self.__controlDbCombo = QComboBox() self.__controlDbCombo.setMinimumHeight(20) self.__controlDbCombo.setMinimumWidth(50) self.__controlDbCombo.addItem("") for db in list(self.__dbs.keys()): self.__controlDbCombo.addItem(db) self.__scrollLayout.addWidget(self.__controlDbCombo, line, 2) line += 1 controlSchemaLabel = QLabel( QCoreApplication.translate("VDLTools", "Control database schema : ")) self.__scrollLayout.addWidget(controlSchemaLabel, line, 1) self.__controlSchemaCombo = QComboBox() self.__controlSchemaCombo.setMinimumHeight(20) self.__controlSchemaCombo.setMinimumWidth(50) self.__controlSchemaCombo.addItem("") self.__scrollLayout.addWidget(self.__controlSchemaCombo, line, 2) line += 1 controlTableLabel = QLabel( QCoreApplication.translate("VDLTools", "Control config table : ")) self.__scrollLayout.addWidget(controlTableLabel, line, 1) self.__controlTableCombo = QComboBox() self.__controlTableCombo.setMinimumHeight(20) self.__controlTableCombo.setMinimumWidth(50) self.__controlTableCombo.addItem("") self.__scrollLayout.addWidget(self.__controlTableCombo, line, 2) self.__controlDbCombo.currentIndexChanged.connect( self.__controlDbComboChanged) self.__controlSchemaCombo.currentIndexChanged.connect( self.__controlSchemaComboChanged) self.__controlTableCombo.currentIndexChanged.connect( self.__controlTableComboChanged) if self.__controlUriDb is not None: if self.__controlUriDb.database() in list(self.__dbs.keys()): self.__controlDbCombo.setCurrentIndex( list(self.__dbs.keys()).index( self.__controlUriDb.database()) + 1) if moreTools: line += 1 importLabel = QLabel( QCoreApplication.translate("VDLTools", "Import ")) self.__scrollLayout.addWidget(importLabel, line, 0) line += 1 importDbLabel = QLabel( QCoreApplication.translate("VDLTools", "Import database : ")) self.__scrollLayout.addWidget(importDbLabel, line, 1) self.__importDbCombo = QComboBox() self.__importDbCombo.setMinimumHeight(20) self.__importDbCombo.setMinimumWidth(50) self.__importDbCombo.addItem("") for db in list(self.__dbs.keys()): self.__importDbCombo.addItem(db) self.__scrollLayout.addWidget(self.__importDbCombo, line, 2) line += 1 importSchemaLabel = QLabel( QCoreApplication.translate("VDLTools", "Import database schema : ")) self.__scrollLayout.addWidget(importSchemaLabel, line, 1) self.__importSchemaCombo = QComboBox() self.__importSchemaCombo.setMinimumHeight(20) self.__importSchemaCombo.setMinimumWidth(50) self.__importSchemaCombo.addItem("") self.__scrollLayout.addWidget(self.__importSchemaCombo, line, 2) line += 1 importTableLabel = QLabel( QCoreApplication.translate("VDLTools", "Import config table : ")) self.__scrollLayout.addWidget(importTableLabel, line, 1) self.__importTableCombo = QComboBox() self.__importTableCombo.setMinimumHeight(20) self.__importTableCombo.setMinimumWidth(50) self.__importTableCombo.addItem("") self.__scrollLayout.addWidget(self.__importTableCombo, line, 2) self.__importDbCombo.currentIndexChanged.connect( self.__importDbComboChanged) self.__importSchemaCombo.currentIndexChanged.connect( self.__importSchemaComboChanged) self.__importTableCombo.currentIndexChanged.connect( self.__importTableComboChanged) if self.__importUriDb is not None: if self.__importUriDb.database() in list(self.__dbs.keys()): self.__importDbCombo.setCurrentIndex( list(self.__dbs.keys()).index( self.__importUriDb.database()) + 1) else: self.__importDbCombo = None self.__importSchemaCombo = None self.__importTableCombo = None widget = QWidget() widget.setLayout(self.__scrollLayout) scroll = QScrollArea() scroll.setWidgetResizable(True) scroll.setWidget(widget) self.__layout.addWidget(scroll, 1, 0, 1, 2) self.__okButton = QPushButton( QCoreApplication.translate("VDLTools", "OK")) self.__okButton.setMinimumHeight(20) self.__okButton.setMinimumWidth(100) self.__cancelButton = QPushButton( QCoreApplication.translate("VDLTools", "Cancel")) self.__cancelButton.setMinimumHeight(20) self.__cancelButton.setMinimumWidth(100) self.__layout.addWidget(self.__okButton, 100, 0) self.__layout.addWidget(self.__cancelButton, 100, 1) self.setLayout(self.__layout) @staticmethod def __resetCombo(combo): """ To reset a combo list :param combo: concerned combo """ while combo.count() > 0: combo.removeItem(combo.count() - 1) def __setSchemaCombo(self, uriDb, schemaCombo, schemaComboChanged, schemaDb): """ To fill the schema combo list :param uriDb: selected database uri :param schemaCombo: concerned schema combo :param schemaComboChanged: concerned schema combo change event :param schemaDb: selected schema db """ connector = DBConnector(uriDb, self.__iface) db = connector.setConnection() if db: Signal.safelyDisconnect(schemaCombo.currentIndexChanged, schemaComboChanged) self.__resetCombo(schemaCombo) schemaCombo.addItem("") self.__schemas = [] query = db.exec_( """SELECT DISTINCT table_schema FROM information_schema.tables WHERE table_schema NOT IN ('pg_catalog', 'information_schema', 'topology') AND table_type = 'BASE TABLE' AND table_name NOT IN (SELECT f_table_name FROM geometry_columns)""") if query.lastError().isValid(): self.__iface.messageBar().pushMessage( query.lastError().text(), level=QgsMessageBar.CRITICAL, duration=0) else: while next(query): self.__schemas.append(query.value(0)) db.close() for schema in self.__schemas: schemaCombo.addItem(schema) schemaCombo.currentIndexChanged.connect(schemaComboChanged) if schemaDb is not None: if schemaDb in self.__schemas: schemaCombo.setCurrentIndex( self.__schemas.index(schemaDb) + 1) def __setTableCombo(self, uriDb, schema, tableCombo, tableComboChanged, configTable): """ To fill the table combo list :param uriDb: selected database uri :param schema: selected database schema :param tableCombo: concerned table combo :param tableComboChanged: concerned table combo change event :param configTable: selected config table """ connector = DBConnector(uriDb, self.__iface) db = connector.setConnection() if db: Signal.safelyDisconnect(tableCombo.currentIndexChanged, tableComboChanged) self.__resetCombo(tableCombo) tableCombo.addItem("") self.__tables = [] query = db.exec_( """SELECT table_name FROM information_schema.tables WHERE table_schema = '""" + schema + """' ORDER BY table_name""") if query.lastError().isValid(): self.__iface.messageBar().pushMessage( query.lastError().text(), level=QgsMessageBar.CRITICAL, duration=0) else: while next(query): self.__tables.append(query.value(0)) db.close() for table in self.__tables: if tableCombo.findText(table) == -1: tableCombo.addItem(table) tableCombo.currentIndexChanged.connect(tableComboChanged) if configTable is not None: if configTable in self.__tables: tableCombo.setCurrentIndex( self.__tables.index(configTable) + 1) def __setPipeDiamCombo(self, drawdownLayer): """ To fill the pipe diameter combo list :param drawdownLayer: choosen drawdown layer """ Signal.safelyDisconnect(self.__pipeDiamCombo.currentIndexChanged, self.__pipeDiamComboChanged) self.__resetCombo(self.__pipeDiamCombo) self.__pipeDiamCombo.addItem("") fields = drawdownLayer.fields() self.__pipeDiamFields = [] for field in fields: self.__pipeDiamFields.append(field.name()) self.__pipeDiamCombo.addItem(field.name()) self.__pipeDiamCombo.currentIndexChanged.connect( self.__pipeDiamComboChanged) if self.__pipeDiam is not None: if self.__pipeDiam in self.__pipeDiamFields: self.__pipeDiamCombo.setCurrentIndex( self.__pipeDiamFields.index(self.__pipeDiam) + 1) def __setLevelAttCombo(self, refLayers): """ To fill the level attribute combo list :param refLayers: choosen reference layers """ Signal.safelyDisconnect(self.__levelAttCombo.currentIndexChanged, self.__levelAttComboChanged) self.__resetCombo(self.__levelAttCombo) self.__levelAttCombo.addItem("") self.__levelAttFields = [] num = 0 for layer in refLayers: fields = layer.fields() if num == 0: for field in fields: self.__levelAttFields.append(field.name()) num = 1 else: names = [] for field in fields: names.append(field.name()) news = [] for name in self.__levelAttFields: if name in names: news.append(name) self.__levelAttFields = news for name in self.__levelAttFields: self.__levelAttCombo.addItem(name) self.__levelAttCombo.currentIndexChanged.connect( self.__levelAttComboChanged) if self.__levelAtt is not None: if self.__levelAtt in self.__levelAttFields: self.__levelAttCombo.setCurrentIndex( self.__levelAttFields.index(self.__levelAtt) + 1) def __lineComboChanged(self): """ To remove blank item when another one is selected """ if self.__lineCombo.itemText(0) == "": self.__lineCombo.removeItem(0) def __pointComboChanged(self): """ To remove blank item when another one is selected """ if self.__pointCombo.itemText(0) == "": self.__pointCombo.removeItem(0) def __refBoxesChanged(self): """ To update level attribute combo when reference layers have changed """ if self.refLayers() is not None: self.__setLevelAttCombo(self.refLayers()) def __drawdownComboChanged(self): """ To remove blank item when another one is selected and update pipe diamete combo when drawdown layer has changed """ if self.__drawdownCombo.itemText(0) == "": self.__drawdownCombo.removeItem(0) if self.drawdownLayer() is not None: self.__setPipeDiamCombo(self.drawdownLayer()) def __controlTableComboChanged(self): """ To remove blank item when another one is selected """ if self.__controlTableCombo.itemText(0) == "": self.__controlTableCombo.removeItem(0) def __importTableComboChanged(self): """ To remove blank item when another one is selected """ if self.__importTableCombo.itemText(0) == "": self.__importTableCombo.removeItem(0) def __controlDbComboChanged(self): """ When the selection in db combo has changed """ if self.__controlDbCombo.itemText(0) == "": self.__controlDbCombo.removeItem(0) if self.controlUriDb() is not None: self.__setSchemaCombo(self.controlUriDb(), self.__controlSchemaCombo, self.__controlSchemaComboChanged, self.__controlSchemaDb) def __importDbComboChanged(self): """ When the selection in db combo has changed """ if self.__importDbCombo.itemText(0) == "": self.__importDbCombo.removeItem(0) if self.importUriDb() is not None: self.__setSchemaCombo(self.importUriDb(), self.__importSchemaCombo, self.__importSchemaComboChanged, self.__importSchemaDb) def __controlSchemaComboChanged(self): """ When the selection in schema combo has changed """ if self.__controlSchemaCombo.itemText(0) == "": self.__controlSchemaCombo.removeItem(0) if self.controlSchemaDb() is not None: self.__setTableCombo(self.controlUriDb(), self.controlSchemaDb(), self.__controlTableCombo, self.__controlTableComboChanged, self.__controlConfigTable) def __importSchemaComboChanged(self): """ When the selection in schema combo has changed """ if self.__importSchemaaCombo.itemText(0) == "": self.__importSchemaCombo.removeItem(0) if self.importSchemaDb() is not None: self.__setTableCombo(self.importUriDb(), self.importSchemaDb(), self.__importTableCombo, self.__importTableComboChanged, self.__importConfigTable) def __pipeDiamComboChanged(self): """ When the selection in schema combo has changed """ if self.__pipeDiamCombo.itemText(0) == "": self.__pipeDiamCombo.removeItem(0) def __levelAttComboChanged(self): """ When the selection in schema combo has changed """ if self.__levelAttCombo.itemText(0) == "": self.__levelAttCombo.removeItem(0) def okButton(self): """ To get the ok button instance :return: ok button instance """ return self.__okButton def cancelButton(self): """ To get the cancel button instance :return: cancel button instance """ return self.__cancelButton def pointsLayer(self): """ To get the selected memory points layer :return: selected memory points layer, or none """ index = self.__pointCombo.currentIndex() if self.__pointCombo.itemText(index) == "": return None else: return self.__pointsLayers[index] def linesLayer(self): """ To get the selected memory lines layer :return: selected memory lines layer, or none """ index = self.__lineCombo.currentIndex() if self.__lineCombo.itemText(index) == "": return None else: return self.__linesLayers[index] def refLayers(self): """ To get the selected reference layers :return: selected reference layers, or none """ layers = [] i = 0 for check in self.__refChecks: if check.isChecked(): layers.append(self.__refAvailableLayers[i]) i += 1 return layers def adjLayers(self): """ To get the selected ajustable layers :return: selected adjustable layers, or none """ layers = [] i = 0 for check in self.__adjChecks: if check.isChecked(): layers.append(self.__refAvailableLayers[i]) i += 1 return layers def levelAtt(self): """ To get the selected level attribute :return: selected level attribute, or none """ if self.__levelAttCombo is None: return None index = self.__levelAttCombo.currentIndex() if self.__levelAttCombo.itemText(index) == "": return None else: return self.__levelAttFields[index] def levelVal(self): """ To get the filled level value :return: filled level value """ return self.__levelValText.text() def drawdownLayer(self): """ To get the selected drawdown layer :return: selected drawdown layer, or none """ index = self.__drawdownCombo.currentIndex() if self.__drawdownCombo.itemText(index) == "": return None else: return self.__drawdownLayers[index] def pipeDiam(self): """ To get the selected pipe diameter :return: selected pipe diameter, or none """ if self.__pipeDiamCombo is None: return None index = self.__pipeDiamCombo.currentIndex() if self.__pipeDiamCombo.itemText(index) == "": return None else: return self.__pipeDiamFields[index] def controlConfigTable(self): """ To get the selected config table :return: selected config table, or none """ if self.__controlTableCombo is None: return None index = self.__controlTableCombo.currentIndex() if self.__controlTableCombo.itemText(index) == "": return None else: return self.__tables[index] def importConfigTable(self): """ To get the selected config table :return: selected config table, or none """ if self.__importTableCombo is None: return None index = self.__importTableCombo.currentIndex() if self.__importTableCombo.itemText(index) == "": return None else: return self.__tables[index] def controlUriDb(self): """ To get selected import database uri :return: import database uri """ if self.__controlDbCombo is None: return None index = self.__controlDbCombo.currentIndex() if self.__controlDbCombo.itemText(index) == "": return None else: return self.__dbs[list(self.__dbs.keys())[index]] def importUriDb(self): """ To get selected import database uri :return: import database uri """ if self.__importDbCombo is None: return None index = self.__importDbCombo.currentIndex() if self.__importDbCombo.itemText(index) == "": return None else: return self.__dbs[list(self.__dbs.keys())[index]] def controlSchemaDb(self): """ To get selected import database schema :return: import database schema """ if self.__controlSchemaCombo is None: return None index = self.__controlSchemaCombo.currentIndex() if self.__controlSchemaCombo.itemText(index) == "": return None else: return self.__schemas[index] def importSchemaDb(self): """ To get selected import database schema :return: import database schema """ if self.__importSchemaCombo is None: return None index = self.__importSchemaCombo.currentIndex() if self.__importSchemaCombo.itemText(index) == "": return None else: return self.__schemas[index] def mntUrl(self): """ To get selected MN url :return: MN url """ return self.__mntText.text()
class WFramework(QWidget, Logger.ClassLogger): """ Framework widget """ # action, description, misc, parameters AddStep = pyqtSignal(str, str, str, dict) UpdateStep = pyqtSignal(str, str, str, dict) CancelEdit = pyqtSignal() def __init__(self, parent): """ Constructor """ QWidget.__init__(self) self.createActions() self.createWidgets() self.createToolbar() self.createConnections() def createActions(self): """ Create qt actions """ self.addAction = QPushButton(QIcon(":/add_black.png"), '&Add Action', self) self.addAction.setMinimumHeight(40) self.addAction.setMaximumWidth(200) self.cancelAction = QtHelper.createAction(self, "&Cancel", self.cancelStep, icon=QIcon(":/undo.png"), tip = 'Cancel update') self.cancelAction.setEnabled(False) self.optionsAction = QtHelper.createAction(self, "&", self.openOptions, icon=QIcon(":/recorder-basic-small.png"), tip = 'Framework options') def openOptions(self): """ Open options dialog """ if self.optionsDialog.exec_() == QDialog.Accepted: pass def createWidgets(self): """ Create all qt widgets """ self.optionsDialog = OptionsDialog(self) self.validatorUpper = ValidatorUpper(self) self.validatorAll = ValidatorAll(self) self.validatorInt = QIntValidator(self) font = QFont() font.setBold(True) self.actionsComboBox = QComboBox(self) self.actionsComboBox.setMinimumHeight(40) for i in xrange(len(GuiSteps.ACTION_FRAMEWORK_DESCR)): if not len( GuiSteps.ACTION_FRAMEWORK_DESCR[i] ): self.actionsComboBox.insertSeparator(i+1) else: el = GuiSteps.ACTION_FRAMEWORK_DESCR[i].keys() self.actionsComboBox.addItem( list(el)[0] ) self.labelActionDescr = QLabel(self) self.labelActionDescr.setText( "%s\n" % GuiSteps.ACTION_FRAMEWORK_DESCR[0][GuiSteps.FRAMEWORK_INFO]) self.labelActionDescr.setWordWrap(True) self.labelActionDescr.hide() self.descriptionLine = QLineEdit(self) self.descriptionLine.hide() actionLayout2 = QGridLayout() self.createWidgetGetText() self.createWidgetGetWait() self.createWidgetCacheSet() self.createWidgetCheckString() self.createWidgetGetAsk() actionLayout2.addWidget( self.setCacheGroup , 0, 0) actionLayout2.addWidget( self.getCheckGroup , 1, 0) actionLayout2.addWidget( self.getTextGroup , 2, 0) actionLayout2.addWidget( self.getWaitGroup , 3, 0) actionLayout2.addWidget( self.getAskGroup , 4, 0) labelAct = QLabel( self.tr("Action: ") ) labelAct.setFont( font) self.arrowLabel = QLabel("") self.arrowLabel.setPixmap(QPixmap(":/arrow-right.png").scaledToWidth(32)) self.arrowLabel2 = QLabel("") self.arrowLabel2.setPixmap(QPixmap(":/arrow-right.png").scaledToWidth(32)) layoutFinal = QHBoxLayout() layoutFinal.addWidget( labelAct ) layoutFinal.addWidget(self.actionsComboBox) layoutFinal.addWidget( self.arrowLabel ) layoutFinal.addLayout( actionLayout2 ) layoutFinal.addWidget( self.arrowLabel2 ) layoutFinal.addWidget(self.addAction) layoutFinal.addStretch(1) self.setLayout(layoutFinal) def createToolbar(self): """ Create toolbar """ pass def createWidgetCheckString(self): """ Create widget to check string """ self.getCheckGroup = QGroupBox(self.tr("")) # check in ? self.checkInTextLine = QLineEdit(self) self.checkInTextLine.setMinimumWidth(300) self.checkInTextCombo = QComboBox(self) self.checkInTextCombo.addItems( [ "CACHE" ] ) # operator self.checkComboBox = QComboBox(self) self.checkComboBox.addItems( [ GuiSteps.OP_CONTAINS, GuiSteps.OP_NOTCONTAINS, GuiSteps.OP_REGEXP, GuiSteps.OP_NOTREGEXP, GuiSteps.OP_STARTSWITH, GuiSteps.OP_NOTSTARTSWITH, GuiSteps.OP_ENDSWITH, GuiSteps.OP_NOTENDSWITH ] ) # check what ? self.checkOutTextLine = QLineEdit(self) self.checkOutTextLine.setMinimumWidth(300) self.checkOutTextCombo = QComboBox(self) self.checkOutTextCombo.addItems( LIST_TYPES ) # final layout mainChecklayout = QGridLayout() mainChecklayout.addWidget( QLabel( self.tr("Checking from:") ), 0, 0 ) mainChecklayout.addWidget( self.checkInTextCombo, 0, 1 ) mainChecklayout.addWidget( self.checkInTextLine, 0, 2 ) mainChecklayout.addWidget( QLabel( self.tr("If:") ), 1, 0 ) mainChecklayout.addWidget( self.checkComboBox, 1, 1 ) mainChecklayout.addWidget( QLabel( self.tr("The Value:") ), 2, 0 ) mainChecklayout.addWidget( self.checkOutTextCombo, 2, 1 ) mainChecklayout.addWidget( self.checkOutTextLine, 2, 2 ) self.getCheckGroup.setLayout(mainChecklayout) self.getCheckGroup.hide() def createWidgetGetText(self): """ Create text widget """ self.getTextGroup = QGroupBox(self.tr("")) self.basicTextLine = QLineEdit(self) self.basicTextLine.setMinimumWidth(300) self.basicTextCombo = QComboBox(self) self.basicTextCombo.addItems( LIST_TYPES ) mainTextlayout = QGridLayout() mainTextlayout.addWidget( QLabel( self.tr("Value:") ), 0, 0 ) mainTextlayout.addWidget( self.basicTextCombo, 0, 1 ) mainTextlayout.addWidget( self.basicTextLine, 0, 2 ) self.getTextGroup.setLayout(mainTextlayout) def createWidgetGetAsk(self): """ Create ask widget """ # ask self.getAskGroup = QGroupBox(self.tr("")) self.askTextLine = QLineEdit(self) self.askTextLine.setMinimumWidth(300) self.askTextCombo = QComboBox(self) self.askTextCombo.addItems( LIST_TYPES ) self.askTextCacheLine = QLineEdit(self) self.askTextCacheLine.setMinimumWidth(300) self.askTextCacheCombo = QComboBox(self) self.askTextCacheCombo.addItems( [ "CACHE" ] ) mainAsklayout = QGridLayout() mainAsklayout.addWidget( QLabel( self.tr("User input prompt:") ), 0, 0 ) mainAsklayout.addWidget( self.askTextCombo, 0, 1 ) mainAsklayout.addWidget( self.askTextLine, 0, 2 ) mainAsklayout.addWidget( QLabel( self.tr("And save response in:") ), 1, 0 ) mainAsklayout.addWidget( self.askTextCacheCombo, 1, 1 ) mainAsklayout.addWidget( self.askTextCacheLine, 1, 2 ) self.getAskGroup.setLayout(mainAsklayout) self.getAskGroup.hide() def createWidgetGetWait(self): """ Create wait text widget """ self.getWaitGroup = QGroupBox(self.tr("")) self.valueWaitLine = QLineEdit(self) self.valueWaitLine.setMinimumWidth(300) self.valueWaitLine.setValidator(self.validatorInt) self.valueWaitCombo = QComboBox(self) self.valueWaitCombo.addItems( LIST_TYPES ) mainTextlayout = QGridLayout() mainTextlayout.addWidget( QLabel( self.tr("Value (in seconds):") ), 0, 0 ) mainTextlayout.addWidget( self.valueWaitCombo, 0, 1 ) mainTextlayout.addWidget( self.valueWaitLine, 0, 2 ) self.getWaitGroup.setLayout(mainTextlayout) self.getWaitGroup.hide() def createWidgetCacheSet(self): """ Create cache widget """ self.setCacheGroup = QGroupBox(self.tr("")) setCacheLayout = QGridLayout() self.cacheKeyName = QLineEdit(self) self.cacheKeyName.setMinimumWidth(300) setCacheLayout.addWidget( QLabel( self.tr("Key name:") ) , 0, 1) setCacheLayout.addWidget( self.cacheKeyName , 0, 2) self.setCacheGroup.setLayout(setCacheLayout) self.setCacheGroup.hide() def createConnections(self): """ Createa qt connections """ self.actionsComboBox.currentIndexChanged.connect(self.onActionChanged) self.addAction.clicked.connect(self.addStep) self.basicTextCombo.currentIndexChanged.connect(self.onBasicTextTypeChanged) self.valueWaitCombo.currentIndexChanged.connect(self.onValueWaitTypeChanged) self.checkOutTextCombo.currentIndexChanged.connect(self.onCheckOutTextTypeChanged) self.askTextCombo.currentIndexChanged.connect(self.onAskTextTypeChanged) def onAskTextTypeChanged(self): """ On ask type changed """ if self.askTextCombo.currentText() in [ "TEXT", "CACHE" ]: self.askTextLine.setValidator(self.validatorAll) if self.askTextCombo.currentText() == "ALIAS": self.askTextLine.setText( self.askTextLine.text().upper() ) self.askTextLine.setValidator(self.validatorUpper) def onCheckOutTextTypeChanged(self): """ On check out type changed """ if self.checkOutTextCombo.currentText() in [ "TEXT", "CACHE" ]: self.checkOutTextLine.setValidator(self.validatorAll) if self.checkOutTextCombo.currentText() == "ALIAS": self.checkOutTextLine.setText( self.checkOutTextLine.text().upper() ) self.checkOutTextLine.setValidator(self.validatorUpper) def onValueWaitTypeChanged(self): """ On value wait changed """ if self.valueWaitCombo.currentText() in [ "TEXT" ]: self.valueWaitLine.setText( "0" ) self.valueWaitLine.setValidator(self.validatorInt) if self.valueWaitCombo.currentText() in [ "CACHE" ]: self.valueWaitLine.setValidator(self.validatorAll) if self.valueWaitCombo.currentText() == "ALIAS": self.valueWaitLine.setText( self.valueWaitLine.text().upper() ) self.valueWaitLine.setValidator(self.validatorUpper) def onBasicTextTypeChanged(self): """ On basic text changed """ if self.basicTextCombo.currentText() in [ "TEXT", "CACHE" ]: self.basicTextLine.setValidator(self.validatorAll) if self.basicTextCombo.currentText() == "ALIAS": self.basicTextLine.setText( self.basicTextLine.text().upper() ) self.basicTextLine.setValidator(self.validatorUpper) def pluginDataAccessor(self): """ Return data for plugins """ return { "data": "" } def onPluginImport(self, dataJson): """ On call from plugin """ pass def onRadioAskChanged(self, button): """ On radio ask changed """ if button.text() == 'From alias parameter': self.askTextLine.setText( self.askTextLine.text().upper() ) self.askTextLine.setValidator(self.validAskUpper) else: self.askTextLine.setValidator(self.validAskAll) def onActionChanged(self): """ On action changed """ descr = 'No description available!' i = 0 for el in GuiSteps.ACTION_FRAMEWORK_DESCR: if isinstance(el, dict): if self.actionsComboBox.currentText() in el: descr = GuiSteps.ACTION_FRAMEWORK_DESCR[i][self.actionsComboBox.currentText()] break i += 1 self.labelActionDescr.setText( "%s\n" % descr ) if self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_INFO, GuiSteps.FRAMEWORK_WARNING ]: self.getTextGroup.show() self.getWaitGroup.hide() self.setCacheGroup.hide() self.getCheckGroup.hide() self.getAskGroup.hide() self.arrowLabel.show() self.arrowLabel2.show() elif self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_WAIT ]: self.getWaitGroup.show() self.getTextGroup.hide() self.setCacheGroup.hide() self.getCheckGroup.hide() self.getAskGroup.hide() self.arrowLabel.show() self.arrowLabel2.show() elif self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_CACHE_SET ]: self.getTextGroup.show() self.getWaitGroup.hide() self.setCacheGroup.show() self.getCheckGroup.hide() self.getAskGroup.hide() self.arrowLabel.show() self.arrowLabel2.show() elif self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_CHECK_STRING ]: self.getCheckGroup.show() self.getTextGroup.hide() self.getWaitGroup.hide() self.setCacheGroup.hide() self.getAskGroup.hide() self.arrowLabel.show() self.arrowLabel2.show() elif self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_INTERACT ]: self.getCheckGroup.hide() self.getTextGroup.hide() self.getWaitGroup.hide() self.setCacheGroup.hide() self.getAskGroup.show() self.arrowLabel.show() self.arrowLabel2.show() elif self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_USERCODE, GuiSteps.FRAMEWORK_CACHE_RESET ]: self.getCheckGroup.hide() self.getTextGroup.hide() self.getWaitGroup.hide() self.setCacheGroup.hide() self.getAskGroup.hide() self.arrowLabel.hide() self.arrowLabel2.show() else: self.getTextGroup.hide() self.getWaitGroup.hide() self.setCacheGroup.hide() self.getCheckGroup.hide() self.getAskGroup.hide() self.arrowLabel.hide() self.arrowLabel2.hide() def addStep(self): """ Add step """ action = self.actionsComboBox.currentText() descr = self.descriptionLine.text() descr = unicode(descr).replace('"', '') signal = self.AddStep if self.cancelAction.isEnabled(): signal = self.UpdateStep if action in [ GuiSteps.FRAMEWORK_INFO, GuiSteps.FRAMEWORK_WARNING ]: fromCache = False if self.basicTextCombo.currentText() == "CACHE": fromCache = True fromAlias = False if self.basicTextCombo.currentText() == "ALIAS": fromAlias = True newText = self.basicTextLine.text() if not len(newText): QMessageBox.warning(self, "Assistant" , "Please to set a value!") else: parameters = { 'text': newText, 'from-cache': fromCache, 'from-alias': fromAlias } signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters ) elif action in [ GuiSteps.FRAMEWORK_INTERACT ]: # read text from cache, alias or not ? fromCache = False if self.askTextCombo.currentText() == "CACHE": fromCache = True fromAlias = False if self.askTextCombo.currentText() == "ALIAS": fromAlias = True askText = self.askTextLine.text() if not len(askText): QMessageBox.warning(self, "Assistant" , "Please to set question to ask!") else: saveAskText = self.askTextCacheLine.text() if not len(saveAskText): QMessageBox.warning(self, "Assistant" , "Please to set key destination cache!") else: parameters = { 'key': saveAskText, 'value': askText, 'from-cache': fromCache, 'from-alias': fromAlias } signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters ) elif action in [ GuiSteps.FRAMEWORK_CHECK_STRING ]: fromCache = False if self.checkOutTextCombo.currentText() == "CACHE": fromCache = True fromAlias = False if self.checkOutTextCombo.currentText() == "ALIAS": fromAlias = True inText = self.checkInTextLine.text() if not len(inText): QMessageBox.warning(self, "Assistant" , "Please to set a cache key value!") else: outText = self.checkOutTextLine.text() if not len(outText): QMessageBox.warning(self, "Assistant" , "Please to set a value!") else: op = self.checkComboBox.currentText() parameters = { 'key': inText, 'value': outText, 'from-cache': fromCache, 'from-alias': fromAlias, "operator": op } signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters ) elif action in [ GuiSteps.FRAMEWORK_WAIT ]: fromCache = False if self.valueWaitCombo.currentText() == "CACHE": fromCache = True fromAlias = False if self.valueWaitCombo.currentText() == "ALIAS": fromAlias = True miscStr = self.valueWaitLine.text() if not len(miscStr): QMessageBox.warning(self, "Assistant" , "Please to set a value!") else: parameters = {'from-cache': fromCache, 'from-alias': fromAlias} signal.emit( str(action), unicode(descr), miscStr, parameters ) elif action in [ GuiSteps.FRAMEWORK_CACHE_SET ]: fromCache = False if self.basicTextCombo.currentText() == "CACHE": fromCache = True fromAlias = False if self.basicTextCombo.currentText() == "ALIAS": fromAlias = True newText = self.basicTextLine.text() if not len(newText): QMessageBox.warning(self, "Assistant" , "Please to set a text value!") else: miscStr = self.cacheKeyName.text() if not len(miscStr): QMessageBox.warning(self, "Assistant" , "Please to set a key name!") else: parameters = { 'key': miscStr, 'value': newText, 'from-cache': fromCache, 'from-alias': fromAlias } signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters ) else: signal.emit( str(action), unicode(descr), EMPTY_VALUE, {} ) def cancelStep(self): """ Cancel step """ self.addAction.setText( "&Add" ) buttonFont = QFont() buttonFont.setBold(False) self.addAction.setFont(buttonFont) self.cancelAction.setEnabled(False) self.CancelEdit.emit() def finalizeUpdate(self): """ Finalize update """ self.addAction.setText( "&Add Action" ) buttonFont = QFont() buttonFont.setBold(False) self.addAction.setFont(buttonFont) self.cancelAction.setEnabled(False) def editStep(self, stepData): """ Edit step """ self.addAction.setText( "&Update" ) buttonFont = QFont() buttonFont.setBold(True) self.addAction.setFont(buttonFont) self.cancelAction.setEnabled(True) # set the current value for actions combo for i in xrange(self.actionsComboBox.count()): item_text = self.actionsComboBox.itemText(i) if unicode(stepData["action"]) == unicode(item_text): self.actionsComboBox.setCurrentIndex(i) break # and then refresh options self.onActionChanged() # finally fill all fields self.descriptionLine.setText( stepData["description"] ) if self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_INFO, GuiSteps.FRAMEWORK_WARNING ] : self.basicTextLine.setText ( stepData["parameters"]["text"] ) if stepData["parameters"]["from-cache"]: self.basicTextLine.setValidator(self.validatorAll) self.basicTextCombo.setCurrentIndex(INDEX_CACHE) elif stepData["parameters"]["from-alias"]: self.basicTextLine.setValidator(self.validatorUpper) self.basicTextCombo.setCurrentIndex(INDEX_ALIAS) else: self.basicTextLine.setValidator(self.validatorAll) self.basicTextCombo.setCurrentIndex(INDEX_TEXT) if self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_WAIT ]: self.valueWaitLine.setText ( stepData["misc"] ) if stepData["parameters"]["from-cache"]: self.valueWaitLine.setValidator(self.validatorAll) self.valueWaitCombo.setCurrentIndex(INDEX_CACHE) elif stepData["parameters"]["from-alias"]: self.valueWaitLine.setValidator(self.validatorUpper) self.valueWaitCombo.setCurrentIndex(INDEX_ALIAS) else: self.valueWaitLine.setValidator(self.validatorInt) self.valueWaitCombo.setCurrentIndex(INDEX_TEXT) if self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_CACHE_SET ]: self.basicTextLine.setText ( stepData["parameters"]["value"] ) if stepData["parameters"]["from-cache"]: self.basicTextLine.setValidator(self.validatorAll) self.basicTextCombo.setCurrentIndex(INDEX_CACHE) elif stepData["parameters"]["from-alias"]: self.basicTextLine.setValidator(self.validatorUpper) self.basicTextCombo.setCurrentIndex(INDEX_ALIAS) else: self.basicTextLine.setValidator(self.validatorAll) self.basicTextCombo.setCurrentIndex(INDEX_TEXT) self.cacheKeyName.setText( stepData["parameters"]["key"] ) if self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_CHECK_STRING ]: self.checkOutTextLine.setText ( stepData["parameters"]["value"] ) if stepData["parameters"]["from-cache"]: self.checkOutTextLine.setValidator(self.validatorAll) self.checkOutTextCombo.setCurrentIndex(INDEX_CACHE) elif stepData["parameters"]["from-alias"]: self.checkOutTextLine.setValidator(self.validatorUpper) self.checkOutTextCombo.setCurrentIndex(INDEX_ALIAS) else: self.checkOutTextLine.setValidator(self.validatorAll) self.checkOutTextCombo.setCurrentIndex(INDEX_TEXT) self.checkInTextLine.setText ( stepData["parameters"]["key"] ) for i in xrange(self.checkComboBox.count()): item_text = self.checkComboBox.itemText(i) if unicode(stepData["parameters"]["operator"]) == unicode(item_text): self.checkComboBox.setCurrentIndex(i) break if self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_INTERACT ]: self.askTextLine.setText ( stepData["parameters"]["value"] ) if stepData["parameters"]["from-cache"]: self.askTextLine.setValidator(self.validatorAll) self.askTextCombo.setCurrentIndex(INDEX_CACHE) elif stepData["parameters"]["from-alias"]: self.askTextLine.setValidator(self.validatorUpper) self.askTextCombo.setCurrentIndex(INDEX_ALIAS) else: self.askTextLine.setValidator(self.validatorAll) self.askTextCombo.setCurrentIndex(INDEX_TEXT) self.askTextCacheLine.setText ( stepData["parameters"]["key"] ) def getTimeout(self): """ Return timeout """ return self.optionsDialog.timeoutLine.text() def setTimeout(self, timeout): """ Set the timeout """ return self.optionsDialog.timeoutLine.setText(timeout)
class ShowSettingsDialog(QDialog): """ Dialog class for plugin settings """ def __init__(self, iface, memoryPointsLayer, memoryLinesLayer, ctllDb, configTable, uriDb, schemaDb, mntUrl, refLayers, adjLayers, levelAtt, levelVal, drawdowmLayer, pipeDiam, moreTools): """ Constructor :param iface: interface :param memoryPointsLayer: working memory points layer :param memoryLinesLayer: working memory lines layer :param configTable: config table selected for import """ QDialog.__init__(self) self.__iface = iface self.__memoryPointsLayer = memoryPointsLayer self.__memoryLinesLayer = memoryLinesLayer self.__ctlDb = ctllDb self.__configTable = configTable self.__uriDb = uriDb self.__schemaDb = schemaDb self.__mntUrl = mntUrl self.__refLayers = refLayers self.__adjLayers = adjLayers self.__levelAtt = levelAtt self.__levelVal = levelVal self.__drawdowmLayer = drawdowmLayer self.__pipeDiam = pipeDiam self.setWindowTitle(QCoreApplication.translate("VDLTools", "Settings")) self.__pointsLayers = [] self.__linesLayers = [] self.__refAvailableLayers = [] self.__drawdownLayers = [] self.__tables = [] self.__schemas = [] self.__pipeDiamFields = [] self.__levelAttFields = [] self.__dbs = DBConnector.getUsedDatabases() self.__refLabels = [] self.__refChecks = [] self.__adjChecks = [] for layer in list(QgsMapLayerRegistry.instance().mapLayers().values()): if layer is not None and layer.type() == QgsMapLayer.VectorLayer: if layer.providerType() == "memory": if layer.geometryType() == QGis.Point: self.__pointsLayers.append(layer) if layer.geometryType() == QGis.Line: self.__linesLayers.append(layer) if QGis.fromOldWkbType(layer.wkbType()) == QgsWKBTypes.LineStringZ: self.__drawdownLayers.append(layer) if QGis.fromOldWkbType(layer.wkbType()) == QgsWKBTypes.PointZ: self.__refAvailableLayers.append(layer) # self.resize(450, 400) self.__layout = QGridLayout() line = 0 intersectLabel = QLabel(QCoreApplication.translate("VDLTools", "Intersect ")) self.__layout.addWidget(intersectLabel, line, 0) line += 1 pointLabel = QLabel(QCoreApplication.translate("VDLTools", "Working points layer : ")) self.__layout.addWidget(pointLabel, line, 1) self.__pointCombo = QComboBox() self.__pointCombo.setMinimumHeight(20) self.__pointCombo.setMinimumWidth(50) self.__pointCombo.addItem("") for layer in self.__pointsLayers: self.__pointCombo.addItem(layer.name()) self.__layout.addWidget(self.__pointCombo, line, 2) self.__pointCombo.currentIndexChanged.connect(self.__pointComboChanged) if self.__memoryPointsLayer is not None: if self.__memoryPointsLayer in self.__pointsLayers: self.__pointCombo.setCurrentIndex(self.__pointsLayers.index(self.__memoryPointsLayer)+1) line += 1 lineLabel = QLabel(QCoreApplication.translate("VDLTools", "Working lines layer : ")) self.__layout.addWidget(lineLabel, line, 1) self.__lineCombo = QComboBox() self.__lineCombo.setMinimumHeight(20) self.__lineCombo.setMinimumWidth(50) self.__lineCombo.addItem("") for layer in self.__linesLayers: self.__lineCombo.addItem(layer.name()) self.__layout.addWidget(self.__lineCombo, line, 2) self.__lineCombo.currentIndexChanged.connect(self.__lineComboChanged) if self.__memoryLinesLayer is not None: if self.__memoryLinesLayer in self.__linesLayers: self.__lineCombo.setCurrentIndex(self.__linesLayers.index(self.__memoryLinesLayer)+1) line += 1 profilesLabel = QLabel(QCoreApplication.translate("VDLTools", "Profiles ")) self.__layout.addWidget(profilesLabel, line, 0) line += 1 mntLabel = QLabel(QCoreApplication.translate("VDLTools", "Url for MNT : ")) self.__layout.addWidget(mntLabel, line, 1) self.__mntText = QLineEdit() if self.__mntUrl is None or self.__mntUrl == "None": self.__mntText.insert('https://map.lausanne.ch/prod/wsgi/profile.json') else: self.__mntText.insert(self.__mntUrl) self.__mntText.setMinimumHeight(20) self.__mntText.setMinimumWidth(100) self.__layout.addWidget(self.__mntText, line, 2) line += 1 ddLabel = QLabel(QCoreApplication.translate("VDLTools", "Drawdown ")) self.__layout.addWidget(ddLabel, line, 0) line += 1 self.__layout.addWidget(QLabel(QCoreApplication.translate("VDLTools", "Layer")), line, 1) namesLayout = QHBoxLayout() namesWidget = QWidget() namesLayout.addWidget(QLabel(QCoreApplication.translate("VDLTools", "Reference"))) namesLayout.addWidget(QLabel(QCoreApplication.translate("VDLTools", "Adjustable"))) namesLayout.setContentsMargins(0,0,0,0) namesWidget.setLayout(namesLayout) self.__layout.addWidget(namesWidget, line, 2) line += 1 for layer in self.__refAvailableLayers: refLabel = QLabel(" - " + layer.name()) self.__refLabels.append(refLabel) self.__layout.addWidget(refLabel, line, 1) checksLayout = QHBoxLayout() checksLayout.setContentsMargins(0,0,0,0) checksWidget = QWidget() refCheck = QCheckBox() self.__refChecks.append(refCheck) refCheck.stateChanged.connect(self.__refBoxesChanged) checksLayout.addWidget(refCheck) adjCheck = QCheckBox() self.__adjChecks.append(adjCheck) checksLayout.addWidget(adjCheck) checksWidget.setLayout(checksLayout) self.__layout.addWidget(checksWidget, line, 2) line += 1 levelAttLabel = QLabel(QCoreApplication.translate("VDLTools", "Code(s) on pipe : ")) self.__layout.addWidget(levelAttLabel, line, 1) self.__levelAttCombo = QComboBox() self.__levelAttCombo.setMinimumHeight(20) self.__levelAttCombo.setMinimumWidth(50) self.__levelAttCombo.addItem("") self.__layout.addWidget(self.__levelAttCombo, line, 2) self.__levelAttCombo.currentIndexChanged.connect(self.__levelAttComboChanged) i = 0 for layer in self.__refAvailableLayers: if layer in self.__refLayers: self.__refChecks[i].setChecked(True) if layer in self.__adjLayers: self.__adjChecks[i].setChecked(True) i += 1 line += 1 levelValLabel = QLabel(QCoreApplication.translate("VDLTools", "Point code attribute : ")) self.__layout.addWidget(levelValLabel, line, 1) self.__levelValText = QLineEdit() if self.__levelVal is not None and self.__levelVal != "None": self.__levelValText.insert(self.__levelVal) self.__levelValText.setMinimumHeight(20) self.__levelValText.setMinimumWidth(100) self.__layout.addWidget(self.__levelValText, line, 2) line += 1 drawdownLabel = QLabel(QCoreApplication.translate("VDLTools", "drawdown layer : ")) self.__layout.addWidget(drawdownLabel, line, 1) self.__drawdownCombo = QComboBox() self.__drawdownCombo.setMinimumHeight(20) self.__drawdownCombo.setMinimumWidth(50) self.__drawdownCombo.addItem("") for layer in self.__drawdownLayers: self.__drawdownCombo.addItem(layer.name()) self.__layout.addWidget(self.__drawdownCombo, line, 2) line += 1 pipeDiamLabel = QLabel(QCoreApplication.translate("VDLTools", "Pipe diameter attribute [cm] : ")) self.__layout.addWidget(pipeDiamLabel, line, 1) self.__pipeDiamCombo = QComboBox() self.__pipeDiamCombo.setMinimumHeight(20) self.__pipeDiamCombo.setMinimumWidth(50) self.__pipeDiamCombo.addItem("") self.__layout.addWidget(self.__pipeDiamCombo, line, 2) self.__drawdownCombo.currentIndexChanged.connect(self.__drawdownComboChanged) self.__pipeDiamCombo.currentIndexChanged.connect(self.__pipeDiamComboChanged) if self.__drawdowmLayer is not None: if self.__drawdowmLayer in self.__drawdownLayers: self.__drawdownCombo.setCurrentIndex(self.__drawdownLayers.index(self.__drawdowmLayer)+1) if moreTools: line += 1 importLabel = QLabel(QCoreApplication.translate("VDLTools", "Import ")) self.__layout.addWidget(importLabel, line, 0) line += 1 dbLabel = QLabel(QCoreApplication.translate("VDLTools", "Import database : ")) self.__layout.addWidget(dbLabel, line, 1) self.__dbCombo = QComboBox() self.__dbCombo.setMinimumHeight(20) self.__dbCombo.setMinimumWidth(50) self.__dbCombo.addItem("") for db in list(self.__dbs.keys()): self.__dbCombo.addItem(db) self.__layout.addWidget(self.__dbCombo, line, 2) line += 1 schemaLabel = QLabel(QCoreApplication.translate("VDLTools", "Database schema : ")) self.__layout.addWidget(schemaLabel, line, 1) self.__schemaCombo = QComboBox() self.__schemaCombo.setMinimumHeight(20) self.__schemaCombo.setMinimumWidth(50) self.__schemaCombo.addItem("") self.__layout.addWidget(self.__schemaCombo, line, 2) line += 1 tableLabel = QLabel(QCoreApplication.translate("VDLTools", "Config table : ")) self.__layout.addWidget(tableLabel, line, 1) self.__tableCombo = QComboBox() self.__tableCombo.setMinimumHeight(20) self.__tableCombo.setMinimumWidth(50) self.__tableCombo.addItem("") self.__layout.addWidget(self.__tableCombo, line, 2) line += 1 controlLabel = QLabel(QCoreApplication.translate("VDLTools", "Control ")) self.__layout.addWidget(controlLabel, line, 0) line += 1 ctlLabel = QLabel(QCoreApplication.translate("VDLTools", "Control database : ")) self.__layout.addWidget(ctlLabel, line, 1) self.__ctlCombo = QComboBox() self.__ctlCombo.setMinimumHeight(20) self.__ctlCombo.setMinimumWidth(50) self.__ctlCombo.addItem("") for db in list(self.__dbs.keys()): self.__ctlCombo.addItem(db) self.__layout.addWidget(self.__ctlCombo, line, 2) self.__dbCombo.currentIndexChanged.connect(self.__dbComboChanged) self.__schemaCombo.currentIndexChanged.connect(self.__schemaComboChanged) self.__tableCombo.currentIndexChanged.connect(self.__tableComboChanged) self.__ctlCombo.currentIndexChanged.connect(self.__ctlComboChanged) if self.__uriDb is not None: if self.__uriDb.database() in list(self.__dbs.keys()): self.__dbCombo.setCurrentIndex(list(self.__dbs.keys()).index(self.__uriDb.database()) + 1) if self.__ctlDb is not None: if self.__ctlDb.database() in list(self.__dbs.keys()): self.__ctlCombo.setCurrentIndex(list(self.__dbs.keys()).index(self.__ctlDb.database()) + 1) else: self.__dbCombo = None self.__schemaCombo = None self.__tableCombo = None self.__ctlCombo = None self.__okButton = QPushButton(QCoreApplication.translate("VDLTools", "OK")) self.__okButton.setMinimumHeight(20) self.__okButton.setMinimumWidth(100) self.__cancelButton = QPushButton(QCoreApplication.translate("VDLTools", "Cancel")) self.__cancelButton.setMinimumHeight(20) self.__cancelButton.setMinimumWidth(100) self.__layout.addWidget(self.__okButton, 100, 1) self.__layout.addWidget(self.__cancelButton, 100, 2) self.setLayout(self.__layout) @staticmethod def __resetCombo(combo): """ To reset a combo list :param combo: concerned combo """ while combo.count() > 0: combo.removeItem(combo.count()-1) def __setSchemaCombo(self, uriDb): """ To fill the schema combo list :param uriDb: selected database uri """ connector = DBConnector(uriDb, self.__iface) db = connector.setConnection() if db: Signal.safelyDisconnect(self.__schemaCombo.currentIndexChanged, self.__schemaComboChanged) self.__resetCombo(self.__schemaCombo) self.__schemaCombo.addItem("") self.__schemas = [] query = db.exec_("""SELECT DISTINCT table_schema FROM information_schema.tables WHERE table_schema NOT IN ('pg_catalog', 'information_schema', 'topology') AND table_type = 'BASE TABLE' AND table_name NOT IN (SELECT f_table_name FROM geometry_columns)""") if query.lastError().isValid(): self.__iface.messageBar().pushMessage(query.lastError().text(), level=QgsMessageBar.CRITICAL, duration=0) else: while next(query): self.__schemas.append(query.value(0)) db.close() for schema in self.__schemas: self.__schemaCombo.addItem(schema) self.__schemaCombo.currentIndexChanged.connect(self.__schemaComboChanged) if self.__schemaDb is not None: if self.__schemaDb in self.__schemas: self.__schemaCombo.setCurrentIndex(self.__schemas.index(self.__schemaDb) + 1) def __setTableCombo(self, uriDb, schema): """ To fill the table combo list :param uriDb: selected database uri :param schema: selected database schema """ connector = DBConnector(uriDb, self.__iface) db = connector.setConnection() if db: Signal.safelyDisconnect(self.__tableCombo.currentIndexChanged, self.__tableComboChanged) self.__resetCombo(self.__tableCombo) self.__tableCombo.addItem("") self.__tables = [] query = db.exec_("""SELECT table_name FROM information_schema.tables WHERE table_schema = '""" + schema + """' ORDER BY table_name""") if query.lastError().isValid(): self.__iface.messageBar().pushMessage(query.lastError().text(), level=QgsMessageBar.CRITICAL, duration=0) else: while next(query): self.__tables.append(query.value(0)) db.close() for table in self.__tables: if self.__tableCombo.findText(table) == -1: self.__tableCombo.addItem(table) self.__tableCombo.currentIndexChanged.connect(self.__tableComboChanged) if self.__configTable is not None: if self.__configTable in self.__tables: self.__tableCombo.setCurrentIndex(self.__tables.index(self.__configTable) + 1) def __setPipeDiamCombo(self, drawdownLayer): """ To fill the pipe diameter combo list :param drawdownLayer: choosen drawdown layer """ Signal.safelyDisconnect(self.__pipeDiamCombo.currentIndexChanged, self.__pipeDiamComboChanged) self.__resetCombo(self.__pipeDiamCombo) self.__pipeDiamCombo.addItem("") fields = drawdownLayer.fields() self.__pipeDiamFields = [] for field in fields: self.__pipeDiamFields.append(field.name()) self.__pipeDiamCombo.addItem(field.name()) self.__pipeDiamCombo.currentIndexChanged.connect(self.__pipeDiamComboChanged) if self.__pipeDiam is not None: if self.__pipeDiam in self.__pipeDiamFields: self.__pipeDiamCombo.setCurrentIndex(self.__pipeDiamFields.index(self.__pipeDiam) + 1) def __setLevelAttCombo(self, refLayers): """ To fill the level attribute combo list :param refLayers: choosen reference layers """ Signal.safelyDisconnect(self.__levelAttCombo.currentIndexChanged, self.__levelAttComboChanged) self.__resetCombo(self.__levelAttCombo) self.__levelAttCombo.addItem("") self.__levelAttFields = [] num = 0 for layer in refLayers: fields = layer.fields() if num == 0: for field in fields: self.__levelAttFields.append(field.name()) num = 1 else: names = [] for field in fields: names.append(field.name()) news = [] for name in self.__levelAttFields: if name in names: news.append(name) self.__levelAttFields = news for name in self.__levelAttFields: self.__levelAttCombo.addItem(name) self.__levelAttCombo.currentIndexChanged.connect(self.__levelAttComboChanged) if self.__levelAtt is not None: if self.__levelAtt in self.__levelAttFields: self.__levelAttCombo.setCurrentIndex(self.__levelAttFields.index(self.__levelAtt) + 1) def __lineComboChanged(self): """ To remove blank item when another one is selected """ if self.__lineCombo.itemText(0) == "": self.__lineCombo.removeItem(0) def __pointComboChanged(self): """ To remove blank item when another one is selected """ if self.__pointCombo.itemText(0) == "": self.__pointCombo.removeItem(0) def __refBoxesChanged(self): """ To update level attribute combo when reference layers have changed """ if self.refLayers() is not None: self.__setLevelAttCombo(self.refLayers()) def __drawdownComboChanged(self): """ To remove blank item when another one is selected and update pipe diamete combo when drawdown layer has changed """ if self.__drawdownCombo.itemText(0) == "": self.__drawdownCombo.removeItem(0) if self.drawdownLayer() is not None: self.__setPipeDiamCombo(self.drawdownLayer()) def __tableComboChanged(self): """ To remove blank item when another one is selected """ if self.__tableCombo.itemText(0) == "": self.__tableCombo.removeItem(0) def __dbComboChanged(self): """ When the selection in db combo has changed """ if self.__dbCombo.itemText(0) == "": self.__dbCombo.removeItem(0) if self.uriDb() is not None: self.__setSchemaCombo(self.uriDb()) def __schemaComboChanged(self): """ When the selection in schema combo has changed """ if self.__schemaCombo.itemText(0) == "": self.__schemaCombo.removeItem(0) if self.schemaDb() is not None: self.__setTableCombo(self.uriDb(), self.schemaDb()) def __pipeDiamComboChanged(self): """ When the selection in schema combo has changed """ if self.__pipeDiamCombo.itemText(0) == "": self.__pipeDiamCombo.removeItem(0) def __levelAttComboChanged(self): """ When the selection in schema combo has changed """ if self.__levelAttCombo.itemText(0) == "": self.__levelAttCombo.removeItem(0) def __ctlComboChanged(self): """ When the selection in ctl combo has changed """ if self.__ctlCombo.itemText(0) == "": self.__ctlCombo.removeItem(0) def okButton(self): """ To get the ok button instance :return: ok button instance """ return self.__okButton def cancelButton(self): """ To get the cancel button instance :return: cancel button instance """ return self.__cancelButton def pointsLayer(self): """ To get the selected memory points layer :return: selected memory points layer, or none """ index = self.__pointCombo.currentIndex() if self.__pointCombo.itemText(index) == "": return None else: return self.__pointsLayers[index] def linesLayer(self): """ To get the selected memory lines layer :return: selected memory lines layer, or none """ index = self.__lineCombo.currentIndex() if self.__lineCombo.itemText(index) == "": return None else: return self.__linesLayers[index] def refLayers(self): """ To get the selected reference layers :return: selected reference layers, or none """ layers = [] i = 0 for check in self.__refChecks: if check.isChecked(): layers.append(self.__refAvailableLayers[i]) i += 1 return layers def adjLayers(self): """ To get the selected ajustable layers :return: selected adjustable layers, or none """ layers = [] i = 0 for check in self.__adjChecks: if check.isChecked(): layers.append(self.__refAvailableLayers[i]) i += 1 return layers def levelAtt(self): """ To get the selected level attribute :return: selected level attribute, or none """ if self.__levelAttCombo is None: return None index = self.__levelAttCombo.currentIndex() if self.__levelAttCombo.itemText(index) == "": return None else: return self.__levelAttFields[index] def levelVal(self): """ To get the filled level value :return: filled level value """ return self.__levelValText.text() def drawdownLayer(self): """ To get the selected drawdown layer :return: selected drawdown layer, or none """ index = self.__drawdownCombo.currentIndex() if self.__drawdownCombo.itemText(index) == "": return None else: return self.__drawdownLayers[index] def pipeDiam(self): """ To get the selected pipe diameter :return: selected pipe diameter, or none """ if self.__pipeDiamCombo is None: return None index = self.__pipeDiamCombo.currentIndex() if self.__pipeDiamCombo.itemText(index) == "": return None else: return self.__pipeDiamFields[index] def configTable(self): """ To get the selected config table :return: selected config table, or none """ if self.__tableCombo is None: return None index = self.__tableCombo.currentIndex() if self.__tableCombo.itemText(index) == "": return None else: return self.__tables[index] def uriDb(self): """ To get selected import database uri :return: import database uri """ if self.__dbCombo is None: return None index = self.__dbCombo.currentIndex() if self.__dbCombo.itemText(index) == "": return None else: return self.__dbs[list(self.__dbs.keys())[index]] def schemaDb(self): """ To get selected import database schema :return: import database schema """ if self.__schemaCombo is None: return None index = self.__schemaCombo.currentIndex() if self.__schemaCombo.itemText(index) == "": return None else: return self.__schemas[index] def mntUrl(self): """ To get selected MN url :return: MN url """ return self.__mntText.text() def ctlDb(self): """ To get selected control database uri :return: control database uri """ if self.__ctlCombo is None: return None index = self.__ctlCombo.currentIndex() if self.__ctlCombo.itemText(index) == "": return None else: return self.__dbs[list(self.__dbs.keys())[index]]
class ProjectTreeColumn(QDialog): def __init__(self, parent=None): super(ProjectTreeColumn, self).__init__(parent, Qt.WindowStaysOnTopHint) vbox = QVBoxLayout(self) vbox.setSizeConstraint(QVBoxLayout.SetDefaultConstraint) vbox.setContentsMargins(0, 0, 0, 0) self._buttons = [] self._combo_project = QComboBox() self._combo_project.setMinimumHeight(30) self._combo_project.setContextMenuPolicy(Qt.CustomContextMenu) vbox.addWidget(self._combo_project) self._projects_area = QStackedLayout() logger.debug("This is the projects area") logger.debug(self._projects_area) vbox.addLayout(self._projects_area) self.projects = [] self.connect(self._combo_project, SIGNAL("currentIndexChanged(int)"), self._change_current_project) self.connect(self._combo_project, SIGNAL( "customContextMenuRequested(const QPoint &)"), self.context_menu_for_root) connections = ( {'target': 'main_container', 'signal_name': 'addToProject(QString)', 'slot': self._add_file_to_project}, {'target': 'main_container', 'signal_name': 'showFileInExplorer(QString)', 'slot': self._show_file_in_explorer}, ) IDE.register_service('projects_explorer', self) IDE.register_signals('projects_explorer', connections) ExplorerContainer.register_tab(translations.TR_TAB_PROJECTS, self) #FIXME: Should have a ninja settings object that stores tree state #FIXME: Or bettter, application data object #TODO: check this: #self.connect(ide, SIGNAL("goingDown()"), #self.tree_projects.shutdown) #def close_project_signal(): #self.emit(SIGNAL("updateLocator()")) def install_tab(self): ide = IDE.get_service('ide') ui_tools.install_shortcuts(self, actions.PROJECTS_TREE_ACTIONS, ide) self.connect(ide, SIGNAL("goingDown()"), self.close) def load_session_projects(self, projects): for project in projects: if os.path.exists(project): self._open_project_folder(project) def open_project_folder(self, folderName=None): if settings.WORKSPACE: directory = settings.WORKSPACE else: directory = os.path.expanduser("~") if folderName is None: folderName = QFileDialog.getExistingDirectory( self, translations.TR_OPEN_PROJECT_DIRECTORY, directory) logger.debug("Choosing Foldername") if folderName: logger.debug("Opening %s" % folderName) self._open_project_folder(folderName) def _open_project_folder(self, folderName): ninjaide = IDE.get_service("ide") project = NProject(folderName) qfsm = ninjaide.filesystem.open_project(project) if qfsm: self.add_project(project) self.emit(SIGNAL("updateLocator()")) self.save_recent_projects(folderName) main_container = IDE.get_service('main_container') if main_container: main_container.show_editor_area() def _add_file_to_project(self, path): """Add the file for 'path' in the project the user choose here.""" if self._active_project: pathProject = [self._active_project.project] addToProject = add_to_project.AddToProject(pathProject, self) addToProject.exec_() if not addToProject.pathSelected: return main_container = IDE.get_service('main_container') if not main_container: return editorWidget = main_container.get_current_editor() if not editorWidget.file_path: name = QInputDialog.getText(None, translations.TR_ADD_FILE_TO_PROJECT, translations.TR_FILENAME + ": ")[0] if not name: QMessageBox.information( self, translations.TR_INVALID_FILENAME, translations.TR_INVALID_FILENAME_ENTER_A_FILENAME) return else: name = file_manager.get_basename(editorWidget.file_path) new_path = file_manager.create_path(addToProject.pathSelected, name) ide_srv = IDE.get_service("ide") old_file = ide_srv.get_or_create_nfile(path) new_file = old_file.save(editorWidget.get_text(), new_path) #FIXME: Make this file replace the original in the open tab else: pass # Message about no project def _show_file_in_explorer(self, path): '''Iterate through the list of available projects and show the current file in the explorer view for the first project that contains it (i.e. if the same file is included in multiple open projects, the path will be expanded for the first project only). Note: This slot is connected to the main container's "showFileInExplorer(QString)" signal.''' for project in self.projects: index = project.model().index(path) if index.isValid(): # Show the explorer if it is currently hidden central = IDE.get_service('central_container') if central and not central.is_lateral_panel_visible(): central.change_lateral_visibility() # This highlights the index in the tree for us project.setCurrentIndex(index) # Loop through the parents to expand the tree # all the way up to the selected index. while index.isValid(): project.expand(index) index = index.parent() break def add_project(self, project): if project not in self.projects: self._combo_project.addItem(project.name) ptree = TreeProjectsWidget(project) self._projects_area.addWidget(ptree) self.connect(ptree, SIGNAL("closeProject(PyQt_PyObject)"), self._close_project) pmodel = project.model ptree.setModel(pmodel) pindex = pmodel.index(pmodel.rootPath()) ptree.setRootIndex(pindex) self.projects.append(ptree) current_index = self._projects_area.count() self._projects_area.setCurrentIndex(current_index - 1) self._combo_project.setCurrentIndex(current_index - 1) def _close_project(self, widget): """Close the project related to the tree widget.""" index = self._projects_area.currentIndex() self.projects.remove(widget) self._projects_area.takeAt(index) self._combo_project.removeItem(index) index = self._combo_project.currentIndex() self._projects_area.setCurrentIndex(index) ninjaide = IDE.get_service('ide') ninjaide.filesystem.close_project(widget.project.path) widget.deleteLater() def _change_current_project(self, index): self._projects_area.setCurrentIndex(index) def close_opened_projects(self): for project in reversed(self.projects): self._close_project(project) def save_project(self): """Save all the opened files that belongs to the actual project.""" if self._active_project: path = self._projects_area.currentWidget().project.path main_container = IDE.get_service('main_container') if path and main_container: main_container.save_project(path) def create_new_project(self): wizard = new_project_manager.NewProjectManager(self) wizard.show() @property def current_project(self): if self._projects_area.count() > 0: return self._projects_area.currentWidget().project @property def current_tree(self): return self._projects_area.currentWidget() def save_recent_projects(self, folder): settings = IDE.data_settings() recent_project_list = settings.value('recentProjects', {}) #if already exist on the list update the date time projectProperties = json_manager.read_ninja_project(folder) name = projectProperties.get('name', '') description = projectProperties.get('description', '') if name == '': name = file_manager.get_basename(folder) if description == '': description = translations.TR_NO_DESCRIPTION if folder in recent_project_list: properties = recent_project_list[folder] properties["lastopen"] = QDateTime.currentDateTime() properties["name"] = name properties["description"] = description recent_project_list[folder] = properties else: recent_project_list[folder] = { "name": name, "description": description, "isFavorite": False, "lastopen": QDateTime.currentDateTime()} #if the length of the project list it's high that 10 then delete #the most old #TODO: add the length of available projects to setting if len(recent_project_list) > 10: del recent_project_list[self.find_most_old_open( recent_project_list)] settings.setValue('recentProjects', recent_project_list) def find_most_old_open(self, recent_project_list): listFounder = [] for recent_project_path, content in list(recent_project_list.items()): listFounder.append((recent_project_path, int( content["lastopen"].toString("yyyyMMddHHmmzzz")))) listFounder = sorted(listFounder, key=lambda date: listFounder[1], reverse=True) # sort by date last used return listFounder[0][0] def reject(self): if self.parent() is None: self.emit(SIGNAL("dockWidget(PyQt_PyObject)"), self) def closeEvent(self, event): self.emit(SIGNAL("dockWidget(PyQt_PyObject)"), self) event.ignore() def context_menu_for_root(self): menu = QMenu(self) path = self.current_tree.project.path action_add_file = menu.addAction(QIcon(":img/new"), translations.TR_ADD_NEW_FILE) action_add_folder = menu.addAction(QIcon( ":img/openProj"), translations.TR_ADD_NEW_FOLDER) action_create_init = menu.addAction(translations.TR_CREATE_INIT) self.connect(action_add_file, SIGNAL("triggered()"), lambda: self.current_tree._add_new_file(path)) self.connect(action_add_folder, SIGNAL("triggered()"), lambda: self.current_tree._add_new_folder(path)) self.connect(action_create_init, SIGNAL("triggered()"), lambda: self.current_tree._create_init(path)) menu.addSeparator() actionRunProject = menu.addAction(QIcon( ":img/play"), translations.TR_RUN_PROJECT) self.connect(actionRunProject, SIGNAL("triggered()"), self.current_tree._execute_project) if self.current_tree._added_to_console: actionRemoveFromConsole = menu.addAction( translations.TR_REMOVE_PROJECT_FROM_PYTHON_CONSOLE) self.connect(actionRemoveFromConsole, SIGNAL("triggered()"), self.current_tree._remove_project_from_console) else: actionAdd2Console = menu.addAction( translations.TR_ADD_PROJECT_TO_PYTHON_CONSOLE) self.connect(actionAdd2Console, SIGNAL("triggered()"), self.current_tree._add_project_to_console) actionShowFileSizeInfo = menu.addAction(translations.TR_SHOW_FILESIZE) self.connect(actionShowFileSizeInfo, SIGNAL("triggered()"), self.current_tree.show_filesize_info) actionProperties = menu.addAction(QIcon(":img/pref"), translations.TR_PROJECT_PROPERTIES) self.connect(actionProperties, SIGNAL("triggered()"), self.current_tree.open_project_properties) menu.addSeparator() action_close = menu.addAction( self.style().standardIcon(QStyle.SP_DialogCloseButton), translations.TR_CLOSE_PROJECT) self.connect(action_close, SIGNAL("triggered()"), self.current_tree._close_project) #menu for the project for m in self.current_tree.extra_menus_by_scope['project']: if isinstance(m, QMenu): menu.addSeparator() menu.addMenu(m) #show the menu! menu.exec_(QCursor.pos())
class ShowSettingsDialog(QDialog): def __init__(self, iface, memoryPointsLayer, memoryLinesLayer, configTable): """ Constructor :param iface: interface :param memoryPointsLayer: working memory points layer :param memoryLinesLayer: working memory lines layer :param configTable: config table selected for import """ QDialog.__init__(self) self.__iface = iface self.__memoryPointsLayer = memoryPointsLayer self.__memoryLinesLayer = memoryLinesLayer self.__configTable = configTable self.setWindowTitle(QCoreApplication.translate("VDLTools", "Settings")) self.__pointsLayers = [] self.__linesLayers = [] self.__tables = [] # dataSource = QgsDataSourceURI(self.__layer.source()) # db = DBConnector.setConnection(dataSource.database(), self.__iface) # if db: # query = db.exec_("""SELECT table_name FROM information_schema.tables WHERE table_schema NOT IN # ('pg_catalog', 'information_schema', 'topology') AND table_type = 'BASE TABLE' AND table_name NOT IN # (SELECT f_table_name FROM geometry_columns)""") # while query.next(): # self.__tables.append(query.value(0)) # db.close() for layer in self.__iface.mapCanvas().layers(): if layer is not None \ and layer.type() == QgsMapLayer.VectorLayer \ and layer.providerType() == "memory": if layer.geometryType() == QGis.Point: self.__pointsLayers.append(layer) if layer.geometryType() == QGis.Line: self.__linesLayers.append(layer) self.resize(400, 200) self.__layout = QGridLayout() pointLabel = QLabel( QCoreApplication.translate("VDLTools", "Working points layer : ")) pointLabel.setMinimumHeight(20) pointLabel.setMinimumWidth(50) self.__layout.addWidget(pointLabel, 0, 1) self.__pointCombo = QComboBox() self.__pointCombo.setMinimumHeight(20) self.__pointCombo.setMinimumWidth(50) self.__pointCombo.addItem("") for layer in self.__pointsLayers: self.__pointCombo.addItem(layer.name()) self.__layout.addWidget(self.__pointCombo, 0, 2) self.__pointCombo.currentIndexChanged.connect(self.__pointComboChanged) if self.__memoryPointsLayer is not None: if self.__memoryPointsLayer in self.__pointsLayers: self.__pointCombo.setCurrentIndex( self.__pointsLayers.index(self.__memoryPointsLayer) + 1) lineLabel = QLabel( QCoreApplication.translate("VDLTools", "Working lines layer : ")) lineLabel.setMinimumHeight(20) lineLabel.setMinimumWidth(50) self.__layout.addWidget(lineLabel, 1, 1) self.__lineCombo = QComboBox() self.__lineCombo.setMinimumHeight(20) self.__lineCombo.setMinimumWidth(50) self.__lineCombo.addItem("") for layer in self.__linesLayers: self.__lineCombo.addItem(layer.name()) self.__layout.addWidget(self.__lineCombo, 1, 2) self.__lineCombo.currentIndexChanged.connect(self.__lineComboChanged) if self.__memoryLinesLayer is not None: if self.__memoryLinesLayer in self.__linesLayers: self.__lineCombo.setCurrentIndex( self.__linesLayers.index(self.__memoryLinesLayer) + 1) tableLabel = QLabel( QCoreApplication.translate("VDLTools", "Config table : ")) tableLabel.setMinimumHeight(20) tableLabel.setMinimumWidth(50) self.__layout.addWidget(tableLabel, 2, 1) self.__tableCombo = QComboBox() self.__tableCombo.setMinimumHeight(20) self.__tableCombo.setMinimumWidth(50) self.__tableCombo.addItem("") for table in self.__tables: self.__tableCombo.addItem(table) self.__layout.addWidget(self.__tableCombo, 2, 2) self.__tableCombo.currentIndexChanged.connect(self.__tableComboChanged) if self.__configTable is not None: if self.__configTable in self.__tables: self.__tableCombo.setCurrentIndex( self.__tables.index(self.__configTable) + 1) self.__okButton = QPushButton( QCoreApplication.translate("VDLTools", "OK")) self.__okButton.setMinimumHeight(20) self.__okButton.setMinimumWidth(100) self.__cancelButton = QPushButton( QCoreApplication.translate("VDLTools", "Cancel")) self.__cancelButton.setMinimumHeight(20) self.__cancelButton.setMinimumWidth(100) self.__layout.addWidget(self.__okButton, 100, 1) self.__layout.addWidget(self.__cancelButton, 100, 2) self.setLayout(self.__layout) def __lineComboChanged(self): """ To remove blank item when another one is selected """ if self.__lineCombo.itemText(0) == "": self.__lineCombo.removeItem(0) def __pointComboChanged(self): """ To remove blank item when another one is selected """ if self.__pointCombo.itemText(0) == "": self.__pointCombo.removeItem(0) def __tableComboChanged(self): """ To remove blank item when another one is selected """ if self.__tableCombo.itemText(0) == "": self.__tableCombo.removeItem(0) def okButton(self): """ To get the ok button instance :return: ok button instance """ return self.__okButton def cancelButton(self): """ To get the cancel button instance :return: cancel button instance """ return self.__cancelButton def pointsLayer(self): """ To get the selected memory points layer :return: selected memeory points layer, or none """ index = self.__pointCombo.currentIndex() if self.__pointCombo.itemText(index) == "": return None else: return self.__pointsLayers[index] def linesLayer(self): """ To get the selected memory lines layer :return: selected memory lines layer, or none """ index = self.__lineCombo.currentIndex() if self.__lineCombo.itemText(index) == "": return None else: return self.__linesLayers[index] def configTable(self): """ To get the selected config table :return: selected config table, or none """ index = self.__tableCombo.currentIndex() if self.__tableCombo.itemText(index) == "": return None else: return self.__tables[index]
class WAndroid(QWidget, Logger.ClassLogger): """ Android widget """ # action, description, misc, parameters AddStep = pyqtSignal(str, str, str, dict) UpdateStep = pyqtSignal(str, str, str, dict) CancelEdit = pyqtSignal() def __init__(self, parent): """ Constructor """ QWidget.__init__(self) self.createActions() self.createWidgets() self.createToolbar() self.createConnections() def createActions(self): """ Create qt actions """ self.addAndroidAction = QPushButton(QIcon(":/add_black.png"), '&Add Action', self) self.addAndroidAction.setMinimumHeight(40) self.addAndroidAction.setMaximumWidth(150) self.cancelAndroidAction = QtHelper.createAction(self, "&Cancel", self.cancelStep, icon=None, tip = 'Cancel update') self.cancelAndroidAction.setEnabled(False) self.optionsAction = QtHelper.createAction(self, "&", self.openOptions, icon=QIcon(":/recorder-mobile-small.png"), tip = 'Android options') def createWidgets(self): """ Create qt widgets """ self.optionsDialog = OptionsDialog(self) self.validatorUpper = ValidatorUpper(self) self.validatorAll = ValidatorAll(self) self.validatorInt = QIntValidator(self) ###################### android action ######################### self.actionsAndroidComboBox = QComboBox(self) self.actionsAndroidComboBox.setMinimumHeight(40) for i in xrange(len(GuiSteps.ACTION_ANDROID_DESCR)): if not len( GuiSteps.ACTION_ANDROID_DESCR[i] ): self.actionsAndroidComboBox.insertSeparator(i+1) else: el = GuiSteps.ACTION_ANDROID_DESCR[i].keys() self.actionsAndroidComboBox.addItem( list(el)[0] ) self.descriptionAndroidLine = QLineEdit(self) self.descriptionAndroidLine.setPlaceholderText("Step purpose description") self.descriptionAndroidLine.hide() self.labelActionAndroidDescr = QLabel( ) self.labelActionAndroidDescr.hide() self.labelActionAndroidDescr.setText( "%s\n" % GuiSteps.ACTION_ANDROID_DESCR[0][GuiSteps.ANDROID_WAKEUP_UNLOCK]) self.labelActionAndroidDescr.setWordWrap(True) actionsLayout = QHBoxLayout() actionsLayout.addWidget(self.actionsAndroidComboBox) actionLayoutAndroid = QGridLayout() actionLayoutAndroid.addLayout(actionsLayout, 0, 1) self.createWidgetShortcut() self.createWidgetCode() self.createWidgetStart() self.createWidgetXY() self.createWidgetEndXY() self.createWidgetElement() self.createWidgetTextTo() self.createWidgetLine() self.createWidgetLine2() actionLayoutAndroid2 = QGridLayout() actionLayoutAndroid2.addWidget( self.shortcutAndroidGroup , 0, 0) actionLayoutAndroid2.addWidget( self.codeAndroidGroup , 0, 0) actionLayoutAndroid2.addWidget( self.elemenAndroidGroup , 0, 0) actionLayoutAndroid2.addWidget( self.xyAndroidGroup , 0, 0) actionLayoutAndroid2.addWidget( self.startAndroidGroup , 0, 0) actionLayoutAndroid2.addWidget( self.lineAndroidGroup , 1, 0) actionLayoutAndroid2.addWidget( self.line2AndroidGroup , 0, 1) actionLayoutAndroid2.addWidget( self.textToGlobalGroup , 0, 1) actionLayoutAndroid2.addWidget( self.endXyAndroidGroup, 0, 1) font = QFont() font.setBold(True) labelAct = QLabel( self.tr("Action: ") ) labelAct.setFont( font) self.arrowLabel = QLabel("") self.arrowLabel.setPixmap(QPixmap(":/arrow-right.png").scaledToWidth(32)) self.arrowLabel.hide() self.arrowLabel2 = QLabel("") self.arrowLabel2.setPixmap(QPixmap(":/arrow-right.png").scaledToWidth(32)) layoutAndroid = QHBoxLayout() layoutAndroid.addWidget( labelAct ) layoutAndroid.addLayout( actionLayoutAndroid ) layoutAndroid.addWidget( self.arrowLabel ) layoutAndroid.addLayout( actionLayoutAndroid2 ) layoutAndroid.addWidget( self.arrowLabel2 ) layoutAndroid.addWidget(self.addAndroidAction) layoutAndroid.addStretch(1) self.setLayout(layoutAndroid) def createToolbar(self): """ Create qt toolbar """ pass def openOptions(self): """ Open options """ if self.optionsDialog.exec_() == QDialog.Accepted: pass def createWidgetLine2(self): """ Create line widget """ self.valueAndroidLine2 = QLineEdit(self) self.valueAndroidLine2.setMinimumWidth(150) self.valueAndroidCombo2 = QComboBox(self) self.valueAndroidCombo2.addItems( LIST_TYPES ) self.line2AndroidGroup = QGroupBox(self.tr("")) line2Androidlayout = QGridLayout() line2Androidlayout.addWidget( QLabel( self.tr("Text to type:") ), 0, 0 ) line2Androidlayout.addWidget( self.valueAndroidCombo2, 0, 1 ) line2Androidlayout.addWidget( self.valueAndroidLine2, 0, 2 ) self.line2AndroidGroup.setLayout(line2Androidlayout) self.line2AndroidGroup.hide() def createWidgetLine(self): """ Create line widget """ self.lineAndroidGroup = QGroupBox(self.tr("")) lineAndroidlayout = QGridLayout() self.valueAndroidLine = QLineEdit(self) self.valueAndroidLine.setMinimumWidth(300) lineAndroidlayout.addWidget( QLabel( self.tr("Value:") ) , 0,1) lineAndroidlayout.addWidget( self.valueAndroidLine , 0, 2) self.lineAndroidGroup.setLayout(lineAndroidlayout) self.lineAndroidGroup.hide() def createWidgetTextTo(self): """ Create text widget """ self.valueTextCacheGlobalLine = QLineEdit(self) self.valueTextCacheGlobalLine.setMinimumWidth(150) self.valueTextCacheGlobalCombo = QComboBox(self) self.valueTextCacheGlobalCombo.addItems( ["CACHE"] ) self.textToGlobalGroup = QGroupBox(self.tr("")) textToGloballayout = QGridLayout() textToGloballayout.addWidget( QLabel( self.tr("Save text in:") ) , 0, 0) textToGloballayout.addWidget( self.valueTextCacheGlobalCombo , 0, 1) textToGloballayout.addWidget( self.valueTextCacheGlobalLine , 0, 2) self.textToGlobalGroup.setLayout(textToGloballayout) self.textToGlobalGroup.hide() def createWidgetElement(self): """ Create text widget """ self.elemenAndroidGroup = QGroupBox(self.tr("")) self.elementTextAndroidLine = QLineEdit(self) self.elementTextAndroidLine.setMinimumWidth(300) self.elementTextCombo = QComboBox(self) self.elementTextCombo.addItems( LIST_TYPES ) self.elementDescriptionAndroidLine = QLineEdit(self) self.elementDescriptionAndroidLine.setMinimumWidth(300) self.elementClassAndroidLine = QLineEdit(self) self.elementClassAndroidLine.setMinimumWidth(300) self.elementRessourceIdAndroidLine = QLineEdit(self) self.elementRessourceIdAndroidLine.setMinimumWidth(300) self.elementPackageAndroidLine = QLineEdit(self) self.elementPackageAndroidLine.setMinimumWidth(300) # get text end elementAndroidlayout = QGridLayout() elementAndroidlayout.addWidget( QLabel( self.tr("Text Element:") ) , 0,1) elementAndroidlayout.addWidget( self.elementTextCombo , 0, 2) elementAndroidlayout.addWidget( self.elementTextAndroidLine , 0, 3) elementAndroidlayout.addWidget( QLabel( self.tr("Description Element:") ) , 1,1) elementAndroidlayout.addWidget( self.elementDescriptionAndroidLine , 1, 3) elementAndroidlayout.addWidget( QLabel( self.tr("Class Name:") ) , 2,1) elementAndroidlayout.addWidget( self.elementClassAndroidLine , 2, 3) elementAndroidlayout.addWidget( QLabel( self.tr("Resource ID:") ) , 3,1) elementAndroidlayout.addWidget( self.elementRessourceIdAndroidLine , 3, 3) elementAndroidlayout.addWidget( QLabel( self.tr("Package Name:") ) , 4,1) elementAndroidlayout.addWidget( self.elementPackageAndroidLine , 4, 3) self.elemenAndroidGroup.setLayout(elementAndroidlayout) self.elemenAndroidGroup.hide() def createWidgetEndXY(self): """ Create widget """ self.endXyAndroidGroup = QGroupBox(self.tr("")) endXyAndroidlayout = QGridLayout() self.endxAndroidLine = QLineEdit(self) validatorEndXAndroid = QIntValidator (self) self.endxAndroidLine.setValidator(validatorEndXAndroid) self.endxAndroidLine.installEventFilter(self) self.endyAndroidLine = QLineEdit(self) validatorEndYAndroid = QIntValidator (self) self.endyAndroidLine.setValidator(validatorEndYAndroid) self.endyAndroidLine.installEventFilter(self) endXyAndroidlayout.addWidget( QLabel( self.tr("Destination Coordinate X:") ) , 0, 0) endXyAndroidlayout.addWidget( self.endxAndroidLine , 0, 1) endXyAndroidlayout.addWidget( QLabel( self.tr("Destination Coordinate Y:") ) , 1,0) endXyAndroidlayout.addWidget( self.endyAndroidLine , 1, 1) self.endXyAndroidGroup.setLayout(endXyAndroidlayout) self.endXyAndroidGroup.hide() def createWidgetXY(self): """ Create text widget """ self.xyAndroidGroup = QGroupBox(self.tr("")) xyAndroidlayout = QGridLayout() self.xAndroidLine = QLineEdit(self) validatorXAndroid = QIntValidator (self) self.xAndroidLine.setValidator(validatorXAndroid) self.xAndroidLine.installEventFilter(self) self.yAndroidLine = QLineEdit(self) validatorYAndroid = QIntValidator (self) self.yAndroidLine.setValidator(validatorYAndroid) self.yAndroidLine.installEventFilter(self) xyAndroidlayout.addWidget( QLabel( self.tr("Coordinate X:") ) , 0,0) xyAndroidlayout.addWidget( self.xAndroidLine , 0, 1) xyAndroidlayout.addWidget( QLabel( self.tr("Coordinate Y:") ) , 1,0) xyAndroidlayout.addWidget( self.yAndroidLine , 1, 1) self.xyAndroidGroup.setLayout(xyAndroidlayout) self.xyAndroidGroup.hide() def createWidgetStart(self): """ Create text widget """ self.startAndroidGroup = QGroupBox(self.tr("")) startAndroidlayout = QGridLayout() self.startXAndroidLine = QLineEdit(self) validatorStartXAndroid = QIntValidator (self) self.startXAndroidLine.setValidator(validatorStartXAndroid) self.startXAndroidLine.installEventFilter(self) self.startYAndroidLine = QLineEdit(self) validatorStartYAndroid = QIntValidator (self) self.startYAndroidLine.setValidator(validatorStartYAndroid) self.startYAndroidLine.installEventFilter(self) self.stopXAndroidLine = QLineEdit(self) validatorStopXAndroid = QIntValidator (self) self.stopXAndroidLine.setValidator(validatorStopXAndroid) self.stopXAndroidLine.installEventFilter(self) self.stopYAndroidLine = QLineEdit(self) validatorStopYAndroid = QIntValidator (self) self.stopYAndroidLine.setValidator(validatorStopYAndroid) self.stopYAndroidLine.installEventFilter(self) startAndroidlayout.addWidget( QLabel( self.tr("From X:") ) , 0,1) startAndroidlayout.addWidget( self.startXAndroidLine , 0, 2) startAndroidlayout.addWidget( QLabel( self.tr("From Y:") ) , 0,3) startAndroidlayout.addWidget( self.startYAndroidLine , 0, 4) startAndroidlayout.addWidget( QLabel( self.tr("To X:") ) ,1,1) startAndroidlayout.addWidget( self.stopXAndroidLine , 1, 2) startAndroidlayout.addWidget( QLabel( self.tr("To Y:") ) , 1,3) startAndroidlayout.addWidget( self.stopYAndroidLine , 1 , 4) self.startAndroidGroup.setLayout(startAndroidlayout) self.startAndroidGroup.hide() def createWidgetShortcut(self): """ Create shortcut widget """ self.shortcutAndroidGroup = QGroupBox(self.tr("")) shortcutAndroidlayout = QGridLayout() self.shortcutAndroidComboBox = QComboBox(self) for i in xrange(len(KEYS_SHORTCUT_ANDROID)): if len(KEYS_SHORTCUT_ANDROID[i]) == 0: self.shortcutAndroidComboBox.insertSeparator(i + 2) else: self.shortcutAndroidComboBox.addItem (KEYS_SHORTCUT_ANDROID[i]) shortcutAndroidlayout.addWidget( QLabel( self.tr("Button:") ) , 0,1) shortcutAndroidlayout.addWidget(self.shortcutAndroidComboBox, 0, 2) self.shortcutAndroidGroup.setLayout(shortcutAndroidlayout) self.shortcutAndroidGroup.hide() def createWidgetCode(self): """ Create code widget """ self.codeAndroidGroup = QGroupBox(self.tr("")) self.codeAndroidLine = QLineEdit(self) validatorCodeAndroid = QIntValidator (self) self.codeAndroidLine.setValidator(validatorCodeAndroid) self.codeAndroidLine.installEventFilter(self) codeAndroidlayout = QGridLayout() codeAndroidlayout.addWidget( QLabel( self.tr("Code:") ) , 0,1) codeAndroidlayout.addWidget( self.codeAndroidLine , 0, 2) self.codeAndroidGroup.setLayout(codeAndroidlayout) self.codeAndroidGroup.hide() def pluginDataAccessor(self): """ Return data for plugin """ return { "data": "" } def onPluginImport(self, dataJson): """ Received data from plugin """ pass def createConnections(self): """ Create qt connections """ self.actionsAndroidComboBox.currentIndexChanged.connect(self.onActionAndroidChanged) self.addAndroidAction.clicked.connect(self.addStep) self.valueAndroidCombo2.currentIndexChanged.connect(self.onValueAndroid2TypeChanged) self.elementTextCombo.currentIndexChanged.connect(self.onElementTextTypeChanged) def onElementTextTypeChanged(self): """ On element text changed """ if self.elementTextCombo.currentText() in [ "TEXT", "CACHE" ]: self.elementTextAndroidLine.setValidator(self.validatorAll) if self.elementTextCombo.currentText() == "ALIAS": self.elementTextAndroidLine.setText( self.elementTextAndroidLine.text().upper() ) self.elementTextAndroidLine.setValidator(self.validatorUpper) def onValueAndroid2TypeChanged(self): """ On value changed """ if self.valueAndroidCombo2.currentText() in [ "TEXT", "CACHE" ]: self.valueAndroidLine2.setValidator(self.validatorAll) if self.valueAndroidCombo2.currentText() == "ALIAS": self.valueAndroidLine2.setText( self.valueAndroidLine2.text().upper() ) self.valueAndroidLine2.setValidator(self.validatorUpper) def addStep(self): """ Add step """ action = self.actionsAndroidComboBox.currentText() descr = self.descriptionAndroidLine.text() descr = unicode(descr).replace('"', '') signal = self.AddStep if self.cancelAndroidAction.isEnabled(): signal = self.UpdateStep if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_WAKUP, GuiSteps.ANDROID_UNLOCK, GuiSteps.ANDROID_REBOOT, GuiSteps.ANDROID_SLEEP, GuiSteps.ANDROID_FREEZE_ROTATION, GuiSteps.ANDROID_UNFREEZE_ROTATION, GuiSteps.ANDROID_BOOTLOADER, GuiSteps.ANDROID_RECOVERY, GuiSteps.ANDROID_NOTIFICATION, GuiSteps.ANDROID_SETTINGS, GuiSteps.ANDROID_DEVICEINFO, GuiSteps.ANDROID_GET_LOGS, GuiSteps.ANDROID_CLEAR_LOGS , GuiSteps.ANDROID_WAKEUP_UNLOCK, GuiSteps.ANDROID_LOCK, GuiSteps.ANDROID_SLEEP_LOCK ]: signal.emit( str(action), unicode(descr), EMPTY_VALUE, {} ) elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_TYPE_SHORTCUT]: shorcut = self.shortcutAndroidComboBox.currentText() signal.emit( str(action), unicode(descr), shorcut, {} ) elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_TYPE_KEYCODE ]: code = self.codeAndroidLine.text() if not len(code): QMessageBox.warning(self, "Recording for Gui" , "Please to set a value!") else: signal.emit( str(action), unicode(descr), code, {} ) elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_CLEAR_ELEMENT, GuiSteps.ANDROID_CLICK_ELEMENT, GuiSteps.ANDROID_LONG_CLICK_ELEMENT, GuiSteps.ANDROID_EXIST_ELEMENT, GuiSteps.ANDROID_WAIT_ELEMENT, GuiSteps.ANDROID_TYPE_TEXT_ELEMENT, GuiSteps.ANDROID_GET_TEXT_ELEMENT, GuiSteps.ANDROID_DRAG_ELEMENT, GuiSteps.ANDROID_WAIT_CLICK_ELEMENT ]: textAndroid = self.elementTextAndroidLine.text() descrAndroid = self.elementDescriptionAndroidLine.text() classAndroid = self.elementClassAndroidLine.text() ressourceAndroid = self.elementRessourceIdAndroidLine.text() packageAndroid = self.elementPackageAndroidLine.text() if not len(textAndroid) and not len(classAndroid) and not len(ressourceAndroid) and not len(packageAndroid) and not len(descrAndroid): QMessageBox.warning(self, "Recording for Gui" , "Please to set one value!") else: # read text from cache or not ? fromElCache = False if self.elementTextCombo.currentText() == "CACHE": fromElCache = True fromElAlias = False if self.elementTextCombo.currentText() == "ALIAS": fromElAlias = True if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_TYPE_TEXT_ELEMENT: newTextAndroid = self.valueAndroidLine2.text() if not len(newTextAndroid): QMessageBox.warning(self, "Recording for Gui" , "Please to set a text value!") else: # read text from cache or not ? fromCache = False if self.valueAndroidCombo2.currentText() == "CACHE": fromCache = True fromAlias = False if self.valueAndroidCombo2.currentText() == "ALIAS": fromAlias = True parameters = {'text': textAndroid, 'class': classAndroid, 'ressource': ressourceAndroid, 'package': packageAndroid, 'description': descrAndroid, 'new-text': newTextAndroid, 'from-cache': fromCache, 'from-alias': fromAlias, 'from-el-cache': fromElCache, 'from-el-alias': fromElAlias } signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters ) elif self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_GET_TEXT_ELEMENT: # read text from cache or not ? cacheKey = '' toCache = True cacheKey = self.valueTextCacheGlobalLine.text() parameters = {'text': textAndroid, 'class': classAndroid, 'ressource': ressourceAndroid, 'package': packageAndroid, 'description': descrAndroid, 'cache-key': cacheKey, 'to-cache': toCache, 'from-el-cache': fromElCache, 'from-el-alias': fromElAlias } signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters ) elif self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_DRAG_ELEMENT: xAndroid = self.endxAndroidLine.text() yAndroid = self.endyAndroidLine.text() if not len(xAndroid) and not len(yAndroid): QMessageBox.warning(self, "Recording for Gui" , "Please to set values!") else: parameters = {'text': textAndroid, 'class': classAndroid, 'ressource': ressourceAndroid, 'package': packageAndroid, 'description': descrAndroid, 'from-el-cache': fromElCache, 'from-el-alias': fromElAlias, 'x': xAndroid, 'y': yAndroid } signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters ) else: parameters = {'text': textAndroid, 'class': classAndroid, 'ressource': ressourceAndroid, 'package': packageAndroid, 'description': descrAndroid, 'from-el-cache': fromElCache, 'from-el-alias': fromElAlias } signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters ) elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_CLICK_POSITION ]: xAndroid = self.xAndroidLine.text() yAndroid = self.yAndroidLine.text() if not len(xAndroid) and not len(yAndroid): QMessageBox.warning(self, "Recording for Gui" , "Please to set values!") else: parameters = { 'x': xAndroid, 'y': yAndroid } signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters ) elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_DRAG_ELEMENT, GuiSteps.ANDROID_DRAG_POSITION, GuiSteps.ANDROID_SWIPE_POSITION]: startXAndroid = self.startXAndroidLine.text() startYAndroid = self.startYAndroidLine.text() stopXAndroid = self.stopXAndroidLine.text() stopYAndroid = self.stopYAndroidLine.text() if not len(startXAndroid) and not len(startYAndroid) and not len(stopXAndroid) and not len(stopYAndroid): QMessageBox.warning(self, "Recording for Gui" , "Please to set values!") else: parameters = { 'start-x': startXAndroid, 'start-y': startYAndroid, 'stop-x': stopXAndroid, 'stop-y': stopYAndroid } signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters ) elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_COMMAND, GuiSteps.ANDROID_SHELL, GuiSteps.ANDROID_RESET_APP, GuiSteps.ANDROID_STOP_APP]: miscStr = self.valueAndroidLine.text() if not len(miscStr): QMessageBox.warning(self, "Recording for Gui" , "Please to set a value!") else: if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_COMMAND: parameters = { 'cmd': miscStr } elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_RESET_APP, GuiSteps.ANDROID_STOP_APP ]: parameters = { 'pkg': miscStr } else: parameters = { 'sh': miscStr } signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters ) else: signal.emit( str(action), unicode(descr), EMPTY_VALUE, {} ) def cancelStep(self): """ Cancel step """ self.addAndroidAction.setText( "&Add" ) buttonFont = QFont() buttonFont.setBold(False) self.addAndroidAction.setFont(buttonFont) self.cancelAndroidAction.setEnabled(False) self.CancelEdit.emit() def finalizeUpdate(self): """ Finalize the update of a step """ self.addAndroidAction.setText( "&Add Action" ) buttonFont = QFont() buttonFont.setBold(False) self.addAndroidAction.setFont(buttonFont) self.cancelAndroidAction.setEnabled(False) def onActionAndroidChanged(self): """ On action changed """ descr = 'No description available!' i = 0 for el in GuiSteps.ACTION_ANDROID_DESCR: if isinstance(el, dict): if self.actionsAndroidComboBox.currentText() in el: descr = GuiSteps.ACTION_ANDROID_DESCR[i][self.actionsAndroidComboBox.currentText()] break i += 1 self.labelActionAndroidDescr.setText( "%s\n" % descr ) if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_TYPE_SHORTCUT ]: self.shortcutAndroidGroup.show() self.codeAndroidGroup.hide() self.elemenAndroidGroup.hide() self.startAndroidGroup.hide() self.xyAndroidGroup.hide() self.lineAndroidGroup.hide() self.line2AndroidGroup.hide() self.textToGlobalGroup.hide() self.endXyAndroidGroup.hide() self.arrowLabel.show() self.arrowLabel2.show() elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_TYPE_KEYCODE ]: self.codeAndroidGroup.show() self.shortcutAndroidGroup.hide() self.elemenAndroidGroup.hide() self.startAndroidGroup.hide() self.xyAndroidGroup.hide() self.lineAndroidGroup.hide() self.line2AndroidGroup.hide() self.textToGlobalGroup.hide() self.endXyAndroidGroup.hide() self.arrowLabel.show() self.arrowLabel2.show() elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_CLEAR_ELEMENT, GuiSteps.ANDROID_CLICK_ELEMENT, GuiSteps.ANDROID_LONG_CLICK_ELEMENT, GuiSteps.ANDROID_EXIST_ELEMENT, GuiSteps.ANDROID_WAIT_ELEMENT, GuiSteps.ANDROID_WAIT_CLICK_ELEMENT ]: self.shortcutAndroidGroup.hide() self.codeAndroidGroup.hide() self.elemenAndroidGroup.show() self.startAndroidGroup.hide() self.xyAndroidGroup.hide() self.lineAndroidGroup.hide() self.line2AndroidGroup.hide() self.textToGlobalGroup.hide() self.endXyAndroidGroup.hide() self.arrowLabel.show() self.arrowLabel2.show() elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_DRAG_ELEMENT ]: self.shortcutAndroidGroup.hide() self.codeAndroidGroup.hide() self.elemenAndroidGroup.show() self.startAndroidGroup.hide() self.xyAndroidGroup.hide() self.lineAndroidGroup.hide() self.line2AndroidGroup.hide() self.textToGlobalGroup.hide() self.endXyAndroidGroup.show() self.arrowLabel.show() self.arrowLabel2.show() elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_GET_TEXT_ELEMENT ]: self.shortcutAndroidGroup.hide() self.codeAndroidGroup.hide() self.elemenAndroidGroup.show() self.startAndroidGroup.hide() self.xyAndroidGroup.hide() self.lineAndroidGroup.hide() self.line2AndroidGroup.hide() self.textToGlobalGroup.show() self.endXyAndroidGroup.hide() self.arrowLabel.show() self.arrowLabel2.show() elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_CLICK_POSITION ]: self.shortcutAndroidGroup.hide() self.codeAndroidGroup.hide() self.elemenAndroidGroup.hide() self.startAndroidGroup.hide() self.xyAndroidGroup.show() self.lineAndroidGroup.hide() self.line2AndroidGroup.hide() self.textToGlobalGroup.hide() self.endXyAndroidGroup.hide() self.arrowLabel.show() self.arrowLabel2.show() elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_DRAG_POSITION, GuiSteps.ANDROID_SWIPE_POSITION ]: self.shortcutAndroidGroup.hide() self.codeAndroidGroup.hide() self.elemenAndroidGroup.hide() self.startAndroidGroup.show() self.xyAndroidGroup.hide() self.lineAndroidGroup.hide() self.line2AndroidGroup.hide() self.textToGlobalGroup.hide() self.endXyAndroidGroup.hide() self.arrowLabel.show() self.arrowLabel2.show() elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_COMMAND, GuiSteps.ANDROID_SHELL, GuiSteps.ANDROID_RESET_APP, GuiSteps.ANDROID_STOP_APP ]: self.shortcutAndroidGroup.hide() self.codeAndroidGroup.hide() self.elemenAndroidGroup.hide() self.startAndroidGroup.hide() self.xyAndroidGroup.hide() self.lineAndroidGroup.show() self.line2AndroidGroup.hide() self.textToGlobalGroup.hide() self.endXyAndroidGroup.hide() self.arrowLabel.show() self.arrowLabel2.show() elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_TYPE_TEXT_ELEMENT ]: self.shortcutAndroidGroup.hide() self.codeAndroidGroup.hide() self.elemenAndroidGroup.show() self.startAndroidGroup.hide() self.xyAndroidGroup.hide() self.lineAndroidGroup.hide() self.line2AndroidGroup.show() self.textToGlobalGroup.hide() self.endXyAndroidGroup.hide() self.arrowLabel.show() self.arrowLabel2.show() else: self.shortcutAndroidGroup.hide() self.codeAndroidGroup.hide() self.elemenAndroidGroup.hide() self.startAndroidGroup.hide() self.xyAndroidGroup.hide() self.lineAndroidGroup.hide() self.line2AndroidGroup.hide() self.textToGlobalGroup.hide() self.endXyAndroidGroup.hide() self.arrowLabel.hide() self.arrowLabel2.show() def setTimeout(self, timeout): """ Set the timeout """ self.optionsDialog.timeoutAndroidLine.setText(timeout) def getTimeout(self): """ Return the timeout """ return self.optionsDialog.timeoutAndroidLine.text() def getAgentName(self): """ Get the agent name """ return self.optionsDialog.agentNameLineAndroid.text() def getAgentList(self): """ Return the agent list """ return self.optionsDialog.agentsAndroidList def editStep(self, stepData): """ Edit a step """ self.addAndroidAction.setText( "&Update" ) buttonFont = QFont() buttonFont.setBold(True) self.addAndroidAction.setFont(buttonFont) self.cancelAndroidAction.setEnabled(True) # set the current value for actions combo for i in xrange(self.actionsAndroidComboBox.count()): item_text = self.actionsAndroidComboBox.itemText(i) if unicode(stepData["action"]) == unicode(item_text): self.actionsAndroidComboBox.setCurrentIndex(i) break # and then refresh options self.onActionAndroidChanged() # finally fill all fields self.descriptionAndroidLine.setText( stepData["description"] ) if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_COMMAND: self.valueAndroidLine.setText( stepData["parameters"]["cmd"] ) if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_SHELL: self.valueAndroidLine.setText( stepData["parameters"]["sh"] ) if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_RESET_APP, GuiSteps.ANDROID_STOP_APP ]: self.valueAndroidLine.setText( stepData["parameters"]["pkg"] ) if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_CLEAR_ELEMENT, GuiSteps.ANDROID_TYPE_TEXT_ELEMENT, GuiSteps.ANDROID_CLICK_ELEMENT, GuiSteps.ANDROID_LONG_CLICK_ELEMENT, GuiSteps.ANDROID_EXIST_ELEMENT, GuiSteps.ANDROID_WAIT_ELEMENT, GuiSteps.ANDROID_GET_TEXT_ELEMENT, GuiSteps.ANDROID_DRAG_ELEMENT, GuiSteps.ANDROID_WAIT_CLICK_ELEMENT ]: self.elementTextAndroidLine.setText( "" ) self.elementDescriptionAndroidLine.setText( "" ) self.elementClassAndroidLine.setText( "" ) self.elementRessourceIdAndroidLine.setText( "" ) self.elementPackageAndroidLine.setText( "" ) self.valueAndroidLine2.setText( "" ) if "text" in stepData["parameters"]: if stepData["parameters"]["from-el-cache"]: self.elementTextCombo.setCurrentIndex(INDEX_CACHE) self.elementTextAndroidLine.setValidator(self.validatorAll) elif stepData["parameters"]["from-el-alias"]: self.elementTextCombo.setCurrentIndex(INDEX_ALIAS) self.elementTextAndroidLine.setValidator(self.validatorUpper) else: self.elementTextCombo.setCurrentIndex(INDEX_TEXT) self.elementTextAndroidLine.setValidator(self.validatorAll) self.elementTextAndroidLine.setText ( stepData["parameters"]["text"] ) if "description" in stepData["parameters"]: self.elementDescriptionAndroidLine.setText( stepData["parameters"]["description"] ) if "class" in stepData["parameters"]: self.elementClassAndroidLine.setText( stepData["parameters"]["class"] ) if "ressource" in stepData["parameters"]: self.elementRessourceIdAndroidLine.setText( stepData["parameters"]["ressource"] ) if "package" in stepData["parameters"]: self.elementPackageAndroidLine.setText( stepData["parameters"]["package"] ) if "new-text" in stepData["parameters"]: self.valueAndroidLine2.setText( stepData["parameters"]["new-text"] ) if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_DRAG_ELEMENT: if "x" in stepData["parameters"]: self.endxAndroidLine.setText( stepData["parameters"]["x"] ) if "y" in stepData["parameters"]: self.endyAndroidLine.setText( stepData["parameters"]["y"] ) if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_TYPE_TEXT_ELEMENT: if stepData["parameters"]["from-cache"]: self.valueAndroidCombo2.setCurrentIndex(INDEX_CACHE) self.valueAndroidLine2.setValidator(self.validatorAll) elif stepData["parameters"]["from-alias"]: self.valueAndroidCombo2.setCurrentIndex(INDEX_ALIAS) self.valueAndroidLine2.setValidator(self.validatorUpper) else: self.valueAndroidCombo2.setCurrentIndex(INDEX_TEXT) self.valueAndroidLine2.setValidator(self.validatorAll) if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_GET_TEXT_ELEMENT: self.valueTextCacheGlobalLine.setText ( stepData["parameters"]["cache-key"] ) if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_CLICK_POSITION]: if "x" in stepData["parameters"]: self.xAndroidLine.setText( stepData["parameters"]["x"] ) if "y" in stepData["parameters"]: self.yAndroidLine.setText( stepData["parameters"]["y"] ) if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_DRAG_POSITION, GuiSteps.ANDROID_SWIPE_POSITION]: if "start-x" in stepData["parameters"]: self.startXAndroidLine.setText( stepData["parameters"]["start-x"] ) if "start-y" in stepData["parameters"]: self.startYAndroidLine.setText( stepData["parameters"]["start-y"] ) if "stop-x" in stepData["parameters"]: self.stopXAndroidLine.setText( stepData["parameters"]["stop-x"] ) if "stop-y" in stepData["parameters"]: self.stopYAndroidLine.setText( stepData["parameters"]["stop-y"] ) if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_TYPE_KEYCODE: self.codeAndroidLine.setText( stepData["misc"] ) if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_TYPE_SHORTCUT ]: # set default for i in xrange(self.shortcutAndroidComboBox.count()): item_text = self.shortcutAndroidComboBox.itemText(i) if unicode(stepData["misc"]) == unicode(item_text): self.shortcutAndroidComboBox.setCurrentIndex(i) break
class SharedSqlQueries: """QGIS Plugin Implementation.""" def __init__(self, iface): """Constructor. :param iface: An interface instance that will be passed to this class which provides the hook by which you can manipulate the QGIS application at run time. :type iface: QgsInterface """ # Save reference to the QGIS interface self.iface = iface # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # initialize locale UNUSED # locale = QSettings().value('locale/userLocale')[0:2] # locale_path = os.path.join( # self.plugin_dir, # 'i18n', # 'SharedSqlQueries_{}.qm'.format(locale)) # # if os.path.exists(locale_path): # self.translator = QTranslator() # self.translator.load(locale_path) # # if qVersion() > '4.3.3': # QCoreApplication.installTranslator(self.translator) # Declare instance attributes self.actions = [] self.menu = self.tr(u'&Shared SQL Queries') self.toolbar = self.iface.addToolBar(u'SharedSqlQueries') self.toolbar.setObjectName(u'SharedSqlQueries') #print "** INITIALIZING SharedSqlQueries" #self.dockwidget = None #combo of queries files self.comboxQueries = None self.config = None self.queriesFolder = None self.dbrequest = None self.selectedQueryPath = None self.pluginIsActive = False # init related to config file. Return False if no config.json has been found def init_config(self): #just once if self.config is not None: return True #config file (in plugin directory) : configpath = os.path.dirname(__file__) + '/config.json' try: self.config = JsonFile(configpath) except IOError: # copy default config json if it does not exist self.errorMessage(self.tr( u"No config.json file found ! A default one is created but you have to edit it (in your plugin directory)")) configpath_default = os.path.dirname(__file__) + '/config_default.json' copyfile(configpath_default, configpath) return False self.queriesFolder = self.config.value("queries_folder") #database self.dbrequest = Connection(self.config.value("bdpostgis")) return True # noinspection PyMethodMayBeStatic def tr(self, message): """Get the translation for a string using Qt translation API. We implement this ourselves since we do not inherit QObject. :param message: String for translation. :type message: str, QString :returns: Translated version of message. :rtype: QString """ # noinspection PyTypeChecker,PyArgumentList,PyCallByClass #return QCoreApplication.translate('SharedSqlQueries', message) return translate.tr(message) #simplier def add_action( self, icon_path, text, callback, enabled_flag=True, add_to_menu=True, add_to_toolbar=True, status_tip=None, whats_this=None, parent=None): """Add a toolbar icon to the toolbar. :param icon_path: Path to the icon for this action. Can be a resource path (e.g. ':/plugins/foo/bar.png') or a normal file system path. :type icon_path: str :param text: Text that should be shown in menu items for this action. :type text: str :param callback: Function to be called when the action is triggered. :type callback: function :param enabled_flag: A flag indicating if the action should be enabled by default. Defaults to True. :type enabled_flag: bool :param add_to_menu: Flag indicating whether the action should also be added to the menu. Defaults to True. :type add_to_menu: bool :param add_to_toolbar: Flag indicating whether the action should also be added to the toolbar. Defaults to True. :type add_to_toolbar: bool :param status_tip: Optional text to show in a popup when mouse pointer hovers over the action. :type status_tip: str :param parent: Parent widget for the new action. Defaults None. :type parent: QWidget :param whats_this: Optional text to show in the status bar when the mouse pointer hovers over the action. :returns: The action that was created. Note that the action is also added to self.actions list. :rtype: QAction """ icon = QIcon(icon_path) action = QAction(icon, text, parent) action.triggered.connect(callback) action.setEnabled(enabled_flag) if status_tip is not None: action.setStatusTip(status_tip) if whats_this is not None: action.setWhatsThis(whats_this) if add_to_toolbar: self.toolbar.addAction(action) if add_to_menu: self.iface.addPluginToMenu( self.menu, action) self.actions.append(action) return action def initGui(self): """Create the menu entries and toolbar icons inside the QGIS GUI.""" icon_path = ':/plugins/SharedSqlQueries/icon.png' self.add_action( icon_path, text=self.tr(u'Shared SQL Queries'), callback=self.run, parent=self.iface.mainWindow()) #combo of queries files self.comboxQueries = QComboBox() self.comboxQueries.setMinimumHeight(27) self.comboxQueries.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) # its model : self.queriesModel = QStandardItemModel() self.comboxQueries.setModel(self.queriesModel) # and its view (treeview) : self.queriesView = QTreeView() self.queriesView.setHeaderHidden(True) self.queriesView.setMinimumHeight(300) setWidgetWidth(self.comboxQueries, 0, 0) #no visible self.comboxQueries.setView(self.queriesView) # capture last clicked query self.queriesView.activated.connect(self.querySelected) self.queriesView.pressed.connect(self.querySelected) self.toolbar.addWidget(self.comboxQueries) #Run query button self.buttonRunQuery = QPushButton(self.tr("Open")) setWidgetWidth(self.buttonRunQuery, 0, 0) #no visible self.buttonRunQuery.clicked.connect(self.runQuery) self.toolbar.addWidget(self.buttonRunQuery) #-------------------------------------------------------------------------- def onClosePlugin(self): """Cleanup necessary items here when plugin dockwidget is closed""" #print "** CLOSING SharedSqlQueries" # disconnects #self.dockwidget.closingPlugin.disconnect(self.onClosePlugin) self.pluginIsActive = False def unload(self): """Removes the plugin menu item and icon from QGIS GUI.""" #print "** UNLOAD SharedSqlQueries" for action in self.actions: self.iface.removePluginMenu( self.tr(u'Shared SQL Queries'), action) self.iface.removeToolBarIcon(action) # remove the toolbar del self.toolbar #-------------------------------------------------------------------------- def run(self): """Run method that loads and starts the plugin""" # look for config file (required at the first run) if not self.init_config(): # invalid config file return if not self.pluginIsActive: self.pluginIsActive = True #first init #print "** STARTING SharedSqlQueries" # dockwidget may not exist if: # first run of plugin # removed on close (see self.onClosePlugin method) #if self.dockwidget == None: # Create the dockwidget (after translation) and keep reference # self.dockwidget = SharedSqlQueriesDockWidget() # connect to provide cleanup on closing of dockwidget #self.dockwidget.closingPlugin.connect(self.onClosePlugin) # show the dockwidget #self.iface.addDockWidget(Qt.TopDockWidgetArea, self.dockwidget) #self.dockwidget.show() #Togle visibility of toolbar options (set width coz visible is not usable in toolbar) show_options = (self.comboxQueries.minimumWidth() == 0) if show_options: self.updateComboQueries() setWidgetWidth(self.comboxQueries, 300, 300) setWidgetWidth(self.buttonRunQuery, 0, 120) else: setWidgetWidth(self.comboxQueries, 0, 0) setWidgetWidth(self.buttonRunQuery, 0, 0) #display an error def errorMessage(self, message): self.iface.messageBar().pushMessage(self.tr(u"Error"), message, level=QgsMessageBar.CRITICAL) #read file in query folder and show them in combo tree view def updateComboQueries(self): self.queriesModel.clear() self.queriesModel.setHorizontalHeaderLabels(['Files']) item = QStandardItem(self.tr(u"Query File")) item.setSelectable(False) self.queriesModel.appendRow(item) # read directories with sql files for path, dirs, files in os.walk(self.queriesFolder): for rep in dirs: item = QStandardItem(rep) item.setData(rep, Qt.UserRole) item.setSelectable(False) self.queriesModel.appendRow(item) # in each directory, look for sql files for nomfich in glob.glob(self.queriesFolder + "/" + rep + "/*.sql"): fileName, fileExtension = os.path.splitext(os.path.basename(nomfich)) # one item found subitem = QStandardItem(fileName) subitem.setData(nomfich, Qt.UserRole) item.appendRow(subitem) #last selected query def querySelected(self, index): item = self.queriesModel.itemFromIndex(index) self.selectedQueryPath = item.data(Qt.UserRole) #run selected query def runQuery(self): #print self.comboxQueries.currentText() #print self.selectedQueryPath try: query = CustomSqlQuery(self.selectedQueryPath) except UnicodeDecodeError: self.errorMessage(self.tr(u"Query File is not UTF8 encoded ! Please convert it to UTF8 !")) return except SyntaxError as e: self.errorMessage(e.text) return except Exception as e: self.errorMessage(str(e)) return # open param dialog dialog = QueryParamDialog(self.iface, self.dbrequest, query, self.toolbar) if dialog.exec_() == QDialog.Accepted: if dialog.errorMessage != "": self.errorMessage(dialog.errorMessage) return # format query as a Qgis readable sql source sql = query.updateFinalSql() QgsMessageLog.logMessage(sql, "SharedSql", QgsMessageLog.INFO) # add the corresponding layer try: # save query in a memory layer if query.headerValue("layer storage") == "memory": layer = self.dbrequest.sqlAddMemoryLayer(sql, query.headerValue("layer name"), query.headerValue("gid"), query.headerValue("geom")) # save query directly as a sql layer elif query.headerValue("layer storage") == "source": layer = self.dbrequest.sqlAddLayer(sql, query.headerValue("layer name"), query.headerValue("gid"), query.headerValue("geom")) # save query in a file layer else: type = query.headerValue("layer storage").lower() driver = None if type == "geojson": driver = "GeoJSON" if type == "shp": driver = "ESRI Shapefile" if driver is None: self.errorMessage(self.tr(u"Unknown file type : ") + str(type)) return directory = query.headerValue("layer directory") if directory is None: self.errorMessage(self.tr(u"No layer directory parameter found in query !")) return name = query.headerValue("layer name") # new layer name and file name if file already exists filepath = directory + "/" + name + "." + type filecount = 1 new_name = name while os.path.exists(filepath): # file already exists filecount += 1 new_name = name + "_" + str(filecount) filepath = directory + "/" + new_name + "." + type name = new_name #wait cursor QApplication.setOverrideCursor(Qt.WaitCursor) # add new layer layer = self.dbrequest.sqlAddFileLayer(sql, driver, filepath, name, query.headerValue("gid"), query.headerValue("geom")) QApplication.setOverrideCursor(Qt.ArrowCursor) except SyntaxError as e: QApplication.setOverrideCursor(Qt.ArrowCursor) # sql is correct but does not fit QGIS requirement (like '%' char) self.errorMessage(self.tr(e.text)) return if layer is None: self.errorMessage(self.tr(u"Unable to add a layer corresponding to this query !") + sql) # sql which is used in layer query print makeSqlValidForLayer(sql) return # if there's a qml style file corresponding to the query, apply it to the newly added layer if os.path.exists(query.styleFilePath()): layer.loadNamedStyle(query.styleFilePath())
class WSystem(QWidget, Logger.ClassLogger): """ System widget """ # action, description, misc, parameters AddStep = pyqtSignal(str, str, str, dict) UpdateStep = pyqtSignal(str, str, str, dict) CancelEdit = pyqtSignal() def __init__(self, parent): """ Constructor """ QWidget.__init__(self) self.createActions() self.createWidgets() self.createToolbar() self.createConnections() def createActions(self): """ Create qt actions """ self.addAction = QPushButton(QIcon(":/add_black.png"), '&Add Action', self) self.addAction.setMinimumHeight(40) self.addAction.setMaximumWidth(150) self.cancelAction = QtHelper.createAction(self, "&Cancel", self.cancelStep, icon=QIcon(":/undo.png"), tip='Cancel update') self.cancelAction.setEnabled(False) self.optionsAction = QtHelper.createAction( self, "&", self.openOptions, icon=QIcon(":/system-small.png"), tip='System options') def openOptions(self): """ Open options dialog """ if self.optionsDialog.exec_() == QDialog.Accepted: pass def createWidgets(self): """ Create qt widgets """ self.optionsDialog = OptionsDialog(self) self.validatorUpper = ValidatorUpper(self) self.validatorAll = ValidatorAll(self) self.validatorInt = QIntValidator(self) self.actionsComboBox = QComboBox(self) self.actionsComboBox.setMinimumHeight(40) for i in xrange(len(GuiSteps.ACTION_SYSTEM_DESCR)): if not len(GuiSteps.ACTION_SYSTEM_DESCR[i]): self.actionsComboBox.insertSeparator(i + 1) else: el = GuiSteps.ACTION_SYSTEM_DESCR[i].keys() self.actionsComboBox.addItem(list(el)[0]) self.labelActionDescr = QLabel(self) self.labelActionDescr.hide() self.descriptionLine = QLineEdit(self) self.descriptionLine.setPlaceholderText("Step purpose description") self.descriptionLine.hide() actionsLayout = QHBoxLayout() actionsLayout.addWidget(self.actionsComboBox) actionLayout1 = QGridLayout() actionLayout1.addLayout(actionsLayout, 0, 1) self.createWidgetSession() self.createWidgetText() self.createWidgetShortcut() self.createWidgetScreen() actionLayout2 = QGridLayout() actionLayout2.addWidget(self.sessionGroup, 1, 0) actionLayout2.addWidget(self.textGroup, 1, 0) actionLayout2.addWidget(self.shortcutGroup, 1, 0) actionLayout2.addWidget(self.screenGroup, 1, 0) font = QFont() font.setBold(True) labelAct = QLabel(self.tr("Action: ")) labelAct.setFont(font) self.arrowLabel = QLabel("") self.arrowLabel.setPixmap( QPixmap(":/arrow-right.png").scaledToWidth(32)) self.arrowLabel2 = QLabel("") self.arrowLabel2.setPixmap( QPixmap(":/arrow-right.png").scaledToWidth(32)) layoutFinal = QHBoxLayout() layoutFinal.addWidget(labelAct) layoutFinal.addLayout(actionLayout1) layoutFinal.addWidget(self.arrowLabel) layoutFinal.addLayout(actionLayout2) layoutFinal.addWidget(self.arrowLabel2) layoutFinal.addWidget(self.addAction) layoutFinal.addStretch(1) self.setLayout(layoutFinal) def createToolbar(self): """ Create toolbar """ pass def createWidgetScreen(self): """ Create screen widget """ self.screenGroup = QGroupBox(self.tr("")) # text self.checkComboBox = QComboBox(self) self.checkComboBox.addItems([ GuiSteps.OP_ANY, GuiSteps.OP_CONTAINS, GuiSteps.OP_NOTCONTAINS, GuiSteps.OP_REGEXP, GuiSteps.OP_NOTREGEXP, GuiSteps.OP_STARTSWITH, GuiSteps.OP_NOTSTARTSWITH, GuiSteps.OP_ENDSWITH, GuiSteps.OP_NOTENDSWITH ]) self.screenLine = QLineEdit(self) self.screenLine.setMinimumWidth(300) self.screenLine.setEnabled(False) self.screenLine.hide() self.screenArea = QTextEdit(self) self.screenArea.setMinimumWidth(300) self.screenArea.setEnabled(False) self.screenCombo = QComboBox(self) self.screenCombo.addItems(LIST_TYPES) self.screenCombo.setEnabled(False) self.screenSaveCombo = QComboBox(self) self.screenSaveCombo.addItems(["VARIABLE", "CACHE"]) self.screenSaveLine = QLineEdit(self) self.screenSaveLine.setMinimumWidth(300) self.screenSaveLine.setEnabled(False) mainTextlayout = QGridLayout() mainTextlayout.addWidget(QLabel(self.tr("Checking if the screen: ")), 0, 0) mainTextlayout.addWidget(self.checkComboBox, 0, 1) mainTextlayout.addWidget(QLabel(self.tr("The value:")), 1, 0) mainTextlayout.addWidget(self.screenCombo, 1, 1) mainTextlayout.addWidget(self.screenLine, 2, 1) mainTextlayout.addWidget(self.screenArea, 2, 1) mainTextlayout.addWidget(QLabel(self.tr("And save the screen in:")), 0, 2) mainTextlayout.addWidget(self.screenSaveCombo, 1, 2) mainTextlayout.addWidget(self.screenSaveLine, 2, 2) self.screenGroup.setLayout(mainTextlayout) self.screenGroup.hide() def createWidgetText(self): """ Create text widget """ self.textGroup = QGroupBox(self.tr("")) # text self.textLine = QLineEdit(self) self.textLine.setMinimumWidth(300) self.textCombo = QComboBox(self) self.textCombo.addItems(LIST_TYPES) mainTextlayout = QGridLayout() mainTextlayout.addWidget(QLabel(self.tr("Send the value:")), 0, 0) mainTextlayout.addWidget(self.textCombo, 0, 1) mainTextlayout.addWidget(self.textLine, 0, 2) self.textGroup.setLayout(mainTextlayout) self.textGroup.hide() def createWidgetShortcut(self): """ Create shortcut widget """ self.shortcutGroup = QGroupBox(self.tr("")) # text self.shortcutComboBox = QComboBox() self.shortcutComboBox.addItems([KEY_CTRLC, KEY_ENTER]) self.shortcutComboBox.setMinimumWidth(300) mainTextlayout = QGridLayout() mainTextlayout.addWidget(QLabel(self.tr("Shortcut:")), 0, 0) mainTextlayout.addWidget(self.shortcutComboBox, 0, 1) self.shortcutGroup.setLayout(mainTextlayout) self.shortcutGroup.hide() def createWidgetSession(self): """ Create session widget """ self.sessionGroup = QGroupBox(self.tr("")) # login self.loginLine = QLineEdit(self) self.loginLine.setMinimumWidth(300) self.loginCombo = QComboBox(self) self.loginCombo.addItems(LIST_TYPES) # password self.pwdLine = QLineEdit(self) self.pwdLine.setMinimumWidth(300) self.pwdCombo = QComboBox(self) self.pwdCombo.addItems(LIST_TYPES) # ip self.ipLine = QLineEdit(self) self.ipLine.setMinimumWidth(300) self.ipCombo = QComboBox(self) self.ipCombo.addItems(LIST_TYPES) # port self.portLine = QLineEdit(self) self.portLine.setMinimumWidth(300) self.portLine.setText("22") self.portLine.setValidator(self.validatorInt) self.portCombo = QComboBox(self) self.portCombo.addItems(LIST_TYPES) # agent support self.useAgent = QCheckBox("Use with agent mode") mainTextlayout = QGridLayout() mainTextlayout.addWidget(QLabel(self.tr("Host:")), 0, 0) mainTextlayout.addWidget(self.ipCombo, 0, 1) mainTextlayout.addWidget(self.ipLine, 0, 2) mainTextlayout.addWidget(QLabel(self.tr("Port (optional):")), 1, 0) mainTextlayout.addWidget(self.portCombo, 1, 1) mainTextlayout.addWidget(self.portLine, 1, 2) mainTextlayout.addWidget(QLabel(self.tr("Login:"******"Password:"******""" Create qt connections """ self.actionsComboBox.currentIndexChanged.connect(self.onActionChanged) self.addAction.clicked.connect(self.addStep) self.ipCombo.currentIndexChanged.connect(self.onIpTypeChanged) self.portCombo.currentIndexChanged.connect(self.onPortTypeChanged) self.loginCombo.currentIndexChanged.connect(self.onLoginTypeChanged) self.pwdCombo.currentIndexChanged.connect(self.onPwdTypeChanged) self.textCombo.currentIndexChanged.connect(self.onTextTypeChanged) self.screenCombo.currentIndexChanged.connect(self.onScreenTypeChanged) self.checkComboBox.currentIndexChanged.connect( self.onScreenOperatorChanged) self.screenSaveCombo.currentIndexChanged.connect( self.onScreenSaveChanged) def pluginDataAccessor(self): """ Return data to plugin """ return {"data": ""} def onPluginImport(self, dataJson): """ Received data from plugins """ if "steps" not in dataJson: QMessageBox.warning(self, "Assistant Automation", "bad import") return if not isinstance(dataJson['steps'], list): QMessageBox.warning(self, "Assistant Automation", "bad import") return if not ('ip' in dataJson and 'login' in dataJson and 'password' in dataJson): QMessageBox.warning(self, "Assistant Automation", "bad import") return # emit open session parameters = { 'dest-ip': dataJson['ip'], 'dest-port': 22, 'login': dataJson['login'], 'password': dataJson['password'], 'from-cache-ip': False, 'from-alias-ip': False, 'from-cache-port': False, 'from-alias-port': False, 'from-cache-login': False, 'from-alias-login': False, 'from-cache-pwd': False, 'from-alias-pwd': False, 'agent-support': False } self.AddStep.emit(GuiSteps.SYSTEM_SESSION, EMPTY_VALUE, EMPTY_VALUE, parameters) for stp in dataJson['steps']: if isinstance(stp, dict): # new in v16 fromCache = False fromAlias = False if "type-value" in stp: if stp["type-value"].lower() == "cache": fromCache = True if stp["type-value"].lower() == "alias": fromAlias = True # end of new if stp["action-name"] == "SEND": parameters = { 'text': stp["action-value"], 'from-cache': fromCache, 'from-alias': fromAlias } self.AddStep.emit(GuiSteps.SYSTEM_TEXT, EMPTY_VALUE, EMPTY_VALUE, parameters) elif stp["action-name"] == "EXPECT": op = "Contains" if stp["action-type"] == "REGEX": op = "RegEx" parameters = { 'value': stp["action-value"], 'from-cache': fromCache, 'from-alias': fromAlias, 'operator': op, 'to-cache': False, 'cache-key': '' } self.AddStep.emit(GuiSteps.SYSTEM_CHECK_SCREEN, EMPTY_VALUE, EMPTY_VALUE, parameters) else: QMessageBox.warning( self, "Assistant Automation", "action not yet supported: %s" % stp["action-name"]) # close self.AddStep.emit(GuiSteps.SYSTEM_CLOSE, EMPTY_VALUE, EMPTY_VALUE, {}) def onScreenOperatorChanged(self): """ On screen operator changed """ if self.checkComboBox.currentText() == GuiSteps.OP_ANY: self.screenLine.setEnabled(False) self.screenArea.setEnabled(False) self.screenCombo.setEnabled(False) else: self.screenLine.setEnabled(True) self.screenArea.setEnabled(True) self.screenCombo.setEnabled(True) def onScreenSaveChanged(self): """ On screen save changed """ if self.screenSaveCombo.currentText() == "VARIABLE": self.screenSaveLine.setEnabled(False) else: self.screenSaveLine.setEnabled(True) def onScreenTypeChanged(self): """ On screen type changed """ if self.screenCombo.currentText() in ["TEXT"]: self.screenArea.show() self.screenLine.hide() else: self.screenLine.show() self.screenArea.hide() if self.screenCombo.currentText() in ["CACHE"]: self.screenLine.setValidator(self.validatorAll) if self.screenCombo.currentText() == "ALIAS": self.screenLine.setText(self.screenLine.text().upper()) self.screenLine.setValidator(self.validatorUpper) def onTextTypeChanged(self): """ On text type changed """ if self.textCombo.currentText() in ["TEXT", "CACHE"]: self.textLine.setValidator(self.validatorAll) if self.textCombo.currentText() == "ALIAS": self.textLine.setText(self.textLine.text().upper()) self.textLine.setValidator(self.validatorUpper) def onLoginTypeChanged(self): """ On login type changed """ if self.loginCombo.currentText() in ["TEXT", "CACHE"]: self.loginLine.setValidator(self.validatorAll) if self.loginCombo.currentText() == "ALIAS": self.loginLine.setText(self.loginLine.text().upper()) self.loginLine.setValidator(self.validatorUpper) def onPwdTypeChanged(self): """ On password type changed """ if self.pwdCombo.currentText() in ["TEXT", "CACHE"]: self.pwdLine.setValidator(self.validatorAll) if self.pwdCombo.currentText() == "ALIAS": self.pwdLine.setText(self.pwdLine.text().upper()) self.pwdLine.setValidator(self.validatorUpper) def onIpTypeChanged(self): """ On ip type changed """ if self.ipCombo.currentText() in ["TEXT", "CACHE"]: self.ipLine.setValidator(self.validatorAll) if self.ipCombo.currentText() == "ALIAS": self.ipLine.setText(self.ipLine.text().upper()) self.ipLine.setValidator(self.validatorUpper) def onPortTypeChanged(self): """ On port type changed """ if self.portCombo.currentText() in ["TEXT"]: self.portLine.setText("22") self.portLine.setValidator(self.validatorInt) if self.portCombo.currentText() in ["CACHE"]: self.portLine.setValidator(self.validatorAll) if self.portCombo.currentText() == "ALIAS": self.portLine.setText(self.portLine.text().upper()) self.portLine.setValidator(self.validatorUpper) def onActionChanged(self): """ On action changed """ descr = 'No description available!' i = 0 for el in GuiSteps.ACTION_SYSTEM_DESCR: if isinstance(el, dict): if self.actionsComboBox.currentText() in el: descr = GuiSteps.ACTION_SYSTEM_DESCR[i][ self.actionsComboBox.currentText()] break i += 1 self.labelActionDescr.setText("%s\n" % descr) if self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_SESSION]: self.sessionGroup.show() self.textGroup.hide() self.shortcutGroup.hide() self.screenGroup.hide() self.arrowLabel.show() self.arrowLabel2.show() elif self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_CLOSE]: self.sessionGroup.hide() self.textGroup.hide() self.shortcutGroup.hide() self.screenGroup.hide() self.arrowLabel.hide() self.arrowLabel2.show() elif self.actionsComboBox.currentText() in [ GuiSteps.SYSTEM_CLEAR_SCREEN ]: self.sessionGroup.hide() self.textGroup.hide() self.shortcutGroup.hide() self.screenGroup.hide() self.arrowLabel.hide() self.arrowLabel2.show() elif self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_TEXT]: self.sessionGroup.hide() self.textGroup.show() self.shortcutGroup.hide() self.screenGroup.hide() self.arrowLabel.show() self.arrowLabel2.show() elif self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_SHORTCUT]: self.sessionGroup.hide() self.textGroup.hide() self.shortcutGroup.show() self.screenGroup.hide() self.arrowLabel.show() self.arrowLabel2.show() elif self.actionsComboBox.currentText() in [ GuiSteps.SYSTEM_CHECK_SCREEN ]: self.sessionGroup.hide() self.textGroup.hide() self.shortcutGroup.hide() self.screenGroup.show() self.arrowLabel.show() self.arrowLabel2.show() else: self.sessionGroup.hide() self.textGroup.hide() self.shortcutGroup.hide() self.screenGroup.hide() self.arrowLabel.hide() self.arrowLabel2.hide() def addStep(self): """ Add step """ action = self.actionsComboBox.currentText() descr = self.descriptionLine.text() descr = unicode(descr).replace('"', '') signal = self.AddStep if self.cancelAction.isEnabled(): signal = self.UpdateStep if action in [GuiSteps.SYSTEM_SESSION]: fromCacheIp = False if self.ipCombo.currentText() == "CACHE": fromCacheIp = True fromAliasIp = False if self.ipCombo.currentText() == "ALIAS": fromAliasIp = True fromCachePort = False if self.portCombo.currentText() == "CACHE": fromCachePort = True fromAliasPort = False if self.portCombo.currentText() == "ALIAS": fromAliasPort = True fromCacheLogin = False if self.loginCombo.currentText() == "CACHE": fromCacheLogin = True fromAliasLogin = False if self.loginCombo.currentText() == "ALIAS": fromAliasLogin = True fromCachePwd = False if self.pwdCombo.currentText() == "CACHE": fromCachePwd = True fromAliasPwd = False if self.pwdCombo.currentText() == "ALIAS": fromAliasPwd = True newIp = self.ipLine.text() if not len(newIp): QMessageBox.warning(self, "Assistant", "Please to provide a ip!") return newPort = self.portLine.text() if not len(newPort): QMessageBox.warning(self, "Assistant", "Please to provide a port!") return newLogin = self.loginLine.text() if not len(newLogin): QMessageBox.warning(self, "Assistant", "Please to provide a login!") return newPwd = self.pwdLine.text() agentSupport = "False" if self.useAgent.isChecked(): agentSupport = "True" parameters = { 'dest-ip': newIp, 'dest-port': newPort, 'login': newLogin, 'password': newPwd, 'from-cache-ip': fromCacheIp, 'from-alias-ip': fromAliasIp, 'from-cache-port': fromCachePort, 'from-alias-port': fromAliasPort, 'from-cache-login': fromCacheLogin, 'from-alias-login': fromAliasLogin, 'from-cache-pwd': fromCachePwd, 'from-alias-pwd': fromAliasPwd, 'agent-support': agentSupport } signal.emit(str(action), unicode(descr), EMPTY_VALUE, parameters) elif action in [GuiSteps.SYSTEM_CLOSE]: signal.emit(str(action), unicode(descr), EMPTY_VALUE, {}) elif action in [GuiSteps.SYSTEM_CLEAR_SCREEN]: signal.emit(str(action), unicode(descr), EMPTY_VALUE, {}) elif action in [GuiSteps.SYSTEM_TEXT]: fromCache = False if self.textCombo.currentText() == "CACHE": fromCache = True fromAlias = False if self.textCombo.currentText() == "ALIAS": fromAlias = True newText = self.textLine.text() if not len(newText): QMessageBox.warning(self, "Assistant", "Please to provide text!") return parameters = { 'text': newText, 'from-cache': fromCache, 'from-alias': fromAlias } signal.emit(str(action), unicode(descr), EMPTY_VALUE, parameters) elif action in [GuiSteps.SYSTEM_SHORTCUT]: newShortcut = self.shortcutComboBox.currentText() parameters = {'shortcut': newShortcut} signal.emit(str(action), unicode(descr), EMPTY_VALUE, parameters) elif action in [GuiSteps.SYSTEM_CHECK_SCREEN]: op = self.checkComboBox.currentText() fromCache = False if self.screenCombo.currentText() == "CACHE": fromCache = True fromAlias = False if self.screenCombo.currentText() == "ALIAS": fromAlias = True toCache = False if self.screenSaveCombo.currentText() == "CACHE": toCache = True keyCache = self.screenSaveLine.text() newText = "" if op != GuiSteps.OP_ANY: if fromCache or fromAlias: newText = self.screenLine.text() else: newText = self.screenArea.toPlainText() if not len(newText): QMessageBox.warning(self, "Assistant", "Please to provide value to search!") return parameters = { 'value': newText, 'from-cache': fromCache, 'from-alias': fromAlias, 'operator': op, 'to-cache': toCache, 'cache-key': keyCache } signal.emit(str(action), unicode(descr), EMPTY_VALUE, parameters) else: signal.emit(str(action), unicode(descr), EMPTY_VALUE, {}) def cancelStep(self): """ Cancel step """ self.addAction.setText("&Add") buttonFont = QFont() buttonFont.setBold(False) self.addAction.setFont(buttonFont) self.cancelAction.setEnabled(False) self.CancelEdit.emit() def finalizeUpdate(self): """ Finalize the update of the step """ self.addAction.setText("&Add Action") buttonFont = QFont() buttonFont.setBold(False) self.addAction.setFont(buttonFont) self.cancelAction.setEnabled(False) def editStep(self, stepData): """ Edit step """ self.addAction.setText("&Update") buttonFont = QFont() buttonFont.setBold(True) self.addAction.setFont(buttonFont) self.cancelAction.setEnabled(True) # set the current value for actions combo for i in xrange(self.actionsComboBox.count()): item_text = self.actionsComboBox.itemText(i) if unicode(stepData["action"]) == unicode(item_text): self.actionsComboBox.setCurrentIndex(i) break # and then refresh options self.onActionChanged() # finally fill all fields self.descriptionLine.setText(stepData["description"]) if self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_SESSION]: self.ipLine.setText(stepData["parameters"]["dest-ip"]) self.portLine.setText("%s" % stepData["parameters"]["dest-port"]) self.loginLine.setText(stepData["parameters"]["login"]) self.pwdLine.setText(stepData["parameters"]["password"]) if stepData["parameters"]["from-cache-ip"]: self.ipLine.setValidator(self.validatorAll) self.ipCombo.setCurrentIndex(INDEX_CACHE) elif stepData["parameters"]["from-alias-ip"]: self.ipLine.setValidator(self.validatorUpper) self.ipCombo.setCurrentIndex(INDEX_ALIAS) else: self.ipLine.setValidator(self.validatorAll) self.ipCombo.setCurrentIndex(INDEX_TEXT) if stepData["parameters"]["from-cache-port"]: self.portLine.setValidator(self.validatorAll) self.portCombo.setCurrentIndex(INDEX_CACHE) elif stepData["parameters"]["from-alias-port"]: self.portLine.setValidator(self.validatorUpper) self.portCombo.setCurrentIndex(INDEX_ALIAS) else: self.portLine.setValidator(self.validatorInt) self.portCombo.setCurrentIndex(INDEX_TEXT) if stepData["parameters"]["from-cache-login"]: self.loginLine.setValidator(self.validatorAll) self.loginCombo.setCurrentIndex(INDEX_CACHE) elif stepData["parameters"]["from-alias-login"]: self.loginLine.setValidator(self.validatorUpper) self.loginCombo.setCurrentIndex(INDEX_ALIAS) else: self.loginLine.setValidator(self.validatorAll) self.loginCombo.setCurrentIndex(INDEX_TEXT) if stepData["parameters"]["from-cache-pwd"]: self.pwdLine.setValidator(self.validatorAll) self.pwdCombo.setCurrentIndex(INDEX_CACHE) elif stepData["parameters"]["from-alias-pwd"]: self.pwdLine.setValidator(self.validatorUpper) self.pwdCombo.setCurrentIndex(INDEX_ALIAS) else: self.pwdLine.setValidator(self.validatorAll) self.pwdCombo.setCurrentIndex(INDEX_TEXT) if self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_CLOSE]: pass if self.actionsComboBox.currentText() in [ GuiSteps.SYSTEM_CLEAR_SCREEN ]: pass if self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_TEXT]: if stepData["parameters"]["from-cache"]: self.textLine.setValidator(self.validatorAll) self.textCombo.setCurrentIndex(INDEX_CACHE) elif stepData["parameters"]["from-alias"]: self.textLine.setValidator(self.validatorUpper) self.textCombo.setCurrentIndex(INDEX_ALIAS) else: self.textLine.setValidator(self.validatorAll) self.textCombo.setCurrentIndex(INDEX_TEXT) self.textLine.setText(stepData["parameters"]["text"]) if self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_SHORTCUT]: for i in xrange(self.shortcutComboBox.count()): item_text = self.shortcutComboBox.itemText(i) if unicode(stepData["parameters"]["shortcut"]) == unicode( item_text): self.shortcutComboBox.setCurrentIndex(i) break if self.actionsComboBox.currentText() in [ GuiSteps.SYSTEM_CHECK_SCREEN ]: if stepData["parameters"]["from-cache"]: self.screenLine.setValidator(self.validatorAll) self.screenCombo.setCurrentIndex(INDEX_CACHE) self.screenLine.setText(stepData["parameters"]["value"]) elif stepData["parameters"]["from-alias"]: self.screenLine.setValidator(self.validatorUpper) self.screenCombo.setCurrentIndex(INDEX_ALIAS) self.screenLine.setText(stepData["parameters"]["value"]) else: self.screenCombo.setCurrentIndex(INDEX_TEXT) self.screenArea.setPlainText(stepData["parameters"]["value"]) for i in xrange(self.checkComboBox.count()): item_text = self.checkComboBox.itemText(i) if unicode(stepData["parameters"]["operator"]) == unicode( item_text): self.checkComboBox.setCurrentIndex(i) break if stepData["parameters"]["to-cache"]: self.screenSaveCombo.setCurrentIndex(1) self.screenSaveLine.setText( stepData["parameters"]["cache-key"]) else: self.screenSaveCombo.setCurrentIndex(0) def getTimeout(self): """ Return timeout value """ return self.optionsDialog.timeoutLine.text() def setTimeout(self, timeout): """ Set the timeout """ return self.optionsDialog.timeoutLine.setText(timeout) def getAgentName(self): """ Return the agent name """ return self.optionsDialog.agentNameLine.text() def getAgentList(self): """ Return the agent list """ return self.optionsDialog.agentsList
class MainWindow(mainwindow_widget, mainwindow_base): """ Main application window """ def __init__(self, settings): super(MainWindow, self).__init__() self.setupUi(self) self.settings = settings roam.featureform.settings = settings.settings self.canvaslayers = [] self.layerbuttons = [] self.project = None self.selectionbands = defaultdict(partial(QgsRubberBand, self.canvas)) self.canvas.setCanvasColor(Qt.white) self.canvas.enableAntiAliasing(True) self.canvas.setWheelAction(QgsMapCanvas.WheelZoomToMouseCursor) self.bar = roam.messagebaritems.MessageBar(self) self.actionMap.setVisible(False) pal = QgsPalLabeling() self.canvas.mapRenderer().setLabelingEngine(pal) self.canvas.setFrameStyle(QFrame.NoFrame) self.menuGroup = QActionGroup(self) self.menuGroup.setExclusive(True) self.menuGroup.addAction(self.actionMap) self.menuGroup.addAction(self.actionDataEntry) self.menuGroup.addAction(self.actionProject) self.menuGroup.addAction(self.actionSync) self.menuGroup.addAction(self.actionSettings) self.menuGroup.triggered.connect(self.updatePage) self.editgroup = QActionGroup(self) self.editgroup.setExclusive(True) self.editgroup.addAction(self.actionPan) self.editgroup.addAction(self.actionZoom_In) self.editgroup.addAction(self.actionZoom_Out) self.editgroup.addAction(self.actionInfo) #TODO Extract GPS out into a service and remove UI stuff self.actionGPS = GPSAction(":/icons/gps", self.canvas, self.settings, self) self.projecttoolbar.addAction(self.actionGPS) self.projectwidget = ProjectsWidget(self) self.projectwidget.requestOpenProject.connect(self.loadProject) QgsProject.instance().readProject.connect(self._readProject) self.project_page.layout().addWidget(self.projectwidget) self.syncwidget = SyncWidget() self.syncpage.layout().addWidget(self.syncwidget) self.settingswidget = SettingsWidget(settings, self) self.settings_page.layout().addWidget(self.settingswidget) self.actionSettings.toggled.connect(self.settingswidget.populateControls) self.actionSettings.toggled.connect(self.settingswidget.readSettings) self.settingswidget.settingsupdated.connect(self.settingsupdated) self.dataentrywidget = DataEntryWidget(self.canvas, self.bar) self.widgetpage.layout().addWidget(self.dataentrywidget) self.dataentrywidget.rejected.connect(self.formrejected) self.dataentrywidget.featuresaved.connect(self.featureSaved) self.dataentrywidget.featuredeleted.connect(self.featuredeleted) self.dataentrywidget.failedsave.connect(self.failSave) self.dataentrywidget.helprequest.connect(self.showhelp) self.dataentrywidget.openimage.connect(self.openimage) def createSpacer(width=0, height=0): widget = QWidget() widget.setMinimumWidth(width) widget.setMinimumHeight(height) return widget gpsspacewidget = createSpacer(30) sidespacewidget = createSpacer(30) sidespacewidget2 = createSpacer(height=20) sidespacewidget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) sidespacewidget2.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) gpsspacewidget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.topspaceraction = self.projecttoolbar.insertWidget(self.actionGPS, gpsspacewidget) def createlabel(text): style = """ QLabel { color: #706565; font: 14px "Calibri" ; }""" label = QLabel(text) label.setStyleSheet(style) return label self.projectlabel = createlabel("Project: {project}") self.userlabel = createlabel("User: {user}".format(user=getpass.getuser())) self.positionlabel = createlabel('') self.statusbar.addWidget(self.projectlabel) self.statusbar.addWidget(self.userlabel) spacer = createSpacer() spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) self.statusbar.addWidget(spacer) self.statusbar.addWidget(self.positionlabel) self.menutoolbar.insertWidget(self.actionQuit, sidespacewidget2) self.menutoolbar.insertWidget(self.actionProject, sidespacewidget) self.stackedWidget.currentChanged.connect(self.updateUIState) self.panels = [] self.connectButtons() self.band = QgsRubberBand(self.canvas) self.band.setIconSize(20) self.band.setWidth(10) self.band.setColor(QColor(186, 93, 212, 76)) self.canvas_page.layout().insertWidget(0, self.projecttoolbar) self.dataentrymodel = QStandardItemModel(self) self.dataentrycombo = QComboBox(self.projecttoolbar) self.dataentrycombo.setIconSize(QSize(48,48)) self.dataentrycombo.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding) self.dataentrycombo.setSizeAdjustPolicy(QComboBox.AdjustToContents) self.dataentrycombo.setModel(self.dataentrymodel) self.dataentrycomboaction = self.projecttoolbar.insertWidget(self.topspaceraction, self.dataentrycombo) self.dataentrycombo.showPopup = self.selectdataentry self.biglist = BigList(self.canvas) self.biglist.setlabel("Select data entry form") self.biglist.setmodel(self.dataentrymodel) self.biglist.itemselected.connect(self.dataentrychanged) self.biglist.hide() self.centralwidget.layout().addWidget(self.statusbar) self.actionGPSFeature.setProperty('dataentry', True) self.infodock = InfoDock(self.canvas) self.infodock.requestopenform.connect(self.openForm) self.infodock.featureupdated.connect(self.highlightfeature) self.infodock.resultscleared.connect(self.clearselection) self.infodock.openurl.connect(self.viewurl) self.infodock.hide() self.hidedataentry() self.canvas.extentsChanged.connect(self.updatestatuslabel) self.projecttoolbar.toolButtonStyleChanged.connect(self.updatecombo) def selectdataentry(self, ): if self.dataentrycombo.count() == 0: return self.biglist.show() def viewurl(self, url): """ Open a URL in Roam :param url: :return: """ key = url.toString().lstrip('file://') try: # Hack. Eww fix me. data, imagetype = roam.htmlviewer.images[os.path.basename(key)] except KeyError: # It's not a image so lets just pass it of as a normal # URL QDesktopServices.openUrl(url) return pix = QPixmap() if imagetype == 'base64': pix.loadFromData(data) else: pix.load(data) self.openimage(pix) def openimage(self, pixmap): viewer = ImageViewer(self.stackedWidget) viewer.resize(self.stackedWidget.size()) viewer.openimage(pixmap) def updatecombo(self, *args): self.dataentrycombo.setMinimumHeight(0) def settingsupdated(self, settings): settings.save() self.show() self.actionGPS.updateGPSPort() # eww! roam.featureform.settings = settings.settings def updatestatuslabel(self): extent = self.canvas.extent() self.positionlabel.setText("Map Center: {}".format(extent.center().toString())) def highlightselection(self, results): for layer, features in results.iteritems(): band = self.selectionbands[layer] band.setColor(QColor(255, 0, 0, 150)) band.setIconSize(20) band.setWidth(2) band.setBrushStyle(Qt.NoBrush) band.reset(layer.geometryType()) for feature in features: band.addGeometry(feature.geometry(), layer) def clearselection(self): # Clear the main selection rubber band self.band.reset() # Clear the rest for band in self.selectionbands.itervalues(): band.reset() def highlightfeature(self, layer, feature, features): self.clearselection() self.highlightselection({layer: features}) self.band.setToGeometry(feature.geometry(), layer) def showmap(self): self.actionMap.setVisible(True) self.actionMap.trigger() def hidedataentry(self): self.actionDataEntry.setVisible(False) def showdataentry(self): self.actionDataEntry.setVisible(True) self.actionDataEntry.trigger() def dataentrychanged(self, index): wasactive = self.clearCapatureTools() if not index.isValid(): return modelindex = index # modelindex = self.dataentrymodel.index(index, 0) form = modelindex.data(Qt.UserRole + 1) self.dataentrycombo.setCurrentIndex(index.row()) self.createCaptureButtons(form, wasactive) def raiseerror(self, *exinfo): info = traceback.format_exception(*exinfo) item = self.bar.pushError('Seems something has gone wrong. Press for more details', info) def setMapTool(self, tool, *args): self.canvas.setMapTool(tool) def homeview(self): """ Zoom the mapview canvas to the extents the project was opened at i.e. the default extent. """ self.canvas.setExtent(self.defaultextent) self.canvas.refresh() def connectButtons(self): def connectAction(action, tool): action.toggled.connect(partial(self.setMapTool, tool)) def cursor(name): pix = QPixmap(name) pix = pix.scaled(QSize(24,24)) return QCursor(pix) self.zoomInTool = QgsMapToolZoom(self.canvas, False) self.zoomOutTool = QgsMapToolZoom(self.canvas, True) self.panTool = TouchMapTool(self.canvas) self.moveTool = MoveTool(self.canvas, []) self.infoTool = InfoTool(self.canvas) connectAction(self.actionZoom_In, self.zoomInTool) connectAction(self.actionZoom_Out, self.zoomOutTool) connectAction(self.actionPan, self.panTool) connectAction(self.actionMove, self.moveTool) connectAction(self.actionInfo, self.infoTool) self.zoomInTool.setCursor(cursor(':/icons/in')) self.zoomOutTool.setCursor(cursor(':/icons/out')) self.infoTool.setCursor(cursor(':/icons/info')) self.actionRaster.triggered.connect(self.toggleRasterLayers) self.infoTool.infoResults.connect(self.showInfoResults) # The edit toolbutton is currently not being used but leaving it for feature. self.moveTool.layersupdated.connect(self.actionMove.setEnabled) self.moveTool.layersupdated.connect(self.actionEdit_Tools.setEnabled) self.actionGPSFeature.triggered.connect(self.addFeatureAtGPS) self.actionGPSFeature.setEnabled(self.actionGPS.isConnected) self.actionGPS.gpsfixed.connect(self.actionGPSFeature.setEnabled) self.actionHome.triggered.connect(self.homeview) self.actionQuit.triggered.connect(self.exit) def showToolError(self, label, message): self.bar.pushMessage(label, message, QgsMessageBar.WARNING) def clearCapatureTools(self): captureselected = False for action in self.projecttoolbar.actions(): if action.objectName() == "capture" and action.isChecked(): captureselected = True if action.property('dataentry'): self.projecttoolbar.removeAction(action) return captureselected def createCaptureButtons(self, form, wasselected): tool = form.getMaptool()(self.canvas) for action in tool.actions: # Create the action here. if action.ismaptool: action.toggled.connect(partial(self.setMapTool, tool)) # Set the action as a data entry button so we can remove it later. action.setProperty("dataentry", True) self.editgroup.addAction(action) self.layerbuttons.append(action) self.projecttoolbar.insertAction(self.topspaceraction, action) if action.isdefault: action.setChecked(wasselected) if hasattr(tool, 'geometryComplete'): add = partial(self.addNewFeature, form) tool.geometryComplete.connect(add) else: tool.finished.connect(self.openForm) tool.error.connect(partial(self.showToolError, form.label)) self.projecttoolbar.insertAction(self.topspaceraction, self.actionGPSFeature) self.actionGPSFeature.setVisible(not tool.isEditTool()) def createFormButtons(self, forms): """ Create buttons for each form that is defined """ self.dataentrymodel.clear() self.clearCapatureTools() def captureFeature(form): item = QStandardItem(QIcon(form.icon), form.icontext) item.setData(form, Qt.UserRole + 1) item.setSizeHint(QSize(item.sizeHint().width(), self.projecttoolbar.height())) self.dataentrymodel.appendRow(item) capabilitityhandlers = {"capture": captureFeature} failedforms = [] for form in forms: valid, reasons = form.valid if not valid: roam.utils.log("Form is invalid for data entry because {}".format(reasons)) failedforms.append((form, reasons)) continue for capability in form.capabilities: try: capabilitityhandlers[capability](form) except KeyError: # Just ignore capabilities we don't support yet. continue if failedforms: for form, reasons in failedforms: html = "<h3>{}</h3><br>{}".format(form.label, "<br>".join(reasons)) self.bar.pushMessage("Form errors", "Looks like some forms couldn't be loaded", level=QgsMessageBar.WARNING, extrainfo=html) visible = self.dataentrymodel.rowCount() > 0 self.dataentrycomboaction.setVisible(visible) self.dataentrycombo.setMinimumHeight(self.projecttoolbar.height()) index = self.dataentrymodel.index(0, 0) self.dataentrychanged(index) def addFeatureAtGPS(self): """ Add a record at the current GPS location. """ index = self.dataentrycombo.currentIndex() modelindex = self.dataentrymodel.index(index, 0) form = modelindex.data(Qt.UserRole + 1) point = self.actionGPS.position point = QgsGeometry.fromPoint(point) self.addNewFeature(form=form, geometry=point) def clearToolRubberBand(self): """ Clear the rubber band of the active tool if it has one """ tool = self.canvas.mapTool() try: tool.clearBand() except AttributeError: # No clearBand method found, but that's cool. pass def showhelp(self, url): help = HelpPage(self.stackedWidget) help.setHelpPage(url) help.show() def dataentryfinished(self): self.hidedataentry() self.showmap() self.cleartempobjects() self.infodock.refreshcurrent() def featuredeleted(self): self.dataentryfinished() self.bar.pushMessage("Deleted", "Feature Deleted", QgsMessageBar.INFO, 1) self.canvas.refresh() def featureSaved(self): self.dataentryfinished() self.canvas.refresh() def failSave(self, messages): self.bar.pushError("Error when saving changes.", messages) def cleartempobjects(self): self.band.reset() self.clearToolRubberBand() def formrejected(self, message, level): self.dataentryfinished() if message: self.bar.pushMessage("Form Message", message, level, duration=2) self.cleartempobjects() def openForm(self, form, feature): """ Open the form that is assigned to the layer """ self.band.setToGeometry(feature.geometry(), form.QGISLayer) self.showdataentry() self.dataentrywidget.openform(feature=feature, form=form, project=self.project) def addNewFeature(self, form, geometry): """ Add a new new feature to the given layer """ layer = form.QGISLayer fields = layer.pendingFields() feature = QgsFeature(fields) feature.setGeometry(geometry) for index in xrange(fields.count()): pkindexes = layer.dataProvider().pkAttributeIndexes() if index in pkindexes and layer.dataProvider().name() == 'spatialite': continue value = layer.dataProvider().defaultValue(index) feature[index] = value self.openForm(form, feature) def exit(self): """ Exit the application. """ QApplication.exit(0) def showInfoResults(self, results): self.infodock.clearResults() forms = {} for layer in results.keys(): layername = layer.name() if not layername in forms: forms[layername] = list(self.project.formsforlayer(layername)) self.infodock.setResults(results, forms) self.infodock.show() def toggleRasterLayers(self): """ Toggle all raster layers on or off. """ if not self.canvaslayers: return #Freeze the canvas to save on UI refresh self.canvas.freeze() for layer in self.canvaslayers: if layer.layer().type() == QgsMapLayer.RasterLayer: layer.setVisible(not layer.isVisible()) # Really!? We have to reload the whole layer set every time? # WAT? self.canvas.setLayerSet(self.canvaslayers) self.canvas.freeze(False) self.canvas.refresh() def missingLayers(self, layers): """ Called when layers have failed to load from the current project """ roam.utils.warning("Missing layers") map(roam.utils.warning, layers) missinglayers = roam.messagebaritems.MissingLayerItem(layers, parent=self.bar) self.bar.pushItem(missinglayers) def loadprojects(self, projects): """ Load the given projects into the project list """ projects = list(projects) self.projectwidget.loadProjectList(projects) self.syncwidget.loadprojects(projects) def updatePage(self, action): """ Update the current stack page based on the current selected action """ page = action.property("page") self.stackedWidget.setCurrentIndex(page) def show(self): """ Override show method. Handles showing the app in fullscreen mode or just maximized """ fullscreen = self.settings.settings.get("fullscreen", False) if fullscreen: self.showFullScreen() else: self.showMaximized() def viewprojects(self): self.stackedWidget.setCurrentIndex(1) def updateUIState(self, page): """ Update the UI state to reflect the currently selected page in the stacked widget """ pass @roam.utils.timeit def _readProject(self, doc): """ readProject is called by QgsProject once the map layer has been populated with all the layers """ parser = ProjectParser(doc) canvasnode = parser.canvasnode self.canvas.freeze() self.canvas.mapRenderer().readXML(canvasnode) self.canvaslayers = parser.canvaslayers() self.canvas.setLayerSet(self.canvaslayers) self.canvas.updateScale() self.projectOpened() self.canvas.freeze(False) self.canvas.refresh() self.showmap() @roam.utils.timeit def projectOpened(self): """ Called when a new project is opened in QGIS. """ projectpath = QgsProject.instance().fileName() self.project = Project.from_folder(os.path.dirname(projectpath)) self.projectlabel.setText("Project: {}".format(self.project.name)) self.createFormButtons(forms=self.project.forms) # Enable the raster layers button only if the project contains a raster layer. layers = QgsMapLayerRegistry.instance().mapLayers().values() hasrasters = any(layer.type() == QgsMapLayer.RasterLayer for layer in layers) self.actionRaster.setEnabled(hasrasters) self.defaultextent = self.canvas.extent() roam.utils.info("Extent: {}".format(self.defaultextent.toString())) # Show panels for panel in self.project.getPanels(): self.mainwindow.addDockWidget(Qt.BottomDockWidgetArea, panel) self.panels.append(panel) # TODO Abstract this out if not self.project.selectlayers: selectionlayers = QgsMapLayerRegistry.instance().mapLayers().values() else: selectionlayers = [] for layername in self.project.selectlayers: try: layer = QgsMapLayerRegistry.instance().mapLayersByName(layername)[0] except IndexError: roam.utils.warning("Can't find QGIS layer for select layer {}".format(layername)) continue selectionlayers.append(layer) self.infoTool.selectionlayers = selectionlayers self.actionPan.trigger() #noinspection PyArgumentList @roam.utils.timeit def loadProject(self, project): """ Load a project into the application . """ roam.utils.log(project) roam.utils.log(project.name) roam.utils.log(project.projectfile) roam.utils.log(project.valid) (passed, message) = project.onProjectLoad() if not passed: self.bar.pushMessage("Project load rejected", "Sorry this project couldn't" "be loaded. Click for me details.", QgsMessageBar.WARNING, extrainfo=message) return self.actionMap.trigger() self.closeProject() self.canvas.refresh() self.canvas.repaint() self.infodock.clearResults() # No idea why we have to set this each time. Maybe QGIS deletes it for # some reason. self.badLayerHandler = BadLayerHandler(callback=self.missingLayers) QgsProject.instance().setBadLayerHandler(self.badLayerHandler) self.stackedWidget.setCurrentIndex(3) self.projectloading_label.setText("Project {} Loading".format(project.name)) pixmap = QPixmap(project.splash) w = self.projectimage.width() h = self.projectimage.height() self.projectimage.setPixmap(pixmap.scaled(w,h, Qt.KeepAspectRatio)) QApplication.processEvents() QDir.setCurrent(os.path.dirname(project.projectfile)) fileinfo = QFileInfo(project.projectfile) QgsProject.instance().read(fileinfo) def closeProject(self): """ Close the current open project """ self.canvas.freeze() QgsMapLayerRegistry.instance().removeAllMapLayers() self.canvas.clear() self.canvas.freeze(False) for panel in self.panels: self.removeDockWidget(panel) del panel # Remove all the old buttons for action in self.layerbuttons: self.editgroup.removeAction(action) self.dataentrymodel.clear() self.panels = [] self.project = None self.dataentrywidget.clear() self.hidedataentry() self.infodock.close()
class ShowSettingsDialog(QDialog): """ Dialog class for plugin settings """ def __init__(self, iface, memoryPointsLayer, memoryLinesLayer, ctllDb, configTable, uriDb, schemaDb, mntUrl): """ Constructor :param iface: interface :param memoryPointsLayer: working memory points layer :param memoryLinesLayer: working memory lines layer :param configTable: config table selected for import """ QDialog.__init__(self) self.__iface = iface self.__memoryPointsLayer = memoryPointsLayer self.__memoryLinesLayer = memoryLinesLayer self.__ctlDb = ctllDb self.__configTable = configTable self.__uriDb = uriDb self.__schemaDb = schemaDb self.__mntUrl = mntUrl self.setWindowTitle(QCoreApplication.translate("VDLTools", "Settings")) self.__pointsLayers = [] self.__linesLayers = [] self.__tables = [] self.__schemas = [] self.__dbs = DBConnector.getUsedDatabases() for layer in list(QgsMapLayerRegistry.instance().mapLayers().values()): if layer is not None and layer.type( ) == QgsMapLayer.VectorLayer and layer.providerType() == "memory": if layer.geometryType() == QGis.Point: self.__pointsLayers.append(layer) if layer.geometryType() == QGis.Line: self.__linesLayers.append(layer) self.resize(450, 200) self.__layout = QGridLayout() pointLabel = QLabel( QCoreApplication.translate("VDLTools", "Working points layer : ")) pointLabel.setMinimumHeight(20) pointLabel.setMinimumWidth(50) self.__layout.addWidget(pointLabel, 0, 1) self.__pointCombo = QComboBox() self.__pointCombo.setMinimumHeight(20) self.__pointCombo.setMinimumWidth(50) self.__pointCombo.addItem("") for layer in self.__pointsLayers: self.__pointCombo.addItem(layer.name()) self.__layout.addWidget(self.__pointCombo, 0, 2) self.__pointCombo.currentIndexChanged.connect(self.__pointComboChanged) if self.__memoryPointsLayer is not None: if self.__memoryPointsLayer in self.__pointsLayers: self.__pointCombo.setCurrentIndex( self.__pointsLayers.index(self.__memoryPointsLayer) + 1) lineLabel = QLabel( QCoreApplication.translate("VDLTools", "Working lines layer : ")) lineLabel.setMinimumHeight(20) lineLabel.setMinimumWidth(50) self.__layout.addWidget(lineLabel, 1, 1) self.__lineCombo = QComboBox() self.__lineCombo.setMinimumHeight(20) self.__lineCombo.setMinimumWidth(50) self.__lineCombo.addItem("") for layer in self.__linesLayers: self.__lineCombo.addItem(layer.name()) self.__layout.addWidget(self.__lineCombo, 1, 2) self.__lineCombo.currentIndexChanged.connect(self.__lineComboChanged) if self.__memoryLinesLayer is not None: if self.__memoryLinesLayer in self.__linesLayers: self.__lineCombo.setCurrentIndex( self.__linesLayers.index(self.__memoryLinesLayer) + 1) dbLabel = QLabel( QCoreApplication.translate("VDLTools", "Import database : ")) dbLabel.setMinimumHeight(20) dbLabel.setMinimumWidth(50) self.__layout.addWidget(dbLabel, 2, 1) self.__dbCombo = QComboBox() self.__dbCombo.setMinimumHeight(20) self.__dbCombo.setMinimumWidth(50) self.__dbCombo.addItem("") for db in list(self.__dbs.keys()): self.__dbCombo.addItem(db) self.__layout.addWidget(self.__dbCombo, 2, 2) schemaLabel = QLabel( QCoreApplication.translate("VDLTools", "Database schema : ")) schemaLabel.setMinimumHeight(20) schemaLabel.setMinimumWidth(50) self.__layout.addWidget(schemaLabel, 3, 1) self.__schemaCombo = QComboBox() self.__schemaCombo.setMinimumHeight(20) self.__schemaCombo.setMinimumWidth(50) self.__schemaCombo.addItem("") self.__layout.addWidget(self.__schemaCombo, 3, 2) tableLabel = QLabel( QCoreApplication.translate("VDLTools", "Config table : ")) tableLabel.setMinimumHeight(20) tableLabel.setMinimumWidth(50) self.__layout.addWidget(tableLabel, 4, 1) self.__tableCombo = QComboBox() self.__tableCombo.setMinimumHeight(20) self.__tableCombo.setMinimumWidth(50) self.__tableCombo.addItem("") self.__layout.addWidget(self.__tableCombo, 4, 2) mntLabel = QLabel( QCoreApplication.translate("VDLTools", "Url for MNT : ")) schemaLabel.setMinimumHeight(20) schemaLabel.setMinimumWidth(50) self.__layout.addWidget(mntLabel, 5, 1) self.__mntText = QLineEdit() if self.__mntUrl is None or self.__mntUrl == "None": self.__mntText.insert( 'http://map.lausanne.ch/main/wsgi/profile.json') else: self.__mntText.insert(self.__mntUrl) self.__mntText.setMinimumHeight(20) self.__mntText.setMinimumWidth(100) self.__layout.addWidget(self.__mntText, 5, 2) ctlLabel = QLabel( QCoreApplication.translate("VDLTools", "Control database : ")) ctlLabel.setMinimumHeight(20) ctlLabel.setMinimumWidth(50) self.__layout.addWidget(ctlLabel, 6, 1) self.__ctlCombo = QComboBox() self.__ctlCombo.setMinimumHeight(20) self.__ctlCombo.setMinimumWidth(50) self.__ctlCombo.addItem("") for db in list(self.__dbs.keys()): self.__ctlCombo.addItem(db) self.__layout.addWidget(self.__ctlCombo, 6, 2) self.__okButton = QPushButton( QCoreApplication.translate("VDLTools", "OK")) self.__okButton.setMinimumHeight(20) self.__okButton.setMinimumWidth(100) self.__cancelButton = QPushButton( QCoreApplication.translate("VDLTools", "Cancel")) self.__cancelButton.setMinimumHeight(20) self.__cancelButton.setMinimumWidth(100) self.__layout.addWidget(self.__okButton, 100, 1) self.__layout.addWidget(self.__cancelButton, 100, 2) self.setLayout(self.__layout) self.__dbCombo.currentIndexChanged.connect(self.__dbComboChanged) self.__schemaCombo.currentIndexChanged.connect( self.__schemaComboChanged) self.__tableCombo.currentIndexChanged.connect(self.__tableComboChanged) self.__ctlCombo.currentIndexChanged.connect(self.__ctlComboChanged) if self.__uriDb is not None: if self.__uriDb.database() in list(self.__dbs.keys()): self.__dbCombo.setCurrentIndex( list(self.__dbs.keys()).index(self.__uriDb.database()) + 1) if self.__ctlDb is not None: if self.__ctlDb.database() in list(self.__dbs.keys()): self.__ctlCombo.setCurrentIndex( list(self.__dbs.keys()).index(self.__ctlDb.database()) + 1) @staticmethod def __resetCombo(combo): """ To reset a combo list :param combo: concerned combo """ while combo.count() > 0: combo.removeItem(combo.count() - 1) def __setSchemaCombo(self, uriDb): """ To fill the schema combo list :param uriDb: selected database uri """ connector = DBConnector(uriDb, self.__iface) db = connector.setConnection() if db: Signal.safelyDisconnect(self.__schemaCombo.currentIndexChanged, self.__schemaComboChanged) self.__resetCombo(self.__schemaCombo) self.__schemaCombo.addItem("") self.__schemas = [] query = db.exec_( """SELECT DISTINCT table_schema FROM information_schema.tables WHERE table_schema NOT IN ('pg_catalog', 'information_schema', 'topology') AND table_type = 'BASE TABLE' AND table_name NOT IN (SELECT f_table_name FROM geometry_columns)""") if query.lastError().isValid(): self.__iface.messageBar().pushMessage( query.lastError().text(), level=QgsMessageBar.CRITICAL, duration=0) else: while next(query): self.__schemas.append(query.value(0)) db.close() for schema in self.__schemas: self.__schemaCombo.addItem(schema) self.__schemaCombo.currentIndexChanged.connect( self.__schemaComboChanged) if self.__schemaDb is not None: if self.__schemaDb in self.__schemas: self.__schemaCombo.setCurrentIndex( self.__schemas.index(self.__schemaDb) + 1) def __setTableCombo(self, uriDb, schema): """ To fill the table combo list :param uriDb: selected database uri :param schema: selected database schema """ connector = DBConnector(uriDb, self.__iface) db = connector.setConnection() if db: Signal.safelyDisconnect(self.__tableCombo.currentIndexChanged, self.__tableComboChanged) self.__resetCombo(self.__tableCombo) self.__tableCombo.addItem("") self.__tables = [] query = db.exec_( """SELECT table_name FROM information_schema.tables WHERE table_schema = '""" + schema + """' ORDER BY table_name""") if query.lastError().isValid(): self.__iface.messageBar().pushMessage( query.lastError().text(), level=QgsMessageBar.CRITICAL, duration=0) else: while next(query): self.__tables.append(query.value(0)) db.close() for table in self.__tables: if self.__tableCombo.findText(table) == -1: self.__tableCombo.addItem(table) self.__tableCombo.currentIndexChanged.connect( self.__tableComboChanged) if self.__configTable is not None: if self.__configTable in self.__tables: self.__tableCombo.setCurrentIndex( self.__tables.index(self.__configTable) + 1) def __lineComboChanged(self): """ To remove blank item when another one is selected """ if self.__lineCombo.itemText(0) == "": self.__lineCombo.removeItem(0) def __pointComboChanged(self): """ To remove blank item when another one is selected """ if self.__pointCombo.itemText(0) == "": self.__pointCombo.removeItem(0) def __tableComboChanged(self): """ To remove blank item when another one is selected """ if self.__tableCombo.itemText(0) == "": self.__tableCombo.removeItem(0) def __dbComboChanged(self): """ When the selection in db combo has changed """ if self.__dbCombo.itemText(0) == "": self.__dbCombo.removeItem(0) if self.uriDb() is not None: self.__setSchemaCombo(self.uriDb()) def __schemaComboChanged(self): """ When the selection in schema combo has changed """ if self.__schemaCombo.itemText(0) == "": self.__schemaCombo.removeItem(0) if self.schemaDb() is not None: self.__setTableCombo(self.uriDb(), self.schemaDb()) def __ctlComboChanged(self): """ When the selection in ctl combo has changed """ if self.__ctlCombo.itemText(0) == "": self.__ctlCombo.removeItem(0) def okButton(self): """ To get the ok button instance :return: ok button instance """ return self.__okButton def cancelButton(self): """ To get the cancel button instance :return: cancel button instance """ return self.__cancelButton def pointsLayer(self): """ To get the selected memory points layer :return: selected memeory points layer, or none """ index = self.__pointCombo.currentIndex() if self.__pointCombo.itemText(index) == "": return None else: return self.__pointsLayers[index] def linesLayer(self): """ To get the selected memory lines layer :return: selected memory lines layer, or none """ index = self.__lineCombo.currentIndex() if self.__lineCombo.itemText(index) == "": return None else: return self.__linesLayers[index] def configTable(self): """ To get the selected config table :return: selected config table, or none """ index = self.__tableCombo.currentIndex() if self.__tableCombo.itemText(index) == "": return None else: return self.__tables[index] def uriDb(self): """ To get selected import database uri :return: import database uri """ index = self.__dbCombo.currentIndex() if self.__dbCombo.itemText(index) == "": return None else: return self.__dbs[list(self.__dbs.keys())[index]] def schemaDb(self): """ To get selected import database schema :return: import database schema """ index = self.__schemaCombo.currentIndex() if self.__schemaCombo.itemText(index) == "": return None else: return self.__schemas[index] def mntUrl(self): """ To get selected MN url :return: MN url """ return self.__mntText.text() def ctlDb(self): """ To get selected control database uri :return: control database uri """ index = self.__ctlCombo.currentIndex() if self.__ctlCombo.itemText(index) == "": return None else: return self.__dbs[list(self.__dbs.keys())[index]]
class ProjectTreeColumn(QDialog): def __init__(self, parent=None): super(ProjectTreeColumn, self).__init__(parent, Qt.WindowStaysOnTopHint) vbox = QVBoxLayout(self) vbox.setSizeConstraint(QVBoxLayout.SetDefaultConstraint) vbox.setContentsMargins(0, 0, 0, 0) self._buttons = [] self._combo_project = QComboBox() self._combo_project.setMinimumHeight(30) self._combo_project.setContextMenuPolicy(Qt.CustomContextMenu) vbox.addWidget(self._combo_project) self._projects_area = QStackedLayout() logger.debug("This is the projects area") logger.debug(self._projects_area) vbox.addLayout(self._projects_area) self.projects = [] self.connect(self._combo_project, SIGNAL("currentIndexChanged(int)"), self._change_current_project) self.connect(self._combo_project, SIGNAL("customContextMenuRequested(const QPoint &)"), self.context_menu_for_root) connections = ( { 'target': 'main_container', 'signal_name': 'addToProject(QString)', 'slot': self._add_file_to_project }, { 'target': 'main_container', 'signal_name': 'showFileInExplorer(QString)', 'slot': self._show_file_in_explorer }, ) IDE.register_service('projects_explorer', self) IDE.register_signals('projects_explorer', connections) ExplorerContainer.register_tab(translations.TR_TAB_PROJECTS, self) #FIXME: Should have a ninja settings object that stores tree state #FIXME: Or bettter, application data object #TODO: check this: #self.connect(ide, SIGNAL("goingDown()"), #self.tree_projects.shutdown) #def close_project_signal(): #self.emit(SIGNAL("updateLocator()")) def install_tab(self): ide = IDE.get_service('ide') ui_tools.install_shortcuts(self, actions.PROJECTS_TREE_ACTIONS, ide) self.connect(ide, SIGNAL("goingDown()"), self.close) def load_session_projects(self, projects): for project in projects: if os.path.exists(project): self._open_project_folder(project) def open_project_folder(self, folderName=None): if settings.WORKSPACE: directory = settings.WORKSPACE else: directory = os.path.expanduser("~") if folderName is None: folderName = QFileDialog.getExistingDirectory( self, translations.TR_OPEN_PROJECT_DIRECTORY, directory) logger.debug("Choosing Foldername") if folderName: logger.debug("Opening %s" % folderName) self._open_project_folder(folderName) def _open_project_folder(self, folderName): ninjaide = IDE.get_service("ide") project = NProject(folderName) qfsm = ninjaide.filesystem.open_project(project) if qfsm: self.add_project(project) self.emit(SIGNAL("updateLocator()")) self.save_recent_projects(folderName) main_container = IDE.get_service('main_container') if main_container: main_container.show_editor_area() def _add_file_to_project(self, path): """Add the file for 'path' in the project the user choose here.""" if self._active_project: pathProject = [self._active_project.project] addToProject = add_to_project.AddToProject(pathProject, self) addToProject.exec_() if not addToProject.pathSelected: return main_container = IDE.get_service('main_container') if not main_container: return editorWidget = main_container.get_current_editor() if not editorWidget.file_path: name = QInputDialog.getText( None, translations.TR_ADD_FILE_TO_PROJECT, translations.TR_FILENAME + ": ")[0] if not name: QMessageBox.information( self, translations.TR_INVALID_FILENAME, translations.TR_INVALID_FILENAME_ENTER_A_FILENAME) return else: name = file_manager.get_basename(editorWidget.file_path) new_path = file_manager.create_path(addToProject.pathSelected, name) ide_srv = IDE.get_service("ide") old_file = ide_srv.get_or_create_nfile(path) new_file = old_file.save(editorWidget.get_text(), new_path) #FIXME: Make this file replace the original in the open tab else: pass # Message about no project def _show_file_in_explorer(self, path): '''Iterate through the list of available projects and show the current file in the explorer view for the first project that contains it (i.e. if the same file is included in multiple open projects, the path will be expanded for the first project only). Note: This slot is connected to the main container's "showFileInExplorer(QString)" signal.''' for project in self.projects: index = project.model().index(path) if index.isValid(): # Show the explorer if it is currently hidden central = IDE.get_service('central_container') if central and not central.is_lateral_panel_visible(): central.change_lateral_visibility() # This highlights the index in the tree for us project.setCurrentIndex(index) # Loop through the parents to expand the tree # all the way up to the selected index. while index.isValid(): project.expand(index) index = index.parent() break def add_project(self, project): if project not in self.projects: self._combo_project.addItem(project.name) ptree = TreeProjectsWidget(project) self._projects_area.addWidget(ptree) self.connect(ptree, SIGNAL("closeProject(PyQt_PyObject)"), self._close_project) pmodel = project.model ptree.setModel(pmodel) pindex = pmodel.index(pmodel.rootPath()) ptree.setRootIndex(pindex) self.projects.append(ptree) current_index = self._projects_area.count() self._projects_area.setCurrentIndex(current_index - 1) self._combo_project.setCurrentIndex(current_index - 1) def _close_project(self, widget): """Close the project related to the tree widget.""" index = self._projects_area.currentIndex() self.projects.remove(widget) self._projects_area.takeAt(index) self._combo_project.removeItem(index) index = self._combo_project.currentIndex() self._projects_area.setCurrentIndex(index) ninjaide = IDE.get_service('ide') ninjaide.filesystem.close_project(widget.project.path) widget.deleteLater() def _change_current_project(self, index): self._projects_area.setCurrentIndex(index) def close_opened_projects(self): for project in reversed(self.projects): self._close_project(project) def save_project(self): """Save all the opened files that belongs to the actual project.""" if self._active_project: path = self._projects_area.currentWidget().project.path main_container = IDE.get_service('main_container') if path and main_container: main_container.save_project(path) def create_new_project(self): wizard = new_project_manager.NewProjectManager(self) wizard.show() @property def current_project(self): if self._projects_area.count() > 0: return self._projects_area.currentWidget().project @property def current_tree(self): return self._projects_area.currentWidget() def save_recent_projects(self, folder): settings = IDE.data_settings() recent_project_list = settings.value('recentProjects', {}) #if already exist on the list update the date time projectProperties = json_manager.read_ninja_project(folder) name = projectProperties.get('name', '') description = projectProperties.get('description', '') if name == '': name = file_manager.get_basename(folder) if description == '': description = translations.TR_NO_DESCRIPTION if folder in recent_project_list: properties = recent_project_list[folder] properties["lastopen"] = QDateTime.currentDateTime() properties["name"] = name properties["description"] = description recent_project_list[folder] = properties else: recent_project_list[folder] = { "name": name, "description": description, "isFavorite": False, "lastopen": QDateTime.currentDateTime() } #if the length of the project list it's high that 10 then delete #the most old #TODO: add the length of available projects to setting if len(recent_project_list) > 10: del recent_project_list[self.find_most_old_open( recent_project_list)] settings.setValue('recentProjects', recent_project_list) def find_most_old_open(self, recent_project_list): listFounder = [] for recent_project_path, content in list(recent_project_list.items()): listFounder.append( (recent_project_path, int(content["lastopen"].toString("yyyyMMddHHmmzzz")))) listFounder = sorted(listFounder, key=lambda date: listFounder[1], reverse=True) # sort by date last used return listFounder[0][0] def reject(self): if self.parent() is None: self.emit(SIGNAL("dockWidget(PyQt_PyObject)"), self) def closeEvent(self, event): self.emit(SIGNAL("dockWidget(PyQt_PyObject)"), self) event.ignore() def context_menu_for_root(self): menu = QMenu(self) path = self.current_tree.project.path action_add_file = menu.addAction(QIcon(":img/new"), translations.TR_ADD_NEW_FILE) action_add_folder = menu.addAction(QIcon(":img/openProj"), translations.TR_ADD_NEW_FOLDER) action_create_init = menu.addAction(translations.TR_CREATE_INIT) self.connect(action_add_file, SIGNAL("triggered()"), lambda: self.current_tree._add_new_file(path)) self.connect(action_add_folder, SIGNAL("triggered()"), lambda: self.current_tree._add_new_folder(path)) self.connect(action_create_init, SIGNAL("triggered()"), lambda: self.current_tree._create_init(path)) menu.addSeparator() actionRunProject = menu.addAction(QIcon(":img/play"), translations.TR_RUN_PROJECT) self.connect(actionRunProject, SIGNAL("triggered()"), self.current_tree._execute_project) if self.current_tree._added_to_console: actionRemoveFromConsole = menu.addAction( translations.TR_REMOVE_PROJECT_FROM_PYTHON_CONSOLE) self.connect(actionRemoveFromConsole, SIGNAL("triggered()"), self.current_tree._remove_project_from_console) else: actionAdd2Console = menu.addAction( translations.TR_ADD_PROJECT_TO_PYTHON_CONSOLE) self.connect(actionAdd2Console, SIGNAL("triggered()"), self.current_tree._add_project_to_console) actionShowFileSizeInfo = menu.addAction(translations.TR_SHOW_FILESIZE) self.connect(actionShowFileSizeInfo, SIGNAL("triggered()"), self.current_tree.show_filesize_info) actionProperties = menu.addAction(QIcon(":img/pref"), translations.TR_PROJECT_PROPERTIES) self.connect(actionProperties, SIGNAL("triggered()"), self.current_tree.open_project_properties) menu.addSeparator() action_close = menu.addAction( self.style().standardIcon(QStyle.SP_DialogCloseButton), translations.TR_CLOSE_PROJECT) self.connect(action_close, SIGNAL("triggered()"), self.current_tree._close_project) #menu for the project for m in self.current_tree.extra_menus_by_scope['project']: if isinstance(m, QMenu): menu.addSeparator() menu.addMenu(m) #show the menu! menu.exec_(QCursor.pos())
class ShowSettingsDialog(QDialog): """ Dialog class for plugin settings """ def __init__(self, iface, configTable, uriDb, schemaDb): """ Constructor :param iface: interface :param memoryPointsLayer: working memory points layer :param memoryLinesLayer: working memory lines layer :param configTable: config table selected for import """ QDialog.__init__(self) self.__iface = iface self.__configTable = configTable self.__uriDb = uriDb self.__schemaDb = schemaDb self.setWindowTitle( QCoreApplication.translate("VDLNetwork", "Settings")) self.__tables = [] self.__schemas = [] self.__dbs = DBConnector.getUsedDatabases() self.resize(450, 200) self.__layout = QGridLayout() dbLabel = QLabel( QCoreApplication.translate("VDLNetwork", "Control database : ")) dbLabel.setMinimumHeight(20) dbLabel.setMinimumWidth(50) self.__layout.addWidget(dbLabel, 0, 1) self.__dbCombo = QComboBox() self.__dbCombo.setMinimumHeight(20) self.__dbCombo.setMinimumWidth(50) self.__dbCombo.addItem("") for db in list(self.__dbs.keys()): self.__dbCombo.addItem(db) self.__layout.addWidget(self.__dbCombo, 0, 2) schemaLabel = QLabel( QCoreApplication.translate("VDLNetwork", "Control schema : ")) schemaLabel.setMinimumHeight(20) schemaLabel.setMinimumWidth(50) self.__layout.addWidget(schemaLabel, 1, 1) self.__schemaCombo = QComboBox() self.__schemaCombo.setMinimumHeight(20) self.__schemaCombo.setMinimumWidth(50) self.__schemaCombo.addItem("") self.__layout.addWidget(self.__schemaCombo, 1, 2) tableLabel = QLabel( QCoreApplication.translate("VDLNetwork", "Control table : ")) tableLabel.setMinimumHeight(20) tableLabel.setMinimumWidth(50) self.__layout.addWidget(tableLabel, 2, 1) self.__tableCombo = QComboBox() self.__tableCombo.setMinimumHeight(20) self.__tableCombo.setMinimumWidth(50) self.__tableCombo.addItem("") self.__layout.addWidget(self.__tableCombo, 2, 2) self.__okButton = QPushButton( QCoreApplication.translate("VDLNetwork", "OK")) self.__okButton.setMinimumHeight(20) self.__okButton.setMinimumWidth(100) self.__cancelButton = QPushButton( QCoreApplication.translate("VDLNetwork", "Cancel")) self.__cancelButton.setMinimumHeight(20) self.__cancelButton.setMinimumWidth(100) self.__layout.addWidget(self.__okButton, 100, 1) self.__layout.addWidget(self.__cancelButton, 100, 2) self.setLayout(self.__layout) self.__dbCombo.currentIndexChanged.connect(self.__dbComboChanged) self.__schemaCombo.currentIndexChanged.connect( self.__schemaComboChanged) self.__tableCombo.currentIndexChanged.connect(self.__tableComboChanged) if self.__uriDb is not None: if self.__uriDb.database() in list(self.__dbs.keys()): self.__dbCombo.setCurrentIndex( list(self.__dbs.keys()).index(self.__uriDb.database()) + 1) @staticmethod def __resetCombo(combo): """ To reset a combo list :param combo: concerned combo """ while combo.count() > 0: combo.removeItem(combo.count() - 1) def __setSchemaCombo(self, uriDb): """ To fill the schema combo list :param uriDb: selected database uri """ connector = DBConnector(uriDb, self.__iface) db = connector.setConnection() if db: Signal.safelyDisconnect(self.__schemaCombo.currentIndexChanged, self.__schemaComboChanged) self.__resetCombo(self.__schemaCombo) self.__schemaCombo.addItem("") self.__schemas = [] query = db.exec_( """SELECT DISTINCT table_schema FROM information_schema.tables WHERE table_schema NOT IN ('pg_catalog', 'information_schema', 'topology') AND table_type = 'BASE TABLE' AND table_name NOT IN (SELECT f_table_name FROM geometry_columns)""") if query.lastError().isValid(): self.__iface.messageBar().pushMessage( query.lastError().text(), level=QgsMessageBar.CRITICAL, duration=0) else: while next(query): self.__schemas.append(query.value(0)) db.close() for schema in self.__schemas: self.__schemaCombo.addItem(schema) self.__schemaCombo.currentIndexChanged.connect( self.__schemaComboChanged) if self.__schemaDb is not None: if self.__schemaDb in self.__schemas: self.__schemaCombo.setCurrentIndex( self.__schemas.index(self.__schemaDb) + 1) def __setTableCombo(self, uriDb, schema): """ To fill the table combo list :param uriDb: selected database uri :param schema: selected database schema """ connector = DBConnector(uriDb, self.__iface) db = connector.setConnection() if db: Signal.safelyDisconnect(self.__tableCombo.currentIndexChanged, self.__tableComboChanged) self.__resetCombo(self.__tableCombo) self.__tableCombo.addItem("") self.__tables = [] query = db.exec_( """SELECT table_name FROM information_schema.tables WHERE table_schema = '""" + schema + """' ORDER BY table_name""") if query.lastError().isValid(): self.__iface.messageBar().pushMessage( query.lastError().text(), level=QgsMessageBar.CRITICAL, duration=0) else: while next(query): self.__tables.append(query.value(0)) db.close() for table in self.__tables: if self.__tableCombo.findText(table) == -1: self.__tableCombo.addItem(table) self.__tableCombo.currentIndexChanged.connect( self.__tableComboChanged) if self.__configTable is not None: if self.__configTable in self.__tables: self.__tableCombo.setCurrentIndex( self.__tables.index(self.__configTable) + 1) def __tableComboChanged(self): """ To remove blank item when another one is selected """ if self.__tableCombo.itemText(0) == "": self.__tableCombo.removeItem(0) def __dbComboChanged(self): """ When the selection in db combo has changed """ if self.__dbCombo.itemText(0) == "": self.__dbCombo.removeItem(0) if self.uriDb() is not None: self.__setSchemaCombo(self.uriDb()) def __schemaComboChanged(self): """ When the selection in schema combo has changed """ if self.__schemaCombo.itemText(0) == "": self.__schemaCombo.removeItem(0) if self.schemaDb() is not None: self.__setTableCombo(self.uriDb(), self.schemaDb()) def okButton(self): """ To get the ok button instance :return: ok button instance """ return self.__okButton def cancelButton(self): """ To get the cancel button instance :return: cancel button instance """ return self.__cancelButton def configTable(self): """ To get the selected config table :return: selected config table, or none """ index = self.__tableCombo.currentIndex() if self.__tableCombo.itemText(index) == "": return None else: return self.__tables[index] def uriDb(self): """ To get selected import database uri :return: import database uri """ index = self.__dbCombo.currentIndex() if self.__dbCombo.itemText(index) == "": return None else: return self.__dbs[list(self.__dbs.keys())[index]] def schemaDb(self): """ To get selected import database schema :return: import database schema """ index = self.__schemaCombo.currentIndex() if self.__schemaCombo.itemText(index) == "": return None else: return self.__schemas[index]
def addGuiItem(self, ParentClass, parameters, width): """Defines a new set of Label and a box that can be a ComboBox, RComboBox, LineEdit, TextEdit or DoubleSpinBox.""" widgetType=parameters[1] #check if there are default values: if len(parameters)>2: default=parameters[2] else: default="" skip = False notnull=parameters[3] #setting the right type of widget if widgetType=="comboBox": widget = QComboBox(ParentClass) widget.addItems(default.split(';')) widget.setFixedHeight(26) elif widgetType=="RComboBox": widget = RComboBox(ParentClass, default.split(';')) widget.setFixedHeight(26) self.hasRComboBox = True widget.setEditable(True) elif widgetType=="RListWidget": widget = RListWidget(ParentClass, default.split(';'), notnull) widget.setMinimumHeight(116) self.hasRComboBox = True widget.setSelectionMode( QAbstractItemView.ExtendedSelection) elif widgetType=="doubleSpinBox": widget = QDoubleSpinBox(ParentClass) widget.setValue(float(default)) widget.setFixedHeight(26) widget.setMaximum(999999.9999) widget.setDecimals(4) elif widgetType=="textEdit": widget = QTextEdit(ParentClass) widget.setPlainText(default) widget.setMinimumHeight(116) elif widgetType=="helpString": self.helpString = default skip = True else: #if unknown assumes lineEdit widget = QLineEdit(ParentClass) widget.setText(default) widget.setFixedHeight(26) if not skip: hbox = QHBoxLayout() name="widget"+unicode(self.widgetCounter) widget.setObjectName(name) widget.setMinimumWidth(250) self.widgets.append(widget) name="label"+unicode(self.widgetCounter) self.widgetCounter += 1 label = QLabel(ParentClass) label.setObjectName(name) label.setFixedWidth(width*8) label.setText(parameters[0]) hbox.addWidget(label) hbox.addWidget(widget) self.vbox.addLayout(hbox)
class ImportJobsDialog(QDialog): def __init__(self, jobs): """ Constructor :param jobs: all the jobs available for import """ QDialog.__init__(self) self.__jobs = jobs self.setWindowTitle( QCoreApplication.translate("VDLTools", "Choose job")) self.resize(300, 100) self.__layout = QGridLayout() self.__okButton = QPushButton( QCoreApplication.translate("VDLTools", "OK")) self.__okButton.setMinimumHeight(20) self.__okButton.setMinimumWidth(100) self.__cancelButton = QPushButton( QCoreApplication.translate("VDLTools", "Cancel")) self.__cancelButton.setMinimumHeight(20) self.__cancelButton.setMinimumWidth(100) self.__layout.addWidget(self.__okButton, 100, 1) self.__layout.addWidget(self.__cancelButton, 100, 2) label = QLabel(QCoreApplication.translate("VDLTools", "Job : ")) label.setMinimumHeight(20) label.setMinimumWidth(50) self.__layout.addWidget(label, 0, 1) self.__jobCombo = QComboBox() self.__jobCombo.setMinimumHeight(20) self.__jobCombo.setMinimumWidth(50) self.__jobCombo.addItem("") for job in self.__jobs: self.__jobCombo.addItem(job) self.__layout.addWidget(self.__jobCombo, 0, 2) self.__jobCombo.currentIndexChanged.connect(self.__jobComboChanged) self.setLayout(self.__layout) def __jobComboChanged(self): """ When the selected job has changed """ if self.__pointCombo.itemText(0) == "": self.__pointCombo.removeItem(0) def okButton(self): """ To get the ok button instance :return: ok button instance """ return self.__okButton def cancelButton(self): """ To get the cancel button instance :return: cancel button instance """ return self.__cancelButton def job(self): """ To get the selected job :return: selected job """ index = self.__jobCombo.currentIndex() if self.__jobCombo.itemText(index) == "": return None else: return self.__jobs[index]