Native gui usable for data editing. Lots of fixes and improvenemts

This commit is contained in:
thooge committed 2026-11-11 18:58:02 +01:00
1 parent a6abdaa614
commit 09387280fc
52 files changed
+1579 -294

No files matched your search

+336 -40
View File
@@ -17,7 +17,7 @@ import json
from .view import View
from yms import gtkutils, combobox, treeview
from yms.lookup import Dropdown
from yms.lookup import Dropdown, DDNAME
from yms.model import user
class BaseView(View):
@@ -50,7 +50,7 @@ class BaseView(View):
key: f"{prefix} - {today.strftime(fmt)}"
for key, (fmt, prefix) in context.datefmt_map.items()
}
self.datefmt = context.db.load_setting(2)[0] or 'Y-m-d'
self.datefmt = context.db.load_setting(2, False)[0] or 'Y-m-d'
combobox.load_from_dict(self.combo['datefmt'], datedict, self.datefmt)
# shipyard
@@ -78,15 +78,14 @@ class BaseView(View):
self.context.vessel.vesselname = "Ghost"
# default storage for current vessel
#sql = "SELECT sid, sname FROM storage WHERE stype=0 AND vid=%s ORDER BY sname"
#self.db.cur.execute(sql, (self.context.vessel.vid,))
#storages = dict(self.db.cur.fetchall())
storages = self.context.lookup.storage(self.context.vessel.vid)
combobox.load_from_dict(self.combo['storage'], {-1: _("─── none ───")} | storages)
self.dd_storage = self.context.lookup.storage(self.context.vessel.vid)
combobox.load_from_dict(self.combo['storage'], {-1: _("─── none ───")} | self.dd_storage)
self.context.subscribe("storage_modified", self.storage_modified)
# Vessel types
self.dd_vtype = self.context.lookup.dropdown(Dropdown.VESSEL_TYPE)
combobox.load_from_dict(self.combo['vtype'], {-1: _("─── none ───")} | self.dd_vtype, -1)
self.context.subscribe("dd_vtype_modified", self.vtype_modified)
# Hull types
self.dd_htype = self.context.lookup.enum('vessel.htype')
@@ -97,44 +96,65 @@ class BaseView(View):
combobox.load_from_dict(self.combo['hull_shape'], {"-1": _("─── none ───")} | shapes)
# get list of vessels
#vessellist = {}
#self.db.dcur.execute("SELECT vid, vesselname, model FROM vessel ORDER BY vid")
#for row in self.db.dcur.fetchall():
# vessellist[row['vid']] = (
# row['vesselname'] if row['model'] is None
# else row['vesselname'] + " - " + row['model']
# )
vessellist = self.context.lookup.vessel()
combobox.load_from_dict(self.combo['vessel'], vessellist, self.context.vessel.vid)
# vessel load triggered from combobox init
if len(vessellist) > 0:
combobox.load_from_dict(self.combo['vessel'], vessellist, self.context.vessel.vid)
# TODO ? vessel load triggered from combobox init
# self.context.publish("vessel_modified", self.context.EVENT_UPD, None)
# prepare lists
self.lst_user = Gtk.ListStore(int, str)
self.db.cur.execute("SELECT userid, login FROM user WHERE userid>0 ORDER BY login")
for row in self.db.cur.fetchall():
self.lst_user.append(row)
self.load_list_user()
treeview.add_column(self.tree['user'], 'ID', 0)
treeview.add_column(self.tree['user'], 'Login', 1)
self.tree['user'].set_model(self.lst_user)
# list of dropdown lists
# list of dropdown lists (static!)
self.lst_lists = Gtk.ListStore(int, str, int)
# self.db.cur.execute("SELECT ddval, ddtext FROM dropdown WHERE ddid=0 AND ddval>0 ORDER BY ddval")
sql = (
"SELECT dd.ddval, dd.ddtext, COUNT(n.ddval) AS records "
"SELECT dd.ddval, dd.ddtext, FIND_IN_SET('locked', dd.flags) AS locked, "
"COUNT(n.ddval) AS records "
"FROM dropdown AS dd LEFT JOIN dropdown AS n ON dd.ddval=n.ddid "
"WHERE dd.ddid=0 "
"GROUP BY dd.ddval, dd.ddtext "
"ORDER BY dd.ddval"
)
self.db.cur.execute(sql)
for row in self.db.cur.fetchall():
self.lst_lists.append(row)
treeview.add_column(self.tree['ddlists'], _('ID'), 0)
treeview.add_column(self.tree['ddlists'], _('List'), 1)
treeview.add_column(self.tree['ddlists'], _('Records'), 2)
self.db.dcur.execute(sql)
for row in self.db.dcur.fetchall():
data = []
data.append(row['ddval'])
if row['locked']:
# Unicode Lock-Symbol
data.append("{} \U0001F512".format(row['ddtext']))
else:
data.append(row['ddtext'])
data.append(row['records'])
self.lst_lists.append(data)
treeview.create_columns(
self.tree['ddlists'],
(_('ID'), _('List'), _('Records'))
)
self.tree['ddlists'].set_model(self.lst_lists)
self.lst_list = Gtk.ListStore(int, str, str, int, str, str)
treeview.create_columns(
self.tree['ddlist'],
(_('ID'), _('Text'), _('Short'), _('Sort'), _('Color'), _('Flags'))
)
self.tree['ddlist'].set_model(self.lst_list)
# Select first list
selection = self.tree['ddlists'].get_selection()
path = Gtk.TreePath.new_from_indices([1])
selection.select_path(path)
self.ddid_cur = None # Current selected dropdown entry
self.ddval_cur = None
self.ddid_iter = None # to easy update selected item
self.ddval_iter = None # to easy update selected item
self.dd_newrecord = False
# Settings date format selection list
# self.context.datefmt_map
@@ -157,13 +177,68 @@ class BaseView(View):
# WIP generic remarks handling
self.text['vessel_remarks'].set_size_request(200, 70)
def load_list(self):
# placeholder
pass
def load_list_user(self):
selected_id = treeview.get_value(self.tree['user'])
self.lst_user.clear()
self.db.cur.execute("SELECT userid, login FROM user WHERE userid>0 ORDER BY login")
selection = self.tree['user'].get_selection()
for row in self.db.cur.fetchall():
treeiter = self.lst_user.append(row)
if row[0] == selected_id:
# restore previous selected row
selection.select_iter(treeiter)
def load_list_dropdown(self, listid):
self.lst_list.clear()
sql = (
"SELECT ddval, ddtext, ddshort, sort, color, flags "
"FROM dropdown "
"WHERE ddid=%s "
"ORDER BY ddval"
)
self.db.cur.execute(sql, (listid,))
for row in self.db.cur.fetchall():
self.lst_list.append(row)
def load_dropdowns(self):
# non static dropdown (re-)load feature
# default storage for current vessel
sql = "SELECT sid, sname FROM storage WHERE stype=0 AND vid=%s ORDER BY sname"
self.db.cur.execute(sql, (self.context.vessel.vid,))
storages = dict(self.db.cur.fetchall())
combobox.refresh_dict(self.combo['storage'], {-1: _("─── none ───")} | storages)
self.dd_storage = dict(self.db.cur.fetchall())
combobox.refresh_dict(self.combo['storage'], {-1: _("─── none ───")} | self.dd_storage)
def vtype_modified(self, eventtype, data):
self.dd_vtype[data[0]] = data[1]
lst = self.combo['vtype'].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 storage_modified(self, eventtype, data):
self.dd_storage[data[0]] = data[1]
lst = self.combo['storage'].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 load_shapes(self):
# TODO / WIP process shapeindex
@@ -173,7 +248,7 @@ class BaseView(View):
# load json
with open(indexfile, "r", encoding="utf-8") as fh:
sflist = json.load(fh)
print("Shapefile found and loaded")
print("Shapeindex file found and loaded")
else:
# create shapeindex (first simple version)
sflist = {}
@@ -328,7 +403,7 @@ class BaseView(View):
self.db.conn.commit()
# Refresh dependent data
self.load_dropdowns()
self.context.publish("vessel_changed", (self.context.vessel.pk_value, ))
self.context.publish("vessel_modified", self.context.EVENT_UPD, (self.context.vessel.pk_value, ))
# Show data
self.display_vessel(self.context.vessel)
@@ -340,9 +415,13 @@ class BaseView(View):
if answer == False:
return
self.context.vessel.create()
print(self.context.vessel)
model = self.combo['vessel'].get_model()
model.append((self.context.vessel.vid, self.context.vessel.vesselname))
combobox.activate_row(self.combo['vessel'], self.context.vessel.vid)
if model is None:
combobox.load_from_dict(self.combo['vessel'], {self.context.vessel.vid: self.context.vessel.vesselname}, self.context.vessel.vid)
else:
model.append((self.context.vessel.vid, self.context.vessel.vesselname))
combobox.activate_row(self.combo['vessel'], self.context.vessel.vid)
self.edit_vessel(self.context.vessel)
self.stack['vessel'].set_visible_child(self.box['vessel_edit'])
@@ -377,19 +456,43 @@ class BaseView(View):
vessel.shapefile = None
vessel.remarks = gtkutils.get_text_contents(self.text['vessel_remarks'])
vessel.save()
self.context.publish("vessel_modified", self.context.EVENT_UPD, (vessel.vid, ))
self.stack['vessel'].set_visible_child(self.box['vessel'])
self.display_vessel(self.context.vessel)
def on_but_vessel_cancel_clicked(self, widget):
self.stack['vessel'].set_visible_child(self.box['vessel'])
def on_but_vessel_delete_clicked(self, widget):
pass
# TODO check if there are no associated data with vessel
answer = gtkutils.questionbox(
_("Delete vessel!\n"
"Are you sure?"
), title="YMS")
if answer == False:
return
# TODO
def on_but_settings_save_clicked(self, widget):
print("Save settings")
#self.entry['sys_currency']
#self.spin['sys_max_width']
#self.spin['sys_max_height']
# System settings
new_currency = self.entry['sys_currency'].get_text()
if self.sys_currency != new_currency:
self.db.save_setting(4, new_currency, None)
self.sys_currency = new_currency
new_max_width = self.spin['sys_max_width'].get_value_as_int()
if self.sys_max_width != new_max_width:
self.db.save_setting(20, None, new_max_width)
self.sys_max_width = new_max_width
new_max_height = self.spin['sys_max_height'].get_value_as_int()
if self.sys_max_height != new_max_height:
self.db.save_setting(21, None, new_max_height)
self.sys_max_height = new_max_height
# User settings
new_datefmt = combobox.get_list_value(self.combo['datefmt'])
if self.datefmt != new_datefmt:
self.db.save_setting(2, new_datefmt, None)
self.context.datefmt = new_datefmt
self.db.conn.commit()
def display_vessel(self, vessel):
self.label['vesselname'].set_text(vessel.vesselname)
@@ -453,7 +556,6 @@ class BaseView(View):
self.lst_user.append((self.context.user.user_id, self.context.user.login))
def on_but_user_del_clicked(self, widget):
print("Delete user")
answer = gtkutils.questionbox(
_("Delete user!\n"
"Are you sure?"
@@ -503,3 +605,197 @@ class BaseView(View):
else:
# Password to short
pass
def clear_dd_entry(self):
# Clear list entry editor
self.spin['dd_val'].set_text('')
self.entry['dd_text'].set_text('')
self.entry['dd_short'].set_text('')
self.spin['dd_sort'].set_text('')
self.entry['dd_color'].set_text('')
# TODO set color button to undef shown as 100% transparent
# self.button['dd_color']
self.check['dd_fixed'].set_active(False)
self.check['dd_locked'].set_active(False)
def on_but_dd_color_set(self, button):
rgba = button.get_rgba()
r = round(rgba.red * 255)
g = round(rgba.green * 255)
b = round(rgba.blue * 255)
a = round(rgba.alpha * 255)
if a > 0:
self.entry['dd_color'].set_text(f"#{r:02X}{g:02X}{b:02X}")
else:
self.entry['dd_color'].set_text('')
def on_ent_dd_color_activate(self, entry):
self.set_color_from_entry(entry, self.button['dd_color'])
def on_ent_dd_color_focus_out_event(self, entry, event):
self.set_color_from_entry(entry, self.button['dd_color'])
return False
def on_but_list_new_clicked(self, widget):
self.dd_newrecord = True
self.ddval_cur = None
self.clear_dd_entry()
# get next free value for ddid, ddval
sql = (
"SELECT MIN(n.ddval) AS nextval "
"FROM ("
"SELECT 1 AS ddval "
"UNION ALL "
"SELECT DISTINCT ddval+1 "
"FROM dropdown "
"WHERE ddid=%(ddid)s AND ddval>0"
") AS n "
"LEFT JOIN dropdown AS m ON m.ddval=n.ddval AND m.ddid=%(ddid)s "
"WHERE m.ddval IS NULL"
)
self.db.cur.execute(sql, {'ddid': self.ddid_cur})
self.ddval_cur = self.db.cur.fetchone()[0] or 1
if not self.ddval_cur:
# TODO message internal error to user
print("internal error while creating new value")
return
self.spin['dd_val'].set_value(self.ddval_cur)
self.button['list_save'].set_sensitive(True)
self.entry['dd_text'].grab_focus()
def on_but_list_save_clicked(self, widget):
if self.dd_newrecord:
sql = (
"INSERT INTO dropdown (ddid, ddval, ddtext, ddshort, sort, color, flags) "
"VALUES (%s, %s, %s, %s, %s, %s, %s)"
)
values = (
self.ddid_cur,
self.spin['dd_val'].get_value_as_int(), # autogenerated by new button
self.entry['dd_text'].get_text(),
self.entry['dd_short'].get_text(),
self.spin['dd_sort'].get_value_as_int(),
self.entry['dd_color'].get_text().lstrip('#'),
self.get_checks(('dd_locked', 'dd_fixed'), prefix='dd_')
)
if self.db.execute_write(sql, values, 1):
self.db.conn.commit()
else:
# TODO message sql error to user
print(self.db.last_error())
print(sql, values)
return
# TODO
# message success to user
# refresh list
data = (
self.spin['dd_val'].get_value_as_int(),
self.entry['dd_text'].get_text(),
self.entry['dd_short'].get_text(),
self.spin['dd_sort'].get_value_as_int(),
self.entry['dd_color'].get_text().lstrip('#'),
'' # TODO flags
)
treeiter = self.lst_list.append(data)
selection = self.tree['ddlist'].get_selection()
selection.select_iter(treeiter)
# increase entry in main list
count = treeview.get_value(self.tree['ddlists'], 2)
treeview.set_value(self.tree['ddlists'], 2, count+1)
# send event
eventname = "dd_{}_modified".format(DDNAME[self.ddid_cur])
self.context.publish(eventname, self.context.EVENT_ADD, (data[0], data[1]))
else:
if self.ddid_cur is None or self.ddval_cur is None:
print("internal error: ids not set")
return
sql = (
"UPDATE dropdown SET ddtext=%s, ddshort=%s, sort=%s, color=%s, flags=%s "
"WHERE ddid=%s AND ddval=%s"
)
values = (
self.entry['dd_text'].get_text(),
self.entry['dd_short'].get_text(),
self.spin['dd_sort'].get_value_as_int(),
self.entry['dd_color'].get_text().lstrip('#'),
self.get_checks(('dd_locked', 'dd_fixed'), prefix='dd_'),
self.ddid_cur,
self.ddval_cur
)
if self.db.execute_write(sql, values):
self.db.conn.commit()
else:
# TODO message sql error to user
print(self.db.last_error())
print(sql, values)
return
# refresh list
data = (
self.spin['dd_val'].get_value_as_int(),
self.entry['dd_text'].get_text(),
self.entry['dd_short'].get_text(),
self.spin['dd_sort'].get_value_as_int(),
self.entry['dd_color'].get_text().lstrip('#'),
'' # TODO flags
)
treeview.set_row_values(self.tree['ddlist'], data)
# send event
eventname = "dd_{}_modified".format(DDNAME[self.ddid_cur])
self.context.publish(eventname, self.context.EVENT_UPD, (data[0], data[1]))
self.dd_newrecord = False
# TODO
# message success to user
# refresh list
def on_but_list_delete_clicked(self, widget):
answer = gtkutils.questionbox(
_("Delete list entry!\n"
"Are you sure?"
), title="YMS")
if answer == False:
return
def on_tvw_ddlists_row_activated(self, widget, path, column):
# load single list
self.ddid_iter = widget.get_selection().get_selected()[1]
self.ddid_cur = treeview.get_value(widget, 0)
self.ddval_cur = None
self.load_list_dropdown(self.ddid_cur)
self.clear_dd_entry()
self.button['list_save'].set_sensitive(False)
def on_tvw_ddlist_row_activated(self, widget, path, column):
# load list entry details
self.ddval_iter = widget.get_selection().get_selected()[1]
self.ddval_cur = treeview.get_value(widget, 0)
sql = (
"SELECT ddtext, ddshort, sort, color, flags "
"FROM dropdown "
"WHERE ddid=%s AND ddval=%s "
"ORDER BY ddval"
)
self.db.dcur.execute(sql, (self.ddid_cur, self.ddval_cur))
row = self.db.dcur.fetchone()
if not row:
# internal error
print(f"internal error ddval #{self.ddval_cur} not found")
self.ddval_cur = None
return
# fill edit fields
self.spin['dd_val'].set_value(self.ddval_cur)
self.entry['dd_text'].set_text(row['ddtext'] or '')
self.entry['dd_short'].set_text(row['ddshort'] or '')
if row['sort']:
self.spin['dd_sort'].set_value(row['sort'])
else:
self.spin['dd_sort'].set_text('')
self.entry['dd_color'].set_text(row['color'] or '')
flags = (row['flags'] or '').split(',')
self.check['dd_fixed'].set_active('fixed' in flags)
self.check['dd_locked'].set_active('locked' in flags)
self.button['list_save'].set_sensitive(True)
self.dd_newrecord = False