def _make_page(self):
"""
Make the Similar Item RAMSTKTreeview().
:return: a gtk.Frame() containing the instance of gtk.Treeview().
:rtype: :class:`gtk.Frame`
"""
# Load the quality from and quality to gtk.CellRendererCombo().
for _idx in [4, 5]:
_model = self._get_cell_model(_idx)
for _quality in self._dic_quality:
_model.append([
_quality,
])
# Load the environment from and environment to gtk.CellRendererCombo().
for _idx in [6, 7]:
_model = self._get_cell_model(_idx)
for _environment in self._dic_environment:
_model.append([
_environment,
])
_scrollwindow = gtk.ScrolledWindow()
_scrollwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
_scrollwindow.add(self.treeview)
_frame = ramstk.RAMSTKFrame(label=_(u"Similar Item Analysis"))
_frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
_frame.add(_scrollwindow)
self.treeview.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH)
return _frame
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 _make_page(self):
"""
Make the Hardware gtk.Notebook() assessment results page.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
_return = False
# Create the left side.
_fixed = gtk.Fixed()
self.pack1(_fixed, True, True)
_x_pos, _y_pos = ramstk.make_label_group(self._lst_labels, _fixed, 5,
35)
_x_pos += 50
_fixed.put(self.txtCurrentRatio, _x_pos, _y_pos[0])
_fixed.put(self.txtPowerRatio, _x_pos, _y_pos[1])
_fixed.put(self.txtVoltageRatio, _x_pos, _y_pos[2])
_fixed.put(self.chkOverstress, _x_pos, _y_pos[3])
_fixed.put(self.txtReason.scrollwindow, _x_pos, _y_pos[4])
_fixed.show_all()
# Create the derating plot.
_frame = ramstk.RAMSTKFrame(
label=_(u"Derating Curve and Operating Point"))
_frame.add(self.pltDerate.plot)
_frame.show_all()
self.pack2(_frame, True, True)
return _return
def _make_page(self):
"""
Make the Allocation RAMSTKTreeview().
:return: a gtk.Frame() containing the instance of gtk.Treeview().
:rtype: :class:`gtk.Frame`
"""
_scrollwindow = gtk.ScrolledWindow()
_scrollwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
_scrollwindow.add(self.treeview)
_frame = ramstk.RAMSTKFrame(label=_(u"Allocation Analysis"))
_frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
_frame.add(_scrollwindow)
self.treeview.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH)
return _frame
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 _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_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 _make_page(self):
"""
Make the PoF RAMSTKTreeview().
:return: a gtk.Frame() containing the instance of gtk.Treeview().
:rtype: :class:`gtk.Frame`
"""
_scrollwindow = gtk.ScrolledWindow()
_scrollwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
_scrollwindow.add(self.treeview)
_frame = ramstk.RAMSTKFrame(label=_(u"Physics of Failure (PoF) Analysis"))
_frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
_frame.add(_scrollwindow)
self.treeview.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH)
for i in [0, 1, 2, 3, 4]:
_column = self.treeview.get_column(self._lst_col_order[i])
if i == 0:
_cell = _column.get_cell_renderers()[1]
else:
_cell = _column.get_cell_renderers()[0]
_cell.set_property('font', 'normal bold')
# Load the damage models into the gtk.CellRendererCombo().
_model = self._get_cell_model(self._lst_col_order[5])
_model.append(('', ))
for _item in self._mdcRAMSTK.RAMSTK_CONFIGURATION.RAMSTK_DAMAGE_MODELS:
_model.append(
(self._mdcRAMSTK.RAMSTK_CONFIGURATION.RAMSTK_DAMAGE_MODELS[
_item][0], ))
# Load the measureable parameter into the gtk.CellRendererCombo().
_model = self._get_cell_model(self._lst_col_order[6])
_model.append(('', ))
for _item in self._mdcRAMSTK.RAMSTK_CONFIGURATION.RAMSTK_MEASURABLE_PARAMETERS:
_model.append((self._mdcRAMSTK.RAMSTK_CONFIGURATION.
RAMSTK_MEASURABLE_PARAMETERS[_item][1], ))
# Load the load history into the gtk.CellRendererCombo().
_model = self._get_cell_model(self._lst_col_order[7])
_model.append(('', ))
for _item in self._mdcRAMSTK.RAMSTK_CONFIGURATION.RAMSTK_LOAD_HISTORY:
_model.append(
(self._mdcRAMSTK.RAMSTK_CONFIGURATION.RAMSTK_LOAD_HISTORY[
_item][0], ))
# Set the priority gtk.CellRendererSpin()'s adjustment limits and
# step increments.
_cell = self.treeview.get_column(
self._lst_col_order[9]).get_cell_renderers()[0]
_adjustment = _cell.get_property('adjustment')
_adjustment.configure(5, 1, 5, -1, 0, 0)
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))
for i in self._lst_col_order:
_cell = self.treeview.get_column(
self._lst_col_order[i]).get_cell_renderers()
if isinstance(_cell[0], gtk.CellRendererPixbuf):
pass
elif isinstance(_cell[0], gtk.CellRendererToggle):
_cell[0].connect('toggled', self._do_edit_cell, None, i,
self.treeview.get_model())
elif isinstance(_cell[0], gtk.CellRendererCombo):
_cell[0].connect('edited', self._do_edit_cell, i,
self.treeview.get_model())
else:
_cell[0].connect('edited', self._do_edit_cell, i,
self.treeview.get_model())
return _frame
def _make_page(self):
"""
Make the Requirement Analysis Work View page.
:return: _hpaned
:rtype: :class:`gtk.HPaned`
"""
_lst_clear = [
_(u"1. The requirement clearly states what is needed or "
u"desired."),
_(u"2. The requirement is unambiguous and not open to "
u"interpretation."),
_(u"3. All terms that can have more than one meaning are "
u"qualified so that the desired meaning is readily "
u"apparent."),
_(u"4. Diagrams, drawings, etc. are used to increase "
u"understanding of the requirement."),
_(u"5. The requirement is free from spelling and "
u"grammatical errors."),
_(u"6. The requirement is written in non-technical "
u"language using the vocabulary of the stakeholder."),
_(u"7. Stakeholders understand the requirement as written."),
_(u"8. The requirement is clear enough to be turned over "
u"to an independent group and still be understood."),
_(u"9. The requirement avoids stating how the problem is "
u"to be solved or what techniques are to be used.")
]
_lst_complete = [
_(u"1. Performance objectives are properly documented "
u"from the user's point of view."),
_(u"2. No necessary information is missing from the "
u"requirement."),
_(u"3. The requirement has been assigned a priority."),
_(u"4. The requirement is realistic given the technology "
u"that will used to implement the system."),
_(u"5. The requirement is feasible to implement given the "
u"defined project time frame, scope, structure and "
u"budget."),
_(u"6. If the requirement describes something as a "
u"'standard' the specific source is cited."),
_(u"7. The requirement is relevant to the problem and its "
u"solution."),
_(u"8. The requirement contains no implied design details."),
_(u"9. The requirement contains no implied implementation "
u"constraints."),
_(u"10. The requirement contains no implied project "
u"management constraints.")
]
_lst_consistent = [
_(u"1. The requirement describes a single need or want; "
u"it could not be broken into several different "
u"requirements."),
_(u"2. The requirement requires non-standard hardware or "
u"must use software to implement."),
_(u"3. The requirement can be implemented within known "
u"constraints."),
_(u"4. The requirement provides an adequate basis for "
u"design and testing."),
_(u"5. The requirement adequately supports the business "
u"goal of the project."),
_(u"6. The requirement does not conflict with some "
u"constraint, policy or regulation."),
_(u"7. The requirement does not conflict with another "
u"requirement."),
_(u"8. The requirement is not a duplicate of another "
u"requirement."),
_(u"9. The requirement is in scope for the project.")
]
_lst_verifiable = [
_(u"1. The requirement is verifiable by testing, "
u"demonstration, review, or analysis."),
_(u"2. The requirement lacks 'weasel words' (e.g. "
u"various, mostly, suitable, integrate, maybe, "
u"consistent, robust, modular, user-friendly, "
u"superb, good)."),
_(u"3. Any performance criteria are quantified such that "
u"they are testable."),
_(u"4. Independent testing would be able to determine "
u"whether the requirement has been satisfied."),
_(u"5. The task(s) that will validate and verify the "
u"final design satisfies the requirement have been "
u"identified."),
_(u"6. The identified V&V task(s) have been added to "
u"the validation plan (e.g., DVP)")
]
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
# Build-up the containers for the tab. #
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
_hpaned = gtk.HPaned()
# Create quadrant #1 (upper left) for determining if the
# requirement is clear.
_vpaned = gtk.VPaned()
_hpaned.pack1(_vpaned, resize=False)
_scrollwindow = gtk.ScrolledWindow()
_scrollwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
_scrollwindow.add(self.tvwClear)
_frame = ramstk.RAMSTKFrame(label=_(u"Clarity of Requirement"))
_frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
_frame.add(_scrollwindow)
_vpaned.pack1(_frame, resize=False)
# Create quadrant #3 (lower left) for determining if the
# requirement is complete.
_scrollwindow = gtk.ScrolledWindow()
_scrollwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
_scrollwindow.add(self.tvwComplete)
_frame = ramstk.RAMSTKFrame(label=_(u"Completeness of Requirement"))
_frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
_frame.add(_scrollwindow)
_vpaned.pack2(_frame, resize=False)
# Create quadrant #2 (upper right) for determining if the
# requirement is consistent.
_vpaned = gtk.VPaned()
_hpaned.pack2(_vpaned, resize=False)
_scrollwindow = gtk.ScrolledWindow()
_scrollwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
_scrollwindow.add(self.tvwConsistent)
_frame = ramstk.RAMSTKFrame(label=_(u"Consistency of Requirement"))
_frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
_frame.add(_scrollwindow)
_vpaned.pack1(_frame, resize=False)
# Create quadrant #4 (lower right) for determining if the
# requirement is verifiable.
_scrollwindow = gtk.ScrolledWindow()
_scrollwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
_scrollwindow.add(self.tvwVerifiable)
_frame = ramstk.RAMSTKFrame(label=_(u"Verifiability of Requirement"))
_frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
_frame.add(_scrollwindow)
_vpaned.pack2(_frame, resize=False)
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
# Place the widgets used to display requirements analysis #
# information. #
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
for _index, _treeview in enumerate([
self.tvwClear, self.tvwComplete, self.tvwConsistent,
self.tvwVerifiable
]):
_model = gtk.ListStore(gobject.TYPE_INT, gobject.TYPE_STRING,
gobject.TYPE_INT)
_treeview.set_model(_model)
_treeview.set_headers_visible(False)
_column = gtk.TreeViewColumn()
_cell = gtk.CellRendererText()
_cell.set_property('editable', 0)
_cell.set_property('visible', 0)
_column.pack_start(_cell, True)
_column.set_attributes(_cell, text=0)
_cell = gtk.CellRendererText()
_cell.set_property('cell-background', '#E5E5E5')
_cell.set_property('editable', 0)
_cell.set_property('wrap-width', 650)
_cell.set_property('wrap-mode', pango.WRAP_WORD_CHAR)
_cell.set_property('yalign', 0.1)
_column.pack_start(_cell, True)
_column.set_attributes(_cell, markup=1)
_cell = gtk.CellRendererToggle()
_cell.set_property('activatable', 1)
_cell.set_property('cell-background', '#E5E5E5')
_cell.connect('toggled', self._do_edit_cell, None, None, _model,
_index)
_column.pack_start(_cell, True)
_column.set_attributes(_cell, active=2)
_column.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE)
_treeview.append_column(_column)
_model = self.tvwClear.get_model()
_model.clear()
for _index, _clear in enumerate(_lst_clear):
_model.append(
[_index, "<span weight='bold'>" + _clear + "</span>", 0])
_model = self.tvwComplete.get_model()
_model.clear()
for _index, _complete in enumerate(_lst_complete):
_model.append(
[_index, "<span weight='bold'>" + _complete + "</span>", 0])
_model = self.tvwConsistent.get_model()
_model.clear()
for _index, _consistent in enumerate(_lst_consistent):
_model.append(
[_index, "<span weight='bold'>" + _consistent + "</span>", 0])
_model = self.tvwVerifiable.get_model()
_model.clear()
for _index, _verifiable in enumerate(_lst_verifiable):
_model.append(
[_index, "<span weight='bold'>" + _verifiable + "</span>", 0])
# Insert the tab.
_label = gtk.Label()
_label.set_markup("<span weight='bold'>" + _(u"Analysis") + "</span>")
_label.set_alignment(xalign=0.5, yalign=0.5)
_label.set_justify(gtk.JUSTIFY_CENTER)
_label.set_tooltip_text(_(u"Analyzes the selected requirement."))
_label.show_all()
self.hbx_tab_label.pack_start(_label)
return _hpaned
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