/* Copyright 2011 David Henningsson, Canonical Ltd.

   License: GPLv2+ 

*/

#include <string.h>

#include <stdlib.h>

#include <gtk/gtk.h>

#include <stdbool.h>

#include "sysfs-pin-configs.h"

#include "apply-changes.h"

typedef struct ui_data_t ui_data_t;

typedef struct pin_ui_data_t {

    pin_configs_t* pin_config;

    typical_pins_t pins_info[32];

    GtkWidget *frame, *override, *jacktype;

    GtkWidget* free_override_cb[FREE_OVERRIDES_COUNT];

    ui_data_t* owner;

} pin_ui_data_t;

typedef struct hints_ui_data_t {

    gboolean visible;

    GtkWidget *frame;

    GtkListStore *store;

    gchar *values;

} hints_ui_data_t;

struct ui_data_t {

    GList* pin_ui_data;

    GtkWidget *main_window;

    GtkWidget *content_scroll_widget;

    GtkWidget *content_inner_box;

    GtkWidget *codec_selection_combo;

    codec_name_t* current_codec;

    int sysfs_pincount;

    codec_name_t sysfs_codec_names[128];

    pin_configs_t sysfs_pins[32];

    gboolean free_overrides;

    gboolean trust_codec;

    gboolean trust_defcfg;

    gboolean model_auto;

    hints_ui_data_t hints;

};

static void update_user_pin_config(ui_data_t* ui, pin_configs_t* cfg);

static void update_override_sensitive(GtkWidget* sender, pin_ui_data_t* data)

{

    int i;

    gboolean checked = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sender));

    gtk_widget_set_sensitive(data->jacktype, checked); 

    for (i = 0; i < FREE_OVERRIDES_COUNT; i++)

        gtk_widget_set_sensitive(data->free_override_cb[i], checked);

}

static void override_toggled(GtkWidget* sender, pin_ui_data_t* data)

{

    update_override_sensitive(sender, data);

    update_user_pin_config(data->owner, data->pin_config);

}

static void jacktype_changed(GtkWidget* sender, pin_ui_data_t* data)

{

    update_user_pin_config(data->owner, data->pin_config);

}

static GtkWidget* create_pin_ui(ui_data_t* ui, pin_configs_t* pin_cfg)

{

    GtkWidget* result;

    GtkContainer* box;

    pin_ui_data_t* data;

    int port_conn = get_port_conn(pin_cfg->init_pin_config);

    /* Do not show unconnected pins */

    if (ui->trust_defcfg && port_conn == 1) 

        return NULL;

    data = calloc(1, sizeof(pin_ui_data_t));

    data->pin_config = pin_cfg;

    data->owner = ui;

    { /* Frame */

        gchar* d = get_config_description(pin_cfg->init_pin_config);

        gchar* c = g_strdup_printf("Pin ID: 0x%02x", pin_cfg->nid);

        GtkWidget* label = gtk_label_new(c);

        result = gtk_frame_new(d);

        data->frame = result;

        box = GTK_CONTAINER(gtk_box_new(GTK_ORIENTATION_VERTICAL, 2));

        gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);

        gtk_container_add(box, label);

        g_free(d);

        g_free(c);

    }

    { /* Capabilities 

        gchar* s = get_caps_description(pin_cfg->pin_caps);

        gchar* s2 = g_strdup_printf("Capabilities: %s", strlen(s) > 2 ? s+2 : ""); // Hack for initial comma

        GtkWidget* label = gtk_label_new(s2);

        gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);

        gtk_container_add(box, label);

        g_free(s);

        g_free(s2); */

    }

    { /* Override */

        GtkWidget* override = data->override = gtk_check_button_new_with_label("Override");

        GtkWidget* jacktype = data->jacktype = gtk_combo_box_text_new();

        GtkWidget* jacktype_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);

        int index = get_typical_pins(data->pins_info, 32, pin_cfg, ui->trust_codec);

        typical_pins_t* current = data->pins_info;

        while (current->name) {

            gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(jacktype), current->name);

            current++;

        }

        gtk_combo_box_set_active(GTK_COMBO_BOX(jacktype), index);

        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(override), pin_cfg->user_override);

        g_signal_connect(override, "toggled", G_CALLBACK(override_toggled), data);

        g_signal_connect(jacktype, "changed", G_CALLBACK(jacktype_changed), data);

        gtk_container_add(box, override);

        gtk_container_add(GTK_CONTAINER(jacktype_box), jacktype);

        if (!ui->free_overrides)

            gtk_container_add(box, jacktype_box);

    }

    /* Advanced override */

    {

        int i;

        GtkGrid* grid = GTK_GRID(gtk_grid_new());

        gtk_grid_set_row_spacing(grid, 2);

        gtk_grid_set_column_spacing(grid, 4);

        for (i = 0; i < FREE_OVERRIDES_COUNT; i++) {

            int index = -1;

            int j = 0;

            unsigned long act_pincfg = actual_pin_config(pin_cfg);

            unsigned long mask = get_free_override_mask(i);

            free_override_t* values = get_free_override_list(i);

            data->free_override_cb[i] = gtk_combo_box_text_new();

            if (!values)

                continue;

            while (values->name) {

                gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->free_override_cb[i]), values->name);

                if ((act_pincfg & mask) == values->value)

                    index = j;

                values++;

                j++;

            }

            if (index >= 0)

                gtk_combo_box_set_active(GTK_COMBO_BOX(data->free_override_cb[i]), index);

            g_signal_connect(data->free_override_cb[i], "changed", G_CALLBACK(jacktype_changed), data);

        }

        gtk_grid_attach(grid, gtk_label_new("Connectivity"), 0, 0, 1, 1);

        gtk_grid_attach(grid, data->free_override_cb[0], 0, 1, 1, 1);

        gtk_grid_attach(grid, gtk_label_new("Location"), 1, 0, 1, 1);

        gtk_grid_attach(grid, data->free_override_cb[1], 1, 1, 1, 1);

        gtk_grid_attach(grid, gtk_label_new("Device"), 2, 0, 1, 1);

        gtk_grid_attach(grid, data->free_override_cb[2], 2, 1, 1, 1);

        gtk_grid_attach(grid, gtk_label_new("Jack"), 3, 0, 1, 1);

        gtk_grid_attach(grid, data->free_override_cb[3], 3, 1, 1, 1);

        gtk_grid_attach(grid, gtk_label_new("Color"), 0, 2, 1, 1);

        gtk_grid_attach(grid, data->free_override_cb[4], 0, 3, 1, 1);

        gtk_grid_attach(grid, gtk_label_new("Jack detection"), 1, 2, 1, 1);

        gtk_grid_attach(grid, data->free_override_cb[5], 1, 3, 1, 1);

        gtk_grid_attach(grid, gtk_label_new("Channel group"), 2, 2, 1, 1);

        gtk_grid_attach(grid, data->free_override_cb[6], 2, 3, 1, 1);

        gtk_grid_attach(grid, gtk_label_new("Channel (in group)"), 3, 2, 1, 1);

        gtk_grid_attach(grid, data->free_override_cb[7], 3, 3, 1, 1);

        if (ui->free_overrides)

            gtk_container_add(box, GTK_WIDGET(grid));

    }

    update_override_sensitive(data->override, data);

    gtk_container_add(GTK_CONTAINER(result), GTK_WIDGET(box));

    ui->pin_ui_data = g_list_prepend(ui->pin_ui_data, data);

    return result;

}

static void free_pin_ui_data(pin_ui_data_t* data)

{

    if (!data)

        return;

    if (data->frame)

        gtk_widget_destroy(data->frame);

    free(data);

}

static gint pin_config_find(pin_ui_data_t* pin_ui, pin_configs_t* cfg)

{

    return pin_ui->pin_config == cfg ? 0 : 1;

}

static void update_user_pin_config(ui_data_t* ui, pin_configs_t* cfg)

{

    pin_ui_data_t* pin_ui;

    GList *pos = g_list_find_custom(ui->pin_ui_data, cfg, (GCompareFunc) pin_config_find);

    cfg->user_override = FALSE;

    if (!pos)

        return;

    pin_ui = pos->data;

    if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pin_ui->override)))

        return;

    if (ui->free_overrides) {

        int j;

        int index;

        unsigned long val = 0;

        for (j = 0; j < FREE_OVERRIDES_COUNT; j++) {

            index = gtk_combo_box_get_active(GTK_COMBO_BOX(pin_ui->free_override_cb[j]));

            if (index < 0)

                break;

            val += get_free_override_list(j)[index].value;

        }

        if (index < 0)

            return;

        cfg->user_pin_config = val;

    } else {

        int index;

        index = gtk_combo_box_get_active(GTK_COMBO_BOX(pin_ui->jacktype));

        if (index < 0)

            return;

        cfg->user_pin_config = pin_ui->pins_info[index].pin_set;

    }

    cfg->user_override = TRUE;

}

static void update_all_user_pin_config(ui_data_t* ui)

{

    int i;

    for (i = 0; i < ui->sysfs_pincount; i++)

        update_user_pin_config(ui, &ui->sysfs_pins[i]);

}

static gboolean update_one_hint(GtkTreeModel *model, GtkTreePath *path,

                            GtkTreeIter *iter, gpointer userdata)

{

    gchar *name, *value;

    ui_data_t *ui = userdata;

    gtk_tree_model_get(GTK_TREE_MODEL(ui->hints.store), iter, 0, &name, 1, &value, -1);

    if (g_strcmp0(value, "default")) {

        gchar *s = g_strconcat(name, "=", value, "\n", ui->hints.values, NULL);

        g_free(ui->hints.values);

        ui->hints.values = s;

    }

    g_free(name);

    g_free(value);

    return FALSE;

}

static void update_hints(ui_data_t* ui)

{

    g_free(ui->hints.values);

    ui->hints.values = NULL;

    if (ui->hints.visible)

        gtk_tree_model_foreach(GTK_TREE_MODEL(ui->hints.store), update_one_hint, ui);

}

static GQuark quark()

{

    return g_quark_from_static_string("hda-jack-retask-error");

}

static gboolean validate_user_pin_config(ui_data_t* ui, GError** err)

{

    int i;

    if (!ui->current_codec) {

        g_set_error(err, quark(), 0, "You must first select a codec!");

        return FALSE;

    }

    update_hints(ui);

    update_all_user_pin_config(ui);

    if (ui->free_overrides)

        return TRUE;

    /* Check surround configs */

    for (i = 0; i < ui->sysfs_pincount; i++) {

        unsigned long v = ui->sysfs_pins[i].user_pin_config;

        if (!ui->sysfs_pins[i].user_override)

            continue;

        if ((v & 0xf0) != 0x10)

            continue;

        if (((v & 0xf) != 0) && !find_pin_channel_match(ui->sysfs_pins, ui->sysfs_pincount, v & 0xf0)) {

            g_set_error(err, quark(), 0, "This surround setup also requires a \"front\" channel override.");

            return FALSE;

        }

        if (((v & 0xf) >= 3) && !find_pin_channel_match(ui->sysfs_pins, ui->sysfs_pincount, 2 + (v & 0xf0))) {

            g_set_error(err, quark(), 0, "This surround setup also requires a \"back\" channel override.");

            return FALSE;

        }

        if ((v & 0xf) >= 3 && !find_pin_channel_match(ui->sysfs_pins, ui->sysfs_pincount, 1 + (v & 0xf0))) {

            g_set_error(err, quark(), 0, "This surround setup also requires a \"Center/LFE\" channel override.");

            return FALSE;

        }

    }

    return TRUE;

}

static gboolean update_tree_one_hint(GtkTreeModel *model, GtkTreePath *path,

                            GtkTreeIter *iter, gpointer userdata)

{

    gchar *name;

    ui_data_t *ui = userdata;

    gtk_tree_model_get(GTK_TREE_MODEL(ui->hints.store), iter, 0, &name, -1);

    gchar *s = strstr(ui->hints.values, name);

    if (!s) {

        g_free(name);

        gtk_list_store_set(ui->hints.store, iter, 1, "default", -1);

        return FALSE;

    }

    s += strlen(name);

    while (*s == ' ' || *s == '=') s++;

    gchar *s2 = s;

    while (*s != '\n' && *s != '\0') s++;

    s2 = g_strndup(s2, s - s2);

    gtk_list_store_set(ui->hints.store, iter, 1, s2, -1);

    g_free(s2);

    g_free(name);

    return FALSE;

}

static void show_action_result(ui_data_t* ui, GError* err, const gchar* ok_msg)

{

    GtkWidget* dialog;

    const gchar* msg = err ? err->message : ok_msg;

    dialog = gtk_message_dialog_new (GTK_WINDOW(ui->main_window),

        GTK_DIALOG_DESTROY_WITH_PARENT, err ? GTK_MESSAGE_ERROR : GTK_MESSAGE_INFO, 

        GTK_BUTTONS_CLOSE, "%s", msg);

    gtk_dialog_run (GTK_DIALOG (dialog));

    gtk_widget_destroy (dialog);

    if (err)

        g_error_free(err);

}

static void apply_now_clicked(GtkButton* button, gpointer user_data)

{

    GError* err = NULL;

    ui_data_t* ui = user_data;

    gboolean ok = validate_user_pin_config(ui, &err;;

    if (ok)

        apply_changes_reconfig(ui->sysfs_pins, ui->sysfs_pincount, 

            ui->current_codec->card, ui->current_codec->device, 

            ui->model_auto ? "auto" : NULL, ui->hints.values, &err;;

    show_action_result(ui, err, 

        "Ok, now go ahead and test to see if it actually worked!\n"

        "(Remember, this stuff is still experimental.)");

}

static void apply_boot_clicked(GtkButton* button, gpointer user_data)

{

    GError* err = NULL;

    ui_data_t* ui = user_data;

    gboolean ok = validate_user_pin_config(ui, &err;;

    if (ok) 

        apply_changes_boot(ui->sysfs_pins, ui->sysfs_pincount, 

            ui->current_codec->card, ui->current_codec->device, 

            ui->model_auto ? "auto" : NULL, ui->hints.values, &err;;

    show_action_result(ui, err,

        "Ok, now reboot to test to see if it actually worked!\n"

        "(Remember, this stuff is still experimental.)");

}

static void reset_boot_clicked(GtkButton* button, gpointer user_data)

{

    GError* err = NULL;

    ui_data_t* ui = user_data;

    reset_changes_boot(&err;;

    show_action_result(ui, err, 

        "The previous installed files (if any) of this program have been removed.\n"

        "Reboot to finish the uninstallation.");

}

static void resize_main_window(ui_data_t* ui)

{

    GtkAllocation a;

    GtkRequisition r;

    gint oldw, oldh, neww, newh, maxw, maxh;

    GdkScreen* screen = gtk_window_get_screen(GTK_WINDOW(ui->main_window));

    gtk_widget_size_request(GTK_WIDGET(ui->content_inner_box), &r);

    gtk_widget_get_allocation(ui->content_scroll_widget, &a);

//    fprintf(stderr, "W: %d, H: %d, W: %d, H: %d\n", a.width, a.height, r.width, r.height);

    gtk_window_get_size(GTK_WINDOW(ui->main_window), &oldw, &oldh);

    maxw = screen ? (gdk_screen_get_width(screen)*3)/4 : INT_MAX / 4;

    maxh = screen ? (gdk_screen_get_height(screen)*3)/4 : INT_MAX / 4;

//    fprintf(stderr, "Before: W: %d, H: %d\n", oldw, oldh);

    neww = oldw;

    newh = oldh;

    if (a.width < r.width) {

        neww += 8 + r.width - a.width;

        if (neww > maxw)

            neww = maxw;

    }

    if (a.height < r.height) {

        newh += 8 + r.height - a.height;

        if (newh > maxh)

            newh = maxh;

    }

    if (neww != oldw || newh != oldh) {

        gtk_window_resize(GTK_WINDOW(ui->main_window), neww, newh);

//        fprintf(stderr, "After: W: %d, H: %d\n", neww, newh);   

    }

}

static void update_codec_ui(ui_data_t* ui, bool codec_change)

{

    int codec_index = gtk_combo_box_get_active(GTK_COMBO_BOX(ui->codec_selection_combo));

    int i;

    g_list_free_full(ui->pin_ui_data, (GDestroyNotify) free_pin_ui_data);

    ui->pin_ui_data = NULL;

    ui->current_codec = NULL;

    if (codec_index < 0)

        return;

    ui->current_codec = &ui->sysfs_codec_names[codec_index];

    if (codec_change) {

        ui->sysfs_pincount = get_pin_configs_list(ui->sysfs_pins, 32, ui->current_codec->card, ui->current_codec->device);

        ui->hints.values = get_hint_overrides(ui->current_codec->card, ui->current_codec->device);

        gtk_tree_model_foreach(GTK_TREE_MODEL(ui->hints.store), update_tree_one_hint, ui);

    }

    for (i = 0; i < ui->sysfs_pincount; i++) {

        GtkWidget *w = create_pin_ui(ui, &ui->sysfs_pins[i]);

        if (w)

            gtk_container_add(GTK_CONTAINER(ui->content_inner_box), w);

    }

    gtk_widget_show_all(GTK_WIDGET(ui->content_inner_box));

    if (ui->hints.visible)

        gtk_widget_show_all(ui->hints.frame);

    else

        gtk_widget_hide(ui->hints.frame);

    resize_main_window(ui);

}

static void codec_selected(GtkComboBox* combo, gpointer user_data) 

{

    update_codec_ui(user_data, true);

}

static void showallpins_toggled(GtkWidget* sender, ui_data_t* ui_data)

{

    gboolean checked = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sender));

    ui_data->trust_defcfg = !checked;

    update_codec_ui(ui_data, false);

}

static void automodel_toggled(GtkWidget* sender, ui_data_t* ui_data)

{

    ui_data->model_auto = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sender));

}

static void free_override_toggled(GtkWidget* sender, ui_data_t* ui_data)

{

    ui_data->free_overrides = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sender));

    update_codec_ui(ui_data, false);

}

static void hints_toggled(GtkWidget* sender, ui_data_t* ui_data)

{

    ui_data->hints.visible = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sender));

    update_codec_ui(ui_data, false);

}

static void hints_row_activated(GtkTreeView *tree_view, GtkTreePath *path,

                                GtkTreeViewColumn *column, ui_data_t* ui_data)

{

    GtkTreeIter iter;

    gchar *value;

    const gchar *newvalue = "default";

    gtk_tree_model_get_iter(GTK_TREE_MODEL(ui_data->hints.store), &iter, path);

    gtk_tree_model_get(GTK_TREE_MODEL(ui_data->hints.store), &iter, 1, &value, -1);

    if (!g_strcmp0(value, "default"))

        newvalue = "yes";

    else if (!g_strcmp0(value, "yes"))

        newvalue = "no";

    gtk_list_store_set(ui_data->hints.store, &iter, 1, newvalue, -1);

    g_free(value);

}

static const char* readme_text = 

#include "README.generated.h"

;

static void documentation_clicked(GtkWidget* sender, ui_data_t* ui)

{

    GtkDialog* dlg = GTK_DIALOG(gtk_dialog_new_with_buttons("Jack retasking documentation", 

        GTK_WINDOW(ui->main_window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,

        GTK_STOCK_CLOSE, GTK_RESPONSE_NONE, NULL));

    GtkTextView* textview = GTK_TEXT_VIEW(gtk_text_view_new());

    GtkContainer* content_area = GTK_CONTAINER(gtk_dialog_get_content_area(dlg));

    GtkScrolledWindow* content_scroll = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL, NULL));

    gtk_text_buffer_set_text(gtk_text_view_get_buffer(textview), readme_text, -1);

    gtk_text_view_set_editable(textview, FALSE);

    gtk_text_view_set_wrap_mode(textview, GTK_WRAP_WORD);

    gtk_text_view_set_cursor_visible(textview, FALSE);

    gtk_scrolled_window_add_with_viewport(content_scroll, GTK_WIDGET(textview));

    gtk_container_add(content_area, GTK_WIDGET(content_scroll));

    gtk_box_set_child_packing(GTK_BOX(content_area), GTK_WIDGET(content_scroll), TRUE, TRUE, 2, GTK_PACK_START);

    gtk_widget_show_all(GTK_WIDGET(content_area));

    { /* Resize to fit screen */

        GdkScreen* screen = gtk_window_get_screen(GTK_WINDOW(ui->main_window));

        int neww = screen ? (gdk_screen_get_width(screen)*3)/4 : 800;

        int newh = screen ? (gdk_screen_get_height(screen)*3)/4 : 600;

        gtk_window_set_default_size(GTK_WINDOW(dlg), neww, newh);

    }

    gtk_dialog_run(dlg);

    gtk_widget_destroy(GTK_WIDGET(dlg));

}

static ui_data_t* create_ui()

{

    ui_data_t* ui = calloc(sizeof(ui_data_t), 1);

    GtkContainer* toplevel_box = GTK_CONTAINER(gtk_box_new(GTK_ORIENTATION_VERTICAL, 2));

    GtkContainer* toplevel_2ndbox = GTK_CONTAINER(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2));

    ui->content_inner_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);

    GtkContainer* rightside_box = GTK_CONTAINER(gtk_box_new(GTK_ORIENTATION_VERTICAL, 2));

    ui->main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

    gtk_window_set_title(GTK_WINDOW(ui->main_window), "Jack retasking for HDA Intel sound cards");

    g_signal_connect (ui->main_window, "destroy", G_CALLBACK (gtk_main_quit), NULL);

    ui->trust_codec = TRUE;

    ui->trust_defcfg = TRUE;

    /* Select codec to work with */

    {

        GtkWidget* combo = ui->codec_selection_combo = gtk_combo_box_text_new();

        GtkWidget* box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);

        codec_name_t *n = ui->sysfs_codec_names;

        get_codec_name_list(ui->sysfs_codec_names, 128);

        while (n->card != -1) {

            gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), n->name);

            n++;

        }

        /* Select the first codec */

        if (ui->sysfs_codec_names->card != -1) {

            gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);

            g_signal_connect(combo, "changed", G_CALLBACK(codec_selected), ui);

            gtk_container_add(GTK_CONTAINER(box), gtk_label_new("Select a codec:"));

            gtk_container_add(GTK_CONTAINER(box), combo);

        }

        else {

            gtk_container_add(GTK_CONTAINER(box), gtk_label_new("No codecs found. Sorry."));

            gtk_widget_destroy(combo);

        }

        gtk_container_add(toplevel_box, box);

    }

    /* Add pin content area */

    {

        GtkWidget* frame = gtk_frame_new("Pin configuration");

        GtkScrolledWindow* content_scroll = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL, NULL));

        ui->content_scroll_widget = GTK_WIDGET(content_scroll);

        gtk_frame_set_label_align(GTK_FRAME(frame), 0.5, 0.5);

        gtk_scrolled_window_add_with_viewport(content_scroll, ui->content_inner_box);

        gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(content_scroll));

        gtk_container_add(toplevel_2ndbox, frame);

        gtk_box_set_child_packing(GTK_BOX(toplevel_2ndbox), frame, TRUE, TRUE, 2, GTK_PACK_START);

    }

    /* Create hints */

    {

        GtkWidget* frame = gtk_frame_new("Hints");

        ui->hints.frame = frame;

        GtkListStore *store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);

        ui->hints.store = store;

        const gchar** names = get_standard_hint_names();

        for (; *names; names++) {

            GtkTreeIter iter;

            gtk_list_store_append(store, &iter);

            gtk_list_store_set(store, &iter, 0, *names, 1, "default", -1);

        }

        GtkWidget *tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));

        gtk_tree_view_append_column(GTK_TREE_VIEW(tree), gtk_tree_view_column_new_with_attributes

            ("Name", gtk_cell_renderer_text_new(), "text", 0, NULL));

        gtk_tree_view_append_column(GTK_TREE_VIEW(tree), gtk_tree_view_column_new_with_attributes

            ("Value", gtk_cell_renderer_text_new(), "text", 1, NULL));

        g_signal_connect(tree, "row-activated", G_CALLBACK(hints_row_activated), ui);

        gtk_container_add(GTK_CONTAINER(frame), tree);

        gtk_container_add(toplevel_2ndbox, frame);

    }

    /* Create settings */

    {

        GtkWidget* frame = gtk_frame_new("Options");

        GtkContainer* box = GTK_CONTAINER(gtk_button_box_new(GTK_ORIENTATION_VERTICAL));

        GtkWidget* check;

        check = gtk_check_button_new_with_label("Show unconnected pins");

        g_signal_connect(check, "toggled", G_CALLBACK(showallpins_toggled), ui);

        gtk_container_add(box, check);

        check = gtk_check_button_new_with_label("Set model=auto");

        g_signal_connect(check, "toggled", G_CALLBACK(automodel_toggled), ui);

        gtk_container_add(box, check);

        check = gtk_check_button_new_with_label("Advanced override");

        g_signal_connect(check, "toggled", G_CALLBACK(free_override_toggled), ui);

        gtk_container_add(box, check);

        check = gtk_check_button_new_with_label("Parser hints");

        g_signal_connect(check, "toggled", G_CALLBACK(hints_toggled), ui);

        gtk_container_add(box, check);

        gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));

        gtk_container_add(rightside_box, frame);

    }

    /* Create bottom right buttons */

    {

        GtkWidget* button;

        GtkWidget* box = gtk_button_box_new(GTK_ORIENTATION_VERTICAL);

        button = gtk_button_new_with_label("Read documentation");

        g_signal_connect(button, "clicked", G_CALLBACK(documentation_clicked), ui);

        gtk_container_add(GTK_CONTAINER(box), button);

        button = gtk_button_new_with_label("Apply now");

        g_signal_connect(button, "clicked", G_CALLBACK(apply_now_clicked), ui);

        gtk_container_add(GTK_CONTAINER(box), button);

        button = gtk_button_new_with_label("Install boot override");

        g_signal_connect(button, "clicked", G_CALLBACK(apply_boot_clicked), ui);

        gtk_container_add(GTK_CONTAINER(box), button);

        button = gtk_button_new_with_label("Remove boot override");

        g_signal_connect(button, "clicked", G_CALLBACK(reset_boot_clicked), ui);

        gtk_container_add(GTK_CONTAINER(box), button);

        gtk_container_add(rightside_box, box);

        gtk_box_set_child_packing(GTK_BOX(rightside_box), box, FALSE, FALSE, 2, GTK_PACK_END);

    }

    gtk_container_add(toplevel_2ndbox, GTK_WIDGET(rightside_box));

    gtk_container_add(GTK_CONTAINER(toplevel_box), GTK_WIDGET(toplevel_2ndbox));

    gtk_box_set_child_packing(GTK_BOX(toplevel_box), GTK_WIDGET(toplevel_2ndbox), TRUE, TRUE, 2, GTK_PACK_END);

    gtk_container_add(GTK_CONTAINER(ui->main_window), GTK_WIDGET(toplevel_box));

    return ui;

}

int main(int argc, char *argv[])

{

    ui_data_t* ui;

    gtk_init(&argc, &argv);

    ui = create_ui();

    gtk_widget_show_all(ui->main_window);

    if (ui->codec_selection_combo)

        update_codec_ui(ui, true);

    gtk_main();

    return 0;

}