384 lines
16 KiB
C#
384 lines
16 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Net;
|
|
using iTextSharp.text;
|
|
using iTextSharp.text.rtf;
|
|
using iTextSharp.text.rtf.document;
|
|
using iTextSharp.text.rtf.document.output;
|
|
using iTextSharp.text.rtf.text;
|
|
using iTextSharp.text.rtf.style;
|
|
using iTextSharp.text.pdf.codec.wmf;
|
|
/*
|
|
* $Id: RtfImage.cs,v 1.11 2008/05/16 19:30:59 psoares33 Exp $
|
|
*
|
|
*
|
|
* Copyright 2001, 2002, 2003, 2004 by Mark Hall
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version 1.1
|
|
* (the "License"); you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the License.
|
|
*
|
|
* The Original Code is 'iText, a free JAVA-PDF library'.
|
|
*
|
|
* The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
|
|
* the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
|
|
* All Rights Reserved.
|
|
* Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
|
|
* are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
|
|
*
|
|
* Contributor(s): all the names of the contributors are added in the source code
|
|
* where applicable.
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of the
|
|
* LGPL license (the ?GNU LIBRARY GENERAL PUBLIC LICENSE?), in which case the
|
|
* provisions of LGPL are applicable instead of those above. If you wish to
|
|
* allow use of your version of this file only under the terms of the LGPL
|
|
* License and not to allow others to use your version of this file under
|
|
* the MPL, indicate your decision by deleting the provisions above and
|
|
* replace them with the notice and other provisions required by the LGPL.
|
|
* If you do not delete the provisions above, a recipient may use your version
|
|
* of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
|
|
*
|
|
* This library is free software; you can redistribute it and/or modify it
|
|
* under the terms of the MPL as stated above or under the terms of the GNU
|
|
* Library General Public License as published by the Free Software Foundation;
|
|
* either version 2 of the License, or any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
* FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
|
|
* details.
|
|
*
|
|
* If you didn't download this code from the following link, you should check if
|
|
* you aren't using an obsolete version:
|
|
* http://www.lowagie.com/iText/
|
|
*/
|
|
|
|
namespace iTextSharp.text.rtf.graphic {
|
|
|
|
/**
|
|
* The RtfImage contains one image. Supported image types are jpeg, png, wmf, bmp.
|
|
*
|
|
* @version $Version:$
|
|
* @author Mark Hall (Mark.Hall@mail.room3b.eu)
|
|
* @author Paulo Soares
|
|
*/
|
|
public class RtfImage : RtfElement {
|
|
|
|
/**
|
|
* Constant for the shape/picture group
|
|
*/
|
|
private static byte[] PICTURE_GROUP = DocWriter.GetISOBytes("\\*\\shppict");
|
|
/**
|
|
* Constant for a picture
|
|
*/
|
|
private static byte[] PICTURE = DocWriter.GetISOBytes("\\pict");
|
|
/**
|
|
* Constant for a jpeg image
|
|
*/
|
|
private static byte[] PICTURE_JPEG = DocWriter.GetISOBytes("\\jpegblip");
|
|
/**
|
|
* Constant for a png image
|
|
*/
|
|
private static byte[] PICTURE_PNG = DocWriter.GetISOBytes("\\pngblip");
|
|
/**
|
|
* Constant for a wmf image
|
|
*/
|
|
private static byte[] PICTURE_WMF = DocWriter.GetISOBytes("\\wmetafile8");
|
|
/**
|
|
* Constant for the picture width
|
|
*/
|
|
private static byte[] PICTURE_WIDTH = DocWriter.GetISOBytes("\\picw");
|
|
/**
|
|
* Constant for the picture height
|
|
*/
|
|
private static byte[] PICTURE_HEIGHT = DocWriter.GetISOBytes("\\pich");
|
|
/**
|
|
* Constant for the picture width scale
|
|
*/
|
|
private static byte[] PICTURE_SCALED_WIDTH = DocWriter.GetISOBytes("\\picwgoal");
|
|
/**
|
|
* Constant for the picture height scale
|
|
*/
|
|
private static byte[] PICTURE_SCALED_HEIGHT = DocWriter.GetISOBytes("\\pichgoal");
|
|
/**
|
|
* Constant for horizontal picture scaling
|
|
*/
|
|
private static byte[] PICTURE_SCALE_X = DocWriter.GetISOBytes("\\picscalex");
|
|
/**
|
|
* Constant for vertical picture scaling
|
|
*/
|
|
private static byte[] PICTURE_SCALE_Y = DocWriter.GetISOBytes("\\picscaley");
|
|
/**
|
|
* "\bin" constant
|
|
*/
|
|
private static byte[] PICTURE_BINARY_DATA = DocWriter.GetISOBytes("\\bin");
|
|
/**
|
|
* Constant for converting pixels to twips
|
|
*/
|
|
private const int PIXEL_TWIPS_FACTOR = 15;
|
|
|
|
/**
|
|
* The type of image this is.
|
|
*/
|
|
private int imageType;
|
|
/**
|
|
* Binary image data.
|
|
*/
|
|
private byte[][] imageData;
|
|
/**
|
|
* The alignment of this picture
|
|
*/
|
|
private int alignment = Element.ALIGN_LEFT;
|
|
/**
|
|
* The width of this picture
|
|
*/
|
|
private float width = 0;
|
|
/**
|
|
* The height of this picutre
|
|
*/
|
|
private float height = 0;
|
|
/**
|
|
* The intended display width of this picture
|
|
*/
|
|
private float plainWidth = 0;
|
|
/**
|
|
* The intended display height of this picture
|
|
*/
|
|
private float plainHeight = 0;
|
|
/**
|
|
* Whether this RtfImage is a top level element and should
|
|
* be an extra paragraph.
|
|
*/
|
|
private bool topLevelElement = false;
|
|
|
|
/**
|
|
* Constructs a RtfImage for an Image.
|
|
*
|
|
* @param doc The RtfDocument this RtfImage belongs to
|
|
* @param image The Image that this RtfImage wraps
|
|
* @throws DocumentException If an error occured accessing the image content
|
|
*/
|
|
public RtfImage(RtfDocument doc, Image image) : base(doc) {
|
|
imageType = image.OriginalType;
|
|
if (!(imageType == Image.ORIGINAL_JPEG || imageType == Image.ORIGINAL_BMP
|
|
|| imageType == Image.ORIGINAL_PNG || imageType == Image.ORIGINAL_WMF || imageType == Image.ORIGINAL_GIF)) {
|
|
throw new DocumentException("Only BMP, PNG, WMF, GIF and JPEG images are supported by the RTF Writer");
|
|
}
|
|
alignment = image.Alignment;
|
|
width = image.Width;
|
|
height = image.Height;
|
|
plainWidth = image.PlainWidth;
|
|
plainHeight = image.PlainHeight;
|
|
this.imageData = GetImageData(image);
|
|
}
|
|
|
|
/**
|
|
* Extracts the image data from the Image.
|
|
*
|
|
* @param image The image for which to extract the content
|
|
* @return The raw image data, not formated
|
|
* @throws DocumentException If an error occurs accessing the image content
|
|
*/
|
|
private byte[][] GetImageData(Image image) {
|
|
int WMF_PLACEABLE_HEADER_SIZE = 22;
|
|
RtfByteArrayBuffer bab = new RtfByteArrayBuffer();
|
|
|
|
try {
|
|
if (imageType == Image.ORIGINAL_BMP) {
|
|
bab.Append(MetaDo.WrapBMP(image));
|
|
} else {
|
|
byte[] iod = image.OriginalData;
|
|
if (iod == null) {
|
|
Stream imageIn = WebRequest.Create(image.Url).GetResponse().GetResponseStream();
|
|
if (imageType == Image.ORIGINAL_WMF) { //remove the placeable header first
|
|
for (int k = 0; k < WMF_PLACEABLE_HEADER_SIZE; k++) {
|
|
if (imageIn.ReadByte() < 0) throw (new IOException("while removing wmf placeable header"));
|
|
}
|
|
}
|
|
bab.Write(imageIn);
|
|
imageIn.Close();
|
|
|
|
} else {
|
|
|
|
if (imageType == Image.ORIGINAL_WMF) {
|
|
//remove the placeable header
|
|
bab.Write(iod, WMF_PLACEABLE_HEADER_SIZE, iod.Length - WMF_PLACEABLE_HEADER_SIZE);
|
|
} else {
|
|
bab.Append(iod);
|
|
}
|
|
|
|
}
|
|
}
|
|
return bab.ToArrayArray();
|
|
} catch (IOException ioe) {
|
|
throw new DocumentException(ioe.Message);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* lookup table used for converting bytes to hex chars.
|
|
* TODO Should probably be refactored into a helper class
|
|
*/
|
|
public static byte[] byte2charLUT = new byte[512]; //'0001020304050607 ... fafbfcfdfeff'
|
|
static RtfImage() {
|
|
char c = '0';
|
|
for (int k = 0; k < 16; k++) {
|
|
for (int x = 0; x < 16; x++) {
|
|
byte2charLUT[((k*16)+x)*2] = byte2charLUT[(((x*16)+k)*2)+1] = (byte)c;
|
|
}
|
|
if (++c == ':') c = 'a';
|
|
}
|
|
}
|
|
/**
|
|
* Writes the image data to the given buffer as hex encoded text.
|
|
*
|
|
* @param binary
|
|
* @param bab
|
|
* @
|
|
*/
|
|
private void WriteImageDataHexEncoded(Stream bab) {
|
|
int cnt = 0;
|
|
for (int k = 0; k < imageData.Length; k++) {
|
|
byte[] chunk = imageData[k];
|
|
for (int x = 0; x < chunk.Length; x++) {
|
|
bab.Write(byte2charLUT, (chunk[x]&0xff)*2, 2);
|
|
if (++cnt == 64) {
|
|
bab.WriteByte((byte)'\n');
|
|
cnt = 0;
|
|
}
|
|
}
|
|
}
|
|
if (cnt > 0) bab.WriteByte((byte)'\n');
|
|
}
|
|
/**
|
|
* Returns the image raw data size in bytes.
|
|
*
|
|
* @return
|
|
*/
|
|
private int ImageDataSize() {
|
|
int size = 0;
|
|
for (int k = 0; k < imageData.Length; k++) {
|
|
size += imageData[k].Length;
|
|
}
|
|
return size;
|
|
}
|
|
|
|
/**
|
|
* Writes the RtfImage content
|
|
*/
|
|
public override void WriteContent(Stream result)
|
|
{
|
|
byte[] t;
|
|
if (this.topLevelElement) {
|
|
result.Write(RtfParagraph.PARAGRAPH_DEFAULTS, 0, RtfParagraph.PARAGRAPH_DEFAULTS.Length);
|
|
switch (alignment) {
|
|
case Element.ALIGN_LEFT:
|
|
result.Write(RtfParagraphStyle.ALIGN_LEFT, 0, RtfParagraphStyle.ALIGN_LEFT.Length);
|
|
break;
|
|
case Element.ALIGN_RIGHT:
|
|
result.Write(RtfParagraphStyle.ALIGN_RIGHT, 0, RtfParagraphStyle.ALIGN_RIGHT.Length);
|
|
break;
|
|
case Element.ALIGN_CENTER:
|
|
result.Write(RtfParagraphStyle.ALIGN_CENTER, 0, RtfParagraphStyle.ALIGN_CENTER.Length);
|
|
break;
|
|
case Element.ALIGN_JUSTIFIED:
|
|
result.Write(RtfParagraphStyle.ALIGN_JUSTIFY, 0, RtfParagraphStyle.ALIGN_JUSTIFY.Length);
|
|
break;
|
|
}
|
|
}
|
|
result.Write(OPEN_GROUP, 0, OPEN_GROUP.Length);
|
|
result.Write(PICTURE_GROUP, 0, PICTURE_GROUP.Length);
|
|
result.Write(OPEN_GROUP, 0, OPEN_GROUP.Length);
|
|
result.Write(PICTURE, 0, PICTURE.Length);
|
|
switch (imageType) {
|
|
case Image.ORIGINAL_JPEG:
|
|
result.Write(PICTURE_JPEG, 0, PICTURE_JPEG.Length);
|
|
break;
|
|
case Image.ORIGINAL_PNG:
|
|
case Image.ORIGINAL_GIF:
|
|
result.Write(PICTURE_PNG, 0, PICTURE_PNG.Length);
|
|
break;
|
|
case Image.ORIGINAL_WMF:
|
|
case Image.ORIGINAL_BMP:
|
|
result.Write(PICTURE_WMF, 0, PICTURE_WMF.Length);
|
|
break;
|
|
}
|
|
result.Write(PICTURE_WIDTH, 0, PICTURE_WIDTH.Length);
|
|
result.Write(t = IntToByteArray((int) width), 0, t.Length);
|
|
result.Write(PICTURE_HEIGHT, 0, PICTURE_HEIGHT.Length);
|
|
result.Write(t = IntToByteArray((int) height), 0, t.Length);
|
|
if (this.document.GetDocumentSettings().IsWriteImageScalingInformation()) {
|
|
result.Write(PICTURE_SCALE_X, 0, PICTURE_SCALE_X.Length);
|
|
result.Write(t = IntToByteArray((int)(100 * plainWidth / width)), 0, t.Length);
|
|
result.Write(PICTURE_SCALE_Y, 0, PICTURE_SCALE_Y.Length);
|
|
result.Write(t = IntToByteArray((int)(100 * plainHeight / height)), 0, t.Length);
|
|
}
|
|
if (this.document.GetDocumentSettings().IsImagePDFConformance()) {
|
|
result.Write(PICTURE_SCALED_WIDTH, 0, PICTURE_SCALED_WIDTH.Length);
|
|
result.Write(t = IntToByteArray((int) (plainWidth * RtfElement.TWIPS_FACTOR)), 0, t.Length);
|
|
result.Write(PICTURE_SCALED_HEIGHT, 0, PICTURE_SCALED_HEIGHT.Length);
|
|
result.Write(t = IntToByteArray((int) (plainHeight * RtfElement.TWIPS_FACTOR)), 0, t.Length);
|
|
} else {
|
|
if (this.width != this.plainWidth || this.imageType == Image.ORIGINAL_BMP) {
|
|
result.Write(PICTURE_SCALED_WIDTH, 0, PICTURE_SCALED_WIDTH.Length);
|
|
result.Write(t = IntToByteArray((int) (plainWidth * PIXEL_TWIPS_FACTOR)), 0, t.Length);
|
|
}
|
|
if (this.height != this.plainHeight || this.imageType == Image.ORIGINAL_BMP) {
|
|
result.Write(PICTURE_SCALED_HEIGHT, 0, PICTURE_SCALED_HEIGHT.Length);
|
|
result.Write(t = IntToByteArray((int) (plainHeight * PIXEL_TWIPS_FACTOR)), 0, t.Length);
|
|
}
|
|
}
|
|
|
|
if (this.document.GetDocumentSettings().IsImageWrittenAsBinary()) {
|
|
//binary
|
|
result.WriteByte((byte)'\n');
|
|
result.Write(PICTURE_BINARY_DATA, 0, PICTURE_BINARY_DATA.Length);
|
|
result.Write(t = IntToByteArray(ImageDataSize()), 0, t.Length);
|
|
result.Write(DELIMITER, 0, DELIMITER.Length);
|
|
if (result is RtfByteArrayBuffer) {
|
|
((RtfByteArrayBuffer)result).Append(imageData);
|
|
} else {
|
|
for (int k = 0; k < imageData.Length; k++) {
|
|
result.Write(imageData[k], 0, imageData[k].Length);
|
|
}
|
|
}
|
|
} else {
|
|
//hex encoded
|
|
result.Write(DELIMITER, 0, DELIMITER.Length);
|
|
result.WriteByte((byte)'\n');
|
|
WriteImageDataHexEncoded(result);
|
|
}
|
|
result.Write(CLOSE_GROUP, 0, CLOSE_GROUP.Length);
|
|
result.Write(CLOSE_GROUP, 0, CLOSE_GROUP.Length);
|
|
if (this.topLevelElement) {
|
|
result.Write(RtfParagraph.PARAGRAPH, 0, RtfParagraph.PARAGRAPH.Length);
|
|
}
|
|
result.WriteByte((byte)'\n');
|
|
}
|
|
|
|
/**
|
|
* Sets the alignment of this RtfImage. Uses the alignments from com.lowagie.text.Element.
|
|
*
|
|
* @param alignment The alignment to use.
|
|
*/
|
|
public void SetAlignment(int alignment) {
|
|
this.alignment = alignment;
|
|
}
|
|
|
|
/**
|
|
* Set whether this RtfImage should behave like a top level element
|
|
* and enclose itself in a paragraph.
|
|
*
|
|
* @param topLevelElement Whether to behave like a top level element.
|
|
*/
|
|
public void SetTopLevelElement(bool topLevelElement) {
|
|
this.topLevelElement = topLevelElement;
|
|
}
|
|
}
|
|
} |