void cb_page_widget_image_selected(ZathuraPage* page, GdkPixbuf* pixbuf, void* data) { g_return_if_fail(page != NULL); g_return_if_fail(pixbuf != NULL); g_return_if_fail(data != NULL); zathura_t* zathura = data; GdkAtom* selection = get_selection(zathura); if (selection != NULL) { gtk_clipboard_set_image(gtk_clipboard_get(*selection), pixbuf); bool notification = true; girara_setting_get(zathura->ui.session, "selection-notification", ¬ification); if (notification == true) { char* target = NULL; girara_setting_get(zathura->ui.session, "selection-clipboard", &target); char* escaped_text = g_markup_printf_escaped( _("Copied selected image to selection %s"), target); g_free(target); girara_notify(zathura->ui.session, GIRARA_INFO, "%s", escaped_text); } g_free(selection); } }
void cb_page_widget_scaled_button_release(ZathuraPage* page_widget, GdkEventButton* event, void* data) { if (event->button != 1 || !(event->state & GDK_CONTROL_MASK)) { return; } zathura_t* zathura = data; bool synctex = false; girara_setting_get(zathura->ui.session, "synctex", &synctex); if (synctex == false) { return; } zathura_page_t* page = zathura_page_widget_get_page(page_widget); if (zathura->dbus != NULL) { zathura_dbus_edit(zathura->dbus, zathura_page_get_index(page), event->x, event->y); } char* editor = NULL; girara_setting_get(zathura->ui.session, "synctex-editor-command", &editor); if (editor == NULL || *editor == '\0') { g_free(editor); return; } synctex_edit(editor, page, event->x, event->y); g_free(editor); }
bool sc_zoom(girara_session_t* session, girara_argument_t* argument, girara_event_t* UNUSED(event), unsigned int t) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; g_return_val_if_fail(argument != NULL, false); g_return_val_if_fail(zathura->document != NULL, false); zathura_document_set_adjust_mode(zathura->document, ZATHURA_ADJUST_NONE); /* retreive zoom step value */ int value = 1; girara_setting_get(zathura->ui.session, "zoom-step", &value); int nt = (t == 0) ? 1 : t; float zoom_step = value / 100.0f * nt; float old_zoom = zathura_document_get_scale(zathura->document); /* specify new zoom value */ if (argument->n == ZOOM_IN) { zathura_document_set_scale(zathura->document, old_zoom + zoom_step); } else if (argument->n == ZOOM_OUT) { zathura_document_set_scale(zathura->document, old_zoom - zoom_step); } else if (argument->n == ZOOM_SPECIFIC) { if (t == 0) { zathura_document_set_scale(zathura->document, 1.0f); } else { zathura_document_set_scale(zathura->document, t / 100.0f); } } else { zathura_document_set_scale(zathura->document, 1.0f); } /* zoom limitations */ int zoom_min_int = 10; int zoom_max_int = 1000; girara_setting_get(session, "zoom-min", &zoom_min_int); girara_setting_get(session, "zoom-max", &zoom_max_int); float zoom_min = zoom_min_int * 0.01f; float zoom_max = zoom_max_int * 0.01f; float scale = zathura_document_get_scale(zathura->document); if (scale < zoom_min) { zathura_document_set_scale(zathura->document, zoom_min); } else if (scale > zoom_max) { zathura_document_set_scale(zathura->document, zoom_max); } /* keep position */ readjust_view_after_zooming(zathura, old_zoom, true); render_all(zathura); return false; }
bool sc_navigate(girara_session_t* session, girara_argument_t* argument, girara_event_t* UNUSED(event), unsigned int t) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; g_return_val_if_fail(argument != NULL, false); g_return_val_if_fail(zathura->document != NULL, false); int number_of_pages = zathura_document_get_number_of_pages(zathura->document); int new_page = zathura_document_get_current_page_number(zathura->document); bool scroll_wrap = false; girara_setting_get(session, "scroll-wrap", &scroll_wrap); bool columns_per_row_offset = false; girara_setting_get(session, "advance-pages-per-row", &columns_per_row_offset); int offset = 1; if (columns_per_row_offset == true) { girara_setting_get(session, "pages-per-row", &offset); } t = (t == 0) ? (unsigned int) offset : t; if (argument->n == NEXT) { if (scroll_wrap == false) { new_page = new_page + t; } else { new_page = (new_page + t) % number_of_pages; } } else if (argument->n == PREVIOUS) { if (scroll_wrap == false) { new_page = new_page - t; } else { new_page = (new_page + number_of_pages - t) % number_of_pages; } } if (!scroll_wrap) { if (new_page <= 0) { new_page = 0; } else if (new_page >= number_of_pages) { new_page = number_of_pages - 1; } } page_set(zathura, new_page); return false; }
bool sc_navigate(girara_session_t* session, girara_argument_t* argument, girara_event_t* UNUSED(event), unsigned int t) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; g_return_val_if_fail(argument != NULL, false); g_return_val_if_fail(zathura->document != NULL, false); int number_of_pages = zathura_document_get_number_of_pages(zathura->document); int new_page = zathura_document_get_current_page_number(zathura->document); bool scroll_wrap = false; girara_setting_get(session, "scroll-wrap", &scroll_wrap); bool columns_per_row_offset = false; girara_setting_get(session, "advance-pages-per-row", &columns_per_row_offset); int offset = 1; if (columns_per_row_offset == true) { girara_setting_get(session, "pages-per-row", &offset); } t = (t == 0) ? (unsigned int) offset : t; if (argument->n == NEXT) { if (scroll_wrap == false) { new_page = new_page + t; } else { new_page = (new_page + t) % number_of_pages; } } else if (argument->n == PREVIOUS) { if (scroll_wrap == false) { new_page = new_page - t; } else { new_page = (new_page + number_of_pages - t) % number_of_pages; } } if ((new_page < 0 || new_page >= number_of_pages) && !scroll_wrap) { return false; } page_set(zathura, new_page); /* adjust horizontal position */ GtkAdjustment* hadjustment = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(session->gtk.view)); cb_view_hadjustment_changed(hadjustment, zathura); return false; }
static void init_database(zathura_t* zathura) { char* database = NULL; girara_setting_get(zathura->ui.session, "database", &database); if (g_strcmp0(database, "plain") == 0) { girara_debug("Using plain database backend."); zathura->database = zathura_plaindatabase_new(zathura->config.data_dir); #ifdef WITH_SQLITE } else if (g_strcmp0(database, "sqlite") == 0) { girara_debug("Using sqlite database backend."); char* tmp = g_build_filename(zathura->config.data_dir, "bookmarks.sqlite", NULL); zathura->database = zathura_sqldatabase_new(tmp); g_free(tmp); #endif } else if (g_strcmp0(database, "null") != 0) { girara_error("Database backend '%s' is not supported.", database); } if (zathura->database == NULL && g_strcmp0(database, "null") != 0) { girara_error( "Unable to initialize database. Bookmarks won't be available."); } else { g_object_set(G_OBJECT(zathura->ui.session->command_history), "io", zathura->database, NULL); } g_free(database); }
bool sc_toggle_page_mode(girara_session_t* session, girara_argument_t* UNUSED(argument), girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; if (zathura->document == NULL) { girara_notify(session, GIRARA_WARNING, _("No document opened.")); return false; } int pages_per_row = 1; girara_setting_get(zathura->ui.session, "pages-per-row", &pages_per_row); static int tmp = 2; int value = 1; if (pages_per_row == 1) { value = tmp; } else { tmp = pages_per_row; } girara_setting_set(zathura->ui.session, "pages-per-row", &value); return true; }
bool sc_toggle_page_mode(girara_session_t* session, girara_argument_t* UNUSED(argument), girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; if (zathura->document == NULL) { girara_notify(session, GIRARA_WARNING, _("No document opened.")); return false; } unsigned int page_id = zathura_document_get_current_page_number(zathura->document); int pages_per_row = 1; girara_setting_get(zathura->ui.session, "pages-per-row", &pages_per_row); int value = 1; if (pages_per_row == 1) { value = zathura->shortcut.toggle_page_mode.pages; } else { zathura->shortcut.toggle_page_mode.pages = pages_per_row; } girara_setting_set(zathura->ui.session, "pages-per-row", &value); adjust_view(zathura); page_set(zathura, page_id); render_all(zathura); refresh_view(zathura); return true; }
bool sc_abort(girara_session_t* session, girara_argument_t* UNUSED(argument), girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; bool clear_search = true; girara_setting_get(session, "abort-clear-search", &clear_search); if (zathura->document != NULL) { unsigned int number_of_pages = zathura_document_get_number_of_pages(zathura->document); for (unsigned int page_id = 0; page_id < number_of_pages; ++page_id) { zathura_page_t* page = zathura_document_get_page(zathura->document, page_id); if (page == NULL) { continue; } GtkWidget* page_widget = zathura_page_get_widget(zathura, page); g_object_set(page_widget, "draw-links", FALSE, NULL); if (clear_search == true) { g_object_set(page_widget, "draw-search-results", FALSE, NULL); } } } /* Setting the mode back here has not worked for ages. We need another way to * do this. Let's disable this for now. */ /* girara_mode_set(session, session->modes.normal); */ girara_sc_abort(session, NULL, NULL, 0); return false; }
bool sc_abort(girara_session_t* session, girara_argument_t* UNUSED(argument), girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; bool clear_search = true; girara_setting_get(session, "abort-clear-search", &clear_search); if (zathura->document != NULL) { unsigned int number_of_pages = zathura_document_get_number_of_pages(zathura->document); for (unsigned int page_id = 0; page_id < number_of_pages; ++page_id) { zathura_page_t* page = zathura_document_get_page(zathura->document, page_id); if (page == NULL) { continue; } g_object_set(zathura_page_get_widget(zathura, page), "draw-links", FALSE, NULL); if (clear_search == true) { g_object_set(zathura_page_get_widget(zathura, page), "search-results", NULL, NULL); } } } girara_mode_set(session, session->modes.normal); girara_sc_abort(session, NULL, NULL, 0); return false; }
static void init_css(zathura_t* zathura) { GiraraTemplate* csstemplate = girara_session_get_template(zathura->ui.session); static const char* index_settings[] = { "index-fg", "index-bg", "index-active-fg", "index-active-bg" }; for (size_t s = 0; s < LENGTH(index_settings); ++s) { girara_template_add_variable(csstemplate, index_settings[s]); char* tmp_value = NULL; GdkRGBA rgba = {0, 0, 0, 0}; girara_setting_get(zathura->ui.session, index_settings[s], &tmp_value); if (tmp_value != NULL) { gdk_rgba_parse(&rgba, tmp_value); g_free(tmp_value); } char* color = gdk_rgba_to_string(&rgba); girara_template_set_variable_value(csstemplate, index_settings[s], color); g_free(color); } char* css = g_strdup_printf("%s\n%s", girara_template_get_base(csstemplate), CSS_TEMPLATE_INDEX); girara_template_set_base(csstemplate, css); g_free(css); }
bool sc_zoom(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; g_return_val_if_fail(argument != NULL, false); g_return_val_if_fail(zathura->document != NULL, false); zathura_document_set_adjust_mode(zathura->document, ZATHURA_ADJUST_NONE); /* retrieve zoom step value */ int value = 1; girara_setting_get(zathura->ui.session, "zoom-step", &value); const int nt = (t == 0) ? 1 : t; const double zoom_step = 1.0 + value / 100.0 * nt; const double old_zoom = zathura_document_get_scale(zathura->document); /* specify new zoom value */ if (argument->n == ZOOM_IN) { girara_debug("Increasing zoom by %f.", zoom_step - 1.0); zathura_document_set_scale(zathura->document, old_zoom * zoom_step); } else if (argument->n == ZOOM_OUT) { girara_debug("Decreasing zoom by %f.", zoom_step - 1.0); zathura_document_set_scale(zathura->document, old_zoom / zoom_step); } else if (argument->n == ZOOM_SPECIFIC) { if (t == 0) { girara_debug("Setting zoom to 1."); zathura_document_set_scale(zathura->document, 1.0); } else { girara_debug("Setting zoom to %f.", t / 100.0); zathura_document_set_scale(zathura->document, t / 100.0); } } else if (argument->n == ZOOM_SMOOTH) { const double dy = (event != NULL) ? event->y : 1.0; girara_debug("Increasing zoom by %f.", zoom_step * dy - 1.0); zathura_document_set_scale(zathura->document, old_zoom + zoom_step * dy); } else { girara_debug("Setting zoom to 1."); zathura_document_set_scale(zathura->document, 1.0); } /* zoom limitations */ const double scale = zathura_document_get_scale(zathura->document); zathura_document_set_scale(zathura->document, zathura_correct_scale_value(session, scale)); const double new_zoom = zathura_document_get_scale(zathura->document); if (fabs(new_zoom - old_zoom) <= DBL_EPSILON) { girara_debug("New and old zoom level are too close: %f vs. %f, diff = %f", new_zoom, old_zoom, fabs(new_zoom - old_zoom)); return false; } girara_debug("Re-rendering with new zoom level %f.", new_zoom); render_all(zathura); refresh_view(zathura); return false; }
void cb_page_layout_value_changed(girara_session_t* session, const char* name, girara_setting_type_t UNUSED(type), void* value, void* UNUSED(data)) { g_return_if_fail(value != NULL); g_return_if_fail(session != NULL); g_return_if_fail(session->global.data != NULL); zathura_t* zathura = session->global.data; /* pages-per-row must not be 0 */ if (g_strcmp0(name, "pages-per-row") == 0) { unsigned int pages_per_row = *((unsigned int*) value); if (pages_per_row == 0) { pages_per_row = 1; girara_setting_set(session, name, &pages_per_row); girara_notify(session, GIRARA_WARNING, _("'%s' must not be 0. Set to 1."), name); return; } } if (zathura->document == NULL) { /* no document has been openend yet */ return; } unsigned int pages_per_row = 1; girara_setting_get(session, "pages-per-row", &pages_per_row); /* get list of first_page_column settings */ char* first_page_column_list = NULL; girara_setting_get(session, "first-page-column", &first_page_column_list); /* find value for first_page_column */ unsigned int first_page_column = find_first_page_column(first_page_column_list, pages_per_row); g_free(first_page_column_list); unsigned int page_padding = 1; girara_setting_get(zathura->ui.session, "page-padding", &page_padding); bool page_right_to_left = false; girara_setting_get(zathura->ui.session, "page-right-to-left", &page_right_to_left); page_widget_set_mode(zathura, page_padding, pages_per_row, first_page_column, page_right_to_left); zathura_document_set_page_layout(zathura->document, page_padding, pages_per_row, first_page_column); }
bool zathura_init(zathura_t* zathura) { if (zathura == NULL) { return false; } /* create zathura (config/data) directory */ create_directories(zathura); /* load plugins */ zathura_plugin_manager_load(zathura->plugins.manager); /* configuration */ config_load_default(zathura); config_load_files(zathura); /* UI */ if (!init_ui(zathura)) { goto error_free; } /* database */ init_database(zathura); /* bookmarks */ zathura->bookmarks.bookmarks = girara_sorted_list_new2( (girara_compare_function_t)zathura_bookmarks_compare, (girara_free_function_t)zathura_bookmark_free); /* jumplist */ init_jumplist(zathura); /* CSS for index mode */ init_css(zathura); /* Shortcut helpers */ init_shortcut_helpers(zathura); /* Start D-Bus service */ bool dbus = true; girara_setting_get(zathura->ui.session, "dbus-service", &dbus); if (dbus == true) { zathura->dbus = zathura_dbus_new(zathura); } return true; error_free: if (zathura->ui.page_widget != NULL) { g_object_unref(zathura->ui.page_widget); } return false; }
void cb_view_vadjustment_value_changed(GtkAdjustment* GIRARA_UNUSED(adjustment), gpointer data) { zathura_t* zathura = data; if (zathura == NULL || zathura->document == NULL || zathura->ui.page_widget == NULL) { return; } GtkAdjustment* view_vadjustment = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(zathura->ui.session->gtk.view)); GtkAdjustment* view_hadjustment = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(zathura->ui.session->gtk.view)); GdkRectangle view_rect; /* get current adjustment values */ view_rect.y = 0; view_rect.height = gtk_adjustment_get_page_size(view_vadjustment); view_rect.x = 0; view_rect.width = gtk_adjustment_get_page_size(view_hadjustment); int page_padding = 1; girara_setting_get(zathura->ui.session, "page-padding", &page_padding); GdkRectangle center; center.x = (view_rect.width + 1) / 2; center.y = (view_rect.height + 1) / 2; center.height = center.width = (2 * page_padding) + 1; unsigned int number_of_pages = zathura_document_get_number_of_pages(zathura->document); double scale = zathura_document_get_scale(zathura->document); bool updated = false; /* find page that fits */ for (unsigned int page_id = 0; page_id < number_of_pages; page_id++) { zathura_page_t* page = zathura_document_get_page(zathura->document, page_id); GdkRectangle page_rect; GtkWidget* page_widget = zathura_page_get_widget(zathura, page); gtk_widget_translate_coordinates(page_widget, zathura->ui.session->gtk.view, 0, 0, &page_rect.x, &page_rect.y); page_rect.width = zathura_page_get_width(page) * scale; page_rect.height = zathura_page_get_height(page) * scale; if (gdk_rectangle_intersect(&view_rect, &page_rect, NULL) == TRUE) { zathura_page_set_visibility(page, true); if (zathura->global.update_page_number == true && updated == false && gdk_rectangle_intersect(¢er, &page_rect, NULL) == TRUE) { zathura_document_set_current_page_number(zathura->document, page_id); updated = true; } } else { zathura_page_set_visibility(page, false); } zathura_page_widget_update_view_time(ZATHURA_PAGE(page_widget)); } statusbar_page_number_update(zathura); }
static void init_jumplist(zathura_t* zathura) { int jumplist_size = 20; girara_setting_get(zathura->ui.session, "jumplist-size", &jumplist_size); zathura->jumplist.max_size = jumplist_size < 0 ? 0 : jumplist_size; zathura->jumplist.list = NULL; zathura->jumplist.size = 0; zathura->jumplist.cur = NULL; }
void cb_page_widget_scaled_button_release(ZathuraPage* page_widget, GdkEventButton* event, void* data) { zathura_t* zathura = data; zathura_page_t* page = zathura_page_widget_get_page(page_widget); /* set page number (but don't scroll there. it was clicked on, so it's visible) */ if (event->button == GDK_BUTTON_PRIMARY) { zathura_document_set_current_page_number(zathura->document, zathura_page_get_index(page)); refresh_view(zathura); } if (event->button != GDK_BUTTON_PRIMARY || !(event->state & GDK_CONTROL_MASK)) { return; } bool synctex = false; girara_setting_get(zathura->ui.session, "synctex", &synctex); if (synctex == false) { return; } if (zathura->dbus != NULL) { zathura_dbus_edit(zathura->dbus, zathura_page_get_index(page), event->x, event->y); } char* editor = NULL; girara_setting_get(zathura->ui.session, "synctex-editor-command", &editor); if (editor == NULL || *editor == '\0') { girara_debug("No SyncTeX editor specified."); g_free(editor); return; } synctex_edit(editor, page, event->x, event->y); g_free(editor); }
bool sc_recolor(girara_session_t* session, girara_argument_t* UNUSED(argument), girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); bool value = false; girara_setting_get(session, "recolor", &value); value = !value; girara_setting_set(session, "recolor", &value); return false; }
void cb_page_widget_text_selected(ZathuraPage* page, const char* text, void* data) { g_return_if_fail(page != NULL); g_return_if_fail(text != NULL); g_return_if_fail(data != NULL); zathura_t* zathura = data; girara_mode_t mode = girara_mode_get(zathura->ui.session); if (mode != zathura->modes.normal && mode != zathura->modes.fullscreen) { return; } GdkAtom* selection = get_selection(zathura); /* copy to clipboard */ if (selection != NULL) { gtk_clipboard_set_text(gtk_clipboard_get(*selection), text, -1); bool notification = true; girara_setting_get(zathura->ui.session, "selection-notification", ¬ification); if (notification == true) { char* target = NULL; girara_setting_get(zathura->ui.session, "selection-clipboard", &target); char* stripped_text = g_strdelimit(g_strdup(text), "\n\t\r\n", ' '); char* escaped_text = g_markup_printf_escaped( _("Copied selected text to selection %s: %s"), target, stripped_text); g_free(target); g_free(stripped_text); girara_notify(zathura->ui.session, GIRARA_INFO, "%s", escaped_text); g_free(escaped_text); } } g_free(selection); }
bool cmd_tabopen(girara_session_t* session, girara_list_t* argument_list) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); jumanji_t* jumanji = (jumanji_t*) session->global.data; char* url = jumanji_build_url(jumanji, argument_list); bool focus_new_tabs; girara_setting_get(jumanji->ui.session, "focus-new-tabs", &focus_new_tabs); jumanji_tab_new(jumanji, url, focus_new_tabs); free(url); return true; }
void zathura_get_document_size(zathura_t* zathura, unsigned int cell_height, unsigned int cell_width, unsigned int* height, unsigned int* width) { g_return_if_fail(zathura != NULL && zathura->document != NULL && height != NULL && width != NULL); unsigned int pages_per_row = 1; girara_setting_get(zathura->ui.session, "pages-per-row", &pages_per_row); if (pages_per_row == 0) pages_per_row = 1; unsigned int first_page_column = 1; girara_setting_get(zathura->ui.session, "first-page-column", &first_page_column); if (first_page_column < 1) first_page_column = 1; if (first_page_column > pages_per_row) first_page_column = (first_page_column - 1) % pages_per_row + 1; int padding = 1; girara_setting_get(zathura->ui.session, "page-padding", &padding); double scale = zathura_document_get_scale(zathura->document); cell_height = ceil(cell_height * scale); cell_width = ceil(cell_width * scale); *width = pages_per_row * cell_width + (pages_per_row - 1) * padding; unsigned int effective_number_of_pages = zathura_document_get_number_of_pages(zathura->document) + first_page_column - 1; unsigned int rows = effective_number_of_pages / pages_per_row + (effective_number_of_pages % pages_per_row ? 1 : 0); *height = rows * cell_height + (rows - 1) * padding; }
void cb_first_page_column_value_changed(girara_session_t* session, const char* UNUSED(name), girara_setting_type_t UNUSED(type), void* value, void* UNUSED(data)) { g_return_if_fail(value != NULL); g_return_if_fail(session != NULL); g_return_if_fail(session->global.data != NULL); zathura_t* zathura = session->global.data; int first_page_column = *(int*) value; if (first_page_column < 1) { first_page_column = 1; } unsigned int pages_per_row = 1; girara_setting_get(session, "pages-per-row", &pages_per_row); page_widget_set_mode(zathura, pages_per_row, first_page_column); if (zathura->document != NULL) { unsigned int current_page = zathura_document_get_current_page_number(zathura->document); page_set_delayed(zathura, current_page); } }
bool sc_search(girara_session_t* session, girara_argument_t* argument, girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; g_return_val_if_fail(argument != NULL, false); g_return_val_if_fail(zathura->document != NULL, false); const unsigned int num_pages = zathura_document_get_number_of_pages(zathura->document); const unsigned int cur_page = zathura_document_get_current_page_number(zathura->document); GtkWidget *cur_page_widget = zathura_page_get_widget(zathura, zathura_document_get_page(zathura->document, cur_page)); bool nohlsearch, first_time_after_abort; gboolean draw; nohlsearch = first_time_after_abort = false; draw = FALSE; girara_setting_get(session, "nohlsearch", &nohlsearch); if (nohlsearch == false) { g_object_get(G_OBJECT(cur_page_widget), "draw-search-results", &draw, NULL); if (draw == false) { first_time_after_abort = true; } document_draw_search_results(zathura, true); } int diff = argument->n == FORWARD ? 1 : -1; if (zathura->global.search_direction == BACKWARD) diff = -diff; zathura_page_t* target_page = NULL; int target_idx = 0; for (unsigned int page_id = 0; page_id < num_pages; ++page_id) { int tmp = cur_page + diff * page_id; zathura_page_t* page = zathura_document_get_page(zathura->document, (tmp + num_pages) % num_pages); if (page == NULL) { continue; } GtkWidget* page_widget = zathura_page_get_widget(zathura, page); int num_search_results = 0, current = -1; g_object_get(G_OBJECT(page_widget), "search-current", ¤t, "search-length", &num_search_results, NULL); if (num_search_results == 0 || current == -1) { continue; } if (first_time_after_abort == true || (tmp + num_pages) % num_pages != cur_page) { target_page = page; target_idx = diff == 1 ? 0 : num_search_results - 1; break; } if (diff == 1 && current < num_search_results - 1) { /* the next result is on the same page */ target_page = page; target_idx = current + 1; } else if (diff == -1 && current > 0) { target_page = page; target_idx = current - 1; } else { /* the next result is on a different page */ g_object_set(G_OBJECT(page_widget), "search-current", -1, NULL); for (int npage_id = 1; page_id < num_pages; ++npage_id) { int ntmp = cur_page + diff * (page_id + npage_id); zathura_page_t* npage = zathura_document_get_page(zathura->document, (ntmp + 2*num_pages) % num_pages); GtkWidget* npage_page_widget = zathura_page_get_widget(zathura, npage); g_object_get(G_OBJECT(npage_page_widget), "search-length", &num_search_results, NULL); if (num_search_results != 0) { target_page = npage; target_idx = diff == 1 ? 0 : num_search_results - 1; break; } } } break; } if (target_page != NULL) { girara_list_t* results = NULL; GtkWidget* page_widget = zathura_page_get_widget(zathura, target_page); GObject* obj_page_widget = G_OBJECT(page_widget); g_object_set(obj_page_widget, "search-current", target_idx, NULL); g_object_get(obj_page_widget, "search-results", &results, NULL); /* Need to adjust rectangle to page scale and orientation */ zathura_rectangle_t* rect = girara_list_nth(results, target_idx); zathura_rectangle_t rectangle = recalc_rectangle(target_page, *rect); bool search_hadjust = true; girara_setting_get(session, "search-hadjust", &search_hadjust); /* compute the position of the center of the page */ double pos_x = 0; double pos_y = 0; page_number_to_position(zathura->document, zathura_page_get_index(target_page), 0.5, 0.5, &pos_x, &pos_y); /* correction to center the current result */ /* NOTE: rectangle is in viewport units, already scaled and rotated */ unsigned int cell_height = 0; unsigned int cell_width = 0; zathura_document_get_cell_size(zathura->document, &cell_height, &cell_width); unsigned int doc_height = 0; unsigned int doc_width = 0; zathura_document_get_document_size(zathura->document, &doc_height, &doc_width); /* compute the center of the rectangle, which will be aligned to the center of the viewport */ double center_x = (rectangle.x1 + rectangle.x2) / 2; double center_y = (rectangle.y1 + rectangle.y2) / 2; pos_y += (center_y - (double)cell_height/2) / (double)doc_height; if (search_hadjust == true) { pos_x += (center_x - (double)cell_width/2) / (double)doc_width; } /* move to position */ zathura_jumplist_add(zathura); position_set(zathura, pos_x, pos_y); zathura_jumplist_add(zathura); } return false; }
bool sc_scroll(girara_session_t* session, girara_argument_t* argument, girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; g_return_val_if_fail(argument != NULL, false); if (zathura->document == NULL) { return false; } GtkAdjustment* adjustment = NULL; if ( (argument->n == LEFT) || (argument->n == FULL_LEFT) || (argument->n == HALF_LEFT) || (argument->n == RIGHT) || (argument->n == FULL_RIGHT) || (argument->n == HALF_RIGHT)) { adjustment = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(session->gtk.view)); } else { adjustment = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(session->gtk.view)); } gdouble view_size = gtk_adjustment_get_page_size(adjustment); gdouble value = gtk_adjustment_get_value(adjustment); gdouble max = gtk_adjustment_get_upper(adjustment) - view_size; zathura->global.update_page_number = true; float scroll_step = 40; girara_setting_get(session, "scroll-step", &scroll_step); float scroll_hstep = -1; girara_setting_get(session, "scroll-hstep", &scroll_hstep); if (scroll_hstep < 0) { scroll_hstep = scroll_step; } float scroll_full_overlap = 0.0; girara_setting_get(session, "scroll-full-overlap", &scroll_full_overlap); bool scroll_page_aware = false; girara_setting_get(session, "scroll-page-aware", &scroll_page_aware); bool scroll_wrap = false; girara_setting_get(session, "scroll-wrap", &scroll_wrap); int padding = 1; girara_setting_get(session, "page-padding", &padding); gdouble new_value; switch(argument->n) { case FULL_UP: case FULL_LEFT: new_value = value - (1.0 - scroll_full_overlap) * view_size - padding; break; case FULL_DOWN: case FULL_RIGHT: new_value = value + (1.0 - scroll_full_overlap) * view_size + padding; break; case HALF_UP: case HALF_LEFT: new_value = value - ((view_size + padding) / 2); break; case HALF_DOWN: case HALF_RIGHT: new_value = value + ((view_size + padding) / 2); break; case LEFT: new_value = value - scroll_hstep; break; case UP: new_value = value - scroll_step; break; case RIGHT: new_value = value + scroll_hstep; break; case DOWN: new_value = value + scroll_step; break; case TOP: new_value = 0; break; case BOTTOM: new_value = max; break; default: new_value = value; } if (scroll_wrap == true) { if (new_value < 0) new_value = max; else if (new_value > max) new_value = 0; } if (scroll_page_aware == true) { int page_offset; double page_size; { unsigned int page_id = zathura_document_get_current_page_number(zathura->document); zathura_page_t* page = zathura_document_get_page(zathura->document, page_id); page_offset_t offset; page_calculate_offset(zathura, page, &offset); double scale = zathura_document_get_scale(zathura->document); if ((argument->n == LEFT) || (argument->n == FULL_LEFT) || (argument->n == HALF_LEFT) || (argument->n == RIGHT) || (argument->n == FULL_RIGHT) || (argument->n == HALF_RIGHT)) { page_offset = offset.x; page_size = zathura_page_get_width(page) * scale; } else { page_offset = offset.y; page_size = zathura_page_get_height(page) * scale; } page_offset -= padding / 2; page_size += padding; } if ((argument->n == FULL_DOWN) || (argument->n == HALF_DOWN) || (argument->n == FULL_RIGHT) || (argument->n == HALF_RIGHT)) { if ((page_offset > value) && (page_offset < value + view_size)) { new_value = page_offset; } else if ((page_offset <= value) && (page_offset + page_size < value + view_size)) { new_value = page_offset + page_size + 1; } else if ((page_offset <= value) && (page_offset + page_size < new_value + view_size)) { new_value = page_offset + page_size - view_size + 1; } } else if ((argument->n == FULL_UP) || (argument->n == HALF_UP) || (argument->n == FULL_LEFT) || (argument->n == HALF_LEFT)) { if ((page_offset + 1 >= value) && (page_offset < value + view_size)) { new_value = page_offset - view_size; } else if ((page_offset <= value) && (page_offset + page_size + 1 < value + view_size)) { new_value = page_offset + page_size - view_size; } else if ((page_offset <= value) && (page_offset > new_value)) { new_value = page_offset; } } } set_adjustment(adjustment, new_value); return false; }
bool sc_scroll(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; g_return_val_if_fail(argument != NULL, false); if (zathura->document == NULL) { return false; } /* if TOP or BOTTOM, go there and we are done */ if (argument->n == TOP) { position_set(zathura, -1, 0); return false; } else if (argument->n == BOTTOM) { position_set(zathura, -1, 1.0); return false; } /* Retrieve current page and position */ const unsigned int page_id = zathura_document_get_current_page_number(zathura->document); double pos_x = zathura_document_get_position_x(zathura->document); double pos_y = zathura_document_get_position_y(zathura->document); /* If PAGE_TOP or PAGE_BOTTOM, go there and we are done */ if (argument->n == PAGE_TOP) { double dontcare = 0.5; page_number_to_position(zathura->document, page_id, dontcare, 0.0, &dontcare, &pos_y); position_set(zathura, pos_x, pos_y); return false; } else if (argument->n == PAGE_BOTTOM) { double dontcare = 0.5; page_number_to_position(zathura->document, page_id, dontcare, 1.0, &dontcare, &pos_y); position_set(zathura, pos_x, pos_y); return false; } if (t == 0) { t = 1; } unsigned int view_width = 0; unsigned int view_height = 0; zathura_document_get_viewport_size(zathura->document, &view_height, &view_width); unsigned int doc_width = 0; unsigned int doc_height = 0; zathura_document_get_document_size(zathura->document, &doc_height, &doc_width); float scroll_step = 40; girara_setting_get(session, "scroll-step", &scroll_step); float scroll_hstep = -1; girara_setting_get(session, "scroll-hstep", &scroll_hstep); if (scroll_hstep < 0) { scroll_hstep = scroll_step; } float scroll_full_overlap = 0.0; girara_setting_get(session, "scroll-full-overlap", &scroll_full_overlap); bool scroll_page_aware = false; girara_setting_get(session, "scroll-page-aware", &scroll_page_aware); bool scroll_wrap = false; girara_setting_get(session, "scroll-wrap", &scroll_wrap); /* compute the direction of scrolling */ double direction = 1.0; if ((argument->n == LEFT) || (argument->n == FULL_LEFT) || (argument->n == HALF_LEFT) || (argument->n == UP) || (argument->n == FULL_UP) || (argument->n == HALF_UP)) { direction = -1.0; } const double vstep = (double)view_height / (double)doc_height; const double hstep = (double)view_width / (double)doc_width; /* compute new position */ switch (argument->n) { case FULL_UP: case FULL_DOWN: pos_y += direction * (1.0 - scroll_full_overlap) * vstep; break; case FULL_LEFT: case FULL_RIGHT: pos_x += direction * (1.0 - scroll_full_overlap) * hstep; break; case HALF_UP: case HALF_DOWN: pos_y += direction * 0.5 * vstep; break; case HALF_LEFT: case HALF_RIGHT: pos_x += direction * 0.5 * hstep; break; case UP: case DOWN: pos_y += direction * t * scroll_step / (double)doc_height; break; case LEFT: case RIGHT: pos_x += direction * t * scroll_hstep / (double)doc_width; break; case BIDIRECTIONAL: { pos_x += event->x * t * scroll_hstep / (double)doc_width; pos_y += event->y * t * scroll_step / (double)doc_height; break; } } /* handle boundaries */ const double end_x = 0.5 * (double)view_width / (double)doc_width; const double end_y = 0.5 * (double)view_height / (double)doc_height; const double new_x = scroll_wrap ? 1.0 - end_x : end_x; const double new_y = scroll_wrap ? 1.0 - end_y : end_y; if (pos_x < end_x) { pos_x = new_x; } else if (pos_x > 1.0 - end_x) { pos_x = 1 - new_x; } if (pos_y < end_y) { pos_y = new_y; } else if (pos_y > 1.0 - end_y) { pos_y = 1 - new_y; } /* snap to the border if we change page */ const unsigned int new_page_id = position_to_page_number(zathura->document, pos_x, pos_y); if (scroll_page_aware == true && page_id != new_page_id) { double dummy = 0.0; switch(argument->n) { case FULL_LEFT: case HALF_LEFT: page_number_to_position(zathura->document, new_page_id, 1.0, 0.0, &pos_x, &dummy); break; case FULL_RIGHT: case HALF_RIGHT: page_number_to_position(zathura->document, new_page_id, 0.0, 0.0, &pos_x, &dummy); break; case FULL_UP: case HALF_UP: page_number_to_position(zathura->document, new_page_id, 0.0, 1.0, &dummy, &pos_y); break; case FULL_DOWN: case HALF_DOWN: page_number_to_position(zathura->document, new_page_id, 0.0, 0.0, &dummy, &pos_y); break; } } position_set(zathura, pos_x, pos_y); return false; }
bool sc_search(girara_session_t* session, girara_argument_t* argument, girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; g_return_val_if_fail(argument != NULL, false); g_return_val_if_fail(zathura->document != NULL, false); const int num_pages = zathura_document_get_number_of_pages(zathura->document); const int cur_page = zathura_document_get_current_page_number(zathura->document); int diff = argument->n == FORWARD ? 1 : -1; if (zathura->global.search_direction == BACKWARD) diff = -diff; zathura_page_t* target_page = NULL; int target_idx = 0; for (int page_id = 0; page_id < num_pages; ++page_id) { int tmp = cur_page + diff * page_id; zathura_page_t* page = zathura_document_get_page(zathura->document, (tmp + num_pages) % num_pages); if (page == NULL) { continue; } GtkWidget* page_widget = zathura_page_get_widget(zathura, page); int num_search_results = 0, current = -1; g_object_get(page_widget, "search-current", ¤t, "search-length", &num_search_results, NULL); if (num_search_results == 0 || current == -1) { continue; } if (diff == 1 && current < num_search_results - 1) { /* the next result is on the same page */ target_page = page; target_idx = current + 1; } else if (diff == -1 && current > 0) { target_page = page; target_idx = current - 1; } else { /* the next result is on a different page */ zathura_jumplist_save(zathura); g_object_set(page_widget, "search-current", -1, NULL); for (int npage_id = 1; page_id < num_pages; ++npage_id) { int ntmp = cur_page + diff * (page_id + npage_id); zathura_page_t* npage = zathura_document_get_page(zathura->document, (ntmp + 2*num_pages) % num_pages); zathura_document_set_current_page_number(zathura->document, zathura_page_get_index(npage)); GtkWidget* npage_page_widget = zathura_page_get_widget(zathura, npage); g_object_get(npage_page_widget, "search-length", &num_search_results, NULL); if (num_search_results != 0) { target_page = npage; target_idx = diff == 1 ? 0 : num_search_results - 1; break; } } zathura_jumplist_add(zathura); } break; } if (target_page != NULL) { girara_list_t* results = NULL; GtkWidget* page_widget = zathura_page_get_widget(zathura, target_page); g_object_set(page_widget, "search-current", target_idx, NULL); g_object_get(page_widget, "search-results", &results, NULL); zathura_rectangle_t* rect = girara_list_nth(results, target_idx); zathura_rectangle_t rectangle = recalc_rectangle(target_page, *rect); page_offset_t offset; page_calculate_offset(zathura, target_page, &offset); GtkAdjustment* view_vadjustment = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(zathura->ui.session->gtk.view)); int y = offset.y - gtk_adjustment_get_page_size(view_vadjustment) / 2 + rectangle.y1; set_adjustment(view_vadjustment, y); bool search_hadjust = true; girara_setting_get(session, "search-hadjust", &search_hadjust); if (search_hadjust == true) { GtkAdjustment* view_hadjustment = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(zathura->ui.session->gtk.view)); int x = offset.x - gtk_adjustment_get_page_size(view_hadjustment) / 2 + rectangle.x1; set_adjustment(view_hadjustment, x); } } return false; }
bool sc_adjust_window(girara_session_t* session, girara_argument_t* argument, girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; g_return_val_if_fail(argument != NULL, false); unsigned int pages_per_row = 1; girara_setting_get(session, "pages-per-row", &pages_per_row); unsigned int first_page_column = 1; girara_setting_get(session, "first-page-column", &first_page_column); int padding = 1; girara_setting_get(zathura->ui.session, "page-padding", &padding); if (zathura->ui.page_widget == NULL || zathura->document == NULL) { goto error_ret; } float old_zoom = zathura_document_get_scale(zathura->document); zathura_document_set_adjust_mode(zathura->document, argument->n); if (argument->n == ZATHURA_ADJUST_NONE) { /* there is nothing todo */ goto error_ret; } /* get window size */ GtkAllocation allocation; gtk_widget_get_allocation(session->gtk.view, &allocation); unsigned int width = allocation.width; unsigned int height = allocation.height; /* scrollbar spacing */ gint spacing; gtk_widget_style_get(session->gtk.view, "scrollbar_spacing", &spacing, NULL); width -= spacing; /* correct view size */ if (gtk_widget_get_visible(GTK_WIDGET(session->gtk.inputbar)) == true) { gtk_widget_get_allocation(session->gtk.inputbar, &allocation); height += allocation.height; } double scale = 1.0; unsigned int cell_height = 0, cell_width = 0; unsigned int document_height = 0, document_width = 0; zathura_document_set_scale(zathura->document, scale); zathura_document_get_cell_size(zathura->document, &cell_height, &cell_width); zathura_get_document_size(zathura, cell_height, cell_width, &document_height, &document_width); double page_ratio = (double)cell_height / (double)document_width; double window_ratio = (double)height / (double)width; if (argument->n == ZATHURA_ADJUST_WIDTH || (argument->n == ZATHURA_ADJUST_BESTFIT && page_ratio < window_ratio)) { scale = (double)(width - (pages_per_row - 1) * padding) / (double)(pages_per_row * cell_width); zathura_document_set_scale(zathura->document, scale); bool show_scrollbars = false; girara_setting_get(session, "show-scrollbars", &show_scrollbars); if (show_scrollbars) { /* If the document is taller than the view, there's a vertical * scrollbar; we need to substract its width from the view's width. */ zathura_get_document_size(zathura, cell_height, cell_width, &document_height, &document_width); if (height < document_height) { GtkWidget* vscrollbar = gtk_scrolled_window_get_vscrollbar( GTK_SCROLLED_WINDOW(session->gtk.view)); if (vscrollbar != NULL) { GtkRequisition requisition; gtk_widget_get_requisition(vscrollbar, &requisition); if (0 < requisition.width && (unsigned)requisition.width < width) { width -= requisition.width; scale = (double)(width - (pages_per_row - 1) * padding) / (double)(pages_per_row * cell_width); zathura_document_set_scale(zathura->document, scale); } } } } } else if (argument->n == ZATHURA_ADJUST_BESTFIT) { scale = (double)height / (double)cell_height; zathura_document_set_scale(zathura->document, scale); } else { goto error_ret; } /* keep position */ readjust_view_after_zooming(zathura, old_zoom, false); /* re-render all pages */ render_all(zathura); error_ret: return false; }
bool sc_toggle_presentation(girara_session_t* session, girara_argument_t* UNUSED(argument), girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; if (zathura->document == NULL) { girara_notify(session, GIRARA_WARNING, _("No document opened.")); return false; } const girara_mode_t old_mode = girara_mode_get(session); if (old_mode == zathura->modes.presentation) { /* reset pages per row */ girara_setting_set(session, "pages-per-row", &zathura->shortcut.toggle_presentation_mode.pages); /* reset first page column */ if (zathura->shortcut.toggle_presentation_mode.first_page_column_list != NULL) { girara_setting_set(session, "first-page-column", zathura->shortcut.toggle_presentation_mode.first_page_column_list); } /* show status bar */ gtk_widget_show(GTK_WIDGET(session->gtk.statusbar)); /* set full screen */ gtk_window_unfullscreen(GTK_WINDOW(session->gtk.window)); /* reset scale */ zathura_document_set_scale(zathura->document, zathura->shortcut.toggle_presentation_mode.zoom); render_all(zathura); refresh_view(zathura); /* set mode */ girara_mode_set(session, zathura->modes.normal); } else if (old_mode == zathura->modes.normal) { /* backup pages per row */ girara_setting_get(session, "pages-per-row", &zathura->shortcut.toggle_presentation_mode.pages); /* backup first page column */ g_free(zathura->shortcut.toggle_presentation_mode.first_page_column_list); zathura->shortcut.toggle_presentation_mode.first_page_column_list = NULL; /* this will leak. we need to move the values somewhere else */ girara_setting_get(session, "first-page-column", &zathura->shortcut.toggle_presentation_mode.first_page_column_list); /* set single view */ int int_value = 1; girara_setting_set(session, "pages-per-row", &int_value); /* back up zoom */ zathura->shortcut.toggle_presentation_mode.zoom = zathura_document_get_scale(zathura->document); /* adjust window */ girara_argument_t argument = { ZATHURA_ADJUST_BESTFIT, NULL }; sc_adjust_window(session, &argument, NULL, 0); /* hide status and inputbar */ gtk_widget_hide(GTK_WIDGET(session->gtk.inputbar)); gtk_widget_hide(GTK_WIDGET(session->gtk.statusbar)); /* set full screen */ gtk_window_fullscreen(GTK_WINDOW(session->gtk.window)); refresh_view(zathura); /* set mode */ girara_mode_set(session, zathura->modes.presentation); } return false; }
bool sc_toggle_fullscreen(girara_session_t* session, girara_argument_t* UNUSED(argument), girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; if (zathura->document == NULL) { girara_notify(session, GIRARA_WARNING, _("No document opened.")); return false; } static bool fullscreen = false; static int pages_per_row = 1; static int first_page_column = 1; static double zoom = 1.0; if (fullscreen == true) { /* reset pages per row */ girara_setting_set(session, "pages-per-row", &pages_per_row); /* reset first page column */ girara_setting_set(session, "first-page-column", &first_page_column); /* show status bar */ gtk_widget_show(GTK_WIDGET(session->gtk.statusbar)); /* set full screen */ gtk_window_unfullscreen(GTK_WINDOW(session->gtk.window)); /* reset scale */ zathura_document_set_scale(zathura->document, zoom); render_all(zathura); page_set_delayed(zathura, zathura_document_get_current_page_number(zathura->document)); /* setm ode */ girara_mode_set(session, zathura->modes.normal); } else { /* backup pages per row */ girara_setting_get(session, "pages-per-row", &pages_per_row); /* backup first page column */ girara_setting_get(session, "first-page-column", &first_page_column); /* set single view */ int int_value = 1; girara_setting_set(session, "pages-per-row", &int_value); /* back up zoom */ zoom = zathura_document_get_scale(zathura->document); /* adjust window */ girara_argument_t argument = { ZATHURA_ADJUST_BESTFIT, NULL }; sc_adjust_window(session, &argument, NULL, 0); /* hide status and inputbar */ gtk_widget_hide(GTK_WIDGET(session->gtk.inputbar)); gtk_widget_hide(GTK_WIDGET(session->gtk.statusbar)); /* set full screen */ gtk_window_fullscreen(GTK_WINDOW(session->gtk.window)); page_set_delayed(zathura, zathura_document_get_current_page_number(zathura->document)); /* setm ode */ girara_mode_set(session, zathura->modes.fullscreen); } fullscreen = fullscreen ? false : true; return false; }
bool zathura_init(zathura_t* zathura) { if (zathura == NULL) { return false; } /* create zathura (config/data) directory */ if (g_mkdir_with_parents(zathura->config.config_dir, 0771) == -1) { girara_error("Could not create '%s': %s", zathura->config.config_dir, strerror(errno)); } if (g_mkdir_with_parents(zathura->config.data_dir, 0771) == -1) { girara_error("Could not create '%s': %s", zathura->config.data_dir, strerror(errno)); } /* load plugins */ zathura_plugin_manager_load(zathura->plugins.manager); /* configuration */ config_load_default(zathura); /* load global configuration files */ char* config_path = girara_get_xdg_path(XDG_CONFIG_DIRS); girara_list_t* config_dirs = girara_split_path_array(config_path); ssize_t size = girara_list_size(config_dirs) - 1; for (; size >= 0; --size) { const char* dir = girara_list_nth(config_dirs, size); char* file = g_build_filename(dir, ZATHURA_RC, NULL); config_load_file(zathura, file); g_free(file); } girara_list_free(config_dirs); g_free(config_path); config_load_file(zathura, GLOBAL_RC); /* load local configuration files */ char* configuration_file = g_build_filename(zathura->config.config_dir, ZATHURA_RC, NULL); config_load_file(zathura, configuration_file); g_free(configuration_file); /* UI */ if (girara_session_init(zathura->ui.session, "zathura") == false) { goto error_free; } /* girara events */ zathura->ui.session->events.buffer_changed = cb_buffer_changed; zathura->ui.session->events.unknown_command = cb_unknown_command; /* zathura signals */ zathura->signals.refresh_view = g_signal_new("refresh-view", GTK_TYPE_WIDGET, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 1, G_TYPE_POINTER); g_signal_connect(G_OBJECT(zathura->ui.session->gtk.view), "refresh-view", G_CALLBACK(cb_refresh_view), zathura); /* page view */ #if (GTK_MAJOR_VERSION == 3) zathura->ui.page_widget = gtk_grid_new(); gtk_grid_set_row_homogeneous(GTK_GRID(zathura->ui.page_widget), TRUE); gtk_grid_set_column_homogeneous(GTK_GRID(zathura->ui.page_widget), TRUE); #else zathura->ui.page_widget = gtk_table_new(0, 0, TRUE); #endif if (zathura->ui.page_widget == NULL) { goto error_free; } g_signal_connect(G_OBJECT(zathura->ui.session->gtk.window), "size-allocate", G_CALLBACK(cb_view_resized), zathura); GtkAdjustment* hadjustment = gtk_scrolled_window_get_hadjustment( GTK_SCROLLED_WINDOW(zathura->ui.session->gtk.view)); /* Connect hadjustment signals */ g_signal_connect(G_OBJECT(hadjustment), "value-changed", G_CALLBACK(cb_view_hadjustment_value_changed), zathura); g_signal_connect(G_OBJECT(hadjustment), "changed", G_CALLBACK(cb_view_hadjustment_changed), zathura); GtkAdjustment* vadjustment = gtk_scrolled_window_get_vadjustment( GTK_SCROLLED_WINDOW(zathura->ui.session->gtk.view)); /* Connect vadjustment signals */ g_signal_connect(G_OBJECT(vadjustment), "value-changed", G_CALLBACK(cb_view_vadjustment_value_changed), zathura); g_signal_connect(G_OBJECT(vadjustment), "changed", G_CALLBACK(cb_view_vadjustment_changed), zathura); /* page view alignment */ zathura->ui.page_widget_alignment = gtk_alignment_new(0.5, 0.5, 0, 0); if (zathura->ui.page_widget_alignment == NULL) { goto error_free; } gtk_container_add(GTK_CONTAINER(zathura->ui.page_widget_alignment), zathura->ui.page_widget); #if (GTK_MAJOR_VERSION == 3) gtk_widget_set_hexpand_set(zathura->ui.page_widget_alignment, TRUE); gtk_widget_set_hexpand(zathura->ui.page_widget_alignment, FALSE); gtk_widget_set_vexpand_set(zathura->ui.page_widget_alignment, TRUE); gtk_widget_set_vexpand(zathura->ui.page_widget_alignment, FALSE); #endif gtk_widget_show(zathura->ui.page_widget); /* statusbar */ zathura->ui.statusbar.file = girara_statusbar_item_add(zathura->ui.session, TRUE, TRUE, TRUE, NULL); if (zathura->ui.statusbar.file == NULL) { goto error_free; } zathura->ui.statusbar.buffer = girara_statusbar_item_add(zathura->ui.session, FALSE, FALSE, FALSE, NULL); if (zathura->ui.statusbar.buffer == NULL) { goto error_free; } zathura->ui.statusbar.page_number = girara_statusbar_item_add(zathura->ui.session, FALSE, FALSE, FALSE, NULL); if (zathura->ui.statusbar.page_number == NULL) { goto error_free; } girara_statusbar_item_set_text(zathura->ui.session, zathura->ui.statusbar.file, _("[No name]")); /* signals */ g_signal_connect(G_OBJECT(zathura->ui.session->gtk.window), "destroy", G_CALLBACK(cb_destroy), zathura); /* database */ char* database = NULL; girara_setting_get(zathura->ui.session, "database", &database); if (g_strcmp0(database, "plain") == 0) { girara_debug("Using plain database backend."); zathura->database = zathura_plaindatabase_new(zathura->config.data_dir); #ifdef WITH_SQLITE } else if (g_strcmp0(database, "sqlite") == 0) { girara_debug("Using sqlite database backend."); char* tmp = g_build_filename(zathura->config.data_dir, "bookmarks.sqlite", NULL); zathura->database = zathura_sqldatabase_new(tmp); g_free(tmp); #endif } else { girara_error("Database backend '%s' is not supported.", database); } g_free(database); if (zathura->database == NULL) { girara_error("Unable to initialize database. Bookmarks won't be available."); } else { g_object_set(zathura->ui.session->command_history, "io", zathura->database, NULL); } /* bookmarks */ zathura->bookmarks.bookmarks = girara_sorted_list_new2((girara_compare_function_t) zathura_bookmarks_compare, (girara_free_function_t) zathura_bookmark_free); /* jumplist */ int jumplist_size = 20; girara_setting_get(zathura->ui.session, "jumplist-size", &jumplist_size); zathura->jumplist.max_size = jumplist_size < 0 ? 0 : jumplist_size; zathura->jumplist.list = NULL; zathura->jumplist.size = 0; zathura->jumplist.cur = NULL; return true; error_free: if (zathura->ui.page_widget != NULL) { g_object_unref(zathura->ui.page_widget); } if (zathura->ui.page_widget_alignment != NULL) { g_object_unref(zathura->ui.page_widget_alignment); } return false; }