/*
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
* contributor license agreements. See the NOTICE file distributed with
|
* this work for Additional information regarding copyright ownership.
|
* The ASF licenses this file to You under the Apache License, Version 2.0
|
* (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.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
namespace HH.WMS.Utils.NPOI.DDF
|
{
|
using System;
|
using System.IO;
|
using System.Text;
|
using System.Collections;
|
using System.Drawing;
|
using HH.WMS.Utils.NPOI.Util;
|
using HH.WMS.Utils.Ionic.Zlib;
|
|
/// <summary>
|
/// @author Daniel Noll
|
/// </summary>
|
public class EscherMetafileBlip:EscherBlipRecord
|
{
|
private static POILogger log = POILogFactory.GetLogger(typeof(EscherMetafileBlip));
|
|
public const short RECORD_ID_EMF = unchecked((short) 0xF018) + 2;
|
public const short RECORD_ID_WMF = unchecked((short)0xF018) + 3;
|
public const short RECORD_ID_PICT = unchecked((short)0xF018) + 4;
|
|
/**
|
* BLIP signatures as defined in the escher spec
|
*/
|
public const short SIGNATURE_EMF = 0x3D40;
|
public const short SIGNATURE_WMF = 0x2160;
|
public const short SIGNATURE_PICT = 0x5420;
|
|
private const int HEADER_SIZE = 8;
|
|
private byte[] field_1_UID;
|
/**
|
* The primary UID is only saved to disk if (blip_instance ^ blip_signature == 1)
|
*/
|
private byte[] field_2_UID;
|
private int field_2_cb;
|
private int field_3_rcBounds_x1;
|
private int field_3_rcBounds_y1;
|
private int field_3_rcBounds_x2;
|
private int field_3_rcBounds_y2;
|
private int field_4_ptSize_w;
|
private int field_4_ptSize_h;
|
private int field_5_cbSave;
|
private byte field_6_fCompression;
|
private byte field_7_fFilter;
|
|
private byte[] raw_pictureData;
|
private byte[] remainingData;
|
|
/// <summary>
|
/// This method deSerializes the record from a byte array.
|
/// </summary>
|
/// <param name="data">The byte array containing the escher record information</param>
|
/// <param name="offset">The starting offset into</param>
|
/// <param name="recordFactory">May be null since this is not a container record.</param>
|
/// <returns>
|
/// The number of bytes Read from the byte array.
|
/// </returns>
|
public override int FillFields( byte[] data, int offset, EscherRecordFactory recordFactory )
|
{
|
int bytesAfterHeader = ReadHeader( data, offset );
|
int pos = offset + HEADER_SIZE;
|
|
field_1_UID = new byte[16];
|
Array.Copy( data, pos, field_1_UID, 0, 16 ); pos += 16;
|
|
if((Options ^ Signature) == 0x10){
|
field_2_UID = new byte[16];
|
Array.Copy( data, pos, field_2_UID, 0, 16 ); pos += 16;
|
}
|
|
field_2_cb = LittleEndian.GetInt( data, pos ); pos += 4;
|
field_3_rcBounds_x1 = LittleEndian.GetInt( data, pos ); pos += 4;
|
field_3_rcBounds_y1 = LittleEndian.GetInt( data, pos ); pos += 4;
|
field_3_rcBounds_x2 = LittleEndian.GetInt( data, pos ); pos += 4;
|
field_3_rcBounds_y2 = LittleEndian.GetInt( data, pos ); pos += 4;
|
field_4_ptSize_w = LittleEndian.GetInt( data, pos ); pos += 4;
|
field_4_ptSize_h = LittleEndian.GetInt( data, pos ); pos += 4;
|
field_5_cbSave = LittleEndian.GetInt( data, pos ); pos += 4;
|
field_6_fCompression = data[pos]; pos++;
|
field_7_fFilter = data[pos]; pos++;
|
|
raw_pictureData = new byte[field_5_cbSave];
|
Array.Copy( data, pos, raw_pictureData, 0, field_5_cbSave );
|
pos += field_5_cbSave;
|
|
// 0 means DEFLATE compression
|
// 0xFE means no compression
|
if (field_6_fCompression == 0)
|
{
|
field_pictureData = InflatePictureData(raw_pictureData);
|
}
|
else
|
{
|
field_pictureData = raw_pictureData;
|
}
|
int remaining = bytesAfterHeader - pos + offset + HEADER_SIZE;
|
if (remaining > 0)
|
{
|
remainingData = new byte[remaining];
|
Array.Copy(data, pos, remainingData, 0, remaining);
|
}
|
return bytesAfterHeader + HEADER_SIZE;
|
}
|
|
/// <summary>
|
/// Serializes the record to an existing byte array.
|
/// </summary>
|
/// <param name="offset">the offset within the byte array</param>
|
/// <param name="data">the data array to Serialize to</param>
|
/// <param name="listener">a listener for begin and end serialization events.</param>
|
/// <returns>the number of bytes written.</returns>
|
public override int Serialize(int offset, byte[] data, EscherSerializationListener listener)
|
{
|
listener.BeforeRecordSerialize(offset, RecordId, this);
|
|
int pos = offset;
|
LittleEndian.PutShort( data, pos, Options ); pos += 2;
|
LittleEndian.PutShort( data, pos, RecordId ); pos += 2;
|
LittleEndian.PutInt( data, pos, RecordSize - HEADER_SIZE ); pos += 4;
|
|
Array.Copy( field_1_UID, 0, data, pos, field_1_UID.Length ); pos += field_1_UID.Length;
|
if((Options ^ Signature) == 0x10){
|
Array.Copy( field_2_UID, 0, data, pos, field_2_UID.Length ); pos += field_2_UID.Length;
|
}
|
LittleEndian.PutInt( data, pos, field_2_cb ); pos += 4;
|
LittleEndian.PutInt( data, pos, field_3_rcBounds_x1 ); pos += 4;
|
LittleEndian.PutInt( data, pos, field_3_rcBounds_y1 ); pos += 4;
|
LittleEndian.PutInt( data, pos, field_3_rcBounds_x2 ); pos += 4;
|
LittleEndian.PutInt( data, pos, field_3_rcBounds_y2 ); pos += 4;
|
LittleEndian.PutInt( data, pos, field_4_ptSize_w ); pos += 4;
|
LittleEndian.PutInt( data, pos, field_4_ptSize_h ); pos += 4;
|
LittleEndian.PutInt( data, pos, field_5_cbSave ); pos += 4;
|
data[pos] = field_6_fCompression; pos++;
|
data[pos] = field_7_fFilter; pos++;
|
|
Array.Copy( raw_pictureData, 0, data, pos, raw_pictureData.Length );
|
pos += raw_pictureData.Length;
|
if (remainingData != null)
|
{
|
Array.Copy(remainingData, 0, data, pos, remainingData.Length);
|
pos += remainingData.Length;
|
}
|
listener.AfterRecordSerialize(offset + RecordSize, RecordId, RecordSize, this);
|
return RecordSize;
|
}
|
|
/// <summary>
|
/// Decompresses the provided data, returning the inflated result.
|
/// </summary>
|
/// <param name="data">the deflated picture data.</param>
|
/// <returns>the inflated picture data.</returns>
|
private static byte[] InflatePictureData(byte[] data)
|
{
|
using (MemoryStream in1 = new MemoryStream(data))
|
{
|
using (MemoryStream out1 = new MemoryStream())
|
{
|
ZlibStream zIn = null;
|
try
|
{
|
zIn = new ZlibStream(in1, CompressionMode.Decompress, true);
|
|
byte[] buf = new byte[4096];
|
int ReadBytes;
|
while ((ReadBytes = zIn.Read(buf, 0, buf.Length)) > 0)
|
{
|
out1.Write(buf, 0, ReadBytes);
|
}
|
return out1.ToArray();
|
}
|
catch (IOException e)
|
{
|
log.Log(POILogger.WARN, "Possibly corrupt compression or non-compressed data", e);
|
return data;
|
}
|
}
|
}
|
}
|
|
/// <summary>
|
/// Returns the number of bytes that are required to Serialize this record.
|
/// </summary>
|
/// <value>Number of bytes</value>
|
public override int RecordSize
|
{
|
get
|
{
|
int size = 8 + 50 + raw_pictureData.Length;
|
if (remainingData != null) size += remainingData.Length;
|
if ((Options ^ Signature) == 0x10)
|
{
|
size += field_2_UID.Length;
|
}
|
return size;
|
}
|
}
|
|
/// <summary>
|
/// Gets or sets the UID.
|
/// </summary>
|
/// <value>The UID.</value>
|
public byte[] UID
|
{
|
get { return field_1_UID; }
|
set { this.field_1_UID = value; }
|
}
|
|
/// <summary>
|
/// Gets or sets the primary UID.
|
/// </summary>
|
/// <value>The primary UID.</value>
|
public byte[] PrimaryUID
|
{
|
get{return field_2_UID;}
|
set { this.field_2_UID = value; }
|
}
|
|
|
/// <summary>
|
/// Gets or sets the size of the uncompressed.
|
/// </summary>
|
/// <value>The size of the uncompressed.</value>
|
public int UncompressedSize
|
{
|
get { return field_2_cb; }
|
set { field_2_cb = value; }
|
}
|
|
/// <summary>
|
/// Gets or sets the bounds.
|
/// </summary>
|
/// <value>The bounds.</value>
|
public Rectangle Bounds
|
{
|
get
|
{
|
return new Rectangle(field_3_rcBounds_x1,
|
field_3_rcBounds_y1,
|
field_3_rcBounds_x2 - field_3_rcBounds_x1,
|
field_3_rcBounds_y2 - field_3_rcBounds_y1);
|
}
|
set
|
{
|
field_3_rcBounds_x1 = value.X;
|
field_3_rcBounds_y1 = value.Y;
|
field_3_rcBounds_x2 = value.X + value.Width;
|
field_3_rcBounds_y2 = value.Y + value.Height;
|
}
|
}
|
|
/// <summary>
|
/// Gets or sets the size EMU.
|
/// </summary>
|
/// <value>The size EMU.</value>
|
public Size SizeEMU
|
{
|
get{
|
return new Size(field_4_ptSize_w, field_4_ptSize_h);
|
}
|
set
|
{
|
field_4_ptSize_w = value.Width;
|
field_4_ptSize_h = value.Height;
|
}
|
}
|
|
/// <summary>
|
/// Gets or sets the size of the compressed.
|
/// </summary>
|
/// <value>The size of the compressed.</value>
|
public int CompressedSize
|
{
|
get{return field_5_cbSave;}
|
set{field_5_cbSave=value;}
|
}
|
|
/// <summary>
|
/// Gets or sets a value indicating whether this instance is compressed.
|
/// </summary>
|
/// <value>
|
/// <c>true</c> if this instance is compressed; otherwise, <c>false</c>.
|
/// </value>
|
public bool IsCompressed
|
{
|
get{return (field_6_fCompression == 0);}
|
set { field_6_fCompression = value ? (byte)0 : (byte)0xFE; }
|
}
|
public byte[] RemainingData
|
{
|
get
|
{
|
return remainingData;
|
}
|
}
|
/// <summary>
|
/// Returns a <see cref="T:System.String"/> that represents the current <see cref="T:System.Object"/>.
|
/// </summary>
|
/// <returns>
|
/// A <see cref="T:System.String"/> that represents the current <see cref="T:System.Object"/>.
|
/// </returns>
|
public override String ToString()
|
{
|
String nl = Environment.NewLine;
|
|
String extraData;
|
using (MemoryStream b = new MemoryStream())
|
{
|
try
|
{
|
HexDump.Dump(this.field_pictureData, 0, b, 0);
|
extraData = b.ToString();
|
}
|
catch (Exception e)
|
{
|
extraData = e.ToString();
|
}
|
return GetType().Name + ":" + nl +
|
" RecordId: 0x" + HexDump.ToHex(RecordId) + nl +
|
" Options: 0x" + HexDump.ToHex(Options) + nl +
|
" UID: 0x" + HexDump.ToHex(field_1_UID) + nl +
|
(field_2_UID == null ? "" : (" UID2: 0x" + HexDump.ToHex(field_2_UID) + nl)) +
|
" Uncompressed Size: " + HexDump.ToHex(field_2_cb) + nl +
|
" Bounds: " + Bounds + nl +
|
" Size in EMU: " + SizeEMU + nl +
|
" Compressed Size: " + HexDump.ToHex(field_5_cbSave) + nl +
|
" Compression: " + HexDump.ToHex(field_6_fCompression) + nl +
|
" Filter: " + HexDump.ToHex(field_7_fFilter) + nl +
|
" Extra Data:" + nl + extraData +
|
(remainingData == null ? null : ("\n" +
|
" Remaining Data: " + HexDump.ToHex(remainingData, 32)));
|
}
|
}
|
|
/// <summary>
|
/// Return the blip signature
|
/// </summary>
|
/// <value>the blip signature</value>
|
public short Signature
|
{
|
get{
|
short sig = 0;
|
switch(RecordId){
|
case RECORD_ID_EMF:
|
sig = SIGNATURE_EMF;
|
break;
|
case RECORD_ID_WMF:
|
sig = SIGNATURE_WMF;
|
break;
|
case RECORD_ID_PICT:
|
sig = SIGNATURE_PICT;
|
break;
|
default: log.Log(POILogger.WARN, "Unknown metafile: " + RecordId); break;
|
}
|
return sig;
|
}
|
}
|
}
|
}
|
