zathura_error_t
djvu_page_init(zathura_page_t* page, void* UNUSED(data))
{
if (page == NULL) {
return ZATHURA_ERROR_INVALID_ARGUMENTS;
}
zathura_document_t* document = zathura_page_get_document(page);
djvu_document_t* djvu_document = zathura_document_get_data(document);
ddjvu_status_t status;
ddjvu_pageinfo_t page_info;
unsigned int index = zathura_page_get_index(page);
while ((status = ddjvu_document_get_pageinfo(djvu_document->document, index,
&page_info)) < DDJVU_JOB_OK) {
handle_messages(djvu_document, true);
}
if (status >= DDJVU_JOB_FAILED) {
handle_messages(djvu_document, true);
return ZATHURA_ERROR_UNKNOWN;
}
zathura_page_set_width(page, ZATHURA_DJVU_SCALE * page_info.width);
zathura_page_set_height(page, ZATHURA_DJVU_SCALE * page_info.height);
return ZATHURA_ERROR_OK;
}
int main()
{
client_make_connection();
handle_messages();
client_close_connection();
return 0;
}
bool Scene::run() {
Graphics* ptr_graphics = Graphics::instance();
Audio* ptr_audio = Audio::instance();
TextureCache* ptr_texture_cache = TextureCache::instance();
InputManager* ptr_inputManager = new InputManager();
m_frame_timer.start(m_millis_per_frame);
on_setup();
setup_sprites();
on_begin();
while (!m_scene_is_ended) {
ptr_inputManager->update();
on_check_input(ptr_inputManager);
if (!m_is_paused) {
handle_messages();
on_detect_collisions();
on_update();
update_sprites();
ptr_graphics->begin_render();
on_render(ptr_graphics);
ptr_graphics->end_render();
}
while (!m_frame_timer.has_elapsed());
}
cleanup_sprites();
on_cleanup();
return !m_game_is_ended;
}
zathura_error_t
djvu_document_save_as(zathura_document_t* document, djvu_document_t* djvu_document, const char* path)
{
if (document == NULL || djvu_document == NULL || path == NULL) {
return ZATHURA_ERROR_INVALID_ARGUMENTS;
}
FILE* fp = fopen(path, "w");
if (fp == NULL) {
return ZATHURA_ERROR_UNKNOWN;
}
const char* extension = get_extension(path);
ddjvu_job_t* job = NULL;
if (extension != NULL && g_strcmp0(extension, "ps") == 0) {
job = ddjvu_document_print(djvu_document->document, fp, 0, NULL);
} else {
job = ddjvu_document_save(djvu_document->document, fp, 0, NULL);
}
while (ddjvu_job_done(job) != true) {
handle_messages(djvu_document, true);
}
fclose(fp);
return ZATHURA_ERROR_OK;
}
girara_tree_node_t*
djvu_document_index_generate(zathura_document_t* document, djvu_document_t*
djvu_document, zathura_error_t* error)
{
if (document == NULL || djvu_document == NULL) {
if (error != NULL) {
*error = ZATHURA_ERROR_INVALID_ARGUMENTS;
}
return NULL;
}
miniexp_t outline = miniexp_dummy;
while ((outline = ddjvu_document_get_outline(djvu_document->document)) ==
miniexp_dummy) {
handle_messages(djvu_document, true);
}
if (outline == miniexp_dummy) {
return NULL;
}
if (miniexp_consp(outline) == 0 || miniexp_car(outline) != miniexp_symbol("bookmarks")) {
ddjvu_miniexp_release(djvu_document->document, outline);
return NULL;
}
girara_tree_node_t* root = girara_node_new(zathura_index_element_new("ROOT"));
build_index(djvu_document, miniexp_cdr(outline), root);
ddjvu_miniexp_release(djvu_document->document, outline);
return root;
}
int main(int argc, char *argv[])
{
struct sockaddr_un addr;
signal(SIGINT, handle_sigint);
signal(SIGTERM, handle_sigterm);
signal(SIGQUIT, handle_sigquit);
if (options(argc, argv) < 0) {
usage();
goto failure;
}
if (flags & HELP) {
usage();
goto success;
}
if (flags & DAEMON)
if (daemon(1, 1) < 0)
goto failure;
if (db_start() < 0)
goto failure;
if ((control_sock = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0)
goto failure;
addr.sun_family = AF_UNIX;
strncpy(addr.sun_path, CONTROL_SOCKET_PATH, UNIX_PATH_MAX);
if (bind(control_sock, (struct sockaddr *)&addr, sizeof(addr)) < 0)
goto failure;
if (handle_messages() < 0)
goto failure;
close(control_sock);
unlink(CONTROL_SOCKET_PATH);
if (db_end() < 0)
goto failure;
return 0;
failure:
if (control_sock != -1) {
close(control_sock);
unlink(CONTROL_SOCKET_PATH);
}
return 1;
success:
return 0;
}
zathura_error_t
djvu_page_render_cairo(zathura_page_t* page, void* UNUSED(data), cairo_t* cairo,
bool GIRARA_UNUSED(printing))
{
if (page == NULL || cairo == NULL) {
return ZATHURA_ERROR_INVALID_ARGUMENTS;
}
zathura_document_t* document = zathura_page_get_document(page);
if (document == NULL) {
return ZATHURA_ERROR_UNKNOWN;
}
/* init ddjvu render data */
djvu_document_t* djvu_document = zathura_document_get_data(document);
ddjvu_page_t* djvu_page = ddjvu_page_create_by_pageno(djvu_document->document, zathura_page_get_index(page));
if (djvu_page == NULL) {
return ZATHURA_ERROR_UNKNOWN;
}
while (!ddjvu_page_decoding_done(djvu_page)) {
handle_messages(djvu_document, true);
}
cairo_surface_t* surface = cairo_get_target(cairo);
if (surface == NULL ||
cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS ||
cairo_surface_get_type(surface) != CAIRO_SURFACE_TYPE_IMAGE) {
ddjvu_page_release(djvu_page);
return ZATHURA_ERROR_UNKNOWN;
}
unsigned int page_width = cairo_image_surface_get_width(surface);
unsigned int page_height = cairo_image_surface_get_height(surface);;
ddjvu_rect_t rrect = { 0, 0, page_width, page_height };
ddjvu_rect_t prect = { 0, 0, page_width, page_height };
char* surface_data = (char*) cairo_image_surface_get_data(surface);
if (surface_data == NULL) {
ddjvu_page_release(djvu_page);
return ZATHURA_ERROR_UNKNOWN;
}
/* render page */
ddjvu_page_render(djvu_page, DDJVU_RENDER_COLOR, &prect, &rrect,
djvu_document->format, cairo_image_surface_get_stride(surface), surface_data);
ddjvu_page_release(djvu_page);
return ZATHURA_ERROR_OK;
}
static int do_service(void)
{
int rc;
rc = dbus_bus_request_name(connection, name,
DBUS_NAME_FLAG_REPLACE_EXISTING, &error);
if (dbus_error_is_set(&error)) {
fprintf(stderr, "FAIL: %s: %s\n", error.name, error.message);
dbus_error_free(&error);
}
if (rc != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
return 1;
}
if (unlock_fd())
return 1;
rc = 0;
while (!terminate && !rc)
rc = handle_messages();
/* If we've received SIGTERM, try one last time to drain the incoming queue */
if (terminate && !rc)
rc = handle_messages();
if (rc < 0)
return 1;
rc = dbus_bus_release_name(connection, name, &error);
if (dbus_error_is_set(&error)) {
fprintf(stderr, "FAIL: %s: %s\n", error.name, error.message);
dbus_error_free(&error);
}
if (rc != DBUS_RELEASE_NAME_REPLY_RELEASED) {
return 1;
}
return 0;
}
static size_t write_callback(void *ptr, size_t size, size_t nmemb, void *data)
{
viprinet_status_t *status;
size_t realsize = size * nmemb;
status = (viprinet_status_t *)data;
buffer_realloc(status, realsize + 1);
if (status->buffer) {
memcpy(&(status->buffer[0]), ptr, realsize);
status->buffer[realsize] = 0;
handle_messages(status);
}
return realsize;
}
//******************************************************************************
/// \brief Main bridge function to handle a single connection
/// \return #mxt_rc
static int bridge(struct mxt_device *mxt, int sockfd)
{
int ret, pollret;
struct pollfd fds[2];
int fopts = 0;
int debug_ng_fd = 0;
int numfds = 1;
int timeout;
mxt_info(mxt->ctx, "Connected");
ret = mxt_msg_reset(mxt);
if (ret)
mxt_err(mxt->ctx, "Failure to reset msgs");
fds[0].fd = sockfd;
fds[0].events = POLLIN | POLLERR;
ret = send_chip_attach(mxt, sockfd);
if (ret)
return ret;
while (1) {
debug_ng_fd = mxt_get_msg_poll_fd(mxt);
if (debug_ng_fd) {
fds[1].fd = debug_ng_fd;
fds[1].events = POLLPRI;
numfds = 2;
timeout = -1;
} else {
timeout = 100; // milliseconds
}
pollret = poll(fds, numfds, timeout);
if (pollret == -1 && errno == EINTR) {
mxt_dbg(mxt->ctx, "Interrupted");
continue;
} else if (pollret == -1) {
mxt_err(mxt->ctx, "Poll returned %d (%s)", errno, strerror(errno));
ret = mxt_errno_to_rc(errno);
goto disconnect;
}
/* Detect socket disconnect */
if (fcntl(sockfd, F_GETFL, &fopts) < 0) {
ret = MXT_SUCCESS;
mxt_dbg(mxt->ctx, "Socket disconnected");
goto disconnect;
}
if (fds[0].revents) {
ret = handle_cmd(mxt, sockfd);
if (ret) {
mxt_dbg(mxt->ctx, "handle_cmd returned %d", ret);
goto disconnect;
}
}
/* If timeout or msg poll fd event */
if (pollret == 0 || fds[1].revents) {
ret = handle_messages(mxt, sockfd);
if (ret)
goto disconnect;
}
}
disconnect:
mxt_info(mxt->ctx, "Disconnected");
return ret;
}
zathura_image_buffer_t*
djvu_page_render(zathura_page_t* page, void* UNUSED(data), zathura_error_t* error)
{
if (page == NULL) {
if (error != NULL) {
*error = ZATHURA_ERROR_INVALID_ARGUMENTS;
}
return NULL;
}
zathura_document_t* document = zathura_page_get_document(page);
if (document == NULL) {
return NULL;
}
/* calculate sizes */
unsigned int page_width = zathura_document_get_scale(document) * zathura_page_get_width(page);
unsigned int page_height = zathura_document_get_scale(document) * zathura_page_get_height(page);
if (page_width == 0 || page_height == 0) {
if (error != NULL) {
*error = ZATHURA_ERROR_UNKNOWN;
}
goto error_out;
}
/* init ddjvu render data */
djvu_document_t* djvu_document = zathura_document_get_data(document);
ddjvu_page_t* djvu_page = ddjvu_page_create_by_pageno(
djvu_document->document, zathura_page_get_index(page));
if (djvu_page == NULL) {
if (error != NULL) {
*error = ZATHURA_ERROR_UNKNOWN;
}
goto error_out;
}
while (!ddjvu_page_decoding_done(djvu_page)) {
handle_messages(djvu_document, true);
}
ddjvu_rect_t rrect = { 0, 0, page_width, page_height };
ddjvu_rect_t prect = { 0, 0, page_width, page_height };
zathura_image_buffer_t* image_buffer =
zathura_image_buffer_create(page_width, page_height);
if (image_buffer == NULL) {
if (error != NULL) {
*error = ZATHURA_ERROR_OUT_OF_MEMORY;
}
goto error_free;
}
/* set rotation */
ddjvu_page_set_rotation(djvu_page, DDJVU_ROTATE_0);
/* render page */
ddjvu_page_render(djvu_page, DDJVU_RENDER_COLOR, &prect, &rrect,
djvu_document->format, 3 * page_width, (char*) image_buffer->data);
return image_buffer;
error_free:
ddjvu_page_release(djvu_page);
zathura_image_buffer_free(image_buffer);
error_out:
return NULL;
}
zathura_error_t
djvu_document_open(zathura_document_t* document)
{
zathura_error_t error = ZATHURA_ERROR_OK;
if (document == NULL) {
error = ZATHURA_ERROR_INVALID_ARGUMENTS;
goto error_out;
}
djvu_document_t* djvu_document = calloc(1, sizeof(djvu_document_t));
if (djvu_document == NULL) {
error = ZATHURA_ERROR_OUT_OF_MEMORY;
goto error_out;
}
/* setup format */
static unsigned int masks[4] = {0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000};
djvu_document->format = ddjvu_format_create(DDJVU_FORMAT_RGBMASK32, 4, masks);
if (djvu_document->format == NULL) {
error = ZATHURA_ERROR_UNKNOWN;
goto error_free;
}
ddjvu_format_set_row_order(djvu_document->format, TRUE);
/* setup context */
djvu_document->context = ddjvu_context_create("zathura");
if (djvu_document->context == NULL) {
error = ZATHURA_ERROR_UNKNOWN;
goto error_free;
}
/* setup document */
djvu_document->document =
ddjvu_document_create_by_filename(
djvu_document->context,
zathura_document_get_path(document),
FALSE
);
if (djvu_document->document == NULL) {
error = ZATHURA_ERROR_UNKNOWN;
goto error_free;
}
/* load document info */
ddjvu_message_t* msg;
ddjvu_message_wait(djvu_document->context);
while ((msg = ddjvu_message_peek(djvu_document->context)) &&
(msg->m_any.tag != DDJVU_DOCINFO)) {
if (msg->m_any.tag == DDJVU_ERROR) {
error = ZATHURA_ERROR_UNKNOWN;
goto error_free;
}
ddjvu_message_pop(djvu_document->context);
}
/* decoding error */
if (ddjvu_document_decoding_error(djvu_document->document)) {
handle_messages(djvu_document, true);
error = ZATHURA_ERROR_UNKNOWN;
goto error_free;
}
zathura_document_set_data(document, djvu_document);
zathura_document_set_number_of_pages(document,
ddjvu_document_get_pagenum(djvu_document->document));
return error;
error_free:
if (djvu_document->format != NULL) {
ddjvu_format_release(djvu_document->format);
}
if (djvu_document->context != NULL) {
ddjvu_context_release(djvu_document->context);
}
free(djvu_document);
error_out:
return error;
}
girara_list_t*
djvu_page_links_get(zathura_page_t* page, void* UNUSED(data), zathura_error_t* error)
{
if (page == NULL) {
if (error != NULL) {
*error = ZATHURA_ERROR_INVALID_ARGUMENTS;
}
goto error_ret;
}
zathura_document_t* document = zathura_page_get_document(page);
if (document == NULL) {
goto error_ret;
}
girara_list_t* list = girara_list_new2((girara_free_function_t) zathura_link_free);
if (list == NULL) {
if (error != NULL) {
*error = ZATHURA_ERROR_OUT_OF_MEMORY;
}
goto error_ret;
}
djvu_document_t* djvu_document = zathura_document_get_data(document);
miniexp_t annotations = miniexp_nil;
while ((annotations = ddjvu_document_get_pageanno(djvu_document->document,
zathura_page_get_index(page))) == miniexp_dummy) {
handle_messages(djvu_document, true);
}
if (annotations == miniexp_nil) {
goto error_free;
}
miniexp_t* hyperlinks = ddjvu_anno_get_hyperlinks(annotations);
for (miniexp_t* iter = hyperlinks; *iter != NULL; iter++) {
if (miniexp_car(*iter) != miniexp_symbol("maparea")) {
continue;
}
miniexp_t inner = miniexp_cdr(*iter);
/* extract url information */
const char* target_string = NULL;
if (miniexp_caar(inner) == miniexp_symbol("url")) {
if (exp_to_str(miniexp_caddr(miniexp_car(inner)), &target_string) == false) {
continue;
}
} else {
if (exp_to_str(miniexp_car(inner), &target_string) == false) {
continue;
}
}
/* skip comment */
inner = miniexp_cdr(inner);
/* extract link area */
inner = miniexp_cdr(inner);
zathura_rectangle_t rect = { 0, 0, 0, 0 };
if (exp_to_rect(miniexp_car(inner), &rect) == false) {
continue;
}
/* update rect */
unsigned int page_height = zathura_page_get_height(page) / ZATHURA_DJVU_SCALE;
rect.x1 = rect.x1 * ZATHURA_DJVU_SCALE;
rect.x2 = rect.x2 * ZATHURA_DJVU_SCALE;
double tmp = rect.y1;
rect.y1 = (page_height - rect.y2) * ZATHURA_DJVU_SCALE;
rect.y2 = (page_height - tmp) * ZATHURA_DJVU_SCALE;
/* create zathura link */
zathura_link_type_t type = ZATHURA_LINK_INVALID;
zathura_link_target_t target = { ZATHURA_LINK_DESTINATION_UNKNOWN, NULL, 0, -1, -1, -1, -1, 0 };;
/* goto page */
if (target_string[0] == '#' && target_string[1] == 'p') {
type = ZATHURA_LINK_GOTO_DEST;
target.page_number = atoi(target_string + 2) - 1;
/* url or other? */
} else if (strstr(target_string, "//") != NULL) {
type = ZATHURA_LINK_URI;
target.value = (char*) target_string;
/* TODO: Parse all different links */
} else {
continue;
}
zathura_link_t* link = zathura_link_new(type, rect, target);
if (link != NULL) {
girara_list_append(list, link);
}
}
return list;
error_free:
if (list != NULL) {
girara_list_free(list);
}
error_ret:
return NULL;
}