Data loading over socket.

dsst/dsst_gtk3/client.py

@@ -0,0 +1,40 @@
+import pprint
+import socket
+from common import util, models
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+
+
+class Access:
+    def __init__(self, connection):
+        self.host = connection.get('host')
+        self.port = connection.get('port')
+        self.buffer = connection.get('buffer_size')
+        self.auth_key = connection.get('auth_key')
+        self.socket = socket.socket()
+
+    def send_request(self, action: str, *args):
+        request = {'auth_key': self.auth_key,
+                   'action': action,
+                   'args': args}
+        request = pickle.dumps(request)
+        try:
+            self.socket.connect((self.host, self.port))
+            util.send_msg(self.socket, request)
+            response = util.recv_msg(self.socket)
+            response = pickle.loads(response)
+            if not response.get('success'):
+                raise Exception(response.get('message'))
+        finally:
+            self.socket.close()
+        return response.get('data')
+
+if __name__ == '__main__':
+    access = Access({'host': 'europa', 'port': 12345, 'buffer_size': 1024, 'auth_key': 'a'})
+    action = 'load_seasons'
+    response = access.send_request(action)
+    pp = pprint.PrettyPrinter(indent=1)
+    for s in response:
+        pp.pprint(s.__dict__)

dsst/dsst_gtk3/dialogs.py

@@ -0,0 +1,191 @@
+"""
+This module contains UI functions for displaying different dialogs
+"""
+import gi
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk
+from datetime import datetime
+import sql
+from dsst_gtk3 import util
+
+
+def enter_string_dialog(builder: Gtk.Builder, title: str, value=None) -> str:
+    """ Simple modal dialog for entering a string value
+    :param builder: GtkBuilder with loaded dialogs.glade file
+    :param title: Dialog title
+    :param value: Pre set value for dialog
+    :return:
+    """
+    dialog = builder.get_object("nameEnterDialog")  # type: Gtk.Dialog
+    dialog.set_transient_for(builder.get_object("main_window"))
+    dialog.set_title(title)
+    entry = builder.get_object("nameEnterEntry")
+    if value:
+        entry.set_text(value)
+    entry.grab_focus()
+
+    result = dialog.run()
+    dialog.hide()
+
+    if result == Gtk.ResponseType.OK:
+        return entry.get_text()
+    else:
+        return value
+
+
+def show_episode_dialog(builder: Gtk.Builder, title: str, season_id: int, episode: sql.Episode=None):
+    """ Shows a dialog to edit an episode
+    :param builder: GtkBuilder with loaded 'dialogs.glade'
+    :param title: Title of the dialog window
+    :param season_id: Season to witch the episode should be added
+    :param episode: (Optional) Existing episode to edit
+    :return True if changes where saved False if discarded
+    """
+    # Set up the dialog
+    dialog = builder.get_object("edit_episode_dialog")  # type: Gtk.Dialog
+    dialog.set_transient_for(builder.get_object("main_window"))
+    dialog.set_title(title)
+    with sql.db.atomic():
+        if not episode:
+            nxt_number = len(sql.Season.get_by_id(season_id).episodes) + 1
+            episode = sql.Episode.create(seq_number=nxt_number, number=nxt_number, date=datetime.today(),
+                                         season=season_id)
+        # Set episode number
+        builder.get_object("episode_no_spin_button").set_value(episode.number)
+        # Set episode date
+        builder.get_object('episode_calendar').select_month(episode.date.month, episode.date.year)
+        builder.get_object('episode_calendar').select_day(episode.date.day)
+        # Set participants for the episode
+        builder.get_object('episode_players_store').clear()
+        for player in episode.players:
+            builder.get_object('episode_players_store').append([player.id, player.name, player.hex_id])
+
+        result = dialog.run()
+        dialog.hide()
+
+        if result != Gtk.ResponseType.OK:
+            sql.db.rollback()
+            return False
+
+        # Save all changes to Database
+        player_ids = [row[0] for row in builder.get_object('episode_players_store')]
+        # Insert new Players
+        episode.players = sql.Player.select().where(sql.Player.id << player_ids)
+        # Update Date of the Episode
+        cal_value = builder.get_object('episode_calendar').get_date()
+        selected_date = datetime(*cal_value).date()
+        episode.date = selected_date,
+        episode.number = int(builder.get_object("episode_no_spin_button").get_value())
+        episode.name = builder.get_object("episode_name_entry").get_text()
+        episode.save()
+        return True
+
+
+def show_manage_players_dialog(builder: Gtk.Builder, title: str):
+    """Show a dialog for managing player base data.
+    :param builder: Gtk.Builder object
+    :param title: Title for the dialog
+    """
+    dialog = builder.get_object("manage_players_dialog")  # type: Gtk.Dialog
+    dialog.set_transient_for(builder.get_object("main_window"))
+    dialog.run()
+    dialog.hide()
+
+
+def show_manage_enemies_dialog(builder: Gtk.Builder, season_id: int):
+    dialog = builder.get_object("manage_enemies_dialog")  # type: Gtk.Dialog
+    dialog.set_transient_for(builder.get_object("main_window"))
+    dialog.run()
+    dialog.hide()
+
+
+def show_manage_drinks_dialog(builder: Gtk.Builder):
+    dialog = builder.get_object("manage_drinks_dialog")  # type: Gtk.Dialog
+    dialog.set_transient_for(builder.get_object("main_window"))
+    dialog.run()
+    dialog.hide()
+
+
+def show_edit_death_dialog(builder: Gtk.Builder, episode_id: int, death: sql.Death=None):
+    """Show a dialog for editing or creating death events.
+    :param builder: A Gtk.Builder object
+    :param episode_id: ID to witch the death event belongs to
+    :param death: (Optional) Death event witch should be edited
+    :return: Gtk.ResponseType of the dialog
+    """
+    dialog = builder.get_object("edit_death_dialog")  # type: Gtk.Dialog
+    dialog.set_transient_for(builder.get_object("main_window"))
+    with sql.db.atomic():
+        if death:
+            index = util.get_index_of_combo_model(builder.get_object('edit_death_enemy_combo'), 0, death.enemy.id)
+            builder.get_object('edit_death_enemy_combo').set_active(index)
+
+        # TODO Default drink should be set in config
+        default_drink = sql.Drink.get().name
+        store = builder.get_object('player_penalties_store')
+        store.clear()
+        for player in builder.get_object('episode_players_store'):
+            store.append([None, player[1], default_drink, player[0]])
+
+        # Run the dialog
+        result = dialog.run()
+        dialog.hide()
+        if result != Gtk.ResponseType.OK:
+            sql.db.rollback()
+            return result
+
+        # Collect info from widgets and save to database
+        player_id = util.get_combo_value(builder.get_object('edit_death_player_combo'), 0)
+        enemy_id = util.get_combo_value(builder.get_object('edit_death_enemy_combo'), 3)
+        comment = builder.get_object('edit_death_comment_entry').get_text()
+        if not death:
+            death = sql.Death.create(episode=episode_id, player=player_id, enemy=enemy_id, info=comment)
+
+        store = builder.get_object('player_penalties_store')
+        size = builder.get_object('edit_death_size_spin').get_value()
+        for entry in store:
+            drink_id = sql.Drink.get(sql.Drink.name == entry[2])
+            sql.Penalty.create(size=size, player=entry[3], death=death.id, drink=drink_id)
+
+        return result
+
+
+def show_edit_victory_dialog(builder: Gtk.Builder, episode_id: int, victory: sql.Victory=None):
+    """Show a dialog for editing or creating victory events.
+    :param builder: A Gtk.Builder object
+    :param episode_id: ID to witch the victory event belongs to
+    :param victory: (Optional) Victory event witch should be edited
+    :return: Gtk.ResponseType of the dialog
+    """
+    dialog = builder.get_object("edit_victory_dialog")  # type: Gtk.Dialog
+    dialog.set_transient_for(builder.get_object("main_window"))
+    with sql.db.atomic():
+        if victory:
+            infos = [['edit_victory_player_combo', victory.player.id],
+                     ['edit_victory_enemy_combo', victory.enemy.id]]
+            for info in infos:
+                combo = builder.get_object(info[0])
+                index = util.get_index_of_combo_model(combo, 0, info[1])
+                combo.set_active(index)
+            builder.get_object('victory_comment_entry').set_text(victory.info)
+
+        # Run the dialog
+        result = dialog.run()
+        dialog.hide()
+        if result != Gtk.ResponseType.OK:
+            sql.db.rollback()
+            return result
+
+        # Collect info from widgets and save to database
+        player_id = util.get_combo_value(builder.get_object('edit_victory_player_combo'), 0)
+        enemy_id = util.get_combo_value(builder.get_object('edit_victory_enemy_combo'), 3)
+        comment = builder.get_object('victory_comment_entry').get_text()
+        if not victory:
+            sql.Victory.create(episode=episode_id, player=player_id, enemy=enemy_id, info=comment)
+        else:
+            victory.player = player_id
+            victory.enemy = enemy_id
+            victory.info = comment
+            victory.save()
+
+        return result

dsst/dsst_gtk3/gtk_ui.py

@@ -0,0 +1,75 @@
+import os
+
+import gi
+
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk
+from dsst_gtk3.handlers import handlers
+from dsst_gtk3 import util, reload
+import sql_func
+import sql
+
+
+class GtkUi:
+    """ The main UI class """
+    def __init__(self, config: dict):
+        # Load Glade UI files
+        self.ui = Gtk.Builder()
+        glade_resources = [
+            ['dsst_gtk3', 'resources', 'glade', 'window.glade'],
+            ['dsst_gtk3', 'resources', 'glade', 'dialogs.glade']
+        ]
+        for path in glade_resources:
+            self.ui.add_from_string(util.load_ui_resource_string(path))
+        # Connect signal handlers to UI
+        self.handlers = handlers.Handlers(self)
+        self.ui.connect_signals(self.handlers)
+        # Show all widgets
+        self.ui.get_object('main_window').show_all()
+        db_config = config['sql_connections'][0]
+        # Initialize the database
+        sql.db.init(db_config['db_name'], host=db_config['host'], port=db_config['port'],
+                    user=db_config['user'], password=db_config['password'])
+        # Show database info in status bar
+        self.set_db_status_label(db_config)
+        # Create database if not exists
+        sql_func.create_tables()
+        self.reload()
+
+    def reload(self):
+        reload.reload_base_data(self.ui, self)
+        season_id = self.get_selected_season_id()
+        if season_id:
+            reload.reload_episodes(self.ui, self, season_id)
+            reload.reload_season_stats(self.ui, self, season_id)
+        else:
+            return
+        episode_id = self.get_selected_episode_id()
+        if episode_id:
+            reload.reload_episode_stats(self.ui, self, episode_id)
+
+    def set_db_status_label(self, db_conf: dict):
+        self.ui.get_object('connection_label').set_text(f'{db_conf["user"]}@{db_conf["host"]}')
+        self.ui.get_object('db_label').set_text(f'{db_conf["db_name"]}')
+
+    def get_selected_season_id(self) -> int:
+        """Read ID of the selected season from the UI
+        :return: ID of the selected season
+        """
+        season_id = util.get_combo_value(self.ui.get_object('season_combo_box'), 0)
+        return season_id if season_id != -1 else None
+
+    def get_selected_episode_id(self):
+        """Parse ID of the selected episode from the UI
+        :return: ID of the selected episode
+        """
+        (model, tree_iter) = self.ui.get_object('episodes_tree_view').get_selection().get_selected()
+        return model.get_value(tree_iter, 0) if tree_iter else None
+
+
+def main():
+    if not os.path.isfile(util.CONFIG_PATH):
+        util.save_config(util.DEFAULT_CONFIG, util.CONFIG_PATH)
+    config = util.load_config(util.CONFIG_PATH)
+    GtkUi(config)
+    Gtk.main()

dsst/dsst_gtk3/handlers/base_data_handlers.py

@@ -0,0 +1,54 @@
+import sql
+from dsst_gtk3 import dialogs
+
+
+class BaseDataHandlers:
+    """Callback handlers for signals related to the manipulation of base data (players, drinks, ...)"""
+    def __init__(self, app: 'gtk_ui.GtkUi'):
+        self.app = app
+
+    def do_manage_players(self, *_):
+        dialogs.show_manage_players_dialog(self.app.ui, 'Manage Players')
+
+    def do_add_player(self, entry):
+        if entry.get_text():
+            sql.Player.create(name=entry.get_text())
+            entry.set_text('')
+            self.app.reload()
+
+    def do_manage_enemies(self, *_):
+        dialogs.show_manage_enemies_dialog(self.app.ui, self.app.get_selected_season_id())
+
+    def on_player_name_edited(self, _, index, value):
+        row = self.app.ui.get_object('all_players_store')[index]
+        sql.Player.update(name=value)\
+                  .where(sql.Player.id == row[0])\
+                  .execute()
+        self.app.reload()
+
+    def on_player_hex_edited(self, _, index, value):
+        row = self.app.ui.get_object('all_players_store')[index]
+        sql.Player.update(hex_id=value)\
+                  .where(sql.Player.id == row[0])\
+                  .execute()
+        self.app.reload()
+
+    def do_add_drink(self, entry):
+        if entry.get_text():
+            sql.Drink.create(name=entry.get_text(), vol=0)
+            entry.set_text('')
+            self.app.reload()
+
+    def on_drink_name_edited(self, _, index, value):
+        row = self.app.ui.get_object('drink_store')[index]
+        sql.Drink.update(name=value)\
+                 .where(sql.Drink.id == row[0])\
+                 .execute()
+        self.app.reload()
+
+    def on_drink_vol_edited(self, _, index, value):
+        row = self.app.ui.get_object('drink_store')[index]
+        sql.Drink.update(vol=value) \
+                 .where(sql.Drink.id == row[0]) \
+                 .execute()
+        self.app.reload()

dsst/dsst_gtk3/handlers/death_handlers.py

@@ -0,0 +1,20 @@
+from gi.repository import Gtk
+
+from dsst_gtk3 import dialogs
+
+
+class DeathHandlers:
+    """Callback handlers for signals related to managing death events"""
+    def __init__(self, app: 'gtk_ui.GtkUi'):
+        self.app = app
+
+    def do_add_death(self, *_):
+        ep_id = self.app.get_selected_episode_id()
+        if not ep_id:
+            return
+        result = dialogs.show_edit_death_dialog(self.app.ui, ep_id)
+        if result == Gtk.ResponseType.OK:
+            self.app.reload()
+
+    def on_penalty_drink_changed(self, _, path, text):
+        self.app.ui.get_object('player_penalties_store')[path][2] = text

dsst/dsst_gtk3/handlers/dialog_handlers.py

@@ -0,0 +1,30 @@
+import sql
+from dsst_gtk3 import dialogs, util
+
+
+class DialogHandlers:
+    """ Callback handlers for signals emitted from dialogs of the main window"""
+    def __init__(self, app: 'gtk_ui.GtkUi'):
+        self.app = app
+
+    def do_add_player_to_episode(self, combo):
+        """ Signal Handler for Add Player to Episode Button in Manage Episode Dialog
+        :param combo: Combo box with all the available players
+        """
+        player_id = util.get_combo_value(combo, 0)
+        if player_id:
+            self.app.ui.get_object('add_player_combo_box').set_active(-1)
+            player = sql.Player.get(sql.Player.id == player_id)
+            store = self.app.ui.get_object('episode_players_store')
+            if not any(row[0] == player_id for row in store):
+                store.append([player_id, player.name, player.hex_id])
+
+    def do_add_enemy(self, entry):
+        if entry.get_text():
+            store = self.app.ui.get_object('enemy_season_store')
+            enemy = sql.Enemy.create(name=entry.get_text(), season=self.app.get_selected_season_id())
+            store.append([enemy.name, False, 0, enemy.id])
+            entry.set_text('')
+
+    def do_manage_drinks(self, *_):
+        result = dialogs.show_manage_drinks_dialog(self.app.ui)

dsst/dsst_gtk3/handlers/handlers.py

@@ -0,0 +1,40 @@
+import gi
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk
+from dsst_gtk3.handlers.season_handlers import SeasonHandlers
+from dsst_gtk3.handlers.base_data_handlers import BaseDataHandlers
+from dsst_gtk3.handlers.dialog_handlers import DialogHandlers
+from dsst_gtk3.handlers.death_handlers import DeathHandlers
+from dsst_gtk3.handlers.victory_handlers import VictoryHandlers
+import sql_func
+import sql
+
+
+class Handlers(SeasonHandlers, BaseDataHandlers, DialogHandlers, DeathHandlers, VictoryHandlers):
+    """Single callback handler class derived from specialized handler classes"""
+    def __init__(self, app):
+        """ Initialize handler class
+        :param app: reference to the main application object
+        """
+        self.app = app
+        # Call constructors of superclasses
+        SeasonHandlers.__init__(self, app)
+        BaseDataHandlers.__init__(self, app)
+        DialogHandlers.__init__(self, app)
+        DeathHandlers.__init__(self, app)
+        VictoryHandlers.__init__(self, app)
+
+    @staticmethod
+    def do_delete_event(*_):
+        """ Signal will be sent when app should close
+        :param _: Arguments to the delete event
+        """
+        sql.db.close()
+        Gtk.main_quit()
+
+    # DEBUG Functions ##################################################################################################
+
+    @staticmethod
+    def do_delete_database(*_):
+        sql_func.drop_tables()
+        sql_func.create_tables()

dsst/dsst_gtk3/handlers/season_handlers.py

@@ -0,0 +1,30 @@
+from data_access import sql
+from dsst_gtk3 import dialogs
+
+
+class SeasonHandlers:
+    """Callback handlers related to signals for managing seasonal data"""
+    def __init__(self, app: 'gtk_ui.GtkUi'):
+        self.app = app
+
+    def do_add_season(self, *_):
+        name = dialogs.enter_string_dialog(self.app.ui, 'Name for the new Season')
+        if name:
+            sql.Season.create(game_name=name, number=1)
+            self.app.reload()
+
+    def do_season_selected(self, *_):
+        self.app.reload()
+
+    def do_add_episode(self, *_):
+        season_id = self.app.get_selected_season_id()
+        if not season_id:
+            return
+        dialogs.show_episode_dialog(self.app.ui, 'Create new Episode', season_id)
+        self.app.reload()
+
+    def on_selected_episode_changed(self, *_):
+        self.app.reload()
+
+    def on_episode_double_click(self, *_):
+        self.app.ui.get_object('stats_notebook').set_current_page(1)

dsst/dsst_gtk3/handlers/victory_handlers.py

@@ -0,0 +1,17 @@
+from gi.repository import Gtk
+
+from dsst_gtk3 import dialogs
+
+
+class VictoryHandlers:
+    """Callback handlers for signals related to managing victory events"""
+    def __init__(self, app: 'gtk_ui.GtkUi'):
+        self.app = app
+
+    def do_add_victory(self, *_):
+        ep_id = self.app.get_selected_episode_id()
+        if not ep_id:
+            return
+        result = dialogs.show_edit_victory_dialog(self.app.ui, ep_id)
+        if result == Gtk.ResponseType.OK:
+            self.app.reload()

dsst/dsst_gtk3/reload.py

@@ -0,0 +1,123 @@
+from collections import Counter
+
+from gi.repository import Gtk
+
+from data_access import sql, sql_func
+from dsst_gtk3 import util
+
+
+def reload_base_data(builder: Gtk.Builder, app: 'gtk_ui.GtkUi'):
+    """Reload function for all base data witch is not dependant on a selected season or episode
+    :param app: GtkUi instance
+    :param builder: Gtk.Builder with loaded UI
+    """
+    # Rebuild all players store
+    builder.get_object('all_players_store').clear()
+    for player in sql.Player.select():
+        builder.get_object('all_players_store').append([player.id, player.name, player.hex_id])
+    # Rebuild drink store
+        builder.get_object('drink_store').clear()
+    for drink in sql.Drink.select():
+        builder.get_object('drink_store').append([drink.id, drink.name, '{:.2f}%'.format(drink.vol)])
+    # Rebuild seasons store
+    combo = builder.get_object('season_combo_box')  # type: Gtk.ComboBox
+    active = combo.get_active()
+    with util.block_handler(combo, app.handlers.do_season_selected):
+        store = builder.get_object('seasons_store')
+        store.clear()
+        for season in sql.Season.select().order_by(sql.Season.number):
+            store.append([season.id, season.game_name])
+        combo.set_active(active)
+
+
+def reload_episodes(builder: Gtk.Builder, app: 'gtk_ui.GtkUi', season_id: int):
+    """Reload all data that is dependant on a selected season
+    :param app: GtkUi instance
+    :param builder: Gtk.Builder with loaded UI
+    :param season_id: ID of the season for witch to load data
+    """
+    # Rebuild episodes store
+    selection = builder.get_object('episodes_tree_view').get_selection()
+    with util.block_handler(selection, app.handlers.on_selected_episode_changed):
+        model, selected_paths = selection.get_selected_rows()
+        model.clear()
+        for episode in sql_func.get_episodes_for_season(season_id):
+            model.append([episode.id, episode.name, str(episode.date), episode.number])
+        if selected_paths:
+            selection.select_path(selected_paths[0])
+
+
+def reload_season_stats(builder: Gtk.Builder, app: 'gtk_ui.GtkUi', season_id: int):
+    """Load statistic data for selected season
+    :param builder: Gtk.Builder with loaded UI
+    :param app: GtkUi instance
+    :param season_id: ID of the season for witch to load data
+    """
+    player_stats = {}
+    for episode in sql_func.get_episodes_for_season(season_id):
+        for player in episode.players:
+            player_stats[player.name] = [sql_func.get_player_deaths_for_season(season_id, player.id),
+                                         sql_func.get_player_victories_for_season(season_id, player.id)]
+    store = builder.get_object('player_season_store')
+    store.clear()
+    for name, stats in player_stats.items():
+        store.append([name, stats[0], stats[1]])
+    # Load enemy stats for season
+    season = sql.Season.get(sql.Season.id == season_id)
+    enemy_stats = {
+        enemy.name: [False, len(sql.Death.select().where(sql.Death.enemy == enemy)), enemy.id]
+        for enemy in season.enemies}
+    store = builder.get_object('enemy_season_store')
+    store.clear()
+    for name, stats in enemy_stats.items():
+        store.append([name, stats[0], stats[1], stats[2]])
+
+
+def reload_episode_stats(builder: Gtk.Builder, app: 'gtk_ui.GtkUi', episode_id: int):
+    """Reload all data that is dependant on a selected episode
+    :param builder: builder: Gtk.Builder with loaded UI
+    :param app: app: GtkUi instance
+    :param episode_id: ID of the episode for witch to load data
+    """
+    episode = sql.Episode.get(sql.Episode.id == episode_id)
+    store = builder.get_object('episode_players_store')
+    store.clear()
+    for player in episode.players:
+        store.append([player.id, player.name, player.hex_id])
+    # Reload death store for notebook view
+    store = builder.get_object('episode_deaths_store')
+    store.clear()
+    for death in episode.deaths:
+        penalties = [x.drink.name for x in death.penalties]
+        penalties = [f'{number}x {drink}' for drink, number in Counter(penalties).items()]
+        penalty_string = ', '.join(penalties)
+        store.append([death.id, death.player.name, death.enemy.name, penalty_string])
+    # Reload victory store for notebook view
+    store = builder.get_object('episode_victories_store')
+    store.clear()
+    for victory in episode.victories:
+        store.append([victory.id, victory.player.name, victory.enemy.name, victory.info])
+
+    # Stat grid
+    builder.get_object('ep_stat_title').set_text('Stats for episode {}\n{}'.format(episode.number, episode.name))
+    builder.get_object('ep_death_count_label').set_text(str(len(episode.deaths)))
+    drink_count = sum(len(death.penalties) for death in episode.deaths)
+    builder.get_object('ep_drinks_label').set_text(str(drink_count))
+    builder.get_object('ep_player_drinks_label').set_text(str(len(episode.deaths)))
+    dl_booze = sum(len(death.penalties) * death.penalties[0].size for death in episode.deaths)
+    l_booze = round(dl_booze / 10, 2)
+    builder.get_object('ep_booze_label').set_text('{}l'.format(l_booze))
+    dl_booze = sum(len(death.penalties) * death.penalties[0].size for death in episode.deaths)
+    ml_booze = round(dl_booze * 10, 0)
+    builder.get_object('ep_player_booze_label').set_text('{}ml'.format(ml_booze))
+    enemy_list = [death.enemy.name for death in episode.deaths]
+    sorted_list = Counter(enemy_list).most_common(1)
+    if sorted_list:
+        enemy_name, deaths = sorted_list[0]
+        builder.get_object('ep_enemy_name_label').set_text(f'{enemy_name} ({deaths} Deaths)')
+
+
+def fill_list_store(store: Gtk.ListStore, models: list):
+    store.clear()
+    for model in models:
+        pass

dsst/dsst_gtk3/resources/glade/dialogs.glade

@@ -0,0 +1,241 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.20.3 -->
+<interface>
+  <requires lib="gtk+" version="3.20"/>
+  <object class="GtkDialog" id="nameEnterDialog">
+    <property name="can_focus">False</property>
+    <property name="resizable">False</property>
+    <property name="modal">True</property>
+    <property name="type_hint">dialog</property>
+    <property name="deletable">False</property>
+    <child internal-child="vbox">
+      <object class="GtkBox">
+        <property name="can_focus">False</property>
+        <property name="orientation">vertical</property>
+        <property name="spacing">4</property>
+        <child internal-child="action_area">
+          <object class="GtkButtonBox">
+            <property name="can_focus">False</property>
+            <property name="layout_style">end</property>
+            <child>
+              <object class="GtkButton" id="okButtonRename">
+                <property name="label">gtk-ok</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="use_stock">True</property>
+              </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkButton" id="cancelButtonRename">
+                <property name="label">gtk-cancel</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="use_stock">True</property>
+              </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">False</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkEntry" id="nameEnterEntry">
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+    <action-widgets>
+      <action-widget response="-5">okButtonRename</action-widget>
+      <action-widget response="-6">cancelButtonRename</action-widget>
+    </action-widgets>
+    <child>
+      <placeholder/>
+    </child>
+  </object>
+  <object class="GtkDialog" id="yn_dialog">
+    <property name="can_focus">False</property>
+    <property name="resizable">False</property>
+    <property name="type_hint">dialog</property>
+    <property name="deletable">False</property>
+    <child internal-child="vbox">
+      <object class="GtkBox">
+        <property name="can_focus">False</property>
+        <property name="orientation">vertical</property>
+        <property name="spacing">15</property>
+        <child internal-child="action_area">
+          <object class="GtkButtonBox">
+            <property name="can_focus">False</property>
+            <property name="layout_style">end</property>
+            <child>
+              <object class="GtkButton" id="yn_yes">
+                <property name="label">gtk-yes</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="use_stock">True</property>
+              </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkButton" id="yn_no">
+                <property name="label">gtk-no</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="use_stock">True</property>
+              </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">False</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkLabel" id="yn_label">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <property name="margin_left">2</property>
+            <property name="margin_right">2</property>
+            <property name="margin_top">2</property>
+            <property name="margin_bottom">2</property>
+            <property name="justify">center</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+    <action-widgets>
+      <action-widget response="-8">yn_yes</action-widget>
+      <action-widget response="-9">yn_no</action-widget>
+    </action-widgets>
+    <child>
+      <placeholder/>
+    </child>
+  </object>
+  <object class="GtkDialog" id="ync_dialog">
+    <property name="can_focus">False</property>
+    <property name="resizable">False</property>
+    <property name="type_hint">dialog</property>
+    <property name="deletable">False</property>
+    <child internal-child="vbox">
+      <object class="GtkBox">
+        <property name="can_focus">False</property>
+        <property name="orientation">vertical</property>
+        <property name="spacing">15</property>
+        <child internal-child="action_area">
+          <object class="GtkButtonBox">
+            <property name="can_focus">False</property>
+            <property name="layout_style">end</property>
+            <child>
+              <object class="GtkButton" id="ync_yes">
+                <property name="label">gtk-yes</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="use_stock">True</property>
+              </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkButton" id="ync_no">
+                <property name="label">gtk-no</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="use_stock">True</property>
+              </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkButton" id="ync_cancel">
+                <property name="label">gtk-cancel</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="use_stock">True</property>
+              </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">2</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">False</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkLabel" id="ync_label">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <property name="margin_left">2</property>
+            <property name="margin_right">2</property>
+            <property name="margin_top">2</property>
+            <property name="margin_bottom">2</property>
+            <property name="justify">center</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+    <action-widgets>
+      <action-widget response="-8">ync_yes</action-widget>
+      <action-widget response="-9">ync_no</action-widget>
+      <action-widget response="-6">ync_cancel</action-widget>
+    </action-widgets>
+    <child>
+      <placeholder/>
+    </child>
+  </object>
+</interface>

dsst/dsst_gtk3/util.py

@@ -0,0 +1,94 @@
+"""
+This modules contains general utilities for the GTK application to use.
+"""
+import json
+import os
+from contextlib import contextmanager
+from gi.repository import Gtk
+from typing import Callable
+from zipfile import ZipFile
+
+CONFIG_PATH = os.path.join(os.path.expanduser('~'), '.config', 'dsst', 'config.json')
+DEFAULT_CONFIG = {
+    'auto_connect': False,
+    'sql_connections': [{
+        'host': 'localhost',
+        'port': 3306,
+        'db_name': 'dsst',
+        'user': 'dsst',
+        'password': 'dsst'}
+    ]
+}
+
+
+@contextmanager
+def block_handler(widget: 'Gtk.Widget', handler_func: Callable):
+    """Run an operation while a signal handler for a widget is blocked
+    :param widget: A Gtk widget
+    :param handler_func: Signal handler of the widget to block
+    """
+    widget.handler_block_by_func(handler_func)
+    yield
+    widget.handler_unblock_by_func(handler_func)
+
+
+def get_combo_value(combo, index: int):
+    """ Retrieve the selected value of a combo box at the selected index in the model
+    :param combo: Any Gtk Widget that supports 'get_active_iter()'
+    :param index: Index of the value in the widgets model to be retrieved
+    :return: The value of the model at the selected index (Default -1)
+    """
+    tree_iter = combo.get_active_iter()
+    if tree_iter:
+        return combo.get_model().get_value(tree_iter, index)
+    else:
+        return -1
+
+
+def get_index_of_combo_model(widget, column: int, value: int):
+    """Get the index of a value within a Gtk widgets model based on column an value
+    :param widget: Any Gtk widget that can be bound to a ListStore or TreeStore
+    :param column: Column in the model where to look for the value
+    :param value: Value to look for in the model
+    :return: List of the indexes where the value occurs
+    """
+    model = widget.get_model()
+    return [model.index(entry) for entry in model if entry[column] == value]
+
+
+def load_ui_resource_from_file(resource_path: list) -> str:
+    project_base_dir = os.path.dirname(os.path.dirname(__file__))
+    full_path = os.path.join(project_base_dir, *resource_path)
+    with open(full_path, 'r') as file:
+        return file.read()
+
+
+def load_ui_resource_from_archive(resource_path: list) -> str:
+    zip_path = os.path.dirname(os.path.dirname(__file__))
+    with ZipFile(zip_path, 'r') as archive:
+        return archive.read(str(os.path.join(*resource_path))).decode('utf-8')
+
+
+def load_ui_resource_string(resource_path: list) -> str:
+    """ Load content of Glade UI files from resources path
+    :param resource_path: List of directory names from 'dsst' base directory
+    :return: String content of the Glade file
+    """
+    if os.path.isdir(os.path.dirname(__file__)):
+        return load_ui_resource_from_file(resource_path)
+    else:
+
+        return load_ui_resource_from_archive(resource_path)
+
+
+def load_config(config_path: str) -> dict:
+    with open(config_path) as config_file:
+        return json.load(config_file)
+
+
+def save_config(config: dict, config_path: str):
+    path = os.path.dirname(config_path)
+    if not os.path.isdir(path):
+        os.mkdir(path)
+    with open(config_path, 'wb') as file:
+        file.write(json.dumps(config, sort_keys=True, indent=4, separators=(',', ': ')).encode('utf-8'))