~donadigo/+junk/euclide-bazaar

/*

 * Copyright (c) 2011 Lucas Baudin <xapantu@gmail.com>

 *

 * This is a free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License as

 * published by the Free Software Foundation; either version 2 of the

 * License, or (at your option) any later version.

 *

 * This is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License for more details.

 *

 * You should have received a copy of the GNU General Public

 * License along with this program; see the file COPYING.  If not,

 * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 *`

 */

using Euclide;

using Granite.Widgets;

Settings euclide_settings;

Scratch.Services.Interface plugins;

public class Euclide.Plugin : Peas.Activatable, Object {

    Gtk.ActionGroup main_actions;

    Gtk.UIManager ui;

    Terminal terminal;

    RawTerminal raw_terminal;

    Gtk.Menu menu_binaries;

    ProgramList list;

    Gtk.Notebook notebook_terminal;

    Gtk.ToolButton toolbar_compile;

    Granite.Widgets.ToolArrow build_arrow;

    CMake.Parser cmake;

    Euclide.Bazaar.BazaarDialog bzr_dialog;

    GLib.List<CMake.Parser> projects;

    SearchBar search_bar;

    static string current_folder = GLib.Environment.get_home_dir ();

    static string project_path;

    static string executable;

    Scratch.MainWindow? window = null;

    Scratch.Widgets.Toolbar? toolbar = null;

    const string ui_string = """

        <ui>

        <popup name="CompactMenu" accelerators="true">

            <menuitem name="Open Project" action="Open Project"/>

            <menuitem name="Terminal" action="Terminal"/>

            <menuitem name="Build and test" action="Build and test"/>

            <menuitem name="Only Build" action="Only Build"/>

            <menuitem name="Clean" action="Clean"/>

            <menuitem name="Plugins" action="Plugins"/>

        <menu action="Add">

            <menuitem name="AddLibrary" action="AddLibrary"/>

            <menuitem name="AddExecutable" action="AddExecutable"/>

            </menu>

            <menuitem name="Project Settings" action="Project Settings"/>

            <menuitem name="Settings" action="Settings"/>

            <menuitem name="About" action="About"/>

        </popup>

        <popup name="MenuItemTool" accelerators="false">

            <menuitem name="Save" action="Save"/>

            <menuitem name="New" action="New"/>

            <menuitem name="Compile" action="Compile"/>

            <menuitem name="Build and test" action="Build and test"/>

            <menuitem name="Fetch" action="Fetch"/>

            <menuitem name="Save as" action="Save as"/>

            <menuitem name="About" action="About"/>

        </popup>

        <popup name="AppMenu" accelerators="true">

            <separator />

            <menuitem name="AddExecutable" action="AddExecutable"/>

            <menuitem name="AddLibrary" action="AddLibrary"/>

            <menuitem name="Open Project" action="Open Project"/>

        </popup>

        </ui>

    """;

    void on_new_source_view (Scratch.Services.Document doc) {

        var view = doc.source_view;

        ((Gtk.TextView)view).key_press_event.connect(Euclide.SourceView.on_insert_event);

    }

    void hook_preferences_dialog (Object dialog) {

        var preferences_dialog = dialog as Scratch.Dialogs.Preferences;

        assert(preferences_dialog != null);

        this.projects.foreach ((project) => {

            var euclide_settings = new ProjectSettingsDialog(project);

            //preferences_dialog.main_static_notebook.append_page (euclide_settings, new Gtk.Label(project.project.name));

        });

    }

    void on_new_window (Scratch.MainWindow window) {

        if (this.window != null)

            return;

        this.window = window;

        debug ("");

        window.add_accel_group (ui.get_accel_group ());

    }

    void action_new_project () {

        var dialog = new NewProjectDialog (this.window);

        string project = dialog.create ();

        if (project != null) {

            open_project (project);

        }

        dialog.destroy ();

    }

    void action_add_library () {

        var dialog = new EntryDialog (this.window);

        dialog.title = _("Add Library");

        dialog.run ();

        cmake.add_target (dialog.value_entry, true /* is library */);

        list.open_project (cmake);

        update_executable_menu ();

        dialog.destroy ();

    }

    void action_add_executable () {

        var dialog = new EntryDialog (this.window);

        dialog.title = _("Add Executable");

        dialog.run ();

        cmake.add_target(dialog.value_entry);

        list.open_project(cmake);

        update_executable_menu();

        dialog.destroy();

    }

    /*void welcome_activated(int index) {

        switch(index)

        {

        case 0: /* create *

            action_new_project();

            break;

        case 1: /* open project *

            action_open_project();

            break;

        case 2:

            action_open_file();

            break;

        default:

            open_project(euclide_settings.get_string("recent-" + (index - 2).to_string()));

            break;

        }

    }*/

    void update_executable_menu () {

        Gtk.RadioMenuItem menuitem = null;

        foreach (var w in menu_binaries.get_children()) {

            w.destroy();

        }

        foreach (var bin in cmake.project.bin) {

            menuitem = new Gtk.RadioMenuItem.with_label((menuitem != null ? menuitem.get_group() : null), bin.name);

            menuitem.activate.connect( () => { executable = bin.filename; });

            menu_binaries.append(menuitem);

        }

        menu_binaries.show_all();

    }

    Gtk.VBox create_binary_choice () {

        var vbox = new Gtk.VBox(false, 0);

        Gtk.RadioButton? former_radio = null;

        this.projects.foreach ((project) => {

            foreach(var bin in project.project.bin) {

                former_radio = new Gtk.RadioButton(former_radio == null ? null : former_radio.get_group());

                former_radio.label = bin.name;

                former_radio.toggled.connect( () => { executable = bin.filename; });

                vbox.pack_start(former_radio);

                if(bin.filename == executable)

                    former_radio.active = true;

            }

        });

        return vbox;

    }

    void unlock_project_actions()

    {

        main_actions.get_action("Project Settings").set_sensitive(true);

        main_actions.get_action("Add").set_sensitive(true);

        main_actions.get_action("AddLibrary").set_sensitive(true);

        main_actions.get_action("AddExecutable").set_sensitive(true);

    }

    void lock_project_actions()

    {

        main_actions.get_action("Project Settings").set_sensitive(false);

        main_actions.get_action("Add").set_sensitive(false);

        main_actions.get_action("AddLibrary").set_sensitive(false);

        main_actions.get_action("AddExecutable").set_sensitive(false);

    }

    public void open_project(string filename) {

        unlock_project_actions();

        unlock_build();

        project_path = filename;

        cmake = new Euclide.CMake.Parser(project_path + "/CMakeLists.txt");

        if(cmake.project.bin.size > 0)

            executable = cmake.project.bin[0].filename;

        cmake.project.project_path = project_path;

        projects.append(cmake);

        list.open_project(cmake, project_path);

        update_executable_menu();

        list.no_show_all = false;

        list.visible = true;

        list.show_all();

    }

    public void action_fetch() {

        search_bar.grab_focus();

    }

    Threads.SimpleCommand simple_command;

    BuildActions.Build build_command;

    BuildActions.Check check_command;

    public void action_build() {

        show_terminal();

        lock_build();

        build_command = new BuildActions.Build(cmake, raw_terminal, terminal, list.progress);

        build_command.build_finished.connect( (exit) => {

            unlock_build();

            if(exit == 0)

            {

                raw_terminal.clear();

                string[] arguments = cmake.arguments.split(" ");

                Gee.LinkedList<string> new_arguments = new Gee.LinkedList<string>();

                new_arguments.add(executable);

                foreach(var arg in arguments)

                    new_arguments.add(arg);

                try {

                    raw_terminal.fork_command_full (Vte.PtyFlags.DEFAULT, project_path, new_arguments.to_array(), null, SpawnFlags.SEARCH_PATH, null, null);

                } catch (Error e) {

                    warning (e.message);

                }

            }

            else

            {

                show_terminal();

            }

         });

         build_command.run();

    }

    public void action_only_build()

    {

        show_terminal();

        lock_build();

        build_command = new BuildActions.Build(cmake, raw_terminal, terminal, list.progress);

        build_command.build_finished.connect( (exit) => {

            unlock_build();

        });

        build_command.run();

    }

    void lock_build()

    {

        notebook_terminal.page = 0;

        main_actions.get_action("Clean").set_sensitive(false);

        main_actions.get_action("Build and test").set_sensitive(false);

        main_actions.get_action("Compile").set_sensitive(false);

        main_actions.get_action("Only Build").set_sensitive(false);

        build_arrow.set_sensitive(false);

        toolbar_compile.set_sensitive(false);

    }

    void unlock_build()

    {

        main_actions.get_action("Clean").set_sensitive(true);

        main_actions.get_action("Build and test").set_sensitive(true);

        main_actions.get_action("Compile").set_sensitive(true);

        main_actions.get_action("Only Build").set_sensitive(true);

        build_arrow.set_sensitive (true);

        toolbar_compile.set_sensitive(true);

    }

    void action_make_check()

    {

        lock_build();

        check_command = new BuildActions.Check(cmake, raw_terminal);

        show_terminal();

        check_command.build_finished.connect( (exit) => {

            unlock_build();

        });

        check_command.run();

    }

    public void action_build_tests()

    {

        lock_build();

        build_command = new BuildActions.Build(cmake, raw_terminal, terminal, list.progress);

        show_terminal();

        build_command.build_finished.connect( (exit) => {

            if(exit == 0)

            {

                if(!euclide_settings.get_boolean ("make-ctest"))

                {

                    notebook_terminal.page = 1;

                    raw_terminal.clear();

                    simple_command = new Threads.SimpleCommand(project_path + "/build/", "/usr/bin/ctest -V");

                    simple_command.output_changed.connect((text) => {raw_terminal.add_text(text); });

                    simple_command.done.connect( (exit) => {

                        unlock_build();

                    });

                    simple_command.run();

                }

                else

                    action_make_check();

            }

            else

                unlock_build();

         });

         build_command.run();

    }

    public void action_clean_project()

    {

        lock_build();

        simple_command = new Threads.SimpleCommand(project_path + "/build/", "/usr/bin/make clean");

        simple_command.output_changed.connect((text) => {raw_terminal.add_text(text); });

        simple_command.done.connect( () => {unlock_build(); });

        simple_command.run();

    }

    public void action_terminal() {

        notebook_terminal.visible = !notebook_terminal.visible;

        notebook_terminal.no_show_all = !notebook_terminal.no_show_all;

    }

    public void show_terminal () {

        terminal_grid.visible = true;

        terminal_grid.no_show_all = false;

        terminal_grid.show_all();

        scrolled_raw_terminal.visible = true;

        scrolled_raw_terminal.no_show_all = false;

        scrolled_raw_terminal.show_all();

    }

    public void hide_terminal () {

        terminal_grid.visible = false;

        terminal_grid.no_show_all = true;

        scrolled_raw_terminal.visible = false;

        scrolled_raw_terminal.no_show_all = true;

    }

    public void open_file(string file_path, int line = -1)

    {

        var file = GLib.File.new_for_path (file_path);

        plugins.open_file (file).source_view.go_to_line (line);

    }

    void action_open_project () {

        var file_chooser = new Gtk.FileChooserDialog (_("Open a file..."),

            this.window, Gtk.FileChooserAction.OPEN,

            Gtk.Stock.CANCEL, Gtk.ResponseType.CANCEL,

            Gtk.Stock.OPEN, Gtk.ResponseType.ACCEPT, null);

        file_chooser.set_current_folder (current_folder);

        file_chooser.add_filter (get_project_filter ());

        int reponse = file_chooser.run ();

        if (reponse == Gtk.ResponseType.ACCEPT) {

            open_project (file_chooser.get_current_folder ());

        }

        current_folder = file_chooser.get_current_folder ();

        file_chooser.destroy ();

        show_terminal ();

    }

    static const Gtk.ActionEntry[] main_entries = {

        { "Terminal", null,

        /* label, accelerator */       N_("Terminal"), null,

        /* tooltip */                  N_("Terminal"),

                                     action_terminal },

        { "Only Build", Gtk.Stock.EXECUTE,

        /* label, accelerator */       N_("Only Build"), "<Control><shift>b",

        /* tooltip */                  N_("Only Build"),

                                     action_only_build },

        { "Compile", Gtk.Stock.MEDIA_PLAY,

        /* label, accelerator */       N_("Compile"), "<Control><shift>r",

        /* tooltip */                  N_("Compile"),

                                     action_build },

        { "Build and test", Gtk.Stock.EXECUTE,

        /* label, accelerator */       N_("Build and test"), "<Control>u",

        /* tooltip */                  N_("Build and test"),

                                     action_build_tests },

        { "Open Project", Gtk.Stock.OPEN,

        /* label, accelerator */       N_("Open Project"), "<Control><shift>o",

        /* tooltip */                  N_("Open Project"),

                                     action_open_project },

        { "Clean", Gtk.Stock.CLEAR,

        /* label, accelerator */       N_("Clean"), "<Control><alt>c",

        /* tooltip */                  N_("Clean"),

                                     action_clean_project },

        { "New Project", Gtk.Stock.NEW,

        /* label, accelerator */       N_("New Project"), "<Control><shift>n",

        /* tooltip */                  N_("New Project"),

                                     action_new_project },

        { "Add", null,

        /* label, accelerator */       N_("Add"), null,

        /* tooltip */                  N_("Add"),

                                     null },

        { "AddLibrary", Gtk.Stock.ADD,

        /* label, accelerator */       N_("Add a library"), null,

        /* tooltip */                  N_("Add a library"),

                                     action_add_library },

        { "AddExecutable", Gtk.Stock.ADD,

        /* label, accelerator */       N_("Add an executable"), null,

        /* tooltip */                  N_("Add an excutable"),

                                     action_add_executable },

        { "Project Settings", null,

        /* label, accelerator */       N_("Project Settings"), null,

        /* tooltip */                  N_("Project Settings"),

                                     null },

        { "Settings", null,

        /* label, accelerator */       N_("Settings"), null,

        /* tooltip */                  N_("Settings"),

                                     null },

        { "About", null,

        /* label, accelerator */       N_("About"), null,

        /* tooltip */                  N_("About"),

                                     null },

        { "Save", null,

        /* label, accelerator */       N_("Save"), null,

        /* tooltip */                  N_("Save"),

                                     null },

        { "New", null,

        /* label, accelerator */       N_("New"), null,

        /* tooltip */                  N_("New"),

                                     null },

        { "Fetch", null,

        /* label, accelerator */       N_("Fetch"), null,

        /* tooltip */                  N_("Fetch"),

                                     null },

        { "Save as", null,

        /* label, accelerator */       N_("Save as"), null,

        /* tooltip */                  N_("Save as"),

                                     null },

        { "Plugins", null,

        /* label, accelerator */       N_("Plugins"), null,

        /* tooltip */                  N_("Plugins"),

                                     null }

    };

    Gtk.FileFilter get_project_filter() {

        var filter = new Gtk.FileFilter();

        filter.set_filter_name(_("CMake Project"));

        filter.add_pattern("CMakeLists.txt");

        return filter;

    }

    public Object object { owned get; construct; }

    public void activate()

    {

        /* Init stuff */

        euclide_settings = new Settings("org.pantheon.euclide.settings");

        main_actions = new Gtk.ActionGroup("MainActionGroup"); /* Actions and UIManager */

        main_actions.set_translation_domain("euclide");

        main_actions.add_actions(main_entries, this);

        build_arrow = new Granite.Widgets.ToolArrow();

        build_arrow.no_show_all = false;

        build_arrow.visible = true;

        // Init internationalization support

        Intl.setlocale (LocaleCategory.ALL, "");

        string langpack_dir = Path.build_filename (Constants.INSTALL_PREFIX, "share", "locale");

        Intl.bindtextdomain (Constants.GETTEXT_PACKAGE, langpack_dir);

        Intl.bind_textdomain_codeset (Constants.GETTEXT_PACKAGE, "UTF-8");

        Intl.textdomain (Constants.GETTEXT_PACKAGE);

        // Init projects var

        this.projects = new GLib.List<CMake.Parser> ();

        ui = new Gtk.UIManager();

        try {

            ui.add_ui_from_string(ui_string, -1);

        }

        catch(Error e) {

            error("Couldn't load the UI");

        }

        ui.insert_action_group(main_actions, 0);

        ui.ensure_update();

        list = new ProgramList();

        list.open_file.connect( (s) => {open_file(s);});

        notebook_terminal = new Gtk.Notebook();

        terminal = new Terminal();

        terminal.open_file.connect(open_file);

        raw_terminal = new RawTerminal();

        raw_terminal.child_exited.connect( () => { raw_terminal.add_text("[Exited]\n"); });

        toolbar_compile = (Gtk.ToolButton)new Gtk.MenuToolButton.from_stock(Gtk.Stock.EXECUTE);

        menu_binaries = new Gtk.Menu ();

        menu_binaries.show_all ();

        ((Gtk.MenuToolButton)toolbar_compile).set_menu(menu_binaries);

        toolbar_compile.clicked.connect (() => { action_build(); });

        plugins = (Scratch.Services.Interface) object;

        plugins.hook_notebook_sidebar.connect (on_notebook_sidebar);

        plugins.hook_main_menu.connect (on_main_menu);

        plugins.hook_notebook_bottom.connect (on_notebook_bottom);

        plugins.hook_toolbar.connect (on_toolbar);

        plugins.hook_window.connect (on_new_window);

        plugins.hook_document.connect (on_new_source_view);

        plugins.hook_preferences_dialog.connect (hook_preferences_dialog);

        lock_build ();

        lock_project_actions ();

        //on_set_arg();

        /* Templates! */

        var template_manager = plugins.template_manager;

        template_manager.template_loaded.connect ((t, f) => {

            debug (f.get_path ());

            // Open loaded template

            if (!f.query_exists ())

                return;

            open_project (f.get_path ());

            current_folder = f.get_path ();

            show_terminal ();

        });

    }

    void on_notebook_sidebar (Gtk.Notebook sidebar) {

        sidebar.append_page (list, new Gtk.Label (_("Project")));

    }

    Gtk.Grid terminal_grid;

    Gtk.ScrolledWindow scrolled_raw_terminal;

    void on_notebook_bottom (Gtk.Notebook bottombar) {

        terminal_grid = new Gtk.Grid ();

        raw_terminal.vexpand = true;

        raw_terminal.hexpand = true;

        var sb = new Gtk.Scrollbar (Gtk.Orientation.VERTICAL, raw_terminal.vadjustment);

        terminal_grid.attach (raw_terminal, 0, 0, 1, 1);

        terminal_grid.attach (sb, 1, 0, 1, 1);

        bottombar.append_page (terminal_grid, new Gtk.Label (_("Compilation")));

        scrolled_raw_terminal = new Gtk.ScrolledWindow (null, null);

        scrolled_raw_terminal.add (terminal);

        bottombar.append_page (scrolled_raw_terminal, new Gtk.Label (_("Output")));

        hide_terminal ();

    }

    void on_main_menu (Gtk.Menu main_menu) {

        /*var sep = new Gtk.SeparatorMenuItem ();

        main_menu.insert (sep, 5);

        sep.show ();

        var menu = ui.get_widget ("ui/AppMenu") as Gtk.Menu;

        ((Gtk.Container)menu).get_children ().foreach ((w) => {

            w.unparent ();

            main_menu.insert ((Gtk.MenuItem)w, 5);

        });*/

        main_menu.insert ((Gtk.MenuItem)main_actions.get_action ("AddExecutable").create_menu_item (), 5);

        main_menu.insert ((Gtk.MenuItem)main_actions.get_action ("AddLibrary").create_menu_item (), 5);

        main_menu.insert ((Gtk.MenuItem)main_actions.get_action ("Open Project").create_menu_item (), 5);

    }

    /*** TOOLBAR  SECTION ***/

    void on_toolbar (Scratch.Widgets.Toolbar toolbar) {

        if (this.toolbar != null)

            return;

        this.toolbar = toolbar;

        build_arrow.clicked.connect (on_show_popover);

        toolbar.pack_start (build_arrow);

        toolbar.pack_start ((Gtk.ToolItem)main_actions.get_action ("Compile").create_tool_item ());

        toolbar.pack_start ((Gtk.ToolItem)main_actions.get_action ("Only Build").create_tool_item ());

        var bzr_btn = new Gtk.Button.from_icon_name("applications-versioncontrol", Gtk.IconSize.LARGE_TOOLBAR);

        bzr_btn.clicked.connect(() => {

            bzr_dialog = new Bazaar.BazaarDialog ();

            bzr_dialog.build_ui (current_folder);

        });

        toolbar.pack_end (bzr_btn);

        toolbar.show_all ();

    }

    public void deactivate() {

    }

    public void update_state() {

    }

    void on_show_popover() {

        build_arrow.set_state (true);

        var build_popover = new Granite.Widgets.PopOver();

        build_popover.move_to_widget(build_arrow);

        var box = build_popover.get_content_area() as Gtk.Box;

        var label = new Gtk.Label(_("Binary to launch:"));

        label.halign = Gtk.Align.START;

        box.pack_start(label);

        box.pack_start(create_binary_choice());

        var arguments = new Granite.Widgets.HintedEntry(_("Arguments..."));

        arguments.text = cmake.arguments;

        arguments.set_margin_top(10);

        box.pack_start(arguments);

        build_popover.show_all();

        build_popover.present();

        build_popover.run();

        cmake.arguments = arguments.text;

        build_popover.destroy();

        build_arrow.set_state (false);

    }

    /*public void on_set_arg()

    {

        if (plugins.set_name.down() == "euclide" && plugins.argument != null)

            open_project(plugins.argument);

    }*/

}

[ModuleInit]

public void peas_register_types (GLib.TypeModule module) {

  var objmodule = module as Peas.ObjectModule;

  objmodule.register_extension_type (typeof (Peas.Activatable),

                                     typeof (Euclide.Plugin));

}