EvJobPriority priority)

{

ev_debug_message (DEBUG_JOBS, "%s priority %d", EV_GET_TYPE_NAME (job->job), priority);

g_mutex_lock (&job_queue_mutex);

g_queue_push_tail (job_queue[priority], job);

g_cond_broadcast (&job_queue_cond);

g_mutex_unlock (&job_queue_mutex);

}

{

gint i;

EvSchedulerJob *job = NULL;

for (i = EV_JOB_PRIORITY_URGENT; i < EV_JOB_N_PRIORITIES; i++) {

job = (EvSchedulerJob *) g_queue_pop_head (job_queue[i]);

if (job)

ev_job_scheduler_init (gpointer data)

{

g_thread_new ("EvJobScheduler", ev_job_thread_proxy, NULL);

return NULL;

}

ev_scheduler_job_list_add (EvSchedulerJob *job)

{

ev_debug_message (DEBUG_JOBS, "%s", EV_GET_TYPE_NAME (job->job));

G_LOCK (job_list);

job_list = g_slist_prepend (job_list, job);

job->job_link = job_list;

G_UNLOCK (job_list);

}

ev_scheduler_job_list_remove (EvSchedulerJob *job)

{

ev_debug_message (DEBUG_JOBS, "%s", EV_GET_TYPE_NAME (job->job));

G_LOCK (job_list);

job_list = g_slist_delete_link (job_list, job->job_link);

G_UNLOCK (job_list);

}

ev_debug_message (DEBUG_JOBS, "%s", EV_GET_TYPE_NAME (job->job));

if (job->job->run_mode == EV_JOB_RUN_MAIN_LOOP) {

G_CALLBACK (ev_scheduler_job_destroy),

job);

} else {

G_CALLBACK (ev_scheduler_thread_job_cancelled),

job);

}

ev_scheduler_job_list_remove (job);

ev_scheduler_job_free (job);

}

GCancellable *cancellable)

{

GList *list;

ev_debug_message (DEBUG_JOBS, "%s", EV_GET_TYPE_NAME (job->job));

g_mutex_lock (&job_queue_mutex);

/* If the job is not still running,

* remove it from the job queue and job list.

* If the job is currently running, it will be

*/

list = g_queue_find (job_queue[job->priority], job);

if (list) {

continue;

}

g_mutex_unlock (&job_queue_mutex);

ev_job_thread (job->job);

ev_scheduler_job_destroy (job);

}

s_job->priority = priority;

ev_scheduler_job_list_add (s_job);

switch (ev_job_get_run_mode (job)) {

case EV_JOB_RUN_THREAD:

g_signal_connect_swapped (job->cancellable, "cancelled",

return;

ev_debug_message (DEBUG_JOBS, "%s pirority %d", EV_GET_TYPE_NAME (job), priority);

G_LOCK (job_list);

for (l = job_list; l; l = l->next) {

break;

}

}

G_UNLOCK (job_list);

if (need_resort) {

GList *list;

g_mutex_lock (&job_queue_mutex);

list = g_queue_find (job_queue[s_job->priority], s_job);

if (list) {

ev_debug_message (DEBUG_JOBS, "Moving job %s from pirority %d to %d",

g_queue_push_tail (job_queue[priority], s_job);

g_cond_broadcast (&job_queue_cond);

}

g_mutex_unlock (&job_queue_mutex);

}

}

ev_debug_message (DEBUG_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);

job->idle_finished_id = 0;

if (job->cancelled) {

ev_debug_message (DEBUG_JOBS, "%s (%p) job was cancelled, do not emit finished", EV_GET_TYPE_NAME (job), job);

} else {

ev_profiler_stop (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);

g_signal_emit (job, job_signals[FINISHED], 0);

}

return FALSE;

}

ev_debug_message (DEBUG_JOBS, "%s (%p) job was cancelled, returning", EV_GET_TYPE_NAME (job), job);

return;

}

job->finished = TRUE;

if (job->run_mode == EV_JOB_RUN_THREAD) {

job->idle_finished_id =

g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,

ev_job_run (EvJob *job)

{

EvJobClass *class = EV_JOB_GET_CLASS (job);

return class-> run (job);

}

ev_debug_message (DEBUG_JOBS, "job %s (%p) cancelled", EV_GET_TYPE_NAME (job), job);

ev_profiler_stop (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);

/* This should never be called from a thread */

job->cancelled = TRUE;

g_cancellable_cancel (job->cancellable);

{

va_list args;

gchar *message;

if (job->failed || job->finished)

return;

ev_debug_message (DEBUG_JOBS, "job %s (%p) failed", EV_GET_TYPE_NAME (job), job);

job->failed = TRUE;

va_start (args, format);

message = g_strdup_vprintf (format, args);

va_end (args);

job->error = g_error_new_literal (domain, code, message);

g_free (message);

}

/**

{

if (job->failed || job->finished)

return;

ev_debug_message (DEBUG_JOBS, "job %s (%p) failed", EV_GET_TYPE_NAME (job), job);

job->failed = TRUE;

return;

ev_debug_message (DEBUG_JOBS, "job %s (%p) succeeded", EV_GET_TYPE_NAME (job), job);

job->failed = FALSE;

ev_job_emit_finished (job);

}

EvJobLinks *job;

ev_debug_message (DEBUG_JOBS, NULL);

job = EV_JOB_LINKS (object);

if (job->model) {

ev_debug_message (DEBUG_JOBS, NULL);

ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);

ev_document_doc_mutex_lock ();

job_links->model = ev_document_links_get_links_model (EV_DOCUMENT_LINKS (job->document));

ev_document_doc_mutex_unlock ();

gtk_tree_model_foreach (job_links->model, (GtkTreeModelForeachFunc)fill_page_labels, job);

ev_job_succeeded (job);

return FALSE;

}

job = g_object_new (EV_TYPE_JOB_LINKS, NULL);

job->document = g_object_ref (document);

return job;

}

EvJobAttachments *job;

ev_debug_message (DEBUG_JOBS, NULL);

job = EV_JOB_ATTACHMENTS (object);

if (job->attachments) {

job = g_object_new (EV_TYPE_JOB_ATTACHMENTS, NULL);

job->document = g_object_ref (document);

return job;

}

ev_debug_message (DEBUG_JOBS, "page: %d (%p)", job_render->page, job);

ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);

ev_document_doc_mutex_lock ();

ev_profiler_start (EV_PROFILE_JOBS, "Rendering page %d", job_render->page);

ev_document_fc_mutex_lock ();

ev_page = ev_document_get_page (job->document, job_render->page);

if ( job->document->iswebdocument == TRUE )

{

return TRUE;

if (g_cancellable_is_cancelled (job->cancellable)) {

ev_document_fc_mutex_unlock ();

ev_document_doc_mutex_unlock ();

return FALSE;

}

ev_document_fc_mutex_unlock ();

ev_document_doc_mutex_unlock ();

ev_job_succeeded (job);

ev_document_fc_mutex_unlock ();

ev_document_doc_mutex_unlock ();

ev_job_succeeded (job);

return FALSE;

}

EvJobRender *job;

ev_debug_message (DEBUG_JOBS, "page: %d", page);

job = g_object_new (EV_TYPE_JOB_RENDER, NULL);

EV_JOB (job)->document = g_object_ref (document);

job = EV_JOB_THUMBNAIL (object);

ev_debug_message (DEBUG_JOBS, "%d (%p)", job->page, job);

if (job->thumbnail) {

g_object_unref (job->thumbnail);

job->thumbnail = NULL;

if (job->document->iswebdocument == TRUE) {

GtkWidget *webview;

GtkWidget *offscreenwindow;

webview = webkit_web_view_new ();

offscreenwindow = gtk_offscreen_window_new ();

g_object_ref (job_thumb));

webkit_web_view_load_uri (WEBKIT_WEB_VIEW (webview), (gchar*) rc->page->backend_page);

}

#endif /* ENABLE_EPUB */

{

ev_document_doc_mutex_lock ();

ev_job_succeeded (job);

}

g_object_unref (rc);

return FALSE;

}

EvJobThumbnail *job;

ev_debug_message (DEBUG_JOBS, "%d", page);

job = g_object_new (EV_TYPE_JOB_THUMBNAIL, NULL);

EV_JOB (job)->document = g_object_ref (document);

EvDocumentFonts *fonts = EV_DOCUMENT_FONTS (job->document);

ev_debug_message (DEBUG_JOBS, NULL);

/* Do not block the main loop */

if (!ev_document_doc_mutex_trylock ())

return TRUE;

if (!ev_document_fc_mutex_trylock ()) {

ev_document_doc_mutex_unlock ();

return TRUE;

if (job_fonts->scan_completed)

ev_job_succeeded (job);

return !job_fonts->scan_completed;

}

ev_job_fonts_class_init (EvJobFontsClass *class)

{

EvJobClass *job_class = EV_JOB_CLASS (class);

job_class->run = ev_job_fonts_run;

job_fonts_signals[FONTS_UPDATED] =

g_signal_new ("updated",

EV_TYPE_JOB_FONTS,

EvJobFonts *job;

ev_debug_message (DEBUG_JOBS, NULL);

job = g_object_new (EV_TYPE_JOB_FONTS, NULL);

EV_JOB (job)->document = g_object_ref (document);

EvJobLoad *job = EV_JOB_LOAD (object);

ev_debug_message (DEBUG_JOBS, "%s", job->uri);

if (job->uri) {

g_free (job->uri);

job->uri = NULL;

{

EvJobLoad *job_load = EV_JOB_LOAD (job);

GError *error = NULL;

ev_debug_message (DEBUG_JOBS, "%s", job_load->uri);

ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);

ev_document_fc_mutex_lock ();

/* This job may already have a document even if the job didn't complete

ev_document_security_set_password (EV_DOCUMENT_SECURITY (job->document),

job_load->password);

}

job->failed = FALSE;

job->finished = FALSE;

g_clear_error (&job->error);

EvJobLoad *job;

ev_debug_message (DEBUG_JOBS, "%s", uri);

job = g_object_new (EV_TYPE_JOB_LOAD, NULL);

job->uri = g_strdup (uri);

ev_job_load_set_uri (EvJobLoad *job, const gchar *uri)

{

ev_debug_message (DEBUG_JOBS, "%s", uri);

if (job->uri)

g_free (job->uri);

job->uri = g_strdup (uri);

EvJobSave *job = EV_JOB_SAVE (object);

ev_debug_message (DEBUG_JOBS, "%s", job->uri);

if (job->uri) {

g_free (job->uri);

job->uri = NULL;

gchar *tmp_filename = NULL;

gchar *local_uri;

GError *error = NULL;

ev_debug_message (DEBUG_JOBS, "uri: %s, document_uri: %s", job_save->uri, job_save->document_uri);

ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);

g_free (local_uri);

ev_job_failed_from_error (job, error);

g_error_free (error);

return FALSE;

}

EvCompressionType ctype = EV_COMPRESSION_NONE;

const gchar *ext;

gchar *uri_comp;

ext = g_strrstr (job_save->document_uri, ".gz");

if (ext && g_ascii_strcasecmp (ext, ".gz") == 0)

ctype = EV_COMPRESSION_GZIP;

ext = g_strrstr (job_save->document_uri, ".bz2");

if (ext && g_ascii_strcasecmp (ext, ".bz2") == 0)

ctype = EV_COMPRESSION_BZIP2;

g_free (local_uri);

ev_job_failed_from_error (job, error);

g_error_free (error);

return FALSE;

}

} else {

ev_job_succeeded (job);

}

return FALSE;

}

if (job->results) {

g_free(job->results);

}

(* G_OBJECT_CLASS (ev_job_find_parent_class)->dispose) (object);

}

EvPage *ev_page;

GList *matches;

ev_debug_message (DEBUG_JOBS, NULL);

/* Do not block the main loop */

if (!ev_document_doc_mutex_trylock ())

return TRUE;

#ifdef EV_ENABLE_DEBUG

/* We use the #ifdef in this case because of the if */

if (job_find->current_page == job_find->start_page)

job_find->case_sensitive);

}else {

matches = ev_document_find_find_text (find, ev_page, job_find->text,

}

g_object_unref (ev_page);

ev_document_doc_mutex_unlock ();

if (!job_find->has_results && !job->document->iswebdocument) {

}

g_signal_emit (job_find, job_find_signals[FIND_UPDATED], 0, job_find->current_page);

job_find->current_page = (job_find->current_page + 1) % job_find->n_pages;

if (job_find->current_page == job_find->start_page) {

ev_job_succeeded (job);

{

EvJobClass *job_class = EV_JOB_CLASS (class);

GObjectClass *gobject_class = G_OBJECT_CLASS (class);

job_class->run = ev_job_find_run;

gobject_class->dispose = ev_job_find_dispose;

job_find_signals[FIND_UPDATED] =

g_signal_new ("updated",

EV_TYPE_JOB_FIND,

gboolean case_sensitive)

{

EvJobFind *job;

ev_debug_message (DEBUG_JOBS, NULL);

job = g_object_new (EV_TYPE_JOB_FIND, NULL);

EV_JOB (job)->document = g_object_ref (document);

if (ev_job_is_finished (EV_JOB (job)))

return 1.0;

if (job->current_page > job->start_page) {

pages_done = job->current_page - job->start_page + 1;

} else if (job->current_page == job->start_page) {

EvJobLayers *job;

ev_debug_message (DEBUG_JOBS, NULL);

job = EV_JOB_LAYERS (object);

if (job->model) {

ev_debug_message (DEBUG_JOBS, NULL);

ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);

ev_document_doc_mutex_lock ();

job_layers->model = ev_document_layers_get_layers (EV_DOCUMENT_LAYERS (job->document));

ev_document_doc_mutex_unlock ();

ev_job_succeeded (job);

return FALSE;

}

job = g_object_new (EV_TYPE_JOB_LAYERS, NULL);

job->document = g_object_ref (document);

return job;

}

EvJobExport *job;

ev_debug_message (DEBUG_JOBS, NULL);

job = EV_JOB_EXPORT (object);

if (job->rc) {

ev_debug_message (DEBUG_JOBS, NULL);

ev_profiler_start (EV_PROFILE_JOBS, "%s (%p)", EV_GET_TYPE_NAME (job), job);

ev_document_doc_mutex_lock ();

ev_page = ev_document_get_page (job->document, job_export->page);

if (job_export->rc) {

job->failed = FALSE;

job->finished = FALSE;

g_clear_error (&job->error);

ev_render_context_set_page (job_export->rc, ev_page);

} else {

job_export->rc = ev_render_context_new (ev_page, 0, 1.0);

}

g_object_unref (ev_page);

ev_file_exporter_do_page (EV_FILE_EXPORTER (job->document), job_export->rc);

ev_document_doc_mutex_unlock ();

ev_job_succeeded (job);

return FALSE;

}

job = g_object_new (EV_TYPE_JOB_EXPORT, NULL);

job->document = g_object_ref (document);

return job;

}

struct _EvJob

{

GObject parent;

EvDocument *document;

EvJobRunMode run_mode;

guint cancelled : 1;

guint finished : 1;

guint failed : 1;

GError *error;

GCancellable *cancellable;

GObjectClass parent_class;

gboolean (*run) (EvJob *job);

/* Signals */

void (* cancelled) (EvJob *job);

void (* finished) (EvJob *job);

/* Device scale factor of target widget */

int device_scale;

* Selection_points are the coordinates encapsulated in selection.

* target_points is the target selection size. */

EvRectangle target_points;

EvSelectionStyle selection_style;

gboolean points_set;

cairo_surface_t *selection;

gdouble selection_scale;

EvRectangle selection_points;

EvPixbufCache *pixbuf_cache;

pixbuf_cache = (EvPixbufCache *) g_object_new (EV_TYPE_PIXBUF_CACHE, NULL);

pixbuf_cache->view = view;

pixbuf_cache->model = g_object_ref (model);

pixbuf_cache->document = ev_document_model_get_document (model);

GdkColor text, base;

get_selection_colors (EV_VIEW (pixbuf_cache->view), &text, &base);

&(job_info->target_points),

job_info->selection_style,

&text, &base);

update_job_selection (CacheJobInfo *job_info,

EvViewSelection *selection)

{

job_info->target_points = selection->rect;

job_info->selection_style = selection->style;

}

if (((EvViewSelection *)list->data)->page == page) {

selection = list->data;

break;

break;

list = list->next;

}

if (((EvViewSelection *)list->data)->page == page) {

selection = list->data;

break;

break;

list = list->next;

}

if (((EvViewSelection *)list->data)->page == page) {

selection = list->data;

break;

break;

list = list->next;

}

selection->covered_region = cairo_region_reference (pixbuf_cache->prev_job[i].selection_region);

retval = g_list_prepend (retval, selection);

}

page ++;

}

selection->covered_region = cairo_region_reference (pixbuf_cache->job_list[i].selection_region);

retval = g_list_prepend (retval, selection);

}

page ++;

}

selection->covered_region = cairo_region_reference (pixbuf_cache->next_job[i].selection_region);

retval = g_list_prepend (retval, selection);

}

page ++;

}

gboolean embed_page_setup;

guint idle_id;

/* Context */

EvFileExporterContext fc;

gint n_pages_to_print;

queue = g_hash_table_lookup (print_queue, document);

if (!queue || g_queue_is_empty (queue))

return NULL;

op = g_queue_pop_tail (queue);

g_object_unref (op);

EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);

g_return_if_fail (current_page < export->n_pages);

export->current_page = current_page;

}

for (i = 0; i < export->n_ranges; i++) {

gint n_pages;

if ((export->ranges[i].start >= 0) &&

(export->ranges[i].start < export->n_pages) &&

(export->ranges[i].end >= 0) &&

export->ranges[num_of_correct_ranges] = export->ranges[i];

num_of_correct_ranges++;

}

n_pages = export->ranges[i].end - export->ranges[i].start + 1;

if (export->page_set == GTK_PAGE_SET_ALL) {

n_pages_to_print += n_pages;

} else if (export->page_set == GTK_PAGE_SET_EVEN) {

if (n_pages==1 && export->ranges[i].start % 2 == 0)

null_flag = TRUE;

n_pages_to_print += export->ranges[i].start % 2 == 0 ?

n_pages / 2 : (n_pages / 2) + 1;

} else if (export->page_set == GTK_PAGE_SET_ODD) {

null_flag = TRUE;

n_pages_to_print += export->ranges[i].start % 2 == 0 ?

(n_pages / 2) + 1 : n_pages / 2;

}

/* First pop the current job */

document = op->document;

ev_print_queue_pop (document);

next = ev_print_queue_peek (document);

if (next)

ev_print_operation_export_begin (EV_PRINT_OPERATION_EXPORT (next));

GError *error = NULL;

g_assert (export->temp_file != NULL);

/* Some printers take into account some print settings,

* and others don't. However we have exported the document

* to a ps or pdf file according to such print settings. So,

data = g_key_file_to_data (key_file, &data_len, &error);

if (data) {

gint fd;

fd = g_file_open_tmp ("print-settingsXXXXXX", &print_settings_file, &error);

if (!error)

g_file_set_contents (print_settings_file, data, data_len, &error);

close (fd);

g_free (data);

}

}

} else {

GtkPrintJob *job;

job = gtk_print_job_new (export->job_name,

export->printer,

settings,

g_object_unref (export->job_export);

export->job_export = NULL;

}

if (export->fd != -1) {

close (export->fd);

export->fd = -1;

ev_job_scheduler_push_job (export->job_export, EV_JOB_PRIORITY_NONE);

update_progress (export);

return FALSE;

}

if (!export->temp_file)

return; /* cancelled */

ev_document_doc_mutex_lock ();

ev_file_exporter_begin (EV_FILE_EXPORTER (op->document), &export->fc);

ev_document_doc_mutex_unlock ();

export->idle_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,

(GSourceFunc)export_print_page,

export,

}

static void

gchar *filename;

GError *error = NULL;

EvPrintOperation *op = EV_PRINT_OPERATION (export);

if (response != GTK_RESPONSE_OK &&

response != GTK_RESPONSE_APPLY) {

gtk_widget_destroy (GTK_WIDGET (dialog));

}

export->print_preview = (response == GTK_RESPONSE_APPLY);

printer = gtk_print_unix_dialog_get_selected_printer (GTK_PRINT_UNIX_DIALOG (dialog));

ev_print_operation_export_set_printer (export, printer);

if (!gtk_printer_accepts_ps (export->printer)) {

gtk_widget_destroy (GTK_WIDGET (dialog));

g_set_error_literal (&export->error,

GTK_PRINT_ERROR,

GTK_PRINT_ERROR_GENERAL,

_("Printing is not supported on this printer."));

g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);

return;

}

file_format = gtk_print_settings_get (print_settings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT);

filename = g_strdup_printf ("atril_print.%s.XXXXXX", file_format != NULL ? file_format : "");

export->fd = g_file_open_tmp (filename, &export->temp_file, &error);

g_free (filename);

if (export->fd <= -1) {

gtk_widget_destroy (GTK_WIDGET (dialog));

g_set_error_literal (&export->error,

GTK_PRINT_ERROR,

GTK_PRINT_ERROR_GENERAL,

export->current_page = gtk_print_unix_dialog_get_current_page (GTK_PRINT_UNIX_DIALOG (dialog));

export->page_set = gtk_print_settings_get_page_set (print_settings);

print_pages = gtk_print_settings_get_print_pages (print_settings);

switch (print_pages) {

case GTK_PRINT_PAGES_CURRENT:

export->ranges = &export->one_range;

export->ranges[0].start = export->current_page;

export->ranges[0].end = export->current_page;

export->n_ranges = 1;

break;

case GTK_PRINT_PAGES_RANGES: {

gint i;

export->ranges = gtk_print_settings_get_page_ranges (print_settings, &export->n_ranges);

for (i = 0; i < export->n_ranges; i++)

if (export->ranges[i].end == -1 || export->ranges[i].end >= export->n_pages)

export->ranges[0].start = 0;

export->ranges[0].end = export->n_pages - 1;

export->n_ranges = 1;

break;

}

return;

} else ev_print_operation_update_status (op, -1, -1, 0.0);

width = gtk_page_setup_get_paper_width (page_setup, GTK_UNIT_POINTS);

height = gtk_page_setup_get_paper_height (page_setup, GTK_UNIT_POINTS);

scale = gtk_print_settings_get_scale (print_settings) * 0.01;

}

export->pages_per_sheet = MAX (1, gtk_print_settings_get_number_up (print_settings));

export->copies = gtk_print_settings_get_n_copies (print_settings);

export->collate = gtk_print_settings_get_collate (print_settings);

export->reverse = gtk_print_settings_get_reverse (print_settings);

ev_print_queue_push (op);

g_signal_emit (op, signals[BEGIN_PRINT], 0);

gtk_widget_destroy (GTK_WIDGET (dialog));

}

/* translators: Title of the print dialog */

dialog = gtk_print_unix_dialog_new (_("Print"), parent);

gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);

capabilities = GTK_PRINT_CAPABILITY_PREVIEW |

ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (op->document));

gtk_print_unix_dialog_set_manual_capabilities (GTK_PRINT_UNIX_DIALOG (dialog),

gtk_print_unix_dialog_set_current_page (GTK_PRINT_UNIX_DIALOG (dialog),

export->current_page);

gtk_print_unix_dialog_set_settings (GTK_PRINT_UNIX_DIALOG (dialog),

export->print_settings);

if (export->page_setup)

gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (dialog),

export->page_setup);

close (export->fd);

export->fd = -1;

}

if (export->ranges) {

if (export->ranges != &export->one_range)

g_free (export->ranges);

GObject *object;

EvPrintOperationExport *export;

EvPrintOperation *op;

object = G_OBJECT_CLASS (ev_print_operation_export_parent_class)->constructor (type,

n_construct_properties,

construct_params);

gdouble ev_print_operation_get_progress (EvPrintOperation *op);

G_END_DECLS

#endif /* __EV_PRINT_OPERATION_H__ */

*

* You should have received a copy of the GNU Library General Public

* License along with this library; if not, write to the

* Boston, MA 02110-1301, USA.

*/

*

* You should have received a copy of the GNU Library General Public

* License along with this library; if not, write to the

* Boston, MA 02110-1301, USA.

*/

*

* You should have received a copy of the GNU Library General Public

* License along with this library; if not, write to the

* Boston, MA 02110-1301, USA.

*/

*

* You should have received a copy of the GNU Library General Public

* License along with this library; if not, write to the

* Boston, MA 02110-1301, USA.

*/

gboolean autoscrolling;

guint last_y;

guint start_y;

} AutoScrollInfo;

/* Information for handling selection */

guint vscroll_policy : 1;

gint scroll_x;

/* Delta sum for emulating normal scrolling */

gdouble total_delta;

EvPoint pending_point;

/* Current geometry */

gint start_page;

gint end_page;

gint current_page;

/* Information for middle clicking and dragging around. */

DragInfo drag_info;

/* Autoscrolling */

AutoScrollInfo scroll_info;

gint page,

gint result);

static void jump_to_find_result (EvView *view);

EvViewFindDirection direction,

gint shift);

/*** Selection ***/

if (page == -1)

return FALSE;

region = ev_page_cache_get_text_mapping (view->page_cache, page);

if (region)

}

static gboolean

gint *y_new)

{

gdouble width, height;

x = width - x_offset;

y = height - y_offset;

} else if (view->rotation == 270) {

y = x_offset;

} else {

g_assert_not_reached ();

*x_new = x;

*y_new = y;

return TRUE;

}

EvPoint doc_point;

gint page;

gdouble zoom, left, top;

zoom = ev_link_dest_get_zoom (dest, &change_zoom);

page = ev_link_dest_get_page (dest);

return;

current_page = view->current_page;

type = ev_link_dest_get_dest_type (dest);

switch (type) {

type = ev_link_dest_get_dest_type (dest);

if (type == EV_LINK_DEST_TYPE_NAMED) {

const gchar *named_dest;

named_dest = ev_link_dest_get_named_dest (dest);

goto_dest (view, dest);

}

void

ev_view_handle_link (EvView *view, EvLink *link)

{

switch (type) {

case EV_LINK_ACTION_TYPE_GOTO_DEST: {

EvLinkDest *dest;

g_signal_emit (view, signals[SIGNAL_HANDLE_LINK], 0, link);

dest = ev_link_action_get_dest (action);

ev_view_goto_dest (view, dest);

}

tip_from_action_named (EvLinkAction *action)

{

const gchar *name = ev_link_action_get_name (action);

if (g_ascii_strcasecmp (name, "FirstPage") == 0) {

return g_strdup (_("Go to first page"));

} else if (g_ascii_strcasecmp (name, "PrevPage") == 0) {

} else if (g_ascii_strcasecmp (name, "Find") == 0) {

return g_strdup (_("Find"));

}

return NULL;

}

action = ev_link_get_action (link);

title = ev_link_get_title (link);

if (!action)

return title ? g_strdup (title) : NULL;

type = ev_link_action_get_action_type (action);

switch (type) {

msg = g_strdup (title);

break;

}

return msg;

}

if (!view->document)

return;

field = g_object_get_data (G_OBJECT (widget), "form-field");

if (field->changed) {

EvFormFieldText *field_text = EV_FORM_FIELD_TEXT (field);

cairo_region_t *field_region;

field_region = ev_view_form_field_get_region (view, field);

ev_document_forms_form_field_text_set_text (EV_DOCUMENT_FORMS (view->document),

field, field_text->text);

field->changed = FALSE;

gtk_entry_set_has_frame (GTK_ENTRY (text), FALSE);

gtk_entry_set_max_length (GTK_ENTRY (text), field_text->max_len);

gtk_entry_set_visibility (GTK_ENTRY (text), !field_text->is_password);

if (txt) {

gtk_entry_set_text (GTK_ENTRY (text), txt);

g_free (txt);

break;

case EV_FORM_FIELD_TEXT_MULTILINE: {

GtkTextBuffer *buffer;

text = gtk_text_view_new ();

buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text));

if (txt) {

gtk_text_buffer_set_text (buffer, txt, -1);

g_free (txt);

field);

}

break;

g_object_weak_ref (G_OBJECT (text),

(GWeakNotify)ev_view_form_field_text_save,

if (!view->document)

return;

field = g_object_get_data (G_OBJECT (widget), "form-field");

if (field->changed) {

EvFormField *field)

{

EvFormFieldChoice *field_choice = EV_FORM_FIELD_CHOICE (field);

if (GTK_IS_COMBO_BOX (widget)) {

gint item;

item = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));

if (!field_choice->selected_items ||

GPOINTER_TO_INT (field_choice->selected_items->data) != item) {

GtkTreeSelection *selection = GTK_TREE_SELECTION (widget);

GtkTreeModel *model;

GList *items, *l;

items = gtk_tree_selection_get_selected_rows (selection, &model);

g_list_free (field_choice->selected_items);

field_choice->selected_items = NULL;

GtkTreeIter iter;

GtkTreePath *path = (GtkTreePath *)l->data;

gint item;

gtk_tree_model_get_iter (model, &iter, path);

gtk_tree_model_get (model, &iter, 1, &item, -1);

field_choice->selected_items = g_list_prepend (field_choice->selected_items,

GINT_TO_POINTER (i));

}

if (item) {

gtk_list_store_append (GTK_LIST_STORE (model), &iter);

gtk_list_store_set (GTK_LIST_STORE (model), &iter,

view);

} else if (field_choice->is_editable) { /* ComboBoxEntry */

gchar *text;

choice = gtk_combo_box_new_with_model_and_entry (model);

gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (choice), 0);

text = ev_document_forms_form_field_choice_get_text (EV_DOCUMENT_FORMS (view->document), field);

NULL);

gtk_combo_box_set_active (GTK_COMBO_BOX (choice), selected_item);

gtk_combo_box_popup (GTK_COMBO_BOX (choice));

g_signal_connect (choice, "changed",

G_CALLBACK (ev_view_form_field_choice_changed),

field);

ev_view_size_request (widget, &req);

view->internal_size_request = FALSE;

}

view_set_adjustment_values (view, GTK_ORIENTATION_HORIZONTAL);

view_set_adjustment_values (view, GTK_ORIENTATION_VERTICAL);

x += view->scroll_x;

y += view->scroll_y;

find_page_at_location (view, x, y, &page, &x_offset, &y_offset);

link_mapping = ev_page_cache_get_link_mapping (view->page_cache, page);

ev_view_get_area_from_mapping (view, page,

link_mapping,

ev_annotation_window_ungrab_focus (window);

view->window_child_focus = NULL;

}

view->pressed_button = event->button;

view->selection_info.in_drag = FALSE;

ev_view_pend_cursor_blink (view);

}

}

return TRUE;

case 2:

/* use root coordinates as reference point because

ev_view_set_focused_element_at_location (view, event->x, event->y);

return ev_view_do_popup_menu (view, event->x, event->y);

}

return FALSE;

}

pixbuf = ev_document_images_get_image (EV_DOCUMENT_IMAGES (view->document),

view->image_dnd_info.image);

ev_document_doc_mutex_unlock ();

gtk_selection_data_set_pixbuf (selection_data, pixbuf);

g_object_unref (pixbuf);

}

pixbuf = ev_document_images_get_image (EV_DOCUMENT_IMAGES (view->document),

view->image_dnd_info.image);

ev_document_doc_mutex_unlock ();

tmp_uri = ev_image_save_tmp (view->image_dnd_info.image, pixbuf);

g_object_unref (pixbuf);

gdk_drag_status (context, 0, time);

else

gdk_drag_status (context, gdk_drag_context_get_suggested_action (context), time);

return TRUE;

}

static gboolean

selection_update_idle_cb (EvView *view)

{

static gboolean

selection_scroll_timeout_cb (EvView *view)

gint x, y, shift = 0;

GtkWidget *widget = GTK_WIDGET (view);

GtkAllocation allocation;

int i;

if (!view->drag_info.in_drag)

return FALSE;

for (i = DRAG_HISTORY - 1; i > 0; i--) {

view->drag_info.buffer[i].x = view->drag_info.buffer[i-1].x;

view->drag_info.buffer[i].y = view->drag_info.buffer[i-1].y;

}

/* Momentum is a moving average of 10ms granularity over

*/

view->drag_info.momentum.x = (view->drag_info.buffer[DRAG_HISTORY - 1].x - view->drag_info.buffer[0].x);

view->drag_info.momentum.y = (view->drag_info.buffer[DRAG_HISTORY - 1].y - view->drag_info.buffer[0].y);

return TRUE;

}

}

switch (view->pressed_button) {

case 1:

/* For the Atril 0.4.x release, we limit selection to un-rotated

if (view->rotation != 0)

return FALSE;

* scroll once to allow arbitrary speed. */

if (!view->selection_scroll_id)

view->selection_scroll_id = g_timeout_add (SCROLL_TIME,

(GSourceFunc)selection_scroll_timeout_cb,

view);

selection_scroll_timeout_cb (view);

view->motion.x = x + view->scroll_x;

view->motion.y = y + view->scroll_y;

* mouse. */

if (!view->selection_update_id)

view->selection_update_id = g_idle_add ((GSourceFunc)selection_update_idle_cb, view);

break;

default:

ev_view_handle_cursor_over_xy (view, x, y);

return FALSE;

}

EvView *view = EV_VIEW (widget);

ev_view_handle_cursor_over_xy (view, event->x, event->y);

return FALSE;

}

ev_view_window_child_move (view, child, child->x + dx, child->y + dy);

}

if (view->pending_resize) {

gtk_widget_queue_draw (widget);

} else {

view->scroll_info.timeout_id = 0;

return FALSE;

}

/* Replace 100 with your speed of choice: The lower the faster.

* Replace 3 with another speed of choice: The higher, the faster it accelerated

* based on the distance of the starting point from the mouse

speed = -pow ((((gdouble)view->scroll_info.start_y - view->scroll_info.last_y) / 100), 3);

else

speed = pow ((((gdouble)view->scroll_info.last_y - view->scroll_info.start_y) / 100), 3);

value = gtk_adjustment_get_value (view->vadjustment);

value = CLAMP (value + speed, 0,

gtk_adjustment_get_upper (view->vadjustment) -

gtk_adjustment_get_page_size (view->vadjustment));

gtk_adjustment_set_value (view->vadjustment, value);

return TRUE;

}

ev_view_autoscroll_start (EvView *view)

{

gint x, y;

g_return_if_fail (EV_IS_VIEW (view));

if (view->scroll_info.autoscrolling)

return;

view->scroll_info.autoscrolling = TRUE;

view->scroll_info.timeout_id =

g_timeout_add (20, (GSourceFunc)ev_view_autoscroll_cb,

ev_view_autoscroll_stop (EvView *view)

{

gint x, y;

g_return_if_fail (EV_IS_VIEW (view));

if (!view->scroll_info.autoscrolling)

* @shift: Shift from current page

*

* Jumps to the first page that has occurences of searched word.

*

*/

static void

for (i = 0; i < n_pages; i++) {

int page;

if (direction == EV_VIEW_FIND_NEXT)

page = view->current_page + i;

else

page += shift;

if (page >= n_pages) {

page = page - n_pages;

page = page + n_pages;

if (ev_view_find_get_n_results (view, page) > 0) {

{

g_return_if_fail (view->current_page >= 0);

view->find_pages = results;

if (view->jump_to_find_result == TRUE) {

jump_to_find_page (view, EV_VIEW_FIND_NEXT, 0);

jump_to_find_result (view);

for (i = start_page; i <= end_page; i++) {

GdkRectangle page_area;

GtkBorder border;

ev_view_get_page_extents (view, i, &page_area, &border);

page_area.x -= border.left;

page_area.y -= border.top;

page_area.width += border.left + border.right;

page_area.height += border.top + border.bottom;

gdk_rectangle_point_in (&page_area, stop)) {

if (first == -1)

first = i;

}

ev_document_doc_mutex_unlock ();

normalized_text = g_utf8_normalize (text->str, text->len, G_NORMALIZE_NFKC);

g_string_free (text, TRUE);

return normalized_text;

} else if (EV_IS_SELECTION (ev_view->document) &&

ev_view->selection_info.selections) {

gchar *text;

text = get_selected_text (ev_view);

if (text) {

gtk_selection_data_set_text (selection_data, text, -1);

gtk_target_list_add_text_targets (target_list, 0);

targets = gtk_target_table_new_from_list (target_list, &n_targets);

gtk_target_list_unref (target_list);

if (!gtk_clipboard_set_with_owner (clipboard,

targets, n_targets,

ev_view_primary_get_cb,

EvLinkAction *action)

{

clear_link_selected (view);

ev_view_clipboard_copy (view, ev_link_action_get_uri (action));

view->link_selected = g_object_ref (action);

ev_view_update_primary_selection (view);

}

return TRUE;

}

/**

* ev_view_disconnect_handlers

* @view: #EvView instance

* Disconnect all signal handlers from the model, to ensure error free operation of the webview,

* we have an equivalent function for the webview.

*/

gchar *hlink;

};

{

WebKitWebViewClass base_class;

};

web_view_update_range_and_current_page (EvWebView *webview)

{

g_return_if_fail(EV_IS_WEB_VIEW(webview));

if (ev_document_get_n_pages (webview->document) <= 0)

return;

g_object_unref(webview->model);

webview->model = NULL;

}

if (webview->hlink) {

g_free(webview->hlink);

webview->hlink = NULL;

webview->search->on_result = -1 ;

webview->search->results = NULL;

webview->search->search_jump = TRUE ;

webview->fullscreen = FALSE;

webview->inverted_stylesheet = FALSE;

webview->hlink = NULL;

gint new_page)

{

g_return_if_fail(EV_IS_WEB_VIEW(webview));

EvDocumentClass *klass = EV_DOCUMENT_GET_CLASS(webview->document);

webview->current_page = new_page;

EvWebView *webview)

{

g_return_if_fail(EV_IS_WEB_VIEW(webview));

EvDocument *document = ev_document_model_get_document (model);

if (document != webview->document) {

}

webview->inverted_stylesheet = FALSE;

gint current_page = ev_document_model_get_page(model);

ev_web_view_change_page (webview, current_page);

}

static void

ev_web_view_inverted_colors_changed_cb (EvDocumentModel *model,

if (!document || !document->iswebdocument)

return;

if (ev_document_model_get_inverted_colors(model) == TRUE) {

if (document == NULL) {

ev_document_model_set_inverted_colors(model,FALSE);

return;

if (webview->inverted_stylesheet == FALSE) {

ev_document_check_add_night_sheet(document);

webview->inverted_stylesheet = TRUE;

int page, n_pages;

g_return_val_if_fail (EV_IS_WEB_VIEW (webview), FALSE);

if (!webview->document)

return FALSE;

EvPage *webpage = ev_document_get_page(webview->document,page);

webkit_web_view_load_uri(WEBKIT_WEB_VIEW(webview),(gchar*)webpage->backend_page);

return TRUE;

return FALSE;

}

}

{

EvLinkAction *action = NULL;

EvLinkDest *dest = NULL;

return;

dest = ev_link_action_get_dest(action);

if (dest == NULL)

return;

dest_type = ev_link_dest_get_dest_type(dest);

switch(dest_type) {

case EV_LINK_DEST_TYPE_PAGE: {

ev_document_model_set_page(webview->model,ev_link_dest_get_page(dest));

ev_document_model_set_page(webview->model,ev_link_dest_get_page(dest));

webkit_web_view_load_uri(WEBKIT_WEB_VIEW(webview),uri);

break;

default:return;

}

}

* @shift: Shift from current page

*

* Jumps to the first page that has occurences of searched word.

**/

static void

jump_to_find_page (EvWebView *webview, EvWebViewFindDirection direction, gint shift)

if (direction == EV_WEB_VIEW_FIND_NEXT)

page = webview->current_page + i;

else

page += shift;

if (page >= n_pages) {

page = page - n_pages;

page = page + n_pages;

if (page == webview->current_page && ev_web_view_find_get_n_results(webview,page) > 0) {

webview->findoptions |= WEBKIT_FIND_OPTIONS_WRAP_AROUND;

else

webview->findoptions &= ~WEBKIT_FIND_OPTIONS_WRAP_AROUND;

webview->findoptions &= ~WEBKIT_FIND_OPTIONS_BACKWARDS;

}

void

ev_web_view_find_changed (EvWebView *webview, guint *results, gchar *text,gboolean case_sensitive)

{

webview->search->on_result = 0;

webview->search->search_string = g_strdup(text);

webview->search->case_sensitive = case_sensitive;

}

jump_to_find_page (webview, EV_WEB_VIEW_FIND_NEXT, 0);

}

void

ev_web_view_find_next (EvWebView *webview)

if (webview->search->on_result >= n_results) {

webview->search->on_result = 0;

jump_to_find_page (webview, EV_WEB_VIEW_FIND_NEXT, 1);

else {

webkit_find_controller_search_next(webview->findcontroller);

}

webkit_find_controller_search_finish (webview->findcontroller);

}

ev_web_view_set_handler(EvWebView *webview,gboolean visible)

{

if (visible) {

else {

g_signal_handlers_disconnect_by_func(webview,

jump_to_find_results,

g_signal_handlers_disconnect_by_func(webview,

results_counted_cb,

NULL);

/**

* ev_web_view_disconnect_handlers

* @webview : #EvWebView instance

* This function call will disconnect all model signal handlers from the webview, to ensure smooth operation of the Atril-view.

* Equivalent to function ev_view_disconnect_handlers in ev-view.c

*/

void ev_web_view_reload_page (EvWebView *webview,

gint page);

/* Navigation */

gboolean ev_web_view_next_page (EvWebView *webview);

gboolean ev_web_view_previous_page (EvWebView *webview);

void ev_web_view_find_changed (EvWebView *webview,

guint *results,

gboolean case_sensitive);

void ev_web_view_find_search_changed (EvWebView *webview);