splash.cc

将pdf文档转换为高质量的html文档

	      updateModY(y);
	    }
	  }
	  p += 4;
	}
      } else {
	for (i = 0; i < n; ++i) {
	  if (noClip || state->clip->test(x0 + i, y)) {
	    pattern->getColor(x0 + i, y, color);
	    if (softMask) {
	      alpha2 = (int)(alpha *
			     softMask->data[y * softMask->rowSize + x0 + i]);
	      ialpha2 = 255 - alpha2;
	    }
	    (*blendFunc)(color, p, blend, bitmap->mode);
	    p[0] = (alpha2 * blend[0] + ialpha2 * p[0]) >> 8;
	    p[1] = (alpha2 * blend[1] + ialpha2 * p[1]) >> 8;
	    p[2] = (alpha2 * blend[2] + ialpha2 * p[2]) >> 8;
	    p[3] = (alpha2 * blend[3] + ialpha2 * p[3]) >> 8;
	    if (!noClip) {
	      updateModX(x0 + i);
	      updateModY(y);
	    }
	  }
	  p += 4;
	}
      }
      break;
#if SPLASH_CMYK
    case splashModeACMYK8:
      p = &bitmap->data[y * bitmap->rowSize + 5 * x0];
      if (pattern->isStatic()) {
	pattern->getColor(0, 0, color);
	for (i = 0; i < n; ++i) {
	  if (noClip || state->clip->test(x0 + i, y)) {
	    if (softMask) {
	      alpha2 = (int)(alpha *
			     softMask->data[y * softMask->rowSize + x0 + i]);
	      ialpha2 = 255 - alpha2;
	    }
	    (*blendFunc)(color, p, blend, bitmap->mode);
	    p[0] = (alpha2 * blend[0] + ialpha2 * p[0]) >> 8;
	    p[1] = (alpha2 * blend[1] + ialpha2 * p[1]) >> 8;
	    p[2] = (alpha2 * blend[2] + ialpha2 * p[2]) >> 8;
	    p[3] = (alpha2 * blend[3] + ialpha2 * p[3]) >> 8;
	    p[4] = (alpha2 * blend[4] + ialpha2 * p[4]) >> 8;
	    if (!noClip) {
	      updateModX(x0 + i);
	      updateModY(y);
	    }
	  }
	  p += 4;
	}
      } else {
	for (i = 0; i < n; ++i) {
	  if (noClip || state->clip->test(x0 + i, y)) {
	    pattern->getColor(x0 + i, y, color);
	    if (softMask) {
	      alpha2 = (int)(alpha *
			     softMask->data[y * softMask->rowSize + x0 + i]);
	      ialpha2 = 255 - alpha2;
	    }
	    (*blendFunc)(color, p, blend, bitmap->mode);
	    p[0] = (alpha2 * blend[0] + ialpha2 * p[0]) >> 8;
	    p[1] = (alpha2 * blend[1] + ialpha2 * p[1]) >> 8;
	    p[2] = (alpha2 * blend[2] + ialpha2 * p[2]) >> 8;
	    p[3] = (alpha2 * blend[3] + ialpha2 * p[3]) >> 8;
	    p[4] = (alpha2 * blend[4] + ialpha2 * p[4]) >> 8;
	    if (!noClip) {
	      updateModX(x0 + i);
	      updateModY(y);
	    }
	  }
	  p += 4;
	}
      }
      break;
#endif
    }

  } else {
    switch (bitmap->mode) {
    case splashModeMono1:
      p = &bitmap->data[y * bitmap->rowSize + (x0 >> 3)];
      i = 0;
      if (pattern->isStatic()) {
	pattern->getColor(0, 0, color);
	if ((j = x0 & 7)) {
	  mask = 0x80 >> j;
	  for (; j < 8 && i < n; ++i, ++j) {
	    if (noClip || state->clip->test(x0 + i, y)) {
	      if (color[0]) {
		*p |= mask;
	      } else {
		*p &= ~mask;
	      }
	      if (!noClip) {
		updateModX(x0 + i);
		updateModY(y);
	      }
	    }
	    mask >>= 1;
	  }
	  ++p;
	}
	while (i < n) {
	  mask = 0x80;
	  for (j = 0; j < 8 && i < n; ++i, ++j) {
	    if (noClip || state->clip->test(x0 + i, y)) {
	      if (color[0]) {
		*p |= mask;
	      } else {
		*p &= ~mask;
	      }
	      if (!noClip) {
		updateModX(x0 + i);
		updateModY(y);
	      }
	    }
	    mask >>= 1;
	  }
	  ++p;
	}
      } else {
	if ((j = x0 & 7)) {
	  mask = 0x80 >> j;
	  for (; j < 8 && i < n; ++i, ++j) {
	    if (noClip || state->clip->test(x0 + i, y)) {
	      pattern->getColor(x0 + i, y, color);
	      if (color[0]) {
		*p |= mask;
	      } else {
		*p &= ~mask;
	      }
	      if (!noClip) {
		updateModX(x0 + i);
		updateModY(y);
	      }
	    }
	    mask >>= 1;
	  }
	  ++p;
	}
	while (i < n) {
	  mask = 0x80;
	  for (j = 0; j < 8 && i < n; ++i, ++j) {
	    if (noClip || state->clip->test(x0 + i, y)) {
	      pattern->getColor(x0 + i, y, color);
	      if (color[0]) {
		*p |= mask;
	      } else {
		*p &= ~mask;
	      }
	      if (!noClip) {
		updateModX(x0 + i);
		updateModY(y);
	      }
	    }
	    mask >>= 1;
	  }
	  ++p;
	}
      }
      break;

    case splashModeMono8:
      p = &bitmap->data[y * bitmap->rowSize + x0];
      if (pattern->isStatic()) {
	pattern->getColor(0, 0, color);
	for (i = 0; i < n; ++i) {
	  if (noClip || state->clip->test(x0 + i, y)) {
	    *p = color[0];
	    if (!noClip) {
	      updateModX(x0 + i);
	      updateModY(y);
	    }
	  }
	  ++p;
	}
      } else {
	for (i = 0; i < n; ++i) {
	  if (noClip || state->clip->test(x0 + i, y)) {
	    pattern->getColor(x0 + i, y, color);
	    *p = color[0];
	    if (!noClip) {
	      updateModX(x0 + i);
	      updateModY(y);
	    }
	  }
	  ++p;
	}
      }
      break;

    case splashModeAMono8:
      p = &bitmap->data[y * bitmap->rowSize + 2 * x0];
      if (pattern->isStatic()) {
	pattern->getColor(0, 0, color);
	for (i = 0; i < n; ++i) {
	  if (noClip || state->clip->test(x0 + i, y)) {
	    p[0] = color[0];
	    p[1] = color[1];
	    if (!noClip) {
	      updateModX(x0 + i);
	      updateModY(y);
	    }
	  }
	  p += 2;
	}
      } else {
	for (i = 0; i < n; ++i) {
	  if (noClip || state->clip->test(x0 + i, y)) {
	    pattern->getColor(x0 + i, y, color);
	    p[0] = color[0];
	    p[1] = color[1];
	    if (!noClip) {
	      updateModX(x0 + i);
	      updateModY(y);
	    }
	  }
	  p += 2;
	}
      }
      break;

    case splashModeRGB8:
    case splashModeBGR8:
      p = &bitmap->data[y * bitmap->rowSize + 3 * x0];
      if (pattern->isStatic()) {
	pattern->getColor(0, 0, color);
	for (i = 0; i < n; ++i) {
	  if (noClip || state->clip->test(x0 + i, y)) {
	    p[0] = color[0];
	    p[1] = color[1];
	    p[2] = color[2];
	    if (!noClip) {
	      updateModX(x0 + i);
	      updateModY(y);
	    }
	  }
	  p += 3;
	}
      } else {
	for (i = 0; i < n; ++i) {
	  if (noClip || state->clip->test(x0 + i, y)) {
	    pattern->getColor(x0 + i, y, color);
	    p[0] = color[0];
	    p[1] = color[1];
	    p[2] = color[2];
	    if (!noClip) {
	      updateModX(x0 + i);
	      updateModY(y);
	    }
	  }
	  p += 3;
	}
      }
      break;

    case splashModeARGB8:
    case splashModeBGRA8:
#if SPLASH_CMYK
    case splashModeCMYK8:
#endif
      p = &bitmap->data[y * bitmap->rowSize + 4 * x0];
      if (pattern->isStatic()) {
	pattern->getColor(0, 0, color);
	for (i = 0; i < n; ++i) {
	  if (noClip || state->clip->test(x0 + i, y)) {
	    p[0] = color[0];
	    p[1] = color[1];
	    p[2] = color[2];
	    p[3] = color[3];
	    if (!noClip) {
	      updateModX(x0 + i);
	      updateModY(y);
	    }
	  }
	  p += 4;
	}
      } else {
	for (i = 0; i < n; ++i) {
	  if (noClip || state->clip->test(x0 + i, y)) {
	    pattern->getColor(x0 + i, y, color);
	    p[0] = color[0];
	    p[1] = color[1];
	    p[2] = color[2];
	    p[3] = color[3];
	    if (!noClip) {
	      updateModX(x0 + i);
	      updateModY(y);
	    }
	  }
	  p += 4;
	}
      }
      break;
#if SPLASH_CMYK
    case splashModeACMYK8:
      p = &bitmap->data[y * bitmap->rowSize + 5 * x0];
      if (pattern->isStatic()) {
	pattern->getColor(0, 0, color);
	for (i = 0; i < n; ++i) {
	  if (noClip || state->clip->test(x0 + i, y)) {
	    p[0] = color[0];
	    p[1] = color[1];
	    p[2] = color[2];
	    p[3] = color[3];
	    p[4] = color[4];
	    if (!noClip) {
	      updateModX(x0 + i);
	      updateModY(y);
	    }
	  }
	  p += 4;
	}
      } else {
	for (i = 0; i < n; ++i) {
	  if (noClip || state->clip->test(x0 + i, y)) {
	    pattern->getColor(x0 + i, y, color);
	    p[0] = color[0];
	    p[1] = color[1];
	    p[2] = color[2];
	    p[3] = color[3];
	    p[4] = color[4];
	    if (!noClip) {
	      updateModX(x0 + i);
	      updateModY(y);
	    }
	  }
	  p += 4;
	}
      }
      break;
#endif
    }
  }
}

void Splash::xorSpan(int x0, int x1, int y, SplashPattern *pattern,
		     GBool noClip) {
  SplashColor color;
  SplashColorPtr p;
  Guchar mask;
  int i, j, n;

  n = x1 - x0 + 1;

  if (noClip) {
    updateModX(x0);
    updateModX(x1);
    updateModY(y);
  }

  switch (bitmap->mode) {
  case splashModeMono1:
    p = &bitmap->data[y * bitmap->rowSize + (x0 >> 3)];
    i = 0;
    if ((j = x0 & 7)) {
      mask = 0x80 >> j;
      for (; j < 8 && i < n; ++i, ++j) {
	if (noClip || state->clip->test(x0 + i, y)) {
	  pattern->getColor(x0 + i, y, color);
	  if (color[0]) {
	    *p ^= mask;
	  }
	  if (!noClip) {
	    updateModX(x0 + i);
	    updateModY(y);
	  }
	}
	mask >>= 1;
      }
      ++p;
    }
    while (i < n) {
      mask = 0x80;
      for (j = 0; j < 8 && i < n; ++i, ++j) {
	if (noClip || state->clip->test(x0 + i, y)) {
	  pattern->getColor(x0 + i, y, color);
	  if (color[0]) {
	    *p ^= mask;
	  }
	  if (!noClip) {
	    updateModX(x0 + i);
	    updateModY(y);
	  }
	}
	mask >>= 1;
      }
      ++p;
    }
    break;

  case splashModeMono8:
    p = &bitmap->data[y * bitmap->rowSize + x0];
    for (i = 0; i < n; ++i) {
      if (noClip || state->clip->test(x0 + i, y)) {
	pattern->getColor(x0 + i, y, color);
	*p ^= color[0];
	if (!noClip) {
	  updateModX(x0 + i);
	  updateModY(y);
	}
      }
      ++p;
    }
    break;

  case splashModeAMono8:
    p = &bitmap->data[y * bitmap->rowSize + 2 * x0];
    for (i = 0; i < n; ++i) {
      if (noClip || state->clip->test(x0 + i, y)) {
	pattern->getColor(x0 + i, y, color);
	p[0] ^= color[0];
	p[1] ^= color[1];
	if (!noClip) {
	  updateModX(x0 + i);
	  updateModY(y);
	}
      }
      p += 2;
    }
    break;

  case splashModeRGB8:
  case splashModeBGR8:
    p = &bitmap->data[y * bitmap->rowSize + 3 * x0];
    for (i = 0; i < n; ++i) {
      if (noClip || state->clip->test(x0 + i, y)) {
	pattern->getColor(x0 + i, y, color);
	p[0] ^= color[0];
	p[1] ^= color[1];
	p[2] ^= color[2];
	if (!noClip) {
	  updateModX(x0 + i);
	  updateModY(y);
	}
      }
      p += 3;
    }
    break;

  case splashModeARGB8:
  case splashModeBGRA8:
#if SPLASH_CMYK
  case splashModeCMYK8:
#endif
    p = &bitmap->data[y * bitmap->rowSize + 4 * x0];
    for (i = 0; i < n; ++i) {
      if (noClip || state->clip->test(x0 + i, y)) {
	pattern->getColor(x0 + i, y, color);
	p[0] ^= color[0];
	p[1] ^= color[1];
	p[2] ^= color[2];
	p[3] ^= color[3];
	if (!noClip) {
	  updateModX(x0 + i);
	  updateModY(y);
	}
      }
      p += 4;
    }
    break;
#if SPLASH_CMYK
  case splashModeACMYK8:
    p = &bitmap->data[y * bitmap->rowSize + 5 * x0];
    for (i = 0; i < n; ++i) {
      if (noClip || state->clip->test(x0 + i, y)) {
	pattern->getColor(x0 + i, y, color);
	p[0] ^= color[0];
	p[1] ^= color[1];
	p[2] ^= color[2];
	p[3] ^= color[3];
	p[4] ^= color[4];
	if (!noClip) {
	  updateModX(x0 + i);
	  updateModY(y);
	}
      }
      p += 4;
    }
    break;
#endif
  }
}

SplashError Splash::fillChar(SplashCoord x, SplashCoord y,
			     int c, SplashFont *font) {
  SplashGlyphBitmap glyph;
  int x0, y0, xFrac, yFrac;
  SplashError err;