lib/pdf/BitmapOutputDev.cc

   1 /* InfoOutputDev.h
   2
   3    Output Device which creates a bitmap.
   4
   5    Swftools is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2 of the License, or
   8    (at your option) any later version.
   9
  10    Swftools is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with swftools; if not, write to the Free Software
  17    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  18
  19 #include <stdlib.h>
  20 #include <stdio.h>
  21 #include <memory.h>
  22 #include "config.h"
  23 #include "BitmapOutputDev.h"
  24 #include "GFXOutputDev.h"
  25 #include "SplashBitmap.h"
  26 #include "SplashPattern.h"
  27 #include "Splash.h"
  28 #include "../log.h"
  29 #include "../png.h"
  30 #include "../devices/record.h"
  31
  32 static SplashColor splash_white = {255,255,255};
  33 static SplashColor splash_black = {0,0,0};
  34
  35 ClipState::ClipState()
  36 {
  37     this->next = 0;
  38     this->clipbitmap = 0;
  39     this->written = 0;
  40 }
  41
  42 BitmapOutputDev::BitmapOutputDev(InfoOutputDev*info, PDFDoc*doc)
  43 {
  44     this->info = info;
  45     this->doc = doc;
  46     this->xref = doc->getXRef();
  47
  48     /* color graphic output device, for creating bitmaps */
  49     this->rgbdev = new SplashOutputDev(splashModeRGB8, 1, gFalse, splash_white, gTrue, gTrue);
  50
  51     /* color mode for binary bitmaps */
  52     SplashColorMode colorMode = splashModeMono8;
  53
  54     /* two devices for testing things against clipping: one clips, the other doesn't */
  55     this->clip0dev = new SplashOutputDev(colorMode, 1, gFalse, splash_black, gTrue, gFalse);
  56     this->clip1dev = new SplashOutputDev(colorMode, 1, gFalse, splash_black, gTrue, gFalse);
  57
  58     /* device indicating where polygonal pixels were drawn */
  59     this->boolpolydev = new SplashOutputDev(colorMode, 1, gFalse, splash_black, gTrue, gFalse);
  60     /* device indicating where text pixels were drawn */
  61     this->booltextdev = new SplashOutputDev(colorMode, 1, gFalse, splash_black, gTrue, gFalse);
  62
  63     /* device for handling texts and links */
  64     this->gfxdev = new GFXOutputDev(info, this->doc);
  65
  66     this->rgbdev->startDoc(this->xref);
  67     this->boolpolydev->startDoc(this->xref);
  68     this->booltextdev->startDoc(this->xref);
  69     this->clip0dev->startDoc(this->xref);
  70     this->clip1dev->startDoc(this->xref);
  71
  72     this->gfxoutput = (gfxdevice_t*)malloc(sizeof(gfxdevice_t));
  73     gfxdevice_record_init(this->gfxoutput);
  74
  75     this->gfxdev->setDevice(this->gfxoutput);
  76
  77     this->config_bitmapfonts = 0;
  78     this->config_extrafontdata = 0;
  79     this->bboxpath = 0;
  80     //this->clipdev = 0;
  81     //this->clipstates = 0;
  82 }
  83 BitmapOutputDev::~BitmapOutputDev()
  84 {
  85     if(this->gfxoutput) {
  86         gfxresult_t*r = this->gfxoutput->finish(this->gfxoutput);
  87         r->destroy(r);
  88         free(this->gfxoutput);this->gfxoutput = 0;
  89     }
  90     if(this->bboxpath) {
  91         delete this->bboxpath;this->bboxpath = 0;
  92     }
  93     if(this->rgbdev) {
  94         delete this->rgbdev;this->rgbdev = 0;
  95     }
  96     if(this->gfxdev) {
  97         delete this->gfxdev;this->gfxdev= 0;
  98     }
  99     if(this->boolpolydev) {
 100         delete this->boolpolydev;this->boolpolydev = 0;
 101     }
 102     if(this->booltextdev) {
 103         delete this->booltextdev;this->booltextdev = 0;
 104     }
 105     if(this->clip0dev) {
 106         delete this->clip0dev;this->clip0dev = 0;
 107     }
 108     if(this->clip1dev) {
 109         delete this->clip1dev;this->clip1dev = 0;
 110     }
 111     //if(this->clipbitmap) {
 112     //    delete this->clipbitmap;this->clipbitmap = 0;
 113     //}
 114     //if(this->clipdev) {
 115     //    delete this->clipdev;this->clipdev = 0;
 116     //}
 117
 118 }
 119
 120 GBool BitmapOutputDev::getVectorAntialias()
 121 {
 122     return this->rgbdev->getVectorAntialias();
 123 }
 124 void BitmapOutputDev::setVectorAntialias(GBool vaa)
 125 {
 126     this->rgbdev->setVectorAntialias(vaa);
 127 }
 128 void BitmapOutputDev::setDevice(gfxdevice_t*dev)
 129 {
 130     this->dev = dev;
 131 }
 132 void BitmapOutputDev::setMove(int x,int y)
 133 {
 134     this->gfxdev->setMove(x,y);
 135     this->user_movex = x;
 136     this->user_movey = y;
 137 }
 138 void BitmapOutputDev::setClip(int x1,int y1,int x2,int y2)
 139 {
 140     this->gfxdev->setClip(x1,y1,x2,y2);
 141     this->user_clipx1 = x1;
 142     this->user_clipy1 = y1;
 143     this->user_clipx2 = x2;
 144     this->user_clipy2 = y2;
 145 }
 146 void BitmapOutputDev::setParameter(const char*key, const char*value)
 147 {
 148     if(!strcmp(key, "extrafontdata")) {
 149         this->config_extrafontdata = atoi(value);
 150     } else if(!strcmp(key, "bitmapfonts")) {
 151         this->config_bitmapfonts = atoi(value);
 152     }
 153     this->gfxdev->setParameter(key, value);
 154 }
 155 void BitmapOutputDev::preparePage(int pdfpage, int outputpage)
 156 {
 157 }
 158
 159 void getBitmapBBox(Guchar*alpha, int width, int height, int*xmin, int*ymin, int*xmax, int*ymax)
 160 {
 161     *ymin = -1;
 162     *xmin = width;
 163     *xmax = 0;
 164     int x,y;
 165     for(y=0;y<height;y++) {
 166         Guchar*a = &alpha[y*width];
 167         for(x=0;x<width;x++) {
 168             if(a[x]) break;
 169         }
 170         int left = x; //first occupied pixel from left
 171         int right = x+1; //last non-occupied pixel from right
 172         for(;x<width;x++) {
 173             if(a[x]) right=x+1;
 174         }
 175
 176         if(left!=width) {
 177             if(*ymin<0)
 178                 *ymin=y;
 179             *ymax=y+1;
 180             if(left<*xmin) *xmin = left;
 181             if(right>*xmax) *xmax = right;
 182         }
 183     }
 184     if(*xmin>=*xmax || *ymin>=*ymax) {
 185         *xmin = 0;
 186         *ymin = 0;
 187         *xmax = 0;
 188         *ymax = 0;
 189     }
 190 }
 191
 192 void BitmapOutputDev::flushBitmap()
 193 {
 194     int width = rgbdev->getBitmapWidth();
 195     int height = rgbdev->getBitmapHeight();
 196
 197     SplashColorPtr rgb = rgbdev->getBitmap()->getDataPtr();
 198     Guchar*alpha = rgbdev->getBitmap()->getAlphaPtr();
 199
 200     int xmin,ymin,xmax,ymax;
 201     getBitmapBBox(alpha, width, height, &xmin,&ymin,&xmax,&ymax);
 202
 203     /* clip against (-movex, -movey, -movex+width, -movey+height) */
 204     if(xmin < -this->movex) xmin = -this->movex;
 205     if(ymin < -this->movey) ymin = -this->movey;
 206     if(xmax > -this->movex + width) xmax = -this->movex+this->width;
 207     if(ymax > -this->movey + height) ymax = -this->movey+this->height;
 208
 209     msg("<verbose> Flushing bitmap (bbox: %d,%d,%d,%d)", xmin,ymin,xmax,ymax);
 210
 211     if((xmax-xmin)<=0 || (ymax-ymin)<=0) // no bitmap, nothing to do
 212         return;
 213
 214     if(sizeof(SplashColor)!=3) {
 215         msg("<error> sizeof(SplashColor)!=3");
 216         return;
 217     }
 218     //xmin = ymin = 0;
 219     //xmax = width;
 220     //ymax = height;
 221
 222     int rangex = xmax-xmin;
 223     int rangey = ymax-ymin;
 224     gfximage_t*img = (gfximage_t*)malloc(sizeof(gfximage_t));
 225     img->data = (gfxcolor_t*)malloc(rangex * rangey * 4);
 226     img->width = rangex;
 227     img->height = rangey;
 228     int x,y;
 229     for(y=0;y<rangey;y++) {
 230         SplashColorPtr in=&rgb[((y+ymin)*width+xmin)*sizeof(SplashColor)];
 231         gfxcolor_t*out = &img->data[y*rangex];
 232         Guchar*ain = &alpha[(y+ymin)*width+xmin];
 233         for(x=0;x<rangex;x++) {
 234             /* according to endPage()/compositeBackground() in xpdf/SplashOutputDev.cc, we
 235                have to premultiply alpha (mix background and pixel according to the alpha channel).
 236             */
 237             out[x].r = (in[x*3+0]*ain[x])/255;
 238             out[x].g = (in[x*3+1]*ain[x])/255;
 239             out[x].b = (in[x*3+2]*ain[x])/255;
 240             out[x].a = ain[x];
 241         }
 242     }
 243     /* transform bitmap rectangle to "device space" */
 244     xmin += movex;
 245     ymin += movey;
 246     xmax += movex;
 247     ymax += movey;
 248
 249     gfxmatrix_t m;
 250     m.tx = xmin;
 251     m.ty = ymin;
 252     m.m00 = m.m11 = 1;
 253     m.m10 = m.m01 = 0;
 254
 255     gfxline_t* line = gfxline_makerectangle(xmin, ymin, xmax, ymax);
 256     dev->fillbitmap(dev, line, img, &m, 0);
 257     gfxline_free(line);
 258
 259     memset(rgbdev->getBitmap()->getAlphaPtr(), 0, rgbdev->getBitmap()->getWidth()*rgbdev->getBitmap()->getHeight());
 260     memset(rgbdev->getBitmap()->getDataPtr(), 0, rgbdev->getBitmap()->getRowSize()*rgbdev->getBitmap()->getHeight());
 261
 262     free(img->data);img->data=0;free(img);img=0;
 263 }
 264
 265 void BitmapOutputDev::flushText()
 266 {
 267     msg("<verbose> Flushing text/polygons");
 268     gfxdevice_record_flush(this->gfxoutput, this->dev);
 269 }
 270
 271 void writeAlpha(SplashBitmap*bitmap, char*filename)
 272 {
 273     return;
 274     int y,x;
 275
 276     int width = bitmap->getWidth();
 277     int height = bitmap->getHeight();
 278
 279     gfxcolor_t*data = (gfxcolor_t*)malloc(sizeof(gfxcolor_t)*width*height);
 280
 281     for(y=0;y<height;y++) {
 282         gfxcolor_t*line = &data[y*width];
 283         for(x=0;x<width;x++) {
 284             int a = bitmap->getAlpha(x,y);
 285             line[x].r = a;
 286             line[x].g = a;
 287             line[x].b = a;
 288             line[x].a = 255;
 289         }
 290     }
 291     writePNG(filename, (unsigned char*)data, width, height);
 292     free(data);
 293 }
 294 static int dbg_btm_counter=1;
 295
 296 void BitmapOutputDev::checkNewText()
 297 {
 298     /* called once some new text was drawn on booltextdev, and
 299        before the same thing is drawn on gfxdev */
 300
 301     msg("<trace> Testing new text data against current bitmap data, state=%d, counter=%d\n", layerstate, dbg_btm_counter);
 302
 303     char filename1[80];
 304     char filename2[80];
 305     sprintf(filename1, "state%dbitmap_newtext.png", dbg_btm_counter);
 306     sprintf(filename2, "state%dtext_newtext.png", dbg_btm_counter);
 307     writeAlpha(boolpolydev->getBitmap(), filename1);
 308     writeAlpha(booltextdev->getBitmap(), filename2);
 309     dbg_btm_counter++;
 310
 311     if(intersection()) {
 312         msg("<verbose> Text is above current bitmap/polygon data");
 313         if(layerstate==STATE_PARALLEL) {
 314             /* the new text is above the bitmap. So record that fact,
 315                and also clear the bitmap buffer, so we can check for
 316                new intersections */
 317             layerstate=STATE_TEXT_IS_ABOVE;
 318             clearBoolPolyDev();
 319         } else if(layerstate==STATE_BITMAP_IS_ABOVE) {
 320             /* there's a bitmap above the (old) text. So we need
 321                to flush out that text, and record that the *new*
 322                text is now *above* the bitmap
 323              */
 324             flushText();
 325             layerstate=STATE_TEXT_IS_ABOVE;
 326             /* clear both bool devices- the text device because
 327                we just dumped out all the (old) text, and the
 328                poly dev so we can check for new intersections */
 329             clearBoolPolyDev();
 330             clearBoolTextDev();
 331         } else {
 332             /* we already know that the current text section is
 333                above the current bitmap section- now just new
 334                bitmap data *and* new text data was drawn, and
 335                *again* it's above the current bitmap- so clear
 336                the polygon bitmap again, so we can check for
 337                new intersections */
 338             clearBoolPolyDev();
 339         }
 340     }
 341 }
 342
 343 void BitmapOutputDev::checkNewBitmap()
 344 {
 345     /* similar to checkNewText() above, only in reverse */
 346     msg("<trace> Testing new graphics data against current text data, state=%d, counter=%d\n", layerstate, dbg_btm_counter);
 347
 348     char filename1[80];
 349     char filename2[80];
 350     sprintf(filename1, "state%dbitmap_newbitmap.png", dbg_btm_counter);
 351     sprintf(filename2, "state%dtext_newbitmap.png", dbg_btm_counter);
 352     writeAlpha(boolpolydev->getBitmap(), filename1);
 353     writeAlpha(booltextdev->getBitmap(), filename2);
 354     dbg_btm_counter++;
 355
 356     if(intersection()) {
 357         msg("<verbose> Bitmap is above current text data");
 358         if(layerstate==STATE_PARALLEL) {
 359             layerstate=STATE_BITMAP_IS_ABOVE;
 360             clearBoolTextDev();
 361         } else if(layerstate==STATE_TEXT_IS_ABOVE) {
 362             flushBitmap();
 363             layerstate=STATE_BITMAP_IS_ABOVE;
 364             clearBoolTextDev();
 365             clearBoolPolyDev();
 366         } else {
 367             clearBoolTextDev();
 368         }
 369     }
 370 }
 371
 372 //void checkNewText() {
 373 //    Guchar*alpha = rgbdev->getBitmap()->getAlphaPtr();
 374 //    Guchar*charpixels = clip1dev->getBitmap()->getDataPtr();
 375 //    int xx,yy;
 376 //    for(yy=0;yy<height;yy++) {
 377 //        Guchar*aline = &alpha[yy*width];
 378 //        Guchar*cline = &charpixels[yy*width8];
 379 //        for(xx=0;xx<width;xx++) {
 380 //            int bit = xx&7;
 381 //            int bytepos = xx>>3;
 382 //            /* TODO: is the bit order correct? */
 383 //            if(aline[xx] && (cline[bytepos]&(1<<bit)))
 384 //              break;
 385 //        }
 386 //        if(xx!=width)
 387 //            break;
 388 //}
 389
 390 GBool BitmapOutputDev::clip0and1differ()
 391 {
 392     if(clip0dev->getBitmap()->getMode()==splashModeMono1) {
 393         SplashBitmap*clip0 = clip0dev->getBitmap();
 394         SplashBitmap*clip1 = clip1dev->getBitmap();
 395         int width8 = (clip0->getWidth()+7)/8;
 396         int height = clip0->getHeight();
 397         return memcmp(clip0->getDataPtr(), clip1->getDataPtr(), width8*height);
 398     } else {
 399         SplashBitmap*clip0 = clip0dev->getBitmap();
 400         SplashBitmap*clip1 = clip1dev->getBitmap();
 401         int width = clip0->getAlphaRowSize();
 402         int height = clip0->getHeight();
 403         return memcmp(clip0->getAlphaPtr(), clip1->getAlphaPtr(), width*height);
 404     }
 405 }
 406
 407 static void clearBooleanDev(SplashOutputDev*dev)
 408 {
 409     SplashBitmap*btm = dev->getBitmap();
 410     if(btm->getMode()==splashModeMono1) {
 411         int width8 = (btm->getWidth()+7)/8;
 412         int width = btm->getWidth();
 413         int height = btm->getHeight();
 414         memset(btm->getDataPtr(), 0, width8*height);
 415     } else {
 416         int width = btm->getAlphaRowSize();
 417         int height = btm->getHeight();
 418         memset(btm->getAlphaPtr(), 0, width*height);
 419     }
 420 }
 421
 422 GBool BitmapOutputDev::intersection()
 423 {
 424     SplashBitmap*boolpoly = boolpolydev->getBitmap();
 425     SplashBitmap*booltext = booltextdev->getBitmap();
 426
 427     if(boolpoly->getMode()==splashModeMono1) {
 428         /* alternative implementation, using one bit per pixel-
 429            would work if xpdf wouldn't try to dither everything */
 430
 431         Guchar*polypixels = boolpoly->getDataPtr();
 432         Guchar*textpixels = booltext->getDataPtr();
 433
 434         int width8 = (width+7)/8;
 435         int height = boolpoly->getHeight();
 436
 437         int t;
 438         int len = height*width8;
 439         unsigned int c=0;
 440         if(len & (sizeof(unsigned int)-1)) {
 441             Guchar c2=0;
 442             for(t=0;t<len;t++) {
 443                 c2 |= polypixels[t]&textpixels[t];
 444             }
 445             c = c2;
 446         } else {
 447             len /= sizeof(unsigned int);
 448             for(t=0;t<len;t++) {
 449                 c |= (((unsigned int*)polypixels)[t]) & (((unsigned int*)textpixels)[t]);
 450             }
 451         }
 452         if(c)
 453             /* if graphic data and the characters overlap, they have common bits */
 454             return gTrue;
 455         else
 456             return gFalse;
 457     } else {
 458         Guchar*polypixels = boolpoly->getAlphaPtr();
 459         Guchar*textpixels = booltext->getAlphaPtr();
 460
 461         int width = boolpoly->getAlphaRowSize();
 462         int height = boolpoly->getHeight();
 463
 464         int t;
 465         int len = height*width;
 466         unsigned int c=0;
 467         if(len & (sizeof(unsigned int)-1)) {
 468             Guchar c2=0;
 469             for(t=0;t<len;t++) {
 470                 if(polypixels[t]&&textpixels[t])
 471                     return gTrue;
 472             }
 473         } else {
 474             len /= sizeof(unsigned int);
 475             for(t=0;t<len;t++) {
 476                 if((((unsigned int*)polypixels)[t]) & (((unsigned int*)textpixels)[t]))
 477                     return gTrue;
 478             }
 479         }
 480         return gFalse;
 481     }
 482 }
 483
 484
 485 void BitmapOutputDev::startPage(int pageNum, GfxState *state, double crop_x1, double crop_y1, double crop_x2, double crop_y2)
 486 {
 487     double x1,y1,x2,y2;
 488     state->transform(crop_x1,crop_y1,&x1,&y1);
 489     state->transform(crop_x2,crop_y2,&x2,&y2);
 490     if(x2<x1) {double x3=x1;x1=x2;x2=x3;}
 491     if(y2<y1) {double y3=y1;y1=y2;y2=y3;}
 492
 493     this->movex = -(int)x1 - user_movex;
 494     this->movey = -(int)y1 - user_movey;
 495
 496     if(user_clipx1|user_clipy1|user_clipx2|user_clipy2) {
 497         x1 = user_clipx1;
 498         x2 = user_clipx2;
 499         y1 = user_clipy1;
 500         y2 = user_clipy2;
 501     }
 502     this->width = (int)(x2-x1);
 503     this->height = (int)(y2-y1);
 504
 505     msg("<debug> startPage");
 506     rgbdev->startPage(pageNum, state, crop_x1, crop_y1, crop_x2, crop_y2);
 507     boolpolydev->startPage(pageNum, state, crop_x1, crop_y1, crop_x2, crop_y2);
 508     booltextdev->startPage(pageNum, state, crop_x1, crop_y1, crop_x2, crop_y2);
 509     clip0dev->startPage(pageNum, state, crop_x1, crop_y1, crop_x2, crop_y2);
 510     clip1dev->startPage(pageNum, state, crop_x1, crop_y1, crop_x2, crop_y2);
 511     gfxdev->startPage(pageNum, state, crop_x1, crop_y1, crop_x2, crop_y2);
 512
 513     flushText(); // write out the initial clipping rectangle
 514
 515     /* just in case any device did draw a white background rectangle
 516        into the device */
 517     clearBoolTextDev();
 518     clearBoolPolyDev();
 519
 520     this->layerstate = STATE_PARALLEL;
 521 }
 522
 523 void BitmapOutputDev::endPage()
 524 {
 525     msg("<verbose> endPage (BitmapOutputDev)");
 526
 527     if(layerstate == STATE_BITMAP_IS_ABOVE) {
 528         this->flushText();
 529         this->flushBitmap();
 530     } else {
 531         this->flushBitmap();
 532         this->flushText();
 533     }
 534
 535     /* splash will now destroy alpha, and paint the
 536        background color into the "holes" in the bitmap */
 537     boolpolydev->endPage();
 538     booltextdev->endPage();
 539     rgbdev->endPage();
 540     clip0dev->endPage();
 541     clip1dev->endPage();
 542     gfxdev->endPage();
 543 }
 544
 545 GBool BitmapOutputDev::upsideDown()
 546 {
 547     boolpolydev->upsideDown();
 548     booltextdev->upsideDown();
 549     clip0dev->upsideDown();
 550     clip1dev->upsideDown();
 551     return rgbdev->upsideDown();
 552 }
 553
 554 GBool BitmapOutputDev::useDrawChar()
 555 {
 556     boolpolydev->useDrawChar();
 557     booltextdev->useDrawChar();
 558     clip0dev->useDrawChar();
 559     clip1dev->useDrawChar();
 560     return rgbdev->useDrawChar();
 561 }
 562
 563 GBool BitmapOutputDev::useTilingPatternFill()
 564 {
 565     boolpolydev->useTilingPatternFill();
 566     booltextdev->useTilingPatternFill();
 567     clip0dev->useTilingPatternFill();
 568     clip1dev->useTilingPatternFill();
 569     return rgbdev->useTilingPatternFill();
 570 }
 571
 572 GBool BitmapOutputDev::useShadedFills()
 573 {
 574     boolpolydev->useShadedFills();
 575     booltextdev->useShadedFills();
 576     clip0dev->useShadedFills();
 577     clip1dev->useShadedFills();
 578     return rgbdev->useShadedFills();
 579 }
 580
 581 GBool BitmapOutputDev::useDrawForm()
 582 {
 583     boolpolydev->useDrawForm();
 584     booltextdev->useDrawForm();
 585     clip0dev->useDrawForm();
 586     clip1dev->useDrawForm();
 587     return rgbdev->useDrawForm();
 588 }
 589
 590 GBool BitmapOutputDev::interpretType3Chars()
 591 {
 592     if(!config_bitmapfonts) {
 593         boolpolydev->interpretType3Chars();
 594         booltextdev->interpretType3Chars();
 595         clip0dev->interpretType3Chars();
 596         clip1dev->interpretType3Chars();
 597         return rgbdev->interpretType3Chars();
 598     } else {
 599         return gfxdev->interpretType3Chars();
 600     }
 601 }
 602
 603 GBool BitmapOutputDev::needNonText()
 604 {
 605     boolpolydev->needNonText();
 606     booltextdev->needNonText();
 607     clip0dev->needNonText();
 608     clip1dev->needNonText();
 609     return rgbdev->needNonText();
 610 }
 611 /*GBool BitmapOutputDev::checkPageSlice(Page *page, double hDPI, double vDPI,
 612                            int rotate, GBool useMediaBox, GBool crop,
 613                            int sliceX, int sliceY, int sliceW, int sliceH,
 614                            GBool printing, Catalog *catalog,
 615                            GBool (*abortCheckCbk)(void *data),
 616                            void *abortCheckCbkData)
 617 {
 618     return gTrue;
 619 }*/
 620 void BitmapOutputDev::setDefaultCTM(double *ctm)
 621 {
 622     boolpolydev->setDefaultCTM(ctm);
 623     booltextdev->setDefaultCTM(ctm);
 624     rgbdev->setDefaultCTM(ctm);
 625     clip0dev->setDefaultCTM(ctm);
 626     clip1dev->setDefaultCTM(ctm);
 627     //gfxdev->setDefaultCTM(ctm);//?
 628 }
 629 void BitmapOutputDev::saveState(GfxState *state)
 630 {
 631     boolpolydev->saveState(state);
 632     booltextdev->saveState(state);
 633     rgbdev->saveState(state);
 634     clip0dev->saveState(state);
 635     clip1dev->saveState(state);
 636
 637     /*ClipState*cstate = new ClipState();
 638     cstate->next = this->clipstates;
 639     this->clipstates = cstate;*/
 640 }
 641 void BitmapOutputDev::restoreState(GfxState *state)
 642 {
 643     boolpolydev->restoreState(state);
 644     booltextdev->restoreState(state);
 645     rgbdev->restoreState(state);
 646     clip0dev->restoreState(state);
 647     clip1dev->restoreState(state);
 648
 649     /*if(this->clipstates) {
 650         ClipState*old = this->clipstates;
 651         if(old->written) {
 652             gfxdev->restoreState(state);
 653         }
 654         this->clipstates = this->clipstates->next;
 655         delete(old);
 656     } else {
 657         msg("<error> invalid restoreState()");
 658     }*/
 659 }
 660 void BitmapOutputDev::updateAll(GfxState *state)
 661 {
 662     boolpolydev->updateAll(state);
 663     booltextdev->updateAll(state);
 664     rgbdev->updateAll(state);
 665     clip0dev->updateAll(state);
 666     clip1dev->updateAll(state);
 667     if(!config_bitmapfonts)
 668         gfxdev->updateAll(state);
 669 }
 670 void BitmapOutputDev::updateCTM(GfxState *state, double m11, double m12, double m21, double m22, double m31, double m32)
 671 {
 672     boolpolydev->updateCTM(state,m11,m12,m21,m22,m31,m32);
 673     booltextdev->updateCTM(state,m11,m12,m21,m22,m31,m32);
 674     rgbdev->updateCTM(state,m11,m12,m21,m22,m31,m32);
 675     clip0dev->updateCTM(state,m11,m12,m21,m22,m31,m32);
 676     clip1dev->updateCTM(state,m11,m12,m21,m22,m31,m32);
 677     if(!config_bitmapfonts)
 678         gfxdev->updateCTM(state,m11,m12,m21,m22,m31,m32);
 679 }
 680 void BitmapOutputDev::updateLineDash(GfxState *state)
 681 {
 682     boolpolydev->updateLineDash(state);
 683     booltextdev->updateLineDash(state);
 684     rgbdev->updateLineDash(state);
 685     clip0dev->updateLineDash(state);
 686     clip1dev->updateLineDash(state);
 687     if(!config_bitmapfonts)
 688         gfxdev->updateLineDash(state);
 689 }
 690 void BitmapOutputDev::updateFlatness(GfxState *state)
 691 {
 692     boolpolydev->updateFlatness(state);
 693     booltextdev->updateFlatness(state);
 694     rgbdev->updateFlatness(state);
 695     clip0dev->updateFlatness(state);
 696     clip1dev->updateFlatness(state);
 697     if(!config_bitmapfonts)
 698         gfxdev->updateFlatness(state);
 699 }
 700 void BitmapOutputDev::updateLineJoin(GfxState *state)
 701 {
 702     boolpolydev->updateLineJoin(state);
 703     booltextdev->updateLineJoin(state);
 704     rgbdev->updateLineJoin(state);
 705     clip0dev->updateLineJoin(state);
 706     clip1dev->updateLineJoin(state);
 707     if(!config_bitmapfonts)
 708         gfxdev->updateLineJoin(state);
 709 }
 710 void BitmapOutputDev::updateLineCap(GfxState *state)
 711 {
 712     boolpolydev->updateLineCap(state);
 713     booltextdev->updateLineCap(state);
 714     rgbdev->updateLineCap(state);
 715     clip0dev->updateLineCap(state);
 716     clip1dev->updateLineCap(state);
 717     if(!config_bitmapfonts)
 718         gfxdev->updateLineCap(state);
 719 }
 720 void BitmapOutputDev::updateMiterLimit(GfxState *state)
 721 {
 722     boolpolydev->updateMiterLimit(state);
 723     booltextdev->updateMiterLimit(state);
 724     rgbdev->updateMiterLimit(state);
 725     clip0dev->updateMiterLimit(state);
 726     clip1dev->updateMiterLimit(state);
 727     if(!config_bitmapfonts)
 728         gfxdev->updateMiterLimit(state);
 729 }
 730 void BitmapOutputDev::updateLineWidth(GfxState *state)
 731 {
 732     boolpolydev->updateLineWidth(state);
 733     booltextdev->updateLineWidth(state);
 734     rgbdev->updateLineWidth(state);
 735     clip0dev->updateLineWidth(state);
 736     clip1dev->updateLineWidth(state);
 737     if(!config_bitmapfonts)
 738         gfxdev->updateLineWidth(state);
 739 }
 740 void BitmapOutputDev::updateStrokeAdjust(GfxState *state)
 741 {
 742     boolpolydev->updateStrokeAdjust(state);
 743     booltextdev->updateStrokeAdjust(state);
 744     rgbdev->updateStrokeAdjust(state);
 745     clip0dev->updateStrokeAdjust(state);
 746     clip1dev->updateStrokeAdjust(state);
 747     if(!config_bitmapfonts)
 748         gfxdev->updateStrokeAdjust(state);
 749 }
 750 void BitmapOutputDev::updateFillColorSpace(GfxState *state)
 751 {
 752     boolpolydev->updateFillColorSpace(state);
 753     booltextdev->updateFillColorSpace(state);
 754     rgbdev->updateFillColorSpace(state);
 755     clip0dev->updateFillColorSpace(state);
 756     clip1dev->updateFillColorSpace(state);
 757     if(!config_bitmapfonts)
 758         gfxdev->updateFillColorSpace(state);
 759 }
 760 void BitmapOutputDev::updateStrokeColorSpace(GfxState *state)
 761 {
 762     boolpolydev->updateStrokeColorSpace(state);
 763     booltextdev->updateStrokeColorSpace(state);
 764     rgbdev->updateStrokeColorSpace(state);
 765     clip0dev->updateStrokeColorSpace(state);
 766     clip1dev->updateStrokeColorSpace(state);
 767     if(!config_bitmapfonts)
 768         gfxdev->updateStrokeColorSpace(state);
 769 }
 770 void BitmapOutputDev::updateFillColor(GfxState *state)
 771 {
 772     boolpolydev->updateFillColor(state);
 773     booltextdev->updateFillColor(state);
 774     rgbdev->updateFillColor(state);
 775     clip0dev->updateFillColor(state);
 776     clip1dev->updateFillColor(state);
 777     if(!config_bitmapfonts)
 778         gfxdev->updateFillColor(state);
 779 }
 780 void BitmapOutputDev::updateStrokeColor(GfxState *state)
 781 {
 782     boolpolydev->updateStrokeColor(state);
 783     booltextdev->updateStrokeColor(state);
 784     rgbdev->updateStrokeColor(state);
 785     clip0dev->updateStrokeColor(state);
 786     clip1dev->updateStrokeColor(state);
 787     if(!config_bitmapfonts)
 788         gfxdev->updateStrokeColor(state);
 789 }
 790 void BitmapOutputDev::updateBlendMode(GfxState *state)
 791 {
 792     boolpolydev->updateBlendMode(state);
 793     booltextdev->updateBlendMode(state);
 794     rgbdev->updateBlendMode(state);
 795     clip0dev->updateBlendMode(state);
 796     clip1dev->updateBlendMode(state);
 797     if(!config_bitmapfonts)
 798         gfxdev->updateBlendMode(state);
 799 }
 800 void BitmapOutputDev::updateFillOpacity(GfxState *state)
 801 {
 802     boolpolydev->updateFillOpacity(state);
 803     booltextdev->updateFillOpacity(state);
 804     rgbdev->updateFillOpacity(state);
 805     clip0dev->updateFillOpacity(state);
 806     clip1dev->updateFillOpacity(state);
 807     if(!config_bitmapfonts)
 808         gfxdev->updateFillOpacity(state);
 809 }
 810 void BitmapOutputDev::updateStrokeOpacity(GfxState *state)
 811 {
 812     boolpolydev->updateStrokeOpacity(state);
 813     booltextdev->updateStrokeOpacity(state);
 814     rgbdev->updateStrokeOpacity(state);
 815     clip0dev->updateStrokeOpacity(state);
 816     clip1dev->updateStrokeOpacity(state);
 817     if(!config_bitmapfonts)
 818         gfxdev->updateStrokeOpacity(state);
 819 }
 820 void BitmapOutputDev::updateFillOverprint(GfxState *state)
 821 {
 822     boolpolydev->updateFillOverprint(state);
 823     booltextdev->updateFillOverprint(state);
 824     rgbdev->updateFillOverprint(state);
 825     clip0dev->updateFillOverprint(state);
 826     clip1dev->updateFillOverprint(state);
 827     if(!config_bitmapfonts)
 828         gfxdev->updateFillOverprint(state);
 829 }
 830 void BitmapOutputDev::updateStrokeOverprint(GfxState *state)
 831 {
 832     boolpolydev->updateStrokeOverprint(state);
 833     booltextdev->updateStrokeOverprint(state);
 834     rgbdev->updateStrokeOverprint(state);
 835     clip0dev->updateStrokeOverprint(state);
 836     clip1dev->updateStrokeOverprint(state);
 837     if(!config_bitmapfonts)
 838         gfxdev->updateStrokeOverprint(state);
 839 }
 840 void BitmapOutputDev::updateTransfer(GfxState *state)
 841 {
 842     boolpolydev->updateTransfer(state);
 843     booltextdev->updateTransfer(state);
 844     rgbdev->updateTransfer(state);
 845     clip0dev->updateTransfer(state);
 846     clip1dev->updateTransfer(state);
 847     if(!config_bitmapfonts)
 848         gfxdev->updateTransfer(state);
 849 }
 850 void BitmapOutputDev::updateFont(GfxState *state)
 851 {
 852     boolpolydev->updateFont(state);
 853     booltextdev->updateFont(state);
 854     rgbdev->updateFont(state);
 855     clip0dev->updateFont(state);
 856     clip1dev->updateFont(state);
 857     if(!config_bitmapfonts)
 858         gfxdev->updateFont(state);
 859 }
 860 void BitmapOutputDev::updateTextMat(GfxState *state)
 861 {
 862     boolpolydev->updateTextMat(state);
 863     booltextdev->updateTextMat(state);
 864     rgbdev->updateTextMat(state);
 865     clip0dev->updateTextMat(state);
 866     clip1dev->updateTextMat(state);
 867     if(!config_bitmapfonts)
 868         gfxdev->updateTextMat(state);
 869 }
 870 void BitmapOutputDev::updateCharSpace(GfxState *state)
 871 {
 872     boolpolydev->updateCharSpace(state);
 873     booltextdev->updateCharSpace(state);
 874     rgbdev->updateCharSpace(state);
 875     clip0dev->updateCharSpace(state);
 876     clip1dev->updateCharSpace(state);
 877     if(!config_bitmapfonts)
 878         gfxdev->updateCharSpace(state);
 879 }
 880 void BitmapOutputDev::updateRender(GfxState *state)
 881 {
 882     boolpolydev->updateRender(state);
 883     booltextdev->updateRender(state);
 884     rgbdev->updateRender(state);
 885     clip0dev->updateRender(state);
 886     clip1dev->updateRender(state);
 887     if(!config_bitmapfonts)
 888         gfxdev->updateRender(state);
 889 }
 890 void BitmapOutputDev::updateRise(GfxState *state)
 891 {
 892     boolpolydev->updateRise(state);
 893     booltextdev->updateRise(state);
 894     rgbdev->updateRise(state);
 895     clip0dev->updateRise(state);
 896     clip1dev->updateRise(state);
 897     if(!config_bitmapfonts)
 898         gfxdev->updateRise(state);
 899 }
 900 void BitmapOutputDev::updateWordSpace(GfxState *state)
 901 {
 902     boolpolydev->updateWordSpace(state);
 903     booltextdev->updateWordSpace(state);
 904     rgbdev->updateWordSpace(state);
 905     clip0dev->updateWordSpace(state);
 906     clip1dev->updateWordSpace(state);
 907     if(!config_bitmapfonts)
 908         gfxdev->updateWordSpace(state);
 909 }
 910 void BitmapOutputDev::updateHorizScaling(GfxState *state)
 911 {
 912     boolpolydev->updateHorizScaling(state);
 913     booltextdev->updateHorizScaling(state);
 914     rgbdev->updateHorizScaling(state);
 915     clip0dev->updateHorizScaling(state);
 916     clip1dev->updateHorizScaling(state);
 917     if(!config_bitmapfonts)
 918         gfxdev->updateHorizScaling(state);
 919 }
 920 void BitmapOutputDev::updateTextPos(GfxState *state)
 921 {
 922     boolpolydev->updateTextPos(state);
 923     booltextdev->updateTextPos(state);
 924     rgbdev->updateTextPos(state);
 925     clip0dev->updateTextPos(state);
 926     clip1dev->updateTextPos(state);
 927     if(!config_bitmapfonts)
 928         gfxdev->updateTextPos(state);
 929 }
 930 void BitmapOutputDev::updateTextShift(GfxState *state, double shift)
 931 {
 932     boolpolydev->updateTextShift(state, shift);
 933     booltextdev->updateTextShift(state, shift);
 934     rgbdev->updateTextShift(state, shift);
 935     clip0dev->updateTextShift(state, shift);
 936     clip1dev->updateTextShift(state, shift);
 937     if(!config_bitmapfonts)
 938         gfxdev->updateTextShift(state, shift);
 939 }
 940
 941 void BitmapOutputDev::stroke(GfxState *state)
 942 {
 943     msg("<debug> stroke");
 944     boolpolydev->stroke(state);
 945     checkNewBitmap();
 946     rgbdev->stroke(state);
 947 }
 948 void BitmapOutputDev::fill(GfxState *state)
 949 {
 950     msg("<debug> fill");
 951     boolpolydev->fill(state);
 952     checkNewBitmap();
 953     rgbdev->fill(state);
 954 }
 955 void BitmapOutputDev::eoFill(GfxState *state)
 956 {
 957     msg("<debug> eoFill");
 958     boolpolydev->eoFill(state);
 959     checkNewBitmap();
 960     rgbdev->eoFill(state);
 961 }
 962 #if (xpdfMajorVersion*10000 + xpdfMinorVersion*100 + xpdfUpdateVersion) < 30207
 963 void BitmapOutputDev::tilingPatternFill(GfxState *state, Object *str,
 964                                int paintType, Dict *resDict,
 965                                double *mat, double *bbox,
 966                                int x0, int y0, int x1, int y1,
 967                                double xStep, double yStep)
 968 {
 969     msg("<debug> tilingPatternFill");
 970     boolpolydev->tilingPatternFill(state, str, paintType, resDict, mat, bbox, x0, y0, x1, y1, xStep, yStep);
 971     checkNewBitmap();
 972     rgbdev->tilingPatternFill(state, str, paintType, resDict, mat, bbox, x0, y0, x1, y1, xStep, yStep);
 973 }
 974 #else
 975 void BitmapOutputDev::tilingPatternFill(GfxState *state, Gfx *gfx, Object *str,
 976                                int paintType, Dict *resDict,
 977                                double *mat, double *bbox,
 978                                int x0, int y0, int x1, int y1,
 979                                double xStep, double yStep)
 980 {
 981     msg("<debug> tilingPatternFill");
 982     boolpolydev->tilingPatternFill(state, gfx, str, paintType, resDict, mat, bbox, x0, y0, x1, y1, xStep, yStep);
 983     checkNewBitmap();
 984     rgbdev->tilingPatternFill(state, gfx, str, paintType, resDict, mat, bbox, x0, y0, x1, y1, xStep, yStep);
 985 }
 986 #endif
 987
 988 GBool BitmapOutputDev::functionShadedFill(GfxState *state, GfxFunctionShading *shading)
 989 {
 990     msg("<debug> functionShadedFill");
 991     boolpolydev->functionShadedFill(state, shading);
 992     checkNewBitmap();
 993     return rgbdev->functionShadedFill(state, shading);
 994 }
 995 GBool BitmapOutputDev::axialShadedFill(GfxState *state, GfxAxialShading *shading)
 996 {
 997     msg("<debug> axialShadedFill");
 998     boolpolydev->axialShadedFill(state, shading);
 999     checkNewBitmap();
1000     return rgbdev->axialShadedFill(state, shading);
1001 }
1002 GBool BitmapOutputDev::radialShadedFill(GfxState *state, GfxRadialShading *shading)
1003 {
1004     msg("<debug> radialShadedFill");
1005     boolpolydev->radialShadedFill(state, shading);
1006     checkNewBitmap();
1007     return rgbdev->radialShadedFill(state, shading);
1008 }
1009
1010 SplashColor black = {0,0,0};
1011 SplashColor white = {255,255,255};
1012
1013 void BitmapOutputDev::clip(GfxState *state)
1014 {
1015     msg("<debug> clip");
1016     boolpolydev->clip(state);
1017     booltextdev->clip(state);
1018     rgbdev->clip(state);
1019     clip1dev->clip(state);
1020 }
1021 void BitmapOutputDev::eoClip(GfxState *state)
1022 {
1023     msg("<debug> eoClip");
1024     boolpolydev->eoClip(state);
1025     booltextdev->eoClip(state);
1026     rgbdev->eoClip(state);
1027     clip1dev->eoClip(state);
1028 }
1029 void BitmapOutputDev::clipToStrokePath(GfxState *state)
1030 {
1031     msg("<debug> clipToStrokePath");
1032     boolpolydev->clipToStrokePath(state);
1033     booltextdev->clipToStrokePath(state);
1034     rgbdev->clipToStrokePath(state);
1035     clip1dev->clipToStrokePath(state);
1036 }
1037
1038 void BitmapOutputDev::beginStringOp(GfxState *state)
1039 {
1040     msg("<debug> beginStringOp");
1041     if(this->config_bitmapfonts) {
1042         rgbdev->beginStringOp(state);
1043     } else {
1044         clip0dev->beginStringOp(state);
1045         clip1dev->beginStringOp(state);
1046         booltextdev->beginStringOp(state);
1047         gfxdev->beginStringOp(state);
1048     }
1049 }
1050 void BitmapOutputDev::endStringOp(GfxState *state)
1051 {
1052     msg("<debug> endStringOp");
1053     if(this->config_bitmapfonts) {
1054         rgbdev->endStringOp(state);
1055     } else {
1056         clip0dev->endStringOp(state);
1057         clip1dev->endStringOp(state);
1058         booltextdev->endStringOp(state);
1059         checkNewText();
1060         gfxdev->endStringOp(state);
1061     }
1062 }
1063 void BitmapOutputDev::beginString(GfxState *state, GString *s)
1064 {
1065     msg("<debug> beginString");
1066     if(this->config_bitmapfonts) {
1067         rgbdev->beginString(state, s);
1068     } else {
1069         clip0dev->beginString(state, s);
1070         clip1dev->beginString(state, s);
1071         booltextdev->beginString(state, s);
1072         gfxdev->beginString(state, s);
1073     }
1074 }
1075 void BitmapOutputDev::endString(GfxState *state)
1076 {
1077     msg("<debug> endString");
1078     if(this->config_bitmapfonts) {
1079         rgbdev->endString(state);
1080     } else {
1081         clip0dev->endString(state);
1082         clip1dev->endString(state);
1083         booltextdev->endString(state);
1084         checkNewText();
1085         gfxdev->endString(state);
1086     }
1087 }
1088
1089 void BitmapOutputDev::clearClips()
1090 {
1091     clearBooleanDev(clip0dev);
1092     clearBooleanDev(clip1dev);
1093 }
1094 void BitmapOutputDev::clearBoolPolyDev()
1095 {
1096     clearBooleanDev(boolpolydev);
1097 }
1098 void BitmapOutputDev::clearBoolTextDev()
1099 {
1100     clearBooleanDev(booltextdev);
1101 }
1102 void BitmapOutputDev::drawChar(GfxState *state, double x, double y,
1103                       double dx, double dy,
1104                       double originX, double originY,
1105                       CharCode code, int nBytes, Unicode *u, int uLen)
1106 {
1107     msg("<debug> drawChar");
1108     if(this->config_bitmapfonts || (state->getRender()&4) /*clip*/ ) {
1109         rgbdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1110     } else {
1111         clearClips();
1112         clip0dev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1113         clip1dev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1114
1115         /* if this character is affected somehow by the various clippings (i.e., it looks
1116            different on a device without clipping), then draw it on the bitmap, not as
1117            text */
1118         if(clip0and1differ()) {
1119             msg("<verbose> Char %d is affected by clipping", code);
1120             boolpolydev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1121             checkNewBitmap();
1122             rgbdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1123             if(config_extrafontdata) {
1124                 int oldrender = state->getRender();
1125                 state->setRender(3); //invisible
1126                 gfxdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1127                 state->setRender(oldrender);
1128             }
1129         } else {
1130             /* this char is not at all affected by clipping.
1131                Now just dump out the bitmap we're currently working on, if necessary. */
1132             booltextdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1133             checkNewText();
1134             /* use polygonal output device to do the actual text handling */
1135             gfxdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1136         }
1137     }
1138 }
1139 void BitmapOutputDev::drawString(GfxState *state, GString *s)
1140 {
1141     msg("<error> internal error: drawString not implemented");
1142     return;
1143     if(this->config_bitmapfonts) {
1144         rgbdev->drawString(state, s);
1145         clip0dev->drawString(state, s);
1146         clip1dev->drawString(state, s);
1147     } else {
1148         booltextdev->drawString(state, s);
1149         gfxdev->drawString(state, s);
1150     }
1151 }
1152 void BitmapOutputDev::endTextObject(GfxState *state)
1153 {
1154     /* FIXME: the below might render things (stroke outlines etc.) to gfxdev which
1155               might end up unflushed- should be handled similarily as
1156               drawChar() above
1157      */
1158     msg("<debug> endTextObject");
1159     if(this->config_bitmapfonts) {
1160         rgbdev->endTextObject(state);
1161     } else {
1162         clip0dev->endTextObject(state);
1163         clip1dev->endTextObject(state);
1164         gfxdev->endType3Char(state);
1165     }
1166 }
1167
1168 /* TODO: these four operations below *should* do nothing, as type3
1169          chars are drawn using operations like fill() */
1170 GBool BitmapOutputDev::beginType3Char(GfxState *state, double x, double y,
1171                              double dx, double dy,
1172                              CharCode code, Unicode *u, int uLen)
1173 {
1174     msg("<debug> beginType3Char");
1175     if(this->config_bitmapfonts) {
1176         return rgbdev->beginType3Char(state, x, y, dx, dy, code, u, uLen);
1177     } else {
1178         /* call gfxdev so that it can generate "invisible" characters
1179            on top of the actual graphic content, for text extraction */
1180         return gfxdev->beginType3Char(state, x, y, dx, dy, code, u, uLen);
1181     }
1182 }
1183 void BitmapOutputDev::type3D0(GfxState *state, double wx, double wy)
1184 {
1185     msg("<debug> type3D0");
1186     if(this->config_bitmapfonts) {
1187         rgbdev->type3D0(state, wx, wy);
1188     } else {
1189         return gfxdev->type3D0(state, wx, wy);
1190     }
1191 }
1192 void BitmapOutputDev::type3D1(GfxState *state, double wx, double wy, double llx, double lly, double urx, double ury)
1193 {
1194     msg("<debug> type3D1");
1195     if(this->config_bitmapfonts) {
1196         rgbdev->type3D1(state, wx, wy, llx, lly, urx, ury);
1197     } else {
1198         return gfxdev->type3D1(state, wx, wy, llx, lly, urx, ury);
1199     }
1200 }
1201 void BitmapOutputDev::endType3Char(GfxState *state)
1202 {
1203     msg("<debug> endType3Char");
1204     if(this->config_bitmapfonts) {
1205         rgbdev->endType3Char(state);
1206     } else {
1207         gfxdev->endType3Char(state);
1208     }
1209 }
1210 void BitmapOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str,
1211                            int width, int height, GBool invert,
1212                            GBool inlineImg)
1213 {
1214     msg("<debug> drawImageMask");
1215     boolpolydev->drawImageMask(state, ref, str, width, height, invert, inlineImg);
1216     checkNewBitmap();
1217     rgbdev->drawImageMask(state, ref, str, width, height, invert, inlineImg);
1218 }
1219 void BitmapOutputDev::drawImage(GfxState *state, Object *ref, Stream *str,
1220                        int width, int height, GfxImageColorMap *colorMap,
1221                        int *maskColors, GBool inlineImg)
1222 {
1223     msg("<debug> drawImage");
1224     boolpolydev->drawImage(state, ref, str, width, height, colorMap, maskColors, inlineImg);
1225     checkNewBitmap();
1226     rgbdev->drawImage(state, ref, str, width, height, colorMap, maskColors, inlineImg);
1227 }
1228 void BitmapOutputDev::drawMaskedImage(GfxState *state, Object *ref, Stream *str,
1229                              int width, int height,
1230                              GfxImageColorMap *colorMap,
1231                              Stream *maskStr, int maskWidth, int maskHeight,
1232                              GBool maskInvert)
1233 {
1234     msg("<debug> drawMaskedImage");
1235     boolpolydev->drawMaskedImage(state, ref, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskInvert);
1236     checkNewBitmap();
1237     rgbdev->drawMaskedImage(state, ref, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskInvert);
1238 }
1239 void BitmapOutputDev::drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str,
1240                                  int width, int height,
1241                                  GfxImageColorMap *colorMap,
1242                                  Stream *maskStr,
1243                                  int maskWidth, int maskHeight,
1244                                  GfxImageColorMap *maskColorMap)
1245 {
1246     msg("<debug> drawSoftMaskedImage");
1247     boolpolydev->drawSoftMaskedImage(state, ref, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskColorMap);
1248     checkNewBitmap();
1249     rgbdev->drawSoftMaskedImage(state, ref, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskColorMap);
1250 }
1251 void BitmapOutputDev::drawForm(Ref id)
1252 {
1253     msg("<debug> drawForm");
1254     boolpolydev->drawForm(id);
1255     checkNewBitmap();
1256     rgbdev->drawForm(id);
1257 }
1258
1259 void BitmapOutputDev::processLink(Link *link, Catalog *catalog)
1260 {
1261     msg("<debug> processLink");
1262     gfxdev->processLink(link, catalog);
1263 }
1264
1265 void BitmapOutputDev::beginTransparencyGroup(GfxState *state, double *bbox,
1266                                     GfxColorSpace *blendingColorSpace,
1267                                     GBool isolated, GBool knockout,
1268                                     GBool forSoftMask)
1269 {
1270     msg("<debug> beginTransparencyGroup");
1271     boolpolydev->beginTransparencyGroup(state, bbox, blendingColorSpace, isolated, knockout, forSoftMask);
1272     rgbdev->beginTransparencyGroup(state, bbox, blendingColorSpace, isolated, knockout, forSoftMask);
1273     clip1dev->beginTransparencyGroup(state, bbox, blendingColorSpace, isolated, knockout, forSoftMask);
1274 }
1275 void BitmapOutputDev::endTransparencyGroup(GfxState *state)
1276 {
1277     msg("<debug> endTransparencyGroup");
1278     boolpolydev->endTransparencyGroup(state);
1279     checkNewBitmap();
1280     rgbdev->endTransparencyGroup(state);
1281     clip1dev->endTransparencyGroup(state);
1282 }
1283 void BitmapOutputDev::paintTransparencyGroup(GfxState *state, double *bbox)
1284 {
1285     msg("<debug> paintTransparencyGroup");
1286     boolpolydev->paintTransparencyGroup(state,bbox);
1287     checkNewBitmap();
1288     rgbdev->paintTransparencyGroup(state,bbox);
1289 }
1290 void BitmapOutputDev::setSoftMask(GfxState *state, double *bbox, GBool alpha, Function *transferFunc, GfxColor *backdropColor)
1291 {
1292     msg("<debug> setSoftMask");
1293     boolpolydev->setSoftMask(state, bbox, alpha, transferFunc, backdropColor);
1294     checkNewBitmap();
1295     rgbdev->setSoftMask(state, bbox, alpha, transferFunc, backdropColor);
1296     clip1dev->setSoftMask(state, bbox, alpha, transferFunc, backdropColor);
1297 }
1298 void BitmapOutputDev::clearSoftMask(GfxState *state)
1299 {
1300     msg("<debug> clearSoftMask");
1301     boolpolydev->clearSoftMask(state);
1302     checkNewBitmap();
1303     rgbdev->clearSoftMask(state);
1304     clip1dev->clearSoftMask(state);
1305 }