mu-office-lib.h

Go to the documentation of this file.

// Copyright (C) 2004-2021 Artifex Software, Inc.
//
// This file is part of MuPDF.
//
// MuPDF is free software: you can redistribute it and/or modify it under the
// terms of the GNU Affero General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
// details.
//
// You should have received a copy of the GNU Affero General Public License
// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
//
// Alternative licensing terms are available from the licensor.
// For commercial licensing, see <https://www.artifex.com/> or contact
// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
// CA 94129, USA, for further information.

 
#ifndef MU_OFFICE_LIB_H
#define MU_OFFICE_LIB_H
 
/*
 * General use
 *
 * This library uses threads but is not thread safe for the caller. All
 * calls should be made from a single thread. Some calls allow the user
 * to arrange for their own functions to be called back from the library;
 * often the users functions will be called back from a different thread. If
 * a call into the library is required in response to information from a
 * callback, it is the responsibility of the user to arrange for those
 * library calls to be made on the same thread as for other library calls.
 * Calls back into the library from a callback are not permitted.
 *
 * There are two main modes of use. In interactive windowing systems, it
 * is usual for the app developers code to be called on the main UI thread.
 * It is from the UI thread that all library calls should be made. Such
 * systems usually provide a way to post a call onto the UI thread. That
 * is the best way to respond to a callback from the library.
 *
 * The other mode of use is for plain executables that might wish to
 * (say) generate images of all the pages of a document. This can
 * be achieved, without use of callbacks, using the few synchronous
 * calls. E.g., MuOfficeDoc_getNumPages will wait for background document
 * loading to complete before returning the total number of pages and
 * MuOfficeRender_destroy will wait for background rendering to complete
 * before returning.
 */
 
#include <stddef.h> /* For size_t */
#include "mupdf/fitz.h" /* For fz_context/fz_document/fz_page */

typedef int MuError;

typedef enum MuOfficeDocErrorType
{
    MuOfficeDocErrorType_NoError = 0,
    MuOfficeDocErrorType_UnsupportedDocumentType = 1,
    MuOfficeDocErrorType_EmptyDocument = 2,
    MuOfficeDocErrorType_UnableToLoadDocument = 4,
    MuOfficeDocErrorType_UnsupportedEncryption = 5,
    MuOfficeDocErrorType_Aborted = 6,
    MuOfficeDocErrorType_OutOfMemory = 7,
 
    /* FIXME: Additional ones that should be backported to
     * smart-office-lib.h */
    MuOfficeDocErrorType_IllegalArgument = 8,

    MuOfficeDocErrorType_PasswordRequest = 0x1000
} MuOfficeDocErrorType;

typedef struct
{
    void *memptr;
    int   width;
    int   height;
    int   lineSkip;
} MuOfficeBitmap;

typedef struct
{
    float x;
    float y;
} MuOfficePoint;

typedef struct
{
    float x;
    float y;
    float width;
    float height;
} MuOfficeBox;
 
typedef enum MuOfficePointType
{
    MuOfficePointType_MoveTo,
    MuOfficePointType_LineTo
} MuOfficePointType;
 
typedef struct
{
    float x;
    float y;
    MuOfficePointType type;
} MuOfficePathPoint;

typedef struct
{
    MuOfficePoint   origin;
    MuOfficeBox     renderArea;
} MuOfficeRenderArea;
 
typedef struct MuOfficeLib MuOfficeLib;
typedef struct MuOfficeDoc MuOfficeDoc;
typedef struct MuOfficePage MuOfficePage;
typedef struct MuOfficeRender MuOfficeRender;

typedef void *(MuOfficeAllocFn)(void   *cookie,
                size_t  size);

typedef void (MuOfficeLoadingProgressFn)(void *cookie,
                    int   pagesLoaded,
                    int   complete);

typedef void (MuOfficeLoadingErrorFn)(  void                 *cookie,
                    MuOfficeDocErrorType  error);

typedef void (MuOfficePageUpdateFn)(    void                 *cookie,
                    const MuOfficeBox *area);

typedef void (MuOfficeRenderProgressFn)(void    *cookie,
                    MuError  error);

typedef enum
{
    MuOfficeDocType_PDF,
    MuOfficeDocType_XPS,
    MuOfficeDocType_IMG
} MuOfficeDocType;

typedef enum MuOfficeSaveResult
{
    MuOfficeSave_Succeeded,
    MuOfficeSave_Error,
    MuOfficeSave_Cancelled
}
MuOfficeSaveResult;

typedef void (MuOfficeSaveResultFn)(    void                 *cookie,
                    MuOfficeSaveResult result);

MuError MuOfficeLib_create(MuOfficeLib **pMu);

void MuOfficeLib_destroy(MuOfficeLib *mu);

MuOfficeDocType MuOfficeLib_getDocTypeFromFileExtension(const char *path);

char * MuOfficeLib_getSupportedFileExtensions(void);

MuError MuOfficeLib_loadDocument(MuOfficeLib              *mu,
                const char                *path,
                MuOfficeLoadingProgressFn *progressFn,
                MuOfficeLoadingErrorFn    *errorFn,
                void                      *cookie,
                MuOfficeDoc              **pDoc);

MuError MuOfficeLib_run(MuOfficeLib *mu, void (*fn)(fz_context *ctx, void *arg), void *arg);

int MuOfficeDoc_providePassword(MuOfficeDoc *doc, const char *password);

MuOfficeDocType MuOfficeDoc_docType(MuOfficeDoc *doc);

MuError MuOfficeDoc_getNumPages(MuOfficeDoc *doc, int *pNumPages);

int MuOfficeDoc_hasBeenModified(MuOfficeDoc *doc);

MuError MuOfficeDoc_save(MuOfficeDoc         *doc,
            const char           *path,
            MuOfficeSaveResultFn *resultFn,
            void                 *cookie);

void MuOfficeDoc_abortLoad(MuOfficeDoc *doc);

void MuOfficeDoc_destroy(MuOfficeDoc *doc);

MuError MuOfficeDoc_getPage(    MuOfficeDoc          *doc,
                int                   pageNumber,
                MuOfficePageUpdateFn *updateFn,
                void                 *cookie,
                MuOfficePage        **pPage);

MuError MuOfficeDoc_run(MuOfficeDoc *doc, void (*fn)(fz_context *ctx, fz_document *doc, void *arg), void *arg);

void MuOfficePage_destroy(MuOfficePage *page);

MuError MuOfficePage_getSize(   MuOfficePage *page,
                float        *pWidth,
                float        *pHeight);

MuError MuOfficePage_calculateZoom( MuOfficePage *page,
                    int           width,
                    int           height,
                    float        *pXZoom,
                    float        *pYZoom);

MuError MuOfficePage_getSizeForZoom(    MuOfficePage *page,
                    float         zoom,
                    int          *pWidth,
                    int          *pHeight);

MuError MuOfficePage_run(MuOfficePage *page, void (*fn)(fz_context *ctx, fz_page *page, void *arg), void *arg);

MuError MuOfficePage_render(    MuOfficePage             *page,
                float                     zoom,
            const   MuOfficeBitmap           *bitmap,
            const   MuOfficeRenderArea       *area,
                MuOfficeRenderProgressFn *progressFn,
                void                     *cookie,
                MuOfficeRender          **pRender);

void MuOfficeRender_destroy(MuOfficeRender *render);

void MuOfficeRender_abort(MuOfficeRender *render);

MuError MuOfficeRender_waitUntilComplete(MuOfficeRender *render);
 
#endif /* SMART_OFFICE_LIB_H */