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 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 = [] # 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 self.parent.layer.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 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 report', '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 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 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 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.parameters = [] self.parameter_container = ParameterContainer() self.kwExtraKeywordsGridLayout.addWidget(self.parameter_container)
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 __init__(self, parameter, parent=None): """Constructor .. versionadded:: 2.2 :param parameter: A GroupParameter object. :type parameter: GroupParameter """ super(GroupParameterWidget, self).__init__(parameter, parent) # Get the parameter label and use its value as the checkbox text label_item = self.input_layout.itemAt(0) label_widget = label_item.widget() text = label_widget.text() self._enable_check_box = QCheckBox(text) # Tooltips self.setToolTip('Tick here to enable ' + self._parameter.name) # add all widget in the group self._group_layout = QVBoxLayout() self._group_layout.setSpacing(0) if not self._parameter.is_required: self.input_layout.insertWidget(0, self._enable_check_box) # now we don't need the parameter label anymore so chuck it self.input_layout.removeItem(label_item) # Make the sub group appear indented self._group_layout.setContentsMargins(20, 0, 0, 0) else: self._parameter.enable_parameter = True self.main_layout.addLayout(self._group_layout) # Why are we doing imports here? TS from parameters.qt_widgets.parameter_container import ParameterContainer self.param_container = ParameterContainer( parameters=self._parameter.value) self.param_container.setup_ui(must_scroll=parameter.must_scroll) # add handlers # noinspection PyUnresolvedReferences self._enable_check_box.stateChanged.connect( self.on_enable_checkbox_changed) self._enable_check_box.setChecked(self._parameter.enable_parameter) self.on_enable_checkbox_changed(self._parameter.enable_parameter) self._group_layout.addWidget(self.param_container)
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 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 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 = [] for i in reversed(list(range(self.container_layout.count()))): widget = self.container_layout.itemAt(i).widget() if widget is not None: widget.setParent(None) 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'], extra_parameters=extra_parameter) 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, extra_parameters=extra_parameter) 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_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 = [] # 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 self.parent.layer.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 report' 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 report' parameter_widget.set_selected_radio_button()
def main(): """Main function""" application = QApplication([]) 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. Tea, 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-1') description_parameter.name = 'Resource description' description_parameter.help_text = ( 'Description of the resource that will be provided as part of minimum ' 'needs. e.g. Tea, Water etc.') description_parameter.description = ( 'Description of the resource that will be provided as part of minimum ' 'needs. e.g. Tea, Water etc.') description_parameter.is_required = True description_parameter.value = '' unit_parameter = StringParameter('UUID-2') unit_parameter.name = 'Units' unit_parameter.help_text = ('Unit for the resources. e.g. litres, kg etc.') unit_parameter.description = ( 'A <b>unit</b> the basic measurement unit used for computing the ' 'allowance per individual. For example when planning water rations ' 'the units would be litres.') unit_parameter.is_required = True unit_parameter.value = '' minimum_parameter = FloatParameter('UUID-3') minimum_parameter.name = 'Minimum allowed' minimum_parameter.is_required = True minimum_parameter.precision = 3 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.') minimum_parameter.value = 1.0 maximum_parameter = FloatParameter('UUID-3') maximum_parameter.name = 'Minimum allowed' maximum_parameter.is_required = True maximum_parameter.precision = 3 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.') maximum_parameter.value = 1.0 maximum_parameter = FloatParameter('UUID-4') maximum_parameter.name = 'Minimum allowed' maximum_parameter.is_required = True maximum_parameter.precision = 3 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.') maximum_parameter.value = 1.0 default_parameter = FloatParameter('UUID-5') default_parameter.name = 'Default' default_parameter.is_required = True default_parameter.precision = 3 default_parameter.minimum_allowed_value = -99999.0 default_parameter.default_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 per day should be 25l.') default_parameter.value = 1.0 parameters = [ name_parameter, description_parameter, unit_parameter, minimum_parameter, maximum_parameter, default_parameter ] parameter_container = ParameterContainer(parameters) widget = QWidget() layout = QGridLayout() layout.addWidget(parameter_container) widget.setLayout(layout) widget.setGeometry(0, 0, 500, 500) widget.show() new_parameters = parameter_container.get_parameters() for new_parameter in new_parameters: print new_parameter.name, new_parameter.value sys.exit(application.exec_())
def main(): """Main function to run the example.""" from safe.test.utilities import get_qgis_app QGIS_APP, CANVAS, IFACE, PARENT = get_qgis_app(qsetting=INASAFE_TEST) options = OrderedDict([ (DO_NOT_REPORT, { 'label': 'Do not report', '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) def show_error_message(parent, exception): """Generate error message to handle parameter errors :param parent: The widget as a parent of message box :type parent: QWidget :param exception: python Exception or Error :type exception: Exception """ box = QMessageBox() box.critical(parent, 'Error occured', str(exception)) def show_parameter(the_parameter_container): """Print the value of parameter. :param the_parameter_container: A parameter container :type the_parameter_container: ParameterContainer """ def show_parameter_value(a_parameter): if isinstance(a_parameter, GroupParameter): for param in a_parameter.value: show_parameter_value(param) else: print((a_parameter.guid, a_parameter.name, a_parameter.value)) try: the_parameters = the_parameter_container.get_parameters() if the_parameters: for parameter in the_parameters: show_parameter_value(parameter) except Exception as inst: show_error_message(parameter_container, inst) print_button = QPushButton('Print Result') # noinspection PyUnresolvedReferences print_button.clicked.connect( partial(show_parameter, the_parameter_container=parameter_container)) layout.addWidget(print_button) widget.setLayout(layout) widget.setGeometry(0, 0, 500, 500) widget.show() sys.exit(QGIS_APP.exec_())
def set_up_resource_parameters(self): """Set up the resource parameter for the add/edit view. """ name_parameter = StringParameter('UUID-1') name_parameter.name = self.resource_parameters['Resource name'] name_parameter.help_text = tr( 'Name of the resource that will be provided ' 'as part of minimum needs. ' 'e.g. Rice, Water etc.') name_parameter.description = tr( '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 = self.resource_parameters[ 'Resource description'] description_parameter.help_text = tr( 'Description of the resource that will be provided as part of ' 'minimum needs.') description_parameter.description = tr( '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 = self.resource_parameters['Unit'] unit_parameter.help_text = tr( 'Single unit for the resources spelled out. e.g. litre, ' 'kilogram etc.') unit_parameter.description = tr( '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 = self.resource_parameters['Units'] units_parameter.help_text = tr( 'Multiple units for the resources spelled out. e.g. litres, ' 'kilogram etc.') units_parameter.description = tr( '<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 = \ self.resource_parameters['Unit abbreviation'] unit_abbreviation_parameter.help_text = tr( 'Abbreviations of unit for the resources. e.g. l, kg etc.') unit_abbreviation_parameter.description = tr( "A <b>unit 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 = self.resource_parameters['Minimum allowed'] minimum_parameter.is_required = True minimum_parameter.precision = 6 minimum_parameter.minimum_allowed_value = 0.0 minimum_parameter.maximum_allowed_value = 99999.0 minimum_parameter.help_text = tr( 'The minimum allowable quantity per person. ') minimum_parameter.description = tr( '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 = self.resource_parameters['Maximum allowed'] maximum_parameter.is_required = True maximum_parameter.precision = 6 maximum_parameter.minimum_allowed_value = 0.0 maximum_parameter.maximum_allowed_value = 99999.0 maximum_parameter.help_text = tr( 'The maximum allowable quantity per person. ') maximum_parameter.description = tr( '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 67l. This is enforced when tweaking a maximum needs set ' 'before an impact evaluation.') maximum_parameter.value = 100.0 default_parameter = FloatParameter('UUID-8') default_parameter.name = self.resource_parameters['Default'] default_parameter.is_required = True default_parameter.precision = 6 default_parameter.minimum_allowed_value = 0.0 default_parameter.maximum_allowed_value = 99999.0 default_parameter.help_text = tr( 'The default allowable quantity per person. ') default_parameter.description = tr( "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 = self.resource_parameters['Frequency'] frequency_parameter.help_text = tr( "The frequency that this resource needs to be provided to a " "displaced person. e.g. weekly, daily, once etc.") frequency_parameter.description = tr( "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 = tr('weekly') sentence_parameter = TextParameter('UUID-10') sentence_parameter.name = self.resource_parameters['Readable sentence'] sentence_parameter.help_text = tr( 'A readable presentation of the resource.') sentence_parameter.description = tr( "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 = tr( 'A displaced person should be provided with ' '%(default value)s %(unit)s/%(units)s/%(unit abbreviation)s of ' '%(resource name)s. Though no less than %(minimum allowed)s ' 'and no more than %(maximum allowed)s. This should be provided ' '%(frequency)s.' % { 'default value': '{{ Default }}', 'unit': '{{ Unit }}', 'units': '{{ Units }}', 'unit abbreviation': '{{ Unit abbreviation }}', 'resource name': '{{ Resource name }}', 'minimum allowed': '{{ Minimum allowed }}', 'maximum allowed': '{{ Maximum allowed }}', 'frequency': '{{ 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) parameter_container.setup_ui() layout = QGridLayout() layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(0) layout.addWidget(parameter_container) self.parameters_scrollarea.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_REPORT options = OrderedDict([ (DO_NOT_REPORT, { 'label': tr('Do not report'), '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) default_ratio_help_text = tr( 'By default, InaSAFE will calculate the default ratio ' 'however users have the option to include this in the ' 'analysis report. If you do not want to see the default ' 'results in the report choose "do not report".') # 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' + default_ratio_help_text 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' + default_ratio_help_text header_text += '\n\n' + tr( 'You can map one field to more than one concepts.') self.header_label.setText(header_text)
def main(): """Main function to run the example.""" app = QApplication([]) options = OrderedDict([ (DO_NOT_REPORT, { 'label': 'Do not report', '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 main(): """Main function""" app = QApplication([]) def validate_min_max(parent_container): """ :param parent_container: The container that use this validator. :type parent_container: ParameterContainer :return: """ min_value_parameter = parent_container.get_parameter_by_guid( min_integer_parameter.guid) max_value_parameter = parent_container.get_parameter_by_guid( max_integer_parameter.guid) min_value = min_value_parameter.value max_value = max_value_parameter.value print 'min', min_value print 'max', max_value if min_value > max_value: print 'Not valid' return { 'valid': False, 'message': ('Your minimum value (%d) should be less than your maximum ' 'value (%d)' % (min_value, max_value)) } print 'Valid' return {'valid': True, 'message': ''} unit_feet = Unit('130790') unit_feet.load_dictionary(unit_feet_depth) unit_metres = Unit('900713') unit_metres.load_dictionary(unit_metres_depth) string_parameter = StringParameter('28082014') string_parameter.name = 'Province Name' string_parameter.description = 'Name of province.' string_parameter.help_text = ( 'A <b>test help</b> that is very long so that you need to ' 'read it for one minute and you will be tired after read this ' 'description. You are the best user so far. Even better if you read ' 'this description loudly so that all of your friends will be able ' 'to hear you') string_parameter.is_required = True string_parameter.value = 'Daerah Istimewa Yogyakarta' boolean_parameter = BooleanParameter('1231231') boolean_parameter.name = 'Post processor' boolean_parameter.description = 'This is post processor parameter.' boolean_parameter.help_text = ( 'A <b>test help text</b> that is very long so that you need to ' 'read it for one minute and you will be tired after read this ' 'description. You are the best user so far. Even better if you read ' 'this description loudly so that all of your friends will be able ' 'to hear you') boolean_parameter.is_required = True boolean_parameter.value = True float_parameter = FloatParameter() float_parameter.name = 'Flood Depth' float_parameter.is_required = True float_parameter.precision = 3 float_parameter.minimum_allowed_value = 1.0 float_parameter.maximum_allowed_value = 2.0 float_parameter.description = 'The depth of flood.' float_parameter.help_text = ( 'A <b>test _description</b> that is very long so that you need to ' 'read it for one minute and you will be tired after read this ' 'description. You are the best user so far. Even better if you read ' 'this description loudly so that all of your friends will be able ' 'to hear you') float_parameter.unit = unit_feet float_parameter.allowed_units = [unit_metres, unit_feet] float_parameter.value = 1.12 integer_parameter = IntegerParameter() integer_parameter.name = 'Paper' integer_parameter.is_required = True integer_parameter.minimum_allowed_value = 1 integer_parameter.maximum_allowed_value = 5 integer_parameter.description = 'Number of paper' integer_parameter.help_text = ( 'A <b>test _description</b> that is very long so that you need to ' 'read it for one minute and you will be tired after read this ' 'description. You are the best user so far. Even better if you read ' 'this description loudly so that all of your friends will be able ' 'to hear you') integer_parameter.unit = unit_feet integer_parameter.allowed_units = [unit_feet] integer_parameter.value = 3 point_parameter = PointParameter() point_parameter.name = 'Point Parameter' point_parameter.is_required = True point_parameter.description = 'Short help.' point_parameter.help_text = 'Long description for parameter.' point_parameter.value = (0, 1) min_integer_parameter = IntegerParameter() min_integer_parameter.name = 'Minimal Stick Length' min_integer_parameter.is_required = True min_integer_parameter.minimum_allowed_value = 1 min_integer_parameter.maximum_allowed_value = 50 min_integer_parameter.description = 'Minimum length of a stick' min_integer_parameter.help_text = ( 'Minimum length of a stick that are allowed') min_integer_parameter.unit = unit_metres min_integer_parameter.allowed_units = [unit_metres] min_integer_parameter.value = 3 max_integer_parameter = IntegerParameter() max_integer_parameter.name = 'Maximum Stick Length' max_integer_parameter.is_required = True max_integer_parameter.minimum_allowed_value = 1 max_integer_parameter.maximum_allowed_value = 50 max_integer_parameter.description = 'Maximum length of a stick' max_integer_parameter.help_text = ( 'Maximum length of a stick that are allowed') max_integer_parameter.unit = unit_metres max_integer_parameter.allowed_units = [unit_metres] max_integer_parameter.value = 4 list_parameter = ListParameter() list_parameter.name = 'Affected Field' list_parameter.is_required = True list_parameter.maximum_item_count = 3 list_parameter.minimum_item_count = 1 list_parameter.description = 'Column used for affected field' list_parameter.help_text = 'Column used for affected field in the vector' list_parameter.element_type = str list_parameter.options_list = [ 'FLOODPRONE', 'affected', 'floodprone', 'yes/no', '\xddounicode test' ] list_parameter.value = ['FLOODPRONE', 'affected', 'floodprone'] select_parameter = SelectParameter() select_parameter.name = 'Select Affected Field' select_parameter.is_required = True select_parameter.description = 'Column used for affected field' select_parameter.help_text = ( 'Column used for affected field in the vector') select_parameter.element_type = str select_parameter.options_list = [ 'FLOODPRONE', 'affected', 'floodprone', 'yes/no', '\xddounicode test' ] select_parameter.value = 'affected' input_list_parameter = InputListParameter() input_list_parameter.name = 'Thresholds' input_list_parameter.is_required = True input_list_parameter.maximum_item_count = 3 input_list_parameter.minimum_item_count = 1 input_list_parameter.description = 'Specified List of thresholds' input_list_parameter.help_text = 'Some help text' input_list_parameter.element_type = int input_list_parameter.ordering = InputListParameter.DescendingOrder input_list_parameter.value = [1] dict_parameter = DictParameter() dict_parameter.name = 'Dict Parameter' dict_parameter.is_required = True dict_parameter.maximum_item_count = 5 dict_parameter.minimum_item_count = 1 dict_parameter.description = 'Dict Parameter example' dict_parameter.help_text = 'Dict Parameter help text.' dict_parameter.element_type = str dict_parameter.value = { 'foo': 'True', 'bar': '10', 'woo': 'False', 'sub_dict_sample': { 'key1': 'val1', 'key2': 'val2' } } group_parameter = GroupParameter() group_parameter.name = 'Age ratios' group_parameter.is_required = True group_parameter.value = [ string_parameter, integer_parameter, boolean_parameter ] def _custom_validator(value): valid = True if string_parameter.value == 'foo' and integer_parameter.value == \ 3 and boolean_parameter.value is True: valid = False if not valid: raise Exception('Parameter not valid') group_parameter.custom_validator = _custom_validator parameters = [ string_parameter, integer_parameter, boolean_parameter, float_parameter, float_parameter, boolean_parameter, integer_parameter, point_parameter, list_parameter, input_list_parameter, dict_parameter, group_parameter, select_parameter ] extra_parameters = [(PointParameter, PointParameterWidget)] min_max_parameters = [min_integer_parameter, max_integer_parameter] description_text = ( 'These parameters are merely created for showing example only') # description_text = '' parameter_container = ParameterContainer(parameters, extra_parameters=extra_parameters, description_text=description_text) parameter_container.setup_ui() # create error handler parameter_widget = parameter_container.get_parameter_widgets() try: input_list_widget = [ w.widget() for w in parameter_widget if isinstance(w.widget(), InputListParameterWidget) ][0] def add_row_handler(exception): box = QMessageBox() box.critical(input_list_widget, 'Add Row Error', exception.message) input_list_widget.add_row_error_handler = add_row_handler except IndexError: pass parameter_container2 = ParameterContainer( extra_parameters=extra_parameters, description_text='Empty Parameter Container Description') parameter_container2.setup_ui() parameter_container3 = ParameterContainer( parameters=min_max_parameters, extra_parameters=extra_parameters, description_text='Minimum Maximum Parameter') parameter_container3.add_validator(validate_min_max) parameter_container3.setup_ui() def show_error_message(parent, exception): """Generate error message to handle parameter errors :param parent: The widget as a parent of message box :type parent: QWidget :param exception: python Exception or Error :type exception: Exception """ box = QMessageBox() box.critical(parent, 'Error occured', exception.message) def show_parameter(the_parameter_container): """Print the value of parameter. :param the_parameter_container: A parameter container :type the_parameter_container: ParameterContainer """ def show_parameter_value(a_parameter): if isinstance(a_parameter, GroupParameter): for param in a_parameter.value: show_parameter_value(param) else: print a_parameter.guid, a_parameter.name, a_parameter.value try: the_parameters = the_parameter_container.get_parameters() if the_parameters: for parameter in the_parameters: show_parameter_value(parameter) except Exception as inst: show_error_message(parameter_container, inst) button = QPushButton('Show parameters') # noinspection PyUnresolvedReferences button.clicked.connect( partial(show_parameter, the_parameter_container=parameter_container)) validate_button = QPushButton('Validate parameters') # noinspection PyUnresolvedReferences validate_button.clicked.connect( partial(show_parameter, the_parameter_container=parameter_container3)) widget = QWidget() layout = QGridLayout() layout.addWidget(parameter_container) layout.addWidget(button) layout.addWidget(parameter_container2) layout.addWidget(parameter_container3) layout.addWidget(validate_button) widget.setLayout(layout) widget.setGeometry(0, 0, 500, 500) widget.show() sys.exit(app.exec_())