• Skip to content
• Skip to link menu

KDE 4.0 API Reference

• KDE API Reference
• kdegraphics

• Sitemap
• Contact Us

 

okular

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>           *
 *                                                                         *
 *   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/core/okular_export.h>
#include <okular/core/fontinfo.h>
#include <okular/core/global.h>
#include <okular/core/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 QMutex;
class QPrinter;
class QPrintDialog;
class KIcon;

namespace Okular {

class Document;
class DocumentFonts;
class DocumentInfo;
class DocumentSynopsis;
class EmbeddedFile;
class ExportFormatPrivate;
class GeneratorPrivate;
class Page;
class PixmapRequest;
class PixmapRequestPrivate;
class TextPage;

/* 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                
        };

        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        
        };

        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 );

        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 );

        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;

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

        friend class Document;

    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:
        PixmapRequest( int id, int pageNumber, int width, int height, int priority, bool asynchronous );

        ~PixmapRequest();

        int id() const;

        int pageNumber() const;

        int width() const;

        int height() const;

        int priority() const;

        bool asynchronous() const;

        Page *page() const;

    private:
        Q_DISABLE_COPY( PixmapRequest )

        friend class PixmapRequestPrivate;
        PixmapRequestPrivate* const d;
};

}

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

#endif

okular

Skip menu "okular"

• Main Page
• Namespace List
• Class Hierarchy
• Alphabetical List
• Class List
• File List
• Namespace Members
• Class Members
• Related Pages

kdegraphics

Skip menu "kdegraphics"

• okular

Generated for kdegraphics by doxygen 1.5.4
This website is maintained by Adriaan de Groot and Allen Winter.
KDE^® and the K Desktop Environment^® logo are registered trademarks of KDE e.V. | Legal