static void status_changed(GtkPrintOperation *op, gpointer data)
{
gchar *filename = (data != NULL) ? data : GEANY_STRING_UNTITLED;
if (gtk_print_operation_get_status(op) == GTK_PRINT_STATUS_FINISHED_ABORTED)
msgwin_status_add(_("Did not send document %s to the printing subsystem."), filename);
else if (gtk_print_operation_get_status(op) == GTK_PRINT_STATUS_FINISHED)
msgwin_status_add(_("Document %s was sent to the printing subsystem."), filename);
}
static void update_check_result_cb(SoupSession *session,
SoupMessage *msg, gpointer user_data)
{
gint type = GPOINTER_TO_INT(user_data);
/* Checking whether we did get a valid (200) result */
if (msg->status_code == 200)
{
const gchar *remote_version = msg->response_body->data;
if (version_compare(remote_version) == TRUE)
{
gchar *update_msg = g_strdup_printf(
_("There is a more recent version of Geany available: %s"),
remote_version);
dialogs_show_msgbox(GTK_MESSAGE_INFO, "%s", update_msg);
g_message("%s", update_msg);
g_free(update_msg);
}
else
{
const gchar *no_update_msg = _("No newer Geany version available.");
if (type == UPDATECHECK_MANUAL)
{
dialogs_show_msgbox(GTK_MESSAGE_INFO, "%s", no_update_msg);
}
else
{
msgwin_status_add("%s", no_update_msg);
}
g_message("%s", no_update_msg);
}
}
else
{
gchar *error_message = g_strdup_printf(
_("Unable to perform version check.\nError code: %d \nError message: »%s«"),
msg->status_code, msg->reason_phrase);
if (type == UPDATECHECK_MANUAL)
{
dialogs_show_msgbox(GTK_MESSAGE_ERROR, "%s", error_message);
}
else
{
msgwin_status_add("%s", error_message);
}
g_warning("Connection error: Code: %d; Message: %s", msg->status_code, msg->reason_phrase);
g_free(error_message);
}
}
static gboolean
plugin_check_version(GModule *module)
{
gint (*version_check)(gint) = NULL;
g_module_symbol(module, "plugin_version_check", (void *) &version_check);
if (G_UNLIKELY(! version_check))
{
geany_debug("Plugin \"%s\" has no plugin_version_check() function - ignoring plugin!",
g_module_name(module));
return FALSE;
}
else
{
gint result = version_check(GEANY_ABI_VERSION);
if (result < 0)
{
msgwin_status_add(_("The plugin \"%s\" is not binary compatible with this "
"release of Geany - please recompile it."), g_module_name(module));
geany_debug("Plugin \"%s\" is not binary compatible with this "
"release of Geany - recompile it.", g_module_name(module));
return FALSE;
}
if (result > GEANY_API_VERSION)
{
geany_debug("Plugin \"%s\" requires a newer version of Geany (API >= v%d).",
g_module_name(module), result);
return FALSE;
}
}
return TRUE;
}
static void
reindent (GeanyDocument *doc,
GrindIndenter *indenter)
{
if (DOC_VALID (doc)) {
int start;
int end;
ScintillaObject *sci = doc->editor->sci;
if (sci_has_selection (sci)) {
start = sci_get_line_from_position (sci, sci_get_selection_start (sci));
end = sci_get_line_from_position (sci, sci_get_selection_end (sci));
} else {
start = 0;
end = sci_get_line_count (sci);
}
if (start != end) {
g_debug ("Using indenter \"%s\" by \"%s\"",
grind_indenter_get_name (indenter),
grind_indenter_get_author (indenter));
sci_start_undo_action (sci);
if (grind_indenter_indent (indenter, doc,
sci_get_position_from_line (sci, start),
sci_get_line_end_position (sci, end))) {
msgwin_status_add ("Reindented \"%s\"", DOC_FILENAME (doc));
}
sci_end_undo_action (sci);
}
}
}
static void on_recent_menu_item_activate(G_GNUC_UNUSED GtkMenuItem *menuitem, const gchar *name)
{
GtkTreeIter iter;
if (utils_filenamecmp(name, *program_executable ? program_executable :
program_load_script) && program_find(&iter, name))
{
gint id;
char *configfile;
GKeyFile *config = g_key_file_new();
GError *gerror = NULL;
gchar *message;
scp_tree_store_get(recent_programs, &iter, PROGRAM_ID, &id, -1);
configfile = recent_file_name(id);
if (g_key_file_load_from_file(config, configfile, G_KEY_FILE_NONE, &gerror))
{
scp_tree_store_move(recent_programs, &iter, 0);
save_program_settings();
stash_foreach((GFunc) stash_group_load_from_key_file, config);
if ((unsigned) option_inspect_expand > EXPAND_MAX)
option_inspect_expand = 100;
breaks_load(config);
watches_load(config);
inspects_load(config);
registers_load(config);
parse_load(config);
message = g_strdup_printf(_("Loaded debug settings for %s."), name);
program_find(&iter, name);
scp_tree_store_move(recent_programs, &iter, 0);
recent_menu_create();
program_configure();
}
else
{
message = g_strdup_printf(_("Could not load debug settings file %s: %s."),
configfile, gerror->message);
g_error_free(gerror);
}
if (menuitem)
ui_set_statusbar(TRUE, "%s", message);
else
msgwin_status_add("%s", message);
g_free(message);
g_key_file_free(config);
g_free(configfile);
}
}
static void broker_init_failed(void)
{
const gchar *err = enchant_broker_get_error(sc_speller_broker);
gchar *msg = g_strdup_printf(
_("The Enchant library couldn't be initialized (%s)."),
(err != NULL) ? err : _("unknown error (maybe the chosen language is not available)"));
msgwin_status_add("%s", msg);
if (main_is_realized())
/* show dialog only after Geany has been loaded already, i.e. not while starting up */
dialogs_show_msgbox(GTK_MESSAGE_ERROR, "%s", msg);
g_free(msg);
}
/* simple file print using an external tool */
static void print_external(GeanyDocument *doc)
{
gchar *cmdline;
if (doc->file_name == NULL)
return;
if (! NZV(printing_prefs.external_print_cmd))
{
dialogs_show_msgbox(GTK_MESSAGE_ERROR,
_("Please set a print command in the preferences dialog first."));
return;
}
cmdline = g_strdup(printing_prefs.external_print_cmd);
utils_str_replace_all(&cmdline, "%f", doc->file_name);
if (dialogs_show_question(
_("The file \"%s\" will be printed with the following command:\n\n%s"),
doc->file_name, cmdline))
{
GError *error = NULL;
#ifdef G_OS_WIN32
gchar *tmp_cmdline = g_strdup(cmdline);
#else
/* /bin/sh -c emulates the system() call and makes complex commands possible
* but only needed on non-win32 systems due to the lack of win32's shell capabilities */
gchar *tmp_cmdline = g_strconcat("/bin/sh -c \"", cmdline, "\"", NULL);
#endif
if (! g_spawn_command_line_async(tmp_cmdline, &error))
{
dialogs_show_msgbox(GTK_MESSAGE_ERROR,
_("Printing of \"%s\" failed (return code: %s)."),
doc->file_name, error->message);
g_error_free(error);
}
else
{
msgwin_status_add(_("File %s printed."), doc->file_name);
}
g_free(tmp_cmdline);
}
g_free(cmdline);
}
static void on_recent_menu_item_activate(G_GNUC_UNUSED GtkMenuItem *menuitem, const gchar *name)
{
RecentProgram *recent = (RecentProgram *) array_find(recent_programs, name, TRUE);
if (recent && utils_filenamecmp(recent->name, *program_executable ? program_executable :
program_load_script))
{
char *configfile = recent_file_name(recent->id);
GKeyFile *config = g_key_file_new();
GError *gerror = NULL;
gchar *message;
if (g_key_file_load_from_file(config, configfile, G_KEY_FILE_NONE, &gerror))
{
save_program_settings();
recent = (RecentProgram *) array_find(recent_programs, name, TRUE);
stash_foreach((GFunc) stash_group_load_from_key_file, config);
if ((unsigned) option_inspect_expand > EXPAND_MAX)
option_inspect_expand = 100;
breaks_load(config);
watches_load(config);
inspects_load(config);
parse_load(config);
message = g_strdup_printf(_("Loaded debug settings for %s."), recent->name);
g_array_insert_vals(recent_programs, 0, ++recent, 1);
array_remove(recent_programs, recent);
recent_menu_create();
program_configure();
}
else
{
message = g_strdup_printf(_("Could not load debug settings file %s: %s."),
configfile, gerror->message);
g_error_free(gerror);
}
if (menuitem)
ui_set_statusbar(TRUE, "%s", message);
else
msgwin_status_add("%s", message);
g_free(message);
g_key_file_free(config);
g_free(configfile);
}
}
void prefs_init(void)
{
guint i;
MarkerStyle *style = pref_marker_styles;
StashGroup *group;
char *configdir = g_build_filename(geany->app->configdir, "plugins", "scope", NULL);
char *configfile = prefs_file_name();
GKeyFile *config = g_key_file_new();
gchar *tmp_string;
group = stash_group_new("scope");
stash_group_add_string(group, &pref_gdb_executable, "gdb_executable", "gdb");
stash_group_add_boolean(group, &pref_gdb_async_mode, "gdb_async_mode", FALSE);
stash_group_add_integer(group, &pref_gdb_buffer_length, "gdb_buffer_length", 16383);
stash_group_add_integer(group, &pref_gdb_wait_death, "gdb_wait_death", 20);
#ifndef G_OS_UNIX
stash_group_add_integer(group, &pref_gdb_send_interval, "gdb_send_interval", 5);
stash_group_add_boolean(group, &pref_async_break_bugs, "async_break_bugs", TRUE);
#endif
stash_group_add_boolean(group, &pref_auto_view_source, "auto_view_source", FALSE);
stash_group_add_boolean(group, &pref_keep_exec_point, "keep_exec_point", FALSE);
stash_group_add_integer(group, &pref_visual_beep_length, "visual_beep_length", 25);
#ifdef G_OS_UNIX
stash_group_add_boolean(group, &pref_debug_console_vte, "debug_console_vte", TRUE);
#endif
stash_group_add_integer(group, &pref_sci_marker_1st, "sci_marker_first", 17);
stash_group_add_integer(group, &pref_sci_caret_policy, "sci_caret_policy", CARET_SLOP |
CARET_JUMPS | CARET_EVEN);
stash_group_add_integer(group, &pref_sci_caret_slop, "sci_caret_slop", 3);
stash_group_add_boolean(group, &pref_unmark_current_line, "unmark_current_line", FALSE);
stash_group_add_boolean(group, &pref_scope_goto_cursor, "scope_run_to_cursor", FALSE);
stash_group_add_boolean(group, &pref_seek_with_navqueue, "seek_with_navqueue", FALSE);
stash_group_add_integer(group, &pref_panel_tab_pos, "panel_tab_pos", GTK_POS_TOP);
stash_group_add_integer(group, &pref_show_recent_items, "show_recent_items", 10);
stash_group_add_integer(group, &pref_show_toolbar_items, "show_toolbar_items", 0xFF);
stash_group_add_integer(group, &pref_tooltips_fail_action, "tooltips_fail_action", 0);
stash_group_add_integer(group, &pref_tooltips_send_delay, "tooltips_send_delay", 25);
stash_group_add_integer(group, &pref_tooltips_length, "tooltips_length", 2048);
stash_group_add_integer(group, &pref_memory_bytes_per_line, "memory_line_bytes", 16);
stash_group_add_string(group, &pref_memory_font, "memory_font", "");
scope_group = group;
config_item = ui_add_config_file_menu_item(configfile, NULL, NULL);
plugin_signal_connect(geany_plugin, NULL, "document-save", FALSE,
G_CALLBACK(on_document_save), NULL);
group = stash_group_new("terminal");
#ifdef G_OS_UNIX
stash_group_add_boolean(group, &pref_terminal_save_pos, "save_pos", TRUE);
stash_group_add_boolean(group, &pref_terminal_padding, "padding", TRUE);
stash_group_add_integer(group, &pref_terminal_window_x, "window_x", 70);
stash_group_add_integer(group, &pref_terminal_window_y, "window_y", 50);
stash_group_add_integer(group, &pref_terminal_width, "width", 640);
stash_group_add_integer(group, &pref_terminal_height, "height", 480);
#endif /* G_OS_UNIX */
terminal_group = group;
for (i = 0; i < MARKER_COUNT; i++, style++)
{
group = stash_group_new(style->name);
stash_group_add_integer(group, &style->mark, "mark", style->default_mark);
stash_group_add_integer(group, &style->alpha, "alpha", style->default_alpha);
marker_group[i] = group;
}
g_key_file_load_from_file(config, configfile, G_KEY_FILE_NONE, NULL);
load_scope_prefs(config);
pref_sci_marker_first = pref_sci_marker_1st;
prefs_configure();
program_load_config(config);
if (pref_panel_tab_pos == GTK_POS_LEFT || pref_panel_tab_pos == GTK_POS_RIGHT)
{
gtk_label_set_label(GTK_LABEL(get_widget("program_terminal_label")), _("Program"));
gtk_label_set_label(GTK_LABEL(get_widget("break_view_label")), _("Breaks"));
gtk_label_set_label(GTK_LABEL(get_widget("debug_console_label")), _("Console"));
}
if (!g_file_test(configfile, G_FILE_TEST_IS_REGULAR))
{
gint error = utils_mkdir(configdir, TRUE);
if (error)
msgwin_status_add(_("Scope: %s: %s."), configdir, g_strerror(error));
else
{
save_scope_prefs(config);
if (utils_key_file_write_to_file(config, configfile))
msgwin_status_add(_("Scope: created configuration file."));
}
}
g_key_file_free(config);
g_free(configfile);
g_free(configdir);
configfile = g_build_filename(geany_data->app->configdir, "geany.conf", NULL);
config = g_key_file_new();
g_key_file_load_from_file(config, configfile, G_KEY_FILE_NONE, NULL);
pref_vte_blinken = utils_get_setting_boolean(config, "VTE", "cursor_blinks", FALSE);
pref_vte_emulation = utils_get_setting_string(config, "VTE", "emulation", "xterm");
pref_vte_font = utils_get_setting_string(config, "VTE", "font", "Monospace 10");
pref_vte_scrollback = utils_get_setting_integer(config, "VTE", "scrollback_lines", 500);
tmp_string = utils_get_setting_string(config, "VTE", "colour_fore", "#ffffff");
gdk_color_parse(tmp_string, &pref_vte_colour_fore);
g_free(tmp_string);
tmp_string = utils_get_setting_string(config, "VTE", "colour_back", "#000000");
gdk_color_parse(tmp_string, &pref_vte_colour_back);
g_free(tmp_string);
g_key_file_free(config);
g_free(configfile);
}
void plugin_init(G_GNUC_UNUSED GeanyData *gdata)
{
GeanyKeyGroup *scope_key_group;
char *gladefile = g_build_filename(PLUGINDATADIR, "scope.glade", NULL);
GError *gerror = NULL;
GtkWidget *menubar1 = find_widget(geany->main_widgets->window, "menubar1");
guint item;
const MenuKey *menu_key = debug_menu_keys;
ToolItem *tool_item = toolbar_items;
const ScopeCallback *scb;
main_locale_init(LOCALEDIR, GETTEXT_PACKAGE);
scope_key_group = plugin_set_key_group(geany_plugin, "scope", COUNT_KB, NULL);
builder = gtk_builder_new();
gtk_builder_set_translation_domain(builder, GETTEXT_PACKAGE);
scp_tree_store_register_dynamic();
if (!gtk_builder_add_from_file(builder, gladefile, &gerror))
{
msgwin_status_add(_("Scope: %s."), gerror->message);
g_warning(_("Scope: %s."), gerror->message);
g_error_free(gerror);
g_object_unref(builder);
builder = NULL;
}
g_free(gladefile);
if (!builder)
return;
/* interface */
#ifndef G_OS_UNIX
gtk_widget_hide(get_widget("terminal_show"));
#endif
debug_item = get_widget("debug_item");
if (menubar1)
gtk_menu_shell_insert(GTK_MENU_SHELL(menubar1), debug_item, DEBUG_MENU_ITEM_POS);
else
gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), debug_item);
menu_connect("debug_menu", &debug_menu_info, NULL);
ui_add_document_sensitive(get_widget("scope_reset_markers"));
ui_add_document_sensitive(get_widget("scope_cleanup_files"));
for (item = 0; item < EVALUATE_KB; item++, menu_key++)
{
keybindings_set_item(scope_key_group, item, on_scope_key, 0, 0, menu_key->name,
_(menu_key->label), debug_menu_items[item].widget);
}
geany_statusbar = GTK_STATUSBAR(gtk_widget_get_parent(geany->main_widgets->progressbar));
debug_statusbar = get_widget("debug_statusbar");
debug_state_label = GTK_LABEL(get_widget("debug_state_label"));
gtk_box_pack_end(GTK_BOX(geany_statusbar), debug_statusbar, FALSE, FALSE, 0);
debug_panel = get_widget("debug_panel");
gtk_notebook_append_page(GTK_NOTEBOOK(geany->main_widgets->message_window_notebook),
debug_panel, get_widget("debug_label"));
/* startup */
gtk216_init();
program_init();
prefs_init();
conterm_init();
inspect_init();
register_init();
parse_init();
debug_init();
views_init();
thread_init();
break_init();
watch_init();
stack_init();
local_init();
memory_init();
menu_init();
menu_set_popup_keybindings(scope_key_group, item);
for (item = 0; tool_item->index != -1; item++, tool_item++)
{
GtkMenuItem *menu_item = GTK_MENU_ITEM(debug_menu_items[tool_item->index].widget);
GtkToolItem *button = gtk_tool_button_new(NULL, gtk_menu_item_get_label(menu_item));
gtk_tool_button_set_use_underline(GTK_TOOL_BUTTON(button),
gtk_menu_item_get_use_underline(menu_item));
g_signal_connect(button, "clicked", G_CALLBACK(on_toolbar_button_clicked),
GINT_TO_POINTER(tool_item->index));
g_signal_connect(button, "toolbar-reconfigured",
G_CALLBACK(on_toolbar_reconfigured), tool_item);
tool_item->widget = GTK_WIDGET(button);
plugin_add_toolbar_item(geany_plugin, button);
}
toolbar_update_state(DS_INACTIVE);
views_update_state(DS_INACTIVE);
configure_toolbar();
g_signal_connect(debug_panel, "switch-page", G_CALLBACK(on_view_changed), NULL);
for (scb = scope_callbacks; scb->name; scb++)
plugin_signal_connect(geany_plugin, NULL, scb->name, FALSE, scb->callback, NULL);
}
void conterm_init(void)
{
GtkWidget *console;
#ifdef G_OS_UNIX
gchar *error = NULL;
int pty_master;
char *pty_name;
#endif
conterm_load_config();
#ifdef G_OS_UNIX
program_window = get_widget("program_window");
console = vte_terminal_new();
gtk_widget_show(console);
program_terminal = VTE_TERMINAL(console);
g_object_ref(program_terminal);
gtk_container_add(GTK_CONTAINER(program_window), console);
g_signal_connect_after(program_terminal, "realize", G_CALLBACK(on_vte_realize), NULL);
terminal_parent = get_widget("terminal_parent");
g_signal_connect(terminal_parent, "delete-event", G_CALLBACK(on_terminal_parent_delete),
NULL);
terminal_window = get_widget("terminal_window");
terminal_show = GTK_CHECK_MENU_ITEM(get_widget("terminal_show"));
if (pref_terminal_padding)
{
gint vte_border_x, vte_border_y;
#if GTK_CHECK_VERSION(3, 4, 0)
GtkStyleContext *context;
GtkBorder border;
context = gtk_widget_get_style_context (console);
gtk_style_context_get_padding (context, GTK_STATE_FLAG_NORMAL, &border);
vte_border_x = border.left + border.right;
vte_border_y = border.top + border.bottom;
#elif VTE_CHECK_VERSION(0, 24, 0)
GtkBorder *border = NULL;
gtk_widget_style_get(console, "inner-border", &border, NULL);
if (border)
{
vte_border_x = border->left + border->right;
vte_border_y = border->top + border->bottom;
gtk_border_free(border);
}
else
vte_border_x = vte_border_y = 2;
#else /* VTE 0.24.0 */
/* VTE manual says "deprecated since 0.26", but it's since 0.24 */
vte_terminal_get_padding(program_terminal, &vte_border_x, &vte_border_y);
#endif /* VTE 0.24.0 */
pref_terminal_width += vte_border_x;
pref_terminal_height += vte_border_y;
pref_terminal_padding = FALSE;
}
if (openpty(&pty_master, &pty_slave, NULL, NULL, NULL) == 0 &&
grantpt(pty_master) == 0 && unlockpt(pty_master) == 0 &&
(pty_name = ttyname(pty_slave)) != NULL)
{
#if VTE_CHECK_VERSION(0, 25, 0)
GError *gerror = NULL;
VtePty *pty = vte_pty_new_foreign(pty_master, &gerror);
if (pty)
{
vte_terminal_set_pty_object(program_terminal, pty);
slave_pty_name = g_strdup(pty_name);
}
else
{
error = g_strdup(gerror->message);
g_error_free(gerror);
}
#else /* VTE 0.25.0 */
vte_terminal_set_pty(program_terminal, pty_master);
slave_pty_name = g_strdup(pty_name);
#endif /* VTE 0.25.0 */
}
else
error = g_strdup_printf("pty: %s", g_strerror(errno));
if (error)
{
gtk_widget_set_sensitive(program_window, FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(terminal_show), FALSE);
msgwin_status_add(_("Scope: %s."), error);
g_free(error);
}
else
menu_connect("terminal_menu", &terminal_menu_info, GTK_WIDGET(program_terminal));
#else /* G_OS_UNIX */
gtk_widget_hide(get_widget("program_window"));
#endif /* G_OS_UNIX */
#ifdef G_OS_UNIX
if (pref_debug_console_vte)
{
console = vte_terminal_new();
gtk_widget_show(console);
debug_console = VTE_TERMINAL(console);
dc_output = console_output;
dc_output_nl = console_output_nl;
g_signal_connect_after(debug_console, "realize", G_CALLBACK(on_vte_realize), NULL);
menu_connect("console_menu", &console_menu_info, console);
}
else
#endif /* G_OS_UNIX */
{
static const char *const colors[NFD] = { "#00C0C0", "#C0C0C0", "#C00000",
"#C0C0C0", "#C000C0" };
guint i;
console = get_widget("debug_context");
context_apply_config(console);
debug_context = GTK_TEXT_VIEW(console);
dc_output = context_output;
dc_output_nl = context_output_nl;
context = gtk_text_view_get_buffer(debug_context);
for (i = 0; i < NFD; i++)
{
fd_tags[i] = gtk_text_buffer_create_tag(context, NULL, "foreground",
colors[i], NULL);
}
g_signal_connect(console, "button-press-event",
G_CALLBACK(on_console_button_3_press),
menu_connect("console_menu", &console_menu_info, NULL));
}
gtk_container_add(GTK_CONTAINER(get_widget("debug_window")), console);
g_signal_connect(console, "key-press-event", G_CALLBACK(on_console_key_press), NULL);
}
void backup_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];
gint fd_dst = -1;
gchar backupcopy_time_fmt[] = "%Y-%m-%d-%H-%M-%S";
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.") );
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 = backup_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);
msgwin_status_add ( "Backup into %s", locale_filename_dst );
/* Use g_open() on non-Windows to set file permissions to 600 atomically.
* On Windows, seting file permissions would require specific Windows API. */
fd_dst = g_open(locale_filename_dst, O_CREAT | O_WRONLY, S_IWUSR | S_IRUSR);
if (fd_dst == -1 || (dst = fdopen(fd_dst, "w")) == NULL)
{
ui_set_statusbar(FALSE, _("Backup Copy: File could not be saved.") );
g_free(locale_filename_src);
g_free(locale_filename_dst);
g_free(stamp);
fclose(src);
if (fd_dst != -1)
close(fd_dst);
return;
}
while (fgets(buf, sizeof(buf), src) != NULL)
{
fputs(buf, dst);
}
//ui_set_statusbar ( FALSE, _("Backup Copy Saved into %s."), local_filename_dst );
msgwin_status_add ( "Backup created in %s", locale_filename_dst );
fclose(src);
fclose(dst);
if (fd_dst != -1)
close(fd_dst);
g_free(locale_filename_src);
g_free(locale_filename_dst);
g_free(stamp);
}
/* 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);
}
}
}
