ev-document-factory.c File Reference

#include <string.h>
#include <gio/gio.h>
#include <glib/gstdio.h>
#include <glib/gi18n-lib.h>
#include <gtk/gtk.h>
#include "ev-backend-info.h"
#include "ev-document-factory.h"
#include "ev-file-helpers.h"
#include "ev-module.h"
#include "ev-backends-manager.h"

Include dependency graph for ev-document-factory.c:

Go to the source code of this file.

Macros
#define	BACKEND_DATA_KEY   "ev-backend-info"

Functions
static EvDocument *	ev_document_factory_new_document_for_mime_type (const char *mime_type, GError **error)
static EvBackendInfo *	get_backend_info_for_mime_type (const gchar *mime_type)
static EvBackendInfo *	get_backend_info_for_document (EvDocument *document)
static EvDocument *	ev_document_factory_new_document_for_mime_type (const gchar *mime_type, GError **error)
static EvCompressionType	get_compression_from_mime_type (const gchar *mime_type)
static EvDocument *	new_document_for_uri (const char *uri, gboolean fast, EvCompressionType *compression, GError **error)
static void	free_uncompressed_uri (gchar *uri_unc)
gboolean	_ev_document_factory_init (void)
void	_ev_document_factory_shutdown (void)
EvDocument *	ev_document_factory_get_document_full (const char *uri, EvDocumentLoadFlags flags, GError **error)
EvDocument *	ev_document_factory_get_document (const char *uri, GError **error)
EvDocument *	ev_document_factory_get_document_for_gfile (GFile *file, EvDocumentLoadFlags flags, GCancellable *cancellable, GError **error)
EvDocument *	ev_document_factory_get_document_for_stream (GInputStream *stream, const char *mime_type, EvDocumentLoadFlags flags, GCancellable *cancellable, GError **error)
static void	file_filter_add_mime_types (EvBackendInfo *info, GtkFileFilter *filter)
void	ev_document_factory_add_filters (GtkWidget *chooser, EvDocument *document)
EvDocument *	ev_backends_manager_get_document (const gchar *mime_type)
const gchar *	ev_backends_manager_get_document_module_name (EvDocument *document)
EvTypeInfo *	ev_backends_manager_get_document_type_info (EvDocument *document)
GList *	ev_backends_manager_get_all_types_info (void)

Variables
static GList *	ev_backends_list = NULL
static GHashTable *	ev_module_hash = NULL
static gchar *	ev_backends_dir = NULL

Macro Definition Documentation

#define BACKEND_DATA_KEY   "ev-backend-info"

Definition at line 41 of file ev-document-factory.c.

Function Documentation

gboolean _ev_document_factory_init

(

void

)

Definition at line 227 of file ev-document-factory.c.

{
    if (ev_backends_list)
        return TRUE;

#ifdef G_OS_WIN32
{
        gchar *dir;

        dir = g_win32_get_package_installation_directory_of_module (NULL);
        ev_backends_dir = g_build_filename (dir, "lib", "evince",
                                        EV_BACKENDSBINARYVERSION,
                                        "backends", NULL);
        g_free (dir);
}
#else
        ev_backends_dir = g_strdup (EV_BACKENDSDIR);
#endif

        ev_backends_list = _ev_backend_info_load_from_dir (ev_backends_dir);

        return ev_backends_list != NULL;
}

Here is the caller graph for this function:

void _ev_document_factory_shutdown

(

void

)

Definition at line 257 of file ev-document-factory.c.

{
    g_list_foreach (ev_backends_list, (GFunc) _ev_backend_info_unref, NULL);
    g_list_free (ev_backends_list);
    ev_backends_list = NULL;

    if (ev_module_hash != NULL) {
        g_hash_table_unref (ev_module_hash);
        ev_module_hash = NULL;
    }

    g_free (ev_backends_dir);
        ev_backends_dir = NULL;
}

Here is the caller graph for this function:

GList* ev_backends_manager_get_all_types_info

(

void

)

Definition at line 641 of file ev-document-factory.c.

{
        return g_list_copy (ev_backends_list);
}

Here is the caller graph for this function:

EvDocument* ev_backends_manager_get_document

(

const gchar *

mime_type)

ev_backends_manager_get_document: : a mime type hint

Returns: (transfer full): a new EvDocument

Definition at line 620 of file ev-document-factory.c.

{
        return ev_document_factory_new_document_for_mime_type (mime_type, NULL);
}

Here is the caller graph for this function:

const gchar* ev_backends_manager_get_document_module_name

(

EvDocument *

document)

Definition at line 626 of file ev-document-factory.c.

{
        EvBackendInfo *info = get_backend_info_for_document (document);
        if (info == NULL)
                return NULL;

        return info->module_name;
}

EvTypeInfo* ev_backends_manager_get_document_type_info

(

EvDocument *

document)

Definition at line 635 of file ev-document-factory.c.

{
        return (EvTypeInfo *) get_backend_info_for_document (document);
}

void ev_document_factory_add_filters	(	GtkWidget *	chooser,
		EvDocument *	document
	)

ev_document_factory_add_filters: : a #GtkFileChooser : a EvDocument, or NULL

Adds some file filters to .

Always add a "All documents" format.

If is not NULL, adds a #GtkFileFilter for 's MIME type.

If is NULL, adds a #GtkFileFilter for each document type that evince can handle.

Definition at line 567 of file ev-document-factory.c.

{
    GtkFileFilter *filter;
    GtkFileFilter *default_filter;
    GtkFileFilter *document_filter;

        g_return_if_fail (GTK_IS_FILE_CHOOSER (chooser));
        g_return_if_fail (document == NULL || EV_IS_DOCUMENT (document));

    default_filter = document_filter = filter = gtk_file_filter_new ();
    gtk_file_filter_set_name (filter, _("All Documents"));
    g_list_foreach (ev_backends_list, (GFunc)file_filter_add_mime_types, filter);
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);

    if (document) {
        EvBackendInfo *info;

        info = get_backend_info_for_document (document);
                g_assert (info != NULL);
        default_filter = filter = gtk_file_filter_new ();
        gtk_file_filter_set_name (filter, info->type_desc);
        file_filter_add_mime_types (info, filter);
        gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
    } else {
        GList *l;

        for (l = ev_backends_list; l; l = l->next) {
                        EvBackendInfo *info = (EvBackendInfo *) l->data;

            default_filter = filter = gtk_file_filter_new ();
            gtk_file_filter_set_name (filter, info->type_desc);
            file_filter_add_mime_types (info, filter);
            gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
        }
    }

    filter = gtk_file_filter_new ();
    gtk_file_filter_set_name (filter, _("All Files"));
    gtk_file_filter_add_pattern (filter, "*");
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);

    gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (chooser),
                     document == NULL ? document_filter : default_filter);
}

Here is the caller graph for this function:

EvDocument* ev_document_factory_get_document	(	const char *	uri,
		GError **	error
	)

ev_document_factory_get_document: : an URI : a #GError location to store an error, or NULL

Creates a EvDocument for the document at ; or, if no backend handling the document's type is found, or an error occurred on opening the document, returns NULL and fills in . If the document is encrypted, it is returned but also is set to EV_DOCUMENT_ERROR_ENCRYPTED.

Returns: (transfer full): a new EvDocument, or NULL

Definition at line 397 of file ev-document-factory.c.

{
    return ev_document_factory_get_document_full (uri,
                              EV_DOCUMENT_LOAD_FLAG_NONE,
                              error);
}

Here is the caller graph for this function:

EvDocument* ev_document_factory_get_document_for_gfile	(	GFile *	file,
		EvDocumentLoadFlags	flags,
		GCancellable *	cancellable,
		GError **	error
	)

Definition at line 422 of file ev-document-factory.c.

{
        EvDocument *document;
        GFileInfo *file_info;
        const char *content_type;
        char *mime_type = NULL;

        g_return_val_if_fail (G_IS_FILE (file), NULL);
        g_return_val_if_fail (error == NULL || *error == NULL, NULL);


        file_info = g_file_query_info (file,
                                       G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
                                       G_FILE_QUERY_INFO_NONE,
                                       cancellable,
                                       error);
        if (file_info == NULL)
                return NULL;

        content_type = g_file_info_get_content_type (file_info);
        if (content_type == NULL) {
                g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
                                     "Failed to query file mime type");
                return NULL;
        }

        mime_type = g_content_type_get_mime_type (content_type);
        g_object_unref (file_info);

        document = ev_document_factory_new_document_for_mime_type (mime_type, error);
        g_free (mime_type);
        if (document == NULL)
                return NULL;

        if (!ev_document_load_gfile (document, file, flags, cancellable, error)) {
                g_object_unref (document);
                return NULL;
        }

        return document;
}

Here is the caller graph for this function:

EvDocument* ev_document_factory_get_document_for_stream	(	GInputStream *	stream,
		const char *	mime_type,
		EvDocumentLoadFlags	flags,
		GCancellable *	cancellable,
		GError **	error
	)

ev_document_factory_get_document_for_stream: : a #GInputStream : (allow-none): a mime type hint : flags from EvDocumentLoadFlags : (allow-none): a #GCancellable, or NULL : (allow-none): a #GError location to store an error, or NULL

Synchronously creates a EvDocument for the document from ; or, if no backend handling the document's type is found, or an error occurred on opening the document, returns NULL and fills in . If the document is encrypted, it is returned but also is set to EV_DOCUMENT_ERROR_ENCRYPTED.

If is non-NULL, this overrides any type inferred from the stream. If the mime type cannot be inferred from the stream, and is NULL, an error is returned.

Returns: (transfer full): a new EvDocument, or NULL

Since: 3.6

Definition at line 490 of file ev-document-factory.c.

{
        EvDocument *document;
        char *mime = NULL;

        g_return_val_if_fail (G_IS_INPUT_STREAM (stream), NULL);
        g_return_val_if_fail (error == NULL || *error == NULL, NULL);

        if (mime_type == NULL && G_IS_FILE_INPUT_STREAM (stream)) {
                GFileInfo *file_info;
                const char *content_type;

                file_info = g_file_input_stream_query_info (G_FILE_INPUT_STREAM (stream),
                                                            G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
                                                            cancellable,
                                                            error);
                if (file_info != NULL) {
                        content_type = g_file_info_get_content_type (file_info);
                        if (content_type)
                                mime_type = mime = g_content_type_get_mime_type (content_type);
                        g_object_unref (file_info);
                }
        }

        if (mime_type == NULL) {
                g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
                                     "Cannot query mime type from stream");
                return NULL;
        }

        document = ev_document_factory_new_document_for_mime_type (mime_type, error);
        g_free (mime);

        if (document == NULL)
                return NULL;

        if (!ev_document_load_stream (document, stream, flags, cancellable, error)) {
                g_object_unref (document);
                return NULL;
        }

        return document;
}

Here is the caller graph for this function:

EvDocument* ev_document_factory_get_document_full	(	const char *	uri,
		EvDocumentLoadFlags	flags,
		GError **	error
	)

ev_document_factory_get_document_full: : an URI : flags from EvDocumentLoadFlags : a #GError location to store an error, or NULL

Creates a EvDocument for the document at ; or, if no backend handling the document's type is found, or an error occurred on opening the document, returns NULL and fills in . If the document is encrypted, it is returned but also is set to EV_DOCUMENT_ERROR_ENCRYPTED.

Returns: (transfer full): a new EvDocument, or NULL

Definition at line 287 of file ev-document-factory.c.

{
    EvDocument *document;
    int result;
    EvCompressionType compression;
    gchar *uri_unc = NULL;
    GError *err = NULL;

    g_return_val_if_fail (uri != NULL, NULL);

    document = new_document_for_uri (uri, TRUE, &compression, &err);
    g_assert (document != NULL || err != NULL);

    if (document != NULL) {
        uri_unc = ev_file_uncompress (uri, compression, &err);
        if (uri_unc) {
            g_object_set_data_full (G_OBJECT (document),
                        "uri-uncompressed",
                        uri_unc,
                        (GDestroyNotify) free_uncompressed_uri);
        } else if (err != NULL) {
            /* Error uncompressing file */
            g_object_unref (document);
            g_propagate_error (error, err);
            return NULL;
        }

        result = ev_document_load_full (document, uri_unc ? uri_unc : uri, flags, &err);

        if (result == FALSE || err) {
            if (err &&
                g_error_matches (err, EV_DOCUMENT_ERROR, EV_DOCUMENT_ERROR_ENCRYPTED)) {
                g_propagate_error (error, err);
                return document;
                }
            /* else fall through to slow mime code section below */
        } else {
            return document;
        }

        g_object_unref (document);
        document = NULL;
    }

    /* Try again with slow mime detection */
    g_clear_error (&err);
    uri_unc = NULL;

    document = new_document_for_uri (uri, FALSE, &compression, &err);
    if (document == NULL) {
        g_assert (err != NULL);
        g_propagate_error (error, err);
        return NULL;
    }

    uri_unc = ev_file_uncompress (uri, compression, &err);
    if (uri_unc) {
        g_object_set_data_full (G_OBJECT (document),
                    "uri-uncompressed",
                    uri_unc,
                    (GDestroyNotify) free_uncompressed_uri);
    } else if (err != NULL) {
        /* Error uncompressing file */
        g_propagate_error (error, err);

        g_object_unref (document);
        return NULL;
    }

    result = ev_document_load_full (document, uri_unc ? uri_unc : uri,
                    EV_DOCUMENT_LOAD_FLAG_NONE, &err);
    if (result == FALSE) {
        if (err == NULL) {
            /* FIXME: this really should not happen; the backend should
             * always return a meaningful error.
             */
            g_set_error_literal (&err,
                                             EV_DOCUMENT_ERROR,
                                             EV_DOCUMENT_ERROR_INVALID,
                                             _("Unknown MIME Type"));
        } else if (g_error_matches (err, EV_DOCUMENT_ERROR, EV_DOCUMENT_ERROR_ENCRYPTED)) {
            g_propagate_error (error, err);
            return document;
        }

        g_object_unref (document);
        document = NULL;

        g_propagate_error (error, err);
    }

    return document;
}

Here is the caller graph for this function:

static EvDocument* ev_document_factory_new_document_for_mime_type ( const char *  mime_type, GError **  error  )

static

Here is the caller graph for this function:

static EvDocument* ev_document_factory_new_document_for_mime_type ( const gchar *  mime_type, GError **  error  )

static

Definition at line 81 of file ev-document-factory.c.

{
        EvDocument    *document;
        EvBackendInfo *info;
        GTypeModule *module = NULL;

        g_return_val_if_fail (mime_type != NULL, NULL);

        info = get_backend_info_for_mime_type (mime_type);
        if (info == NULL) {
                char *content_type, *mime_desc = NULL;

                content_type = g_content_type_from_mime_type (mime_type);
                if (content_type)
                        mime_desc = g_content_type_get_description (content_type);

                g_set_error (error,
                             EV_DOCUMENT_ERROR,
                             EV_DOCUMENT_ERROR_INVALID,
                             _("File type %s (%s) is not supported"),
                             mime_desc ? mime_desc : "(unknown)", mime_type);
                g_free (mime_desc);
                g_free (content_type);

                return NULL;
        }

        if (ev_module_hash != NULL) {
                module = g_hash_table_lookup (ev_module_hash, info->module_name);
        }
        if (module == NULL) {
                gchar *path;

                path = g_module_build_path (ev_backends_dir, info->module_name);
                module = G_TYPE_MODULE (_ev_module_new (path, info->resident));
                g_free (path);

                if (ev_module_hash == NULL) {
                        ev_module_hash = g_hash_table_new_full (g_str_hash, g_str_equal,
                                                                g_free,
                                                                NULL /* leaked on purpose */);
                }
                g_hash_table_insert (ev_module_hash, g_strdup (info->module_name), module);
        }

        if (!g_type_module_use (module)) {
                const char *err;

                err = g_module_error ();
                g_set_error (error, EV_DOCUMENT_ERROR, EV_DOCUMENT_ERROR_INVALID,
                             "Failed to load backend for '%s': %s",
                             mime_type, err ? err : "unknown error");
                return NULL;
        }

        document = EV_DOCUMENT (_ev_module_new_object (EV_MODULE (module)));
        g_type_module_unuse (module);

        g_object_set_data_full (G_OBJECT (document), BACKEND_DATA_KEY,
                                _ev_backend_info_ref (info),
                                (GDestroyNotify) _ev_backend_info_unref);

        return document;
}

static void file_filter_add_mime_types ( EvBackendInfo *  info, GtkFileFilter *  filter  )

static

Definition at line 539 of file ev-document-factory.c.

{
        char **mime_types;
    guint i;

        mime_types = info->mime_types;
        if (mime_types == NULL)
                return;

        for (i = 0; mime_types[i] != NULL; ++i)
                gtk_file_filter_add_mime_type (filter, mime_types[i]);
}

Here is the caller graph for this function:

static void free_uncompressed_uri ( gchar *  uri_unc)

static

Definition at line 210 of file ev-document-factory.c.

{
    if (!uri_unc)
        return;

    ev_tmp_uri_unlink (uri_unc);
    g_free (uri_unc);
}

Here is the caller graph for this function:

static EvBackendInfo* get_backend_info_for_document ( EvDocument *  document)

static

Definition at line 70 of file ev-document-factory.c.

{
        EvBackendInfo *info;

        info = g_object_get_data (G_OBJECT (document), BACKEND_DATA_KEY);

        g_warn_if_fail (info != NULL);
        return info;
}

Here is the caller graph for this function:

static EvBackendInfo* get_backend_info_for_mime_type ( const gchar *  mime_type)

static

Definition at line 51 of file ev-document-factory.c.

{
        GList *l;

        for (l = ev_backends_list; l; l = l->next) {
                EvBackendInfo *info = (EvBackendInfo *) l->data;
                char **mime_types = info->mime_types;
                guint i;

                for (i = 0; mime_types[i] != NULL; ++i) {
                        if (g_ascii_strcasecmp (mime_type, mime_types[i]) == 0)
                                return info;
                }
        }

        return NULL;
}

Here is the caller graph for this function:

static EvCompressionType get_compression_from_mime_type ( const gchar *  mime_type)

static

Definition at line 148 of file ev-document-factory.c.

{
    gchar type[3];
    gchar *p;

    if (!(p = g_strrstr (mime_type, "/")))
        return EV_COMPRESSION_NONE;

    if (sscanf (++p, "x-%2s%*s", type) == 1) {
        if (g_ascii_strcasecmp (type, "gz") == 0)
            return EV_COMPRESSION_GZIP;
        else if (g_ascii_strcasecmp (type, "bz") == 0)
            return EV_COMPRESSION_BZIP2;
                else if (g_ascii_strcasecmp (type, "xz") == 0)
                        return EV_COMPRESSION_LZMA;
    }

    return EV_COMPRESSION_NONE;
}

Here is the caller graph for this function:

static EvDocument* new_document_for_uri ( const char *  uri, gboolean  fast, EvCompressionType *  compression, GError **  error  )

static

Definition at line 184 of file ev-document-factory.c.

{
    EvDocument *document = NULL;
    gchar      *mime_type = NULL;

    *compression = EV_COMPRESSION_NONE;

    mime_type = ev_file_get_mime_type (uri, fast, error);
    if (mime_type == NULL)
        return NULL;

    document = ev_document_factory_new_document_for_mime_type (mime_type, error);
    if (document == NULL)
                return NULL;

    *compression = get_compression_from_mime_type (mime_type);

    g_free (mime_type);
    
        return document;
}

Here is the caller graph for this function:

Variable Documentation

gchar* ev_backends_dir = NULL

static

Definition at line 45 of file ev-document-factory.c.

GList* ev_backends_list = NULL

static

Definition at line 43 of file ev-document-factory.c.

GHashTable* ev_module_hash = NULL

static

Definition at line 44 of file ev-document-factory.c.