/// <summary> /// This functions loads a stroke from a memory stream based on the descriptor and GuidList. It returns /// the no of bytes it has read from the stream to correctly load the stream, which should be same as /// the value of the size parameter. If they are unequal throws ArgumentException. Stroke descriptor is /// used to load the packetproperty as well as ExtendedPropertyCollection on this stroke. Compressor is used /// to decompress the data. /// </summary> /// <param name="compressor"></param> /// <param name="stream"></param> /// <param name="totalBytesInStrokeBlockOfIsfStream"></param> /// <param name="guidList"></param> /// <param name="strokeDescriptor"></param> /// <param name="stylusPointDescription"></param> /// <param name="transform"></param> /// <param name="stylusPoints"></param> /// <param name="extendedProperties"></param> /// <returns></returns> #else /// <summary> /// This functions loads a stroke from a memory stream based on the descriptor and GuidList. It returns /// the no of bytes it has read from the stream to correctly load the stream, which should be same as /// the value of the size parameter. If they are unequal throws ArgumentException. Stroke descriptor is /// used to load the packetproperty as well as ExtendedPropertyCollection on this stroke. Compressor is used /// to decompress the data. /// </summary> /// <param name="stream"></param> /// <param name="totalBytesInStrokeBlockOfIsfStream"></param> /// <param name="guidList"></param> /// <param name="strokeDescriptor"></param> /// <param name="stylusPointDescription"></param> /// <param name="transform"></param> /// <param name="stylusPoints"></param> /// <param name="extendedProperties"></param> #endif static uint DecodeISFIntoStroke( #if OLD_ISF Compressor compressor, #endif Stream stream, uint totalBytesInStrokeBlockOfIsfStream, GuidList guidList, StrokeDescriptor strokeDescriptor, StylusPointDescription stylusPointDescription, Matrix transform, out StylusPointCollection stylusPoints, out ExtendedPropertyCollection extendedProperties) { stylusPoints = null; extendedProperties = null; // We do allow a stroke with no packet data if (0 == totalBytesInStrokeBlockOfIsfStream) { return(0); } uint locallyDecodedBytes; uint remainingBytesInStrokeBlock = totalBytesInStrokeBlockOfIsfStream; // First try to load any packet data locallyDecodedBytes = LoadPackets(stream, remainingBytesInStrokeBlock, #if OLD_ISF compressor, #endif stylusPointDescription, transform, out stylusPoints); if (locallyDecodedBytes > remainingBytesInStrokeBlock) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Packet buffer overflowed the ISF stream")); } remainingBytesInStrokeBlock -= locallyDecodedBytes; if (0 == remainingBytesInStrokeBlock) { return(locallyDecodedBytes); } // Now read the extended propertes for (int iTag = 1; iTag < strokeDescriptor.Template.Count && remainingBytesInStrokeBlock > 0; iTag++) { KnownTagCache.KnownTagIndex tag = strokeDescriptor.Template[iTag - 1]; switch (tag) { case MS.Internal.Ink.InkSerializedFormat.KnownTagCache.KnownTagIndex.StrokePropertyList: { // we've found the stroke extended properties. Load them now. while (iTag < strokeDescriptor.Template.Count && remainingBytesInStrokeBlock > 0) { tag = strokeDescriptor.Template[iTag]; object data; Guid guid = guidList.FindGuid(tag); if (guid == Guid.Empty) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Stroke Custom Attribute tag embedded in ISF stream does not match guid table")); } // load the extended property data from the stream (and decode the type) locallyDecodedBytes = ExtendedPropertySerializer.DecodeAsISF(stream, remainingBytesInStrokeBlock, guidList, tag, ref guid, out data); // add the guid/data pair into the property collection (don't redecode the type) if (extendedProperties == null) { extendedProperties = new ExtendedPropertyCollection(); } extendedProperties[guid] = data; if (locallyDecodedBytes > remainingBytesInStrokeBlock) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Invalid ISF data")); } remainingBytesInStrokeBlock -= locallyDecodedBytes; iTag++; } } break; case MS.Internal.Ink.InkSerializedFormat.KnownTagCache.KnownTagIndex.Buttons: { // Next tag is count of buttons and the tags for the button guids iTag += (int)((uint)strokeDescriptor.Template[iTag]) + 1; } break; // ignore any tags embedded in the Stroke block that this // version of the ISF decoder doesn't understand default: { System.Diagnostics.Trace.WriteLine("Ignoring unhandled stroke tag in ISF stroke descriptor"); } break; } } // Now try to load any tagged property data or point property data while (remainingBytesInStrokeBlock > 0) { // Read the tag first KnownTagCache.KnownTagIndex tag; uint uiTag; locallyDecodedBytes = SerializationHelper.Decode(stream, out uiTag); tag = (KnownTagCache.KnownTagIndex)uiTag; if (locallyDecodedBytes > remainingBytesInStrokeBlock) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Invalid ISF data")); } remainingBytesInStrokeBlock -= locallyDecodedBytes; // if it is a point property block switch (tag) { case MS.Internal.Ink.InkSerializedFormat.KnownTagCache.KnownTagIndex.PointProperty: { // First load the totalBytesInStrokeBlockOfIsfStream of the point property block uint cbsize; locallyDecodedBytes = SerializationHelper.Decode(stream, out cbsize); if (locallyDecodedBytes > remainingBytesInStrokeBlock) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Invalid ISF data")); } remainingBytesInStrokeBlock -= locallyDecodedBytes; while (remainingBytesInStrokeBlock > 0) { // First read the tag corresponding to the property locallyDecodedBytes = SerializationHelper.Decode(stream, out uiTag); tag = (KnownTagCache.KnownTagIndex)uiTag; if (locallyDecodedBytes > remainingBytesInStrokeBlock) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Invalid ISF data")); } remainingBytesInStrokeBlock -= locallyDecodedBytes; // Now read the packet index for which the property will apply uint propindex; locallyDecodedBytes = SerializationHelper.Decode(stream, out propindex); if (locallyDecodedBytes > remainingBytesInStrokeBlock) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Invalid ISF data")); } remainingBytesInStrokeBlock -= locallyDecodedBytes; uint propsize; locallyDecodedBytes = SerializationHelper.Decode(stream, out propsize); if (locallyDecodedBytes > remainingBytesInStrokeBlock) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Invalid ISF data")); } remainingBytesInStrokeBlock -= locallyDecodedBytes; // Compressed data totalBytesInStrokeBlockOfIsfStream propsize += 1; // Make sure we have enough data to read if (propsize > remainingBytesInStrokeBlock) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Invalid ISF data")); } byte[] in_buffer = new byte[propsize]; uint bytesRead = StrokeCollectionSerializer.ReliableRead(stream, in_buffer, propsize); if (propsize != bytesRead) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Read different size from stream then expected")); } byte[] out_buffer = Compressor.DecompressPropertyData(in_buffer); System.Diagnostics.Debug.Assert(false, "ExtendedProperties for points are not supported"); // skip the bytes in both success & failure cases // Note: Point ExtendedProperties are discarded remainingBytesInStrokeBlock -= propsize; } } break; default: { object data; Guid guid = guidList.FindGuid(tag); if (guid == Guid.Empty) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Stroke Custom Attribute tag embedded in ISF stream does not match guid table")); } // load the extended property data from the stream (and decode the type) locallyDecodedBytes = ExtendedPropertySerializer.DecodeAsISF(stream, remainingBytesInStrokeBlock, guidList, tag, ref guid, out data); // add the guid/data pair into the property collection (don't redecode the type) if (extendedProperties == null) { extendedProperties = new ExtendedPropertyCollection(); } extendedProperties[guid] = data; if (locallyDecodedBytes > remainingBytesInStrokeBlock) { throw new InvalidOperationException(StrokeCollectionSerializer.ISFDebugMessage("ExtendedProperty decoded totalBytesInStrokeBlockOfIsfStream exceeded ISF stream totalBytesInStrokeBlockOfIsfStream")); } remainingBytesInStrokeBlock -= locallyDecodedBytes; } break; } } if (0 != remainingBytesInStrokeBlock) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Invalid ISF data")); } return(totalBytesInStrokeBlockOfIsfStream); }
/// <summary> /// Loads drawing attributes from a memory buffer. /// </summary> /// <param name="stream">Memory buffer to read from</param> /// <param name="guidList">Guid tags if extended properties are used</param> /// <param name="maximumStreamSize">Maximum size of buffer to read through</param> /// <param name="da">The drawing attributes collection to decode into</param> /// <returns>Number of bytes read</returns> #endif internal static uint DecodeAsISF(Stream stream, GuidList guidList, uint maximumStreamSize, DrawingAttributes da) { PenTip penTip = PenTip.Default; PenStyle penStyle = PenStyle.Default; double stylusWidth = DrawingAttributeSerializer.V1PenWidthWhenWidthIsMissing; double stylusHeight = DrawingAttributeSerializer.V1PenHeightWhenHeightIsMissing; uint rasterOperation = DrawingAttributeSerializer.RasterOperationDefaultV1; int transparency = DrawingAttributeSerializer.TransparencyDefaultV1; bool widthIsSetInISF = false; //did we find KnownIds.Width? bool heightIsSetInISF = false; //did we find KnownIds.Height? uint cbTotal = maximumStreamSize; while (maximumStreamSize > 0) { KnownTagCache.KnownTagIndex tag; uint uiTag; // First read the tag uint cb = SerializationHelper.Decode (stream, out uiTag); tag = (KnownTagCache.KnownTagIndex)uiTag; if (maximumStreamSize < cb) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("ISF size is larger than maximum stream size")); } maximumStreamSize -= cb; // Get the guid based on the tag Guid guid = guidList.FindGuid (tag); if (guid == Guid.Empty) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Drawing Attribute tag embedded in ISF stream does not match guid table")); } uint dw = 0; if (KnownIds.PenTip == guid) { cb = SerializationHelper.Decode (stream, out dw); penTip = (PenTip)dw; if (!PenTipHelper.IsDefined(penTip)) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Invalid PenTip value found in ISF stream")); } maximumStreamSize -= cb; } else if (KnownIds.PenStyle == guid) { cb = SerializationHelper.Decode(stream, out dw); penStyle = (PenStyle)dw; maximumStreamSize -= cb; } else if (KnownIds.DrawingFlags == guid) { // Encode the drawing flags with considerations for v2 model cb = SerializationHelper.Decode (stream, out dw); DrawingFlags flags = (DrawingFlags)dw; da.DrawingFlags = flags; maximumStreamSize -= cb; } else if (KnownIds.RasterOperation == guid) { uint ropSize = GuidList.GetDataSizeIfKnownGuid(KnownIds.RasterOperation); if (ropSize == 0) { throw new InvalidOperationException(StrokeCollectionSerializer. ISFDebugMessage("ROP data size was not found")); } byte[] data = new byte[ropSize]; stream.Read (data, 0, (int)ropSize); if (data != null && data.Length > 0) { //data[0] holds the allowable values of 0-255 rasterOperation = Convert.ToUInt32(data[0]); } maximumStreamSize -= ropSize; } else if (KnownIds.CurveFittingError == guid) { cb = SerializationHelper.Decode (stream, out dw); da.FittingError = (int)dw; maximumStreamSize -= cb; } else if (KnownIds.StylusHeight == guid || KnownIds.StylusWidth == guid) { double _size; cb = SerializationHelper.Decode (stream, out dw); _size = (double)dw; maximumStreamSize -= cb; if (maximumStreamSize > 0) { cb = SerializationHelper.Decode (stream, out dw); maximumStreamSize -= cb; if (KnownTagCache.KnownTagIndex.Mantissa == (KnownTagCache.KnownTagIndex)dw) { uint cbInSize; // First thing that is in there is maximumStreamSize of the data cb = SerializationHelper.Decode (stream, out cbInSize); maximumStreamSize -= cb; // in maximumStreamSize is one more than the decoded no cbInSize++; if (cbInSize > maximumStreamSize) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("ISF size if greater then maximum stream size")); } byte[] in_data = new byte[cbInSize]; uint bytesRead = (uint) stream.Read (in_data, 0, (int)cbInSize); if (cbInSize != bytesRead) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Read different size from stream then expected")); } byte[] out_buffer = Compressor.DecompressPropertyData (in_data); using (MemoryStream localStream = new MemoryStream(out_buffer)) using (BinaryReader rdr = new BinaryReader(localStream)) { short sFraction = rdr.ReadInt16(); _size += (double)(sFraction / DrawingAttributes.StylusPrecision); maximumStreamSize -= cbInSize; } } else { // Seek it back by cb stream.Seek (-cb, SeekOrigin.Current); maximumStreamSize += cb; } } if (KnownIds.StylusWidth == guid) { widthIsSetInISF = true; stylusWidth = _size; } else { heightIsSetInISF = true; stylusHeight = _size; } } else if (KnownIds.Transparency == guid) { cb = SerializationHelper.Decode(stream, out dw); transparency = (int)dw; maximumStreamSize -= cb; } else if (KnownIds.Color == guid) { cb = SerializationHelper.Decode(stream, out dw); Color color = Color.FromRgb((byte)(dw & 0xff), (byte)((dw & 0xff00) >> Native.BitsPerByte), (byte)((dw & 0xff0000) >> (Native.BitsPerByte * 2))); da.Color = color; maximumStreamSize -= cb; } else if (KnownIds.StylusTipTransform == guid) { try { object data; cb = ExtendedPropertySerializer.DecodeAsISF(stream, maximumStreamSize, guidList, tag, ref guid, out data); Matrix matrix = Matrix.Parse((string)data); da.StylusTipTransform = matrix; } catch (InvalidOperationException) // Matrix.Parse failed. { System.Diagnostics.Debug.Assert(false, "Corrupt Matrix in the ExtendedPropertyCollection!"); } finally { maximumStreamSize -= cb; } } else { object data; cb = ExtendedPropertySerializer.DecodeAsISF(stream, maximumStreamSize, guidList, tag, ref guid, out data); maximumStreamSize -= cb; da.AddPropertyData(guid,data); } } if (0 != maximumStreamSize) { throw new ArgumentException (); } // // time to create our drawing attributes. // // 1) First we need to evaluate PenTip / StylusTip // Here is the V1 - V2 mapping // // PenTip.Circle == StylusTip.Ellipse // PenTip.Rectangle == StylusTip.Rectangle // PenTip.Rectangle == StylusTip.Diamond if (penTip == PenTip.Default) { //Since StylusTip is stored in the EPC at this point (if set), we can compare against it here. if (da.StylusTip != StylusTip.Ellipse) { // // StylusTip was set to something other than Ellipse // when we last serialized (or else StylusTip would be Ellipse, the default) // when StylusTip is != Ellipse and we serialize, we set PenTip to Rectangle // which is not the default. Therefore, if PenTip is back to Circle, // that means someone set it in V1 and we should respect that by // changing StylusTip back to Ellipse // da.StylusTip = StylusTip.Ellipse; } //else da.StylusTip is already set } else { System.Diagnostics.Debug.Assert(penTip == PenTip.Rectangle); if (da.StylusTip == StylusTip.Ellipse) { // // PenTip is Rectangle and StylusTip was either not set // before or was set to Ellipse and PenTip was changed // in a V1 ink object. Either way, we need to change StylusTip to Rectangle da.StylusTip = StylusTip.Rectangle; } //else da.StylusTip is already set } // // 2) next we need to set hight and width // if (da.StylusTip == StylusTip.Ellipse && widthIsSetInISF && !heightIsSetInISF) { // // special case: V1 PenTip of Circle only used Width to compute the circle size // and so it only serializes Width of 53 // but since our default is Ellipse, if Height is unset and we use the default // height of 30, then your ink that looked like 53,53 in V1 will look // like 30,53 here. // // stylusHeight = stylusWidth; da.HeightChangedForCompatabity = true; } // need to convert width/height into Avalon, since they are stored in HIMETRIC in ISF stylusHeight *= StrokeCollectionSerializer.HimetricToAvalonMultiplier; stylusWidth *= StrokeCollectionSerializer.HimetricToAvalonMultiplier; // Map 0.0 width to DrawingAttributes.DefaultXXXXXX (V1 53 equivalent) double height = DoubleUtil.IsZero(stylusHeight) ? (Double)DrawingAttributes.GetDefaultDrawingAttributeValue(KnownIds.StylusHeight) : stylusHeight; double width = DoubleUtil.IsZero(stylusWidth) ? (Double)DrawingAttributes.GetDefaultDrawingAttributeValue(KnownIds.StylusWidth) : stylusWidth; da.Height = GetCappedHeightOrWidth(height); da.Width = GetCappedHeightOrWidth(width); // // 3) next we need to set IsHighlighter (by looking for RasterOperation.MaskPen) // // // always store raster op // da.RasterOperation = rasterOperation; if (rasterOperation == DrawingAttributeSerializer.RasterOperationDefaultV1) { // // if rasterop is default, make sure IsHighlighter isn't in the EPC // if (da.ContainsPropertyData(KnownIds.IsHighlighter)) { da.RemovePropertyData(KnownIds.IsHighlighter); } } else { if (rasterOperation == DrawingAttributeSerializer.RasterOperationMaskPen) { da.IsHighlighter = true; } } //else, IsHighlighter will be set to false by default, no need to set it // // 4) see if there is a transparency we need to add to color // if (transparency > DrawingAttributeSerializer.TransparencyDefaultV1) { //note: Color.A is set to 255 by default, which means fully opaque //transparency is just the opposite - 0 means fully opaque so //we need to flip the values int alpha = MathHelper.AbsNoThrow(transparency - 255); Color color = da.Color; color.A = Convert.ToByte(alpha); da.Color = color; } return cbTotal; }
/// <summary> /// Loads a single ExtendedProperty from the stream and add that to the list. Tag may be passed as in /// the case of Stroke ExtendedPropertyCollection where tag is stored in the stroke descriptor or 0 when tag /// is embeded in the stream /// </summary> /// <param name="stream">Memory buffer to load from</param> /// <param name="cbSize">Maximum length of buffer to read</param> /// <param name="guidList">Guid cache to read from</param> /// <param name="tag">Guid tag to lookup</param> /// <param name="guid">Guid of property</param> /// <param name="data">Data of property</param> /// <returns>Length of buffer read</returns> #endif internal static uint DecodeAsISF(Stream stream, uint cbSize, GuidList guidList, KnownTagCache.KnownTagIndex tag, ref Guid guid, out object data) { uint cb, cbRead = 0; uint cbTotal = cbSize; if (0 == cbSize) { throw new InvalidOperationException(SR.Get(SRID.EmptyDataToLoad)); } if (0 == tag) // no tag is passed, it must be embedded in the data { uint uiTag; cb = SerializationHelper.Decode(stream, out uiTag); tag = (KnownTagCache.KnownTagIndex)uiTag; if (cb > cbTotal) throw new ArgumentException(SR.Get(SRID.InvalidSizeSpecified), "cbSize"); cbTotal -= cb; cbRead += cb; System.Diagnostics.Debug.Assert(guid == Guid.Empty); guid = guidList.FindGuid(tag); } if (guid == Guid.Empty) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Custom Attribute tag embedded in ISF stream does not match guid table"), "tag"); } // Try and find the size uint size = GuidList.GetDataSizeIfKnownGuid(guid); if (size > cbTotal) throw new ArgumentException(SR.Get(SRID.InvalidSizeSpecified), "cbSize"); // if the size is 0 if (0 == size) { // Size must be embedded in the stream. Find out the compressed data size cb = SerializationHelper.Decode(stream, out size); uint cbInsize = size + 1; cbRead += cb; cbTotal -= cb; if (cbInsize > cbTotal) throw new ArgumentException(); byte[] bytes = new byte[cbInsize]; uint bytesRead = (uint) stream.Read(bytes, 0, (int)cbInsize); if (cbInsize != bytesRead) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Read different size from stream then expected"), "cbSize"); } cbRead += cbInsize; cbTotal -= cbInsize; //Find out the Decompressed buffer size using (MemoryStream decompressedStream = new MemoryStream(Compressor.DecompressPropertyData(bytes))) { // Add the property data = ExtendedPropertySerializer.DecodeAttribute(guid, decompressedStream); } } else { // For known size data, we just read the data directly from the stream byte[] bytes = new byte[size]; uint bytesRead = (uint) stream.Read(bytes, 0, (int)size); if (size != bytesRead) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Read different size from stream then expected"), "cbSize"); } using (MemoryStream subStream = new MemoryStream(bytes)) { data = ExtendedPropertySerializer.DecodeAttribute(guid, subStream); } cbTotal -= size; cbRead += size; } return cbRead; }
/// <summary> /// Takes an ISF Stream and populates the StrokeCollection /// attached to this StrokeCollectionSerializer. /// </summary> /// <param name="inputStream">a Stream the raw isf to decode</param> #endif private void DecodeRawISF(Stream inputStream) { Debug.Assert(inputStream != null); KnownTagCache.KnownTagIndex isfTag; uint remainingBytesInStream; uint bytesDecodedInCurrentTag = 0; bool strokeDescriptorBlockDecoded = false; bool drawingAttributesBlockDecoded = false; bool metricBlockDecoded = false; bool transformDecoded = false; uint strokeDescriptorTableIndex = 0; uint oldStrokeDescriptorTableIndex = 0xFFFFFFFF; uint drawingAttributesTableIndex = 0; uint oldDrawingAttributesTableIndex = 0xFFFFFFFF; uint metricDescriptorTableIndex = 0; uint oldMetricDescriptorTableIndex = 0xFFFFFFFF; uint transformTableIndex = 0; uint oldTransformTableIndex = 0xFFFFFFFF; GuidList guidList = new GuidList(); int strokeIndex = 0; StylusPointDescription currentStylusPointDescription = null; Matrix currentTabletToInkTransform = Matrix.Identity; _strokeDescriptorTable = new System.Collections.Generic.List<StrokeDescriptor>(); _drawingAttributesTable = new System.Collections.Generic.List<DrawingAttributes>(); _transformTable = new System.Collections.Generic.List<TransformDescriptor>(); _metricTable = new System.Collections.Generic.List<MetricBlock>(); // First make sure this ink is empty if (0 != _coreStrokes.Count || _coreStrokes.ExtendedProperties.Count != 0) { throw new InvalidOperationException(ISFDebugMessage("ISF decoder cannot operate on non-empty ink container")); } #if OLD_ISF // // store a compressor reference at this scope, if it is needed (if there is a compresson header) and // therefore instanced during this routine, we will dispose of it // in the finally block // Compressor compressor = null; try { #endif // First read the isfTag uint uiTag; uint localBytesDecoded = SerializationHelper.Decode(inputStream, out uiTag); if (0x00 != uiTag) throw new ArgumentException(SR.Get(SRID.InvalidStream)); // Now read the size of the stream localBytesDecoded = SerializationHelper.Decode(inputStream, out remainingBytesInStream); ISFDebugTrace("Decoded Stream Size in Bytes: " + remainingBytesInStream.ToString()); if (0 == remainingBytesInStream) return; while (0 < remainingBytesInStream) { bytesDecodedInCurrentTag = 0; // First read the isfTag localBytesDecoded = SerializationHelper.Decode(inputStream, out uiTag); isfTag = (KnownTagCache.KnownTagIndex)uiTag; if (remainingBytesInStream >= localBytesDecoded) remainingBytesInStream -= localBytesDecoded; else { throw new ArgumentException(ISFDebugMessage("Invalid ISF data")); } ISFDebugTrace("Decoding Tag: " + ((KnownTagCache.KnownTagIndex)isfTag).ToString()); switch (isfTag) { case KnownTagCache.KnownTagIndex.GuidTable: case KnownTagCache.KnownTagIndex.DrawingAttributesTable: case KnownTagCache.KnownTagIndex.DrawingAttributesBlock: case KnownTagCache.KnownTagIndex.StrokeDescriptorTable: case KnownTagCache.KnownTagIndex.StrokeDescriptorBlock: case KnownTagCache.KnownTagIndex.MetricTable: case KnownTagCache.KnownTagIndex.MetricBlock: case KnownTagCache.KnownTagIndex.TransformTable: case KnownTagCache.KnownTagIndex.ExtendedTransformTable: case KnownTagCache.KnownTagIndex.Stroke: case KnownTagCache.KnownTagIndex.CompressionHeader: case KnownTagCache.KnownTagIndex.PersistenceFormat: case KnownTagCache.KnownTagIndex.HimetricSize: case KnownTagCache.KnownTagIndex.StrokeIds: { localBytesDecoded = SerializationHelper.Decode(inputStream, out bytesDecodedInCurrentTag); if (remainingBytesInStream < (localBytesDecoded + bytesDecodedInCurrentTag)) { throw new ArgumentException(ISFDebugMessage("Invalid ISF data"), "inputStream"); } remainingBytesInStream -= localBytesDecoded; // Based on the isfTag figure out what information we're loading switch (isfTag) { case KnownTagCache.KnownTagIndex.GuidTable: { // Load guid Table localBytesDecoded = guidList.Load(inputStream, bytesDecodedInCurrentTag); break; } case KnownTagCache.KnownTagIndex.DrawingAttributesTable: { // Load drawing attributes table localBytesDecoded = LoadDrawAttrsTable(inputStream, guidList, bytesDecodedInCurrentTag); drawingAttributesBlockDecoded = true; break; } case KnownTagCache.KnownTagIndex.DrawingAttributesBlock: { //initialize to V1 defaults, we do it this way as opposed //to dr.DrawingFlags = 0 because this was a perf hot spot //and instancing the epc first mitigates it ExtendedPropertyCollection epc = new ExtendedPropertyCollection(); epc.Add(KnownIds.DrawingFlags, DrawingFlags.Polyline); DrawingAttributes dr = new DrawingAttributes(epc); localBytesDecoded = DrawingAttributeSerializer.DecodeAsISF(inputStream, guidList, bytesDecodedInCurrentTag, dr); _drawingAttributesTable.Add(dr); drawingAttributesBlockDecoded = true; break; } case KnownTagCache.KnownTagIndex.StrokeDescriptorTable: { // Load stroke descriptor table localBytesDecoded = DecodeStrokeDescriptorTable(inputStream, bytesDecodedInCurrentTag); strokeDescriptorBlockDecoded = true; break; } case KnownTagCache.KnownTagIndex.StrokeDescriptorBlock: { // Load a single stroke descriptor localBytesDecoded = DecodeStrokeDescriptorBlock(inputStream, bytesDecodedInCurrentTag); strokeDescriptorBlockDecoded = true; break; } case KnownTagCache.KnownTagIndex.MetricTable: { // Load Metric Table localBytesDecoded = DecodeMetricTable(inputStream, bytesDecodedInCurrentTag); metricBlockDecoded = true; break; } case KnownTagCache.KnownTagIndex.MetricBlock: { // Load a single Metric Block MetricBlock blk; localBytesDecoded = DecodeMetricBlock(inputStream, bytesDecodedInCurrentTag, out blk); _metricTable.Clear(); _metricTable.Add(blk); metricBlockDecoded = true; break; } case KnownTagCache.KnownTagIndex.TransformTable: { // Load Transform Table localBytesDecoded = DecodeTransformTable(inputStream, bytesDecodedInCurrentTag, false); transformDecoded = true; break; } case KnownTagCache.KnownTagIndex.ExtendedTransformTable: { // non-double transform table should have already been loaded if (!transformDecoded) { throw new ArgumentException(ISFDebugMessage("Invalid ISF data")); } // Load double-sized Transform Table localBytesDecoded = DecodeTransformTable(inputStream, bytesDecodedInCurrentTag, true); break; } case KnownTagCache.KnownTagIndex.PersistenceFormat: { uint fmt; localBytesDecoded = SerializationHelper.Decode(inputStream, out fmt); // Set the appropriate persistence information if (0 == fmt) { CurrentPersistenceFormat = PersistenceFormat.InkSerializedFormat; } else if (0x00000001 == fmt) { CurrentPersistenceFormat = PersistenceFormat.Gif; } break; } case KnownTagCache.KnownTagIndex.HimetricSize: { // Loads the Hi Metric Size for Fortified GIFs int sz; localBytesDecoded = SerializationHelper.SignDecode(inputStream, out sz); if (localBytesDecoded > remainingBytesInStream) throw new ArgumentException(ISFDebugMessage("Invalid ISF data")); _himetricSize.X = (double)sz; localBytesDecoded += SerializationHelper.SignDecode(inputStream, out sz); _himetricSize.Y = (double)sz; break; } case KnownTagCache.KnownTagIndex.CompressionHeader: { #if OLD_ISF byte[] data = new byte[bytesDecodedInCurrentTag]; // read the header from the stream uint bytesRead = StrokeCollectionSerializer.ReliableRead(inputStream, data, bytesDecodedInCurrentTag); if (bytesDecodedInCurrentTag != bytesRead) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Read different size from stream then expected"), "isfStream"); } uint size = bytesDecodedInCurrentTag; compressor = new Compressor(data, ref size); // in case the actual number of bytes read by the compressor // is less than the encoder had expected (e.g. compression // header was encoded as 10 bytes, but only 7 bytes were read) // then we don't want to adjust the stream position because // there are likely other following tags that are encoded // after the compression tag. This should never happen, // so just fail if the compressor is broken or the ISF is // corrupted. if (size != bytesDecodedInCurrentTag) { throw new InvalidOperationException(ISFDebugMessage("Compressor intialization reported inconsistent size")); } #else //just advance the inputstream position, we don't need //no compression header in the new isf decoding inputStream.Seek(bytesDecodedInCurrentTag, SeekOrigin.Current); #endif localBytesDecoded = bytesDecodedInCurrentTag; break; } case KnownTagCache.KnownTagIndex.StrokeIds: { localBytesDecoded = LoadStrokeIds(inputStream, bytesDecodedInCurrentTag); break; } case KnownTagCache.KnownTagIndex.Stroke: { ISFDebugTrace(" Decoding Stroke Id#(" + (strokeIndex + 1).ToString() + ")"); StrokeDescriptor strokeDescriptor = null; // Load the stroke descriptor based on the index from the list of unique // stroke descriptors if (strokeDescriptorBlockDecoded) { if (oldStrokeDescriptorTableIndex != strokeDescriptorTableIndex) { if (_strokeDescriptorTable.Count <= strokeDescriptorTableIndex) throw new ArgumentException(ISFDebugMessage("Invalid ISF data")); } strokeDescriptor = _strokeDescriptorTable[(int)strokeDescriptorTableIndex]; } // use new transform if the last transform is uninit'd or has changed if (oldTransformTableIndex != transformTableIndex) { // if transform was specified in the ISF stream if (transformDecoded) { if (_transformTable.Count <= transformTableIndex) throw new ArgumentException(ISFDebugMessage("Invalid ISF data")); // Load the transform descriptor based on the index from the list of unique // transforn descriptors currentTabletToInkTransform = LoadTransform(_transformTable[(int)transformTableIndex]); } oldTransformTableIndex = transformTableIndex; // cache the transform by remembering the index // since ISF is stored in HIMETRIC, and we want to expose packet data // as Avalon units, we'll update the convert the transform before loading the stroke currentTabletToInkTransform.Scale(StrokeCollectionSerializer.HimetricToAvalonMultiplier, StrokeCollectionSerializer.HimetricToAvalonMultiplier); } MetricBlock metricBlock = null; // Load the metric block based on the index from the list of unique metric blocks if (metricBlockDecoded) { if (oldMetricDescriptorTableIndex != metricDescriptorTableIndex) { if (_metricTable.Count <= metricDescriptorTableIndex) throw new ArgumentException(ISFDebugMessage("Invalid ISF data")); } metricBlock = _metricTable[(int)metricDescriptorTableIndex]; } DrawingAttributes activeDrawingAttributes = null; // Load the drawing attributes based on the index from the list of unique drawing attributes if (drawingAttributesBlockDecoded) { if (oldDrawingAttributesTableIndex != drawingAttributesTableIndex) { if (_drawingAttributesTable.Count <= drawingAttributesTableIndex) throw new ArgumentException(ISFDebugMessage("Invalid ISF data")); oldDrawingAttributesTableIndex = drawingAttributesTableIndex; } DrawingAttributes currDA = (DrawingAttributes)_drawingAttributesTable[(int)drawingAttributesTableIndex]; //we always clone so we don't get strokes that share DAs, which can lead //to all sorts of unpredictable behavior (ex: see Windows OS Bugs 1450047) activeDrawingAttributes = currDA.Clone(); } // if we didn't find an existing da to use, instance a new one if (activeDrawingAttributes == null) { activeDrawingAttributes = new DrawingAttributes(); } // Now create the StylusPacketDescription from the stroke descriptor and metric block if (oldMetricDescriptorTableIndex != metricDescriptorTableIndex || oldStrokeDescriptorTableIndex != strokeDescriptorTableIndex) { currentStylusPointDescription = BuildStylusPointDescription(strokeDescriptor, metricBlock, guidList); oldStrokeDescriptorTableIndex = strokeDescriptorTableIndex; oldMetricDescriptorTableIndex = metricDescriptorTableIndex; } // Load the stroke Stroke localStroke; #if OLD_ISF localBytesDecoded = StrokeSerializer.DecodeStroke(inputStream, bytesDecodedInCurrentTag, guidList, strokeDescriptor, currentStylusPointDescription, activeDrawingAttributes, currentTabletToInkTransform, compressor, out localStroke); #else localBytesDecoded = StrokeSerializer.DecodeStroke(inputStream, bytesDecodedInCurrentTag, guidList, strokeDescriptor, currentStylusPointDescription, activeDrawingAttributes, currentTabletToInkTransform, out localStroke); #endif if (localStroke != null) { _coreStrokes.AddWithoutEvent(localStroke); strokeIndex++; } break; } default: { throw new InvalidOperationException(ISFDebugMessage("Invalid ISF tag logic")); } } // if this isfTag's decoded size != expected size, then error out if (localBytesDecoded != bytesDecodedInCurrentTag) { throw new ArgumentException(ISFDebugMessage("Invalid ISF data")); } break; } case KnownTagCache.KnownTagIndex.Transform: case KnownTagCache.KnownTagIndex.TransformIsotropicScale: case KnownTagCache.KnownTagIndex.TransformAnisotropicScale: case KnownTagCache.KnownTagIndex.TransformRotate: case KnownTagCache.KnownTagIndex.TransformTranslate: case KnownTagCache.KnownTagIndex.TransformScaleAndTranslate: { // Load a single Transform Block TransformDescriptor xform; bytesDecodedInCurrentTag = DecodeTransformBlock(inputStream, isfTag, remainingBytesInStream, false, out xform); transformDecoded = true; _transformTable.Clear(); _transformTable.Add(xform); break; } case KnownTagCache.KnownTagIndex.TransformTableIndex: { // Load the Index into the Transform Table which will be used by the stroke following this till // a next different Index is found bytesDecodedInCurrentTag = SerializationHelper.Decode(inputStream, out transformTableIndex); break; } case KnownTagCache.KnownTagIndex.MetricTableIndex: { // Load the Index into the Metric Table which will be used by the stroke following this till // a next different Index is found bytesDecodedInCurrentTag = SerializationHelper.Decode(inputStream, out metricDescriptorTableIndex); break; } case KnownTagCache.KnownTagIndex.DrawingAttributesTableIndex: { // Load the Index into the Drawing Attributes Table which will be used by the stroke following this till // a next different Index is found bytesDecodedInCurrentTag = SerializationHelper.Decode(inputStream, out drawingAttributesTableIndex); break; } case KnownTagCache.KnownTagIndex.InkSpaceRectangle: { // Loads the Ink Space Rectangle information bytesDecodedInCurrentTag = DecodeInkSpaceRectangle(inputStream, remainingBytesInStream); break; } case KnownTagCache.KnownTagIndex.StrokeDescriptorTableIndex: { // Load the Index into the Stroke Descriptor Table which will be used by the stroke following this till // a next different Index is found bytesDecodedInCurrentTag = SerializationHelper.Decode(inputStream, out strokeDescriptorTableIndex); break; } default: { if ((uint)isfTag >= KnownIdCache.CustomGuidBaseIndex || ((uint)isfTag >= KnownTagCache.KnownTagCount && ((uint)isfTag < (KnownTagCache.KnownTagCount + KnownIdCache.OriginalISFIdTable.Length)))) { ISFDebugTrace(" CUSTOM_GUID=" + guidList.FindGuid(isfTag).ToString()); // Loads any custom property data bytesDecodedInCurrentTag = remainingBytesInStream; Guid guid = guidList.FindGuid(isfTag); if (guid == Guid.Empty) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Global Custom Attribute tag embedded in ISF stream does not match guid table"), "inkdata"); } object data; // load the custom property data from the stream (and decode the type) localBytesDecoded = ExtendedPropertySerializer.DecodeAsISF(inputStream, bytesDecodedInCurrentTag, guidList, isfTag, ref guid, out data); if (localBytesDecoded > bytesDecodedInCurrentTag) { throw new ArgumentException(ISFDebugMessage("Invalid ISF data"), "inkdata"); } // add the guid/data pair into the property collection (don't redecode the type) _coreStrokes.ExtendedProperties[guid] = data; } else { // Skip objects that this library doesn't know about // First read the size associated with this unknown isfTag localBytesDecoded = SerializationHelper.Decode(inputStream, out bytesDecodedInCurrentTag); if (remainingBytesInStream < (localBytesDecoded + bytesDecodedInCurrentTag)) { throw new ArgumentException(ISFDebugMessage("Invalid ISF data")); } else { inputStream.Seek(bytesDecodedInCurrentTag + localBytesDecoded, SeekOrigin.Current); } } bytesDecodedInCurrentTag = localBytesDecoded; break; } } ISFDebugTrace(" Size = " + bytesDecodedInCurrentTag.ToString()); if (bytesDecodedInCurrentTag > remainingBytesInStream) { throw new ArgumentException(ISFDebugMessage("Invalid ISF data")); } // update remaining ISF buffer length with decoded so far remainingBytesInStream -= bytesDecodedInCurrentTag; } #if OLD_ISF } finally { if (null != compressor) { compressor.Dispose(); compressor = null; } } #endif if (0 != remainingBytesInStream) throw new ArgumentException(ISFDebugMessage("Invalid ISF data"), "inkdata"); }
/// <summary> /// Builds StylusPointDescription based on StrokeDescriptor and Metric Descriptor Block. Sometime Metric Descriptor block may contain /// metric information for properties which are not part of the stroke descriptor. They are simply ignored. /// </summary> /// <param name="strd"></param> /// <param name="block"></param> /// <param name="guidList"></param> /// <returns></returns> private StylusPointDescription BuildStylusPointDescription(StrokeDescriptor strd, MetricBlock block, GuidList guidList) { int cTags = 0; int packetPropertyCount = 0; uint buttonCount = 0; Guid[] buttonguids = null; System.Collections.Generic.List<KnownTagCache.KnownTagIndex> tags = null; // if strd is null, it means there is only default descriptor with X & Y if (null != strd) { tags = new System.Collections.Generic.List<KnownTagCache.KnownTagIndex>(); while (cTags < strd.Template.Count) { KnownTagCache.KnownTagIndex tag = (KnownTagCache.KnownTagIndex)strd.Template[cTags]; if (KnownTagCache.KnownTagIndex.Buttons == tag) { cTags++; // The next item in the array is no of buttongs. buttonCount = (uint)strd.Template[cTags]; cTags++; // Currently we skip the the no of buttons as buttons is not implimented yet buttonguids = new Guid[buttonCount]; for (uint u = 0; u < buttonCount; u++) { Guid guid = guidList.FindGuid(strd.Template[cTags]); if (guid == Guid.Empty) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Button guid tag embedded in ISF stream does not match guid table"),"strd"); } buttonguids[(int)u] = guid; cTags++; } } else if (KnownTagCache.KnownTagIndex.StrokePropertyList == tag) { break; // since no more Packet properties can be stored } else { if (KnownTagCache.KnownTagIndex.NoX == tag || KnownTagCache.KnownTagIndex.NoY == tag) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Invalid ISF with NoX or NoY specified"), "strd"); } tags.Add(strd.Template[cTags]); packetPropertyCount++; cTags++; } } } List<StylusPointPropertyInfo> stylusPointPropertyInfos = new List<StylusPointPropertyInfo>(); stylusPointPropertyInfos.Add(GetStylusPointPropertyInfo(KnownIds.X, (KnownTagCache.KnownTagIndex)((uint)KnownIdCache.KnownGuidBaseIndex + (uint)KnownIdCache.OriginalISFIdIndex.X), block)); stylusPointPropertyInfos.Add(GetStylusPointPropertyInfo(KnownIds.Y, (KnownTagCache.KnownTagIndex)((uint)KnownIdCache.KnownGuidBaseIndex + (uint)KnownIdCache.OriginalISFIdIndex.Y), block)); stylusPointPropertyInfos.Add(GetStylusPointPropertyInfo(KnownIds.NormalPressure, (KnownTagCache.KnownTagIndex)((uint)KnownIdCache.KnownGuidBaseIndex + (uint)KnownIdCache.OriginalISFIdIndex.NormalPressure), block)); int pressureIndex = -1; if (tags != null) { for (int i = 0; i < tags.Count; i++) { Guid guid = guidList.FindGuid(tags[i]); if (guid == Guid.Empty) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Packet Description Property tag embedded in ISF stream does not match guid table"), "strd"); } if (pressureIndex == -1 && guid == StylusPointPropertyIds.NormalPressure) { pressureIndex = i + 2; //x,y have already been accounted for continue; //we've already added pressure (above) } stylusPointPropertyInfos.Add(GetStylusPointPropertyInfo(guid, tags[i], block)); } if (null != buttonguids) { // // add the buttons to the end of the description if they exist // for (int i = 0; i < buttonguids.Length; i++) { StylusPointProperty buttonProperty = new StylusPointProperty(buttonguids[i], true); StylusPointPropertyInfo buttonInfo = new StylusPointPropertyInfo(buttonProperty); stylusPointPropertyInfos.Add(buttonInfo); } } } return new StylusPointDescription(stylusPointPropertyInfos, pressureIndex); }
/// <summary> /// Loads drawing attributes from a memory buffer. /// </summary> /// <param name="stream">Memory buffer to read from</param> /// <param name="guidList">Guid tags if extended properties are used</param> /// <param name="maximumStreamSize">Maximum size of buffer to read through</param> /// <param name="da">The drawing attributes collection to decode into</param> /// <returns>Number of bytes read</returns> #else /// <summary> /// Loads drawing attributes from a memory buffer. /// </summary> /// <param name="stream">Memory buffer to read from</param> /// <param name="guidList">Guid tags if extended properties are used</param> /// <param name="maximumStreamSize">Maximum size of buffer to read through</param> /// <param name="da">The drawing attributes collection to decode into</param> /// <returns>Number of bytes read</returns> #endif internal static uint DecodeAsISF(Stream stream, GuidList guidList, uint maximumStreamSize, DrawingAttributes da) { PenTip penTip = PenTip.Default; PenStyle penStyle = PenStyle.Default; double stylusWidth = DrawingAttributeSerializer.V1PenWidthWhenWidthIsMissing; double stylusHeight = DrawingAttributeSerializer.V1PenHeightWhenHeightIsMissing; uint rasterOperation = DrawingAttributeSerializer.RasterOperationDefaultV1; int transparency = DrawingAttributeSerializer.TransparencyDefaultV1; bool widthIsSetInISF = false; //did we find KnownIds.Width? bool heightIsSetInISF = false; //did we find KnownIds.Height? uint cbTotal = maximumStreamSize; while (maximumStreamSize > 0) { KnownTagCache.KnownTagIndex tag; uint uiTag; // First read the tag uint cb = SerializationHelper.Decode(stream, out uiTag); tag = (KnownTagCache.KnownTagIndex)uiTag; if (maximumStreamSize < cb) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("ISF size is larger than maximum stream size")); } maximumStreamSize -= cb; // Get the guid based on the tag Guid guid = guidList.FindGuid(tag); if (guid == Guid.Empty) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Drawing Attribute tag embedded in ISF stream does not match guid table")); } uint dw = 0; if (KnownIds.PenTip == guid) { cb = SerializationHelper.Decode(stream, out dw); penTip = (PenTip)dw; if (!PenTipHelper.IsDefined(penTip)) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Invalid PenTip value found in ISF stream")); } maximumStreamSize -= cb; } else if (KnownIds.PenStyle == guid) { cb = SerializationHelper.Decode(stream, out dw); penStyle = (PenStyle)dw; maximumStreamSize -= cb; } else if (KnownIds.DrawingFlags == guid) { // Encode the drawing flags with considerations for v2 model cb = SerializationHelper.Decode(stream, out dw); DrawingFlags flags = (DrawingFlags)dw; da.DrawingFlags = flags; maximumStreamSize -= cb; } else if (KnownIds.RasterOperation == guid) { uint ropSize = GuidList.GetDataSizeIfKnownGuid(KnownIds.RasterOperation); if (ropSize == 0) { throw new InvalidOperationException(StrokeCollectionSerializer.ISFDebugMessage("ROP data size was not found")); } byte[] data = new byte[ropSize]; stream.Read(data, 0, (int)ropSize); if (data != null && data.Length > 0) { //data[0] holds the allowable values of 0-255 rasterOperation = Convert.ToUInt32(data[0]); } maximumStreamSize -= ropSize; } else if (KnownIds.CurveFittingError == guid) { cb = SerializationHelper.Decode(stream, out dw); da.FittingError = (int)dw; maximumStreamSize -= cb; } else if (KnownIds.StylusHeight == guid || KnownIds.StylusWidth == guid) { double _size; cb = SerializationHelper.Decode(stream, out dw); _size = (double)dw; maximumStreamSize -= cb; if (maximumStreamSize > 0) { cb = SerializationHelper.Decode(stream, out dw); maximumStreamSize -= cb; if (KnownTagCache.KnownTagIndex.Mantissa == (KnownTagCache.KnownTagIndex)dw) { uint cbInSize; // First thing that is in there is maximumStreamSize of the data cb = SerializationHelper.Decode(stream, out cbInSize); maximumStreamSize -= cb; // in maximumStreamSize is one more than the decoded no cbInSize++; if (cbInSize > maximumStreamSize) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("ISF size if greater then maximum stream size")); } byte[] in_data = new byte[cbInSize]; uint bytesRead = (uint)stream.Read(in_data, 0, (int)cbInSize); if (cbInSize != bytesRead) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Read different size from stream then expected")); } byte[] out_buffer = Compressor.DecompressPropertyData(in_data); using (MemoryStream localStream = new MemoryStream(out_buffer)) using (BinaryReader rdr = new BinaryReader(localStream)) { short sFraction = rdr.ReadInt16(); _size += (double)(sFraction / DrawingAttributes.StylusPrecision); maximumStreamSize -= cbInSize; } } else { // Seek it back by cb stream.Seek(-cb, SeekOrigin.Current); maximumStreamSize += cb; } } if (KnownIds.StylusWidth == guid) { widthIsSetInISF = true; stylusWidth = _size; } else { heightIsSetInISF = true; stylusHeight = _size; } } else if (KnownIds.Transparency == guid) { cb = SerializationHelper.Decode(stream, out dw); transparency = (int)dw; maximumStreamSize -= cb; } else if (KnownIds.Color == guid) { cb = SerializationHelper.Decode(stream, out dw); Color color = Color.FromRgb((byte)(dw & 0xff), (byte)((dw & 0xff00) >> Native.BitsPerByte), (byte)((dw & 0xff0000) >> (Native.BitsPerByte * 2))); da.Color = color; maximumStreamSize -= cb; } else if (KnownIds.StylusTipTransform == guid) { try { object data; cb = ExtendedPropertySerializer.DecodeAsISF(stream, maximumStreamSize, guidList, tag, ref guid, out data); Matrix matrix = Matrix.Parse((string)data); da.StylusTipTransform = matrix; } catch (InvalidOperationException) // Matrix.Parse failed. { System.Diagnostics.Debug.Assert(false, "Corrupt Matrix in the ExtendedPropertyCollection!"); } finally { maximumStreamSize -= cb; } } else { object data; cb = ExtendedPropertySerializer.DecodeAsISF(stream, maximumStreamSize, guidList, tag, ref guid, out data); maximumStreamSize -= cb; da.AddPropertyData(guid, data); } } if (0 != maximumStreamSize) { throw new ArgumentException(); } // // time to create our drawing attributes. // // 1) First we need to evaluate PenTip / StylusTip // Here is the V1 - V2 mapping // // PenTip.Circle == StylusTip.Ellipse // PenTip.Rectangle == StylusTip.Rectangle // PenTip.Rectangle == StylusTip.Diamond if (penTip == PenTip.Default) { //Since StylusTip is stored in the EPC at this point (if set), we can compare against it here. if (da.StylusTip != StylusTip.Ellipse) { // // StylusTip was set to something other than Ellipse // when we last serialized (or else StylusTip would be Ellipse, the default) // when StylusTip is != Ellipse and we serialize, we set PenTip to Rectangle // which is not the default. Therefore, if PenTip is back to Circle, // that means someone set it in V1 and we should respect that by // changing StylusTip back to Ellipse // da.StylusTip = StylusTip.Ellipse; } //else da.StylusTip is already set } else { System.Diagnostics.Debug.Assert(penTip == PenTip.Rectangle); if (da.StylusTip == StylusTip.Ellipse) { // // PenTip is Rectangle and StylusTip was either not set // before or was set to Ellipse and PenTip was changed // in a V1 ink object. Either way, we need to change StylusTip to Rectangle da.StylusTip = StylusTip.Rectangle; } //else da.StylusTip is already set } // // 2) next we need to set hight and width // if (da.StylusTip == StylusTip.Ellipse && widthIsSetInISF && !heightIsSetInISF) { // // special case: V1 PenTip of Circle only used Width to compute the circle size // and so it only serializes Width of 53 // but since our default is Ellipse, if Height is unset and we use the default // height of 30, then your ink that looked like 53,53 in V1 will look // like 30,53 here. // // stylusHeight = stylusWidth; da.HeightChangedForCompatabity = true; } // need to convert width/height into Avalon, since they are stored in HIMETRIC in ISF stylusHeight *= StrokeCollectionSerializer.HimetricToAvalonMultiplier; stylusWidth *= StrokeCollectionSerializer.HimetricToAvalonMultiplier; // Map 0.0 width to DrawingAttributes.DefaultXXXXXX (V1 53 equivalent) double height = DoubleUtil.IsZero(stylusHeight) ? (Double)DrawingAttributes.GetDefaultDrawingAttributeValue(KnownIds.StylusHeight) : stylusHeight; double width = DoubleUtil.IsZero(stylusWidth) ? (Double)DrawingAttributes.GetDefaultDrawingAttributeValue(KnownIds.StylusWidth) : stylusWidth; da.Height = GetCappedHeightOrWidth(height); da.Width = GetCappedHeightOrWidth(width); // // 3) next we need to set IsHighlighter (by looking for RasterOperation.MaskPen) // // // always store raster op // da.RasterOperation = rasterOperation; if (rasterOperation == DrawingAttributeSerializer.RasterOperationDefaultV1) { // // if rasterop is default, make sure IsHighlighter isn't in the EPC // if (da.ContainsPropertyData(KnownIds.IsHighlighter)) { da.RemovePropertyData(KnownIds.IsHighlighter); } } else { if (rasterOperation == DrawingAttributeSerializer.RasterOperationMaskPen) { da.IsHighlighter = true; } } //else, IsHighlighter will be set to false by default, no need to set it // // 4) see if there is a transparency we need to add to color // if (transparency > DrawingAttributeSerializer.TransparencyDefaultV1) { //note: Color.A is set to 255 by default, which means fully opaque //transparency is just the opposite - 0 means fully opaque so //we need to flip the values int alpha = MathHelper.AbsNoThrow(transparency - 255); Color color = da.Color; color.A = Convert.ToByte(alpha); da.Color = color; } return(cbTotal); }
/// <summary> /// This functions loads a stroke from a memory stream based on the descriptor and GuidList. It returns /// the no of bytes it has read from the stream to correctly load the stream, which should be same as /// the value of the size parameter. If they are unequal throws ArgumentException. Stroke descriptor is /// used to load the packetproperty as well as ExtendedPropertyCollection on this stroke. Compressor is used /// to decompress the data. /// </summary> /// <param name="stream"></param> /// <param name="totalBytesInStrokeBlockOfIsfStream"></param> /// <param name="guidList"></param> /// <param name="strokeDescriptor"></param> /// <param name="stylusPointDescription"></param> /// <param name="transform"></param> /// <param name="stylusPoints"></param> /// <param name="extendedProperties"></param> #endif static uint DecodeISFIntoStroke( #if OLD_ISF Compressor compressor, #endif Stream stream, uint totalBytesInStrokeBlockOfIsfStream, GuidList guidList, StrokeDescriptor strokeDescriptor, StylusPointDescription stylusPointDescription, Matrix transform, out StylusPointCollection stylusPoints, out ExtendedPropertyCollection extendedProperties) { stylusPoints = null; extendedProperties = null; // We do allow a stroke with no packet data if (0 == totalBytesInStrokeBlockOfIsfStream) { return 0; } uint locallyDecodedBytes; uint remainingBytesInStrokeBlock = totalBytesInStrokeBlockOfIsfStream; // First try to load any packet data locallyDecodedBytes = LoadPackets( stream, remainingBytesInStrokeBlock, #if OLD_ISF compressor, #endif stylusPointDescription, transform, out stylusPoints); if (locallyDecodedBytes > remainingBytesInStrokeBlock) throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Packet buffer overflowed the ISF stream")); remainingBytesInStrokeBlock -= locallyDecodedBytes; if (0 == remainingBytesInStrokeBlock) { return locallyDecodedBytes; } // Now read the extended propertes for (int iTag = 1; iTag < strokeDescriptor.Template.Count && remainingBytesInStrokeBlock > 0; iTag++) { KnownTagCache.KnownTagIndex tag = strokeDescriptor.Template[iTag - 1]; switch (tag) { case MS.Internal.Ink.InkSerializedFormat.KnownTagCache.KnownTagIndex.StrokePropertyList: { // we've found the stroke extended properties. Load them now. while (iTag < strokeDescriptor.Template.Count && remainingBytesInStrokeBlock > 0) { tag = strokeDescriptor.Template[iTag]; object data; Guid guid = guidList.FindGuid(tag); if (guid == Guid.Empty) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Stroke Custom Attribute tag embedded in ISF stream does not match guid table")); } // load the extended property data from the stream (and decode the type) locallyDecodedBytes = ExtendedPropertySerializer.DecodeAsISF(stream, remainingBytesInStrokeBlock, guidList, tag, ref guid, out data); // add the guid/data pair into the property collection (don't redecode the type) if (extendedProperties == null) { extendedProperties = new ExtendedPropertyCollection(); } extendedProperties[guid] = data; if (locallyDecodedBytes > remainingBytesInStrokeBlock) throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Invalid ISF data")); remainingBytesInStrokeBlock -= locallyDecodedBytes; iTag++; } } break; case MS.Internal.Ink.InkSerializedFormat.KnownTagCache.KnownTagIndex.Buttons: { // Next tag is count of buttons and the tags for the button guids iTag += (int)((uint)strokeDescriptor.Template[iTag]) + 1; } break; // ignore any tags embedded in the Stroke block that this // version of the ISF decoder doesn't understand default: { System.Diagnostics.Trace.WriteLine("Ignoring unhandled stroke tag in ISF stroke descriptor"); } break; } } // Now try to load any tagged property data or point property data while (remainingBytesInStrokeBlock > 0) { // Read the tag first KnownTagCache.KnownTagIndex tag; uint uiTag; locallyDecodedBytes = SerializationHelper.Decode(stream, out uiTag); tag = (KnownTagCache.KnownTagIndex)uiTag; if (locallyDecodedBytes > remainingBytesInStrokeBlock) throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Invalid ISF data")); remainingBytesInStrokeBlock -= locallyDecodedBytes; // if it is a point property block switch (tag) { case MS.Internal.Ink.InkSerializedFormat.KnownTagCache.KnownTagIndex.PointProperty: { // First load the totalBytesInStrokeBlockOfIsfStream of the point property block uint cbsize; locallyDecodedBytes = SerializationHelper.Decode(stream, out cbsize); if (locallyDecodedBytes > remainingBytesInStrokeBlock) throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Invalid ISF data")); remainingBytesInStrokeBlock -= locallyDecodedBytes; while (remainingBytesInStrokeBlock > 0) { // First read the tag corresponding to the property locallyDecodedBytes = SerializationHelper.Decode(stream, out uiTag); tag = (KnownTagCache.KnownTagIndex)uiTag; if (locallyDecodedBytes > remainingBytesInStrokeBlock) throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Invalid ISF data")); remainingBytesInStrokeBlock -= locallyDecodedBytes; // Now read the packet index for which the property will apply uint propindex; locallyDecodedBytes = SerializationHelper.Decode(stream, out propindex); if (locallyDecodedBytes > remainingBytesInStrokeBlock) throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Invalid ISF data")); remainingBytesInStrokeBlock -= locallyDecodedBytes; uint propsize; locallyDecodedBytes = SerializationHelper.Decode(stream, out propsize); if (locallyDecodedBytes > remainingBytesInStrokeBlock) throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Invalid ISF data")); remainingBytesInStrokeBlock -= locallyDecodedBytes; // Compressed data totalBytesInStrokeBlockOfIsfStream propsize += 1; // Make sure we have enough data to read if (propsize > remainingBytesInStrokeBlock) throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Invalid ISF data")); byte[] in_buffer = new byte[propsize]; uint bytesRead = StrokeCollectionSerializer.ReliableRead(stream, in_buffer, propsize); if (propsize != bytesRead) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Read different size from stream then expected")); } byte[] out_buffer = Compressor.DecompressPropertyData(in_buffer); System.Diagnostics.Debug.Assert(false, "ExtendedProperties for points are not supported"); // skip the bytes in both success & failure cases // Note: Point ExtendedProperties are discarded remainingBytesInStrokeBlock -= propsize; } } break; default: { object data; Guid guid = guidList.FindGuid(tag); if (guid == Guid.Empty) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Stroke Custom Attribute tag embedded in ISF stream does not match guid table")); } // load the extended property data from the stream (and decode the type) locallyDecodedBytes = ExtendedPropertySerializer.DecodeAsISF(stream, remainingBytesInStrokeBlock, guidList, tag, ref guid, out data); // add the guid/data pair into the property collection (don't redecode the type) if (extendedProperties == null) { extendedProperties = new ExtendedPropertyCollection(); } extendedProperties[guid] = data; if (locallyDecodedBytes > remainingBytesInStrokeBlock) { throw new InvalidOperationException(StrokeCollectionSerializer.ISFDebugMessage("ExtendedProperty decoded totalBytesInStrokeBlockOfIsfStream exceeded ISF stream totalBytesInStrokeBlockOfIsfStream")); } remainingBytesInStrokeBlock -= locallyDecodedBytes; } break; } } if (0 != remainingBytesInStrokeBlock) throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Invalid ISF data")); return totalBytesInStrokeBlockOfIsfStream; }
/// <summary> /// Loads a single ExtendedProperty from the stream and add that to the list. Tag may be passed as in /// the case of Stroke ExtendedPropertyCollection where tag is stored in the stroke descriptor or 0 when tag /// is embeded in the stream /// </summary> /// <param name="stream">Memory buffer to load from</param> /// <param name="cbSize">Maximum length of buffer to read</param> /// <param name="guidList">Guid cache to read from</param> /// <param name="tag">Guid tag to lookup</param> /// <param name="guid">Guid of property</param> /// <param name="data">Data of property</param> /// <returns>Length of buffer read</returns> #endif internal static uint DecodeAsISF(Stream stream, uint cbSize, GuidList guidList, KnownTagCache.KnownTagIndex tag, ref Guid guid, out object data) { uint cb, cbRead = 0; uint cbTotal = cbSize; if (0 == cbSize) { throw new InvalidOperationException(SR.Get(SRID.EmptyDataToLoad)); } if (0 == tag) // no tag is passed, it must be embedded in the data { uint uiTag; cb = SerializationHelper.Decode(stream, out uiTag); tag = (KnownTagCache.KnownTagIndex)uiTag; if (cb > cbTotal) { throw new ArgumentException(SR.Get(SRID.InvalidSizeSpecified), "cbSize"); } cbTotal -= cb; cbRead += cb; System.Diagnostics.Debug.Assert(guid == Guid.Empty); guid = guidList.FindGuid(tag); } if (guid == Guid.Empty) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Custom Attribute tag embedded in ISF stream does not match guid table"), "tag"); } // Try and find the size uint size = GuidList.GetDataSizeIfKnownGuid(guid); if (size > cbTotal) { throw new ArgumentException(SR.Get(SRID.InvalidSizeSpecified), "cbSize"); } // if the size is 0 if (0 == size) { // Size must be embedded in the stream. Find out the compressed data size cb = SerializationHelper.Decode(stream, out size); uint cbInsize = size + 1; cbRead += cb; cbTotal -= cb; if (cbInsize > cbTotal) { throw new ArgumentException(); } byte[] bytes = new byte[cbInsize]; uint bytesRead = (uint)stream.Read(bytes, 0, (int)cbInsize); if (cbInsize != bytesRead) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Read different size from stream then expected"), "cbSize"); } cbRead += cbInsize; cbTotal -= cbInsize; //Find out the Decompressed buffer size using (MemoryStream decompressedStream = new MemoryStream(Compressor.DecompressPropertyData(bytes))) { // Add the property data = ExtendedPropertySerializer.DecodeAttribute(guid, decompressedStream); } } else { // For known size data, we just read the data directly from the stream byte[] bytes = new byte[size]; uint bytesRead = (uint)stream.Read(bytes, 0, (int)size); if (size != bytesRead) { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("Read different size from stream then expected"), "cbSize"); } using (MemoryStream subStream = new MemoryStream(bytes)) { data = ExtendedPropertySerializer.DecodeAttribute(guid, subStream); } cbTotal -= size; cbRead += size; } return(cbRead); }