private static void PersistRasterOperation(DrawingAttributes da, Stream stream, GuidList guidList, ref uint cbData, ref BinaryWriter bw) { // write any non-default RasterOp value that we might have picked up from // V1 interop or by setting IsHighlighter. if (da.RasterOperation != DrawingAttributeSerializer.RasterOperationDefaultV1) { uint ropSize = GuidList.GetDataSizeIfKnownGuid(KnownIds.RasterOperation); if (ropSize == 0) { throw new InvalidOperationException(StrokeCollectionSerializer.ISFDebugMessage("ROP data size was not found")); } Debug.Assert(bw != null); cbData += SerializationHelper.Encode(stream, (uint)guidList.FindTag(KnownIds.RasterOperation, true)); long currentPosition = stream.Position; bw.Write(da.RasterOperation); if ((uint)(stream.Position - currentPosition) != ropSize) { throw new InvalidOperationException(StrokeCollectionSerializer.ISFDebugMessage("ROP data was incorrectly serialized")); } cbData += ropSize; } }
/// <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> /// 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> /// Encodes a custom attribute to the ISF stream /// </summary> #endif internal static uint EncodeAsISF(Guid id, byte[] data, Stream strm, GuidList guidList, byte compressionAlgorithm, bool fTag) { uint cbWrite = 0; uint cbSize = GuidList.GetDataSizeIfKnownGuid(id); Debug.Assert(strm != null); if (fTag) { uint uTag = (uint)guidList.FindTag(id, true); cbWrite += SerializationHelper.Encode(strm, uTag); } // If cbSize is 0, it is either a custom property or a known property with 0 // size. In either case, we need to write the size of the individual object if (0 == cbSize) { // Now we need to write the actual data for the property cbSize = (uint)data.Length; byte[] compresseddata = Compressor.CompressPropertyData(data, compressionAlgorithm); #if OLD_ISF byte nAlgo = compressionAlgorithm; uint cbOut = 0; Compressor.CompressPropertyData(data, ref nAlgo, ref cbOut, null); // Allocate a buffer big enough to hold the compressed data byte[] compresseddata2 = new byte[cbOut]; // NativeCompressor the data Compressor.CompressPropertyData(data, ref nAlgo, ref cbOut, compresseddata2); if (compresseddata.Length != compresseddata2.Length) { throw new InvalidOperationException("MAGIC EXCEPTION: Property bytes length when compressed didn't match with new compression"); } for (int i = 0; i < compresseddata.Length; i++) { if (compresseddata[i] != compresseddata2[i]) { throw new InvalidOperationException("MAGIC EXCEPTION: Property data didn't match with new property compression at index " + i.ToString()); } } #endif // write the encoded compressed size minus the algo byte cbWrite += SerializationHelper.Encode(strm, (uint)(compresseddata.Length - 1)); // Write the raw data strm.Write(compresseddata, 0, (int)compresseddata.Length); cbWrite += (uint)compresseddata.Length; } else { // // note that we used to write the nocompression byte, but that // was incorrect. We must not write it because loaders do not // expect it for known guids // // write the algo byte //strm.WriteByte(Compressor.NoCompression); //cbWrite++; // write the raw data without compression strm.Write(data, 0, (int)data.Length); cbWrite += (uint)data.Length; } return(cbWrite); }