static void set_tab_preview_settings(GuPrefsGui* prefs)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prefs->compile_status),
TO_BOOL(config_get_value("compile_status")));
if (!config_get_value("compile_status"))
gtk_widget_set_sensitive(GTK_WIDGET(prefs->compile_timer), FALSE);
gtk_spin_button_set_value(prefs->compile_timer,
atoi(config_get_value("compile_timer")));
/* compile scheme */
if (STR_EQU(config_get_value("compile_scheme"), "real_time"))
gtk_combo_box_set_active(prefs->compile_scheme, 1);
if (STR_EQU(config_get_value("animated_scroll"), "always")) {
gtk_combo_box_set_active(prefs->combo_animated_scroll, 0);
} else if (STR_EQU(config_get_value("animated_scroll"), "never")) {
gtk_combo_box_set_active(prefs->combo_animated_scroll, 2);
} else {
gtk_combo_box_set_active(prefs->combo_animated_scroll, 1);
}
gtk_spin_button_set_value(prefs->spin_cache_size,
atoi(config_get_value("cache_size")));
}
gboolean biblio_detect_bibliography (GuBiblio* bc, GuEditor* ec) {
gchar* content = NULL;
gchar* bibfn = NULL;
gchar** result = NULL;
GMatchInfo *match_info;
GRegex* bib_regex = NULL;
gboolean state = FALSE;
content = editor_grab_buffer (ec);
bib_regex = g_regex_new ("^[^%]*\\\\bibliography{\\s*([^{}\\s]*)\\s*}",
G_REGEX_MULTILINE, 0, NULL);
if (g_regex_match (bib_regex, content, 0, &match_info)) {
result = g_match_info_fetch_all (match_info);
if (result[1]) {
if (!STR_EQU (result[1] +strlen (result[1]) -4, ".bib"))
bibfn = g_strconcat (result[1], ".bib", NULL);
else
bibfn = g_strdup (result[1]);
state = editor_fileinfo_update_biblio (ec, bibfn);
g_free (bibfn);
}
slog (L_INFO, "Detect bibliography file: %s\n", ec->bibfile);
g_strfreev (result);
}
g_free (content);
g_match_info_free (match_info);
g_regex_unref (bib_regex);
return state;
}
gboolean latex_method_active(gchar* method)
{
if (STR_EQU(config_get_value("compile_steps"), method)) {
return TRUE;
}
return FALSE;
}
void latex_export_pdffile(GuLatex* lc, GuEditor* ec, const gchar* path,
gboolean prompt_overrite)
{
gchar* savepath = NULL;
GError* err = NULL;
gint ret = 0;
if (!STR_EQU(path + strlen(path) - 4, ".pdf"))
savepath = g_strdup_printf("%s.pdf", path);
else
savepath = g_strdup(path);
if (prompt_overrite && utils_path_exists(savepath)) {
ret = utils_yes_no_dialog(_("The file already exists. Overwrite?"));
if (GTK_RESPONSE_YES != ret) {
g_free(savepath);
return;
}
}
if (!utils_copy_file(ec->pdffile, savepath, &err)) {
slog(L_G_ERROR, _("Unable to export PDF file.\n\n%s"),
err->message);
g_error_free(err);
}
g_free(savepath);
}
static void set_tab_miscellaneous_settings(GuPrefsGui* prefs)
{
GtkTreeModel* combo_lang = 0;
GtkTreeIter iter;
const gchar* lang = 0;
gint count = 0;
gboolean valid = FALSE;
combo_lang = gtk_combo_box_get_model(GTK_COMBO_BOX(prefs->combo_languages));
lang = config_get_value("spell_language");
valid = gtk_tree_model_get_iter_first(combo_lang, &iter);
while (valid) {
const gchar* str_value;
gtk_tree_model_get(combo_lang, &iter, 0, &str_value, -1);
if (STR_EQU(lang, str_value)) {
gtk_combo_box_set_active(GTK_COMBO_BOX(prefs->combo_languages), count);
break;
}
++count;
valid = gtk_tree_model_iter_next(combo_lang, &iter);
}
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prefs->autoexport),
TO_BOOL(config_get_value("autoexport")));
}
gboolean project_create_new(const gchar* filename)
{
const gchar* version = g_strdup("0.6.0");
const gchar* csetter = config_get_value("typesetter");
const gchar* csteps = config_get_value("compile_steps");
const gchar* rootfile = g_active_editor->filename;
// TODO: do we need to encode this text?
const gchar* content = g_strdup_printf("version=%s\n"
"typesetter=%s\n"
"steps=%s\n"
"root=%s\n",
version, csetter, csteps, rootfile);
if (!STR_EQU(filename + strlen(filename) - 6, ".gummi")) {
filename = g_strdup_printf("%s.gummi", filename);
}
statusbar_set_message(g_strdup_printf("Creating project file: %s",
filename));
utils_set_file_contents(filename, content, -1);
gummi->project->projfile = g_strdup(filename);
return TRUE;
}
gchar* texlive_get_command (const gchar* method, gchar* workfile, gchar* basename) {
slog(L_INFO, "texlive_get_command. workfile: %s, basename: %s\n", workfile, basename);
const gchar* outdir = g_strdup_printf("-output-directory=\"%s\"", C_TMPDIR);
gchar *typesetter = NULL;
gchar *texcmd = NULL;
if (pdflatex_active()) typesetter = C_PDFLATEX;
else typesetter = C_XELATEX;
gchar *flags = texlive_get_flags("texpdf");
gchar *dviname = g_strdup_printf("%s.dvi", g_path_get_basename (basename));
gchar *psname = g_strdup_printf("%s.ps", g_path_get_basename (basename));
#ifdef WIN32
gchar *script = g_build_filename (GUMMI_LIBS, "latex_dvi.cmd", NULL);
#else
gchar *script = g_build_filename (GUMMI_LIBS, "latex_dvi.sh", NULL);
#endif
if (STR_EQU (method, "texpdf")) {
slog(L_INFO, "texpdf method\n");
texcmd = g_strdup_printf("%s %s %s \"%s-new\"", typesetter,
flags,
outdir,
workfile);
} else if (STR_EQU (method, "texdvipdf")) {
texcmd = g_strdup_printf("%s pdf "
"\"%s\" \"%s\" \"%s\" \"%s\" \"%s\"", script,
flags, outdir, workfile, C_TMPDIR, dviname);
} else {
texcmd = g_strdup_printf("%s ps "
"\"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"", script,
flags, outdir, workfile, C_TMPDIR, dviname, psname);
}
g_free(script);
g_free(dviname);
g_free(psname);
slog(L_INFO, "Command: %s\n", texcmd);
return texcmd;
}
GList* project_list_files (const gchar* content) {
gchar** splcontent = g_strsplit(content, "\n", 0);
GList* filelist = NULL;
gint i;
for (i = 0; i < g_strv_length(splcontent); i++) {
gchar** line = g_strsplit(splcontent[i], "=", 0);
if (STR_EQU ("file", line[0])) {
filelist = g_list_append (filelist, line[1]);
gummi->project->nroffiles += 1;
}
if (STR_EQU ("root", line[0])) {
filelist = g_list_prepend (filelist, line[1]);
gummi->project->rootfile = g_strdup (line[1]);
}
}
return filelist;
}
void infoscreengui_set_message (GuInfoscreenGui *is, const gchar *msg) {
gtk_widget_set_visible (GTK_WIDGET(is->image), TRUE);
if (STR_EQU (msg, "compile_error")) {
gtk_label_set_text (is->header, get_infoheader(1));
gtk_label_set_text (is->details, get_infodetails(1));
}
else if (STR_EQU (msg, "document_error")) {
gtk_label_set_text (is->header, get_infoheader(2));
gtk_label_set_text (is->details, get_infodetails(2));
}
else if (STR_EQU (msg, "program_error")) {
gtk_label_set_text (is->header, get_infoheader(3));
gtk_label_set_text (is->details, get_infodetails(3));
}
else {
gtk_label_set_text (is->header, get_infoheader(4));
gtk_label_set_text (is->details, get_infodetails(4));
gtk_widget_set_visible (GTK_WIDGET(is->image), FALSE);
}
}
gchar* project_get_value (const gchar* content, const gchar* item) {
gchar** splcontent = g_strsplit(content, "\n", 0);
gchar* result = g_strdup ("");
gint i;
for (i = 0; i < g_strv_length(splcontent) -1; i++) {
gchar** line = g_strsplit(splcontent[i], "=", 0);
if (STR_EQU (item, line[0])) {
return line[1];
}
}
return result;
}
G_MODULE_EXPORT
void on_menu_export_activate(GtkWidget *widget, void *user)
{
gchar* filename = NULL;
filename = get_save_filename(TYPE_PDF);
if (filename){
if(strlen(filename) > 4 && STR_EQU(filename + strlen(filename) - 4, ".tex")){
latex_export_pdffile(gummi->latex, g_active_editor, filename, TRUE);
}
}
g_free(filename);
}
gchar* latex_update_workfile(GuLatex* lc, GuEditor* ec)
{
gchar *text;
text = editor_grab_buffer(ec);
// bit of a dirty hack, but only write the buffer content when
// there is not a recovery in progress, otherwise the workfile
// will be overwritten with empty text
if (!STR_EQU(text, "")) {
utils_set_file_contents(ec->workfile, text, -1);
}
return text;
}
void snippets_accel_disconnect (GuSnippets* sc, const gchar* key) {
Tuple2* closure_data = NULL;
GList* current = NULL;
g_return_if_fail (key != NULL);
current = sc->closure_data;
while (current) {
closure_data = TUPLE2 (current->data);
if (STR_EQU (closure_data->first, key))
break;
current = g_list_next (current);
}
if (current) {
gtk_accel_group_disconnect (sc->accel_group, closure_data->second);
sc->closure_data = g_list_remove (sc->closure_data, closure_data);
g_free (closure_data);
slog (L_DEBUG, "Accelerator for `%s' disconnected\n",
closure_data->first);
}
}
void prefsgui_apply_style_scheme(GuPrefsGui* prefs)
{
const gchar* scheme = config_get_value("style_scheme");
GList* schemes = editor_list_style_scheme_sorted();
GList* schemes_iter = schemes;
GList* tab = gummi->tabmanager->tabs;
gint column = 0;
GtkTreePath* treepath;
while (schemes_iter) {
if (STR_EQU(gtk_source_style_scheme_get_id(schemes_iter->data),
scheme)) {
gchar* path = g_strdup_printf("%d", column);
treepath = gtk_tree_path_new_from_string(path);
gtk_tree_view_set_cursor(prefs->styleschemes_treeview, treepath,
NULL, FALSE);
gtk_tree_path_free(treepath);
g_free(path);
break;
}
++column;
schemes_iter = g_list_next(schemes_iter);
}
g_list_free(schemes);
if (schemes && !schemes_iter) {
treepath = gtk_tree_path_new_from_string("0");
gtk_tree_view_set_cursor(prefs->styleschemes_treeview, treepath, NULL,
FALSE);
gtk_tree_path_free(treepath);
while (tab) {
editor_set_style_scheme_by_id(GU_TAB_CONTEXT(tab->data)->editor,
"classic");
tab = g_list_next(tab);
}
}
}
gboolean xelatex_active (void) {
if (STR_EQU (config_get_value("typesetter"), "xelatex")) {
return TRUE;
}
return FALSE;
}
void snippet_info_initial_expand (GuSnippetInfo* info, GuEditor* ec) {
GuSnippetExpandInfo* value = NULL;
GtkTextIter start, end;
GHashTable* map = NULL;
GList* current = NULL;
gchar* text = NULL;
gint key = 0;
map = g_hash_table_new (NULL, NULL);
current = g_list_first (info->einfo);
while (current) {
GuSnippetExpandInfo* einfo = GU_SNIPPET_EXPAND_INFO (current->data);
if (!g_hash_table_lookup_extended (map, ((gpointer)einfo->group_number),
(gpointer)&key, (gpointer)&value)) {
g_hash_table_insert (map, (gpointer)einfo->group_number, einfo);
info->einfo_unique = g_list_append (info->einfo_unique, einfo);
}
current = g_list_next (current);
}
info->einfo_unique = g_list_sort (info->einfo_unique, snippet_info_num_cmp);
current = g_list_first (info->einfo);
info->offset = 0;
while (current) {
GuSnippetExpandInfo* einfo = GU_SNIPPET_EXPAND_INFO (current->data);
g_hash_table_lookup_extended (map, (gpointer)einfo->group_number,
(gpointer)&key, (gpointer)&value);
gtk_text_buffer_get_iter_at_mark (ec_buffer, &start, einfo->left_mark);
gtk_text_buffer_get_iter_at_mark (ec_buffer, &end, einfo->right_mark);
/* Expand macros */
text = GU_SNIPPET_EXPAND_INFO(current->data)->text;
if (STR_EQU (text, "SELECTED_TEXT")) {
GtkTextIter ms, me;
gtk_text_buffer_delete (ec_buffer, &start, &end);
gtk_text_buffer_insert (ec_buffer, &start, info->sel_text, -1);
gtk_text_buffer_get_iter_at_mark (ec_buffer, &ms, &info->sel_start);
me = ms;
gtk_text_iter_forward_chars (&me, strlen (info->sel_text));
gtk_text_buffer_delete (ec_buffer, &ms, &me);
} else if (STR_EQU (text, "FILENAME")) {
gtk_text_buffer_delete (ec_buffer, &start, &end);
gtk_text_buffer_insert (ec_buffer, &start,
ec->filename? ec->filename: "", -1);
} else if (STR_EQU (text, "BASENAME")) {
gchar* basename = g_path_get_basename(ec->filename?ec->filename:"");
gtk_text_buffer_delete (ec_buffer, &start, &end);
gtk_text_buffer_insert (ec_buffer, &start, basename, -1);
g_free (basename);
} else {
/* Expand text of same group with with text of group leader */
gtk_text_buffer_delete (ec_buffer, &start, &end);
gtk_text_buffer_insert (ec_buffer, &start, value->text, -1);
}
current = g_list_next (current);
}
g_hash_table_destroy (map);
}
