# SPDX-License-Identifier: WTFPL """ Special: Notebook with Vessel, User, Lists, Settings """ import os import pyudev from gi.repository import GLib, Gtk, Gdk, Rsvg from datetime import datetime import subprocess import locale import xml.etree.ElementTree as ET import json from .view import View from yms import gtkutils, combobox, treeview from yms.lookup import Dropdown, DDNAME from yms.model import user class BaseView(View): def __init__(self, context): super().__init__(context, _("Base Data"), "base.ui") self.context = context self.user = user.User(context.db) # current user record self.newuser = False self.backupdevice = None # USB-Stick detected only on demand # Settings self.sys_currency = context.db.load_setting(4)[0] or '€' self.entry['sys_currency'].set_text(self.sys_currency) self.sys_max_width = context.db.load_setting(20)[1] or 1024 self.spin['sys_max_width'].set_value(self.sys_max_width) self.sys_max_height = context.db.load_setting(21)[1] or 768 self.spin['sys_max_height'].set_value(self.sys_max_height) # combos roles = {'captain': 'Captain', 'helmsman': 'Helmsman', 'sailor': 'Sailor'} combobox.load_from_dict(self.combo['user_role'], roles) langs = {'de': 'Deutsch', 'en': 'English'} combobox.load_from_dict(self.combo['user_lang'], langs) today = datetime.now() datedict = { key: f"{prefix} - {today.strftime(fmt)}" for key, (fmt, prefix) in context.datefmt_map.items() } self.datefmt = context.db.load_setting(2, False)[0] or 'Y-m-d' combobox.load_from_dict(self.combo['datefmt'], datedict, self.datefmt) # shipyard self.db.cur.execute("SELECT compid, compname FROM company WHERE comptype=3 ORDER BY compname") shipyards = dict(self.db.cur.fetchall()) combobox.load_from_dict(self.combo['shipyard'], {-1: _("─── none ───")} | shipyards) # get current vessel data self.db.cur.execute("SELECT valint FROM settings WHERE userid=0 AND sno=1") row = self.db.cur.fetchone() if not row: self.context.vessel.vid = 0 self.context.vessel.vesselname = "Ghost" self.db.cur.execute("INSERT INTO settings (userid, sno, valint) VALUES (0, 1, 0)") self.db.conn.commit() else: # check if vessel from settings exist self.db.cur.execute("SELECT count(*) FROM vessel WHERE vid=%s", (row[0],)) res = self.db.cur.fetchone()[0] if res > 0: self.context.vessel.vid = row[0] else: # TODO set vessel to first in list self.context.vessel.vid = 0 self.context.vessel.vesselname = "Ghost" # default storage for current vessel 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') combobox.load_from_dict(self.combo['htype'], self.dd_htype, 'mono') # List of available shapes for combobox selection shapes = self.load_shapes() combobox.load_from_dict(self.combo['hull_shape'], {"-1": _("─── none ───")} | shapes) # get list of vessels vessellist = self.context.lookup.vessel() 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.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 (static!) self.lst_lists = Gtk.ListStore(int, str, int, bool) sql = ( "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.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']) data.append(row['locked']) 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.dd_newrecord = False # Settings date format selection list # self.context.datefmt_map # load shape of vessel if available if self.context.vessel.vid > 0: self.db.cur.execute("SELECT shapefile FROM vessel WHERE vid=%s", (self.context.vessel.vid, )) filename = self.db.cur.fetchone()[0] or '' shapefilepath = os.path.join(context.cfg['shapedir'], filename) if os.path.isfile(shapefilepath): handle = Rsvg.Handle() self._svg = handle.new_from_file(shapefilepath) #self._svg = handle.new_from_file(os.path.join(sys.path[0], cfg['shapedir'], "elizabethan29.svg")) #viewport = Rsvg.Rectangle() #viewport.x = 0 #viewport.y = 0 #viewport.width = 320 #viewport.height = 240 #self._svg.render_document(ctx, viewport) # 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,)) 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 # returns dict of filename: title indexfile = os.path.join(self.context.cfg['docpath'], "shapeindex.json") if os.path.isfile(indexfile): # load json with open(indexfile, "r", encoding="utf-8") as fh: sflist = json.load(fh) print("Shapeindex file found and loaded") else: # create shapeindex (first simple version) sflist = {} for fname in os.listdir(self.context.cfg['shapedir']): if fname.lower().endswith(".svg"): shapefile = os.path.join(self.context.cfg['shapedir'], fname) try: root = ET.parse(shapefile).getroot() title_element = root.find("{http://www.w3.org/2000/svg}title") if title_element is not None and title_element.text: title = title_element.text.strip() else: title = os.path.splitext(fname)[0] except ET.ParseError: title = os.path.splitext(fname)[0] sflist[fname] = title with open(indexfile, "w", encoding="utf-8") as fh: json.dump(sflist, fh, ensure_ascii=False, indent=4) print("Created new shapeindex file") return sflist def find_usb_sticks(self): result = [] for name in os.listdir("/sys/block"): device = "/sys/block/" + name removable = device + "/removable" if not os.path.exists(removable): continue with open(removable) as f: if f.read().strip() != "1": continue device_path = os.path.realpath(device + "/device") if "/usb" in device_path.lower(): result.append(name) return result def is_mounted(self, device): with open("/proc/mounts") as f: for line in f: mounted_device = line.split()[0] if mounted_device == device: return True return False def on_but_usbdevice_clicked(self, widget): self.backupdevice = None devlist = self.find_usb_sticks() if len(devlist) == 0: self.label['usb_device'].set_text('n/a') return if len(devlist) != 1: print(devlist) print("Multiple devices not supported yet") self.label['usb_device'].set_text('multiple') return usbdev = devlist[0] self.label['usb_device'].set_text(f"/dev/{usbdev}") """ serial number via python3-pyudev: import pyudev Settings 7 - usb backup device serial 8 - usb backup partition uuid 9 - last backup timestamp """ # first get stick hardware data udevctx = pyudev.Context() device = pyudev.Devices.from_sys_path(udevctx, os.path.join("/sys/class/block", usbdev)) serial = device.get("ID_SERIAL_SHORT") vendor = device.get("ID_VENDOR") model = device.get("ID_MODEL") self.label['usb_serial'].set_text(serial or 'n/a') self.label['usb_vendor'].set_text(vendor or 'n/a') self.label['usb_model'].set_text(model or 'n/a') # TODO second get partition, filesystem type and label # there must be only one ext4 partition on disk partitions = [ child for child in device.children if child.device_type == "partition" ] partition = partitions[0] print(f"Partition={partition}") if len(partitions) != 1: print("error: more than one partition!") return partuuid = partition.properties.get("ID_PART_ENTRY_UUID") fstype = partition.get("ID_FS_TYPE") plabel = partition.get("ID_FS_LABEL") self.label['usb_partition'].set_text(plabel) self.label['usb_uuid'].set_text(partuuid) self.label['usb_fstype'].set_text(fstype) if fstype != "ext4": print(f"error: invalid fileystem type {fstype}, ext4 expected") return self.backupdevice = f"/dev/{usbdev}1" # partition! # check if device is mounted if not self.is_mounted(self.backupdevice): print("device is not mounted. trying to mount now") pass # For backup there must be an directory names ymsbackup which contains # backup description and backup sets # Desription and identification file backup.json? # if plabel != 'BACKUP' or not os.path.isdir('ymsbackup') mountpoint = os.path.join("/media", os.getlogin(), "BACKUP") if not os.path.isdir(mountpoint): print(f"Device is not mounted at {mountpoint}") def on_but_usbinit_clicked(self, widget): if self.backupdevice is None: return # UUID of devive -> settings # check if backups already exist answer = gtkutils.questionbox( _("Initialize USB-Stick\n" "All data on that device will be lost!\n" "Are you really sure?" ), title="YMS") if answer == False: return if self.label['usb_fstype'].get_text() != 'ext4': print("formatting {self.backupdevice} with ext4") #try: # subprocess.run(["sudo", "mkfs.ext4", "-L", "BACKUP", self.backupdevice], check=True) #except subprocess.CalledProcessError as e: # print("formatting failed: ", e) myself = os.getlogin() mountpoint = os.path.join("/media", myself, "backup") basedir = os.path.join(mountpoint, 'ymsbackup') print(basedir) # mkdir basedir # chown (os.getlogin(), 'yms') # chmod 770 else: # pass def on_cmb_vessel_changed(self, widget): self.context.vessel.load(combobox.get_list_value(widget)) sql = ("UPDATE settings SET valint=%s WHERE userid=0 AND sno=1") self.db.cur.execute(sql, (self.context.vessel.vid,)) self.db.conn.commit() # Refresh dependent data self.load_dropdowns() self.context.publish("vessel_modified", self.context.EVENT_UPD, (self.context.vessel.pk_value, )) # Show data self.display_vessel(self.context.vessel) def on_but_vessel_add_clicked(self, widget): answer = gtkutils.questionbox( _("Add new vessel.\n" "Are you sure?" ), title="YMS") if answer == False: return self.context.vessel.create() print(self.context.vessel) model = self.combo['vessel'].get_model() 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']) def on_but_vessel_edit_clicked(self, widget): self.edit_vessel(self.context.vessel) self.stack['vessel'].set_visible_child(self.box['vessel_edit']) def on_but_vessel_save_clicked(self, widget): vessel = self.context.vessel vessel.vesselname = self.entry['vesselname'].get_text() vessel.model = self.entry['model'].get_text() vessel.vtype = combobox.get_list_value(self.combo['vtype']) if vessel.vtype == -1: vessel.vtype = None vessel.year_built = self.spin['year_built'].get_value_as_int() vessel.hull_number = self.entry['hull_number'].get_text() vessel.shipyard = combobox.get_list_value(self.combo['shipyard']) if vessel.shipyard == -1: vessel.shipyard = None vessel.loa = self.spin['loa'].get_value() vessel.lwl = self.spin['lwl'].get_value() vessel.beam = self.spin['beam'].get_value() vessel.draught = self.spin['draught'].get_value() vessel.draught_min = self.spin['draught_min'].get_value() vessel.displacement = self.spin['displacement'].get_value_as_int() vessel.ballast = self.spin['ballast'].get_value_as_int() vessel.beltpos_bow = self.spin['belt_bow'].get_value() vessel.beltpos_aft = self.spin['belt_aft'].get_value() vessel.htype = combobox.get_list_value(self.combo['htype']) vessel.shapefile = combobox.get_list_value(self.combo['hull_shape']) if vessel.shapefile == '-1': 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, )) # refresh vessel selection list model = self.combo['vessel'].get_model() active = self.combo['vessel'].get_active() model[active][1] = f"{vessel.vesselname} - {vessel.model}" if vessel.model else vessel.vesselname # switch to display mode 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): # 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): # 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 or '') self.label['model'].set_text(vessel.model or '') self.label['shipyard'].set_text(self.dd_storage.get(vessel.shipyard, '-')) self.label['year_built'].set_text(self.format_int(vessel.year_built, False, default='n/a')) self.label['hull_number'].set_text(vessel.hull_number or '') self.label['loa'].set_text(self.format_float(vessel.loa, 2, suffix='m')) self.label['lwl'].set_text(self.format_float(vessel.lwl, 2, suffix='m')) self.label['beam'].set_text(self.format_float(vessel.beam, 2, suffix='m')) self.label['draught'].set_text(self.format_float(vessel.draught, 2, suffix='m')) self.label['draught_min'].set_text(self.format_float(vessel.draught_min, 2, suffix='m')) self.label['displacement'].set_text(self.format_int(vessel.displacement, 2, suffix='kg')) self.label['ballast'].set_text(self.format_int(vessel.ballast, 2, suffix='kg')) self.label['belt_bow'].set_text(self.format_float(vessel.beltpos_bow, 2, suffix='m')) self.label['belt_aft'].set_text(self.format_float(vessel.beltpos_aft, 2, suffix='m')) self.label['hull_shape'].set_text(vessel.shapefile or '-') self.label['storage_def'].set_text(self.dd_storage.get(vessel.sid_default, '-')) self.label['remarks'].set_text(vessel.remarks or '') def edit_vessel(self, vessel): self.entry['vesselname'].set_text(vessel.vesselname) self.entry['model'].set_text(vessel.model or '') combobox.activate_row(self.combo['vtype'], vessel.vtype or -1) self.spin['year_built'].set_value(vessel.year_built or 0) self.entry['hull_number'].set_text(vessel.hull_number or '') combobox.activate_row(self.combo['shipyard'], vessel.shipyard or -1) self.spin['loa'].set_value(vessel.loa or 0) self.spin['lwl'].set_value(vessel.lwl or 0) self.spin['beam'].set_value(vessel.beam or 0) self.spin['draught'].set_value(vessel.draught or 0) self.spin['draught_min'].set_value(vessel.draught_min or 0) self.spin['displacement'].set_value(vessel.displacement or 0) self.spin['ballast'].set_value(vessel.ballast or 0) self.spin['belt_bow'].set_value(vessel.beltpos_bow or 0) self.spin['belt_aft'].set_value(vessel.beltpos_aft or 0) combobox.activate_row(self.combo['htype'], vessel.htype) combobox.activate_row(self.combo['hull_shape'], vessel.shapefile or "-1") combobox.activate_row(self.combo['storage'], vessel.sid_default or -1) self.text['vessel_remarks'].get_buffer().set_text(vessel.remarks or '') self.entry['vesselname'].grab_focus() def display_user(self, user): self.entry['user_login'].set_text(user.login) self.entry['user_displayname'].set_text(user.displayname) combobox.activate_row(self.combo['user_role'], user.role) combobox.activate_row(self.combo['user_lang'], user.language) self.check['user_locked'].set_active('locked' in user.flags) self.check['user_deleted'].set_active('deleted' in user.flags) self.entry['user_pass'].set_text('') def on_tvw_user_row_activated(self, widget, path, column): # load selected user self.context.user.user_id = treeview.get_value(widget, 0) self.context.user.load() self.display_user(self.context.user) def on_but_user_new_clicked(self, widget): # get first free user id and create a new record with name "user" self.context.user.create() self.lst_user.append((self.context.user.user_id, self.context.user.login)) def on_but_user_del_clicked(self, widget): answer = gtkutils.questionbox( _("Delete user!\n" "Are you sure?" ), title="YMS") if answer == False: return self.context.user.delete() selection = self.tree['user'].get_selection() model, tree_iter = selection.get_selected() model.remove(tree_iter) # TODO Select some other user from new list selection self.context.user.user_id = treeview.get_value(self.tree['user']) self.context.user.load() self.display_user(self.context.user) def on_but_user_newpass_clicked(self, widget): self.entry['user_pass'].set_text(self.context.user.genpass()) def on_but_user_save_clicked(self, widget): newlogin = self.entry['user_login'].get_text() # check if changed login exists and throw error in that case if newlogin != self.context.user.login: sql = "SELECT COUNT(login) FROM user WHERE login=%s" self.db.cur.execute(sql, (newlogin, )) if self.db.cur.fetchone()[0] > 0: # TODO set error indicator print("Error: Login already exists!") return sql = "UPDATE user SET login=%s WHERE userid=%s" self.db.cur.execute(sql, (newlogin, self.context.user.user_id)) treeview.set_value(self.tree['user'], 1, newlogin) self.context.user.displayname = self.entry['user_displayname'].get_text() self.context.user.role = combobox.get_list_value(self.combo['user_role']) self.context.user.language = combobox.get_list_value(self.combo['user_lang']) self.context.user.flags = [] if self.check['user_locked'].get_active(): self.context.user.flags.append('locked') if self.check['user_deleted'].get_active(): self.context.user.flags.append('deleted') self.context.user.save() # password field is different. if filled set new password newpass = self.entry['user_pass'].get_text() if len(newpass) >= 8: try: self.context.user.setpass(newpass) finally: newpass = None self.entry['user_pass'].set_text('') 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): """ Flags locked and fixed should not be overwritten! """ 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: fixed must not be overwritten! ) 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.button['list_save'].set_sensitive(False) if treeview.get_value(widget, 3) == True: # List is locked! self.lst_list.clear() self.clear_dd_entry() self.button['list_new'].set_sensitive(False) return 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_new'].set_sensitive(True) def on_tvw_ddlist_row_activated(self, widget, path, column): # load list entry details 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_delete'].set_sensitive(not 'fixed' in flags) self.button['list_save'].set_sensitive(True) self.dd_newrecord = False