mirrors/zathura
1
0
Fork 0
mirror of https://git.pwmt.org/pwmt/zathura.git synced 2024-12-28 06:16:00 +01:00
Code Issues Projects Releases Packages Wiki Activity

Introduce and use zathura_document wrapper functions

Browse source
This commit is contained in:
Moritz Lipp 2012-03-27 21:59:35 +02:00
parent c82c2aaf04
commit 334b4fbb95
18 changed files with 517 additions and 289 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
bookmarks.c
View file

@ -34,7 +34,8 @@ zathura_bookmark_add(zathura_t* zathura, const gchar* id, unsigned int page)
girara_list_append(zathura->bookmarks.bookmarks, bookmark);
if (zathura->database != NULL) {
if (zathura_db_add_bookmark(zathura->database, zathura->document->file_path, bookmark) == false) {
const char* path = zathura_document_get_path(zathura->document);
if (zathura_db_add_bookmark(zathura->database, path, bookmark) == false) {
girara_warning("Failed to add bookmark to database.");
}
}
@ -54,7 +55,8 @@ zathura_bookmark_remove(zathura_t* zathura, const gchar* id)
}
if (zathura->database != NULL) {
if (zathura_db_remove_bookmark(zathura->database, zathura->document->file_path, bookmark->id) == false) {
const char* path = zathura_document_get_path(zathura->document);
if (zathura_db_remove_bookmark(zathura->database, path, bookmark->id) == false) {
girara_warning("Failed to remove bookmark from database.");
}
}

25
callbacks.c
View file

@ -51,8 +51,7 @@ void
cb_view_vadjustment_value_changed(GtkAdjustment* GIRARA_UNUSED(adjustment), gpointer data)
{
zathura_t* zathura = data;
if (zathura == NULL || zathura->document == NULL || zathura->document->pages == NULL
|| zathura->ui.page_widget == NULL) {
if (zathura == NULL || zathura->document == NULL || zathura->ui.page_widget == NULL) {
return;
}
@ -74,23 +73,26 @@ cb_view_vadjustment_value_changed(GtkAdjustment* GIRARA_UNUSED(adjustment), gpoi
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 < zathura->document->number_of_pages; page_id++) {
zathura_page_t* page = zathura->document->pages[page_id];
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(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) * zathura->document->scale;
page_rect.height = zathura_page_get_height(page) * zathura->document->scale;
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(&center, &page_rect, NULL) == TRUE) {
zathura->document->current_page_number = page_id;
zathura_document_set_current_page_number(zathura->document, page_id);
updated = true;
}
} else {
@ -119,7 +121,7 @@ cb_pages_per_row_value_changed(girara_session_t* session, const char* UNUSED(nam
page_widget_set_mode(zathura, pages_per_row);
if (zathura->document != NULL) {
unsigned int current_page = zathura->document->current_page_number;
unsigned int current_page = zathura_document_get_current_page_number(zathura->document);
page_set_delayed(zathura, current_page);
}
}
@ -185,8 +187,9 @@ cb_sc_follow(GtkEntry* entry, girara_session_t* session)
/* set pages to draw links */
bool invalid_index = true;
for (unsigned int page_id = 0; page_id < zathura->document->number_of_pages; page_id++) {
zathura_page_t* page = zathura->document->pages[page_id];
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;
}
@ -322,7 +325,7 @@ cb_view_resized(GtkWidget* UNUSED(widget), GtkAllocation* allocation, zathura_t*
/* adjust only if the allocation changed */
if (width != allocation->width || height != allocation->height) {
girara_argument_t argument = { zathura->document->adjust_mode, NULL };
girara_argument_t argument = { zathura_document_get_adjust_mode(zathura->document), NULL };
sc_adjust_window(zathura->ui.session, &argument, NULL, 0);
width = allocation->width;

19
commands.c
View file

@ -40,12 +40,12 @@ cmd_bookmark_create(girara_session_t* session, girara_list_t* argument_list)
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->current_page_number + 1;
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->current_page_number + 1);
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;
@ -304,8 +304,13 @@ cmd_search(girara_session_t* session, const char* input, girara_argument_t* argu
bool firsthit = true;
zathura_error_t error = ZATHURA_ERROR_OK;
for (unsigned int page_id = 0; page_id < zathura->document->number_of_pages; ++page_id) {
zathura_page_t* page = zathura->document->pages[(page_id + zathura->document->current_page_number) % zathura->document->number_of_pages];
unsigned int number_of_pages = zathura_document_get_number_of_pages(zathura->document);
unsigned int current_page_number = zathura_document_get_current_page_number(zathura->document);
for (unsigned int page_id = 0; page_id < number_of_pages; ++page_id) {
unsigned int index = (page_id + current_page_number) % number_of_pages;
zathura_page_t* page = zathura_document_get_page(zathura->document, index);
if (page == NULL) {
continue;
}
@ -385,7 +390,7 @@ cmd_offset(girara_session_t* session, girara_list_t* argument_list)
}
/* no argument: take current page as offset */
unsigned int page_offset = zathura->document->current_page_number;
unsigned int page_offset = zathura_document_get_current_page_number(zathura->document);
/* retrieve offset from argument */
if (girara_list_size(argument_list) == 1) {
@ -399,8 +404,8 @@ cmd_offset(girara_session_t* session, girara_list_t* argument_list)
}
}
if (page_offset < zathura->document->number_of_pages) {
zathura->document->page_offset = page_offset;
if (page_offset < zathura_document_get_number_of_pages(zathura->document)) {
zathura_document_set_page_offset(zathura->document, page_offset);
}
return true;

8
config.c
View file

@ -126,8 +126,8 @@ config_load_default(zathura_t* zathura)
girara_shortcut_add(gsession, GDK_CONTROL_MASK, GDK_KEY_c, NULL, sc_abort, 0, 0, NULL);
girara_shortcut_add(gsession, 0, GDK_KEY_Escape, NULL, sc_abort, 0, 0, NULL);
girara_shortcut_add(gsession, 0, GDK_KEY_a, NULL, sc_adjust_window, NORMAL, ADJUST_BESTFIT, NULL);
girara_shortcut_add(gsession, 0, GDK_KEY_s, NULL, sc_adjust_window, NORMAL, ADJUST_WIDTH, NULL);
girara_shortcut_add(gsession, 0, GDK_KEY_a, NULL, sc_adjust_window, NORMAL, ZATHURA_ADJUST_BESTFIT, NULL);
girara_shortcut_add(gsession, 0, GDK_KEY_s, NULL, sc_adjust_window, NORMAL, ZATHURA_ADJUST_WIDTH, NULL);
girara_shortcut_add(gsession, 0, GDK_KEY_m, NULL, sc_change_mode, NORMAL, ADD_MARKER, NULL);
girara_shortcut_add(gsession, 0, GDK_KEY_apostrophe, NULL, sc_change_mode, NORMAL, EVAL_MARKER, NULL);
@ -302,8 +302,8 @@ config_load_default(zathura_t* zathura)
girara_argument_mapping_add(gsession, "specific", ZOOM_SPECIFIC);
girara_argument_mapping_add(gsession, "top", TOP);
girara_argument_mapping_add(gsession, "up", UP);
girara_argument_mapping_add(gsession, "best-fit", ADJUST_BESTFIT);
girara_argument_mapping_add(gsession, "width", ADJUST_WIDTH);
girara_argument_mapping_add(gsession, "best-fit", ZATHURA_ADJUST_BESTFIT);
girara_argument_mapping_add(gsession, "width", ZATHURA_ADJUST_WIDTH);
girara_argument_mapping_add(gsession, "rotate-cw", ROTATE_CW);
girara_argument_mapping_add(gsession, "rotate-ccw", ROTATE_CCW);
}

197
document.c
View file

@ -32,6 +32,34 @@ static const size_t GT_MAX_READ = 1 << 16;
static const gchar* guess_type(const char* path);
/**
* Document
*/
struct zathura_document_s
{
char* file_path; /**< File path of the document */
const char* password; /**< Password of the document */
unsigned int current_page_number; /**< Current page number */
unsigned int number_of_pages; /**< Number of pages */
double scale; /**< Scale value */
unsigned int rotate; /**< Rotation */
void* data; /**< Custom data */
zathura_adjust_mode_t adjust_mode; /**< Adjust mode (best-fit, width) */
zathura_t* zathura; /**< Zathura instance */
unsigned int page_offset; /**< Page offset */
/**
* Document pages
*/
zathura_page_t** pages;
/**
* Used plugin
*/
zathura_plugin_t* plugin;
};
zathura_document_t*
zathura_document_open(zathura_t* zathura, const char* path, const char* password)
{
@ -94,8 +122,8 @@ zathura_document_open(zathura_t* zathura, const char* path, const char* password
document->file_path = real_path;
document->password = password;
document->scale = 1.0;
document->zathura = zathura;
document->plugin = plugin;
document->zathura = zathura;
/* open document */
if (plugin->functions.document_open == NULL) {
@ -170,14 +198,14 @@ zathura_document_open(zathura_t* zathura, const char* path, const char* password
/* apply open adjustment */
char* adjust_open = "best-fit";
document->adjust_mode = ADJUST_BESTFIT;
document->adjust_mode = ZATHURA_ADJUST_BESTFIT;
if (girara_setting_get(zathura->ui.session, "adjust-open", &(adjust_open)) == true) {
if (g_strcmp0(adjust_open, "best-fit") == 0) {
document->adjust_mode = ADJUST_BESTFIT;
document->adjust_mode = ZATHURA_ADJUST_BESTFIT;
} else if (g_strcmp0(adjust_open, "width") == 0) {
document->adjust_mode = ADJUST_WIDTH;
document->adjust_mode = ZATHURA_ADJUST_WIDTH;
} else {
document->adjust_mode = ADJUST_NONE;
document->adjust_mode = ZATHURA_ADJUST_NONE;
}
g_free(adjust_open);
}
@ -203,8 +231,7 @@ error_free:
zathura_error_t
zathura_document_free(zathura_document_t* document)
{
if (document == NULL || document->plugin == NULL || document->zathura == NULL
|| document->zathura->ui.session == NULL) {
if (document == NULL || document->plugin == NULL) {
return ZATHURA_ERROR_INVALID_ARGUMENTS;
}
@ -219,8 +246,6 @@ zathura_document_free(zathura_document_t* document)
/* free document */
zathura_error_t error = ZATHURA_ERROR_OK;
if (document->plugin->functions.document_free == NULL) {
girara_notify(document->zathura->ui.session, GIRARA_WARNING, _("%s not implemented"), __FUNCTION__);
girara_error("%s not implemented", __FUNCTION__);
error = ZATHURA_ERROR_NOT_IMPLEMENTED;
} else {
error = document->plugin->functions.document_free(document, document->data);
@ -255,6 +280,16 @@ zathura_document_get_password(zathura_document_t* document)
return document->password;
}
zathura_page_t*
zathura_document_get_page(zathura_document_t* document, unsigned int index)
{
if (document == NULL || document->pages == NULL || (document->number_of_pages <= index)) {
return NULL;
}
return document->pages[index];
}
void*
zathura_document_get_data(zathura_document_t* document)
{
@ -296,7 +331,7 @@ zathura_document_set_number_of_pages(zathura_document_t* document, unsigned int
}
unsigned int
zathura_document_get_current_page(zathura_document_t* document)
zathura_document_get_current_page_number(zathura_document_t* document)
{
if (document == NULL) {
return 0;
@ -306,7 +341,7 @@ zathura_document_get_current_page(zathura_document_t* document)
}
void
zathura_document_set_current_page(zathura_document_t* document, unsigned int
zathura_document_set_current_page_number(zathura_document_t* document, unsigned int
current_page)
{
if (document == NULL) {
@ -316,17 +351,110 @@ zathura_document_set_current_page(zathura_document_t* document, unsigned int
document->current_page_number = current_page;
}
double
zathura_document_get_scale(zathura_document_t* document)
{
if (document == NULL) {
return 0;
}
return document->scale;
}
void
zathura_document_set_scale(zathura_document_t* document, double scale)
{
if (document == NULL) {
return;
}
document->scale = scale;
}
unsigned int
zathura_document_get_rotation(zathura_document_t* document)
{
if (document == NULL) {
return 0;
}
return document->rotate;
}
void
zathura_document_set_rotation(zathura_document_t* document, unsigned int rotation)
{
if (document == NULL) {
return;
}
document->rotate = rotation % 360;
if (document->rotate > 0 && document->rotate < 90) {
document->rotate = 90;
} else if (document->rotate > 0 && document->rotate < 180) {
document->rotate = 180;
} else if (document->rotate > 0 && document->rotate < 270) {
document->rotate = 270;
} else {
document->rotate = 0;
}
}
zathura_adjust_mode_t
zathura_document_get_adjust_mode(zathura_document_t* document)
{
if (document == NULL) {
return ZATHURA_ADJUST_NONE;
}
return document->adjust_mode;
}
void
zathura_document_set_adjust_mode(zathura_document_t* document, zathura_adjust_mode_t mode)
{
if (document == NULL) {
return;
}
if (mode == ZATHURA_ADJUST_BESTFIT || mode == ZATHURA_ADJUST_WIDTH) {
document->adjust_mode = mode;
} else {
document->adjust_mode = ZATHURA_ADJUST_NONE;
}
}
unsigned int
zathura_document_get_page_offset(zathura_document_t* document)
{
if (document == NULL) {
return 0;
}
return document->page_offset;
}
void
zathura_document_set_page_offset(zathura_document_t* document, unsigned int page_offset)
{
if (document == NULL) {
return;
}
if (page_offset < document->number_of_pages) {
document->page_offset = page_offset;
}
}
zathura_error_t
zathura_document_save_as(zathura_document_t* document, const char* path)
{
if (document == NULL || document->plugin == NULL || path == NULL ||
document->zathura == NULL || document->zathura->ui.session == NULL) {
if (document == NULL || document->plugin == NULL || path == NULL) {
return ZATHURA_ERROR_UNKNOWN;
}
if (document->plugin->functions.document_save_as == NULL) {
girara_notify(document->zathura->ui.session, GIRARA_WARNING, _("%s not implemented"), __FUNCTION__);
girara_error("%s not implemented", __FUNCTION__);
return ZATHURA_ERROR_NOT_IMPLEMENTED;
}
@ -336,8 +464,7 @@ zathura_document_save_as(zathura_document_t* document, const char* path)
girara_tree_node_t*
zathura_document_index_generate(zathura_document_t* document, zathura_error_t* error)
{
if (document == NULL || document->plugin == NULL || document->zathura == NULL
|| document->zathura->ui.session == NULL) {
if (document == NULL || document->plugin == NULL) {
if (error != NULL) {
*error = ZATHURA_ERROR_INVALID_ARGUMENTS;
}
@ -345,8 +472,6 @@ zathura_document_index_generate(zathura_document_t* document, zathura_error_t* e
}
if (document->plugin->functions.document_index_generate == NULL) {
girara_notify(document->zathura->ui.session, GIRARA_WARNING, _("%s not implemented"), __FUNCTION__);
girara_error("%s not implemented", __FUNCTION__);
if (error != NULL) {
*error = ZATHURA_ERROR_NOT_IMPLEMENTED;
}
@ -359,8 +484,7 @@ zathura_document_index_generate(zathura_document_t* document, zathura_error_t* e
girara_list_t*
zathura_document_attachments_get(zathura_document_t* document, zathura_error_t* error)
{
if (document == NULL || document->plugin == NULL || document->zathura == NULL
|| document->zathura->ui.session == NULL) {
if (document == NULL || document->plugin == NULL) {
if (error != NULL) {
*error = ZATHURA_ERROR_INVALID_ARGUMENTS;
}
@ -368,8 +492,6 @@ zathura_document_attachments_get(zathura_document_t* document, zathura_error_t*
}
if (document->plugin->functions.document_attachments_get == NULL) {
girara_notify(document->zathura->ui.session, GIRARA_WARNING, _("%s not implemented"), __FUNCTION__);
girara_error("%s not implemented", __FUNCTION__);
if (error != NULL) {
*error = ZATHURA_ERROR_NOT_IMPLEMENTED;
}
@ -382,14 +504,11 @@ zathura_document_attachments_get(zathura_document_t* document, zathura_error_t*
zathura_error_t
zathura_document_attachment_save(zathura_document_t* document, const char* attachment, const char* file)
{
if (document == NULL || document->plugin == NULL || document->zathura == NULL
|| document->zathura->ui.session == NULL) {
if (document == NULL || document->plugin == NULL) {
return ZATHURA_ERROR_INVALID_ARGUMENTS;
}
if (document->plugin->functions.document_attachment_save == NULL) {
girara_notify(document->zathura->ui.session, GIRARA_WARNING, _("%s not implemented"), __FUNCTION__);
girara_error("%s not implemented", __FUNCTION__);
return ZATHURA_ERROR_NOT_IMPLEMENTED;
}
@ -399,7 +518,7 @@ zathura_document_attachment_save(zathura_document_t* document, const char* attac
char*
zathura_document_meta_get(zathura_document_t* document, zathura_document_meta_t meta, zathura_error_t* error)
{
if (document == NULL || document->plugin == NULL || document->zathura == NULL || document->zathura->ui.session == NULL) {
if (document == NULL || document->plugin == NULL) {
if (error != NULL) {
*error = ZATHURA_ERROR_INVALID_ARGUMENTS;
}
@ -410,8 +529,6 @@ zathura_document_meta_get(zathura_document_t* document, zathura_document_meta_t
if (error != NULL) {
*error = ZATHURA_ERROR_NOT_IMPLEMENTED;
}
girara_notify(document->zathura->ui.session, GIRARA_WARNING, _("%s not implemented"), __FUNCTION__);
girara_error("%s not implemented", __FUNCTION__);
return NULL;
}
@ -493,3 +610,23 @@ guess_type(const char* path)
g_strdelimit(out, "\n\r", '\0');
return out;
}
zathura_t*
zathura_document_get_zathura(zathura_document_t* document)
{
if (document == NULL) {
return NULL;
}
return document->zathura;
}
zathura_plugin_t*
zathura_document_get_plugin(zathura_document_t* document)
{
if (document == NULL) {
return NULL;
}
return document->plugin;
}

128
document.h
View file

@ -26,33 +26,6 @@ typedef enum zathura_document_meta_e
ZATHURA_DOCUMENT_MODIFICATION_DATE /**< Modification data */
} zathura_document_meta_t;
/**
* Document
*/
struct zathura_document_s
{
char* file_path; /**< File path of the document */
const char* password; /**< Password of the document */
unsigned int current_page_number; /**< Current page number */
unsigned int number_of_pages; /**< Number of pages */
double scale; /**< Scale value */
unsigned int rotate; /**< Rotation */
void* data; /**< Custom data */
zathura_t* zathura; /** Zathura object */
int adjust_mode; /**< Adjust mode (best-fit, width) */
unsigned int page_offset; /**< Page offset */
/**
* Document pages
*/
zathura_page_t** pages;
/**
* Used plugin
*/
zathura_plugin_t* plugin;
};
/**
* Open the document
*
@ -64,6 +37,15 @@ struct zathura_document_s
zathura_document_t* zathura_document_open(zathura_t* zathura, const char* path,
const char* password);
/**
* Free the document
*
* @param document
* @return ZATHURA_ERROR_OK when no error occured, otherwise see
* zathura_error_t
*/
zathura_error_t zathura_document_free(zathura_document_t* document);
/**
* Returns the path of the document
*
@ -81,21 +63,13 @@ const char* zathura_document_get_path(zathura_document_t* document);
const char* zathura_document_get_password(zathura_document_t* document);
/**
* Free the document
*
* @param document
* @return ZATHURA_ERROR_OK when no error occured, otherwise see
* zathura_error_t
*/
zathura_error_t zathura_document_free(zathura_document_t* document);
/**
* Returns the private data of the document
* Returns the page at the given index
*
* @param document The document
* @return The private data or NULL
* @param index The index of the page
* @return The page or NULL if an error occured
*/
void* zathura_document_get_data(zathura_document_t* document);
zathura_page_t* zathura_document_get_page(zathura_document_t* document, unsigned int index);
/**
* Returns the number of pages
@ -120,7 +94,7 @@ void zathura_document_set_number_of_pages(zathura_document_t* document, unsigned
* @param document The document
* @return Current page
*/
unsigned int zathura_document_get_current_page(zathura_document_t* document);
unsigned int zathura_document_get_current_page_number(zathura_document_t* document);
/**
* Sets the number of pages
@ -128,9 +102,81 @@ unsigned int zathura_document_get_current_page(zathura_document_t* document);
* @param document The document
* @param current_page The current page number
*/
void zathura_document_set_current_page(zathura_document_t* document, unsigned
void zathura_document_set_current_page_number(zathura_document_t* document, unsigned
int current_page);
/**
* Returns the current scale value of the document
*
* @param document The document
* @return The current scale value
*/
double zathura_document_get_scale(zathura_document_t* document);
/**
* Sets the new scale value of the document
*
* @param document The document
* @param scale The new scale value
*/
void zathura_document_set_scale(zathura_document_t* document, double scale);
/**
* Returns the rotation value of zathura (0..360)
*
* @param document The document
* @return The current rotation value
*/
unsigned int zathura_document_get_rotation(zathura_document_t* document);
/**
* Sets the new rotation value
*
* @param document The document
* @param rotation The new rotation value
*/
void zathura_document_set_rotation(zathura_document_t* document, unsigned int rotation);
/**
* Returns the adjust mode of the document
*
* @param document The document
* @return The adjust mode
*/
zathura_adjust_mode_t zathura_document_get_adjust_mode(zathura_document_t* document);
/**
* Sets the new adjust mode of the document
*
* @param document The document
* @param mode The new adjust mode
*/
void zathura_document_set_adjust_mode(zathura_document_t* document, zathura_adjust_mode_t mode);
/**
* Returns the page offset of the document
*
* @param document The document
* @return The page offset
*/
unsigned int zathura_document_get_page_offset(zathura_document_t* document);
/**
* Sets the new page offset of the document
*
* @param document The document
* @param page_offset The new page offset
*/
void zathura_document_set_page_offset(zathura_document_t* document, unsigned int page_offset);
/**
* Returns the private data of the document
*
* @param document The document
* @return The private data or NULL
*/
void* zathura_document_get_data(zathura_document_t* document);
/**
* Sets the private data of the document
*

18
internal.h
View file

@ -4,6 +4,7 @@
#define INTERNAL_H
#include "zathura.h"
#include "plugin.h"
/**
* Zathura password dialog
@ -14,4 +15,21 @@ typedef struct zathura_password_dialog_info_s
zathura_t* zathura; /**< Zathura session */
} zathura_password_dialog_info_t;
/**
* Returns the associated zathura instance
* TODO: Separate zathura_t completely from the document
*
* @param document The docment
* @return The associated zathura instance
*/
zathura_t* zathura_document_get_zathura(zathura_document_t* document);
/**
* Returns the associated plugin
*
* @param document The document
* @return The plugin or NULL
*/
zathura_plugin_t* zathura_document_get_plugin(zathura_document_t* document);
#endif // INTERNAL_H

25
page-widget.c
View file

@ -179,7 +179,7 @@ zathura_page_widget_set_property(GObject* object, guint prop_id, const GValue* v
case PROP_PAGE:
priv->page = g_value_get_pointer(value);
document = zathura_page_get_document(priv->page);
priv->zathura = document->zathura;
priv->zathura = zathura_document_get_zathura(document);
break;
case PROP_DRAW_LINKS:
priv->draw_links = g_value_get_boolean(value);
@ -300,7 +300,8 @@ zathura_page_widget_draw(GtkWidget* widget, cairo_t* cairo)
if (priv->surface != NULL) {
cairo_save(cairo);
switch (document->rotate) {
unsigned int rotation = zathura_document_get_rotation(document);
switch (rotation) {
case 90:
cairo_translate(cairo, page_width, 0);
break;
@ -312,8 +313,8 @@ zathura_page_widget_draw(GtkWidget* widget, cairo_t* cairo)
break;
}
if (document->rotate != 0) {
cairo_rotate(cairo, document->rotate * G_PI / 180.0);
if (rotation != 0) {
cairo_rotate(cairo, rotation * G_PI / 180.0);
}
cairo_set_source_surface(cairo, priv->surface, 0, 0);
@ -547,7 +548,7 @@ cb_zathura_page_widget_button_release_event(GtkWidget* widget, GdkEventButton* b
&& rect.y1 <= button->y && rect.y2 >= button->y) {
switch (link->type) {
case ZATHURA_LINK_TO_PAGE:
page_set_delayed(document->zathura, link->target.page_number);
page_set_delayed(priv->zathura, link->target.page_number);
return false;
case ZATHURA_LINK_EXTERNAL:
girara_xdg_open(link->target.uri);
@ -562,10 +563,11 @@ cb_zathura_page_widget_button_release_event(GtkWidget* widget, GdkEventButton* b
redraw_rect(ZATHURA_PAGE(widget), &priv->selection);
zathura_rectangle_t tmp = priv->selection;
tmp.x1 /= document->scale;
tmp.x2 /= document->scale;
tmp.y1 /= document->scale;
tmp.y2 /= document->scale;
double scale = zathura_document_get_scale(document);
tmp.x1 /= scale;
tmp.x2 /= scale;
tmp.y1 /= scale;
tmp.y2 /= scale;
char* text = zathura_page_get_text(priv->page, tmp, NULL);
if (text != NULL) {
@ -574,10 +576,9 @@ cb_zathura_page_widget_button_release_event(GtkWidget* widget, GdkEventButton* b
gtk_clipboard_set_text(gtk_clipboard_get(GDK_SELECTION_PRIMARY), text, -1);
if (priv->page != NULL && document != NULL && document->zathura != NULL) {
zathura_t* zathura = document->zathura;
if (priv->page != NULL && document != NULL && priv->zathura != NULL) {
char* stripped_text = g_strdelimit(g_strdup(text), "\n\t\r\n", ' ');
girara_notify(zathura->ui.session, GIRARA_INFO, _("Copied selected text to clipbard: %s"), stripped_text);
girara_notify(priv->zathura->ui.session, GIRARA_INFO, _("Copied selected text to clipbard: %s"), stripped_text);
g_free(stripped_text);
}
}

94
page.c
View file

@ -9,6 +9,7 @@
#include "page-widget.h"
#include "plugin.h"
#include "utils.h"
#include "internal.h"
struct zathura_page_s {
double height; /**< Page height */
@ -23,8 +24,7 @@ struct zathura_page_s {
zathura_page_t*
zathura_page_new(zathura_document_t* document, unsigned int index, zathura_error_t* error)
{
if (document == NULL || document->plugin == NULL || document->zathura == NULL
|| document->zathura->ui.session == NULL) {
if (document == NULL) {
if (error != NULL) {
*error = ZATHURA_ERROR_INVALID_ARGUMENTS;
}
@ -47,16 +47,15 @@ zathura_page_new(zathura_document_t* document, unsigned int index, zathura_error
}
/* init plugin */
if (document->plugin->functions.page_init == NULL) {
zathura_plugin_t* plugin = zathura_document_get_plugin(document);
if (plugin->functions.page_init == NULL) {
if (error != NULL) {
girara_notify(page->document->zathura->ui.session, GIRARA_WARNING, _("%s not implemented"), __FUNCTION__);
girara_error("%s not implemented", __FUNCTION__);
*error = ZATHURA_ERROR_NOT_IMPLEMENTED;
}
goto error_ret;
}
zathura_error_t ret = document->plugin->functions.page_init(page);
zathura_error_t ret = plugin->functions.page_init(page);
if (ret != ZATHURA_ERROR_OK) {
if (error != NULL) {
*error = ret;
@ -91,19 +90,17 @@ zathura_page_free(zathura_page_t* page)
return ZATHURA_ERROR_INVALID_ARGUMENTS;
}
if (page->document == NULL || page->document->plugin == NULL ||
page->document->zathura == NULL || page->document->zathura->ui.session == NULL) {
if (page->document == NULL) {
g_free(page);
return ZATHURA_ERROR_INVALID_ARGUMENTS;
}
if (page->document->plugin->functions.page_clear == NULL) {
girara_notify(page->document->zathura->ui.session, GIRARA_WARNING, _("%s not implemented"), __FUNCTION__);
girara_error("%s not implemented", __FUNCTION__);
zathura_plugin_t* plugin = zathura_document_get_plugin(page->document);
if (plugin->functions.page_clear == NULL) {
return ZATHURA_ERROR_NOT_IMPLEMENTED;
}
zathura_error_t error = page->document->plugin->functions.page_clear(page, page->data);
zathura_error_t error = plugin->functions.page_clear(page, page->data);
g_free(page);
@ -223,47 +220,43 @@ zathura_page_set_data(zathura_page_t* page, void* data)
girara_list_t*
zathura_page_search_text(zathura_page_t* page, const char* text, zathura_error_t* error)
{
if (page == NULL || page->document == NULL || page->document->plugin == NULL || text == NULL ||
page->document->zathura == NULL || page->document->zathura->ui.session == NULL) {
if (page == NULL || page->document == NULL || text == NULL) {
if (error != NULL) {
*error = ZATHURA_ERROR_INVALID_ARGUMENTS;
}
return NULL;
}
if (page->document->plugin->functions.page_search_text == NULL) {
girara_notify(page->document->zathura->ui.session, GIRARA_WARNING, _("%s not implemented"), __FUNCTION__);
girara_error("%s not implemented", __FUNCTION__);
zathura_plugin_t* plugin = zathura_document_get_plugin(page->document);
if (plugin->functions.page_search_text == NULL) {
if (error != NULL) {
*error = ZATHURA_ERROR_NOT_IMPLEMENTED;
}
return NULL;
}
return page->document->plugin->functions.page_search_text(page, page->data, text, error);
return plugin->functions.page_search_text(page, page->data, text, error);
}
girara_list_t*
zathura_page_links_get(zathura_page_t* page, zathura_error_t* error)
{
if (page == NULL || page->document == NULL || page->document->plugin == NULL || page->document->zathura == NULL
|| page->document->zathura->ui.session == NULL) {
if (page == NULL || page->document == NULL ) {
if (error != NULL) {
*error = ZATHURA_ERROR_INVALID_ARGUMENTS;
}
return NULL;
}
if (page->document->plugin->functions.page_links_get == NULL) {
girara_notify(page->document->zathura->ui.session, GIRARA_WARNING, _("%s not implemented"), __FUNCTION__);
girara_error("%s not implemented", __FUNCTION__);
zathura_plugin_t* plugin = zathura_document_get_plugin(page->document);
if (plugin->functions.page_links_get == NULL) {
if (error != NULL) {
*error = ZATHURA_ERROR_NOT_IMPLEMENTED;
}
return NULL;
}
return page->document->plugin->functions.page_links_get(page, page->data, error);
return plugin->functions.page_links_get(page, page->data, error);
}
zathura_error_t
@ -275,24 +268,22 @@ zathura_page_links_free(girara_list_t* UNUSED(list))
girara_list_t*
zathura_page_form_fields_get(zathura_page_t* page, zathura_error_t* error)
{
if (page == NULL || page->document == NULL || page->document->plugin == NULL || page->document->zathura == NULL
|| page->document->zathura->ui.session == NULL) {
if (page == NULL || page->document == NULL ) {
if (error != NULL) {
*error = ZATHURA_ERROR_INVALID_ARGUMENTS;
}
return NULL;
}
if (page->document->plugin->functions.page_form_fields_get == NULL) {
girara_notify(page->document->zathura->ui.session, GIRARA_WARNING, _("%s not implemented"), __FUNCTION__);
girara_error("%s not implemented", __FUNCTION__);
zathura_plugin_t* plugin = zathura_document_get_plugin(page->document);
if (plugin->functions.page_form_fields_get == NULL) {
if (error != NULL) {
*error = ZATHURA_ERROR_NOT_IMPLEMENTED;
}
return NULL;
}
return page->document->plugin->functions.page_form_fields_get(page, page->data, error);
return plugin->functions.page_form_fields_get(page, page->data, error);
}
zathura_error_t
@ -304,87 +295,76 @@ zathura_page_form_fields_free(girara_list_t* UNUSED(list))
girara_list_t*
zathura_page_images_get(zathura_page_t* page, zathura_error_t* error)
{
if (page == NULL || page->document == NULL || page->document->plugin == NULL || page->document->zathura == NULL
|| page->document->zathura->ui.session == NULL) {
if (page == NULL || page->document == NULL ) {
if (error != NULL) {
*error = ZATHURA_ERROR_INVALID_ARGUMENTS;
}
return NULL;
}
if (page->document->plugin->functions.page_images_get == NULL) {
girara_notify(page->document->zathura->ui.session, GIRARA_WARNING, _("%s not implemented"), __FUNCTION__);
girara_error("%s not implemented", __FUNCTION__);
zathura_plugin_t* plugin = zathura_document_get_plugin(page->document);
if (plugin->functions.page_images_get == NULL) {
if (error != NULL) {
*error = ZATHURA_ERROR_NOT_IMPLEMENTED;
}
return NULL;
}
return page->document->plugin->functions.page_images_get(page, page->data, error);
return plugin->functions.page_images_get(page, page->data, error);
}
cairo_surface_t*
zathura_page_image_get_cairo(zathura_page_t* page, zathura_image_t* image, zathura_error_t* error)
{
if (page == NULL || page->document == NULL || page->document->plugin == NULL || image == NULL ||
page->document->zathura == NULL || page->document->zathura->ui.session ==
NULL) {
if (page == NULL || page->document == NULL || image == NULL) {
if (error != NULL) {
*error = ZATHURA_ERROR_INVALID_ARGUMENTS;
}
return NULL;
}
if (page->document->plugin->functions.page_image_get_cairo == NULL) {
girara_notify(page->document->zathura->ui.session, GIRARA_WARNING, _("%s not implemented"), __FUNCTION__);
girara_error("%s not implemented", __FUNCTION__);
zathura_plugin_t* plugin = zathura_document_get_plugin(page->document);
if (plugin->functions.page_image_get_cairo == NULL) {
if (error != NULL) {
*error = ZATHURA_ERROR_NOT_IMPLEMENTED;
}
return NULL;
}
return page->document->plugin->functions.page_image_get_cairo(page, page->data, image, error);
return plugin->functions.page_image_get_cairo(page, page->data, image, error);
}
char* zathura_page_get_text(zathura_page_t* page, zathura_rectangle_t rectangle, zathura_error_t* error)
{
if (page == NULL || page->document == NULL || page->document->plugin == NULL
|| page->document->zathura == NULL || page->document->zathura->ui.session
== NULL) {
if (page == NULL || page->document == NULL ) {
if (error) {
*error = ZATHURA_ERROR_INVALID_ARGUMENTS;
}
return NULL;
}
if (page->document->plugin->functions.page_get_text == NULL) {
girara_notify(page->document->zathura->ui.session, GIRARA_WARNING, _("%s not implemented"), __FUNCTION__);
girara_error("%s not implemented", __FUNCTION__);
zathura_plugin_t* plugin = zathura_document_get_plugin(page->document);
if (plugin->functions.page_get_text == NULL) {
if (error) {
*error = ZATHURA_ERROR_NOT_IMPLEMENTED;
}
return NULL;
}
return page->document->plugin->functions.page_get_text(page, page->data, rectangle, error);
return plugin->functions.page_get_text(page, page->data, rectangle, error);
}
zathura_error_t
zathura_page_render(zathura_page_t* page, cairo_t* cairo, bool printing)
{
if (page == NULL || page->document->plugin == NULL || page->document == NULL || cairo == NULL ||
page->document->zathura == NULL || page->document->zathura->ui.session ==
NULL) {
if (page == NULL || page->document == NULL || cairo == NULL) {
return ZATHURA_ERROR_INVALID_ARGUMENTS;
}
if (page->document->plugin->functions.page_render_cairo == NULL) {
girara_notify(page->document->zathura->ui.session, GIRARA_WARNING, _("%s not implemented"), __FUNCTION__);
girara_error("%s not implemented", __FUNCTION__);
zathura_plugin_t* plugin = zathura_document_get_plugin(page->document);
if (plugin->functions.page_render_cairo == NULL) {
return ZATHURA_ERROR_NOT_IMPLEMENTED;
}
return page->document->plugin->functions.page_render_cairo(page, page->data, cairo, printing);
return plugin->functions.page_render_cairo(page, page->data, cairo, printing);
}

10
plugin-api.h
View file

@ -41,11 +41,11 @@ void zathura_plugin_add_mimetype(zathura_plugin_t* plugin, const char* mime_type
* @param mimetypes a char array of mime types supported by the plugin
*/
#define ZATHURA_PLUGIN_REGISTER(plugin_name, major, minor, rev, register_functions, mimetypes) \
unsigned int plugin_version_major() { return major; } \
unsigned int plugin_version_minor() { return minor; } \
unsigned int plugin_version_revision() { return rev; } \
unsigned int plugin_api_version() { return ZATHURA_API_VERSION; } \
unsigned int plugin_abi_version() { return ZATHURA_ABI_VERSION; } \
unsigned int zathura_plugin_version_major() { return major; } \
unsigned int zathura_plugin_version_minor() { return minor; } \
unsigned int zathura_plugin_version_revision() { return rev; } \
unsigned int zathura_plugin_api_version() { return ZATHURA_API_VERSION; } \
unsigned int zathura_plugin_abi_version() { return ZATHURA_ABI_VERSION; } \
\
void zathura_plugin_register(zathura_plugin_t* plugin) \
{ \

6
plugin.h
View file

@ -10,9 +10,9 @@
#include "version.h"
#include "zathura.h"
#define PLUGIN_REGISTER_FUNCTION "plugin_register"
#define PLUGIN_API_VERSION_FUNCTION "plugin_api_version"
#define PLUGIN_ABI_VERSION_FUNCTION "plugin_abi_version"
#define PLUGIN_REGISTER_FUNCTION "zathura_plugin_register"
#define PLUGIN_API_VERSION_FUNCTION "zathura_plugin_api_version"
#define PLUGIN_ABI_VERSION_FUNCTION "zathura_plugin_abi_version"
/**
* Plugin mapping

19
print.c
View file

@ -26,8 +26,8 @@ print(zathura_t* zathura)
}
gtk_print_operation_set_allow_async(print_operation, TRUE);
gtk_print_operation_set_n_pages(print_operation, zathura->document->number_of_pages);
gtk_print_operation_set_current_page(print_operation, zathura->document->current_page_number);
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));
/* print operation signals */
g_signal_connect(print_operation, "draw-page", G_CALLBACK(cb_print_draw_page), zathura);
@ -59,20 +59,23 @@ void
cb_print_end(GtkPrintOperation* UNUSED(print_operation), GtkPrintContext*
UNUSED(context), zathura_t* zathura)
{
if (zathura == NULL || zathura->ui.session == NULL || zathura->document == NULL
|| zathura->document->file_path == NULL) {
if (zathura == NULL || zathura->ui.session == NULL || zathura->document == NULL) {
return;
}
girara_statusbar_item_set_text(zathura->ui.session,
zathura->ui.statusbar.file, zathura->document->file_path);
const char* file_path = zathura_document_get_path(zathura->document);
if (file_path != NULL) {
girara_statusbar_item_set_text(zathura->ui.session,
zathura->ui.statusbar.file, file_path);
}
}
void
cb_print_draw_page(GtkPrintOperation* UNUSED(print_operation), GtkPrintContext*
context, gint page_number, zathura_t* zathura)
{
if (context == NULL || zathura == NULL || zathura->document->pages == NULL ||
if (context == NULL || zathura == NULL || zathura->document == NULL ||
zathura->ui.session == NULL || zathura->ui.statusbar.file == NULL) {
return;
}
@ -85,7 +88,7 @@ cb_print_draw_page(GtkPrintOperation* UNUSED(print_operation), GtkPrintContext*
/* render page */
cairo_t* cairo = gtk_print_context_get_cairo_context(context);
zathura_page_t* page = zathura->document->pages[page_number];
zathura_page_t* page = zathura_document_get_page(zathura->document, page_number);
if (cairo == NULL || page == NULL) {
return;
}

10
render.c
View file

@ -111,8 +111,9 @@ render(zathura_t* zathura, zathura_page_t* page)
cairo_restore(cairo);
cairo_save(cairo);
if (fabs(zathura->document->scale - 1.0f) > FLT_EPSILON) {
cairo_scale(cairo, zathura->document->scale, zathura->document->scale);
double scale = zathura_document_get_scale(zathura->document);
if (fabs(scale - 1.0f) > FLT_EPSILON) {
cairo_scale(cairo, scale, scale);
}
if (zathura_page_render(page, cairo, false) != ZATHURA_ERROR_OK) {
@ -177,8 +178,9 @@ render_all(zathura_t* zathura)
}
/* unmark all pages */
for (unsigned int page_id = 0; page_id < zathura->document->number_of_pages; page_id++) {
zathura_page_t* page = zathura->document->pages[page_id];
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);
unsigned int page_height = 0, page_width = 0;
page_calc_height_width(page, &page_height, &page_width, true);

107
shortcuts.c
View file

@ -20,12 +20,17 @@
static void
readjust_view_after_zooming(zathura_t *zathura, float old_zoom) {
if (zathura == NULL || zathura->document == NULL) {
return;
}
GtkScrolledWindow *window = GTK_SCROLLED_WINDOW(zathura->ui.session->gtk.view);
GtkAdjustment* vadjustment = gtk_scrolled_window_get_vadjustment(window);
GtkAdjustment* hadjustment = gtk_scrolled_window_get_hadjustment(window);
gdouble valx = gtk_adjustment_get_value(hadjustment) / old_zoom * zathura->document->scale;
gdouble valy = gtk_adjustment_get_value(vadjustment) / old_zoom * zathura->document->scale;
double scale = zathura_document_get_scale(zathura->document);
gdouble valx = gtk_adjustment_get_value(hadjustment) / old_zoom * scale;
gdouble valy = gtk_adjustment_get_value(vadjustment) / old_zoom * scale;
set_adjustment(hadjustment, valx);
set_adjustment(vadjustment, valy);
}
@ -39,8 +44,9 @@ sc_abort(girara_session_t* session, girara_argument_t* UNUSED(argument),
zathura_t* zathura = session->global.data;
if (zathura->document != NULL) {
for (unsigned int page_id = 0; page_id < zathura->document->number_of_pages; ++page_id) {
zathura_page_t* page = zathura->document->pages[page_id];
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;
}
@ -71,9 +77,9 @@ sc_adjust_window(girara_session_t* session, girara_argument_t* argument,
goto error_ret;
}
float old_zoom = zathura->document->scale;
zathura->document->adjust_mode = argument->n;
if (argument->n == ADJUST_NONE) {
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;
}
@ -88,12 +94,13 @@ sc_adjust_window(girara_session_t* session, girara_argument_t* argument,
double total_width = 0;
double max_height = 0;
unsigned int number_of_pages = zathura_document_get_number_of_pages(zathura->document);
for (unsigned int page_id = 0; page_id < pages_per_row; page_id++) {
if (page_id == zathura->document->number_of_pages) {
if (page_id == number_of_pages) {
break;
}
zathura_page_t* page = zathura->document->pages[page_id];
zathura_page_t* page = zathura_document_get_page(zathura->document, page_id);
if (page == NULL) {
goto error_ret;
}
@ -105,10 +112,10 @@ sc_adjust_window(girara_session_t* session, girara_argument_t* argument,
total_width += zathura_page_get_width(page);
}
if (argument->n == ADJUST_WIDTH) {
zathura->document->scale = width / total_width;
} else if (argument->n == ADJUST_BESTFIT) {
zathura->document->scale = height / max_height;
if (argument->n == ZATHURA_ADJUST_WIDTH) {
zathura_document_set_scale(zathura->document, width / total_width);
} else if (argument->n == ZATHURA_ADJUST_BESTFIT) {
zathura_document_set_scale(zathura->document, height / max_height);
} else {
goto error_ret;
}
@ -159,22 +166,20 @@ sc_focus_inputbar(girara_session_t* session, girara_argument_t* argument, girara
/* append filepath */
if (argument->n == APPEND_FILEPATH && zathura->document != NULL) {
char* file_path = g_strdup(zathura->document->file_path);
if (file_path == NULL) {
return false;
}
const char* file_path = zathura_document_get_path(zathura->document);
if (file_path == NULL) {
return false;
}
char* path = dirname(file_path);
char* path = dirname(g_strdup(file_path));
char* tmp = g_strdup_printf("%s%s/", (char*) argument->data, (g_strcmp0(path, "/") == 0) ? "" : path);
if (tmp == NULL) {
g_free(file_path);
return false;
}
gtk_entry_set_text(session->gtk.inputbar_entry, tmp);
g_free(tmp);
g_free(file_path);
}
/* we save the X clipboard that will be clear by "grab_focus" */
@ -207,8 +212,9 @@ sc_follow(girara_session_t* session, girara_argument_t* UNUSED(argument),
/* set pages to draw links */
bool show_links = false;
unsigned int page_offset = 0;
for (unsigned int page_id = 0; page_id < zathura->document->number_of_pages; page_id++) {
zathura_page_t* page = zathura->document->pages[page_id];
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;
}
@ -249,15 +255,16 @@ sc_goto(girara_session_t* session, girara_argument_t* argument, girara_event_t*
if (t != 0) {
/* add offset */
if (zathura->document->page_offset > 0) {
t += zathura->document->page_offset;
unsigned int page_offset = zathura_document_get_page_offset(zathura->document);
if (page_offset > 0) {
t += page_offset;
}
page_set(zathura, t - 1);
} else if (argument->n == TOP) {
page_set(zathura, 0);
} else if (argument->n == BOTTOM) {
page_set(zathura, zathura->document->number_of_pages - 1);
page_set(zathura, zathura_document_get_number_of_pages(zathura->document) - 1);
}
return false;
@ -360,8 +367,8 @@ sc_navigate(girara_session_t* session, girara_argument_t* argument,
g_return_val_if_fail(argument != NULL, false);
g_return_val_if_fail(zathura->document != NULL, false);
int number_of_pages = zathura->document->number_of_pages;
int new_page = zathura->document->current_page_number;
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);
@ -434,7 +441,7 @@ sc_rotate(girara_session_t* session, girara_argument_t* argument,
zathura_t* zathura = session->global.data;
g_return_val_if_fail(zathura->document != NULL, false);
unsigned int page_number = zathura->document->current_page_number;
unsigned int page_number = zathura_document_get_current_page_number(zathura->document);
int angle = 90;
if (argument != NULL && argument->n == ROTATE_CCW) {
@ -442,7 +449,8 @@ sc_rotate(girara_session_t* session, girara_argument_t* argument,
}
/* update rotate value */
zathura->document->rotate = (zathura->document->rotate + angle) % 360;
unsigned int rotation = zathura_document_get_rotation(zathura->document);
zathura_document_set_rotation(zathura->document, (rotation + angle) % 360);
/* render all pages again */
render_all(zathura);
@ -535,8 +543,8 @@ sc_search(girara_session_t* session, girara_argument_t* argument,
g_return_val_if_fail(argument != NULL, false);
g_return_val_if_fail(zathura->document != NULL, false);
const int num_pages = zathura->document->number_of_pages;
const int cur_page = zathura->document->current_page_number;
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;
zathura_page_t* target_page = NULL;
@ -544,7 +552,7 @@ sc_search(girara_session_t* session, girara_argument_t* argument,
for (int page_id = 0; page_id < num_pages; ++page_id) {
int tmp = cur_page + diff * page_id;
zathura_page_t* page = zathura->document->pages[(tmp + num_pages) % num_pages];
zathura_page_t* page = zathura_document_get_page(zathura->document, (tmp + num_pages) % num_pages);
if (page == NULL) {
continue;
}
@ -571,8 +579,8 @@ sc_search(girara_session_t* session, girara_argument_t* argument,
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->pages[(ntmp + 2*num_pages) % num_pages];
zathura->document->current_page_number = zathura_page_get_index(npage);
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(npage);
g_object_get(npage_page_widget, "search-length", &num_search_results, NULL);
if (num_search_results != 0) {
@ -848,9 +856,9 @@ sc_toggle_fullscreen(girara_session_t* session, girara_argument_t*
gtk_window_unfullscreen(GTK_WINDOW(session->gtk.window));
/* reset scale */
zathura->document->scale = zoom;
zathura_document_set_scale(zathura->document, zoom);
render_all(zathura);
page_set_delayed(zathura, zathura->document->current_page_number);
page_set_delayed(zathura, zathura_document_get_current_page_number(zathura->document));
} else {
/* backup pages per row */
girara_setting_get(session, "pages-per-row", &pages_per_row);
@ -860,10 +868,10 @@ sc_toggle_fullscreen(girara_session_t* session, girara_argument_t*
girara_setting_set(session, "pages-per-row", &int_value);
/* back up zoom */
zoom = zathura->document->scale;
zoom = zathura_document_get_scale(zathura->document);
/* adjust window */
girara_argument_t argument = { ADJUST_BESTFIT, NULL };
girara_argument_t argument = { ZATHURA_ADJUST_BESTFIT, NULL };
sc_adjust_window(session, &argument, NULL, 0);
/* hide status and inputbar */
@ -872,7 +880,7 @@ sc_toggle_fullscreen(girara_session_t* session, girara_argument_t*
/* set full screen */
gtk_window_fullscreen(GTK_WINDOW(session->gtk.window));
page_set_delayed(zathura, zathura->document->current_page_number);
page_set_delayed(zathura, zathura_document_get_current_page_number(zathura->document));
}
fullscreen = fullscreen ? false : true;
@ -904,24 +912,24 @@ sc_zoom(girara_session_t* session, girara_argument_t* argument, girara_event_t*
g_return_val_if_fail(argument != NULL, false);
g_return_val_if_fail(zathura->document != NULL, false);
zathura->document->adjust_mode = ADJUST_NONE;
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);
float zoom_step = value / 100.0f;
float old_zoom = zathura->document->scale;
float old_zoom = zathura_document_get_scale(zathura->document);
/* specify new zoom value */
if (argument->n == ZOOM_IN) {
zathura->document->scale += zoom_step;
zathura_document_set_scale(zathura->document, old_zoom + zoom_step);
} else if (argument->n == ZOOM_OUT) {
zathura->document->scale -= zoom_step;
zathura_document_set_scale(zathura->document, old_zoom - zoom_step);
} else if (argument->n == ZOOM_SPECIFIC) {
zathura->document->scale = t / 100.0f;
zathura_document_set_scale(zathura->document, t / 100.0f);
} else {
zathura->document->scale = 1.0;
zathura_document_set_scale(zathura->document, 1.0);
}
/* zoom limitations */
@ -933,10 +941,11 @@ sc_zoom(girara_session_t* session, girara_argument_t* argument, girara_event_t*
float zoom_min = zoom_min_int * 0.01f;
float zoom_max = zoom_max_int * 0.01f;
if (zathura->document->scale < zoom_min) {
zathura->document->scale = zoom_min;
} else if (zathura->document->scale > zoom_max) {
zathura->document->scale = zoom_max;
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 */

10
types.h
View file

@ -34,6 +34,16 @@ typedef struct zathura_image_buffer_s
unsigned int rowstride; /**< Rowstride of the image */
} zathura_image_buffer_t;
/**
* Adjust mode
*/
typedef enum zathura_adjust_mode_e
{
ZATHURA_ADJUST_NONE, /**< No adjustment */
ZATHURA_ADJUST_BESTFIT, /**< Adjust to best-fit */
ZATHURA_ADJUST_WIDTH /**< Adjust to width */
} zathura_adjust_mode_t;
/**
* Creates an image buffer
*

49
utils.c
View file

@ -11,6 +11,7 @@
#include "utils.h"
#include "zathura.h"
#include "internal.h"
#include "document.h"
#include "page.h"
#include "plugin.h"
@ -177,7 +178,7 @@ page_calculate_offset(zathura_page_t* page, page_offset_t* offset)
g_return_if_fail(page != NULL);
g_return_if_fail(offset != NULL);
zathura_document_t* document = zathura_page_get_document(page);
zathura_t* zathura = document->zathura;
zathura_t* zathura = zathura_document_get_zathura(document);
GtkWidget* widget = zathura_page_get_widget(page);
g_return_if_fail(gtk_widget_translate_coordinates(widget,
@ -231,33 +232,34 @@ recalc_rectangle(zathura_page_t* page, zathura_rectangle_t rectangle)
double page_height = zathura_page_get_height(page);
double page_width = zathura_page_get_width(page);
double scale = zathura_document_get_scale(document);
zathura_rectangle_t tmp;
switch (document->rotate) {
switch (zathura_document_get_rotation(document)) {
case 90:
tmp.x1 = (page_height - rectangle.y2) * document->scale;
tmp.x2 = (page_height - rectangle.y1) * document->scale;
tmp.y1 = rectangle.x1 * document->scale;
tmp.y2 = rectangle.x2 * document->scale;
tmp.x1 = (page_height - rectangle.y2) * scale;
tmp.x2 = (page_height - rectangle.y1) * scale;
tmp.y1 = rectangle.x1 * scale;
tmp.y2 = rectangle.x2 * scale;
break;
case 180:
tmp.x1 = (page_width - rectangle.x2) * document->scale;
tmp.x2 = (page_width - rectangle.x1) * document->scale;
tmp.y1 = (page_height - rectangle.y2) * document->scale;
tmp.y2 = (page_height - rectangle.y1) * document->scale;
tmp.x1 = (page_width - rectangle.x2) * scale;
tmp.x2 = (page_width - rectangle.x1) * scale;
tmp.y1 = (page_height - rectangle.y2) * scale;
tmp.y2 = (page_height - rectangle.y1) * scale;
break;
case 270:
tmp.x1 = rectangle.y1 * document->scale;
tmp.x2 = rectangle.y2 * document->scale;
tmp.y1 = (page_width - rectangle.x2) * document->scale;
tmp.y2 = (page_width - rectangle.x1) * document->scale;
tmp.x1 = rectangle.y1 * scale;
tmp.x2 = rectangle.y2 * scale;
tmp.y1 = (page_width - rectangle.x2) * scale;
tmp.y2 = (page_width - rectangle.x1) * scale;
break;
default:
tmp.x1 = rectangle.x1 * document->scale;
tmp.x2 = rectangle.x2 * document->scale;
tmp.y1 = rectangle.y1 * document->scale;
tmp.y2 = rectangle.y2 * document->scale;
tmp.x1 = rectangle.x1 * scale;
tmp.x2 = rectangle.x2 * scale;
tmp.y1 = rectangle.y1 * scale;
tmp.y2 = rectangle.y2 * scale;
}
return tmp;
@ -286,12 +288,13 @@ page_calc_height_width(zathura_page_t* page, unsigned int* page_height, unsigned
double height = zathura_page_get_height(page);
double width = zathura_page_get_width(page);
double scale = zathura_document_get_scale(document);
if (rotate && document->rotate % 180) {
*page_width = ceil(height * document->scale);
*page_height = ceil(width * document->scale);
if (rotate && zathura_document_get_rotation(document) % 180) {
*page_width = ceil(height * scale);
*page_height = ceil(width * scale);
} else {
*page_width = ceil(width * document->scale);
*page_height = ceil(height * document->scale);
*page_width = ceil(width * scale);
*page_height = ceil(height * scale);
}
}

65
zathura.c
View file

@ -444,7 +444,8 @@ document_open(zathura_t* zathura, const char* path, const char* password)
}
/* install file monitor */
gchar* file_uri = g_filename_to_uri(document->file_path, NULL, NULL);
const char* file_path = zathura_document_get_path(document);
gchar* file_uri = g_filename_to_uri(file_path, NULL, NULL);
if (file_uri == NULL) {
goto error_free;
}
@ -465,15 +466,15 @@ document_open(zathura_t* zathura, const char* path, const char* password)
}
if (zathura->file_monitor.file_path == NULL) {
zathura->file_monitor.file_path = g_strdup(document->file_path);
zathura->file_monitor.file_path = g_strdup(file_path);
if (zathura->file_monitor.file_path == NULL) {
goto error_free;
}
}
if (document->password != NULL) {
if (password != NULL) {
g_free(zathura->file_monitor.password);
zathura->file_monitor.password = g_strdup(document->password);
zathura->file_monitor.password = g_strdup(password);
if (zathura->file_monitor.password == NULL) {
goto error_free;
}
@ -496,8 +497,9 @@ document_open(zathura_t* zathura, const char* path, const char* password)
}
/* create blank pages */
for (unsigned int page_id = 0; page_id < document->number_of_pages; page_id++) {
zathura_page_t* page = document->pages[page_id];
unsigned int number_of_pages = zathura_document_get_number_of_pages(document);
for (unsigned int page_id = 0; page_id < number_of_pages; page_id++) {
zathura_page_t* page = zathura_document_get_page(document, page_id);
if (page != NULL) {
GtkWidget* page_widget = zathura_page_get_widget(page);
if (page_widget != NULL) {
@ -507,18 +509,18 @@ document_open(zathura_t* zathura, const char* path, const char* password)
}
/* bookmarks */
zathura_bookmarks_load(zathura, zathura->document->file_path);
zathura_bookmarks_load(zathura, file_path);
page_set_delayed(zathura, document->current_page_number);
page_set_delayed(zathura, zathura_document_get_current_page_number(document));
cb_view_vadjustment_value_changed(NULL, zathura);
/* update title */
girara_set_window_title(zathura->ui.session, document->file_path);
girara_set_window_title(zathura->ui.session, file_path);
free(file_uri);
/* adjust window */
girara_argument_t argument = { zathura->document->adjust_mode, NULL };
girara_argument_t argument = { zathura_document_get_adjust_mode(document), NULL };
sc_adjust_window(zathura->ui.session, &argument, NULL, 0);
return true;
@ -598,10 +600,15 @@ document_close(zathura_t* zathura, bool keep_monitor)
}
}
const char* path = zathura_document_get_path(zathura->document);
unsigned int current_page_number = zathura_document_get_current_page_number(zathura->document);
unsigned int page_offset = zathura_document_get_page_offset(zathura->document);
double scale = zathura_document_get_scale(zathura->document);
unsigned int rotation = zathura_document_get_rotation(zathura->document);
/* store last seen page */
zathura_db_set_fileinfo(zathura->database, zathura->document->file_path,
zathura->document->current_page_number, zathura->document->page_offset,
zathura->document->scale, zathura->document->rotate);
zathura_db_set_fileinfo(zathura->database, path, current_page_number,
page_offset, scale, rotation);
render_free(zathura->sync.render_thread);
zathura->sync.render_thread = NULL;
@ -644,8 +651,8 @@ page_set_delayed_impl(gpointer data)
bool
page_set_delayed(zathura_t* zathura, unsigned int page_id)
{
if (zathura == NULL || zathura->document == NULL || zathura->document->pages == NULL ||
page_id >= zathura->document->number_of_pages) {
if (zathura == NULL || zathura->document == NULL ||
(page_id >= zathura_document_get_number_of_pages(zathura->document))) {
return false;
}
@ -659,22 +666,18 @@ page_set_delayed(zathura_t* zathura, unsigned int page_id)
bool
page_set(zathura_t* zathura, unsigned int page_id)
{
if (zathura == NULL || zathura->document == NULL || zathura->document->pages == NULL) {
goto error_out;
}
if (page_id >= zathura->document->number_of_pages) {
if (zathura == NULL || zathura->document == NULL) {
goto error_out;
}
/* render page */
zathura_page_t* page = zathura->document->pages[page_id];
zathura_page_t* page = zathura_document_get_page(zathura->document, page_id);
if (page == NULL) {
goto error_out;
}
zathura->document->current_page_number = page_id;
zathura_document_set_current_page_number(zathura->document, page_id);
zathura->global.update_page_number = false;
page_offset_t offset;
@ -701,8 +704,11 @@ statusbar_page_number_update(zathura_t* zathura)
return;
}
unsigned int number_of_pages = zathura_document_get_number_of_pages(zathura->document);
unsigned int current_page_number = zathura_document_get_current_page_number(zathura->document);
if (zathura->document != NULL) {
char* page_number_text = g_strdup_printf("[%d/%d]", zathura->document->current_page_number + 1, zathura->document->number_of_pages);
char* page_number_text = g_strdup_printf("[%d/%d]", current_page_number + 1, number_of_pages);
girara_statusbar_item_set_text(zathura->ui.session, zathura->ui.statusbar.page_number, page_number_text);
g_free(page_number_text);
} else {
@ -724,13 +730,15 @@ page_widget_set_mode(zathura_t* zathura, unsigned int pages_per_row)
gtk_container_foreach(GTK_CONTAINER(zathura->ui.page_widget), remove_page_from_table, (gpointer)0);
gtk_table_resize(GTK_TABLE(zathura->ui.page_widget), ceil(zathura->document->number_of_pages / pages_per_row), pages_per_row);
for (unsigned int i = 0; i < zathura->document->number_of_pages; i++)
unsigned int number_of_pages = zathura_document_get_number_of_pages(zathura->document);
gtk_table_resize(GTK_TABLE(zathura->ui.page_widget), ceil(number_of_pages / pages_per_row), pages_per_row);
for (unsigned int i = 0; i < number_of_pages; i++)
{
int x = i % pages_per_row;
int y = i / pages_per_row;
GtkWidget* page_widget = zathura_page_get_widget(zathura->document->pages[i]);
zathura_page_t* page = zathura_document_get_page(zathura->document, i);
GtkWidget* page_widget = zathura_page_get_widget(page);
gtk_table_attach(GTK_TABLE(zathura->ui.page_widget), page_widget, x, x + 1, y, y + 1, GTK_SHRINK, GTK_SHRINK, 0, 0);
}
@ -751,8 +759,9 @@ gboolean purge_pages(gpointer data)
return TRUE;
}
for (unsigned int page_id = 0; page_id < zathura->document->number_of_pages; page_id++) {
zathura_page_t* page = zathura->document->pages[page_id];
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);
GtkWidget* page_widget = zathura_page_get_widget(page);
zathura_page_widget_purge_unused(ZATHURA_PAGE(page_widget), threshold);
}

10
zathura.h
View file

@ -11,11 +11,11 @@
enum { NEXT, PREVIOUS, LEFT, RIGHT, UP, DOWN, BOTTOM, TOP, HIDE, HIGHLIGHT,
DELETE_LAST_WORD, DELETE_LAST_CHAR, DEFAULT, ERROR, WARNING, NEXT_GROUP,
PREVIOUS_GROUP, ZOOM_IN, ZOOM_OUT, ZOOM_ORIGINAL, ZOOM_SPECIFIC, FORWARD,
BACKWARD, ADJUST_BESTFIT, ADJUST_WIDTH, ADJUST_NONE, CONTINUOUS, DELETE_LAST,
ADD_MARKER, EVAL_MARKER, EXPAND, EXPAND_ALL, COLLAPSE_ALL, COLLAPSE, SELECT,
GOTO_DEFAULT, GOTO_LABELS, GOTO_OFFSET, HALF_UP, HALF_DOWN, FULL_UP,
FULL_DOWN, HALF_LEFT, HALF_RIGHT, FULL_LEFT, FULL_RIGHT, NEXT_CHAR, PREVIOUS_CHAR,
DELETE_TO_LINE_START, APPEND_FILEPATH, ROTATE_CW, ROTATE_CCW };
BACKWARD, CONTINUOUS, DELETE_LAST, ADD_MARKER, EVAL_MARKER, EXPAND,
EXPAND_ALL, COLLAPSE_ALL, COLLAPSE, SELECT, GOTO_DEFAULT, GOTO_LABELS,
GOTO_OFFSET, HALF_UP, HALF_DOWN, FULL_UP, FULL_DOWN, HALF_LEFT, HALF_RIGHT,
FULL_LEFT, FULL_RIGHT, NEXT_CHAR, PREVIOUS_CHAR, DELETE_TO_LINE_START,
APPEND_FILEPATH, ROTATE_CW, ROTATE_CCW };
/* forward declaration for types from document.h */
struct zathura_document_s;