void msgwin_compiler_add_string(gint msg_color, const gchar *msg)
{
GtkTreeIter iter;
GtkTreePath *path;
const GdkColor *color = get_color(msg_color);
gchar *utf8_msg;
if (! g_utf8_validate(msg, -1, NULL))
utf8_msg = utils_get_utf8_from_locale(msg);
else
utf8_msg = (gchar *) msg;
gtk_list_store_append(msgwindow.store_compiler, &iter);
gtk_list_store_set(msgwindow.store_compiler, &iter,
COMPILER_COL_COLOR, color, COMPILER_COL_STRING, utf8_msg, -1);
if (ui_prefs.msgwindow_visible && interface_prefs.compiler_tab_autoscroll)
{
path = gtk_tree_model_get_path(
gtk_tree_view_get_model(GTK_TREE_VIEW(msgwindow.tree_compiler)), &iter);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(msgwindow.tree_compiler), path, NULL, TRUE, 0.5, 0.5);
gtk_tree_path_free(path);
}
/* calling build_menu_update for every build message would be overkill, TODO really should call it once when all done */
gtk_widget_set_sensitive(build_get_menu_items(-1)->menu_item[GBG_FIXED][GBF_NEXT_ERROR], TRUE);
gtk_widget_set_sensitive(build_get_menu_items(-1)->menu_item[GBG_FIXED][GBF_PREV_ERROR], TRUE);
if (utf8_msg != msg)
g_free(utf8_msg);
}
gboolean on_view_query_tooltip(GtkWidget *widget, gint x, gint y, gboolean keyboard_tip,
GtkTooltip *tooltip, GtkTreeViewColumn *base_name_column)
{
GtkTreeView *tree = GTK_TREE_VIEW(widget);
GtkTreeIter iter;
if (gtk_tree_view_get_tooltip_context(tree, &x, &y, keyboard_tip, NULL, NULL, &iter))
{
const char *file;
gtk_tree_view_set_tooltip_cell(tree, tooltip, NULL, base_name_column, NULL);
scp_tree_store_get((ScpTreeStore *) gtk_tree_view_get_model(tree), &iter,
COLUMN_FILE, &file, -1);
if (file)
{
gchar *utf8 = utils_get_utf8_from_locale(file);
gtk_tooltip_set_text(tooltip, utf8);
g_free(utf8);
return TRUE;
}
}
return FALSE;
}
/* adds string to the msg treeview */
void msgwin_msg_add_string(gint msg_color, gint line, GeanyDocument *doc, const gchar *string)
{
GtkTreeIter iter;
const GdkColor *color = get_color(msg_color);
gchar *tmp;
gsize len;
gchar *utf8_msg;
if (! ui_prefs.msgwindow_visible)
msgwin_show_hide(TRUE);
/* work around a strange problem when adding very long lines(greater than 4000 bytes)
* cut the string to a maximum of 1024 bytes and discard the rest */
/* TODO: find the real cause for the display problem / if it is GtkTreeView file a bug report */
len = strlen(string);
if (len > 1024)
tmp = g_strndup(string, 1024);
else
tmp = g_strdup(string);
if (! g_utf8_validate(tmp, -1, NULL))
utf8_msg = utils_get_utf8_from_locale(tmp);
else
utf8_msg = tmp;
gtk_list_store_append(msgwindow.store_msg, &iter);
gtk_list_store_set(msgwindow.store_msg, &iter,
MSG_COL_LINE, line, MSG_COL_DOC_ID, doc ? doc->id : 0, MSG_COL_COLOR,
color, MSG_COL_STRING, utf8_msg, -1);
g_free(tmp);
if (utf8_msg != tmp)
g_free(utf8_msg);
}
static void on_add_external(G_GNUC_UNUSED GtkMenuItem * menuitem, G_GNUC_UNUSED gpointer user_data)
{
gchar *utf8_base_path = get_project_base_path();
gchar *locale_path = utils_get_locale_from_utf8(utf8_base_path);
GtkWidget *dialog;
dialog = gtk_file_chooser_dialog_new(_("Add External Directory"),
GTK_WINDOW(geany->main_widgets->window), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("Add"), GTK_RESPONSE_ACCEPT, NULL);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), locale_path);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
gchar *locale_filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
gchar *utf8_filename = utils_get_utf8_from_locale(locale_filename);
prjorg_project_add_external_dir(utf8_filename);
prjorg_sidebar_update(TRUE);
project_write_config();
g_free(utf8_filename);
g_free(locale_filename);
}
gtk_widget_destroy(dialog);
g_free(utf8_base_path);
g_free(locale_path);
}
/* try to parse the file and line number where the error occurred described in string
* and when something useful is found, it stores the line number in *line and the
* relevant file with the error in *filename.
* *line will be -1 if no error was found in string.
* *filename must be freed unless it is NULL. */
void msgwin_parse_compiler_error_line(const gchar *string, const gchar *dir,
gchar **filename, gint *line)
{
GeanyFiletype *ft;
gchar *trimmed_string, *utf8_dir;
*filename = NULL;
*line = -1;
if (G_UNLIKELY(string == NULL))
return;
if (dir == NULL)
utf8_dir = utils_get_utf8_from_locale(build_info.dir);
else
utf8_dir = g_strdup(dir);
g_return_if_fail(utf8_dir != NULL);
trimmed_string = g_strdup(string);
g_strchug(trimmed_string); /* remove possible leading whitespace */
ft = filetypes[build_info.file_type_id];
/* try parsing with a custom regex */
if (!filetypes_parse_error_message(ft, trimmed_string, filename, line))
{
/* fallback to default old-style parsing */
parse_compiler_error_line(trimmed_string, filename, line);
}
make_absolute(filename, utf8_dir);
g_free(trimmed_string);
g_free(utf8_dir);
}
static void on_config_file_clicked(G_GNUC_UNUSED GtkWidget *widget, gpointer user_data)
{
const gchar *file_name = user_data;
GeanyFiletype *ft = NULL;
if (strstr(file_name, G_DIR_SEPARATOR_S "filetypes."))
ft = filetypes_index(GEANY_FILETYPES_CONF);
if (g_file_test(file_name, G_FILE_TEST_EXISTS))
document_open_file(file_name, FALSE, ft, NULL);
else
{
gchar *utf8_filename = utils_get_utf8_from_locale(file_name);
gchar *base_name = g_path_get_basename(file_name);
gchar *global_file = g_build_filename(geany->app->datadir, base_name, NULL);
gchar *global_content = NULL;
/* if the requested file doesn't exist in the user's config dir, try loading the file
* from the global data directory and use its contents for the newly created file */
if (g_file_test(global_file, G_FILE_TEST_EXISTS))
g_file_get_contents(global_file, &global_content, NULL, NULL);
document_new_file(utf8_filename, ft, global_content);
g_free(utf8_filename);
g_free(base_name);
g_free(global_file);
g_free(global_content);
}
}
static gchar *read_file(const gchar *locale_fname)
{
gchar *contents;
gsize length;
GString *str;
if (! g_file_get_contents(locale_fname, &contents, &length, NULL))
return NULL;
if (! encodings_convert_to_utf8_auto(&contents, &length, NULL, NULL, NULL, NULL))
{
gchar *utf8_fname = utils_get_utf8_from_locale(locale_fname);
ui_set_statusbar(TRUE, _("Failed to convert template file \"%s\" to UTF-8"), utf8_fname);
g_free(utf8_fname);
g_free(contents);
return NULL;
}
str = g_string_new(contents);
g_free(contents);
/* convert to LF endings for consistency in mixing templates */
utils_ensure_same_eol_characters(str, SC_EOL_LF);
return g_string_free(str, FALSE);
}
static void dictionary_dir_button_clicked_cb(GtkButton *button, gpointer item)
{
GtkWidget *dialog;
gchar *text;
/* initialise the dialog */
dialog = gtk_file_chooser_dialog_new(_("Select Directory"), NULL,
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
text = utils_get_locale_from_utf8(gtk_entry_get_text(GTK_ENTRY(item)));
if (NZV(text))
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), text);
/* run it */
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
gchar *utf8_filename, *tmp;
tmp = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
utf8_filename = utils_get_utf8_from_locale(tmp);
gtk_entry_set_text(GTK_ENTRY(item), utf8_filename);
g_free(utf8_filename);
g_free(tmp);
}
gtk_widget_destroy(dialog);
}
static gchar *run_file_chooser(const gchar *title, GtkFileChooserAction action,
const gchar *utf8_path)
{
GtkWidget *dialog = gtk_file_chooser_dialog_new(title,
GTK_WINDOW(geany->main_widgets->window), action,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
gchar *locale_path;
gchar *ret_path = NULL;
gtk_widget_set_name(dialog, "GeanyDialog");
locale_path = utils_get_locale_from_utf8(utf8_path);
if (action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
{
if (g_path_is_absolute(locale_path) && g_file_test(locale_path, G_FILE_TEST_IS_DIR))
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), locale_path);
}
else if (action == GTK_FILE_CHOOSER_ACTION_OPEN)
{
if (g_path_is_absolute(locale_path))
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), locale_path);
}
g_free(locale_path);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
{
gchar *dir_locale;
dir_locale = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
ret_path = utils_get_utf8_from_locale(dir_locale);
g_free(dir_locale);
}
gtk_widget_destroy(dialog);
return ret_path;
}
static gboolean goto_compiler_file_line(const gchar *filename, gint line, gboolean focus_editor)
{
if (!filename || line <= -1)
return FALSE;
/* If the path doesn't exist, try the current document.
* This happens when we receive build messages in the wrong order - after the
* 'Leaving directory' messages */
if (!g_file_test(filename, G_FILE_TEST_EXISTS))
{
gchar *cur_dir = utils_get_current_file_dir_utf8();
gchar *name;
if (cur_dir)
{
/* we let the user know we couldn't find the parsed filename from the message window */
setptr(cur_dir, utils_get_locale_from_utf8(cur_dir));
name = g_path_get_basename(filename);
setptr(name, g_build_path(G_DIR_SEPARATOR_S, cur_dir, name, NULL));
g_free(cur_dir);
if (g_file_test(name, G_FILE_TEST_EXISTS))
{
ui_set_statusbar(FALSE, _("Could not find file '%s' - trying the current document path."),
filename);
filename = name;
}
else
g_free(name);
}
}
{
gchar *utf8_filename = utils_get_utf8_from_locale(filename);
GeanyDocument *doc = document_find_by_filename(utf8_filename);
GeanyDocument *old_doc = document_get_current();
g_free(utf8_filename);
if (doc == NULL) /* file not already open */
doc = document_open_file(filename, FALSE, NULL, NULL);
if (doc != NULL)
{
gboolean ret;
if (! doc->changed && editor_prefs.use_indicators) /* if modified, line may be wrong */
editor_indicator_set_on_line(doc->editor, GEANY_INDICATOR_ERROR, line - 1);
ret = navqueue_goto_line(old_doc, doc, line);
if (ret && focus_editor)
gtk_widget_grab_focus(GTK_WIDGET(doc->editor->sci));
return ret;
}
}
return FALSE;
}
static void spawn_cmd(const gchar *cmd, const gchar *dir)
{
GError *error = NULL;
gchar **argv = NULL;
gchar *working_dir;
gchar *utf8_working_dir;
gchar *utf8_cmd_string;
gchar *out;
gint exitcode;
gboolean success;
GString *output;
#ifndef G_OS_WIN32
/* run within shell so we can use pipes */
argv = g_new0(gchar *, 4);
argv[0] = g_strdup("/bin/sh");
argv[1] = g_strdup("-c");
argv[2] = g_strdup(cmd);
argv[3] = NULL;
#endif
utf8_cmd_string = utils_get_utf8_from_locale(cmd);
utf8_working_dir = g_strdup(dir);
working_dir = utils_get_locale_from_utf8(utf8_working_dir);
msgwin_clear_tab(MSG_MESSAGE);
msgwin_switch_tab(MSG_MESSAGE, TRUE);
msgwin_msg_add(COLOR_BLUE, -1, NULL, _("%s (in directory: %s)"), utf8_cmd_string, utf8_working_dir);
g_free(utf8_working_dir);
g_free(utf8_cmd_string);
output = g_string_new(NULL);
#ifndef G_OS_WIN32
success = spawn_sync(working_dir, NULL, argv, NULL,
NULL, NULL, output, &exitcode, &error);
#else
success = spawn_sync(working_dir, cmd, NULL, NULL,
NULL, output, NULL, &exitcode, &error);
#endif
out = g_string_free(output, FALSE);
if (!success || exitcode != 0)
{
if (error != NULL)
{
msgwin_msg_add(COLOR_RED, -1, NULL, _("Process execution failed (%s)"), error->message);
g_error_free(error);
}
msgwin_msg_add(COLOR_RED, -1, NULL, "%s", out);
}
else
{
msgwin_msg_add(COLOR_BLACK, -1, NULL, "%s", out);
}
g_strfreev(argv);
g_free(working_dir);
g_free(out);
}
void on_menu_evaluate_value(GArray *nodes)
{
if (atoi(parse_grab_token(nodes)) == scid_gen && !gtk_widget_get_visible(modify_dialog))
{
gchar *expr = utils_get_utf8_from_locale(input);
menu_evaluate_modify(expr, parse_lead_value(nodes), "Evaluate/Modify",
parse_mode_get(input, MODE_HBIT), eval_mr_mode, NULL);
g_free(expr);
}
}
static void write_data(const gchar *filename, const gchar *data)
{
gint error_nr = utils_write_file(filename, data);
gchar *utf8_filename = utils_get_utf8_from_locale(filename);
if (error_nr == 0)
ui_set_statusbar(TRUE, _("Document successfully exported as '%s'."), utf8_filename);
else
ui_set_statusbar(TRUE, _("File '%s' could not be written (%s)."),
utf8_filename, g_strerror(error_nr));
g_free(utf8_filename);
}
void gprj_project_rescan(void)
{
GSList *pattern_list = NULL;
GSList *ignored_dirs_list = NULL;
GSList *lst;
GSList *elem;
if (!g_prj)
return;
if (g_prj->generate_tags)
g_hash_table_foreach(g_prj->file_tag_table, (GHFunc)workspace_remove_tag, NULL);
g_hash_table_destroy(g_prj->file_tag_table);
g_prj->file_tag_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
deferred_op_queue_clean();
pattern_list = get_precompiled_patterns(geany_data->app->project->file_patterns);
ignored_dirs_list = get_precompiled_patterns(g_prj->ignored_dirs_patterns);
lst = get_file_list(geany_data->app->project->base_path, pattern_list, ignored_dirs_list);
for (elem = lst; elem != NULL; elem = g_slist_next(elem))
{
char *path;
TagObject *obj;
obj = g_new0(TagObject, 1);
obj->tag = NULL;
path = tm_get_real_path(elem->data);
if (path)
{
setptr(path, utils_get_utf8_from_locale(path));
g_hash_table_insert(g_prj->file_tag_table, path, obj);
}
}
if (g_prj->generate_tags)
g_hash_table_foreach(g_prj->file_tag_table, (GHFunc)workspace_add_tag, NULL);
g_slist_foreach(lst, (GFunc) g_free, NULL);
g_slist_free(lst);
g_slist_foreach(pattern_list, (GFunc) g_pattern_spec_free, NULL);
g_slist_free(pattern_list);
g_slist_foreach(ignored_dirs_list, (GFunc) g_pattern_spec_free, NULL);
g_slist_free(ignored_dirs_list);
}
/* Reads the given filename and creates a new project with the data found in the file.
* At this point there should not be an already opened project in Geany otherwise it will just
* return.
* The filename is expected in the locale encoding. */
static gboolean load_config(const gchar *filename)
{
GKeyFile *config;
GeanyProject *p;
GSList *node;
/* there should not be an open project */
g_return_val_if_fail(app->project == NULL && filename != NULL, FALSE);
config = g_key_file_new();
if (! g_key_file_load_from_file(config, filename, G_KEY_FILE_NONE, NULL))
{
g_key_file_free(config);
return FALSE;
}
p = create_project();
foreach_slist(node, stash_groups)
stash_group_load_from_key_file(node->data, config);
p->name = utils_get_setting_string(config, "project", "name", GEANY_STRING_UNTITLED);
p->description = utils_get_setting_string(config, "project", "description", "");
p->file_name = utils_get_utf8_from_locale(filename);
p->base_path = utils_get_setting_string(config, "project", "base_path", "");
p->file_patterns = g_key_file_get_string_list(config, "project", "file_patterns", NULL, NULL);
p->long_line_behaviour = utils_get_setting_integer(config, "long line marker",
"long_line_behaviour", 1 /* follow global */);
p->long_line_column = utils_get_setting_integer(config, "long line marker",
"long_line_column", editor_prefs.long_line_column);
apply_editor_prefs();
build_load_menu(config, GEANY_BCS_PROJ, (gpointer)p);
if (project_prefs.project_session)
{
/* save current (non-project) session (it could has been changed since program startup) */
configuration_save_default_session();
/* now close all open files */
document_close_all();
/* read session files so they can be opened with configuration_open_files() */
configuration_load_session_files(config, FALSE);
ui_focus_current_document();
}
g_signal_emit_by_name(geany_object, "project-open", config);
g_key_file_free(config);
update_ui();
return TRUE;
}
gboolean project_load_file(const gchar *locale_file_name)
{
g_return_val_if_fail(locale_file_name != NULL, FALSE);
if (load_config(locale_file_name))
{
gchar *utf8_filename = utils_get_utf8_from_locale(locale_file_name);
ui_set_statusbar(TRUE, _("Project \"%s\" opened."), app->project->name);
ui_add_recent_project_file(utf8_filename);
g_free(utf8_filename);
return TRUE;
}
else
{
gchar *utf8_filename = utils_get_utf8_from_locale(locale_file_name);
ui_set_statusbar(TRUE, _("Project file \"%s\" could not be loaded."), utf8_filename);
g_free(utf8_filename);
}
return FALSE;
}
static void run_dialog(GtkWidget *dialog, GtkWidget *entry)
{
/* set filename in the file chooser dialog */
const gchar *utf8_filename = gtk_entry_get_text(GTK_ENTRY(entry));
gchar *locale_filename = utils_get_locale_from_utf8(utf8_filename);
if (g_path_is_absolute(locale_filename))
{
if (g_file_test(locale_filename, G_FILE_TEST_EXISTS))
{
/* if the current filename is a directory, we must use
* gtk_file_chooser_set_current_folder(which expects a locale filename) otherwise
* we end up in the parent directory */
if (g_file_test(locale_filename, G_FILE_TEST_IS_DIR))
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), locale_filename);
else
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), utf8_filename);
}
else /* if the file doesn't yet exist, use at least the current directory */
{
gchar *locale_dir = g_path_get_dirname(locale_filename);
gchar *name = g_path_get_basename(utf8_filename);
if (g_file_test(locale_dir, G_FILE_TEST_EXISTS))
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), locale_dir);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), name);
g_free(name);
g_free(locale_dir);
}
}
else if (gtk_file_chooser_get_action(GTK_FILE_CHOOSER(dialog)) != GTK_FILE_CHOOSER_ACTION_OPEN)
{
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), utf8_filename);
}
g_free(locale_filename);
/* run it */
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
gchar *tmp_utf8_filename = utils_get_utf8_from_locale(filename);
gtk_entry_set_text(GTK_ENTRY(entry), tmp_utf8_filename);
g_free(tmp_utf8_filename);
g_free(filename);
}
gtk_widget_destroy(dialog);
}
static gboolean match(TMTag *tag, const gchar *name, gboolean declaration, gboolean case_sensitive,
MatchType match_type, GPatternSpec *pspec, gchar *utf8_path)
{
const gint forward_types = tm_tag_prototype_t | tm_tag_externvar_t;
gboolean matches = FALSE;
gint type;
type = declaration ? forward_types : tm_tag_max_t - forward_types;
matches = tag->type & type;
if (matches)
{
gchar *name_case;
if (case_sensitive)
name_case = g_strdup(tag->name);
else
name_case = g_utf8_strdown(tag->name, -1);
switch (match_type)
{
case MATCH_FULL:
matches = g_strcmp0(name_case, name) == 0;
break;
case MATCH_PATTERN:
matches = g_pattern_match_string(pspec, name_case);
break;
case MATCH_PREFIX:
matches = g_str_has_prefix(name_case, name);
break;
}
g_free(name_case);
}
if (matches && utf8_path)
{
gchar *utf8_file_name = utils_get_utf8_from_locale(tag->file->file_name);
gchar *relpath;
relpath = get_relative_path(utf8_path, utf8_file_name);
matches = relpath != NULL;
g_free(relpath);
g_free(utf8_file_name);
}
return matches;
}
static void find_tags(const gchar *name, gboolean declaration, gboolean case_sensitive, MatchType match_type, gchar *utf8_path)
{
gchar *utf8_base_path = get_project_base_path();
gchar *locale_base_path = utils_get_locale_from_utf8(utf8_base_path);
GPtrArray *tags_array = geany_data->app->tm_workspace->tags_array;
guint i;
gchar *name_case;
GPatternSpec *pspec;
if (case_sensitive)
name_case = g_strdup(name);
else
name_case = g_utf8_strdown(name, -1);
pspec = g_pattern_spec_new(name_case);
msgwin_set_messages_dir(locale_base_path);
msgwin_clear_tab(MSG_MESSAGE);
for (i = 0; i < tags_array->len; i++) /* TODO: binary search */
{
TMTag *tag = tags_array->pdata[i];
if (match(tag, name_case, declaration, case_sensitive, match_type, pspec, utf8_path))
{
gchar *scopestr = tag->scope ? g_strconcat(tag->scope, "::", NULL) : g_strdup("");
gchar *utf8_fname = utils_get_utf8_from_locale(tag->file->file_name);
gchar *relpath;
relpath = get_relative_path(utf8_base_path, utf8_fname);
msgwin_msg_add(COLOR_BLACK, -1, NULL, "%s:%lu:\n\t[%s]\t %s%s%s", relpath ? relpath : utf8_fname,
tag->line, tm_tag_type_name(tag), scopestr, tag->name, tag->arglist ? tag->arglist : "");
g_free(scopestr);
g_free(relpath);
g_free(utf8_fname);
}
}
msgwin_switch_tab(MSG_MESSAGE, TRUE);
g_free(name_case);
g_pattern_spec_free(pspec);
g_free(utf8_base_path);
g_free(locale_base_path);
}
static void run_open_dialog(GtkDialog *dialog)
{
while (gtk_dialog_run(dialog) == GTK_RESPONSE_ACCEPT)
{
gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
/* try to load the config */
if (! project_load_file_with_session(filename))
{
gchar *utf8_filename = utils_get_utf8_from_locale(filename);
SHOW_ERR1(_("Project file \"%s\" could not be loaded."), utf8_filename);
gtk_widget_grab_focus(GTK_WIDGET(dialog));
g_free(utf8_filename);
g_free(filename);
continue;
}
g_free(filename);
break;
}
}
/* utf8 */
gchar *get_relative_path(const gchar *utf8_parent, const gchar *utf8_descendant)
{
GFile *gf_parent, *gf_descendant;
gchar *locale_parent, *locale_descendant;
gchar *locale_ret, *utf8_ret;
locale_parent = utils_get_locale_from_utf8(utf8_parent);
locale_descendant = utils_get_locale_from_utf8(utf8_descendant);
gf_parent = g_file_new_for_path(locale_parent);
gf_descendant = g_file_new_for_path(locale_descendant);
locale_ret = g_file_get_relative_path(gf_parent, gf_descendant);
utf8_ret = utils_get_utf8_from_locale(locale_ret);
g_object_unref(gf_parent);
g_object_unref(gf_descendant);
g_free(locale_parent);
g_free(locale_descendant);
g_free(locale_ret);
return utf8_ret;
}
static void backupcopy_dir_button_clicked_cb(GtkButton *button, gpointer item)
{
/** TODO add win32_show_pref_file_dialog to the plugin API and use it **/
/*
#ifdef G_OS_WIN32
win32_show_pref_file_dialog(item);
#else
*/
GtkWidget *dialog;
gchar *text;
/* initialize the dialog */
dialog = gtk_file_chooser_dialog_new(_("Select Directory"), NULL,
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
text = utils_get_locale_from_utf8(gtk_entry_get_text(GTK_ENTRY(item)));
if (!EMPTY(text))
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), text);
/* run it */
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
gchar *utf8_filename, *tmp;
tmp = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
utf8_filename = utils_get_utf8_from_locale(tmp);
gtk_entry_set_text(GTK_ENTRY(item), utf8_filename);
g_free(utf8_filename);
g_free(tmp);
}
gtk_widget_destroy(dialog);
}
/* handler that opens the current filetype's configuration file */
static void
open_current_filetype_conf_handler (GtkWidget *widget,
gpointer data)
{
GeanyDocument *doc;
(void)widget;
(void)data;
doc = document_get_current ();
if (DOC_VALID (doc)) {
gchar *path_read;
gchar *path_write;
GError *err = NULL;
path_write = ggd_file_type_manager_get_conf_path (doc->file_type->id,
GGD_PERM_W | GGD_PERM_NOCREAT,
&err);
if (! path_write) {
msgwin_status_add (_("Failed to find configuration file "
"for file type \"%s\": %s"),
doc->file_type->name, err->message);
g_error_free (err);
} else {
gchar *text = NULL;
gchar *path_write_u8;
path_read = ggd_file_type_manager_get_conf_path (doc->file_type->id,
GGD_PERM_R, &err);
if (! path_read) {
text = g_strdup (_(
"# Configuration for this file type doesn't exist yet.\n"
"# To create it, just write it in this file and save it. For the description\n"
"# of the syntax of this file, please refer to the manual.\n"
));
} else {
gchar *content = NULL;
gsize length;
if (! g_file_get_contents (path_read, &content, &length, &err)) {
gchar *display_path_read;
display_path_read = g_filename_display_name (path_read);
g_warning (_("Failed to load file \"%s\": %s"),
display_path_read, err->message);
g_free (display_path_read);
g_error_free (err);
} else {
text = encodings_convert_to_utf8 (content, length, NULL);
g_free (content);
}
g_free (path_read);
}
path_write_u8 = utils_get_utf8_from_locale (path_write);
/* It's no Ruby, but it is the closest one I've found. It has:
* - # comments
* - multi-line double-quoted strings
*/
document_new_file (path_write_u8, filetypes[GEANY_FILETYPES_RUBY], text);
g_free (path_write_u8);
g_free (text);
g_free (path_write);
}
}
}
static void on_swap_header_source(G_GNUC_UNUSED GtkMenuItem * menuitem, G_GNUC_UNUSED gpointer user_data)
{
GSList *header_patterns, *source_patterns;
GeanyDocument *doc;
gboolean known_type = TRUE;
gboolean is_header;
gchar *doc_basename;
doc = document_get_current();
if (!g_prj || !geany_data->app->project || !doc || !doc->file_name)
return;
header_patterns = get_precompiled_patterns(g_prj->header_patterns);
source_patterns = get_precompiled_patterns(g_prj->source_patterns);
doc_basename = g_path_get_basename(doc->file_name);
if (patterns_match(header_patterns, doc_basename))
is_header = TRUE;
else if (patterns_match(source_patterns, doc_basename))
is_header = FALSE;
else
known_type = FALSE;
if (known_type)
{
gboolean swapped;
GSList *elem, *list = NULL;
gint i;
foreach_document(i)
{
gchar *filename;
filename = document_index(i)->file_name;
if (gprj_project_is_in_project(filename))
list = g_slist_prepend(list, filename);
}
swapped = try_swap_header_source(doc->file_name, is_header, list, header_patterns, source_patterns);
g_slist_free(list);
list = NULL;
if (!swapped)
{
gchar *doc_dir;
doc_dir = g_path_get_dirname(doc->file_name);
setptr(doc_dir, utils_get_locale_from_utf8(doc_dir));
list = utils_get_file_list(doc_dir, NULL, NULL);
for (elem = list; elem != NULL; elem = g_slist_next(elem))
{
gchar *full_name;
full_name = g_build_filename(doc_dir, elem->data, NULL);
setptr(full_name, utils_get_utf8_from_locale(full_name));
setptr(elem->data, full_name);
}
swapped = try_swap_header_source(doc->file_name, is_header, list, header_patterns, source_patterns);
g_slist_foreach(list, (GFunc) g_free, NULL);
g_slist_free(list);
g_free(doc_dir);
list = NULL;
}
if (!swapped)
{
g_hash_table_foreach(g_prj->file_tag_table, (GHFunc) get_project_file_list, &list);
try_swap_header_source(doc->file_name, is_header, list, header_patterns, source_patterns);
g_slist_free(list);
}
}
g_free(doc_basename);
g_slist_foreach(header_patterns, (GFunc) g_pattern_spec_free, NULL);
g_slist_free(header_patterns);
g_slist_foreach(source_patterns, (GFunc) g_pattern_spec_free, NULL);
g_slist_free(source_patterns);
}
