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); } } }