static void on_document_save(G_GNUC_UNUSED GObject *object, GeanyDocument *doc)
{
gchar *f;
g_return_if_fail(!EMPTY(doc->real_path));
f = g_build_filename(app->configdir, "filetype_extensions.conf", NULL);
if (utils_str_equal(doc->real_path, f))
filetypes_reload_extensions();
g_free(f);
f = g_build_filename(app->configdir, GEANY_FILEDEFS_SUBDIR, "filetypes.common", NULL);
if (utils_str_equal(doc->real_path, f))
{
guint i;
/* Note: we don't reload other filetypes, even though the named styles may have changed.
* The user can do this manually with 'Tools->Reload Configuration' */
filetypes_load_config(GEANY_FILETYPES_NONE, TRUE);
foreach_document(i)
document_reload_config(documents[i]);
}
g_free(f);
}
/* Changes the current working directory of the VTE to the path of the given filename.
* filename is expected to be in UTF-8 encoding.
* filename can also be a path, then it is used directly.
* If force is set to TRUE, it will always change the cwd
*/
void vte_cwd(const gchar *filename, gboolean force)
{
if (vte_info.have_vte && (vc->follow_path || force) &&
filename != NULL && g_path_is_absolute(filename))
{
gchar *path;
if (g_file_test(filename, G_FILE_TEST_IS_DIR))
path = g_strdup(filename);
else
path = g_path_get_dirname(filename);
vte_get_working_directory(); /* refresh vte_info.dir */
if (! utils_str_equal(path, vte_info.dir))
{
/* use g_shell_quote to avoid problems with spaces, '!' or something else in path */
gchar *quoted_path = g_shell_quote(path);
gchar *cmd = g_strconcat(vc->send_cmd_prefix, "cd ", quoted_path, "\n", NULL);
if (! vte_send_cmd(cmd))
{
ui_set_statusbar(FALSE,
_("Could not change the directory in the VTE because it probably contains a command."));
geany_debug(
"Could not change the directory in the VTE because it probably contains a command.");
}
g_free(quoted_path);
g_free(cmd);
}
g_free(path);
}
}
static void add_dict_array(const gchar* const lang_tag, const gchar* const provider_name,
const gchar* const provider_desc, const gchar* const provider_file,
gpointer user_data)
{
guint i;
gchar *result = g_strdup(lang_tag);
/* sometimes dictionaries are named lang-LOCALE instead of lang_LOCALE, so replace the
* hyphen by a dash, enchant seems to not care about it. */
for (i = 0; i < strlen(result); i++)
{
if (result[i] == '-')
result[i] = '_';
}
/* find duplicates and skip them */
for (i = 0; i < sc_info->dicts->len; i++)
{
if (utils_str_equal(g_ptr_array_index(sc_info->dicts, i), result))
{
g_free(result);
return;
}
}
g_ptr_array_add(sc_info->dicts, result);
}
static void dict_compare(gpointer data, gpointer user_data)
{
gboolean *supported = user_data;
if (utils_str_equal(sc_info->default_language, data))
*supported = TRUE;
}
/* Changes the current working directory of the VTE to the path of the given filename.
* filename is expected to be in UTF-8 encoding.
* filename can also be a path, then it is used directly.
* If force is set to TRUE, it will always change the cwd
*/
void vte_cwd(const gchar *filename, gboolean force)
{
if (vte_info.have_vte && (vc->follow_path || force) &&
filename != NULL && g_path_is_absolute(filename))
{
gchar *path;
if (g_file_test(filename, G_FILE_TEST_IS_DIR))
path = g_strdup(filename);
else
path = g_path_get_dirname(filename);
vte_get_working_directory(); /* refresh vte_info.dir */
if (! utils_str_equal(path, vte_info.dir))
{
/* use g_shell_quote to avoid problems with spaces, '!' or something else in path */
gchar *quoted_path = g_shell_quote(path);
gchar *cmd = g_strconcat(vc->send_cmd_prefix, "cd ", quoted_path, "\n", NULL);
if (! vte_send_cmd(cmd))
{
const gchar *msg = _("Directory not changed because the terminal may contain some input (press Ctrl+C or Enter to clear it).");
ui_set_statusbar(FALSE, "%s", msg);
geany_debug("%s", msg);
}
g_free(quoted_path);
g_free(cmd);
}
g_free(path);
}
}
static gint find_by_filename(gconstpointer a, gconstpointer b)
{
if (utils_str_equal(((const filepos*)a)->file, (const gchar*) b))
return 0;
else
return 1;
}
/* convert data with the specified encoding */
static gboolean
handle_forced_encoding(BufferData *buffer, const gchar *forced_enc)
{
GeanyEncodingIndex enc_idx;
if (utils_str_equal(forced_enc, "UTF-8"))
{
if (! g_utf8_validate(buffer->data, buffer->len, NULL))
{
return FALSE;
}
}
else
{
gchar *converted_text = encodings_convert_to_utf8_from_charset(
buffer->data, buffer->size, forced_enc, FALSE);
if (converted_text == NULL)
{
return FALSE;
}
else
{
setptr(buffer->data, converted_text);
buffer->len = strlen(converted_text);
}
}
enc_idx = encodings_scan_unicode_bom(buffer->data, buffer->size, NULL);
buffer->bom = (enc_idx == GEANY_ENCODING_UTF_8);
buffer->enc = g_strdup(forced_enc);
return TRUE;
}
const gchar *glatex_get_entity(const gchar *letter)
{
if (! utils_str_equal(letter, "\\"))
{
guint i, len;
len = G_N_ELEMENTS(glatex_char_array);
for (i = 0; i < len; i++)
{
if (utils_str_equal(glatex_char_array[i].label, letter))
{
return glatex_char_array[i].latex;
}
}
}
/* if the char is not in the list */
return NULL;
}
const gchar *main_get_version_string(void)
{
static gchar full[] = VERSION " (git >= " REVISION ")";
if (utils_str_equal(REVISION, "-1"))
return VERSION;
else
return full;
}
void glatex_bibtex_write_entry(GPtrArray *entry, gint doctype)
{
gint i;
GString *output = NULL;
gchar *tmp = NULL;
GeanyDocument *doc = NULL;
const gchar *eol;
doc = document_get_current();
if (doc != NULL)
{
eol = editor_get_eol_char(doc->editor);
}
else
{
eol = "\n";
}
/* Adding the doctype to entry */
output = g_string_new("@");
g_string_append(output, glatex_bibtex_types[doctype].latex);
g_string_append(output, "{");
g_string_append(output, eol);
/* Adding the keywords and values to entry */
for (i = 0; i < GLATEX_BIBTEX_N_ENTRIES; i++)
{
/* Check whether a field has been marked for being used */
if (g_ptr_array_index (entry, i) != NULL)
{
/* Check whether a field was only set for being used ... */
if (utils_str_equal(g_ptr_array_index (entry, i), "\0"))
{
g_string_append(output, glatex_label_entry_keywords[i]);
g_string_append(output," = {},");
g_string_append(output, eol);
}
/* ... or has some real value inside. */
else
{
g_string_append(output, glatex_label_entry_keywords[i]);
g_string_append(output, " = {");
g_string_append(output, g_ptr_array_index(entry, i));
g_string_append(output, "},");
g_string_append(output, eol);
}
}
}
g_string_append(output, "}");
g_string_append(output, eol);
tmp = g_string_free(output, FALSE);
sci_start_undo_action(doc->editor->sci);
glatex_insert_string(tmp, FALSE);
sci_end_undo_action(doc->editor->sci);
g_free(tmp);
}
static void on_term_font_set(GtkFontButton *widget, gpointer user_data)
{
const gchar *fontbtn = gtk_font_button_get_font_name(widget);
if (! utils_str_equal(fontbtn, vc->font))
{
SETPTR(vc->font, g_strdup(gtk_font_button_get_font_name(widget)));
vte_apply_user_settings();
}
}
static gboolean
queue_pos_matches(guint queue_pos, const gchar *fname, gint pos)
{
if (queue_pos < g_queue_get_length(navigation_queue))
{
filepos *fpos = g_queue_peek_nth(navigation_queue, queue_pos);
return (utils_str_equal(fpos->file, fname) && fpos->pos == pos);
}
return FALSE;
}
/* Prevent the same plugin filename being loaded more than once.
* Note: g_module_name always returns the .so name, even when Plugin::filename is a .la file. */
static gboolean
plugin_loaded(GModule *module)
{
gchar *basename_module, *basename_loaded;
GList *item;
basename_module = g_path_get_basename(g_module_name(module));
for (item = plugin_list; item != NULL; item = g_list_next(item))
{
basename_loaded = g_path_get_basename(
g_module_name(((Plugin*)item->data)->module));
if (utils_str_equal(basename_module, basename_loaded))
{
g_free(basename_loaded);
g_free(basename_module);
return TRUE;
}
g_free(basename_loaded);
}
/* Look also through the list of active plugins. This prevents problems when we have the same
* plugin in libdir/geany/ AND in configdir/plugins/ and the one in libdir/geany/ is loaded
* as active plugin. The plugin manager list would only take the one in configdir/geany/ and
* the plugin manager would list both plugins. Additionally, unloading the active plugin
* would cause a crash. */
for (item = active_plugin_list; item != NULL; item = g_list_next(item))
{
basename_loaded = g_path_get_basename(g_module_name(((Plugin*)item->data)->module));
if (utils_str_equal(basename_module, basename_loaded))
{
g_free(basename_loaded);
g_free(basename_module);
return TRUE;
}
g_free(basename_loaded);
}
g_free(basename_module);
return FALSE;
}
static void on_document_save(G_GNUC_UNUSED GObject *object, GeanyDocument *doc)
{
gchar *f, *basename;
g_return_if_fail(!EMPTY(doc->real_path));
f = g_build_filename(app->configdir, "filetype_extensions.conf", NULL);
if (utils_str_equal(doc->real_path, f))
filetypes_reload_extensions();
g_free(f);
basename = g_path_get_basename(doc->real_path);
if (g_str_has_prefix(basename, "filetypes."))
{
guint i;
for (i = 0; i < filetypes_array->len; i++)
{
GeanyFiletype *ft = filetypes[i];
f = filetypes_get_filename(ft, TRUE);
if (utils_str_equal(doc->real_path, f))
{
guint j;
/* Note: we don't reload other filetypes, even though the named styles may have changed.
* The user can do this manually with 'Tools->Reload Configuration' */
filetypes_load_config(i, TRUE);
foreach_document(j)
document_reload_config(documents[j]);
g_free(f);
break;
}
g_free(f);
}
}
g_free(basename);
}
/* return a FileData structure for a file
* if not come across this file before then create one, otherwise return existing structure with
* data in it
* returns NULL on error
*/
static FileData * GetFileData(gchar *pcFileName)
{
FileData *fdTemp=fdKnownFilesSettings;
gint i;
/* First handle if main pointer doesn't point to anything */
if(fdTemp==NULL)
{
if((fdKnownFilesSettings=(FileData*)(g_malloc(sizeof *fdTemp)))!=NULL)
{
fdKnownFilesSettings->pcFileName=g_strdup(pcFileName);
for(i=0;i<10;i++)
fdKnownFilesSettings->iBookmark[i]=-1;
/* don't need to initiate iBookmarkLinePos */
fdKnownFilesSettings->pcFolding=NULL;
fdKnownFilesSettings->LastChangedTime=-1;
fdKnownFilesSettings->pcBookmarks=NULL;
fdKnownFilesSettings->NextNode=NULL;
}
return fdKnownFilesSettings;
}
/* move through chain to the correct entry or the end of a chain */
while(TRUE)
{
/* if have found relavent FileData, then exit */
if(utils_str_equal(pcFileName,fdTemp->pcFileName)==TRUE)
return fdTemp;
/* if end of chain, then add new entry, and return it. */
if(fdTemp->NextNode==NULL)
{
if((fdTemp->NextNode=(FileData*)(g_malloc(sizeof *fdTemp)))!=NULL)
{
fdTemp->NextNode->pcFileName=g_strdup(pcFileName);
for(i=0;i<10;i++)
fdTemp->NextNode->iBookmark[i]=-1;
/* don't need to initiate iBookmarkLinePos */
fdTemp->NextNode->pcFolding=NULL;
fdTemp->NextNode->LastChangedTime=-1;
fdTemp->NextNode->pcBookmarks=NULL;
fdTemp->NextNode->NextNode=NULL;
}
return fdTemp->NextNode;
}
fdTemp=fdTemp->NextNode;
}
}
static Plugin *find_active_plugin_by_name(const gchar *filename)
{
GList *item;
g_return_val_if_fail(filename, FALSE);
for (item = active_plugin_list; item != NULL; item = g_list_next(item))
{
if (utils_str_equal(filename, ((Plugin*)item->data)->filename))
return item->data;
}
return NULL;
}
static void populate_dict_combo(GtkComboBox *combo)
{
guint i;
GtkTreeModel *model = gtk_combo_box_get_model(combo);
gtk_list_store_clear(GTK_LIST_STORE(model));
for (i = 0; i < sc_info->dicts->len; i++)
{
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), g_ptr_array_index(sc_info->dicts, i));
if (utils_str_equal(g_ptr_array_index(sc_info->dicts, i), sc_info->default_language))
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), i);
}
/* if the default language couldn't be selected, select the first available language */
if (gtk_combo_box_get_active(GTK_COMBO_BOX(combo)) == -1)
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
}
static void socket_get_document_list(gint sock)
{
gchar doc_list[BUFFER_LENGTH];
gint doc_list_len;
if (sock < 0)
return;
socket_fd_write_all(sock, "doclist\n", 8);
doc_list_len = socket_fd_read(sock, doc_list, sizeof(doc_list));
if (doc_list_len >= BUFFER_LENGTH)
doc_list_len = BUFFER_LENGTH -1;
doc_list[doc_list_len] = '\0';
/* if we received ETX (end-of-text), there were no open files, so print only otherwise */
if (! utils_str_equal(doc_list, "\3"))
printf("%s", doc_list);
}
void sc_gui_update_menu(void)
{
GtkWidget *menu_item;
guint i;
static gboolean need_init = TRUE;
GSList *group = NULL;
gchar *label;
if (need_init)
{
gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), sc_info->menu_item);
need_init = FALSE;
}
if (sc_info->main_menu != NULL)
gtk_widget_destroy(sc_info->main_menu);
sc_info->main_menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(sc_info->menu_item), sc_info->main_menu);
sc_info->submenu_item_default = gtk_menu_item_new_with_label(NULL);
gtk_container_add(GTK_CONTAINER(sc_info->main_menu), sc_info->submenu_item_default);
g_signal_connect(sc_info->submenu_item_default, "activate",
G_CALLBACK(menu_item_toggled_cb), NULL);
update_labels();
menu_item = gtk_separator_menu_item_new();
gtk_container_add(GTK_CONTAINER(sc_info->main_menu), menu_item);
sc_ignore_callback = TRUE;
for (i = 0; i < sc_info->dicts->len; i++)
{
label = g_ptr_array_index(sc_info->dicts, i);
menu_item = gtk_radio_menu_item_new_with_label(group, label);
group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menu_item));
if (utils_str_equal(sc_info->default_language, label))
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_item), TRUE);
gtk_container_add(GTK_CONTAINER(sc_info->main_menu), menu_item);
g_signal_connect(menu_item, "toggled", G_CALLBACK(menu_item_toggled_cb), label);
}
sc_ignore_callback = FALSE;
gtk_widget_show_all(sc_info->main_menu);
}
static void encodings_radio_item_change_cb(GtkCheckMenuItem *menuitem, gpointer user_data)
{
GeanyDocument *doc = document_get_current();
guint i = GPOINTER_TO_INT(user_data);
if (ignore_callback || doc == NULL || encodings[i].charset == NULL ||
! gtk_check_menu_item_get_active(menuitem) ||
utils_str_equal(encodings[i].charset, doc->encoding))
return;
if (doc->readonly)
{
utils_beep();
return;
}
document_undo_add(doc, UNDO_ENCODING, g_strdup(doc->encoding));
document_set_encoding(doc, encodings[i].charset);
}
void encodings_select_radio_item(const gchar *charset)
{
gint i;
g_return_if_fail(charset != NULL);
i = 0;
while (i < GEANY_ENCODINGS_MAX)
{
if (utils_str_equal(charset, encodings[i].charset))
break;
i++;
}
if (i == GEANY_ENCODINGS_MAX)
i = GEANY_ENCODING_UTF_8; /* fallback to UTF-8 */
/* ignore_callback has to be set by the caller */
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(radio_items[i]), TRUE);
}
/* loads textfile data, verifies and converts to forced_enc or UTF-8. Also handles BOM. */
static gboolean handle_buffer(BufferData *buffer, const gchar *forced_enc)
{
GeanyEncodingIndex tmp_enc_idx;
/* temporarily retrieve the encoding idx based on the BOM to suppress the following warning
* if we have a BOM */
tmp_enc_idx = encodings_scan_unicode_bom(buffer->data, buffer->size, NULL);
/* check whether the size of the loaded data is equal to the size of the file in the
* filesystem file size may be 0 to allow opening files in /proc/ which have typically a
* file size of 0 bytes */
if (buffer->len != buffer->size && buffer->size != 0 && (
tmp_enc_idx == GEANY_ENCODING_UTF_8 || /* tmp_enc_idx can be UTF-7/8/16/32, UCS and None */
tmp_enc_idx == GEANY_ENCODING_UTF_7)) /* filter UTF-7/8 where no NULL bytes are allowed */
{
buffer->partial = TRUE;
}
/* Determine character encoding and convert to UTF-8 */
if (forced_enc != NULL)
{
/* the encoding should be ignored(requested by user), so open the file "as it is" */
if (utils_str_equal(forced_enc, encodings[GEANY_ENCODING_NONE].charset))
{
buffer->bom = FALSE;
buffer->enc = g_strdup(encodings[GEANY_ENCODING_NONE].charset);
}
else if (! handle_forced_encoding(buffer, forced_enc))
{
return FALSE;
}
}
else if (! handle_encoding(buffer, tmp_enc_idx))
{
return FALSE;
}
if (buffer->bom)
handle_bom(buffer);
return TRUE;
}
static gboolean utils_font_desc_check_monospace(PangoContext *pc, PangoFontDescription *desc)
{
PangoFontFamily **families;
gint n_families, i;
const gchar *font;
gboolean ret = TRUE;
font = pango_font_description_get_family(desc);
pango_context_list_families(pc, &families, &n_families);
for (i = 0; i < n_families; i++)
{
if (utils_str_equal(font, pango_font_family_get_name(families[i])))
{
if (!pango_font_family_is_monospace(families[i]))
{
ret = FALSE;
}
}
}
g_free(families);
return ret;
}
/* Constructs the project's base path which is used for "Make all" and "Execute".
* The result is an absolute string in UTF-8 encoding which is either the same as
* base path if it is absolute or it is built out of project file name's dir and base_path.
* If there is no project or project's base_path is invalid, NULL will be returned.
* The returned string should be freed when no longer needed. */
gchar *project_get_base_path(void)
{
GeanyProject *project = app->project;
if (project && NZV(project->base_path))
{
if (g_path_is_absolute(project->base_path))
return g_strdup(project->base_path);
else
{ /* build base_path out of project file name's dir and base_path */
gchar *path;
gchar *dir = g_path_get_dirname(project->file_name);
if (utils_str_equal(project->base_path, "./"))
return dir;
else
path = g_strconcat(dir, G_DIR_SEPARATOR_S, project->base_path, NULL);
g_free(dir);
return path;
}
}
return NULL;
}
/**
* @brief Comparison of strings, for use with g_slist_find_custom
* @param const gchar*, const gchar*
* @return gint
*
*/
gint
compare_strings(const gchar* a, const gchar* b)
{
return (gint)(!utils_str_equal(a, b));
}
GtkWidget *plugin_configure(GtkDialog *dialog)
{
GtkWidget *vbox, *label, *notebook_vbox, *checkbox_enable;
GtkWidget *notebook, *inner_vbox;
vbox = gtk_vbox_new(FALSE, 6);
notebook = gtk_notebook_new();
gtk_widget_set_can_focus(notebook, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(notebook), 5);
gtk_box_pack_start(GTK_BOX(vbox), notebook, FALSE, TRUE, 0);
/*
* Auto Save
*/
{
GtkWidget *spin, *hbox, *checkbox, *checkbox_enable_as_lf, *radio1, *radio2;
notebook_vbox = gtk_vbox_new(FALSE, 2);
inner_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(inner_vbox), 5);
gtk_box_pack_start(GTK_BOX(notebook_vbox), inner_vbox, TRUE, TRUE, 5);
gtk_notebook_insert_page(GTK_NOTEBOOK(notebook),
notebook_vbox, gtk_label_new(_("Auto Save")), NOTEBOOK_PAGE_AUTOSAVE);
checkbox_enable_as_lf = gtk_check_button_new_with_mnemonic(_("Enable save when losing _focus"));
gtk_button_set_focus_on_click(GTK_BUTTON(checkbox_enable_as_lf), FALSE);
pref_widgets.checkbox_enable_autosave_losing_focus = checkbox_enable_as_lf;
gtk_box_pack_start(GTK_BOX(inner_vbox), checkbox_enable_as_lf, FALSE, FALSE, 6);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox_enable_as_lf), enable_autosave_losing_focus);
checkbox_enable = gtk_check_button_new_with_mnemonic(_("_Enable"));
gtk_button_set_focus_on_click(GTK_BUTTON(checkbox_enable), FALSE);
pref_widgets.checkbox_enable_autosave = checkbox_enable;
gtk_box_pack_start(GTK_BOX(inner_vbox), checkbox_enable, FALSE, FALSE, 6);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox_enable), enable_autosave);
g_signal_connect(checkbox_enable, "toggled",
G_CALLBACK(checkbox_toggled_cb), GINT_TO_POINTER(NOTEBOOK_PAGE_AUTOSAVE));
label = gtk_label_new_with_mnemonic(_("Auto save _interval:"));
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(inner_vbox), label, TRUE, TRUE, 0);
pref_widgets.autosave_interval_spin = spin = gtk_spin_button_new_with_range(1, 1800, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), autosave_interval);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), spin);
label = gtk_label_new(_("seconds"));
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), spin, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(inner_vbox), hbox, FALSE, FALSE, 5);
checkbox = gtk_check_button_new_with_mnemonic(
_("_Print status message if files have been automatically saved"));
gtk_button_set_focus_on_click(GTK_BUTTON(checkbox), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox), autosave_print_msg);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), checkbox);
gtk_box_pack_start(GTK_BOX(inner_vbox), checkbox, FALSE, FALSE, 5);
pref_widgets.autosave_print_msg_checkbox = checkbox;
radio1 = gtk_radio_button_new_with_mnemonic(NULL,
_("Save only current open _file"));
pref_widgets.autosave_save_all_radio1 = radio1;
gtk_label_set_mnemonic_widget(GTK_LABEL(label), radio1);
gtk_button_set_focus_on_click(GTK_BUTTON(radio1), FALSE);
gtk_container_add(GTK_CONTAINER(inner_vbox), radio1);
radio2 = gtk_radio_button_new_with_mnemonic_from_widget(
GTK_RADIO_BUTTON(radio1), _("Sa_ve all open files"));
pref_widgets.autosave_save_all_radio2 = radio2;
gtk_label_set_mnemonic_widget(GTK_LABEL(label), radio2);
gtk_button_set_focus_on_click(GTK_BUTTON(radio2), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio2), autosave_save_all);
gtk_container_add(GTK_CONTAINER(inner_vbox), radio2);
}
/*
* Instant Save
*/
{
GtkWidget *combo;
guint i;
const GSList *node;
notebook_vbox = gtk_vbox_new(FALSE, 2);
inner_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(inner_vbox), 5);
gtk_box_pack_start(GTK_BOX(notebook_vbox), inner_vbox, TRUE, TRUE, 5);
gtk_notebook_insert_page(GTK_NOTEBOOK(notebook),
notebook_vbox, gtk_label_new(_("Instant Save")), NOTEBOOK_PAGE_INSTANTSAVE);
checkbox_enable = gtk_check_button_new_with_mnemonic(_("_Enable"));
pref_widgets.checkbox_enable_instantsave = checkbox_enable;
gtk_button_set_focus_on_click(GTK_BUTTON(checkbox_enable), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox_enable), enable_instantsave);
gtk_box_pack_start(GTK_BOX(inner_vbox), checkbox_enable, FALSE, FALSE, 6);
g_signal_connect(checkbox_enable, "toggled",
G_CALLBACK(checkbox_toggled_cb), GINT_TO_POINTER(NOTEBOOK_PAGE_INSTANTSAVE));
label = gtk_label_new_with_mnemonic(_("_Filetype to use for newly opened files:"));
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(inner_vbox), label, FALSE, FALSE, 0);
pref_widgets.instantsave_ft_combo = combo = gtk_combo_box_text_new();
i = 0;
foreach_slist(node, filetypes_get_sorted_by_name())
{
GeanyFiletype *ft = node->data;
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), ft->name);
if (utils_str_equal(ft->name, instantsave_default_ft))
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), i);
i++;
}
gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(combo), 3);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), combo);
gtk_box_pack_start(GTK_BOX(inner_vbox), combo, FALSE, FALSE, 0);
}
/* ---------------------------------------------------------------------
* Callback when the menu item is clicked.
* ---------------------------------------------------------------------
*/
static void
menu_item_activate(guint key_id)
{
GeanyDocument* current_doc = document_get_current();
GeanyDocument* new_doc = NULL;
guint nb_documents = geany->documents_array->len;
gchar* extension = NULL; /* e.g. : "hpp" */
GSList* p_extensions_to_test = NULL; /* e.g. : ["cpp", "cxx", ...] */
GSList* filenames_to_test = NULL; /* e.g. : ["f.cpp", "f.cxx", ...] */
GSList* iter_lang = NULL;
GSList* iter_ext = NULL;
GSList* iter_filename = NULL;
gint i=0;
gchar* dirname = NULL;
gchar* basename = NULL;
gchar* basename_no_extension = NULL;
gchar* p_str = NULL; /* Local variables, used as temporary buffers */
gchar* p_str2 = NULL;
log_func();
log_debug("current_doc->file_name == %s", current_doc->file_name);
log_debug("geany->documents_array->len == %d", geany->documents_array->len);
if(current_doc != NULL && current_doc->file_name != NULL && current_doc->file_name[0] != '\0')
{
/* Get the basename, e.g. : "/home/me/file.cpp" -> "file.cpp" */
basename = g_path_get_basename(current_doc->file_name);
if(g_utf8_strlen(basename, -1) < 2)
goto free_mem;
log_debug("basename == %s", basename);
/* Get the extension , e.g. : "cpp" */
extension = get_extension(basename);
if(extension == NULL || g_utf8_strlen(extension, -1) == 0)
goto free_mem;
log_debug("extension == %s", extension);
/* Get the basename without any extension */
basename_no_extension = copy_and_remove_extension(basename);
if(basename_no_extension == NULL || g_utf8_strlen(basename_no_extension, -1) == 0)
goto free_mem;
/* Identify the language and whether the file is a header or an implementation. */
/* For each recognized language : */
for(iter_lang = languages ; iter_lang != NULL ; iter_lang = iter_lang->next)
{
Language* lang = (Language*)(iter_lang->data);
/* Test the headers : */
if(g_slist_find_custom(lang->head_extensions, extension, (GCompareFunc)(&compare_strings)) != NULL)
{
p_extensions_to_test = lang->impl_extensions;
break;
}
/* Test the implementations : */
else if(g_slist_find_custom(lang->impl_extensions, extension, (GCompareFunc)(&compare_strings)) != NULL)
{
p_extensions_to_test = lang->head_extensions;
break;
}
}
if(p_extensions_to_test == NULL)
goto free_mem;
#ifdef CODE_NAVIGATION_DEBUG
log_debug("extension known !");
log_debug("p_extensions_to_test : ");
g_slist_foreach(p_extensions_to_test, (GFunc)(&log_debug), NULL);
#endif
/* Build a list of filenames to test : */
filenames_to_test = NULL;
for(iter_ext = p_extensions_to_test ; iter_ext != NULL ; iter_ext = iter_ext->next)
{
p_str = g_strdup_printf("%s.%s", basename_no_extension, (const gchar*)(iter_ext->data));
filenames_to_test = g_slist_prepend(filenames_to_test, p_str);
}
filenames_to_test = g_slist_reverse(filenames_to_test);
#ifdef CODE_NAVIGATION_DEBUG
log_debug("filenames to test :");
g_slist_foreach(filenames_to_test, (GFunc)(&log_debug), NULL);
#endif
/* First : look for a corresponding file in the opened files.
* If found, open it. */
for(i=0 ; i < nb_documents ; i++)
{
new_doc = document_index(i);
for(iter_filename = filenames_to_test ; iter_filename != NULL ; iter_filename = iter_filename->next)
{
p_str = g_path_get_basename(new_doc->file_name);
log_debug("comparing \"%s\" and \"%s\"", (const gchar*)(iter_filename->data), p_str);
if(utils_str_equal((const gchar*)(iter_filename->data), p_str))
{
log_debug("FOUND !");
g_free(p_str);
p_str = g_locale_from_utf8(new_doc->file_name, -1, NULL, NULL, NULL);
document_open_file(p_str, FALSE, NULL, NULL);
g_free(p_str);
goto free_mem;
}
g_free(p_str);
}
}
/* Second : if not found, look for a corresponding file in the same directory.
* If found, open it.
*/
/* -> compute dirname */
dirname = g_path_get_dirname(current_doc->real_path);
if(dirname == NULL)
goto free_mem;
log_debug("dirname == \"%s\"", dirname);
/* -> try all the extensions we should test */
for(iter_ext = p_extensions_to_test ; iter_ext != NULL ; iter_ext = iter_ext->next)
{
p_str = g_strdup_printf( "%s" G_DIR_SEPARATOR_S "%s.%s",
dirname, basename_no_extension, (const gchar*)(iter_ext->data));
p_str2 = g_locale_from_utf8(p_str, -1, NULL, NULL, NULL);
g_free(p_str);
log_debug("trying to open the file \"%s\"\n", p_str2);
/* Try without read-only and in read-only mode */
if( document_open_file(p_str2, FALSE, NULL, NULL) != NULL ||
document_open_file(p_str2, TRUE, NULL, NULL) != NULL)
{
g_free(p_str2);
goto free_mem;
}
g_free(p_str2);
}
/* Third : if not found, ask the user if he wants to create it or not. */
{
p_str = g_strdup_printf("%s.%s", basename_no_extension, (const gchar*)(p_extensions_to_test->data));
GtkWidget* dialog = gtk_message_dialog_new( GTK_WINDOW(geany_data->main_widgets->window),
GTK_DIALOG_MODAL,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_OK_CANCEL,
_("%s not found, create it?"), p_str);
gtk_window_set_title(GTK_WINDOW(dialog), "Geany");
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
{
p_str2 = g_strdup_printf( "%s" G_DIR_SEPARATOR_S "%s", dirname, p_str);
document_new_file(p_str2, current_doc->file_type, NULL);
document_set_text_changed(document_get_current(), TRUE);
g_free(p_str2);
}
log_debug("DESTROY");
gtk_widget_destroy(dialog);
g_free(p_str);
}
/* Free the memory */
free_mem:
g_slist_foreach(filenames_to_test, (GFunc)(&g_free), NULL);
g_free(dirname);
g_free(basename_no_extension);
g_free(extension);
g_free(basename);
}
}
/* if type == -1 then we will try to autodetect the type */
void glatex_insert_environment(const gchar *environment, gint type)
{
GeanyDocument *doc = NULL;
doc = document_get_current();
/* Only do anything if it is realy needed to */
if (doc != NULL && environment != NULL)
{
if (sci_has_selection(doc->editor->sci))
{
gchar *selection = NULL;
gchar *replacement = NULL;
selection = sci_get_selection_contents(doc->editor->sci);
sci_start_undo_action(doc->editor->sci);
if (utils_str_equal(environment, "block") == TRUE)
{
replacement = g_strconcat("\\begin{", environment, "}{}\n",
selection, "\n\\end{", environment, "}\n", NULL);
}
else
{
replacement = g_strconcat("\\begin{", environment, "}\n",
selection, "\n\\end{", environment, "}\n", NULL);
}
sci_replace_sel(doc->editor->sci, replacement);
sci_end_undo_action(doc->editor->sci);
g_free(selection);
g_free(replacement);
}
else
{
gint indent, pos;
GString *tmpstring = NULL;
gchar *tmp = NULL;
static const GeanyIndentPrefs *indention_prefs = NULL;
if (type == -1)
{
gint i;
/* First, we check whether we have a known list over here
* an reset type to fit new value*/
for (i = 0; i < GLATEX_LIST_END; i++)
{
if (utils_str_equal(glatex_list_environments[i], environment) == TRUE)
{
type = GLATEX_ENVIRONMENT_TYPE_LIST;
break;
}
}
}
pos = sci_get_current_position(doc->editor->sci);
sci_start_undo_action(doc->editor->sci);
tmpstring = g_string_new("\\begin{");
g_string_append(tmpstring, environment);
if (utils_str_equal(environment, "block") == TRUE)
{
g_string_append(tmpstring, "}{}");
}
else
{
g_string_append(tmpstring, "}");
}
g_string_append(tmpstring, "\n");
if (type == GLATEX_ENVIRONMENT_TYPE_LIST)
{
g_string_append(tmpstring, "\t\\item ");
}
tmp = g_string_free(tmpstring, FALSE);
glatex_insert_string(tmp, TRUE);
g_free(tmp);
indent = sci_get_line_indentation(doc->editor->sci,
sci_get_line_from_position(doc->editor->sci, pos));
tmp = g_strdup_printf("\n\\end{%s}", environment);
glatex_insert_string(tmp, FALSE);
g_free(tmp);
indention_prefs = editor_get_indent_prefs(doc->editor);
if (type == GLATEX_ENVIRONMENT_TYPE_LIST)
{
sci_set_line_indentation(doc->editor->sci,
sci_get_current_line(doc->editor->sci),
indent + indention_prefs->width);
}
sci_set_line_indentation(doc->editor->sci,
sci_get_current_line(doc->editor->sci) + 1, indent);
sci_end_undo_action(doc->editor->sci);
}
}
}
