341 lines
14 KiB
Python
341 lines
14 KiB
Python
# SPDX-License-Identifier: WTFPL
|
|
|
|
import os
|
|
from gi.repository import Gtk
|
|
from dateutil.parser import parse
|
|
|
|
from .view import View, DatePicker
|
|
from yms import gtkutils, combobox, treeview
|
|
from yms.lookup import Dropdown
|
|
from yms.model import measurement
|
|
|
|
class MeasurementView(View):
|
|
|
|
def __init__(self, context):
|
|
super().__init__(context, _("Measurements"), "measurement.ui")
|
|
self.infobar.set_revealed(False)
|
|
self.infobar_label = Gtk.Label()
|
|
self.infobar.get_content_area().add(self.infobar_label)
|
|
|
|
self.measure = measurement.Measurement(context.db) # current record
|
|
self.newrecord = False
|
|
|
|
# dimensions
|
|
self.dd_dimensions = { 1: "1D", 2: "2D", 3: "3D"}
|
|
combobox.load_from_dict(self.combo['dimensions'], self.dd_dimensions, 1)
|
|
|
|
# accuracy
|
|
self.dd_accuracy = self.context.lookup.enum('measurement.accuracy')
|
|
combobox.load_from_dict(self.combo['accuracy'], self.dd_accuracy, 'unknown')
|
|
|
|
# measurement units
|
|
# ATTENTION: Minimum one element in list has to be defined!
|
|
self.dd_unit = self.context.lookup.dropdown(Dropdown.UNIT)
|
|
combobox.load_from_dict(self.combo['unit'], self.dd_unit, 1)
|
|
|
|
# equipment
|
|
self.dd_equipment = self.context.lookup.equipment(context.vessel.vid)
|
|
combobox.load_from_dict(self.combo['equipment'], {-1: _("─── none ───")} | self.dd_equipment)
|
|
|
|
# category
|
|
self.dd_category = self.context.lookup.dropdown(Dropdown.MEASUREMENT_CATEGORY)
|
|
combobox.load_from_dict(self.combo['category'], {-1: _("─── none ───")} | self.dd_category)
|
|
|
|
self.lst_measurement = Gtk.ListStore(int, str, str, str, str, str)
|
|
self.load_list()
|
|
|
|
treeview.add_column(self.tree['measurement'], _('ID'), 0)
|
|
treeview.add_column(self.tree['measurement'], _('Measurement'), 1)
|
|
treeview.add_column(self.tree['measurement'], _('Value'), 2)
|
|
treeview.add_column(self.tree['measurement'], _('Accuracy'), 3)
|
|
treeview.add_column(self.tree['measurement'], _('Equipment'), 4)
|
|
treeview.add_column(self.tree['measurement'], _('Note'), 5)
|
|
self.tree['measurement'].set_model(self.lst_measurement)
|
|
|
|
self.entry['date'].set_placeholder_text(context.get_datefmt_placeholder())
|
|
DatePicker(self.entry['date'], self.button['date'], context.get_datefmt())
|
|
|
|
self.context.subscribe("dd_mcat_modified", self.category_modified)
|
|
self.context.subscribe("dd_unit_modified", self.unit_modified)
|
|
self.context.subscribe("equipment_modified", self.equipment_modified)
|
|
|
|
def get_list_row(self):
|
|
unit = self.dd_unit[self.measure.unit]
|
|
if self.measure.nval == 1:
|
|
value = "{} {}".format(self.measure.val1, unit)
|
|
elif self.measure.nval == 2:
|
|
value = "{}x{} {}".format(self.measure.val1, self.measure.val2, unit)
|
|
elif self.measure.nval == 3:
|
|
value = "{}x{}x{} {}".format(self.measure.val1, self.measure.val2, self.measure.val3, unit)
|
|
else:
|
|
#invalid
|
|
value = "#invalid"
|
|
|
|
return (
|
|
self.measure.mid,
|
|
self.measure.mname,
|
|
value,
|
|
self.measure.accuracy,
|
|
self.dd_equipment.get(self.measure.eid, ''),
|
|
self.measure.note
|
|
)
|
|
|
|
def add_row(self):
|
|
treeiter = self.lst_measurement.append(self.get_list_row())
|
|
self.tree['measurement'].get_selection().select_iter(treeiter)
|
|
|
|
def refresh_row(self):
|
|
treeview.set_row_values(self.tree['measurement'], self.get_list_row())
|
|
|
|
def load_list(self):
|
|
selected_id = treeview.get_value(self.tree['measurement'])
|
|
self.lst_measurement.clear()
|
|
sql = (
|
|
"SELECT m.mid, m.mname, m.nval, m.val1, m.val2, m.val3, m.unit, "
|
|
"m.accuracy, m.note, e.ename "
|
|
"FROM measurement AS m LEFT OUTER JOIN equipment AS e USING (eid) "
|
|
"WHERE m.vid=%s "
|
|
"ORDER BY m.mid"
|
|
)
|
|
self.db.dcur.execute(sql, (self.context.vessel.vid,))
|
|
selection = self.tree['measurement'].get_selection()
|
|
for row in self.db.dcur.fetchall():
|
|
unit = self.dd_unit[row['unit']]
|
|
if row['nval'] == 1:
|
|
value = "{} {}".format(row['val1'], unit)
|
|
elif row['nval'] == 2:
|
|
value = "{}x{} {}".format(row['val1'], row['val2'], unit)
|
|
elif row['nval'] == 3:
|
|
value = "{}x{}x{} {}".format(row['val1'], row['val2'], row['val3'], unit)
|
|
else:
|
|
#invalid
|
|
value = "#invalid"
|
|
data = (
|
|
row['mid'],
|
|
row['mname'],
|
|
value,
|
|
row['accuracy'],
|
|
row['ename'],
|
|
row['note'] or ''
|
|
)
|
|
treeiter = self.lst_measurement.append(data)
|
|
if row['mid'] == selected_id:
|
|
# restore previous selected row
|
|
selection.select_iter(treeiter)
|
|
|
|
def equipment_modified(self, eventtype, data):
|
|
self.dd_equipment[data[0]] = data[1]
|
|
lst = self.combo['equipment'].get_model()
|
|
if eventtype == self.context.EVENT_UPD:
|
|
for row in lst:
|
|
if row[0] == data[0]:
|
|
row[1] = data[1]
|
|
return
|
|
elif eventtype == self.context.EVENT_ADD:
|
|
lst.append(data)
|
|
else:
|
|
# not implemented
|
|
pass
|
|
|
|
def category_modified(self, eventtype, data):
|
|
self.dd_category[data[0]] = data[1]
|
|
lst = self.combo['category'].get_model()
|
|
if eventtype == self.context.EVENT_UPD:
|
|
for row in lst:
|
|
if row[0] == data[0]:
|
|
row[1] = data[1]
|
|
return
|
|
elif eventtype == self.context.EVENT_ADD:
|
|
lst.append(data)
|
|
else:
|
|
# not implemented
|
|
pass
|
|
|
|
def unit_modified(self, eventtype, data):
|
|
self.dd_unit[data[0]] = data[1]
|
|
lst = self.combo['unit'].get_model()
|
|
if eventtype == self.context.EVENT_UPD:
|
|
for row in lst:
|
|
if row[0] == data[0]:
|
|
row[1] = data[1]
|
|
return
|
|
elif eventtype == self.context.EVENT_ADD:
|
|
lst.append(data)
|
|
else:
|
|
# not implemented
|
|
pass
|
|
|
|
def clear_record(self):
|
|
self.measure.clear()
|
|
self.entry['name'].set_text('')
|
|
combobox.activate_row(self.combo['dimensions'], 1)
|
|
self.spin['val1'].set_text('')
|
|
self.spin['val2'].set_text('')
|
|
self.spin['val3'].set_text('')
|
|
combobox.activate_row(self.combo['accuracy'], 'unknown')
|
|
self.entry['date'].set_text('')
|
|
combobox.activate_row(self.combo['equipment'], -1)
|
|
combobox.activate_row(self.combo['category'], -1)
|
|
self.text['note'].get_buffer().set_text('')
|
|
self.entry['name'].grab_focus()
|
|
|
|
self.label['edit_val2'].set_visible(False)
|
|
self.spin['val2'].set_visible(False)
|
|
self.label['edit_val3'].set_visible(False)
|
|
self.spin['val3'].set_visible(False)
|
|
|
|
def display_record(self):
|
|
self.label['name'].set_text(self.measure.mname)
|
|
self.label['dimensions'].set_text(self.dd_dimensions[self.measure.nval])
|
|
self.label['val1'].set_text(self.format_int(self.measure.val1))
|
|
if self.measure.nval >= 2:
|
|
self.label['val2'].set_text(self.format_int(self.measure.val2))
|
|
else:
|
|
self.label['val2'].set_text('n/a')
|
|
if self.measure.nval == 3:
|
|
self.label['val3'].set_text(self.format_int(self.measure.val3))
|
|
else:
|
|
self.label['val3'].set_text('n/a')
|
|
self.label['unit'].set_text(self.dd_unit.get(self.measure.unit, ''))
|
|
self.label['accuracy'].set_text(self.dd_accuracy[self.measure.accuracy])
|
|
self.label['date'].set_text(self.format_date(self.measure.mdate))
|
|
self.label['category'].set_text(self.dd_category.get(self.measure.mcat, ''))
|
|
self.label['note'].set_text(self.measure.note or '')
|
|
|
|
def edit_record(self):
|
|
self.entry['name'].set_text(self.measure.mname)
|
|
combobox.activate_row(self.combo['dimensions'], self.measure.nval)
|
|
if self.measure.val1 is None:
|
|
self.spin['val1'].set_text('')
|
|
else:
|
|
self.spin['val1'].set_value(self.measure.val1)
|
|
if self.measure.val2 is None:
|
|
self.spin['val2'].set_text('')
|
|
else:
|
|
self.spin['val2'].set_value(self.measure.val2)
|
|
if self.measure.val3 is None:
|
|
self.spin['val3'].set_text('')
|
|
else:
|
|
self.spin['val3'].set_value(self.measure.val3)
|
|
combobox.activate_row(self.combo['unit'], self.measure.unit or 1)
|
|
combobox.activate_row(self.combo['accuracy'], self.measure.accuracy)
|
|
self.entry['date'].set_text(self.format_date(self.measure.mdate))
|
|
combobox.activate_row(self.combo['equipment'], self.measure.eid or -1)
|
|
combobox.activate_row(self.combo['category'], self.measure.mcat or -1)
|
|
self.text['note'].get_buffer().set_text(self.measure.note or '')
|
|
self.entry['name'].grab_focus()
|
|
|
|
self.label['edit_val2'].set_visible(self.measure.nval > 1)
|
|
self.spin['val2'].set_visible(self.measure.nval > 1)
|
|
self.label['edit_val3'].set_visible(self.measure.nval > 2)
|
|
self.spin['val3'].set_visible(self.measure.nval > 2)
|
|
|
|
def save_record(self):
|
|
# fields must have been validated beforehand
|
|
self.measure.vid = self.context.vessel.vid
|
|
self.measure.mname = self.entry['name'].get_text()
|
|
self.measure.nval = combobox.get_list_value(self.combo['dimensions'])
|
|
self.measure.val1 = self.spin['val1'].get_value_as_int()
|
|
self.measure.val2 = self.spin['val2'].get_value_as_int()
|
|
self.measure.val3 = self.spin['val3'].get_value_as_int()
|
|
self.measure.unit = combobox.get_list_value(self.combo['unit'])
|
|
self.measure.accuracy = combobox.get_list_value(self.combo['accuracy'])
|
|
try:
|
|
self.measure.mdate = parse(self.entry['date'].get_text(), dayfirst=True)
|
|
except ValueError:
|
|
self.measure.mdate = None
|
|
self.measure.eid = combobox.get_list_value(self.combo['equipment'])
|
|
if self.measure.eid == -1:
|
|
self.measure.eid = None
|
|
self.measure.mcat = combobox.get_list_value(self.combo['category'])
|
|
if self.measure.mcat == -1:
|
|
self.measure.mcat = None
|
|
self.measure.note = gtkutils.get_text_contents(self.text['note'])
|
|
|
|
# buttons on list page
|
|
def on_but_new_clicked(self, widget):
|
|
self.newrecord = True
|
|
self.label['title_edit'].set_text(_("Add new Measurement"))
|
|
self.clear_record()
|
|
self.topwidget.set_visible_child(self.box['measure_edit'])
|
|
|
|
def on_but_edit_clicked(self, widget):
|
|
mid = treeview.get_value(self.tree['measurement'], 0)
|
|
if not mid:
|
|
return
|
|
self.newrecord = False
|
|
self.label['title_edit'].set_text(_("Edit Measurement"))
|
|
if not self.record_lock('measurement', mid):
|
|
return
|
|
self.measure.load(mid)
|
|
self.edit_record()
|
|
self.topwidget.set_visible_child(self.box['measure_edit'])
|
|
|
|
def on_but_detail_clicked(self, widget):
|
|
mid = treeview.get_value(self.tree['measurement'], 0)
|
|
if not mid:
|
|
return
|
|
self.measure.load(mid)
|
|
self.display_record()
|
|
self.topwidget.set_visible_child(self.box['measure_detail'])
|
|
self.button['close'].grab_focus()
|
|
|
|
def on_tvw_measurement_row_activated(self, widget, path, column):
|
|
mid = treeview.get_value(widget, 0)
|
|
self.measure.load(mid)
|
|
self.display_record()
|
|
self.topwidget.set_visible_child(self.box['measure_detail'])
|
|
self.button['close'].grab_focus()
|
|
|
|
def on_cmb_dimensions_changed(self, widget):
|
|
ndim = combobox.get_list_value(widget)
|
|
self.label['edit_val2'].set_visible(ndim > 1)
|
|
self.spin['val2'].set_visible(ndim > 1)
|
|
self.label['edit_val3'].set_visible(ndim > 2)
|
|
self.spin['val3'].set_visible(ndim > 2)
|
|
|
|
# buttons on detail page
|
|
# edit2 uses edit callback
|
|
def on_but_close_clicked(self, widget):
|
|
self.topwidget.set_visible_child(self.box['measurement'])
|
|
|
|
def on_but_delete_clicked(self, widget):
|
|
answer = gtkutils.questionbox(
|
|
_("Delete measurement!\n"
|
|
"Are you sure?"), title="YMS"
|
|
)
|
|
if answer == False:
|
|
return
|
|
self.topwidget.set_visible_child(self.box['measurement'])
|
|
|
|
# buttons on edit page
|
|
def on_but_save_clicked(self, widget):
|
|
# check mandatory fields
|
|
if not self.entry['name'].get_text().strip():
|
|
# TODO error marker
|
|
print("Save error mandatory fields missing")
|
|
self.infobar.set_message_type(Gtk.MessageType.WARNING)
|
|
self.infobar_label.set_text("Save error mandatory fields missing")
|
|
self.infobar.set_revealed(True)
|
|
return
|
|
else:
|
|
self.infobar_label.set_text('')
|
|
self.infobar.set_revealed(False)
|
|
self.save_record()
|
|
print(self.measure)
|
|
if not self.measure.save():
|
|
pass
|
|
self.record_unlock()
|
|
if self.newrecord:
|
|
#self.load_list()
|
|
self.add_row()
|
|
self.newrecord = False
|
|
else:
|
|
self.refresh_row()
|
|
self.display_record()
|
|
self.topwidget.set_visible_child(self.box['measure_detail'])
|
|
|
|
def on_but_cancel_clicked(self, widget):
|
|
self.record_unlock()
|
|
self.topwidget.set_visible_child(self.box['measurement'])
|