protected override void ReadValue(PsdReader reader, object userData, out IProperties value)
{
value = new Properties();
short version = reader.ReadInt16();
int count = reader.ReadInt16();
for (int i = 0; i < count; i++)
{
string _8bim = reader.ReadAscii(4);
string effectType = reader.ReadAscii(4);
int size = reader.ReadInt32();
long p = reader.Position;
switch (effectType)
{
case "dsdw":
{
//ShadowInfo.Parse(reader);
}
break;
case "sofi":
{
//this.solidFillInfo = SolidFillInfo.Parse(reader);
}
break;
}
reader.Position = p + size;
}
}
protected override void ReadValue(PsdReader reader, object userData, out IProperties value)
{
Properties props = new Properties();
int version = reader.ReadInt32();
if (version != 1)
throw new InvalidFormatException();
props["HorizontalGrid"] = reader.ReadInt32();
props["VerticalGrid"] = reader.ReadInt32();
int guideCount = reader.ReadInt32();
List<int> hg = new List<int>();
List<int> vg = new List<int>();
for (int i = 0; i < guideCount; i++)
{
int n = reader.ReadInt32();
byte t = reader.ReadByte();
if (t == 0)
vg.Add(n);
else
hg.Add(n);
}
props["HorizontalGuides"] = hg.ToArray();
props["VerticalGuides"] = vg.ToArray();
value = props;
}
protected override void ReadValue(PsdReader reader, object userData, out IProperties value)
{
Properties props = new Properties();
int count = reader.ReadInt32();
List<DescriptorStructure> dss = new List<DescriptorStructure>();
for (int i = 0; i < count; i++)
{
string s = reader.ReadAscii(4);
string k = reader.ReadAscii(4);
var c = reader.ReadByte();
var p = reader.ReadBytes(3);
var l = reader.ReadInt32();
var p2 = reader.Position;
var ds = new DescriptorStructure(reader);
dss.Add(ds);
reader.Position = p2 + l;
}
props["Items"] = dss;
value = props;
}
public StructureUnitFloat(PsdReader reader)
{
string type = reader.ReadType();
this.Add("Type", PsdUtility.ToUnitType(type));
this.Add("Value", reader.ReadDouble());
}
public StructureEnumerateReference(PsdReader reader)
{
this.Add("Name", reader.ReadString());
this.Add("ClassID", reader.ReadKey());
this.Add("TypeID", reader.ReadKey());
this.Add("EnumID", reader.ReadKey());
}
public DescriptorStructure(PsdReader reader, bool hasVersion)
{
if (hasVersion == true)
{
this.version = reader.ReadInt32();
}
this.Add("Name", reader.ReadString());
this.Add("ClassID", reader.ReadKey());
int count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
string key = reader.ReadKey();
string osType = reader.ReadType();
if (key == "EngineData")
{
this.Add(key.Trim(), new StructureEngineData(reader));
}
else
{
object value = StructureReader.Read(osType, reader);
this.Add(key.Trim(), value);
}
}
}
protected override void ReadValue(PsdReader reader, object userData, out IProperties value)
{
Properties props = new Properties();
int version = reader.ReadInt32();
if (version == 6)
{
var r1 = reader.ReadInt32();
var r2 = reader.ReadInt32();
var r3 = reader.ReadInt32();
var r4 = reader.ReadInt32();
string text = reader.ReadString();
var count = reader.ReadInt32();
List<IProperties> slices = new List<IProperties>(count);
for (int i = 0; i < count; i++)
{
slices.Add(ReadSliceInfo(reader));
}
}
{
var descriptor = new DescriptorStructure(reader) as IProperties;
var items = descriptor["slices.Items[0]"] as object[];
List<IProperties> slices = new List<IProperties>(items.Length);
foreach (var item in items)
{
slices.Add(ReadSliceInfo(item as IProperties));
}
props["Items"] = slices.ToArray();
}
value = props;
}
private void ReadProperties(PsdReader reader, int level, Properties props)
{
reader.Skip('\t', level);
char c = reader.ReadChar();
if (c == ']')
{
return;
}
else if (c == '<')
{
reader.Skip('<');
}
reader.Skip('\n');
//Properties props = new Properties();
while (true)
{
reader.Skip('\t', level);
c = reader.ReadChar();
if (c == '>')
{
reader.Skip('>');
return;
}
else
{
//assert c == 9;
c = reader.ReadChar();
//assert c == '/' : "unknown char: " + c + " on level: " + level;
string name = string.Empty;
while (true)
{
c = reader.ReadChar();
if (c == ' ' || c == 10)
{
break;
}
name += c;
}
if (c == 10)
{
Properties p = new Properties();
this.ReadProperties(reader, level + 1, p);
if (p.Count > 0)
props.Add(name, p);
reader.Skip('\n');
}
else if (c == ' ')
{
object value = this.ReadValue(reader, level + 1);
props.Add(name, value);
}
else
{
//assert false;
}
}
}
}
public static ResourceReaderBase CreateReader(string resourceID, PsdReader reader, long length)
{
Type readerType = typeof(EmptyResourceReader);
if (readers.ContainsKey(resourceID) == true)
{
readerType = readers[resourceID];
}
return TypeDescriptor.CreateInstance(null, readerType, new Type[] { typeof(PsdReader), typeof(long), }, new object[] { reader, length, }) as ResourceReaderBase;
}
public static FileHeaderSection FromFile(string filename)
{
using (FileStream stream = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read))
using (PsdReader reader = new PsdReader(stream, new PathResolver(), new Uri(Path.GetDirectoryName(filename))))
{
reader.ReadDocumentHeader();
return FileHeaderSectionReader.Read(reader);
}
}
public PsdLayer(PsdReader reader, PsdDocument document)
{
this.document = document;
this.records = LayerRecordsReader.Read(reader);
this.records = LayerExtraRecordsReader.Read(reader, this.records);
this.left = this.records.Left;
this.top = this.records.Top;
this.right = this.records.Right;
this.bottom = this.records.Bottom;
}
protected override void ReadValue(PsdReader reader, object userData, out IProperties value)
{
Properties props = new Properties(5);
props["Version"] = reader.ReadInt32();
props["HasCompatibilityImage"] = reader.ReadBoolean();
props["WriterName"] = reader.ReadString();
props["ReaderName"] = reader.ReadString();
props["FileVersion"] = reader.ReadInt32();
value = props;
}
public BaseStructure(PsdReader reader)
{
List<object> items = new List<object>();
int count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
string type = reader.ReadType();
object value = StructureReader.Read(type, reader);
items.Add(value);
}
this.Add("Items", items.ToArray());
}
protected override void ReadValue(PsdReader reader, object userData, out IProperties value)
{
Properties props = new Properties(6);
props["HorizontalRes"] = reader.ReadInt16();
props["HorizontalResUnit"] = reader.ReadInt32();
props["WidthUnit"] = reader.ReadInt16();
props["VerticalRes"] = reader.ReadInt16();
props["VerticalResUnit"] = reader.ReadInt32();
props["HeightUnit"] = reader.ReadInt16();
value = props;
}
protected override void ReadValue(PsdReader reader, object userData, out IProperties value)
{
Properties props = new Properties();
List<LinkedLayer> linkedLayers = new List<LinkedLayer>();
while (reader.Position < this.EndPosition)
{
LinkedLayerReader r = new LinkedLayerReader(reader);
linkedLayers.Add(r.Value);
}
props["Items"] = linkedLayers.ToArray();
value = props;
}
private long ReadLength(PsdReader reader, string resourceID)
{
long length = 0;
if (doubleTypeKeys.Contains(resourceID) && reader.Version == 2)
{
length = reader.ReadInt64();
}
else
{
length = reader.ReadInt32();
}
return (length + 3) & (~3);
}
protected override void ReadValue(PsdReader reader, object userData, out IProperties value)
{
Properties props = new Properties(7);
reader.ValidateInt16(1, "Typetool Version");
props["Transforms"] = reader.ReadDoubles(6);
props["TextVersion"] = reader.ReadInt16();
props["Text"] = new DescriptorStructure(reader);
props["WarpVersion"] = reader.ReadInt16();
props["Warp"] = new DescriptorStructure(reader);
props["Bounds"] = reader.ReadDoubles(2);
value = props;
}
protected override void ReadValue(PsdReader reader, object userData, out IProperties value)
{
Properties props = new Properties();
while (reader.Position < this.EndPosition)
{
reader.ValidateSignature(true);
string resourceID = reader.ReadType();
long length = this.ReadLength(reader, resourceID);
ResourceReaderBase resourceReader = ReaderCollector.CreateReader(resourceID, reader, length);
string resourceName = ReaderCollector.GetDisplayName(resourceID);
props[resourceName] = resourceReader;
}
value = props;
}
protected override void ReadValue(PsdReader reader, object userData, out IProperties value)
{
Properties props = new Properties();
while(reader.Position < this.EndPosition)
{
reader.ValidateSignature();
string resourceID = reader.ReadInt16().ToString();
string name = reader.ReadPascalString(2);
long length = reader.ReadInt32();
length += (length % 2);
ResourceReaderBase resourceReader = ReaderCollector.CreateReader(resourceID, reader, length);
string resourceName = ReaderCollector.GetDisplayName(resourceID);
props[resourceName] = resourceReader;
}
value = props;
}
private static Properties ReadSliceInfo(PsdReader reader)
{
Properties props = new Properties();
props["ID"] = reader.ReadInt32();
props["GroupID"] = reader.ReadInt32();
int origin = reader.ReadInt32();
if (origin == 1)
{
int asso = reader.ReadInt32();
}
props["Name"] = reader.ReadString();
int type = reader.ReadInt32();
props["Left"] = reader.ReadInt32();
props["Top"] = reader.ReadInt32();
props["Right"] = reader.ReadInt32();
props["Bottom"] = reader.ReadInt32();
props["Url"] = reader.ReadString();
props["Target"] = reader.ReadString();
props["Message"] = reader.ReadString();
props["AltTag"] = reader.ReadString();
bool b = reader.ReadBoolean();
string cellText = reader.ReadString();
props["HorzAlign"] = reader.ReadInt32();
props["VertAlign"] = reader.ReadInt32();
props["Alpha"] = reader.ReadByte();
props["Red"] = reader.ReadByte();
props["Green"] = reader.ReadByte();
props["Blue"] = reader.ReadByte();
return props;
}
public StructureObjectArray(PsdReader reader)
{
int version = reader.ReadInt32();
this.Add("Name", reader.ReadString());
this.Add("ClassID", reader.ReadKey());
int count = reader.ReadInt32();
List<Properties> items = new List<Properties>();
for (int i = 0; i < count; i++)
{
Properties props = new Properties();
props.Add("Type1", reader.ReadKey());
props.Add("EnumName", reader.ReadType());
props.Add("Type2", PsdUtility.ToUnitType(reader.ReadType()));
int d4 = reader.ReadInt32();
props.Add("Values", reader.ReadDoubles(d4));
items.Add(props);
}
this.Add("items", items.ToArray());
}
public StructureBool(PsdReader reader)
{
Value = reader.ReadBoolean();
}
public Reader_SoLE(PsdReader reader, long length)
: base(reader, length)
{
}
private LayerBlendingRangesBlock(PsdReader reader)
{
Init(reader, true, null);
}
protected override void ReadData(PsdReader reader, object userData)
{
Name = reader.ReadString();
}
public Reader_lnk2(PsdReader reader, long length)
: base(reader, length)
{
}
public StructureDescriptor(PsdReader reader)
: this(reader, true)
{
}
public StructureEnumerate(PsdReader reader)
{
this.Add("ScriptType", reader.ReadKey());
this.Add("Value", reader.ReadKey());
}
public Reader_PlLd(PsdReader reader, Int64 length)
: base(reader, length)
{
}
public LayerInfoReader(PsdReader reader, PsdDocument document)
: base(reader, true, document)
{
}
public LinkedDocumentReader(PsdReader reader, long length)
: base(reader, length, null)
{
}
/// <summary>
/// no data to read here
/// </summary>
protected override void ReadData(PsdReader reader, object userData)
{
}
public EmptyResource(PsdReader reader, long length)
: base(reader, length)
{
// irgnore the block and advance the reader position to
// the end of the block
}
protected override long ReadLength(PsdReader reader)
{
return(reader.ReadInt32());
}
public static LayerBlendingRangesBlock Read(PsdReader reader)
{
LayerBlendingRangesBlock instance = new LayerBlendingRangesBlock(reader);
return(instance);
}
private static void MergeLayers(PsdReader psdReader, Graphics graphics, Func <PsdTextFrame, string> getLayerText)
{
for (int i = 0; i < psdReader.Frames.Count; i++)
{
var frame = psdReader.Frames[i];
if (frame.Type == FrameType.Text)
{
var textFrame = (PsdTextFrame)frame;
var layerText = getLayerText(textFrame);
Text text;
var font = graphics.CreateFont(textFrame.FontName, textFrame.FontSize);
if (textFrame.Path != null)
{
text = new PathText(textFrame.Text, font)
{
Path = textFrame.Raw.Path
};
}
else if (textFrame.TextBox.Width == 0 || textFrame.TextBox.Height == 0)
{
text = new PlainText(layerText, font)
{
Position = new System.Drawing.PointF(textFrame.Raw.TextBox.Left, textFrame.Raw.TextBox.Top)
};
}
else
{
text = new BoundedText(layerText, font)
{
Rectangle = textFrame.Raw.TextBox
};
}
text.Alignment = JustificationToTextAlignment(textFrame.Justification);
text.Brush = new SolidBrush(textFrame.Color);
text.Tracking = textFrame.Tracking;
text.Transform = textFrame.Transform;
graphics.DrawText(text);
}
else if (frame.Type == FrameType.Raster)
{
using (var frameBitmap = frame.GetBitmap())
{
graphics.DrawImage(frameBitmap, frame.X, frame.Y);
}
}
else if (frame.Type == FrameType.Shape)
{
var shapeFrame = (PsdShapeFrame)frame;
var path = shapeFrame.VectorMask;
graphics.FillPath(shapeFrame.Brush, path);
}
}
}
public Reader_SlicesInfo(PsdReader reader, long length)
: base(reader, length)
{
}
public Reader_lrFX(PsdReader reader, long length)
: base(reader, length)
{
}
public Reader_PlLd(PsdReader reader, long length)
: base(reader, length)
{
}
protected override long OnLengthGet(PsdReader reader)
{
return((reader.ReadInt64() + 3) & (~3));
}
protected override void ReadValue(PsdReader reader, object userData, out IProperties value)
{
reader.ValidateInt32(0, "lfx2 Version");
value = new DescriptorStructure(reader, true);
}
public void ReadHeader(PsdReader reader, CompressionType compressionType)
{
if (compressionType != CompressionType.RLE)
return;
this.rlePackLengths = new int[this.height];
if (reader.Version == 1)
{
for (int i = 0; i < this.height; i++)
{
this.rlePackLengths[i] = reader.ReadInt16();
}
}
else
{
for (int i = 0; i < this.height; i++)
{
this.rlePackLengths[i] = reader.ReadInt32();
}
}
}
public luniResource(PsdReader reader, long length)
: base(reader, length)
{
}
public ImageResourcesSectionReader(PsdReader reader)
: base(reader, null)
{
}
public EmbeddedLayerReader(PsdReader reader)
: base(reader, true, null)
{
}
public StructureReference(PsdReader reader)
: base(reader)
{
}
public void Read(PsdReader reader, int bpp, CompressionType compressionType)
{
switch (compressionType)
{
case CompressionType.Raw:
this.ReadData(reader, bpp, compressionType, null);
return;
case CompressionType.RLE:
this.ReadData(reader, bpp, compressionType, this.rlePackLengths);
return;
default:
break;
}
}
protected override void ReadValue(PsdReader reader, Object userData, out IProperties value)
{
value = new Properties();
}
private void ReadData(PsdReader reader, int bps, CompressionType compressionType, int[] rlePackLengths)
{
int length = PsdUtility.DepthToPitch(bps, this.width);
this.data = new byte[length * this.height];
switch (compressionType)
{
case CompressionType.Raw:
reader.Read(this.data, 0, this.data.Length);
break;
case CompressionType.RLE:
for (int i = 0; i < this.height; i++)
{
byte[] buffer = new byte[rlePackLengths[i]];
byte[] dst = new byte[length];
reader.Read(buffer, 0, rlePackLengths[i]);
DecodeRLE(buffer, dst, rlePackLengths[i], length);
for (int j = 0; j < length; j++)
{
this.data[(i * length) + j] = (byte)(dst[j] * this.opacity);
}
}
break;
}
}
public GlobalLayerMaskInfoReader(PsdReader reader)
: base(reader, true, null)
{
}
protected override long OnLengthGet(PsdReader reader)
{
return reader.ReadInt32();
}
protected override void ReadValue(PsdReader reader, object userData, out IProperties value)
{
Properties props = new Properties();
props["SectionType"] = (SectionType)reader.ReadInt32();
value = props;
}
public static object Read(string ostype, PsdReader reader)
{
switch (ostype)
{
case "obj ":
return new StructureReference(reader);
case "Objc":
return new DescriptorStructure(reader, false);
case "VlLs":
return new StructureList(reader);
case "doub":
return reader.ReadDouble();
case "UntF":
return new StructureUnitFloat(reader);
case "TEXT":
return reader.ReadString();
case "enum":
return new StructureEnumerate(reader);
case "long":
return reader.ReadInt32();
case "bool":
return reader.ReadBoolean();
case "GlbO":
return new DescriptorStructure(reader, false);
case "type":
return new StructureClass(reader);
case "GlbC":
return new StructureClass(reader);
case "alis":
return new StructureAlias(reader);
case "tdta":
return new StructureUnknownOSType("Cannot read RawData");
case "prop":
return new StructureProperty(reader);
case "Clss":
return new StructureClass(reader);
case "Enmr":
return new StructureEnumerate(reader);
case "rele":
return new StructureOffset(reader);
case "Idnt":
return new StructureUnknownOSType("Cannot read Identifier");
case "indx":
return new StructureUnknownOSType("Cannot read Index");
case "name":
return new StructureUnknownOSType("Cannot read Name");
case "ObAr":
return new StructureObjectArray(reader);
}
throw new NotSupportedException(ostype);
}
public LazyResourceDataReader(PsdReader reader, long length)
: base(reader, length, null)
{
}
protected override long OnLengthGet(PsdReader reader)
{
return(reader.ReadInt32());
}
public StructureClass(PsdReader reader)
{
this.Add("Name", reader.ReadString());
this.Add("ClassID", reader.ReadKey());
}
protected override void ReadValue(PsdReader reader, object userData, out IProperties value)
{
reader.ValidateInt32(0, "lfx2 Version");
value = new DescriptorStructure(reader, true);
}
protected override void ReadValue(PsdReader reader, object userData, out object value)
{
value = new object();
}
public StructureList(PsdReader reader)
: base(reader)
{
}
public EmptyResourceReader(PsdReader reader, Int64 length)
: base(reader, length)
{
}
