Blob Blame Raw
/* 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;
}