Changeset 44


Ignore:
Timestamp:
Jun 5, 2006, 4:02:32 PM (16 years ago)
Author:
Eugene Romanenko
Message:

poppler updated to version 0.5.3, related changes

Location:
trunk
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/Lucide/SOURCE/gui/Lucide.rc

    r40 r44  
    8787    "/", CM_SELECTALL, CONTROL
    8888    "A", CM_SELECTALL, CONTROL
     89    "a", CM_SELECTALL, CONTROL
    8990    VK_INSERT, CM_COPY, VIRTUALKEY, CONTROL
    9091    "F", CM_FIND, CONTROL
  • trunk/Lucide/SOURCE/plugins/lupoppler/lupoppler.cpp

    r35 r44  
    179179SOM_Scope short  SOMLINK getBpp(LuPopplerDocument *somSelf,  Environment *ev)
    180180{
    181     return 4;
     181    return 3;
    182182}
    183183
     
    13771377    white[1] = 255;
    13781378    white[2] = 255;
    1379     document->output_dev = new SplashOutputDev( splashModeRGB8, 4, gFalse, white );
     1379    document->output_dev = new SplashOutputDev( splashModeBGR8, 4, gFalse, white );
    13801380    document->output_dev->startDoc( document->doc->getXRef() );
    13811381
  • trunk/poppler/mypoppler/poppler/CairoFontEngine.cc

    r2 r44  
    3939}
    4040
    41 CairoFont::CairoFont(GfxFont *gfxFont, XRef *xref, FT_Library lib, GBool useCIDs) {
     41CairoFont *CairoFont::create(GfxFont *gfxFont, XRef *xref, FT_Library lib, GBool useCIDs) {
    4242  Ref embRef;
    4343  Object refObj, strObj;
     
    5353  CharCodeToUnicode *ctu;
    5454  Unicode uBuf[8];
     55  Ref ref;
    5556  static cairo_user_data_key_t cairo_font_face_key;
     57  cairo_font_face_t *cairo_font_face;
     58  FT_Face face;
     59
     60  Gushort *codeToGID;
     61  int codeToGIDLen;
    5662 
    5763  dfp = NULL;
     
    161167              gfxFont->getName() ? gfxFont->getName()->getCString()
    162168                        : "(unnamed)");
     169        goto err2;
    163170      }
    164171    } else {
     
    242249    goto err2; /* this doesn't do anything, but it looks like we're
    243250                * handling the error */
    244   }
    245 
     251  } {
     252  CairoFont *ret = new CairoFont(ref, cairo_font_face, face, codeToGID, codeToGIDLen);
    246253  cairo_font_face_set_user_data (cairo_font_face,
    247254                                 &cairo_font_face_key,
    248                                  this,
     255                                 ret,
    249256                                 cairo_font_face_destroy);
    250257
    251   return;
     258  return ret;
     259  }
    252260 err2:
    253261  /* hmm? */
    254262  printf ("some font thing failed\n");
    255 }
     263  return NULL;
     264}
     265
     266CairoFont::CairoFont(Ref ref, cairo_font_face_t *cairo_font_face, FT_Face face,
     267    Gushort *codeToGID, int codeToGIDLen) : ref(ref), cairo_font_face(cairo_font_face),
     268                                            face(face), codeToGID(codeToGID),
     269                                            codeToGIDLen(codeToGIDLen) { }
    256270
    257271CairoFont::~CairoFont() {
     
    337351  }
    338352 
    339   font = new CairoFont (gfxFont, xref, lib, useCIDs);
     353  font = CairoFont::create (gfxFont, xref, lib, useCIDs);
     354  //XXX: if font is null should we still insert it into the cache?
    340355  if (fontCache[cairoFontCacheSize - 1]) {
    341356    delete fontCache[cairoFontCacheSize - 1];
  • trunk/poppler/mypoppler/poppler/CairoFontEngine.h

    r27 r44  
    1919class CairoFont {
    2020public:
    21   CairoFont(GfxFont *gfxFont, XRef *xref, FT_Library lib, GBool useCIDs);
     21  static CairoFont *create(GfxFont *gfxFont, XRef *xref, FT_Library lib, GBool useCIDs);
    2222  ~CairoFont();
    2323
     
    2626  unsigned long getGlyph(CharCode code, Unicode *u, int uLen);
    2727private:
     28  CairoFont(Ref ref, cairo_font_face_t *cairo_font_face, FT_Face face,
     29      Gushort *codeToGID, int codeToGIDLen);
    2830  Ref ref;
    2931  cairo_font_face_t *cairo_font_face;
  • trunk/poppler/mypoppler/poppler/CairoOutputDev.cc

    r27 r44  
    259259  needFontUpdate = gFalse;
    260260
     261  if (state->getFont()->getType() == fontType3) 
     262    return;
     263
    261264  currentFont = fontEngine->getFont (state->getFont(), xref);
    262265
     266  if (!currentFont)
     267    return;
    263268  state->getFontTransMat(&m11, &m12, &m21, &m22);
    264269  m11 *= state->getHorizScaling();
     
    372377  double tx, ty;
    373378
     379  if (!currentFont)
     380    return;
     381 
    374382  glyphs[glyphCount].index = currentFont->getGlyph (code, u, uLen);
    375383  state->transform(x - originX, y - originY, &tx, &ty);
  • trunk/poppler/mypoppler/poppler/CairoOutputDev.h

    r27 r44  
    5353  // Does this device use beginType3Char/endType3Char?  Otherwise,
    5454  // text in Type 3 fonts will be drawn with drawChar/drawString.
    55   virtual GBool interpretType3Chars() { return gFalse; }
     55  virtual GBool interpretType3Chars() { return gTrue; }
    5656
    5757  //----- initialization and control
  • trunk/poppler/mypoppler/poppler/SplashOutputDev.cc

    r2 r44  
    627627  case splashModeRGB8:
    628628  case splashModeBGR8:
     629  case splashModeRGB8Qt:
    629630    color[0] = color[1] = color[2] = 0;
    630631    break;
     
    878879    break;
    879880  case splashModeRGB8:
     881  case splashModeRGB8Qt:
    880882    color1[0] = colToByte(r);
    881883    color1[1] = colToByte(g);
     
    16711673  case splashModeRGB8:
    16721674    case splashModeBGR8:
     1675    case splashModeRGB8Qt:
    16731676      for (x = 0, p = imgData->imgStr->getLine(), q = line;
    16741677           x < imgData->width;
     
    17141717        break;
    17151718    case splashModeRGB8:
     1719    case splashModeRGB8Qt:
    17161720      for (x = 0, p = imgData->imgStr->getLine(), q = line;
    17171721           x < imgData->width;
     
    17981802        break;
    17991803      case splashModeRGB8:
     1804      case splashModeRGB8Qt:
    18001805        *q++ = alpha;
    18011806        col = &imgData->lookup[3 * *p];
     
    18391844        break;
    18401845      case splashModeRGB8:
     1846      case splashModeRGB8Qt:
    18411847        imgData->colorMap->getRGB(p, &rgb);
    18421848        *q++ = alpha;
     
    20442050        break;
    20452051      case splashModeRGB8:
     2052      case splashModeRGB8Qt:
    20462053        *q++ = alpha;
    20472054        col = &imgData->lookup[3 * *p];
     
    20852092        break;
    20862093      case splashModeRGB8:
     2094      case splashModeRGB8Qt:
    20872095        imgData->colorMap->getRGB(p, &rgb);
    20882096        *q++ = alpha;
  • trunk/poppler/mypoppler/splash/Splash.cc

    r27 r44  
    308308  case splashModeRGB8:
    309309  case splashModeBGR8:
     310    if (color[0] == color[1] && color[1] == color[2]) {
     311      if (bitmap->rowSize < 0) {
     312        memset(bitmap->data + bitmap->rowSize * (bitmap->height - 1),
     313               color[0], -bitmap->rowSize * bitmap->height);
     314      } else {
     315        memset(bitmap->data, color[0], bitmap->rowSize * bitmap->height);
     316      }
     317    } else {
     318      row = bitmap->data;
     319      for (y = 0; y < bitmap->height; ++y) {
     320        p = row;
     321        for (x = 0; x < bitmap->width; ++x) {
     322          *p++ = color[0];
     323          *p++ = color[1];
     324          *p++ = color[2];
     325        }
     326        row += bitmap->rowSize;
     327      }
     328    }
     329    break;
     330  case splashModeRGB8Qt:
    310331    if (color[0] == color[1] && color[1] == color[2]) {
    311332      if (bitmap->rowSize < 0) {
     
    965986      case splashModeRGB8:
    966987      case splashModeBGR8:
     988        p = &bitmap->data[y * bitmap->rowSize + 3 * x];
     989        (*blendFunc)(color, p, blend, bitmap->mode);
     990        p[0] = (alpha2 * blend[0] + ialpha2 * p[0]) >> 8;
     991        p[1] = (alpha2 * blend[1] + ialpha2 * p[1]) >> 8;
     992        p[2] = (alpha2 * blend[2] + ialpha2 * p[2]) >> 8;
     993        break;
     994      case splashModeRGB8Qt:
    967995        p = &bitmap->data[y * bitmap->rowSize + 4 * x];
    968996        (*blendFunc)(color, p, blend, bitmap->mode);
     
    10161044      case splashModeRGB8:
    10171045      case splashModeBGR8:
     1046        p = &bitmap->data[y * bitmap->rowSize + 3 * x];
     1047        p[0] = color[0];
     1048        p[1] = color[1];
     1049        p[2] = color[2];
     1050        break;
     1051      case splashModeRGB8Qt:
    10181052        p = &bitmap->data[y * bitmap->rowSize + 4 * x];
    10191053        p[0] = color[2];
     
    10941128      case splashModeRGB8:
    10951129      case splashModeBGR8:
     1130        p = &bitmap->data[y * bitmap->rowSize + 3 * x];
     1131        (*blendFunc)(color, p, blend, bitmap->mode);
     1132        p[0] = (alpha2 * blend[0] + ialpha2 * p[0]) >> 8;
     1133        p[1] = (alpha2 * blend[1] + ialpha2 * p[1]) >> 8;
     1134        p[2] = (alpha2 * blend[2] + ialpha2 * p[2]) >> 8;
     1135        break;
     1136      case splashModeRGB8Qt:
    10961137        p = &bitmap->data[y * bitmap->rowSize + 4 * x];
    10971138        (*blendFunc)(color, p, blend, bitmap->mode);
     
    11461187      case splashModeRGB8:
    11471188      case splashModeBGR8:
     1189        p = &bitmap->data[y * bitmap->rowSize + 3 * x];
     1190        p[0] = color[0];
     1191        p[1] = color[1];
     1192        p[2] = color[2];
     1193        break;
     1194      case splashModeRGB8Qt:
    11481195        p = &bitmap->data[y * bitmap->rowSize + 4 * x];
    11491196        p[0] = color[2];
     
    14071454    case splashModeRGB8:
    14081455    case splashModeBGR8:
     1456      p = &bitmap->data[y * bitmap->rowSize + 3 * x0];
     1457      if (pattern->isStatic()) {
     1458        pattern->getColor(0, 0, color);
     1459        for (i = 0; i < n; ++i) {
     1460          if (noClip || state->clip->test(x0 + i, y)) {
     1461            if (softMask) {
     1462              alpha2 = (int)(alpha *
     1463                             softMask->data[y * softMask->rowSize + x0 + i]);
     1464              ialpha2 = 255 - alpha2;
     1465            }
     1466            (*blendFunc)(color, p, blend, bitmap->mode);
     1467            p[0] = (alpha2 * blend[0] + ialpha2 * p[0]) >> 8;
     1468            p[1] = (alpha2 * blend[1] + ialpha2 * p[1]) >> 8;
     1469            p[2] = (alpha2 * blend[2] + ialpha2 * p[2]) >> 8;
     1470            if (!noClip) {
     1471              updateModX(x0 + i);
     1472              updateModY(y);
     1473            }
     1474          }
     1475          p += 3;
     1476        }
     1477      } else {
     1478        for (i = 0; i < n; ++i) {
     1479          if (noClip || state->clip->test(x0 + i, y)) {
     1480            pattern->getColor(x0 + i, y, color);
     1481            if (softMask) {
     1482              alpha2 = (int)(alpha *
     1483                             softMask->data[y * softMask->rowSize + x0 + i]);
     1484              ialpha2 = 255 - alpha2;
     1485            }
     1486            (*blendFunc)(color, p, blend, bitmap->mode);
     1487            p[0] = (alpha2 * blend[0] + ialpha2 * p[0]) >> 8;
     1488            p[1] = (alpha2 * blend[1] + ialpha2 * p[1]) >> 8;
     1489            p[2] = (alpha2 * blend[2] + ialpha2 * p[2]) >> 8;
     1490            if (!noClip) {
     1491              updateModX(x0 + i);
     1492              updateModY(y);
     1493            }
     1494          }
     1495          p += 3;
     1496        }
     1497      }
     1498      break;
     1499
     1500    case splashModeRGB8Qt:
    14091501      p = &bitmap->data[y * bitmap->rowSize + 4 * x0];
    14101502      if (pattern->isStatic()) {
     
    17001792    case splashModeRGB8:
    17011793    case splashModeBGR8:
     1794      p = &bitmap->data[y * bitmap->rowSize + 3 * x0];
     1795      if (pattern->isStatic()) {
     1796        pattern->getColor(0, 0, color);
     1797        for (i = 0; i < n; ++i) {
     1798          if (noClip || state->clip->test(x0 + i, y)) {
     1799            p[0] = color[0];
     1800            p[1] = color[1];
     1801            p[2] = color[2];
     1802            if (!noClip) {
     1803              updateModX(x0 + i);
     1804              updateModY(y);
     1805            }
     1806          }
     1807          p += 3;
     1808        }
     1809      } else {
     1810        for (i = 0; i < n; ++i) {
     1811          if (noClip || state->clip->test(x0 + i, y)) {
     1812            pattern->getColor(x0 + i, y, color);
     1813            p[0] = color[0];
     1814            p[1] = color[1];
     1815            p[2] = color[2];
     1816            if (!noClip) {
     1817              updateModX(x0 + i);
     1818              updateModY(y);
     1819            }
     1820          }
     1821          p += 3;
     1822        }
     1823      }
     1824      break;
     1825
     1826    case splashModeRGB8Qt:
    17021827      p = &bitmap->data[y * bitmap->rowSize + 4 * x0];
    17031828      if (pattern->isStatic()) {
     
    19002025  case splashModeRGB8:
    19012026  case splashModeBGR8:
     2027    p = &bitmap->data[y * bitmap->rowSize + 3 * x0];
     2028    for (i = 0; i < n; ++i) {
     2029      if (noClip || state->clip->test(x0 + i, y)) {
     2030        pattern->getColor(x0 + i, y, color);
     2031        p[0] ^= color[0];
     2032        p[1] ^= color[1];
     2033        p[2] ^= color[2];
     2034        if (!noClip) {
     2035          updateModX(x0 + i);
     2036          updateModY(y);
     2037        }
     2038      }
     2039      p += 3;
     2040    }
     2041    break;
     2042
     2043  case splashModeRGB8Qt:
    19022044    p = &bitmap->data[y * bitmap->rowSize + 4 * x0];
    19032045    for (i = 0; i < n; ++i) {
     
    20572199                case splashModeRGB8:
    20582200                case splashModeBGR8:
     2201                  pix = &bitmap->data[y1 * bitmap->rowSize + 3 * x1];
     2202                  (*blendFunc)(fg, pix, blend, bitmap->mode);
     2203                  pix[0] = (alpha * blend[0] + ialpha * pix[0]) >> 8;
     2204                  pix[1] = (alpha * blend[1] + ialpha * pix[1]) >> 8;
     2205                  pix[2] = (alpha * blend[2] + ialpha * pix[2]) >> 8;
     2206                  break;
     2207                case splashModeRGB8Qt:
    20592208                  pix = &bitmap->data[y1 * bitmap->rowSize + 4 * x1];
    20602209                  (*blendFunc)(fg, pix, blend, bitmap->mode);
     
    21382287                  case splashModeRGB8:
    21392288                  case splashModeBGR8:
     2289                    pix = &bitmap->data[y1 * bitmap->rowSize + 3 * x1];
     2290                    (*blendFunc)(fg, pix, blend, bitmap->mode);
     2291                    pix[0] = (alpha * blend[0] + ialpha * pix[0]) >> 8;
     2292                    pix[1] = (alpha * blend[1] + ialpha * pix[1]) >> 8;
     2293                    pix[2] = (alpha * blend[2] + ialpha * pix[2]) >> 8;
     2294                    break;
     2295                  case splashModeRGB8Qt:
    21402296                    pix = &bitmap->data[y1 * bitmap->rowSize + 4 * x1];
    21412297                    (*blendFunc)(fg, pix, blend, bitmap->mode);
     
    22132369                case splashModeRGB8:
    22142370                case splashModeBGR8:
     2371                  pix = &bitmap->data[y1 * bitmap->rowSize + 3 * x1];
     2372                  pix[0] = (alpha * fg[0] + ialpha * pix[0]) >> 8;
     2373                  pix[1] = (alpha * fg[1] + ialpha * pix[1]) >> 8;
     2374                  pix[2] = (alpha * fg[2] + ialpha * pix[2]) >> 8;
     2375                  break;
     2376                case splashModeRGB8Qt:
    22152377                  pix = &bitmap->data[y1 * bitmap->rowSize + 4 * x1];
    22162378                  pix[0] = (alpha * fg[2] + ialpha * pix[0]) >> 8;
     
    22782440                  case splashModeRGB8:
    22792441                  case splashModeBGR8:
     2442                    pix = &bitmap->data[y1 * bitmap->rowSize + 3 * x1];
     2443                    pix[0] = fg[0];
     2444                    pix[1] = fg[1];
     2445                    pix[2] = fg[2];
     2446                    break;
     2447                  case splashModeRGB8Qt:
    22802448                    pix = &bitmap->data[y1 * bitmap->rowSize + 4 * x1];
    22812449                    pix[0] = fg[2];
     
    26352803    nComps = 2;
    26362804    break;
     2805  case splashModeRGB8Qt:
    26372806  case splashModeRGB8:
    26382807    ok = srcMode == splashModeRGB8 || srcMode == splashModeARGB8;
  • trunk/poppler/mypoppler/splash/SplashBitmap.cc

    r27 r44  
    3737  case splashModeRGB8:
    3838  case splashModeBGR8:
    39     rowSize = width * 4;
    40     break;
     39    rowSize = width * 3;
     40    break;
     41  case splashModeRGB8Qt:
    4142  case splashModeARGB8:
    4243  case splashModeBGRA8:
     
    129130        fputc(splashRGB8G(p), f);
    130131        fputc(splashRGB8B(p), f);
    131         p += 4;
     132        p += 3;
    132133      }
    133134      row += rowSize;
     
    150151    break;
    151152
     153 case splashModeRGB8Qt:
     154    fprintf(f, "P6\n%d %d\n255\n", width, height);
     155    row = data;
     156    for (y = 0; y < height; ++y) {
     157      p = row;
     158      for (x = 0; x < width; ++x) {
     159        fputc(splashRGB8R(p), f);
     160        fputc(splashRGB8G(p), f);
     161        fputc(splashRGB8B(p), f);
     162        p += 4;
     163      }
     164      row += rowSize;
     165    }
     166    break;
     167
    152168  case splashModeARGB8:
    153169    fprintf(f, "P6\n%d %d\n255\n", width, height);
     
    214230  case splashModeRGB8:
    215231  case splashModeBGR8:
     232    p = &data[y * rowSize + 3 * x];
     233    pixel[0] = p[0];
     234    pixel[1] = p[1];
     235    pixel[2] = p[2];
     236    break;
     237  case splashModeRGB8Qt:
    216238    p = &data[y * rowSize + 4 * x];
    217239    pixel[0] = p[2];
  • trunk/poppler/mypoppler/splash/SplashTypes.h

    r2 r44  
    3737  splashModeARGB8,              // 1 byte per component, 4 bytes per pixel:
    3838                                //   ARGBARGB...
     39  splashModeRGB8Qt,             // 1 byte per component, 4 bytes per pixel:
     40                                //   Specially hacked to use in Qt frontends
    3941  splashModeBGRA8               // 1 byte per component, 4 bytes per pixel:
    4042                                //   BGRABGRA...
Note: See TracChangeset for help on using the changeset viewer.