} END_TEST
START_TEST(test_datastructures_list_free_empty) {
// free empty list
girara_list_t* list = girara_list_new();
fail_unless((list != NULL), NULL);
girara_list_free(list);
list = girara_list_new2(NULL);
fail_unless((list != NULL), NULL);
girara_list_free(list);
list = girara_list_new2(g_free);
fail_unless((list != NULL), NULL);
girara_list_free(list);
} END_TEST
zathura_plugin_manager_t*
zathura_plugin_manager_new()
{
zathura_plugin_manager_t* plugin_manager = g_malloc0(sizeof(zathura_plugin_manager_t));
plugin_manager->plugins = girara_list_new2((girara_free_function_t) zathura_plugin_free);
plugin_manager->path = girara_list_new2(g_free);
plugin_manager->type_plugin_mapping = girara_list_new2((girara_free_function_t)zathura_type_plugin_mapping_free);
if (plugin_manager->plugins == NULL
|| plugin_manager->path == NULL
|| plugin_manager->type_plugin_mapping == NULL) {
zathura_plugin_manager_free(plugin_manager);
return NULL;
}
return plugin_manager;
}
} END_TEST
START_TEST(test_datastructures_sorted_list) {
girara_list_t* list = girara_sorted_list_new2((girara_compare_function_t) g_strcmp0,
(girara_free_function_t) g_free);
fail_unless((list != NULL), NULL);
girara_list_t* unsorted_list = girara_list_new2((girara_free_function_t) g_free);
fail_unless((unsorted_list != NULL), NULL);
static const char* test_strings[] = {
"A",
"C",
"Baa",
"Za",
"Bba",
"Bab",
NULL
};
static const char* test_strings_sorted[] = {
"A",
"Baa",
"Bab",
"Bba",
"C",
"Za",
NULL
};
// append
for (const char** p = test_strings; *p != NULL; ++p) {
girara_list_append(list, (void*)g_strdup(*p));
girara_list_append(unsorted_list, (void*)g_strdup(*p));
}
fail_unless((girara_list_size(list) == sizeof(test_strings) / sizeof(char*) - 1), NULL);
fail_unless((girara_list_size(unsorted_list) == sizeof(test_strings) / sizeof(char*) - 1), NULL);
// check sorting
const char** p = test_strings_sorted;
GIRARA_LIST_FOREACH(list, const char*, iter, value)
fail_unless((g_strcmp0(value, *p) == 0), NULL);
++p;
GIRARA_LIST_FOREACH_END(list, const char*, iter, value);
girara_list_sort(unsorted_list, (girara_compare_function_t) g_strcmp0);
p = test_strings_sorted;
GIRARA_LIST_FOREACH(unsorted_list, const char*, iter, value)
fail_unless((g_strcmp0(value, *p) == 0), NULL);
++p;
GIRARA_LIST_FOREACH_END(unsorted_list, const char*, iter, value);
girara_list_free(list);
girara_list_free(unsorted_list);
} END_TEST
} END_TEST
START_TEST(test_datastructures_list_free_free_function_remove) {
// remove with free function
list_free_called = 0;
girara_list_t* list = girara_list_new2(list_free);
fail_unless((list != NULL), NULL);
girara_list_append(list, (void*)0xDEAD);
girara_list_remove(list, (void*)0xDEAD);
fail_unless((girara_list_size(list) == 0), NULL);
girara_list_free(list);
fail_unless((list_free_called == 1), NULL);
} END_TEST
girara_list_t*
girara_split_path_array(const char* patharray)
{
if (patharray == NULL || !g_strcmp0(patharray, "")) {
return NULL;
}
girara_list_t* res = girara_list_new2(g_free);
char** paths = g_strsplit(patharray, ":", 0);
for (size_t i = 0; paths[i] != NULL; ++i) {
girara_list_append(res, g_strdup(paths[i]));
}
g_strfreev(paths);
return res;
}
bool
synctex_view(zathura_t* zathura, const char* input_file,
unsigned int line, unsigned int column)
{
if (zathura == NULL || input_file == NULL) {
return false;
}
const unsigned int number_of_pages = zathura_document_get_number_of_pages(zathura->document);
unsigned int page = 0;
girara_list_t* secondary_rects = NULL;
girara_list_t* rectangles = synctex_rectangles_from_position(
zathura_document_get_path(zathura->document), input_file, line,
column, &page, &secondary_rects);
if (rectangles == NULL) {
return false;
}
girara_list_t** all_rectangles = g_try_malloc0(number_of_pages * sizeof(girara_list_t*));
if (all_rectangles == NULL) {
girara_list_free(rectangles);
return false;
}
for (unsigned int p = 0; p != number_of_pages; ++p) {
if (p == page) {
all_rectangles[p] = rectangles;
} else {
all_rectangles[p] = girara_list_new2(g_free);
}
}
if (secondary_rects != NULL) {
GIRARA_LIST_FOREACH(secondary_rects, synctex_page_rect_t*, iter, rect)
zathura_rectangle_t* newrect = g_try_malloc0(sizeof(zathura_rectangle_t));
if (newrect != NULL) {
*newrect = rect->rect;
girara_list_append(all_rectangles[rect->page], newrect);
}
GIRARA_LIST_FOREACH_END(secondary_rects, synctex_page_rect_t*, iter, rect);
}
void
zathura_plugin_manager_load(zathura_plugin_manager_t* plugin_manager)
{
if (plugin_manager == NULL || plugin_manager->path == NULL) {
return;
}
GIRARA_LIST_FOREACH(plugin_manager->path, char*, iter, plugindir)
/* read all files in the plugin directory */
GDir* dir = g_dir_open(plugindir, 0, NULL);
if (dir == NULL) {
girara_error("could not open plugin directory: %s", plugindir);
girara_list_iterator_next(iter);
continue;
}
char* name = NULL;
while ((name = (char*) g_dir_read_name(dir)) != NULL) {
char* path = g_build_filename(plugindir, name, NULL);
if (g_file_test(path, G_FILE_TEST_IS_REGULAR) == 0) {
girara_debug("%s is not a regular file. Skipping.", path);
g_free(path);
continue;
}
if (check_suffix(path) == false) {
girara_debug("%s is not a plugin file. Skipping.", path);
g_free(path);
continue;
}
zathura_plugin_t* plugin = NULL;
/* load plugin */
GModule* handle = g_module_open(path, G_MODULE_BIND_LOCAL);
if (handle == NULL) {
girara_error("could not load plugin %s (%s)", path, g_module_error());
g_free(path);
continue;
}
/* resolve symbols and check API and ABI version*/
zathura_plugin_api_version_t api_version = NULL;
if (g_module_symbol(handle, PLUGIN_API_VERSION_FUNCTION, (gpointer*) &api_version) == FALSE ||
api_version == NULL) {
girara_error("could not find '%s' function in plugin %s", PLUGIN_API_VERSION_FUNCTION, path);
g_free(path);
g_module_close(handle);
continue;
}
if (api_version() != ZATHURA_API_VERSION) {
girara_error("plugin %s has been built againt zathura with a different API version (plugin: %d, zathura: %d)",
path, api_version(), ZATHURA_API_VERSION);
g_free(path);
g_module_close(handle);
continue;
}
zathura_plugin_abi_version_t abi_version = NULL;
if (g_module_symbol(handle, PLUGIN_ABI_VERSION_FUNCTION, (gpointer*) &abi_version) == FALSE ||
abi_version == NULL) {
girara_error("could not find '%s' function in plugin %s", PLUGIN_ABI_VERSION_FUNCTION, path);
g_free(path);
g_module_close(handle);
continue;
}
if (abi_version() != ZATHURA_ABI_VERSION) {
girara_error("plugin %s has been built againt zathura with a different ABI version (plugin: %d, zathura: %d)",
path, abi_version(), ZATHURA_ABI_VERSION);
g_free(path);
g_module_close(handle);
continue;
}
zathura_plugin_register_service_t register_service = NULL;
if (g_module_symbol(handle, PLUGIN_REGISTER_FUNCTION, (gpointer*) ®ister_service) == FALSE ||
register_service == NULL) {
girara_error("could not find '%s' function in plugin %s", PLUGIN_REGISTER_FUNCTION, path);
g_free(path);
g_module_close(handle);
continue;
}
plugin = g_try_malloc0(sizeof(zathura_plugin_t));
if (plugin == NULL) {
girara_error("Failed to allocate memory for plugin.");
g_free(path);
g_module_close(handle);
continue;
}
plugin->content_types = girara_list_new2(g_free);
plugin->handle = handle;
register_service(plugin);
/* register functions */
if (plugin->register_function == NULL) {
girara_error("plugin has no document functions register function");
g_free(path);
g_free(plugin);
g_module_close(handle);
continue;
}
plugin->register_function(&(plugin->functions));
plugin->path = path;
bool ret = register_plugin(plugin_manager, plugin);
if (ret == false) {
girara_error("could not register plugin %s", path);
zathura_plugin_free(plugin);
} else {
girara_debug("successfully loaded plugin %s", path);
zathura_plugin_version_function_t plugin_major = NULL, plugin_minor = NULL, plugin_rev = NULL;
g_module_symbol(handle, PLUGIN_VERSION_MAJOR_FUNCTION, (gpointer*) &plugin_major);
g_module_symbol(handle, PLUGIN_VERSION_MINOR_FUNCTION, (gpointer*) &plugin_minor);
g_module_symbol(handle, PLUGIN_VERSION_REVISION_FUNCTION, (gpointer*) &plugin_rev);
if (plugin_major != NULL && plugin_minor != NULL && plugin_rev != NULL) {
plugin->version.major = plugin_major();
plugin->version.minor = plugin_minor();
plugin->version.rev = plugin_rev();
girara_debug("plugin '%s': version %u.%u.%u", path,
plugin->version.major, plugin->version.minor,
plugin->version.rev);
}
}
}
g_dir_close(dir);
GIRARA_LIST_FOREACH_END(zathura->plugins.path, char*, iter, plugindir);
}
girara_list_t*
synctex_rectangles_from_position(const char* filename, const char* input_file,
int line, int column, unsigned int* page,
girara_list_t** secondary_rects)
{
if (filename == NULL || input_file == NULL || page == NULL) {
return NULL;
}
synctex_scanner_t scanner = synctex_scanner_new_with_output_file(filename, NULL, 1);
if (scanner == NULL) {
girara_debug("Failed to create synctex scanner.");
return NULL;
}
synctex_scanner_t temp = synctex_scanner_parse(scanner);
if (temp == NULL) {
girara_debug("Failed to parse synctex file.");
synctex_scanner_free(scanner);
return NULL;
}
girara_list_t* hitlist = girara_list_new2(g_free);
girara_list_t* other_rects = girara_list_new2(g_free);
if (synctex_display_query(scanner, input_file, line, column) > 0) {
synctex_node_t node = NULL;
bool got_page = false;
while ((node = synctex_next_result (scanner)) != NULL) {
const unsigned int current_page = synctex_node_page(node) - 1;
if (got_page == false) {
got_page = true;
*page = current_page;
}
zathura_rectangle_t rect = { 0, 0, 0, 0 };
rect.x1 = synctex_node_box_visible_h(node);
rect.y1 = synctex_node_box_visible_v(node) - synctex_node_box_visible_height(node);
rect.x2 = rect.x1 + synctex_node_box_visible_width(node);
rect.y2 = synctex_node_box_visible_depth(node) + synctex_node_box_visible_height (node) + rect.y1;
if (*page == current_page) {
zathura_rectangle_t* real_rect = g_try_malloc(sizeof(zathura_rectangle_t));
if (real_rect == NULL) {
continue;
}
*real_rect = rect;
girara_list_append(hitlist, real_rect);
} else {
synctex_page_rect_t* page_rect = g_try_malloc(sizeof(synctex_page_rect_t));
if (page_rect == NULL) {
continue;
}
page_rect->page = current_page;
page_rect->rect = rect;
girara_list_append(other_rects, page_rect);
}
}
}
synctex_scanner_free(scanner);
if (secondary_rects != NULL) {
*secondary_rects = other_rects;
} else {
girara_list_free(other_rects);
}
return hitlist;
}
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;
}
bool
zathura_init(zathura_t* zathura)
{
if (zathura == NULL) {
return false;
}
/* create zathura (config/data) directory */
if (g_mkdir_with_parents(zathura->config.config_dir, 0771) == -1) {
girara_error("Could not create '%s': %s", zathura->config.config_dir, strerror(errno));
}
if (g_mkdir_with_parents(zathura->config.data_dir, 0771) == -1) {
girara_error("Could not create '%s': %s", zathura->config.data_dir, strerror(errno));
}
/* load plugins */
zathura_plugin_manager_load(zathura->plugins.manager);
/* configuration */
config_load_default(zathura);
/* load global configuration files */
char* config_path = girara_get_xdg_path(XDG_CONFIG_DIRS);
girara_list_t* config_dirs = girara_split_path_array(config_path);
ssize_t size = girara_list_size(config_dirs) - 1;
for (; size >= 0; --size) {
const char* dir = girara_list_nth(config_dirs, size);
char* file = g_build_filename(dir, ZATHURA_RC, NULL);
config_load_file(zathura, file);
g_free(file);
}
girara_list_free(config_dirs);
g_free(config_path);
config_load_file(zathura, GLOBAL_RC);
/* load local configuration files */
char* configuration_file = g_build_filename(zathura->config.config_dir, ZATHURA_RC, NULL);
config_load_file(zathura, configuration_file);
g_free(configuration_file);
/* UI */
if (girara_session_init(zathura->ui.session, "zathura") == false) {
goto error_free;
}
/* girara events */
zathura->ui.session->events.buffer_changed = cb_buffer_changed;
zathura->ui.session->events.unknown_command = cb_unknown_command;
/* page view */
#if (GTK_MAJOR_VERSION == 3)
zathura->ui.page_widget = gtk_grid_new();
gtk_grid_set_row_homogeneous(GTK_GRID(zathura->ui.page_widget), TRUE);
gtk_grid_set_column_homogeneous(GTK_GRID(zathura->ui.page_widget), TRUE);
#else
zathura->ui.page_widget = gtk_table_new(0, 0, TRUE);
#endif
if (zathura->ui.page_widget == NULL) {
goto error_free;
}
g_signal_connect(G_OBJECT(zathura->ui.session->gtk.window), "size-allocate", G_CALLBACK(cb_view_resized), zathura);
/* Setup hadjustment tracker */
GtkAdjustment* hadjustment = gtk_scrolled_window_get_hadjustment(
GTK_SCROLLED_WINDOW(zathura->ui.session->gtk.view));
zathura->ui.hadjustment = zathura_adjustment_clone(hadjustment);
g_object_ref_sink(zathura->ui.hadjustment);
/* Connect hadjustment signals */
g_signal_connect(G_OBJECT(hadjustment), "value-changed",
G_CALLBACK(cb_view_vadjustment_value_changed), zathura);
g_signal_connect(G_OBJECT(hadjustment), "value-changed",
G_CALLBACK(cb_adjustment_track_value), zathura->ui.hadjustment);
g_signal_connect(G_OBJECT(hadjustment), "changed",
G_CALLBACK(cb_view_hadjustment_changed), zathura);
g_signal_connect(G_OBJECT(hadjustment), "changed",
G_CALLBACK(cb_adjustment_track_bounds), zathura->ui.hadjustment);
/* Setup vadjustment tracker */
GtkAdjustment* vadjustment = gtk_scrolled_window_get_vadjustment(
GTK_SCROLLED_WINDOW(zathura->ui.session->gtk.view));
zathura->ui.vadjustment = zathura_adjustment_clone(vadjustment);
g_object_ref_sink(zathura->ui.vadjustment);
/* Connect vadjustment signals */
g_signal_connect(G_OBJECT(vadjustment), "value-changed",
G_CALLBACK(cb_view_vadjustment_value_changed), zathura);
g_signal_connect(G_OBJECT(vadjustment), "value-changed",
G_CALLBACK(cb_adjustment_track_value), zathura->ui.vadjustment);
g_signal_connect(G_OBJECT(vadjustment), "changed",
G_CALLBACK(cb_view_vadjustment_changed), zathura);
g_signal_connect(G_OBJECT(vadjustment), "changed",
G_CALLBACK(cb_adjustment_track_bounds), zathura->ui.vadjustment);
/* page view alignment */
zathura->ui.page_widget_alignment = gtk_alignment_new(0.5, 0.5, 0, 0);
if (zathura->ui.page_widget_alignment == NULL) {
goto error_free;
}
gtk_container_add(GTK_CONTAINER(zathura->ui.page_widget_alignment), zathura->ui.page_widget);
#if (GTK_MAJOR_VERSION == 3)
gtk_widget_set_hexpand_set(zathura->ui.page_widget_alignment, TRUE);
gtk_widget_set_hexpand(zathura->ui.page_widget_alignment, FALSE);
gtk_widget_set_vexpand_set(zathura->ui.page_widget_alignment, TRUE);
gtk_widget_set_vexpand(zathura->ui.page_widget_alignment, FALSE);
#endif
gtk_widget_show(zathura->ui.page_widget);
/* statusbar */
zathura->ui.statusbar.file = girara_statusbar_item_add(zathura->ui.session, TRUE, TRUE, TRUE, NULL);
if (zathura->ui.statusbar.file == NULL) {
goto error_free;
}
zathura->ui.statusbar.buffer = girara_statusbar_item_add(zathura->ui.session, FALSE, FALSE, FALSE, NULL);
if (zathura->ui.statusbar.buffer == NULL) {
goto error_free;
}
zathura->ui.statusbar.page_number = girara_statusbar_item_add(zathura->ui.session, FALSE, FALSE, FALSE, NULL);
if (zathura->ui.statusbar.page_number == NULL) {
goto error_free;
}
girara_statusbar_item_set_text(zathura->ui.session, zathura->ui.statusbar.file, _("[No name]"));
/* signals */
g_signal_connect(G_OBJECT(zathura->ui.session->gtk.window), "destroy", G_CALLBACK(cb_destroy), zathura);
/* set page padding */
int page_padding = 1;
girara_setting_get(zathura->ui.session, "page-padding", &page_padding);
#if (GTK_MAJOR_VERSION == 3)
gtk_grid_set_row_spacing(GTK_GRID(zathura->ui.page_widget), page_padding);
gtk_grid_set_column_spacing(GTK_GRID(zathura->ui.page_widget), page_padding);
#else
gtk_table_set_row_spacings(GTK_TABLE(zathura->ui.page_widget), page_padding);
gtk_table_set_col_spacings(GTK_TABLE(zathura->ui.page_widget), page_padding);
#endif
/* database */
char* database = NULL;
girara_setting_get(zathura->ui.session, "database", &database);
if (g_strcmp0(database, "plain") == 0) {
girara_debug("Using plain database backend.");
zathura->database = zathura_plaindatabase_new(zathura->config.data_dir);
#ifdef WITH_SQLITE
} else if (g_strcmp0(database, "sqlite") == 0) {
girara_debug("Using sqlite database backend.");
char* tmp = g_build_filename(zathura->config.data_dir, "bookmarks.sqlite", NULL);
zathura->database = zathura_sqldatabase_new(tmp);
g_free(tmp);
#endif
} else {
girara_error("Database backend '%s' is not supported.", database);
}
g_free(database);
if (zathura->database == NULL) {
girara_error("Unable to initialize database. Bookmarks won't be available.");
} else {
g_object_set(zathura->ui.session->command_history, "io", zathura->database, NULL);
}
/* bookmarks */
zathura->bookmarks.bookmarks = girara_sorted_list_new2((girara_compare_function_t) zathura_bookmarks_compare,
(girara_free_function_t) zathura_bookmark_free);
/* jumplist */
zathura->jumplist.max_size = 20;
girara_setting_get(zathura->ui.session, "jumplist-size", &(zathura->jumplist.max_size));
zathura->jumplist.list = girara_list_new2(g_free);
zathura->jumplist.size = 0;
zathura->jumplist.cur = NULL;
zathura_jumplist_append_jump(zathura);
zathura->jumplist.cur = girara_list_iterator(zathura->jumplist.list);
/* page cache */
int cache_size = 0;
girara_setting_get(zathura->ui.session, "page-cache-size", &cache_size);
if (cache_size <= 0) {
girara_warning("page-cache-size is not positive, using %d instead", ZATHURA_PAGE_CACHE_DEFAULT_SIZE);
zathura->page_cache.size = ZATHURA_PAGE_CACHE_DEFAULT_SIZE;
} else {
zathura->page_cache.size = cache_size;
}
zathura->page_cache.cache = g_malloc(zathura->page_cache.size * sizeof(int));
zathura_page_cache_invalidate_all(zathura);
return true;
error_free:
if (zathura->ui.page_widget != NULL) {
g_object_unref(zathura->ui.page_widget);
}
if (zathura->ui.page_widget_alignment != NULL) {
g_object_unref(zathura->ui.page_widget_alignment);
}
return false;
}