internaldocument.cpp.svn-base

okular

/***************************************************************************
 *   Copyright (C) 1997-2005 the KGhostView authors. See file GV_AUTHORS.  *
 *   Copyright (C) 2005 by Piotr Szymanski <[e-mail]>             *
 *                                                                         *
 *   Many portions of this file are based on kghostview's kpswidget code   *
 *                                                                         *
 *   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.                                   *
 ***************************************************************************/

#include <kdebug.h>
#include <kglobal.h>
#include <klocale.h>
#include <qfile.h>
#include <qstring.h>
#include <qstringlist.h>
extern "C" {
#include "ps.h"
}

#include "internaldocument.h"

QStringList GSInternalDocument::paperSizes()
{
    QStringList list;
    int i=0;
    for (;i<CDSC_KNOWN_MEDIA;i++)
    {
        if ( ! dsc_known_media[i].name )
            break;
        list << QString ( dsc_known_media[i].name );
    }
    return list;
}

void GSInternalDocument::scanDSC()
{
    m_dsc = new KDSC();
    char buf[4096];
    int count=1;
    while( count != 0 )
    {
        count = fread( buf, sizeof(char), sizeof( buf ), m_internalFile );
        m_dsc->scanData( buf, count );
    }
    m_dsc->fixup();
}

GSInternalDocument::GSInternalDocument(const QString &fname, Format form) : m_error(false), m_fileName(fname), docInfo(0), m_format(form)
{
    m_internalFile = fopen(QFile::encodeName(fname),"r");
    if( m_internalFile == 0 )
    {
        m_error=true;
        m_errorString=strerror(errno);
    }

    if (!m_error)
    {
        m_fallbackMedia = pageSizeToString( static_cast< QPrinter::PageSize >( KGlobal::locale()->pageSize() ) );
        m_overrideOrientation = CDSC_ORIENT_UNKNOWN;
        m_overrideMedia = QString();

        scanDSC();

        if (!m_dsc)
        {
            m_error=true;
            m_errorString="Failed to construct KDSC";
        }
        if ( !m_error && ! m_dsc->dsc() )
        {
            m_error=true;
            // note this is not a fatal error, just a notice, we support docs without dsc
            m_errorString="Document has no DSC.";
        }
    }

    if (!m_error)
    {
        // available media information
        // 1. known predefined media
        const CDSCMEDIA* m = dsc_known_media;
        while( m->name )
        {
            m_mediaNames << m->name;
            m++;
        }

        // 2. media defined in the document
        if( m_dsc->media() ) 
        {
            unsigned int end=m_dsc->media_count();
            for( unsigned int i = 0; i < end ; i++ ) 
            {
                if( m_dsc->media()[i] && m_dsc->media()[i]->name )
                    m_mediaNames << m_dsc->media()[i]->name;
            }
        }
    }

    if (m_error)
        kDebug(4656) << m_errorString << endl;
}

GSInternalDocument::~GSInternalDocument()
{
    delete docInfo;
}

const DocumentInfo * GSInternalDocument::generateDocumentInfo()
{
    if (! m_dsc->dsc() )
        return 0L;

    if (!docInfo)
    {
        docInfo = new DocumentInfo();

        docInfo->set( "title", m_dsc->dsc_title(), i18n("Title") );
        docInfo->set( "author", m_dsc->dsc_for(), i18n("Author") );
        docInfo->set( "creator", m_dsc->dsc_creator(), i18n("Creator") );
        docInfo->set( "creationDate", m_dsc->dsc_date(), i18n("Created") );
        docInfo->set( "copyright", m_dsc->dsc_copyright(), i18n("Copyright") );
        QString dscVer=m_dsc->dsc_version();
        docInfo->set( "dscversion", dscVer, i18n("DSC version") );

        switch (m_format)
        {
            case PDF:
                docInfo->set( "mimeType", "application/pdf" );
                break;
            case PS:
                docInfo->set( "langlevel", QString::number(m_dsc->language_level()), i18n("Language Level") );
                if (dscVer.contains ("EPS"))
                    docInfo->set( "mimeType", "image/x-eps" );
                else
                    docInfo->set( "mimeType", "application/postscript" );
                break;
        }

        int pages=m_dsc->page_pages();
        if (!pages)
            pages = m_dsc->page_count();
        docInfo->set( "pages", QString::number(pages), i18n("Pages") );
    }
    return docInfo;
}


QString GSInternalDocument::pageSizeToString( QPrinter::PageSize pSize )
{
    switch( pSize )
    {
        case QPrinter::A3:
             return "A3";
        case QPrinter::A4:
             return "A4";
        case QPrinter::A5:
             return "A5";
        case QPrinter::B4:
             return "B4";
        case QPrinter::Ledger:
            return "Ledger";
        case QPrinter::Legal:
            return "Legal";
        case QPrinter::Letter:
            return "Letter";
        default:
            return "Unknown";
    }
}

QString GSInternalDocument::pageMedia() const
{
    if( !m_overrideMedia.isNull() )
        return m_overrideMedia;
    else if( m_dsc->page_media() != 0 )
        return QString( m_dsc->page_media()->name );
    else if( m_dsc->bbox().get() != 0 )
        return QString( "BoundingBox" );
    else
        return m_fallbackMedia;
}

QString GSInternalDocument::pageMedia( int pagenumber ) const
{
    if ( !m_dsc ) 
        return pageMedia();

    if ( unsigned( pagenumber ) >= m_dsc->page_count() ) 
        return pageMedia();

    if( !m_overrideMedia.isNull() )
        return m_overrideMedia;
    else if( m_dsc->page()[ pagenumber ].media != 0 )
        return QString( m_dsc->page()[ pagenumber ].media->name );
    else if( m_dsc->page_media() != 0 )
        return QString( m_dsc->page_media()->name );
    else if( m_dsc->bbox().get() != 0 )
        return QString( "BoundingBox" );
    else
        return m_fallbackMedia;
}

const CDSCMEDIA* GSInternalDocument::findMediaByName( const QString& mediaName ) const
{
    if( m_dsc->media() ) 
    {
        for( unsigned int i = 0; i < m_dsc->media_count(); i++ ) 
        {
            if( m_dsc->media()[i] && m_dsc->media()[i]->name
                && qstricmp( mediaName.toLocal8Bit(), m_dsc->media()[i]->name ) == 0 ) 
            {
                return m_dsc->media()[i];
            }
        }
    }
    /* It didn't match %%DocumentPaperSizes: */
    /* Try our known media */
    const CDSCMEDIA *m = dsc_known_media;
    while( m->name ) 
    {
        if( qstricmp( mediaName.toLocal8Bit(), m->name ) == 0 ) 
            return m;
        m++;
    }
    return 0;
}

QString GSInternalDocument::getPaperSize( const QString& mediaName ) const
{
    const CDSCMEDIA * r = 0;
    r=findMediaByName( mediaName );
    if (!r)
    {
        const CDSCMEDIA *m = dsc_known_media;
        while( m->name ) 
        {
            if( qstricmp( m_fallbackMedia.toLocal8Bit(), m->name ) == 0 ) 
                return QString(m->name);
            m++;
        }
        // should never happen as we have fallback
        kDebug(4656) << "UNABLE TO FIND PAPER SIZE FOR MEDIA NAME: " << mediaName << endl;
        return QString("a4");
    }
    return QString(r->name);
}

QSize GSInternalDocument::computePageSize( const QString& mediaName ) const
{
    if( mediaName == "BoundingBox" ) 
    {
        if( m_dsc->bbox().get() != 0 )
            return m_dsc->bbox()->size();
        else
            return QSize( 0, 0 );
    }

    const CDSCMEDIA* m = findMediaByName( mediaName );
    Q_ASSERT( m );
    return QSize( static_cast<int>( m->width ), static_cast<int>( m->height ) );
}

CDSC_ORIENTATION_ENUM GSInternalDocument::orientation() const
{