def _make_map_field_page(self):
"""
Make the Import Assistant page to map fields.
This method allows the user to map input file fields to RAMSTK
database table fields.
:return: _page
:rtype: :class:`gtk.ScrolledWindow`
"""
_page = gtk.ScrolledWindow()
_page.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
_page.add(self._tvw_field_map)
_model = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
_column = gtk.TreeViewColumn()
_label = ramstk.RAMSTKLabel(
_(u"Import File Column"), justify=gtk.JUSTIFY_CENTER)
_column.set_widget(_label)
_cell = gtk.CellRendererText()
_cell.set_property('foreground', '#000000')
_cell.set_property('cell-background', 'light gray')
_column.pack_start(_cell, True)
_column.set_attributes(_cell, text=0)
_column.set_visible(True)
self._tvw_field_map.append_column(_column)
_column = gtk.TreeViewColumn()
_label = ramstk.RAMSTKLabel(
_(u"RAMSTK Field"), justify=gtk.JUSTIFY_CENTER)
_column.set_widget(_label)
_cell = gtk.CellRendererCombo()
_cellmodel = gtk.ListStore(gobject.TYPE_STRING)
_cellmodel.append([""])
_cell.set_property('editable', True)
_cell.set_property('foreground', '#000000')
_cell.set_property('has-entry', False)
_cell.set_property('model', _cellmodel)
_cell.set_property('text-column', 0)
_cell.connect('edited', self._do_edit_cell, _model)
_column.pack_start(_cell, True)
_column.set_attributes(_cell, text=1)
_column.set_visible(True)
self._tvw_field_map.append_column(_column)
self._tvw_field_map.set_model(_model)
return _page
def _make_page(self):
"""
Create the Revision Work View general data page.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
_fixed = gtk.Fixed()
_scrollwindow = ramstk.RAMSTKScrolledWindow(_fixed)
_frame = ramstk.RAMSTKFrame(label=_(u"General Information"))
_frame.add(_scrollwindow)
_x_pos, _y_pos = ramstk.make_label_group(self._lst_gendata_labels,
_fixed, 5, 5)
_x_pos += 50
_fixed.put(self.txtCode, _x_pos, _y_pos[0])
_fixed.put(self.txtName, _x_pos, _y_pos[1])
_fixed.put(self.txtRemarks.scrollwindow, _x_pos, _y_pos[2])
_fixed.show_all()
_label = ramstk.RAMSTKLabel(
_(u"General\nData"),
height=30,
width=-1,
justify=gtk.JUSTIFY_CENTER,
tooltip=_(u"Displays general information for the selected "
u"revision."))
self.hbx_tab_label.pack_start(_label)
return _frame
def __init__(self, controller, **kwargs): # pylint: disable=unused-argument
"""
Initialize the Module View for the Hardware package.
:param controller: the RAMSTK Master data controller instance.
:type controller: :class:`ramstk.RAMSTK.RAMSTK`
"""
RAMSTKModuleView.__init__(self, controller, module='hardware')
# Initialize private dictionary attributes.
self._dic_icons['tab'] = controller.RAMSTK_CONFIGURATION.RAMSTK_ICON_DIR + \
'/32x32/hardware.png'
self._dic_icons['insert_part'] = \
controller.RAMSTK_CONFIGURATION.RAMSTK_ICON_DIR + \
'/32x32/insert_part.png'
# Initialize private list attributes.
# Initialize private scalar attributes.
self._hardware_id = None
self._revision_id = None
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self._make_treeview()
self.treeview.set_tooltip_text(
_(u"Displays the hierarchical list of "
u"hardware items."))
self._lst_handler_id.append(
self.treeview.connect('cursor_changed', self._do_change_row))
self._lst_handler_id.append(
self.treeview.connect('button_press_event', self._on_button_press))
self._img_tab.set_from_file(self._dic_icons['tab'])
_label = ramstk.RAMSTKLabel(
_(u"Hardware"),
width=-1,
height=-1,
tooltip=_(u"Displays the hierarchical list of hardware items."))
self.hbx_tab_label.pack_start(self._img_tab)
self.hbx_tab_label.pack_end(_label)
self.hbx_tab_label.show_all()
_scrollwindow = gtk.ScrolledWindow()
_scrollwindow.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
_scrollwindow.add_with_viewport(self._make_buttonbox())
self.pack_start(_scrollwindow, expand=False, fill=False)
self.show_all()
pub.subscribe(self._on_select_revision, 'selectedRevision')
pub.subscribe(self._on_edit, 'wvwEditedHardware')
pub.subscribe(self._on_calculate, 'calculatedAllHardware')
def __init__(self):
"""
Method to initialize on instance of the Add Control or Action
Assistant.
"""
ramstk.RAMSTKDialog.__init__(
self,
_(u"RAMSTK FMEA/FMECA Design Control and "
u"Action Addition Assistant"))
# Initialize private dictionary attributes.
# Initialize private list attributes.
# Initialize private scalar attributes.
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.rdoControl = ramstk.RAMSTKOptionButton(None, _(u"Add control"))
self.rdoAction = ramstk.RAMSTKOptionButton(self.rdoControl,
_(u"Add action"))
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
# Build-up the containers for the dialog. #
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
_fixed = gtk.Fixed()
self.vbox.pack_start(_fixed)
_label = ramstk.RAMSTKLabel(_(
u"This is the RAMSTK Design Control and Action "
u"Addition Assistant. Enter the information "
u"requested below and then press 'OK' to add "
u"a new design control or action to the RAMSTK "
u"Program database."),
width=600,
height=-1,
wrap=True)
_fixed.put(_label, 5, 10)
_y_pos = _label.size_request()[1] + 50
self.rdoControl.set_tooltip_text(
_(u"Select to add a design control "
u"to the selected failure cause."))
self.rdoAction.set_tooltip_text(
_(u"Select to add an Action to the "
u"selected failure cause."))
_fixed.put(self.rdoControl, 10, _y_pos)
_fixed.put(self.rdoAction, 10, _y_pos + 35)
_fixed.show_all()
def _make_goalbox(self):
"""
Make the Allocation methods and goal-setting container.
:return: a gtk.Frame() containing the widgets used to select the
allocation method and goals.
:rtype: :class:`gtk.Frame`
"""
# Load the method and goal comboboxes.
self.cmbAllocationGoal.do_load_combo([[_(u"Reliability"), 0],
[_(u"Hazard Rate"), 1],
[_(u"MTBF"), 2]])
self.cmbAllocationMethod.do_load_combo(
[[_(u"Equal Apportionment"), 0], [_(u"AGREE Apportionment"), 1],
[_(u"ARINC Apportionment"), 2],
[_(u"Feasibility of Objectives"), 3]])
_fixed = gtk.Fixed()
_fixed.put(ramstk.RAMSTKLabel(_(u"Select Allocation Method")), 5, 5)
_fixed.put(self.cmbAllocationMethod, 5, 30)
_fixed.put(ramstk.RAMSTKLabel(_(u"Select Goal Metric")), 5, 70)
_fixed.put(self.cmbAllocationGoal, 5, 95)
_fixed.put(ramstk.RAMSTKLabel(_(u"R(t) Goal")), 5, 135)
_fixed.put(self.txtReliabilityGoal, 5, 160)
_fixed.put(ramstk.RAMSTKLabel(_(u"h(t) Goal")), 5, 200)
_fixed.put(self.txtHazardRateGoal, 5, 225)
_fixed.put(ramstk.RAMSTKLabel(_(u"MTBF Goal")), 5, 265)
_fixed.put(self.txtMTBFGoal, 5, 290)
_frame = ramstk.RAMSTKFrame(label=_(u"Allocation Goals and Method"))
_frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
_frame.add(_fixed)
self.txtHazardRateGoal.props.editable = 0
self.txtHazardRateGoal.set_sensitive(0)
self.txtMTBFGoal.props.editable = 0
self.txtMTBFGoal.set_sensitive(0)
self.txtReliabilityGoal.props.editable = 0
self.txtReliabilityGoal.set_sensitive(0)
return _frame
def __init__(self):
"""
Method to initialize on instance of the Add Stress or Test Method
Assistant.
"""
ramstk.RAMSTKDialog.__init__(
self,
_(u"RAMSTK Physics of Failure Analysis Operating Stress and "
u"Test Method Addition Assistant"))
# Initialize private dictionary attributes.
# Initialize private list attributes.
# Initialize private scalar attributes.
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.rdoStress = ramstk.RAMSTKOptionButton(None, _(u"Add stress"))
self.rdoMethod = ramstk.RAMSTKOptionButton(self.rdoStress,
_(u"Add test method"))
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
# Build-up the containers for the dialog. #
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
_fixed = gtk.Fixed()
self.vbox.pack_start(_fixed)
_label = ramstk.RAMSTKLabel(
_(u"This is the RAMSTK Operating Stress and Test Method "
u"Addition Assistant. Enter the information "
u"requested below and then press 'OK' to add "
u"a new design control or action to the RAMSTK "
u"Program database."),
width=600,
height=-1,
wrap=True)
_fixed.put(_label, 5, 10)
_y_pos = _label.size_request()[1] + 50
self.rdoStress.set_tooltip_text(
_(u"Select to add an operating stress to the selected operating "
u"load."))
self.rdoMethod.set_tooltip_text(
_(u"Select to add a test method to the selected operating load."))
_fixed.put(self.rdoStress, 10, _y_pos)
_fixed.put(self.rdoMethod, 10, _y_pos + 35)
_fixed.show_all()
def __init__(self, controller, **kwargs):
"""
Initialize an instance of the Hardware assessment result view.
:param controller: the hardware data controller instance.
:type controller: :class:`ramstk.hardware.Controller.HardwareBoMDataController`
:param int hardware_id: the hardware ID of the currently selected
hardware item.
:param int subcategory_id: the ID of the hardware item subcategory.
"""
gtk.Fixed.__init__(self)
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_labels = [
u"\u03BB<sub>b</sub>:", u"\u03C0<sub>Q</sub>:",
u"\u03C0<sub>E</sub>:"
]
# Initialize private scalar attributes.
self._dtc_data_controller = controller
self._hardware_id = kwargs['hardware_id']
self._subcategory_id = kwargs['subcategory_id']
self._lblModel = ramstk.RAMSTKLabel(
'',
tooltip=_(u"The assessment model used to calculate the hardware "
u"item failure rate."))
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.fmt = None
self.txtLambdaB = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The base hazard rate of the hardware item."))
self.txtPiQ = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The quality factor for the hardware item."))
self.txtPiE = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The environment factor for the hardware item."))
def _make_confirm_page():
"""
Make the Import Assistant confimation page.
:return: _page
:rtype: :class:`gtk.Fixed`
"""
_page = gtk.Fixed()
_label = ramstk.RAMSTKLabel(
_(u"RAMSTK is all set and ready to import your "
u"data. Press 'Apply' to import or 'Cancel' "
u"to abort the import."),
height=300,
width=-1,
wrap=True)
_label.set_alignment(0.05, 0.05)
_page.put(_label, 25, 5)
return _page
def _make_input_file_select_page(self):
"""
Make the Import Assistant page to select the input file.
:return: _page
:rtype: :class:`gtk.ScrolledWindow`
"""
# TODO: Implement NSWC (add Design Mechanic to this list).
self._cmb_select_module.do_load_combo(
[[_(u"Function")], [_(u"Requirement")], [_(u"Hardware")],
[_(u"Validation")]])
_page = gtk.HBox()
_fixed = gtk.Fixed()
_label = ramstk.RAMSTKLabel(_(u"Select the RAMSTK module to import:"))
_fixed.put(_label, 5, 5)
_fixed.put(self._cmb_select_module, 55, 5)
_page.pack_start(_fixed, False, False)
_scrollwindow = gtk.ScrolledWindow()
_file_chooser = gtk.FileChooserWidget(
action=gtk.FILE_CHOOSER_ACTION_OPEN)
_scrollwindow.add_with_viewport(_file_chooser)
_page.pack_end(_scrollwindow, True, True)
_file_filter = gtk.FileFilter()
_file_filter.set_name(_(u"Delimited Text Files"))
_file_filter.add_pattern('*.csv')
_file_filter.add_pattern('*.txt')
_file_chooser.add_filter(_file_filter)
_file_filter = gtk.FileFilter()
_file_filter.set_name(_(u"Excel Files"))
_file_filter.add_pattern('*.xls*')
_file_chooser.add_filter(_file_filter)
_file_chooser.connect('selection_changed', self._do_select_file)
return _page
def _make_methodbox(self):
"""
Make the Similar Item analysis method container.
:return: a gtk.Frame() containing the widgets used to select the
allocation method and goals.
:rtype: :class:`gtk.Frame`
"""
# Load the method and goal comboboxes.
self.cmbSimilarItemMethod.do_load_combo([[_(u"Topic 633"), 0],
[_(u"User-Defined"), 1]])
_fixed = gtk.Fixed()
_fixed.put(ramstk.RAMSTKLabel(_(u"Select Method")), 5, 5)
_fixed.put(self.cmbSimilarItemMethod, 5, 30)
_frame = ramstk.RAMSTKFrame(label=_(u"Similar Item Method"))
_frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
_frame.add(_fixed)
return _frame
def _make_introduction_page():
"""
Make the Import Assistant introduction page.
:return: _page
:rtype: :class:`gtk.Fixed`
"""
_page = gtk.Fixed()
_label = ramstk.RAMSTKLabel(
_(u"This is the RAMSTK Import Assistant. It "
u"will guide you through the process of "
u"importing RAMSTK Program module data from "
u"an external file. Press 'Forward' to continue "
u"or 'Cancel' to quit."),
height=300,
width=-1,
wrap=True)
_label.set_alignment(0.05, 0.05)
_page.put(_label, 25, 5)
return _page
def _make_page(self):
"""
Make the Requirement Work View General Data gtk.Notebook() page.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
# Load the requirement type gtk.ComboBox(); each _type is
# (Code, Description, Type).
_types = []
for _index, _key in enumerate(
self._mdcRAMSTK.RAMSTK_CONFIGURATION.RAMSTK_REQUIREMENT_TYPE):
_types.append(self._mdcRAMSTK.RAMSTK_CONFIGURATION.
RAMSTK_REQUIREMENT_TYPE[_key])
self.cmbRequirementType.do_load_combo(list(_types),
index=1,
simple=False)
# Load the owner gtk.ComboBox(); each _owner is
# (Description, Group Type).
_owners = []
for _index, _key in enumerate(
self._mdcRAMSTK.RAMSTK_CONFIGURATION.RAMSTK_WORKGROUPS):
_owners.append(
self._mdcRAMSTK.RAMSTK_CONFIGURATION.RAMSTK_WORKGROUPS[_key])
self.cmbOwner.do_load_combo(list(_owners))
# Load the priority gtk.Combo().
_priorities = [["1"], ["2"], ["3"], ["4"], ["5"]]
self.cmbPriority.do_load_combo(_priorities)
# Build the General Data page.
_fixed = gtk.Fixed()
_scrollwindow = ramstk.RAMSTKScrolledWindow(_fixed)
_frame = ramstk.RAMSTKFrame(label=_(u"General Information"))
_frame.add(_scrollwindow)
_x_pos, _y_pos = ramstk.make_label_group(self._lst_gendata_labels,
_fixed, 5, 5)
_x_pos += 50
_fixed.put(self.txtCode, _x_pos, _y_pos[0])
_fixed.put(self.txtName, _x_pos, _y_pos[1])
_fixed.put(self.cmbRequirementType, _x_pos, _y_pos[2])
_fixed.put(self.chkDerived, _x_pos, _y_pos[3] + 5)
_fixed.put(self.txtSpecification, _x_pos, _y_pos[4])
_fixed.put(self.txtPageNum, _x_pos, _y_pos[5])
_fixed.put(self.txtFigNum, _x_pos, _y_pos[6])
_fixed.put(self.cmbPriority, _x_pos, _y_pos[7])
_fixed.put(self.cmbOwner, _x_pos, _y_pos[8])
_fixed.put(self.chkValidated, _x_pos, _y_pos[9] + 5)
_fixed.put(self.txtValidatedDate, _x_pos, _y_pos[10])
_fixed.put(self.btnValidateDate, _x_pos + 205, _y_pos[10])
_fixed.show_all()
# Create the label for the gtk.Notebook() tab.
_label = ramstk.RAMSTKLabel(
_(u"General\nData"),
height=30,
width=-1,
justify=gtk.JUSTIFY_CENTER,
tooltip=_(u"Displays general information for the selected "
u"requirement."))
self.hbx_tab_label.pack_start(_label)
return _frame
def __init__(self, controller, **kwargs): # pylint: disable=unused-argument
"""
Initialize the Validation Module View.
:param controller: the RAMSTK Master data controller instance.
:type controller: :class:`ramstk.RAMSTK.RAMSTK`
"""
RAMSTKModuleView.__init__(self, controller, module='validation')
# Initialize private dictionary attributes.
self._dic_icons['tab'] = controller.RAMSTK_CONFIGURATION.RAMSTK_ICON_DIR + \
'/32x32/validation.png'
# Initialize private list attributes.
# Initialize private scalar attributes.
self._revision_id = None
self._validation_id = None
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self._make_treeview()
self.treeview.set_tooltip_text(
_(u"Displays the list of validation "
u"tasks."))
self._lst_handler_id.append(
self.treeview.connect('cursor_changed', self._do_change_row))
self._lst_handler_id.append(
self.treeview.connect('button_press_event', self._on_button_press))
i = 0
for _column in self.treeview.get_columns():
_cell = _column.get_cell_renderers()[0]
try:
if _cell.get_property('editable'):
_cell.connect('edited', self._do_edit_cell, i,
self.treeview.get_model())
except TypeError:
pass
i += 1
self._img_tab.set_from_file(self._dic_icons['tab'])
_label = ramstk.RAMSTKLabel(
_(u"Validation"),
width=-1,
height=-1,
tooltip=_(u"Displays the program validation tasks."))
self.hbx_tab_label.pack_start(self._img_tab)
self.hbx_tab_label.pack_end(_label)
self.hbx_tab_label.show_all()
_scrollwindow = gtk.ScrolledWindow()
_scrollwindow.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
_scrollwindow.add_with_viewport(self._make_buttonbox())
self.pack_start(_scrollwindow, expand=False, fill=False)
self.show_all()
pub.subscribe(self._on_select_revision, 'selectedRevision')
pub.subscribe(self._on_edit, 'wvwEditedValidation')
def _make_assessment_results_page(self):
"""
Create the gtk.Notebook() page for displaying assessment results.
:return: False if successful or True if an error is encountered.
:rtype: boolean
"""
_hbox = gtk.HBox()
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
# Build the left half of the page. #
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
_fxd_left = gtk.Fixed()
_scrollwindow = ramstk.RAMSTKScrolledWindow(_fxd_left)
_frame = ramstk.RAMSTKFrame(label=_(u"Reliability Results"))
_frame.add(_scrollwindow)
_hbox.pack_start(_frame)
_x_pos_l, _y_pos_l = ramstk.make_label_group(
self._lst_assess_labels[0], _fxd_left, 5, 5)
_x_pos_l += 50
_fxd_left.put(self.txtActiveHt, _x_pos_l, _y_pos_l[0])
_fxd_left.put(self.txtDormantHt, _x_pos_l, _y_pos_l[1])
_fxd_left.put(self.txtSoftwareHt, _x_pos_l, _y_pos_l[2])
_fxd_left.put(self.txtPredictedHt, _x_pos_l, _y_pos_l[3])
_fxd_left.put(self.txtMissionHt, _x_pos_l, _y_pos_l[4])
_fxd_left.put(self.txtMTBF, _x_pos_l, _y_pos_l[5])
_fxd_left.put(self.txtMissionMTBF, _x_pos_l, _y_pos_l[6])
_fxd_left.put(self.txtReliability, _x_pos_l, _y_pos_l[7])
_fxd_left.put(self.txtMissionRt, _x_pos_l, _y_pos_l[8])
_fxd_left.put(self.txtPartCount, _x_pos_l, _y_pos_l[9])
_fxd_left.show_all()
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
# Build the right half of the page. #
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
_fxd_right = gtk.Fixed()
_scrollwindow = ramstk.RAMSTKScrolledWindow(_fxd_right)
_frame = ramstk.RAMSTKFrame(label=_(u"Maintainability Results"))
_frame.add(_scrollwindow)
_hbox.pack_end(_frame)
_x_pos_r, _y_pos_r = ramstk.make_label_group(
self._lst_assess_labels[1], _fxd_right, 5, 5)
_x_pos_r += 55
_fxd_right.put(self.txtMPMT, _x_pos_r, _y_pos_r[0])
_fxd_right.put(self.txtMCMT, _x_pos_r, _y_pos_r[1])
_fxd_right.put(self.txtMTTR, _x_pos_r, _y_pos_r[2])
_fxd_right.put(self.txtMMT, _x_pos_r, _y_pos_r[3])
_fxd_right.put(self.txtAvailability, _x_pos_r, _y_pos_r[4])
_fxd_right.put(self.txtMissionAt, _x_pos_r, _y_pos_r[5])
_fxd_right.put(self.txtTotalCost, _x_pos_r, _y_pos_r[6])
_fxd_right.put(self.txtCostFailure, _x_pos_r, _y_pos_r[7])
_fxd_right.put(self.txtCostHour, _x_pos_r, _y_pos_r[8])
_fxd_right.show_all()
_label = ramstk.RAMSTKLabel(
_(u"Assessment\nResults"),
height=30,
width=-1,
justify=gtk.JUSTIFY_CENTER,
tooltip=_(u"Displays reliability, "
u"maintainability, and availability "
u"assessment results for the selected "
u"{0:s}.").format(self._module))
self.hbx_tab_label.pack_start(_label)
return (_hbox, _fxd_left, _fxd_right, _x_pos_l, _x_pos_r, _y_pos_l,
_y_pos_r)
def _do_request_edit_function(self, __button):
"""
Request to edit the Similar Item analysis user-defined functions.
:param __button: the gtk.ToolButton() that called this method.
:type __button: :class:`gtk.ToolButton`.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
(_model, _row) = self.treeview.get_selection().get_selected()
_title = _(u"RAMSTK - Edit Similar Item Analysis Functions")
_label = ramstk.RAMSTKLabel(_(u"You can define up to five functions. "
u"You can use the system failure rate, "
u"selected assembly failure rate, the "
u"change factor, the user float, the "
u"user integer values, and results of "
u"other functions.\n\n \
System hazard rate is hr_sys\n \
Assembly hazard rate is hr\n \
Change factor is pi[1-8]\n \
User float is uf[1-3]\n \
User integer is ui[1-3]\n \
Function result is res[1-5]"),
width=600,
height=-1,
wrap=True)
_label2 = ramstk.RAMSTKLabel(_(u"For example, pi1*pi2+pi3, multiplies "
u"the first two change factors and "
u"adds the value to the third change "
u"factor."),
width=600,
height=-1,
wrap=True)
# Build the dialog assistant.
_dialog = ramstk.RAMSTKDialog(_title)
_fixed = gtk.Fixed()
_y_pos = 10
_fixed.put(_label, 5, _y_pos)
_y_pos += _label.size_request()[1] + 10
_fixed.put(_label2, 5, _y_pos)
_y_pos += _label2.size_request()[1] + 10
_label = ramstk.RAMSTKLabel(_(u"User function 1:"))
_txtFunction1 = ramstk.RAMSTKEntry()
_txtFunction1.set_text(_model.get_value(_row, 30))
_fixed.put(_label, 5, _y_pos)
_fixed.put(_txtFunction1, 195, _y_pos)
_y_pos += 30
_label = ramstk.RAMSTKLabel(_(u"User function 2:"))
_txtFunction2 = ramstk.RAMSTKEntry()
_txtFunction2.set_text(_model.get_value(_row, 31))
_fixed.put(_label, 5, _y_pos)
_fixed.put(_txtFunction2, 195, _y_pos)
_y_pos += 30
_label = ramstk.RAMSTKLabel(_(u"User function 3:"))
_txtFunction3 = ramstk.RAMSTKEntry()
_txtFunction3.set_text(_model.get_value(_row, 32))
_fixed.put(_label, 5, _y_pos)
_fixed.put(_txtFunction3, 195, _y_pos)
_y_pos += 30
_label = ramstk.RAMSTKLabel(_(u"User function 4:"))
_txtFunction4 = ramstk.RAMSTKEntry()
_txtFunction4.set_text(_model.get_value(_row, 33))
_fixed.put(_label, 5, _y_pos)
_fixed.put(_txtFunction4, 195, _y_pos)
_y_pos += 30
_label = ramstk.RAMSTKLabel(_(u"User function 5:"))
_txtFunction5 = ramstk.RAMSTKEntry()
_txtFunction5.set_text(_model.get_value(_row, 34))
_fixed.put(_label, 5, _y_pos)
_fixed.put(_txtFunction5, 195, _y_pos)
_y_pos += 30
_chkApplyAll = gtk.CheckButton(label=_(u"Apply to all assemblies."))
_fixed.put(_chkApplyAll, 5, _y_pos)
_fixed.show_all()
_dialog.vbox.pack_start(_fixed) # pylint: disable=E1101
# Run the dialog and apply the changes if the 'OK' button is pressed.
if _dialog.run() == gtk.RESPONSE_OK:
if _chkApplyAll.get_active():
_row = _model.get_iter_root()
while _row is not None:
_hardware_id = _model.get_value(_row, 1)
_similaritem = self._dtc_data_controller.request_do_select(
_hardware_id)
_similaritem.function_1 = _txtFunction1.get_text()
_similaritem.function_2 = _txtFunction2.get_text()
_similaritem.function_3 = _txtFunction3.get_text()
_similaritem.function_4 = _txtFunction4.get_text()
_similaritem.function_5 = _txtFunction5.get_text()
_model.set_value(_row, 30, _similaritem.function_1)
_model.set_value(_row, 31, _similaritem.function_2)
_model.set_value(_row, 32, _similaritem.function_3)
_model.set_value(_row, 33, _similaritem.function_4)
_model.set_value(_row, 34, _similaritem.function_5)
self._dtc_data_controller.request_do_update(_hardware_id)
_row = _model.iter_next(_row)
else:
_similaritem = self._dtc_data_controller.request_do_select(
self._hardware_id)
_similaritem.function_1 = _txtFunction1.get_text()
_similaritem.function_2 = _txtFunction2.get_text()
_similaritem.function_3 = _txtFunction3.get_text()
_similaritem.function_4 = _txtFunction4.get_text()
_similaritem.function_5 = _txtFunction5.get_text()
_model.set_value(_row, 30, _similaritem.function_1)
_model.set_value(_row, 31, _similaritem.function_2)
_model.set_value(_row, 32, _similaritem.function_3)
_model.set_value(_row, 33, _similaritem.function_4)
_model.set_value(_row, 34, _similaritem.function_5)
self._dtc_data_controller.request_do_update(self._hardware_id)
_dialog.destroy()
return False
def __init__(self, controller, **kwargs): # pylint: disable=unused-argument
"""
Initialize the Work View for the Similar Item.
:param controller: the RAMSTK master data controller instance.
:type controller: :class:`ramstk.RAMSTK.RAMSTK`
"""
RAMSTKWorkView.__init__(self, controller, module='SimilarItem')
# Initialize private dictionary attributes.
self._dic_icons['edit'] = (
controller.RAMSTK_CONFIGURATION.RAMSTK_ICON_DIR +
'/32x32/edit.png')
self._dic_quality = {
'Space': 1,
'Full Military': 2,
'Ruggedized': 3,
'Commercial': 4
}
self._dic_environment = {
'Ground, Benign': 1,
'Ground,Mobile': 2,
'Naval, Sheltered': 3,
'Airborne, Inhabited, Cargo': 4,
'Airborne, Rotary Wing': 5,
'Space, Flight': 6
}
# Initialize private list attributes.
# Initialize private scalar attributes.
self._revision_id = None
self._parent_id = None
self._hardware_id = None
self._method_id = None
self._dtc_hw_controller = None
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
_bg_color = '#FFFFFF'
_fg_color = '#000000'
_fmt_file = (
controller.RAMSTK_CONFIGURATION.RAMSTK_CONF_DIR + '/layouts/' +
controller.RAMSTK_CONFIGURATION.RAMSTK_FORMAT_FILE['similaritem'])
_fmt_path = "/root/tree[@name='SimilarItem']/column"
_tooltip = _(u"Displays the Similar Item Analysis for the currently "
u"selected Hardware item.")
self.treeview = ramstk.RAMSTKTreeView(_fmt_path,
0,
_fmt_file,
_bg_color,
_fg_color,
pixbuf=False)
self._lst_col_order = self.treeview.order
self.treeview.set_tooltip_text(_tooltip)
self.cmbSimilarItemMethod = ramstk.RAMSTKComboBox(
tooltip=_(u"Select the similar item analysis method."))
self._lst_handler_id.append(
self.treeview.connect('cursor_changed', self._do_change_row))
self._lst_handler_id.append(
self.treeview.connect('button_press_event', self._on_button_press))
self._lst_handler_id.append(
self.cmbSimilarItemMethod.connect('changed',
self._on_combo_changed, 2))
for _idx in self._lst_col_order[3:]:
_cell = self.treeview.get_column(
self._lst_col_order[_idx]).get_cell_renderers()
try:
_cell[0].connect('edited', self._do_edit_cell, _idx,
self.treeview.get_model())
except TypeError:
_cell[0].connect('toggled', self._do_edit_cell, 'new text',
_idx, self.treeview.get_model())
_label = ramstk.RAMSTKLabel(
_(u"SimilarItem"),
height=30,
width=-1,
justify=gtk.JUSTIFY_CENTER,
tooltip=_(u"Displays the Similar Item analysis for the selected "
u"hardware item."))
self.hbx_tab_label.pack_start(_label)
self.pack_start(self._make_buttonbox(), False, True)
_hbox = gtk.HBox()
_hbox.pack_start(self._make_methodbox(), False, True)
_hbox.pack_end(self._make_page(), True, True)
self.pack_end(_hbox, True, True)
self.show_all()
pub.subscribe(self._on_select, 'selectedHardware')
pub.subscribe(self._do_clear_page, 'closedProgram')
def __init__(self, controller, **kwargs): # pylint: disable=unused-argument
"""
Initialize the Work View for the PoF.
:param controller: the RAMSTK master data controller instance.
:type controller: :class:`ramstk.RAMSTK.RAMSTK`
"""
RAMSTKWorkView.__init__(self, controller, module='PoF')
# Initialize private dictionary attributes.
self._dic_icons['mode'] = controller.RAMSTK_CONFIGURATION.RAMSTK_ICON_DIR + \
'/32x32/mode.png'
self._dic_icons['mechanism'] = \
controller.RAMSTK_CONFIGURATION.RAMSTK_ICON_DIR + '/32x32/mechanism.png'
self._dic_icons['opload'] = \
controller.RAMSTK_CONFIGURATION.RAMSTK_ICON_DIR + '/32x32/load.png'
self._dic_icons['opstress'] = \
controller.RAMSTK_CONFIGURATION.RAMSTK_ICON_DIR + '/32x32/stress.png'
self._dic_icons['testmethod'] = \
controller.RAMSTK_CONFIGURATION.RAMSTK_ICON_DIR + '/32x32/method.png'
# Initialize private list attributes.
# Initialize private scalar attributes.
self._hardware_id = None
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
_fmt_file = (
controller.RAMSTK_CONFIGURATION.RAMSTK_CONF_DIR + '/layouts/' +
controller.RAMSTK_CONFIGURATION.RAMSTK_FORMAT_FILE['pof'])
_fmt_path = "/root/tree[@name='PoF']/column"
_tooltip = _(u"Displays the Physics of Failure (PoF) Analysis for the "
u"currently selected hardware item.")
self.treeview = ramstk.RAMSTKTreeView(
_fmt_path,
0,
_fmt_file,
'#FFFFFF',
'#000000',
pixbuf=True,
indexed=True)
self._lst_col_order = self.treeview.order
self.treeview.set_tooltip_text(_tooltip)
_label = ramstk.RAMSTKLabel(
_(u"Damage\nModeling"),
height=30,
width=-1,
justify=gtk.JUSTIFY_CENTER,
tooltip=_(u"Displays the Physics of Failure (PoF) Analysis for "
u"the selected hardware item."))
self.hbx_tab_label.pack_start(_label)
self.pack_start(self._make_buttonbox(), False, True)
self.pack_end(self._make_page(), True, True)
self.show_all()
pub.subscribe(self._on_select, 'selectedHardware')
pub.subscribe(self._do_clear_page, 'closedProgram')
def _do_change_row(self, treeview):
"""
Handle 'cursor-changed' event for the (D)FME(C)A RAMSTKTreeView().
This method is called whenever a Tree View row is activated.
:param treeview: the FMEA RAMSTKTreeView().
:type treeview: :class:`ramstk.gui.gtk.ramstk.TreeViewRAMSTKTreeView`
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
_return = False
_headings = [
self.treeview.headings[self._lst_col_order[0]],
self.treeview.headings[self._lst_col_order[1]],
self.treeview.headings[self._lst_col_order[2]],
self.treeview.headings[self._lst_col_order[3]],
self.treeview.headings[self._lst_col_order[4]],
self.treeview.headings[self._lst_col_order[5]],
self.treeview.headings[self._lst_col_order[6]],
self.treeview.headings[self._lst_col_order[7]],
self.treeview.headings[self._lst_col_order[8]],
self.treeview.headings[self._lst_col_order[9]],
self.treeview.headings[self._lst_col_order[10]]
]
treeview.handler_block(self._lst_handler_id[0])
_model, _row = treeview.get_selection().get_selected()
try:
_node_id = _model.get_value(_row, 12)
except (TypeError, ValueError):
_node_id = 0
_level = self._get_level(_node_id)
if _level == 'mode':
_headings[0] = self.treeview.headings[self._lst_col_order[0]]
_headings[1] = self.treeview.headings[self._lst_col_order[1]]
for _idx in [1, 2, 3, 4, 5, 6, 7, 8, 9]:
_cell = self.treeview.get_column(
self._lst_col_order[_idx]).get_cell_renderers()[0]
_cell.set_property('editable', False)
elif _level == 'mechanism':
_headings[0] = _(u"Mechanism ID")
_headings[1] = _(u"Failure\nMechanism")
for _idx in [1, 2, 3, 4, 5, 6, 7, 8, 9]:
_cell = self.treeview.get_column(
self._lst_col_order[_idx]).get_cell_renderers()[0]
_cell.set_property('editable', False)
elif _level == 'opload':
_headings[0] = _(u"Operating\nLoad ID")
_headings[1] = _(u"Damaging\nCondition")
for _idx in [2, 3, 4, 6, 7, 8]:
_cell = self.treeview.get_column(
self._lst_col_order[_idx]).get_cell_renderers()[0]
_cell.set_property('editable', False)
for _idx in [1, 5, 9]:
_cell = self.treeview.get_column(
self._lst_col_order[_idx]).get_cell_renderers()[0]
_cell.set_property('editable', True)
elif _level == 'opstress':
_headings[0] = _(u"Stress ID")
_headings[1] = _(u"Operating\nStress")
for _idx in [2, 3, 4, 5, 8, 9]:
_cell = self.treeview.get_column(
self._lst_col_order[_idx]).get_cell_renderers()[0]
_cell.set_property('editable', False)
for _idx in [1, 6, 7]:
_cell = self.treeview.get_column(
self._lst_col_order[_idx]).get_cell_renderers()[0]
_cell.set_property('editable', True)
elif _level == 'testmethod':
_headings[0] = _(u"Test ID")
_headings[1] = _(u"Existing or\nProposed Test")
for _idx in [2, 3, 4, 5, 6, 7, 9]:
_cell = self.treeview.get_column(
self._lst_col_order[_idx]).get_cell_renderers()[0]
_cell.set_property('editable', False)
_cell.set_property('mode', gtk.CELL_RENDERER_MODE_INERT)
for _idx in [1, 8]:
_cell = self.treeview.get_column(
self._lst_col_order[_idx]).get_cell_renderers()[0]
_cell.set_property('editable', True)
_cell.set_property('mode', gtk.CELL_RENDERER_MODE_EDITABLE)
_columns = self.treeview.get_columns()
i = 0
for _heading in _headings:
_label = ramstk.RAMSTKLabel(
_heading, height=-1, justify=gtk.JUSTIFY_CENTER, wrap=True)
_label.show_all()
_columns[i].set_widget(_label)
if _heading == '':
_columns[i].set_visible(False)
else:
_columns[i].set_visible(True)
i += 1
treeview.handler_unblock(self._lst_handler_id[0])
return _return
def __init__(self, controller, **kwargs): # pylint: disable=unused-argument
"""
Initialize the Work View for the Allocation.
:param controller: the RAMSTK master data controller instance.
:type controller: :class:`ramstk.RAMSTK.RAMSTK`
"""
RAMSTKWorkView.__init__(self, controller, module='Allocation')
# Initialize private dictionary attributes.
# Initialize private list attributes.
# Initialize private scalar attributes.
self._parent_id = None
self._allocation_id = None
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
_bg_color = '#FFFFFF'
_fg_color = '#000000'
_fmt_file = (
controller.RAMSTK_CONFIGURATION.RAMSTK_CONF_DIR + '/layouts/' +
controller.RAMSTK_CONFIGURATION.RAMSTK_FORMAT_FILE['allocation'])
_fmt_path = "/root/tree[@name='Allocation']/column"
_tooltip = _(u"Displays the Allocation Analysis for the "
u"currently selected Hardware item.")
self.treeview = ramstk.RAMSTKTreeView(_fmt_path,
0,
_fmt_file,
_bg_color,
_fg_color,
pixbuf=False)
self._lst_col_order = self.treeview.order
self.treeview.set_tooltip_text(_tooltip)
self.cmbAllocationGoal = ramstk.RAMSTKComboBox(tooltip=_(
u"Selects the goal measure for the selected hardware assembly."))
self.cmbAllocationMethod = ramstk.RAMSTKComboBox(tooltip=_(
u"Selects the method for allocating the reliability goal for "
u"the selected hardware assembly."))
self.txtHazardRateGoal = ramstk.RAMSTKEntry(
width=125,
tooltip=(
u"Displays the hazard rate goal for the selected hardware "
u"item."))
self.txtMTBFGoal = ramstk.RAMSTKEntry(
width=125,
tooltip=_(
u"Displays the MTBF goal for the selected hardware item."))
self.txtReliabilityGoal = ramstk.RAMSTKEntry(
width=125,
tooltip=_(
u"Displays the reliability goal for the selected hardware "
u"item."))
self._lst_handler_id.append(
self.treeview.connect('cursor_changed', self._do_change_row))
self._lst_handler_id.append(
self.treeview.connect('button_press_event', self._on_button_press))
self._lst_handler_id.append(
self.cmbAllocationMethod.connect('changed', self._on_combo_changed,
2))
self._lst_handler_id.append(
self.cmbAllocationGoal.connect('changed', self._on_combo_changed,
3))
self._lst_handler_id.append(
self.txtReliabilityGoal.connect('focus_out_event',
self._on_focus_out, 4))
self._lst_handler_id.append(
self.txtHazardRateGoal.connect('focus_out_event',
self._on_focus_out, 5))
self._lst_handler_id.append(
self.txtMTBFGoal.connect('focus_out_event', self._on_focus_out, 6))
for i in [
self._lst_col_order[3], self._lst_col_order[5],
self._lst_col_order[6], self._lst_col_order[7],
self._lst_col_order[8], self._lst_col_order[9],
self._lst_col_order[10], self._lst_col_order[11]
]:
_cell = self.treeview.get_column(
self._lst_col_order[i]).get_cell_renderers()
try:
_cell[0].connect('edited', self._do_edit_cell, i,
self.treeview.get_model())
except TypeError:
_cell[0].connect('toggled', self._do_edit_cell, 'new text', i,
self.treeview.get_model())
_label = ramstk.RAMSTKLabel(
_(u"Allocation"),
height=30,
width=-1,
justify=gtk.JUSTIFY_CENTER,
tooltip=_(u"Displays the Allocation analysis for the selected "
u"hardware item."))
self.hbx_tab_label.pack_start(_label)
self.pack_start(self._make_buttonbox(), False, True)
_hbox = gtk.HBox()
_hbox.pack_start(self._make_goalbox(), False, True)
_hbox.pack_end(self._make_page(), True, True)
self.pack_end(_hbox, True, True)
self.show_all()
pub.subscribe(self._on_select, 'selectedHardware')
pub.subscribe(self._do_clear_page, 'closedProgram')