path: root/src/main.vala

using Emulation;
using Gtk;

namespace GUI
{
    public class CActions : GLib.Object
    {
        public Action New;
        public Action Open;
        public Action Save;
        public Action SaveAs;
        public Action RemoveCS;
        public Action ImportCS;
        public Action ExportCS;
        public Action Quit;

        construct {
            New = new Action("New", null, null, "gtk-new");
            Open = new Action("Open", null, null, "gtk-open");
            Save = new Action("Save", null, null, "gtk-save");
            SaveAs = new Action("SaveAs", null, null, "gtk-save-as");
            RemoveCS = new Action("RemoveCS", "Remove", "Remove selected CS' from the list", "gtk-remove");
            ImportCS = new Action("ImportCS", "Import", "Import a command stream to the list", "gtk-add");
            ExportCS = new Action("ExportCS", "Export", "Export a CS to a file", "gtk-convert");
            Quit = new Action("Quit", null, null, "gtk-quit");

            ImportCS.activate.connect((source) => { var d = new CSImport(); d.run(); });
        }
    }

    public class CMenus
    {
        public Menu file;
        public Menu edit;
    }

    public class CMain : Window
    {
        public CMenus menu;
        public MenuBar menubar;
        public Toolbar toolbar;
        public ListStore cs_store;

        construct {
            menu = new CMenus();

            toolbar = new Toolbar();
            add_toolitem(actions.New);
            add_toolitem(actions.Open);
            add_toolitem(actions.Save);
            toolbar.insert(new SeparatorToolItem() as ToolItem, -1);
            add_toolitem(actions.RemoveCS);
            add_toolitem(actions.ImportCS);
            add_toolitem(actions.ExportCS);

            menu.file = new Menu();
            menu.file.append(actions.New.create_menu_item() as MenuItem);
            menu.file.append(actions.Open.create_menu_item() as MenuItem);
            menu.file.append(actions.Save.create_menu_item() as MenuItem);
            menu.file.append(actions.SaveAs.create_menu_item() as MenuItem);
            menu.file.append(new SeparatorMenuItem() as MenuItem);
            menu.file.append(actions.Quit.create_menu_item() as MenuItem);
            var menu_file_item = new MenuItem.with_label("File");
            menu_file_item.submenu = menu.file;

            menu.edit = new Menu();
            menu.edit.append(actions.RemoveCS.create_menu_item() as MenuItem);
            menu.edit.append(actions.ImportCS.create_menu_item() as MenuItem);
            menu.edit.append(actions.ExportCS.create_menu_item() as MenuItem);
            var menu_edit_item = new MenuItem.with_label("Edit");
            menu_edit_item.submenu = menu.edit;

            menubar = new MenuBar();
            menubar.append(menu_file_item);
            menubar.append(menu_edit_item);

            cs_store = new ListStore(2, typeof(string), typeof(CS));
            var cslist = new TreeView();
            cslist.insert_column_with_data_func(-1, "DWORDs", new CellRendererText(), dwords_cellrenderer);
            cslist.insert_column_with_attributes(-1, "Name", new CellRendererText(), "text", 0, null);
            cslist.set_model(cs_store);
            cslist.row_activated.connect(open_csview);

            var sw = new ScrolledWindow(null, null);
            sw.hscrollbar_policy = PolicyType.AUTOMATIC;
            sw.vscrollbar_policy = PolicyType.AUTOMATIC;
            sw.add(cslist);

            var mainbox = new VBox(false, 0);
            mainbox.pack_start(menubar, false, true, 0);
            mainbox.pack_start(toolbar, false, true, 0);
            mainbox.pack_start(sw, true, true, 0);

            set_size_request(400, 200);
            title = "Radeon Simulator";
            add(mainbox);
            destroy.connect(main_quit);

            try {
                /* XXX This shouldn't be hardcoded */
                set_icon_from_file("/usr/share/pixmaps/rsim.png");
            } catch (Error e) { /* don't care */ }

            show_all();
        }

        private void add_toolitem(Action action)
        {
            ToolItem titem = action.create_tool_item() as ToolItem;
            titem.set_homogeneous(false);
            toolbar.insert(titem, -1);
        }

        private void dwords_cellrenderer(TreeViewColumn tree_column, CellRenderer cell, TreeModel model, TreeIter iter)
        {
            CS cs;
            model.get(iter, 1, out cs, -1);
            assert(cs != null);
            (cell as CellRendererText).text = cs.dwords.length.to_string();
        }

        private void open_csview(TreePath path, TreeViewColumn column)
        {
            TreeIter iter;
            CS cs;
            cs_store.get_iter(out iter, path);
            cs_store.get(iter, 1, out cs, -1);

            var csv = new CSView(cs);
            csv.show_all();
        }
    }

    public static CActions actions;
    public static CMain main;

    static void init(ref weak string[] args)
    {
        Gtk.init(ref args);
        actions = new CActions();
        main = new CMain();

        {
            Gdk.threads_init();

            var specload = new SpecLoadDialog(main);
            try {
                Thread.create(specload.run, false);
            } catch (ThreadError e) {
                stderr.printf("Unable to start loading thread.\n");
                assert(false);
            }
        }

        Gtk.main();
    }
}

namespace Emulation
{
    public struct SpecEntry
    {
        Spec spec;
        string name;
    }

    public SpecEntry[] specs;
    public uint spec_default = 1;

    internal class SpecLoadDialog : Window
    {
        private Label loading;
        private ProgressBar progress;
        private bool done;

        public SpecLoadDialog(Window? parent = null)
        {
            if (parent != null) {
                set_transient_for(parent);
                modal = true;
                destroy_with_parent = true;
            }
            deletable = false;

            specs = new SpecEntry[2];
            loading = new Label("Loading...");

            progress = new ProgressBar();
            progress.pulse_fraction = 0.1;

            var box = new VBox(false, 5);
            box.pack_start(loading, false, true, 0);
            box.pack_start(progress, false, true, 0);

            border_width = 10;
            set_default_size(300, 10);

            add(box);
        }

        public void *run()
        {
            Gdk.threads_enter();
                show_all();
            Gdk.threads_leave();

            done = false;
            weak Thread load;
            weak Thread pulse;

            try {
                pulse = Thread.create(pulse_thread, true);
                load = Thread.create(specload_thread, true);
            } catch (ThreadError e) {
                stderr.printf("Unable to start loading thread.\n");
                assert(false);
                return null; /* appease vala */
            }

            void *result = load.join();
            done = true;
            pulse.join();

            Gdk.threads_enter();
                hide_all();
            Gdk.threads_leave();

            return result;
        }

        private void *pulse_thread()
        {
            while (!done) {
                Gdk.threads_enter();
                    progress.pulse();
                Gdk.threads_leave();

                Thread.usleep(50000);
            }
            return null;
        }

        private void *specload_thread()
        {
            /* XXX This shouldn't be hardcoded */
            Gdk.threads_enter();
                loading.label = "Loading r300 registers...";
            Gdk.threads_leave();
            var r300_registers = new Spec("/usr/share/rsim/r300reg.xml", "r300");

            Gdk.threads_enter();
                loading.label = "Loading r500 registers...";
            Gdk.threads_leave();
            var r500_registers = new Spec("/usr/share/rsim/r300reg.xml", "r500");

            Gdk.threads_enter();
                loading.label = "Done";
            Gdk.threads_leave();

            specs[0].spec = r300_registers;
            specs[0].name = "r300";
            specs[1].spec = r500_registers;
            specs[1].name = "r500";

            return (void *)123;
        }
    }
}

public static int main(string[] args)
{
    if (!Thread.supported()) {
        stderr.printf("Cannot run without threads.\n");
        return 1;
    }

    GUI.init(ref args);

    /* vala doesn't unref globals */
    for (uint i = 0; i < specs.length; i++) {
        specs[i].spec.unref();
    }
    GUI.actions.unref();
    GUI.main.unref();

    return 0;
}