def set_widgets_into_composer(self, dialog, field, my_json=None): widget = None label = None if field['label']: label = QLabel() label.setObjectName('lbl_' + field['widgetname']) label.setText(field['label'].capitalize()) if field['stylesheet'] is not None and 'label' in field['stylesheet']: label = set_setStyleSheet(field, label) if 'tooltip' in field: label.setToolTip(field['tooltip']) else: label.setToolTip(field['label'].capitalize()) if field['widgettype'] == 'text' or field['widgettype'] == 'typeahead': widget = add_lineedit(field) widget = set_widget_size(widget, field) widget = set_data_type(field, widget) widget.editingFinished.connect(partial(get_values, dialog, widget, my_json)) widget.returnPressed.connect(partial(get_values, dialog, widget, my_json)) elif field['widgettype'] == 'combo': widget = add_combobox(field) widget = set_widget_size(widget, field) widget.currentIndexChanged.connect(partial(get_values, dialog, widget, my_json)) if 'widgetfunction' in field: if field['widgetfunction'] is not None: function_name = field['widgetfunction'] # Call def set_print(self, dialog, my_json): of the class ApiManageComposer widget.currentIndexChanged.connect(partial(getattr(self, function_name), dialog, my_json)) return label, widget
def _set_widgets(self, dialog, db_return, field): widget = None label = None if field['label']: label = QLabel() label.setObjectName('lbl_' + field['widgetname']) label.setText(field['label'].capitalize()) if 'stylesheet' in field and field[ 'stylesheet'] is not None and 'label' in field[ 'stylesheet']: label = tools_gw.set_stylesheet(field, label) if 'tooltip' in field: label.setToolTip(field['tooltip']) else: label.setToolTip(field['label'].capitalize()) if field['widgettype'] == 'text' or field['widgettype'] == 'typeahead': completer = QCompleter() widget = tools_gw.add_lineedit(field) widget = tools_gw.set_widget_size(widget, field) widget = tools_gw.set_data_type(field, widget) if field['widgettype'] == 'typeahead': widget = tools_gw.set_typeahead(field, dialog, widget, completer) elif field['widgettype'] == 'combo': widget = tools_gw.add_combo(field) widget = tools_gw.set_widget_size(widget, field) elif field['widgettype'] == 'check': widget = tools_gw.add_checkbox(field) elif field['widgettype'] == 'datetime': widget = tools_gw.add_calendar(dialog, field) elif field['widgettype'] == 'button': widget = tools_gw.add_button(dialog, field) widget = tools_gw.set_widget_size(widget, field) elif field['widgettype'] == 'hyperlink': widget = tools_gw.add_hyperlink(field) widget = tools_gw.set_widget_size(widget, field) elif field['widgettype'] == 'hspacer': widget = tools_qt.add_horizontal_spacer() elif field['widgettype'] == 'vspacer': widget = tools_qt.add_verticalspacer() elif field['widgettype'] == 'textarea': widget = tools_gw.add_textarea(field) elif field['widgettype'] in 'spinbox': widget = tools_gw.add_spinbox(field) elif field['widgettype'] == 'tableview': widget = tools_gw.add_tableview(db_return, field) widget = tools_gw.add_tableview_header(widget, field) widget = tools_gw.fill_tableview_rows(widget, field) widget = tools_gw.set_tablemodel_config(dialog, widget, field['widgetname'], sort_order=1, isQStandardItemModel=True) tools_qt.set_tableview_config(widget) widget.setObjectName(widget.property('columnname')) return label, widget
def set_widgets(self, dialog, db_return, field): widget = None label = None if field['label']: label = QLabel() label.setObjectName('lbl_' + field['widgetname']) label.setText(field['label'].capitalize()) if field['stylesheet'] is not None and 'label' in field[ 'stylesheet']: label = self.set_setStyleSheet(field, label) if 'tooltip' in field: label.setToolTip(field['tooltip']) else: label.setToolTip(field['label'].capitalize()) if field['widgettype'] == 'text' or field['widgettype'] == 'typeahead': completer = QCompleter() widget = self.add_lineedit(field) widget = self.set_widget_size(widget, field) widget = self.set_data_type(field, widget) if field['widgettype'] == 'typeahead': widget = self.manage_lineedit(field, dialog, widget, completer) elif field['widgettype'] == 'combo': widget = self.add_combobox(field) widget = self.set_widget_size(widget, field) elif field['widgettype'] == 'check': widget = self.add_checkbox(field) elif field['widgettype'] == 'datetime': widget = self.add_calendar(dialog, field) elif field['widgettype'] == 'button': widget = self.add_button(dialog, field) widget = self.set_widget_size(widget, field) elif field['widgettype'] == 'hyperlink': widget = self.add_hyperlink(field) widget = self.set_widget_size(widget, field) elif field['widgettype'] == 'hspacer': widget = self.add_horizontal_spacer() elif field['widgettype'] == 'vspacer': widget = self.add_verical_spacer() elif field['widgettype'] == 'textarea': widget = self.add_textarea(field) elif field['widgettype'] in ('spinbox'): widget = self.add_spinbox(field) elif field['widgettype'] == 'tableview': widget = self.add_tableview(db_return, field) widget = self.set_headers(widget, field) widget = self.populate_table(widget, field) widget = self.set_columns_config(widget, field['widgetname'], sort_order=1, isQStandardItemModel=True) utils_giswater.set_qtv_config(widget) widget.setObjectName(widget.property('columnname')) return label, widget
class Ui_GHydraulicsResultDialog(object): def setupUi(self, GHydraulicsResultDialog): GHydraulicsResultDialog.setObjectName(_fromUtf8("GHydraulicsResultDialog")) GHydraulicsResultDialog.resize(640, 480) self.buttonBox = QDialogButtonBox(GHydraulicsResultDialog) self.buttonBox.setGeometry(QtCore.QRect(10, 440, 620, 32)) self.buttonBox.setOrientation(QtCore.Qt.Horizontal) self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel|QDialogButtonBox.Ok) self.buttonBox.setObjectName(_fromUtf8("buttonBox")) self.tabWidget = QTabWidget(GHydraulicsResultDialog) self.tabWidget.setGeometry(QtCore.QRect(10, 10, 620, 390)) self.tabWidget.setObjectName(_fromUtf8("tabWidget")) self.tabOutput = QWidget() self.tabOutput.setObjectName(_fromUtf8("tabOutput")) self.textOutput = QTextBrowser(self.tabOutput) self.textOutput.setGeometry(QtCore.QRect(10, 10, 600, 340)) sizePolicy = QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.textOutput.sizePolicy().hasHeightForWidth()) self.textOutput.setSizePolicy(sizePolicy) self.textOutput.setObjectName(_fromUtf8("textOutput")) self.tabWidget.addTab(self.tabOutput, _fromUtf8("")) self.tabReport = QWidget() self.tabReport.setObjectName(_fromUtf8("tabReport")) self.textReport = QTextBrowser(self.tabReport) self.textReport.setGeometry(QtCore.QRect(10, 10, 600, 340)) sizePolicy = QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.textReport.sizePolicy().hasHeightForWidth()) self.textReport.setSizePolicy(sizePolicy) self.textReport.setObjectName(_fromUtf8("textReport")) self.tabWidget.addTab(self.tabReport, _fromUtf8("")) self.comboStep = QComboBox(GHydraulicsResultDialog) self.comboStep.setGeometry(QtCore.QRect(150, 410, 80, 27)) self.comboStep.setObjectName(_fromUtf8("comboStep")) self.labelStep = QLabel(GHydraulicsResultDialog) self.labelStep.setGeometry(QtCore.QRect(10, 415, 120, 17)) self.labelStep.setObjectName(_fromUtf8("labelStep")) self.retranslateUi(GHydraulicsResultDialog) self.tabWidget.setCurrentIndex(0) #QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL(_fromUtf8("accepted()")), GHydraulicsResultDialog.accept) self.buttonBox.accepted.connect(GHydraulicsResultDialog.accept) #QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL(_fromUtf8("rejected()")), GHydraulicsResultDialog.reject) self.buttonBox.rejected.connect(GHydraulicsResultDialog.reject) QtCore.QMetaObject.connectSlotsByName(GHydraulicsResultDialog) def retranslateUi(self, GHydraulicsResultDialog): GHydraulicsResultDialog.setWindowTitle(_translate("GHydraulicsResultDialog", "EPANET Results", None)) self.tabWidget.setTabText(self.tabWidget.indexOf(self.tabOutput), _translate("GHydraulicsResultDialog", "EPANET Output", None)) self.tabWidget.setTabText(self.tabWidget.indexOf(self.tabReport), _translate("GHydraulicsResultDialog", "Report", None)) self.labelStep.setText(_translate("GHydraulicsResultDialog", "Load time step", None))
def api_search(self): # Dialog self.dlg_search = ApiSearchUi() self.load_settings(self.dlg_search) self.dlg_search.lbl_msg.setStyleSheet("QLabel{color:red;}") self.dlg_search.lbl_msg.setVisible(False) # Make it dockable in left dock widget area self.iface.addDockWidget(Qt.LeftDockWidgetArea, self.dlg_search) body = self.create_body() function_name = "gw_api_getsearch" row = self.controller.execute_api_function(function_name, body) if not row: return False complet_list = [json.loads(row[0], object_pairs_hook=OrderedDict)] main_tab = self.dlg_search.findChild(QTabWidget, 'main_tab') first_tab = None self.lineedit_list = [] for tab in complet_list[0]["form"]: if first_tab is None: first_tab = tab['tabName'] tab_widget = QWidget(main_tab) tab_widget.setObjectName(tab['tabName']) main_tab.addTab(tab_widget, tab['tabtext']) gridlayout = QGridLayout() tab_widget.setLayout(gridlayout) x = 0 for field in tab['fields']: label = QLabel() label.setObjectName('lbl_' + field['label']) label.setText(field['label'].capitalize()) if field['widgettype'] == 'typeahead': completer = QCompleter() widget = self.add_lineedit(field) widget = self.set_completer(widget, completer) self.lineedit_list.append(widget) elif field['widgettype'] == 'combo': widget = self.add_combobox(field) gridlayout.addWidget(label, x, 0) gridlayout.addWidget(widget, x, 1) x += 1 vertical_spacer1 = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding) gridlayout.addItem(vertical_spacer1) self.dlg_search.dlg_closed.connect(self.rubber_polygon.reset)
def _set_widgets_into_composer(self, dialog, field, my_json=None): """ functions called in -> widget.currentIndexChanged.connect(partial(getattr(self, function_name), dialog, my_json)) def set_print(self, dialog, my_json) """ widget = None label = None if field['label']: label = QLabel() label.setObjectName('lbl_' + field['widgetname']) label.setText(field['label'].capitalize()) if 'stylesheet' in field and field[ 'stylesheet'] is not None and 'label' in field[ 'stylesheet']: label = tools_gw.set_stylesheet(field, label) if 'tooltip' in field: label.setToolTip(field['tooltip']) else: label.setToolTip(field['label'].capitalize()) if field['widgettype'] == 'text' or field['widgettype'] == 'typeahead': widget = tools_gw.add_lineedit(field) widget = tools_gw.set_widget_size(widget, field) widget = tools_gw.set_data_type(field, widget) widget.editingFinished.connect( partial(tools_gw.get_values, dialog, widget, my_json)) widget.returnPressed.connect( partial(tools_gw.get_values, dialog, widget, my_json)) elif field['widgettype'] == 'combo': widget = tools_gw.add_combo(field) widget = tools_gw.set_widget_size(widget, field) widget.currentIndexChanged.connect( partial(tools_gw.get_values, dialog, widget, my_json)) if 'widgetfunction' in field: if field['widgetfunction']['functionName'] is not None: function_name = field['widgetfunction']['functionName'] widget.currentIndexChanged.connect( partial(getattr(self, function_name), dialog, my_json)) return label, widget
def get_missing_layers(self, dialog, m_layers, critical_level): grl_critical = dialog.findChild(QGridLayout, "grl_critical") grl_others = dialog.findChild(QGridLayout, "grl_others") for pos, item in enumerate(m_layers): try: if not item: continue widget = dialog.findChild(QCheckBox, f"{item['layer']}") # If it is the case that a layer is necessary for two functions, # and the widget has already been put in another iteration if widget: continue label = QLabel() label.setObjectName(f"lbl_{item['layer']}") label.setText( f'<b>{item["layer"]}</b><font size="2";> {item["qgis_message"]}</font>' ) critical_level = int(item['criticity']) if int( item['criticity']) > critical_level else critical_level widget = QCheckBox() widget.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) widget.setObjectName(f"{item['layer']}") if int(item['criticity']) == 3: grl_critical.addWidget(label, pos, 0) grl_critical.addWidget(widget, pos, 1) else: grl_others.addWidget(label, pos, 0) grl_others.addWidget(widget, pos, 1) except KeyError: description = "Key on returned json from ddbb is missed" self.controller.manage_exception(None, description) return critical_level
class ParamDxf2Rfu(QWidget, gui_dlg_dxf2rfu): send_nw_params = pyqtSignal(dict) def __init__(self, dwg_lyrs, dwg_blocks, typo_nature_som, typo_nature_lim, precision_class, auth_creator, user, parent=None): super(ParamDxf2Rfu, self).__init__(parent) self.setupUi(self) # Initialization of the closing method (False= quit by red cross) self.quit_valid = False self.param_dxf = {} self.valid_btn.clicked.connect(self.butt_ok) # Delete Widget on close event.. # self.setAttribute(Qt.WA_DeleteOnClose, True) # Load the original parameters try: self.params_path = os.path.join(os.path.dirname(__file__), r"import_dxf2rfu_param.json") except IOError as error: raise error with codecs.open(self.params_path, encoding='utf-8', mode='r') as json_file: self.json_params = json.load(json_file) self.old_params = self.json_params[r"dxfparams"] # Manage delim_pub_chk text self.delim_pub_chk.stateChanged.connect(self.settext_delim_pub_chk) # Create sorted list of the names of dwg layers self.dwg_lyrs = dwg_lyrs lyr_names = [] for lyr in self.dwg_lyrs: lyr_names.append(str(lyr.name)) lyr_names.sort() # Create sorted list of the names of blocks self.dwg_blocks = dwg_blocks blk_names = [] for blk_def in self.dwg_blocks: if len(blk_def.name) > 0: if (not blk_def.is_xref) and (not blk_def.is_anonymous) and blk_def.name[0] != '*': blk_names.append(str(blk_def.name)) blk_names.sort() self.typo_nature_som = typo_nature_som self.typo_nature_lim = typo_nature_lim self.precision_class = precision_class self.auth_creator = auth_creator self.user = user # Fill the delim_pub checkbox if "delim_pub" in self.old_params: if self.old_params["delim_pub"] == 'true': self.delim_pub_chk.setChecked(True) else: self.delim_pub_chk.setChecked(False) # Populate createur list creat_param = False for i, e in enumerate(self.auth_creator): self.createur_cmb.addItem("%s (%s)" % (e[1], e[0])) # Find the creator in the params if "createur" in self.old_params: if self.old_params["createur"] == e[0]: self.createur_cmb.setCurrentIndex(i) creat_param = True # Set current user as the creator by default if self.user == e[0] and not creat_param: self.createur_cmb.setCurrentIndex(i) # Populate the precision class list prec_class_dft = None prec_class_curidx = 0 prec_class_dft_exist = False if "prec_class" in self.old_params: prec_class_dft = self.old_params["prec_class"] for (idx, prec_val) in enumerate(self.precision_class): if prec_class_dft == self.precision_class[idx][1]: prec_class_curidx = idx prec_class_dft_exist = True if not prec_class_dft_exist: self.precision_class_cmb.addItem(prec_class_dft) self.precision_class_cmb.setItemData(0, QColor("red"), Qt.TextColorRole) for prec_class in self.precision_class: self.precision_class_cmb.addItem(prec_class[1]) self.precision_class_cmb.setCurrentIndex(prec_class_curidx) # Populate the layer list (for vertices) vtx_lyr_dft = None vtx_curidx = 0 if "vtx_lyr" in self.old_params: vtx_lyr_dft = self.old_params["vtx_lyr"] else: vtx_lyr_dft = "0" if vtx_lyr_dft in lyr_names: vtx_curidx = lyr_names.index(vtx_lyr_dft) else: self.vtx_lyr_cmb.addItem(vtx_lyr_dft) self.vtx_lyr_cmb.setItemData(0, QColor("red"), Qt.TextColorRole) for lyr_name in lyr_names: self.vtx_lyr_cmb.addItem(lyr_name) self.vtx_lyr_cmb.setCurrentIndex(vtx_curidx) # Populate the different types of points for idx, pt_type in enumerate (self.typo_nature_som): self.symb_corr_lab = QLabel(self.pt_type_gpb) sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.symb_corr_lab.sizePolicy().hasHeightForWidth()) self.symb_corr_lab.setSizePolicy(sizePolicy) self.symb_corr_lab.setAlignment(Qt.AlignRight | Qt.AlignVCenter) self.symb_corr_lab.setMinimumSize(QSize(160, 25)) self.symb_corr_lab.setMaximumSize(QSize(160, 25)) self.symb_corr_lab.setObjectName("symb_corr_lab" + str(idx)) self.symb_corr_lab.setText(str(pt_type)) self.corr_grid_lay.addWidget(self.symb_corr_lab, (idx), 0, 1, 1) self.symb_corr_cmb = QComboBox(self.pt_type_gpb) self.symb_corr_cmb.setMinimumSize(QSize(0, 25)) self.symb_corr_cmb.setMaximumSize(QSize(16777215, 25)) self.symb_corr_cmb.setObjectName("symb_corr_cmb" + str(idx)) self.corr_grid_lay.addWidget(self.symb_corr_cmb, (idx), 1, 1, 1) self.cur_cmb = self.findChild(QComboBox, "symb_corr_cmb" + str(idx)) # Manage the background color of the comboboxes self.cur_cmb.currentTextChanged.connect(partial(self.chk_cmb_bkgrd, self.cur_cmb)) # Add specific values (all block and no none block) self.cur_cmb.addItem(no_blk) self.cur_cmb.setItemData(0, QColor(111,111,111), Qt.TextColorRole) self.cur_cmb.addItem(all_blks) self.cur_cmb.setItemData(1, QColor(42,195,124), Qt.TextColorRole) blk_dft = None blk_curidx = 0 # Manage v2.1 new config.json structure if "blk_corrs" in self.old_params: blks_params = self.old_params["blk_corrs"] # Manage old config.json structure else: blks_params = self.old_params # Find the correct param if str(pt_type) in blks_params: blk_dft = blks_params[str(pt_type)] if blk_dft in blk_names : blk_curidx = blk_names.index(blk_dft) + 2 else: if blk_dft == no_blk: blk_curidx = 0 elif blk_dft == all_blks: blk_curidx = 1 else: self.cur_cmb.addItem(blk_dft) blk_curidx = 2 self.cur_cmb.setItemData(2, QColor("red"), Qt.TextColorRole) for blk_name in blk_names: self.cur_cmb.addItem(blk_name) self.cur_cmb.setCurrentIndex(blk_curidx) sp_item1 = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding) self.corr_grid_lay.addItem(sp_item1, (idx + 1), 0, 1, 1) # Adapt the size of the dlg self.pt_type_gpb.setMinimumSize(QSize(470, 56+29*(idx+1))) # Populate the different types of limits for idx, lim_type in enumerate (self.typo_nature_lim): self.lim_corr_lab = QLabel(self.lim_type_gpb) sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.lim_corr_lab.sizePolicy().hasHeightForWidth()) self.lim_corr_lab.setSizePolicy(sizePolicy) self.lim_corr_lab.setAlignment(Qt.AlignRight | Qt.AlignVCenter) self.lim_corr_lab.setMinimumSize(QSize(160, 25)) self.lim_corr_lab.setMaximumSize(QSize(160, 25)) self.lim_corr_lab.setObjectName("lim_corr_lab" + str(idx)) self.lim_corr_lab.setText(str(lim_type)) self.lim_grid_lay.addWidget(self.lim_corr_lab, (idx), 0, 1, 1) self.lim_corr_cmb = QComboBox(self.lim_type_gpb) self.lim_corr_cmb.setMinimumSize(QSize(0, 25)) self.lim_corr_cmb.setMaximumSize(QSize(16777215, 25)) self.lim_corr_cmb.setObjectName("lim_corr_cmb" + str(idx)) self.lim_grid_lay.addWidget(self.lim_corr_cmb, (idx), 1, 1, 1) self.cur_cmb = self.findChild(QComboBox, "lim_corr_cmb" + str(idx)) # Manage the background color of the comboboxes self.cur_cmb.currentTextChanged.connect(partial(self.chk_cmb_bkgrd, self.cur_cmb)) # Add specific value (none layer) self.cur_cmb.addItem(no_lyr) self.cur_cmb.setItemData(0, QColor(111,111,111), Qt.TextColorRole) lyr_dft = None lyr_cur_idx = 0 # Manage v2.1 new config.json structure if "lim_lyrs" in self.old_params: lim_lyrs_params = self.old_params["lim_lyrs"] # Manage old config.json structure else: lim_lyrs_params = self.old_params # Find the correct param if str(lim_type) in lim_lyrs_params: lyr_dft = lim_lyrs_params[str(lim_type)] else: lyr_dft = "0" if lyr_dft in lyr_names: lyr_cur_idx = lyr_names.index(lyr_dft) + 1 else: if lyr_dft == no_lyr: lyr_cur_idx = 0 else: self.cur_cmb.addItem(lyr_dft) lyr_cur_idx = 1 self.cur_cmb.setItemData(1, QColor("red"), Qt.TextColorRole) for lyr_name in lyr_names: self.cur_cmb.addItem(lyr_name) self.cur_cmb.setCurrentIndex(lyr_cur_idx) sp_item2 = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding) self.lim_grid_lay.addItem(sp_item2, (idx + 1), 0, 1, 1) # Adapt the size of the dlg self.lim_type_gpb.setMinimumSize(QSize(470, 56+29*(idx+1))) # Change the text of the delim_pub checkbox def settext_delim_pub_chk(self): if self.delim_pub_chk.isChecked(): self.delim_pub_chk.setText('oui') else: self.delim_pub_chk.setText('non') # Manage the background color of comboboxes # (depends on the color of the current item) # And the all block sate -> only one block combobox with this state def chk_cmb_bkgrd(self, combo): sel_col = "QComboBox QAbstractItemView {selection-background-color: lightgray;}" std_bkg_col = "QComboBox:on {background-color: rgb(240, 240, 240);}" if combo.itemData(combo.currentIndex(), Qt.TextColorRole) == QColor("red"): css = "QComboBox {background-color: rgb(255, 189, 189);}" + sel_col + std_bkg_col combo.setStyleSheet(css) elif combo.itemData(combo.currentIndex(), Qt.TextColorRole) == QColor(42,195,124): css = "QComboBox {background-color: rgb(208, 255, 222);}" + sel_col + std_bkg_col combo.setStyleSheet(css) for idx, pt_type in enumerate(self.typo_nature_som): type_cmb = self.findChild(QComboBox, "symb_corr_cmb" + str(idx)) if type_cmb: if type_cmb != combo: type_cmb.setCurrentText(no_blk) elif combo.itemData(combo.currentIndex(), Qt.TextColorRole) == QColor(111,111,111): css = "QComboBox {background-color: rgb(144, 144, 144);}" + sel_col + std_bkg_col combo.setStyleSheet(css) else: css = "" combo.setStyleSheet(css) # Deactivate the all_blks combobox if another combox is used change = False for idx, pt_type in enumerate(self.typo_nature_som): type_cmb = self.findChild(QComboBox, "symb_corr_cmb" + str(idx)) if type_cmb: if type_cmb.currentText() != all_blks and type_cmb.currentText() != no_blk: change = True if change: for idx, pt_type in enumerate(self.typo_nature_som): type_cmb = self.findChild(QComboBox, "symb_corr_cmb" + str(idx)) if type_cmb: if type_cmb.currentText() == all_blks: type_cmb.setCurrentText(no_blk) # Close the window when clicking on the OK button def butt_ok(self): self.quit_valid = True self.close() # Send the parameters when the windows is quit def closeEvent(self, event): if self.quit_valid: # Save the different parameters self.param_dxf["createur"] = self.createur_cmb.currentText()[-6:-1] self.param_dxf["vtx_lyr"] = self.vtx_lyr_cmb.currentText() self.param_dxf["prec_class"] = self.precision_class_cmb.currentText() # Transform the delim_pub checkbox into the correct value self.param_dxf["delim_pub"] = chkbox_to_truefalse(self.delim_pub_chk) blk_def = {} for idx, pt_type in enumerate(self.typo_nature_som): type_cmb = self.findChild(QComboBox, "symb_corr_cmb" + str(idx)) blk_def[str(pt_type)] = str(type_cmb.currentText()) self.param_dxf["blk_corrs"] = blk_def lim_def = {} for idx, lim_type in enumerate(self.typo_nature_lim): type_cmb = self.findChild(QComboBox, "lim_corr_cmb" + str(idx)) lim_def[str(lim_type)] = str(type_cmb.currentText()) self.param_dxf["lim_lyrs"] = lim_def self.hide() # Update the new parameters in the json file json_params = {} json_params["dxfparams"] = self.param_dxf with codecs.open(self.params_path, encoding='utf-8', mode='w') as json_file: json_file.write(json.dumps(json_params, indent=4, separators=(',', ': '), ensure_ascii=False)) # Send the parameters self.send_nw_params.emit(self.param_dxf) else: # Hide the window self.hide()
def api_catalog(self, previous_dialog, widget_name, geom_type, feature_type): # Manage if geom_type is gully and set grate if geom_type == 'gully': geom_type == 'grate' form_name = 'upsert_catalog_' + geom_type + '' form = f'"formName":"{form_name}", "tabName":"data", "editable":"TRUE"' feature = f'"feature_type":"{feature_type}"' body = self.create_body(form, feature) sql = f"SELECT gw_fct_getcatalog({body})::text" row = self.controller.get_row(sql, log_sql=True) if not row: self.controller.show_message("NOT ROW FOR: " + sql, 2) return complet_list = [json.loads(row[0], object_pairs_hook=OrderedDict)] groupBox_1 = QGroupBox("Filter") self.filter_form = QGridLayout() self.dlg_catalog = InfoCatalogUi() self.load_settings(self.dlg_catalog) self.dlg_catalog.btn_cancel.clicked.connect( partial(self.close_dialog, self.dlg_catalog)) self.dlg_catalog.btn_accept.clicked.connect( partial(self.fill_geomcat_id, previous_dialog, widget_name)) main_layout = self.dlg_catalog.widget.findChild( QGridLayout, 'main_layout') result = complet_list[0]['body']['data'] for field in result['fields']: label = QLabel() label.setObjectName('lbl_' + field['label']) label.setText(field['label'].capitalize()) widget = None if field['widgettype'] == 'combo': widget = self.add_combobox(self.dlg_catalog, field) if field['layoutname'] == 'lyt_data_1': self.filter_form.addWidget(label, field['layoutorder'], 0) self.filter_form.addWidget(widget, field['layoutorder'], 1) groupBox_1.setLayout(self.filter_form) main_layout.addWidget(groupBox_1) verticalSpacer1 = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding) main_layout.addItem(verticalSpacer1) matcat_id = self.dlg_catalog.findChild(QComboBox, 'matcat_id') pnom = None dnom = None if self.controller.get_project_type() == 'ws': pnom = self.dlg_catalog.findChild(QComboBox, 'pnom') dnom = self.dlg_catalog.findChild(QComboBox, 'dnom') elif self.controller.get_project_type() == 'ud': pnom = self.dlg_catalog.findChild(QComboBox, 'shape') dnom = self.dlg_catalog.findChild(QComboBox, 'geom1') id = self.dlg_catalog.findChild(QComboBox, 'id') # Call get_api_catalog first time self.get_api_catalog(matcat_id, pnom, dnom, id, feature_type, geom_type) # Set Listeners matcat_id.currentIndexChanged.connect( partial(self.populate_pn_dn, matcat_id, pnom, dnom, feature_type, geom_type)) pnom.currentIndexChanged.connect( partial(self.get_api_catalog, matcat_id, pnom, dnom, id, feature_type, geom_type)) dnom.currentIndexChanged.connect( partial(self.get_api_catalog, matcat_id, pnom, dnom, id, feature_type, geom_type)) # Open form self.open_dialog(self.dlg_catalog, dlg_name='info_catalog')
def api_search(self, dlg_mincut=None): form = "" if self.dlg_search is None and dlg_mincut is None: self.init_dialog() if dlg_mincut: self.dlg_search = dlg_mincut self.is_mincut = True form = f'"singleTab":"tab_address"' self.dlg_search.lbl_msg.setStyleSheet("QLabel{color:red;}") self.dlg_search.lbl_msg.setVisible(False) project_vars = global_vars.project_vars qgis_project_add_schema = project_vars['add_schema'] self.controller.set_user_settings_value('open_search', 'true') if qgis_project_add_schema is None: body = create_body(form=form) else: extras = f'"addSchema":"{qgis_project_add_schema}"' body = create_body(form=form, extras=extras) function_name = "gw_fct_getsearch" complet_list = self.controller.get_json(function_name, body) if not complet_list: return False main_tab = self.dlg_search.findChild(QTabWidget, 'main_tab') if dlg_mincut and len(complet_list["form"]) == 1: main_tab = self.dlg_search.findChild(QTabWidget, 'main_tab') main_tab.setStyleSheet( "QTabBar::tab { background-color: transparent; text-align:left;" "border: 1px solid transparent;}" "QTabWidget::pane { background-color: #fcfcfc; border: 1 solid #dadada;}" ) first_tab = None self.lineedit_list = [] for tab in complet_list["form"]: if first_tab is None: first_tab = tab['tabName'] tab_widget = QWidget(main_tab) tab_widget.setObjectName(tab['tabName']) main_tab.addTab(tab_widget, tab['tabLabel']) gridlayout = QGridLayout() tab_widget.setLayout(gridlayout) x = 0 for field in tab['fields']: label = QLabel() label.setObjectName('lbl_' + field['label']) label.setText(field['label'].capitalize()) widget = None if field['widgettype'] == 'typeahead': completer = QCompleter() widget = add_lineedit(field) widget = self.set_typeahead_completer(widget, completer) self.lineedit_list.append(widget) elif field['widgettype'] == 'combo': widget = self.add_combobox(field) gridlayout.addWidget(label, x, 0) gridlayout.addWidget(widget, x, 1) x += 1 vertical_spacer1 = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding) gridlayout.addItem(vertical_spacer1) if self.is_mincut is False: self.controller.manage_translation('search', self.dlg_search)
def _open_function(self, index): # this '0' refers to the index of the item in the selected row self.function_selected = index.sibling(index.row(), 0).data() # Control no clickable items if self.function_selected in self.no_clickable_items: return if 'reports' in index.parent().data().lower(): # this '1' refers to the index of the item in the selected row function_name = index.sibling(index.row(), 0).data() self.function_selected = index.sibling(index.row(), 1).data() self.dlg_reports = GwToolboxReportsUi() tools_gw.load_settings(self.dlg_reports) # Set listeners self.dlg_reports.btn_export_path.clicked.connect(self._select_file_report) self.dlg_reports.btn_export.clicked.connect(partial(self._export_reports, self.dlg_reports, self.dlg_reports.tbl_reports, self.dlg_reports.txt_export_path)) self.dlg_reports.rejected.connect(partial(tools_gw.close_dialog, self.dlg_reports)) self.dlg_reports.btn_close.clicked.connect(self.dlg_reports.reject) extras = f'"filterText":null, "listId":"{self.function_selected}"' body = tools_gw.create_body(extras=extras) json_result = tools_gw.execute_procedure('gw_fct_getreport', body) if not json_result or json_result['status'] == 'Failed': return False layout = self.dlg_reports.findChild(QGridLayout, 'lyt_filters') order = 0 for field in json_result['body']['data']['fields']: label = None widget = None if 'label' in field and field['label']: label = QLabel() label.setObjectName('lbl_' + field['widgetname']) label.setText(field['label'].capitalize()) if 'stylesheet' in field and field['stylesheet'] is not None and 'label' in field['stylesheet']: label = tools_gw.set_stylesheet(field, label) if 'tooltip' in field: label.setToolTip(field['tooltip']) else: label.setToolTip(field['label'].capitalize()) if field['widgettype'] == 'text' or field['widgettype'] == 'typeahead': completer = QCompleter() widget = tools_gw.add_lineedit(field) widget = tools_gw.set_widget_size(widget, field) widget = tools_gw.set_data_type(field, widget) widget.textChanged.connect(partial(self._update_tbl_reports)) if field['widgettype'] == 'typeahead': widget = tools_gw.set_typeahead(field, self.dlg_reports, widget, completer) elif field['widgettype'] == 'combo': widget = tools_gw.add_combo(field) widget = tools_gw.set_widget_size(widget, field) widget.currentIndexChanged.connect(partial(self._update_tbl_reports)) elif field['widgettype'] == 'check': widget = tools_gw.add_checkbox(field) widget.stateChanged.connect(partial(self._update_tbl_reports)) elif field['widgettype'] == 'datetime': widget = tools_gw.add_calendar(self.dlg_reports, field) widget.valueChanged.connect(partial(self._update_tbl_reports)) elif field['widgettype'] == 'list': numrows = len(field['value']) numcols = len(field['value'][0]) self.dlg_reports.tbl_reports.setColumnCount(numcols) self.dlg_reports.tbl_reports.setRowCount(numrows) i = 0 dict_keys = {} for key in field['value'][0].keys(): dict_keys[i] = f"{key}" self.dlg_reports.tbl_reports.setHorizontalHeaderItem(i, QTableWidgetItem(f"{key}")) i = i + 1 for row in range(numrows): for column in range(numcols): column_name = dict_keys[column] self.dlg_reports.tbl_reports.setItem(row, column, QTableWidgetItem(f"{field['value'][row][column_name]}")) continue order = order + 1 if label: layout.addWidget(label, 0, order) if widget: layout.addWidget(widget, 1, order) self.dlg_reports.setWindowTitle(f"{function_name}") tools_gw.open_dialog(self.dlg_reports, dlg_name='reports') elif 'giswater' in index.parent().data().lower(): self.dlg_functions = GwToolboxManagerUi() tools_gw.load_settings(self.dlg_functions) self.dlg_functions.progressBar.setVisible(False) self.dlg_functions.btn_cancel.hide() self.dlg_functions.btn_close.show() self.dlg_functions.btn_cancel.clicked.connect(self._cancel_task) self.dlg_functions.cmb_layers.currentIndexChanged.connect(partial(self.set_selected_layer, self.dlg_functions, self.dlg_functions.cmb_layers)) self.dlg_functions.rbt_previous.toggled.connect(partial(self._rbt_state, self.dlg_functions.rbt_previous)) self.dlg_functions.rbt_layer.toggled.connect(partial(self._rbt_state, self.dlg_functions.rbt_layer)) self.dlg_functions.rbt_layer.setChecked(True) extras = f'"filterText":"{self.function_selected}"' extras += ', "isToolbox":true' body = tools_gw.create_body(extras=extras) json_result = tools_gw.execute_procedure('gw_fct_gettoolbox', body) if not json_result or json_result['status'] == 'Failed': return False status = self._populate_functions_dlg(self.dlg_functions, json_result['body']['data']['processes']) if not status: self.function_selected = index.sibling(index.row(), 1).data() message = "Function not found" tools_qgis.show_message(message, parameter=self.function_selected) return # Disable tab log tools_gw.disable_tab_log(self.dlg_functions) # Connect signals self.dlg_functions.mainTab.currentChanged.connect(partial(self._manage_btn_run)) self.dlg_functions.btn_run.clicked.connect(partial(self._execute_function, self.function_selected, self.dlg_functions, self.dlg_functions.cmb_layers, json_result['body']['data']['processes'])) self.dlg_functions.btn_close.clicked.connect(partial(tools_gw.close_dialog, self.dlg_functions)) self.dlg_functions.rejected.connect(partial(tools_gw.close_dialog, self.dlg_functions)) self.dlg_functions.btn_cancel.clicked.connect(partial(self.remove_layers)) # Open form and set title self.dlg_functions.setWindowTitle(f"{self.function_selected}") tools_gw.open_dialog(self.dlg_functions, dlg_name='toolbox')
def construct_form_param_system(self, row, pos): widget = None for field in row[pos]['fields']: if field['label']: lbl = QLabel() lbl.setObjectName('lbl' + field['widgetname']) lbl.setText(field['label']) lbl.setMinimumSize(160, 0) lbl.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred) lbl.setToolTip(field['tooltip']) if field['widgettype'] == 'text' or field[ 'widgettype'] == 'linetext': widget = QLineEdit() widget.setText(field['value']) widget.editingFinished.connect( partial(self.get_values_changed_param_system, widget)) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) elif field['widgettype'] == 'textarea': widget = QTextEdit() widget.setText(field['value']) widget.editingFinished.connect( partial(self.get_values_changed_param_system, widget)) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) elif field['widgettype'] == 'combo': widget = QComboBox() self.populate_combo(widget, field) widget.currentIndexChanged.connect( partial(self.get_values_changed_param_system, widget)) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) elif field['widgettype'] == 'checkbox' or field[ 'widgettype'] == 'check': widget = QCheckBox() if field['value'].lower() == 'true': widget.setChecked(True) elif field['value'].lower() == 'FALSE': widget.setChecked(False) widget.stateChanged.connect( partial(self.get_values_changed_param_system, widget)) widget.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) elif field['widgettype'] == 'datepickertime': widget = QDateEdit() widget.setCalendarPopup(True) date = QDate.fromString(field['value'], 'yyyy/MM/dd') widget.setDate(date) widget.dateChanged.connect( partial(self.get_values_changed_param_system, widget)) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) elif field['widgettype'] == 'spinbox': widget = QDoubleSpinBox() if 'value' in field and field['value'] is not None: value = float(str(field['value'])) widget.setValue(value) widget.valueChanged.connect( partial(self.get_values_changed_param_system, widget)) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) else: pass if widget: widget.setObjectName(field['widgetname']) else: pass # Order Widgets if field['layout_id'] == 1: self.order_widgets_system(field, self.basic_form, lbl, widget) elif field['layout_id'] == 2: self.order_widgets_system(field, self.om_form, lbl, widget) elif field['layout_id'] == 3: self.order_widgets_system(field, self.workcat_form, lbl, widget) elif field['layout_id'] == 4: self.order_widgets_system(field, self.mapzones_form, lbl, widget) elif field['layout_id'] == 5: self.order_widgets_system(field, self.cad_form, lbl, widget) elif field['layout_id'] == 6: self.order_widgets_system(field, self.epa_form, lbl, widget) elif field['layout_id'] == 7: self.order_widgets_system(field, self.masterplan_form, lbl, widget) elif field['layout_id'] == 8: self.order_widgets_system(field, self.other_form, lbl, widget) elif field['layout_id'] == 9: self.order_widgets_system(field, self.node_type_form, lbl, widget) elif field['layout_id'] == 10: self.order_widgets_system(field, self.cat_form, lbl, widget) elif field['layout_id'] == 11: self.order_widgets_system(field, self.utils_form, lbl, widget) elif field['layout_id'] == 12: self.order_widgets_system(field, self.connec_form, lbl, widget) elif field['layout_id'] == 13: self.order_widgets_system(field, self.topology_form, lbl, widget) elif field['layout_id'] == 14: self.order_widgets_system(field, self.builder_form, lbl, widget) elif field['layout_id'] == 15: self.order_widgets_system(field, self.review_form, lbl, widget) elif field['layout_id'] == 16: self.order_widgets_system(field, self.analysis_form, lbl, widget) elif field['layout_id'] == 17: self.order_widgets_system(field, self.system_form, lbl, widget)
def construct_form_param_system(self, row, pos): widget = None for field in row[pos]['fields']: if field['label']: lbl = QLabel() lbl.setObjectName('lbl' + field['widgetname']) lbl.setText(field['label']) lbl.setMinimumSize(160, 0) lbl.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred) lbl.setToolTip(field['tooltip']) if field['widgettype'] == 'text' or field[ 'widgettype'] == 'linetext': widget = QLineEdit() widget.setText(field['value']) widget.editingFinished.connect( partial(self.get_values_changed_param_system, widget)) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) elif field['widgettype'] == 'textarea': widget = QTextEdit() widget.setText(field['value']) widget.editingFinished.connect( partial(self.get_values_changed_param_system, widget)) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) elif field['widgettype'] == 'combo': widget = QComboBox() self.populate_combo(widget, field) widget.currentIndexChanged.connect( partial(self.get_values_changed_param_system, widget)) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) elif field['widgettype'] == 'checkbox' or field[ 'widgettype'] == 'check': widget = QCheckBox() if field['value'] in ('true', 'True', 'TRUE', True): widget.setChecked(True) elif field['value'] in ('false', 'False', 'FALSE', False): widget.setChecked(False) widget.stateChanged.connect( partial(self.get_values_changed_param_system, widget)) widget.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) elif field['widgettype'] == 'datetime': widget = QDateEdit() widget.setCalendarPopup(True) if field['value']: field['value'] = field['value'].replace('/', '-') date = QDate.fromString(field['value'], 'yyyy-MM-dd') widget.setDate(date) widget.dateChanged.connect( partial(self.get_values_changed_param_system, widget)) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) elif field['widgettype'] == 'spinbox': widget = QSpinBox() if 'value' in field and field['value'] is not None: value = float(str(field['value'])) widget.setValue(value) widget.valueChanged.connect( partial(self.get_values_changed_param_system, widget)) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) else: pass if widget: widget.setObjectName(field['widgetname']) else: pass # Order Widgets if 'layoutname' in field: if field['layoutname'] == 'lyt_topology': self.order_widgets_system(field, self.topology_form, lbl, widget) elif field['layoutname'] == 'lyt_builder': self.order_widgets_system(field, self.builder_form, lbl, widget) elif field['layoutname'] == 'lyt_review': self.order_widgets_system(field, self.review_form, lbl, widget) elif field['layoutname'] == 'lyt_analysis': self.order_widgets_system(field, self.analysis_form, lbl, widget) elif field['layoutname'] == 'lyt_system': self.order_widgets_system(field, self.system_form, lbl, widget)
def construct_form_param_user(self, row, pos): widget = None for field in row[pos]['fields']: if field['label']: lbl = QLabel() lbl.setObjectName('lbl' + field['widgetname']) lbl.setText(field['label']) lbl.setMinimumSize(160, 0) lbl.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred) lbl.setToolTip(field['tooltip']) chk = QCheckBox() chk.setObjectName('chk_' + field['widgetname']) if field['checked'] in ('true', 'True', 'TRUE', True): chk.setChecked(True) elif field['checked'] in ('false', 'False', 'FALSE', False): chk.setChecked(False) chk.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) if field['widgettype'] == 'text' or field[ 'widgettype'] == 'linetext' or field[ 'widgettype'] == 'typeahead': widget = QLineEdit() widget.setText(field['value']) widget.editingFinished.connect( partial(self.get_values_changed_param_user, chk, widget, field)) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) if field['widgettype'] == 'typeahead': completer = QCompleter() if 'dv_querytext' in field or 'dv_querytext_filterc' in field: widget.setProperty('typeahead', True) model = QStringListModel() widget.textChanged.connect( partial(self.populate_typeahead, completer, model, field, self.dlg_config, widget)) elif field['widgettype'] == 'textarea': widget = QTextEdit() widget.setText(field['value']) widget.editingFinished.connect( partial(self.get_values_changed_param_user, chk, widget, field)) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) elif field['widgettype'] == 'combo': widget = QComboBox() self.populate_combo(widget, field) widget.currentIndexChanged.connect( partial(self.get_values_changed_param_user, chk, widget, field)) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) elif field['widgettype'] == 'check': widget = chk widget.stateChanged.connect( partial(self.get_values_changed_param_user, chk, chk, field)) widget.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) elif field['widgettype'] == 'datetime': widget = QgsDateTimeEdit() widget.setAllowNull(True) widget.setCalendarPopup(True) widget.setDisplayFormat('dd/MM/yyyy') if field['value']: field['value'] = field['value'].replace('/', '-') date = QDate.fromString(field['value'], 'yyyy-MM-dd') if date: widget.setDate(date) else: widget.clear() widget.dateChanged.connect( partial(self.get_values_changed_param_user, chk, widget, field)) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) elif field['widgettype'] == 'spinbox': widget = QDoubleSpinBox() if 'value' in field and field['value'] is not None: value = float(str(field['value'])) widget.setValue(value) widget.valueChanged.connect( partial(self.get_values_changed_param_user, chk, widget, field)) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) else: pass widget.setObjectName(field['widgetname']) # Set signals chk.stateChanged.connect( partial(self.get_values_checked_param_user, chk, widget, field)) if field['layoutname'] == 'lyt_basic': self.order_widgets(field, self.basic_form, lbl, chk, widget) elif field['layoutname'] == 'lyt_om': self.order_widgets(field, self.om_form, lbl, chk, widget) elif field['layoutname'] == 'lyt_inventory': self.order_widgets(field, self.inventory_form, lbl, chk, widget) elif field['layoutname'] == 'lyt_mapzones': self.order_widgets(field, self.mapzones_form, lbl, chk, widget) elif field['layoutname'] == 'lyt_edit': self.order_widgets(field, self.cad_form, lbl, chk, widget) elif field['layoutname'] == 'lyt_epa': self.order_widgets(field, self.epa_form, lbl, chk, widget) elif field['layoutname'] == 'lyt_masterplan': self.order_widgets(field, self.masterplan_form, lbl, chk, widget) elif field['layoutname'] == 'lyt_other': self.order_widgets(field, self.other_form, lbl, chk, widget) elif field['layoutname'] == 'lyt_node_vdef': self.order_widgets(field, self.node_type_form, lbl, chk, widget) elif field['layoutname'] == 'lyt_arc_vdef': self.order_widgets(field, self.cat_form, lbl, chk, widget) elif field['layoutname'] == 'lyt_utils_vdef': self.order_widgets(field, self.utils_form, lbl, chk, widget) elif field['layoutname'] == 'lyt_connec_vdef': self.order_widgets(field, self.connec_form, lbl, chk, widget) elif field['layoutname'] == 'lyt_gully_vdef': self.order_widgets(field, self.gully_form, lbl, chk, widget) elif field['layoutname'] == 'lyt_fluid_type': self.order_widgets(field, self.fluid_type_form, lbl, chk, widget) elif field['layoutname'] == 'lyt_location_type': self.order_widgets(field, self.location_type_form, lbl, chk, widget) elif field['layoutname'] == 'lyt_category_type': self.order_widgets(field, self.category_type_form, lbl, chk, widget) elif field['layoutname'] == 'lyt_function_type': self.order_widgets(field, self.function_type_form, lbl, chk, widget) elif field['layoutname'] == 'lyt_addfields': self.order_widgets(field, self.addfields_form, lbl, chk, widget)
class ReferencedTableEditor(QWidget): referenced_table_changed = pyqtSignal(str) changed = pyqtSignal() def __init__(self, parent=None): QWidget.__init__(self, parent) self.setupUi() self._block_changed = False self.cbo_ref_table.setInsertPolicy(QComboBox.InsertAlphabetically) self.cbo_ref_table.currentIndexChanged[str].connect(self._on_ref_table_changed) self.cbo_source_field.currentTextChanged.connect(self._on_changed) self.cbo_ref_table.currentIndexChanged[str].connect(self._on_changed) self.cbo_referencing_col.currentTextChanged.connect(self._on_changed) # Tables that will be omitted from the referenced table list self._omit_ref_tables = [] self._layout = None def _on_changed(self): if not self._block_changed: self.changed.emit() def add_omit_table(self, table): """ Add a table name that will be omitted from the list of referenced tables. :param table: Table name that will be omitted :type table: str """ if not table in self._omit_ref_tables: self._omit_ref_tables.append(table) def add_omit_tables(self, tables): """ Add a list of tables that will be omitted from the list of referenced tables. :param tables: Table names to be omitted. :type tables: list """ for t in tables: self.add_omit_table(t) @property def omit_tables(self): """ :return: Returns a list of tables that are to be omitted from the list of referenced tables. """ return self._omit_ref_tables def setupUi(self): self.setObjectName("ReferencedTableEditor") self.gridLayout = QGridLayout(self) self.gridLayout.setVerticalSpacing(10) self.gridLayout.setObjectName("gridLayout") self.label_2 = QLabel(self) self.label_2.setMaximumSize(QSize(100, 16777215)) self.label_2.setObjectName("label_2") self.gridLayout.addWidget(self.label_2, 1, 0, 1, 1) self.cbo_source_field = QComboBox(self) self.cbo_source_field.setMinimumSize(QSize(0, 30)) self.cbo_source_field.setObjectName("cbo_source_field") self.gridLayout.addWidget(self.cbo_source_field, 2, 1, 1, 1) self.label = QLabel(self) self.label.setObjectName("label") self.gridLayout.addWidget(self.label, 2, 0, 1, 1) self.label_3 = QLabel(self) self.label_3.setObjectName("label_3") self.gridLayout.addWidget(self.label_3, 3, 0, 1, 1) self.cbo_referencing_col = QComboBox(self) self.cbo_referencing_col.setMinimumSize(QSize(0, 30)) self.cbo_referencing_col.setObjectName("cbo_referencing_col") self.gridLayout.addWidget(self.cbo_referencing_col, 3, 1, 1, 1) self.cbo_ref_table = QComboBox(self) self.cbo_ref_table.setMinimumSize(QSize(0, 30)) self.cbo_ref_table.setObjectName("cbo_ref_table") self.gridLayout.addWidget(self.cbo_ref_table, 1, 1, 1, 1) self.label_2.setText(QApplication.translate("ReferencedTableEditor", "References")) self.label.setText(QApplication.translate("ReferencedTableEditor", "Data source field")) self.label_3.setText(QApplication.translate("ReferencedTableEditor", "Referencing")) self._current_profile = current_profile() self._current_profile_tables = [] if self._current_profile is not None: self._current_profile_tables =self._current_profile.user_table_names() # Connect signals QMetaObject.connectSlotsByName(self) self.cbo_ref_table.currentIndexChanged[str].connect(self._load_source_table_fields) def set_layout(self, layout): self._layout = layout self._layout.variablesChanged.connect(self.layout_variables_changed) def layout_variables_changed(self): """ When the user changes the data source then update the fields. """ data_source_name = LayoutUtils.get_stdm_data_source_for_layout(self._layout) self.load_data_source_fields(data_source_name) def on_data_source_changed(self, data_source_name): """ Loads data source fields for the given data source name. """ self.load_data_source_fields(data_source_name) def _on_ref_table_changed(self, table): """ Raise signal when the referenced table changes. :param table: Selected table name. :type table: str """ self.referenced_table_changed.emit(table) def properties(self): """ :returns: Returns the user-defined mapping of linked table and column pairings. :rtype: LinkedTableProps """ l_table = self.cbo_ref_table.currentText() s_field = self.cbo_source_field.currentText() l_field = self.cbo_referencing_col.currentText() return LinkedTableProps(linked_table=l_table, source_field=s_field, linked_field=l_field) def set_properties(self, table_props): """ Sets the combo selection based on the text in the linked table object properties. :param table_props: Object containing the linked table information. :type table_props: LinkedTableProps """ self._block_changed = True GuiUtils.set_combo_current_index_by_text(self.cbo_ref_table, table_props.linked_table) GuiUtils.set_combo_current_index_by_text(self.cbo_source_field, table_props.source_field) GuiUtils.set_combo_current_index_by_text(self.cbo_referencing_col, table_props.linked_field) self._block_changed = False def load_data_source_fields(self, data_source_name): """ Load fields/columns of the given data source. """ if data_source_name == "": self.clear() return columns_names = table_column_names(data_source_name) if len(columns_names) == 0: return self.cbo_source_field.clear() self.cbo_source_field.addItem("") self.cbo_source_field.addItems(columns_names) def clear(self): """ Resets combo box selections. """ self._reset_combo_index(self.cbo_ref_table) self._reset_combo_index(self.cbo_referencing_col) self._reset_combo_index(self.cbo_source_field) def _reset_combo_index(self, combo): if combo.count > 0: combo.setCurrentIndex(0) def reset_referenced_table(self): self._reset_combo_index(self.cbo_ref_table) def load_link_tables(self, reg_exp=None, source=TABLES | VIEWS): self.cbo_ref_table.clear() self.cbo_ref_table.addItem("") ref_tables = [] source_tables = [] # Table source if (TABLES & source) == TABLES: ref_tables.extend(pg_tables(exclude_lookups=True)) for t in ref_tables: # Ensure we are dealing with tables in the current profile if not t in self._current_profile_tables: continue # Assert if the table is in the list of omitted tables if t in self._omit_ref_tables: continue if not reg_exp is None: if reg_exp.indexIn(t) >= 0: source_tables.append(t) else: source_tables.append(t) # View source if (VIEWS & source) == VIEWS: profile_user_views = profile_and_user_views(self._current_profile) source_tables = source_tables + profile_user_views self.cbo_ref_table.addItems(source_tables) def _load_source_table_fields(self, sel): self.cbo_referencing_col.clear() data_source_index = self.cbo_source_field.currentIndex() # self.on_data_source_changed( # self.cbo_source_field.itemData(data_source_index) # ) if not sel: return columns_names = table_column_names(sel) self.cbo_referencing_col.clear() self.cbo_referencing_col.addItem("") self.cbo_referencing_col.addItems(columns_names)
def get_selector(self, dialog, selector_type, filter=False, widget=None, text_filter=None, current_tab=None): """ Ask to DB for selectors and make dialog :param dialog: Is a standard dialog, from file selector.ui, where put widgets :param selector_type: List of selectors to ask DB ['exploitation', 'state', ...] """ index = 0 main_tab = dialog.findChild(QTabWidget, 'main_tab') # Set filter if filter is not False: main_tab = dialog.findChild(QTabWidget, 'main_tab') text_filter = tools_qt.get_text(dialog, widget) if text_filter in ('null', None): text_filter = '' # Set current_tab index = dialog.main_tab.currentIndex() current_tab = dialog.main_tab.widget(index).objectName() # Profilactic control of nones if text_filter is None: text_filter = '' # Built querytext form = f'"currentTab":"{current_tab}"' extras = f'"selectorType":{selector_type}, "filterText":"{text_filter}"' body = tools_gw.create_body(form=form, extras=extras) json_result = tools_gw.execute_procedure('gw_fct_getselectors', body) if not json_result or json_result['status'] == 'Failed': return False # Get styles stylesheet = json_result['body']['form'][ 'style'] if 'style' in json_result['body']['form'] else None color_rows = False if stylesheet: # Color selectors zebra-styled if 'rowsColor' in stylesheet and stylesheet[ 'rowsColor'] is not None: color_rows = tools_os.set_boolean(stylesheet['rowsColor'], False) for form_tab in json_result['body']['form']['formTabs']: if filter and form_tab['tabName'] != str(current_tab): continue selection_mode = form_tab['selectionMode'] # Create one tab for each form_tab and add to QTabWidget tab_widget = QWidget(main_tab) tab_widget.setObjectName(form_tab['tabName']) tab_widget.setProperty('selector_type', form_tab['selectorType']) if filter: main_tab.removeTab(index) main_tab.insertTab(index, tab_widget, form_tab['tabLabel']) else: main_tab.addTab(tab_widget, form_tab['tabLabel']) if 'typeaheadForced' in form_tab and form_tab[ 'typeaheadForced'] is not None: tab_widget.setProperty('typeahead_forced', form_tab['typeaheadForced']) # Create a new QGridLayout and put it into tab gridlayout = QGridLayout() gridlayout.setObjectName("lyt" + form_tab['tabName']) tab_widget.setLayout(gridlayout) field = {} i = 0 if 'typeaheadFilter' in form_tab: label = QLabel() label.setObjectName('lbl_filter') label.setText('Filter:') if tools_qt.get_widget( dialog, 'txt_filter_' + str(form_tab['tabName'])) is None: widget = QLineEdit() widget.setObjectName('txt_filter_' + str(form_tab['tabName'])) widget.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) widget.textChanged.connect( partial(self.get_selector, dialog, selector_type, filter=True, widget=widget, current_tab=current_tab)) widget.setLayoutDirection(Qt.RightToLeft) else: widget = tools_qt.get_widget( dialog, 'txt_filter_' + str(form_tab['tabName'])) field['layoutname'] = gridlayout.objectName() field['layoutorder'] = i i = i + 1 gridlayout.addWidget(label, int(field['layoutorder']), 0) gridlayout.addWidget(widget, int(field['layoutorder']), 2) widget.setFocus() if 'manageAll' in form_tab: if (form_tab['manageAll']).lower() == 'true': if tools_qt.get_widget( dialog, f"chk_all_{form_tab['tabName']}") is None: widget = QCheckBox() widget.setObjectName('chk_all_' + str(form_tab['tabName'])) widget.stateChanged.connect( partial(self._manage_all, dialog, widget)) widget.setLayoutDirection(Qt.LeftToRight) else: widget = tools_qt.get_widget( dialog, f"chk_all_{form_tab['tabName']}") widget.setText('Check all') field['layoutname'] = gridlayout.objectName() field['layoutorder'] = i i = i + 1 gridlayout.addWidget(widget, int(field['layoutorder']), 0, 1, -1) for order, field in enumerate(form_tab['fields']): try: # Create checkbox widget = tools_gw.add_checkbox(field) widget.setText(field['label']) widget.stateChanged.connect( partial(self._set_selection_mode, dialog, widget, selection_mode)) widget.setLayoutDirection(Qt.LeftToRight) # Set background color every other item (if enabled) if color_rows and order % 2 == 0: widget.setStyleSheet(f"background-color: #E9E7E3") # Add widget to layout field['layoutname'] = gridlayout.objectName() field['layoutorder'] = order + i + 1 gridlayout.addWidget(widget, int(field['layoutorder']), 0, 1, -1) except Exception: msg = f"key 'comboIds' or/and comboNames not found WHERE columname='{field['columnname']}' AND " \ f"widgetname='{field['widgetname']}'" tools_qgis.show_message(msg, 2) vertical_spacer1 = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding) gridlayout.addItem(vertical_spacer1) # Set last tab used by user as current tab tabname = json_result['body']['form']['currentTab'] tab = main_tab.findChild(QWidget, tabname) if tab: main_tab.setCurrentWidget(tab)
def buildfromauto(formconfig, base) -> QWidget: """ Build a auto form from the form config given. :param formconfig: The form config containing the information about the widgets to create. :param base: The base widget to create the new widgets in. :return: The base widget with the added widgets created inside the layout. """ widgetsconfig = copy.deepcopy(formconfig['widgets']) try: widgetsconfig = base.get_widgets(widgetsconfig) except AttributeError: pass newstyle = formconfig.get("newstyle", False) hassections = any(config['widget'] == "Section" for config in widgetsconfig) def make_layout(): """ Create the inner layout for the widget. For new style forms this is a vbox layout so everything is stacked on top of each other in a simple list. :return: """ if newstyle: return QVBoxLayout() else: layout = QFormLayout() layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow) return layout def make_tab(tabwidget, name): """ Create a table in the given tab widget. :param tabwidget: The tab widget to create the tab in. :param name: The name of the new tab to create. :return: The new widget inside the tab and the widgets inner layout. """ widget = QWidget() widget.setLayout(make_layout()) tabwidget.addTab(widget, name) return widget, widget.layout() if hassections: outwidget = QTabWidget(base) outlayout = None base.setLayout(QVBoxLayout()) base.layout().setContentsMargins(0, 0, 0, 0) base.layout().addWidget(outwidget) else: outwidget = base outlayout = make_layout() outwidget.setLayout(outlayout) # Add the geometry editor widget of that is set in the config. # This is a hidden option so isn't exposed in config manager yet if roam.config.settings.get("form_geom_edit", False): geomwidget = GeomWidget() geomwidget.setObjectName("__geomwidget") outlayout.addRow("Geometry", geomwidget) insection = False for config in widgetsconfig: widgettype = config['widget'] # Make the first tab if one isn't defined already and we have other sections in the config if not insection and hassections and not widgettype == "Section": name = formconfig['label'] tabwidget, outlayout = make_tab(outwidget, name) insection = True if widgettype == 'Section': # Add a spacer to the last widget if outlayout: spacer = QWidget() spacer.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding) outlayout.addItem(QSpacerItem(10, 500)) outlayout.addWidget(spacer) name = config['name'] tabwidget, outlayout = make_tab(outwidget, name) insection = True continue field = config['field'] name = config.get('name', field) if not field: utils.warning("Field can't be null for {}".format(name)) utils.warning("Skipping widget") continue label = QLabel(name) label.setObjectName(field + "_label") labelwidget = QWidget() labelwidget.setLayout(QBoxLayout(QBoxLayout.LeftToRight)) labelwidget.layout().addWidget(label) labelwidget.layout().setContentsMargins(0, 0, 0, 0) widget = roam.editorwidgets.core.createwidget(widgettype, parent=base) widget.setObjectName(field) layoutwidget = QWidget() layoutwidget.setLayout(QBoxLayout(QBoxLayout.LeftToRight)) layoutwidget.layout().addWidget(widget) layoutwidget.layout().setContentsMargins(0, 0, 0, 10) if config.get('rememberlastvalue', False): savebutton = QToolButton() savebutton.setObjectName('{}_save'.format(field)) if newstyle: spacer = QWidget() spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) labelwidget.layout().addWidget(spacer) labelwidget.layout().addWidget(savebutton) else: layoutwidget.layout().addWidget(savebutton) if newstyle: outlayout.addWidget(labelwidget) outlayout.addWidget(layoutwidget) else: outlayout.addRow(labelwidget, layoutwidget) spacer = QWidget() spacer.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding) outlayout.addWidget(spacer) if not hassections: outlayout.addItem(QSpacerItem(10, 500)) return base
def open_catalog(self, previous_dialog, widget_name, feature_type, child_type): """ Main function of catalog """ # Manage if feature_type is gully and set grate if feature_type == 'gully': feature_type = 'grate' form_name = 'upsert_catalog_' + feature_type + '' form = f'"formName":"{form_name}", "tabName":"data", "editable":"TRUE"' feature = f'"feature_type":"{child_type}"' body = tools_gw.create_body(form, feature) json_result = tools_gw.execute_procedure('gw_fct_getcatalog', body, log_sql=True) if json_result is None: return group_box_1 = QGroupBox("Filter") self.filter_form = QGridLayout() self.dlg_catalog = GwInfoCatalogUi() tools_gw.load_settings(self.dlg_catalog) self.dlg_catalog.btn_cancel.clicked.connect( partial(tools_gw.close_dialog, self.dlg_catalog)) self.dlg_catalog.btn_accept.clicked.connect( partial(self._fill_geomcat_id, previous_dialog, widget_name)) main_layout = self.dlg_catalog.widget.findChild( QGridLayout, 'main_layout') result = json_result['body']['data'] for field in result['fields']: label = QLabel() label.setObjectName('lbl_' + field['label']) label.setText(field['label'].capitalize()) widget = None if field['widgettype'] == 'combo': widget = self._add_combobox(field) if field['layoutname'] == 'lyt_data_1': self.filter_form.addWidget(label, field['layoutorder'], 0) self.filter_form.addWidget(widget, field['layoutorder'], 1) group_box_1.setLayout(self.filter_form) main_layout.addWidget(group_box_1) vertical_spacer1 = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding) main_layout.addItem(vertical_spacer1) matcat_id = self.dlg_catalog.findChild(QComboBox, 'matcat_id') pnom = None dnom = None if tools_gw.get_project_type() == 'ws': pnom = self.dlg_catalog.findChild(QComboBox, 'pnom') dnom = self.dlg_catalog.findChild(QComboBox, 'dnom') elif tools_gw.get_project_type() == 'ud': pnom = self.dlg_catalog.findChild(QComboBox, 'shape') dnom = self.dlg_catalog.findChild(QComboBox, 'geom1') id = self.dlg_catalog.findChild(QComboBox, 'id') # Call _get_catalog first time self._get_catalog(matcat_id, pnom, dnom, id, feature_type, child_type) # Set Listeners if matcat_id: matcat_id.currentIndexChanged.connect( partial(self._populate_pn_dn, matcat_id, pnom, dnom, feature_type, child_type)) if pnom: pnom.currentIndexChanged.connect( partial(self._get_catalog, matcat_id, pnom, dnom, id, feature_type, child_type)) if dnom: dnom.currentIndexChanged.connect( partial(self._get_catalog, matcat_id, pnom, dnom, id, feature_type, child_type)) # Set shortcut keys self.dlg_catalog.key_escape.connect( partial(tools_gw.close_dialog, self.dlg_catalog)) # Open form tools_gw.open_dialog(self.dlg_catalog, dlg_name='info_catalog')
def _build_dialog_options(self, row, tab): self.tab = tab for field in row['fields']: try: widget = None self.chk = None if field['label']: lbl = QLabel() lbl.setObjectName('lbl' + field['widgetname']) lbl.setText(field['label']) lbl.setMinimumSize(160, 0) lbl.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred) lbl.setToolTip(field['tooltip']) if self.tab == 'user': self.chk = QCheckBox() self.chk.setObjectName('chk_' + field['widgetname']) if field['checked'] in ('true', 'True', 'TRUE', True): self.chk.setChecked(True) elif field['checked'] in ('false', 'False', 'FALSE', False): self.chk.setChecked(False) self.chk.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) if field['widgettype'] in ('text', 'linetext', 'typeahead'): widget = QLineEdit() widget.setText(field['value']) widget.editingFinished.connect( partial(self._get_dialog_changed_values, widget, self.tab, self.chk)) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) if field['widgettype'] == 'typeahead': completer = QCompleter() if 'dv_querytext' in field: widget.setProperty('typeahead', True) model = QStringListModel() widget.textChanged.connect( partial(self.populate_typeahead, completer, model, field, self.dlg_config, widget)) elif field['widgettype'] == 'textarea': widget = QTextEdit() widget.setText(field['value']) widget.editingFinished.connect( partial(self._get_dialog_changed_values, widget, self.tab, self.chk)) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) elif field['widgettype'] == 'combo': widget = QComboBox() self._fill_combo(widget, field) widget.currentIndexChanged.connect( partial(self._get_dialog_changed_values, widget, self.tab, self.chk)) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) elif field['widgettype'] == 'check': self.chk = QCheckBox() self.chk.setObjectName(field['widgetname']) if self.tab == 'user' and field['checked'] in ( 'true', 'True', 'TRUE', True): self.chk.setChecked(True) elif self.tab == 'user' and field['checked'] in ( 'false', 'False', 'FALSE', False): self.chk.setChecked(False) elif field['value'] in ('true', 'True', 'TRUE', True): self.chk.setChecked(True) elif field['value'] in ('false', 'False', 'FALSE', False): self.chk.setChecked(False) self.chk.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) self.chk.stateChanged.connect( partial(self._get_dialog_changed_values, self.chk, self.tab, self.chk)) elif field['widgettype'] == 'datetime': widget = QgsDateTimeEdit() widget.setAllowNull(True) widget.setCalendarPopup(True) widget.setDisplayFormat('dd/MM/yyyy') if global_vars.date_format in ("dd/MM/yyyy", "dd-MM-yyyy", "yyyy/MM/dd", "yyyy-MM-dd"): widget.setDisplayFormat(global_vars.date_format) if field['value']: field['value'] = field['value'].replace('/', '-') date = QDate.fromString(field['value'], 'yyyy-MM-dd') if date: widget.setDate(date) else: widget.clear() widget.valueChanged.connect( partial(self._get_dialog_changed_values, widget, self.tab, self.chk)) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) elif field['widgettype'] == 'spinbox': widget = QDoubleSpinBox() if 'value' in field and field['value'] is not None: value = float(str(field['value'])) widget.setValue(value) widget.valueChanged.connect( partial(self._get_dialog_changed_values, widget, self.tab, self.chk)) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) if widget: widget.setObjectName(field['widgetname']) # Set signals if self.tab == 'user' and widget is not None: self.chk.stateChanged.connect( partial(self._get_dialog_changed_values, widget, self.tab, self.chk)) if widget is None: widget = self.chk self._order_widgets(field, lbl, widget) except Exception as e: msg = f"{type(e).__name__} {e}. widgetname='{field['widgetname']}' AND widgettype='{field['widgettype']}'" tools_qgis.show_message(msg, 2)
class Ui_DistroMap(object): def setupUi(self, DistroMap): DistroMap.setObjectName("DistroMap") DistroMap.resize(439, 657) self.gridLayout_3 = QGridLayout(DistroMap) self.gridLayout_3.setObjectName("gridLayout_3") self.scrollArea = QScrollArea(DistroMap) self.scrollArea.setWidgetResizable(True) self.scrollArea.setObjectName("scrollArea") self.scrollAreaWidgetContents = QWidget() self.scrollAreaWidgetContents.setGeometry(QRect(0, 0, 419, 573)) self.scrollAreaWidgetContents.setObjectName("scrollAreaWidgetContents") self.gridLayout_6 = QGridLayout(self.scrollAreaWidgetContents) self.gridLayout_6.setObjectName("gridLayout_6") self.verticalLayout = QVBoxLayout() self.verticalLayout.setObjectName("verticalLayout") self.label_5 = QLabel(self.scrollAreaWidgetContents) self.label_5.setObjectName("label_5") self.verticalLayout.addWidget(self.label_5) self.comboLocalities = QComboBox(self.scrollAreaWidgetContents) self.comboLocalities.setObjectName("comboLocalities") self.verticalLayout.addWidget(self.comboLocalities) self.gridLayout_6.addLayout(self.verticalLayout, 1, 0, 1, 1) self.horizontalLayout_6 = QHBoxLayout() self.horizontalLayout_6.setObjectName("horizontalLayout_6") self.verticalLayout_13 = QVBoxLayout() self.verticalLayout_13.setObjectName("verticalLayout_13") self.label_19 = QLabel(self.scrollAreaWidgetContents) self.label_19.setObjectName("label_19") self.verticalLayout_13.addWidget(self.label_19) self.horizontalLayout_3 = QHBoxLayout() self.horizontalLayout_3.setObjectName("horizontalLayout_3") self.spnOutWidth = QSpinBox(self.scrollAreaWidgetContents) self.spnOutWidth.setMaximum(999999) self.spnOutWidth.setProperty("value", 325) self.spnOutWidth.setObjectName("spnOutWidth") self.horizontalLayout_3.addWidget(self.spnOutWidth) self.label_20 = QLabel(self.scrollAreaWidgetContents) self.label_20.setAlignment(Qt.AlignCenter) self.label_20.setObjectName("label_20") self.horizontalLayout_3.addWidget(self.label_20) self.spnOutHeight = QSpinBox(self.scrollAreaWidgetContents) self.spnOutHeight.setMaximum(999999) self.spnOutHeight.setProperty("value", 299) self.spnOutHeight.setObjectName("spnOutHeight") self.horizontalLayout_3.addWidget(self.spnOutHeight) self.verticalLayout_13.addLayout(self.horizontalLayout_3) self.horizontalLayout_6.addLayout(self.verticalLayout_13) self.horizontalLayout_5 = QHBoxLayout() self.horizontalLayout_5.setObjectName("horizontalLayout_5") self.verticalLayout_14 = QVBoxLayout() self.verticalLayout_14.setObjectName("verticalLayout_14") self.label_21 = QLabel(self.scrollAreaWidgetContents) sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.label_21.sizePolicy().hasHeightForWidth()) self.label_21.setSizePolicy(sizePolicy) self.label_21.setAlignment(Qt.AlignRight|Qt.AlignTrailing|Qt.AlignVCenter) self.label_21.setObjectName("label_21") self.verticalLayout_14.addWidget(self.label_21) self.horizontalLayout_4 = QHBoxLayout() self.horizontalLayout_4.setObjectName("horizontalLayout_4") spacerItem = QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum) self.horizontalLayout_4.addItem(spacerItem) self.btnColour = QPushButton(self.scrollAreaWidgetContents) sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.btnColour.sizePolicy().hasHeightForWidth()) self.btnColour.setSizePolicy(sizePolicy) self.btnColour.setObjectName("btnColour") self.horizontalLayout_4.addWidget(self.btnColour) self.verticalLayout_14.addLayout(self.horizontalLayout_4) self.horizontalLayout_5.addLayout(self.verticalLayout_14) self.frmColour = QFrame(self.scrollAreaWidgetContents) sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.frmColour.sizePolicy().hasHeightForWidth()) self.frmColour.setSizePolicy(sizePolicy) self.frmColour.setMinimumSize(QSize(45, 45)) self.frmColour.setSizeIncrement(QSize(1, 1)) self.frmColour.setBaseSize(QSize(0, 0)) self.frmColour.setFrameShape(QFrame.StyledPanel) self.frmColour.setFrameShadow(QFrame.Raised) self.frmColour.setObjectName("frmColour") self.horizontalLayout_5.addWidget(self.frmColour) self.horizontalLayout_6.addLayout(self.horizontalLayout_5) self.gridLayout_6.addLayout(self.horizontalLayout_6, 4, 0, 1, 1) self.verticalLayout_2 = QVBoxLayout() self.verticalLayout_2.setObjectName("verticalLayout_2") self.label_6 = QLabel(self.scrollAreaWidgetContents) self.label_6.setObjectName("label_6") self.verticalLayout_2.addWidget(self.label_6) self.comboTaxonField = QComboBox(self.scrollAreaWidgetContents) self.comboTaxonField.setObjectName("comboTaxonField") self.verticalLayout_2.addWidget(self.comboTaxonField) self.gridLayout_6.addLayout(self.verticalLayout_2, 2, 0, 1, 1) self.verticalLayout_5 = QVBoxLayout() self.verticalLayout_5.setObjectName("verticalLayout_5") self.label_9 = QLabel(self.scrollAreaWidgetContents) self.label_9.setObjectName("label_9") self.verticalLayout_5.addWidget(self.label_9) self.horizontalLayout = QHBoxLayout() self.horizontalLayout.setObjectName("horizontalLayout") self.leOutDir = QLineEdit(self.scrollAreaWidgetContents) self.leOutDir.setPlaceholderText("") self.leOutDir.setObjectName("leOutDir") self.horizontalLayout.addWidget(self.leOutDir) self.btnBrowse = QPushButton(self.scrollAreaWidgetContents) self.btnBrowse.setObjectName("btnBrowse") self.horizontalLayout.addWidget(self.btnBrowse) self.verticalLayout_5.addLayout(self.horizontalLayout) self.gridLayout_6.addLayout(self.verticalLayout_5, 5, 0, 1, 1) self.verticalLayout_6 = QVBoxLayout() self.verticalLayout_6.setObjectName("verticalLayout_6") self.label = QLabel(self.scrollAreaWidgetContents) self.label.setObjectName("label") self.verticalLayout_6.addWidget(self.label) self.gridLayout = QGridLayout() self.gridLayout.setObjectName("gridLayout") self.label_2 = QLabel(self.scrollAreaWidgetContents) self.label_2.setObjectName("label_2") self.gridLayout.addWidget(self.label_2, 0, 0, 1, 1) self.comboSecondary = QComboBox(self.scrollAreaWidgetContents) self.comboSecondary.setObjectName("comboSecondary") self.gridLayout.addWidget(self.comboSecondary, 1, 1, 1, 1) self.comboSurface = QComboBox(self.scrollAreaWidgetContents) self.comboSurface.setObjectName("comboSurface") self.gridLayout.addWidget(self.comboSurface, 2, 1, 1, 1) self.label_3 = QLabel(self.scrollAreaWidgetContents) self.label_3.setObjectName("label_3") self.gridLayout.addWidget(self.label_3, 1, 0, 1, 1) self.label_4 = QLabel(self.scrollAreaWidgetContents) self.label_4.setObjectName("label_4") self.gridLayout.addWidget(self.label_4, 2, 0, 1, 1) self.comboBase = QComboBox(self.scrollAreaWidgetContents) self.comboBase.setObjectName("comboBase") self.gridLayout.addWidget(self.comboBase, 0, 1, 1, 1) self.gridLayout.setColumnStretch(0, 1) self.gridLayout.setColumnStretch(1, 3) self.verticalLayout_6.addLayout(self.gridLayout) self.gridLayout_6.addLayout(self.verticalLayout_6, 0, 0, 1, 1) self.verticalLayout_3 = QVBoxLayout() self.verticalLayout_3.setObjectName("verticalLayout_3") self.label_7 = QLabel(self.scrollAreaWidgetContents) self.label_7.setObjectName("label_7") self.verticalLayout_3.addWidget(self.label_7) self.comboGrid = QComboBox(self.scrollAreaWidgetContents) self.comboGrid.setObjectName("comboGrid") self.verticalLayout_3.addWidget(self.comboGrid) self.verticalLayout_4 = QVBoxLayout() self.verticalLayout_4.setObjectName("verticalLayout_4") self.label_8 = QLabel(self.scrollAreaWidgetContents) self.label_8.setObjectName("label_8") self.verticalLayout_4.addWidget(self.label_8) self.gridLayout_2 = QGridLayout() self.gridLayout_2.setObjectName("gridLayout_2") self.leMaxY = QLineEdit(self.scrollAreaWidgetContents) self.leMaxY.setObjectName("leMaxY") self.gridLayout_2.addWidget(self.leMaxY, 0, 1, 1, 1) self.leMinX = QLineEdit(self.scrollAreaWidgetContents) self.leMinX.setObjectName("leMinX") self.gridLayout_2.addWidget(self.leMinX, 1, 0, 1, 1) self.leMaxX = QLineEdit(self.scrollAreaWidgetContents) self.leMaxX.setObjectName("leMaxX") self.gridLayout_2.addWidget(self.leMaxX, 1, 2, 1, 1) self.leMinY = QLineEdit(self.scrollAreaWidgetContents) self.leMinY.setObjectName("leMinY") self.gridLayout_2.addWidget(self.leMinY, 2, 1, 1, 1) self.btnExtent = QPushButton(self.scrollAreaWidgetContents) self.btnExtent.setObjectName("btnExtent") self.gridLayout_2.addWidget(self.btnExtent, 1, 1, 1, 1) self.verticalLayout_4.addLayout(self.gridLayout_2) self.verticalLayout_3.addLayout(self.verticalLayout_4) self.gridLayout_6.addLayout(self.verticalLayout_3, 3, 0, 1, 1) self.scrollArea.setWidget(self.scrollAreaWidgetContents) self.gridLayout_3.addWidget(self.scrollArea, 0, 0, 1, 1) self.buttonBox = QDialogButtonBox(DistroMap) self.buttonBox.setOrientation(Qt.Horizontal) self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel|QDialogButtonBox.Ok) self.buttonBox.setObjectName("buttonBox") self.gridLayout_3.addWidget(self.buttonBox, 2, 0, 1, 1) self.progressBar = QProgressBar(DistroMap) self.progressBar.setProperty("value", 0) self.progressBar.setObjectName("progressBar") self.gridLayout_3.addWidget(self.progressBar, 1, 0, 1, 1) self.retranslateUi(DistroMap) self.buttonBox.rejected.connect(DistroMap.reject) QMetaObject.connectSlotsByName(DistroMap) def retranslateUi(self, DistroMap): DistroMap.setWindowTitle(QApplication.translate("DistroMap", "Distribution Map Generator", None)) self.label_5.setText(QApplication.translate("DistroMap", "Point localities layer", None)) self.label_19.setText(QApplication.translate("DistroMap", "Output resolution", None)) self.label_20.setText(QApplication.translate("DistroMap", "x", None)) self.label_21.setText(QApplication.translate("DistroMap", "Map background", None)) self.btnColour.setText(QApplication.translate("DistroMap", "Change", None)) self.label_6.setText(QApplication.translate("DistroMap", "Taxon identifier field", None)) self.label_9.setText(QApplication.translate("DistroMap", "Output directory", None)) self.btnBrowse.setText(QApplication.translate("DistroMap", "Browse...", None)) self.label.setText(QApplication.translate("DistroMap", "Background layers:", None)) self.label_2.setText(QApplication.translate("DistroMap", "Base", None)) self.label_3.setText(QApplication.translate("DistroMap", "Secondary", None)) self.label_4.setText(QApplication.translate("DistroMap", "Surface", None)) self.label_7.setText(QApplication.translate("DistroMap", "Grid layer", None)) self.label_8.setText(QApplication.translate("DistroMap", "Output extent:", None)) self.leMaxY.setText(QApplication.translate("DistroMap", "-21.00", None)) self.leMinX.setText(QApplication.translate("DistroMap", "14.75", None)) self.leMaxX.setText(QApplication.translate("DistroMap", "34.00", None)) self.leMinY.setText(QApplication.translate("DistroMap", "-36.00", None)) self.btnExtent.setText(QApplication.translate("DistroMap", "Use current", None))
class Ui_form1(object): def setupUi(self, form1): form1.setObjectName(_fromUtf8("form1")) form1.resize(400, 253) form1.setFocusPolicy(QtCore.Qt.TabFocus) form1.setWindowTitle(_fromUtf8("Kuwahara filter")) icon = QtGui.QIcon() icon.addPixmap(QtGui.QPixmap(_fromUtf8(":/qgis.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off) form1.setWindowIcon(icon) self.label = QLabel(form1) self.label.setGeometry(QtCore.QRect(21, 10, 111, 20)) font = QtGui.QFont() font.setPointSize(10) self.label.setFont(font) self.label.setToolTip(_fromUtf8("")) self.label.setObjectName(_fromUtf8("label")) self.outputb = QPushButton(form1) self.outputb.setGeometry(QtCore.QRect(320, 47, 31, 23)) self.outputb.setObjectName(_fromUtf8("outputb")) self.label_2 = QLabel(form1) self.label_2.setGeometry(QtCore.QRect(22, 49, 101, 20)) font = QtGui.QFont() font.setPointSize(10) self.label_2.setFont(font) self.label_2.setToolTip(_fromUtf8("")) self.label_2.setObjectName(_fromUtf8("label_2")) self.progressBar = QProgressBar(form1) self.progressBar.setGeometry(QtCore.QRect(19, 220, 361, 23)) self.progressBar.setProperty(_fromUtf8("value"), 24) self.progressBar.setObjectName(_fromUtf8("progressBar")) self.label_3 = QLabel(form1) self.label_3.setGeometry(QtCore.QRect(22, 88, 131, 20)) font = QtGui.QFont() font.setPointSize(10) self.label_3.setFont(font) self.label_3.setObjectName(_fromUtf8("label_3")) self.label_4 = QLabel(form1) self.label_4.setGeometry(QtCore.QRect(21, 125, 181, 20)) font = QtGui.QFont() font.setPointSize(10) self.label_4.setFont(font) self.label_4.setObjectName(_fromUtf8("label_4")) self.run = QPushButton(form1) self.run.setGeometry(QtCore.QRect(139, 185, 101, 23)) self.run.setObjectName(_fromUtf8("run")) self.inputbox = QgsMapLayerComboBox(form1) self.inputbox.setGeometry(QtCore.QRect(141, 10, 170, 22)) self.inputbox.setObjectName(_fromUtf8("input")) self.output = QLineEdit(form1) self.output.setGeometry(QtCore.QRect(149, 45, 160, 28)) self.output.setAlignment(QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter) self.output.setObjectName(_fromUtf8("output")) self.refb = QLineEdit(form1) self.refb.setGeometry(QtCore.QRect(149, 82, 160, 28)) self.refb.setObjectName(_fromUtf8("refb")) self.mem = QLineEdit(form1) self.mem.setGeometry(QtCore.QRect(208, 120, 101, 28)) self.mem.setObjectName(_fromUtf8("mem")) self.addout = QCheckBox(form1) self.addout.setGeometry(QtCore.QRect(100, 158, 171, 17)) self.addout.setChecked(True) self.addout.setObjectName(_fromUtf8("checkBox")) self.inputb = QPushButton(form1) self.inputb.setGeometry(QtCore.QRect(320, 10, 31, 23)) self.inputb.setObjectName(_fromUtf8("inputb")) self.retranslateUi(form1) self.setWindowFlags(QtCore.Qt.WindowFlags(QtCore.Qt.WindowMinimizeButtonHint | QtCore.Qt.WindowMaximizeButtonHint | QtCore.Qt.WindowCloseButtonHint)) QtCore.QMetaObject.connectSlotsByName(form1) def retranslateUi(self, form1): self.label.setText(QtCore.QCoreApplication.translate("form1", "Input raster")) self.outputb.setText("...") self.label_2.setText(QApplication.translate("form1", "Output raster")) self.label_3.setToolTip(QApplication.translate("form1", "Reference band from which variances will be calculated to choose subwindow mean.")) self.label_3.setText(QApplication.translate("form1", "Reference band")) self.label_4.setToolTip(QApplication.translate("form1", "Maximum memory usage in megabytes (it is an approximated value, since algorithm will only choose how many lines will be read at once).")) self.label_4.setText(QApplication.translate("form1", "Max memory usage (MB)")) self.run.setText(QApplication.translate("form1", "Run")) self.output.setPlaceholderText(QApplication.translate("form1", "<temporary file>")) self.refb.setToolTip(QApplication.translate("form1", "Reference band from which variances will be calculated to choose subwindow mean.")) self.refb.setText("1") self.mem.setToolTip(QApplication.translate("form1", "Maximum memory usage in MeB (it is an approximated value, since algorithm will only choose how many lines will be read at once).")) self.mem.setText("100") self.addout.setText(QApplication.translate("form1", "Add results to project")) self.inputb.setText("...")
class Ui_Dialog(object): def setupUi(self, Dialog): Dialog.setObjectName("Dialog") Dialog.resize( QtCore.QSize(QtCore.QRect(0, 0, 440, 660).size()).expandedTo( Dialog.minimumSizeHint())) self.gridlayout = QGridLayout(Dialog) self.gridlayout.setObjectName("gridlayout") font = QFont() font.setPointSize(15) font.setWeight(50) font.setBold(True) self.label_2 = QLabel(Dialog) self.label_2.setFont(font) self.label_2.setTextFormat(QtCore.Qt.RichText) self.label_2.setObjectName("label_2") self.gridlayout.addWidget(self.label_2, 1, 1, 1, 2) self.textEdit = QTextEdit(Dialog) palette = QPalette() brush = QBrush(QColor(0, 0, 0, 0)) brush.setStyle(QtCore.Qt.SolidPattern) palette.setBrush(QPalette.Active, QPalette.Base, brush) brush = QBrush(QColor(0, 0, 0, 0)) brush.setStyle(QtCore.Qt.SolidPattern) palette.setBrush(QPalette.Inactive, QPalette.Base, brush) brush = QBrush(QColor(255, 255, 255)) brush.setStyle(QtCore.Qt.SolidPattern) palette.setBrush(QPalette.Disabled, QPalette.Base, brush) self.textEdit.setPalette(palette) self.textEdit.setAutoFillBackground(True) self.textEdit.width = 320 self.textEdit.height = 360 self.textEdit.setFrameShape(QFrame.NoFrame) self.textEdit.setFrameShadow(QFrame.Plain) self.textEdit.setReadOnly(True) self.textEdit.setObjectName("textEdit") self.textEdit.setTextInteractionFlags(QtCore.Qt.TextBrowserInteraction) self.gridlayout.addWidget(self.textEdit, 2, 1, 5, 2) self.pushButton = QPushButton(Dialog) self.pushButton.setObjectName("pushButton") self.gridlayout.addWidget(self.pushButton, 4, 2, 1, 1) spacerItem = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding) self.gridlayout.addItem(spacerItem, 3, 1, 1, 1) self.retranslateUi(Dialog) self.pushButton.clicked.connect(Dialog.reject) QtCore.QMetaObject.connectSlotsByName(Dialog) def retranslateUi(self, Dialog): Dialog.setWindowTitle( QApplication.translate("Dialog", "GroupPointsWithinDistance", None)) self.label_2.setText( QApplication.translate("Dialog", "GroupPointsWithinDistance 0.2", None)) self.textEdit.setHtml( QApplication.translate( "Dialog", "<html><head><meta name=\"qrichtext\" content=\"1\" /><style type=\"text/css\">\n" "p, li { white-space: pre-wrap; }\n" "</style></head><body style=\" font-family:\'Sans Serif\'; font-size:8pt; font-weight:400; font-style:normal;\">\n" "<p style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-family:\'MS Shell Dlg 2\'; font-size:8pt;\"><span style=\" font-weight:600;\">" " GroupPointsWithinDistance 0.2 :</span>" " A little QGIS plugin to find and group/aggregate points of a points' layer if they are at a given distance of one another.</b>\n" + " \n" + " <br><b>WARNING:</b><br><b> Work with projected datas only, in other words do not use geographical (long-lat type) reference systems !</b>\n " + " \n" + " \n" + "This plugin is meant to deal with points datas (not multipoints, convert first to points) (for instance faunistic or floristic observations), nearby from one another, that the user wants to be regrouped/aggregated as a station.\n" + "\n" + " \n" + "The user should appreciate and cheack which distance to use, and - may be - keep the distance chosen as small as possible in order to avoid '" 'chains effect' "' and producing too widespread groups .\n" + " \n" + "The plugin produces a layer of point called '" 'input_layer_name_aggregated_with_Distance' "' with 3 mores attributes: \n" + " \n" + " - Point_id: the point id, \n" + " \n" + " - NumAggreg: the '" 'aggregates id number' "' \n" + " \n" + " - Nb_Pts: the number of regrouped points, \n " + "\n" + " \n" + " - List_Pts: the list of the points ids in the aggregate. \n" + "\n" + " \n" + " \n" + "\n" + " The plugin also produce a line layer, with not all lines connecting points of a same aggregate but showing only the very one of the connections that were made to link the points as part of a same aggregate." " the plugin also produces a layer of polygons overlaping the regrouped points within distance with an attribute table with also NumAggreg,Nb_Pts,List_Pts attributes. \n " + "\n" + " \n" + " The polygons are buffers (D/100) of the convex hull polygons of the aggregated points \n " + " \n" + "\n" + "<br><b>WARNING 2:</b><br> The polygons are meant - as the lines - only to show the aggregates but they overlap often points that are not part of the aggregate. The lines can be used for that matter \n" + "<br><b>In order to select point of an aggregate only consider the point table attribute !</b><br>" " \n" + "\n" + " <br><b><i>NOTA BENE: all rasters should be unchecked in layer panel or the plugin won't work !</i></b></br>" " This plugin is not a part of Qgis engine and any problems should be reported only to the author. </p></td></tr></table>" "<p style=\"-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"></p>\n" "<p style=\"margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\">" " " "<br><b>[email protected]</b><br>" "<br><br><i>code 0.2 (26 march 2019).</i></p></body></html>", None)) self.pushButton.setText(QApplication.translate("Dialog", "OK", None))
class Ui_Dialog(object): """ def __init__(self, iface): self.iface = iface """ def setupUi(self, Dialog): self.iface = iface Dialog.setObjectName("Dialog") Dialog.resize( QtCore.QSize(QtCore.QRect(0, 0, 350, 250).size()).expandedTo( Dialog.minimumSizeHint())) Dialog.setWindowTitle("GroupPointsWithinDistance") # QLabel lancer recherche self.label10 = QLabel(Dialog) self.label10.setGeometry(QtCore.QRect(15, 15, 320, 18)) self.label10.setObjectName("label10") self.label10.setText("Select a layer with points to regroup: ") ListeCouchesPoint = [""] NbCouches = self.iface.mapCanvas().layerCount() if NbCouches == 0: QMessageBox.information(None, "information:", "No layers ! ") else: for i in range(0, NbCouches): couche = self.iface.mapCanvas().layer(i) # 0 pour point if couche.geometryType() == 0 or couche.geometryType() == 3: if couche.isValid(): ListeCouchesPoint.append(couche.name()) else: QMessageBox.information(None, "information:", "No layers with points ! ") return None self.ComboBoxPoints = QComboBox(Dialog) self.ComboBoxPoints.setMinimumSize(QtCore.QSize(320, 25)) self.ComboBoxPoints.setMaximumSize(QtCore.QSize(320, 25)) self.ComboBoxPoints.setGeometry(QtCore.QRect(10, 35, 320, 25)) self.ComboBoxPoints.setObjectName("ComboBoxPoints") for i in range(len(ListeCouchesPoint)): self.ComboBoxPoints.addItem(ListeCouchesPoint[i]) # QLabel entrer Enter distance of recherch self.labelResearchDistance = QLabel(Dialog) self.labelResearchDistance.setGeometry(QtCore.QRect(15, 80, 240, 23)) self.labelResearchDistance.setObjectName(" ResearchDistance") self.labelResearchDistance.setText("Enter distance of research :") #Exemple de QDoubleSpinBox self.dsbResearchDistance = QDoubleSpinBox(Dialog) self.dsbResearchDistance.setMinimumSize(QtCore.QSize(70, 23)) self.dsbResearchDistance.setMaximumSize(QtCore.QSize(70, 23)) self.dsbResearchDistance.setGeometry(QtCore.QRect(180, 80, 70, 23)) self.dsbResearchDistance.setObjectName("dsb") #self.dsbResearchDistance.setValue(10.0) self.dsbResearchDistance.setDecimals(1) self.dsbResearchDistance.setSingleStep(10.0) self.dsbResearchDistance.setRange(0, 1000000) self.dsbResearchDistance.setProperty("value", 100.0) #self.dsbResearchDistance.valueChanged.connect(self.onValueChanged) #Exemple de QPushButton self.DoButton = QPushButton(Dialog) self.DoButton.setMinimumSize(QtCore.QSize(280, 20)) self.DoButton.setMaximumSize(QtCore.QSize(280, 20)) self.DoButton.setGeometry(QtCore.QRect(15, 120, 280, 20)) self.DoButton.setObjectName("DoButton") self.DoButton.setText(" Let's make aggregates - being patient !") #Exemple de QLCDNumber self.progressBar = QProgressBar(Dialog) self.progressBar.setProperty("value", 0) self.progressBar.setMinimumSize(QtCore.QSize(260, 15)) self.progressBar.setMaximumSize(QtCore.QSize(260, 15)) self.progressBar.setGeometry(QtCore.QRect(30, 155, 260, 15)) self.progressBar.setAlignment(QtCore.Qt.AlignCenter) self.progressBar.setTextVisible(True) self.progressBar.setObjectName("progressBar") self.progressBar.setStyleSheet( """QProgressBar {border: 2px solid grey; border-radius: 5px; text-align: center;}""" """QProgressBar::chunk {background-color: #6C96C6; width: 20px;}""" ) #Pose a minima une valeur de la barre de progression / slide contrôle self.progressBar.setValue(0) #Exemple de QPushButton self.aboutButton = QPushButton(Dialog) self.aboutButton.setMinimumSize(QtCore.QSize(70, 20)) self.aboutButton.setMaximumSize(QtCore.QSize(70, 20)) self.aboutButton.setGeometry(QtCore.QRect(30, 195, 70, 23)) self.aboutButton.setObjectName("aboutButton") self.aboutButton.setText(" Read me ") self.PushButton = QPushButton(Dialog) self.PushButton.setMinimumSize(QtCore.QSize(100, 20)) self.PushButton.setMaximumSize(QtCore.QSize(100, 20)) self.PushButton.setGeometry(QtCore.QRect(185, 195, 100, 20)) self.PushButton.setObjectName("PushButton") self.PushButton.setText("Close") self.PushButton.clicked.connect(Dialog.reject) self.ComboBoxPoints.activated[str].connect(self.onComboP) self.aboutButton.clicked.connect(self.doAbout) self.DoButton.clicked.connect(self.Run) QtCore.QMetaObject.connectSlotsByName(Dialog) def onComboP(self): global SelectionP SelectionP = self.ComboBoxPoints.currentText() def doAbout(self): d = doAboutGroupPointsWithinDistance.Dialog() d.exec_() def Run(self): D = 0.0 D = self.dsbResearchDistance.value() #QMessageBox.information(None,"information:"," D : "+str(D)) DicoP1 = {} DicoA = {} counterProgess = 0 compteur_pt = 0 layerP = fonctionsGPWD.getVectorLayerByName(SelectionP) # on parcourt la couche de points et on stocke dans les dictionnaire DicoP1 les points # the points of the point laye are put into a dictionnary for featP in layerP.getFeatures(): Point_id = featP.id() geomP1 = featP.geometry() Point1 = geomP1.asPoint() DicoP1[Point_id] = [Point1] compteur_pt += 1 if D == 0: QMessageBox.information(None, "information:", "Zero is not a value for D !") #zdim est le compteur de la progress bar zDim = compteur_pt counterProgess = 0 cpt_agg = 1 nb = 0 liste_id = [] liste_pt = [] liste_aggreg_pt = [] DicoSegments = {} firstDicoSegments = True T = True while len(DicoP1) != 0: first = True zPercent = int(100 * counterProgess / zDim) self.progressBar.setValue(zPercent) nb = 0 for keyD1 in list(DicoP1.keys()): P1 = DicoP1[keyD1][0] if first: # we pick a first point and delete it from the dictionnary we point are stored T = True first = False nb += 1 liste_id = [keyD1] liste_pt = [P1] counterProgess += 1 del DicoP1[keyD1] while T: # We are generating an aggregates and making it grows # by adding points at distance from the point it contains # and repeating the research all over again as soon a poitn is added # untill none are added for pt in liste_pt: compteur_corresP = 0 for keyD1 in list(DicoP1.keys()): P1 = DicoP1[keyD1][0] if fonctionsGPWD.mag(fonctionsGPWD.vect( pt, P1)) < D: # one point at distance found compteur_corresId = 0 for idp in liste_id: if keyD1 == idp: # is this point already added in the aggregate compteur_corresId += 1 if compteur_corresId == 0: # if not let s add it nb += 1 liste_id.append(keyD1) liste_pt.append(P1) compteur_corresP += 1 counterProgess += 1 # boucle des segments # interpoint line loop idseg = '' # a segment as an id made of the points id order ordered id: smallerid-biggerid idseg = str(keyD1) + '-' + str(idp) idseg_reverse = str(idp) + '-' + str(keyD1) if firstDicoSegments: firstDicoSegments = False if int(keyD1) > int(idp): idseg = idseg_reverse DicoSegments[idseg] = [[pt, P1], idp, keyD1, cpt_agg] else: DicoSegments[idseg] = [[P1, pt], keyD1, idp, cpt_agg] else: for idseg_cheack in list( DicoSegments.keys()): if idseg == idseg_cheack or idseg_reverse == idseg_cheack: pass else: if int(keyD1) > int(idp): idseg = idseg_reverse DicoSegments[idseg] = [[ pt, P1 ], idp, keyD1, cpt_agg] else: DicoSegments[idseg] = [[ P1, pt ], keyD1, idp, cpt_agg] if compteur_corresP == 0: # if no more points are find then we are over with the previous aggregate T = False DicoA[cpt_agg] = [nb, liste_id, liste_pt, DicoSegments] cpt_agg += 1 for id in liste_id: for keyD1 in list(DicoP1.keys()): if id == keyD1: del DicoP1[keyD1] # on fabrique un polygone buffer de D/100 # du convexHull de tous les points de l'agregat # pour les operateur Pyqgis # voir http://www.qgis.org/api/classQgsGeometry.html#a1699b205d01c365a50ead2d0bf2bbcfb DicoP4 = {} for key2 in list(DicoA.keys()): list_pt = [] list_pt = DicoA[key2][2] nb_pt = 0 nb_pt = DicoA[key2][0] Liste_id = [] Liste_id = DicoA[key2][1] buff = 0.0 first = True for pt in list_pt: if first: first = False #https://docs.qgis.org/testing/en/docs/pyqgis_developer_cookbook/geometry.html g0 = QgsGeometry().fromPointXY(pt) else: g0 = QgsGeometry().fromPointXY(pt).combine( g0) # combine pour union car union reserve C++ buff = D / 100 P = g0.convexHull() B = P.buffer(buff, 5) DicoP4[key2] = [B, Liste_id, nb_pt] zPercent = int(100 * counterProgess / zDim) self.progressBar.setValue(zPercent) self.iface.mapCanvas().refresh() STATIONS = QgsVectorLayer( "MultiPolygon", "Polygons_under_AGGREGATES_D" + str(D) + "_OF_" + str(layerP.name()), "memory") QgsProject.instance().addMapLayer(STATIONS) prSTATIONS = STATIONS.dataProvider() listFieldsS = [] listFieldsS.append(QgsField("NumAggreg", QVariant.String)) listFieldsS.append(QgsField("List_Pts", QVariant.String)) listFieldsS.append(QgsField("Nb_Pts", QVariant.Int)) prSTATIONS.addAttributes(listFieldsS) STATIONS.startEditing() newfeatSTATIONS = QgsFeature() for keyP4 in DicoP4.keys(): GeomPoly = DicoP4[keyP4][0] newfeatSTATIONS = QgsFeature() newfeatSTATIONS.setGeometry(GeomPoly) toto = '' first = True for t in DicoP4[keyP4][1]: if first: first = False toto = str(t) else: toto = toto + ' - ' + str(t) NbObs = DicoP4[keyP4][2] ValuesSTATIONS = [keyP4] ValuesSTATIONS.append(toto) ValuesSTATIONS.append(NbObs) newfeatSTATIONS.setAttributes(ValuesSTATIONS) prSTATIONS.addFeatures([newfeatSTATIONS]) STATIONS.commitChanges() iface.mapCanvas().refresh() SEGMENTS = QgsVectorLayer( "MultiLineString", "Lines_from_" + str(layerP.name()) + "_Aggregates_with_D" + str(D), "memory") QgsProject.instance().addMapLayer(SEGMENTS) prSEGMENTS = SEGMENTS.dataProvider() listFields = [] listFields.append(QgsField("NumAgregat", QVariant.String)) listFields.append(QgsField("Nb_Pts", QVariant.Int)) prSEGMENTS.addAttributes(listFields) SEGMENTS.startEditing() newfeatSEGMENTS = QgsFeature() attributs = [] for keyA in DicoA.keys(): DicoSeg = DicoA[keyA][3] NbObs = DicoA[keyA][0] firstSEG = True MultiLine = [] GeomLine = QgsGeometry for keyPair in DicoSeg.keys(): if DicoSeg[keyPair][3] == keyA: if firstSEG: firstSEG = False MultiLine = [] MultiLine = [DicoSeg[keyPair][0]] else: MultiLine.append(DicoSeg[keyPair][0]) GeomLine = QgsGeometry.fromMultiPolylineXY(MultiLine) NumAg = keyA newfeatSEGMENTS = QgsFeature() newfeatSEGMENTS.setGeometry(GeomLine) ValuesSEGMENTS = [NumAg] ValuesSEGMENTS.append(NbObs) newfeatSEGMENTS.setAttributes(ValuesSEGMENTS) prSEGMENTS.addFeatures([newfeatSEGMENTS]) SEGMENTS.commitChanges() iface.mapCanvas().refresh() # modification de la table de point initiale pour ajout d un numero d agregat # making of the modified point layer with aggregates code AGGREGATS = QgsVectorLayer( "Point", str(layerP.name()) + "_aggregated_with_D" + str(D), "memory") QgsProject.instance().addMapLayer(AGGREGATS) prAGGREGATS = AGGREGATS.dataProvider() fieldsP = layerP.fields() listFields = [] for f in fieldsP: znameField = f.name() Type = str(f.typeName()) if Type == 'Integer': listFields.append(QgsField(znameField, QVariant.Int)) if Type == 'Real': listFields.append(QgsField(znameField, QVariant.Double)) if Type == 'String': listFields.append(QgsField(znameField, QVariant.String)) else: listFields.append(QgsField(znameField, QVariant.String)) listFields.append(QgsField("Point_id", QVariant.String)) listFields.append(QgsField("NumAggreg", QVariant.String)) listFields.append(QgsField("Nb_Pts", QVariant.Int)) listFields.append(QgsField("List_Pts", QVariant.String)) prAGGREGATS.addAttributes(listFields) AGGREGATS.startEditing() newfeatAGGREGATS = QgsFeature() attributs = [] for featP in layerP.getFeatures(): attributs = featP.attributes() Point_id = featP.id() geomP1 = featP.geometry() NbObs = 1 NumAgregat = 0 for keyP4 in DicoP4.keys(): #GeomPoly=DicoP4[keyP4][0] #if geomP1.intersects(GeomPoly): for ptid in DicoP4[keyP4][1]: if Point_id == ptid: NbObs = DicoP4[keyP4][2] toto = '' first = True for t in DicoP4[keyP4][1]: if first: first = False toto = str(t) else: toto = toto + ' - ' + str(t) list_id = toto NumAgregat = keyP4 newfeatAGGREGATS = QgsFeature() newfeatAGGREGATS.setGeometry(geomP1) ValuesAGGREGATS = attributs ValuesAGGREGATS.append(Point_id) ValuesAGGREGATS.append(NumAgregat) ValuesAGGREGATS.append(NbObs) ValuesAGGREGATS.append(list_id) newfeatAGGREGATS.setAttributes(ValuesAGGREGATS) prAGGREGATS.addFeatures([newfeatAGGREGATS]) AGGREGATS.commitChanges() iface.mapCanvas().refresh()