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");
}
private Color readColor(PsdBinaryReader reader)
{
reader.BaseStream.Position += 2; //Always?
ushort r = reader.ReadUInt16();
ushort g = reader.ReadUInt16();
ushort b = reader.ReadUInt16();
ushort a = reader.ReadUInt16();
return(Util.FromArgb((int)a >> 8, (int)r >> 8, (int)g >> 8, (int)b >> 8));
}
public EffectsLayer(PsdBinaryReader reader, string key)
{
mKey = key;
Version = reader.ReadUInt16();
ushort count = reader.ReadUInt16();
for (int i = 0; i < count; i++)
{
LayerInfo li = EffectLayerFactory.Load(reader);
_resources[li.Key] = li;
}
}
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 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 static ImageResource CreateImageResource(PsdBinaryReader reader)
{
Debug.Print("ImageResource started at {0}", reader.BaseStream.Position);
var signature = reader.ReadAsciiChars(4);
var resourceIdInt = reader.ReadUInt16();
var name = reader.ReadPascalString(2);
var dataLength = (int)reader.ReadUInt32();
var dataPaddedLength = Util.RoundUp(dataLength, 2);
var endPosition = reader.BaseStream.Position + dataPaddedLength;
ImageResource resource = null;
var resourceId = (ResourceID)resourceIdInt;
switch (resourceId)
{
case ResourceID.ResolutionInfo:
resource = new ResolutionInfo(reader, name);
break;
case ResourceID.ThumbnailRgb:
case ResourceID.ThumbnailBgr:
resource = new Thumbnail(reader, resourceId, name, dataLength);
break;
case ResourceID.AlphaChannelNames:
resource = new AlphaChannelNames(reader, name, dataLength);
break;
case ResourceID.UnicodeAlphaNames:
resource = new UnicodeAlphaNames(reader, name, dataLength);
break;
case ResourceID.VersionInfo:
resource = new VersionInfo(reader, name);
break;
default:
resource = new RawImageResource(reader, signature, resourceId, name, dataLength);
break;
}
// Reposition the reader if we do not consume the full resource block.
// This takes care of the even-padding, and also preserves forward-
// compatibility in case a resource block is later extended with
// additional properties.
if (reader.BaseStream.Position < endPosition)
{
reader.BaseStream.Position = endPosition;
}
// However, overruns are definitely an error.
if (reader.BaseStream.Position > endPosition)
{
throw new PsdInvalidException("Corruption detected in resource.");
}
return(resource);
}
public ColorStop(PsdBinaryReader reader)
{
uint localColorStop = reader.ReadUInt32();
uint midpointColorStop = reader.ReadUInt32();
ushort followColorMode = reader.ReadUInt16();
ActualColor = reader.ReadPSDColor(16, true);
ushort numTransparency = reader.ReadUInt16();
Trsps = new List <Transparency>(numTransparency);
for (int j = 0; j < numTransparency; j++)
{
Trsps.Add(new Transparency(reader));
}
}
public RleRowLengths(PsdBinaryReader reader, int rowCount)
: this(rowCount)
{
for (int i = 0; i < rowCount; i++)
{
Values[i] = reader.ReadUInt16();
}
}
public RleRowLengths(PsdBinaryReader reader, int rowCount)
: this(rowCount)
{
for (int i = 0; i < rowCount; i++)
{
Values[i] = reader.ReadUInt16();
}
}
public FontInfo(PsdBinaryReader r)
{
Mark = r.ReadUInt16();
FontType = r.ReadUInt32();
FontName = r.ReadPascalString(2);
FontFamilyName = r.ReadPascalString(2);
FontStyleName = r.ReadPascalString(2);
Script = r.ReadUInt16();
ushort NumDesignAxesVectors = r.ReadUInt16();
DesignVectors = new List <uint>();
for (int vectorNum = 0; vectorNum < NumDesignAxesVectors; vectorNum++)
{
DesignVectors.Add(r.ReadUInt32());
}
}
///////////////////////////////////////////////////////////////////////////
#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;
}
}
public RleRowLengths(PsdBinaryReader reader, int rowCount, bool isLargeDocument)
: this(rowCount)
{
for (int i = 0; i < rowCount; i++)
{
Values[i] = isLargeDocument
? reader.ReadInt32()
: reader.ReadUInt16();
}
}
public Transparency(PsdBinaryReader reader)
{
uint localColorStop = reader.ReadUInt32();
uint midpointColorStop = reader.ReadUInt32();
Opacity = reader.ReadUInt16();
ushort expansionCount = reader.ReadUInt16();
ushort interpolation = reader.ReadUInt16();
ushort length = reader.ReadUInt16();
ushort gradientMode = reader.ReadUInt16();
uint randomNumSeed = reader.ReadUInt32();
ushort showFlag = reader.ReadUInt16();
ushort usingVectorColorFlag = reader.ReadUInt16();
uint roughnessFactor = reader.ReadUInt16();
ushort colorModel = reader.ReadUInt16();
MinColor = reader.ReadPSDColor(16, true);
MaxColor = reader.ReadPSDColor(16, true);
ushort dummy = reader.ReadUInt16();
}
public GradientMap(PsdBinaryReader r, string key)
{
m_key = key;
uint version = r.ReadUInt32();
//Is gradient reversed
bool isReversed = r.ReadBoolean();
bool isDithered = r.ReadBoolean();
string gradientName = r.ReadUnicodeString();
ushort numColors = r.ReadUInt16();
ColorStops = new List <ColorStop>(numColors);
for (int i = 0; i < numColors; i++)
{
ColorStops.Add(new ColorStop(r));
}
}
public Layer(PsdBinaryReader reader, PsdFile psdFile)
: this(psdFile)
{
Util.DebugMessage(reader.BaseStream, "Load, Begin, Layer");
Rect = reader.ReadRectangle();
//-----------------------------------------------------------------------
// Read channel headers. Image data comes later, after the layer header.
int numberOfChannels = reader.ReadUInt16();
for (int channel = 0; channel < numberOfChannels; channel++)
{
var ch = new Channel(reader, this);
Channels.Add(ch);
}
//-----------------------------------------------------------------------
//
var signature = reader.ReadAsciiChars(4);
if (signature != "8BIM")
{
throw (new PsdInvalidException("Invalid signature in layer header."));
}
BlendModeKey = reader.ReadAsciiChars(4);
Opacity = reader.ReadByte();
Clipping = reader.ReadBoolean();
var flagsByte = reader.ReadByte();
flags = new BitVector32(flagsByte);
reader.ReadByte(); //padding
//-----------------------------------------------------------------------
// This is the total size of the MaskData, the BlendingRangesData, the
// Name and the AdjustmentLayerInfo.
var extraDataSize = reader.ReadUInt32();
var extraDataStartPosition = reader.BaseStream.Position;
Masks = new MaskInfo(reader, this);
BlendingRangesData = new BlendingRanges(reader, this);
Name = reader.ReadPascalString(4);
//-----------------------------------------------------------------------
// Process Additional Layer Information
long adjustmentLayerEndPos = extraDataStartPosition + extraDataSize;
while (reader.BaseStream.Position < adjustmentLayerEndPos)
{
var layerInfo = LayerInfoFactory.Load(reader,
psdFile: this.PsdFile,
globalLayerInfo: false);
AdditionalInfo.Add(layerInfo);
}
foreach (var adjustmentInfo in AdditionalInfo)
{
switch (adjustmentInfo.Key)
{
case "luni":
Name = ((LayerUnicodeName)adjustmentInfo).Name;
break;
}
}
Util.DebugMessage(reader.BaseStream, "Load, End, Layer, {0}", Name);
PsdFile.LoadContext.OnLoadLayerHeader(this);
}
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(r.ReadAsciiChars(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.Reference:
vt.References = ReadValues(r, true);
break;
case OSType.Descriptor:
vt.Value = 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
string tst = GetMeaningOfFourCC(r.ReadAsciiChars(4)); //#Prc #Pxl #Ang = percent / pixels / angle?
double d = r.ReadDouble();
tst += ": " + d;
vt.Value = tst;
break;
case OSType.Enumerated:
string typeID = ReadSpecialString(r);
string enumVal = ReadSpecialString(r);
vt.Value = GetMeaningOfFourCC(typeID) + "." + GetMeaningOfFourCC(enumVal);
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;
case OSType.LargeInteger:
vt.Value = r.ReadInt64();
break;
case OSType.Class:
vt.Value = ReadClass(r);
break;
case OSType.Alias:
vt.Value = ReadAlias(r);
break;
case OSType.PropertyRef:
vt.Value = ReadProperty(r);
break;
case OSType.EnumeratedRef:
vt.Value = ReadEnumeratedRef(r);
break;
case OSType.OffestRef:
vt.Value = ReadOffset(r);
break;
case OSType.IdentifierRef:
vt.Value = r.ReadAsciiChars(4);
break;
case OSType.IndexRef:
vt.Value = r.ReadUInt16();
break;
case OSType.NameRef:
vt.Value = r.ReadAsciiChars(4);
break;
default:
throw new Exception("Unhandled type: " + vt.Type);
}
return(vt);
}
///////////////////////////////////////////////////////////////////////////
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;
}
}
public Layer(PsdBinaryReader reader, PsdFile psdFile)
: this(psdFile)
{
IsText = false;
Rect = reader.ReadRectangle();
//-----------------------------------------------------------------------
// Read channel headers. Image data comes later, after the layer header.
int numberOfChannels = reader.ReadUInt16();
for (int channel = 0; channel < numberOfChannels; channel++)
{
var ch = new Channel(reader, this);
Channels.Add(ch);
}
//-----------------------------------------------------------------------
//
var signature = reader.ReadAsciiChars(4);
if (signature != "8BIM")
{
throw (new PsdInvalidException("Invalid signature in layer header."));
}
BlendModeKey = reader.ReadAsciiChars(4);
Opacity = reader.ReadByte();
Clipping = reader.ReadBoolean();
var flagsByte = reader.ReadByte();
flags = new BitVector32(flagsByte);
reader.ReadByte(); //padding
//-----------------------------------------------------------------------
// This is the total size of the MaskData, the BlendingRangesData, the
// Name and the AdjustmentLayerInfo.
var extraDataSize = reader.ReadUInt32();
var extraDataStartPosition = reader.BaseStream.Position;
Masks = new MaskInfo(reader, this);
BlendingRangesData = new BlendingRanges(reader, this);
Name = reader.ReadPascalString(4);
//-----------------------------------------------------------------------
// Process Additional Layer Information
long adjustmentLayerEndPos = extraDataStartPosition + extraDataSize;
while (reader.BaseStream.Position < adjustmentLayerEndPos)
{
var layerInfo = LayerInfoFactory.Load(reader);
AdditionalInfo.Add(layerInfo);
}
foreach (var adjustmentInfo in AdditionalInfo)
{
switch (adjustmentInfo.Key)
{
case "luni":
Name = ((LayerUnicodeName)adjustmentInfo).Name;
break;
case "TySh":
IsText = true;
LayerText = (LayerText)adjustmentInfo;
break;
case "lrFX":
Effects = (EffectsLayer)adjustmentInfo;
break;
case "lfx2":
BaseEffect = (ObjectBasedEffect)adjustmentInfo;
break;
}
}
}
public Layer(PsdBinaryReader reader, PsdFile psdFile)
: this(psdFile)
{
Rect = reader.ReadRectangle();
//-----------------------------------------------------------------------
// Read channel headers. Image data comes later, after the layer header.
int numberOfChannels = reader.ReadUInt16();
for (int channel = 0; channel < numberOfChannels; channel++)
{
var ch = new Channel(reader, this);
Channels.Add(ch);
}
//-----------------------------------------------------------------------
//
var signature = reader.ReadAsciiChars(4);
if (signature != "8BIM")
throw (new PsdInvalidException("Invalid signature in layer header."));
BlendModeKey = reader.ReadAsciiChars(4);
Opacity = reader.ReadByte();
Clipping = reader.ReadBoolean();
var flagsByte = reader.ReadByte();
flags = new BitVector32(flagsByte);
reader.ReadByte(); //padding
//-----------------------------------------------------------------------
// This is the total size of the MaskData, the BlendingRangesData, the
// Name and the AdjustmentLayerInfo.
var extraDataSize = reader.ReadUInt32();
var extraDataStartPosition = reader.BaseStream.Position;
Masks = new MaskInfo(reader, this);
BlendingRangesData = new BlendingRanges(reader, this);
Name = reader.ReadPascalString(4);
//-----------------------------------------------------------------------
// Process Additional Layer Information
long adjustmentLayerEndPos = extraDataStartPosition + extraDataSize;
while (reader.BaseStream.Position < adjustmentLayerEndPos)
{
var layerInfo = LayerInfoFactory.Load(reader);
AdditionalInfo.Add(layerInfo);
}
foreach (var adjustmentInfo in AdditionalInfo)
{
switch (adjustmentInfo.Key)
{
case "luni":
Name = ((LayerUnicodeName)adjustmentInfo).Name;
break;
}
}
}
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 LayerTextType(PsdBinaryReader reader)
{
version = reader.ReadUInt16(); // 1 = Photoshop 5.0
transform = new Matrix2D(reader);
//Font info:
// fontVersion
reader.ReadUInt16(); // 6 = Photoshop 5.0
ushort faceCount = reader.ReadUInt16();
fontInfos = new List <FontInfo>();
for (int i = 0; i < faceCount; i++)
{
fontInfos.Add(new FontInfo(reader));
}
//TODO: make classes of styles as well...
ushort styleCount = reader.ReadUInt16();
for (int i = 0; i < styleCount; i++)
{
// mark
reader.ReadUInt16();
// faceMark
reader.ReadUInt16();
// size
reader.ReadUInt32();
// tracking
reader.ReadUInt32();
// kerning
reader.ReadUInt32();
// leading
reader.ReadUInt32();
// baseShift
reader.ReadUInt32();
// autoKern
reader.ReadByte();
if (version <= 5)
{
// extra
reader.ReadByte();
}
// rotate
reader.ReadByte();
}
//Text information
// type
reader.ReadUInt16();
// scalingFactor
reader.ReadUInt32();
// characterCount
reader.ReadUInt32();
// horizontalPlacement
reader.ReadUInt32();
// verticalPlacement
reader.ReadUInt32();
// selectStart
reader.ReadUInt32();
// selectEnd
reader.ReadUInt32();
ushort lineCount = reader.ReadUInt16();
for (int i = 0; i < lineCount; i++)
{
// characterCountLine
reader.ReadUInt32();
// orientation
reader.ReadUInt16();
// alignment
reader.ReadUInt16();
// doubleByteChar
reader.ReadUInt16();
// style
reader.ReadUInt16();
}
// colorSpace
reader.ReadUInt16();
for (int i = 0; i < 4; i++)
{
reader.ReadUInt16(); //Color compensation
}
// antiAlias
reader.ReadByte();
}
