public void Save(Stream outputStream) { if (this.iconData != null) { outputStream.Write(this.iconData, 0, this.iconData.Length); } else { SafeNativeMethods.PICTDESC pictdesc = SafeNativeMethods.PICTDESC.CreateIconPICTDESC(this.Handle); Guid gUID = typeof(SafeNativeMethods.IPicture).GUID; SafeNativeMethods.IPicture o = SafeNativeMethods.OleCreatePictureIndirect(pictdesc, ref gUID, false); if (o != null) { try { int num; o.SaveAsFile(new System.Drawing.UnsafeNativeMethods.ComStreamFromDataStream(outputStream), -1, out num); } finally { Marshal.ReleaseComObject(o); } } } }
public void Save(Stream outputStream) { if (_iconData != null) { outputStream.Write(_iconData, 0, _iconData.Length); } else { // Ideally, we would pick apart the icon using // GetIconInfo, and then pull the individual bitmaps out, // converting them to DIBS and saving them into the file. // But, in the interest of simplicity, we just call to // OLE to do it for us. SafeNativeMethods.PICTDESC pictdesc = SafeNativeMethods.PICTDESC.CreateIconPICTDESC(Handle); Guid g = typeof(SafeNativeMethods.IPicture).GUID; SafeNativeMethods.IPicture picture = SafeNativeMethods.OleCreatePictureIndirect(pictdesc, ref g, false); if (picture != null) { try { picture.SaveAsFile(new UnsafeNativeMethods.ComStreamFromDataStream(outputStream), -1, out int temp); } finally { Marshal.ReleaseComObject(picture); } } } }
/// <devdoc> /// Loads an image from a COM stream. This will return a bitmap, icon, /// cursor or metafile object depending on the type of data in the stream. /// </devdoc> unsafe private static Cursor LoadImage(UnsafeNativeMethods.IStream stream) { Cursor cursor = null; SafeNativeMethods.IPicture picture = LoadPicture(stream); if (picture.GetPictureType() == NativeMethods.Ole.PICTYPE_ICON) { // black magic stolen from oleaut. stream.Seek(2, NativeMethods.STREAM_SEEK_SET); byte b = 0; int numRead = stream.Read((IntPtr)(int)&b, 1); Debug.Assert(numRead == 1, "Could read 1 byte from the stream!!!"); if (numRead == 1 && b == 2) { cursor = new Cursor(picture); } // Otherwise, it's really an Icon. } if (cursor != null) { return(cursor); } else { throw new ArgumentException(SR.GetString(SR.InvalidPictureType, "picture", "Cursor"), "stream"); } }
/// <devdoc> /// Initializes this image for the first time. This should only be called once. /// </devdoc> private void Initialize(SafeNativeMethods.IPicture picture) { if (this.picture != null) { throw new InvalidOperationException(SR.GetString(SR.IllegalState, GetType().Name)); } this.picture = picture; // SECUNDONE : Assert shouldn't be needed, however we can't put SuppressUnmanagedCode // : on the IPicture interface, so we must do an Assert. // new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Assert(); try { if (picture != null && picture.GetPictureType() == NativeMethods.Ole.PICTYPE_ICON) { handle = picture.GetHandle(); ownHandle = false; } else { throw new ArgumentException(SR.GetString(SR.InvalidPictureType, "picture", "Cursor"), "picture"); } } finally { CodeAccessPermission.RevertAssert(); } }
/// <include file='doc\COM2PictureConverter.uex' path='docs/doc[@for="Com2PictureConverter.ConvertNativeToManaged"]/*' /> /// <devdoc> /// Converts the native value into a managed value /// </devdoc> public override object ConvertNativeToManaged(object nativeValue, Com2PropertyDescriptor pd) { if (nativeValue == null) { return(null); } Debug.Assert(nativeValue is SafeNativeMethods.IPicture, "nativevalue is not IPicture"); SafeNativeMethods.IPicture nativePicture = (SafeNativeMethods.IPicture)nativeValue; IntPtr handle = nativePicture.GetHandle(); if (lastManaged != null && handle == lastNativeHandle) { return(lastManaged); } lastNativeHandle = handle; //lastPalette = nativePicture.GetHPal(); if (handle != IntPtr.Zero) { switch (nativePicture.GetPictureType()) { case NativeMethods.Ole.PICTYPE_ICON: pictureType = typeof(Icon); lastManaged = Icon.FromHandle(handle); break; case NativeMethods.Ole.PICTYPE_BITMAP: pictureType = typeof(Bitmap); lastManaged = Image.FromHbitmap(handle); break; default: Debug.Fail("Unknown picture type"); break; } pictureRef = new WeakReference(nativePicture); } else { lastManaged = null; pictureRef = null; } return(lastManaged); }
/// <include file='doc\COM2PictureConverter.uex' path='docs/doc[@for="Com2PictureConverter.ConvertManagedToNative"]/*' /> /// <devdoc> /// Converts the managed value into a native value /// </devdoc> public override object ConvertManagedToNative(object managedValue, Com2PropertyDescriptor pd, ref bool cancelSet) { // don't cancel the set cancelSet = false; if (lastManaged != null && lastManaged.Equals(managedValue) && pictureRef != null && pictureRef.IsAlive) { return(pictureRef.Target); } // we have to build an IPicture lastManaged = managedValue; if (managedValue != null) { Guid g = typeof(SafeNativeMethods.IPicture).GUID; NativeMethods.PICTDESC pictdesc = null; bool own = false; if (lastManaged is Icon) { pictdesc = NativeMethods.PICTDESC.CreateIconPICTDESC(((Icon)lastManaged).Handle); } else if (lastManaged is Bitmap) { pictdesc = NativeMethods.PICTDESC.CreateBitmapPICTDESC(((Bitmap)lastManaged).GetHbitmap(), lastPalette); own = true; } else { Debug.Fail("Unknown Image type: " + managedValue.GetType().Name); } SafeNativeMethods.IPicture pict = SafeNativeMethods.OleCreatePictureIndirect(pictdesc, ref g, own); lastNativeHandle = pict.GetHandle(); pictureRef = new WeakReference(pict); return(pict); } else { lastManaged = null; lastNativeHandle = lastPalette = IntPtr.Zero; pictureRef = null; return(null); } }
/// <devdoc> /// Loads a picture from the requested stream. /// </devdoc> private static SafeNativeMethods.IPicture LoadPicture(UnsafeNativeMethods.IStream stream) { SafeNativeMethods.IPicture picture = null; if (stream == null) { throw new ArgumentException(SR.GetString(SR.InvalidArgument, "stream", "null")); } try { Guid g = typeof(SafeNativeMethods.IPicture).GUID; picture = SafeNativeMethods.OleLoadPicture(stream, 0, false, ref g); } catch (Exception e) { Debug.Fail(e.ToString()); throw new ArgumentException(SR.GetString(SR.InvalidPictureFormat), "stream"); } return(picture); }
void Dispose(bool disposing) { if (picture != null) { picture = null; // If we have no message loop, OLE may block on this call. // Let pent up SendMessage calls go through here. // NativeMethods.MSG msg = new NativeMethods.MSG(); UnsafeNativeMethods.PeekMessage(ref msg, NativeMethods.NullHandleRef, 0, 0, NativeMethods.PM_NOREMOVE | NativeMethods.PM_NOYIELD); } if (handle != IntPtr.Zero) { DestroyHandle(); handle = IntPtr.Zero; } }
/// <devdoc> /// <para> /// Initializes a new instance of the <see cref='System.Windows.Forms.Cursor'/> class from a /// COM stream. /// </para> /// </devdoc> private Cursor(SafeNativeMethods.IPicture picture) { Initialize(picture); }