bool
cmd_offset(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);
zathura_t* zathura = session->global.data;
if (zathura->document == NULL) {
girara_notify(session, GIRARA_ERROR, _("No document opened."));
return false;
}
/* no argument: take current page as offset */
int page_offset = zathura_document_get_current_page_number(zathura->document);
/* retrieve offset from argument */
if (girara_list_size(argument_list) == 1) {
const char* value = girara_list_nth(argument_list, 0);
if (value != NULL) {
page_offset = atoi(value);
if (page_offset == 0 && strcmp(value, "0") != 0) {
girara_notify(session, GIRARA_WARNING, _("Argument must be a number."));
return false;
}
}
}
zathura_document_set_page_offset(zathura->document, page_offset);
return true;
}
bool
cmd_bookmark_open(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);
zathura_t* zathura = session->global.data;
if (zathura->document == NULL) {
girara_notify(session, GIRARA_ERROR, _("No document opened."));
return false;
}
const unsigned int argc = girara_list_size(argument_list);
if (argc != 1) {
girara_notify(session, GIRARA_ERROR, _("Invalid number of arguments given."));
return false;
}
const char* bookmark_name = girara_list_nth(argument_list, 0);
zathura_bookmark_t* bookmark = zathura_bookmark_get(zathura, bookmark_name);
if (bookmark == NULL) {
girara_notify(session, GIRARA_ERROR, _("No such bookmark: %s"), bookmark_name);
return false;
}
zathura_jumplist_add(zathura);
page_set(zathura, bookmark->page - 1);
if (bookmark->x != DBL_MIN && bookmark->y != DBL_MIN) {
position_set(zathura, bookmark->x, bookmark->y);
}
zathura_jumplist_add(zathura);
return true;
}
bool
cmd_bookmark_delete(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);
zathura_t* zathura = session->global.data;
if (zathura->document == NULL) {
girara_notify(session, GIRARA_ERROR, _("No document opened."));
return false;
}
const unsigned int argc = girara_list_size(argument_list);
if (argc != 1) {
girara_notify(session, GIRARA_ERROR, _("Invalid number of arguments given."));
return false;
}
const char* bookmark = girara_list_nth(argument_list, 0);
if (zathura_bookmark_remove(zathura, bookmark)) {
girara_notify(session, GIRARA_INFO, _("Removed bookmark: %s"), bookmark);
} else {
girara_notify(session, GIRARA_ERROR, _("Failed to remove bookmark: %s"), bookmark);
}
return true;
}
bool
cmd_savef(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);
zathura_t* zathura = session->global.data;
if (zathura->document == NULL) {
girara_notify(session, GIRARA_ERROR, _("No document opened."));
return false;
}
if (girara_list_size(argument_list) == 1) {
if (document_save(zathura, girara_list_nth(argument_list, 0), true) == true) {
girara_notify(session, GIRARA_INFO, _("Document saved."));
} else {
girara_notify(session, GIRARA_INFO, _("Failed to save document."));
}
} else {
girara_notify(session, GIRARA_ERROR, _("Invalid number of arguments."));
return false;
}
return true;
}
bool
cmd_open(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);
zathura_t* zathura = session->global.data;
const int argc = girara_list_size(argument_list);
if (argc > 2) {
girara_notify(session, GIRARA_ERROR, _("Too many arguments."));
return false;
} else if (argc >= 1) {
if (zathura->document != NULL) {
document_close(zathura, false);
}
document_open(zathura, girara_list_nth(argument_list, 0),
(argc == 2) ? girara_list_nth(argument_list, 1) : NULL,
ZATHURA_PAGE_NUMBER_UNSPECIFIED);
} else {
girara_notify(session, GIRARA_ERROR, _("No arguments given."));
return false;
}
return true;
}
bool
cmd_bookmark_create(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);
zathura_t* zathura = session->global.data;
if (zathura->document == NULL) {
girara_notify(session, GIRARA_ERROR, _("No document opened."));
return false;
}
const unsigned int argc = girara_list_size(argument_list);
if (argc != 1) {
girara_notify(session, GIRARA_ERROR, _("Invalid number of arguments given."));
return false;
}
const char* bookmark_name = girara_list_nth(argument_list, 0);
zathura_bookmark_t* bookmark = zathura_bookmark_get(zathura, bookmark_name);
if (bookmark != NULL) {
bookmark->page = zathura_document_get_current_page_number(zathura->document) + 1;
girara_notify(session, GIRARA_INFO, _("Bookmark successfuly updated: %s"), bookmark_name);
return true;
}
bookmark = zathura_bookmark_add(zathura, bookmark_name, zathura_document_get_current_page_number(zathura->document) + 1);
if (bookmark == NULL) {
girara_notify(session, GIRARA_ERROR, _("Could not create bookmark: %s"), bookmark_name);
return false;
}
girara_notify(session, GIRARA_INFO, _("Bookmark successfuly created: %s"), bookmark_name);
return true;
}
bool
cmd_info(girara_session_t* session, girara_list_t* UNUSED(argument_list))
{
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_ERROR, _("No document opened."));
return false;
}
struct meta_field {
char* name;
zathura_document_information_type_t field;
};
const struct meta_field meta_fields[] = {
{ _("Title"), ZATHURA_DOCUMENT_INFORMATION_TITLE },
{ _("Author"), ZATHURA_DOCUMENT_INFORMATION_AUTHOR },
{ _("Subject"), ZATHURA_DOCUMENT_INFORMATION_SUBJECT },
{ _("Keywords"), ZATHURA_DOCUMENT_INFORMATION_KEYWORDS },
{ _("Creator"), ZATHURA_DOCUMENT_INFORMATION_CREATOR },
{ _("Producer"), ZATHURA_DOCUMENT_INFORMATION_PRODUCER },
{ _("Creation date"), ZATHURA_DOCUMENT_INFORMATION_CREATION_DATE },
{ _("Modification date"), ZATHURA_DOCUMENT_INFORMATION_MODIFICATION_DATE }
};
girara_list_t* information = zathura_document_get_information(zathura->document, NULL);
if (information == NULL) {
girara_notify(session, GIRARA_INFO, _("No information available."));
return false;
}
GString* string = g_string_new(NULL);
GIRARA_LIST_FOREACH(information, zathura_document_information_entry_t*, iter, entry)
if (entry != NULL) {
for (unsigned int i = 0; i < LENGTH(meta_fields); i++) {
if (meta_fields[i].field == entry->type) {
char* text = g_strdup_printf("<b>%s:</b> %s\n", meta_fields[i].name, entry->value);
g_string_append(string, text);
g_free(text);
}
}
}
GIRARA_LIST_FOREACH_END(information, zathura_document_information_entry_t*, iter, entry);
if (strlen(string->str) > 0) {
g_string_erase(string, strlen(string->str) - 1, 1);
girara_notify(session, GIRARA_INFO, "%s", string->str);
} else {
girara_notify(session, GIRARA_INFO, _("No information available."));
}
g_string_free(string, TRUE);
return false;
}
bool
cb_sc_follow(GtkEntry* entry, girara_session_t* session)
{
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 eval = true;
char* input = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1);
if (input == NULL || strlen(input) == 0) {
eval = false;
}
int index = 0;
if (eval == true) {
index = atoi(input);
if (index == 0 && g_strcmp0(input, "0") != 0) {
girara_notify(session, GIRARA_WARNING, _("Invalid input '%s' given."), input);
eval = false;
}
index = index - 1;
}
/* set pages to draw links */
bool invalid_index = true;
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 || zathura_page_get_visibility(page) == false) {
continue;
}
GtkWidget* page_widget = zathura_page_get_widget(zathura, page);
g_object_set(page_widget, "draw-links", FALSE, NULL);
if (eval == true) {
zathura_link_t* link = zathura_page_widget_link_get(ZATHURA_PAGE(page_widget), index);
if (link != NULL) {
zathura_link_evaluate(zathura, link);
invalid_index = false;
}
}
}
if (eval == true && invalid_index == true) {
girara_notify(session, GIRARA_WARNING, _("Invalid index '%s' given."), input);
}
g_free(input);
return (eval == TRUE) ? TRUE : FALSE;
}
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
cmd_bookmark_delete(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 = session->global.data;
if (jumanji->database == NULL) {
return false;
}
char* url = NULL;
if (girara_list_size(argument_list) > 0) {
url = girara_list_nth(argument_list, 0);
} else {
jumanji_tab_t* tab = jumanji_tab_get_current(jumanji);
if (tab != NULL && tab->web_view != NULL) {
url = (char*) webkit_web_view_get_uri(WEBKIT_WEB_VIEW(tab->web_view));
}
}
gchar* escaped_url = g_markup_escape_text(url, -1);
jumanji_db_bookmark_remove(jumanji->database, url);
girara_notify(session, GIRARA_INFO, "Removed bookmark: %s", escaped_url);
g_free(escaped_url);
return true;
}
bool
cmd_bookmark_add(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 = session->global.data;
if (jumanji->database == NULL) {
return false;
}
int number_of_arguments = girara_list_size(argument_list);
char* url = NULL;
char* title = NULL;
if (number_of_arguments > 0) {
url = girara_list_nth(argument_list, 0);
title = (number_of_arguments > 1) ? girara_list_nth(argument_list, 1) : NULL;
} else {
jumanji_tab_t* tab = jumanji_tab_get_current(jumanji);
if (tab != NULL && tab->web_view != NULL) {
url = (char*) webkit_web_view_get_uri(WEBKIT_WEB_VIEW(tab->web_view));
title = (char*) webkit_web_view_get_title(WEBKIT_WEB_VIEW(tab->web_view));
}
}
gchar* escaped_url = g_markup_escape_text(url, -1);
jumanji_db_bookmark_add(jumanji->database, url, title);
girara_notify(session, GIRARA_INFO, "Added bookmark: %s", escaped_url);
g_free(escaped_url);
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;
}
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);
}
}
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;
}
const girara_mode_t old_mode = girara_mode_get(session);
if (old_mode == zathura->modes.fullscreen) {
gtk_window_unfullscreen(GTK_WINDOW(session->gtk.window));
refresh_view(zathura);
girara_mode_set(session, zathura->modes.normal);
} else if (old_mode == zathura->modes.normal) {
gtk_window_fullscreen(GTK_WINDOW(session->gtk.window));
refresh_view(zathura);
girara_mode_set(session, zathura->modes.fullscreen);
}
return false;
}
void
print(zathura_t* zathura)
{
g_return_if_fail(zathura != NULL);
g_return_if_fail(zathura->document != NULL);
GtkPrintOperation* print_operation = gtk_print_operation_new();
/* print operation settings */
gtk_print_operation_set_job_name(print_operation, zathura_document_get_path(zathura->document));
gtk_print_operation_set_allow_async(print_operation, TRUE);
gtk_print_operation_set_n_pages(print_operation, zathura_document_get_number_of_pages(zathura->document));
gtk_print_operation_set_current_page(print_operation, zathura_document_get_current_page_number(zathura->document));
gtk_print_operation_set_use_full_page(print_operation, TRUE);
if (zathura->print.settings != NULL) {
gtk_print_operation_set_print_settings(print_operation,
zathura->print.settings);
}
if (zathura->print.page_setup != NULL) {
gtk_print_operation_set_default_page_setup(print_operation,
zathura->print.page_setup);
}
gtk_print_operation_set_embed_page_setup(print_operation, TRUE);
/* print operation signals */
g_signal_connect(print_operation, "draw-page", G_CALLBACK(cb_print_draw_page), zathura);
g_signal_connect(print_operation, "end-print", G_CALLBACK(cb_print_end), zathura);
g_signal_connect(print_operation, "request-page-setup", G_CALLBACK(cb_print_request_page_setup), zathura);
/* print */
GError* error = NULL;
GtkPrintOperationResult result = gtk_print_operation_run(print_operation,
GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
GTK_WINDOW(zathura->ui.session->gtk.window), &error);
if (result == GTK_PRINT_OPERATION_RESULT_ERROR) {
girara_notify(zathura->ui.session, GIRARA_ERROR, _("Printing failed: %s"),
error->message);
g_error_free(error);
} else if (result == GTK_PRINT_OPERATION_RESULT_APPLY) {
g_clear_object(&zathura->print.settings);
g_clear_object(&zathura->print.page_setup);
/* save previous settings */
zathura->print.settings = g_object_ref(gtk_print_operation_get_print_settings(print_operation));
zathura->print.page_setup = g_object_ref(gtk_print_operation_get_default_page_setup(print_operation));
}
g_object_unref(print_operation);
}
bool
cmd_print(girara_session_t* session, girara_list_t* UNUSED(argument_list))
{
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_ERROR, _("No document opened."));
return false;
}
print(zathura);
return true;
}
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
cmd_version(girara_session_t* session, girara_list_t* UNUSED(argument_list))
{
g_return_val_if_fail(session != NULL, false);
g_return_val_if_fail(session->global.data != NULL, false);
zathura_t* zathura = session->global.data;
char* string = zathura_get_version_string(zathura, true);
if (string == NULL) {
return false;
}
/* display information */
girara_notify(session, GIRARA_INFO, "%s", string);
g_free(string);
return true;
}
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);
if (argument->n < ZATHURA_ADJUST_NONE || argument->n >= ZATHURA_ADJUST_MODE_NUMBER) {
girara_error("Invalid adjust mode: %d", argument->n);
girara_notify(session, GIRARA_ERROR, _("Invalid adjust mode: %d"), argument->n);
} else {
girara_debug("Setting adjust mode to: %d", argument->n);
zathura_document_set_adjust_mode(zathura->document, argument->n);
adjust_view(zathura);
}
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);
}
static void
cb_print_done(GtkPrintOperation* operation, GtkPrintOperationResult result,
zathura_t* zathura)
{
if (result == GTK_PRINT_OPERATION_RESULT_APPLY) {
if (zathura->print.settings != NULL) {
g_object_unref(zathura->print.settings);
}
if (zathura->print.page_setup != NULL) {
g_object_unref(zathura->print.page_setup);
}
/* save previous settings */
zathura->print.settings = g_object_ref(gtk_print_operation_get_print_settings(operation));
zathura->print.page_setup = g_object_ref(gtk_print_operation_get_default_page_setup(operation));
} else if (result == GTK_PRINT_OPERATION_RESULT_ERROR) {
GError* error = NULL;
gtk_print_operation_get_error(operation, &error);
girara_notify(zathura->ui.session, GIRARA_ERROR, _("Printing failed: %s"),
error->message);
g_error_free(error);
}
}
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
cmd_export(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);
zathura_t* zathura = session->global.data;
if (zathura->document == NULL) {
girara_notify(session, GIRARA_ERROR, _("No document opened."));
return false;
}
if (girara_list_size(argument_list) != 2) {
girara_notify(session, GIRARA_ERROR, _("Invalid number of arguments given."));
return false;
}
const char* file_identifier = girara_list_nth(argument_list, 0);
const char* file_name = girara_list_nth(argument_list, 1);
if (file_name == NULL || file_identifier == NULL) {
return false;
}
char* export_path = girara_fix_path(file_name);
if (export_path == NULL) {
return false;
}
/* attachment */
if (strncmp(file_identifier, "attachment-", strlen("attachment-")) == 0) {
if (zathura_document_attachment_save(zathura->document, file_identifier + strlen("attachment-"), export_path) == false) {
girara_notify(session, GIRARA_ERROR, _("Couldn't write attachment '%s' to '%s'."), file_identifier, file_name);
} else {
girara_notify(session, GIRARA_INFO, _("Wrote attachment '%s' to '%s'."), file_identifier, export_path);
}
/* image */
} else if (strncmp(file_identifier, "image-p", strlen("image-p")) == 0 && strlen(file_identifier) >= 10) {
/* parse page id */
const char* input = file_identifier + strlen("image-p");
int page_id = atoi(input);
if (page_id == 0) {
goto image_error;
}
/* parse image id */
input = strstr(input, "-");
if (input == NULL) {
goto image_error;
}
int image_id = atoi(input + 1);
if (image_id == 0) {
goto image_error;
}
/* get image */
zathura_page_t* page = zathura_document_get_page(zathura->document, page_id - 1);
if (page == NULL) {
goto image_error;
}
girara_list_t* images = zathura_page_images_get(page, NULL);
if (images == NULL) {
goto image_error;
}
zathura_image_t* image = girara_list_nth(images, image_id - 1);
if (image == NULL) {
goto image_error;
}
cairo_surface_t* surface = zathura_page_image_get_cairo(page, image, NULL);
if (surface == NULL) {
goto image_error;
}
if (cairo_surface_write_to_png(surface, export_path) == CAIRO_STATUS_SUCCESS) {
girara_notify(session, GIRARA_INFO, _("Wrote image '%s' to '%s'."), file_identifier, export_path);
} else {
girara_notify(session, GIRARA_ERROR, _("Couldn't write image '%s' to '%s'."), file_identifier, file_name);
}
goto error_ret;
image_error:
girara_notify(session, GIRARA_ERROR, _("Unknown image '%s'."), file_identifier);
goto error_ret;
/* unknown */
} else {
girara_notify(session, GIRARA_ERROR, _("Unknown attachment or image '%s'."), file_identifier);
}
error_ret:
g_free(export_path);
return true;
}
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
sc_toggle_index(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) {
return false;
}
girara_tree_node_t* document_index = NULL;
GtkWidget* treeview = NULL;
GtkTreeModel* model = NULL;
GtkCellRenderer* renderer = NULL;
GtkCellRenderer* renderer2 = NULL;
if (zathura->ui.index == NULL) {
/* create new index widget */
zathura->ui.index = gtk_scrolled_window_new(NULL, NULL);
if (zathura->ui.index == NULL) {
goto error_ret;
}
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(zathura->ui.index),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
/* create index */
document_index = zathura_document_index_generate(zathura->document, NULL);
if (document_index == NULL) {
girara_notify(session, GIRARA_WARNING, _("This document does not contain any index"));
goto error_free;
}
model = GTK_TREE_MODEL(gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER));
if (model == NULL) {
goto error_free;
}
treeview = gtk_tree_view_new_with_model(model);
if (treeview == NULL) {
goto error_free;
}
gtk_style_context_add_class(gtk_widget_get_style_context(treeview),
"indexmode");
g_object_unref(model);
renderer = gtk_cell_renderer_text_new();
if (renderer == NULL) {
goto error_free;
}
renderer2 = gtk_cell_renderer_text_new();
if (renderer2 == NULL) {
goto error_free;
}
document_index_build(model, NULL, document_index);
girara_node_free(document_index);
/* setup widget */
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW (treeview), 0, "Title", renderer, "markup", 0, NULL);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW (treeview), 1, "Target", renderer2, "text", 1, NULL);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
g_object_set(G_OBJECT(gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), 0)), "expand", TRUE, NULL);
gtk_tree_view_column_set_alignment(gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), 1), 1.0f);
gtk_tree_view_set_cursor(GTK_TREE_VIEW(treeview), gtk_tree_path_new_first(), NULL, FALSE);
g_signal_connect(G_OBJECT(treeview), "row-activated", G_CALLBACK(cb_index_row_activated), zathura);
gtk_container_add(GTK_CONTAINER(zathura->ui.index), treeview);
gtk_widget_show(treeview);
}
if (gtk_widget_get_visible(GTK_WIDGET(zathura->ui.index))) {
girara_set_view(session, zathura->ui.page_widget);
gtk_widget_hide(GTK_WIDGET(zathura->ui.index));
girara_mode_set(zathura->ui.session, zathura->modes.normal);
/* refresh view */
refresh_view(zathura);
} else {
/* save current position to the jumplist */
zathura_jumplist_add(zathura);
girara_set_view(session, zathura->ui.index);
gtk_widget_show(GTK_WIDGET(zathura->ui.index));
girara_mode_set(zathura->ui.session, zathura->modes.index);
}
return false;
error_free:
if (zathura->ui.index != NULL) {
g_object_ref_sink(zathura->ui.index);
zathura->ui.index = NULL;
}
if (document_index != NULL) {
girara_node_free(document_index);
}
error_ret:
return false;
}
