lib/pdf/GFXOutputDev.cc

   1 /* GFXOutputDev.cc
   2    implements a pdf output device (OutputDev).
   3
   4    This file is part of swftools.
   5
   6    Swftools is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    Swftools is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with swftools; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <stdarg.h>
  23 #include <stddef.h>
  24 #include <string.h>
  25 #ifdef HAVE_UNISTD_H
  26 #include <unistd.h>
  27 #endif
  28 #include "../../config.h"
  29 #include "../os.h"
  30 #ifdef HAVE_DIRENT_H
  31 #include <dirent.h>
  32 #endif
  33 #ifdef HAVE_SYS_STAT_H
  34 #include <sys/stat.h>
  35 #endif
  36 #ifdef HAVE_FONTCONFIG
  37 #include <fontconfig.h>
  38 #endif
  39 //xpdf header files
  40 #include "config.h"
  41 #include "gfile.h"
  42 #include "GString.h"
  43 #include "gmem.h"
  44 #include "Object.h"
  45 #include "Stream.h"
  46 #include "Array.h"
  47 #include "Dict.h"
  48 #include "XRef.h"
  49 #include "Catalog.h"
  50 #include "Page.h"
  51 #include "PDFDoc.h"
  52 #include "Error.h"
  53 #include "Link.h"
  54 #include "OutputDev.h"
  55 #include "GfxFont.h"
  56 #include "GfxState.h"
  57 #include "CharCodeToUnicode.h"
  58 #include "NameToUnicodeTable.h"
  59 #include "GlobalParams.h"
  60 #include "FoFiType1C.h"
  61 #include "FoFiTrueType.h"
  62 #include "GHash.h"
  63 #include "GFXOutputDev.h"
  64
  65 //  swftools header files
  66 #include "../log.h"
  67 #include "../gfxdevice.h"
  68 #include "../gfxtools.h"
  69 #include "../gfxfont.h"
  70 #include "../gfxpoly.h"
  71 #include "../devices/record.h"
  72 #include "../devices/ops.h"
  73 #include "../devices/polyops.h"
  74 #include "../devices/render.h"
  75
  76 #include "../png.h"
  77 #include "fonts.h"
  78
  79 #include <math.h>
  80
  81 #define SQRT2 1.41421356237309504880
  82
  83 typedef struct _fontfile
  84 {
  85     const char*filename;
  86     int len; // basename length
  87     int used;
  88     struct _fontfile*next;
  89 } fontfile_t;
  90
  91 // for pdfswf_addfont
  92
  93 static fontfile_t* global_fonts = 0;
  94 static fontfile_t* global_fonts_next = 0;
  95
  96 static int fontnum = 0;
  97
  98 /* config */
  99
 100 static char* lastfontdir = 0;
 101
 102 struct fontentry {
 103     const char*pdffont;
 104     const char*filename;
 105     char*afm;
 106     int afmlen;
 107     char*pfb;
 108     int pfblen;
 109     char*fullfilename;
 110 } pdf2t1map[] ={
 111 {"Times-Roman",           "n021003l", n021003l_afm, n021003l_afm_len, n021003l_pfb, n021003l_pfb_len},
 112 {"Times-Italic",          "n021023l", n021023l_afm, n021023l_afm_len, n021023l_pfb, n021023l_pfb_len},
 113 {"Times-Bold",            "n021004l", n021004l_afm, n021004l_afm_len, n021004l_pfb, n021004l_pfb_len},
 114 {"Times-BoldItalic",      "n021024l", n021024l_afm, n021024l_afm_len, n021024l_pfb, n021024l_pfb_len},
 115 {"Helvetica",             "n019003l", n019003l_afm, n019003l_afm_len, n019003l_pfb, n019003l_pfb_len},
 116 {"Helvetica-Oblique",     "n019023l", n019023l_afm, n019023l_afm_len, n019023l_pfb, n019023l_pfb_len},
 117 {"Helvetica-Bold",        "n019004l", n019004l_afm, n019004l_afm_len, n019004l_pfb, n019004l_pfb_len},
 118 {"Helvetica-BoldOblique", "n019024l", n019024l_afm, n019024l_afm_len, n019024l_pfb, n019024l_pfb_len},
 119 {"Courier",               "n022003l", n022003l_afm, n022003l_afm_len, n022003l_pfb, n022003l_pfb_len},
 120 {"Courier-Oblique",       "n022023l", n022023l_afm, n022023l_afm_len, n022023l_pfb, n022023l_pfb_len},
 121 {"Courier-Bold",          "n022004l", n022004l_afm, n022004l_afm_len, n022004l_pfb, n022004l_pfb_len},
 122 {"Courier-BoldOblique",   "n022024l", n022024l_afm, n022024l_afm_len, n022024l_pfb, n022024l_pfb_len},
 123 {"Symbol",                "s050000l", s050000l_afm, s050000l_afm_len, s050000l_pfb, s050000l_pfb_len},
 124 {"ZapfDingbats",          "d050000l", d050000l_afm, d050000l_afm_len, d050000l_pfb, d050000l_pfb_len}};
 125
 126
 127 static int verbose = 0;
 128 static int dbgindent = 0;
 129 static void dbg(const char*format, ...)
 130 {
 131     char buf[1024];
 132     int l;
 133     va_list arglist;
 134     if(!verbose)
 135         return;
 136     va_start(arglist, format);
 137     vsprintf(buf, format, arglist);
 138     va_end(arglist);
 139     l = strlen(buf);
 140     while(l && buf[l-1]=='\n') {
 141         buf[l-1] = 0;
 142         l--;
 143     }
 144     printf("(pdf) ");
 145     int indent = dbgindent;
 146     while(indent) {
 147         printf(" ");
 148         indent--;
 149     }
 150     printf("%s\n", buf);
 151     fflush(stdout);
 152 }
 153
 154
 155 void GFXOutputDev::showfeature(const char*feature, char fully, char warn)
 156 {
 157     feature_t*f = this->featurewarnings;
 158     while(f) {
 159         if(!strcmp(feature, f->string))
 160             return;
 161         f = f->next;
 162     }
 163     f = (feature_t*)malloc(sizeof(feature_t));
 164     f->string = strdup(feature);
 165     f->next = this->featurewarnings;
 166     this->featurewarnings = f;
 167     if(warn) {
 168         msg("<warning> %s not yet %ssupported!",feature,fully?"fully ":"");
 169         if(this->config_break_on_warning) {
 170             msg("<fatal> Aborting conversion due to unsupported feature");
 171             exit(1);
 172         }
 173     } else {
 174         msg("<notice> File contains %s",feature);
 175     }
 176 }
 177 void GFXOutputDev::warnfeature(const char*feature,char fully)
 178 {
 179     showfeature(feature,fully,1);
 180 }
 181 void GFXOutputDev::infofeature(const char*feature)
 182 {
 183     showfeature(feature,0,0);
 184 }
 185
 186 GFXOutputState::GFXOutputState() {
 187     this->clipping = 0;
 188     this->createsoftmask = 0;
 189     this->transparencygroup = 0;
 190     this->softmask = 0;
 191     this->grouprecording = 0;
 192     this->isolated = 0;
 193 }
 194
 195 GBool GFXOutputDev::interpretType3Chars()
 196 {
 197     return gTrue;
 198 }
 199
 200 typedef struct _drawnchar
 201 {
 202     gfxcoord_t x,y;
 203     int charid;
 204     gfxcolor_t color;
 205 } drawnchar_t;
 206
 207 class CharBuffer
 208 {
 209     drawnchar_t * chars;
 210     int buf_size;
 211     int num_chars;
 212
 213 public:
 214
 215     CharBuffer()
 216     {
 217         buf_size = 32;
 218         chars = (drawnchar_t*)malloc(sizeof(drawnchar_t)*buf_size);
 219         memset(chars, 0, sizeof(drawnchar_t)*buf_size);
 220         num_chars = 0;
 221     }
 222     ~CharBuffer()
 223     {
 224         free(chars);chars = 0;
 225     }
 226
 227     void grow(int size)
 228     {
 229         if(size>=buf_size) {
 230             buf_size += 32;
 231             chars = (drawnchar_t*)realloc(chars, sizeof(drawnchar_t)*buf_size);
 232         }
 233     }
 234
 235     void addChar(int charid, gfxcoord_t x, gfxcoord_t y, gfxcolor_t color)
 236     {
 237         grow(num_chars);
 238         chars[num_chars].x = x;
 239         chars[num_chars].y = y;
 240         chars[num_chars].color = color;
 241         chars[num_chars].charid = charid;
 242     }
 243 };
 244
 245 char* writeOutStdFont(fontentry* f)
 246 {
 247     FILE*fi;
 248     char namebuf1[512];
 249     char namebuf2[512];
 250     char* tmpFileName = mktmpname(namebuf1);
 251
 252     sprintf(namebuf2, "%s.afm", tmpFileName);
 253     fi = fopen(namebuf2, "wb");
 254     if(!fi)
 255         return 0;
 256     fwrite(f->afm, 1, f->afmlen, fi);
 257     fclose(fi);
 258
 259     sprintf(namebuf2, "%s.pfb", tmpFileName);
 260     fi = fopen(namebuf2, "wb");
 261     if(!fi)
 262         return 0;
 263     fwrite(f->pfb, 1, f->pfblen, fi);
 264     fclose(fi);
 265     return strdup(namebuf2);
 266 }
 267 void unlinkfont(char* filename)
 268 {
 269     int l;
 270     if(!filename)
 271         return;
 272     msg("<verbose> Removing temporary font file %s", filename);
 273     l=strlen(filename);
 274     unlink(filename);
 275     if(!strncmp(&filename[l-4],".afm",4)) {
 276         memcpy(&filename[l-4],".pfb",4); unlink(filename);
 277         memcpy(&filename[l-4],".pfa",4); unlink(filename);
 278         memcpy(&filename[l-4],".afm",4);
 279         return;
 280     } else
 281     if(!strncmp(&filename[l-4],".pfa",4)) {
 282         memcpy(&filename[l-4],".afm",4); unlink(filename);
 283         memcpy(&filename[l-4],".pfa",4);
 284         return;
 285     } else
 286     if(!strncmp(&filename[l-4],".pfb",4)) {
 287         memcpy(&filename[l-4],".afm",4); unlink(filename);
 288         memcpy(&filename[l-4],".pfb",4);
 289         return;
 290     }
 291 }
 292
 293 static int config_use_fontconfig = 1;
 294 static int fcinitcalled = 0;
 295
 296 GFXGlobalParams::GFXGlobalParams()
 297 : GlobalParams("")
 298 {
 299     //setupBaseFonts(char *dir); //not tested yet
 300 }
 301 GFXGlobalParams::~GFXGlobalParams()
 302 {
 303     msg("<verbose> Performing cleanups");
 304     int t;
 305     for(t=0;t<sizeof(pdf2t1map)/sizeof(fontentry);t++) {
 306         if(pdf2t1map[t].fullfilename) {
 307             unlinkfont(pdf2t1map[t].fullfilename);
 308         }
 309     }
 310 #ifdef HAVE_FONTCONFIG
 311     if(config_use_fontconfig && fcinitcalled)
 312         FcFini();
 313 #endif
 314 }
 315 #ifdef HAVE_FONTCONFIG
 316 static char fc_ismatch(FcPattern*match, char*family, char*style)
 317 {
 318     char*fcfamily=0,*fcstyle=0,*fcfullname=0,*filename=0;
 319     FcBool scalable=FcFalse, outline=FcFalse;
 320     FcPatternGetString(match, "family", 0, (FcChar8**)&fcfamily);
 321     FcPatternGetString(match, "style", 0, (FcChar8**)&fcstyle);
 322     FcPatternGetString(match, "file", 0, (FcChar8**)&filename);
 323     FcPatternGetBool(match, "outline", 0, &outline);
 324     FcPatternGetBool(match, "scalable", 0, &scalable);
 325
 326     if(scalable!=FcTrue || outline!=FcTrue)
 327         return 0;
 328
 329     if (!strcasecmp(fcfamily, family)) {
 330         msg("<debug> Font %s-%s (%s) is a match for %s%s%s", fcfamily, fcstyle, filename, family, style?"-":"", style?style:"");
 331         return 1;
 332     } else {
 333         //msg("<debug> Font %s-%s (%s) is NOT a match for %s%s%s", fcfamily, fcstyle, filename, family, style?"-":"", style?style:"");
 334         return 0;
 335     }
 336 }
 337 #endif
 338
 339 char* fontconfig_searchForFont(char*name)
 340 {
 341 #ifdef HAVE_FONTCONFIG
 342     if(!config_use_fontconfig)
 343         return 0;
 344
 345     // call init ony once
 346     if (!fcinitcalled) {
 347         fcinitcalled = 1;
 348
 349         // check whether we have a config file
 350         char* configfile = (char*)FcConfigFilename(0);
 351         int configexists = 0;
 352         FILE*fi = fopen(configfile, "rb");
 353         if(fi) {
 354             configexists = 1;fclose(fi);
 355             msg("<debug> Initializing FontConfig (configfile=%s)", configfile);
 356         } else {
 357             msg("<debug> Initializing FontConfig (no configfile)");
 358         }
 359
 360         if(!configexists) {
 361             /* A fontconfig instance which didn't find a configfile is unbelievably
 362                cranky, so let's just write out a small xml file and make fontconfig
 363                happy */
 364             FcConfig*c = FcConfigCreate();
 365             char namebuf[512];
 366             char* tmpFileName = mktmpname(namebuf);
 367             FILE*fi = fopen(tmpFileName, "wb");
 368             fprintf(fi, "<?xml version=\"1.0\"?>\n<fontconfig>\n");//<!DOCTYPE fontconfig SYSTEM "fonts.dtd">
 369 #ifdef WIN32
 370             fprintf(fi, "<dir>WINDOWSFONTDIR</dir>\n");
 371 #endif
 372             fprintf(fi, "<dir>~/.fonts</dir>\n");
 373 #ifdef WIN32
 374             fprintf(fi, "<cachedir>WINDOWSTEMPDIR_FONTCONFIG_CACHE</cachedir>\n");
 375 #endif
 376             fprintf(fi, "<cachedir>~/.fontconfig</cachedir>\n");
 377             fprintf(fi, "</fontconfig>\n");
 378             fclose(fi);
 379             FcConfigParseAndLoad(c, (FcChar8*)tmpFileName, 1);
 380             FcConfigBuildFonts(c);
 381             FcConfigSetCurrent(c);
 382         }
 383
 384         if(!FcInit()) {
 385             msg("<debug> FontConfig Initialization failed. Disabling.");
 386             config_use_fontconfig = 0;
 387             return 0;
 388         }
 389         FcConfig * config = FcConfigGetCurrent();
 390         if(!config) {
 391             msg("<debug> FontConfig Config Initialization failed. Disabling.");
 392             config_use_fontconfig = 0;
 393             return 0;
 394         }
 395         FcFontSet * set =  FcConfigGetFonts(config, FcSetSystem);
 396         msg("<verbose> FontConfig initialized. Found %d fonts", set?set->nfont:0);
 397         if(!set || !set->nfont) {
 398             msg("<debug> FontConfig has zero fonts. Disabling.");
 399             config_use_fontconfig = 0;
 400             return 0;
 401         }
 402
 403         if(getLogLevel() >= LOGLEVEL_TRACE) {
 404             int t;
 405             for(t=0;t<set->nfont;t++) {
 406                 char*fcfamily=0,*fcstyle=0,*filename=0;
 407                 FcBool scalable=FcFalse, outline=FcFalse;
 408                 FcPatternGetString(set->fonts[t], "family", 0, (FcChar8**)&fcfamily);
 409                 FcPatternGetString(set->fonts[t], "style", 0, (FcChar8**)&fcstyle);
 410                 FcPatternGetString(set->fonts[t], "file", 0, (FcChar8**)&filename);
 411                 FcPatternGetBool(set->fonts[t], "outline", 0, &outline);
 412                 FcPatternGetBool(set->fonts[t], "scalable", 0, &scalable);
 413                 if(scalable && outline) {
 414                     msg("<trace> %s-%s -> %s", fcfamily, fcstyle, filename);
 415                 }
 416             }
 417         }
 418     }
 419
 420     char*family = strdup(name);
 421     char*style = 0;
 422     char*dash = strchr(family, '-');
 423     FcPattern*pattern = 0;
 424     if(dash) {
 425         *dash = 0;
 426         style = dash+1;
 427         msg("<debug> FontConfig: Looking for font %s (family=%s style=%s)", name, family, style);
 428         pattern = FcPatternBuild(NULL, FC_OUTLINE, FcTypeBool, FcTrue, FC_SCALABLE, FcTypeBool, FcTrue, FC_FAMILY, FcTypeString, family, FC_STYLE, FcTypeString, style, NULL);
 429     } else {
 430         msg("<debug> FontConfig: Looking for font %s (family=%s)", name, family);
 431         pattern = FcPatternBuild(NULL, FC_OUTLINE, FcTypeBool, FcTrue, FC_SCALABLE, FcTypeBool, FcTrue, FC_FAMILY, FcTypeString, family, NULL);
 432     }
 433
 434     FcResult result;
 435     FcConfigSubstitute(0, pattern, FcMatchPattern);
 436     FcDefaultSubstitute(pattern);
 437
 438     FcFontSet*set = FcFontSort(0, pattern, 1, 0, &result);
 439     if(set) {
 440         int t;
 441         for(t=0;t<set->nfont;t++) {
 442             FcPattern*match = set->fonts[t];
 443             //FcPattern*match = FcFontMatch(0, pattern, &result);
 444             if(fc_ismatch(match, family, style)) {
 445                 char*filename=0;
 446                 if(FcPatternGetString(match, "file", 0, (FcChar8**)&filename) != FcResultMatch) {
 447                     msg("<debug> FontConfig: Couldn't get fontconfig's filename for font %s", name);
 448                     filename=0;
 449                 }
 450                 //FcPatternDestroy(match);
 451                 msg("<debug> fontconfig: returning filename %s", filename);
 452                 free(family);
 453                 FcPatternDestroy(pattern);
 454                 FcFontSetDestroy(set);
 455                 return filename?strdup(filename):0;
 456             }
 457         }
 458     }
 459     free(family);
 460     FcPatternDestroy(pattern);
 461     FcFontSetDestroy(set);
 462     return 0;
 463 #else
 464     return 0;
 465 #endif
 466 }
 467
 468 static DisplayFontParamKind detectFontType(const char*filename)
 469 {
 470     if(strstr(filename, ".ttf") || strstr(filename, ".TTF"))
 471         return displayFontTT;
 472     if(strstr(filename, ".pfa") || strstr(filename, ".PFA") || strstr(filename, ".pfb"))
 473         return displayFontT1;
 474     return displayFontTT;
 475 }
 476
 477 DisplayFontParam *GFXGlobalParams::getDisplayFont(GString *fontName)
 478 {
 479     msg("<verbose> looking for font %s in global params", fontName->getCString());
 480
 481     char*name = fontName->getCString();
 482
 483     /* see if it is a pdf standard font */
 484     int t;
 485     for(t=0;t<sizeof(pdf2t1map)/sizeof(fontentry);t++) {
 486         if(!strcmp(name, pdf2t1map[t].pdffont)) {
 487             if(!pdf2t1map[t].fullfilename) {
 488                 pdf2t1map[t].fullfilename = writeOutStdFont(&pdf2t1map[t]);
 489                 if(!pdf2t1map[t].fullfilename) {
 490                     msg("<error> Couldn't save default font- is the Temp Directory writable?");
 491                 } else {
 492                     msg("<verbose> Storing standard PDF font %s at %s", name, pdf2t1map[t].fullfilename);
 493                 }
 494             }
 495             DisplayFontParam *dfp = new DisplayFontParam(new GString(fontName), displayFontT1);
 496             dfp->t1.fileName = new GString(pdf2t1map[t].fullfilename);
 497             return dfp;
 498         }
 499     }
 500
 501     int bestlen = 0x7fffffff;
 502     const char*bestfilename = 0;
 503
 504     fontfile_t*f = global_fonts;
 505     while(f) {
 506         if(strstr(f->filename, name)) {
 507             if(f->len < bestlen) {
 508                 bestlen = f->len;
 509                 bestfilename = f->filename;
 510             }
 511         }
 512         f = f->next;
 513     }
 514
 515     /* if we didn't find anything up to now, try looking for the
 516        font via fontconfig */
 517     char*filename = 0;
 518     if(!bestfilename) {
 519         filename = fontconfig_searchForFont(name);
 520     } else {
 521         filename = strdup(bestfilename);
 522     }
 523
 524     if(filename) {
 525         DisplayFontParamKind kind = detectFontType(filename);
 526         DisplayFontParam *dfp = new DisplayFontParam(new GString(fontName), kind);
 527         if(kind == displayFontTT) {
 528             dfp->tt.fileName = new GString(filename);
 529         } else {
 530             dfp->t1.fileName = new GString(filename);
 531         }
 532         free(filename);
 533         return dfp;
 534     }
 535     return GlobalParams::getDisplayFont(fontName);
 536 }
 537
 538 GFXOutputDev::GFXOutputDev(InfoOutputDev*info, PDFDoc*doc)
 539 {
 540     this->info = info;
 541     this->doc = doc;
 542     this->xref = doc->getXRef();
 543
 544     this->jpeginfo = 0;
 545     this->textmodeinfo = 0;
 546     this->linkinfo = 0;
 547     this->pbminfo = 0;
 548     this->type3active = 0;
 549     this->statepos = 0;
 550     this->xref = 0;
 551     this->substitutepos = 0;
 552     this->type3Warning = 0;
 553     this->user_movex = 0;
 554     this->user_movey = 0;
 555     this->clipmovex = 0;
 556     this->clipmovey = 0;
 557     this->user_clipx1 = 0;
 558     this->user_clipy1 = 0;
 559     this->user_clipx2 = 0;
 560     this->user_clipy2 = 0;
 561     this->current_text_stroke = 0;
 562     this->current_text_clip = 0;
 563     this->outer_clip_box = 0;
 564     this->pages = 0;
 565     this->pagebuflen = 0;
 566     this->pagepos = 0;
 567     this->config_convertgradients=1;
 568     this->config_break_on_warning=0;
 569     this->config_remapunicode=0;
 570     this->config_transparent=0;
 571     this->config_extrafontdata = 0;
 572     this->config_fontquality = 10;
 573     this->config_optimize_polygons = 0;
 574
 575     this->gfxfontlist = gfxfontlist_create();
 576
 577     memset(states, 0, sizeof(states));
 578     this->featurewarnings = 0;
 579 };
 580
 581 void GFXOutputDev::setParameter(const char*key, const char*value)
 582 {
 583     if(!strcmp(key,"breakonwarning")) {
 584         this->config_break_on_warning = atoi(value);
 585     } else if(!strcmp(key,"remapunicode")) {
 586         this->config_remapunicode = atoi(value);
 587     } else if(!strcmp(key,"transparent")) {
 588         this->config_transparent = atoi(value);
 589     } else if(!strcmp(key,"extrafontdata")) {
 590         this->config_extrafontdata = atoi(value);
 591     } else if(!strcmp(key,"convertgradients")) {
 592         this->config_convertgradients = atoi(value);
 593     } else if(!strcmp(key,"optimize_polygons")) {
 594         this->config_optimize_polygons = atoi(value);
 595     } else if(!strcmp(key,"fontquality")) {
 596         this->config_fontquality = atof(value);
 597         if(this->config_fontquality<=1)
 598             this->config_fontquality=1;
 599     } else if(!strcmp(key,"help")) {
 600         printf("\nPDF layer options:\n");
 601         printf("breakonwarning=0/1  Abort conversion if graphic objects are found which\n");
 602         printf("                    are not 100%% supported\n");
 603         printf("transparent=0/1     Make PDF transparent (alpha background)\n");
 604         printf("extrafontdata=0/1   Store Type3 characters and capture characters\n");
 605         printf("fontquality=1..100  Curve approximation quality of the fonts\n");
 606     }
 607
 608 }
 609
 610 void GFXOutputDev::setDevice(gfxdevice_t*dev)
 611 {
 612     this->device = dev;
 613 }
 614
 615 void GFXOutputDev::setMove(int x,int y)
 616 {
 617     this->user_movex = x;
 618     this->user_movey = y;
 619 }
 620
 621 void GFXOutputDev::setClip(int x1,int y1,int x2,int y2)
 622 {
 623     if(x2<x1) {int x3=x1;x1=x2;x2=x3;}
 624     if(y2<y1) {int y3=y1;y1=y2;y2=y3;}
 625
 626     this->user_clipx1 = x1;
 627     this->user_clipy1 = y1;
 628     this->user_clipx2 = x2;
 629     this->user_clipy2 = y2;
 630 }
 631
 632 static char*getFontName(GfxFont*font)
 633 {
 634     char*fontid;
 635     GString*gstr = font->getName();
 636     char* fname = gstr==0?0:gstr->getCString();
 637     if(fname==0) {
 638         char buf[32];
 639         Ref*r=font->getID();
 640         sprintf(buf, "UFONT%d", r->num);
 641         fontid = strdup(buf);
 642     } else {
 643         fontid = strdup(fname);
 644     }
 645
 646     char*fontname= 0;
 647     char* plus = strchr(fontid, '+');
 648     if(plus && plus < &fontid[strlen(fontid)-1]) {
 649         fontname = strdup(plus+1);
 650     } else {
 651         fontname = strdup(fontid);
 652     }
 653     free(fontid);
 654     return fontname;
 655 }
 656
 657 static void dumpFontInfo(const char*loglevel, GfxFont*font);
 658 static int lastdumps[1024];
 659 static int lastdumppos = 0;
 660 /* nr = 0  unknown
 661    nr = 1  substituting
 662    nr = 2  type 3
 663  */
 664 static void showFontError(GfxFont*font, int nr)
 665 {
 666     Ref*r=font->getID();
 667     int t;
 668     for(t=0;t<lastdumppos;t++)
 669         if(lastdumps[t] == r->num)
 670             break;
 671     if(t < lastdumppos)
 672       return;
 673     if(lastdumppos<sizeof(lastdumps)/sizeof(int))
 674     lastdumps[lastdumppos++] = r->num;
 675     if(nr == 0)
 676       msg("<warning> The following font caused problems:");
 677     else if(nr == 1)
 678       msg("<warning> The following font caused problems (substituting):");
 679     else if(nr == 2)
 680       msg("<warning> The following Type 3 Font will be rendered as graphics:");
 681     dumpFontInfo("<warning>", font);
 682 }
 683
 684 static void dumpFontInfo(const char*loglevel, GfxFont*font)
 685 {
 686   char* id = getFontID(font);
 687   char* name = getFontName(font);
 688   Ref* r=font->getID();
 689   msg("%s=========== %s (ID:%d,%d) ==========", loglevel, name, r->num,r->gen);
 690
 691   GString*gstr  = font->getTag();
 692
 693   msg("%s| Tag: %s", loglevel, id);
 694
 695   if(font->isCIDFont()) msg("%s| is CID font", loglevel);
 696
 697   GfxFontType type=font->getType();
 698   switch(type) {
 699     case fontUnknownType:
 700      msg("%s| Type: unknown",loglevel);
 701     break;
 702     case fontType1:
 703      msg("%s| Type: 1",loglevel);
 704     break;
 705     case fontType1C:
 706      msg("%s| Type: 1C",loglevel);
 707     break;
 708     case fontType3:
 709      msg("%s| Type: 3",loglevel);
 710     break;
 711     case fontTrueType:
 712      msg("%s| Type: TrueType",loglevel);
 713     break;
 714     case fontCIDType0:
 715      msg("%s| Type: CIDType0",loglevel);
 716     break;
 717     case fontCIDType0C:
 718      msg("%s| Type: CIDType0C",loglevel);
 719     break;
 720     case fontCIDType2:
 721      msg("%s| Type: CIDType2",loglevel);
 722     break;
 723   }
 724
 725   Ref embRef;
 726   GBool embedded = font->getEmbeddedFontID(&embRef);
 727   char*embeddedName=0;
 728   if(font->getEmbeddedFontName()) {
 729     embeddedName = font->getEmbeddedFontName()->getCString();
 730   }
 731   if(embedded)
 732    msg("%s| Embedded id: %s id: %d",loglevel, FIXNULL(embeddedName), embRef.num);
 733
 734   gstr = font->getExtFontFile();
 735   if(gstr)
 736    msg("%s| External Font file: %s", loglevel, FIXNULL(gstr->getCString()));
 737
 738   // Get font descriptor flags.
 739   if(font->isFixedWidth()) msg("%s| is fixed width", loglevel);
 740   if(font->isSerif()) msg("%s| is serif", loglevel);
 741   if(font->isSymbolic()) msg("%s| is symbolic", loglevel);
 742   if(font->isItalic()) msg("%s| is italic", loglevel);
 743   if(font->isBold()) msg("%s| is bold", loglevel);
 744
 745   free(id);
 746   free(name);
 747 }
 748
 749 //void GFXOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str, int width, int height, GBool invert, GBool inlineImg) {printf("void GFXOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str, int width, int height, GBool invert, GBool inlineImg) \n");}
 750 //void GFXOutputDev::drawImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, GBool inlineImg) {printf("void GFXOutputDev::drawImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, GBool inlineImg) \n");}
 751
 752 void dump_outline(gfxline_t*line)
 753 {
 754     while(line) {
 755         if(line->type == gfx_moveTo) {
 756             msg("<debug> |     moveTo %.2f %.2f", line->x,line->y);
 757         } else if(line->type == gfx_lineTo) {
 758             msg("<debug> |     lineTo %.2f %.2f", line->x,line->y);
 759         } else if(line->type == gfx_splineTo) {
 760             msg("<debug> |     splineTo (%.2f %.2f) %.2f %.2f", line->sx,line->sy, line->x, line->y);
 761         }
 762         line = line->next;
 763     }
 764 }
 765
 766 gfxline_t* GFXOutputDev::gfxPath_to_gfxline(GfxState*state, GfxPath*path, int closed, int user_movex, int user_movey)
 767 {
 768     int num = path->getNumSubpaths();
 769     int s,t;
 770     int cpos = 0;
 771     double lastx=0,lasty=0,posx=0,posy=0;
 772     int needsfix=0;
 773     if(!num) {
 774         msg("<warning> empty path");
 775         return 0;
 776     }
 777     gfxdrawer_t draw;
 778     gfxdrawer_target_gfxline(&draw);
 779
 780     for(t = 0; t < num; t++) {
 781         GfxSubpath *subpath = path->getSubpath(t);
 782         int subnum = subpath->getNumPoints();
 783         double bx=0,by=0,cx=0,cy=0;
 784
 785         for(s=0;s<subnum;s++) {
 786            double x,y;
 787
 788            this->transformXY(state, subpath->getX(s),subpath->getY(s),&x,&y);
 789
 790            if(s==0) {
 791                 if(closed && needsfix && (fabs(posx-lastx)+fabs(posy-lasty))>0.001) {
 792                     draw.lineTo(&draw, lastx, lasty);
 793                 }
 794                 draw.moveTo(&draw, x,y);
 795                 posx = lastx = x;
 796                 posy = lasty = y;
 797                 cpos = 0;
 798                 needsfix = 0;
 799            } else if(subpath->getCurve(s) && cpos==0) {
 800                 bx = x;
 801                 by = y;
 802                 cpos = 1;
 803            } else if(subpath->getCurve(s) && cpos==1) {
 804                 cx = x;
 805                 cy = y;
 806                 cpos = 2;
 807            } else {
 808                 posx = x;
 809                 posy = y;
 810                 if(cpos==0) {
 811                     draw.lineTo(&draw, x,y);
 812                 } else {
 813                     gfxdraw_cubicTo(&draw, bx,by, cx,cy, x,y, 0.05);
 814                 }
 815                 needsfix = 1;
 816                 cpos = 0;
 817            }
 818         }
 819     }
 820     /* fix non-closed lines */
 821     if(closed && needsfix && (fabs(posx-lastx)+fabs(posy-lasty))>0.001) {
 822         draw.lineTo(&draw, lastx, lasty);
 823     }
 824     gfxline_t*result = (gfxline_t*)draw.result(&draw);
 825
 826     gfxline_optimize(result);
 827
 828     return result;
 829 }
 830
 831 GBool GFXOutputDev::useTilingPatternFill()
 832 {
 833     infofeature("tiled patterns");
 834 //    if(config_convertgradients)
 835 //      return gTrue;
 836     return gFalse;
 837 }
 838 GBool GFXOutputDev::useShadedFills()
 839 {
 840     infofeature("shaded fills");
 841     if(config_convertgradients)
 842         return gTrue;
 843     return gFalse;
 844 }
 845
 846 void GFXOutputDev::transformXY(GfxState*state, double x, double y, double*nx, double*ny)
 847 {
 848     state->transform(x,y,nx,ny);
 849     *nx += user_movex + clipmovex;
 850     *ny += user_movey + clipmovey;
 851 }
 852
 853
 854 #if (xpdfMajorVersion*10000 + xpdfMinorVersion*100 + xpdfUpdateVersion) < 30207
 855 void GFXOutputDev::tilingPatternFill(GfxState *state, Object *str,
 856                                int paintType, Dict *resDict,
 857                                double *mat, double *bbox,
 858                                int x0, int y0, int x1, int y1,
 859                                double xStep, double yStep)
 860 #else
 861 void GFXOutputDev::tilingPatternFill(GfxState *state, Gfx *gfx, Object *str,
 862                                int paintType, Dict *resDict,
 863                                double *mat, double *bbox,
 864                                int x0, int y0, int x1, int y1,
 865                                double xStep, double yStep)
 866 #endif
 867 {
 868     msg("<debug> tilingPatternFill");
 869     infofeature("tiling pattern fills");
 870 }
 871
 872 GBool GFXOutputDev::functionShadedFill(GfxState *state, GfxFunctionShading *shading)
 873 {
 874     msg("<error> functionShadedFill not supported yet");
 875     infofeature("function shaded fills");
 876     return gFalse;
 877 }
 878 static gfxcolor_t col2col(GfxColorSpace*colspace, GfxColor* col)
 879 {
 880     gfxcolor_t c;
 881     GfxRGB rgb;
 882     colspace->getRGB(col, &rgb);
 883     c.r = colToByte(rgb.r);
 884     c.g = colToByte(rgb.g);
 885     c.b = colToByte(rgb.b);
 886     c.a = 255;
 887     return c;
 888 }
 889
 890 GBool GFXOutputDev::radialShadedFill(GfxState *state, GfxRadialShading *shading)
 891 {
 892     double x0,y0,r0,x1,y1,x2,y2,x9,y9,r1;
 893     shading->getCoords(&x0,&y0,&r0,&x9,&y9,&r1);
 894     x1=x0+r1;y1=y0;
 895     x2=x0;   y2=y0+r1;
 896     this->transformXY(state, x0,y0, &x0,&y0);
 897     this->transformXY(state, x1,y1, &x1,&y1);
 898     this->transformXY(state, x2,y2, &x2,&y2);
 899
 900     GfxColor color0;
 901     GfxColor color1;
 902     GfxColor color2;
 903     shading->getColor(0.0, &color0);
 904     shading->getColor(0.5, &color1);
 905     shading->getColor(1.0, &color2);
 906
 907     GfxColorSpace* colspace = shading->getColorSpace();
 908
 909     msg("<verbose> radialShadedFill %f %f %f %f %f %f %02x%02x%02x->%02x%02x%02x", x0, y0, x1, y1, x2, y2,
 910             colToByte(color0.c[0]), colToByte(color0.c[1]), colToByte(color0.c[2]),
 911             colToByte(color1.c[0]), colToByte(color1.c[1]), colToByte(color1.c[2]),
 912             colToByte(color2.c[0]), colToByte(color2.c[1]), colToByte(color2.c[2]));
 913     infofeature("radial shaded fills");
 914
 915     gfxgradient_t*g = (gfxgradient_t*)malloc(sizeof(gfxgradient_t)*3);
 916     g[0].next = &g[1];
 917     g[1].next = &g[2];
 918     g[2].next = 0;
 919     g[0].color = col2col(colspace, &color0);
 920     g[1].color = col2col(colspace, &color1);
 921     g[2].color = col2col(colspace, &color2);
 922     g[0].pos = 0.0;
 923     g[1].pos = 0.5;
 924     g[2].pos = 1.0;
 925
 926     gfxbbox_t b = states[statepos].clipbbox;
 927     gfxline_t p1,p2,p3,p4,p5;
 928     p1.type=gfx_moveTo;p1.x=b.xmin; p1.y=b.ymin; p1.next=&p2;
 929     p2.type=gfx_lineTo;p2.x=b.xmin; p2.y=b.ymax; p2.next=&p3;
 930     p3.type=gfx_lineTo;p3.x=b.xmax; p3.y=b.ymax; p3.next=&p4;
 931     p4.type=gfx_lineTo;p4.x=b.xmax; p4.y=b.ymin; p4.next=&p5;
 932     p5.type=gfx_lineTo;p5.x=b.xmin; p5.y=b.ymin; p5.next=0;
 933
 934     gfxmatrix_t m;
 935     //m.m00 = (x3-x0); m.m10 = (x1-x0);
 936     //m.m01 = (y3-y0); m.m11 = (y1-y0);
 937     //x3/y3 specifies another (the ending) circle, not the second radius of an ellipse
 938     m.m00 = (x1-x0); m.m10 = (x2-x0);
 939     m.m01 = (y1-y0); m.m11 = (y2-y0);
 940     m.tx = x0 - 0.5;
 941     m.ty = y0 - 0.5;
 942
 943     device->fillgradient(device, &p1, g, gfxgradient_radial, &m);
 944     return gTrue;
 945 }
 946
 947 GBool GFXOutputDev::axialShadedFill(GfxState *state, GfxAxialShading *shading)
 948 {
 949     double x0,y0,x1,y1;
 950     shading->getCoords(&x0,&y0,&x1,&y1);
 951     this->transformXY(state, x0,y0,&x0,&y0);
 952     this->transformXY(state, x1,y1,&x1,&y1);
 953
 954     GfxColor color0;
 955     GfxColor color1;
 956     GfxColor color2;
 957     shading->getColor(0.0, &color0);
 958     shading->getColor(0.5, &color1);
 959     shading->getColor(1.0, &color2);
 960
 961     GfxColorSpace* colspace = shading->getColorSpace();
 962
 963     msg("<verbose> axialShadedFill %f %f %f %f %02x%02x%02x->%02x%02x%02x->%02x%02x%02x", x0, y0, x1, y1,
 964             colToByte(color0.c[0]), colToByte(color0.c[1]), colToByte(color0.c[2]),
 965             colToByte(color1.c[0]), colToByte(color1.c[1]), colToByte(color1.c[2]),
 966             colToByte(color2.c[0]), colToByte(color2.c[1]), colToByte(color2.c[2])
 967             );
 968     infofeature("axial shaded fills");
 969
 970     gfxgradient_t*g = (gfxgradient_t*)malloc(sizeof(gfxgradient_t)*3);
 971     g[0].next = &g[1];
 972     g[1].next = &g[2];
 973     g[2].next = 0;
 974     g[0].color = col2col(colspace, &color0);
 975     g[1].color = col2col(colspace, &color1);
 976     g[2].color = col2col(colspace, &color2);
 977     g[0].pos = 0.0;
 978     g[1].pos = 0.5;
 979     g[2].pos = 1.0;
 980
 981     double xMin,yMin,xMax,yMax;
 982     state->getUserClipBBox(&xMin, &yMin, &xMax, &yMax);
 983     this->transformXY(state, xMin, yMin, &xMin, &yMin);
 984     msg("<verbose> userClipBox %f %f %f %f", xMin, yMin, xMax, yMax);
 985
 986     xMin = 0; yMin = 0;
 987     xMin = 1024; yMin = 1024;
 988
 989     gfxbbox_t b = states[statepos].clipbbox;
 990     gfxline_t p1,p2,p3,p4,p5;
 991     p1.type=gfx_moveTo;p1.x=b.xmin; p1.y=b.ymin; p1.next=&p2;
 992     p2.type=gfx_lineTo;p2.x=b.xmin; p2.y=b.ymax; p2.next=&p3;
 993     p3.type=gfx_lineTo;p3.x=b.xmax; p3.y=b.ymax; p3.next=&p4;
 994     p4.type=gfx_lineTo;p4.x=b.xmax; p4.y=b.ymin; p4.next=&p5;
 995     p5.type=gfx_lineTo;p5.x=b.xmin; p5.y=b.ymin; p5.next=0;
 996
 997     /* the gradient starts at (-1.0,0.0), so move (0,0) to
 998        the middle of the two control points */
 999     gfxmatrix_t m;
1000     m.m00 = (x1-x0)/2; m.m10 = -(y1-y0)/2;
1001     m.m01 = (y1-y0)/2; m.m11 =  (x1-x0)/2;
1002     m.tx = (x0 + x1)/2 - 0.5;
1003     m.ty = (y0 + y1)/2 - 0.5;
1004
1005     device->fillgradient(device, &p1, g, gfxgradient_linear, &m);
1006     return gTrue;
1007 }
1008
1009 GBool GFXOutputDev::useDrawForm()
1010 {
1011     infofeature("forms");
1012     return gFalse;
1013 }
1014 void GFXOutputDev::drawForm(Ref id)
1015 {
1016     msg("<error> drawForm not implemented");
1017 }
1018 GBool GFXOutputDev::needNonText()
1019 {
1020     return gTrue;
1021 }
1022 void GFXOutputDev::endPage()
1023 {
1024     msg("<verbose> endPage (GfxOutputDev)");
1025     if(outer_clip_box) {
1026         device->endclip(device);
1027         outer_clip_box = 0;
1028     }
1029     this->dashPattern = 0;
1030     /* notice: we're not fully done yet with this page- there might still be
1031        a few calls to drawLink() yet to come */
1032 }
1033
1034 static inline double sqr(double x) {return x*x;}
1035
1036 #define STROKE_FILL 1
1037 #define STROKE_CLIP 2
1038 void GFXOutputDev::strokeGfxline(GfxState *state, gfxline_t*line, int flags)
1039 {
1040     int lineCap = state->getLineCap(); // 0=butt, 1=round 2=square
1041     int lineJoin = state->getLineJoin(); // 0=miter, 1=round 2=bevel
1042     double miterLimit = state->getMiterLimit();
1043     double width = state->getTransformedLineWidth();
1044
1045     GfxRGB rgb;
1046     double opaq = state->getStrokeOpacity();
1047     if(type3active)
1048         state->getFillRGB(&rgb);
1049     else
1050         state->getStrokeRGB(&rgb);
1051     gfxcolor_t col;
1052     col.r = colToByte(rgb.r);
1053     col.g = colToByte(rgb.g);
1054     col.b = colToByte(rgb.b);
1055     col.a = (unsigned char)(opaq*255);
1056
1057     gfx_capType capType = gfx_capRound;
1058     if(lineCap == 0) capType = gfx_capButt;
1059     else if(lineCap == 1) capType = gfx_capRound;
1060     else if(lineCap == 2) capType = gfx_capSquare;
1061
1062     gfx_joinType joinType = gfx_joinRound;
1063     if(lineJoin == 0) joinType = gfx_joinMiter;
1064     else if(lineJoin == 1) joinType = gfx_joinRound;
1065     else if(lineJoin == 2) joinType = gfx_joinBevel;
1066
1067     gfxline_t*line2 = 0;
1068
1069     if(this->dashLength && this->dashPattern) {
1070         float * dash = (float*)malloc(sizeof(float)*(this->dashLength+1));
1071         int t;
1072
1073         /* try to find out how much the transformation matrix would
1074            stretch the dashes, and factor that into the dash lengths.
1075            This is not the entirely correct approach- it would be
1076            better to first convert the path to an unscaled version,
1077            then apply dashing, and then transform the path using
1078            the current transformation matrix. However there are few
1079            PDFs which actually stretch a dashed path in a non-orthonormal
1080            way */
1081         double tx1, ty1, tx2, ty2;
1082         this->transformXY(state, 0, 0, &tx1, &ty1);
1083         this->transformXY(state, 1, 1, &tx2, &ty2);
1084         double f = sqrt(sqr(tx2-tx1)+sqr(ty2-ty1)) / SQRT2;
1085
1086         f = 1.0; //disable dash length transform for now
1087
1088         msg("<trace> %d dashes", this->dashLength);
1089         msg("<trace> |  phase: %f", this->dashStart);
1090         for(t=0;t<this->dashLength;t++) {
1091             dash[t] = (float)this->dashPattern[t] * f;
1092             msg("<trace> |  d%-3d: %f", t, this->dashPattern[t]);
1093         }
1094         dash[this->dashLength] = -1;
1095         if(getLogLevel() >= LOGLEVEL_TRACE) {
1096             dump_outline(line);
1097         }
1098
1099         line2 = gfxtool_dash_line(line, dash, (float)(this->dashStart*f));
1100         line = line2;
1101         free(dash);
1102         msg("<trace> After dashing:");
1103     }
1104
1105     if(getLogLevel() >= LOGLEVEL_TRACE)  {
1106         msg("<trace> stroke width=%f join=%s cap=%s dashes=%d color=%02x%02x%02x%02x",
1107                 width,
1108                 lineJoin==0?"miter": (lineJoin==1?"round":"bevel"),
1109                 lineCap==0?"butt": (lineJoin==1?"round":"square"),
1110                 this->dashLength,
1111                 col.r,col.g,col.b,col.a
1112                 );
1113         dump_outline(line);
1114     }
1115
1116     if(flags&STROKE_FILL) {
1117         gfxpoly_t* poly = gfxpoly_strokeToPoly(line, width, capType, joinType, miterLimit);
1118         gfxline_t*gfxline = gfxpoly_to_gfxline(poly);
1119         if(getLogLevel() >= LOGLEVEL_TRACE)  {
1120             dump_outline(gfxline);
1121         }
1122         if(!gfxline) {
1123             msg("<warning> Empty polygon (resulting from stroked line)");
1124         }
1125         if(flags&STROKE_CLIP) {
1126             device->startclip(device, gfxline);
1127             states[statepos].clipping++;
1128         } else {
1129             device->fill(device, gfxline, &col);
1130         }
1131         gfxline_free(gfxline);
1132         gfxpoly_free(poly);
1133     } else {
1134         if(flags&STROKE_CLIP)
1135             msg("<error> Stroke&clip not supported at the same time");
1136         device->stroke(device, line, width, &col, capType, joinType, miterLimit);
1137     }
1138
1139     if(line2)
1140         gfxline_free(line2);
1141 }
1142
1143 gfxcolor_t getFillColor(GfxState * state)
1144 {
1145     GfxRGB rgb;
1146     double opaq = state->getFillOpacity();
1147     state->getFillRGB(&rgb);
1148     gfxcolor_t col;
1149     col.r = colToByte(rgb.r);
1150     col.g = colToByte(rgb.g);
1151     col.b = colToByte(rgb.b);
1152     col.a = (unsigned char)(opaq*255);
1153     return col;
1154 }
1155
1156 void GFXOutputDev::fillGfxLine(GfxState *state, gfxline_t*line)
1157 {
1158     gfxcolor_t col = getFillColor(state);
1159
1160     if(getLogLevel() >= LOGLEVEL_TRACE)  {
1161         msg("<trace> fill %02x%02x%02x%02x", col.r, col.g, col.b, col.a);
1162         dump_outline(line);
1163     }
1164     device->fill(device, line, &col);
1165 }
1166
1167 void GFXOutputDev::clipToGfxLine(GfxState *state, gfxline_t*line)
1168 {
1169     if(getLogLevel() >= LOGLEVEL_TRACE)  {
1170         dump_outline(line);
1171     }
1172     gfxbbox_t bbox = gfxline_getbbox(line);
1173     gfxbbox_intersect(&states[statepos].clipbbox, &bbox);
1174
1175     device->startclip(device, line);
1176     states[statepos].clipping++;
1177 }
1178
1179 void GFXOutputDev::clip(GfxState *state)
1180 {
1181     GfxPath * path = state->getPath();
1182     msg("<trace> clip");
1183     gfxline_t*line = gfxPath_to_gfxline(state, path, 1, user_movex + clipmovex, user_movey + clipmovey);
1184     if(config_optimize_polygons) {
1185         gfxline_t*line2 = gfxline_circularToEvenOdd(line);
1186         gfxline_free(line);
1187         line = line2;
1188     }
1189     clipToGfxLine(state, line);
1190     gfxline_free(line);
1191 }
1192
1193 void GFXOutputDev::eoClip(GfxState *state)
1194 {
1195     GfxPath * path = state->getPath();
1196     gfxline_t*line = gfxPath_to_gfxline(state, path, 1, user_movex + clipmovex, user_movey + clipmovey);
1197     clipToGfxLine(state, line);
1198     gfxline_free(line);
1199 }
1200 void GFXOutputDev::clipToStrokePath(GfxState *state)
1201 {
1202     GfxPath * path = state->getPath();
1203     gfxline_t*line= gfxPath_to_gfxline(state, path, 0, user_movex + clipmovex, user_movey + clipmovey);
1204
1205     if(getLogLevel() >= LOGLEVEL_TRACE)  {
1206         double width = state->getTransformedLineWidth();
1207         msg("<trace> cliptostrokepath width=%f", width);
1208         dump_outline(line);
1209     }
1210
1211     strokeGfxline(state, line, STROKE_FILL|STROKE_CLIP);
1212     gfxline_free(line);
1213 }
1214
1215 void GFXOutputDev::finish()
1216 {
1217     if(outer_clip_box) {
1218         if(device) {
1219             device->endclip(device);
1220         }
1221         outer_clip_box = 0;
1222     }
1223 }
1224
1225 GFXOutputDev::~GFXOutputDev()
1226 {
1227     finish();
1228
1229     if(this->pages) {
1230         free(this->pages); this->pages = 0;
1231     }
1232
1233     feature_t*f = this->featurewarnings;
1234     while(f) {
1235         feature_t*next = f->next;
1236         if(f->string) {
1237             free(f->string);f->string =0;
1238         }
1239         f->next = 0;
1240         free(f);
1241         f = next;
1242     }
1243     this->featurewarnings = 0;
1244
1245     gfxfontlist_free(this->gfxfontlist, 1);this->gfxfontlist = 0;
1246 };
1247 GBool GFXOutputDev::upsideDown()
1248 {
1249     return gTrue;
1250 };
1251 GBool GFXOutputDev::useDrawChar()
1252 {
1253     return gTrue;
1254 }
1255
1256 const char*renderModeDesc[]= {"fill", "stroke", "fill+stroke", "invisible",
1257                       "clip+fill", "stroke+clip", "fill+stroke+clip", "clip"};
1258
1259 static char tmp_printstr[4096];
1260 char* makeStringPrintable(char*str)
1261 {
1262     int len = strlen(str);
1263     int dots = 0;
1264     if(len>=80) {
1265         len = 80;
1266         dots = 1;
1267     }
1268     int t;
1269     for(t=0;t<len;t++) {
1270         char c = str[t];
1271         if(c<32 || c>124) {
1272             c = '.';
1273         }
1274         tmp_printstr[t] = c;
1275     }
1276     if(dots) {
1277         tmp_printstr[len++] = '.';
1278         tmp_printstr[len++] = '.';
1279         tmp_printstr[len++] = '.';
1280     }
1281     tmp_printstr[len] = 0;
1282     return tmp_printstr;
1283 }
1284 #define INTERNAL_FONT_SIZE 1024.0
1285 void GFXOutputDev::updateFontMatrix(GfxState*state)
1286 {
1287     double* ctm = state->getCTM();
1288     double fontSize = state->getFontSize();
1289     double*textMat = state->getTextMat();
1290
1291     /*  taking the absolute value of horizScaling seems to be required for
1292         some italic fonts. FIXME: SplashOutputDev doesn't need this- why? */
1293     double hscale = fabs(state->getHorizScaling());
1294
1295     // from xpdf-3.02/SplashOutputDev:updateFont
1296     double mm11 = textMat[0] * fontSize * hscale;
1297     double mm12 = textMat[1] * fontSize * hscale;
1298     double mm21 = textMat[2] * fontSize;
1299     double mm22 = textMat[3] * fontSize;
1300
1301     // multiply with ctm, like state->getFontTransMat() does
1302     this->current_font_matrix.m00 = (ctm[0]*mm11 + ctm[2]*mm12) / INTERNAL_FONT_SIZE;
1303     this->current_font_matrix.m01 = (ctm[1]*mm11 + ctm[3]*mm12) / INTERNAL_FONT_SIZE;
1304     this->current_font_matrix.m10 = (ctm[0]*mm21 + ctm[2]*mm22) / INTERNAL_FONT_SIZE;
1305     this->current_font_matrix.m11 = (ctm[1]*mm21 + ctm[3]*mm22) / INTERNAL_FONT_SIZE;
1306     this->current_font_matrix.tx = 0;
1307     this->current_font_matrix.ty = 0;
1308 }
1309
1310 void GFXOutputDev::beginString(GfxState *state, GString *s)
1311 {
1312     int render = state->getRender();
1313     if(current_text_stroke) {
1314         msg("<error> Error: Incompatible change of text rendering to %d while inside cliptext", render);
1315     }
1316
1317     msg("<trace> beginString(%s) render=%d", makeStringPrintable(s->getCString()), render);
1318 }
1319
1320 static gfxline_t* mkEmptyGfxShape(double x, double y)
1321 {
1322     gfxline_t*line = (gfxline_t*)malloc(sizeof(gfxline_t));
1323     line->x = x;line->y = y;line->type = gfx_moveTo;line->next = 0;
1324     return line;
1325 }
1326
1327 static char isValidUnicode(int c)
1328 {
1329     if(c>=32 && c<0x2fffe)
1330         return 1;
1331     return 0;
1332 }
1333
1334 void GFXOutputDev::drawChar(GfxState *state, double x, double y,
1335                         double dx, double dy,
1336                         double originX, double originY,
1337                         CharCode charid, int nBytes, Unicode *_u, int uLen)
1338 {
1339     if(!current_fontinfo || (unsigned)charid >= current_fontinfo->num_glyphs || !current_fontinfo->glyphs[charid]) {
1340         msg("<error> Invalid charid %d for font (%d characters)", charid, current_fontinfo?current_fontinfo->num_glyphs:0);
1341         return;
1342     }
1343
1344     CharCode glyphid = current_fontinfo->glyphs[charid]->glyphid;
1345
1346     int render = state->getRender();
1347     gfxcolor_t col = getFillColor(state);
1348
1349     // check for invisible text -- this is used by Acrobat Capture
1350     if (render == RENDER_INVISIBLE) {
1351         col.a = 255;
1352         if(!config_extrafontdata)
1353             return;
1354     }
1355
1356     GfxFont*font = state->getFont();
1357
1358     if(font->getType() == fontType3) {
1359         /* type 3 chars are passed as graphics */
1360         msg("<debug> type3 char at %f/%f", x, y);
1361         return;
1362     }
1363
1364     Unicode u = uLen?(_u[0]):0;
1365     msg("<debug> drawChar(%f,%f,c='%c' (%d), u=%d <%d>) CID=%d render=%d glyphid=%d font=%08x",x,y,(charid&127)>=32?charid:'?', charid, u, uLen, font->isCIDFont(), render, glyphid, current_gfxfont);
1366
1367     gfxmatrix_t m = this->current_font_matrix;
1368     this->transformXY(state, x, y, &m.tx, &m.ty);
1369
1370     if(render == RENDER_FILL || render == RENDER_INVISIBLE) {
1371         device->drawchar(device, current_gfxfont, glyphid, &col, &m);
1372     } else {
1373         msg("<debug> Drawing glyph %d as shape", charid);
1374         if(!textmodeinfo) {
1375             msg("<notice> Some texts will be rendered as shape");
1376             textmodeinfo = 1;
1377         }
1378         gfxline_t*glyph = current_gfxfont->glyphs[glyphid].line;
1379         gfxline_t*tglyph = gfxline_clone(glyph);
1380         gfxline_transform(tglyph, &m);
1381         if((render&3) != RENDER_INVISIBLE) {
1382             gfxline_t*add = gfxline_clone(tglyph);
1383             current_text_stroke = gfxline_append(current_text_stroke, add);
1384         }
1385         if(render&RENDER_CLIP) {
1386             gfxline_t*add = gfxline_clone(tglyph);
1387             current_text_clip = gfxline_append(current_text_clip, add);
1388             if(!current_text_clip) {
1389                 current_text_clip = mkEmptyGfxShape(m.tx, m.ty);
1390             }
1391         }
1392         gfxline_free(tglyph);
1393     }
1394 }
1395
1396 void GFXOutputDev::endString(GfxState *state)
1397 {
1398     int render = state->getRender();
1399     msg("<trace> endString() render=%d textstroke=%08x", render, current_text_stroke);
1400
1401     if(current_text_stroke) {
1402         /* fillstroke and stroke text rendering objects we can process right
1403            now (as there may be texts of other rendering modes in this
1404            text object)- clipping objects have to wait until endTextObject,
1405            however */
1406         device->setparameter(device, "mark","TXT");
1407         if((render&3) == RENDER_FILL) {
1408             fillGfxLine(state, current_text_stroke);
1409             gfxline_free(current_text_stroke);
1410             current_text_stroke = 0;
1411         } else if((render&3) == RENDER_FILLSTROKE) {
1412             fillGfxLine(state, current_text_stroke);
1413             strokeGfxline(state, current_text_stroke,0);
1414             gfxline_free(current_text_stroke);
1415             current_text_stroke = 0;
1416         } else if((render&3) == RENDER_STROKE) {
1417             strokeGfxline(state, current_text_stroke,0);
1418             gfxline_free(current_text_stroke);
1419             current_text_stroke = 0;
1420         }
1421         device->setparameter(device, "mark","");
1422     }
1423 }
1424
1425 void GFXOutputDev::endTextObject(GfxState *state)
1426 {
1427     int render = state->getRender();
1428     msg("<trace> endTextObject() render=%d textstroke=%08x clipstroke=%08x", render, current_text_stroke, current_text_clip);
1429
1430     if(current_text_clip) {
1431         device->setparameter(device, "mark","TXT");
1432         clipToGfxLine(state, current_text_clip);
1433         device->setparameter(device, "mark","");
1434         gfxline_free(current_text_clip);
1435         current_text_clip = 0;
1436     }
1437 }
1438
1439 /* the logic seems to be as following:
1440    first, beginType3Char is called, with the charcode and the coordinates.
1441    if this function returns true, it already knew about the char and has now drawn it.
1442    if the function returns false, it's a new char, and type3D0 and/or type3D1 might be
1443    called with some parameters.
1444    Afterwards, all draw operations until endType3Char are part of the char (which in this moment is
1445    at the position first passed to beginType3Char). the char ends with endType3Char.
1446
1447    The drawing operations between beginType3Char and endType3Char are somewhat different to
1448    the normal ones. For example, the fillcolor equals the stroke color. (Because the stroke
1449    color determines the color of a font)
1450 */
1451
1452 GBool GFXOutputDev::beginType3Char(GfxState *state, double x, double y, double dx, double dy, CharCode charid, Unicode *u, int uLen)
1453 {
1454     msg("<debug> beginType3Char %d u=%d", charid, uLen?u[0]:0);
1455     type3active = 1;
1456
1457     if(config_extrafontdata && current_fontinfo) {
1458
1459         gfxmatrix_t m = this->current_font_matrix;
1460         this->transformXY(state, 0, 0, &m.tx, &m.ty);
1461         m.m00*=INTERNAL_FONT_SIZE;
1462         m.m01*=INTERNAL_FONT_SIZE;
1463         m.m10*=INTERNAL_FONT_SIZE;
1464         m.m11*=INTERNAL_FONT_SIZE;
1465
1466         if(!current_fontinfo || (unsigned)charid >= current_fontinfo->num_glyphs || !current_fontinfo->glyphs[charid]) {
1467             msg("<error> Invalid charid %d for font", charid);
1468             return gFalse;
1469         }
1470         gfxcolor_t col={0,0,0,0};
1471         CharCode glyphid = current_fontinfo->glyphs[charid]->glyphid;
1472         device->drawchar(device, current_gfxfont, glyphid, &col, &m);
1473     }
1474
1475
1476     /* the character itself is going to be passed using the draw functions */
1477     return gFalse; /* gTrue= is_in_cache? */
1478 }
1479
1480 void GFXOutputDev::type3D0(GfxState *state, double wx, double wy) {
1481 }
1482 void GFXOutputDev::type3D1(GfxState *state, double wx, double wy, double llx, double lly, double urx, double ury) {
1483 }
1484
1485 void GFXOutputDev::endType3Char(GfxState *state)
1486 {
1487     type3active = 0;
1488     msg("<debug> endType3Char");
1489 }
1490
1491 void GFXOutputDev::startPage(int pageNum, GfxState *state, double crop_x1, double crop_y1, double crop_x2, double crop_y2)
1492 {
1493     this->currentpage = pageNum;
1494     double x1,y1,x2,y2;
1495     int rot = doc->getPageRotate(1);
1496     gfxcolor_t white = {255,255,255,255};
1497     gfxcolor_t black = {255,0,0,0};
1498     laststate = state;
1499     gfxline_t clippath[5];
1500
1501     /* state->transform(state->getX1(),state->getY1(),&x1,&y1);
1502     state->transform(state->getX2(),state->getY2(),&x2,&y2);
1503     Use CropBox, not MediaBox, as page size
1504     */
1505
1506     /*x1 = crop_x1;
1507     y1 = crop_y1;
1508     x2 = crop_x2;
1509     y2 = crop_y2;*/
1510     state->transform(crop_x1,crop_y1,&x1,&y1); //x1 += user_movex; y1 += user_movey;
1511     state->transform(crop_x2,crop_y2,&x2,&y2); //x2 += user_movex; y2 += user_movey;
1512
1513     if(x2<x1) {double x3=x1;x1=x2;x2=x3;}
1514     if(y2<y1) {double y3=y1;y1=y2;y2=y3;}
1515
1516     this->clipmovex = -(int)x1;
1517     this->clipmovey = -(int)y1;
1518
1519     /* apply user clip box */
1520     if(user_clipx1|user_clipy1|user_clipx2|user_clipy2) {
1521         /*if(user_clipx1 > x1)*/ x1 = user_clipx1;
1522         /*if(user_clipx2 < x2)*/ x2 = user_clipx2;
1523         /*if(user_clipy1 > y1)*/ y1 = user_clipy1;
1524         /*if(user_clipy2 < y2)*/ y2 = user_clipy2;
1525         msg("<verbose> Using user clip box %f/%f/%f/%f",x1,y1,x2,y2);
1526     }
1527
1528     //msg("<verbose> Bounding box is (%f,%f)-(%f,%f) [shifted by %d/%d]", x1,y1,x2,y2, user_movex, user_movey);
1529
1530     msg("<notice> processing PDF page %d (%dx%d:%d:%d) (move:%d:%d)", pageNum, (int)x2-(int)x1,(int)y2-(int)y1, (int)x1, (int)y1, user_movex + clipmovex, user_movey + clipmovey);
1531     if(rot!=0)
1532         msg("<verbose> page is rotated %d degrees", rot);
1533
1534     clippath[0].type = gfx_moveTo;clippath[0].x = x1; clippath[0].y = y1; clippath[0].next = &clippath[1];
1535     clippath[1].type = gfx_lineTo;clippath[1].x = x2; clippath[1].y = y1; clippath[1].next = &clippath[2];
1536     clippath[2].type = gfx_lineTo;clippath[2].x = x2; clippath[2].y = y2; clippath[2].next = &clippath[3];
1537     clippath[3].type = gfx_lineTo;clippath[3].x = x1; clippath[3].y = y2; clippath[3].next = &clippath[4];
1538     clippath[4].type = gfx_lineTo;clippath[4].x = x1; clippath[4].y = y1; clippath[4].next = 0;
1539     device->startclip(device, clippath); outer_clip_box = 1;
1540     if(!config_transparent) {
1541         device->fill(device, clippath, &white);
1542     }
1543     states[statepos].clipbbox.xmin = x1;
1544     states[statepos].clipbbox.ymin = x1;
1545     states[statepos].clipbbox.xmax = x2;
1546     states[statepos].clipbbox.ymax = y2;
1547
1548     this->dashPattern = 0;
1549     this->dashLength = 0;
1550     this->dashStart = 0;
1551 }
1552
1553
1554 void GFXOutputDev::processLink(Link *link, Catalog *catalog)
1555 {
1556     double x1, y1, x2, y2;
1557     gfxline_t points[5];
1558     int x, y;
1559
1560     msg("<debug> drawlink");
1561
1562     link->getRect(&x1, &y1, &x2, &y2);
1563     cvtUserToDev(x1, y1, &x, &y);
1564     points[0].type = gfx_moveTo;
1565     points[0].x = points[4].x = x + user_movex + clipmovex;
1566     points[0].y = points[4].y = y + user_movey + clipmovey;
1567     points[0].next = &points[1];
1568     cvtUserToDev(x2, y1, &x, &y);
1569     points[1].type = gfx_lineTo;
1570     points[1].x = x + user_movex + clipmovex;
1571     points[1].y = y + user_movey + clipmovey;
1572     points[1].next = &points[2];
1573     cvtUserToDev(x2, y2, &x, &y);
1574     points[2].type = gfx_lineTo;
1575     points[2].x = x + user_movex + clipmovex;
1576     points[2].y = y + user_movey + clipmovey;
1577     points[2].next = &points[3];
1578     cvtUserToDev(x1, y2, &x, &y);
1579     points[3].type = gfx_lineTo;
1580     points[3].x = x + user_movex + clipmovex;
1581     points[3].y = y + user_movey + clipmovey;
1582     points[3].next = &points[4];
1583     cvtUserToDev(x1, y1, &x, &y);
1584     points[4].type = gfx_lineTo;
1585     points[4].x = x + user_movex + clipmovex;
1586     points[4].y = y + user_movey + clipmovey;
1587     points[4].next = 0;
1588
1589     msg("<trace> drawlink %.2f/%.2f %.2f/%.2f %.2f/%.2f %.2f/%.2f",
1590             points[0].x, points[0].y,
1591             points[1].x, points[1].y,
1592             points[2].x, points[2].y,
1593             points[3].x, points[3].y);
1594
1595     if(getLogLevel() >= LOGLEVEL_TRACE)  {
1596         dump_outline(points);
1597     }
1598
1599     LinkAction*action=link->getAction();
1600     char buf[128];
1601     char*s = 0;
1602     const char*type = "-?-";
1603     char*named = 0;
1604     int page = -1;
1605     msg("<trace> drawlink action=%d", action->getKind());
1606     switch(action->getKind())
1607     {
1608         case actionGoTo: {
1609             type = "GoTo";
1610             LinkGoTo *ha=(LinkGoTo *)link->getAction();
1611             LinkDest *dest=NULL;
1612             if (ha->getDest()==NULL)
1613                 dest=catalog->findDest(ha->getNamedDest());
1614             else dest=ha->getDest();
1615             if (dest){
1616               if (dest->isPageRef()){
1617                 Ref pageref=dest->getPageRef();
1618                 page=catalog->findPage(pageref.num,pageref.gen);
1619               }
1620               else  page=dest->getPageNum();
1621               sprintf(buf, "%d", page);
1622               s = strdup(buf);
1623             }
1624         }
1625         break;
1626         case actionGoToR: {
1627             type = "GoToR";
1628             LinkGoToR*l = (LinkGoToR*)action;
1629             GString*g = l->getFileName();
1630             if(g)
1631              s = strdup(g->getCString());
1632             if(!s) {
1633                 /* if the GoToR link has no filename, then
1634                    try to find a refernce in the *local*
1635                    file */
1636                 GString*g = l->getNamedDest();
1637                 if(g)
1638                  s = strdup(g->getCString());
1639             }
1640         }
1641         break;
1642         case actionNamed: {
1643             type = "Named";
1644             LinkNamed*l = (LinkNamed*)action;
1645             GString*name = l->getName();
1646             if(name) {
1647                 s = strdup(name->lowerCase()->getCString());
1648                 named = name->getCString();
1649                 if(!strchr(s,':'))
1650                 {
1651                     if(strstr(s, "next") || strstr(s, "forward"))
1652                     {
1653                         page = currentpage + 1;
1654                     }
1655                     else if(strstr(s, "prev") || strstr(s, "back"))
1656                     {
1657                         page = currentpage - 1;
1658                     }
1659                     else if(strstr(s, "last") || strstr(s, "end"))
1660                     {
1661                         if(pages && pagepos>0)
1662                             page = pages[pagepos-1];
1663                     }
1664                     else if(strstr(s, "first") || strstr(s, "top"))
1665                     {
1666                         page = 1;
1667                     }
1668                 }
1669             }
1670         }
1671         break;
1672         case actionLaunch: {
1673             type = "Launch";
1674             LinkLaunch*l = (LinkLaunch*)action;
1675             GString * str = new GString(l->getFileName());
1676             GString * params = l->getParams();
1677             if(params)
1678                 str->append(params);
1679             s = strdup(str->getCString());
1680             delete str;
1681         }
1682         break;
1683         case actionURI: {
1684             char*url = 0;
1685             type = "URI";
1686             LinkURI*l = (LinkURI*)action;
1687             GString*g = l->getURI();
1688             if(g) {
1689              url = g->getCString();
1690              s = strdup(url);
1691             }
1692         }
1693         break;
1694         case actionUnknown: {
1695             type = "Unknown";
1696             LinkUnknown*l = (LinkUnknown*)action;
1697             s = strdup("");
1698         }
1699         break;
1700         default: {
1701             msg("<error> Unknown link type!");
1702             break;
1703         }
1704     }
1705
1706     if(!s) s = strdup("-?-");
1707
1708     msg("<trace> drawlink s=%s", s);
1709
1710     if(!linkinfo && (page || s))
1711     {
1712         msg("<notice> File contains links");
1713         linkinfo = 1;
1714     }
1715
1716     if(page>0)
1717     {
1718         int t;
1719         int lpage = -1;
1720         for(t=1;t<=pagepos;t++) {
1721             if(pages[t]==page) {
1722                 lpage = t;
1723                 break;
1724             }
1725         }
1726         if(lpage<0) {
1727             lpage = page;
1728         }
1729         char buf[80];
1730         sprintf(buf, "page%d", lpage);
1731         device->drawlink(device, points, buf);
1732     }
1733     else if(s)
1734     {
1735         device->drawlink(device, points, s);
1736     }
1737
1738     msg("<verbose> \"%s\" link to \"%s\" (%d)", type, FIXNULL(s), page);
1739     free(s);s=0;
1740 }
1741
1742 void GFXOutputDev::saveState(GfxState *state) {
1743     dbg("saveState"); dbgindent+=2;
1744
1745     msg("<trace> saveState");
1746     updateAll(state);
1747     if(statepos>=64) {
1748       msg("<error> Too many nested states in pdf.");
1749       return;
1750     }
1751     statepos ++;
1752     states[statepos].createsoftmask = states[statepos-1].createsoftmask;
1753     states[statepos].transparencygroup = states[statepos-1].transparencygroup;
1754     states[statepos].clipping = 0;
1755     states[statepos].clipbbox = states[statepos-1].clipbbox;
1756 };
1757
1758 void GFXOutputDev::restoreState(GfxState *state) {
1759   dbgindent-=2; dbg("restoreState");
1760
1761   if(statepos==0) {
1762       msg("<error> Invalid restoreState");
1763       return;
1764   }
1765   msg("<trace> restoreState%s%s", states[statepos].softmask?" (end softmask)":"",
1766                                   states[statepos].clipping?" (end clipping)":"");
1767   if(states[statepos].softmask) {
1768       clearSoftMask(state);
1769   }
1770   updateAll(state);
1771   while(states[statepos].clipping) {
1772       device->endclip(device);
1773       states[statepos].clipping--;
1774   }
1775   statepos--;
1776 }
1777
1778 void GFXOutputDev::updateLineDash(GfxState *state)
1779 {
1780     state->getLineDash(&this->dashPattern, &this->dashLength, &this->dashStart);
1781     msg("<debug> updateLineDash, %d dashes", this->dashLength);
1782     if(!this->dashLength) {
1783         this->dashPattern = 0;
1784     }
1785 }
1786
1787 void GFXOutputDev::updateLineWidth(GfxState *state)
1788 {
1789     double width = state->getTransformedLineWidth();
1790 }
1791
1792 void GFXOutputDev::updateLineCap(GfxState *state)
1793 {
1794     int c = state->getLineCap();
1795 }
1796
1797 void GFXOutputDev::updateLineJoin(GfxState *state)
1798 {
1799     int j = state->getLineJoin();
1800 }
1801
1802 void GFXOutputDev::updateFillColor(GfxState *state)
1803 {
1804     GfxRGB rgb;
1805     double opaq = state->getFillOpacity();
1806     state->getFillRGB(&rgb);
1807 }
1808 void GFXOutputDev::updateFillOpacity(GfxState *state)
1809 {
1810     GfxRGB rgb;
1811     double opaq = state->getFillOpacity();
1812     state->getFillRGB(&rgb);
1813     dbg("update fillopaq %f", opaq);
1814 }
1815 void GFXOutputDev::updateStrokeOpacity(GfxState *state)
1816 {
1817     double opaq = state->getFillOpacity();
1818     dbg("update strokeopaq %f", opaq);
1819 }
1820 void GFXOutputDev::updateFillOverprint(GfxState *state)
1821 {
1822     double opaq = state->getFillOverprint();
1823     dbg("update filloverprint %f", opaq);
1824 }
1825 void GFXOutputDev::updateStrokeOverprint(GfxState *state)
1826 {
1827     double opaq = state->getStrokeOverprint();
1828     dbg("update strokeoverprint %f", opaq);
1829 }
1830 void GFXOutputDev::updateTransfer(GfxState *state)
1831 {
1832     dbg("update transfer");
1833 }
1834
1835
1836 void GFXOutputDev::updateStrokeColor(GfxState *state)
1837 {
1838     GfxRGB rgb;
1839     double opaq = state->getStrokeOpacity();
1840     state->getStrokeRGB(&rgb);
1841 }
1842
1843
1844 static gfxfont_t* createGfxFont(GfxFont*xpdffont, FontInfo*src, double config_fontquality)
1845 {
1846     gfxfont_t*font = (gfxfont_t*)malloc(sizeof(gfxfont_t));
1847     memset(font, 0, sizeof(gfxfont_t));
1848
1849     font->glyphs = (gfxglyph_t*)malloc(sizeof(gfxglyph_t)*src->num_glyphs);
1850     memset(font->glyphs, 0, sizeof(gfxglyph_t)*src->num_glyphs);
1851     font->id = 0;
1852     int t;
1853
1854     double quality = (INTERNAL_FONT_SIZE * 200 / config_fontquality) / src->max_size;
1855     double scale = 1;
1856     //printf("%d glyphs\n", font->num_glyphs);
1857     font->num_glyphs = 0;
1858     for(t=0;t<src->num_glyphs;t++) {
1859         if(src->glyphs[t]) {
1860             SplashPath*path = src->glyphs[t]->path;
1861             int len = path?path->getLength():0;
1862             //printf("glyph %d) %08x (%d line segments)\n", t, path, len);
1863             gfxglyph_t*glyph = &font->glyphs[font->num_glyphs];
1864             src->glyphs[t]->glyphid = font->num_glyphs;
1865             glyph->unicode = src->glyphs[t]->unicode;
1866             if(glyph->unicode >= font->max_unicode)
1867                 font->max_unicode = glyph->unicode+1;
1868             gfxdrawer_t drawer;
1869             gfxdrawer_target_gfxline(&drawer);
1870             int s;
1871             int count = 0;
1872             double xmax = 0;
1873             for(s=0;s<len;s++) {
1874                 Guchar f;
1875                 double x, y;
1876                 path->getPoint(s, &x, &y, &f);
1877                 if(!s || x > xmax)
1878                     xmax = x;
1879                 if(f&splashPathFirst) {
1880                     drawer.moveTo(&drawer, x*scale, y*scale);
1881                 }
1882                 if(f&splashPathCurve) {
1883                     double x2,y2;
1884                     path->getPoint(++s, &x2, &y2, &f);
1885                     if(f&splashPathCurve) {
1886                         double x3,y3;
1887                         path->getPoint(++s, &x3, &y3, &f);
1888                         gfxdraw_cubicTo(&drawer, x*scale, y*scale, x2*scale, y2*scale, x3*scale, y3*scale, quality);
1889                     } else {
1890                         drawer.splineTo(&drawer, x*scale, y*scale, x2*scale, y2*scale);
1891                     }
1892                 } else {
1893                     drawer.lineTo(&drawer, x*scale, y*scale);
1894                 }
1895              //   printf("%f %f %s %s\n", x, y, (f&splashPathCurve)?"curve":"",
1896              //                           (f&splashPathFirst)?"first":"",
1897              //                           (f&splashPathLast)?"last":"");
1898             }
1899             glyph->line = (gfxline_t*)drawer.result(&drawer);
1900             glyph->advance = xmax*scale; // we don't know the real advance value, so this'll have to do
1901             font->num_glyphs++;
1902         }
1903     }
1904     font->unicode2glyph = (int*)malloc(sizeof(int)*font->max_unicode);
1905     memset(font->unicode2glyph, -1, sizeof(int)*font->max_unicode);
1906     for(t=0;t<font->num_glyphs;t++) {
1907         if(font->glyphs[t].unicode>0 && font->glyphs[t].unicode<font->max_unicode) {
1908             font->unicode2glyph[font->glyphs[t].unicode] = t;
1909         }
1910
1911     }
1912     msg("<trace> %d glyphs.", t, font->num_glyphs);
1913     return font;
1914 }
1915
1916 void GFXOutputDev::updateFont(GfxState *state)
1917 {
1918     GfxFont* gfxFont = state->getFont();
1919     if (!gfxFont) {
1920         return;
1921     }
1922     char*id = getFontID(gfxFont);
1923     msg("<verbose> Updating font to %s", id);
1924     if(gfxFont->getType() == fontType3) {
1925         infofeature("Type3 fonts");
1926         if(!config_extrafontdata) {
1927             return;
1928         }
1929     }
1930     if(!id) {
1931         msg("<error> Internal Error: FontID is null");
1932         return;
1933     }
1934
1935     this->current_fontinfo = this->info->getFont(id);
1936     if(!this->current_fontinfo) {
1937         msg("<error> Internal Error: no fontinfo for font %s", id);
1938         return;
1939     }
1940     if(!this->current_fontinfo->seen) {
1941         dumpFontInfo("<verbose>", gfxFont);
1942     }
1943
1944     gfxfont_t*font = gfxfontlist_findfont(this->gfxfontlist,id);
1945     if(!font) {
1946         font = createGfxFont(gfxFont, current_fontinfo, this->config_fontquality);
1947         font->id = strdup(id);
1948         this->gfxfontlist = gfxfontlist_addfont(this->gfxfontlist, font);
1949     }
1950     device->addfont(device, font);
1951
1952     current_gfxfont = font;
1953     free(id);
1954
1955     updateFontMatrix(state);
1956 }
1957
1958 #define SQR(x) ((x)*(x))
1959
1960 unsigned char* antialize(unsigned char*data, int width, int height, int newwidth, int newheight, int palettesize)
1961 {
1962     if((newwidth<2 || newheight<2) ||
1963        (width<=newwidth || height<=newheight))
1964         return 0;
1965     unsigned char*newdata;
1966     int x,y;
1967     newdata= (unsigned char*)malloc(newwidth*newheight);
1968     double fx = (double)(width)/newwidth;
1969     double fy = (double)(height)/newheight;
1970     double px = 0;
1971     int blocksize = (int)(8192/(fx*fy));
1972     int r = 8192*256/palettesize;
1973     for(x=0;x<newwidth;x++) {
1974         double ex = px + fx;
1975         int fromx = (int)px;
1976         int tox = (int)ex;
1977         int xweight1 = (int)(((fromx+1)-px)*256);
1978         int xweight2 = (int)((ex-tox)*256);
1979         double py =0;
1980         for(y=0;y<newheight;y++) {
1981             double ey = py + fy;
1982             int fromy = (int)py;
1983             int toy = (int)ey;
1984             int yweight1 = (int)(((fromy+1)-py)*256);
1985             int yweight2 = (int)((ey-toy)*256);
1986             int a = 0;
1987             int xx,yy;
1988             for(xx=fromx;xx<=tox;xx++)
1989             for(yy=fromy;yy<=toy;yy++) {
1990                 int b = 1-data[width*yy+xx];
1991                 int weight=256;
1992                 if(xx==fromx) weight = (weight*xweight1)/256;
1993                 if(xx==tox) weight = (weight*xweight2)/256;
1994                 if(yy==fromy) weight = (weight*yweight1)/256;
1995                 if(yy==toy) weight = (weight*yweight2)/256;
1996                 a+=b*weight;
1997             }
1998             //if(a) a=(palettesize-1)*r/blocksize;
1999             newdata[y*newwidth+x] = (a*blocksize)/r;
2000             py = ey;
2001         }
2002         px = ex;
2003     }
2004     return newdata;
2005 }
2006
2007 #define IMAGE_TYPE_JPEG 0
2008 #define IMAGE_TYPE_LOSSLESS 1
2009
2010 static void drawimage(gfxdevice_t*dev, gfxcolor_t* data, int sizex,int sizey,
2011         double x1,double y1,
2012         double x2,double y2,
2013         double x3,double y3,
2014         double x4,double y4, int type)
2015 {
2016     gfxcolor_t*newpic=0;
2017
2018     double l1 = sqrt((x4-x1)*(x4-x1) + (y4-y1)*(y4-y1));
2019     double l2 = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
2020
2021     gfxline_t p1,p2,p3,p4,p5;
2022     p1.type=gfx_moveTo;p1.x=x1; p1.y=y1;p1.next=&p2;
2023     p2.type=gfx_lineTo;p2.x=x2; p2.y=y2;p2.next=&p3;
2024     p3.type=gfx_lineTo;p3.x=x3; p3.y=y3;p3.next=&p4;
2025     p4.type=gfx_lineTo;p4.x=x4; p4.y=y4;p4.next=&p5;
2026     p5.type=gfx_lineTo;p5.x=x1; p5.y=y1;p5.next=0;
2027
2028     {p1.x = (int)(p1.x*20)/20.0;
2029      p1.y = (int)(p1.y*20)/20.0;
2030      p2.x = (int)(p2.x*20)/20.0;
2031      p2.y = (int)(p2.y*20)/20.0;
2032      p3.x = (int)(p3.x*20)/20.0;
2033      p3.y = (int)(p3.y*20)/20.0;
2034      p4.x = (int)(p4.x*20)/20.0;
2035      p4.y = (int)(p4.y*20)/20.0;
2036      p5.x = (int)(p5.x*20)/20.0;
2037      p5.y = (int)(p5.y*20)/20.0;
2038     }
2039
2040     gfxmatrix_t m;
2041     m.m00 = (p4.x-p1.x)/sizex; m.m10 = (p2.x-p1.x)/sizey;
2042     m.m01 = (p4.y-p1.y)/sizex; m.m11 = (p2.y-p1.y)/sizey;
2043     m.tx = p1.x - 0.5;
2044     m.ty = p1.y - 0.5;
2045
2046     gfximage_t img;
2047     img.data = (gfxcolor_t*)data;
2048     img.width = sizex;
2049     img.height = sizey;
2050
2051     if(type == IMAGE_TYPE_JPEG)
2052         /* TODO: pass image_dpi to device instead */
2053         dev->setparameter(dev, "next_bitmap_is_jpeg", "1");
2054
2055     dev->fillbitmap(dev, &p1, &img, &m, 0);
2056 }
2057
2058 void drawimagejpeg(gfxdevice_t*dev, gfxcolor_t*mem, int sizex,int sizey,
2059         double x1,double y1, double x2,double y2, double x3,double y3, double x4,double y4)
2060 {
2061     drawimage(dev,mem,sizex,sizey,x1,y1,x2,y2,x3,y3,x4,y4, IMAGE_TYPE_JPEG);
2062 }
2063
2064 void drawimagelossless(gfxdevice_t*dev, gfxcolor_t*mem, int sizex,int sizey,
2065         double x1,double y1, double x2,double y2, double x3,double y3, double x4,double y4)
2066 {
2067     drawimage(dev,mem,sizex,sizey,x1,y1,x2,y2,x3,y3,x4,y4, IMAGE_TYPE_LOSSLESS);
2068 }
2069
2070
2071 void GFXOutputDev::drawGeneralImage(GfxState *state, Object *ref, Stream *str,
2072                                    int width, int height, GfxImageColorMap*colorMap, GBool invert,
2073                                    GBool inlineImg, int mask, int*maskColors,
2074                                    Stream *maskStr, int maskWidth, int maskHeight, GBool maskInvert, GfxImageColorMap*maskColorMap)
2075 {
2076   double x1,y1,x2,y2,x3,y3,x4,y4;
2077   ImageStream *imgStr;
2078   Guchar pixBuf[4];
2079   GfxRGB rgb;
2080   int ncomps = 1;
2081   int bits = 1;
2082   unsigned char* maskbitmap = 0;
2083
2084   if(colorMap) {
2085     ncomps = colorMap->getNumPixelComps();
2086     bits = colorMap->getBits();
2087   }
2088
2089   if(maskStr) {
2090       int x,y;
2091       unsigned char buf[8];
2092       maskbitmap = (unsigned char*)malloc(maskHeight*maskWidth);
2093       if(maskColorMap) {
2094           ImageStream*imgMaskStr = new ImageStream(maskStr, maskWidth, maskColorMap->getNumPixelComps(), maskColorMap->getBits());
2095           imgMaskStr->reset();
2096           unsigned char pal[256];
2097           int n = 1 << colorMap->getBits();
2098           int t;
2099           for(t=0;t<n;t++) {
2100               GfxGray gray;
2101               pixBuf[0] = t;
2102               maskColorMap->getGray(pixBuf, &gray);
2103               pal[t] = colToByte(gray);
2104           }
2105           for (y = 0; y < maskHeight; y++) {
2106               for (x = 0; x < maskWidth; x++) {
2107                   imgMaskStr->getPixel(buf);
2108                   maskbitmap[y*maskWidth+x] = pal[buf[0]];
2109               }
2110           }
2111           delete imgMaskStr;
2112       } else {
2113           ImageStream*imgMaskStr = new ImageStream(maskStr, maskWidth, 1, 1);
2114           imgMaskStr->reset();
2115           for (y = 0; y < maskHeight; y++) {
2116               for (x = 0; x < maskWidth; x++) {
2117                   imgMaskStr->getPixel(buf);
2118                   buf[0]^=maskInvert;
2119                   maskbitmap[y*maskWidth+x] = (buf[0]^1)*255;
2120               }
2121           }
2122           delete imgMaskStr;
2123       }
2124       maskStr->close();
2125   }
2126
2127   imgStr = new ImageStream(str, width, ncomps,bits);
2128   imgStr->reset();
2129
2130   if(!width || !height || (height<=1 && width<=1 && maskWidth<=1 && maskHeight<=1))
2131   {
2132       msg("<verbose> Ignoring %d by %d image", width, height);
2133       unsigned char buf[8];
2134       int x,y;
2135       for (y = 0; y < height; ++y)
2136       for (x = 0; x < width; ++x) {
2137           imgStr->getPixel(buf);
2138       }
2139       delete imgStr;
2140       if(maskbitmap)
2141           free(maskbitmap);
2142       return;
2143   }
2144
2145   this->transformXY(state, 0, 1, &x1, &y1);
2146   this->transformXY(state, 0, 0, &x2, &y2);
2147   this->transformXY(state, 1, 0, &x3, &y3);
2148   this->transformXY(state, 1, 1, &x4, &y4);
2149
2150   if(!pbminfo && !(str->getKind()==strDCT)) {
2151       if(!type3active) {
2152           msg("<notice> File contains pbm pictures %s",mask?"(masked)":"");
2153           pbminfo = 1;
2154       }
2155       if(mask)
2156       msg("<verbose> drawing %d by %d masked picture", width, height);
2157   }
2158   if(!jpeginfo && (str->getKind()==strDCT)) {
2159       msg("<notice> File contains jpeg pictures");
2160       jpeginfo = 1;
2161   }
2162
2163   if(mask) {
2164       unsigned char buf[8];
2165       int x,y;
2166       unsigned char*pic = new unsigned char[width*height];
2167       gfxcolor_t pal[256];
2168       GfxRGB rgb;
2169       state->getFillRGB(&rgb);
2170
2171       memset(pal,255,sizeof(pal));
2172       pal[0].r = (int)(colToByte(rgb.r)); pal[1].r = 0;
2173       pal[0].g = (int)(colToByte(rgb.g)); pal[1].g = 0;
2174       pal[0].b = (int)(colToByte(rgb.b)); pal[1].b = 0;
2175       pal[0].a = 255;              pal[1].a = 0;
2176
2177       int numpalette = 2;
2178       int realwidth = (int)sqrt(SQR(x2-x3) + SQR(y2-y3));
2179       int realheight = (int)sqrt(SQR(x1-x2) + SQR(y1-y2));
2180       for (y = 0; y < height; ++y)
2181       for (x = 0; x < width; ++x)
2182       {
2183             imgStr->getPixel(buf);
2184             if(invert)
2185                 buf[0]=1-buf[0];
2186             pic[width*y+x] = buf[0];
2187       }
2188
2189       /* the size of the drawn image is added to the identifier
2190          as the same image may require different bitmaps if displayed
2191          at different sizes (due to antialiasing): */
2192       int found = -1;
2193       if(type3active) {
2194           unsigned char*pic2 = 0;
2195           numpalette = 16;
2196
2197           pic2 = antialize(pic,width,height,realwidth,realheight,numpalette);
2198
2199           if(!pic2) {
2200             delete[] pic;
2201             delete imgStr;
2202             return;
2203           }
2204
2205           width = realwidth;
2206           height = realheight;
2207           delete[] pic;
2208           pic = pic2;
2209
2210           /* make a black/white palette */
2211
2212           float r = 255./(float)(numpalette-1);
2213           int t;
2214           for(t=0;t<numpalette;t++) {
2215               pal[t].r = colToByte(rgb.r);
2216               pal[t].g = colToByte(rgb.g);
2217               pal[t].b = colToByte(rgb.b);
2218               pal[t].a = (unsigned char)(t*r);
2219           }
2220       }
2221
2222       gfxcolor_t*pic2 = new gfxcolor_t[width*height];
2223       for (y = 0; y < height; ++y) {
2224         for (x = 0; x < width; ++x) {
2225           pic2[width*y+x] = pal[pic[y*width+x]];
2226         }
2227       }
2228       drawimagelossless(device, pic2, width, height, x1,y1,x2,y2,x3,y3,x4,y4);
2229       delete[] pic2;
2230       delete[] pic;
2231       delete imgStr;
2232       if(maskbitmap) free(maskbitmap);
2233       return;
2234   }
2235
2236   int x,y;
2237
2238   if(colorMap->getNumPixelComps()!=1 || str->getKind()==strDCT) {
2239       gfxcolor_t*pic=new gfxcolor_t[width*height];
2240       for (y = 0; y < height; ++y) {
2241         for (x = 0; x < width; ++x) {
2242           imgStr->getPixel(pixBuf);
2243           colorMap->getRGB(pixBuf, &rgb);
2244           pic[width*y+x].r = (unsigned char)(colToByte(rgb.r));
2245           pic[width*y+x].g = (unsigned char)(colToByte(rgb.g));
2246           pic[width*y+x].b = (unsigned char)(colToByte(rgb.b));
2247           pic[width*y+x].a = 255;//(U8)(rgb.a * 255 + 0.5);
2248           if(maskbitmap) {
2249               pic[width*y+x].a = maskbitmap[(y*maskHeight/height)*maskWidth+(x*maskWidth/width)];
2250           }
2251         }
2252       }
2253       if(str->getKind()==strDCT)
2254           drawimagejpeg(device, pic, width, height, x1,y1,x2,y2,x3,y3,x4,y4);
2255       else
2256           drawimagelossless(device, pic, width, height, x1,y1,x2,y2,x3,y3,x4,y4);
2257       delete[] pic;
2258       delete imgStr;
2259       if(maskbitmap) free(maskbitmap);
2260       return;
2261   } else {
2262       gfxcolor_t*pic=new gfxcolor_t[width*height];
2263       gfxcolor_t pal[256];
2264       int n = 1 << colorMap->getBits();
2265       int t;
2266       for(t=0;t<256;t++) {
2267           pixBuf[0] = t;
2268           colorMap->getRGB(pixBuf, &rgb);
2269
2270           {/*if(maskColors && *maskColors==t) {
2271               msg("<notice> Color %d is transparent", t);
2272               if (imgData->maskColors) {
2273                 *alpha = 0;
2274                 for (i = 0; i < imgData->colorMap->getNumPixelComps(); ++i) {
2275                   if (pix[i] < imgData->maskColors[2*i] ||
2276                       pix[i] > imgData->maskColors[2*i+1]) {
2277                     *alpha = 1;
2278                     break;
2279                   }
2280                 }
2281               } else {
2282                 *alpha = 1;
2283               }
2284               if(!*alpha) {
2285                     pal[t].r = 0;
2286                     pal[t].g = 0;
2287                     pal[t].b = 0;
2288                     pal[t].a = 0;
2289               }
2290           } else {*/
2291               pal[t].r = (unsigned char)(colToByte(rgb.r));
2292               pal[t].g = (unsigned char)(colToByte(rgb.g));
2293               pal[t].b = (unsigned char)(colToByte(rgb.b));
2294               pal[t].a = 255;//(U8)(rgb.b * 255 + 0.5);
2295           }
2296       }
2297       for (y = 0; y < height; ++y) {
2298         for (x = 0; x < width; ++x) {
2299           imgStr->getPixel(pixBuf);
2300           pic[width*y+x] = pal[pixBuf[0]];
2301         }
2302       }
2303       if(maskbitmap) {
2304           if(maskWidth < width && maskHeight < height) {
2305               for(y = 0; y < height; y++) {
2306                   for (x = 0; x < width; x++) {
2307                       pic[width*y+x].a = maskbitmap[(y*maskHeight/height)*maskWidth+(x*maskWidth/width)];
2308                   }
2309               }
2310           } else {
2311               msg("<verbose> resampling %dx%d to mask size (%dx%d)", width, height, maskWidth, maskHeight);
2312               gfxcolor_t*newpic=new gfxcolor_t[maskWidth*maskHeight];
2313               double dx = width / maskWidth;
2314               double dy = height / maskHeight;
2315               double yy = 0;
2316               for(y = 0; y < maskHeight; y++) {
2317                   double xx = 0;
2318                   for (x = 0; x < maskWidth; x++) {
2319                       newpic[maskWidth*y+x] = pic[int(yy)*width+int(xx)];
2320                       newpic[maskWidth*y+x].a = maskbitmap[maskWidth*y+x];
2321                       xx += dx;
2322                   }
2323                   yy += dy;
2324               }
2325               delete[] pic;
2326               pic = newpic;
2327               width = maskWidth;
2328               height = maskHeight;
2329           }
2330       }
2331       drawimagelossless(device, pic, width, height, x1,y1,x2,y2,x3,y3,x4,y4);
2332
2333       delete[] pic;
2334       delete imgStr;
2335       if(maskbitmap) free(maskbitmap);
2336       return;
2337   }
2338 }
2339
2340 void GFXOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str,
2341                                    int width, int height, GBool invert,
2342                                    GBool inlineImg)
2343 {
2344     dbg("drawImageMask %dx%d, invert=%d inline=%d", width, height, invert, inlineImg);
2345     msg("<verbose> drawImageMask %dx%d, invert=%d inline=%d", width, height, invert, inlineImg);
2346     drawGeneralImage(state,ref,str,width,height,0,invert,inlineImg,1, 0, 0,0,0,0, 0);
2347 }
2348
2349 void GFXOutputDev::drawImage(GfxState *state, Object *ref, Stream *str,
2350                          int width, int height, GfxImageColorMap *colorMap,
2351                          int *maskColors, GBool inlineImg)
2352 {
2353     dbg("drawImage %dx%d, %s, %s, inline=%d", width, height,
2354             colorMap?"colorMap":"no colorMap",
2355             maskColors?"maskColors":"no maskColors",
2356             inlineImg);
2357     msg("<verbose> drawImage %dx%d, %s, %s, inline=%d", width, height,
2358             colorMap?"colorMap":"no colorMap",
2359             maskColors?"maskColors":"no maskColors",
2360             inlineImg);
2361     if(colorMap)
2362         msg("<verbose> colorMap pixcomps:%d bits:%d mode:%d", colorMap->getNumPixelComps(),
2363                 colorMap->getBits(),colorMap->getColorSpace()->getMode());
2364     drawGeneralImage(state,ref,str,width,height,colorMap,0,inlineImg,0,maskColors, 0,0,0,0, 0);
2365 }
2366
2367 void GFXOutputDev::drawMaskedImage(GfxState *state, Object *ref, Stream *str,
2368                                int width, int height,
2369                                GfxImageColorMap *colorMap,
2370                                Stream *maskStr, int maskWidth, int maskHeight,
2371                                GBool maskInvert)
2372 {
2373     dbg("drawMaskedImage %dx%d, %s, %dx%d mask", width, height,
2374             colorMap?"colorMap":"no colorMap",
2375             maskWidth, maskHeight);
2376     msg("<verbose> drawMaskedImage %dx%d, %s, %dx%d mask", width, height,
2377             colorMap?"colorMap":"no colorMap",
2378             maskWidth, maskHeight);
2379     if(colorMap)
2380         msg("<verbose> colorMap pixcomps:%d bits:%d mode:%d", colorMap->getNumPixelComps(),
2381                 colorMap->getBits(),colorMap->getColorSpace()->getMode());
2382     drawGeneralImage(state,ref,str,width,height,colorMap,0,0,0,0, maskStr, maskWidth, maskHeight, maskInvert, 0);
2383 }
2384
2385 void GFXOutputDev::drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str,
2386                                    int width, int height,
2387                                    GfxImageColorMap *colorMap,
2388                                    Stream *maskStr,
2389                                    int maskWidth, int maskHeight,
2390                                    GfxImageColorMap *maskColorMap)
2391 {
2392     dbg("drawSoftMaskedImage %dx%d, %s, %dx%d mask", width, height,
2393             colorMap?"colorMap":"no colorMap",
2394             maskWidth, maskHeight);
2395     msg("<verbose> drawSoftMaskedImage %dx%d, %s, %dx%d mask", width, height,
2396             colorMap?"colorMap":"no colorMap",
2397             maskWidth, maskHeight);
2398     if(colorMap)
2399         msg("<verbose> colorMap pixcomps:%d bits:%d mode:%d", colorMap->getNumPixelComps(),
2400                 colorMap->getBits(),colorMap->getColorSpace()->getMode());
2401     drawGeneralImage(state,ref,str,width,height,colorMap,0,0,0,0, maskStr, maskWidth, maskHeight, 0, maskColorMap);
2402 }
2403
2404 void GFXOutputDev::stroke(GfxState *state)
2405 {
2406     dbg("stroke");
2407
2408     GfxPath * path = state->getPath();
2409     gfxline_t*line= gfxPath_to_gfxline(state, path, 0, user_movex + clipmovex, user_movey + clipmovey);
2410     strokeGfxline(state, line, 0);
2411     gfxline_free(line);
2412 }
2413
2414 void GFXOutputDev::fill(GfxState *state)
2415 {
2416     gfxcolor_t col = getFillColor(state);
2417     dbg("fill %02x%02x%02x%02x",col.r,col.g,col.b,col.a);
2418
2419     GfxPath * path = state->getPath();
2420     gfxline_t*line= gfxPath_to_gfxline(state, path, 1, user_movex + clipmovex, user_movey + clipmovey);
2421     if(config_optimize_polygons) {
2422         gfxline_t*line2 = gfxline_circularToEvenOdd(line);
2423         gfxline_free(line);
2424         line = line2;
2425     }
2426     fillGfxLine(state, line);
2427     gfxline_free(line);
2428 }
2429
2430 void GFXOutputDev::eoFill(GfxState *state)
2431 {
2432     gfxcolor_t col = getFillColor(state);
2433     dbg("eofill %02x%02x%02x%02x",col.r,col.g,col.b,col.a);
2434
2435     GfxPath * path = state->getPath();
2436     gfxline_t*line= gfxPath_to_gfxline(state, path, 1, user_movex + clipmovex, user_movey + clipmovey);
2437     fillGfxLine(state, line);
2438     gfxline_free(line);
2439 }
2440
2441
2442 static const char* dirseparator()
2443 {
2444 #ifdef WIN32
2445     return "\\";
2446 #else
2447     return "/";
2448 #endif
2449 }
2450
2451 void addGlobalFont(const char*filename)
2452 {
2453     fontfile_t* f = (fontfile_t*)malloc(sizeof(fontfile_t));
2454     memset(f, 0, sizeof(fontfile_t));
2455     f->filename = filename;
2456     int len = strlen(filename);
2457     char*r1 = strrchr(filename, '/');
2458     char*r2 = strrchr(filename, '\\');
2459     if(r2>r1)
2460         r1 = r2;
2461     if(r1) {
2462         len = strlen(r1+1);
2463     }
2464     f->len = len;
2465
2466     msg("<notice> Adding font \"%s\".", filename);
2467     if(global_fonts_next) {
2468         global_fonts_next->next = f;
2469         global_fonts_next = global_fonts_next->next;
2470     } else {
2471         global_fonts_next = global_fonts = f;
2472     }
2473 }
2474
2475 void addGlobalLanguageDir(const char*dir)
2476 {
2477     msg("<notice> Adding %s to language pack directories", dir);
2478
2479     FILE*fi = 0;
2480     char* config_file = (char*)malloc(strlen(dir) + 1 + sizeof("add-to-xpdfrc") + 1);
2481     strcpy(config_file, dir);
2482     strcat(config_file, dirseparator());
2483     strcat(config_file, "add-to-xpdfrc");
2484
2485     fi = fopen(config_file, "rb");
2486     if(!fi) {
2487         msg("<error> Could not open %s", config_file);
2488         return;
2489     }
2490     globalParams->parseFile(new GString(config_file), fi);
2491     fclose(fi);
2492 }
2493
2494 void addGlobalFontDir(const char*dirname)
2495 {
2496 #ifdef HAVE_DIRENT_H
2497     msg("<notice> Adding %s to font directories", dirname);
2498     lastfontdir = strdup(dirname);
2499     DIR*dir = opendir(dirname);
2500     if(!dir) {
2501         msg("<warning> Couldn't open directory %s", dirname);
2502         return;
2503     }
2504     struct dirent*ent;
2505     while(1) {
2506         ent = readdir (dir);
2507         if (!ent)
2508             break;
2509         int l;
2510         char*name = ent->d_name;
2511         char type = 0;
2512         if(!name) continue;
2513         l=strlen(name);
2514         if(l<4)
2515             continue;
2516         if(!strncasecmp(&name[l-4], ".pfa", 4))
2517             type=1;
2518         if(!strncasecmp(&name[l-4], ".pfb", 4))
2519             type=3;
2520         if(!strncasecmp(&name[l-4], ".ttf", 4))
2521             type=2;
2522         if(type) {
2523             char*fontname = (char*)malloc(strlen(dirname)+strlen(name)+2);
2524             strcpy(fontname, dirname);
2525             strcat(fontname, dirseparator());
2526             strcat(fontname, name);
2527             addGlobalFont(fontname);
2528         }
2529     }
2530     closedir(dir);
2531 #else
2532     msg("<warning> No dirent.h- unable to add font dir %s", dirname);
2533 #endif
2534 }
2535
2536 void GFXOutputDev::preparePage(int pdfpage, int outputpage)
2537 {
2538     if(pdfpage < 0)
2539         return;
2540
2541     if(!this->pages) {
2542         this->pagebuflen = 1024;
2543         this->pages = (int*)malloc(this->pagebuflen*sizeof(int));
2544         memset(this->pages, -1, this->pagebuflen*sizeof(int));
2545     } else {
2546         while(pdfpage >= this->pagebuflen)
2547         {
2548             int oldlen = this->pagebuflen;
2549             this->pagebuflen+=1024;
2550             this->pages = (int*)realloc(this->pages, this->pagebuflen*sizeof(int));
2551             memset(&this->pages[oldlen], -1, (this->pagebuflen-oldlen)*sizeof(int));
2552         }
2553     }
2554     this->pages[pdfpage] = outputpage;
2555     if(pdfpage>this->pagepos)
2556         this->pagepos = pdfpage;
2557 }
2558
2559 void GFXOutputDev::beginTransparencyGroup(GfxState *state, double *bbox,
2560                                       GfxColorSpace *blendingColorSpace,
2561                                       GBool isolated, GBool knockout,
2562                                       GBool forSoftMask)
2563 {
2564     const char*colormodename = "";
2565
2566     if(blendingColorSpace) {
2567         colormodename = GfxColorSpace::getColorSpaceModeName(blendingColorSpace->getMode());
2568     }
2569     dbg("beginTransparencyGroup device=%08x %.1f/%.1f/%.1f/%.1f %s isolated=%d knockout=%d forsoftmask=%d", device, bbox[0],bbox[1],bbox[2],bbox[3], colormodename, isolated, knockout, forSoftMask);
2570     msg("<verbose> beginTransparencyGroup %.1f/%.1f/%.1f/%.1f %s isolated=%d knockout=%d forsoftmask=%d", bbox[0],bbox[1],bbox[2],bbox[3], colormodename, isolated, knockout, forSoftMask);
2571
2572     //states[statepos].createsoftmask |= forSoftMask;
2573     states[statepos].createsoftmask = forSoftMask;
2574     states[statepos].transparencygroup = !forSoftMask;
2575     states[statepos].isolated = isolated;
2576
2577     states[statepos].olddevice = this->device;
2578     this->device = (gfxdevice_t*)rfx_calloc(sizeof(gfxdevice_t));
2579
2580     gfxdevice_record_init(this->device);
2581
2582     /*if(!forSoftMask) { ////???
2583         state->setFillOpacity(0.0);
2584     }*/
2585     dbgindent+=2;
2586 }
2587
2588 void GFXOutputDev::endTransparencyGroup(GfxState *state)
2589 {
2590     dbgindent-=2;
2591     gfxdevice_t*r = this->device;
2592
2593     this->device = states[statepos].olddevice;
2594
2595     gfxresult_t*recording = r->finish(r);
2596
2597     dbg("endTransparencyGroup forsoftmask=%d recording=%08x/%08x", states[statepos].createsoftmask, r, recording);
2598     msg("<verbose> endTransparencyGroup forsoftmask=%d recording=%08x/%08x", states[statepos].createsoftmask, r, recording);
2599
2600     if(states[statepos].createsoftmask) {
2601         states[statepos-1].softmaskrecording = recording;
2602     } else {
2603         states[statepos-1].grouprecording = recording;
2604     }
2605
2606     states[statepos].createsoftmask = 0;
2607     states[statepos].transparencygroup = 0;
2608     free(r);
2609 }
2610
2611 void GFXOutputDev::paintTransparencyGroup(GfxState *state, double *bbox)
2612 {
2613     const char*blendmodes[] = {"normal","multiply","screen","overlay","darken", "lighten",
2614                                "colordodge","colorburn","hardlight","softlight","difference",
2615                                "exclusion","hue","saturation","color","luminosity"};
2616
2617     dbg("paintTransparencyGroup blend=%s softmaskon=%d", blendmodes[state->getBlendMode()], states[statepos].softmask);
2618     msg("<verbose> paintTransparencyGroup blend=%s softmaskon=%d", blendmodes[state->getBlendMode()], states[statepos].softmask);
2619
2620     if(state->getBlendMode() == gfxBlendNormal)
2621         infofeature("transparency groups");
2622     else {
2623         char buffer[80];
2624         sprintf(buffer, "%s blended transparency groups", blendmodes[state->getBlendMode()]);
2625         warnfeature(buffer, 0);
2626     }
2627
2628     gfxresult_t*grouprecording = states[statepos].grouprecording;
2629
2630     int blendmode = state->getBlendMode();
2631     if(blendmode == gfxBlendNormal || blendmode == gfxBlendMultiply) {
2632         int alpha = (int)(state->getFillOpacity()*255);
2633         if(blendmode == gfxBlendMultiply && alpha>200)
2634             alpha = 128;
2635         gfxdevice_t ops;
2636         gfxdevice_ops_init(&ops, this->device, alpha);
2637         gfxresult_record_replay(grouprecording, &ops);
2638         ops.finish(&ops);
2639     }
2640     grouprecording->destroy(grouprecording);
2641
2642     states[statepos].grouprecording = 0;
2643 }
2644
2645 void GFXOutputDev::setSoftMask(GfxState *state, double *bbox, GBool alpha, Function *transferFunc, GfxColor *rgb)
2646 {
2647     if(states[statepos].softmask) {
2648         /* shouldn't happen, but *does* happen */
2649         clearSoftMask(state);
2650     }
2651
2652     /* alpha = 1: retrieve mask values from alpha layer
2653        alpha = 0: retrieve mask values from luminance */
2654
2655     dbg("setSoftMask %.1f/%.1f/%.1f/%.1f alpha=%d backdrop=%02x%02x%02x",
2656             bbox[0], bbox[1], bbox[2], bbox[3], alpha, colToByte(rgb->c[0]), colToByte(rgb->c[1]), colToByte(rgb->c[2]));
2657     msg("<verbose> setSoftMask %.1f/%.1f/%.1f/%.1f alpha=%d backdrop=%02x%02x%02x",
2658             bbox[0], bbox[1], bbox[2], bbox[3], alpha, colToByte(rgb->c[0]), colToByte(rgb->c[1]), colToByte(rgb->c[2]));
2659     if(!alpha)
2660         infofeature("soft masks");
2661     else
2662         warnfeature("soft masks from alpha channel",0);
2663
2664     states[statepos].olddevice = this->device;
2665     this->device = (gfxdevice_t*)rfx_calloc(sizeof(gfxdevice_t));
2666     gfxdevice_record_init(this->device);
2667
2668     dbg("softmaskrecording is %08x (dev=%08x) at statepos %d\n", states[statepos].softmaskrecording, this->device, statepos);
2669
2670     states[statepos].softmask = 1;
2671     states[statepos].softmask_alpha = alpha;
2672 }
2673
2674 static inline Guchar div255(int x) {
2675   return (Guchar)((x + (x >> 8) + 0x80) >> 8);
2676 }
2677
2678 static unsigned char clampU8(unsigned char c, unsigned char min, unsigned char max)
2679 {
2680     if(c < min) c = min;
2681     if(c > max) c = max;
2682     return c;
2683 }
2684
2685 void GFXOutputDev::clearSoftMask(GfxState *state)
2686 {
2687     if(!states[statepos].softmask)
2688         return;
2689     states[statepos].softmask = 0;
2690     dbg("clearSoftMask statepos=%d", statepos);
2691     msg("<verbose> clearSoftMask statepos=%d", statepos);
2692
2693     if(!states[statepos].softmaskrecording || strcmp(this->device->name, "record")) {
2694         msg("<error> Error in softmask/tgroup ordering");
2695         return;
2696     }
2697
2698     gfxresult_t*mask = states[statepos].softmaskrecording;
2699     gfxresult_t*below = this->device->finish(this->device);free(this->device);
2700     this->device = states[statepos].olddevice;
2701
2702     /* get outline of all objects below the soft mask */
2703     gfxdevice_t uniondev;
2704     gfxdevice_union_init(&uniondev, 0);
2705     gfxresult_record_replay(below, &uniondev);
2706     gfxline_t*belowoutline = gfxdevice_union_getunion(&uniondev);
2707     uniondev.finish(&uniondev);
2708     gfxbbox_t bbox = gfxline_getbbox(belowoutline);
2709     gfxline_free(belowoutline);belowoutline=0;
2710 #if 0
2711     this->device->startclip(this->device, belowoutline);
2712     gfxresult_record_replay(below, this->device);
2713     gfxresult_record_replay(mask, this->device);
2714     this->device->endclip(this->device);
2715 #endif
2716
2717     int width = (int)bbox.xmax,height = (int)bbox.ymax;
2718     if(width<=0 || height<=0)
2719         return;
2720
2721     gfxdevice_t belowrender;
2722     gfxdevice_render_init(&belowrender);
2723     if(states[statepos+1].isolated) {
2724         belowrender.setparameter(&belowrender, "fillwhite", "1");
2725     }
2726     belowrender.setparameter(&belowrender, "antialize", "2");
2727     belowrender.startpage(&belowrender, width, height);
2728     gfxresult_record_replay(below, &belowrender);
2729     belowrender.endpage(&belowrender);
2730     gfxresult_t* belowresult = belowrender.finish(&belowrender);
2731     gfximage_t* belowimg = (gfximage_t*)belowresult->get(belowresult,"page0");
2732     //writePNG("below.png", (unsigned char*)belowimg->data, belowimg->width, belowimg->height);
2733
2734     gfxdevice_t maskrender;
2735     gfxdevice_render_init(&maskrender);
2736     maskrender.startpage(&maskrender, width, height);
2737     gfxresult_record_replay(mask, &maskrender);
2738     maskrender.endpage(&maskrender);
2739     gfxresult_t* maskresult = maskrender.finish(&maskrender);
2740     gfximage_t* maskimg = (gfximage_t*)maskresult->get(maskresult,"page0");
2741
2742     if(belowimg->width != maskimg->width || belowimg->height != maskimg->height) {
2743         msg("<fatal> Internal error in mask drawing");
2744         return;
2745     }
2746
2747     int y,x;
2748     for(y=0;y<height;y++) {
2749         gfxcolor_t* l1 = &maskimg->data[maskimg->width*y];
2750         gfxcolor_t* l2 = &belowimg->data[belowimg->width*y];
2751         for(x=0;x<width;x++) {
2752             int alpha;
2753             if(states[statepos].softmask_alpha) {
2754                 alpha = l1->a;
2755             } else {
2756                 alpha = (77*l1->r + 151*l1->g + 28*l1->b) >> 8;
2757             }
2758
2759             l2->a = div255(alpha*l2->a);
2760
2761             /* DON'T premultiply alpha- this is done by fillbitmap,
2762                depending on the output device */
2763             //l2->r = div255(alpha*l2->r);
2764             //l2->g = div255(alpha*l2->g);
2765             //l2->b = div255(alpha*l2->b);
2766
2767             l1++;
2768             l2++;
2769         }
2770     }
2771     gfxline_t*line = gfxline_makerectangle(0,0,width,height);
2772
2773     gfxmatrix_t matrix;
2774     matrix.m00 = 1.0; matrix.m10 = 0.0; matrix.tx = 0.0;
2775     matrix.m01 = 0.0; matrix.m11 = 1.0; matrix.ty = 0.0;
2776
2777     this->device->fillbitmap(this->device, line, belowimg, &matrix, 0);
2778
2779     mask->destroy(mask);
2780     below->destroy(below);
2781     maskresult->destroy(maskresult);
2782     belowresult->destroy(belowresult);
2783     states[statepos].softmaskrecording = 0;
2784 }
2785
2786 //class MemCheck
2787 //{
2788 //    public: ~MemCheck()
2789 //    {
2790 //        delete globalParams;globalParams=0;
2791 //        Object::memCheck(stderr);
2792 //        gMemReport(stderr);
2793 //    }
2794 //} myMemCheck;
2795