Changeset 91


Ignore:
Timestamp:
Aug 2, 2006, 3:02:52 PM (15 years ago)
Author:
Eugene Romanenko
Message:

bitmap printing, preliminary postscript printing, export to PS for djvu plugin, other improvements

Location:
trunk
Files:
34 edited

Legend:

Unmodified
Added
Removed
  • trunk/Lucide/BIN/Lucide.lng

    r90 r91  
    66# Main menu
    77#
    8 MENU_FILE=~File
    9 MENU_OPEN=Open...\tCtrl+O
    10 MENU_SAVE_AS=Save As...
    11 MENU_PAGE_SETUP=Page setup...
    12 MENU_PRINT=Print...
    13 MENU_DOCUMENT_INFO=Document info...
    14 MENU_FONTS_INFO=Fonts info...
    15 MENU_PLUGINS_LIST=Plugins list...
    16 MENU_EXIT=Exit\tCtrl+X
     8MENU_DOCUMENT=~Document
     9MENU_OPEN=~Open...\tCtrl+O
     10MENU_SAVE_AS=~Save As...
     11MENU_PAGE_SETUP=Pa~ge setup...
     12MENU_PRINT=~Print...
     13MENU_DOCUMENT_INFO=~Document info...
     14MENU_FONTS_INFO=Fonts ~info...
     15MENU_PLUGINS_LIST=Plugins ~list...
     16MENU_EXIT=E~xit\tCtrl+X
    1717MENU_EDIT=~Edit
    18 MENU_COPY=Copy\tCtrl+Insert
    19 MENU_SELECT_ALL=Select all\tCtrl+/
    20 MENU_FIND=Find...\tCtrl+F
    21 MENU_FINDAGAIN=Find again\tCtrl+G
    22 MENU_SETTINGS=Settings
    23 MENU_DOCUMENT=~Document
    24 MENU_FIRST_PAGE=First page
    25 MENU_PREV_PAGE=Previous page\t-
    26 MENU_NEXT_PAGE=Next page\t+
    27 MENU_LAST_PAGE=Last page
    28 MENU_GO_TO_PAGE=Go to page...\tCtrl+N
     18MENU_COPY=~Copy\tCtrl+Insert
     19MENU_SELECT_ALL=Select ~all\tCtrl+/
     20MENU_FIND=~Find...\tCtrl+F
     21MENU_FINDAGAIN=Find a~gain\tCtrl+G
     22MENU_SETTINGS=~Settings
     23MENU_FIRST_PAGE=~First page
     24MENU_PREV_PAGE=~Previous page\t-
     25MENU_NEXT_PAGE=~Next page\t+
     26MENU_LAST_PAGE=~Last page
     27MENU_GO_TO_PAGE=~Go to page...\tCtrl+N
    2928MENU_VIEW=~View
    30 MENU_FIT_WINDOW=Fit in window
    31 MENU_ACTUAL_SIZE=Actual size
    32 MENU_FIT_WIDTH=Fit width
    33 MENU_ROTATE_CW=Rotate 90ø CW
    34 MENU_ROTATE_CCW=Rotate 90ø CCW
    35 MENU_SHOW_NAV_PANE=Show navigation pane
    36 MENU_SINGLE_PAGE=Single page
    37 MENU_CONTINUOUS=Continuous
     29MENU_FIT_WINDOW=Fi~t in window
     30MENU_ACTUAL_SIZE=~Actual size
     31MENU_FIT_WIDTH=Fit ~width
     32MENU_ROTATE_CW=~Rotate 90ø CW
     33MENU_ROTATE_CCW=Rotate 90ø ~CCW
     34MENU_SHOW_NAV_PANE=~Show navigation pane
     35MENU_SINGLE_PAGE=~Single page
     36MENU_CONTINUOUS=C~ontinuous
    3837MENU_WINDOW=~Window
    39 MENU_MAXVIEW=Maximized view\tF11
    40 MENU_FULLSCREEN=Fullscreen\tCtrl+L
     38MENU_MAXVIEW=~Maximized view\tF11
     39MENU_FULLSCREEN=~Fullscreen\tCtrl+L
    4140MENU_HELP=~Help
    42 MENU_PRODUCT_INFORMATION=Product Information
     41MENU_PRODUCT_INFORMATION=~Product Information
    4342
    4443#
     
    7574#
    7675PLUGLIST_PLUGINS_LIST=Plugins list
    77 PLUGLIST_CLOSE=Close
     76PLUGLIST_CLOSE=~Close
    7877# List columns titles
    7978PLUGLIST_PLUGIN_NAME=Plugin name
     
    8584#
    8685FONTINFO_FONTINFO=Font info
    87 FONTINFO_CLOSE=Close
     86FONTINFO_CLOSE=~Close
    8887FONTINFO_ENUMERATING=Enumerating fonts, please wait...
    8988# List columns titles
     
    9695#
    9796DOCINFO_DOCUMENT_INFO=Document info
    98 DOCINFO_CLOSE=Close
     97DOCINFO_CLOSE=~Close
    9998# Document info keys
    10099DOCINFO_TITLE=Title:
     
    132131AD_DESCRIPTION=Plugin-based document viewer with support for various file formats
    133132AD_COPYRIGHTS=(c) by Eugene Romanenko, netlabs.org in co-operation with Serenity Systems International
    134 AD_OK=OK
     133AD_OK=~OK
    135134
    136135#
     
    138137#
    139138SD_SETTINGS=Settings
    140 SD_DEFAULT_PAGE_LAYOUT=Default Page Layout
    141 SD_DEFAULT_ZOOM=Default Zoom
     139SD_DEFAULT_PAGE_LAYOUT=Default ~Page Layout
     140SD_DEFAULT_ZOOM=Default ~Zoom
     141SD_SINGLE_PAGE=Single page
     142SD_CONTINUOUS=Continuous
    142143SD_OK=~OK
    143144SD_CANCEL=~Cancel
     
    157158PD_TITLE=Print
    158159PD_PRINTER=Printer
    159 PD_NAME_LABEL=Name
    160 PD_JOB_PROPERTIES=Job properties
     160PD_NAME_LABEL=~Name
     161PD_JOB_PROPERTIES=~Job properties
    161162PD_DRIVER_LABEL=Driver
    162 PD_PRINT_RANGE=Print range
    163 PD_RANGE_ALL=All
    164 PD_RANGE_CURRENT_PAGE=Current page
    165 PD_RANGE_PAGES=Pages
    166 PD_FROM=From
    167 PD_TO=To
     163PD_PRINT_RANGE=Print ~range
     164PD_RANGE_ALL=~All
     165PD_RANGE_CURRENT_PAGE=C~urrent page
     166PD_RANGE_PAGES=Pa~ges
     167PD_FROM=~From
     168PD_TO=~To
    168169PD_PRINT_TYPE=Print type
    169 PD_TYPE_POSTSCRIPT=Postscript
    170 PD_TYPE_ASIMAGE=As image
    171 PD_HIGHER_IMAGE_QUALITY=Higher image quality (slower and require more memory)
    172 PD_BTNPRINT=Print
    173 PD_BTNCANCEL=Cancel
     170PD_TYPE_POSTSCRIPT=Post~script
     171PD_TYPE_ASIMAGE=As ~image
     172PD_HIGHER_IMAGE_QUALITY=~Higher image quality (slower and require more memory)
     173PD_BTNPRINT=~Print
     174PD_BTNCANCEL=~Cancel
     175# other 'print'-related messages
     176PRINT_PRINTING_PAGE_OF=Printing page %d of %d...
     177PRINT_GENERATING_POSTSCRIPT=Generating postscript file...
     178PRINT_SPOOLING_POSTSCRIPT=Spooling postscript data...
     179PRINT_FAILED=Print failed!
  • trunk/Lucide/BIN/Lucide_de.lng

    r89 r91  
    66# Main menu
    77#
    8 MENU_FILE=~Datei
     8MENU_DOCUMENT=~Dokument
    99MENU_OPEN=™ffnen...\tStrg+O
    1010MENU_SAVE_AS=Sichern unter...
     
    2121MENU_FINDAGAIN=Weitersuchen\tStrg+G
    2222MENU_SETTINGS=Einstellungen...
    23 MENU_DOCUMENT=~Dokument
    2423MENU_FIRST_PAGE=Erste Seite
    2524MENU_PREV_PAGE=Vorige Seite\t-
     
    6766MSGS_FILE_LOAD_ERROR=Datei kann nicht gelesen werden!
    6867MSGS_LOADING_DOCUMENT=Lese Dokument, bitte warten...
     68MSGS_WARNING=Warnung!
     69MSGS_OVERWRITE_FILE=Datei existiert bereits. šberschreiben?
     70MSGS_FILE_SAVE_ERROR=Fehler beim Schreiben der Datei!
    6971
    7072#
     
    140142SD_CANCEL=~Abbruch
    141143
     144#
     145# 'Go to page' dialog
     146#
     147GTP_GOTOPAGE=Gehe zu Seite
     148GTP_PAGE=Seite
     149GTP_OF=von %d
     150GTP_OK=~OK
     151GTP_CANCEL=~Abbruch
     152
     153
  • trunk/Lucide/BIN/Lucide_fr.lng

    r89 r91  
    66# Main menu
    77#
    8 MENU_FILE=~Fichier
     8MENU_DOCUMENT=~Document
    99MENU_OPEN=Ouvrir...\tCtrl+O
    1010MENU_SAVE_AS=Enregistrer sous...
     
    2020MENU_FIND=Rechercher...\tCtrl+F
    2121MENU_FINDAGAIN=Poursuivre la recherche\tCtrl+G
    22 MENU_DOCUMENT=~Document
    2322MENU_FIRST_PAGE=PremiŠre page
    2423MENU_PREV_PAGE=Page pr‚c‚dente\t-
  • trunk/Lucide/BIN/Lucide_sv.lng

    r89 r91  
    66# Main menu
    77#
    8 MENU_FILE=~Arkiv
     8MENU_DOCUMENT=~Dokument
    99MENU_OPEN=™ppna...\tCtrl+O
    1010MENU_SAVE_AS=Spara som...
     
    2020MENU_FIND=Finn...\tCtrl+F
    2121MENU_FINDAGAIN=Finn igen\tCtrl+G
    22 MENU_DOCUMENT=~Dokument
    2322MENU_FIRST_PAGE=F”rsta sidan
    2423MENU_PREV_PAGE=F”reg†ende sida\t-
  • trunk/Lucide/SOURCE/gui/aboutDlg.cpp

    r66 r91  
    4141#include <malloc.h>
    4242
    43 #include "lucide.h"
     43#include "globals.h"
    4444#include "luutils.h"
    4545#include "lucide_res.h"
  • trunk/Lucide/SOURCE/gui/docViewer.cpp

    r86 r91  
    6868
    6969// DocumentViewer constructor
    70 DocumentViewer::DocumentViewer( HAB _hab, HWND hWndFrame )
    71 {
    72     hab         = _hab;
     70DocumentViewer::DocumentViewer( HWND hWndFrame )
     71{
    7372    hMainFrame  = hWndFrame;
    7473    sHscrollMax = 0;
     
    9493    realzoom    = 1.0;
    9594    rotation    = 0;
    96     ev          = somGetGlobalEnvironment();
    9795    pixbuf      = NULL;
    9896    spos_x      = 0;
     
    179177
    180178// static, registration of a window class
    181 void DocumentViewer::registerClass( HAB hab )
     179void DocumentViewer::registerClass()
    182180{
    183181    WinRegisterClass( hab, "er.docview", docViewProc, CS_SIZEREDRAW, sizeof( ULONG ) * 2 );
     
    524522        delete buf;
    525523
    526         _this->foundrects[ i ] = _this->doc->searchText( _this->ev, i,
     524        _this->foundrects[ i ] = _this->doc->searchText( ev, i,
    527525                                        (char *)_this->searchString, _this->caseSensitive );
    528526        if ( _this->foundrects[ i ] != NULL )
     
    815813        pbmi.cPlanes = 1;
    816814        pbmi.cBitCount = _this->bpp * 8;
    817         GpiDrawBits( hps, _this->pixbuf->getDataPtr( _this->ev ), &pbmi, 4L,
     815        GpiDrawBits( hps, _this->pixbuf->getDataPtr( ev ), &pbmi, 4L,
    818816                     aptlPoints, lRop, BBO_IGNORE );
    819817
     
    851849                LONG rclx = pda->drawrect.xRight - pda->drawrect.xLeft;
    852850                LONG rcly = pda->drawrect.yTop - pda->drawrect.yBottom;
    853                 _this->pixbuf = new LuPixbuf( _this->ev, rclx, rcly, _this->bpp );
    854                 _this->doc->renderPageToPixbufAsynch( _this->ev, pda->pagenum,
     851                _this->pixbuf = new LuPixbuf( ev, rclx, rcly, _this->bpp );
     852                _this->doc->renderPageToPixbufAsynch( ev, pda->pagenum,
    855853                       pda->startpos.x, pda->startpos.y, rclx, rcly, _this->realzoom,
    856854                       _this->rotation, _this->pixbuf,
     
    877875                    WinReleasePS( hps );
    878876                }
    879                 WinSetRectEmpty( _this->hab, &_this->savedRcl );
     877                WinSetRectEmpty( thab, &_this->savedRcl );
    880878                delete _this->drawareas;
    881879                _this->drawareas = NULL;
  • trunk/Lucide/SOURCE/gui/docViewer.h

    r87 r91  
    5757{
    5858    public:
    59         DocumentViewer( HAB _hab, HWND hWndFrame );
     59        DocumentViewer( HWND hWndFrame );
    6060        virtual ~DocumentViewer();
    6161
     
    8181        void setFullscreen( bool _fullscreen );
    8282
    83         static void registerClass( HAB hab );
     83        static void registerClass();
    8484
    8585        // Internal stuffs
     
    129129
    130130        LuDocument *doc;
    131         HAB hab;
    132131        HWND hMainFrame;
    133132        HWND hWndDocFrame;
     
    149148        HPS hpsBuffer;
    150149        HDC hdcBuffer;
    151         Environment *ev;
    152150        LuPixbuf *pixbuf;
    153151        short bpp;
  • trunk/Lucide/SOURCE/gui/fontsInfoDlg.cpp

    r35 r91  
    4040#include <ludoc.xh>
    4141
     42#include "globals.h"
    4243#include "luutils.h"
    4344#include "fontsInfoDlg.h"
     
    8283void FontsInfoDlg::loadList()
    8384{
    84     Environment *ev = somGetGlobalEnvironment();
    8585    LuDocument_LuFontInfoSequence *fonts = doc->getFontInfo( ev );
    8686
  • trunk/Lucide/SOURCE/gui/indexWindow.cpp

    r85 r91  
    5050
    5151// IndexWindow constructor
    52 IndexWindow::IndexWindow( HAB _hab, HWND hWndFrame )
    53 {
    54     hab         = _hab;
     52IndexWindow::IndexWindow( HWND hWndFrame )
     53{
    5554    hMainFrame  = hWndFrame;
    5655    hWndIndex   = NULLHANDLE;
    5756    doc         = NULL;
    5857    totalpages  = 0;
    59     ev          = somGetGlobalEnvironment();
    6058
    6159    hWndPanel = WinCreateWindow( hWndFrame, WC_ER_SPLITTER, "",
  • trunk/Lucide/SOURCE/gui/indexWindow.h

    r35 r91  
    4949{
    5050    public:
    51         IndexWindow( HAB _hab, HWND hWndFrame );
     51        IndexWindow( HWND hWndFrame );
    5252        virtual ~IndexWindow();
    5353
     
    7070       
    7171        LuDocument *doc;
    72         HAB hab;
    7372        HWND hMainFrame;
    7473        HWND hWndPanel;
    7574        HWND hWndBar;
    7675        HWND hWndIndex;
    77                 Environment *ev;
    7876                long totalpages;
    7977};
  • trunk/Lucide/SOURCE/gui/intern.cpp

    r35 r91  
    4747#include <io.h>
    4848
    49 #include "lucide.h"
     49#include "globals.h"
    5050#include "wwbtn.h"
    5151#include "luutils.h"
  • trunk/Lucide/SOURCE/gui/lucide.cpp

    r90 r91  
    9494
    9595
    96 bool  Lucide::dontSwitchPage = false;
    97 SHORT Lucide::splitterPos    = 100;
    98 bool  Lucide::showIndex      = true;
    99 bool  Lucide::isMaxview      = false;
    100 bool  Lucide::isFullscreen   = false;
    101 LuWindowPos Lucide::winPos   = {0};
     96bool         Lucide::dontSwitchPage                = false;
     97SHORT        Lucide::splitterPos                   = 100;
     98bool         Lucide::showIndex                     = true;
     99bool         Lucide::isMaxview                     = false;
     100bool         Lucide::isFullscreen                  = false;
     101LuWindowPos  Lucide::winPos                        = {0};
     102char         Lucide::docFullName[ CCHMAXPATH ]     = "";
     103char         Lucide::docFileName[ CCHMAXPATHCOMP ] = "";
     104// static data for asynch loading document
     105ProgressDlg *Lucide::loadProgressDlg               = NULL;
     106bool         Lucide::docLoaded                     = false;;
     107char        *Lucide::loadError                     = NULL;
    102108
    103109
     
    328334
    329335
    330 // static data for asynch loading document
    331 ProgressDlg *Lucide::loadProgressDlg       = NULL;
    332 char         Lucide::docName[ CCHMAXPATH ] = "";
    333 bool         Lucide::docLoaded             = false;;
    334 char        *Lucide::loadError             = NULL;
    335 
    336336void Lucide::loadthread( void *p )
    337337{
     
    339339    HMQ thmq = WinCreateMsgQueue( thab, 0 );
    340340
    341     docLoaded = doc->loadFile( ev, docName, NULL, &loadError );
     341    docLoaded = doc->loadFile( ev, docFullName, NULL, &loadError );
    342342    loadProgressDlg->hide();
    343343
     
    379379            else
    380380            {
    381                 strcpy( docName, fn );
     381                strcpy( docFullName, fn );
    382382                docLoaded = false;;
    383383                loadError = NULL;
     
    397397                    char _ex[ _MAX_EXT ];
    398398                    _splitpath( fn, NULL, NULL, _fn, _ex );
    399                     snprintf( t, 2048, "%s%s - %s", _fn, _ex, title );
     399                    strcpy( docFileName, _fn );
     400                    strcat( docFileName, _ex );
     401                    snprintf( t, 2048, "%s - %s", docFileName, title );
    400402                    WinSetWindowText( hWndFrame, t );
    401403                    delete t;
     
    466468    char fil[ _MAX_FNAME ] = "";
    467469    char ext[ _MAX_EXT ] = "";
    468     _splitpath( docName, NULL, NULL, fil, ext );
     470    _splitpath( docFullName, NULL, NULL, fil, ext );
    469471    snprintf( fd->szFullFile, sizeof( fd->szFullFile ),
    470472                "%s%s%s", dirbuf, fil, ext );
     
    642644                    if ( d->showDialog() == DID_OK ) {
    643645                        // print
    644                         //printDocument( doc, d->getCurrentQInfo() );
     646                        PrintSetup *p = new PrintSetup;
     647                        memset( p, 0, sizeof( PrintSetup ) );
     648                        d->getPrintSetup( p );
     649                        printDocument( hWndFrame, doc, Lucide::docFileName, p );
     650                        delete p;
    645651                    }
    646652                    delete d;
     
    842848                                     ID_SPLITTER, NULL, NULL );
    843849
    844     indexWin = new IndexWindow( hab, hWndFrame );
    845 
    846     DocumentViewer::registerClass( hab );
    847 
    848     docViewer = new DocumentViewer( hab, hWndFrame );
     850    indexWin = new IndexWindow( hWndFrame );
     851
     852    DocumentViewer::registerClass();
     853
     854    docViewer = new DocumentViewer( hWndFrame );
    849855
    850856    WinSendMsg( hVertSplitter, SBM_SETWINDOWS,
  • trunk/Lucide/SOURCE/gui/lucide.h

    r89 r91  
    3636#define __LUCIDE_H
    3737
    38 extern const char *appName;
    39 extern const char *appVersion;
    40 extern HAB hab;
    41 extern char deffont[];
    42 extern int deffontlen;
     38#include "globals.h"
     39
    4340
    4441class LuDocument;
     
    6360   
    6461                static ProgressDlg *loadProgressDlg;
    65                 static char docName[ CCHMAXPATH ];
     62                static char docFullName[ CCHMAXPATH ];
    6663                static bool docLoaded;
    6764                static char *loadError;
     
    7673
    7774    public:
     75                static char docFileName[ CCHMAXPATHCOMP ];
    7876        static bool dontSwitchPage;
    7977        static SHORT splitterPos;
  • trunk/Lucide/SOURCE/gui/makefile

    r90 r91  
    11.autodepend
    22
    3 TEST=1
     3TEST=0
    44VERSION=Beta 2.1
    55
  • trunk/Lucide/SOURCE/gui/messages.cpp

    r88 r91  
    3636
    3737
    38 // Some menu item, which used not only in menu
    39 const char *MENU_SINGLE_PAGE = "MENU_SINGLE_PAGE";
    40 const char *MENU_CONTINUOUS  = "MENU_CONTINUOUS";
    41 
    42 
    4338// Toolbar hints
    4439const char *TBHINT_OPEN          = "TBHINT_OPEN";
     
    6661const char *MSGS_OVERWRITE_FILE   = "MSGS_OVERWRITE_FILE";
    6762const char *MSGS_FILE_SAVE_ERROR  = "MSGS_FILE_SAVE_ERROR";
     63
     64// Settings dialog
     65const char *SD_SINGLE_PAGE = "SD_SINGLE_PAGE";
     66const char *SD_CONTINUOUS  = "SD_CONTINUOUS";
    6867
    6968// Plugins List columns titles
     
    9594// 'Go to page' dialog
    9695const char *GTP_OF = "GTP_OF";
     96
     97// Printing, other 'print'-related messages
     98const char *PRINT_PRINTING_PAGE_OF      = "PRINT_PRINTING_PAGE_OF";
     99const char *PRINT_GENERATING_POSTSCRIPT = "PRINT_GENERATING_POSTSCRIPT";
     100const char *PRINT_SPOOLING_POSTSCRIPT   = "PRINT_SPOOLING_POSTSCRIPT";
     101const char *PRINT_FAILED                = "PRINT_FAILED";
     102
  • trunk/Lucide/SOURCE/gui/messages.h

    r88 r91  
    3737
    3838
    39 // Some menu item, which used not only in menu
    40 extern const char *MENU_SINGLE_PAGE;
    41 extern const char *MENU_CONTINUOUS;
    42 
    4339// Toolbar hints
    4440extern const char *TBHINT_OPEN;
     
    6561extern const char *MSGS_OVERWRITE_FILE;
    6662extern const char *MSGS_FILE_SAVE_ERROR;
     63
     64// Settings dialog
     65extern const char *SD_SINGLE_PAGE;
     66extern const char *SD_CONTINUOUS;
    6767
    6868// Plugins List columns titles
     
    9595extern const char *GTP_OF;
    9696
     97// Printing, other 'print'-related messages
     98extern const char *PRINT_PRINTING_PAGE_OF;
     99extern const char *PRINT_GENERATING_POSTSCRIPT;
     100extern const char *PRINT_SPOOLING_POSTSCRIPT;
     101extern const char *PRINT_FAILED;
     102
    97103
    98104#endif // __MESSAGES_H
  • trunk/Lucide/SOURCE/gui/print.cpp

    r90 r91  
    3535#define INCL_WIN
    3636#define INCL_GPI
     37#define INCL_DOS
    3738#define INCL_DEV
    3839#define INCL_ERRORS
     
    4445
    4546#include <string.h>
    46 
     47#include <process.h>
     48#include <stdio.h>
     49#include <io.h>
     50
     51#include "globals.h"
     52#include "progressDlg.h"
    4753#include "print.h"
     54#include "luutils.h"
     55#include "messages.h"
    4856
    4957// OpenWatcom headers doesn't have GpiDrawBits() declaration
     
    5462
    5563#define UNITS_MULTIPLIER    100
    56 
     64#define STD_IMAGE_ZOOM      2.0
     65#define HIGH_IMAGE_ZOOM     3.0
     66#define PS_PRINT_BUF_SIZE   32768
    5767#define TEST_MARGIN         10
    5868
    59 void printPage( LuDocument *doc, long page, HPS hpsPrinter, PHCINFO pcurForm );
    60 void queryCurrentForm( HDC hdcPrinter, PHCINFO pcurForm );
    61 
    62 void printDocument( LuDocument *doc, void *q )
    63 {
    64     PPRQINFO3    pQueueInfo = (PPRQINFO3)q;
     69
     70class LucidePrinting
     71{
     72    public:
     73        LucidePrinting( HWND hWndFrame, LuDocument *_doc,
     74                        const char *_title, PrintSetup *_psetup );
     75        ~LucidePrinting();
     76        void doPrint();
     77
     78    private:
     79        bool queryCurrentForm( HAB lhab, PHCINFO pcurForm );
     80        void printPagePm( long page, HPS hpsPrinter, PHCINFO pcurForm );
     81        bool doPmPrint( HAB lhab );
     82        bool doPsPrint( HAB lhab );
     83
     84        HWND hFrame;
     85        LuDocument *doc;
     86        char *title;
     87        PrintSetup *psetup;
     88        bool abortPrinting;
     89        ProgressDlg *progressDlg;
     90
     91        static void printabort( void *data );
     92        static void printthread( void *data );
     93};
     94
     95
     96void printDocument( HWND hWndFrame, LuDocument *doc, const char *title, PrintSetup *psetup )
     97{
     98    LucidePrinting *p = new LucidePrinting( hWndFrame, doc, title, psetup );
     99    p->doPrint();
     100}
     101
     102
     103LucidePrinting::LucidePrinting( HWND hWndFrame, LuDocument *_doc,
     104                                const char *_title, PrintSetup *_psetup )
     105{
     106    hFrame = hWndFrame;
     107    doc    = _doc;
     108    title  = newstrdup( _title );
     109    psetup = new PrintSetup;
     110    memcpy( psetup, _psetup, sizeof( PrintSetup ) );
     111    abortPrinting = false;
     112    progressDlg = new ProgressDlg( hWndFrame );
     113}
     114
     115LucidePrinting::~LucidePrinting()
     116{
     117    delete title;
     118    delete psetup;
     119    delete progressDlg;
     120}
     121
     122void LucidePrinting::doPrint()
     123{
     124    progressDlg->setBreakFunc( printabort, this );
     125    progressDlg->setText( "" );
     126    progressDlg->show( printthread, this );
     127}
     128
     129bool LucidePrinting::doPmPrint( HAB lhab )
     130{
    65131    CHAR         achDriverName[ DRIVERNAME_LENGTH ] = "";
     132    DEVOPENSTRUC dos   = { 0 };
    66133    SIZEL        sizel = { 0 };
    67     DEVOPENSTRUC dos   = { 0 };
     134
     135    HCINFO curForm = { 0 };
     136    if ( !queryCurrentForm( lhab, &curForm ) ) {
     137        return false;
     138    }
    68139
    69140    // build a devopenstruct for the call to DevOpenDC
    70     dos.pszLogAddress = pQueueInfo->pszName;
    71     strcpy( achDriverName, pQueueInfo->pszDriverName );
     141    dos.pszLogAddress = psetup->QueueInfo.pszName;              // 1
     142    strcpy( achDriverName, psetup->QueueInfo.pszDriverName );
    72143    achDriverName[ strcspn( achDriverName, "." ) ] = '\0';
    73     dos.pszDriverName = achDriverName;
    74     dos.pdriv = pQueueInfo->pDriverData;
    75 
    76     HDC hdcPrinter = DevOpenDC( hab, OD_QUEUED, "*", 3L, (PDEVOPENDATA)&dos, NULLHANDLE );
     144    dos.pszDriverName = achDriverName;                          // 2
     145    dos.pdriv         = psetup->QueueInfo.pDriverData;          // 3
     146    dos.pszDataType   = "PM_Q_STD";                             // 4
     147
     148    HDC hdcPrinter = DevOpenDC( lhab, OD_QUEUED, "*", 4L, (PDEVOPENDATA)&dos, NULLHANDLE );
    77149    if ( hdcPrinter == DEV_ERROR ) {
    78         somPrintf( "DevOpenDC error\n" );
    79         return;
     150        return false;
    80151    }
    81152
    82153    // PS in HiMetric, 0.01 mm
    83     HPS hpsPrinter = GpiCreatePS( hab, hdcPrinter, &sizel, PU_HIMETRIC | GPIA_ASSOC );
     154    HPS hpsPrinter = GpiCreatePS( lhab, hdcPrinter, &sizel, PU_HIMETRIC | GPIA_ASSOC );
    84155    if ( hpsPrinter == DEV_ERROR ) {
    85156        DevCloseDC( hdcPrinter );
    86         somPrintf( "GpiCreatePS error\n" );
    87         return;
    88     }
    89 
    90     HCINFO curForm = { 0 };
    91     queryCurrentForm( hdcPrinter, &curForm );
    92     char *psz = "test";
     157        return false;
     158    }
     159
    93160    // Issue STARTDOC to begin printing
    94     DevEscape( hdcPrinter, DEVESC_STARTDOC, (LONG)strlen(psz), (PBYTE)psz, NULL, NULL );
    95 
    96     somPrintf( "begin!\n" );
    97 
    98     printPage( doc, 0, hpsPrinter, &curForm );
    99 
    100     somPrintf( "end!\n" );
    101 
    102     DevEscape( hdcPrinter, DEVESC_ENDDOC, 0L, NULL, NULL, NULL );
     161    DevEscape( hdcPrinter, DEVESC_STARTDOC, strlen(title), (PBYTE)title, NULL, NULL );
     162
     163    long totalpages = psetup->pgto - psetup->pgfrom + 1;
     164    for ( long pg = psetup->pgfrom; pg <= psetup->pgto; pg++ )
     165    {
     166        char *fmt = newstrdupL( PRINT_PRINTING_PAGE_OF );
     167        char *buf = new char[ 255 ];
     168        snprintf( buf, 255, fmt, pg, totalpages );
     169        progressDlg->setText( buf );
     170        delete fmt;
     171        delete buf;
     172
     173        printPagePm( pg - 1, hpsPrinter, &curForm );
     174
     175        if ( pg != psetup->pgto ) {
     176            DevEscape( hdcPrinter, DEVESC_NEWFRAME, 0L, NULL, NULL, NULL );
     177        }
     178
     179        if ( abortPrinting ) {
     180            break;
     181        }
     182    }
     183
     184    // Issue DEVESC_ENDDOC, or DEVESC_ABORTDOC if printing was aborted
     185    DevEscape( hdcPrinter, abortPrinting ? DEVESC_ABORTDOC : DEVESC_ENDDOC,
     186               0L, NULL, NULL, NULL );
    103187
    104188    // Release PS and DC
     
    106190    GpiDestroyPS( hpsPrinter );
    107191    DevCloseDC( hdcPrinter );
    108 }
    109 
    110 
    111 static void printPage( LuDocument *doc, long page, HPS hpsPrinter, PHCINFO pcurForm )
     192    return true;
     193}
     194
     195
     196void LucidePrinting::printPagePm( long page, HPS hpsPrinter, PHCINFO pcurForm )
    112197{
    113198    long bpp = doc->getBpp( ev );
     
    125210    LONG pheight = ( pcurForm->cy - mTop - mBottom ) * UNITS_MULTIPLIER;
    126211
    127     double zoom = __min( (double)pwidth / w, (double)pheight / h );
    128     if ( zoom > 2.0 ) {
    129         zoom = 2.0;
    130     }
    131 
    132     somPrintf( "Doc pgsz: %g/%g  zoom: %g\n", w, h, zoom );
    133     somPrintf( "Paper %s, pgsz: %d/%d\n", pcurForm->szFormname, pcurForm->cx, pcurForm->cy );
    134     somPrintf( "pw/ph %d/%d\n", pwidth, pheight );
     212    double zoom = 1.0;
     213    if ( doc->isScalable( ev ) )
     214    {
     215        double maxcoeff = psetup->higherQuality ? HIGH_IMAGE_ZOOM : STD_IMAGE_ZOOM;
     216        zoom = __min( (double)pwidth / w, (double)pheight / h );
     217        if ( zoom > maxcoeff ) {
     218            zoom = maxcoeff;
     219        }
     220    }
     221
     222    //somPrintf( "Doc pgsz: %g/%g  zoom: %g\n", w, h, zoom );
     223    //somPrintf( "Paper %s, pgsz: %d/%d\n", pcurForm->szFormname, pcurForm->cx, pcurForm->cy );
     224    //somPrintf( "pw/ph %d/%d\n", pwidth, pheight );
     225
    135226    w *= zoom;
    136227    h *= zoom;
     
    149240    LONG rclx = w;
    150241    LONG rcly = h;
    151     LuPixbuf *pixbuf = new LuPixbuf( ev, rclx, rcly, bpp );
    152     POINTL aptlPoints[4]={ rclDraw.xLeft, rclDraw.yBottom,
    153                            rclDraw.xRight-1, rclDraw.yTop-1,
    154                            0, 0, rclx, rcly };
    155 
    156     doc->renderPageToPixbuf( ev, page, 0, 0, rclx, rcly, zoom, 0, pixbuf );
    157 
    158     LONG lRop = ROP_SRCCOPY;
    159     BITMAPINFO2 pbmi;
    160     pbmi.cbFix = 16L;
    161     pbmi.cx = rclx;
    162     pbmi.cy = rcly;
    163     pbmi.cPlanes = 1;
    164     pbmi.cBitCount = bpp * 8;
    165     GpiDrawBits( hpsPrinter, pixbuf->getDataPtr( ev ), &pbmi, 4L,
    166                  aptlPoints, lRop, BBO_IGNORE );
    167     delete pixbuf;
    168 }
    169 
    170 
    171 static void queryCurrentForm( HDC hdcPrinter, PHCINFO pcurForm )
    172 {
    173     LONG lForms = DevQueryHardcopyCaps( hdcPrinter, 0, 0, NULL );
     242    if ( doc->isRenderIntoPS( ev ) )
     243    {
     244        doc->renderPageToPS( ev, page, 0, 0, rclx, rcly, zoom, 0, hpsPrinter, &rclDraw );
     245    }
     246    else
     247    {
     248        LuPixbuf *pixbuf = new LuPixbuf( ev, rclx, rcly, bpp );
     249        POINTL aptlPoints[4]={ rclDraw.xLeft, rclDraw.yBottom,
     250                               rclDraw.xRight-1, rclDraw.yTop-1,
     251                               0, 0, rclx, rcly };
     252
     253        doc->renderPageToPixbuf( ev, page, 0, 0, rclx, rcly, zoom, 0, pixbuf );
     254
     255        LONG lRop = ROP_SRCCOPY;
     256        BITMAPINFO2 pbmi;
     257        pbmi.cbFix = 16L;
     258        pbmi.cx = rclx;
     259        pbmi.cy = rcly;
     260        pbmi.cPlanes = 1;
     261        pbmi.cBitCount = bpp * 8;
     262        GpiDrawBits( hpsPrinter, pixbuf->getDataPtr( ev ), &pbmi, 4L,
     263                     aptlPoints, lRop, BBO_IGNORE );
     264        delete pixbuf;
     265    }
     266}
     267
     268
     269
     270bool LucidePrinting::doPsPrint( HAB lhab )
     271{
     272    CHAR         achDriverName[ DRIVERNAME_LENGTH ] = "";
     273    DEVOPENSTRUC dos   = { 0 };
     274    SIZEL        sizel = { 0 };
     275
     276    HCINFO curForm = { 0 };
     277    if ( !queryCurrentForm( lhab, &curForm ) ) {
     278        return false;
     279    }
     280
     281    char *generating_ps = newstrdupL( PRINT_GENERATING_POSTSCRIPT );
     282    progressDlg->setText( generating_ps );
     283    delete generating_ps;
     284
     285    // Magrins
     286    LONG mLeft   = __max( TEST_MARGIN, curForm.xLeftClip );
     287    LONG mBottom = __max( TEST_MARGIN, curForm.yBottomClip );
     288    LONG mRight  = __max( TEST_MARGIN, curForm.cx - curForm.xRightClip );
     289    LONG mTop    = __max( TEST_MARGIN, curForm.cy - curForm.yTopClip );
     290
     291    // Count paper page size in 1/72 inches
     292    double pwidth = ( (double)( curForm.cx - mLeft - mRight ) / 25.4 ) * 72.0;
     293    double pheight = ( (double)( curForm.cy - mTop - mBottom ) / 25.4 ) * 72.0;
     294
     295    char *tmpps = "TMPLUCID.PS";
     296    BOOL rc = doc->exportToPostScript( ev, tmpps, psetup->pgfrom-1, psetup->pgto-1,
     297                                       pwidth, pheight, false );
     298    if ( !rc ) {
     299        unlink( tmpps );
     300        return false;
     301    }
     302    if ( abortPrinting ) {
     303        unlink( tmpps );
     304        return true;
     305    }
     306
     307    char *spooling_ps = newstrdupL( PRINT_SPOOLING_POSTSCRIPT );
     308    progressDlg->setText( spooling_ps );
     309    delete spooling_ps;
     310
     311    // build a devopenstruct for the call to SplQmOpen
     312    dos.pszLogAddress = psetup->QueueInfo.pszName;              // 1
     313    strcpy( achDriverName, psetup->QueueInfo.pszDriverName );
     314    achDriverName[ strcspn( achDriverName, "." ) ] = '\0';
     315    dos.pszDriverName = achDriverName;                          // 2
     316    dos.pdriv         = psetup->QueueInfo.pDriverData;          // 3
     317    dos.pszDataType   = "PM_Q_RAW";                             // 4
     318
     319    HSPL hspl = SplQmOpen( "*", 4L, (PQMOPENDATA)&dos );
     320    if ( hspl == SPL_ERROR ) {
     321        unlink( tmpps );
     322        return false;
     323    }
     324
     325    rc = SplQmStartDoc( hspl, title );
     326    if ( !rc ) {
     327        SplQmAbort( hspl );
     328        unlink( tmpps );
     329        return false;
     330    }
     331
     332    FILE *f = fopen( tmpps, "rb" );
     333    if ( f == NULL ) {
     334        SplQmAbort( hspl );
     335        unlink( tmpps );
     336        return false;
     337    }
     338
     339    bool splerr = false;
     340    void *buf = malloc( PS_PRINT_BUF_SIZE );
     341    int rd = 0;
     342    while ( rc && ( rd = fread( buf, 1, PS_PRINT_BUF_SIZE, f ) ) != 0 ) {
     343        rc = SplQmWrite( hspl, rd, buf );
     344        if ( !rc || abortPrinting ) {
     345            splerr = true;
     346            break;
     347        }
     348    }
     349    free( buf );
     350    fclose( f );
     351    unlink( tmpps );
     352
     353    if ( splerr ) {
     354        SplQmAbort( hspl );
     355        if ( !abortPrinting ) {
     356            return false;
     357        }
     358    }
     359    else {
     360        SplQmEndDoc( hspl );
     361        SplQmClose( hspl );
     362    }
     363
     364    return true;
     365}
     366
     367bool LucidePrinting::queryCurrentForm( HAB lhab, PHCINFO pcurForm )
     368{
     369    CHAR         achDriverName[ DRIVERNAME_LENGTH ] = "";
     370    DEVOPENSTRUC dos   = { 0 };
     371    // build a devopenstruct for the call to DevOpenDC
     372    dos.pszLogAddress = psetup->QueueInfo.pszName;              // 1
     373    strcpy( achDriverName, psetup->QueueInfo.pszDriverName );
     374    achDriverName[ strcspn( achDriverName, "." ) ] = '\0';
     375    dos.pszDriverName = achDriverName;                          // 2
     376    dos.pdriv = psetup->QueueInfo.pDriverData;                  // 3
     377
     378    HDC hdcPrinterInfo = DevOpenDC( lhab, OD_INFO, "*", 3L, (PDEVOPENDATA)&dos, NULLHANDLE );
     379    if ( hdcPrinterInfo == DEV_ERROR ) {
     380        return false;
     381    }
     382
     383    //long lTech = 0;
     384    //DevQueryCaps( hdcPrinterInfo, CAPS_TECHNOLOGY, sizeof(long), &lTech );
     385    //somPrintf( "lTech: 0x%x\n", lTech );
     386
     387    LONG lForms = DevQueryHardcopyCaps( hdcPrinterInfo, 0, 0, NULL );
    174388    if ( lForms == DQHC_ERROR ) {
    175         return;
     389        DevCloseDC( hdcPrinterInfo );
     390        return false;
    176391    }
    177392
    178393    HCINFO *forms = new HCINFO[ lForms ];
    179394    memset( forms, 0, sizeof( HCINFO ) * lForms );
    180     lForms = DevQueryHardcopyCaps( hdcPrinter, 0, lForms, forms );
     395    lForms = DevQueryHardcopyCaps( hdcPrinterInfo, 0, lForms, forms );
    181396    if ( lForms == DQHC_ERROR ) {
    182397        delete forms;
    183         return;
     398        DevCloseDC( hdcPrinterInfo );
     399        return false;
    184400    }
    185401
     
    190406        }
    191407    }
     408
    192409    delete forms;
    193 }
    194 
     410    DevCloseDC( hdcPrinterInfo );
     411    return true;
     412}
     413
     414// static method
     415void LucidePrinting::printabort( void *data )
     416{
     417    ((LucidePrinting *)data)->abortPrinting = true;
     418}
     419
     420// static method, thread for asynchronous printing
     421void LucidePrinting::printthread( void *p )
     422{
     423    DosSetPriority( PRTYS_THREAD, PRTYC_IDLETIME, PRTYD_MAXIMUM, 0 );
     424    LucidePrinting *_this = (LucidePrinting *)p;
     425
     426    HAB thab = WinInitialize( 0 );
     427    HMQ thmq = WinCreateMsgQueue( thab, 0 );
     428
     429    bool printOk = false;
     430    if ( _this->psetup->ptype == TypePostScript ) {
     431        printOk = _this->doPsPrint( thab );
     432    }
     433    else {
     434        printOk = _this->doPmPrint( thab );
     435    }
     436    _this->progressDlg->hide();
     437
     438    if ( !printOk )
     439    {
     440        char *printfailed = newstrdupL( PRINT_FAILED );
     441        WinMessageBox( HWND_DESKTOP, _this->hFrame, printfailed, NULL,
     442                       1, MB_OK | MB_ERROR | MB_MOVEABLE );
     443        delete printfailed;
     444    }
     445
     446    WinDestroyMsgQueue( thmq );
     447    WinTerminate( thab );
     448    _endthread();
     449
     450    delete _this;
     451}
     452
  • trunk/Lucide/SOURCE/gui/print.h

    r90 r91  
    3636#define __PRINT_H
    3737
    38 extern HAB hab;
    39 extern Environment *ev;
    4038
    4139#define DEVICENAME_LENGTH   32
     
    5654
    5755class LuDocument;
    58 void printDocument( LuDocument *doc, PrintSetup *psetup );
     56void printDocument( HWND hWndFrame, LuDocument *doc,
     57                    const char *title, PrintSetup *psetup );
    5958
    6059#endif // __PRINT_H
  • trunk/Lucide/SOURCE/gui/printDlg.cpp

    r90 r91  
    4242#include <ludoc.xh>
    4343
     44#include "globals.h"
    4445#include "printDlg.h"
    4546#include "Lucide_res.h"
     
    5152    hFrame      = hWndFrame;
    5253    doc         = _doc;
     54    scalable    = _doc->isScalable( ev );
    5355    currentpage = _currentpage;
    5456    psetup      = new PrintSetup;
     
    243245                case IDC_TYPE_ASIMAGE:
    244246                {
     247                    BOOL asimg = WinQueryButtonCheckstate( hwnd, IDC_TYPE_ASIMAGE );
    245248                    WinEnableControl( hwnd, IDC_HIGHER_IMAGE_QUALITY,
    246                                 WinQueryButtonCheckstate( hwnd, IDC_TYPE_ASIMAGE ) );
     249                                      asimg && _this->scalable );
    247250                }
    248251                break;
     
    283286                                _this->psetup->pgto = tmpVal;
    284287                            }
     288                            if ( _this->psetup->pgfrom > _this->psetup->pgto ) {
     289                                long tmp = _this->psetup->pgfrom;
     290                                _this->psetup->pgfrom = _this->psetup->pgto;
     291                                _this->psetup->pgto = tmp;
     292                            }
    285293                        }
    286294
  • trunk/Lucide/SOURCE/gui/printDlg.h

    r90 r91  
    6060        HWND hFrame;
    6161        LuDocument *doc;
     62        bool scalable;
    6263        long currentpage;
    6364        PPRQINFO3 pQueueInfo;
  • trunk/Lucide/SOURCE/gui/settingsDlg.cpp

    r63 r91  
    104104            // layout
    105105            HWND hLayout = WinWindowFromID( hwnd, IDC_DEFPGLAYOUT );
    106             std::string spage = getLocalizedString( MENU_SINGLE_PAGE );
    107             std::string cont = getLocalizedString( MENU_CONTINUOUS );
     106            std::string spage = getLocalizedString( SD_SINGLE_PAGE );
     107            std::string cont = getLocalizedString( SD_CONTINUOUS );
    108108            WinSendMsg( hLayout, LM_INSERTITEM, MPFROMSHORT(LIT_END),
    109109                        MPFROMP( spage.c_str() ) );
  • trunk/Lucide/SOURCE/plugins/ludjvu/ludjvu.cpp

    r88 r91  
    55 *     SOM incremental update: 2.24
    66 */
     7
    78
    89/*
     
    105106}
    106107
     108
    107109SOM_Scope boolean  SOMLINK loadFile(LuDjvuDocument *somSelf,
    108110                                     Environment *ev, string filename,
     
    132134}
    133135
     136
    134137SOM_Scope short  SOMLINK getBpp(LuDjvuDocument *somSelf,  Environment *ev)
    135138{
    136139    return 3;
    137140}
     141
    138142
    139143SOM_Scope boolean  SOMLINK isScalable(LuDjvuDocument *somSelf,
     
    143147}
    144148
     149
    145150SOM_Scope long  SOMLINK getPageCount(LuDjvuDocument *somSelf,
    146151                                      Environment *ev)
     
    150155    return ddjvu_document_get_pagenum( d->d_document );
    151156}
     157
    152158
    153159SOM_Scope void  SOMLINK getPageSize(LuDjvuDocument *somSelf,
     
    171177    }
    172178}
     179
    173180
    174181SOM_Scope void  SOMLINK renderPageToPixbuf(LuDjvuDocument *somSelf,
     
    235242}
    236243
     244
    237245SOM_Scope boolean  SOMLINK getThumbnailSize(LuDjvuDocument *somSelf,
    238246                                             Environment *ev,
     
    253261    return TRUE;
    254262}
     263
    255264
    256265SOM_Scope LuPixbuf*  SOMLINK getThumbnail(LuDjvuDocument *somSelf,
     
    294303}
    295304
     305
    296306SOM_Scope boolean  SOMLINK isSaveable(LuDjvuDocument *somSelf,
    297307                                       Environment *ev)
     
    303313#endif
    304314}
     315
    305316
    306317SOM_Scope boolean  SOMLINK saveAs(LuDjvuDocument *somSelf,  Environment *ev,
     
    327338#endif
    328339}
     340
     341
     342SOM_Scope boolean  SOMLINK isPostScriptExportable(LuDjvuDocument *somSelf,
     343                                                   Environment *ev)
     344{
     345#ifdef __GNUC__
     346    return TRUE;
     347#else
     348    return FALSE;
     349#endif
     350}
     351
     352
     353SOM_Scope boolean  SOMLINK exportToPostScript(LuDjvuDocument *somSelf,
     354                                               Environment *ev,
     355                                              string filename,
     356                                              long first_page,
     357                                              long last_page,
     358                                              double width, double height,
     359                                              boolean duplex)
     360{
     361#ifdef __GNUC__
     362    LuDjvuDocumentData *somThis = LuDjvuDocumentGetData(somSelf);
     363    DjvuDocument *d = (DjvuDocument *)somThis->data;
     364
     365    FILE *f = NULL;
     366    if ( ( f = fopen( filename, "wb" ) ) == NULL ) {
     367        return FALSE;
     368    }
     369
     370    char pgbuf[ 20 ];
     371    snprintf( pgbuf, 20, "-page=%d-%d", first_page + 1, last_page + 1 );
     372    const char *optv[] = { pgbuf };
     373
     374    ddjvu_job_t *job = ddjvu_document_print( d->d_document, f, 1, optv );
     375    while ( !ddjvu_job_done( job ) ) {
     376        djvu_handle_events( d->d_context );
     377    }
     378    fclose( f );
     379
     380    return TRUE;
     381#else
     382    return FALSE;
     383#endif
     384}
     385
    329386
    330387SOM_Scope void SOMLINK somDefaultInit(LuDjvuDocument *somSelf,
  • trunk/Lucide/SOURCE/plugins/ludjvu/ludjvu.idl

    r88 r91  
    3030        isSaveable: override;
    3131        saveAs: override;
     32        isPostScriptExportable: override;
     33        exportToPostScript: override;
    3234
    3335        somDefaultInit: override, init;
  • trunk/Lucide/SOURCE/plugins/ludjvu/ludjvu.xh

    r88 r91  
    151151typedef boolean   SOMLINK somTP_LuDjvuDocument_isPostScriptExportable(LuDjvuDocument *somSelf, Environment *ev);
    152152typedef somTP_LuDjvuDocument_isPostScriptExportable *somTD_LuDjvuDocument_isPostScriptExportable;
    153 typedef void   SOMLINK somTP_LuDjvuDocument_exportToPostScript(LuDjvuDocument *somSelf, Environment *ev,
     153typedef boolean   SOMLINK somTP_LuDjvuDocument_exportToPostScript(LuDjvuDocument *somSelf, Environment *ev,
    154154                string filename,
    155155                long first_page,
     
    587587
    588588/* method: exportToPostScript */
    589 void   exportToPostScript(Environment *ev,
     589boolean   exportToPostScript(Environment *ev,
    590590                string filename,
    591591                long first_page,
     
    595595                boolean duplex)
    596596{
    597    SOM_ResolveD(this,LuDjvuDocument,LuDocument,exportToPostScript)
     597   return SOM_ResolveD(this,LuDjvuDocument,LuDocument,exportToPostScript)
    598598        (this, ev,filename,first_page,last_page,width,height,duplex);
    599599}
  • trunk/Lucide/SOURCE/plugins/ludjvu/ludjvu.xih

    r88 r91  
    149149  #define _isSaveable somSelf->isSaveable
    150150  #define _saveAs somSelf->saveAs
     151  #define _isPostScriptExportable somSelf->isPostScriptExportable
     152  #define _exportToPostScript somSelf->exportToPostScript
    151153  #define _somDefaultInit somSelf->somDefaultInit
    152154  #define _somDestruct somSelf->somDestruct
     
    596598#define LuDjvuDocument_parents_saveAs(somSelf,ev,filename) (\
    597599   LuDjvuDocument_parent_LuDocument_saveAs(somSelf,ev,filename))
     600
     601/*
     602 * Overridden method: isPostScriptExportable
     603 */
     604SOM_Scope boolean  SOMLINK isPostScriptExportable(LuDjvuDocument *somSelf, Environment *ev);
     605static char *somMN_LuDjvuDocumentisPostScriptExportable = "LuDocument::isPostScriptExportable";
     606static somId somId_LuDjvuDocumentisPostScriptExportable = &somMN_LuDjvuDocumentisPostScriptExportable;
     607#ifdef somId_isPostScriptExportable
     608#undef somId_isPostScriptExportable
     609#else
     610#define somId_isPostScriptExportable somId_LuDjvuDocumentisPostScriptExportable
     611#endif
     612typedef boolean   SOMLINK somTP_xih_LuDjvuDocument_isPostScriptExportable(LuDjvuDocument *somSelf, Environment *ev);
     613typedef somTP_xih_LuDjvuDocument_isPostScriptExportable *somTD_xih_LuDjvuDocument_isPostScriptExportable;
     614/* define the parent method call macro */
     615static somMethodProc* LuDjvuDocument_parent_LuDocument_isPostScriptExportable_resolved;
     616#define LuDjvuDocument_parent_LuDocument_isPostScriptExportable(somSelf,ev) \
     617  ((( somTD_xih_LuDjvuDocument_isPostScriptExportable ) \
     618      LuDjvuDocument_parent_LuDocument_isPostScriptExportable_resolved) \
     619        (somSelf,ev))
     620/* define a variety of (possibly ambiguous) short forms */
     621#ifndef SOMGD_pmc_parent_isPostScriptExportable
     622  #ifdef parent_isPostScriptExportable
     623    #define SOMGD_pmc_parent_isPostScriptExportable
     624    #undef parent_isPostScriptExportable
     625  #else
     626#define parent_isPostScriptExportable LuDjvuDocument_parent_LuDocument_isPostScriptExportable
     627  #endif
     628#endif
     629#ifndef SOMGD_pmc_parent_LuDocument_isPostScriptExportable
     630  #ifdef parent_LuDocument_isPostScriptExportable
     631    #define SOMGD_pmc_parent_LuDocument_isPostScriptExportable
     632    #undef parent_LuDocument_isPostScriptExportable
     633  #else
     634    #define parent_LuDocument_isPostScriptExportable LuDjvuDocument_parent_LuDocument_isPostScriptExportable
     635  #endif
     636#endif
     637#define LuDjvuDocument_parents_isPostScriptExportable(somSelf,ev) (\
     638   LuDjvuDocument_parent_LuDocument_isPostScriptExportable(somSelf,ev))
     639
     640/*
     641 * Overridden method: exportToPostScript
     642 */
     643SOM_Scope boolean  SOMLINK exportToPostScript(LuDjvuDocument *somSelf, Environment *ev,
     644                string filename,
     645                long first_page,
     646                long last_page,
     647                double width,
     648                double height,
     649                boolean duplex);
     650static char *somMN_LuDjvuDocumentexportToPostScript = "LuDocument::exportToPostScript";
     651static somId somId_LuDjvuDocumentexportToPostScript = &somMN_LuDjvuDocumentexportToPostScript;
     652#ifdef somId_exportToPostScript
     653#undef somId_exportToPostScript
     654#else
     655#define somId_exportToPostScript somId_LuDjvuDocumentexportToPostScript
     656#endif
     657typedef boolean   SOMLINK somTP_xih_LuDjvuDocument_exportToPostScript(LuDjvuDocument *somSelf, Environment *ev,
     658                string filename,
     659                long first_page,
     660                long last_page,
     661                double width,
     662                double height,
     663                boolean duplex);
     664typedef somTP_xih_LuDjvuDocument_exportToPostScript *somTD_xih_LuDjvuDocument_exportToPostScript;
     665/* define the parent method call macro */
     666static somMethodProc* LuDjvuDocument_parent_LuDocument_exportToPostScript_resolved;
     667#define LuDjvuDocument_parent_LuDocument_exportToPostScript(somSelf,ev,filename,first_page,last_page,width,height,duplex) \
     668  ((( somTD_xih_LuDjvuDocument_exportToPostScript ) \
     669      LuDjvuDocument_parent_LuDocument_exportToPostScript_resolved) \
     670        (somSelf,ev,filename,first_page,last_page,width,height,duplex))
     671/* define a variety of (possibly ambiguous) short forms */
     672#ifndef SOMGD_pmc_parent_exportToPostScript
     673  #ifdef parent_exportToPostScript
     674    #define SOMGD_pmc_parent_exportToPostScript
     675    #undef parent_exportToPostScript
     676  #else
     677#define parent_exportToPostScript LuDjvuDocument_parent_LuDocument_exportToPostScript
     678  #endif
     679#endif
     680#ifndef SOMGD_pmc_parent_LuDocument_exportToPostScript
     681  #ifdef parent_LuDocument_exportToPostScript
     682    #define SOMGD_pmc_parent_LuDocument_exportToPostScript
     683    #undef parent_LuDocument_exportToPostScript
     684  #else
     685    #define parent_LuDocument_exportToPostScript LuDjvuDocument_parent_LuDocument_exportToPostScript
     686  #endif
     687#endif
     688#define LuDjvuDocument_parents_exportToPostScript(somSelf,ev,filename,first_page,last_page,width,height,duplex) (\
     689   LuDjvuDocument_parent_LuDocument_exportToPostScript(somSelf,ev,filename,first_page,last_page,width,height,duplex))
    598690
    599691/*
     
    653745    {    &somId_LuDjvuDocumentsaveAs,
    654746         (somMethodProc *) saveAs  },
     747    {    &somId_LuDjvuDocumentisPostScriptExportable,
     748         (somMethodProc *) isPostScriptExportable  },
     749    {    &somId_LuDjvuDocumentexportToPostScript,
     750         (somMethodProc *) exportToPostScript  },
    655751    {    &somId_LuDjvuDocumentsomDefaultInit,
    656752         (somMethodProc *) somDefaultInit  },
     
    671767
    672768static somStaticClassInfo LuDjvuDocumentSCI = {
    673     4, 0, 12, 0, 0, 0, /* layout version 4 */
     769    4, 0, 14, 0, 0, 0, /* layout version 4 */
    674770    LuDjvuDocument_MajorVersion, LuDjvuDocument_MinorVersion,
    675771    sizeof(LuDjvuDocumentData), LuDjvuDocument_MaxNoMethods, 1,
     
    717813    LuDocumentNewClass(LuDocument_MajorVersion,LuDocument_MinorVersion);        /* static reference */
    718814    result = (SOMClass*)((void*)somBuildClass(0xFFFFFFFF,&LuDjvuDocumentSCI, somtmajorVersion, somtminorVersion));
     815    LuDjvuDocument_parent_LuDocument_exportToPostScript_resolved =
     816        somParentNumResolve(LuDjvuDocumentCClassData.parentMtab, 1, LuDocumentClassData.exportToPostScript);
     817    LuDjvuDocument_parent_LuDocument_isPostScriptExportable_resolved =
     818        somParentNumResolve(LuDjvuDocumentCClassData.parentMtab, 1, LuDocumentClassData.isPostScriptExportable);
    719819    LuDjvuDocument_parent_LuDocument_saveAs_resolved =
    720820        somParentNumResolve(LuDjvuDocumentCClassData.parentMtab, 1, LuDocumentClassData.saveAs);
  • trunk/Lucide/SOURCE/plugins/ludoc/ludoc.cpp

    r61 r91  
    278278
    279279
    280 SOM_Scope void  SOMLINK exportToPostScript(LuDocument *somSelf, 
     280SOM_Scope boolean SOMLINK exportToPostScript(LuDocument *somSelf,
    281281                                   Environment *ev,
    282282                                   string filename, long first_page,
     
    285285{
    286286    // Abstract method does nothing
     287    return FALSE;
    287288}
    288289
  • trunk/Lucide/SOURCE/plugins/ludoc/ludoc.idl

    r61 r91  
    1313#include <lutypes.h>
    1414
     15/**
     16 * Note: all page numbers is zero-based.
     17 */
    1518
    1619interface LuDocument : SOMObject
     
    308311     *
    309312     * Create a new postscript file and render document to.
    310      **/
    311     void exportToPostScript( in string filename,
     313     * Return value: TRUE if PS document was generated successfully.
     314     **/
     315    boolean exportToPostScript( in string filename,
    312316                     in long first_page, in long last_page,
    313317                     in double width, in double height, in boolean duplex );
  • trunk/Lucide/SOURCE/plugins/ludoc/ludoc.xh

    r88 r91  
    271271typedef boolean   SOMLINK somTP_LuDocument_isPostScriptExportable(LuDocument *somSelf, Environment *ev);
    272272typedef somTP_LuDocument_isPostScriptExportable *somTD_LuDocument_isPostScriptExportable;
    273 typedef void   SOMLINK somTP_LuDocument_exportToPostScript(LuDocument *somSelf, Environment *ev,
     273typedef boolean   SOMLINK somTP_LuDocument_exportToPostScript(LuDocument *somSelf, Environment *ev,
    274274                string filename,
    275275                long first_page,
     
    707707
    708708/* method: exportToPostScript */
    709 void   exportToPostScript(Environment *ev,
     709boolean   exportToPostScript(Environment *ev,
    710710                string filename,
    711711                long first_page,
     
    715715                boolean duplex)
    716716{
    717    SOM_ResolveD(this,LuDocument,LuDocument,exportToPostScript)
     717   return SOM_ResolveD(this,LuDocument,LuDocument,exportToPostScript)
    718718        (this, ev,filename,first_page,last_page,width,height,duplex);
    719719}
  • trunk/Lucide/SOURCE/plugins/ludoc/ludoc.xih

    r61 r91  
    549549 * New Method: exportToPostScript
    550550 */
    551 SOM_Scope void  SOMLINK exportToPostScript(LuDocument *somSelf, Environment *ev,
     551SOM_Scope boolean  SOMLINK exportToPostScript(LuDocument *somSelf, Environment *ev,
    552552                string filename,
    553553                long first_page,
     
    57057020, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, };
    571571
    572 static somMethodInfo exportToPostScriptMethodInfo = {1, 40, &exportToPostScriptFloatMap};
     572static somMethodInfo exportToPostScriptMethodInfo = {11, 40, &exportToPostScriptFloatMap};
    573573
    574574static somApRdInfo exportToPostScriptStubs = {0, 0, &exportToPostScriptMethodInfo};
  • trunk/Lucide/SOURCE/plugins/lupoppler/lupoppler.cpp

    r71 r91  
    678678
    679679
    680 SOM_Scope void SOMLINK exportToPostScript(LuPopplerDocument *somSelf,
     680SOM_Scope boolean SOMLINK exportToPostScript(LuPopplerDocument *somSelf,
    681681                                    Environment *ev, string filename,
    682                                    long first_page, long last_page,
    683                                    double width, double height,
    684                                    boolean duplex)
     682                                    long first_page, long last_page,
     683                                    double width, double height,
     684                                    boolean duplex)
    685685{
    686686    if ( filename == NULL ) {
    687         return;
     687        return FALSE;
    688688    }
    689689    if ( last_page < first_page ) {
    690         return;
     690        return FALSE;
    691691    }
    692692
    693693    LuPopplerDocumentData *somThis = LuPopplerDocumentGetData(somSelf);
    694694    PDFDoc *doc = ((PopplerDocument *)somThis->data)->doc;
    695 
    696695
    697696    PSOutputDev *out = new PSOutputDev( filename, doc->getXRef(),
     
    701700                                        duplex, 0, 0, 0, 0, gFalse );
    702701
    703 
    704     for ( long i = first_page; i < last_page; i++ ) {
     702        if ( !out->isOk() ) {
     703                delete out;
     704        return FALSE;
     705        }
     706
     707    for ( long i = first_page; i <= last_page; i++ ) {
    705708        doc->displayPage( out, i + 1, 72.0, 72.0, 0, gFalse, gTrue, gFalse );
    706709    }
    707710
    708711    delete out;
     712    return TRUE;
    709713}
    710714
  • trunk/Lucide/SOURCE/plugins/lupoppler/lupoppler.xh

    r88 r91  
    151151typedef boolean   SOMLINK somTP_LuPopplerDocument_isPostScriptExportable(LuPopplerDocument *somSelf, Environment *ev);
    152152typedef somTP_LuPopplerDocument_isPostScriptExportable *somTD_LuPopplerDocument_isPostScriptExportable;
    153 typedef void   SOMLINK somTP_LuPopplerDocument_exportToPostScript(LuPopplerDocument *somSelf, Environment *ev,
     153typedef boolean   SOMLINK somTP_LuPopplerDocument_exportToPostScript(LuPopplerDocument *somSelf, Environment *ev,
    154154                string filename,
    155155                long first_page,
     
    587587
    588588/* method: exportToPostScript */
    589 void   exportToPostScript(Environment *ev,
     589boolean   exportToPostScript(Environment *ev,
    590590                string filename,
    591591                long first_page,
     
    595595                boolean duplex)
    596596{
    597    SOM_ResolveD(this,LuPopplerDocument,LuDocument,exportToPostScript)
     597   return SOM_ResolveD(this,LuPopplerDocument,LuDocument,exportToPostScript)
    598598        (this, ev,filename,first_page,last_page,width,height,duplex);
    599599}
  • trunk/Lucide/SOURCE/plugins/lupoppler/lupoppler.xih

    r61 r91  
    909909 * Overridden method: exportToPostScript
    910910 */
    911 SOM_Scope void  SOMLINK exportToPostScript(LuPopplerDocument *somSelf, Environment *ev,
     911SOM_Scope boolean  SOMLINK exportToPostScript(LuPopplerDocument *somSelf, Environment *ev,
    912912                string filename,
    913913                long first_page,
     
    923923#define somId_exportToPostScript somId_LuPopplerDocumentexportToPostScript
    924924#endif
    925 typedef void   SOMLINK somTP_xih_LuPopplerDocument_exportToPostScript(LuPopplerDocument *somSelf, Environment *ev,
     925typedef boolean   SOMLINK somTP_xih_LuPopplerDocument_exportToPostScript(LuPopplerDocument *somSelf, Environment *ev,
    926926                string filename,
    927927                long first_page,
  • trunk/Lucide/readme

    r75 r91  
    1212  --------------------------------------------------------------------------
    1313         PDF                   Scaling, Rotation, Navigation, Text
    14                                selection, Searching, Asynchronous rendering
     14                               selection, Searching, Asynchronous rendering,
     15                               PostScript printing
    1516
    16          DJVU                  Scaling
     17         DJVU                  Scaling, PostScript printing
    1718
    1819         JPG                   -
  • trunk/poppler/mypoppler/poppler/PSOutputDev.cc

    r2 r91  
    706706
    707707struct PSSubstFont {
    708   char *psName;                 // PostScript name
    709   double mWidth;                // width of 'm' character
     708  char *psName;         // PostScript name
     709  double mWidth;        // width of 'm' character
    710710};
    711711
     
    767767
    768768  PSOutCustomColor(double cA, double mA,
    769                    double yA, double kA, GooString *nameA);
     769           double yA, double kA, GooString *nameA);
    770770  ~PSOutCustomColor();
    771771
     
    776776
    777777PSOutCustomColor::PSOutCustomColor(double cA, double mA,
    778                                    double yA, double kA, GooString *nameA) {
     778                   double yA, double kA, GooString *nameA) {
    779779  c = cA;
    780780  m = mA;
     
    797797
    798798  DeviceNRecoder(Stream *strA, int widthA, int heightA,
    799                 GfxImageColorMap *colorMapA);
     799        GfxImageColorMap *colorMapA);
    800800  virtual ~DeviceNRecoder();
    801801  virtual StreamKind getKind() { return strWeird; }
     
    824824
    825825DeviceNRecoder::DeviceNRecoder(Stream *strA, int widthA, int heightA,
    826                                GfxImageColorMap *colorMapA):
     826                   GfxImageColorMap *colorMapA):
    827827    FilterStream(strA) {
    828828  width = widthA;
     
    846846void DeviceNRecoder::reset() {
    847847  imgStr = new ImageStream(str, width, colorMap->getNumPixelComps(),
    848                            colorMap->getBits());
     848               colorMap->getBits());
    849849  imgStr->reset();
    850850}
     
    888888
    889889PSOutputDev::PSOutputDev(char *fileName, XRef *xrefA, Catalog *catalog,
    890                         int firstPage, int lastPage, PSOutMode modeA,
     890            int firstPage, int lastPage, PSOutMode modeA,
    891891                         int paperWidthA, int paperHeightA, GBool duplexA,
    892                         int imgLLXA, int imgLLYA, int imgURXA, int imgURYA,
    893                         GBool manualCtrlA) {
     892            int imgLLXA, int imgLLYA, int imgURXA, int imgURYA,
     893            GBool manualCtrlA) {
    894894  FILE *f;
    895895  PSFileType fileTypeA;
     
    946946
    947947PSOutputDev::PSOutputDev(PSOutputFunc outputFuncA, void *outputStreamA,
    948                         XRef *xrefA, Catalog *catalog,
    949                         int firstPage, int lastPage, PSOutMode modeA,
     948            XRef *xrefA, Catalog *catalog,
     949            int firstPage, int lastPage, PSOutMode modeA,
    950950                         int paperWidthA, int paperHeightA, GBool duplexA,
    951                         int imgLLXA, int imgLLYA, int imgURXA, int imgURYA,
    952                         GBool manualCtrlA) {
     951            int imgLLXA, int imgLLYA, int imgURXA, int imgURYA,
     952            GBool manualCtrlA) {
    953953  underlayCbk = NULL;
    954954  underlayCbkData = NULL;
     
    973973
    974974void PSOutputDev::init(PSOutputFunc outputFuncA, void *outputStreamA,
    975                        PSFileType fileTypeA, XRef *xrefA, Catalog *catalog,
    976                        int firstPage, int lastPage, PSOutMode modeA,
    977                        int imgLLXA, int imgLLYA, int imgURXA, int imgURYA,
    978                        GBool manualCtrlA, int paperWidthA, int paperHeightA,
     975               PSFileType fileTypeA, XRef *xrefA, Catalog *catalog,
     976               int firstPage, int lastPage, PSOutMode modeA,
     977               int imgLLXA, int imgLLYA, int imgURXA, int imgURYA,
     978               GBool manualCtrlA, int paperWidthA, int paperHeightA,
    979979                       GBool duplexA) {
    980980  Page *page;
     
    10601060    if (firstPage > 0 && firstPage <= catalog->getNumPages()) {
    10611061      writeHeader(firstPage, lastPage,
    1062                   catalog->getPage(firstPage)->getMediaBox(),
    1063                   catalog->getPage(firstPage)->getCropBox(),
    1064                   catalog->getPage(firstPage)->getRotate());
     1062          catalog->getPage(firstPage)->getMediaBox(),
     1063          catalog->getPage(firstPage)->getCropBox(),
     1064          catalog->getPage(firstPage)->getRotate());
    10651065    } else {
    10661066      box = new PDFRectangle(0, 0, 1, 1);
     
    10951095      writeTrailer();
    10961096      if (mode != psModeForm) {
    1097         writePS("%%EOF\n");
     1097    writePS("%%EOF\n");
    10981098      }
    10991099    }
     
    11521152
    11531153void PSOutputDev::writeHeader(int firstPage, int lastPage,
    1154                               PDFRectangle *mediaBox, PDFRectangle *cropBox,
    1155                               int pageRotate) {
     1154                  PDFRectangle *mediaBox, PDFRectangle *cropBox,
     1155                  int pageRotate) {
    11561156  double x1, y1, x2, y2;
    11571157
     
    11611161    writePSFmt("%%%%Creator: xpdf/pdftops %s\n", xpdfVersion);
    11621162    writePSFmt("%%%%LanguageLevel: %d\n",
    1163                (level == psLevel1 || level == psLevel1Sep) ? 1 :
    1164                (level == psLevel2 || level == psLevel2Sep) ? 2 : 3);
     1163           (level == psLevel1 || level == psLevel1Sep) ? 1 :
     1164           (level == psLevel2 || level == psLevel2Sep) ? 2 : 3);
    11651165    if (level == psLevel1Sep || level == psLevel2Sep || level == psLevel3Sep) {
    11661166      writePS("%%DocumentProcessColors: (atend)\n");
     
    11691169    writePS("%%DocumentSuppliedResources: (atend)\n");
    11701170    writePSFmt("%%%%DocumentMedia: plain %d %d 0 () ()\n",
    1171                paperWidth, paperHeight);
     1171           paperWidth, paperHeight);
    11721172    writePSFmt("%%%%BoundingBox: 0 0 %d %d\n", paperWidth, paperHeight);
    11731173    writePSFmt("%%%%Pages: %d\n", lastPage - firstPage + 1);
     
    11811181    writePSFmt("%%%%Creator: xpdf/pdftops %s\n", xpdfVersion);
    11821182    writePSFmt("%%%%LanguageLevel: %d\n",
    1183                (level == psLevel1 || level == psLevel1Sep) ? 1 :
    1184                (level == psLevel2 || level == psLevel2Sep) ? 2 : 3);
     1183           (level == psLevel1 || level == psLevel1Sep) ? 1 :
     1184           (level == psLevel2 || level == psLevel2Sep) ? 2 : 3);
    11851185    if (level == psLevel1Sep || level == psLevel2Sep || level == psLevel3Sep) {
    11861186      writePS("%%DocumentProcessColors: (atend)\n");
     
    12031203    }
    12041204    writePSFmt("%%%%BoundingBox: %d %d %d %d\n",
    1205                (int)floor(x1), (int)floor(y1), (int)ceil(x2), (int)ceil(y2));
     1205           (int)floor(x1), (int)floor(y1), (int)ceil(x2), (int)ceil(y2));
    12061206    if (floor(x1) != ceil(x1) || floor(y1) != ceil(y1) ||
    1207         floor(x2) != ceil(x2) || floor(y2) != ceil(y2)) {
     1207    floor(x2) != ceil(x2) || floor(y2) != ceil(y2)) {
    12081208      writePSFmt("%%%%HiResBoundingBox: %g %g %g %g\n", x1, y1, x2, y2);
    12091209    }
     
    12151215    writePSFmt("%%%%Creator: xpdf/pdftops %s\n", xpdfVersion);
    12161216    writePSFmt("%%%%LanguageLevel: %d\n",
    1217                (level == psLevel1 || level == psLevel1Sep) ? 1 :
    1218                (level == psLevel2 || level == psLevel2Sep) ? 2 : 3);
     1217           (level == psLevel1 || level == psLevel1Sep) ? 1 :
     1218           (level == psLevel2 || level == psLevel2Sep) ? 2 : 3);
    12191219    if (level == psLevel1Sep || level == psLevel2Sep || level == psLevel3Sep) {
    12201220      writePS("%%DocumentProcessColors: (atend)\n");
     
    12251225    writePS("32 dict dup begin\n");
    12261226    writePSFmt("/BBox [%d %d %d %d] def\n",
    1227                (int)floor(mediaBox->x1), (int)floor(mediaBox->y1),
    1228                (int)ceil(mediaBox->x2), (int)ceil(mediaBox->y2));
     1227           (int)floor(mediaBox->x1), (int)floor(mediaBox->y1),
     1228           (int)ceil(mediaBox->x2), (int)ceil(mediaBox->y2));
    12291229    writePS("/FormType 1 def\n");
    12301230    writePS("/Matrix [1 0 0 1 0 0] def\n");
     
    12441244      lev1 = lev2 = lev3 = sep = nonSep = gFalse;
    12451245      for (q = *p + 1; *q; ++q) {
    1246         switch (*q) {
    1247         case '1': lev1 = gTrue; break;
    1248         case '2': lev2 = gTrue; break;
    1249         case '3': lev3 = gTrue; break;
    1250         case 's': sep = gTrue; break;
    1251         case 'n': nonSep = gTrue; break;
    1252         }
     1246    switch (*q) {
     1247    case '1': lev1 = gTrue; break;
     1248    case '2': lev2 = gTrue; break;
     1249    case '3': lev3 = gTrue; break;
     1250    case 's': sep = gTrue; break;
     1251    case 'n': nonSep = gTrue; break;
     1252    }
    12531253      }
    12541254    } else if ((level == psLevel1 && lev1 && nonSep) ||
    1255                (level == psLevel1Sep && lev1 && sep) ||
    1256                (level == psLevel2 && lev2 && nonSep) ||
    1257                (level == psLevel2Sep && lev2 && sep) ||
    1258                (level == psLevel3 && lev3 && nonSep) ||
    1259                (level == psLevel3Sep && lev3 && sep)) {
     1255           (level == psLevel1Sep && lev1 && sep) ||
     1256           (level == psLevel2 && lev2 && nonSep) ||
     1257           (level == psLevel2Sep && lev2 && sep) ||
     1258           (level == psLevel3 && lev3 && nonSep) ||
     1259           (level == psLevel3Sep && lev3 && sep)) {
    12601260      writePSFmt("%s\n", *p);
    12611261    }
     
    12711271
    12721272void PSOutputDev::writeDocSetup(Catalog *catalog,
    1273                                 int firstPage, int lastPage,
     1273                int firstPage, int lastPage,
    12741274                                GBool duplexA) {
    12751275  Page *page;
     
    12941294    for (i = 0; i < annots->getNumAnnots(); ++i) {
    12951295      if (annots->getAnnot(i)->getAppearance(&obj1)->isStream()) {
    1296         obj1.streamGetDict()->lookup("Resources", &obj2);
    1297         if (obj2.isDict()) {
    1298           setupResources(obj2.getDict());
    1299         }
    1300         obj2.free();
     1296    obj1.streamGetDict()->lookup("Resources", &obj2);
     1297    if (obj2.isDict()) {
     1298      setupResources(obj2.getDict());
     1299    }
     1300    obj2.free();
    13011301      }
    13021302      obj1.free();
     
    13071307    if (mode != psModeEPS && !manualCtrl) {
    13081308      writePSFmt("%d %d %s pdfSetup\n",
    1309                 paperWidth, paperHeight, duplexA ? "true" : "false");
     1309        paperWidth, paperHeight, duplexA ? "true" : "false");
    13101310    }
    13111311#if OPI_SUPPORT
     
    13331333    writePS(embFontList->getCString());
    13341334    if (level == psLevel1Sep || level == psLevel2Sep ||
    1335         level == psLevel3Sep) {
     1335    level == psLevel3Sep) {
    13361336      writePS("%%DocumentProcessColors:");
    13371337      if (processColors & psProcessCyan) {
    1338         writePS(" Cyan");
    1339         }
     1338    writePS(" Cyan");
     1339    }
    13401340      if (processColors & psProcessMagenta) {
    1341         writePS(" Magenta");
     1341    writePS(" Magenta");
    13421342      }
    13431343      if (processColors & psProcessYellow) {
    1344         writePS(" Yellow");
     1344    writePS(" Yellow");
    13451345      }
    13461346      if (processColors & psProcessBlack) {
    1347         writePS(" Black");
     1347    writePS(" Black");
    13481348      }
    13491349      writePS("\n");
    13501350      writePS("%%DocumentCustomColors:");
    13511351      for (cc = customColors; cc; cc = cc->next) {
    1352         writePSFmt(" (%s)", cc->name->getCString());
     1352    writePSFmt(" (%s)", cc->name->getCString());
    13531353      }
    13541354      writePS("\n");
    13551355      writePS("%%CMYKCustomColor:\n");
    13561356      for (cc = customColors; cc; cc = cc->next) {
    1357         writePSFmt("%%%%+ %g %g %g %g (%s)\n",
    1358                    cc->c, cc->m, cc->y, cc->k, cc->name->getCString());
     1357    writePSFmt("%%%%+ %g %g %g %g (%s)\n",
     1358           cc->c, cc->m, cc->y, cc->k, cc->name->getCString());
    13591359      }
    13601360    }
     
    13791379      skip = gFalse;
    13801380      if ((xObjDict.dictGetValNF(i, &xObjRef)->isRef())) {
    1381         ref0 = xObjRef.getRef();
    1382         for (j = 0; j < xobjStack->getLength(); ++j) {
    1383           ref1 = *(Ref *)xobjStack->get(j);
    1384           if (ref1.num == ref0.num && ref1.gen == ref0.gen) {
    1385             skip = gTrue;
    1386             break;
    1387           }
    1388         }
    1389         if (!skip) {
    1390           xobjStack->append(&ref0);
    1391         }
     1381    ref0 = xObjRef.getRef();
     1382    for (j = 0; j < xobjStack->getLength(); ++j) {
     1383      ref1 = *(Ref *)xobjStack->get(j);
     1384      if (ref1.num == ref0.num && ref1.gen == ref0.gen) {
     1385        skip = gTrue;
     1386        break;
     1387      }
     1388    }
     1389    if (!skip) {
     1390      xobjStack->append(&ref0);
     1391    }
    13921392      }
    13931393      if (!skip) {
    13941394
    1395         // process the XObject's resource dictionary
    1396         xObjDict.dictGetVal(i, &xObj);
    1397         if (xObj.isStream()) {
    1398           xObj.streamGetDict()->lookup("Resources", &resObj);
    1399           if (resObj.isDict()) {
    1400             setupResources(resObj.getDict());
    1401           }
    1402           resObj.free();
    1403         }
    1404         xObj.free();
     1395    // process the XObject's resource dictionary
     1396    xObjDict.dictGetVal(i, &xObj);
     1397    if (xObj.isStream()) {
     1398      xObj.streamGetDict()->lookup("Resources", &resObj);
     1399      if (resObj.isDict()) {
     1400        setupResources(resObj.getDict());
     1401      }
     1402      resObj.free();
     1403    }
     1404    xObj.free();
    14051405      }
    14061406
    14071407      if (xObjRef.isRef() && !skip) {
    1408         xobjStack->del(xobjStack->getLength() - 1);
     1408    xobjStack->del(xobjStack->getLength() - 1);
    14091409      }
    14101410      xObjRef.free();
     
    14221422      skip = gFalse;
    14231423      if ((patDict.dictGetValNF(i, &patRef)->isRef())) {
    1424         ref0 = patRef.getRef();
    1425         for (j = 0; j < xobjStack->getLength(); ++j) {
    1426           ref1 = *(Ref *)xobjStack->get(j);
    1427           if (ref1.num == ref0.num && ref1.gen == ref0.gen) {
    1428             skip = gTrue;
    1429             break;
    1430           }
    1431         }
    1432         if (!skip) {
    1433           xobjStack->append(&ref0);
    1434         }
     1424    ref0 = patRef.getRef();
     1425    for (j = 0; j < xobjStack->getLength(); ++j) {
     1426      ref1 = *(Ref *)xobjStack->get(j);
     1427      if (ref1.num == ref0.num && ref1.gen == ref0.gen) {
     1428        skip = gTrue;
     1429        break;
     1430      }
     1431    }
     1432    if (!skip) {
     1433      xobjStack->append(&ref0);
     1434    }
    14351435      }
    14361436      if (!skip) {
    14371437
    1438         // process the Pattern's resource dictionary
    1439         patDict.dictGetVal(i, &pat);
    1440         if (pat.isStream()) {
    1441           pat.streamGetDict()->lookup("Resources", &resObj);
    1442           if (resObj.isDict()) {
    1443             setupResources(resObj.getDict());
    1444           }
    1445           resObj.free();
    1446         }
    1447         pat.free();
     1438    // process the Pattern's resource dictionary
     1439    patDict.dictGetVal(i, &pat);
     1440    if (pat.isStream()) {
     1441      pat.streamGetDict()->lookup("Resources", &resObj);
     1442      if (resObj.isDict()) {
     1443        setupResources(resObj.getDict());
     1444      }
     1445      resObj.free();
     1446    }
     1447    pat.free();
    14481448      }
    14491449
    14501450      if (patRef.isRef() && !skip) {
    1451         xobjStack->del(xobjStack->getLength() - 1);
     1451    xobjStack->del(xobjStack->getLength() - 1);
    14521452      }
    14531453      patRef.free();
     
    14801480    for (i = 0; i < gfxFontDict->getNumFonts(); ++i) {
    14811481      if ((font = gfxFontDict->getFont(i))) {
    1482         setupFont(font, resDict);
     1482    setupFont(font, resDict);
    14831483      }
    14841484    }
     
    15071507  for (i = 0; i < fontIDLen; ++i) {
    15081508    if (fontIDs[i].num == font->getID()->num &&
    1509         fontIDs[i].gen == font->getID()->gen) {
     1509    fontIDs[i].gen == font->getID()->gen) {
    15101510      return;
    15111511    }
     
    15291529  // check for embedded Type 1 font
    15301530  } else if (globalParams->getPSEmbedType1() &&
    1531              font->getType() == fontType1 &&
    1532              font->getEmbeddedFontID(&fontFileID)) {
     1531         font->getType() == fontType1 &&
     1532         font->getEmbeddedFontID(&fontFileID)) {
    15331533    psName = filterPSName(font->getEmbeddedFontName());
    15341534    setupEmbeddedType1Font(&fontFileID, psName);
     
    15361536  // check for embedded Type 1C font
    15371537  } else if (globalParams->getPSEmbedType1() &&
    1538              font->getType() == fontType1C &&
    1539              font->getEmbeddedFontID(&fontFileID)) {
     1538         font->getType() == fontType1C &&
     1539         font->getEmbeddedFontID(&fontFileID)) {
    15401540    psName = filterPSName(font->getEmbeddedFontName());
    15411541    setupEmbeddedType1CFont(font, &fontFileID, psName);
     
    15431543  // check for external Type 1 font file
    15441544  } else if (globalParams->getPSEmbedType1() &&
    1545              font->getType() == fontType1 &&
    1546              font->getExtFontFile()) {
     1545         font->getType() == fontType1 &&
     1546         font->getExtFontFile()) {
    15471547    // this assumes that the PS font name matches the PDF font name
    15481548    psName = font->getName()->copy();
     
    15511551  // check for embedded TrueType font
    15521552  } else if (globalParams->getPSEmbedTrueType() &&
    1553              font->getType() == fontTrueType &&
    1554              font->getEmbeddedFontID(&fontFileID)) {
     1553         font->getType() == fontTrueType &&
     1554         font->getEmbeddedFontID(&fontFileID)) {
    15551555    psName = filterPSName(font->getEmbeddedFontName());
    15561556    setupEmbeddedTrueTypeFont(font, &fontFileID, psName);
     
    15581558  // check for external TrueType font file
    15591559  } else if (globalParams->getPSEmbedTrueType() &&
    1560              font->getType() == fontTrueType &&
    1561              font->getExtFontFile()) {
     1560         font->getType() == fontTrueType &&
     1561         font->getExtFontFile()) {
    15621562    psName = setupExternalTrueTypeFont(font);
    15631563
    15641564  // check for embedded CID PostScript font
    15651565  } else if (globalParams->getPSEmbedCIDPostScript() &&
    1566              font->getType() == fontCIDType0C &&
    1567              font->getEmbeddedFontID(&fontFileID)) {
     1566         font->getType() == fontCIDType0C &&
     1567         font->getEmbeddedFontID(&fontFileID)) {
    15681568    psName = filterPSName(font->getEmbeddedFontName());
    15691569    setupEmbeddedCIDType0Font(font, &fontFileID, psName);
     
    15711571  // check for embedded CID TrueType font
    15721572  } else if (globalParams->getPSEmbedCIDTrueType() &&
    1573              font->getType() == fontCIDType2 &&
    1574              font->getEmbeddedFontID(&fontFileID)) {
     1573         font->getType() == fontCIDType2 &&
     1574         font->getEmbeddedFontID(&fontFileID)) {
    15751575    psName = filterPSName(font->getEmbeddedFontName());
    15761576    setupEmbeddedCIDTrueTypeFont(font, &fontFileID, psName, gTrue);
     
    15781578  } else if (font->getType() == fontType3) {
    15791579    sprintf(type3Name, "T3_%d_%d",
    1580             font->getID()->num, font->getID()->gen);
     1580        font->getID()->num, font->getID()->gen);
    15811581    psName = new GooString(type3Name);
    15821582    setupType3Font(font, psName, parentResDict);
     
    15841584  // check for external CID TrueType font file
    15851585  } else if (globalParams->getPSEmbedCIDTrueType() &&
    1586              font->getType() == fontCIDType2 &&
    1587              font->getExtFontFile()) {
     1586         font->getType() == fontCIDType2 &&
     1587         font->getExtFontFile()) {
    15881588    psName = setupExternalCIDTrueTypeFont(font, font->getExtFontFile());
    15891589
     
    15951595    if (name) {
    15961596      for (i = 0; psFonts[i]; ++i) {
    1597         if (name->cmp(psFonts[i]) == 0) {
    1598           psName = new GooString(psFonts[i]);
    1599           break;
    1600         }
     1597    if (name->cmp(psFonts[i]) == 0) {
     1598      psName = new GooString(psFonts[i]);
     1599      break;
     1600    }
    16011601      }
    16021602    }
    16031603    if (!psName) {
    16041604      if (font->isFixedWidth()) {
    1605         i = 8;
     1605    i = 8;
    16061606      } else if (font->isSerif()) {
    1607         i = 4;
     1607    i = 4;
    16081608      } else {
    1609         i = 0;
     1609    i = 0;
    16101610      }
    16111611      if (font->isBold()) {
    1612         i += 2;
     1612    i += 2;
    16131613      }
    16141614      if (font->isItalic()) {
    1615         i += 1;
     1615    i += 1;
    16161616      }
    16171617      psName = new GooString(psSubstFonts[i].psName);
    16181618      for (code = 0; code < 256; ++code) {
    1619         if ((charName = ((Gfx8BitFont *)font)->getCharName(code)) &&
    1620             charName[0] == 'm' && charName[1] == '\0') {
    1621           break;
    1622         }
     1619    if ((charName = ((Gfx8BitFont *)font)->getCharName(code)) &&
     1620        charName[0] == 'm' && charName[1] == '\0') {
     1621      break;
     1622    }
    16231623      }
    16241624      if (code < 256) {
    1625         w1 = ((Gfx8BitFont *)font)->getWidth(code);
     1625    w1 = ((Gfx8BitFont *)font)->getWidth(code);
    16261626      } else {
    1627         w1 = 0;
     1627    w1 = 0;
    16281628      }
    16291629      w2 = psSubstFonts[i].mWidth;
    16301630      xs = w1 / w2;
    16311631      if (xs < 0.1) {
    1632         xs = 1;
     1632    xs = 1;
    16331633      }
    16341634      if (font->getType() == fontType3) {
    1635         // This is a hack which makes it possible to substitute for some
    1636         // Type 3 fonts.  The problem is that it's impossible to know what
    1637         // the base coordinate system used in the font is without actually
    1638         // rendering the font.
    1639         ys = xs;
    1640         fm = font->getFontMatrix();
    1641         if (fm[0] != 0) {
    1642           ys *= fm[3] / fm[0];
    1643         }
     1635    // This is a hack which makes it possible to substitute for some
     1636    // Type 3 fonts.  The problem is that it's impossible to know what
     1637    // the base coordinate system used in the font is without actually
     1638    // rendering the font.
     1639    ys = xs;
     1640    fm = font->getFontMatrix();
     1641    if (fm[0] != 0) {
     1642      ys *= fm[3] / fm[0];
     1643    }
    16441644      } else {
    1645         ys = 1;
     1645    ys = 1;
    16461646      }
    16471647    }
     
    16491649  // do 16-bit font substitution
    16501650  } else if ((fontParam = globalParams->
    1651                 getPSFont16(font->getName(),
    1652                             ((GfxCIDFont *)font)->getCollection(),
    1653                             font->getWMode()))) {
     1651            getPSFont16(font->getName(),
     1652                ((GfxCIDFont *)font)->getCollection(),
     1653                font->getWMode()))) {
    16541654    subst = gTrue;
    16551655    psName = fontParam->psFontName->copy();
     
    16571657      font16EncSize += 16;
    16581658      font16Enc = (PSFont16Enc *)greallocn(font16Enc,
    1659                                            font16EncSize, sizeof(PSFont16Enc));
     1659                       font16EncSize, sizeof(PSFont16Enc));
    16601660    }
    16611661    font16Enc[font16EncLen].fontID = *font->getID();
     
    16661666    } else {
    16671667      error(-1, "Couldn't find Unicode map for 16-bit font encoding '%s'",
    1668             font16Enc[font16EncLen].enc->getCString());
     1668        font16Enc[font16EncLen].enc->getCString());
    16691669    }
    16701670
    16711671  // try the display font for embedding
    16721672  } else if (globalParams->getPSEmbedCIDTrueType() &&
    1673              ((GfxCIDFont *)font)->getCollection() &&
    1674              (dfp = globalParams->
    1675               getDisplayFont(font)) &&
    1676              dfp->kind == displayFontTT) {
     1673         ((GfxCIDFont *)font)->getCollection() &&
     1674         (dfp = globalParams->
     1675          getDisplayFont(font)) &&
     1676         dfp->kind == displayFontTT) {
    16771677    psName = setupExternalCIDTrueTypeFont(font, dfp->tt.fileName, dfp->tt.faceIndex);
    16781678
     
    16801680  } else {
    16811681    error(-1, "Couldn't find a font to substitute for '%s' ('%s' character collection)",
    1682           font->getName() ? font->getName()->getCString() : "(unnamed)",
    1683           ((GfxCIDFont *)font)->getCollection()
    1684             ? ((GfxCIDFont *)font)->getCollection()->getCString()
    1685             : "(unknown)");
     1682      font->getName() ? font->getName()->getCString() : "(unnamed)",
     1683      ((GfxCIDFont *)font)->getCollection()
     1684        ? ((GfxCIDFont *)font)->getCollection()->getCString()
     1685        : "(unknown)");
    16861686    return;
    16871687  }
     
    16911691    if (level == psLevel3 || level == psLevel3Sep) {
    16921692      writePSFmt("/F%d_%d /%s %d pdfMakeFont16L3\n",
    1693                 font->getID()->num, font->getID()->gen, psName->getCString(),
    1694                 font->getWMode());
     1693        font->getID()->num, font->getID()->gen, psName->getCString(),
     1694        font->getWMode());
    16951695    } else {
    16961696      writePSFmt("/F%d_%d /%s %d pdfMakeFont16\n",
    1697                 font->getID()->num, font->getID()->gen, psName->getCString(),
    1698                 font->getWMode());
     1697        font->getID()->num, font->getID()->gen, psName->getCString(),
     1698        font->getWMode());
    16991699    }
    17001700  } else {
    17011701    writePSFmt("/F%d_%d /%s %g %g\n",
    1702                font->getID()->num, font->getID()->gen, psName->getCString(),
    1703                xs, ys);
     1702           font->getID()->num, font->getID()->gen, psName->getCString(),
     1703           xs, ys);
    17041704    for (i = 0; i < 256; i += 8) {
    17051705      writePSFmt((i == 0) ? "[ " : "  ");
    17061706      for (j = 0; j < 8; ++j) {
    1707         if (font->getType() == fontTrueType &&
    1708             !subst &&
    1709             !((Gfx8BitFont *)font)->getHasEncoding()) {
    1710           sprintf(buf, "c%02x", i+j);
    1711           charName = buf;
    1712         } else {
    1713           charName = ((Gfx8BitFont *)font)->getCharName(i+j);
    1714           // this is a kludge for broken PDF files that encode char 32
    1715           // as .notdef
    1716           if (i+j == 32 && charName && !strcmp(charName, ".notdef")) {
    1717             charName = "space";
    1718           }
    1719         }
    1720         writePS("/");
    1721         writePSName(charName ? charName : (char *)".notdef");
    1722         // the empty name is legal in PDF and PostScript, but PostScript
    1723         // uses a double-slash (//...) for "immediately evaluated names",
    1724         // so we need to add a space character here
    1725         if (charName && !charName[0]) {
    1726           writePS(" ");
    1727         }
     1707    if (font->getType() == fontTrueType &&
     1708        !subst &&
     1709        !((Gfx8BitFont *)font)->getHasEncoding()) {
     1710      sprintf(buf, "c%02x", i+j);
     1711      charName = buf;
     1712    } else {
     1713      charName = ((Gfx8BitFont *)font)->getCharName(i+j);
     1714      // this is a kludge for broken PDF files that encode char 32
     1715      // as .notdef
     1716      if (i+j == 32 && charName && !strcmp(charName, ".notdef")) {
     1717        charName = "space";
     1718      }
     1719    }
     1720    writePS("/");
     1721    writePSName(charName ? charName : (char *)".notdef");
     1722    // the empty name is legal in PDF and PostScript, but PostScript
     1723    // uses a double-slash (//...) for "immediately evaluated names",
     1724    // so we need to add a space character here
     1725    if (charName && !charName[0]) {
     1726      writePS(" ");
     1727    }
    17281728      }
    17291729      writePS((i == 256-8) ? (char *)"]\n" : (char *)"\n");
     
    17481748  for (i = 0; i < fontFileIDLen; ++i) {
    17491749    if (fontFileIDs[i].num == id->num &&
    1750         fontFileIDs[i].gen == id->gen)
     1750    fontFileIDs[i].gen == id->gen)
    17511751      return;
    17521752  }
     
    18091809    }
    18101810    if (!((start[i] >= '0' && start[i] <= '9') ||
    1811           (start[i] >= 'A' && start[i] <= 'F') ||
    1812           (start[i] >= 'a' && start[i] <= 'f')))
     1811      (start[i] >= 'A' && start[i] <= 'F') ||
     1812      (start[i] >= 'a' && start[i] <= 'f')))
    18131813      binMode = gTrue;
    18141814  }
     
    18271827    while (i < length2) {
    18281828      if ((c = strObj.streamGetChar()) == EOF) {
    1829         break;
     1829    break;
    18301830      }
    18311831      writePSChar(hexChar[(c >> 4) & 0x0f]);
    18321832      writePSChar(hexChar[c & 0x0f]);
    18331833      if (++i % 32 == 0) {
    1834         writePSChar('\n');
     1834    writePSChar('\n');
    18351835      }
    18361836    }
     
    18461846    for (i = 4; i < length2; ++i) {
    18471847      if ((c = strObj.streamGetChar()) == EOF) {
    1848         break;
     1848    break;
    18491849      }
    18501850      writePSChar(c);
     
    18551855  for (i = 0; i < 8; ++i) {
    18561856    writePS("00000000000000000000000000000000"
    1857             "00000000000000000000000000000000\n");
     1857        "00000000000000000000000000000000\n");
    18581858  }
    18591859  writePS("cleartomark\n");
     
    18851885    fontFileNameSize += 64;
    18861886    fontFileNames = (GooString **)greallocn(fontFileNames,
    1887                                           fontFileNameSize, sizeof(GooString *));
     1887                      fontFileNameSize, sizeof(GooString *));
    18881888    psFileNames = (GooString **)greallocn(psFileNames,
    1889                                        fontFileNameSize, sizeof(GooString *));
     1889                       fontFileNameSize, sizeof(GooString *));
    18901890  }
    18911891  fontFileNames[fontFileNameLen] = fileName->copy();
     
    19141914
    19151915void PSOutputDev::setupEmbeddedType1CFont(GfxFont *font, Ref *id,
    1916                                           GooString *psName) {
     1916                      GooString *psName) {
    19171917  char *fontBuf;
    19181918  int fontLen;
     
    19231923  for (i = 0; i < fontFileIDLen; ++i) {
    19241924    if (fontFileIDs[i].num == id->num &&
    1925         fontFileIDs[i].gen == id->gen)
     1925    fontFileIDs[i].gen == id->gen)
    19261926      return;
    19271927  }
     
    19531953
    19541954void PSOutputDev::setupEmbeddedTrueTypeFont(GfxFont *font, Ref *id,
    1955                                             GooString *psName) {
     1955                        GooString *psName) {
    19561956  char unique[32];
    19571957  char *fontBuf;
     
    19641964  for (i = 0; i < fontFileIDLen; ++i) {
    19651965    if (fontFileIDs[i].num == id->num &&
    1966         fontFileIDs[i].gen == id->gen) {
     1966    fontFileIDs[i].gen == id->gen) {
    19671967      sprintf(unique, "_%d", nextTrueTypeNum++);
    19681968      psName->append(unique);
     
    19911991    codeToGID = ((Gfx8BitFont *)font)->getCodeToGIDMap(ffTT);
    19921992    ffTT->convertToType42(psName->getCString(),
    1993                           ((Gfx8BitFont *)font)->getHasEncoding()
    1994                             ? ((Gfx8BitFont *)font)->getEncoding()
    1995                             : (char **)NULL,
    1996                           codeToGID, outputFunc, outputStream);
     1993              ((Gfx8BitFont *)font)->getHasEncoding()
     1994                ? ((Gfx8BitFont *)font)->getEncoding()
     1995                : (char **)NULL,
     1996              codeToGID, outputFunc, outputStream);
    19971997    gfree(codeToGID);
    19981998    delete ffTT;
     
    20272027      fontFileNameSize += 64;
    20282028      fontFileNames =
    2029         (GooString **)greallocn(fontFileNames,
    2030                               fontFileNameSize, sizeof(GooString *));
     2029    (GooString **)greallocn(fontFileNames,
     2030                  fontFileNameSize, sizeof(GooString *));
    20312031      psFileNames =
    2032         (GooString **)greallocn(psFileNames,
    2033                              fontFileNameSize, sizeof(GooString *));
     2032    (GooString **)greallocn(psFileNames,
     2033                 fontFileNameSize, sizeof(GooString *));
    20342034    }
    20352035  }
     
    20492049    codeToGID = ((Gfx8BitFont *)font)->getCodeToGIDMap(ffTT);
    20502050    ffTT->convertToType42(psName->getCString(),
    2051                           ((Gfx8BitFont *)font)->getHasEncoding()
    2052                             ? ((Gfx8BitFont *)font)->getEncoding()
    2053                             : (char **)NULL,
    2054                           codeToGID, outputFunc, outputStream);
     2051              ((Gfx8BitFont *)font)->getHasEncoding()
     2052                ? ((Gfx8BitFont *)font)->getEncoding()
     2053                : (char **)NULL,
     2054              codeToGID, outputFunc, outputStream);
    20552055    delete ffTT;
    20562056  }
     
    20912091      fontFileNameSize += 64;
    20922092      fontFileNames =
    2093         (GooString **)grealloc(fontFileNames,
    2094                              fontFileNameSize * sizeof(GooString *));
     2093    (GooString **)grealloc(fontFileNames,
     2094                 fontFileNameSize * sizeof(GooString *));
    20952095      psFileNames =
    2096         (GooString **)grealloc(psFileNames,
    2097                              fontFileNameSize * sizeof(GooString *));
     2096    (GooString **)grealloc(psFileNames,
     2097                 fontFileNameSize * sizeof(GooString *));
    20982098    }
    20992099  }
     
    21122112      int n = ((GfxCIDFont *)font)->getCIDToGIDLen();
    21132113      if (n) {
    2114         codeToGID = (Gushort *)gmalloc(n * sizeof(Gushort));
    2115         memcpy(codeToGID, ((GfxCIDFont *)font)->getCIDToGID(), n * sizeof(Gushort));
     2114    codeToGID = (Gushort *)gmalloc(n * sizeof(Gushort));
     2115    memcpy(codeToGID, ((GfxCIDFont *)font)->getCIDToGID(), n * sizeof(Gushort));
    21162116      } else {
    2117         codeToGID = ((GfxCIDFont *)font)->getCodeToGIDMap(ffTT, &n);
     2117    codeToGID = ((GfxCIDFont *)font)->getCodeToGIDMap(ffTT, &n);
    21182118      }
    21192119      if (globalParams->getPSLevel() >= psLevel3) {
    2120         // Level 3: use a CID font
    2121         ffTT->convertToCIDType2(psName->getCString(),
    2122                                 codeToGID, n, gTrue,
    2123                                 outputFunc, outputStream);
     2120    // Level 3: use a CID font
     2121    ffTT->convertToCIDType2(psName->getCString(),
     2122                codeToGID, n, gTrue,
     2123                outputFunc, outputStream);
    21242124      } else {
    2125         // otherwise: use a non-CID composite font
    2126         ffTT->convertToType0(psName->getCString(),
    2127                              codeToGID, n, gTrue,
    2128                              outputFunc, outputStream);
     2125    // otherwise: use a non-CID composite font
     2126    ffTT->convertToType0(psName->getCString(),
     2127                 codeToGID, n, gTrue,
     2128                 outputFunc, outputStream);
    21292129      }
    21302130      gfree(codeToGID);
     
    21382138
    21392139void PSOutputDev::setupEmbeddedCIDType0Font(GfxFont *font, Ref *id,
    2140                                             GooString *psName) {
     2140                        GooString *psName) {
    21412141  char *fontBuf;
    21422142  int fontLen;
     
    21472147  for (i = 0; i < fontFileIDLen; ++i) {
    21482148    if (fontFileIDs[i].num == id->num &&
    2149         fontFileIDs[i].gen == id->gen)
     2149    fontFileIDs[i].gen == id->gen)
    21502150      return;
    21512151  }
     
    21832183
    21842184void PSOutputDev::setupEmbeddedCIDTrueTypeFont(GfxFont *font, Ref *id,
    2185                                                GooString *psName,
    2186                                                GBool needVerticalMetrics) {
     2185                           GooString *psName,
     2186                           GBool needVerticalMetrics) {
    21872187  char unique[32];
    21882188  char *fontBuf;
     
    21942194  for (i = 0; i < fontFileIDLen; ++i) {
    21952195    if (fontFileIDs[i].num == id->num &&
    2196         fontFileIDs[i].gen == id->gen) {
     2196    fontFileIDs[i].gen == id->gen) {
    21972197      sprintf(unique, "_%d", nextTrueTypeNum++);
    21982198      psName->append(unique);
     
    22202220      // Level 3: use a CID font
    22212221      ffTT->convertToCIDType2(psName->getCString(),
    2222                               ((GfxCIDFont *)font)->getCIDToGID(),
    2223                               ((GfxCIDFont *)font)->getCIDToGIDLen(),
    2224                               needVerticalMetrics,
    2225                               outputFunc, outputStream);
     2222                  ((GfxCIDFont *)font)->getCIDToGID(),
     2223                  ((GfxCIDFont *)font)->getCIDToGIDLen(),
     2224                  needVerticalMetrics,
     2225                  outputFunc, outputStream);
    22262226    } else {
    22272227      // otherwise: use a non-CID composite font
    22282228      ffTT->convertToType0(psName->getCString(),
    2229                            ((GfxCIDFont *)font)->getCIDToGID(),
    2230                            ((GfxCIDFont *)font)->getCIDToGIDLen(),
    2231                            needVerticalMetrics,
    2232                            outputFunc, outputStream);
     2229               ((GfxCIDFont *)font)->getCIDToGID(),
     2230               ((GfxCIDFont *)font)->getCIDToGIDLen(),
     2231               needVerticalMetrics,
     2232               outputFunc, outputStream);
    22332233    }
    22342234    delete ffTT;
     
    22412241
    22422242void PSOutputDev::setupType3Font(GfxFont *font, GooString *psName,
    2243                                 Dict *parentResDict) {
     2243                Dict *parentResDict) {
    22442244  Dict *resDict;
    22452245  Dict *charProcs;
     
    22712271  m = font->getFontMatrix();
    22722272  writePSFmt("/FontMatrix [%g %g %g %g %g %g] def\n",
    2273              m[0], m[1], m[2], m[3], m[4], m[5]);
     2273         m[0], m[1], m[2], m[3], m[4], m[5]);
    22742274  m = font->getFontBBox();
    22752275  writePSFmt("/FontBBox [%g %g %g %g] def\n",
    2276              m[0], m[1], m[2], m[3]);
     2276         m[0], m[1], m[2], m[3]);
    22772277  writePS("/Encoding 256 array def\n");
    22782278  writePS("  0 1 255 { Encoding exch /.notdef put } for\n");
     
    23052305      charProc.free();
    23062306      if (t3String) {
    2307         if (t3Cacheable) {
    2308           sprintf(buf, "%g %g %g %g %g %g setcachedevice\n",
    2309                   t3WX, t3WY, t3LLX, t3LLY, t3URX, t3URY);
    2310         } else {
    2311           sprintf(buf, "%g %g setcharwidth\n", t3WX, t3WY);
    2312         }
    2313         (*outputFunc)(outputStream, buf, strlen(buf));
    2314         (*outputFunc)(outputStream, t3String->getCString(),
    2315                       t3String->getLength());
    2316         delete t3String;
    2317         t3String = NULL;
     2307    if (t3Cacheable) {
     2308      sprintf(buf, "%g %g %g %g %g %g setcachedevice\n",
     2309          t3WX, t3WY, t3LLX, t3LLY, t3URX, t3URY);
     2310    } else {
     2311      sprintf(buf, "%g %g setcharwidth\n", t3WX, t3WY);
     2312    }
     2313    (*outputFunc)(outputStream, buf, strlen(buf));
     2314    (*outputFunc)(outputStream, t3String->getCString(),
     2315              t3String->getLength());
     2316    delete t3String;
     2317    t3String = NULL;
    23182318      }
    23192319      (*outputFunc)(outputStream, "Q\n", 2);
     
    23462346      xObjDict.dictGetVal(i, &xObj);
    23472347      if (xObj.isStream()) {
    2348         xObj.streamGetDict()->lookup("Subtype", &subtypeObj);
    2349         if (subtypeObj.isName("Image")) {
    2350           if (xObjRef.isRef()) {
    2351             setupImage(xObjRef.getRef(), xObj.getStream());
    2352           } else {
    2353             error(-1, "Image in resource dict is not an indirect reference");
    2354           }
    2355         }
    2356         subtypeObj.free();
     2348    xObj.streamGetDict()->lookup("Subtype", &subtypeObj);
     2349    if (subtypeObj.isName("Image")) {
     2350      if (xObjRef.isRef()) {
     2351        setupImage(xObjRef.getRef(), xObj.getStream());
     2352      } else {
     2353        error(-1, "Image in resource dict is not an indirect reference");
     2354      }
     2355    }
     2356    subtypeObj.free();
    23572357      }
    23582358      xObj.free();
     
    23922392      ++col;
    23932393      for (i = 1; i <= (useASCIIHex ? 1 : 4); ++i) {
    2394         do {
    2395           c = str->getChar();
    2396         } while (c == '\n' || c == '\r');
    2397         if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
    2398           break;
    2399         }
    2400         ++col;
     2394    do {
     2395      c = str->getChar();
     2396    } while (c == '\n' || c == '\r');
     2397    if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
     2398      break;
     2399    }
     2400    ++col;
    24012401      }
    24022402    }
     
    24282428      ++col;
    24292429      for (i = 1; i <= (useASCIIHex ? 1 : 4); ++i) {
    2430         do {
    2431           c = str->getChar();
    2432         } while (c == '\n' || c == '\r');
    2433         if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
    2434           break;
    2435         }
    2436         writePSChar(c);
    2437         ++col;
     2430    do {
     2431      c = str->getChar();
     2432    } while (c == '\n' || c == '\r');
     2433    if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
     2434      break;
     2435    }
     2436    writePSChar(c);
     2437    ++col;
    24382438      }
    24392439    }
     
    24962496      if (rotate == 0 || rotate == 180) {
    24972497    if (width > height && width > imgWidth) {
    2498           rotate += 90;
    2499           landscape = gTrue;
    2500         } else {
    2501           landscape = gFalse;
    2502         }
     2498      rotate += 90;
     2499      landscape = gTrue;
     2500    } else {
     2501      landscape = gFalse;
     2502    }
    25032503      } else { // rotate == 90 || rotate == 270
    2504         if (height > width && height > imgWidth) {
    2505           rotate = 270 - rotate;
    2506           landscape = gTrue;
    2507         } else {
    2508           landscape = gFalse;
    2509         }
     2504    if (height > width && height > imgWidth) {
     2505      rotate = 270 - rotate;
     2506      landscape = gTrue;
     2507    } else {
     2508      landscape = gFalse;
     2509    }
    25102510      }
    25112511    }
    25122512      writePSFmt("%%%%PageOrientation: %s\n",
    2513                landscape ? "Landscape" : "Portrait");
     2513           landscape ? "Landscape" : "Portrait");
    25142514      writePS("pdfStartPage\n");
    25152515    if (rotate == 0) {
     
    25382538      yScale = yScale0;
    25392539    } else if ((globalParams->getPSShrinkLarger() &&
    2540         (width > imgWidth2 || height > imgHeight2)) ||
    2541         (globalParams->getPSExpandSmaller() &&
    2542         (width < imgWidth2 && height < imgHeight2))) {
     2540    (width > imgWidth2 || height > imgHeight2)) ||
     2541    (globalParams->getPSExpandSmaller() &&
     2542    (width < imgWidth2 && height < imgHeight2))) {
    25432543      xScale = (double)imgWidth2 / (double)width;
    25442544      yScale = (double)imgHeight2 / (double)height;
    25452545      if (yScale < xScale) {
    2546         xScale = yScale;
     2546    xScale = yScale;
    25472547      } else {
    2548         yScale = xScale;
     2548    yScale = xScale;
    25492549      }
    25502550    } else {
     
    25622562    if (globalParams->getPSCenter()) {
    25632563      if (clipLLX0 < clipURX0 && clipLLY0 < clipURY0) {
    2564         tx += (imgWidth2 - xScale * (clipURX0 - clipLLX0)) / 2;
    2565         ty += (imgHeight2 - yScale * (clipURY0 - clipLLY0)) / 2;
     2564    tx += (imgWidth2 - xScale * (clipURX0 - clipLLX0)) / 2;
     2565    ty += (imgHeight2 - yScale * (clipURY0 - clipLLY0)) / 2;
    25662566      } else {
    25672567      tx += (imgWidth2 - xScale * width) / 2;
     
    25792579    if (clipLLX0 < clipURX0 && clipLLY0 < clipURY0) {
    25802580      writePSFmt("%g %g %g %g re W\n",
    2581                 clipLLX0, clipLLY0, clipURX0 - clipLLX0, clipURY0 - clipLLY0);
     2581        clipLLX0, clipLLY0, clipURX0 - clipLLX0, clipURY0 - clipLLY0);
    25822582    } else {
    25832583      writePSFmt("%d %d %d %d re W\n", x1, y1, x2 - x1, y2 - y1);
     
    26552655
    26562656void PSOutputDev::updateCTM(GfxState *state, double m11, double m12,
    2657                             double m21, double m22, double m31, double m32) {
     2657                double m21, double m22, double m31, double m32) {
    26582658  writePSFmt("[%g %g %g %g %g %g] cm\n", m11, m12, m21, m22, m31, m32);
    26592659}
     
    26682668  for (i = 0; i < length; ++i) {
    26692669    writePSFmt("%g%s",
    2670                dash[i] == 0 ? 1 : dash[i],
    2671                (i == length-1) ? "" : " ");
     2670           dash[i] == 0 ? 1 : dash[i],
     2671           (i == length-1) ? "" : " ");
    26722672  }
    26732673  writePSFmt("] %g d\n", start);
     
    27592759      writePS("[");
    27602760      for (i = 0; i < state->getFillColorSpace()->getNComps(); ++i) {
    2761         if (i > 0) {
    2762           writePS(" ");
    2763       }
    2764         writePSFmt("%g", colToDbl(colorPtr->c[i]));
     2761    if (i > 0) {
     2762      writePS(" ");
     2763      }
     2764    writePSFmt("%g", colToDbl(colorPtr->c[i]));
    27652765      }
    27662766      writePS("] sc\n");
     
    27742774      sepCS->getCMYK(&color, &cmyk);
    27752775      writePSFmt("%g %g %g %g %g (%s) ck\n",
    2776                 colToDbl(state->getFillColor()->c[0]),
    2777                 colToDbl(cmyk.c), colToDbl(cmyk.m),
    2778                 colToDbl(cmyk.y), colToDbl(cmyk.k),
    2779                 sepCS->getName()->getCString());
     2776        colToDbl(state->getFillColor()->c[0]),
     2777        colToDbl(cmyk.c), colToDbl(cmyk.m),
     2778        colToDbl(cmyk.y), colToDbl(cmyk.k),
     2779        sepCS->getName()->getCString());
    27802780      addCustomColor(sepCS);
    27812781    } else {
     
    28222822      writePS("[");
    28232823      for (i = 0; i < state->getStrokeColorSpace()->getNComps(); ++i) {
    2824         if (i > 0) {
    2825           writePS(" ");
    2826       }
    2827         writePSFmt("%g", colToDbl(colorPtr->c[i]));
     2824    if (i > 0) {
     2825      writePS(" ");
     2826      }
     2827    writePSFmt("%g", colToDbl(colorPtr->c[i]));
    28282828      }
    28292829      writePS("] SC\n");
     
    28372837      sepCS->getCMYK(&color, &cmyk);
    28382838      writePSFmt("%g %g %g %g %g (%s) CK\n",
    2839                 colToDbl(state->getStrokeColor()->c[0]),
    2840                 colToDbl(cmyk.c), colToDbl(cmyk.m),
    2841                 colToDbl(cmyk.y), colToDbl(cmyk.k),
    2842                 sepCS->getName()->getCString());
     2839        colToDbl(state->getStrokeColor()->c[0]),
     2840        colToDbl(cmyk.c), colToDbl(cmyk.m),
     2841        colToDbl(cmyk.y), colToDbl(cmyk.k),
     2842        sepCS->getName()->getCString());
    28432843      addCustomColor(sepCS);
    28442844    } else {
     
    28842884  sepCS->getCMYK(&color, &cmyk);
    28852885  cc = new PSOutCustomColor(colToDbl(cmyk.c), colToDbl(cmyk.m),
    2886                             colToDbl(cmyk.y), colToDbl(cmyk.k),
    2887                             sepCS->getName()->copy());
     2886                colToDbl(cmyk.y), colToDbl(cmyk.k),
     2887                sepCS->getName()->copy());
    28882888  cc->next = customColors;
    28892889  customColors = cc;
     
    29052905  if (state->getFont()) {
    29062906    writePSFmt("/F%d_%d %g Tf\n",
    2907                state->getFont()->getID()->num, state->getFont()->getID()->gen,
    2908                fabs(state->getFontSize()) < 0.00001 ? 0.00001
    2909                                                     : state->getFontSize());
     2907           state->getFont()->getID()->num, state->getFont()->getID()->gen,
     2908           fabs(state->getFontSize()) < 0.00001 ? 0.00001
     2909                                                : state->getFontSize());
    29102910  }
    29112911}
     
    29202920  } else {
    29212921  writePSFmt("[%g %g %g %g %g %g] Tm\n",
    2922              mat[0], mat[1], mat[2], mat[3], mat[4], mat[5]);
     2922         mat[0], mat[1], mat[2], mat[3], mat[4], mat[5]);
    29232923  }
    29242924}
     
    29912991
    29922992void PSOutputDev::tilingPatternFill(GfxState *state, Object *str,
    2993                                     int paintType, Dict *resDict,
    2994                                     double *mat, double *bbox,
    2995                                     int x0, int y0, int x1, int y1,
    2996                                     double xStep, double yStep) {
     2993                    int paintType, Dict *resDict,
     2994                    double *mat, double *bbox,
     2995                    int x0, int y0, int x1, int y1,
     2996                    double xStep, double yStep) {
    29972997  PDFRectangle box;
    29982998  Gfx *gfx;
     
    30033003  writePS("/FontMatrix [1 0 0 1 0 0] def\n");
    30043004  writePSFmt("/FontBBox [%g %g %g %g] def\n",
    3005              bbox[0], bbox[1], bbox[2], bbox[3]);
     3005         bbox[0], bbox[1], bbox[2], bbox[3]);
    30063006  writePS("/Encoding 256 array def\n");
    30073007  writePS("  0 1 255 { Encoding exch /.notdef put } for\n");
     
    30263026  if (paintType == 2) {
    30273027    writePSFmt("%g 0 %g %g %g %g setcachedevice\n",
    3028                xStep, bbox[0], bbox[1], bbox[2], bbox[3]);
     3028           xStep, bbox[0], bbox[1], bbox[2], bbox[3]);
    30293029  } else {
    30303030    writePSFmt("%g 0 setcharwidth\n", xStep);
     
    30443044  writePSFmt("/xpdfTile%d findfont setfont\n", numTilingPatterns);
    30453045  writePSFmt("gsave [%g %g %g %g %g %g] concat\n",
    3046              mat[0], mat[1], mat[2], mat[3], mat[4], mat[5]);
     3046         mat[0], mat[1], mat[2], mat[3], mat[4], mat[5]);
    30473047  writePSFmt("%d 1 %d { %g exch %g mul m %d 1 %d { pop (x) show } for } for\n",
    3048              y0, y1 - 1, x0 * xStep, yStep, x0, x1 - 1);
     3048         y0, y1 - 1, x0 * xStep, yStep, x0, x1 - 1);
    30493049  writePS("grestore\n");
    30503050}
    30513051
    30523052void PSOutputDev::functionShadedFill(GfxState *state,
    3053                                      GfxFunctionShading *shading) {
     3053                     GfxFunctionShading *shading) {
    30543054  double x0, y0, x1, y1;
    30553055  double *mat;
     
    30593059  mat = shading->getMatrix();
    30603060  writePSFmt("/mat [%g %g %g %g %g %g] def\n",
    3061              mat[0], mat[1], mat[2], mat[3], mat[4], mat[5]);
     3061         mat[0], mat[1], mat[2], mat[3], mat[4], mat[5]);
    30623062  writePSFmt("/n %d def\n", shading->getColorSpace()->getNComps());
    30633063  if (shading->getNFuncs() == 1) {
     
    30693069    for (i = 0; i < shading->getNFuncs(); ++i) {
    30703070      if (i < shading->getNFuncs() - 1) {
    3071         writePS("2 copy\n");
     3071    writePS("2 copy\n");
    30723072      }
    30733073      cvtFunction(shading->getFunc(i));
    30743074      writePS("exec\n");
    30753075      if (i < shading->getNFuncs() - 1) {
    3076         writePS("3 1 roll\n");
     3076    writePS("3 1 roll\n");
    30773077      }
    30783078    }
     
    31503150    for (i = 0; i < shading->getNFuncs(); ++i) {
    31513151      if (i < shading->getNFuncs() - 1) {
    3152         writePS("dup\n");
     3152    writePS("dup\n");
    31533153      }
    31543154      cvtFunction(shading->getFunc(i));
    31553155      writePS("exec\n");
    31563156      if (i < shading->getNFuncs() - 1) {
    3157         writePS("exch\n");
     3157    writePS("exch\n");
    31583158      }
    31593159    }
     
    31643164
    31653165void PSOutputDev::radialShadedFill(GfxState *state,
    3166                                    GfxRadialShading *shading) {
     3166                   GfxRadialShading *shading) {
    31673167  double x0, y0, r0, x1, y1, r1, t0, t1, sMin, sMax;
    31683168  double xMin, yMin, xMax, yMax;
     
    31933193      sMin = (sqrt(sMin) - r0) / (r1 - r0);
    31943194      if (sMin > 0) {
    3195         sMin = 0;
     3195    sMin = 0;
    31963196      } else if (sMin < -20) {
    3197         // sanity check
    3198         sMin = -20;
     3197    // sanity check
     3198    sMin = -20;
    31993199      }
    32003200    }
     
    32153215      sMax = (sqrt(sMax) - r0) / (r1 - r0);
    32163216      if (sMax < 1) {
    3217         sMax = 1;
     3217    sMax = 1;
    32183218      } else if (sMax > 20) {
    3219         // sanity check
    3220         sMax = 20;
     3219    // sanity check
     3220    sMax = 20;
    32213221      }
    32223222    }
     
    32453245    for (i = 0; i < shading->getNFuncs(); ++i) {
    32463246      if (i < shading->getNFuncs() - 1) {
    3247         writePS("dup\n");
     3247    writePS("dup\n");
    32483248      }
    32493249      cvtFunction(shading->getFunc(i));
    32503250      writePS("exec\n");
    32513251      if (i < shading->getNFuncs() - 1) {
    3252         writePS("exch\n");
     3252    writePS("exch\n");
    32533253      }
    32543254    }
     
    32893289      y3 = subpath->getY(3);
    32903290      if (x0 == x1 && x2 == x3 && y0 == y3 && y1 == y2) {
    3291         writePSFmt("%g %g %g %g re\n",
    3292                    x0 < x2 ? x0 : x2, y0 < y1 ? y0 : y1,
    3293                    fabs(x2 - x0), fabs(y1 - y0));
    3294         return;
     3291    writePSFmt("%g %g %g %g re\n",
     3292           x0 < x2 ? x0 : x2, y0 < y1 ? y0 : y1,
     3293           fabs(x2 - x0), fabs(y1 - y0));
     3294    return;
    32953295      } else if (x0 == x3 && x1 == x2 && y0 == y1 && y2 == y3) {
    3296         writePSFmt("%g %g %g %g re\n",
    3297                    x0 < x1 ? x0 : x1, y0 < y2 ? y0 : y2,
    3298                    fabs(x1 - x0), fabs(y2 - y0));
    3299         return;
     3296    writePSFmt("%g %g %g %g re\n",
     3297           x0 < x1 ? x0 : x1, y0 < y2 ? y0 : y2,
     3298           fabs(x1 - x0), fabs(y2 - y0));
     3299    return;
    33003300      }
    33013301    }
     
    33093309    while (j < m) {
    33103310      if (subpath->getCurve(j)) {
    3311         writePSFmt("%g %g %g %g %g %g c\n", subpath->getX(j), subpath->getY(j),
    3312                    subpath->getX(j+1), subpath->getY(j+1),
    3313                    subpath->getX(j+2), subpath->getY(j+2));
    3314         j += 3;
     3311    writePSFmt("%g %g %g %g %g %g c\n", subpath->getX(j), subpath->getY(j),
     3312           subpath->getX(j+1), subpath->getY(j+1),
     3313           subpath->getX(j+2), subpath->getY(j+2));
     3314    j += 3;
    33153315      } else {
    3316         writePSFmt("%g %g l\n", subpath->getX(j), subpath->getY(j));
    3317         ++j;
     3316    writePSFmt("%g %g l\n", subpath->getX(j), subpath->getY(j));
     3317    ++j;
    33183318      }
    33193319    }
     
    33573357    for (i = 0; i < font16EncLen; ++i) {
    33583358      if (font->getID()->num == font16Enc[i].fontID.num &&
    3359           font->getID()->gen == font16Enc[i].fontID.gen) {
    3360         uMap = globalParams->getUnicodeMap(font16Enc[i].enc);
    3361         break;
     3359      font->getID()->gen == font16Enc[i].fontID.gen) {
     3360    uMap = globalParams->getUnicodeMap(font16Enc[i].enc);
     3361    break;
    33623362      }
    33633363    }
     
    33783378  while (len > 0) {
    33793379    n = font->getNextChar(p, len, &code,
    3380                           u, (int)(sizeof(u) / sizeof(Unicode)), &uLen,
    3381                           &dx2, &dy2, &originX, &originY);
     3380              u, (int)(sizeof(u) / sizeof(Unicode)), &uLen,
     3381              &dx2, &dy2, &originX, &originY);
    33823382    if (font->isCIDFont()) {
    33833383      if (uMap) {
    3384         for (i = 0; i < uLen; ++i) {
    3385           m = uMap->mapUnicode(u[i], buf, (int)sizeof(buf));
    3386           for (j = 0; j < m; ++j) {
    3387             s2->append(buf[j]);
    3388           }
    3389         }
    3390         //~ this really needs to get the number of chars in the target
    3391         //~ encoding - which may be more than the number of Unicode
    3392         //~ chars
    3393         nChars += uLen;
     3384    for (i = 0; i < uLen; ++i) {
     3385      m = uMap->mapUnicode(u[i], buf, (int)sizeof(buf));
     3386      for (j = 0; j < m; ++j) {
     3387        s2->append(buf[j]);
     3388      }
     3389    }
     3390    //~ this really needs to get the number of chars in the target
     3391    //~ encoding - which may be more than the number of Unicode
     3392    //~ chars
     3393    nChars += uLen;
    33943394      } else {
    3395         s2->append((char)((code >> 8) & 0xff));
    3396         s2->append((char)(code & 0xff));
    3397         ++nChars;
     3395    s2->append((char)((code >> 8) & 0xff));
     3396    s2->append((char)(code & 0xff));
     3397    ++nChars;
    33983398      }
    33993399    }
     
    34133413    if (font->isCIDFont()) {
    34143414      if (wMode) {
    3415         writePSFmt(" %d %g Tj16V\n", nChars, dy);
     3415    writePSFmt(" %d %g Tj16V\n", nChars, dy);
    34163416      } else {
    3417         writePSFmt(" %d %g Tj16\n", nChars, dx);
     3417    writePSFmt(" %d %g Tj16\n", nChars, dx);
    34183418      }
    34193419    } else {
     
    34383438
    34393439void PSOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str,
    3440                                 int width, int height, GBool invert,
    3441                                 GBool inlineImg) {
     3440                int width, int height, GBool invert,
     3441                GBool inlineImg) {
    34423442  int len;
    34433443
     
    34473447  } else {
    34483448    doImageL2(ref, NULL, invert, inlineImg, str, width, height, len,
    3449               NULL, NULL, 0, 0, gFalse);
     3449          NULL, NULL, 0, 0, gFalse);
    34503450  }
    34513451}
    34523452
    34533453void PSOutputDev::drawImage(GfxState *state, Object *ref, Stream *str,
    3454                             int width, int height, GfxImageColorMap *colorMap,
    3455                             int *maskColors, GBool inlineImg) {
     3454                int width, int height, GfxImageColorMap *colorMap,
     3455                int *maskColors, GBool inlineImg) {
    34563456  int len;
    34573457
    34583458  len = height * ((width * colorMap->getNumPixelComps() *
    3459                    colorMap->getBits() + 7) / 8);
     3459           colorMap->getBits() + 7) / 8);
    34603460  switch (level) {
    34613461  case psLevel1:
     
    34713471  case psLevel3Sep:
    34723472    doImageL2(ref, colorMap, gFalse, inlineImg, str,
    3473               width, height, len, maskColors, NULL, 0, 0, gFalse);
     3473          width, height, len, maskColors, NULL, 0, 0, gFalse);
    34743474    break;
    34753475  }
     
    34783478
    34793479void PSOutputDev::drawMaskedImage(GfxState *state, Object *ref, Stream *str,
    3480                                   int width, int height,
    3481                                   GfxImageColorMap *colorMap,
    3482                                   Stream *maskStr,
    3483                                   int maskWidth, int maskHeight,
    3484                                   GBool maskInvert) {
     3480                  int width, int height,
     3481                  GfxImageColorMap *colorMap,
     3482                  Stream *maskStr,
     3483                  int maskWidth, int maskHeight,
     3484                  GBool maskInvert) {
    34853485  int len;
    34863486
    34873487  len = height * ((width * colorMap->getNumPixelComps() *
    3488                    colorMap->getBits() + 7) / 8);
     3488           colorMap->getBits() + 7) / 8);
    34893489  switch (level) {
    34903490  case psLevel1:
     
    35003500  case psLevel3Sep:
    35013501    doImageL2(ref, colorMap, gFalse, gFalse, str, width, height, len,
    3502               NULL, maskStr, maskWidth, maskHeight, maskInvert);
     3502          NULL, maskStr, maskWidth, maskHeight, maskInvert);
    35033503    break;
    35043504  }
     
    35073507
    35083508void PSOutputDev::doImageL1(Object *ref, GfxImageColorMap *colorMap,
    3509                             GBool invert, GBool inlineImg,
    3510                             Stream *str, int width, int height, int len) {
     3509                GBool invert, GBool inlineImg,
     3510                Stream *str, int width, int height, int len) {
    35113511  ImageStream *imgStr;
    35123512  Guchar pixBuf[gfxColorMaxComps];
     
    35233523      writePS("[<");
    35243524      do {
    3525         do {
    3526           c = str->getChar();
    3527         } while (c == '\n' || c == '\r');
    3528         if (c == '>' || c == EOF) {
    3529           break;
    3530         }
    3531         writePSChar(c);
    3532         ++col;
    3533         // each line is: "<...data...><eol>"
    3534         // so max data length = 255 - 4 = 251
    3535         // but make it 240 just to be safe
    3536         // chunks are 2 bytes each, so we need to stop on an even col number
    3537         if (col == 240) {
    3538           writePS(">\n<");
    3539           col = 0;
    3540         }
     3525    do {
     3526      c = str->getChar();
     3527    } while (c == '\n' || c == '\r');
     3528    if (c == '>' || c == EOF) {
     3529      break;
     3530    }
     3531    writePSChar(c);
     3532    ++col;
     3533    // each line is: "<...data...><eol>"
     3534    // so max data length = 255 - 4 = 251
     3535    // but make it 240 just to be safe
     3536    // chunks are 2 bytes each, so we need to stop on an even col number
     3537    if (col == 240) {
     3538      writePS(">\n<");
     3539      col = 0;
     3540    }
    35413541      } while (c != '>' && c != EOF);
    35423542      writePS(">]\n");
     
    35533553  if (inType3Char && !colorMap) {
    35543554    writePSFmt("%d %d %s [%d 0 0 %d 0 %d] pdfImM1a\n",
    3555                width, height, invert ? "true" : "false",
    3556                width, -height, height);
     3555           width, height, invert ? "true" : "false",
     3556           width, -height, height);
    35573557  } else if (colorMap) {
    35583558    writePSFmt("%d %d 8 [%d 0 0 %d 0 %d] pdfIm1\n",
    3559                width, height,
    3560                width, -height, height);
     3559           width, height,
     3560           width, -height, height);
    35613561  } else {
    35623562    writePSFmt("%d %d %s [%d 0 0 %d 0 %d] pdfImM1\n",
    3563                width, height, invert ? "true" : "false",
    3564                width, -height, height);
     3563           width, height, invert ? "true" : "false",
     3564           width, -height, height);
    35653565  }
    35663566
     
    35723572      // set up to process the data stream
    35733573      imgStr = new ImageStream(str, width, colorMap->getNumPixelComps(),
    3574                                colorMap->getBits());
     3574                   colorMap->getBits());
    35753575      imgStr->reset();
    35763576
     
    35793579      for (y = 0; y < height; ++y) {
    35803580
    3581         // write the line
    3582         for (x = 0; x < width; ++x) {
    3583           imgStr->getPixel(pixBuf);
    3584           colorMap->getGray(pixBuf, &gray);
    3585           writePSFmt("%02x", colToByte(gray));
    3586           if (++i == 32) {
    3587             writePSChar('\n');
    3588             i = 0;
    3589           }
    3590         }
     3581    // write the line
     3582    for (x = 0; x < width; ++x) {
     3583      imgStr->getPixel(pixBuf);
     3584      colorMap->getGray(pixBuf, &gray);
     3585      writePSFmt("%02x", colToByte(gray));
     3586      if (++i == 32) {
     3587        writePSChar('\n');
     3588        i = 0;
     3589      }
     3590    }
    35913591      }
    35923592      if (i != 0) {
    3593         writePSChar('\n');
     3593    writePSChar('\n');
    35943594      }
    35953595      delete imgStr;
     
    36003600      i = 0;
    36013601      for (y = 0; y < height; ++y) {
    3602         for (x = 0; x < width; x += 8) {
    3603           writePSFmt("%02x", str->getChar() & 0xff);
    3604           if (++i == 32) {
    3605             writePSChar('\n');
    3606             i = 0;
    3607           }
    3608         }
     3602    for (x = 0; x < width; x += 8) {
     3603      writePSFmt("%02x", str->getChar() & 0xff);
     3604      if (++i == 32) {
     3605        writePSChar('\n');
     3606        i = 0;
     3607      }
     3608    }
    36093609      }
    36103610      if (i != 0) {
    3611         writePSChar('\n');
     3611    writePSChar('\n');
    36123612      }
    36133613      str->close();
     
    36173617
    36183618void PSOutputDev::doImageL1Sep(GfxImageColorMap *colorMap,
    3619                                GBool invert, GBool inlineImg,
    3620                                Stream *str, int width, int height, int len) {
     3619                   GBool invert, GBool inlineImg,
     3620                   Stream *str, int width, int height, int len) {
    36213621  ImageStream *imgStr;
    36223622  Guchar *lineBuf;
     
    36273627  // width, height, matrix, bits per component
    36283628  writePSFmt("%d %d 8 [%d 0 0 %d 0 %d] pdfIm1Sep\n",
    3629              width, height,
    3630              width, -height, height);
     3629         width, height,
     3630         width, -height, height);
    36313631
    36323632  // allocate a line buffer
     
    36353635  // set up to process the data stream
    36363636  imgStr = new ImageStream(str, width, colorMap->getNumPixelComps(),
    3637                            colorMap->getBits());
     3637               colorMap->getBits());
    36383638  imgStr->reset();
    36393639
     
    36513651      lineBuf[4*x+3] = colToByte(cmyk.k);
    36523652      addProcessColor(colToDbl(cmyk.c), colToDbl(cmyk.m),
    3653                       colToDbl(cmyk.y), colToDbl(cmyk.k));
     3653              colToDbl(cmyk.y), colToDbl(cmyk.k));
    36543654    }
    36553655
     
    36573657    for (comp = 0; comp < 4; ++comp) {
    36583658      for (x = 0; x < width; ++x) {
    3659         writePSFmt("%02x", lineBuf[4*x + comp]);
    3660         if (++i == 32) {
    3661           writePSChar('\n');
    3662           i = 0;
    3663         }
     3659    writePSFmt("%02x", lineBuf[4*x + comp]);
     3660    if (++i == 32) {
     3661      writePSChar('\n');
     3662      i = 0;
     3663    }
    36643664      }
    36653665    }
     
    36753675
    36763676void PSOutputDev::doImageL2(Object *ref, GfxImageColorMap *colorMap,
    3677                             GBool invert, GBool inlineImg,
    3678                             Stream *str, int width, int height, int len,
    3679                             int *maskColors, Stream *maskStr,
    3680                             int maskWidth, int maskHeight, GBool maskInvert) {
     3677                GBool invert, GBool inlineImg,
     3678                Stream *str, int width, int height, int len,
     3679                int *maskColors, Stream *maskStr,
     3680                int maskWidth, int maskHeight, GBool maskInvert) {
    36813681  ImageStream *imgStr;
    36823682  Guchar *line, *pix;
     
    37003700    for (y = 0, y0 = 0; y < height; ++y) {
    37013701      if (!(line = imgStr->getLine())) {
    3702         break;
     3702    break;
    37033703      }
    37043704      for (x = 0, x0 = 0, pix = line; x < width; ++x, pix += numComps) {
    3705         for (i = 0; i < numComps; ++i) {
    3706           if (pix[i] < maskColors[2*i] ||
    3707               pix[i] > maskColors[2*i+1]) {
    3708             break;
    3709           }
    3710         }
    3711         if (i == numComps) {
    3712           if (y0 < y) {
    3713             writePSFmt("0 %d %d %d\n", height - y, width, y - y0);
    3714           }
    3715           if (x0 < x) {
    3716             writePSFmt("%d %d %d 1\n", x0, height - y - 1, x - x0);
    3717           }
    3718           x0 = x + 1;
    3719           y0 = y + 1;
    3720         }
     3705    for (i = 0; i < numComps; ++i) {
     3706      if (pix[i] < maskColors[2*i] ||
     3707          pix[i] > maskColors[2*i+1]) {
     3708        break;
     3709      }
     3710    }
     3711    if (i == numComps) {
     3712      if (y0 < y) {
     3713        writePSFmt("0 %d %d %d\n", height - y, width, y - y0);
     3714      }
     3715      if (x0 < x) {
     3716        writePSFmt("%d %d %d 1\n", x0, height - y - 1, x - x0);
     3717      }
     3718      x0 = x + 1;
     3719      y0 = y + 1;
     3720    }
    37213721      }
    37223722      if (x0 > 0 && x0 < width) {
    3723         writePSFmt("%d %d %d 1\n", x0, height - y - 1, width - x0);
     3723    writePSFmt("%d %d %d 1\n", x0, height - y - 1, width - x0);
    37243724      }
    37253725    }
     
    37393739    for (y = 0, y0 = 0; y < maskHeight; ++y) {
    37403740      if (!(line = imgStr->getLine())) {
    3741         break;
     3741    break;
    37423742      }
    37433743      for (x = 0, x0 = 0, pix = line; x < maskWidth; ++x, ++pix) {
    3744         if (*pix ^ maskXor) {
    3745           if (y0 < y) {
    3746             writePSFmt("0 %d %d %d\n", maskHeight - y, maskWidth, y - y0);
    3747           }
    3748           if (x0 < x) {
    3749             writePSFmt("%d %d %d 1\n", x0, maskHeight - y - 1, x - x0);
    3750           }
    3751           x0 = x + 1;
    3752           y0 = y + 1;
    3753         }
     3744    if (*pix ^ maskXor) {
     3745      if (y0 < y) {
     3746        writePSFmt("0 %d %d %d\n", maskHeight - y, maskWidth, y - y0);
     3747      }
     3748      if (x0 < x) {
     3749        writePSFmt("%d %d %d 1\n", x0, maskHeight - y - 1, x - x0);
     3750      }
     3751      x0 = x + 1;
     3752      y0 = y + 1;
     3753    }
    37543754      }
    37553755      if (x0 > 0 && x0 < maskWidth) {
    3756         writePSFmt("%d %d %d 1\n", x0, maskHeight - y - 1, maskWidth - x0);
     3756    writePSFmt("%d %d %d 1\n", x0, maskHeight - y - 1, maskWidth - x0);
    37573757      }
    37583758    }
     
    37793779      str = new FixedLengthEncoder(str, len);
    37803780      if (useASCIIHex) {
    3781         str = new ASCIIHexEncoder(str);
     3781    str = new ASCIIHexEncoder(str);
    37823782      } else {
    3783         str = new ASCII85Encoder(str);
     3783    str = new ASCII85Encoder(str);
    37843784      }
    37853785      str->reset();
     
    37873787      writePS((char *)(useASCIIHex ? "[<" : "[<~"));
    37883788      do {
    3789         do {
    3790           c = str->getChar();
    3791         } while (c == '\n' || c == '\r');
    3792         if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
    3793           break;
    3794         }
    3795         if (c == 'z') {
    3796           writePSChar(c);
    3797           ++col;
    3798         } else {
    3799           writePSChar(c);
    3800           ++col;
    3801           for (i = 1; i <= (useASCIIHex ? 1 : 4); ++i) {
    3802             do {
    3803               c = str->getChar();
    3804             } while (c == '\n' || c == '\r');
    3805             if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
    3806               break;
    3807             }
    3808             writePSChar(c);
    3809             ++col;
    3810           }
    3811         }
    3812         // each line is: "<~...data...~><eol>"
    3813         // so max data length = 255 - 6 = 249
    3814         // chunks are 1 or 5 bytes each, so we have to stop at 245
    3815         // but make it 240 just to be safe
    3816         if (col > 240) {
    3817           writePS((char *)(useASCIIHex ? ">\n<" : "~>\n<~"));
    3818           col = 0;
    3819         }
     3789    do {
     3790      c = str->getChar();
     3791    } while (c == '\n' || c == '\r');
     3792    if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
     3793      break;
     3794    }
     3795    if (c == 'z') {
     3796      writePSChar(c);
     3797      ++col;
     3798    } else {
     3799      writePSChar(c);
     3800      ++col;
     3801      for (i = 1; i <= (useASCIIHex ? 1 : 4); ++i) {
     3802        do {
     3803          c = str->getChar();
     3804        } while (c == '\n' || c == '\r');
     3805        if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
     3806          break;
     3807        }
     3808        writePSChar(c);
     3809        ++col;
     3810      }
     3811    }
     3812    // each line is: "<~...data...~><eol>"
     3813    // so max data length = 255 - 6 = 249
     3814    // chunks are 1 or 5 bytes each, so we have to stop at 245
     3815    // but make it 240 just to be safe
     3816    if (col > 240) {
     3817      writePS((char *)(useASCIIHex ? ">\n<" : "~>\n<~"));
     3818      col = 0;
     3819    }
    38203820      } while (c != (useASCIIHex ? '>' : '~') && c != EOF);
    38213821      writePS((char *)(useASCIIHex ? ">]\n" : "~>]\n"));
     
    38403840  } else {
    38413841    writePSFmt("  /BitsPerComponent %d\n",
    3842                colorMap ? colorMap->getBits() : 1);
    3843   }
    3844 
    3845   // decode 
     3842           colorMap ? colorMap->getBits() : 1);
     3843  }
     3844
     3845  // decode
    38463846  if (colorMap) {
    38473847    writePS("  /Decode [");
    38483848    if ((level == psLevel2Sep || level == psLevel3Sep) &&
    3849         colorMap->getColorSpace()->getMode() == csSeparation) {
     3849    colorMap->getColorSpace()->getMode() == csSeparation) {
    38503850      // this matches up with the code in the pdfImSep operator
    38513851      n = (1 << colorMap->getBits()) - 1;
    38523852      writePSFmt("%g %g", colorMap->getDecodeLow(0) * n,
    3853                 colorMap->getDecodeHigh(0) * n);
     3853        colorMap->getDecodeHigh(0) * n);
    38543854    } else if (colorMap->getColorSpace()->getMode() == csDeviceN) {
    38553855      numComps = ((GfxDeviceNColorSpace *)colorMap->getColorSpace())->
    3856                    getAlt()->getNComps();
     3856               getAlt()->getNComps();
    38573857      for (i = 0; i < numComps; ++i) {
    3858         if (i > 0) {
    3859           writePS(" ");
    3860         }
    3861         writePS("0 1");
     3858    if (i > 0) {
     3859      writePS(" ");
     3860    }
     3861    writePS("0 1");
    38623862      }
    38633863    } else {
    38643864      numComps = colorMap->getNumPixelComps();
    38653865      for (i = 0; i < numComps; ++i) {
    3866         if (i > 0) {
    3867           writePS(" ");
    3868         }
    3869         writePSFmt("%g %g", colorMap->getDecodeLow(i),
    3870                    colorMap->getDecodeHigh(i));
     3866    if (i > 0) {
     3867      writePS(" ");
     3868    }
     3869    writePSFmt("%g %g", colorMap->getDecodeLow(i),
     3870           colorMap->getDecodeHigh(i));
    38713871      }
    38723872    }
     
    38923892    writePS("  /DataSource currentfile\n");
    38933893    s = str->getPSFilter(level < psLevel2 ? 1 : level < psLevel3 ? 2 : 3,
    3894                         "    ");
     3894            "    ");
    38953895    if ((colorMap && colorMap->getColorSpace()->getMode() == csDeviceN) ||
    3896         inlineImg || !s) {
     3896    inlineImg || !s) {
    38973897      useRLE = gTrue;
    38983898      useASCII = gTrue;
     
    39053905    if (useASCII) {
    39063906      writePSFmt("    /ASCII%sDecode filter\n",
    3907                 useASCIIHex ? "Hex" : "85");
     3907        useASCIIHex ? "Hex" : "85");
    39083908    }
    39093909    if (useRLE) {
     
    39353935    if (useASCII) {
    39363936      if (useASCIIHex) {
    3937         str = new ASCIIHexEncoder(str);
     3937    str = new ASCIIHexEncoder(str);
    39383938      } else {
    3939         str = new ASCII85Encoder(str);
     3939    str = new ASCII85Encoder(str);
    39403940      }
    39413941    }
     
    39463946    if (opi13Nest) {
    39473947      if (inlineImg) {
    3948         // this can't happen -- OPI dictionaries are in XObjects
    3949         error(-1, "Internal: OPI in inline image");
    3950         n = 0;
     3948    // this can't happen -- OPI dictionaries are in XObjects
     3949    error(-1, "Internal: OPI in inline image");
     3950    n = 0;
    39513951      } else {
    3952         // need to read the stream to count characters -- the length
    3953         // is data-dependent (because of ASCII and RLE filters)
    3954         str->reset();
    3955         n = 0;
    3956         while ((c = str->getChar()) != EOF) {
    3957           ++n;
    3958         }
    3959         str->close();
     3952    // need to read the stream to count characters -- the length
     3953    // is data-dependent (because of ASCII and RLE filters)
     3954    str->reset();
     3955    n = 0;
     3956    while ((c = str->getChar()) != EOF) {
     3957      ++n;
     3958    }
     3959    str->close();
    39603960      }
    39613961      // +6/7 for "pdfIm\n" / "pdfImM\n"
     
    39663966#endif
    39673967    if ((level == psLevel2Sep || level == psLevel3Sep) && colorMap &&
    3968         colorMap->getColorSpace()->getMode() == csSeparation) {
     3968    colorMap->getColorSpace()->getMode() == csSeparation) {
    39693969      color.c[0] = gfxColorComp1;
    39703970      sepCS = (GfxSeparationColorSpace *)colorMap->getColorSpace();
    39713971      sepCS->getCMYK(&color, &cmyk);
    39723972      writePSFmt("%g %g %g %g (%s) pdfImSep\n",
    3973                 colToDbl(cmyk.c), colToDbl(cmyk.m),
    3974                 colToDbl(cmyk.y), colToDbl(cmyk.k),
    3975                 sepCS->getName()->getCString());
     3973        colToDbl(cmyk.c), colToDbl(cmyk.m),
     3974        colToDbl(cmyk.y), colToDbl(cmyk.k),
     3975        sepCS->getName()->getCString());
    39763976    } else {
    39773977      writePSFmt("%s\n", colorMap ? "pdfIm" : "pdfImM");
     
    40064006
    40074007void PSOutputDev::dumpColorSpaceL2(GfxColorSpace *colorSpace,
    4008                                    GBool genXform, GBool updateColors) {
     4008                   GBool genXform, GBool updateColors) {
    40094009  GfxCalGrayColorSpace *calGrayCS;
    40104010  GfxCalRGBColorSpace *calRGBCS;
     
    40404040    writePSFmt(" /DecodeA {%g exp} bind\n", calGrayCS->getGamma());
    40414041    writePSFmt(" /MatrixA [%g %g %g]\n",
    4042                calGrayCS->getWhiteX(), calGrayCS->getWhiteY(),
    4043                calGrayCS->getWhiteZ());
     4042           calGrayCS->getWhiteX(), calGrayCS->getWhiteY(),
     4043           calGrayCS->getWhiteZ());
    40444044    writePSFmt(" /WhitePoint [%g %g %g]\n",
    4045                calGrayCS->getWhiteX(), calGrayCS->getWhiteY(),
    4046                calGrayCS->getWhiteZ());
     4045           calGrayCS->getWhiteX(), calGrayCS->getWhiteY(),
     4046           calGrayCS->getWhiteZ());
    40474047    writePSFmt(" /BlackPoint [%g %g %g]\n",
    4048                calGrayCS->getBlackX(), calGrayCS->getBlackY(),
    4049                calGrayCS->getBlackZ());
     4048           calGrayCS->getBlackX(), calGrayCS->getBlackY(),
     4049           calGrayCS->getBlackZ());
    40504050    writePS(">>]");
    40514051    if (genXform) {
     
    40714071    writePS("[/CIEBasedABC <<\n");
    40724072    writePSFmt(" /DecodeABC [{%g exp} bind {%g exp} bind {%g exp} bind]\n",
    4073                calRGBCS->getGammaR(), calRGBCS->getGammaG(),
    4074                calRGBCS->getGammaB());
     4073           calRGBCS->getGammaR(), calRGBCS->getGammaG(),
     4074           calRGBCS->getGammaB());
    40754075    writePSFmt(" /MatrixABC [%g %g %g %g %g %g %g %g %g]\n",
    4076                calRGBCS->getMatrix()[0], calRGBCS->getMatrix()[1],
    4077                calRGBCS->getMatrix()[2], calRGBCS->getMatrix()[3],
    4078                calRGBCS->getMatrix()[4], calRGBCS->getMatrix()[5],
    4079                calRGBCS->getMatrix()[6], calRGBCS->getMatrix()[7],
    4080                calRGBCS->getMatrix()[8]);
     4076           calRGBCS->getMatrix()[0], calRGBCS->getMatrix()[1],
     4077           calRGBCS->getMatrix()[2], calRGBCS->getMatrix()[3],
     4078           calRGBCS->getMatrix()[4], calRGBCS->getMatrix()[5],
     4079           calRGBCS->getMatrix()[6], calRGBCS->getMatrix()[7],
     4080           calRGBCS->getMatrix()[8]);
    40814081    writePSFmt(" /WhitePoint [%g %g %g]\n",
    4082                calRGBCS->getWhiteX(), calRGBCS->getWhiteY(),
    4083                calRGBCS->getWhiteZ());
     4082           calRGBCS->getWhiteX(), calRGBCS->getWhiteY(),
     4083           calRGBCS->getWhiteZ());
    40844084    writePSFmt(" /BlackPoint [%g %g %g]\n",
    4085                calRGBCS->getBlackX(), calRGBCS->getBlackY(),
    4086                calRGBCS->getBlackZ());
     4085           calRGBCS->getBlackX(), calRGBCS->getBlackY(),
     4086           calRGBCS->getBlackZ());
    40874087    writePS(">>]");
    40884088    if (genXform) {
     
    41084108    writePS("[/CIEBasedABC <<\n");
    41094109    writePSFmt(" /RangeABC [0 100 %g %g %g %g]\n",
    4110                labCS->getAMin(), labCS->getAMax(),
    4111                labCS->getBMin(), labCS->getBMax());
     4110           labCS->getAMin(), labCS->getAMax(),
     4111           labCS->getBMin(), labCS->getBMax());
    41124112    writePS(" /DecodeABC [{16 add 116 div} bind {500 div} bind {200 div} bind]\n");
    41134113    writePS(" /MatrixABC [1 1 1 1 0 0 0 0 -1]\n");
     
    41154115    writePS("   [{dup 6 29 div ge {dup dup mul mul}\n");
    41164116    writePSFmt("     {4 29 div sub 108 841 div mul } ifelse %g mul} bind\n",
    4117                labCS->getWhiteX());
     4117           labCS->getWhiteX());
    41184118    writePS("    {dup 6 29 div ge {dup dup mul mul}\n");
    41194119    writePSFmt("     {4 29 div sub 108 841 div mul } ifelse %g mul} bind\n",
    4120                labCS->getWhiteY());
     4120           labCS->getWhiteY());
    41214121    writePS("    {dup 6 29 div ge {dup dup mul mul}\n");
    41224122    writePSFmt("     {4 29 div sub 108 841 div mul } ifelse %g mul} bind]\n",
    4123                labCS->getWhiteZ());
     4123           labCS->getWhiteZ());
    41244124    writePSFmt(" /WhitePoint [%g %g %g]\n",
    4125                labCS->getWhiteX(), labCS->getWhiteY(), labCS->getWhiteZ());
     4125           labCS->getWhiteX(), labCS->getWhiteY(), labCS->getWhiteZ());
    41264126    writePSFmt(" /BlackPoint [%g %g %g]\n",
    4127                labCS->getBlackX(), labCS->getBlackY(), labCS->getBlackZ());
     4127           labCS->getBlackX(), labCS->getBlackY(), labCS->getBlackZ());
    41284128    writePS(">>]");
    41294129    if (genXform) {
     
    41394139    // we can use it directly
    41404140    dumpColorSpaceL2(((GfxICCBasedColorSpace *)colorSpace)->getAlt(),
    4141                      genXform, updateColors);
     4141             genXform, updateColors);
    41424142    break;
    41434143
     
    41564156      p = lookup;
    41574157      for (i = 0; i <= n; i += 8) {
    4158         writePS("  ");
    4159         for (j = i; j < i+8 && j <= n; ++j) {
    4160           for (k = 0; k < numComps; ++k) {
    4161             x[k] = *p++ / 255.0;
    4162           }
    4163           func->transform(x, y);
    4164           for (k = 0; k < numAltComps; ++k) {
    4165             byte = (int)(y[k] * 255 + 0.5);
    4166             if (byte < 0) {
    4167               byte = 0;
    4168             } else if (byte > 255) {
    4169               byte = 255;
    4170             }
    4171             writePSFmt("%02x", byte);
    4172           }
    4173           if (updateColors) {
    4174             color.c[0] = dblToCol(j);
    4175           indexedCS->getCMYK(&color, &cmyk);
    4176             addProcessColor(colToDbl(cmyk.c), colToDbl(cmyk.m),
    4177                             colToDbl(cmyk.y), colToDbl(cmyk.k));
    4178           }
    4179         }
    4180         writePS("\n");
     4158    writePS("  ");
     4159    for (j = i; j < i+8 && j <= n; ++j) {
     4160      for (k = 0; k < numComps; ++k) {
     4161        x[k] = *p++ / 255.0;
     4162      }
     4163      func->transform(x, y);
     4164      for (k = 0; k < numAltComps; ++k) {
     4165        byte = (int)(y[k] * 255 + 0.5);
     4166        if (byte < 0) {
     4167          byte = 0;
     4168        } else if (byte > 255) {
     4169          byte = 255;
     4170        }
     4171        writePSFmt("%02x", byte);
     4172      }
     4173      if (updateColors) {
     4174        color.c[0] = dblToCol(j);
     4175      indexedCS->getCMYK(&color, &cmyk);
     4176        addProcessColor(colToDbl(cmyk.c), colToDbl(cmyk.m),
     4177                colToDbl(cmyk.y), colToDbl(cmyk.k));
     4178      }
     4179    }
     4180    writePS("\n");
    41814181      }
    41824182    } else {
    41834183      for (i = 0; i <= n; i += 8) {
    4184         writePS("  ");
    4185         for (j = i; j < i+8 && j <= n; ++j) {
    4186           for (k = 0; k < numComps; ++k) {
    4187             writePSFmt("%02x", lookup[j * numComps + k]);
    4188           }
    4189           if (updateColors) {
    4190             color.c[0] = dblToCol(j);
    4191           indexedCS->getCMYK(&color, &cmyk);
    4192             addProcessColor(colToDbl(cmyk.c), colToDbl(cmyk.m),
    4193                             colToDbl(cmyk.y), colToDbl(cmyk.k));
    4194           }
    4195         }
    4196         writePS("\n");
     4184    writePS("  ");
     4185    for (j = i; j < i+8 && j <= n; ++j) {
     4186      for (k = 0; k < numComps; ++k) {
     4187        writePSFmt("%02x", lookup[j * numComps + k]);
     4188      }
     4189      if (updateColors) {
     4190        color.c[0] = dblToCol(j);
     4191      indexedCS->getCMYK(&color, &cmyk);
     4192        addProcessColor(colToDbl(cmyk.c), colToDbl(cmyk.m),
     4193                colToDbl(cmyk.y), colToDbl(cmyk.k));
     4194      }
     4195    }
     4196    writePS("\n");
    41974197      }
    41984198    }
     
    42494249      opiDict->lookup("1.3", &dict);
    42504250      if (dict.isDict()) {
    4251         opiBegin13(state, dict.getDict());
     4251    opiBegin13(state, dict.getDict());
    42524252      }
    42534253      dict.free();
     
    42684268  if (getFileSpec(&obj1, &obj2)) {
    42694269    writePSFmt("%%%%ImageFileName: %s\n",
    4270                obj2.getString()->getCString());
     4270           obj2.getString()->getCString());
    42714271    obj2.free();
    42724272  }
     
    43254325    if (obj2.isName()) {
    43264326      writePSFmt("%%%%ImageInks: %s %d",
    4327                 obj2.getName(), (obj1.arrayGetLength() - 1) / 2);
     4327        obj2.getName(), (obj1.arrayGetLength() - 1) / 2);
    43284328      for (i = 1; i+1 < obj1.arrayGetLength(); i += 2) {
    4329         obj1.arrayGet(i, &obj3);
    4330         obj1.arrayGet(i+1, &obj4);
    4331         if (obj3.isString() && obj4.isNum()) {
    4332           writePS(" ");
    4333           writePSString(obj3.getString());
    4334           writePSFmt(" %g", obj4.getNum());
    4335         }
    4336         obj3.free();
    4337         obj4.free();
     4329    obj1.arrayGet(i, &obj3);
     4330    obj1.arrayGet(i+1, &obj4);
     4331    if (obj3.isString() && obj4.isNum()) {
     4332      writePS(" ");
     4333      writePSString(obj3.getString());
     4334      writePSFmt(" %g", obj4.getNum());
     4335    }
     4336    obj3.free();
     4337    obj4.free();
    43384338      }
    43394339      writePS("\n");
     
    43844384  if (getFileSpec(&obj1, &obj2)) {
    43854385    writePSFmt("%%ALDImageFileName: %s\n",
    4386                obj2.getString()->getCString());
     4386           obj2.getString()->getCString());
    43874387    obj2.free();
    43884388  }
     
    44634463    for (i = 0; i < obj1.arrayGetLength(); i += 16) {
    44644464      if (i > 0) {
    4465         writePS("\n%%+");
     4465    writePS("\n%%+");
    44664466      }
    44674467      for (j = 0; j < 16 && i+j < obj1.arrayGetLength(); ++j) {
    4468         obj1.arrayGet(i+j, &obj2);
    4469         writePSFmt(" %d", obj2.getInt());
    4470         obj2.free();
     4468    obj1.arrayGet(i+j, &obj2);
     4469    writePSFmt(" %d", obj2.getInt());
     4470    obj2.free();
    44714471      }
    44724472    }
     
    45304530    opiTransform(state, lrx, lry, &tlrx, &tlry);
    45314531    writePSFmt("%%ALDImagePosition: %g %g %g %g %g %g %g %g\n",
    4532                tllx, tlly, tulx, tuly, turx, tury, tlrx, tlry);
     4532           tllx, tlly, tulx, tuly, turx, tury, tlrx, tlry);
    45334533    obj2.free();
    45344534  }
     
    45844584// PSOutputDev page-fitting transform.
    45854585void PSOutputDev::opiTransform(GfxState *state, double x0, double y0,
    4586                                double *x1, double *y1) {
     4586                   double *x1, double *y1) {
    45874587  double t;
    45884588
     
    46214621      opiDict->lookup("1.3", &dict);
    46224622      if (dict.isDict()) {
    4623         writePS("%%EndObject\n");
    4624         writePS("restore\n");
    4625         --opi13Nest;
     4623    writePS("%%EndObject\n");
     4624    writePS("restore\n");
     4625    --opi13Nest;
    46264626      }
    46274627      dict.free();
     
    46674667
    46684668void PSOutputDev::type3D1(GfxState *state, double wx, double wy,
    4669                           double llx, double lly, double urx, double ury) {
     4669              double llx, double lly, double urx, double ury) {
    46704670  t3WX = wx;
    46714671  t3WY = wy;
     
    47064706  switch (func->getType()) {
    47074707
    4708   case -1:                      // identity
     4708  case -1:          // identity
    47094709    writePS("{}\n");
    47104710    break;
    47114711
    4712   case 0:                       // sampled
     4712  case 0:           // sampled
    47134713    func0 = (SampledFunction *)func;
    47144714    thisFunc = nextFunc++;
     
    47294729      // [e01] [efrac] x0 x1 ... xi
    47304730      writePSFmt("%g sub %g mul %g add\n",
    4731               func0->getDomainMin(i),
    4732               (func0->getEncodeMax(i) - func0->getEncodeMin(i)) /
    4733                 (func0->getDomainMax(i) - func0->getDomainMin(i)),
    4734               func0->getEncodeMin(i));
     4731          func0->getDomainMin(i),
     4732          (func0->getEncodeMax(i) - func0->getEncodeMin(i)) /
     4733            (func0->getDomainMax(i) - func0->getDomainMin(i)),
     4734          func0->getEncodeMin(i));
    47354735      // [e01] [efrac] x0 x1 ... xi-1 xi'
    47364736      writePSFmt("dup 0 lt { pop 0 } { dup %d gt { pop %d } if } ifelse\n",
    4737                 func0->getSampleSize(i) - 1, func0->getSampleSize(i) - 1);
     4737        func0->getSampleSize(i) - 1, func0->getSampleSize(i) - 1);
    47384738      // [e01] [efrac] x0 x1 ... xi-1 xi'
    47394739      writePS("dup floor cvi exch dup ceiling cvi exch 2 index sub\n");
     
    47504750      // [e01] [efrac] y(0) ... y(i-1)
    47514751      for (j = 0; j < (1<<m); ++j) {
    4752         // [e01] [efrac] y(0) ... y(i-1) s(0) s(1) ... s(j-1)
    4753         writePSFmt("xpdfSamples%d\n", thisFunc);
    4754         k = m - 1;
    4755         writePSFmt("%d index %d get\n", i+j+2, 2 * k + ((j >> k) & 1));
    4756         for (k = m - 2; k >= 0; --k) {
    4757           writePSFmt("%d mul %d index %d get add\n",
    4758                      func0->getSampleSize(k),
    4759                      i + j + 3,
    4760                      2 * k + ((j >> k) & 1));
    4761         }
    4762         if (n > 1) {
    4763           writePSFmt("%d mul %d add ", n, i);
    4764         }
    4765         writePS("get\n");
     4752    // [e01] [efrac] y(0) ... y(i-1) s(0) s(1) ... s(j-1)
     4753    writePSFmt("xpdfSamples%d\n", thisFunc);
     4754    k = m - 1;
     4755    writePSFmt("%d index %d get\n", i+j+2, 2 * k + ((j >> k) & 1));
     4756    for (k = m - 2; k >= 0; --k) {
     4757      writePSFmt("%d mul %d index %d get add\n",
     4758             func0->getSampleSize(k),
     4759             i + j + 3,
     4760             2 * k + ((j >> k) & 1));
     4761    }
     4762    if (n > 1) {
     4763      writePSFmt("%d mul %d add ", n, i);
     4764    }
     4765    writePS("get\n");
    47664766      }
    47674767      // [e01] [efrac] y(0) ... y(i-1) s(0) s(1) ... s(2^m-1)
    47684768      for (j = 0; j < m; ++j) {
    4769         // [e01] [efrac] y(0) ... y(i-1) s(0) s(1) ... s(2^(m-j)-1)
    4770         for (k = 0; k < (1 << (m - j)); k += 2) {
    4771           // [e01] [efrac] y(0) ... y(i-1) <k/2 s' values> <2^(m-j)-k s values>
    4772           writePSFmt("%d index %d get dup\n", i + k/2 + (1 << (m-j)) - k, j);
    4773           writePS("3 2 roll mul exch 1 exch sub 3 2 roll mul add\n");
    4774           writePSFmt("%d 1 roll\n", k/2 + (1 << m-j) - k - 1);
    4775         }
    4776         // [e01] [efrac] s'(0) s'(1) ... s(2^(m-j-1)-1)
     4769    // [e01] [efrac] y(0) ... y(i-1) s(0) s(1) ... s(2^(m-j)-1)
     4770    for (k = 0; k < (1 << (m - j)); k += 2) {
     4771      // [e01] [efrac] y(0) ... y(i-1) <k/2 s' values> <2^(m-j)-k s values>
     4772      writePSFmt("%d index %d get dup\n", i + k/2 + (1 << (m-j)) - k, j);
     4773      writePS("3 2 roll mul exch 1 exch sub 3 2 roll mul add\n");
     4774      writePSFmt("%d 1 roll\n", k/2 + (1 << m-j) - k - 1);
     4775    }
     4776    // [e01] [efrac] s'(0) s'(1) ... s(2^(m-j-1)-1)
    47774777      }
    47784778      // [e01] [efrac] y(0) ... y(i-1) s
    47794779      writePSFmt("%g mul %g add\n",
    4780                 func0->getDecodeMax(i) - func0->getDecodeMin(i),
    4781                 func0->getDecodeMin(i));
     4780        func0->getDecodeMax(i) - func0->getDecodeMin(i),
     4781        func0->getDecodeMin(i));
    47824782      writePSFmt("dup %g lt { pop %g } { dup %g gt { pop %g } if } ifelse\n",
    4783                 func0->getRangeMin(i), func0->getRangeMin(i),
    4784                 func0->getRangeMax(i), func0->getRangeMax(i));
     4783        func0->getRangeMin(i), func0->getRangeMin(i),
     4784        func0->getRangeMax(i), func0->getRangeMax(i));
    47854785      // [e01] [efrac] y(0) ... y(i-1) y(i)
    47864786    }
     
    47894789    break;
    47904790
    4791   case 2:                       // exponential
     4791  case 2:           // exponential
    47924792    func2 = (ExponentialFunction *)func;
    47934793    n = func2->getOutputSize();
    47944794    writePSFmt("{ dup %g lt { pop %g } { dup %g gt { pop %g } if } ifelse\n",
    4795                func2->getDomainMin(0), func2->getDomainMin(0),
    4796                func2->getDomainMax(0), func2->getDomainMax(0));
     4795           func2->getDomainMin(0), func2->getDomainMin(0),
     4796           func2->getDomainMax(0), func2->getDomainMax(0));
    47974797    // x
    47984798    for (i = 0; i < n; ++i) {
    47994799      // x y(0) .. y(i-1)
    48004800      writePSFmt("%d index %g exp %g mul %g add\n",
    4801                 i, func2->getE(), func2->getC1()[i] - func2->getC0()[i],
    4802                 func2->getC0()[i]);
     4801        i, func2->getE(), func2->getC1()[i] - func2->getC0()[i],
     4802        func2->getC0()[i]);
    48034803      if (func2->getHasRange()) {
    4804         writePSFmt("dup %g lt { pop %g } { dup %g gt { pop %g } if } ifelse\n",
    4805                    func2->getRangeMin(i), func2->getRangeMin(i),
    4806                    func2->getRangeMax(i), func2->getRangeMax(i));
     4804    writePSFmt("dup %g lt { pop %g } { dup %g gt { pop %g } if } ifelse\n",
     4805           func2->getRangeMin(i), func2->getRangeMin(i),
     4806           func2->getRangeMax(i), func2->getRangeMax(i));
    48074807      }
    48084808    }
     
    48114811    break;
    48124812
    4813   case 3:                       // stitching
     4813  case 3:           // stitching
    48144814    func3 = (StitchingFunction *)func;
    48154815    thisFunc = nextFunc++;
     
    48194819    }
    48204820    writePSFmt("{ dup %g lt { pop %g } { dup %g gt { pop %g } if } ifelse\n",
    4821                func3->getDomainMin(0), func3->getDomainMin(0),
    4822                func3->getDomainMax(0), func3->getDomainMax(0));
     4821           func3->getDomainMin(0), func3->getDomainMin(0),
     4822           func3->getDomainMax(0), func3->getDomainMax(0));
    48234823    for (i = 0; i < func3->getNumFuncs() - 1; ++i) {
    48244824      writePSFmt("dup %g lt { %g sub %g mul %g add xpdfFunc%d_%d } {\n",
    4825                 func3->getBounds()[i+1],
    4826                 func3->getBounds()[i],
    4827                 (func3->getEncode()[2*i+1] - func3->getEncode()[2*i]) /
    4828                    (func3->getBounds()[i+1] - func3->getBounds()[i]),
    4829                 func3->getEncode()[2*i],
    4830                 thisFunc, i);
     4825        func3->getBounds()[i+1],
     4826        func3->getBounds()[i],
     4827        (func3->getEncode()[2*i+1] - func3->getEncode()[2*i]) /
     4828           (func3->getBounds()[i+1] - func3->getBounds()[i]),
     4829        func3->getEncode()[2*i],
     4830        thisFunc, i);
    48314831    }
    48324832    writePSFmt("%g sub %g mul %g add xpdfFunc%d_%d\n",
    4833                func3->getBounds()[i],
    4834                (func3->getEncode()[2*i+1] - func3->getEncode()[2*i]) /
    4835                  (func3->getBounds()[i+1] - func3->getBounds()[i]),
    4836                func3->getEncode()[2*i],
    4837                thisFunc, i);
     4833           func3->getBounds()[i],
     4834           (func3->getEncode()[2*i+1] - func3->getEncode()[2*i]) /
     4835             (func3->getBounds()[i+1] - func3->getBounds()[i]),
     4836           func3->getEncode()[2*i],
     4837           thisFunc, i);
    48384838    for (i = 0; i < func3->getNumFuncs() - 1; ++i) {
    48394839      writePS("} ifelse\n");
     
    48424842    break;
    48434843
    4844   case 4:                       // PostScript
     4844  case 4:           // PostScript
    48454845    func4 = (PostScriptFunction *)func;
    48464846    writePS(func4->getCodeString()->getCString());
     
    49164916  while ((c = *p++)) {
    49174917    if (c <= (char)0x20 || c >= (char)0x7f ||
    4918         c == '(' || c == ')' || c == '<' || c == '>' ||
    4919         c == '[' || c == ']' || c == '{' || c == '}' ||
    4920         c == '/' || c == '%') {
     4918    c == '(' || c == ')' || c == '<' || c == '>' ||
     4919    c == '[' || c == ']' || c == '{' || c == '}' ||
     4920    c == '/' || c == '%') {
    49214921      writePSFmt("#%02x", c & 0xff);
    49224922    } else {
     
    49454945    c = name->getChar(i);
    49464946    if (c <= (char)0x20 || c >= (char)0x7f ||
    4947         c == '(' || c == ')' || c == '<' || c == '>' ||
    4948         c == '[' || c == ']' || c == '{' || c == '}' ||
    4949         c == '/' || c == '%') {
     4947    c == '(' || c == ')' || c == '<' || c == '>' ||
     4948    c == '[' || c == ']' || c == '{' || c == '}' ||
     4949    c == '/' || c == '%') {
    49504950      sprintf(buf, "#%02x", c & 0xff);
    49514951      name2->append(buf);
Note: See TracChangeset for help on using the changeset viewer.