Improve making-a-release a little

[geany-mirror.git] / src / libmain.c

/*
 *      libmain.c - this file is part of Geany, a fast and lightweight IDE
 *
 *      Copyright 2005-2012 Enrico Tröger <enrico(dot)troeger(at)uvena(dot)de>
 *      Copyright 2006-2012 Nick Treleaven <nick(dot)treleaven(at)btinternet(dot)com>
 *
 *      This program is 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 program 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; if not, write to the Free Software Foundation, Inc.,
 *      51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

/**
 * @file: main.h
 * Main program-related commands.
 * Handles program initialization and cleanup.
 */

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include "main.h"

#include "app.h"
#include "build.h"
#include "callbacks.h"
#include "dialogs.h"
#include "document.h"
#include "encodingsprivate.h"
#include "filetypes.h"
#include "geanyobject.h"
#include "highlighting.h"
#include "keybindings.h"
#include "keyfile.h"
#include "log.h"
#include "msgwindow.h"
#include "navqueue.h"
#include "notebook.h"
#include "plugins.h"
#include "prefs.h"
#include "printing.h"
#include "sidebar.h"
#ifdef HAVE_SOCKET
# include "socket.h"
#endif
#include "support.h"
#include "symbols.h"
#include "templates.h"
#include "toolbar.h"
#include "tools.h"
#include "ui_utils.h"
#include "utils.h"
#include "vte.h"
#include "win32.h"
#include "osx.h"

#include "gtkcompat.h"

#include <signal.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>

#include <glib/gstdio.h>

#ifdef HAVE_LOCALE_H
# include <locale.h>
#endif


GeanyApp        *app;
gboolean        ignore_callback;        /* hack workaround for GTK+ toggle button callback problem */

GeanyStatus      main_status;
CommandLineOptions cl_options;  /* fields initialised in parse_command_line_options */

static gchar *original_cwd = NULL;

static const gchar geany_lib_versions[] = "GTK %u.%u.%u, GLib %u.%u.%u";

static gboolean want_plugins;

/* command-line options */
static gboolean verbose_mode = FALSE;
static gboolean ignore_global_tags = FALSE;
static gboolean no_msgwin = FALSE;
static gboolean show_version = FALSE;
static gchar *alternate_config = NULL;
#ifdef HAVE_VTE
static gboolean no_vte = FALSE;
static gchar *lib_vte = NULL;
#endif
static gboolean generate_tags = FALSE;
static gboolean no_preprocessing = FALSE;
static gboolean ft_names = FALSE;
static gboolean print_prefix = FALSE;
#ifdef HAVE_PLUGINS
static gboolean no_plugins = FALSE;
#endif
static gboolean dummy = FALSE;

/* in alphabetical order of short options */
static GOptionEntry entries[] =
{
        { "column", 0, 0, G_OPTION_ARG_INT, &cl_options.goto_column, N_("Set initial column number for the first opened file (useful in conjunction with --line)"), NULL },
        { "config", 'c', 0, G_OPTION_ARG_FILENAME, &alternate_config, N_("Use an alternate configuration directory"), NULL },
        { "ft-names", 0, 0, G_OPTION_ARG_NONE, &ft_names, N_("Print internal filetype names"), NULL },
        { "generate-tags", 'g', 0, G_OPTION_ARG_NONE, &generate_tags, N_("Generate global tags file (see documentation)"), NULL },
        { "no-preprocessing", 'P', 0, G_OPTION_ARG_NONE, &no_preprocessing, N_("Don't preprocess C/C++ files when generating tags file"), NULL },
#ifdef HAVE_SOCKET
        { "new-instance", 'i', 0, G_OPTION_ARG_NONE, &cl_options.new_instance, N_("Don't open files in a running instance, force opening a new instance"), NULL },
        { "socket-file", 0, 0, G_OPTION_ARG_FILENAME, &cl_options.socket_filename, N_("Use this socket filename for communication with a running Geany instance"), NULL },
        { "list-documents", 0, 0, G_OPTION_ARG_NONE, &cl_options.list_documents, N_("Return a list of open documents in a running Geany instance"), NULL },
#endif
        { "line", 'l', 0, G_OPTION_ARG_INT, &cl_options.goto_line, N_("Set initial line number for the first opened file"), NULL },
        { "no-msgwin", 'm', 0, G_OPTION_ARG_NONE, &no_msgwin, N_("Don't show message window at startup"), NULL },
        { "no-ctags", 'n', 0, G_OPTION_ARG_NONE, &ignore_global_tags, N_("Don't load auto completion data (see documentation)"), NULL },
#ifdef HAVE_PLUGINS
        { "no-plugins", 'p', 0, G_OPTION_ARG_NONE, &no_plugins, N_("Don't load plugins"), NULL },
#endif
        { "print-prefix", 0, 0, G_OPTION_ARG_NONE, &print_prefix, N_("Print Geany's installation prefix"), NULL },
        { "read-only", 'r', 0, G_OPTION_ARG_NONE, &cl_options.readonly, N_("Open all FILES in read-only mode (see documentation)"), NULL },
        { "no-session", 's', G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE, &cl_options.load_session, N_("Don't load the previous session's files"), NULL },
#ifdef HAVE_VTE
        { "no-terminal", 't', 0, G_OPTION_ARG_NONE, &no_vte, N_("Don't load terminal support"), NULL },
        { "vte-lib", 0, 0, G_OPTION_ARG_FILENAME, &lib_vte, N_("Filename of libvte.so"), NULL },
#endif
        { "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose_mode, N_("Be verbose"), NULL },
        { "version", 'V', 0, G_OPTION_ARG_NONE, &show_version, N_("Show version and exit"), NULL },
        { "dummy", 0, G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_NONE, &dummy, NULL, NULL }, /* for +NNN line number arguments */
        { NULL, 0, 0, 0, NULL, NULL, NULL }
};


static void setup_window_position(void)
{
        /* interprets the saved window geometry */
        if (!prefs.save_winpos)
                return;

        if (ui_prefs.geometry[0] != -1 && ui_prefs.geometry[1] != -1)
                gtk_window_move(GTK_WINDOW(main_widgets.window),
                        ui_prefs.geometry[0], ui_prefs.geometry[1]);

        if (ui_prefs.geometry[2] != -1 && ui_prefs.geometry[3] != -1)
                gtk_window_set_default_size(GTK_WINDOW(main_widgets.window),
                        ui_prefs.geometry[2], ui_prefs.geometry[3]);

        if (ui_prefs.geometry[4] == 1)
                gtk_window_maximize(GTK_WINDOW(main_widgets.window));
}


/* special things for the initial setup of the checkboxes and related stuff
 * an action on a setting is only performed if the setting is not equal to the program default
 * (all the following code is not perfect but it works for the moment) */
static void apply_settings(void)
{
        ui_update_fold_items();

        /* toolbar, message window and sidebar are by default visible, so don't change it if it is true */
        toolbar_show_hide();
        if (! ui_prefs.msgwindow_visible)
        {
                ignore_callback = TRUE;
                gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ui_lookup_widget(main_widgets.window, "menu_show_messages_window1")), FALSE);
                gtk_widget_hide(main_widgets.message_window_notebook);
                ignore_callback = FALSE;
        }
        if (! ui_prefs.sidebar_visible)
        {
                ignore_callback = TRUE;
                gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ui_lookup_widget(main_widgets.window, "menu_show_sidebar1")), FALSE);
                ignore_callback = FALSE;
        }

        toolbar_apply_settings();
        toolbar_update_ui();

        ui_update_view_editor_menu_items();

        /* hide statusbar if desired */
        if (! interface_prefs.statusbar_visible)
        {
                gtk_widget_hide(ui_widgets.statusbar);
        }

        /* set the tab placements of the notebooks */
        gtk_notebook_set_tab_pos(GTK_NOTEBOOK(main_widgets.notebook), interface_prefs.tab_pos_editor);
        gtk_notebook_set_tab_pos(GTK_NOTEBOOK(msgwindow.notebook), interface_prefs.tab_pos_msgwin);
        gtk_notebook_set_tab_pos(GTK_NOTEBOOK(main_widgets.sidebar_notebook), interface_prefs.tab_pos_sidebar);

        /* whether to show notebook tabs or not */
        gtk_notebook_set_show_tabs(GTK_NOTEBOOK(main_widgets.notebook), interface_prefs.show_notebook_tabs);

#ifdef HAVE_VTE
        if (! vte_info.have_vte)
#endif
        {
                gtk_widget_set_sensitive(
                        ui_lookup_widget(main_widgets.window, "send_selection_to_vte1"), FALSE);
        }

        if (interface_prefs.sidebar_pos != GTK_POS_LEFT)
                ui_swap_sidebar_pos();

        gtk_orientable_set_orientation(GTK_ORIENTABLE(ui_lookup_widget(main_widgets.window, "vpaned1")),
                interface_prefs.msgwin_orientation);
}


static void on_window_active_changed(GtkWindow *window, GParamSpec *pspec, gpointer data)
{
        GeanyDocument *doc = document_get_current();

        if (doc && gtk_window_is_active(window))
                document_check_disk_status(doc, TRUE);
}


static void main_init(void)
{
        /* add our icon path in case we aren't installed in the system prefix */
        gtk_icon_theme_append_search_path(gtk_icon_theme_get_default(), utils_resource_dir(RESOURCE_DIR_ICON));

        /* inits */
        ui_init_stock_items();

        ui_init_builder();

        main_widgets.window                             = NULL;
        app->project                    = NULL;
        ui_widgets.open_fontsel         = NULL;
        ui_widgets.open_colorsel        = NULL;
        ui_widgets.prefs_dialog         = NULL;
        main_status.main_window_realized = FALSE;
        file_prefs.tab_order_ltr                = FALSE;
        file_prefs.tab_order_beside             = FALSE;
        main_status.quitting                    = FALSE;
        ignore_callback = FALSE;
        ui_prefs.recent_queue                           = g_queue_new();
        ui_prefs.recent_projects_queue          = g_queue_new();
        main_status.opening_session_files       = FALSE;

        main_widgets.window = create_window1();
        g_signal_connect(main_widgets.window, "notify::is-active", G_CALLBACK(on_window_active_changed), NULL);

        /* add recent projects to the Project menu */
        ui_widgets.recent_projects_menuitem = ui_lookup_widget(main_widgets.window, "recent_projects1");
        ui_widgets.recent_projects_menu_menubar = gtk_menu_new();
        gtk_menu_item_set_submenu(GTK_MENU_ITEM(ui_widgets.recent_projects_menuitem),
                                                        ui_widgets.recent_projects_menu_menubar);

        /* store important pointers for later reference */
        main_widgets.toolbar = toolbar_init();
        main_widgets.sidebar_notebook = ui_lookup_widget(main_widgets.window, "notebook3");
        main_widgets.notebook = ui_lookup_widget(main_widgets.window, "notebook1");
        main_widgets.editor_menu = create_edit_menu1();
        main_widgets.tools_menu = ui_lookup_widget(main_widgets.window, "tools1_menu");
        main_widgets.message_window_notebook = ui_lookup_widget(main_widgets.window, "notebook_info");
        main_widgets.project_menu = ui_lookup_widget(main_widgets.window, "menu_project1_menu");

        ui_widgets.toolbar_menu = create_toolbar_popup_menu1();
        ui_init();
#ifdef MAC_INTEGRATION
        osx_ui_init();
#endif

        /* set widget names for matching with .gtkrc-2.0 */
        gtk_widget_set_name(main_widgets.window, "GeanyMainWindow");
        gtk_widget_set_name(ui_widgets.toolbar_menu, "GeanyToolbarMenu");
        gtk_widget_set_name(main_widgets.editor_menu, "GeanyEditMenu");
        gtk_widget_set_name(ui_lookup_widget(main_widgets.window, "menubar1"), "GeanyMenubar");
        gtk_widget_set_name(main_widgets.toolbar, "GeanyToolbar");

        gtk_window_set_default_size(GTK_WINDOW(main_widgets.window),
                GEANY_WINDOW_DEFAULT_WIDTH, GEANY_WINDOW_DEFAULT_HEIGHT);
}


const gchar *main_get_version_string(void)
{
        static gchar full[] = VERSION " (git >= " REVISION ")";

        if (utils_str_equal(REVISION, "-1"))
                return VERSION;
        else
                return full;
}


/* get the full file path of a command-line argument
 * N.B. the result should be freed and may contain '/../' or '/./ ' */
gchar *main_get_argv_filename(const gchar *filename)
{
        gchar *result;

        if (g_path_is_absolute(filename) || utils_is_uri(filename))
                result = g_strdup(filename);
        else
        {
                /* use current dir */
                gchar *cur_dir = NULL;
                if (original_cwd == NULL)
                        cur_dir = g_get_current_dir();
                else
                        cur_dir = g_strdup(original_cwd);

                result = g_strjoin(
                        G_DIR_SEPARATOR_S, cur_dir, filename, NULL);
                g_free(cur_dir);
        }
        return result;
}


/* get a :line:column specifier from the end of a filename (if present),
 * return the line/column values, and remove the specifier from the string
 * (Note that *line and *column must both be set to -1 initially) */
static void get_line_and_column_from_filename(gchar *filename, gint *line, gint *column)
{
        gsize i;
        gint colon_count = 0;
        gboolean have_number = FALSE;
        gsize len;

        g_assert(*line == -1 && *column == -1);

        if (G_UNLIKELY(EMPTY(filename)))
                return;

        /* allow to open files like "test:0" */
        if (g_file_test(filename, G_FILE_TEST_EXISTS))
                return;

        len = strlen(filename);
        for (i = len - 1; i >= 1; i--)
        {
                gboolean is_colon = filename[i] == ':';
                gboolean is_digit = g_ascii_isdigit(filename[i]);

                if (! is_colon && ! is_digit)
                        break;

                if (is_colon)
                {
                        if (++colon_count > 1)
                                break;  /* bail on 2+ colons in a row */
                }
                else
                        colon_count = 0;

                if (is_digit)
                        have_number = TRUE;

                if (is_colon && have_number)
                {
                        gint number = atoi(&filename[i + 1]);

                        filename[i] = '\0';
                        have_number = FALSE;

                        *column = *line;
                        *line = number;
                }

                if (*column >= 0)
                        break;  /* line and column are set, so we're done */
        }
}


#ifdef G_OS_WIN32
static void change_working_directory_on_windows(void)
{
        gchar *install_dir = win32_get_installation_dir();

        /* remember original working directory for use with opening files from the command line */
        original_cwd = g_get_current_dir();

        /* On Windows, change the working directory to the Geany installation path to not lock
         * the directory of a file passed as command line argument (see bug #2626124).
         * This also helps if plugins or other code uses relative paths to load
         * any additional resources (e.g. share/geany-plugins/...). */
        win32_set_working_directory(install_dir);

        g_free(install_dir);
}
#endif


static void setup_paths(void)
{
        /* convert path names to locale encoding */
        app->datadir = utils_get_locale_from_utf8(utils_resource_dir(RESOURCE_DIR_DATA));
        app->docdir = utils_get_locale_from_utf8(utils_resource_dir(RESOURCE_DIR_DOC));
}


/**
 *  Checks whether the main window has been realized.
 *  This is an easy indicator whether Geany is right now starting up (main window is not
 *  yet realized) or whether it has finished the startup process (main window is realized).
 *  This is because the main window is realized (i.e. actually drawn on the screen) at the
 *  end of the startup process.
 *
 *  @note Maybe you want to use the @link pluginsignals.c @c "geany-startup-complete" signal @endlink
 *        to get notified about the completed startup process.
 *
 *  @return @c TRUE if the Geany main window has been realized or @c FALSE otherwise.
 *
 *  @since 0.19
 **/
GEANY_API_SYMBOL
gboolean main_is_realized(void)
{
        return main_status.main_window_realized;
}


/**
 *  Initialises the gettext translation system.
 *  This is a convenience function to set up gettext for internationalisation support
 *  in external plugins. You should call this function early in @ref plugin_init().
 *  If the macro HAVE_LOCALE_H is defined, @c setlocale(LC_ALL, "") is called.
 *  The codeset for the message translations is set to UTF-8.
 *
 *  Note that this function only setups the gettext textdomain for you. You still have
 *  to adjust the build system of your plugin to get internationalisation support
 *  working properly.
 *
 *  If you have already used @ref PLUGIN_SET_TRANSLATABLE_INFO() you
 *  don't need to call main_locale_init() again as it has already been done.
 *
 *  @param locale_dir The location where the translation files should be searched. This is
 *                    usually the @c LOCALEDIR macro, defined by the build system.
 *                    E.g. @c $prefix/share/locale.
 *                    Only used on non-Windows systems. On Windows, the directory is determined
 *                    by @c g_win32_get_package_installation_directory().
 *  @param package The package name, usually this is the @c GETTEXT_PACKAGE macro,
 *                 defined by the build system.
 *
 *  @since 0.16
 **/
GEANY_API_SYMBOL
void main_locale_init(const gchar *locale_dir, const gchar *package)
{
#ifdef HAVE_LOCALE_H
        setlocale(LC_ALL, "");
#endif

#ifdef G_OS_WIN32
        locale_dir = utils_resource_dir(RESOURCE_DIR_LOCALE);
#endif
        (void) bindtextdomain(package, locale_dir);
        (void) bind_textdomain_codeset(package, "UTF-8");
}


static void print_filetypes(void)
{
        const GSList *list, *node;

        filetypes_init_types();
        printf("Geany's filetype names:\n");

        list = filetypes_get_sorted_by_name();
        foreach_slist(node, list)
        {
                GeanyFiletype *ft = node->data;

                printf("%s\n", ft->name);
        }
        filetypes_free_types();
}


static void wait_for_input_on_windows(void)
{
#ifdef G_OS_WIN32
        if (verbose_mode)
        {
                geany_debug("Press any key to continue");
                getchar();
        }
#endif
}


static void parse_command_line_options(gint *argc, gchar ***argv)
{
        GError *error = NULL;
        GOptionContext *context;
        gint i;
        CommandLineOptions def_clo = {FALSE, NULL, TRUE, -1, -1, FALSE, FALSE, FALSE};

        /* first initialise cl_options fields with default values */
        cl_options = def_clo;

        /* the GLib option parser can't handle the +NNN (line number) option,
         * so we grab that here and replace it with a no-op */
        for (i = 1; i < (*argc); i++)
        {
                if ((*argv)[i][0] != '+')
                        continue;

                cl_options.goto_line = atoi((*argv)[i] + 1);
                (*argv)[i] = (gchar *) "--dummy";
        }

        context = g_option_context_new(_("[FILES...]"));

        g_option_context_add_main_entries(context, entries, GETTEXT_PACKAGE);
        g_option_group_set_translation_domain(g_option_context_get_main_group(context), GETTEXT_PACKAGE);
        g_option_context_add_group(context, gtk_get_option_group(FALSE));
        g_option_context_parse(context, argc, argv, &error);
        g_option_context_free(context);

        if (error != NULL)
        {
                g_printerr("Geany: %s\n", error->message);
                g_error_free(error);
                exit(1);
        }

        app->debug_mode = verbose_mode;
        if (app->debug_mode)
        {
                /* Since GLib 2.32 messages logged with levels INFO and DEBUG aren't output by the
                 * default log handler unless the G_MESSAGES_DEBUG environment variable contains the
                 * domain of the message or is set to the special value "all" */
                g_setenv("G_MESSAGES_DEBUG", "all", FALSE);
        }

#ifdef G_OS_WIN32
        win32_init_debug_code();
#endif

        if (show_version)
        {
                gchar *build_date = utils_parse_and_format_build_date(__DATE__);

                printf(PACKAGE " %s (", main_get_version_string());
                /* note for translators: library versions are printed after this */
                printf(_("built on %s with "), build_date);
                printf(geany_lib_versions,
                        GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION,
                        GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION, GLIB_MICRO_VERSION);
                printf(")\n");
                g_free(build_date);
                wait_for_input_on_windows();
                exit(0);
        }

        if (print_prefix)
        {
                printf("%s\n", GEANY_PREFIX);
                printf("%s\n", GEANY_DATADIR);
                printf("%s\n", GEANY_LIBDIR);
                printf("%s\n", GEANY_LOCALEDIR);
                wait_for_input_on_windows();
                exit(0);
        }

        if (alternate_config)
        {
                geany_debug("Using alternate configuration directory");
                app->configdir = alternate_config;
        }
        else
        {
                app->configdir = utils_get_user_config_dir();
        }

        if (generate_tags)
        {
                gboolean ret;

                filetypes_init_types();
                ret = symbols_generate_global_tags(*argc, *argv, ! no_preprocessing);
                filetypes_free_types();
                wait_for_input_on_windows();
                exit(ret);
        }

        if (ft_names)
        {
                print_filetypes();
                wait_for_input_on_windows();
                exit(0);
        }

#ifdef HAVE_SOCKET
        socket_info.ignore_socket = cl_options.new_instance;
        if (cl_options.socket_filename)
        {
                socket_info.file_name = cl_options.socket_filename;
        }
#endif

#ifdef HAVE_VTE
        vte_info.lib_vte = lib_vte;
#endif
        cl_options.ignore_global_tags = ignore_global_tags;

        if (! gtk_init_check(NULL, NULL))
        {       /* check whether we have a valid X display and exit if not */
                g_printerr("Geany: cannot open display\n");
                exit(1);
        }

#ifdef MAC_INTEGRATION
        /* Create GtkosxApplication singleton - should be created shortly after gtk_init() */
        gtkosx_application_get();
#endif
}


static gint create_config_dir(void)
{
        gint saved_errno = 0;
        gchar *conf_file = NULL;
        gchar *filedefs_dir = NULL;
        gchar *templates_dir = NULL;

        if (! g_file_test(app->configdir, G_FILE_TEST_EXISTS))
        {
#ifndef G_OS_WIN32
                /* if we are *not* using an alternate config directory, we check whether the old one
                 * in ~/.geany still exists and try to move it */
                if (alternate_config == NULL)
                {
                        gchar *old_dir = g_build_filename(g_get_home_dir(), ".geany", NULL);
                        /* move the old config dir if it exists */
                        if (g_file_test(old_dir, G_FILE_TEST_EXISTS))
                        {
                                if (! dialogs_show_question_full(main_widgets.window,
                                        GTK_STOCK_YES, GTK_STOCK_QUIT, _("Move it now?"),
                                        "%s",
                                        _("Geany needs to move your old configuration directory before starting.")))
                                        exit(0);

                                if (! g_file_test(app->configdir, G_FILE_TEST_IS_DIR))
                                        utils_mkdir(app->configdir, TRUE);

                                if (g_rename(old_dir, app->configdir) == 0)
                                {
                                        dialogs_show_msgbox(GTK_MESSAGE_INFO,
                                                _("Your configuration directory has been successfully moved from \"%s\" to \"%s\"."),
                                                old_dir, app->configdir);
                                        g_free(old_dir);
                                        return 0;
                                }
                                else
                                {
                                        dialogs_show_msgbox(GTK_MESSAGE_WARNING,
                                                /* for translators: the third %s in brackets is the error message which
                                                 * describes why moving the dir didn't work */
                                                _("Your old configuration directory \"%s\" could not be moved to \"%s\" (%s). "
                                                  "Please move manually the directory to the new location."),
                                                old_dir, app->configdir, g_strerror(errno));
                                }
                        }
                        g_free(old_dir);
                }
#endif
                geany_debug("Creating configuration directory");
                saved_errno = utils_mkdir(app->configdir, TRUE);
        }

        conf_file = g_build_filename(app->configdir, "geany.conf", NULL);
        filedefs_dir = g_build_filename(app->configdir, GEANY_FILEDEFS_SUBDIR, NULL);
        templates_dir = g_build_filename(app->configdir, GEANY_TEMPLATES_SUBDIR, NULL);

        if (saved_errno == 0 && ! g_file_test(conf_file, G_FILE_TEST_EXISTS))
        {       /* check whether geany.conf can be written */
                saved_errno = utils_is_file_writable(app->configdir);
        }

        /* make subdir for filetype definitions */
        if (saved_errno == 0)
        {
                gchar *filedefs_readme = g_build_filename(app->configdir,
                                        GEANY_FILEDEFS_SUBDIR, "filetypes.README", NULL);

                if (! g_file_test(filedefs_dir, G_FILE_TEST_EXISTS))
                {
                        saved_errno = utils_mkdir(filedefs_dir, FALSE);
                }
                if (saved_errno == 0 && ! g_file_test(filedefs_readme, G_FILE_TEST_EXISTS))
                {
                        gchar *text = g_strconcat(
"Copy files from ", app->datadir, "/filedefs to this directory to overwrite "
"them. To use the defaults, just delete the file in this directory.\nFor more information read "
"the documentation (in ", app->docdir, G_DIR_SEPARATOR_S "index.html or visit " GEANY_HOMEPAGE ").", NULL);
                        utils_write_file(filedefs_readme, text);
                        g_free(text);
                }
                g_free(filedefs_readme);
        }

        /* make subdir for template files */
        if (saved_errno == 0)
        {
                gchar *templates_readme = g_build_filename(app->configdir, GEANY_TEMPLATES_SUBDIR,
                                                "templates.README", NULL);

                if (! g_file_test(templates_dir, G_FILE_TEST_EXISTS))
                {
                        saved_errno = utils_mkdir(templates_dir, FALSE);
                }
                if (saved_errno == 0 && ! g_file_test(templates_readme, G_FILE_TEST_EXISTS))
                {
                        gchar *text = g_strconcat(
"There are several template files in this directory. For these templates you can use wildcards.\n\
For more information read the documentation (in ", app->docdir, G_DIR_SEPARATOR_S "index.html or visit " GEANY_HOMEPAGE ").",
                                        NULL);
                        utils_write_file(templates_readme, text);
                        g_free(text);
                }
                g_free(templates_readme);
        }

        g_free(filedefs_dir);
        g_free(templates_dir);
        g_free(conf_file);

        return saved_errno;
}


/* Returns 0 if config dir is OK. */
static gint setup_config_dir(void)
{
        gint mkdir_result = 0;

        mkdir_result = create_config_dir();
        if (mkdir_result != 0)
        {
                if (! dialogs_show_question(
                        _("Configuration directory could not be created (%s).\nThere could be some problems "
                          "using Geany without a configuration directory.\nStart Geany anyway?"),
                          g_strerror(mkdir_result)))
                {
                        exit(0);
                }
        }
        /* make configdir a real path */
        if (g_file_test(app->configdir, G_FILE_TEST_EXISTS))
                SETPTR(app->configdir, tm_get_real_path(app->configdir));

        return mkdir_result;
}

/* Signal handling removed since main_quit() uses functions that are
 * illegal in signal handlers
static void signal_cb(gint sig)
{
        if (sig == SIGTERM)
        {
                main_quit();
        }
}
 */

/* Used for command-line arguments at startup or from socket.
 * this will strip any :line:col filename suffix from locale_filename */
gboolean main_handle_filename(const gchar *locale_filename)
{
        GeanyDocument *doc;
        gint line = -1, column = -1;
        gchar *filename;

        g_return_val_if_fail(locale_filename, FALSE);

        /* check whether the passed filename is an URI */
        filename = utils_get_path_from_uri(locale_filename);
        if (filename == NULL)
                return FALSE;

        get_line_and_column_from_filename(filename, &line, &column);
        if (line >= 0)
                cl_options.goto_line = line;
        if (column >= 0)
                cl_options.goto_column = column;

        if (g_file_test(filename, G_FILE_TEST_IS_REGULAR))
        {
                doc = document_open_file(filename, cl_options.readonly, NULL, NULL);
                /* add recent file manually if opening_session_files is set */
                if (doc != NULL && main_status.opening_session_files)
                        ui_add_recent_document(doc);
                g_free(filename);
                return TRUE;
        }
        else if (file_prefs.cmdline_new_files)
        {       /* create new file with the given filename */
                gchar *utf8_filename = utils_get_utf8_from_locale(filename);

                doc = document_find_by_filename(utf8_filename);
                if (doc)
                        document_show_tab(doc);
                else
                        doc = document_new_file(utf8_filename, NULL, NULL);
                if (doc != NULL)
                        ui_add_recent_document(doc);
                g_free(utf8_filename);
                g_free(filename);
                return TRUE;
        }
        g_free(filename);
        return FALSE;
}


/* open files from command line */
static void open_cl_files(gint argc, gchar **argv)
{
        gint i;

        for (i = 1; i < argc; i++)
        {
                gchar *filename = main_get_argv_filename(argv[i]);

                if (g_file_test(filename, G_FILE_TEST_IS_DIR))
                {
                        g_free(filename);
                        continue;
                }

#ifdef G_OS_WIN32
                /* It seems argv elements are encoded in CP1252 on a German Windows */
                SETPTR(filename, g_locale_to_utf8(filename, -1, NULL, NULL, NULL));
#endif
                if (filename && ! main_handle_filename(filename))
                {
                        const gchar *msg = _("Could not find file '%s'.");

                        g_printerr(msg, filename);      /* also print to the terminal */
                        g_printerr("\n");
                        ui_set_statusbar(TRUE, msg, filename);
                }
                g_free(filename);
        }
}


static void load_session_project_file(void)
{
        gchar *locale_filename;

        g_return_if_fail(project_prefs.session_file != NULL);

        locale_filename = utils_get_locale_from_utf8(project_prefs.session_file);

        if (G_LIKELY(!EMPTY(locale_filename)))
                project_load_file(locale_filename);

        g_free(locale_filename);
        g_free(project_prefs.session_file);     /* no longer needed */
}


static void load_settings(void)
{
        configuration_load();
        /* let cmdline options overwrite configuration settings */
#ifdef HAVE_VTE
        vte_info.have_vte = (no_vte) ? FALSE : vte_info.load_vte;
#endif
        if (no_msgwin)
                ui_prefs.msgwindow_visible = FALSE;

#ifdef HAVE_PLUGINS
        want_plugins = prefs.load_plugins && !no_plugins;
#endif
}


void main_load_project_from_command_line(const gchar *locale_filename, gboolean use_session)
{
        gchar *pfile;

        pfile = utils_get_path_from_uri(locale_filename);
        if (pfile != NULL)
        {
                if (use_session)
                        project_load_file_with_session(pfile);
                else
                        project_load_file(pfile);
        }
        g_free(pfile);
}


static void load_startup_files(gint argc, gchar **argv)
{
        gboolean load_session = FALSE;

        if (argc > 1 && g_str_has_suffix(argv[1], ".geany"))
        {
                gchar *filename = main_get_argv_filename(argv[1]);

                /* project file specified: load it, but decide the session later */
                main_load_project_from_command_line(filename, FALSE);
                argc--, argv++;
                /* force session load if using project-based session files */
                load_session = project_prefs.project_session;
                g_free(filename);
        }

        /* Load the default session if:
         * 1. "Load files from the last session" is active.
         * 2. --no-session is not specified.
         * 3. We are a primary instance.
         * Has no effect if a CL project is loaded and using project-based session files. */
        if (prefs.load_session && cl_options.load_session && !cl_options.new_instance)
        {
                if (app->project == NULL)
                        load_session_project_file();
                load_session = TRUE;
        }

        if (load_session)
        {
                /* load session files into tabs, as they are found in the session_files variable */
                configuration_open_files();

                if (gtk_notebook_get_n_pages(GTK_NOTEBOOK(main_widgets.notebook)) == 0)
                {
                        ui_update_popup_copy_items(NULL);
                        ui_update_popup_reundo_items(NULL);
                }
        }

        open_cl_files(argc, argv);
}


static gboolean send_startup_complete(gpointer data)
{
        g_signal_emit_by_name(geany_object, "geany-startup-complete");
        return FALSE;
}


static const gchar *get_locale(void)
{
        const gchar *locale = "unknown";
#ifdef HAVE_LOCALE_H
        locale = setlocale(LC_CTYPE, NULL);
#endif
        return locale;
}


#if ! GTK_CHECK_VERSION(3, 0, 0)
/* This prepends our own gtkrc file to the list of RC files to be loaded by GTK at startup.
 * This function *has* to be called before gtk_init().
 *
 * We have a custom RC file defining various styles we need, and we want the user to be
 * able to override them (e.g. if they want -- or need -- other colors).  Fair enough, one
 * would simply call gtk_rc_parse() with the appropriate filename.  However, the styling
 * rules applies in the order they are loaded, then if we load our styles after GTK has
 * loaded the user's ones we'd override them.
 *
 * There are 2 solutions to fix this:
 * 1) set our styles' priority to something with lower than "user" (actually "theme"
 *    priority because rules precedence are first calculated depending on the priority
 *    no matter of how precise the rules is, so we need to override the theme).
 * 2) prepend our custom style to GTK's list while keeping priority to user (which is the
 *    default), so it gets loaded before real user's ones and so gets overridden by them.
 *
 * One would normally go for 1 because it's ways simpler and requires less code: you just
 * have to add the priorities to your styles, which is a matter of adding a few ":theme" in
 * the RC file.  However, KDE being a bitch it doesn't set the gtk-theme-name but rather
 * directly includes the style to use in a user gtkrc file, which makes the theme have
 * "user" priority, hence overriding our styles.  So, we cannot set priorities in the RC
 * file if we want to support running under KDE, which pretty much leave us with no choice
 * but to go with solution 2, which unfortunately requires writing ugly code since GTK
 * don't have a gtk_rc_prepend_default_file() function.  Thank you very much KDE.
 *
 * Though, as a side benefit it also makes the code work with people using gtk-chtheme,
 * which also found it funny to include the theme in the user RC file. */
static void setup_gtk2_styles(void)
{
        gchar **gtk_files = gtk_rc_get_default_files();
        gchar **new_files = g_malloc(sizeof *new_files * (g_strv_length(gtk_files) + 2));
        guint i = 0;

        new_files[i++] = g_build_filename(app->datadir, "geany.gtkrc", NULL);
        for (; *gtk_files; gtk_files++)
                new_files[i++] = g_strdup(*gtk_files);
        new_files[i] = NULL;

        gtk_rc_set_default_files(new_files);

        g_strfreev(new_files);
}
#endif


GEANY_EXPORT_SYMBOL
gint main_lib(gint argc, gchar **argv)
{
        GeanyDocument *doc;
        gint config_dir_result;
        const gchar *locale;
        gchar *utf8_configdir;

#if ! GLIB_CHECK_VERSION(2, 36, 0)
        g_type_init();
#endif

        log_handlers_init();

        app = g_new0(GeanyApp, 1);
        memset(&main_status, 0, sizeof(GeanyStatus));
        memset(&prefs, 0, sizeof(GeanyPrefs));
        memset(&interface_prefs, 0, sizeof(GeanyInterfacePrefs));
        memset(&toolbar_prefs, 0, sizeof(GeanyToolbarPrefs));
        memset(&file_prefs, 0, sizeof(GeanyFilePrefs));
        memset(&search_prefs, 0, sizeof(GeanySearchPrefs));
        memset(&tool_prefs, 0, sizeof(GeanyToolPrefs));
        memset(&template_prefs, 0, sizeof(GeanyTemplatePrefs));
        memset(&ui_prefs, 0, sizeof(UIPrefs));
        memset(&ui_widgets, 0, sizeof(UIWidgets));

        setup_paths();
#if ! GTK_CHECK_VERSION(3, 0, 0)
        setup_gtk2_styles();
#endif
#ifdef ENABLE_NLS
        main_locale_init(utils_resource_dir(RESOURCE_DIR_LOCALE), GETTEXT_PACKAGE);
#endif
        /* initialize TM before parsing command-line - needed for tag file generation */
        app->tm_workspace = tm_get_workspace();
        parse_command_line_options(&argc, &argv);

#if ! GLIB_CHECK_VERSION(2, 32, 0)
        /* Initialize GLib's thread system in case any plugins want to use it or their
         * dependencies (e.g. WebKit, Soup, ...). Deprecated since GLIB 2.32. */
        if (!g_thread_supported())
                g_thread_init(NULL);
#endif

        /* removed as signal handling was wrong, see signal_cb()
        signal(SIGTERM, signal_cb); */

#ifdef G_OS_UNIX
        /* ignore SIGPIPE signal for preventing sudden death of program */
        signal(SIGPIPE, SIG_IGN);
#endif

        config_dir_result = setup_config_dir();
#ifdef HAVE_SOCKET
        /* check and create (unix domain) socket for remote operation */
        if (! socket_info.ignore_socket)
        {
                socket_info.lock_socket = -1;
                socket_info.lock_socket_tag = 0;
                socket_info.lock_socket = socket_init(argc, argv);
                /* Quit if filenames were sent to first instance or the list of open
                 * documents has been printed */
                if ((socket_info.lock_socket == -2 /* socket exists */ && argc > 1) ||
                        cl_options.list_documents)
                {
                        socket_finalize();
                        gdk_notify_startup_complete();
                        g_free(app->configdir);
                        g_free(app->datadir);
                        g_free(app->docdir);
                        g_free(app);
                        return 0;
                }
                /* Start a new instance if no command line strings were passed,
                 * even if the socket already exists */
                else if (socket_info.lock_socket == -2 /* socket already exists */)
                {
                        socket_info.ignore_socket = TRUE;
                        cl_options.new_instance = TRUE;
                }
        }
#endif

#ifdef G_OS_WIN32
        /* after we initialized the socket code and handled command line args,
         * let's change the working directory on Windows to not lock it */
        change_working_directory_on_windows();
#endif

        locale = get_locale();
        geany_debug("Geany %s, %s",
                main_get_version_string(),
                locale);
        geany_debug(geany_lib_versions,
                gtk_major_version, gtk_minor_version, gtk_micro_version,
                glib_major_version, glib_minor_version, glib_micro_version);
        geany_debug("System data dir: %s", app->datadir);
        utf8_configdir = utils_get_utf8_from_locale(app->configdir);
        geany_debug("User config dir: %s", utf8_configdir);
        g_free(utf8_configdir);

        /* create the object so Geany signals can be connected in init() functions */
        geany_object = geany_object_new();

        /* inits */
        main_init();

        encodings_init();
        editor_init();

        /* init stash groups before loading keyfile */
        configuration_init();
        ui_init_prefs();
        search_init();
        project_init();
#ifdef HAVE_PLUGINS
        plugins_init();
#endif
        sidebar_init();
        load_settings();        /* load keyfile */

        msgwin_init();
        build_init();
        ui_create_insert_menu_items();
        ui_create_insert_date_menu_items();
        keybindings_init();
        notebook_init();
        filetypes_init();
        templates_init();
        navqueue_init();
        document_init_doclist();
        symbols_init();
        editor_snippets_init();

#ifdef HAVE_VTE
        vte_init();
#endif
        ui_create_recent_menus();

        ui_set_statusbar(TRUE, _("This is Geany %s."), main_get_version_string());
        if (config_dir_result != 0)
                ui_set_statusbar(TRUE, _("Configuration directory could not be created (%s)."),
                        g_strerror(config_dir_result));

        /* apply all configuration options */
        apply_settings();

#ifdef HAVE_PLUGINS
        /* load any enabled plugins before we open any documents */
        if (want_plugins)
                plugins_load_active();
#endif

        ui_sidebar_show_hide();

        /* set the active sidebar page after plugins have been loaded */
        gtk_notebook_set_current_page(GTK_NOTEBOOK(main_widgets.sidebar_notebook), ui_prefs.sidebar_page);

        /* load keybinding settings after plugins have added their groups */
        keybindings_load_keyfile();

        /* create the custom command menu after the keybindings have been loaded to have the proper
         * accelerator shown for the menu items */
        tools_create_insert_custom_command_menu_items();

        /* load any command line files or session files */
        main_status.opening_session_files = TRUE;
        load_startup_files(argc, argv);
        main_status.opening_session_files = FALSE;

        /* open a new file if no other file was opened */
        document_new_file_if_non_open();

        ui_document_buttons_update();
        ui_save_buttons_toggle(FALSE);

        doc = document_get_current();
        sidebar_select_openfiles_item(doc);
        build_menu_update(doc);
        sidebar_update_tag_list(doc, FALSE);

#ifdef G_OS_WIN32
        /* Manually realise the main window to be able to set the position but don't show it.
         * We don't set the position after showing the window to avoid flickering. */
        gtk_widget_realize(main_widgets.window);
#endif
        setup_window_position();

        /* finally show the window */
        document_grab_focus(doc);
        gtk_widget_show(main_widgets.window);
        main_status.main_window_realized = TRUE;

        configuration_apply_settings();

#ifdef HAVE_SOCKET
        /* register the callback of socket input */
        if (! socket_info.ignore_socket && socket_info.lock_socket > 0)
        {
                socket_info.read_ioc = g_io_channel_unix_new(socket_info.lock_socket);
                socket_info.lock_socket_tag = g_io_add_watch(socket_info.read_ioc,
                                                G_IO_IN | G_IO_PRI | G_IO_ERR, socket_lock_input_cb, main_widgets.window);
        }
#endif

        /* when we are really done with setting everything up and the main event loop is running,
         * tell other components, mainly plugins, that startup is complete */
        g_idle_add_full(G_PRIORITY_LOW, send_startup_complete, NULL, NULL);

#ifdef MAC_INTEGRATION
        /* OS X application ready - has to be called before entering main loop */
        gtkosx_application_ready(gtkosx_application_get());
#endif

        gtk_main();
        return 0;
}


static void queue_free(GQueue *queue)
{
        while (! g_queue_is_empty(queue))
        {
                g_free(g_queue_pop_tail(queue));
        }
        g_queue_free(queue);
}


static void do_main_quit(void)
{
        geany_debug("Quitting...");

        configuration_save();

        if (app->project != NULL)
                project_close(FALSE);   /* save project session files */

        document_close_all();

        main_status.quitting = TRUE;

#ifdef HAVE_SOCKET
        socket_finalize();
#endif

#ifdef HAVE_PLUGINS
        plugins_finalize();
#endif

        navqueue_free();
        keybindings_free();
        notebook_free();
        highlighting_free_styles();
        templates_free_templates();
        msgwin_finalize();
        search_finalize();
        build_finalize();
        document_finalize();
        symbols_finalize();
        project_finalize();
        editor_finalize();
        editor_snippets_free();
        encodings_finalize();
        toolbar_finalize();
        sidebar_finalize();
        configuration_finalize();
        filetypes_free_types();
        log_finalize();

        tm_workspace_free();
        g_free(app->configdir);
        g_free(app->datadir);
        g_free(app->docdir);
        g_free(prefs.default_open_path);
        g_free(prefs.custom_plugin_path);
        g_free(ui_prefs.custom_date_format);
        g_free(interface_prefs.editor_font);
        g_free(interface_prefs.tagbar_font);
        g_free(interface_prefs.msgwin_font);
        g_free(editor_prefs.long_line_color);
        g_free(editor_prefs.comment_toggle_mark);
        g_free(editor_prefs.color_scheme);
        g_free(tool_prefs.context_action_cmd);
        g_free(template_prefs.developer);
        g_free(template_prefs.company);
        g_free(template_prefs.mail);
        g_free(template_prefs.initials);
        g_free(template_prefs.version);
        g_free(tool_prefs.term_cmd);
        g_free(tool_prefs.browser_cmd);
        g_free(tool_prefs.grep_cmd);
        g_free(printing_prefs.external_print_cmd);
        g_free(printing_prefs.page_header_datefmt);
        g_strfreev(ui_prefs.custom_commands);
        g_strfreev(ui_prefs.custom_commands_labels);

        queue_free(ui_prefs.recent_queue);
        queue_free(ui_prefs.recent_projects_queue);

        if (ui_widgets.prefs_dialog && GTK_IS_WIDGET(ui_widgets.prefs_dialog)) gtk_widget_destroy(ui_widgets.prefs_dialog);
        if (ui_widgets.open_fontsel && GTK_IS_WIDGET(ui_widgets.open_fontsel)) gtk_widget_destroy(ui_widgets.open_fontsel);
        if (ui_widgets.open_colorsel && GTK_IS_WIDGET(ui_widgets.open_colorsel)) gtk_widget_destroy(ui_widgets.open_colorsel);
#ifdef HAVE_VTE
        if (vte_info.have_vte) vte_close();
        g_free(vte_info.lib_vte);
        g_free(vte_info.dir);
#endif
        gtk_widget_destroy(main_widgets.window);

        /* destroy popup menus */
        if (main_widgets.editor_menu && GTK_IS_WIDGET(main_widgets.editor_menu))
                                        gtk_widget_destroy(main_widgets.editor_menu);
        if (ui_widgets.toolbar_menu && GTK_IS_WIDGET(ui_widgets.toolbar_menu))
                                        gtk_widget_destroy(ui_widgets.toolbar_menu);
        if (msgwindow.popup_status_menu && GTK_IS_WIDGET(msgwindow.popup_status_menu))
                                        gtk_widget_destroy(msgwindow.popup_status_menu);
        if (msgwindow.popup_msg_menu && GTK_IS_WIDGET(msgwindow.popup_msg_menu))
                                        gtk_widget_destroy(msgwindow.popup_msg_menu);
        if (msgwindow.popup_compiler_menu && GTK_IS_WIDGET(msgwindow.popup_compiler_menu))
                                        gtk_widget_destroy(msgwindow.popup_compiler_menu);

        g_object_unref(geany_object);
        geany_object = NULL;

        g_free(original_cwd);
        g_free(app);

        ui_finalize_builder();

        gtk_main_quit();
}


static gboolean check_no_unsaved(void)
{
        guint i;

        for (i = 0; i < documents_array->len; i++)
        {
                if (documents[i]->is_valid && documents[i]->changed)
                {
                        return FALSE;
                }
        }
        return TRUE;    /* no unsaved edits */
}


/* Returns false when quitting is aborted due to user cancellation */
gboolean main_quit(void)
{
        main_status.quitting = TRUE;

        if (! check_no_unsaved())
        {
                if (document_account_for_unsaved())
                {
                        do_main_quit();
                        return TRUE;
                }
        }
        else
        if (! prefs.confirm_exit ||
                dialogs_show_question_full(NULL, GTK_STOCK_QUIT, GTK_STOCK_CANCEL, NULL,
                        _("Do you really want to quit?")))
        {
                do_main_quit();
                return TRUE;
        }

        main_status.quitting = FALSE;
        return FALSE;
}

/**
 *  Reloads most of Geany's configuration files without restarting. Currently the following
 *  files are reloaded: all template files, also new file templates and the 'New (with template)'
 *  menus will be updated, Snippets (snippets.conf), filetype extensions (filetype_extensions.conf),
 *  and 'settings' and 'build_settings' sections of the filetype definition files.
 *
 *  Plugins may call this function if they changed any of these files (e.g. a configuration file
 *  editor plugin).
 *
 *  @since 0.15
 **/
GEANY_API_SYMBOL
void main_reload_configuration(void)
{
        /* reload templates */
        templates_free_templates();
        templates_init();

        /* reload snippets */
        editor_snippets_free();
        editor_snippets_init();

        filetypes_reload_extensions();
        filetypes_reload();

        /* C tag names to ignore */
        symbols_reload_config_files();

        ui_set_statusbar(TRUE, _("Configuration files reloaded."));
}