mirrors/zathura
1
0
Fork 0
mirror of https://git.pwmt.org/pwmt/zathura.git synced 2025-02-27 14:34:39 +01:00
Code Issues Projects Releases Packages Wiki Activity

pinned

Browse source
This commit is contained in:
Jimmy 2021-02-04 16:16:02 -08:00
parent 12c8cd9110
commit 46dfa2be22
8 changed files with 1003 additions and 1064 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
.gitignore vendored
View file

@ -36,3 +36,4 @@ compile_commands.json
*.log
.ycm_extra_conf.py
_*/
.ccls-cache/

76
zathura/adjustment.c
View file

@ -5,15 +5,19 @@
#include <math.h>
double
page_calc_height_width(zathura_document_t* document, double height,
// @debug
#include <stdio.h>
double page_calc_height_width(zathura_document_t *document, double height,
double width, unsigned int *page_height,
unsigned int* page_width, bool rotate)
{
g_return_val_if_fail(document != NULL && page_height != NULL && page_width != NULL, 0.0);
unsigned int *page_width, bool rotate) {
g_return_val_if_fail(
document != NULL && page_height != NULL && page_width != NULL, 0.0);
double scale = zathura_document_get_scale(document);
// TODO this just set all pages to the maximum.
// needs to adjust cell size based on the page size itself.
if (rotate == true && zathura_document_get_rotation(document) % 180 != 0) {
*page_width = round(height * scale);
*page_height = round(width * scale);
@ -27,10 +31,8 @@ page_calc_height_width(zathura_document_t* document, double height,
return scale;
}
void
page_calc_position(zathura_document_t* document, double x, double y, double* xn,
double* yn)
{
void page_calc_position(zathura_document_t *document, double x, double y,
double *xn, double *yn) {
g_return_if_fail(document != NULL && xn != NULL && yn != NULL);
const unsigned int rot = zathura_document_get_rotation(document);
@ -49,10 +51,8 @@ page_calc_position(zathura_document_t* document, double x, double y, double* xn,
}
}
unsigned int
position_to_page_number(zathura_document_t* document, double pos_x,
double pos_y)
{
unsigned int position_to_page_number(zathura_document_t *document, double pos_x,
double pos_y) {
g_return_val_if_fail(document != NULL, 0);
unsigned int doc_width, doc_height;
@ -75,8 +75,10 @@ position_to_page_number(zathura_document_t* document, double pos_x,
nrow = 1 + (npag - (ncol - c0 - 1) + (ncol - 1)) / ncol;
}
unsigned int col = floor(pos_x * (double)doc_width / (double)(cell_width + pad));
unsigned int row = floor(pos_y * (double)doc_height / (double)(cell_height + pad));
unsigned int col =
floor(pos_x * (double)doc_width / (double)(cell_width + pad));
unsigned int row =
floor(pos_y * (double)doc_height / (double)(cell_height + pad));
unsigned int page = ncol * (row % nrow) + (col % ncol);
if (page < c0 - 1) {
@ -86,12 +88,9 @@ position_to_page_number(zathura_document_t* document, double pos_x,
}
}
void
page_number_to_position(zathura_document_t* document, unsigned int page_number,
double xalign, double yalign, double* pos_x,
double* pos_y)
{
void page_number_to_position(zathura_document_t *document,
unsigned int page_number, double xalign,
double yalign, double *pos_x, double *pos_y) {
g_return_if_fail(document != NULL);
unsigned int c0 = zathura_document_get_first_page_column(document);
@ -113,14 +112,18 @@ page_number_to_position(zathura_document_t* document, unsigned int page_number,
unsigned int doc_height = 0, doc_width = 0;
zathura_document_get_document_size(document, &doc_height, &doc_width);
/* compute the shift to align to the viewport. If the page fits to viewport, just center it. */
/* compute the shift to align to the viewport. If the page fits to viewport,
* just center it. */
double shift_x = 0.5, shift_y = 0.5;
if (cell_width > view_width) {
shift_x = 0.5 + (xalign - 0.5) * ((double)cell_width - (double)view_width) / (double)cell_width;
shift_x = 0.5 + (xalign - 0.5) * ((double)cell_width - (double)view_width) /
(double)cell_width;
}
if (cell_height > view_height) {
shift_y = 0.5 + (yalign - 0.5) * ((double)cell_height - (double)view_height) / (double)cell_height;
shift_y = 0.5 + (yalign - 0.5) *
((double)cell_height - (double)view_height) /
(double)cell_height;
}
/* compute the position */
@ -128,10 +131,7 @@ page_number_to_position(zathura_document_t* document, unsigned int page_number,
*pos_y = ((double)row + shift_y) / (double)nrow;
}
bool
page_is_visible(zathura_document_t *document, unsigned int page_number)
{
bool page_is_visible(zathura_document_t *document, unsigned int page_number) {
g_return_val_if_fail(document != NULL, false);
/* position at the center of the viewport */
@ -151,13 +151,13 @@ page_is_visible(zathura_document_t *document, unsigned int page_number)
unsigned int view_width, view_height;
zathura_document_get_viewport_size(document, &view_height, &view_width);
return ( fabs(pos_x - page_x) < 0.5 * (double)(view_width + cell_width) / (double)doc_width &&
fabs(pos_y - page_y) < 0.5 * (double)(view_height + cell_height) / (double)doc_height);
return (fabs(pos_x - page_x) <
0.5 * (double)(view_width + cell_width) / (double)doc_width &&
fabs(pos_y - page_y) <
0.5 * (double)(view_height + cell_height) / (double)doc_height);
}
void
zathura_adjustment_set_value(GtkAdjustment* adjustment, gdouble value)
{
void zathura_adjustment_set_value(GtkAdjustment *adjustment, gdouble value) {
const gdouble lower = gtk_adjustment_get_lower(adjustment);
const gdouble upper_m_size = gtk_adjustment_get_upper(adjustment) -
gtk_adjustment_get_page_size(adjustment);
@ -165,9 +165,7 @@ zathura_adjustment_set_value(GtkAdjustment* adjustment, gdouble value)
gtk_adjustment_set_value(adjustment, MAX(lower, MIN(upper_m_size, value)));
}
gdouble
zathura_adjustment_get_ratio(GtkAdjustment* adjustment)
{
gdouble zathura_adjustment_get_ratio(GtkAdjustment *adjustment) {
gdouble lower = gtk_adjustment_get_lower(adjustment);
gdouble upper = gtk_adjustment_get_upper(adjustment);
gdouble page_size = gtk_adjustment_get_page_size(adjustment);
@ -176,10 +174,8 @@ zathura_adjustment_get_ratio(GtkAdjustment* adjustment)
return (value - lower + page_size / 2.0) / (upper - lower);
}
void
zathura_adjustment_set_value_from_ratio(GtkAdjustment* adjustment,
gdouble ratio)
{
void zathura_adjustment_set_value_from_ratio(GtkAdjustment *adjustment,
gdouble ratio) {
if (ratio == 0.0) {
return;
}

298
zathura/document.c
View file

@ -1,22 +1,24 @@
/* SPDX-License-Identifier: Zlib */
#include <gio/gio.h>
#include <glib.h>
#include <limits.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <glib.h>
#include <gio/gio.h>
#include <math.h>
#include <girara/datastructures.h>
#include <girara/utils.h>
#include "adjustment.h"
#include "content-type.h"
#include "document.h"
#include "utils.h"
#include "zathura.h"
#include "page.h"
#include "plugin.h"
#include "content-type.h"
#include "utils.h"
#include "zathura.h"
// @debug
#include <stdio.h>
/**
* Document
@ -34,12 +36,15 @@ struct zathura_document_s {
void *data; /**< Custom data */
zathura_adjust_mode_t adjust_mode; /**< Adjust mode (best-fit, width) */
int page_offset; /**< Page offset */
double cell_width; /**< width of a page cell in the document (not transformed by scale and rotation) */
double cell_height; /**< height of a page cell in the document (not transformed by scale and rotation) */
double cell_width; /**< width of a page cell in the document (not transformed
by scale and rotation) */
double cell_height; /**< height of a page cell in the document (not
transformed by scale and rotation) */
unsigned int view_width; /**< width of current viewport */
unsigned int view_height; /**< height of current viewport */
double view_ppi; /**< PPI of the current viewport */
zathura_device_factors_t device_factors; /**< x and y device scale factors (for e.g. HiDPI) */
zathura_device_factors_t
device_factors; /**< x and y device scale factors (for e.g. HiDPI) */
unsigned int pages_per_row; /**< number of pages in a row */
unsigned int first_page_column; /**< column of the first page */
unsigned int page_padding; /**< padding between pages */
@ -57,16 +62,13 @@ struct zathura_document_s {
zathura_plugin_t *plugin;
};
static void
check_set_error(zathura_error_t* error, zathura_error_t code) {
static void check_set_error(zathura_error_t *error, zathura_error_t code) {
if (error != NULL) {
*error = code;
}
}
static bool
hash_file_sha256(uint8_t* dst, const char* path)
{
static bool hash_file_sha256(uint8_t *dst, const char *path) {
FILE *f = fopen(path, "rb");
if (f == NULL) {
return false;
@ -97,10 +99,9 @@ hash_file_sha256(uint8_t* dst, const char* path)
return true;
}
zathura_document_t*
zathura_document_open(zathura_t* zathura, const char* path, const char* uri,
const char* password, zathura_error_t* error)
{
zathura_document_t *zathura_document_open(zathura_t *zathura, const char *path,
const char *uri, const char *password,
zathura_error_t *error) {
if (zathura == NULL || path == NULL) {
return NULL;
}
@ -124,14 +125,17 @@ zathura_document_open(zathura_t* zathura, const char* path, const char* uri,
goto error_free;
}
content_type = zathura_content_type_guess(zathura->content_type_context, real_path, zathura_plugin_manager_get_content_types(zathura->plugins.manager));
content_type = zathura_content_type_guess(
zathura->content_type_context, real_path,
zathura_plugin_manager_get_content_types(zathura->plugins.manager));
if (content_type == NULL) {
girara_error("Could not determine file type.");
check_set_error(error, ZATHURA_ERROR_UNKNOWN);
goto error_free;
}
plugin = zathura_plugin_manager_get_plugin(zathura->plugins.manager, content_type);
plugin =
zathura_plugin_manager_get_plugin(zathura->plugins.manager, content_type);
if (plugin == NULL) {
girara_error("Unknown file type: '%s'", content_type);
check_set_error(error, ZATHURA_ERROR_UNKNOWN);
@ -180,7 +184,8 @@ zathura_document_open(zathura_t* zathura, const char* path, const char* uri,
file = NULL;
/* open document */
const zathura_plugin_functions_t* functions = zathura_plugin_get_functions(plugin);
const zathura_plugin_functions_t *functions =
zathura_plugin_get_functions(plugin);
if (functions->document_open == NULL) {
girara_error("plugin has no open function\n");
goto error_free;
@ -200,7 +205,8 @@ zathura_document_open(zathura_t* zathura, const char* path, const char* uri,
goto error_free;
}
for (unsigned int page_id = 0; page_id < document->number_of_pages; page_id++) {
for (unsigned int page_id = 0; page_id < document->number_of_pages;
page_id++) {
zathura_page_t *page = zathura_page_new(document, page_id, NULL);
if (page == NULL) {
check_set_error(error, ZATHURA_ERROR_OUT_OF_MEMORY);
@ -209,7 +215,8 @@ zathura_document_open(zathura_t* zathura, const char* path, const char* uri,
document->pages[page_id] = page;
/* cell_width and cell_height is the maximum of all the pages width and height */
/* cell_width and cell_height is the maximum of all the pages width and
* height */
const double width = zathura_page_get_width(page);
if (document->cell_width < width)
document->cell_width = width;
@ -239,16 +246,15 @@ error_free:
return NULL;
}
zathura_error_t
zathura_document_free(zathura_document_t* document)
{
zathura_error_t zathura_document_free(zathura_document_t *document) {
if (document == NULL || document->plugin == NULL) {
return ZATHURA_ERROR_INVALID_ARGUMENTS;
}
if (document->pages != NULL) {
/* free pages */
for (unsigned int page_id = 0; page_id < document->number_of_pages; page_id++) {
for (unsigned int page_id = 0; page_id < document->number_of_pages;
page_id++) {
zathura_page_free(document->pages[page_id]);
document->pages[page_id] = NULL;
}
@ -257,7 +263,8 @@ zathura_document_free(zathura_document_t* document)
/* free document */
zathura_error_t error = ZATHURA_ERROR_OK;
const zathura_plugin_functions_t* functions = zathura_plugin_get_functions(document->plugin);
const zathura_plugin_functions_t *functions =
zathura_plugin_get_functions(document->plugin);
if (functions->document_free == NULL) {
error = ZATHURA_ERROR_NOT_IMPLEMENTED;
} else {
@ -273,9 +280,7 @@ zathura_document_free(zathura_document_t* document)
return error;
}
const char*
zathura_document_get_path(zathura_document_t* document)
{
const char *zathura_document_get_path(zathura_document_t *document) {
if (document == NULL) {
return NULL;
}
@ -283,9 +288,7 @@ zathura_document_get_path(zathura_document_t* document)
return document->file_path;
}
const uint8_t*
zathura_document_get_hash(zathura_document_t* document)
{
const uint8_t *zathura_document_get_hash(zathura_document_t *document) {
if (document == NULL) {
return NULL;
}
@ -293,9 +296,7 @@ zathura_document_get_hash(zathura_document_t* document)
return document->hash_sha256;
}
const char*
zathura_document_get_uri(zathura_document_t* document)
{
const char *zathura_document_get_uri(zathura_document_t *document) {
if (document == NULL) {
return NULL;
}
@ -303,9 +304,7 @@ zathura_document_get_uri(zathura_document_t* document)
return document->uri;
}
const char*
zathura_document_get_basename(zathura_document_t* document)
{
const char *zathura_document_get_basename(zathura_document_t *document) {
if (document == NULL) {
return NULL;
}
@ -313,9 +312,7 @@ zathura_document_get_basename(zathura_document_t* document)
return document->basename;
}
const char*
zathura_document_get_password(zathura_document_t* document)
{
const char *zathura_document_get_password(zathura_document_t *document) {
if (document == NULL) {
return NULL;
}
@ -323,19 +320,17 @@ 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)) {
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)
{
void *zathura_document_get_data(zathura_document_t *document) {
if (document == NULL) {
return NULL;
}
@ -343,9 +338,7 @@ zathura_document_get_data(zathura_document_t* document)
return document->data;
}
void
zathura_document_set_data(zathura_document_t* document, void* data)
{
void zathura_document_set_data(zathura_document_t *document, void *data) {
if (document == NULL) {
return;
}
@ -354,8 +347,7 @@ zathura_document_set_data(zathura_document_t* document, void* data)
}
unsigned int
zathura_document_get_number_of_pages(zathura_document_t* document)
{
zathura_document_get_number_of_pages(zathura_document_t *document) {
if (document == NULL) {
return 0;
}
@ -363,9 +355,8 @@ zathura_document_get_number_of_pages(zathura_document_t* document)
return document->number_of_pages;
}
void
zathura_document_set_number_of_pages(zathura_document_t* document, unsigned int number_of_pages)
{
void zathura_document_set_number_of_pages(zathura_document_t *document,
unsigned int number_of_pages) {
if (document == NULL) {
return;
}
@ -374,8 +365,7 @@ zathura_document_set_number_of_pages(zathura_document_t* document, unsigned int
}
unsigned int
zathura_document_get_current_page_number(zathura_document_t* document)
{
zathura_document_get_current_page_number(zathura_document_t *document) {
if (document == NULL) {
return 0;
}
@ -383,10 +373,8 @@ zathura_document_get_current_page_number(zathura_document_t* document)
return document->current_page_number;
}
void
zathura_document_set_current_page_number(zathura_document_t* document, unsigned int
current_page)
{
void zathura_document_set_current_page_number(zathura_document_t *document,
unsigned int current_page) {
if (document == NULL) {
return;
}
@ -394,9 +382,7 @@ zathura_document_set_current_page_number(zathura_document_t* document, unsigned
document->current_page_number = current_page;
}
double
zathura_document_get_position_x(zathura_document_t* document)
{
double zathura_document_get_position_x(zathura_document_t *document) {
if (document == NULL) {
return 0;
}
@ -404,9 +390,7 @@ zathura_document_get_position_x(zathura_document_t* document)
return document->position_x;
}
double
zathura_document_get_position_y(zathura_document_t* document)
{
double zathura_document_get_position_y(zathura_document_t *document) {
if (document == NULL) {
return 0;
}
@ -414,9 +398,8 @@ zathura_document_get_position_y(zathura_document_t* document)
return document->position_y;
}
void
zathura_document_set_position_x(zathura_document_t* document, double position_x)
{
void zathura_document_set_position_x(zathura_document_t *document,
double position_x) {
if (document == NULL) {
return;
}
@ -424,9 +407,8 @@ zathura_document_set_position_x(zathura_document_t* document, double position_x)
document->position_x = position_x;
}
void
zathura_document_set_position_y(zathura_document_t* document, double position_y)
{
void zathura_document_set_position_y(zathura_document_t *document,
double position_y) {
if (document == NULL) {
return;
}
@ -434,9 +416,7 @@ zathura_document_set_position_y(zathura_document_t* document, double position_y)
document->position_y = position_y;
}
double
zathura_document_get_zoom(zathura_document_t* document)
{
double zathura_document_get_zoom(zathura_document_t *document) {
if (document == NULL) {
return 0;
}
@ -444,9 +424,7 @@ zathura_document_get_zoom(zathura_document_t* document)
return document->zoom;
}
void
zathura_document_set_zoom(zathura_document_t* document, double zoom)
{
void zathura_document_set_zoom(zathura_document_t *document, double zoom) {
if (document == NULL) {
return;
}
@ -454,9 +432,7 @@ zathura_document_set_zoom(zathura_document_t* document, double zoom)
document->zoom = zoom;
}
double
zathura_document_get_scale(zathura_document_t* document)
{
double zathura_document_get_scale(zathura_document_t *document) {
if (document == NULL) {
return 0;
}
@ -471,9 +447,7 @@ zathura_document_get_scale(zathura_document_t* document)
return document->zoom * ppi / 72.0;
}
unsigned int
zathura_document_get_rotation(zathura_document_t* document)
{
unsigned int zathura_document_get_rotation(zathura_document_t *document) {
if (document == NULL) {
return 0;
}
@ -481,9 +455,8 @@ zathura_document_get_rotation(zathura_document_t* document)
return document->rotate;
}
void
zathura_document_set_rotation(zathura_document_t* document, unsigned int rotation)
{
void zathura_document_set_rotation(zathura_document_t *document,
unsigned int rotation) {
if (document == NULL) {
return;
}
@ -501,8 +474,7 @@ zathura_document_set_rotation(zathura_document_t* document, unsigned int rotatio
}
zathura_adjust_mode_t
zathura_document_get_adjust_mode(zathura_document_t* document)
{
zathura_document_get_adjust_mode(zathura_document_t *document) {
if (document == NULL) {
return ZATHURA_ADJUST_NONE;
}
@ -510,9 +482,8 @@ zathura_document_get_adjust_mode(zathura_document_t* document)
return document->adjust_mode;
}
void
zathura_document_set_adjust_mode(zathura_document_t* document, zathura_adjust_mode_t mode)
{
void zathura_document_set_adjust_mode(zathura_document_t *document,
zathura_adjust_mode_t mode) {
if (document == NULL) {
return;
}
@ -520,9 +491,7 @@ zathura_document_set_adjust_mode(zathura_document_t* document, zathura_adjust_mo
document->adjust_mode = mode;
}
int
zathura_document_get_page_offset(zathura_document_t* document)
{
int zathura_document_get_page_offset(zathura_document_t *document) {
if (document == NULL) {
return 0;
}
@ -530,9 +499,8 @@ zathura_document_get_page_offset(zathura_document_t* document)
return document->page_offset;
}
void
zathura_document_set_page_offset(zathura_document_t* document, unsigned int page_offset)
{
void zathura_document_set_page_offset(zathura_document_t *document,
unsigned int page_offset) {
if (document == NULL) {
return;
}
@ -540,55 +508,47 @@ zathura_document_set_page_offset(zathura_document_t* document, unsigned int page
document->page_offset = page_offset;
}
void
zathura_document_set_viewport_width(zathura_document_t* document, unsigned int width)
{
void zathura_document_set_viewport_width(zathura_document_t *document,
unsigned int width) {
if (document == NULL) {
return;
}
document->view_width = width;
}
void
zathura_document_set_viewport_height(zathura_document_t* document, unsigned int height)
{
void zathura_document_set_viewport_height(zathura_document_t *document,
unsigned int height) {
if (document == NULL) {
return;
}
document->view_height = height;
}
void
zathura_document_set_viewport_ppi(zathura_document_t* document, double ppi)
{
void zathura_document_set_viewport_ppi(zathura_document_t *document,
double ppi) {
if (document == NULL) {
return;
}
document->view_ppi = ppi;
}
void
zathura_document_get_viewport_size(zathura_document_t* document,
unsigned int *height, unsigned int* width)
{
void zathura_document_get_viewport_size(zathura_document_t *document,
unsigned int *height,
unsigned int *width) {
g_return_if_fail(document != NULL && height != NULL && width != NULL);
*height = document->view_height;
*width = document->view_width;
}
double
zathura_document_get_viewport_ppi(zathura_document_t* document)
{
double zathura_document_get_viewport_ppi(zathura_document_t *document) {
if (document == NULL) {
return 0.0;
}
return document->view_ppi;
}
void
zathura_document_set_device_factors(zathura_document_t* document,
double x_factor, double y_factor)
{
void zathura_document_set_device_factors(zathura_document_t *document,
double x_factor, double y_factor) {
if (document == NULL) {
return;
}
@ -603,8 +563,7 @@ zathura_document_set_device_factors(zathura_document_t* document,
}
zathura_device_factors_t
zathura_document_get_device_factors(zathura_document_t* document)
{
zathura_document_get_device_factors(zathura_document_t *document) {
if (document == NULL) {
/* The function is guaranteed to not return zero values */
return (zathura_device_factors_t){1.0, 1.0};
@ -613,20 +572,17 @@ zathura_document_get_device_factors(zathura_document_t* document)
return document->device_factors;
}
void
zathura_document_get_cell_size(zathura_document_t* document,
unsigned int* height, unsigned int* width)
{
void zathura_document_get_cell_size(zathura_document_t *document,
unsigned int *height, unsigned int *width) {
g_return_if_fail(document != NULL && height != NULL && width != NULL);
page_calc_height_width(document, document->cell_height, document->cell_width,
height, width, true);
}
void
zathura_document_get_document_size(zathura_document_t* document,
unsigned int* height, unsigned int* width)
{
void zathura_document_get_document_size(zathura_document_t *document,
unsigned int *height,
unsigned int *width) {
g_return_if_fail(document != NULL && height != NULL && width != NULL);
const unsigned int npag = zathura_document_get_number_of_pages(document);
@ -637,7 +593,8 @@ zathura_document_get_document_size(zathura_document_t* document,
}
const unsigned int c0 = zathura_document_get_first_page_column(document);
const unsigned int nrow = (npag + c0 - 1 + ncol - 1) / ncol; /* number of rows */
const unsigned int nrow =
(npag + c0 - 1 + ncol - 1) / ncol; /* number of rows */
const unsigned int pad = zathura_document_get_page_padding(document);
unsigned int cell_height = 0;
@ -648,10 +605,10 @@ zathura_document_get_document_size(zathura_document_t* document,
*height = nrow * cell_height + (nrow - 1) * pad;
}
void
zathura_document_set_page_layout(zathura_document_t* document, unsigned int page_padding,
unsigned int pages_per_row, unsigned int first_page_column)
{
void zathura_document_set_page_layout(zathura_document_t *document,
unsigned int page_padding,
unsigned int pages_per_row,
unsigned int first_page_column) {
g_return_if_fail(document != NULL);
document->page_padding = page_padding;
@ -666,18 +623,14 @@ zathura_document_set_page_layout(zathura_document_t* document, unsigned int page
document->first_page_column = first_page_column;
}
unsigned int
zathura_document_get_page_padding(zathura_document_t* document)
{
unsigned int zathura_document_get_page_padding(zathura_document_t *document) {
if (document == NULL) {
return 0;
}
return document->page_padding;
}
unsigned int
zathura_document_get_pages_per_row(zathura_document_t* document)
{
unsigned int zathura_document_get_pages_per_row(zathura_document_t *document) {
if (document == NULL) {
return 0;
}
@ -685,22 +638,21 @@ zathura_document_get_pages_per_row(zathura_document_t* document)
}
unsigned int
zathura_document_get_first_page_column(zathura_document_t* document)
{
zathura_document_get_first_page_column(zathura_document_t *document) {
if (document == NULL) {
return 0;
}
return document->first_page_column;
}
zathura_error_t
zathura_document_save_as(zathura_document_t* document, const char* path)
{
zathura_error_t zathura_document_save_as(zathura_document_t *document,
const char *path) {
if (document == NULL || document->plugin == NULL || path == NULL) {
return ZATHURA_ERROR_UNKNOWN;
}
const zathura_plugin_functions_t* functions = zathura_plugin_get_functions(document->plugin);
const zathura_plugin_functions_t *functions =
zathura_plugin_get_functions(document->plugin);
if (functions->document_save_as == NULL) {
return ZATHURA_ERROR_NOT_IMPLEMENTED;
}
@ -709,14 +661,15 @@ 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)
{
zathura_document_index_generate(zathura_document_t *document,
zathura_error_t *error) {
if (document == NULL || document->plugin == NULL) {
check_set_error(error, ZATHURA_ERROR_INVALID_ARGUMENTS);
return NULL;
}
const zathura_plugin_functions_t* functions = zathura_plugin_get_functions(document->plugin);
const zathura_plugin_functions_t *functions =
zathura_plugin_get_functions(document->plugin);
if (functions->document_index_generate == NULL) {
check_set_error(error, ZATHURA_ERROR_NOT_IMPLEMENTED);
return NULL;
@ -725,15 +678,15 @@ zathura_document_index_generate(zathura_document_t* document, zathura_error_t* e
return functions->document_index_generate(document, document->data, error);
}
girara_list_t*
zathura_document_attachments_get(zathura_document_t* document, zathura_error_t* error)
{
girara_list_t *zathura_document_attachments_get(zathura_document_t *document,
zathura_error_t *error) {
if (document == NULL || document->plugin == NULL) {
check_set_error(error, ZATHURA_ERROR_INVALID_ARGUMENTS);
return NULL;
}
const zathura_plugin_functions_t* functions = zathura_plugin_get_functions(document->plugin);
const zathura_plugin_functions_t *functions =
zathura_plugin_get_functions(document->plugin);
if (functions->document_attachments_get == NULL) {
check_set_error(error, ZATHURA_ERROR_NOT_IMPLEMENTED);
return NULL;
@ -742,46 +695,49 @@ zathura_document_attachments_get(zathura_document_t* document, zathura_error_t*
return functions->document_attachments_get(document, document->data, error);
}
zathura_error_t
zathura_document_attachment_save(zathura_document_t* document, const char* attachment, const char* file)
{
zathura_error_t zathura_document_attachment_save(zathura_document_t *document,
const char *attachment,
const char *file) {
if (document == NULL || document->plugin == NULL) {
return ZATHURA_ERROR_INVALID_ARGUMENTS;
}
const zathura_plugin_functions_t* functions = zathura_plugin_get_functions(document->plugin);
const zathura_plugin_functions_t *functions =
zathura_plugin_get_functions(document->plugin);
if (functions->document_attachment_save == NULL) {
return ZATHURA_ERROR_NOT_IMPLEMENTED;
}
return functions->document_attachment_save(document, document->data, attachment, file);
return functions->document_attachment_save(document, document->data,
attachment, file);
}
girara_list_t*
zathura_document_get_information(zathura_document_t* document, zathura_error_t* error)
{
girara_list_t *zathura_document_get_information(zathura_document_t *document,
zathura_error_t *error) {
if (document == NULL || document->plugin == NULL) {
check_set_error(error, ZATHURA_ERROR_INVALID_ARGUMENTS);
return NULL;
}
const zathura_plugin_functions_t* functions = zathura_plugin_get_functions(document->plugin);
const zathura_plugin_functions_t *functions =
zathura_plugin_get_functions(document->plugin);
if (functions->document_get_information == NULL) {
check_set_error(error, ZATHURA_ERROR_NOT_IMPLEMENTED);
return NULL;
}
girara_list_t* result = functions->document_get_information(document, document->data, error);
girara_list_t *result =
functions->document_get_information(document, document->data, error);
if (result != NULL) {
girara_list_set_free_function(result, (girara_free_function_t) zathura_document_information_entry_free);
girara_list_set_free_function(
result,
(girara_free_function_t)zathura_document_information_entry_free);
}
return result;
}
zathura_plugin_t*
zathura_document_get_plugin(zathura_document_t* document)
{
zathura_plugin_t *zathura_document_get_plugin(zathura_document_t *document) {
if (document == NULL) {
return NULL;
}

536
zathura/render.c
View file

@ -1,17 +1,18 @@
/* SPDX-License-Identifier: Zlib */
#include <math.h>
#include <string.h>
#include <girara/datastructures.h>
#include <girara/utils.h>
#include <math.h>
#include <string.h>
#include "render.h"
#include "adjustment.h"
#include "zathura.h"
#include "document.h"
#include "page.h"
#include "page-widget.h"
#include "page.h"
#include "render.h"
#include "utils.h"
#include "zathura.h"
#include <stdio.h>
/* private data for ZathuraRenderer */
typedef struct private_s {
@ -55,8 +56,10 @@ typedef struct request_private_s {
} ZathuraRenderRequestPrivate;
/* define the two types */
G_DEFINE_TYPE_WITH_CODE(ZathuraRenderer, zathura_renderer, G_TYPE_OBJECT, G_ADD_PRIVATE(ZathuraRenderer))
G_DEFINE_TYPE_WITH_CODE(ZathuraRenderRequest, zathura_render_request, G_TYPE_OBJECT, G_ADD_PRIVATE(ZathuraRenderRequest))
G_DEFINE_TYPE_WITH_CODE(ZathuraRenderer, zathura_renderer, G_TYPE_OBJECT,
G_ADD_PRIVATE(ZathuraRenderer))
G_DEFINE_TYPE_WITH_CODE(ZathuraRenderRequest, zathura_render_request,
G_TYPE_OBJECT, G_ADD_PRIVATE(ZathuraRenderRequest))
/* private methods for ZathuraRenderer */
static void renderer_finalize(GObject *object);
@ -78,18 +81,15 @@ typedef struct render_job_s {
/* init, new and free for ZathuraRenderer */
static void
zathura_renderer_class_init(ZathuraRendererClass* class)
{
static void zathura_renderer_class_init(ZathuraRendererClass *class) {
/* overwrite methods */
GObjectClass *object_class = G_OBJECT_CLASS(class);
object_class->finalize = renderer_finalize;
}
static void
zathura_renderer_init(ZathuraRenderer* renderer)
{
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
static void zathura_renderer_init(ZathuraRenderer *renderer) {
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
priv->pool = g_thread_pool_new(render_job, renderer, 1, TRUE, NULL);
priv->about_to_close = false;
g_thread_pool_set_sort_function(priv->pool, render_thread_sort, NULL);
@ -110,10 +110,9 @@ zathura_renderer_init(ZathuraRenderer* renderer)
priv->requests = girara_list_new();
}
static bool
page_cache_init(ZathuraRenderer* renderer, size_t cache_size)
{
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
static bool page_cache_init(ZathuraRenderer *renderer, size_t cache_size) {
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
priv->page_cache.size = cache_size;
priv->page_cache.cache = g_try_malloc0(cache_size * sizeof(int));
@ -125,9 +124,7 @@ page_cache_init(ZathuraRenderer* renderer, size_t cache_size)
return true;
}
ZathuraRenderer*
zathura_renderer_new(size_t cache_size)
{
ZathuraRenderer *zathura_renderer_new(size_t cache_size) {
g_return_val_if_fail(cache_size > 0, NULL);
GObject *obj = g_object_new(ZATHURA_TYPE_RENDERER, NULL);
@ -141,11 +138,10 @@ zathura_renderer_new(size_t cache_size)
return ret;
}
static void
renderer_finalize(GObject* object)
{
static void renderer_finalize(GObject *object) {
ZathuraRenderer *renderer = ZATHURA_RENDERER(object);
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
zathura_renderer_stop(renderer);
if (priv->pool != NULL) {
@ -159,19 +155,17 @@ renderer_finalize(GObject* object)
/* (un)register requests at the renderer */
static void
renderer_unregister_request(ZathuraRenderer* renderer,
ZathuraRenderRequest* request)
{
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
static void renderer_unregister_request(ZathuraRenderer *renderer,
ZathuraRenderRequest *request) {
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
girara_list_remove(priv->requests, request);
}
static void
renderer_register_request(ZathuraRenderer* renderer,
ZathuraRenderRequest* request)
{
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
static void renderer_register_request(ZathuraRenderer *renderer,
ZathuraRenderRequest *request) {
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
if (girara_list_contains(priv->requests, request) == false) {
girara_list_append(priv->requests, request);
}
@ -189,56 +183,34 @@ enum {
static guint request_signals[REQUEST_LAST_SIGNAL] = {0};
static void
zathura_render_request_class_init(ZathuraRenderRequestClass* class)
{
zathura_render_request_class_init(ZathuraRenderRequestClass *class) {
/* overwrite methods */
GObjectClass *object_class = G_OBJECT_CLASS(class);
object_class->dispose = render_request_dispose;
object_class->finalize = render_request_finalize;
request_signals[REQUEST_COMPLETED] = g_signal_new("completed",
ZATHURA_TYPE_RENDER_REQUEST,
G_SIGNAL_RUN_LAST,
0,
NULL,
NULL,
g_cclosure_marshal_generic,
G_TYPE_NONE,
1,
G_TYPE_POINTER);
request_signals[REQUEST_COMPLETED] = g_signal_new(
"completed", ZATHURA_TYPE_RENDER_REQUEST, G_SIGNAL_RUN_LAST, 0, NULL,
NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 1, G_TYPE_POINTER);
request_signals[REQUEST_CACHE_ADDED] = g_signal_new("cache-added",
ZATHURA_TYPE_RENDER_REQUEST,
G_SIGNAL_RUN_LAST,
0,
NULL,
NULL,
g_cclosure_marshal_generic,
G_TYPE_NONE,
0);
request_signals[REQUEST_CACHE_ADDED] = g_signal_new(
"cache-added", ZATHURA_TYPE_RENDER_REQUEST, G_SIGNAL_RUN_LAST, 0, NULL,
NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 0);
request_signals[REQUEST_CACHE_INVALIDATED] = g_signal_new("cache-invalidated",
ZATHURA_TYPE_RENDER_REQUEST,
G_SIGNAL_RUN_LAST,
0,
NULL,
NULL,
g_cclosure_marshal_generic,
G_TYPE_NONE,
0);
request_signals[REQUEST_CACHE_INVALIDATED] = g_signal_new(
"cache-invalidated", ZATHURA_TYPE_RENDER_REQUEST, G_SIGNAL_RUN_LAST, 0,
NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 0);
}
static void
zathura_render_request_init(ZathuraRenderRequest* request)
{
ZathuraRenderRequestPrivate* priv = zathura_render_request_get_instance_private(request);
static void zathura_render_request_init(ZathuraRenderRequest *request) {
ZathuraRenderRequestPrivate *priv =
zathura_render_request_get_instance_private(request);
priv->renderer = NULL;
priv->page = NULL;
}
ZathuraRenderRequest*
zathura_render_request_new(ZathuraRenderer* renderer, zathura_page_t* page)
{
ZathuraRenderRequest *zathura_render_request_new(ZathuraRenderer *renderer,
zathura_page_t *page) {
g_return_val_if_fail(renderer != NULL && page != NULL, NULL);
GObject *obj = g_object_new(ZATHURA_TYPE_RENDER_REQUEST, NULL);
@ -247,7 +219,8 @@ zathura_render_request_new(ZathuraRenderer* renderer, zathura_page_t* page)
}
ZathuraRenderRequest *request = ZATHURA_RENDER_REQUEST(obj);
ZathuraRenderRequestPrivate* priv = zathura_render_request_get_instance_private(request);
ZathuraRenderRequestPrivate *priv =
zathura_render_request_get_instance_private(request);
/* we want to make sure that renderer lives long enough */
priv->renderer = g_object_ref(renderer);
priv->page = page;
@ -261,11 +234,10 @@ zathura_render_request_new(ZathuraRenderer* renderer, zathura_page_t* page)
return request;
}
static void
render_request_dispose(GObject* object)
{
static void render_request_dispose(GObject *object) {
ZathuraRenderRequest *request = ZATHURA_RENDER_REQUEST(object);
ZathuraRenderRequestPrivate* priv = zathura_render_request_get_instance_private(request);
ZathuraRenderRequestPrivate *priv =
zathura_render_request_get_instance_private(request);
if (priv->renderer != NULL) {
/* unregister the request */
@ -277,11 +249,10 @@ render_request_dispose(GObject* object)
G_OBJECT_CLASS(zathura_render_request_parent_class)->dispose(object);
}
static void
render_request_finalize(GObject* object)
{
static void render_request_finalize(GObject *object) {
ZathuraRenderRequest *request = ZATHURA_RENDER_REQUEST(object);
ZathuraRenderRequestPrivate* priv = zathura_render_request_get_instance_private(request);
ZathuraRenderRequestPrivate *priv =
zathura_render_request_get_instance_private(request);
if (girara_list_size(priv->active_jobs) != 0) {
girara_error("This should not happen!");
@ -294,66 +265,62 @@ render_request_finalize(GObject* object)
/* renderer methods */
bool
zathura_renderer_recolor_enabled(ZathuraRenderer* renderer)
{
bool zathura_renderer_recolor_enabled(ZathuraRenderer *renderer) {
g_return_val_if_fail(ZATHURA_IS_RENDERER(renderer), false);
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
return priv->recolor.enabled;
}
void
zathura_renderer_enable_recolor(ZathuraRenderer* renderer, bool enable)
{
void zathura_renderer_enable_recolor(ZathuraRenderer *renderer, bool enable) {
g_return_if_fail(ZATHURA_IS_RENDERER(renderer));
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
priv->recolor.enabled = enable;
}
bool
zathura_renderer_recolor_hue_enabled(ZathuraRenderer* renderer)
{
bool zathura_renderer_recolor_hue_enabled(ZathuraRenderer *renderer) {
g_return_val_if_fail(ZATHURA_IS_RENDERER(renderer), false);
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
return priv->recolor.hue;
}
void
zathura_renderer_enable_recolor_hue(ZathuraRenderer* renderer, bool enable)
{
void zathura_renderer_enable_recolor_hue(ZathuraRenderer *renderer,
bool enable) {
g_return_if_fail(ZATHURA_IS_RENDERER(renderer));
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
priv->recolor.hue = enable;
}
bool
zathura_renderer_recolor_reverse_video_enabled(ZathuraRenderer* renderer)
{
bool zathura_renderer_recolor_reverse_video_enabled(ZathuraRenderer *renderer) {
g_return_val_if_fail(ZATHURA_IS_RENDERER(renderer), false);
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
return priv->recolor.reverse_video;
}
void
zathura_renderer_enable_recolor_reverse_video(ZathuraRenderer* renderer, bool enable)
{
void zathura_renderer_enable_recolor_reverse_video(ZathuraRenderer *renderer,
bool enable) {
g_return_if_fail(ZATHURA_IS_RENDERER(renderer));
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
priv->recolor.reverse_video = enable;
}
void
zathura_renderer_set_recolor_colors(ZathuraRenderer* renderer,
const GdkRGBA* light, const GdkRGBA* dark)
{
void zathura_renderer_set_recolor_colors(ZathuraRenderer *renderer,
const GdkRGBA *light,
const GdkRGBA *dark) {
g_return_if_fail(ZATHURA_IS_RENDERER(renderer));
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
if (light != NULL) {
memcpy(&priv->recolor.light, light, sizeof(GdkRGBA));
}
@ -362,10 +329,9 @@ zathura_renderer_set_recolor_colors(ZathuraRenderer* renderer,
}
}
void
zathura_renderer_set_recolor_colors_str(ZathuraRenderer* renderer,
const char* light, const char* dark)
{
void zathura_renderer_set_recolor_colors_str(ZathuraRenderer *renderer,
const char *light,
const char *dark) {
g_return_if_fail(ZATHURA_IS_RENDERER(renderer));
if (dark != NULL) {
@ -382,13 +348,12 @@ zathura_renderer_set_recolor_colors_str(ZathuraRenderer* renderer,
}
}
void
zathura_renderer_get_recolor_colors(ZathuraRenderer* renderer,
GdkRGBA* light, GdkRGBA* dark)
{
void zathura_renderer_get_recolor_colors(ZathuraRenderer *renderer,
GdkRGBA *light, GdkRGBA *dark) {
g_return_if_fail(ZATHURA_IS_RENDERER(renderer));
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
if (light != NULL) {
memcpy(light, &priv->recolor.light, sizeof(GdkRGBA));
}
@ -397,51 +362,47 @@ zathura_renderer_get_recolor_colors(ZathuraRenderer* renderer,
}
}
void
zathura_renderer_lock(ZathuraRenderer* renderer)
{
void zathura_renderer_lock(ZathuraRenderer *renderer) {
g_return_if_fail(ZATHURA_IS_RENDERER(renderer));
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
g_mutex_lock(&priv->mutex);
}
void
zathura_renderer_unlock(ZathuraRenderer* renderer)
{
void zathura_renderer_unlock(ZathuraRenderer *renderer) {
g_return_if_fail(ZATHURA_IS_RENDERER(renderer));
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
g_mutex_unlock(&priv->mutex);
}
void
zathura_renderer_stop(ZathuraRenderer* renderer)
{
void zathura_renderer_stop(ZathuraRenderer *renderer) {
g_return_if_fail(ZATHURA_IS_RENDERER(renderer));
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
priv->about_to_close = true;
}
/* ZathuraRenderRequest methods */
void
zathura_render_request(ZathuraRenderRequest* request, gint64 last_view_time)
{
void zathura_render_request(ZathuraRenderRequest *request,
gint64 last_view_time) {
g_return_if_fail(ZATHURA_IS_RENDER_REQUEST(request));
ZathuraRenderRequestPrivate* request_priv = zathura_render_request_get_instance_private(request);
ZathuraRenderRequestPrivate *request_priv =
zathura_render_request_get_instance_private(request);
g_mutex_lock(&request_priv->jobs_mutex);
bool unfinished_jobs = false;
/* check if there are any active jobs left */
GIRARA_LIST_FOREACH_BODY(request_priv->active_jobs, render_job_t*, job,
GIRARA_LIST_FOREACH_BODY(
request_priv->active_jobs, render_job_t *, job,
if (job->aborted == false) {
unfinished_jobs = true;
break;
}
);
});
/* only add a new job if there are no active ones left */
if (unfinished_jobs == false) {
@ -456,41 +417,38 @@ zathura_render_request(ZathuraRenderRequest* request, gint64 last_view_time)
job->aborted = false;
girara_list_append(request_priv->active_jobs, job);
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(request_priv->renderer);
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(request_priv->renderer);
g_thread_pool_push(priv->pool, job, NULL);
}
g_mutex_unlock(&request_priv->jobs_mutex);
}
void
zathura_render_request_abort(ZathuraRenderRequest* request)
{
void zathura_render_request_abort(ZathuraRenderRequest *request) {
g_return_if_fail(ZATHURA_IS_RENDER_REQUEST(request));
ZathuraRenderRequestPrivate* request_priv = zathura_render_request_get_instance_private(request);
ZathuraRenderRequestPrivate *request_priv =
zathura_render_request_get_instance_private(request);
g_mutex_lock(&request_priv->jobs_mutex);
GIRARA_LIST_FOREACH_BODY(request_priv->active_jobs, render_job_t *, job,
job->aborted = true;
);
job->aborted = true;);
g_mutex_unlock(&request_priv->jobs_mutex);
}
void
zathura_render_request_update_view_time(ZathuraRenderRequest* request)
{
void zathura_render_request_update_view_time(ZathuraRenderRequest *request) {
g_return_if_fail(ZATHURA_IS_RENDER_REQUEST(request));
ZathuraRenderRequestPrivate* request_priv = zathura_render_request_get_instance_private(request);
ZathuraRenderRequestPrivate *request_priv =
zathura_render_request_get_instance_private(request);
request_priv->last_view_time = g_get_real_time();
}
/* render job */
static void
remove_job_and_free(render_job_t* job)
{
ZathuraRenderRequestPrivate* request_priv = zathura_render_request_get_instance_private(job->request);
static void remove_job_and_free(render_job_t *job) {
ZathuraRenderRequestPrivate *request_priv =
zathura_render_request_get_instance_private(job->request);
g_mutex_lock(&request_priv->jobs_mutex);
girara_list_remove(request_priv->active_jobs, job);
@ -500,25 +458,25 @@ remove_job_and_free(render_job_t* job)
g_free(job);
}
typedef struct emit_completed_signal_s
{
typedef struct emit_completed_signal_s {
render_job_t *job;
cairo_surface_t *surface;
} emit_completed_signal_t;
static gboolean
emit_completed_signal(void* data)
{
static gboolean emit_completed_signal(void *data) {
emit_completed_signal_t *ecs = data;
render_job_t *job = ecs->job;
ZathuraRenderRequestPrivate* request_priv = zathura_render_request_get_instance_private(job->request);
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(request_priv->renderer);
ZathuraRenderRequestPrivate *request_priv =
zathura_render_request_get_instance_private(job->request);
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(request_priv->renderer);
if (priv->about_to_close == false && job->aborted == false) {
/* emit the signal */
girara_debug("Emitting signal for page %d",
zathura_page_get_index(request_priv->page) + 1);
g_signal_emit(job->request, request_signals[REQUEST_COMPLETED], 0, ecs->surface);
g_signal_emit(job->request, request_signals[REQUEST_COMPLETED], 0,
ecs->surface);
} else {
girara_debug("Rendering of page %d aborted",
zathura_page_get_index(request_priv->page) + 1);
@ -536,14 +494,14 @@ emit_completed_signal(void* data)
/* Returns the maximum possible saturation for given h and l.
Assumes that l is in the interval l1, l2 and corrects the value to
force u=0 on l1 and l2 */
static double
colorumax(const double h[3], double l, double l1, double l2)
{
if (fabs(h[0]) <= DBL_EPSILON && fabs(h[1]) <= DBL_EPSILON && fabs(h[2]) <= DBL_EPSILON) {
static double colorumax(const double h[3], double l, double l1, double l2) {
if (fabs(h[0]) <= DBL_EPSILON && fabs(h[1]) <= DBL_EPSILON &&
fabs(h[2]) <= DBL_EPSILON) {
return 0;
}
const double lv = (l - l1) / (l2 - l1); /* Remap l to the whole interval [0,1] */
const double lv =
(l - l1) / (l2 - l1); /* Remap l to the whole interval [0,1] */
double u = DBL_MAX;
double v = DBL_MAX;
for (unsigned int k = 0; k < 3; ++k) {
@ -559,14 +517,14 @@ colorumax(const double h[3], double l, double l1, double l2)
/* rescale v according to the length of the interval [l1, l2] */
v = fabs(l2 - l1) * v;
/* forces the returned value to be 0 on l1 and l2, trying not to distort colors too much */
/* forces the returned value to be 0 on l1 and l2, trying not to distort
* colors too much */
return fmin(u, v);
}
static void
recolor(ZathuraRendererPrivate* priv, zathura_page_t* page, unsigned int page_width,
unsigned int page_height, cairo_surface_t* surface)
{
static void recolor(ZathuraRendererPrivate *priv, zathura_page_t *page,
unsigned int page_width, unsigned int page_height,
cairo_surface_t *surface) {
/* uses a representation of a rgb color as follows:
- a lightness scalar (between 0,1), which is a weighted average of r, g, b,
- a hue vector, which indicates a radian direction from the grey axis,
@ -597,11 +555,8 @@ recolor(ZathuraRendererPrivate* priv, zathura_page_t* page, unsigned int page_wi
const double negalph1 = 1. - rgb1.alpha;
const double negalph2 = 1. - rgb2.alpha;
const double rgb_diff[] = {
rgb2.red - rgb1.red,
rgb2.green - rgb1.green,
rgb2.blue - rgb1.blue
};
const double rgb_diff[] = {rgb2.red - rgb1.red, rgb2.green - rgb1.green,
rgb2.blue - rgb1.blue};
const double h1[3] = {
rgb1.red * rgb1.alpha - l1,
@ -616,10 +571,12 @@ recolor(ZathuraRendererPrivate* priv, zathura_page_t* page, unsigned int page_wi
};
/* Decide if we can use the older, faster formulas */
const bool fast_formula = (!priv->recolor.hue || (
fabs(rgb1.red - rgb1.blue) < DBL_EPSILON && fabs(rgb1.red - rgb1.green) < DBL_EPSILON &&
fabs(rgb2.red - rgb2.blue) < DBL_EPSILON && fabs(rgb2.red - rgb2.green) < DBL_EPSILON
)) && (rgb1.alpha >= 1. - DBL_EPSILON && rgb2.alpha >= 1. - DBL_EPSILON);
const bool fast_formula =
(!priv->recolor.hue || (fabs(rgb1.red - rgb1.blue) < DBL_EPSILON &&
fabs(rgb1.red - rgb1.green) < DBL_EPSILON &&
fabs(rgb2.red - rgb2.blue) < DBL_EPSILON &&
fabs(rgb2.red - rgb2.green) < DBL_EPSILON)) &&
(rgb1.alpha >= 1. - DBL_EPSILON && rgb2.alpha >= 1. - DBL_EPSILON);
girara_list_t *images = NULL;
girara_list_t *rectangles = NULL;
@ -638,14 +595,12 @@ recolor(ZathuraRendererPrivate* priv, zathura_page_t* page, unsigned int page_wi
if (found_images == true) {
/* Get images bounding boxes */
GIRARA_LIST_FOREACH_BODY(images, zathura_image_t*, image_it,
GIRARA_LIST_FOREACH_BODY(
images, zathura_image_t *, image_it,
zathura_rectangle_t *rect = g_try_malloc(sizeof(zathura_rectangle_t));
if (rect == NULL) {
break;
}
*rect = recalc_rectangle(page, image_it->position);
girara_list_append(rectangles, rect);
);
if (rect == NULL) { break; } *rect =
recalc_rectangle(page, image_it->position);
girara_list_append(rectangles, rect););
}
}
@ -656,13 +611,13 @@ recolor(ZathuraRendererPrivate* priv, zathura_page_t* page, unsigned int page_wi
/* Check if the pixel belongs to an image when in reverse video mode*/
if (priv->recolor.reverse_video == true && found_images == true) {
bool inside_image = false;
GIRARA_LIST_FOREACH_BODY(rectangles, zathura_rectangle_t*, rect_it,
if (rect_it->x1 <= x && rect_it->x2 >= x &&
rect_it->y1 <= y && rect_it->y2 >= y) {
GIRARA_LIST_FOREACH_BODY(
rectangles, zathura_rectangle_t *, rect_it,
if (rect_it->x1 <= x && rect_it->x2 >= x && rect_it->y1 <= y &&
rect_it->y2 >= y) {
inside_image = true;
break;
}
);
});
/* If it's inside and image don't recolor */
if (inside_image == true) {
/* It is not guaranteed that the pixel is already opaque. */
@ -672,11 +627,7 @@ recolor(ZathuraRendererPrivate* priv, zathura_page_t* page, unsigned int page_wi
}
/* Careful. data color components blue, green, red. */
const double rgb[3] = {
data[2] / 255.,
data[1] / 255.,
data[0] / 255.
};
const double rgb[3] = {data[2] / 255., data[1] / 255., data[0] / 255.};
/* compute h, s, l data */
double l = a[0] * rgb[0] + a[1] * rgb[1] + a[2] * rgb[2];
@ -684,11 +635,7 @@ recolor(ZathuraRendererPrivate* priv, zathura_page_t* page, unsigned int page_wi
if (priv->recolor.hue == true) {
/* adjusting lightness keeping hue of current color. white and black
* go to grays of same ligtness as light and dark colors. */
const double h[3] = {
rgb[0] - l,
rgb[1] - l,
rgb[2] - l
};
const double h[3] = {rgb[0] - l, rgb[1] - l, rgb[2] - l};
/* u is the maximum possible saturation for given h and l. s is a
* rescaled saturation between 0 and 1 */
@ -711,10 +658,17 @@ recolor(ZathuraRendererPrivate* priv, zathura_page_t* page, unsigned int page_wi
* minimal and maximal channel of the original color */
const double tr1 = (1. - fmax(fmax(rgb[0], rgb[1]), rgb[2]));
const double tr2 = fmin(fmin(rgb[0], rgb[1]), rgb[2]);
data[3] = (unsigned char)round(255.*(1. - tr1*negalph1 - tr2*negalph2));
data[2] = (unsigned char)round(255.*fmin(1, fmax(0, tr1*h1[0] + tr2*h2[0] + (l + su * h[0]))));
data[1] = (unsigned char)round(255.*fmin(1, fmax(0, tr1*h1[1] + tr2*h2[1] + (l + su * h[1]))));
data[0] = (unsigned char)round(255.*fmin(1, fmax(0, tr1*h1[2] + tr2*h2[2] + (l + su * h[2]))));
data[3] = (unsigned char)round(
255. * (1. - tr1 * negalph1 - tr2 * negalph2));
data[2] = (unsigned char)round(
255. *
fmin(1, fmax(0, tr1 * h1[0] + tr2 * h2[0] + (l + su * h[0]))));
data[1] = (unsigned char)round(
255. *
fmin(1, fmax(0, tr1 * h1[1] + tr2 * h2[1] + (l + su * h[1]))));
data[0] = (unsigned char)round(
255. *
fmin(1, fmax(0, tr1 * h1[2] + tr2 * h2[2] + (l + su * h[2]))));
}
} else {
/* linear interpolation between dark and light with color ligtness as
@ -725,12 +679,16 @@ recolor(ZathuraRendererPrivate* priv, zathura_page_t* page, unsigned int page_wi
data[1] = (unsigned char)round(255. * (l * rgb_diff[1] + rgb1.green));
data[0] = (unsigned char)round(255. * (l * rgb_diff[2] + rgb1.blue));
} else {
const double f1 = 1. - (1. - fmax(fmax(rgb[0], rgb[1]), rgb[2]))*negalph1;
const double f1 =
1. - (1. - fmax(fmax(rgb[0], rgb[1]), rgb[2])) * negalph1;
const double f2 = fmin(fmin(rgb[0], rgb[1]), rgb[2]) * negalph2;
data[3] = (unsigned char)round(255. * (f1 - f2));
data[2] = (unsigned char)round(255.*(l * rgb_diff[0] - f2*rgb2.red + f1*rgb1.red));
data[1] = (unsigned char)round(255.*(l * rgb_diff[1] - f2*rgb2.green + f1*rgb1.green));
data[0] = (unsigned char)round(255.*(l * rgb_diff[2] - f2*rgb2.blue + f1*rgb1.blue));
data[2] = (unsigned char)round(
255. * (l * rgb_diff[0] - f2 * rgb2.red + f1 * rgb1.red));
data[1] = (unsigned char)round(
255. * (l * rgb_diff[1] - f2 * rgb2.green + f1 * rgb1.green));
data[0] = (unsigned char)round(
255. * (l * rgb_diff[2] - f2 * rgb2.blue + f1 * rgb1.blue));
}
}
}
@ -746,9 +704,8 @@ recolor(ZathuraRendererPrivate* priv, zathura_page_t* page, unsigned int page_wi
cairo_surface_mark_dirty(surface);
}
static bool
invoke_completed_signal(render_job_t* job, cairo_surface_t* surface)
{
static bool invoke_completed_signal(render_job_t *job,
cairo_surface_t *surface) {
emit_completed_signal_t *ecs = g_try_malloc0(sizeof(emit_completed_signal_t));
if (ecs == NULL) {
return false;
@ -762,9 +719,10 @@ invoke_completed_signal(render_job_t* job, cairo_surface_t* surface)
return true;
}
static bool
render_to_cairo_surface(cairo_surface_t* surface, zathura_page_t* page, ZathuraRenderer* renderer, double real_scale)
{
static bool render_to_cairo_surface(cairo_surface_t *surface,
zathura_page_t *page,
ZathuraRenderer *renderer,
double real_scale) {
cairo_t *cairo = cairo_create(surface);
if (cairo == NULL) {
return false;
@ -790,11 +748,12 @@ render_to_cairo_surface(cairo_surface_t* surface, zathura_page_t* page, ZathuraR
return err == ZATHURA_ERROR_OK;
}
static bool
render(render_job_t* job, ZathuraRenderRequest* request, ZathuraRenderer* renderer)
{
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
ZathuraRenderRequestPrivate* request_priv = zathura_render_request_get_instance_private(request);
static bool render(render_job_t *job, ZathuraRenderRequest *request,
ZathuraRenderer *renderer) {
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
ZathuraRenderRequestPrivate *request_priv =
zathura_render_request_get_instance_private(request);
zathura_page_t *page = request_priv->page;
/* create cairo surface */
@ -806,14 +765,19 @@ render(render_job_t* job, ZathuraRenderRequest* request, ZathuraRenderer* render
const double height = zathura_page_get_height(page);
const double width = zathura_page_get_width(page);
// @debug
fprintf(stderr, "height %f\n", height);
fprintf(stderr, "width %f\n", width);
// @
zathura_device_factors_t device_factors = {0};
double real_scale = 1;
if (request_priv->render_plain == false) {
/* page size in user pixels based on document zoom: if PPI information is
* correct, 100% zoom will result in 72 documents points per inch of screen
* (i.e. document size on screen matching the physical paper size). */
real_scale = page_calc_height_width(document, height, width,
&page_height, &page_width, false);
real_scale = page_calc_height_width(document, height, width, &page_height,
&page_width, false);
device_factors = zathura_document_get_device_factors(document);
page_width *= device_factors.x;
@ -826,12 +790,11 @@ render(render_job_t* job, ZathuraRenderRequest* request, ZathuraRenderer* render
cairo_format_t format;
if (priv->recolor.enabled) {
format = CAIRO_FORMAT_ARGB32;
}
else {
} else {
format = CAIRO_FORMAT_RGB24;
}
cairo_surface_t* surface = cairo_image_surface_create(format,
page_width, page_height);
cairo_surface_t *surface =
cairo_image_surface_create(format, page_width, page_height);
if (surface == NULL) {
return false;
@ -876,23 +839,23 @@ render(render_job_t* job, ZathuraRenderRequest* request, ZathuraRenderer* render
return true;
}
static void
render_job(void* data, void* user_data)
{
static void render_job(void *data, void *user_data) {
render_job_t *job = data;
ZathuraRenderRequest *request = job->request;
ZathuraRenderer *renderer = user_data;
g_return_if_fail(ZATHURA_IS_RENDER_REQUEST(request));
g_return_if_fail(ZATHURA_IS_RENDERER(renderer));
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
if (priv->about_to_close == true || job->aborted == true) {
/* back out early */
remove_job_and_free(job);
return;
}
ZathuraRenderRequestPrivate* request_priv = zathura_render_request_get_instance_private(request);
ZathuraRenderRequestPrivate *request_priv =
zathura_render_request_get_instance_private(request);
girara_debug("Rendering page %d ...",
zathura_page_get_index(request_priv->page) + 1);
if (render(job, request, renderer) != true) {
@ -902,25 +865,25 @@ render_job(void* data, void* user_data)
}
}
void
render_all(zathura_t* zathura)
{
void render_all(zathura_t *zathura) {
if (zathura == NULL || zathura->document == NULL) {
return;
}
/* unmark all pages */
const unsigned int number_of_pages = zathura_document_get_number_of_pages(zathura->document);
const 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);
zathura_page_t *page =
zathura_document_get_page(zathura->document, page_id);
unsigned int page_height = 0, page_width = 0;
const double height = zathura_page_get_height(page);
const double width = zathura_page_get_width(page);
page_calc_height_width(zathura->document, height, width, &page_height, &page_width, true);
page_calc_height_width(zathura->document, height, width, &page_height,
&page_width, true);
girara_debug("Queuing resize for page %u to %u x %u (%0.2f x %0.2f).", page_id, page_width, page_height, width, height);
girara_debug("Queuing resize for page %u to %u x %u (%0.2f x %0.2f).",
page_id, page_width, page_height, width, height);
GtkWidget *widget = zathura_page_get_widget(zathura, page);
if (widget != NULL) {
gtk_widget_set_size_request(widget, page_width, page_height);
@ -929,9 +892,8 @@ render_all(zathura_t* zathura)
}
}
static gint
render_thread_sort(gconstpointer a, gconstpointer b, gpointer UNUSED(data))
{
static gint render_thread_sort(gconstpointer a, gconstpointer b,
gpointer UNUSED(data)) {
if (a == NULL || b == NULL) {
return 0;
}
@ -939,11 +901,14 @@ render_thread_sort(gconstpointer a, gconstpointer b, gpointer UNUSED(data))
const render_job_t *job_a = a;
const render_job_t *job_b = b;
if (job_a->aborted == job_b->aborted) {
ZathuraRenderRequestPrivate* priv_a = zathura_render_request_get_instance_private(job_a->request);
ZathuraRenderRequestPrivate* priv_b = zathura_render_request_get_instance_private(job_b->request);
ZathuraRenderRequestPrivate *priv_a =
zathura_render_request_get_instance_private(job_a->request);
ZathuraRenderRequestPrivate *priv_b =
zathura_render_request_get_instance_private(job_b->request);
return priv_a->last_view_time < priv_b->last_view_time ? -1 :
(priv_a->last_view_time > priv_b->last_view_time ? 1 : 0);
return priv_a->last_view_time < priv_b->last_view_time
? -1
: (priv_a->last_view_time > priv_b->last_view_time ? 1 : 0);
}
/* sort aborted entries earlier so that they are thrown out of the queue */
@ -952,11 +917,11 @@ render_thread_sort(gconstpointer a, gconstpointer b, gpointer UNUSED(data))
/* cache functions */
static bool
page_cache_is_cached(ZathuraRenderer* renderer, unsigned int page_index)
{
static bool page_cache_is_cached(ZathuraRenderer *renderer,
unsigned int page_index) {
g_return_val_if_fail(renderer != NULL, false);
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
if (priv->page_cache.num_cached_pages != 0) {
for (size_t i = 0; i < priv->page_cache.size; ++i) {
@ -972,34 +937,33 @@ page_cache_is_cached(ZathuraRenderer* renderer, unsigned int page_index)
return false;
}
static int
find_request_by_page_index(const void* req, const void* data)
{
static int find_request_by_page_index(const void *req, const void *data) {
ZathuraRenderRequest *request = (void *)req;
const unsigned int page_index = *((const int *)data);
ZathuraRenderRequestPrivate* priv = zathura_render_request_get_instance_private(request);
ZathuraRenderRequestPrivate *priv =
zathura_render_request_get_instance_private(request);
if (zathura_page_get_index(priv->page) == page_index) {
return 0;
}
return 1;
}
static ssize_t
page_cache_lru_invalidate(ZathuraRenderer* renderer)
{
static ssize_t page_cache_lru_invalidate(ZathuraRenderer *renderer) {
g_return_val_if_fail(renderer != NULL, -1);
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
g_return_val_if_fail(priv->page_cache.size != 0, -1);
ssize_t lru_index = 0;
gint64 lru_view_time = G_MAXINT64;
ZathuraRenderRequest *request = NULL;
for (size_t i = 0; i < priv->page_cache.size; ++i) {
ZathuraRenderRequest* tmp_request = girara_list_find(priv->requests,
find_request_by_page_index, &priv->page_cache.cache[i]);
ZathuraRenderRequest *tmp_request = girara_list_find(
priv->requests, find_request_by_page_index, &priv->page_cache.cache[i]);
g_return_val_if_fail(tmp_request != NULL, -1);
ZathuraRenderRequestPrivate* request_priv = zathura_render_request_get_instance_private(tmp_request);
ZathuraRenderRequestPrivate *request_priv =
zathura_render_request_get_instance_private(tmp_request);
if (request_priv->last_view_time < lru_view_time) {
lru_view_time = request_priv->last_view_time;
@ -1008,7 +972,8 @@ page_cache_lru_invalidate(ZathuraRenderer* renderer)
}
}
ZathuraRenderRequestPrivate* request_priv = zathura_render_request_get_instance_private(request);
ZathuraRenderRequestPrivate *request_priv =
zathura_render_request_get_instance_private(request);
/* emit the signal */
g_signal_emit(request, request_signals[REQUEST_CACHE_INVALIDATED], 0);
@ -1020,39 +985,36 @@ page_cache_lru_invalidate(ZathuraRenderer* renderer)
return lru_index;
}
static bool
page_cache_is_full(ZathuraRenderer* renderer, bool* result)
{
static bool page_cache_is_full(ZathuraRenderer *renderer, bool *result) {
g_return_val_if_fail(ZATHURA_IS_RENDERER(renderer) && result != NULL, false);
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
*result = priv->page_cache.num_cached_pages == priv->page_cache.size;
return true;
}
static void
page_cache_invalidate_all(ZathuraRenderer* renderer)
{
static void page_cache_invalidate_all(ZathuraRenderer *renderer) {
g_return_if_fail(ZATHURA_IS_RENDERER(renderer));
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
for (size_t i = 0; i < priv->page_cache.size; ++i) {
priv->page_cache.cache[i] = -1;
}
priv->page_cache.num_cached_pages = 0;
}
void
zathura_renderer_page_cache_add(ZathuraRenderer* renderer,
unsigned int page_index)
{
void zathura_renderer_page_cache_add(ZathuraRenderer *renderer,
unsigned int page_index) {
g_return_if_fail(ZATHURA_IS_RENDERER(renderer));
if (page_cache_is_cached(renderer, page_index) == true) {
return;
}
ZathuraRendererPrivate* priv = zathura_renderer_get_instance_private(renderer);
ZathuraRendererPrivate *priv =
zathura_renderer_get_instance_private(renderer);
bool full = false;
if (page_cache_is_full(renderer, &full) == false) {
return;
@ -1071,27 +1033,25 @@ zathura_renderer_page_cache_add(ZathuraRenderer* renderer,
priv->page_cache.num_cached_pages - 1);
}
ZathuraRenderRequest* request = girara_list_find(priv->requests,
find_request_by_page_index, &page_index);
ZathuraRenderRequest *request =
girara_list_find(priv->requests, find_request_by_page_index, &page_index);
g_return_if_fail(request != NULL);
g_signal_emit(request, request_signals[REQUEST_CACHE_ADDED], 0);
}
void zathura_render_request_set_render_plain(ZathuraRenderRequest *request,
bool render_plain)
{
bool render_plain) {
g_return_if_fail(ZATHURA_IS_RENDER_REQUEST(request));
ZathuraRenderRequestPrivate* priv = zathura_render_request_get_instance_private(request);
ZathuraRenderRequestPrivate *priv =
zathura_render_request_get_instance_private(request);
priv->render_plain = render_plain;
}
bool
zathura_render_request_get_render_plain(ZathuraRenderRequest* request)
{
bool zathura_render_request_get_render_plain(ZathuraRenderRequest *request) {
g_return_val_if_fail(ZATHURA_IS_RENDER_REQUEST(request), false);
ZathuraRenderRequestPrivate* priv = zathura_render_request_get_instance_private(request);
ZathuraRenderRequestPrivate *priv =
zathura_render_request_get_instance_private(request);
return priv->render_plain;
}

544
zathura/zathura.c
View file

File diff suppressed because it is too large Load diff