G_MODULE_EXPORT
void on_menu_spelling_toggled(GtkWidget *widget, void *user)
{
#ifdef USE_GTKSPELL
GList *editors;
GuEditor* ec;
int ectotal, i;
gboolean activate = gtk_check_menu_item_get_active
(GTK_CHECK_MENU_ITEM(widget));
editors = gummi_get_all_editors();
ectotal = g_list_length(editors);
for (i = 0; i < ectotal; i++) {
ec = g_list_nth_data(editors, i);
if (activate) {
editor_activate_spellchecking(ec, TRUE);
} else {
editor_activate_spellchecking(ec, FALSE);
}
}
if (activate) config_set_value("spelling", "True");
else {
config_set_value("spelling", "False");
}
#endif
}
G_MODULE_EXPORT
void on_menu_autosync_toggled (GtkCheckMenuItem *menu_autosync, void* user) {
if (gtk_check_menu_item_get_active(menu_autosync)) {
config_set_value("autosync", "True");
} else {
config_set_value("autosync", "False");
}
}
G_MODULE_EXPORT
void on_menu_snippets_toggled (GtkWidget *widget, void *user) {
if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget))) {
slog(L_INFO, "snippets activated\n");
config_set_value ("snippets", "True");
} else {
slog(L_INFO, "snippets deactivated\n");
config_set_value ("snippets", "False");
}
}
G_MODULE_EXPORT
void on_menu_toolbar_toggled (GtkWidget *widget, void *user) {
if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget))) {
gtk_widget_show (gui->toolbar);
config_set_value ("toolbar", "True");
} else {
gtk_widget_hide (gui->toolbar);
config_set_value ("toolbar", "False");
}
}
G_MODULE_EXPORT
void on_menu_rightpane_toggled (GtkWidget *widget, void *user) {
if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget))) {
gtk_widget_show (GTK_WIDGET (gui->rightpane));
config_set_value ("rightpane", "True");
gtk_toggle_tool_button_set_active (gui->previewoff, FALSE);
} else {
gtk_widget_hide (GTK_WIDGET (gui->rightpane));
config_set_value ("rightpane", "False");
gtk_toggle_tool_button_set_active (gui->previewoff, TRUE);
}
}
G_MODULE_EXPORT
gboolean on_menu_quit_activate(void)
{
gint wx = 0, wy = 0, width = 0, height = 0;
gchar buf[16];
int i = 0;
gint length = g_list_length(gummi->tabmanager->tabs);
motion_pause_compile_thread(gummi->motion);
for (i = 0; i < length; i++) {
gtk_notebook_set_current_page(gui->tabmanagergui->notebook, i);
tabmanager_set_active_tab(i);
gint ret = check_for_save(g_active_editor);
if (GTK_RESPONSE_YES == ret) {
gui_save_file(g_active_tab, FALSE);
}
else if (GTK_RESPONSE_CANCEL == ret || GTK_RESPONSE_DELETE_EVENT == ret) {
motion_resume_compile_thread(gummi->motion);
return TRUE;
}
}
/* Stop compile thread */
if (length > 0) motion_stop_compile_thread(gummi->motion);
gboolean is_maximized;
g_object_get(gui->mainwindow, "is-maximized", &is_maximized, NULL);
if (!is_maximized) {
gtk_window_get_size(gui->mainwindow, &width, &height);
gtk_window_get_position(gui->mainwindow, &wx, &wy);
config_begin();
config_set_value("mainwindow_x", g_ascii_dtostr(buf, 16, (double)wx));
config_set_value("mainwindow_y", g_ascii_dtostr(buf, 16, (double)wy));
config_set_value("mainwindow_w", g_ascii_dtostr(buf, 16, (double)width));
config_set_value("mainwindow_h", g_ascii_dtostr(buf, 16, (double)height));
config_commit();
}
gtk_main_quit();
for (i = 0; i < length; i++)
editor_destroy(GU_TAB_CONTEXT(g_list_nth_data
(gummi->tabmanager->tabs, i))->editor);
printf(" ___ \n"
" {o,o} Thanks for using Gummi!\n"
" |)__) I welcome your feedback at:\n"
" -\"-\"- http://gummi.midnightcoding.org\n\n");
return FALSE;
}
G_MODULE_EXPORT
void toggle_textwrapping(GtkWidget* widget, void* user)
{
gboolean newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
GList* tab = gummi->tabmanager->tabs;
config_set_value("textwrapping", newval ? "True" : "False");
if (newval) {
while (tab) {
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW
(GU_TAB_CONTEXT(tab->data)->editor->view), GTK_WRAP_CHAR);
tab = g_list_next(tab);
}
gtk_widget_set_sensitive(GTK_WIDGET(gui->prefsgui->wordwrap_button),
TRUE);
} else {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
(gui->prefsgui->wordwrap_button), FALSE);
/* NOTE: gtk_text_vew_set_wrap_mode () must be placed after
* gtk_toggle_button_set_active () since gtk_toggle_button_set_active ()
* will trigger the 'activate' event of the corresponding button and
* cause wrapmode to be changed after we set it */
while (tab) {
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW
(GU_TAB_CONTEXT(tab->data)->editor->view), GTK_WRAP_NONE);
tab = g_list_next(tab);
}
gtk_widget_set_sensitive
(GTK_WIDGET(gui->prefsgui->wordwrap_button), FALSE);
}
}
G_MODULE_EXPORT
void on_combo_animated_scroll_changed(GtkWidget* widget, void* user)
{
gint selected = gtk_combo_box_get_active(GTK_COMBO_BOX(widget));
const gchar scheme[][16] = { "always", "autosync", "never" };
config_set_value("animated_scroll", scheme[selected]);
}
G_MODULE_EXPORT
void on_synctex_toggled(GtkToggleButton* widget, void* user)
{
gboolean newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
config_set_value("synctex", newval ? "True" : "False");
gtk_widget_set_sensitive(GTK_WIDGET(gui->menu_autosync), newval);
}
G_MODULE_EXPORT
void on_method_texdvipspdf_toggled(GtkToggleButton* widget, void* user)
{
if (gtk_toggle_button_get_active(widget)) {
config_set_value("compile_steps", "texdvipspdf");
slog(L_INFO, "Changed compile method to \"tex->dvi->ps->pdf\"\n");
}
}
G_MODULE_EXPORT
void toggle_compilestatus(GtkWidget* widget, void* user)
{
gboolean newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
config_set_value("compile_status", newval ? "True" : "False");
gtk_widget_set_sensitive(GTK_WIDGET(gui->prefsgui->compile_timer), newval);
gtk_toggle_tool_button_set_active(gui->previewoff, !newval);
}
G_MODULE_EXPORT
void on_typ_latexmk_toggled(GtkToggleButton* widget, void* user)
{
if (gtk_toggle_button_get_active(widget)) {
config_set_value("typesetter", "latexmk");
typesetter_setup();
}
}
G_MODULE_EXPORT
void on_autosave_value_changed(GtkWidget* widget, void* user)
{
gint newval = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widget));
gchar buf[16];
config_set_value("autosave_timer", g_ascii_dtostr(buf, 16, (double)newval));
iofunctions_reset_autosave(g_active_editor->filename);
}
GuLatex* latex_init(void)
{
GuLatex* l = g_new0(GuLatex, 1);
l->compilelog = NULL;
l->modified_since_compile = FALSE;
l->tex_version = texlive_init();
rubber_init();
latexmk_init();
/* TODO: Temp hard set of compilation options for migrating configs */
if (strlen(config_get_value("typesetter")) == 0)
config_set_value("typesetter", "pdflatex");
if (strlen(config_get_value("compile_steps")) == 0)
config_set_value("compile_steps", "texpdf");
return l;
}
G_MODULE_EXPORT
void on_compile_value_changed(GtkWidget* widget, void* user)
{
gint newval = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widget));
gchar buf[16];
config_set_value("compile_timer", g_ascii_dtostr(buf, 16, (double)newval));
previewgui_reset(gui->previewgui);
}
G_MODULE_EXPORT
void on_combo_compilescheme_changed(GtkWidget* widget, void* user)
{
gint selected = gtk_combo_box_get_active(GTK_COMBO_BOX(widget));
const gchar scheme[][16] = { "on_idle", "real_time" };
slog(L_INFO, "compile scheme set to %s\n", scheme[selected]);
config_set_value("compile_scheme", scheme[selected]);
previewgui_reset(gui->previewgui);
}
/*
* Function: config_set_line_value()
*
* Description: Set arbitrary config entry as a raw data value.
* If the length doesn't match the actual length of the field,
* nothing will be copied.
*
* Parameters: id - The id of the config value to set
* buffer - The new value to be set
* length - The number of bytes to set
* line - The line that the ID is associated with
*
* Returns: None
*/
void
config_set_line_value (int id, void *buffer, int length, int line)
{
int line_id = 0;
line_id = config_get_line_id(id, line);
if (line_id) {
config_set_value(line_id, buffer, length);
}
}
G_MODULE_EXPORT
void on_cache_size_value_changed(GtkWidget* widget, void* user)
{
gint newval = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widget));
gchar buf[16];
config_set_value("cache_size", g_ascii_dtostr(buf, 16, (double)newval));
g_idle_add((GSourceFunc) run_garbage_collector, gui->previewgui);
}
G_MODULE_EXPORT
void toggle_linenumbers(GtkWidget* widget, void* user)
{
gboolean newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
GList* tab = gummi->tabmanager->tabs;
config_set_value("line_numbers", newval ? "True" : "False");
while (tab) {
gtk_source_view_set_show_line_numbers(GTK_SOURCE_VIEW
(GU_TAB_CONTEXT(tab->data)->editor->view), newval);
tab = g_list_next(tab);
}
}
G_MODULE_EXPORT
void toggle_autoindentation(GtkWidget* widget, void* user)
{
gboolean newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
GList* tab = gummi->tabmanager->tabs;
config_set_value("autoindentation", newval ? "True" : "False");
while (tab) {
gtk_source_view_set_auto_indent
(GU_TAB_CONTEXT(tab->data)->editor->view, newval);
tab = g_list_next(tab);
}
}
G_MODULE_EXPORT
void on_tabwidth_value_changed(GtkWidget* widget, void* user)
{
gint newval = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widget));
gchar buf[16];
GList* tab = gummi->tabmanager->tabs;
config_set_value("tabwidth", g_ascii_dtostr(buf, 16, (double)newval));
while (tab) {
gtk_source_view_set_tab_width(GU_TAB_CONTEXT(tab->data)->editor->view,
newval);
tab = g_list_next(tab);
}
}
G_MODULE_EXPORT
void on_editor_font_set(GtkWidget* widget, void* user)
{
const gchar* font = gtk_font_button_get_font_name(GTK_FONT_BUTTON(widget));
PangoFontDescription* font_desc = pango_font_description_from_string(font);
GList* tab = gummi->tabmanager->tabs;
slog(L_INFO, "setting font to %s\n", font);
config_set_value("font", font);
while (tab) {
editor_set_font(GU_TAB_CONTEXT(tab->data)->editor, font);
tab = g_list_next(tab);
}
pango_font_description_free(font_desc);
}
G_MODULE_EXPORT
void toggle_wordwrapping(GtkWidget* widget, void* user)
{
gboolean newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
GList* tab = gummi->tabmanager->tabs;
config_set_value("wordwrapping", newval ? "True" : "False");
while (tab) {
if (newval)
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW
(GU_TAB_CONTEXT(tab->data)->editor->view), GTK_WRAP_WORD);
else
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW
(GU_TAB_CONTEXT(tab->data)->editor->view), GTK_WRAP_CHAR);
tab = g_list_next(tab);
}
}
G_MODULE_EXPORT
void toggle_autosaving(GtkWidget* widget, void* user)
{
gboolean newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
config_set_value("autosaving", newval ? "True" : "False");
if (newval) {
gtk_widget_set_sensitive(
GTK_WIDGET(gui->prefsgui->autosave_timer), TRUE);
gint time = atoi(config_get_value("autosave_timer"));
gtk_spin_button_set_value(gui->prefsgui->autosave_timer, time);
iofunctions_reset_autosave(g_active_editor->filename);
} else {
gtk_widget_set_sensitive(
GTK_WIDGET(gui->prefsgui->autosave_timer), FALSE);
iofunctions_stop_autosave();
}
}
void latex_update_pdffile(GuLatex* lc, GuEditor* ec)
{
static glong cerrors = 0;
gchar* basename = ec->basename;
gchar* filename = ec->filename;
if (!lc->modified_since_compile) {
lc->compile_status = cerrors == 0;
}
const gchar* typesetter = config_get_value("typesetter");
if (!external_exists(typesetter)) {
/* Set to default first detected typesetter */
config_set_value("typesetter", "pdflatex");
}
/* create compile command */
gchar* curdir = g_path_get_dirname(ec->targetfile);
gchar *command = latex_set_compile_cmd(ec);
slog(L_DEBUG, "Command: %s\n", command);
g_free(lc->compilelog);
memset(lc->errorlines, 0, BUFSIZ);
/* run pdf compilation */
Tuple2 cresult = utils_popen_r(command, curdir);
cerrors = (glong)cresult.first;
gchar* coutput = (gchar*)cresult.second;
lc->compilelog = latex_analyse_log(coutput, filename, basename);
lc->modified_since_compile = FALSE;
/* find error line */
if (cerrors && (g_utf8_strlen(lc->compilelog, -1) != 0)) {
latex_analyse_errors(lc);
}
g_free(command);
g_free(curdir);
lc->compile_status = cerrors == 0;
}
G_MODULE_EXPORT
void on_combo_language_changed(GtkComboBoxText* widget, void* user)
{
#ifdef USE_GTKSPELL
gchar* selected = gtk_combo_box_text_get_active_text((widget));
GList* tab = gummi->tabmanager->tabs;
config_set_value("spell_language", selected);
if (config_get_value("spelling")) {
while (tab) {
editor_activate_spellchecking(GU_TAB_CONTEXT(tab->data)->editor,
FALSE);
editor_activate_spellchecking(GU_TAB_CONTEXT(tab->data)->editor,
TRUE);
tab = g_list_next(tab);
}
}
#endif
}
G_MODULE_EXPORT
void on_styleschemes_treeview_cursor_changed(GtkTreeView* treeview,
void* user)
{
gchar* id = NULL;
gchar* name = NULL;
GList* tab = gummi->tabmanager->tabs;
GtkTreeIter iter;
GtkTreeModel* model = GTK_TREE_MODEL(gtk_tree_view_get_model(treeview));
GtkTreeSelection* selection = gtk_tree_view_get_selection(treeview);
gtk_tree_selection_get_selected(selection, &model, &iter);
gtk_tree_model_get(model, &iter, 0, &name, 1, &id, -1);
tab = gummi->tabmanager->tabs;
while (tab) {
editor_set_style_scheme_by_id(GU_TAB_CONTEXT(tab->data)->editor, id);
tab = g_list_next(tab);
}
config_set_value("style_scheme", id);
}
void config_set(char *section, const char *token, char *value) {
config_set_value(oscam_conf, section, token, value, &cfg);
}
GummiGui* gui_init(GtkBuilder* builder)
{
g_return_val_if_fail(GTK_IS_BUILDER(builder), NULL);
GtkWidget* hpaned;
gint i = 0, wx = 0, wy = 0, width = 0, height = 0;
GummiGui* g = g_new0(GummiGui, 1);
g->builder = builder;
g->mainwindow =
GTK_WINDOW(gtk_builder_get_object(builder, "mainwindow"));
g->toolbar =
GTK_WIDGET(gtk_builder_get_object(builder, "maintoolbar"));
g->statusbar =
GTK_STATUSBAR(gtk_builder_get_object(builder, "statusbar"));
g->rightpane =
GTK_BOX(gtk_builder_get_object(builder, "rightpanebox"));
g->previewoff = GTK_TOGGLE_TOOL_BUTTON(
gtk_builder_get_object(builder, "tool_previewoff"));
g->errorview =
GTK_TEXT_VIEW(gtk_builder_get_object(builder, "errorview"));
g->errorbuff =
gtk_text_view_get_buffer(GTK_TEXT_VIEW(g->errorview));
g_object_ref(g->errorbuff);
g->menu_spelling =
GTK_CHECK_MENU_ITEM(gtk_builder_get_object(builder, "menu_spelling"));
g->menu_snippets =
GTK_CHECK_MENU_ITEM(gtk_builder_get_object(builder, "menu_snippets"));
g->menu_toolbar =
GTK_CHECK_MENU_ITEM(gtk_builder_get_object(builder, "menu_toolbar"));
g->menu_statusbar =
GTK_CHECK_MENU_ITEM(gtk_builder_get_object(builder, "menu_statusbar"));
g->menu_rightpane =
GTK_CHECK_MENU_ITEM(gtk_builder_get_object(builder, "menu_rightpane"));
g->statusid =
gtk_statusbar_get_context_id(GTK_STATUSBAR(g->statusbar), "Gummi");
g->recent[0] =
GTK_MENU_ITEM(gtk_builder_get_object(builder, "menu_recent1"));
g->recent[1] =
GTK_MENU_ITEM(gtk_builder_get_object(builder, "menu_recent2"));
g->recent[2] =
GTK_MENU_ITEM(gtk_builder_get_object(builder, "menu_recent3"));
g->recent[3] =
GTK_MENU_ITEM(gtk_builder_get_object(builder, "menu_recent4"));
g->recent[4] =
GTK_MENU_ITEM(gtk_builder_get_object(builder, "menu_recent5"));
g->docstatswindow =
GTK_WIDGET(gtk_builder_get_object(builder, "docstatswindow"));
g->menu_runbibtex =
GTK_MENU_ITEM(gtk_builder_get_object(builder, "menu_runbibtex"));
g->menu_runmakeindex =
GTK_MENU_ITEM(gtk_builder_get_object(builder, "menu_runmakeindex"));
g->bibcompile =
GTK_WIDGET(gtk_builder_get_object(builder, "bibcompile"));
g->insens_widget_size = sizeof(insens_widgets_str) / sizeof(gchar*);
g->insens_widgets = g_new0(GtkWidget*, g->insens_widget_size);
for (i = 0; i < g->insens_widget_size; ++i)
g->insens_widgets[i] =
GTK_WIDGET(gtk_builder_get_object(builder, insens_widgets_str[i]));
g->menugui = menugui_init(builder);
g->importgui = importgui_init(builder);
g->previewgui = previewgui_init(builder);
g->searchgui = searchgui_init(builder);
g->prefsgui = prefsgui_init(g->mainwindow);
g->snippetsgui = snippetsgui_init(g->mainwindow);
g->tabmanagergui = tabmanagergui_init(builder);
g->infoscreengui = infoscreengui_init(builder);
g->projectgui = projectgui_init(builder);
gchar* icon_file = g_build_filename(GUMMI_DATA, "icons", "icon.png", NULL);
gtk_window_set_icon_from_file(g->mainwindow, icon_file, NULL);
g_free(icon_file);
if (config_get_value("window_maximized")) {
gtk_window_maximize(g->mainwindow);
} else {
gtk_window_resize(g->mainwindow,
atoi(config_get_value("mainwindow_w")),
atoi(config_get_value("mainwindow_h")));
}
gtk_window_set_default_size(g->mainwindow,
atoi(config_get_value("mainwindow_w")),
atoi(config_get_value("mainwindow_h")));
wx = atoi(config_get_value("mainwindow_x"));
wy = atoi(config_get_value("mainwindow_y"));
if (wx && wy)
gtk_window_move(g->mainwindow, wx, wy);
else
gtk_window_set_position(g->mainwindow, GTK_WIN_POS_CENTER);
/* Set errorview font */
GtkCssProvider* css = gtk_css_provider_new();
GtkStyleContext* context = gtk_widget_get_style_context(
GTK_WIDGET(g->errorview));
gtk_style_context_add_provider(context,
GTK_STYLE_PROVIDER(css),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
const gchar* style = "* { font: Monospace 8; }";
gtk_css_provider_load_from_data(css, style, -1, NULL);
/* Set pane size */
gtk_window_get_size(g->mainwindow, &width, &height);
hpaned = GTK_WIDGET(gtk_builder_get_object(builder, "hpaned"));
gtk_paned_set_position(GTK_PANED(hpaned), (width / 2));
#ifndef USE_GTKSPELL
gtk_widget_set_sensitive(GTK_WIDGET(g->menu_spelling), FALSE);
#else
if (config_get_value("spelling"))
gtk_check_menu_item_set_active(g->menu_spelling, TRUE);
#endif
if (config_get_value("snippets")) {
gtk_check_menu_item_set_active(g->menu_snippets, TRUE);
gtk_widget_show(GTK_WIDGET(g->menu_snippets));
}
if (config_get_value("toolbar")) {
gtk_check_menu_item_set_active(g->menu_toolbar, TRUE);
gtk_widget_show(g->toolbar);
} else {
config_set_value("toolbar", "False");
gtk_check_menu_item_set_active(g->menu_toolbar, FALSE);
gtk_widget_hide(g->toolbar);
}
if (config_get_value("statusbar")) {
gtk_check_menu_item_set_active(g->menu_statusbar, TRUE);
gtk_widget_show(GTK_WIDGET(g->statusbar));
} else {
config_set_value("statusbar", "False");
gtk_check_menu_item_set_active(g->menu_statusbar, FALSE);
gtk_widget_hide(GTK_WIDGET(g->statusbar));
}
if (config_get_value("rightpane")) {
gtk_check_menu_item_set_active(g->menu_rightpane, TRUE);
gtk_widget_show(GTK_WIDGET(g->rightpane));
} else {
config_set_value("compile_status", "False");
gtk_toggle_tool_button_set_active(g->previewoff, FALSE);
gtk_widget_hide(GTK_WIDGET(g->rightpane));
}
g->menu_autosync =
GTK_CHECK_MENU_ITEM(gtk_builder_get_object(builder, "menu_autosync"));
if (latex_can_synctex() && config_get_value("synctex")) {
gtk_widget_set_sensitive(GTK_WIDGET(g->menu_autosync), TRUE);
gboolean async = latex_use_synctex();
gtk_check_menu_item_set_active(g->menu_autosync, (async ? TRUE : FALSE));
}
if (!config_get_value("compile_status"))
gtk_toggle_tool_button_set_active(g->previewoff, TRUE);
g->recent_list[0] = g_strdup(config_get_value("recent1"));
g->recent_list[1] = g_strdup(config_get_value("recent2"));
g->recent_list[2] = g_strdup(config_get_value("recent3"));
g->recent_list[3] = g_strdup(config_get_value("recent4"));
g->recent_list[4] = g_strdup(config_get_value("recent5"));
display_recent_files(g);
return g;
}
G_MODULE_EXPORT
void toggle_shellescape(GtkToggleButton* widget, void* user)
{
gboolean newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
config_set_value("shellescape", newval ? "True" : "False");
}
