static void setup_paths(void)
{
gchar *data_dir;
gchar *doc_dir;
/* set paths */
#ifdef G_OS_WIN32
/* use the installation directory(the one where geany.exe is located) as the base for the
* documentation and data files */
gchar *install_dir = win32_get_installation_dir();
data_dir = g_build_filename(install_dir, "data", NULL); /* e.g. C:\Program Files\geany\data */
doc_dir = g_build_filename(install_dir, "doc", NULL);
change_working_directory_on_windows(install_dir);
g_free(install_dir);
#else
data_dir = g_build_filename(GEANY_DATADIR, "geany", NULL); /* e.g. /usr/share/geany */
doc_dir = g_build_filename(GEANY_DOCDIR, "html", NULL);
#endif
/* convert path names to locale encoding */
app->datadir = utils_get_locale_from_utf8(data_dir);
app->docdir = utils_get_locale_from_utf8(doc_dir);
g_free(data_dir);
g_free(doc_dir);
}
void open_file(gchar *utf8_name)
{
gchar *name;
GeanyDocument *doc;
name = utils_get_locale_from_utf8(utf8_name);
doc = document_find_by_filename(utf8_name);
if (!doc)
{
document_open_file(name, FALSE, NULL, NULL);
}
else
{
GtkNotebook *notebook;
gint page_num;
notebook = GTK_NOTEBOOK(geany->main_widgets->notebook);
page_num = gtk_notebook_page_num(notebook, GTK_WIDGET(doc->editor->sci));
gtk_notebook_set_current_page(notebook, page_num);
}
g_free(name);
}
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 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 void find_file(GtkTreeIter *iter)
{
gchar *pattern_str = NULL;
gboolean case_sensitive, is_full_path;
gchar *utf8_path = build_path(iter);
if (show_dialog_find_file(iter ? utf8_path : NULL, &pattern_str, &case_sensitive, &is_full_path) == GTK_RESPONSE_ACCEPT)
{
gchar *utf8_base_path = get_project_base_path();
gchar *locale_base_path = utils_get_locale_from_utf8(utf8_base_path);
GPatternSpec *pattern;
if (!case_sensitive)
SETPTR(pattern_str, g_utf8_strdown(pattern_str, -1));
pattern = g_pattern_spec_new(pattern_str);
msgwin_clear_tab(MSG_MESSAGE);
msgwin_set_messages_dir(locale_base_path);
find_file_recursive(iter, case_sensitive, is_full_path, pattern);
msgwin_switch_tab(MSG_MESSAGE, TRUE);
g_free(utf8_base_path);
g_free(locale_base_path);
g_pattern_spec_free(pattern);
}
g_free(pattern_str);
g_free(utf8_path);
}
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);
}
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);
}
static void append_startup(const char *command, const gchar *value)
{
if (value && *value)
{
char *locale = utils_get_locale_from_utf8(value);
g_string_append_printf(commands, "%s %s\n", command, locale);
g_free(locale);
}
}
static void backupcopy_document_save_cb(GObject *obj, GeanyDocument *doc, gpointer user_data)
{
FILE *src, *dst;
gchar *locale_filename_src;
gchar *locale_filename_dst;
gchar *basename_src;
gchar *dir_parts_src;
gchar *stamp;
gchar buf[512];
if (! enable_backupcopy)
return;
locale_filename_src = utils_get_locale_from_utf8(doc->file_name);
if ((src = g_fopen(locale_filename_src, "r")) == NULL)
{
/* it's unlikely that this happens */
ui_set_statusbar(FALSE, _("Backup Copy: File could not be read (%s)."),
g_strerror(errno));
g_free(locale_filename_src);
return;
}
stamp = utils_get_date_time(backupcopy_time_fmt, NULL);
basename_src = g_path_get_basename(locale_filename_src);
dir_parts_src = backupcopy_create_dir_parts(locale_filename_src);
locale_filename_dst = g_strconcat(
backupcopy_backup_dir, G_DIR_SEPARATOR_S,
dir_parts_src, G_DIR_SEPARATOR_S,
basename_src, ".", stamp, NULL);
g_free(basename_src);
g_free(dir_parts_src);
if ((dst = g_fopen(locale_filename_dst, "wb")) == NULL)
{
ui_set_statusbar(FALSE, _("Backup Copy: File could not be saved (%s)."),
g_strerror(errno));
g_free(locale_filename_src);
g_free(locale_filename_dst);
g_free(stamp);
fclose(src);
return;
}
while (fgets(buf, sizeof(buf), src) != NULL)
{
fputs(buf, dst);
}
fclose(src);
fclose(dst);
g_free(locale_filename_src);
g_free(locale_filename_dst);
g_free(stamp);
}
/* Returns: the full filename in locale encoding. */
static gchar *get_tree_path_filename(GtkTreePath *treepath)
{
GtkTreeModel *model = GTK_TREE_MODEL(file_store);
GtkTreeIter iter;
gchar *name;
gtk_tree_model_get_iter(model, &iter, treepath);
gtk_tree_model_get(model, &iter, FILEVIEW_COLUMN_NAME, &name, -1);
setptr(name, utils_get_locale_from_utf8(name));
setptr(name, get_full_path(g_current_project->path, name));
return name;
}
/* 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;
}
/* Write the project settings as well as the project session files into its configuration files.
* emit_signal defines whether the project-save signal should be emitted. When write_config()
* is called while closing a project, this is used to skip emitting the signal because
* project-close will be emitted afterwards.
* Returns: TRUE if project file was written successfully. */
static gboolean write_config(gboolean emit_signal)
{
GeanyProject *p;
GKeyFile *config;
gchar *filename;
gchar *data;
gboolean ret = FALSE;
GSList *node;
g_return_val_if_fail(app->project != NULL, FALSE);
p = app->project;
config = g_key_file_new();
/* try to load an existing config to keep manually added comments */
filename = utils_get_locale_from_utf8(p->file_name);
g_key_file_load_from_file(config, filename, G_KEY_FILE_NONE, NULL);
foreach_slist(node, stash_groups)
stash_group_save_to_key_file(node->data, config);
g_key_file_set_string(config, "project", "name", p->name);
g_key_file_set_string(config, "project", "base_path", p->base_path);
if (p->description)
g_key_file_set_string(config, "project", "description", p->description);
if (p->file_patterns)
g_key_file_set_string_list(config, "project", "file_patterns",
(const gchar**) p->file_patterns, g_strv_length(p->file_patterns));
g_key_file_set_integer(config, "long line marker", "long_line_behaviour", p->long_line_behaviour);
g_key_file_set_integer(config, "long line marker", "long_line_column", p->long_line_column);
/* store the session files into the project too */
if (project_prefs.project_session)
configuration_save_session_files(config);
build_save_menu(config, (gpointer)p, GEANY_BCS_PROJ);
if (emit_signal)
{
g_signal_emit_by_name(geany_object, "project-save", config);
}
/* write the file */
data = g_key_file_to_data(config, NULL, NULL);
ret = (utils_write_file(filename, data) == 0);
g_free(data);
g_free(filename);
g_key_file_free(config);
return ret;
}
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);
}
char *debug_send_evaluate(char token, gint scid, const gchar *expr)
{
char *locale = utils_get_locale_from_utf8(expr);
GString *escaped = g_string_sized_new(strlen(locale));
const char *s;
for (s = locale; *s; s++)
{
if (*s == '"' || *s == '\\')
g_string_append_c(escaped, '\\');
g_string_append_c(escaped, *s);
}
debug_send_format(F, "0%c%d-data-evaluate-expression \"%s\"", token, scid, escaped->str);
g_string_free(escaped, TRUE);
return locale;
}
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 on_command_send_button_clicked(G_GNUC_UNUSED GtkButton *button,
G_GNUC_UNUSED gpointer gdata)
{
gchar *text = utils_text_buffer_get_text(command_text, -1);
const gchar *start;
char *locale;
thread_synchronize();
utils_strchrepl(text, '\n', ' ');
gtk_text_buffer_set_text(command_text, text, -1);
start = utils_skip_spaces(text);
locale = gtk_toggle_button_get_active(command_locale) ?
utils_get_locale_from_utf8(start) : g_strdup(start);
debug_send_command(N, locale);
g_free(locale);
gtk_widget_hide(command_dialog);
if (*start)
{
GtkTreePath *path;
GtkTreeIter iter;
gchar *display = g_strdup(start);
/* from ui_combo_box_add_to_history() */
if (store_find(command_store, &iter, COMMAND_TEXT, start))
scp_tree_store_remove(command_store, &iter);
if (strlen(display) >= 273)
strcpy(display + 270, _("\342\200\246")); /* For translators: ellipsis */
scp_tree_store_prepend(command_store, &iter, NULL);
scp_tree_store_set(command_store, &iter, COMMAND_DISPLAY, display, COMMAND_TEXT,
start, COMMAND_LOCALE, gtk_toggle_button_get_active(command_locale), -1);
g_free(display);
path = gtk_tree_path_new_from_indices(15, -1);
if (scp_tree_store_get_iter(command_store, &iter, path))
scp_tree_store_remove(command_store, &iter);
gtk_tree_path_free(path);
}
g_free(text);
}
void open_file(gchar *utf8_name)
{
gchar *name;
GeanyDocument *doc;
name = utils_get_locale_from_utf8(utf8_name);
doc = document_find_by_filename(utf8_name);
if (!doc)
doc = document_open_file(name, FALSE, NULL, NULL);
else
{
gtk_notebook_set_current_page(GTK_NOTEBOOK(geany->main_widgets->notebook),
document_get_notebook_page(doc));
}
if (doc)
gtk_widget_grab_focus(GTK_WIDGET(doc->editor->sci));
g_free(name);
}
static void handle_input_filename(const gchar *buf)
{
gchar *utf8_filename, *locale_filename;
/* we never know how the input is encoded, so do the best auto detection we can */
if (! g_utf8_validate(buf, -1, NULL))
utf8_filename = encodings_convert_to_utf8(buf, -1, NULL);
else
utf8_filename = g_strdup(buf);
locale_filename = utils_get_locale_from_utf8(utf8_filename);
if (locale_filename)
{
if (g_str_has_suffix(locale_filename, ".geany"))
main_load_project_from_command_line(locale_filename, TRUE);
else
main_handle_filename(locale_filename);
}
g_free(utf8_filename);
g_free(locale_filename);
}
/* Tries to parse strings of the file:line style, allowing line field to be missing
* * filename is filled with the filename, should be freed
* * line is filled with the line number or -1 */
static void msgwin_parse_generic_line(const gchar *string, gchar **filename, gint *line)
{
gchar **fields;
gboolean incertain = TRUE; /* whether we're reasonably certain of the result */
*filename = NULL;
*line = -1;
fields = g_strsplit(string, ":", 2);
/* extract the filename */
if (fields[0] != NULL)
{
*filename = utils_get_locale_from_utf8(fields[0]);
if (msgwindow.messages_dir != NULL)
make_absolute(filename, msgwindow.messages_dir);
/* now the line */
if (fields[1] != NULL)
{
gchar *end;
*line = strtol(fields[1], &end, 10);
if (end == fields[1])
*line = -1;
else if (*end == ':' || g_ascii_isspace(*end))
{ /* if we have a blank or a separator right after the number, assume we really got a
* filename (it's a grep-like syntax) */
incertain = FALSE;
}
}
/* if we aren't sure we got a supposedly correct filename, check it */
if (incertain && ! g_file_test(*filename, G_FILE_TEST_EXISTS))
{
SETPTR(*filename, NULL);
*line = -1;
}
}
g_strfreev(fields);
}
/* Ensures utf8_dir exists and is writable and
* set backup_dir to the locale encoded form of utf8_dir */
static gboolean backupcopy_set_backup_dir(const gchar *utf8_dir)
{
gchar *tmp;
if (G_UNLIKELY(EMPTY(utf8_dir)))
return FALSE;
tmp = utils_get_locale_from_utf8(utf8_dir);
if (! g_path_is_absolute(tmp) ||
! g_file_test(tmp, G_FILE_TEST_EXISTS) ||
! g_file_test(tmp, G_FILE_TEST_IS_DIR))
{
g_free(tmp);
return FALSE;
}
/** TODO add utils_is_file_writeable() to the plugin API and make use of it **/
SETPTR(backupcopy_backup_dir, tmp);
return TRUE;
}
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);
}
static void workspace_add_tag(gchar *filename, TagObject *obj, gpointer foo)
{
TMWorkObject *tm_obj = NULL;
if (!document_find_by_filename(filename))
{
gchar *locale_filename;
locale_filename = utils_get_locale_from_utf8(filename);
tm_obj = tm_source_file_new(locale_filename, FALSE, filetypes_detect_from_file(filename)->name);
g_free(locale_filename);
if (tm_obj)
{
tm_workspace_add_object(tm_obj);
tm_source_file_update(tm_obj, TRUE, FALSE, TRUE);
}
}
if (obj->tag)
tm_workspace_remove_object(obj->tag, TRUE, TRUE);
obj->tag = tm_obj;
}
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);
}
/* Verifies data for New & Properties dialogs.
* Returns: FALSE if the user needs to change any data. */
static gboolean update_config(const PropertyDialogElements *e, gboolean new_project)
{
const gchar *name, *file_name, *base_path;
gchar *locale_filename;
gsize name_len;
gint err_code = 0;
GeanyProject *p;
g_return_val_if_fail(e != NULL, TRUE);
name = gtk_entry_get_text(GTK_ENTRY(e->name));
name_len = strlen(name);
if (name_len == 0)
{
SHOW_ERR(_("The specified project name is too short."));
gtk_widget_grab_focus(e->name);
return FALSE;
}
else if (name_len > MAX_NAME_LEN)
{
SHOW_ERR1(_("The specified project name is too long (max. %d characters)."), MAX_NAME_LEN);
gtk_widget_grab_focus(e->name);
return FALSE;
}
if (new_project)
file_name = gtk_entry_get_text(GTK_ENTRY(e->file_name));
else
file_name = gtk_label_get_text(GTK_LABEL(e->file_name));
if (G_UNLIKELY(! NZV(file_name)))
{
SHOW_ERR(_("You have specified an invalid project filename."));
gtk_widget_grab_focus(e->file_name);
return FALSE;
}
locale_filename = utils_get_locale_from_utf8(file_name);
base_path = gtk_entry_get_text(GTK_ENTRY(e->base_path));
if (NZV(base_path))
{ /* check whether the given directory actually exists */
gchar *locale_path = utils_get_locale_from_utf8(base_path);
if (! g_path_is_absolute(locale_path))
{ /* relative base path, so add base dir of project file name */
gchar *dir = g_path_get_dirname(locale_filename);
SETPTR(locale_path, g_strconcat(dir, G_DIR_SEPARATOR_S, locale_path, NULL));
g_free(dir);
}
if (! g_file_test(locale_path, G_FILE_TEST_IS_DIR))
{
gboolean create_dir;
create_dir = dialogs_show_question_full(NULL, GTK_STOCK_OK, GTK_STOCK_CANCEL,
_("Create the project's base path directory?"),
_("The path \"%s\" does not exist."),
base_path);
if (create_dir)
err_code = utils_mkdir(locale_path, TRUE);
if (! create_dir || err_code != 0)
{
if (err_code != 0)
SHOW_ERR1(_("Project base directory could not be created (%s)."),
g_strerror(err_code));
gtk_widget_grab_focus(e->base_path);
utils_free_pointers(2, locale_path, locale_filename, NULL);
return FALSE;
}
}
g_free(locale_path);
}
/* finally test whether the given project file can be written */
if ((err_code = utils_is_file_writable(locale_filename)) != 0 ||
(err_code = g_file_test(locale_filename, G_FILE_TEST_IS_DIR) ? EISDIR : 0) != 0)
{
SHOW_ERR1(_("Project file could not be written (%s)."), g_strerror(err_code));
gtk_widget_grab_focus(e->file_name);
g_free(locale_filename);
return FALSE;
}
g_free(locale_filename);
if (app->project == NULL)
{
create_project();
new_project = TRUE;
}
p = app->project;
SETPTR(p->name, g_strdup(name));
SETPTR(p->file_name, g_strdup(file_name));
/* use "." if base_path is empty */
SETPTR(p->base_path, g_strdup(NZV(base_path) ? base_path : "./"));
if (! new_project) /* save properties specific fields */
{
GtkTextIter start, end;
GtkTextBuffer *buffer;
GeanyDocument *doc = document_get_current();
GeanyBuildCommand *oldvalue;
GeanyFiletype *ft = doc ? doc->file_type : NULL;
GtkWidget *widget;
gchar *tmp;
GString *str;
GSList *node;
/* get and set the project description */
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(e->description));
gtk_text_buffer_get_start_iter(buffer, &start);
gtk_text_buffer_get_end_iter(buffer, &end);
SETPTR(p->description, g_strdup(gtk_text_buffer_get_text(buffer, &start, &end, FALSE)));
foreach_slist(node, stash_groups)
stash_group_update(node->data, e->dialog);
/* read the project build menu */
oldvalue = ft ? ft->projfilecmds : NULL;
build_read_project(ft, e->build_properties);
if (ft != NULL && ft->projfilecmds != oldvalue && ft->project_list_entry < 0)
{
if (p->build_filetypes_list == NULL)
p->build_filetypes_list = g_ptr_array_new();
ft->project_list_entry = p->build_filetypes_list->len;
g_ptr_array_add(p->build_filetypes_list, ft);
}
build_menu_update(doc);
widget = ui_lookup_widget(e->dialog, "radio_long_line_disabled_project");
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
p->long_line_behaviour = 0;
else
{
widget = ui_lookup_widget(e->dialog, "radio_long_line_default_project");
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
p->long_line_behaviour = 1;
else
/* "Custom" radio button must be checked */
p->long_line_behaviour = 2;
}
widget = ui_lookup_widget(e->dialog, "spin_long_line_project");
p->long_line_column = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
apply_editor_prefs();
/* get and set the project file patterns */
tmp = g_strdup(gtk_entry_get_text(GTK_ENTRY(e->patterns)));
g_strfreev(p->file_patterns);
g_strstrip(tmp);
str = g_string_new(tmp);
do {} while (utils_string_replace_all(str, " ", " "));
p->file_patterns = g_strsplit(str->str, " ", -1);
g_string_free(str, TRUE);
g_free(tmp);
}
update_ui();
return TRUE;
}
void project_open(void)
{
const gchar *dir = local_prefs.project_file_path;
#ifdef G_OS_WIN32
gchar *file;
#else
GtkWidget *dialog;
GtkFileFilter *filter;
gchar *locale_path;
#endif
if (! project_ask_close()) return;
#ifdef G_OS_WIN32
file = win32_show_project_open_dialog(main_widgets.window, _("Open Project"), dir, FALSE, TRUE);
if (file != NULL)
{
/* try to load the config */
if (! project_load_file_with_session(file))
{
SHOW_ERR1(_("Project file \"%s\" could not be loaded."), file);
}
g_free(file);
}
#else
dialog = gtk_file_chooser_dialog_new(_("Open Project"), GTK_WINDOW(main_widgets.window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
gtk_widget_set_name(dialog, "GeanyDialogProject");
/* set default Open, so pressing enter can open multiple files */
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(dialog), TRUE);
gtk_window_set_type_hint(GTK_WINDOW(dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window));
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
/* add FileFilters */
filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, _("All files"));
gtk_file_filter_add_pattern(filter, "*");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, _("Project files"));
gtk_file_filter_add_pattern(filter, "*." GEANY_PROJECT_EXT);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
locale_path = utils_get_locale_from_utf8(dir);
if (g_file_test(locale_path, G_FILE_TEST_EXISTS) &&
g_file_test(locale_path, G_FILE_TEST_IS_DIR))
{
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), locale_path);
}
g_free(locale_path);
gtk_widget_show_all(dialog);
run_open_dialog(GTK_DIALOG(dialog));
gtk_widget_destroy(GTK_WIDGET(dialog));
#endif
}
/* Callback for sending file as attachment */
static void
send_as_attachment(G_GNUC_UNUSED GtkMenuItem *menuitem, G_GNUC_UNUSED gpointer gdata)
{
GeanyDocument *doc;
gchar *locale_filename = NULL;
gchar *command = NULL;
GError *error = NULL;
GString *cmd_str = NULL;
gchar *data;
doc = document_get_current();
if (doc->file_name == NULL)
{
dialogs_show_save_as();
}
else
{
document_save_file(doc, FALSE);
}
if (doc->file_name != NULL)
{
if (mailer)
{
locale_filename = utils_get_locale_from_utf8(doc->file_name);
cmd_str = g_string_new(mailer);
if ((use_address_dialog == TRUE) && (g_strrstr(mailer, "%r") != NULL))
{
GKeyFile *config = NULL;
gchar *config_dir = NULL;
gchar *input = dialogs_show_input(_("Recipient's Address"),
GTK_WINDOW(geany->main_widgets->window),
_("Enter the recipient's e-mail address:"),
address);
if (input)
{
config = g_key_file_new();
g_key_file_load_from_file(config, config_file, G_KEY_FILE_NONE, NULL);
g_free(address);
address = input;
g_key_file_set_string(config, "tools", "address", address);
}
else
{
g_string_free(cmd_str, TRUE);
g_free(locale_filename);
return;
}
config_dir = g_path_get_dirname(config_file);
if (! g_file_test(config_dir, G_FILE_TEST_IS_DIR) &&
utils_mkdir(config_dir, TRUE) != 0)
{
dialogs_show_msgbox(GTK_MESSAGE_ERROR,
_("Plugin configuration directory could not be created."));
}
else
{
/* write config to file */
data = g_key_file_to_data(config, NULL, NULL);
utils_write_file(config_file, data);
g_free(data);
}
g_key_file_free(config);
g_free(config_dir);
}
if (! utils_string_replace_all(cmd_str, "%f", locale_filename))
ui_set_statusbar(FALSE,
_("Filename placeholder not found. The executed command might have failed."));
if (use_address_dialog == TRUE && address != NULL)
{
if (! utils_string_replace_all(cmd_str, "%r", address))
ui_set_statusbar(FALSE,
_("Recipient address placeholder not found. The executed command might have failed."));
}
else
{
/* Removes %r if option was not activ but was included into command */
utils_string_replace_all(cmd_str, "%r", "");
}
utils_string_replace_all(cmd_str, "%b", g_path_get_basename(locale_filename));
command = g_string_free(cmd_str, FALSE);
g_spawn_command_line_async(command, &error);
if (error != NULL)
{
ui_set_statusbar(FALSE, _("Could not execute mailer. Please check your configuration."));
g_error_free(error);
}
g_free(locale_filename);
g_free(command);
}
else
{
ui_set_statusbar(FALSE, _("Please define a mail client first."));
}
}
else
{
ui_set_statusbar(FALSE, _("File has to be saved before sending."));
}
}
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));
}
static void create_file_save_as_dialog(const gchar *extension, ExportFunc func,
gboolean show_zoom_level_checkbox)
{
GtkWidget *dialog, *vbox;
GeanyDocument *doc;
ExportInfo *exi;
g_return_if_fail(extension != NULL);
doc = document_get_current();
g_return_if_fail(doc != NULL);
exi = g_new(ExportInfo, 1);
exi->doc = doc;
exi->export_func = func;
exi->have_zoom_level_checkbox = FALSE;
dialog = gtk_file_chooser_dialog_new(_("Export File"), GTK_WINDOW(geany->main_widgets->window),
GTK_FILE_CHOOSER_ACTION_SAVE, NULL, NULL);
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(dialog), TRUE);
gtk_window_set_type_hint(GTK_WINDOW(dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_widget_set_name(dialog, "GeanyExportDialog");
gtk_dialog_add_buttons(GTK_DIALOG(dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
/* file chooser extra widget */
vbox = gtk_vbox_new(FALSE, 0);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dialog), vbox);
{
GtkWidget *check_line_numbers;
check_line_numbers = gtk_check_button_new_with_mnemonic(_("_Insert line numbers"));
gtk_widget_set_tooltip_text(check_line_numbers,
_("Insert line numbers before each line in the exported document"));
gtk_box_pack_start(GTK_BOX(vbox), check_line_numbers, FALSE, FALSE, 0);
gtk_widget_show_all(vbox);
ui_hookup_widget(dialog, check_line_numbers, "check_line_numbers");
}
if (show_zoom_level_checkbox)
{
GtkWidget *check_zoom_level;
check_zoom_level = gtk_check_button_new_with_mnemonic(_("_Use current zoom level"));
gtk_widget_set_tooltip_text(check_zoom_level,
_("Renders the font size of the document together with the current zoom level"));
gtk_box_pack_start(GTK_BOX(vbox), check_zoom_level, FALSE, FALSE, 0);
gtk_widget_show_all(vbox);
ui_hookup_widget(dialog, check_zoom_level, "check_zoom_level");
exi->have_zoom_level_checkbox = TRUE;
}
g_signal_connect(dialog, "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL);
g_signal_connect(dialog, "response", G_CALLBACK(on_file_save_dialog_response), exi);
gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(geany->main_widgets->window));
/* if the current document has a filename we use it as the default. */
gtk_file_chooser_unselect_all(GTK_FILE_CHOOSER(dialog));
if (doc->file_name != NULL)
{
gchar *base_name = g_path_get_basename(doc->file_name);
gchar *file_name;
gchar *locale_filename;
gchar *locale_dirname;
const gchar *suffix = "";
if (g_str_has_suffix(doc->file_name, extension))
suffix = "_export";
file_name = g_strconcat(base_name, suffix, extension, NULL);
locale_filename = utils_get_locale_from_utf8(doc->file_name);
locale_dirname = g_path_get_dirname(locale_filename);
/* set the current name to base_name.html which probably doesn't exist yet so
* gtk_file_chooser_set_filename() can't be used and we need
* gtk_file_chooser_set_current_folder() additionally */
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), locale_dirname);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), file_name);
g_free(locale_dirname);
g_free(locale_filename);
g_free(file_name);
g_free(base_name);
}
else
{
const gchar *default_open_path = geany->prefs->default_open_path;
gchar *fname = g_strconcat(GEANY_STRING_UNTITLED, extension, NULL);
gtk_file_chooser_unselect_all(GTK_FILE_CHOOSER(dialog));
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), fname);
/* use default startup directory(if set) if no files are open */
if (NZV(default_open_path) && g_path_is_absolute(default_open_path))
{
gchar *locale_path = utils_get_locale_from_utf8(default_open_path);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), locale_path);
g_free(locale_path);
}
g_free(fname);
}
gtk_dialog_run(GTK_DIALOG(dialog));
}
static void load_program(void)
{
char *args[] = { utils_get_locale_from_utf8(pref_gdb_executable), (char *) "--quiet",
(char *) "--interpreter=mi2", NULL };
GError *gerror = NULL;
statusbar_update_state(DS_EXTRA_2);
plugin_blink();
while (gtk_events_pending())
gtk_main_iteration();
if (spawn_with_callbacks(NULL, NULL, args, NULL, GDB_SPAWN_FLAGS, obtain_send_channel_cb,
NULL, receive_output_cb, NULL, GDB_BUFFER_SIZE, receive_errors_cb, NULL, 0,
gdb_exit_cb, NULL, &gdb_pid, &gerror))
{
gchar **environment = g_strsplit(program_environment, "\n", -1);
gchar *const *envar;
#ifdef G_OS_UNIX
extern char *slave_pty_name;
#else
GString *escaped = g_string_new(program_executable);
#endif
/* startup */
gdb_state = ACTIVE;
dc_clear();
utils_lock_all(TRUE);
signal(SIGINT, SIG_IGN);
wait_result = 0;
wait_prompt = TRUE;
g_string_truncate(commands, 0);
leading_receive = TRUE;
if (pref_gdb_async_mode)
g_string_append(commands, "-gdb-set target-async on\n");
if (program_non_stop_mode)
g_string_append(commands, "-gdb-set non-stop on\n");
#ifdef G_OS_UNIX
append_startup("010-file-exec-and-symbols", program_executable);
append_startup("-gdb-set inferior-tty", slave_pty_name);
#else /* G_OS_UNIX */
utils_string_replace_all(escaped, "\\", "\\\\");
append_startup("010-file-exec-and-symbols", escaped->str);
g_string_free(escaped, TRUE);
g_string_append(commands, "-gdb-set new-console on\n");
#endif /* G_OS_UNIX */
append_startup("-environment-cd", program_working_dir); /* no escape needed */
append_startup("-exec-arguments", program_arguments);
for (envar = environment; *envar; envar++)
append_startup("-gdb-set environment", *envar);
g_strfreev(environment);
append_startup("011source -v", program_load_script);
g_string_append(commands, "07-list-target-features\n");
breaks_query_async(commands);
if (*program_executable || *program_load_script)
{
debug_load_error = FALSE;
debug_auto_run = debug_auto_exit = program_auto_run_exit;
}
else
debug_auto_run = debug_auto_exit = FALSE;
if (option_open_panel_on_load)
open_debug_panel();
registers_query_names();
}
else
{
show_error(_("%s: %s."), pref_gdb_executable, gerror->message);
g_error_free(gerror);
}
g_free(args[0]);
if (gdb_state == INACTIVE)
statusbar_update_state(DS_INACTIVE);
}
