Changeset 263 for trunk


Ignore:
Timestamp:
Jan 17, 2009, 11:24:41 AM (12 years ago)
Author:
Eugene Romanenko
Message:

PDF plugin: Poppler library updated to version 0.10.3

Location:
trunk
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/Lucide/SOURCE/plugins/lupoppler/lupoppler.cpp

    r261 r263  
    103103extern "C" char * EXPENTRY getDescription()
    104104{
    105     return "PDF plugin, based on poppler library v0.10.2";
     105    return "PDF plugin, based on poppler library v0.10.3";
    106106}
    107107
  • trunk/Lucide/changelog

    r262 r263  
    1 1.XX:
    2   - PDF plugin: Poppler (pdf rendering) library updated to version 0.10.2.
     11.21:
     2  - PDF plugin: Poppler (pdf rendering) library updated to version 0.10.3.
    33  - PDF plugin: freetype library updated to version 2.3.8.
    44
  • trunk/poppler/mypoppler/goo/GooString.cc

    r257 r263  
    1919// Copyright (C) 2006 Krzysztof Kowalczyk <kkowalczyk@gmail.com>
    2020// Copyright (C) 2007 Jeff Muizelaar <jeff@infidigm.net>
     21// Copyright (C) 2008 Albert Astals Cid <aacid@kde.org>
    2122//
    2223// To see a description of the changes please see the Changelog file that
     
    743744    return (s[0] & 0xff) == 0xfe && (s[1] & 0xff) == 0xff;
    744745}
     746
     747GooString *GooString::sanitizedName(GBool psmode)
     748{
     749  GooString *name;
     750  char buf[8];
     751  int i;
     752  char c;
     753
     754  name = new GooString();
     755
     756  if (psmode)
     757  {
     758    // ghostscript chokes on names that begin with out-of-limits
     759    // numbers, e.g., 1e4foo is handled correctly (as a name), but
     760    // 1e999foo generates a limitcheck error
     761    c = getChar(0);
     762    if (c >= '0' && c <= '9') {
     763      name->append('f');
     764    }
     765  }
     766
     767  for (i = 0; i < getLength(); ++i) {
     768    c = getChar(i);
     769    if ((psmode && (c <= (char)0x20 || c >= (char)0x7f)) ||
     770        c == ' ' ||
     771        c == '(' || c == ')' || c == '<' || c == '>' ||
     772        c == '[' || c == ']' || c == '{' || c == '}' ||
     773        c == '/' || c == '%') {
     774      sprintf(buf, "#%02x", c & 0xff);
     775      name->append(buf);
     776    } else {
     777      name->append(c);
     778    }
     779  }
     780  return name;
     781}
  • trunk/poppler/mypoppler/goo/GooString.h

    r257 r263  
    1818// Copyright (C) 2006 Kristian HÞgsberg <krh@redhat.com>
    1919// Copyright (C) 2006 Krzysztof Kowalczyk <kkowalczyk@gmail.com>
     20// Copyright (C) 2008 Albert Astals Cid <aacid@kde.org>
    2021//
    2122// To see a description of the changes please see the Changelog file that
     
    138139  GBool hasUnicodeMarker(void);
    139140
     141  // Sanitizes the string so that it does
     142  // not contain any ( ) < > [ ] { } / %
     143  // The postscript mode also has some more strict checks
     144  // The caller owns the return value
     145  GooString *sanitizedName(GBool psmode);
     146
    140147private:
    141148  // you can tweak this number for a different speed/memory usage tradeoffs.
  • trunk/poppler/mypoppler/poppler/Annot.cc

    r261 r263  
    1616// Copyright (C) 2006 Scott Turner <scotty1024@mac.com>
    1717// Copyright (C) 2007, 2008 Julien Rebetez <julienr@svn.gnome.org>
    18 // Copyright (C) 2007, 2008 Albert Astals Cid <aacid@kde.org>
     18// Copyright (C) 2007-2009 Albert Astals Cid <aacid@kde.org>
    1919// Copyright (C) 2007, 2008 Carlos Garcia Campos <carlosgc@gnome.org>
    2020// Copyright (C) 2007, 2008 Iñigo Martínez <inigomartinez@gmail.com>
     
    2323// Copyright (C) 2008 Michael Vrable <mvrable@cs.ucsd.edu>
    2424// Copyright (C) 2008 Hugo Mercier <hmercier31@gmail.com>
     25// Copyright (C) 2009 Ilya Gorenbein <igorenbein@finjan.com>
    2526//
    2627// To see a description of the changes please see the Changelog file that
     
    21402141  int tfPos, tmPos, i, j;
    21412142  GBool freeText = gFalse;      // true if text should be freed before return
     2143  GBool freeFont = gFalse;
    21422144
    21432145  //~ if there is no MK entry, this should use the existing content stream,
     
    21742176
    21752177  // force ZapfDingbats
    2176   //~ this should create the font if needed (?)
    21772178  if (forceZapfDingbats) {
    21782179    if (tfPos >= 0) {
     
    21912192    if (tok->getLength() >= 1 && tok->getChar(0) == '/') {
    21922193      if (!fontDict || !(font = fontDict->lookup(tok->getCString() + 1))) {
    2193         error(-1, "Unknown font in field's DA string");
     2194        if (forceZapfDingbats) {
     2195          // We are forcing ZaDb but the font does not exist
     2196          // so create a fake one
     2197          Ref r; // dummy Ref, it's not used at all in this codepath
     2198          r.num = 0;
     2199          r.gen = 0;
     2200          Dict *d = new Dict(xref);
     2201          font = new Gfx8BitFont(xref, "ZaDb", r, new GooString("ZapfDingbats"), fontType1, d);
     2202          delete d;
     2203          freeFont = gTrue;
     2204          addDingbatsResource = gTrue;
     2205        } else {
     2206          error(-1, "Unknown font in field's DA string");
     2207        }
    21942208      }
    21952209    } else {
     
    24962510  }
    24972511  delete convertedText;
     2512  if (freeFont) {
     2513    font->decRefCnt();
     2514  }
    24982515}
    24992516
     
    30573074    }
    30583075
     3076    obj2.free();
     3077    obj1.free();
     3078
    30593079    // this annot doesn't have an AP yet, create one
    30603080    if (appRef.num == 0)
     
    30993119  }
    31003120
     3121  addDingbatsResource = gFalse;
    31013122  generateFieldAppearance ();
    31023123
    31033124  // draw the appearance stream
    31043125  appearance.fetch(xref, &obj);
     3126  if (addDingbatsResource) {
     3127    // We are forcing ZaDb but the font does not exist
     3128    // so create a fake one
     3129    Object baseFontObj, subtypeObj;
     3130    baseFontObj.initName("ZapfDingbats");
     3131    subtypeObj.initName("Type1");
     3132
     3133    Object fontDictObj;
     3134    Dict *fontDict = new Dict(xref);
     3135    fontDict->decRef();
     3136    fontDict->add(copyString("BaseFont"), &baseFontObj);
     3137    fontDict->add(copyString("Subtype"), &subtypeObj);
     3138    fontDictObj.initDict(fontDict);
     3139
     3140    Object fontsDictObj;
     3141    Dict *fontsDict = new Dict(xref);
     3142    fontsDict->decRef();
     3143    fontsDict->add(copyString("ZaDb"), &fontDictObj);
     3144    fontsDictObj.initDict(fontsDict);
     3145
     3146    Dict *dict = new Dict(xref);
     3147    dict->add(copyString("Font"), &fontsDictObj);
     3148    gfx->pushResources(dict);
     3149    delete dict;
     3150  }
    31053151  gfx->drawAnnot(&obj, (AnnotBorder *)NULL, color,
    31063152                 rect->x1, rect->y1, rect->x2, rect->y2);
     3153  if (addDingbatsResource) {
     3154    gfx->popResources();
     3155  }
    31073156  obj.free();
    31083157}
     
    33893438  if (appearCharacs)
    33903439    delete appearCharacs;
     3440
     3441  action.free();
     3442  additionAction.free();
    33913443}
    33923444
  • trunk/poppler/mypoppler/poppler/Annot.h

    r261 r263  
    2222// Copyright (C) 2008 Pino Toscano <pino@kde.org>
    2323// Copyright (C) 2008 Tomas Are Haavet <tomasare@gmail.com>
     24// Copyright (C) 2009 Albert Astals Cid <aacid@kde.org>
    2425//
    2526// To see a description of the changes please see the Changelog file that
     
    11951196  Dict *parent;                           // Parent
    11961197  GBool regen;
     1198  GBool addDingbatsResource;
    11971199};
    11981200
  • trunk/poppler/mypoppler/poppler/Form.cc

    r261 r263  
    66//
    77// Copyright 2006-2008 Julien Rebetez <julienr@svn.gnome.org>
    8 // Copyright 2007-2008 Albert Astals Cid <aacid@kde.org>
     8// Copyright 2007-2009 Albert Astals Cid <aacid@kde.org>
    99// Copyright 2007-2008 Carlos Garcia Campos <carlosgc@gnome.org>
    1010// Copyright 2007 Adrian Johnson <ajohnson@redneon.com>
     
    259259          }
    260260        } else if (obj2.isStream()) {
     261          // TODO do something with str and obj3
    261262          Stream *str = obj2.getStream();
    262263          Dict *tmpDict2 = str->getDict();
     
    264265          tmpDict2->lookup("Length", &obj3);
    265266          onStr = new GooString ("D");
     267          obj3.free();
    266268        }
    267269        obj2.free();
  • trunk/poppler/mypoppler/poppler/Gfx.h

    r261 r263  
    1818// Copyright (C) 2008 Brad Hards <bradh@kde.org>
    1919// Copyright (C) 2008 Carlos Garcia Campos <carlosgc@gnome.org>
     20// Copyright (C) 2009 Albert Astals Cid <aacid@kde.org>
    2021//
    2122// To see a description of the changes please see the Changelog file that
     
    163164  // Get the current graphics state object.
    164165  GfxState *getState() { return state; }
     166
     167  void pushResources(Dict *resDict);
     168  void popResources();
    165169
    166170private:
     
    334338  void pushMarkedContent();
    335339  void popMarkedContent();
    336 
    337   void pushResources(Dict *resDict);
    338   void popResources();
    339340};
    340341
  • trunk/poppler/mypoppler/poppler/Outline.cc

    r257 r263  
    1515//
    1616// Copyright (C) 2005 Marco Pesenti Gritti <mpg@redhat.com>
     17// Copyright (C) 2008 Albert Astals Cid <aacid@kde.org>
    1718//
    1819// To see a description of the changes please see the Changelog file that
     
    133134  Object *p;
    134135
     136  if (!lastItemRef->isRef())
     137    return NULL;
     138
    135139  items = new GooList();
    136140  p = firstItemRef;
  • trunk/poppler/mypoppler/poppler/PDFDoc.cc

    r257 r263  
    636636  outStr->printf("<<");
    637637  for (int i=0; i<dict->getLength(); i++) {
    638     outStr->printf("/%s ", dict->getKey(i));
     638    GooString keyName(dict->getKey(i));
     639    GooString *keyNameToPrint = keyName.sanitizedName(gFalse /* non ps mode */);
     640    outStr->printf("/%s ", keyNameToPrint->getCString());
     641    delete keyNameToPrint;
    639642    writeObject(dict->getValNF(i, &obj1), NULL, outStr);
    640643    obj1.free();
    641644  }
    642   outStr->printf(">>");
     645  outStr->printf(">> ");
    643646}
    644647
     
    712715
    713716  if(ref)
    714     outStr->printf("%i %i obj", ref->num, ref->gen);
     717    outStr->printf("%i %i obj ", ref->num, ref->gen);
    715718
    716719  switch (obj->getType()) {
     
    728731      break;
    729732    case objName:
    730       outStr->printf("/%s ", obj->getName());
    731       break;
     733    {
     734      GooString name(obj->getName());
     735      GooString *nameToPrint = name.sanitizedName(gFalse /* non ps mode */);
     736      outStr->printf("/%s ", nameToPrint->getCString());
     737      delete nameToPrint;
     738      break;
     739    }
    732740    case objNull:
    733741      outStr->printf( "null");
     
    740748        obj1.free();
    741749      }
    742       outStr->printf("]");
     750      outStr->printf("] ");
    743751      break;
    744752    case objDict:
  • trunk/poppler/mypoppler/poppler/PSOutputDev.cc

    r257 r263  
    1919// Copyright (C) 2006 Jeff Muizelaar <jeff@infidigm.net>
    2020// Copyright (C) 2007, 2008 Brad Hards <bradh@kde.org>
     21// Copyright (C) 2008 Koji Otani <sho@bbr.jp>
    2122//
    2223// To see a description of the changes please see the Changelog file that
     
    3637#include <signal.h>
    3738#include <math.h>
     39#include <limits.h>
    3840#include "goo/GooString.h"
    3941#include "goo/GooList.h"
     
    16471649             font->getType() == fontType1 &&
    16481650             font->getEmbeddedFontID(&fontFileID)) {
    1649     psName = filterPSName(font->getEmbeddedFontName());
     1651    psName = font->getEmbeddedFontName()->sanitizedName(gTrue /* ps mode */);
    16501652    setupEmbeddedType1Font(&fontFileID, psName);
    16511653
     
    16561658    // use the PDF font name because the embedded font name might
    16571659    // not include the subset prefix
    1658     psName = filterPSName(font->getOrigName());
     1660    psName = font->getOrigName()->sanitizedName(gTrue /* ps mode */);
    16591661    setupEmbeddedType1CFont(font, &fontFileID, psName);
    16601662
     
    16651667    // use the PDF font name because the embedded font name might
    16661668    // not include the subset prefix
    1667     psName = filterPSName(font->getOrigName());
     1669    psName = font->getOrigName()->sanitizedName(gTrue /* ps mode */);
    16681670    setupEmbeddedOpenTypeT1CFont(font, &fontFileID, psName);
    16691671
     
    16811683              font->getType() == fontTrueTypeOT) &&
    16821684             font->getEmbeddedFontID(&fontFileID)) {
    1683     psName = filterPSName(font->getEmbeddedFontName());
     1685    psName = font->getEmbeddedFontName()->sanitizedName(gTrue /* ps mode */);
    16841686    setupEmbeddedTrueTypeFont(font, &fontFileID, psName);
    16851687
     
    16941696             font->getType() == fontCIDType0C &&
    16951697             font->getEmbeddedFontID(&fontFileID)) {
    1696     psName = filterPSName(font->getEmbeddedFontName());
     1698    psName = font->getEmbeddedFontName()->sanitizedName(gTrue /* ps mode */);
    16971699    setupEmbeddedCIDType0Font(font, &fontFileID, psName);
    16981700
     
    17021704              font->getType() == fontCIDType2OT) &&
    17031705             font->getEmbeddedFontID(&fontFileID)) {
    1704     psName = filterPSName(font->getEmbeddedFontName());
     1706    psName = font->getEmbeddedFontName()->sanitizedName(gTrue /* ps mode */);
    17051707    setupEmbeddedCIDTrueTypeFont(font, &fontFileID, psName, gTrue);
    17061708
     
    17091711             font->getType() == fontCIDType0COT &&
    17101712             font->getEmbeddedFontID(&fontFileID)) {
    1711     psName = filterPSName(font->getEmbeddedFontName());
     1713    psName = font->getEmbeddedFontName()->sanitizedName(gTrue /* ps mode */);
    17121714    setupEmbeddedOpenTypeCFFFont(font, &fontFileID, psName);
    17131715
     
    18781880  int start[4];
    18791881  GBool binMode;
     1882  GBool writePadding = gTrue;
    18801883  int i;
    18811884
     
    19491952  }
    19501953
     1954  if (length2 == 0)
     1955  {
     1956    // length2 == 0 is an error
     1957    // trying to solve it by just piping all
     1958    // the stream data
     1959    error(-1, "Font has length2 as 0, trying to overcome the problem reading the stream until the end");
     1960    length2 = INT_MAX;
     1961    writePadding = gFalse;
     1962  }
     1963
     1964
    19511965  // convert binary data to ASCII
    19521966  if (binMode) {
     
    19872001  }
    19882002
    1989   // write padding and "cleartomark"
    1990   for (i = 0; i < 8; ++i) {
    1991     writePS("00000000000000000000000000000000"
    1992             "00000000000000000000000000000000\n");
    1993   }
    1994   writePS("cleartomark\n");
     2003  if (writePadding)
     2004  {
     2005    // write padding and "cleartomark"
     2006    for (i = 0; i < 8; ++i) {
     2007      writePS("00000000000000000000000000000000"
     2008              "00000000000000000000000000000000\n");
     2009    }
     2010    writePS("cleartomark\n");
     2011  }
    19952012
    19962013  // ending comment
     
    22072224  }
    22082225
    2209   psName = filterPSName(font->getName());
     2226  psName = font->getName()->sanitizedName(gTrue /* ps mode */);
    22102227  // add entry to fontFileNames list
    22112228  if (i == fontFileNameLen) {
     
    22802297  }
    22812298
    2282   psName = filterPSName(font->getName());
     2299  psName = font->getName()->sanitizedName(gTrue /* ps mode */);
    22832300  // add entry to fontFileNames list
    22842301  if (i == fontFileNameLen) {
     
    26112628  int c;
    26122629  int size, line, col, i;
     2630  int outerSize, outer;
    26132631
    26142632  // check if image is already setup
     
    26972715    ++size;
    26982716  }
     2717  outerSize = size/65535 + 1;
     2718
    26992719  writePSFmt("{0:d} array dup /ImData_{1:d}_{2:d} exch def\n",
    2700              size, id.num, id.gen);
     2720             outerSize, id.num, id.gen);
    27012721  str->close();
    27022722
    27032723  // write the data into the array
    27042724  str->reset();
    2705   line = col = 0;
    2706   writePS((char *)(useASCIIHex ? "dup 0 <" : "dup 0 <~"));
    2707   do {
    2708     do {
    2709       c = str->getChar();
    2710     } while (c == '\n' || c == '\r');
    2711     if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
    2712       break;
    2713     }
    2714     if (c == 'z') {
    2715       writePSChar(c);
    2716       ++col;
    2717     } else {
    2718       writePSChar(c);
    2719       ++col;
    2720       for (i = 1; i <= (useASCIIHex ? 1 : 4); ++i) {
    2721         do {
    2722           c = str->getChar();
    2723         } while (c == '\n' || c == '\r');
    2724         if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
    2725           break;
    2726         }
     2725  for (outer = 0;outer < outerSize;outer++) {
     2726    int innerSize = size > 65535 ? 65535 : size;
     2727
     2728    // put the inner array into the outer array
     2729    writePSFmt("{0:d} array 1 index {1:d} 2 index put\n",
     2730               innerSize, outer);
     2731    line = col = 0;
     2732    writePS((char *)(useASCIIHex ? "dup 0 <" : "dup 0 <~"));
     2733    for (;;) {
     2734      do {
     2735        c = str->getChar();
     2736      } while (c == '\n' || c == '\r');
     2737      if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
     2738        break;
     2739      }
     2740      if (c == 'z') {
    27272741        writePSChar(c);
    27282742        ++col;
    2729       }
    2730     }
    2731     // each line is: "dup nnnnn <~...data...~> put<eol>"
    2732     // so max data length = 255 - 20 = 235
    2733     // chunks are 1 or 4 bytes each, so we have to stop at 232
    2734     // but make it 225 just to be safe
    2735     if (col > 225) {
     2743      } else {
     2744        writePSChar(c);
     2745        ++col;
     2746        for (i = 1; i <= (useASCIIHex ? 1 : 4); ++i) {
     2747          do {
     2748            c = str->getChar();
     2749          } while (c == '\n' || c == '\r');
     2750          if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
     2751            break;
     2752          }
     2753          writePSChar(c);
     2754          ++col;
     2755        }
     2756      }
     2757      // each line is: "dup nnnnn <~...data...~> put<eol>"
     2758      // so max data length = 255 - 20 = 235
     2759      // chunks are 1 or 4 bytes each, so we have to stop at 232
     2760      // but make it 225 just to be safe
     2761      if (col > 225) {
     2762        writePS((char *)(useASCIIHex ? "> put\n" : "~> put\n"));
     2763        ++line;
     2764        if (line >= innerSize) break;
     2765        writePSFmt((char *)(useASCIIHex ? "dup {0:d} <" : "dup {0:d} <~"), line);
     2766        col = 0;
     2767      }
     2768    }
     2769    if (c == (useASCIIHex ? '>' : '~') || c == EOF) {
    27362770      writePS((char *)(useASCIIHex ? "> put\n" : "~> put\n"));
    2737       ++line;
    2738       writePSFmt((char *)(useASCIIHex ? "dup {0:d} <" : "dup {0:d} <~"), line);
    2739       col = 0;
    2740     }
    2741   } while (c != (useASCIIHex ? '>' : '~') && c != EOF);
    2742   writePS((char *)(useASCIIHex ? "> put\n" : "~> put\n"));
    2743   if (useRLE) {
    2744     ++line;
    2745     writePSFmt("{0:d} <> put\n", line);
    2746   } else {
     2771      if (useRLE) {
     2772        ++line;
     2773        writePSFmt("{0:d} <> put\n", line);
     2774      } else {
     2775        writePS("pop\n");
     2776      }
     2777      break;
     2778    }
    27472779    writePS("pop\n");
    2748   }
     2780    size -= innerSize;
     2781  }
     2782  writePS("pop\n");
    27492783  str->close();
    27502784
     
    43834417      setupImage(ref->getRef(), str);
    43844418      // set up to use the array already created by setupImages()
    4385       writePSFmt("ImData_{0:d}_{1:d} 0\n", ref->getRefNum(), ref->getRefGen());
     4419      writePSFmt("ImData_{0:d}_{1:d} 0 0\n", ref->getRefNum(), ref->getRefGen());
    43864420    }
    43874421  }
     
    48464880      setupImage(ref->getRef(), str);
    48474881      // set up to use the array already created by setupImages()
    4848       writePSFmt("ImData_{0:d}_{1:d} 0\n", ref->getRefNum(), ref->getRefGen());
     4882      writePSFmt("ImData_{0:d}_{1:d} 0 0\n",ref->getRefNum(), ref->getRefGen());
    48494883    }
    48504884  }
     
    49004934  // data source
    49014935  if (mode == psModeForm || inType3Char || preload) {
    4902     writePS("  /DataSource { 2 copy get exch 1 add exch }\n");
     4936    if (inlineImg) {
     4937      writePS("  /DataSource { 2 copy get exch 1 add exch }\n");
     4938    } else {
     4939      writePS("  /DataSource { dup 65535 ge { pop 1 add 0 } if 2 index 2"
     4940        " index get 1 index get exch 1 add exch }\n");
     4941    }
    49034942  } else {
    49044943    writePS("  /DataSource currentfile\n");
     
    49394978
    49404979    // get rid of the array and index
     4980    if (!inlineImg) writePS("pop ");
    49414981    writePS("pop pop\n");
    49424982
     
    51165156      setupImage(ref->getRef(), str);
    51175157      // set up to use the array already created by setupImages()
    5118       writePSFmt("ImData_{0:d}_{1:d} 0\n", ref->getRefNum(), ref->getRefGen());
     5158      writePSFmt("ImData_{0:d}_{1:d} 0 0\n", ref->getRefNum(), ref->getRefGen());
    51195159    }
    51205160  }
     
    51875227  // data source
    51885228  if (mode == psModeForm || inType3Char || preload) {
    5189     writePS("  /DataSource { 2 copy get exch 1 add exch }\n");
     5229    if (inlineImg) {
     5230        writePS("  /DataSource { 2 copy get exch 1 add exch }\n");
     5231    } else {
     5232        writePS("  /DataSource { dup 65535 ge { pop 1 add 0 } if 2 index 2"
     5233          " index get 1 index get exch 1 add exch }\n");
     5234    }
    51905235  } else {
    51915236    writePS("  /DataSource currentfile\n");
     
    53235368  // get rid of the array and index
    53245369  if (mode == psModeForm || inType3Char || preload) {
     5370    if (!inlineImg) writePS("pop ");
    53255371    writePS("pop pop\n");
    53265372
     
    62956341}
    62966342
    6297 GooString *PSOutputDev::filterPSName(GooString *name) {
    6298   GooString *name2;
    6299   char buf[8];
    6300   int i;
    6301   char c;
    6302 
    6303   name2 = new GooString();
    6304 
    6305   // ghostscript chokes on names that begin with out-of-limits
    6306   // numbers, e.g., 1e4foo is handled correctly (as a name), but
    6307   // 1e999foo generates a limitcheck error
    6308   c = name->getChar(0);
    6309   if (c >= '0' && c <= '9') {
    6310     name2->append('f');
    6311   }
    6312 
    6313   for (i = 0; i < name->getLength(); ++i) {
    6314     c = name->getChar(i);
    6315     if (c <= (char)0x20 || c >= (char)0x7f ||
    6316         c == '(' || c == ')' || c == '<' || c == '>' ||
    6317         c == '[' || c == ']' || c == '{' || c == '}' ||
    6318         c == '/' || c == '%') {
    6319       sprintf(buf, "#%02x", c & 0xff);
    6320       name2->append(buf);
    6321     } else {
    6322       name2->append(c);
    6323     }
    6324   }
    6325   return name2;
    6326 }
    6327 
    63286343// Convert GooString to GooString, with appropriate escaping
    63296344// of things that can't appear in a label
  • trunk/poppler/mypoppler/poppler/PSOutputDev.h

    r257 r263  
    1616// Copyright (C) 2005 Martin Kretzschmar <martink@gnome.org>
    1717// Copyright (C) 2005 Kristian HÞgsberg <krh@redhat.com>
    18 // Copyright (C) 2006, 2007 Albert Astals Cid <aacid@kde.org>
     18// Copyright (C) 2006-2008 Albert Astals Cid <aacid@kde.org>
    1919// Copyright (C) 2007 Brad Hards <bradh@kde.org>
    2020//
     
    327327  void writePSString(GooString *s);
    328328  void writePSName(char *s);
    329   GooString *filterPSName(GooString *name);
    330329  GooString *filterPSLabel(GooString *label, GBool *needParens=0);
    331330  void writePSTextLine(GooString *s);
  • trunk/poppler/mypoppler/poppler/poppler-config.h

    r257 r263  
    4949
    5050// copyright notice
    51 #define popplerCopyright "Copyright 2005-2008 The Poppler Developers - http://poppler.freedesktop.org"
     51#define popplerCopyright "Copyright 2005-2009 The Poppler Developers - http://poppler.freedesktop.org"
    5252#define xpdfCopyright "Copyright 1996-2004 Glyph & Cog, LLC"
    5353
Note: See TracChangeset for help on using the changeset viewer.