//////////////////////////////////////////////////////////////////
internal void LoadPixelData(PsdBinaryReader reader)
{
Debug.WriteLine("Channel.LoadPixelData started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
var endPosition = reader.BaseStream.Position + this.Length;
ImageCompression = (ImageCompression)reader.ReadInt16();
imageDataCompressed = true;
var dataLength = this.Length - 2;
switch (ImageCompression)
{
case ImageCompression.Raw:
ImageData = reader.ReadBytes(dataLength);
break;
case ImageCompression.Rle:
// RLE row lengths
RleHeader = reader.ReadBytes(2 * Rect.Height);
var rleDataLength = dataLength - 2 * Rect.Height;
// The PSD specification states that rows are padded to even sizes.
// However, PSD files generated by Photoshop CS4 do not actually
// follow this stipulation.
Data = reader.ReadBytes(rleDataLength);
break;
case ImageCompression.Zip:
case ImageCompression.ZipPrediction:
Data = reader.ReadBytes(dataLength);
break;
}
Debug.Assert(reader.BaseStream.Position == endPosition, "Pixel data successfully read in.");
}
//////////////////////////////////////////////////////////////////
internal void LoadPixelData(PsdBinaryReader reader)
{
var endPosition = reader.BaseStream.Position + this.Length;
ImageCompression = (ImageCompression)reader.ReadInt16();
var dataLength = this.Length - 2;
switch (ImageCompression)
{
case ImageCompression.Raw:
ImageDataRaw = reader.ReadBytes(dataLength);
break;
case ImageCompression.Rle:
// RLE row lengths
RleRowLengths = new RleRowLengths(reader, (int)Rect.height);
var rleDataLength = (int)(endPosition - reader.BaseStream.Position);
// The PSD specification states that rows are padded to even sizes.
// However, Photoshop doesn't actually do this. RLE rows can have
// odd lengths in the header, and there is no padding between rows.
ImageDataRaw = reader.ReadBytes(rleDataLength);
break;
case ImageCompression.Zip:
case ImageCompression.ZipPrediction:
ImageDataRaw = reader.ReadBytes(dataLength);
break;
}
}
///////////////////////////////////////////////////////////////////////////
#endregion
///////////////////////////////////////////////////////////////////////////
#region ImageData
///////////////////////////////////////////////////////////////////////////
private void LoadImage(PsdBinaryReader reader)
{
Debug.WriteLine("LoadImage started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
BaseLayer.Rect = new Rectangle(0, 0, ColumnCount, RowCount);
ImageCompression = (ImageCompression)reader.ReadInt16();
switch (ImageCompression)
{
case ImageCompression.Raw:
var length = this.RowCount * Util.BytesPerRow(BaseLayer.Rect, BitDepth);
for (Int16 i = 0; i < ChannelCount; i++)
{
var channel = new Channel(i, this.BaseLayer);
channel.ImageCompression = ImageCompression;
channel.Length = length;
channel.ImageData = reader.ReadBytes(length);
BaseLayer.Channels.Add(channel);
}
break;
case ImageCompression.Rle:
// Store RLE data length
for (Int16 i = 0; i < ChannelCount; i++)
{
var channel = new Channel(i, this.BaseLayer);
channel.RleHeader = reader.ReadBytes(2 * RowCount);
int totalRleLength = 0;
using (var memoryStream = new MemoryStream(channel.RleHeader))
using (var memoryReader = new PsdBinaryReader(memoryStream, Encoding.ASCII))
{
for (int j = 0; j < RowCount; j++)
{
totalRleLength += memoryReader.ReadUInt16();
}
}
channel.ImageCompression = this.ImageCompression;
channel.Length = (int)totalRleLength;
this.BaseLayer.Channels.Add(channel);
}
foreach (var channel in this.BaseLayer.Channels)
{
channel.Data = reader.ReadBytes(channel.Length);
}
break;
}
// If there is one more channel than we need, then it is the alpha channel
if (ChannelCount == ColorMode.ChannelCount() + 1)
{
var alphaChannel = BaseLayer.Channels.Last();
alphaChannel.ID = -1;
}
}
//internal void Save(PsdBinaryWriter writer)
//{
// Util.DebugMessage(writer.BaseStream, "Save, Begin, Channel");
// writer.Write(ID);
// if (Layer.PsdFile.IsLargeDocument)
// {
// writer.Write(Length);
// }
// else
// {
// writer.Write((Int32)Length);
// }
// Util.DebugMessage(writer.BaseStream, "Save, End, Channel, {0}", ID);
//}
//////////////////////////////////////////////////////////////////
internal void LoadPixelData(PsdBinaryReader reader)
{
Util.DebugMessage(reader.BaseStream, "Load, Begin, Channel image");
if (Length == 0)
{
ImageCompression = ImageCompression.Raw;
ImageDataRaw = new byte[0];
return;
}
var endPosition = reader.BaseStream.Position + this.Length;
ImageCompression = (ImageCompression)reader.ReadInt16();
var longDataLength = this.Length - 2;
Util.CheckByteArrayLength(longDataLength);
var dataLength = (int)longDataLength;
switch (ImageCompression)
{
case ImageCompression.Raw:
ImageDataRaw = reader.ReadBytes(dataLength);
break;
case ImageCompression.Rle:
// RLE row lengths
RleRowLengths = new RleRowLengths(reader, Rect.Height,
Layer.PsdFile.IsLargeDocument);
var rleDataLength = (int)(endPosition - reader.BaseStream.Position);
Debug.Assert(rleDataLength == RleRowLengths.Total,
"RLE row lengths do not sum to length of channel image data.");
// The PSD specification states that rows are padded to even sizes.
// However, Photoshop doesn't actually do this. RLE rows can have
// odd lengths in the header, and there is no padding between rows.
ImageDataRaw = reader.ReadBytes(rleDataLength);
break;
case ImageCompression.Zip:
case ImageCompression.ZipPrediction:
ImageDataRaw = reader.ReadBytes(dataLength);
break;
}
Util.DebugMessage(reader.BaseStream, "Load, End, Channel image, {0}",
ID, Layer.Name);
Debug.Assert(reader.BaseStream.Position == endPosition,
"Pixel data was not fully read in.");
}
public LayerText(PsdBinaryReader psdReader, int dataLength)
{
Data = psdReader.ReadBytes((int)dataLength);
var reader = new PsdBinaryReader(new System.IO.MemoryStream(Data), psdReader);
// PhotoShop version
reader.ReadUInt16();
Transform = new Matrix2D(reader);
// TextVersion
reader.ReadUInt16(); //2 bytes, =50. For Photoshop 6.0.
// DescriptorVersion
reader.ReadUInt32(); //4 bytes,=16. For Photoshop 6.0.
TxtDescriptor = DynVal.ReadDescriptor(reader); //Text descriptor
// WarpVersion
reader.ReadUInt16(); //2 bytes, =1. For Photoshop 6.0.
engineData = (Dictionary <string, object>)TxtDescriptor.Children.Find(c => c.Name == "EngineData").Value;
StylesheetReader = new TdTaStylesheetReader(engineData);
Dictionary <string, object> d = StylesheetReader.GetStylesheetDataFromLongestRun();
Text = StylesheetReader.Text;
FontName = TdTaParser.getString(StylesheetReader.getFontSet()[(int)TdTaParser.query(d, "Font")], "Name$");
FontSize = (double)TdTaParser.query(d, "FontSize");
try
{
FauxBold = TdTaParser.getBool(d, "FauxBold");
}
catch (KeyNotFoundException)
{
FauxBold = false;
}
try
{
FauxItalic = TdTaParser.getBool(d, "FauxItalic");
}
catch (KeyNotFoundException)
{
FauxItalic = false;
}
try
{
Underline = TdTaParser.getBool(d, "Underline");
}
catch (KeyNotFoundException)
{
Underline = false;
}
FillColor = TdTaParser.getColor(d, "FillColor");
}
public RawImageResource(PsdBinaryReader reader, string signature,
ResourceID resourceId, string name, int numBytes)
: base(name)
{
this.Signature = signature;
this.id = resourceId;
Data = reader.ReadBytes(numBytes);
}
public Metadata(PsdBinaryReader reader)
{
string signature = reader.ReadAsciiChars(4);
if (signature != "8BIM")
{
throw new PsdInvalidException("Could not read LayerInfo due to signature mismatch." + signature);
}
Key = reader.ReadAsciiChars(4);
bool sheetCopy = reader.ReadBoolean();
byte[] padding = reader.ReadBytes(3);
uint length = reader.ReadUInt32();
byte[] datas = reader.ReadBytes((int)length);
}
public RawImageResource(PsdBinaryReader reader, string signature,
ResourceID resourceId, string name, int numBytes)
: base(name)
{
this.Signature = signature;
this.id = resourceId;
Data = reader.ReadBytes(numBytes);
}
private void LoadColorModeData(PsdBinaryReader reader)
{
var paletteLength = reader.ReadUInt32();
if (paletteLength > 0)
{
ColorModeData = reader.ReadBytes((int)paletteLength);
}
}
public RawLayerInfo(PsdBinaryReader reader, string signature, string key,
long dataLength)
{
this.signature = signature;
this.key = key;
Util.CheckByteArrayLength(dataLength);
Data = reader.ReadBytes((int)dataLength);
}
/// <summary>
/// A peculiar type of ascii string frequently used throughout the Descriptor data structure.
/// First 4 bytes are length (in bytes), followed by string. If length is 0, length is assumed to be 4. No idea why they did this... RLE compression?
/// </summary>
/// <param name="r"></param>
/// <returns></returns>
public static string ReadSpecialString(PsdBinaryReader r)
{
uint length = r.ReadUInt32();
if (length == 0)
{
length = 4;
}
return(System.Text.Encoding.ASCII.GetString(r.ReadBytes((int)length)));
}
public static DynVal ReadAlias(PsdBinaryReader r)
{
DynVal v = new DynVal();
v.Type = OSType.Alias;
uint length = r.ReadUInt32();
v.Value = r.ReadBytes((int)length);
return(v);
}
private void LoadColorModeData(PsdBinaryReader reader)
{
Debug.WriteLine("LoadColorModeData started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
var paletteLength = reader.ReadUInt32();
if (paletteLength > 0)
{
ColorModeData = reader.ReadBytes((int)paletteLength);
}
}
private void LoadGlobalLayerMask(PsdBinaryReader reader)
{
var maskLength = reader.ReadUInt32();
if (maskLength <= 0)
{
return;
}
GlobalLayerMaskData = reader.ReadBytes((int)maskLength);
}
///////////////////////////////////////////////////////////////////////////
public BlendingRanges(PsdBinaryReader reader, Layer layer)
{
Debug.WriteLine("BlendingRanges started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
Layer = layer;
var dataLength = reader.ReadInt32();
if (dataLength <= 0)
return;
Data = reader.ReadBytes(dataLength);
}
private void LoadColorModeData(PsdBinaryReader reader)
{
Util.DebugMessage(reader.BaseStream, "Load, Begin, ColorModeData");
var paletteLength = reader.ReadUInt32();
if (paletteLength > 0)
{
ColorModeData = reader.ReadBytes((int)paletteLength);
}
Util.DebugMessage(reader.BaseStream, "Load, End, ColorModeData");
}
private void LoadGlobalLayerMask(PsdBinaryReader reader)
{
Debug.WriteLine("LoadGlobalLayerMask started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
var maskLength = reader.ReadUInt32();
if (maskLength <= 0)
{
return;
}
GlobalLayerMaskData = reader.ReadBytes((int)maskLength);
}
public Thumbnail(PsdBinaryReader psdReader, ResourceID id, string name, int numBytes)
: base(psdReader, "8BIM", id, name, numBytes)
{
using (var memoryStream = new MemoryStream(Data))
using (var reader = new PsdBinaryReader(memoryStream, psdReader)) {
const int HEADER_LENGTH = 28;
var format = reader.ReadUInt32();
var width = reader.ReadUInt32();
var height = reader.ReadUInt32();
// widthBytes
reader.ReadUInt32();
// size
reader.ReadUInt32();
// compressedSize
reader.ReadUInt32();
// bitPerPixel
reader.ReadUInt16();
// planes
reader.ReadUInt16();
// Raw RGB bitmap
if (format == 0)
{
Image = new Texture2D((int)width, (int)height, TextureFormat.RGB24, true);
}
// JPEG bitmap
else if (format == 1)
{
byte[] imgData = reader.ReadBytes(numBytes - HEADER_LENGTH);
Image = new Texture2D((int)width, (int)height, TextureFormat.RGB24, true);
Image.LoadImage(imgData);
// Reverse BGR pixels from old thumbnail format
if (id == ResourceID.ThumbnailBgr)
{
//for(int y=0;y<m_thumbnailImage.Height;y++)
// for (int x = 0; x < m_thumbnailImage.Width; x++)
// {
// Color c=m_thumbnailImage.GetPixel(x,y);
// Color c2=Color.FromArgb(c.B, c.G, c.R);
// m_thumbnailImage.SetPixel(x, y, c);
// }
}
}
else
{
throw new PsdInvalidException("Unknown thumbnail format.");
}
}
}
///////////////////////////////////////////////////////////////////////////
public BlendingRanges(PsdBinaryReader reader, Layer layer)
{
Debug.WriteLine("BlendingRanges started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
Layer = layer;
var dataLength = reader.ReadInt32();
if (dataLength <= 0)
{
return;
}
Data = reader.ReadBytes(dataLength);
}
///////////////////////////////////////////////////////////////////////////
public BlendingRanges(PsdBinaryReader reader, Layer layer)
{
Debug.WriteLine("BlendingRanges started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
Layer = layer;
var dataLength = reader.ReadInt32();
if (dataLength <= 0)
{
Data = new byte[0]; // modified to avoid exception at Save method (butaman)
return;
}
Data = reader.ReadBytes(dataLength);
}
public Thumbnail(PsdBinaryReader psdReader, ResourceID id, string name, int numBytes)
: base(psdReader, "8BIM", id, name, numBytes)
{
using (var memoryStream = new MemoryStream(Data))
using (var reader = new PsdBinaryReader(memoryStream, psdReader))
{
const int HEADER_LENGTH = 28;
var format = reader.ReadUInt32();
var width = reader.ReadUInt32();
var height = reader.ReadUInt32();
var widthBytes = reader.ReadUInt32();
var size = reader.ReadUInt32();
var compressedSize = reader.ReadUInt32();
var bitPerPixel = reader.ReadUInt16();
var planes = reader.ReadUInt16();
// Raw RGB bitmap
if (format == 0)
{
Image = new Bitmap((int)width, (int)height, PixelFormat.Format24bppRgb);
}
// JPEG bitmap
else if (format == 1)
{
byte[] imgData = reader.ReadBytes(numBytes - HEADER_LENGTH);
using (MemoryStream stream = new MemoryStream(imgData))
{
var bitmap = new Bitmap(stream);
Image = (Bitmap)bitmap.Clone();
}
// Reverse BGR pixels from old thumbnail format
if (id == ResourceID.ThumbnailBgr)
{
//for(int y=0;y<m_thumbnailImage.Height;y++)
// for (int x = 0; x < m_thumbnailImage.Width; x++)
// {
// Color c=m_thumbnailImage.GetPixel(x,y);
// Color c2=Color.FromArgb(c.B, c.G, c.R);
// m_thumbnailImage.SetPixel(x, y, c);
// }
}
}
else
{
throw new PsdInvalidException("Unknown thumbnail format.");
}
}
}
///////////////////////////////////////////////////////////////////////////
public BlendingRanges(PsdBinaryReader reader, Layer layer)
{
Util.DebugMessage(reader.BaseStream, "Load, Begin, BlendingRanges");
Layer = layer;
var dataLength = reader.ReadInt32();
if (dataLength <= 0)
{
return;
}
Data = reader.ReadBytes(dataLength);
Util.DebugMessage(reader.BaseStream, "Load, End, BlendingRanges");
}
private void LoadGlobalLayerMask(PsdBinaryReader reader)
{
Util.DebugMessage(reader.BaseStream, "Load, Begin, GlobalLayerMask");
var maskLength = reader.ReadUInt32();
if (maskLength <= 0)
{
Util.DebugMessage(reader.BaseStream, "Load, End, GlobalLayerMask");
return;
}
m_GlobalLayerMaskData = reader.ReadBytes((int)maskLength);
Util.DebugMessage(reader.BaseStream, "Load, End, GlobalLayerMask");
}
private void LoadImage(PsdBinaryReader reader)
{
Util.DebugMessage(reader.BaseStream, "Load, Begin, Composite image");
ImageCompression = (ImageCompression)reader.ReadInt16();
// Create channels
for (Int16 i = 0; i < ChannelCount; i++)
{
Util.DebugMessage(reader.BaseStream, "Load, Begin, Channel image data");
var channel = new Channel(i, this.BaseLayer);
channel.ImageCompression = ImageCompression;
channel.Length = this.RowCount
* Util.BytesPerRow(BaseLayer.Rect.Size, BitDepth);
// The composite image stores all RLE headers up-front, rather than
// with each channel.
if (ImageCompression == ImageCompression.Rle)
{
channel.RleRowLengths = new RleRowLengths(reader, RowCount, IsLargeDocument);
channel.Length = channel.RleRowLengths.Total;
}
BaseLayer.Channels.Add(channel);
Util.DebugMessage(reader.BaseStream, "Load, End, Channel image data");
}
foreach (var channel in this.BaseLayer.Channels)
{
Util.DebugMessage(reader.BaseStream, "Load, Begin, Channel image data");
Util.CheckByteArrayLength(channel.Length);
channel.ImageDataRaw = reader.ReadBytes((int)channel.Length);
Util.DebugMessage(reader.BaseStream, "Load, End, Channel image data");
}
// If there is exactly one more channel than we need, then it is the
// alpha channel.
if ((ColorMode != PsdColorMode.Multichannel) &&
(ChannelCount == ColorMode.MinChannelCount() + 1))
{
var alphaChannel = BaseLayer.Channels.Last();
alphaChannel.ID = -1;
}
Util.DebugMessage(reader.BaseStream, "Load, End, Composite image");
}
///////////////////////////////////////////////////////////////////////////
private void LoadImage(PsdBinaryReader reader)
{
Debug.WriteLine("LoadImage started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
BaseLayer.Rect = new Rectangle(0, 0, ColumnCount, RowCount);
ImageCompression = (ImageCompression)reader.ReadInt16();
switch (ImageCompression)
{
case ImageCompression.Raw:
var length = this.RowCount * Util.BytesPerRow(BaseLayer.Rect, BitDepth);
for (Int16 i = 0; i < ChannelCount; i++)
{
var channel = new Channel(i, this.BaseLayer);
channel.ImageCompression = ImageCompression;
channel.Length = length;
channel.ImageData = reader.ReadBytes(length);
BaseLayer.Channels.Add(channel);
}
break;
case ImageCompression.Rle:
// Store RLE data length
for (Int16 i = 0; i < ChannelCount; i++)
{
var channel = new Channel(i, this.BaseLayer);
channel.RleHeader = reader.ReadBytes(2 * RowCount);
int totalRleLength = 0;
using (var memoryStream = new MemoryStream(channel.RleHeader))
using (var memoryReader = new PsdBinaryReader(memoryStream, Encoding.ASCII))
{
for (int j = 0; j < RowCount; j++)
totalRleLength += memoryReader.ReadUInt16();
}
channel.ImageCompression = this.ImageCompression;
channel.Length = (int)totalRleLength;
this.BaseLayer.Channels.Add(channel);
}
foreach (var channel in this.BaseLayer.Channels)
{
channel.Data = reader.ReadBytes(channel.Length);
}
break;
}
// If there is one more channel than we need, then it is the alpha channel
if (ChannelCount == ColorMode.ChannelCount() + 1)
{
var alphaChannel = BaseLayer.Channels.Last();
alphaChannel.ID = -1;
}
}
///////////////////////////////////////////////////////////////////////////
#endregion
///////////////////////////////////////////////////////////////////////////
#region ImageData
///////////////////////////////////////////////////////////////////////////
private void LoadImage(PsdBinaryReader reader) {
ImageCompression = (ImageCompression)reader.ReadInt16();
// Create channels
for (Int16 i = 0; i < ChannelCount; i++) {
var channel = new Channel(i, this.BaseLayer);
channel.ImageCompression = ImageCompression;
channel.Length = this.RowCount * Util.BytesPerRow(BaseLayer.Rect, BitDepth);
// The composite image stores all RLE headers up-front, rather than
// with each channel.
if (ImageCompression == ImageCompression.Rle) {
channel.RleRowLengths = new RleRowLengths(reader, RowCount);
channel.Length = channel.RleRowLengths.Total;
}
BaseLayer.Channels.Add(channel);
}
foreach (var channel in this.BaseLayer.Channels) {
channel.ImageDataRaw = reader.ReadBytes(channel.Length);
}
// If there is exactly one more channel than we need, then it is the
// alpha channel.
if ((ColorMode != PsdColorMode.Multichannel)
&& (ChannelCount == ColorMode.MinChannelCount() + 1)) {
var alphaChannel = BaseLayer.Channels.Last();
alphaChannel.ID = -1;
}
}
private void LoadGlobalLayerMask(PsdBinaryReader reader)
{
Debug.WriteLine("LoadGlobalLayerMask started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
var maskLength = reader.ReadUInt32();
if (maskLength <= 0)
return;
GlobalLayerMaskData = reader.ReadBytes((int)maskLength);
}
public RawLayerInfo(PsdBinaryReader reader, string key, int dataLength)
{
this.key = key;
Data = reader.ReadBytes((int)dataLength);
}
public RawLayerInfo(PsdBinaryReader reader, string key, int dataLength)
{
this.key = key;
Data = reader.ReadBytes((int)dataLength);
}
public LayerText(PsdBinaryReader psdReader, int dataLength)
{
Data = psdReader.ReadBytes((int)dataLength);
var reader = new PsdBinaryReader(new System.IO.MemoryStream(Data), psdReader);
// PhotoShop version
reader.ReadUInt16();
Transform = new Matrix2D(reader);
// TextVersion
reader.ReadUInt16(); //2 bytes, =50. For Photoshop 6.0.
// DescriptorVersion
reader.ReadUInt32(); //4 bytes,=16. For Photoshop 6.0.
TxtDescriptor = DynVal.ReadDescriptor(reader); //Text descriptor
// WarpVersion
ushort wrapVersion = reader.ReadUInt16(); //2 bytes, =1. For Photoshop 6.0.
// DescriptorVersion
uint wrapDescriptorVersion = reader.ReadUInt32();
DynVal warpDescriptor = DynVal.ReadDescriptor(reader);
// double left = reader.ReadDouble();
// double top = reader.ReadDouble();
// double right = reader.ReadDouble();
// double bottom = reader.ReadDouble();
byte[] datas = reader.ReadBytes(32);
engineData = (Dictionary <string, object>)TxtDescriptor.Children.Find(c => c.Name == "EngineData").Value;
StylesheetReader = new TdTaStylesheetReader(engineData);
Dictionary <string, object> d = StylesheetReader.GetStylesheetDataFromLongestRun();
Text = StylesheetReader.Text;
FontName = TdTaParser.getString(StylesheetReader.getFontSet()[(int)TdTaParser.query(d, "Font")], "Name$");
FontSize = (double)TdTaParser.query(d, "FontSize");
if (d.ContainsKey("FauxBold"))
{
FauxBold = TdTaParser.getBool(d, "FauxBold");
}
if (d.ContainsKey("FauxItalic"))
{
FauxItalic = TdTaParser.getBool(d, "FauxItalic");
}
if (d.ContainsKey("Underline"))
{
Underline = TdTaParser.getBool(d, "Underline");
}
if (d.ContainsKey("StyleRunAlignment"))
{
int styleRunAlignment = (int)TdTaParser.query(d, "StyleRunAlignment");//No idea what this maps to.
}
FillColor = Color.black;
if (d.ContainsKey("FillColor"))
{
FillColor = TdTaParser.getColor(d, "FillColor");
}
if (d.ContainsKey("OutlineWidth"))
{
OutlineWidth = (double)TdTaParser.query(d, "OutlineWidth");
}
if (d.ContainsKey("StrokeFlag"))
{
StrokeFlag = TdTaParser.getBool(d, "StrokeFlag");
}
if (d.ContainsKey("StrokeColor"))
{
StrokeColor = TdTaParser.getColor(d, "StrokeColor");
}
if (d.ContainsKey("Strikethrough"))
{
Strikethrough = TdTaParser.getBool(d, "Strikethrough");
}
if (d.ContainsKey("FontBaseline"))
{
FontBaseline = TdTaParser.getIntger(d, "FontBaseline");
}
//Fix newlines
try
{
//Remove MT
if (FontName.EndsWith("MT"))
{
FontName = FontName.Substring(0, FontName.Length - 2);
}
//Remove -Bold, -Italic, -BoldItalic
if (FontName.EndsWith("-Bold", StringComparison.OrdinalIgnoreCase))
{
Style |= FontStyle.Bold;
}
if (FontName.EndsWith("-Italic", StringComparison.OrdinalIgnoreCase))
{
Style |= FontStyle.Italic;
}
if (FontName.EndsWith("-BoldItalic", StringComparison.OrdinalIgnoreCase))
{
Style |= FontStyle.Bold | FontStyle.Italic;
}
//Remove from FontName
FontName = new Regex("\\-(Bold|Italic|BoldItalic)$", RegexOptions.IgnoreCase | RegexOptions.IgnoreCase).Replace(FontName, "");
//Remove PS
if (FontName.EndsWith("PS"))
{
FontName = FontName.Substring(0, FontName.Length - 2);
}
//Find font family
if (FauxBold)
{
Style |= FontStyle.Bold;
}
if (FauxItalic)
{
Style |= FontStyle.Italic;
}
// if (underline) style |= FontStyle.Underline;
// if (strikethrough) style |= FontStyle.Strikeout;
}
finally
{
}
}
public RowData(PsdBinaryReader reader)
{
int length = reader.ReadInt32();
Data = reader.ReadBytes(length);
}
private void LoadColorModeData(PsdBinaryReader reader) {
var paletteLength = reader.ReadUInt32();
if (paletteLength > 0) {
ColorModeData = reader.ReadBytes((int)paletteLength);
}
}
private void LoadGlobalLayerMask(PsdBinaryReader reader) {
var maskLength = reader.ReadUInt32();
if (maskLength <= 0)
return;
GlobalLayerMaskData = reader.ReadBytes((int)maskLength);
}
private void LoadColorModeData(PsdBinaryReader reader)
{
Debug.WriteLine("LoadColorModeData started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
var paletteLength = reader.ReadUInt32();
if (paletteLength > 0)
{
ColorModeData = reader.ReadBytes((int)paletteLength);
}
}
public static DynVal ReadValue(PsdBinaryReader r, bool skipKey)
{
DynVal vt = new DynVal();
if (!skipKey)
{
vt.Name = GetMeaningOfFourCC(ReadSpecialString(r));
}
//TODO: should be assigned a sequential number?
vt.Type = parseTypeString(System.Text.Encoding.ASCII.GetString(r.ReadBytes(4)));
switch (vt.Type)
{
case OSType.tdta:
// unknown
r.ReadUInt32();
TdTaParser p = new TdTaParser(r);
object o = p.ParseOneTree();
vt.Value = o;
break;
case OSType.Descriptor:
vt = DynVal.ReadDescriptor(r);
break;
case OSType.List:
vt.Children = ReadValues(r, true);
break;
case OSType.Double:
vt.Value = r.ReadDouble();
break;
case OSType.UnitFloat: //Unif float
//TODO: need a specific type for this, with a double and a type (percent/pixel)?
string tst = GetMeaningOfFourCC(System.Text.Encoding.ASCII.GetString(r.ReadBytes(4))); //#Prc #Pxl #Ang = percent / pixels / angle?
double d = r.ReadDouble();
tst += ": " + d;
vt.Value = tst;
break;
case OSType.Enumerated:
string namesp = ReadSpecialString(r);
string item = ReadSpecialString(r);
//vt.Value = namesp + "." + item; //TODO: cast to real enum
vt.Value = GetMeaningOfFourCC(namesp) + "." + GetMeaningOfFourCC(item);
break;
case OSType.Integer:
vt.Value = r.ReadInt32(); //4 byte integer
break;
case OSType.Boolean:
vt.Value = r.ReadBoolean();
break;
case OSType.String:
vt.Value = r.ReadUnicodeString(); //r.ReadPSDUnicodeString();
break;
default:
throw new Exception("Unhandled type: " + vt.Type);
}
return(vt);
}
