generator.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004-5 by Enrico Ros <eros.kde@email.it>                *
 *   Copyright (C) 2005   by Piotr Szymanski <niedakh@gmail.com>           *
 *   Copyright (C) 2008   by Albert Astals Cid <aacid@kde.org>             *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 ***************************************************************************/

#ifndef _OKULAR_GENERATOR_H_
#define _OKULAR_GENERATOR_H_

#include "okular_export.h"
#include "fontinfo.h"
#include "global.h"
#include "pagesize.h"

#include <QtCore/QList>
#include <QtCore/QObject>
#include <QtCore/QSharedDataPointer>
#include <QtCore/QString>
#include <QtCore/QVariant>
#include <QtCore/QVector>

#include <kmimetype.h>
#include <kpluginfactory.h>

#define OKULAR_EXPORT_PLUGIN( classname, aboutdata ) \
    K_PLUGIN_FACTORY( classname ## Factory, registerPlugin< classname >(); ) \
    K_EXPORT_PLUGIN( classname ## Factory( aboutdata ) )

class QByteArray;
class QMutex;
class QPrinter;
class QPrintDialog;
class KIcon;

namespace Okular {

class Document;
class DocumentFonts;
class DocumentInfo;
class DocumentObserver;
class DocumentSynopsis;
class EmbeddedFile;
class ExportFormatPrivate;
class FontInfo;
class GeneratorPrivate;
class Page;
class PixmapRequest;
class PixmapRequestPrivate;
class TextPage;
class NormalizedRect;
class SourceReference;

/* Note: on contents generation and asynchronous queries.
 * Many observers may want to request data syncronously or asynchronously.
 * - Sync requests. These should be done in-place.
 * - Async request must be done in real background. That usually means a
 *   thread, such as QThread derived classes.
 * Once contents are available, they must be immediately stored in the
 * Page they refer to, and a signal is emitted as soon as storing
 * (even for sync or async queries) has been done.
 */

class OKULAR_EXPORT ExportFormat
{
    public:
        typedef QList<ExportFormat> List;

        ExportFormat();

        ExportFormat( const QString &description, const KMimeType::Ptr &mimeType );

        ExportFormat( const KIcon &icon, const QString &description, const KMimeType::Ptr &mimeType );

        ~ExportFormat();

        ExportFormat( const ExportFormat &other );

        ExportFormat& operator=( const ExportFormat &other );

        QString description() const;

        KMimeType::Ptr mimeType() const;

        KIcon icon() const;

        bool isNull() const;

        enum StandardExportFormat
        {
            PlainText,         
            PDF,               
            OpenDocumentText,  
            HTML   
        };

        static ExportFormat standardFormat( StandardExportFormat type );

        bool operator==( const ExportFormat &other ) const;

        bool operator!=( const ExportFormat &other ) const;

    private:
        friend class ExportFormatPrivate;
        QSharedDataPointer<ExportFormatPrivate> d;
};

class OKULAR_EXPORT Generator : public QObject
{
    friend class PixmapGenerationThread;
    friend class TextPageGenerationThread;

    Q_OBJECT

    public:
        enum GeneratorFeature
        {
            Threaded,
            TextExtraction,    
            ReadRawData,       
            FontInfo,          
            PageSizes,         
            PrintNative,       
            PrintPostscript,   
            PrintToFile,       
            TiledRendering     
        };

        Generator( QObject *parent, const QVariantList &args );

        virtual ~Generator();

        virtual bool loadDocument( const QString & fileName, QVector< Page * > & pagesVector ) = 0;

        virtual bool loadDocumentFromData( const QByteArray & fileData, QVector< Page * > & pagesVector );

        bool closeDocument();

        virtual bool canGeneratePixmap() const;

        virtual void generatePixmap( PixmapRequest * request );

        virtual bool canGenerateTextPage() const;

        virtual void generateTextPage( Page * page );

        virtual const DocumentInfo * generateDocumentInfo();

        virtual const DocumentSynopsis * generateDocumentSynopsis();

        virtual FontInfo::List fontsForPage( int page );

        virtual const QList<EmbeddedFile*> * embeddedFiles() const;

        enum PageSizeMetric
        {
          None,   
          Points  
        };

        virtual PageSizeMetric pagesSizeMetric() const;

        virtual bool isAllowed( Permission action ) const;

        virtual void rotationChanged( Rotation orientation, Rotation oldOrientation );

        virtual PageSize::List pageSizes() const;

        virtual void pageSizeChanged( const PageSize &pageSize, const PageSize &oldPageSize );

        virtual bool print( QPrinter &printer );

        enum PrintError
        {
            NoPrintError,                       
            UnknownPrintError,
            TemporaryFileOpenPrintError,
            FileConversionPrintError,
            PrintingProcessCrashPrintError,
            PrintingProcessStartPrintError,
            PrintToFilePrintError,
            InvalidPrinterStatePrintError,
            UnableToFindFilePrintError,
            NoFileToPrintError,
            NoBinaryToPrintError,
            InvalidPageSizePrintError 
        };
        
        virtual QVariant metaData( const QString &key, const QVariant &option ) const;

        virtual ExportFormat::List exportFormats() const;

        virtual bool exportTo( const QString &fileName, const ExportFormat &format );

        bool hasFeature( GeneratorFeature feature ) const;

    Q_SIGNALS:
        void error( const QString &message, int duration );

        void warning( const QString &message, int duration );

        void notice( const QString &message, int duration );

    protected:
        void signalPixmapRequestDone( PixmapRequest * request );

        void signalTextGenerationDone( Page *page, TextPage *textPage );

        virtual bool doCloseDocument() = 0;

        virtual QImage image( PixmapRequest *page );

        virtual TextPage* textPage( Page *page );

        const Document * document() const;

        void setFeature( GeneratorFeature feature, bool on = true );

        QVariant documentMetaData( const QString &key, const QVariant &option = QVariant() ) const;

        QMutex* userMutex() const;

        void updatePageBoundingBox( int page, const NormalizedRect & boundingBox );

    protected Q_SLOTS:
        void requestFontData(const Okular::FontInfo &font, QByteArray *data);

        const SourceReference * dynamicSourceReference( int pageNr, double absX, double absY );
        
        Okular::Generator::PrintError printError() const;

    protected:
        Generator( GeneratorPrivate &dd, QObject *parent, const QVariantList &args );
        Q_DECLARE_PRIVATE( Generator )
        GeneratorPrivate *d_ptr;

        friend class Document;
        friend class DocumentPrivate;

    private:
        Q_DISABLE_COPY( Generator )

        Q_PRIVATE_SLOT( d_func(), void pixmapGenerationFinished() )
        Q_PRIVATE_SLOT( d_func(), void textpageGenerationFinished() )
};

class OKULAR_EXPORT PixmapRequest
{
    friend class Document;
    friend class DocumentPrivate;

    public:
        enum PixmapRequestFeature
        {
            NoFeature = 0,
            Asynchronous = 1,
            Preload = 2
        };
        Q_DECLARE_FLAGS( PixmapRequestFeatures, PixmapRequestFeature )

        
        PixmapRequest( DocumentObserver *observer, int pageNumber, int width, int height, int priority, PixmapRequestFeatures features );

        ~PixmapRequest();

        DocumentObserver *observer() const;

        int pageNumber() const;

        int width() const;

        int height() const;

        int priority() const;

        bool asynchronous() const;

        bool preload() const;

        Page *page() const;

        void setTile( bool tile );

        bool isTile() const;

        void setNormalizedRect( const NormalizedRect &rect );

        const NormalizedRect& normalizedRect() const;

    private:
        Q_DISABLE_COPY( PixmapRequest )

        friend class PixmapRequestPrivate;
        PixmapRequestPrivate* const d;
};

}

Q_DECLARE_METATYPE(Okular::Generator::PrintError)

#ifndef QT_NO_DEBUG_STREAM
OKULAR_EXPORT QDebug operator<<( QDebug str, const Okular::PixmapRequest &req );
#endif

#endif

/* kate: replace-tabs on; indent-width 4; */