def main(): """Main function to run the example.""" app = QApplication([]) default_value_parameter = DefaultValueParameter() default_value_parameter.name = 'Value parameter' default_value_parameter.help_text = 'Help text' default_value_parameter.description = 'Description' default_value_parameter.labels = ['Setting', 'Do not use', 'Custom'] default_value_parameter.options = [0, 1, None] parameters = [default_value_parameter] extra_parameters = [(DefaultValueParameter, DefaultValueParameterWidget)] parameter_container = ParameterContainer(parameters, extra_parameters=extra_parameters) parameter_container.setup_ui() widget = QWidget() layout = QGridLayout() layout.addWidget(parameter_container) widget.setLayout(layout) widget.setGeometry(0, 0, 500, 500) widget.show() sys.exit(app.exec_())
def build_minimum_needs_form(self, parameters): """Build minimum needs tab. :param parameters: A list containing element of form :type parameters: list """ # create minimum needs tab scroll_layout = QVBoxLayout() scroll_widget = QWidget() scroll_widget.setLayout(scroll_layout) scroll = QScrollArea() scroll.setWidgetResizable(True) scroll.setWidget(scroll_widget) main_layout = QVBoxLayout() main_layout.addWidget(scroll) main_widget = QWidget() main_widget.setLayout(main_layout) extra_parameters = [(ResourceParameter, ResourceParameterWidget)] parameter_container = ParameterContainer( parameters=parameters, extra_parameters=extra_parameters) parameter_container.setup_ui() scroll_layout.addWidget(parameter_container) self.tabWidget.addTab(main_widget, self.tr('Minimum Needs')) self.tabWidget.tabBar().setVisible(True) self.values['minimum needs'] = parameter_container.get_parameters
def build_post_processor_form(self, form_elements): """Build Post Processor Tab. :param form_elements: A Dictionary containing element of form. :type form_elements: dict """ scroll_layout = QVBoxLayout() scroll_widget = QWidget() scroll_widget.setLayout(scroll_layout) scroll = QScrollArea() scroll.setWidgetResizable(True) scroll.setWidget(scroll_widget) main_layout = QVBoxLayout() main_layout.addWidget(scroll) main_widget = QWidget() main_widget.setLayout(main_layout) self.tabWidget.addTab(main_widget, self.tr('Postprocessors')) self.tabWidget.tabBar().setVisible(True) # create elements for the tab values = OrderedDict() for label, parameters in form_elements.items(): parameter_container = ParameterContainer(parameters) parameter_container.setup_ui(must_scroll=False) scroll_layout.addWidget(parameter_container) input_values = parameter_container.get_parameters values[label] = input_values self.values['postprocessors'] = values scroll_layout.addStretch()
def clear(self): """Clear current state.""" # Adapted from http://stackoverflow.com/a/13103617/1198772 for i in reversed(range(self.kwExtraKeywordsGridLayout.count())): self.kwExtraKeywordsGridLayout.itemAt(i).widget().setParent(None) self.parameters = [] self.parameter_container = ParameterContainer()
def clear(self): """Clear current state.""" # Adapted from http://stackoverflow.com/a/13103617/1198772 for i in reversed(range(self.default_values_grid.count())): self.default_values_grid.itemAt(i).widget().setParent(None) self.parameters = [] self.parameter_container = ParameterContainer()
def __init__(self, parent=None): """Constructor for the tab. :param parent: parent - widget to use as parent (Wizard Dialog). :type parent: QWidget """ WizardStep.__init__(self, parent) self.parameters = [] self.parameter_container = ParameterContainer() self.kwExtraKeywordsGridLayout.addWidget(self.parameter_container)
def set_widgets(self): """Set widgets on the Extra Keywords tab.""" existing_inasafe_default_values = self.parent.get_existing_keyword( 'inasafe_default_values') # Remove old container and parameter if self.parameter_container: self.default_values_grid.removeWidget(self.parameter_container) if self.parameters: self.parameters = [] # Iterate through all inasafe fields # existing_inasafe_default_values for inasafe_field in self.inasafe_fields_for_the_layer(): # Create DefaultSelectParameter parameter = DefaultValueParameter() parameter.guid = inasafe_field['key'] parameter.name = inasafe_field['name'] parameter.is_required = False parameter.help_text = inasafe_field['default_value']['description'] # parameter.description = inasafe_field['default_value'] parameter.element_type = unicode parameter.labels = get_inasafe_default_value_fields( self.parent.setting, inasafe_field['key'])[0] parameter.options = get_inasafe_default_value_fields( self.parent.setting, inasafe_field['key'])[1] if existing_inasafe_default_values: existing_default_value = existing_inasafe_default_values.get( inasafe_field['key']) if existing_default_value: parameter.default = existing_default_value self.parameters.append(parameter) # Create the parameter container and add to the wizard. self.parameter_container = ParameterContainer( self.parameters, extra_parameters=self.extra_parameters) self.parameter_container.setup_ui() self.default_values_grid.addWidget(self.parameter_container) # Set default value to None for parameter_widget in self.parameter_container.\ get_parameter_widgets(): parameter_widget.widget().set_value(None) # Set default value from existing keywords if existing_inasafe_default_values: for guid, default in existing_inasafe_default_values.items(): parameter_widget = self.parameter_container.\ get_parameter_widget_by_guid(guid) if isinstance(parameter_widget, DefaultValueParameterWidget): parameter_widget.set_value(default)
def __init__(self, parent=None): """Constructor for the tab. :param parent: parent - widget to use as parent (Wizard Dialog). :type parent: QWidget """ WizardStep.__init__(self, parent) self.extra_parameters = [(DefaultValueParameter, DefaultValueParameterWidget)] self.parameters = [] self.parameter_container = ParameterContainer( extra_parameters=self.extra_parameters) self.default_values_grid.addWidget(self.parameter_container)
def build_minimum_needs_form(self, parameters): """Build minimum needs tab. :param parameters: A list containing element of form :type parameters: list """ # create minimum needs tab tab = QWidget() form_layout = QGridLayout(tab) form_layout.setContentsMargins(0, 0, 0, 0) parameter_container = ParameterContainer(parameters) form_layout.addWidget(parameter_container) self.tabWidget.addTab(tab, self.tr('Minimum Needs')) self.tabWidget.tabBar().setVisible(True) self.values['minimum needs'] = parameter_container.get_parameters
def __init__(self, parent=None): """Constructor for the tab. :param parent: parent - widget to use as parent (Wizard Dialog). :type parent: QWidget """ WizardStep.__init__(self, parent) self.extra_parameters = [(DefaultSelectParameter, DefaultSelectParameterWidget)] self.parameters = [] self.parameter_container = ParameterContainer( extra_parameters=self.extra_parameters) self.kwExtraKeywordsGridLayout.addWidget(self.parameter_container) self.message_label = QLabel()
def raster_changed(self, index): """Executed when raster is changed :param index: index of the selected raster :return: """ registry = QgsMapLayerRegistry.instance() layer_id = self.cbo_raster_input.itemData( index, QtCore.Qt.UserRole) layer = registry.mapLayer(layer_id) layer_purpose = self.keyword_io.read_keywords(layer, 'layer_purpose') if layer_purpose == 'hazard': impact_function = self.if_registry.filter_by_hazard( self.if_registry.impact_functions, self.keyword_io.read_keywords(layer) ) elif layer_purpose == 'exposure': impact_function = self.if_registry.filter_by_exposure( self.if_registry.impact_functions, self.keyword_io.read_keywords(layer) ) else: impact_function = [] if impact_function: parameters_dict = impact_function[0].parameters threshold_list = [] for param_key, param_value in parameters_dict.iteritems(): if 'threshold' in param_key: threshold_list.append(param_value) if threshold_list: param_container = ParameterContainer(threshold_list) param_container.setup_ui(must_scroll=False) self.threshold_editor.layout().addWidget(param_container) else: empty_threshold_label = QLabel( self.tr('No threshold configuration available ' 'for this layer')) self.threshold_editor.layout().addWidget( empty_threshold_label)
def build_widget(self, form_layout, name, parameter_value): """Create a new form element dynamically based from key_value type. The Parameter Container will be inserted to form_layout. :param form_layout: Mandatory a layout instance :type form_layout: QFormLayout :param name: Mandatory string referencing the key in the function configurable parameters dictionary. :type name: str :param parameter_value: Mandatory representing the value referenced by the key. :type parameter_value: object, list :returns: a function that return the value of widget :raises: None """ input_values = None if parameter_value is not None: # create and add widget to the dialog box # default tab's layout parameter_container = ParameterContainer(parameter_value) parameter_container.setup_ui(must_scroll=False) for w in [ w.widget() for w in parameter_container.get_parameter_widgets() ]: # Rizky : assign error handler for # InputListParameterWidget w.add_row_error_handler = self.explain_errors form_layout.addWidget(parameter_container) # bind parameter input_values = parameter_container.get_parameters self.values[name] = input_values else: LOGGER.debug('build_widget : parameter is None') LOGGER.debug(parameter_value) return input_values
def main(): """Main function to run the example.""" app = QApplication([]) options = OrderedDict([ (DO_NOT_USE, { 'label': 'Do not use', 'value': None, 'type': STATIC, 'constraint': {} }), (GLOBAL_DEFAULT, { 'label': 'Global default', 'value': 0.5, 'type': STATIC, 'constraint': {} }), ( CUSTOM_VALUE, { 'label': 'Custom', 'value': 0.7, # Taken from keywords / recent value 'type': SINGLE_DYNAMIC, 'constraint': { 'min': 0, 'max': 1 } }), ( FIELDS, { 'label': 'Ratio fields', 'value': ['field A', 'field B', 'field C'], # Taken from keywords 'type': MULTIPLE_DYNAMIC, 'constraint': {} }) ]) default_value_parameter = GroupSelectParameter() default_value_parameter.name = 'Group Select parameter' default_value_parameter.help_text = 'Help text' default_value_parameter.description = 'Description' default_value_parameter.options = options default_value_parameter.selected = 'ratio fields' parameters = [default_value_parameter] extra_parameters = [(GroupSelectParameter, GroupSelectParameterWidget)] parameter_container = ParameterContainer(parameters, extra_parameters=extra_parameters) parameter_container.setup_ui() widget = QWidget() layout = QGridLayout() layout.addWidget(parameter_container) widget.setLayout(layout) widget.setGeometry(0, 0, 500, 500) widget.show() sys.exit(app.exec_())
def set_widgets(self): """Set widgets on the Extra Keywords tab.""" self.clear() existing_inasafe_field = self.parent.get_existing_keyword( 'inasafe_fields') existing_inasafe_default_values = self.parent.get_existing_keyword( 'inasafe_default_values') # Remove old container and parameter if self.parameter_container: self.kwExtraKeywordsGridLayout.removeWidget( self.parameter_container) if self.parameters: self.parameters = [] layer_data_provider = self.parent.layer.dataProvider() # Iterate through all inasafe fields # existing_inasafe_default_values for inasafe_field in self.inasafe_fields_for_the_layer(): # Option for Not Available option_list = [no_field] for field in layer_data_provider.fields(): # Check the field type if isinstance(inasafe_field['type'], list): if field.type() in inasafe_field['type']: field_name = field.name() option_list.append('%s' % field_name) else: if field.type() == inasafe_field['type']: field_name = field.name() option_list.append('%s' % field_name) # Create DefaultSelectParameter parameter = DefaultSelectParameter() parameter.guid = inasafe_field['key'] parameter.name = inasafe_field['name'] parameter.is_required = False parameter.description = inasafe_field['description'] parameter.help_text = inasafe_field['help_text'] parameter.element_type = unicode parameter.options_list = option_list parameter.value = no_field parameter.default_labels = get_inasafe_default_value_fields( self.parent.setting, inasafe_field['key'])[0] parameter.default_values = get_inasafe_default_value_fields( self.parent.setting, inasafe_field['key'])[1] parameter.minimum = inasafe_field['default_value'].get('min_value') parameter.maximum = inasafe_field['default_value'].get('max_value') # Check if there is already value in the metadata. if existing_inasafe_field: existing_value = existing_inasafe_field.get( inasafe_field['key']) if existing_value: if existing_value in parameter.options_list: parameter.value = existing_value if existing_inasafe_default_values: existing_default_value = existing_inasafe_default_values.get( inasafe_field['key']) if existing_default_value: parameter.default = existing_default_value self.parameters.append(parameter) # Create the parameter container and add to the wizard. self.parameter_container = ParameterContainer( self.parameters, extra_parameters=self.extra_parameters) self.parameter_container.setup_ui() self.kwExtraKeywordsGridLayout.addWidget(self.parameter_container) # Add Message label self.kwExtraKeywordsGridLayout.addWidget(self.message_label) # Set default value to None for parameter_widget in self.parameter_container.\ get_parameter_widgets(): parameter_widget.widget().set_default(None) # Set selected radio button to 'Do not use' parameter_widget.widget().set_selected_radio_button() # Set default value from existing keywords if existing_inasafe_default_values: for guid, default in existing_inasafe_default_values.items(): parameter_widget = self.parameter_container.\ get_parameter_widget_by_guid(guid) if isinstance(parameter_widget, DefaultSelectParameterWidget): parameter_widget.set_default(default) # Set selected radio button to 'Do not use' parameter_widget.set_selected_radio_button()
def set_widgets(self): """Set widgets on the Extra Keywords tab.""" existing_inasafe_field = self.parent.get_existing_keyword( 'inasafe_fields') # Remove old container and parameter if self.parameter_container: self.kwExtraKeywordsGridLayout.removeWidget( self.parameter_container) if self.parameters: self.parameters = [] layer_data_provider = self.parent.layer.dataProvider() # Iterate through all inasafe fields for inasafe_field in self.inasafe_fields_for_the_layer(): # Option for Not Available option_list = [no_field] for field in layer_data_provider.fields(): # Check the field type if isinstance(inasafe_field['type'], list): if field.type() in inasafe_field['type']: field_name = field.name() option_list.append('%s' % field_name) else: if field.type() == inasafe_field['type']: field_name = field.name() option_list.append('%s' % field_name) # If there is no option, pass if option_list == [no_field]: continue # Create SelectParameter select_parameter = SelectParameter() select_parameter.guid = inasafe_field['key'] select_parameter.name = inasafe_field['name'] select_parameter.is_required = False select_parameter.description = inasafe_field['description'] select_parameter.help_text = inasafe_field['help_text'] select_parameter.element_type = unicode select_parameter.options_list = option_list select_parameter.value = no_field # Check if there is already value in the metadata. if existing_inasafe_field: existing_value = existing_inasafe_field.get( inasafe_field['key']) if existing_value: if existing_value in select_parameter.options_list: select_parameter.value = existing_value self.parameters.append(select_parameter) # Create the parameter container and add to the wizard. self.parameter_container = ParameterContainer(self.parameters) self.parameter_container.setup_ui() self.kwExtraKeywordsGridLayout.addWidget(self.parameter_container) if not self.parameters: no_field_message = tr( 'There is no available field that has match type for the ' 'InaSAFE fields. You can click next.') self.lblInaSAFEFields.setText(no_field_message)
def restore_default_values_page(self): """Setup UI for default values setting.""" # Clear parameters so it doesn't add parameters when # restore from changes. if self.default_value_parameters: self.default_value_parameters = [] if self.default_value_parameter_containers: self.default_value_parameter_containers = [] default_fields = all_default_fields() for field_group in all_field_groups: settable_fields = [] for field in field_group['fields']: if field not in default_fields: continue else: settable_fields.append(field) default_fields.remove(field) if not settable_fields: continue # Create group box for each field group group_box = QGroupBox(self) group_box.setTitle(field_group['name']) self.container_layout.addWidget(group_box) parameters = [] for settable_field in settable_fields: parameter = self.default_field_to_parameter(settable_field) if parameter: parameters.append(parameter) parameter_container = ParameterContainer( parameters, description_text=field_group['description']) parameter_container.setup_ui(must_scroll=False) group_box_inner_layout = QVBoxLayout() group_box_inner_layout.addWidget(parameter_container) group_box.setLayout(group_box_inner_layout) # Add to attribute self.default_value_parameter_containers.append(parameter_container) # Only show non-groups default fields if there is one if len(default_fields) > 0: for default_field in default_fields: parameter = self.default_field_to_parameter(default_field) if parameter: self.default_value_parameters.append(parameter) description_text = tr( 'In this options you can change the global default values for ' 'these variables.') parameter_container = ParameterContainer( self.default_value_parameters, description_text=description_text) parameter_container.setup_ui(must_scroll=False) self.other_group_box = QGroupBox(tr('Non-group fields')) other_group_inner_layout = QVBoxLayout() other_group_inner_layout.addWidget(parameter_container) self.other_group_box.setLayout(other_group_inner_layout) self.container_layout.addWidget(self.other_group_box) # Add to attribute self.default_value_parameter_containers.append(parameter_container)
def set_up_resource_parameters(self): """Set up the resource parameter for the add/edit view. """ name_parameter = StringParameter('UUID-1') name_parameter.name = 'Resource name' name_parameter.help_text = ( 'Name of the resource that will be provided ' 'as part of minimum needs. ' 'e.g. Rice, Water etc.') name_parameter.description = ( 'A <b>resource</b> is something that you provide to displaced ' 'persons in the event of a disaster. The resource will be made ' 'available at IDP camps and may need to be stockpiled by ' 'contingency planners in their preparations for a disaster.') name_parameter.is_required = True name_parameter.value = '' description_parameter = StringParameter('UUID-2') description_parameter.name = 'Resource description' description_parameter.help_text = ( 'Description of the resource that will be provided as part of ' 'minimum needs.') description_parameter.description = ( 'This gives a detailed description of what the resource is and ') description_parameter.is_required = True description_parameter.value = '' unit_parameter = StringParameter('UUID-3') unit_parameter.name = 'Unit' unit_parameter.help_text = ( 'Single unit for the resources spelled out. e.g. litre, ' 'kilogram etc.') unit_parameter.description = ( 'A <b>unit</b> is the basic measurement unit used for computing ' 'the allowance per individual. For example when planning water ' 'rations the unit would be single litre.') unit_parameter.is_required = True unit_parameter.value = '' units_parameter = StringParameter('UUID-4') units_parameter.name = 'Units' units_parameter.help_text = ( 'Multiple units for the resources spelled out. e.g. litres, ' 'kilogram etc.') units_parameter.description = ( '<b>Units</b> are the basic measurement used for computing the ' 'allowance per individual. For example when planning water ' 'rations the units would be litres.') units_parameter.is_required = True units_parameter.value = '' unit_abbreviation_parameter = StringParameter('UUID-5') unit_abbreviation_parameter.name = 'Unit abbreviation' unit_abbreviation_parameter.help_text = ( 'Abbreviations of unit for the resources. e.g. l, kg etc.') unit_abbreviation_parameter.description = ( "A <b>unti abbreviation</b> is the basic measurement unit's " "shortened. For example when planning water rations " "the units would be l.") unit_abbreviation_parameter.is_required = True unit_abbreviation_parameter.value = '' minimum_parameter = FloatParameter('UUID-6') minimum_parameter.name = 'Minimum allowed' minimum_parameter.is_required = True minimum_parameter.precision = 2 minimum_parameter.minimum_allowed_value = -99999.0 minimum_parameter.maximum_allowed_value = 99999.0 minimum_parameter.help_text = ( 'The minimum allowable quantity per person. ') minimum_parameter.description = ( 'The <b>minimum</b> is the minimum allowed quantity of the ' 'resource per person. For example you may dictate that the water ' 'ration per person per day should never be allowed to be less ' 'than 0.5l. This is enforced when tweaking a minimum needs set ' 'before an impact evaluation') minimum_parameter.value = 0.00 maximum_parameter = FloatParameter('UUID-7') maximum_parameter.name = 'Maximum allowed' maximum_parameter.is_required = True maximum_parameter.precision = 2 maximum_parameter.minimum_allowed_value = -99999.0 maximum_parameter.maximum_allowed_value = 99999.0 maximum_parameter.help_text = ( 'The maximum allowable quantity per person. ') maximum_parameter.description = ( 'The <b>maximum</b> is the maximum allowed quantity of the ' 'resource per person. For example you may dictate that the water ' 'ration per person per day should never be allowed to be more ' 'than 50l. This is enforced when tweaking a minimum needs set ' 'before an impact evaluation.') maximum_parameter.value = 100.0 default_parameter = FloatParameter('UUID-8') default_parameter.name = 'Default' default_parameter.is_required = True default_parameter.precision = 2 default_parameter.minimum_allowed_value = -99999.0 default_parameter.maximum_allowed_value = 99999.0 default_parameter.help_text = ( 'The default allowable quantity per person. ') default_parameter.description = ( "The <b>default</b> is the default allowed quantity of the " "resource per person. For example you may indicate that the water " "ration per person weekly should be 67l.") default_parameter.value = 10.0 frequency_parameter = StringParameter('UUID-9') frequency_parameter.name = 'Frequency' frequency_parameter.help_text = ( "The frequency that this resource needs to be provided to a " "displaced person. e.g. weekly, daily, once etc.") frequency_parameter.description = ( "The <b>frequency</b> informs the aid worker how regularly this " "resource needs to be provided to the displaced person.") frequency_parameter.is_required = True frequency_parameter.value = 'weekly' sentence_parameter = StringParameter('UUID-10') sentence_parameter.name = 'Readable sentence' sentence_parameter.help_text = ( 'A readable presentation of the resource.') sentence_parameter.description = ( "A <b>readable sentence</b> is a presentation of the resource " "that displays all pertinent information. If you are unsure then " "use the default. Properties should be included using double " "curly brackets '{{' '}}'. Including the resource name would be " "achieved by including e.g. {{ Resource name }}") sentence_parameter.is_required = True sentence_parameter.value = ( "A displaced person should be provided with " "{{ Default }} {{ Unit }}/{{ Units }}/{{ Unit abbreviation }} of " "{{ Resource name }}. Though no less than {{ Minimum allowed }} " "and no more than {{ Maximum allowed }}. This should be provided " "{{ Frequency }}.") parameters = [ name_parameter, description_parameter, unit_parameter, units_parameter, unit_abbreviation_parameter, default_parameter, minimum_parameter, maximum_parameter, frequency_parameter, sentence_parameter ] parameter_container = ParameterContainer(parameters) layout = QGridLayout() layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(0) layout.addWidget(parameter_container) self.resource_widget.setLayout(layout)
def populate_parameter(self): """Helper to setup the parameter widget.""" used_fields = [] self.parameters = [] for field in self.field_group.get('fields', []): selected_option = DO_NOT_USE options = OrderedDict([ (DO_NOT_USE, { 'label': tr('Do not use'), 'value': None, 'type': STATIC, 'constraint': {} }), ]) # Example: count if field['absolute']: # Used in field options field_label = tr('Count fields') else: # Example: ratio # Used in field options field_label = tr('Ratio fields') global_default_value = get_inasafe_default_value_qsetting( self.setting, GLOBAL, field['key']) options[GLOBAL_DEFAULT] = { 'label': tr('Global default'), 'value': global_default_value, 'type': STATIC, 'constraint': {} } default_custom_value = get_inasafe_default_value_qsetting( self.setting, RECENT, field['key']) custom_value = self.metadata.get( 'inasafe_default_values', {}).get( field['key'], default_custom_value) if field['key'] in self.metadata.get( 'inasafe_default_values', {}): if custom_value == global_default_value: selected_option = GLOBAL_DEFAULT else: selected_option = CUSTOM_VALUE min_value = field['default_value'].get('min_value', 0) max_value = field['default_value'].get('max_value', 100) default_step = (max_value - min_value) / 100.0 step = field['default_value'].get('increment', default_step) options[CUSTOM_VALUE] = { 'label': tr('Custom'), 'value': custom_value, 'type': SINGLE_DYNAMIC, 'constraint': { 'min': min_value, 'max': max_value, 'step': step } } custom_fields = self.metadata.get('inasafe_fields', {}).get( field['key'], []) if field['key'] in self.metadata.get('inasafe_fields', {}): selected_option = FIELDS if isinstance(custom_fields, basestring): custom_fields = [custom_fields] options[FIELDS] = { 'label': field_label, 'value': custom_fields, 'type': MULTIPLE_DYNAMIC, 'constraint': {} } used_fields.extend(custom_fields) parameter = GroupSelectParameter() parameter.guid = field['key'] parameter.name = field['name'] parameter.options = options parameter.selected = selected_option parameter.help_text = field['help_text'] parameter.description = field['description'] self.parameters.append(parameter) self.parameter_container = ParameterContainer( parameters=self.parameters, extra_parameters=self.extra_parameters, vertical=False ) self.parameter_container.setup_ui() constraints = self.field_group.get('constraints', {}) for key, value in constraints.items(): self.parameter_container.add_validator( validators[key], kwargs=value['kwargs'], validation_message=value['message']) self.parameter_layout.addWidget(self.parameter_container) # Set move or copy if self.field_group.get('exclusive', False): # If exclusive, do not add used field. self.populate_field_list(excluded_fields=used_fields) # Use move action since it's exclusive self.field_list.setDefaultDropAction(Qt.MoveAction) # Just make sure that the signal is disconnected try: # noinspection PyUnresolvedReferences self.field_list.itemChanged.disconnect(self.drop_remove) except TypeError: pass # Set header header_text = self.field_group['description'] header_text += '\n\n' + tr( 'You can only map one field to one concept.') else: # If not exclusive, add all field. self.populate_field_list() # Use copy action since it's not exclusive self.field_list.setDefaultDropAction(Qt.CopyAction) # noinspection PyUnresolvedReferences self.field_list.itemChanged.connect( partial(self.drop_remove, field_list=self.field_list)) self.connect_drop_remove_parameter() # Set header header_text = self.field_group['description'] header_text += '\n\n' + tr( 'You can map one field to more than one concepts.') self.header_label.setText(header_text)
def restore_default_values_page(self): """Setup UI for default values setting.""" # Clear parameters so it doesn't add parameters when # restore from changes. if self.default_value_parameters: self.default_value_parameters = [] unordered_parameters = [] default_fields = all_default_fields() for default_field in default_fields: if default_field.get('type') == QVariant.Double: parameter = FloatParameter() elif default_field.get('type') in qvariant_whole_numbers: parameter = IntegerParameter() else: continue default_value = default_field.get('default_value') if not default_value: message = ( 'InaSAFE default field %s does not have default value' % default_field.get('name')) LOGGER.exception(message) continue parameter.guid = default_field.get('key') parameter.name = default_value.get('name') parameter.is_required = True parameter.precision = default_field.get('precision') parameter.minimum_allowed_value = default_value.get( 'min_value', 0) parameter.maximum_allowed_value = default_value.get( 'max_value', 100000000) parameter.help_text = default_value.get('help_text') parameter.description = default_value.get('description') # Check if user ask to restore to the most default value. if self.is_restore_default: parameter._value = default_value.get('default_value') else: # Current value qsetting_default_value = get_inasafe_default_value_qsetting( self.settings, GLOBAL, default_field['key']) # To avoid python error if qsetting_default_value > parameter.maximum_allowed_value: qsetting_default_value = parameter.maximum_allowed_value if qsetting_default_value < parameter.minimum_allowed_value: qsetting_default_value = parameter.minimum_allowed_value parameter.value = qsetting_default_value unordered_parameters.append(parameter) preferred_order = [ youth_ratio_field, adult_ratio_field, elderly_ratio_field ] for order in preferred_order: parameter_index = [ p.guid for p in unordered_parameters].index(order['key']) if parameter_index > -1: self.default_value_parameters.append( unordered_parameters[parameter_index]) unordered_parameters.pop(parameter_index) self.default_value_parameters.extend(unordered_parameters) description_text = tr( 'In this options you can change the global default values for ' 'these variables.') self.default_value_parameter_container = ParameterContainer( self.default_value_parameters, description_text=description_text) self.default_value_parameter_container.setup_ui() self.default_values_layout.addWidget( self.default_value_parameter_container)