From e4dc65675a728004c86930e72d20e600cb3fc6e9 Mon Sep 17 00:00:00 2001
From: NaBian <836904362@qq.com>
Date: Sun, 25 Nov 2018 16:21:04 +0800
Subject: [PATCH] add GifImage
Currently, there are only a few basic features, and more features will be added in version 2.0
---
HandyControl/Controls/GifImage.cs | 461 ++++++++++++++++++
.../Data/{ => Args}/CancelRoutedEventArgs.cs | 0
.../Data/{ => Args}/FunctionEventArgs!1.cs | 0
HandyControl/Data/Gif/GPStream.cs | 271 ++++++++++
HandyControl/Data/Gif/GifFrameDimension.cs | 29 ++
HandyControl/Data/Gif/GifImageInfo.cs | 97 ++++
HandyControl/Data/Gif/GifPropertyItem.cs | 13 +
.../Data/Gif/GifPropertyItemInternal.cs | 114 +++++
.../Data/{ => Operation}/OperationResult!1.cs | 0
.../Data/{ => Operation}/OperationResult.cs | 0
HandyControl/HandyControl.csproj | 17 +-
HandyControl/Tools/ColorHelper.cs | 13 +
HandyControl/Tools/ExternDllHelper.cs | 332 +++++++++++++
HandyControl/Tools/GifImageAnimator.cs | 271 ++++++++++
HandyControlDemo/Data/MessageToken.cs | 2 +
HandyControlDemo/Data/MessageToken.tt | 3 +-
HandyControlDemo/HandyControlDemo.csproj | 9 +
.../Properties/Langs/Lang.Designer.cs | 11 +-
.../Properties/Langs/Lang.en.resx | 3 +
HandyControlDemo/Properties/Langs/Lang.resx | 3 +
.../Img/LeftMainContent/Animation_16x.png | Bin 0 -> 494 bytes
HandyControlDemo/Resources/Img/car_chase.gif | Bin 0 -> 4689837 bytes
.../UserControl/Controls/GifImageDemoCtl.xaml | 13 +
.../Controls/GifImageDemoCtl.xaml.cs | 17 +
.../UserControl/Main/LeftMainContent.xaml | 5 +
HandyControlDemo/ViewModel/MainViewModel.cs | 9 +-
26 files changed, 1686 insertions(+), 7 deletions(-)
create mode 100644 HandyControl/Controls/GifImage.cs
rename HandyControl/Data/{ => Args}/CancelRoutedEventArgs.cs (100%)
rename HandyControl/Data/{ => Args}/FunctionEventArgs!1.cs (100%)
create mode 100644 HandyControl/Data/Gif/GPStream.cs
create mode 100644 HandyControl/Data/Gif/GifFrameDimension.cs
create mode 100644 HandyControl/Data/Gif/GifImageInfo.cs
create mode 100644 HandyControl/Data/Gif/GifPropertyItem.cs
create mode 100644 HandyControl/Data/Gif/GifPropertyItemInternal.cs
rename HandyControl/Data/{ => Operation}/OperationResult!1.cs (100%)
rename HandyControl/Data/{ => Operation}/OperationResult.cs (100%)
create mode 100644 HandyControl/Tools/ColorHelper.cs
create mode 100644 HandyControl/Tools/ExternDllHelper.cs
create mode 100644 HandyControl/Tools/GifImageAnimator.cs
create mode 100644 HandyControlDemo/Resources/Img/LeftMainContent/Animation_16x.png
create mode 100644 HandyControlDemo/Resources/Img/car_chase.gif
create mode 100644 HandyControlDemo/UserControl/Controls/GifImageDemoCtl.xaml
create mode 100644 HandyControlDemo/UserControl/Controls/GifImageDemoCtl.xaml.cs
diff --git a/HandyControl/Controls/GifImage.cs b/HandyControl/Controls/GifImage.cs
new file mode 100644
index 00000000..9c7a91de
--- /dev/null
+++ b/HandyControl/Controls/GifImage.cs
@@ -0,0 +1,461 @@
+using System;
+using System.ComponentModel;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+using System.Security.Permissions;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Interop;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Resources;
+using HandyControl.Data;
+using HandyControl.Tools;
+
+namespace HandyControl.Controls
+{
+ public class GifImage : Image, IDisposable
+ {
+ private static readonly Guid GifGuid = new Guid("{b96b3caa-0728-11d3-9d7b-0000f81ef32e}");
+
+ internal IntPtr NativeImage;
+
+ private byte[] _rawData;
+
+ private bool _isStart;
+
+ private bool _isLoaded;
+
+ static GifImage()
+ {
+ VisibilityProperty.OverrideMetadata(typeof(GifImage), new PropertyMetadata(default(Visibility), OnVisibilityChanged));
+ }
+
+ private static void OnVisibilityChanged(DependencyObject s, DependencyPropertyChangedEventArgs e)
+ {
+ var ctl = (GifImage)s;
+ var v = (Visibility)e.NewValue;
+ if (v != Visibility.Visible)
+ {
+ ctl.StopAnimate();
+ }
+ else if (!ctl._isStart)
+ {
+ ctl.StartAnimate();
+ }
+ }
+
+ ~GifImage() => Dispose(false);
+
+ public GifImage()
+ {
+ Loaded += (s, e) =>
+ {
+ if (DesignerProperties.GetIsInDesignMode(this)) return;
+ if (_isLoaded) return;
+ _isLoaded = true;
+ if (Source is BitmapImage image)
+ {
+ var uri = image.UriSource;
+ GetGifStreamFromPack(uri);
+ StartAnimate();
+ }
+ };
+ }
+
+ public GifImage(string filename)
+ {
+ Source = null;
+ CreateSourceFromFile(filename);
+ StartAnimate();
+ }
+
+ public GifImage(Stream stream)
+ {
+ Source = null;
+ CreateSourceFromStream(stream);
+ StartAnimate();
+ }
+
+ public void Dispose()
+ {
+ Dispose(true);
+ GC.SuppressFinalize(this);
+ }
+
+ protected virtual void Dispose(bool disposing)
+ {
+ if (NativeImage == IntPtr.Zero) return;
+ try
+ {
+ StopAnimate();
+ ExternDllHelper.Gdip.GdipDisposeImage(new HandleRef(this, NativeImage));
+ }
+ catch
+ {
+ // ignored
+ }
+ finally
+ {
+ NativeImage = IntPtr.Zero;
+ }
+ }
+
+ private void CreateSourceFromFile(string filename)
+ {
+ filename = Path.GetFullPath(filename);
+
+ var status = ExternDllHelper.Gdip.GdipCreateBitmapFromFile(filename, out var bitmap);
+
+ if (status != ExternDllHelper.Gdip.Ok)
+ throw ExternDllHelper.Gdip.StatusException(status);
+
+ status = ExternDllHelper.Gdip.GdipImageForceValidation(new HandleRef(null, bitmap));
+
+ if (status != ExternDllHelper.Gdip.Ok)
+ {
+ ExternDllHelper.Gdip.GdipDisposeImage(new HandleRef(null, bitmap));
+ throw ExternDllHelper.Gdip.StatusException(status);
+ }
+
+ SetNativeImage(bitmap);
+
+ EnsureSave(this, filename, null);
+ }
+
+ private void CreateSourceFromStream(Stream stream)
+ {
+ if (stream == null)
+ throw new ArgumentException("stream null");
+
+ var status = ExternDllHelper.Gdip.GdipCreateBitmapFromStream(new GPStream(stream), out var bitmap);
+
+ if (status != ExternDllHelper.Gdip.Ok)
+ throw ExternDllHelper.Gdip.StatusException(status);
+
+ status = ExternDllHelper.Gdip.GdipImageForceValidation(new HandleRef(null, bitmap));
+
+ if (status != ExternDllHelper.Gdip.Ok)
+ {
+ ExternDllHelper.Gdip.GdipDisposeImage(new HandleRef(null, bitmap));
+ throw ExternDllHelper.Gdip.StatusException(status);
+ }
+
+ SetNativeImage(bitmap);
+
+ EnsureSave(this, null, stream);
+ }
+
+ private void GetGifStreamFromPack(Uri uri)
+ {
+ try
+ {
+ StreamResourceInfo streamInfo;
+
+ if (!uri.IsAbsoluteUri)
+ {
+ streamInfo = Application.GetContentStream(uri) ?? Application.GetResourceStream(uri);
+ }
+ else
+ {
+ if (uri.GetLeftPart(UriPartial.Authority).Contains("siteoforigin"))
+ {
+ streamInfo = Application.GetRemoteStream(uri);
+ }
+ else
+ {
+ streamInfo = Application.GetContentStream(uri) ?? Application.GetResourceStream(uri);
+ }
+ }
+ if (streamInfo == null)
+ throw new FileNotFoundException("Resource not found.", uri.ToString());
+ CreateSourceFromStream(streamInfo.Stream);
+ }
+ catch
+ {
+ // ignored
+ }
+ }
+
+ [ResourceExposure(ResourceScope.None)]
+ [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
+ internal static void EnsureSave(GifImage image, string filename, Stream dataStream)
+ {
+ if (!image.RawGuid.Equals(GifGuid)) return;
+ var animatedGif = false;
+
+ var dimensions = image.FrameDimensionsList;
+ if (dimensions.Select(guid => new GifFrameDimension(guid)).Contains(GifFrameDimension.Time))
+ {
+ animatedGif = image.GetFrameCount(GifFrameDimension.Time) > 1;
+ }
+
+ if (!animatedGif) return;
+
+ try
+ {
+ Stream created = null;
+ long lastPos = 0;
+ if (dataStream != null)
+ {
+ lastPos = dataStream.Position;
+ dataStream.Position = 0;
+ }
+
+ try
+ {
+ if (dataStream == null)
+ {
+ created = dataStream = File.OpenRead(filename);
+ }
+
+ image._rawData = new byte[(int)dataStream.Length];
+ dataStream.Read(image._rawData, 0, (int)dataStream.Length);
+ }
+ finally
+ {
+ if (created != null)
+ {
+ created.Close();
+ }
+ else
+ {
+ // ReSharper disable once PossibleNullReferenceException
+ dataStream.Position = lastPos;
+ }
+ }
+ }
+ // possible exceptions for reading the filename
+ catch (UnauthorizedAccessException)
+ {
+ }
+ catch (DirectoryNotFoundException)
+ {
+ }
+ catch (IOException)
+ {
+ }
+ // possible exceptions for setting/getting the position inside dataStream
+ catch (NotSupportedException)
+ {
+ }
+ catch (ObjectDisposedException)
+ {
+ }
+ // possible exception when reading stuff into dataStream
+ catch (ArgumentException)
+ {
+ }
+ }
+
+ internal void SetNativeImage(IntPtr handle)
+ {
+ if (handle == IntPtr.Zero)
+ throw new ArgumentException("NativeHandle0");
+
+ NativeImage = handle;
+ }
+
+ internal Guid RawGuid
+ {
+ get
+ {
+ var guid = new Guid();
+
+ var status = ExternDllHelper.Gdip.GdipGetImageRawFormat(new HandleRef(this, NativeImage), ref guid);
+
+ if (status != ExternDllHelper.Gdip.Ok)
+ throw ExternDllHelper.Gdip.StatusException(status);
+
+ return guid;
+ }
+ }
+
+ internal void StartAnimate()
+ {
+ ImageAnimator.Animate(this, OnFrameChanged);
+ _isStart = true;
+ }
+
+ internal void StopAnimate()
+ {
+ ImageAnimator.StopAnimate(this, OnFrameChanged);
+ _isStart = false;
+ }
+
+ internal Guid[] FrameDimensionsList
+ {
+ get
+ {
+ var status = ExternDllHelper.Gdip.GdipImageGetFrameDimensionsCount(new HandleRef(this, NativeImage), out var count);
+
+ if (status != ExternDllHelper.Gdip.Ok)
+ {
+ throw ExternDllHelper.Gdip.StatusException(status);
+ }
+
+ if (count <= 0)
+ {
+ return new Guid[0];
+ }
+
+ var size = Marshal.SizeOf(typeof(Guid));
+
+ var buffer = Marshal.AllocHGlobal(checked(size * count));
+ if (buffer == IntPtr.Zero)
+ {
+ throw ExternDllHelper.Gdip.StatusException(ExternDllHelper.Gdip.OutOfMemory);
+ }
+
+ status = ExternDllHelper.Gdip.GdipImageGetFrameDimensionsList(new HandleRef(this, NativeImage), buffer, count);
+
+ if (status != ExternDllHelper.Gdip.Ok)
+ {
+ Marshal.FreeHGlobal(buffer);
+ throw ExternDllHelper.Gdip.StatusException(status);
+ }
+
+ var guids = new Guid[count];
+
+ try
+ {
+ for (int i = 0; i < count; i++)
+ {
+ guids[i] = (Guid)ExternDllHelper.PtrToStructure((IntPtr)((long)buffer + size * i), typeof(Guid));
+ }
+ }
+ finally
+ {
+ Marshal.FreeHGlobal(buffer);
+ }
+
+ return guids;
+ }
+ }
+
+ internal int GetFrameCount(GifFrameDimension dimension)
+ {
+ var count = new[] { 0 };
+
+ var dimensionId = dimension.Guid;
+ var status = ExternDllHelper.Gdip.GdipImageGetFrameCount(new HandleRef(this, NativeImage), ref dimensionId, count);
+
+ if (status != ExternDllHelper.Gdip.Ok)
+ throw ExternDllHelper.Gdip.StatusException(status);
+
+ return count[0];
+ }
+
+ internal GifPropertyItem GetPropertyItem(int propid)
+ {
+ GifPropertyItem propitem;
+
+ var status = ExternDllHelper.Gdip.GdipGetPropertyItemSize(new HandleRef(this, NativeImage), propid, out var size);
+
+ if (status != ExternDllHelper.Gdip.Ok)
+ throw ExternDllHelper.Gdip.StatusException(status);
+
+ if (size == 0)
+ return null;
+
+ var propdata = Marshal.AllocHGlobal(size);
+
+ if (propdata == IntPtr.Zero)
+ throw ExternDllHelper.Gdip.StatusException(ExternDllHelper.Gdip.OutOfMemory);
+
+ status = ExternDllHelper.Gdip.GdipGetPropertyItem(new HandleRef(this, NativeImage), propid, size, propdata);
+
+ try
+ {
+ if (status != ExternDllHelper.Gdip.Ok)
+ {
+ throw ExternDllHelper.Gdip.StatusException(status);
+ }
+
+ propitem = GifPropertyItemInternal.ConvertFromMemory(propdata, 1)[0];
+ }
+ finally
+ {
+ Marshal.FreeHGlobal(propdata);
+ }
+
+ return propitem;
+ }
+
+ internal int SelectActiveFrame(GifFrameDimension dimension, int frameIndex)
+ {
+ var count = new[] { 0 };
+
+ var dimensionId = dimension.Guid;
+ var status = ExternDllHelper.Gdip.GdipImageSelectActiveFrame(new HandleRef(this, NativeImage), ref dimensionId, frameIndex);
+
+ if (status != ExternDllHelper.Gdip.Ok)
+ throw ExternDllHelper.Gdip.StatusException(status);
+
+ return count[0];
+ }
+
+ [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+ [ResourceExposure(ResourceScope.Machine)]
+ [ResourceConsumption(ResourceScope.Machine)]
+ internal IntPtr GetHbitmap() => GetHbitmap(Colors.LightGray);
+
+ [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+ [ResourceExposure(ResourceScope.Machine)]
+ [ResourceConsumption(ResourceScope.Machine)]
+ internal IntPtr GetHbitmap(Color background)
+ {
+ var status = ExternDllHelper.Gdip.GdipCreateHBITMAPFromBitmap(new HandleRef(this, NativeImage), out var hBitmap,
+ ColorHelper.ToWin32(background));
+ if (status == 2 && (Width >= short.MaxValue || Height >= short.MaxValue))
+ {
+ throw new ArgumentException("GdiplusInvalidSize");
+ }
+
+ if (status != ExternDllHelper.Gdip.Ok && NativeImage != IntPtr.Zero)
+ {
+ throw ExternDllHelper.Gdip.StatusException(status);
+ }
+
+ return hBitmap;
+ }
+
+ private void GetBitmapSource()
+ {
+ var handle = IntPtr.Zero;
+
+ try
+ {
+ handle = GetHbitmap();
+ Source = Imaging.CreateBitmapSourceFromHBitmap(handle, IntPtr.Zero, Int32Rect.Empty,
+ BitmapSizeOptions.FromEmptyOptions());
+ }
+ catch
+ {
+ // ignored
+ }
+ finally
+ {
+ if (handle != IntPtr.Zero)
+ {
+ ExternDllHelper.DeleteObject(handle);
+ }
+ }
+ }
+
+ private void OnFrameChanged(object sender, EventArgs e)
+ {
+ Dispatcher.BeginInvoke(new Action(() =>
+ {
+ ImageAnimator.UpdateFrames();
+ Source?.Freeze();
+ GetBitmapSource();
+ InvalidateVisual();
+ }));
+ }
+ }
+}
\ No newline at end of file
diff --git a/HandyControl/Data/CancelRoutedEventArgs.cs b/HandyControl/Data/Args/CancelRoutedEventArgs.cs
similarity index 100%
rename from HandyControl/Data/CancelRoutedEventArgs.cs
rename to HandyControl/Data/Args/CancelRoutedEventArgs.cs
diff --git a/HandyControl/Data/FunctionEventArgs!1.cs b/HandyControl/Data/Args/FunctionEventArgs!1.cs
similarity index 100%
rename from HandyControl/Data/FunctionEventArgs!1.cs
rename to HandyControl/Data/Args/FunctionEventArgs!1.cs
diff --git a/HandyControl/Data/Gif/GPStream.cs b/HandyControl/Data/Gif/GPStream.cs
new file mode 100644
index 00000000..4374b4f6
--- /dev/null
+++ b/HandyControl/Data/Gif/GPStream.cs
@@ -0,0 +1,271 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Security.Permissions;
+using HandyControl.Tools;
+
+namespace HandyControl.Data
+{
+ // ReSharper disable once InconsistentNaming
+ internal class GPStream : ExternDllHelper.IStream
+ {
+ protected Stream DataStream;
+
+ // to support seeking ahead of the stream length...
+ long _virtualPosition = -1;
+
+ internal GPStream(Stream stream)
+ {
+ if (!stream.CanSeek)
+ {
+ const int readBlock = 256;
+ var bytes = new byte[readBlock];
+ int readLen;
+ var current = 0;
+ do
+ {
+ if (bytes.Length < current + readBlock)
+ {
+ var newData = new byte[bytes.Length * 2];
+ Array.Copy(bytes, newData, bytes.Length);
+ bytes = newData;
+ }
+ readLen = stream.Read(bytes, current, readBlock);
+ current += readLen;
+ } while (readLen != 0);
+
+ DataStream = new MemoryStream(bytes);
+ }
+ else
+ {
+ DataStream = stream;
+ }
+ }
+
+ private void ActualizeVirtualPosition()
+ {
+ if (_virtualPosition == -1) return;
+
+ if (_virtualPosition > DataStream.Length)
+ DataStream.SetLength(_virtualPosition);
+
+ DataStream.Position = _virtualPosition;
+
+ _virtualPosition = -1;
+ }
+
+ public virtual ExternDllHelper.IStream Clone()
+ {
+ NotImplemented();
+ return null;
+ }
+
+ public virtual void Commit(int grfCommitFlags)
+ {
+ DataStream.Flush();
+ // Extend the length of the file if needed.
+ ActualizeVirtualPosition();
+ }
+
+ [
+ UIPermission(SecurityAction.Demand, Window = UIPermissionWindow.AllWindows),
+ SecurityPermission(SecurityAction.Assert, Flags = SecurityPermissionFlag.UnmanagedCode)
+ ]
+ public virtual long CopyTo(ExternDllHelper.IStream pstm, long cb, long[] pcbRead)
+ {
+
+ const int bufsize = 4096;
+ var buffer = Marshal.AllocHGlobal(bufsize);
+ if (buffer == IntPtr.Zero) throw new OutOfMemoryException();
+ long written = 0;
+ try
+ {
+ while (written < cb)
+ {
+ var toRead = bufsize;
+ if (written + toRead > cb) toRead = (int)(cb - written);
+ var read = Read(buffer, toRead);
+ if (read == 0) break;
+ if (pstm.Write(buffer, read) != read)
+ {
+ throw EFail("Wrote an incorrect number of bytes");
+ }
+ written += read;
+ }
+ }
+ finally
+ {
+ Marshal.FreeHGlobal(buffer);
+ }
+ if (pcbRead != null && pcbRead.Length > 0)
+ {
+ pcbRead[0] = written;
+ }
+
+ return written;
+ }
+
+ public virtual Stream GetDataStream()
+ {
+ return DataStream;
+ }
+
+ public virtual void LockRegion(long libOffset, long cb, int dwLockType)
+ {
+ }
+
+ protected static ExternalException EFail(string msg)
+ {
+ throw new ExternalException(msg, ExternDllHelper.E_FAIL);
+ }
+
+ protected static void NotImplemented()
+ {
+ throw new ExternalException("NotImplemented");
+ }
+
+ public virtual int Read(IntPtr buf, int length)
+ {
+ var buffer = new byte[length];
+ var count = Read(buffer, length);
+ Marshal.Copy(buffer, 0, buf, length);
+ return count;
+ }
+
+ public virtual int Read(byte[] buffer, int length)
+ {
+ ActualizeVirtualPosition();
+ return DataStream.Read(buffer, 0, length);
+ }
+
+ public virtual void Revert()
+ {
+ NotImplemented();
+ }
+
+ public virtual long Seek(long offset, int origin)
+ {
+ var pos = _virtualPosition;
+ if (_virtualPosition == -1)
+ {
+ pos = DataStream.Position;
+ }
+ var len = DataStream.Length;
+ switch (origin)
+ {
+ case ExternDllHelper.StreamConsts.STREAM_SEEK_SET:
+ if (offset <= len)
+ {
+ DataStream.Position = offset;
+ _virtualPosition = -1;
+ }
+ else
+ {
+ _virtualPosition = offset;
+ }
+ break;
+ case ExternDllHelper.StreamConsts.STREAM_SEEK_END:
+ if (offset <= 0)
+ {
+ DataStream.Position = len + offset;
+ _virtualPosition = -1;
+ }
+ else
+ {
+ _virtualPosition = len + offset;
+ }
+ break;
+ case ExternDllHelper.StreamConsts.STREAM_SEEK_CUR:
+ if (offset + pos <= len)
+ {
+ DataStream.Position = pos + offset;
+ _virtualPosition = -1;
+ }
+ else
+ {
+ _virtualPosition = offset + pos;
+ }
+ break;
+ }
+ return _virtualPosition != -1 ? _virtualPosition : DataStream.Position;
+ }
+
+ public virtual void SetSize(long value)
+ {
+ DataStream.SetLength(value);
+ }
+
+ public void Stat(IntPtr pstatstg, int grfStatFlag)
+ {
+ var stats = new STATSTG {cbSize = DataStream.Length};
+ Marshal.StructureToPtr(stats, pstatstg, true);
+ }
+
+ public virtual void UnlockRegion(long libOffset, long cb, int dwLockType)
+ {
+ }
+
+ public virtual int Write(IntPtr buf, int length)
+ {
+ var buffer = new byte[length];
+ Marshal.Copy(buf, buffer, 0, length);
+ return Write(buffer, length);
+ }
+
+ public virtual int Write(byte[] buffer, int length)
+ {
+ ActualizeVirtualPosition();
+ DataStream.Write(buffer, 0, length);
+ return length;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ [SuppressMessage("ReSharper", "InconsistentNaming")]
+ public class STATSTG
+ {
+
+ [SuppressMessage("Microsoft.Reliability", "CA2006:UseSafeHandleToEncapsulateNativeResources")]
+ public IntPtr pwcsName = IntPtr.Zero;
+ public int type;
+ [MarshalAs(UnmanagedType.I8)]
+ public long cbSize;
+ [MarshalAs(UnmanagedType.I8)]
+ public long mtime;
+ [MarshalAs(UnmanagedType.I8)]
+ public long ctime;
+ [MarshalAs(UnmanagedType.I8)]
+ public long atime;
+ [MarshalAs(UnmanagedType.I4)]
+ public int grfMode;
+ [MarshalAs(UnmanagedType.I4)]
+ public int grfLocksSupported;
+
+ public int clsid_data1;
+ [MarshalAs(UnmanagedType.I2)]
+ public short clsid_data2;
+ [MarshalAs(UnmanagedType.I2)]
+ public short clsid_data3;
+ [MarshalAs(UnmanagedType.U1)]
+ public byte clsid_b0;
+ [MarshalAs(UnmanagedType.U1)]
+ public byte clsid_b1;
+ [MarshalAs(UnmanagedType.U1)]
+ public byte clsid_b2;
+ [MarshalAs(UnmanagedType.U1)]
+ public byte clsid_b3;
+ [MarshalAs(UnmanagedType.U1)]
+ public byte clsid_b4;
+ [MarshalAs(UnmanagedType.U1)]
+ public byte clsid_b5;
+ [MarshalAs(UnmanagedType.U1)]
+ public byte clsid_b6;
+ [MarshalAs(UnmanagedType.U1)]
+ public byte clsid_b7;
+ [MarshalAs(UnmanagedType.I4)]
+ public int grfStateBits;
+ [MarshalAs(UnmanagedType.I4)]
+ public int reserved;
+ }
+ }
+}
\ No newline at end of file
diff --git a/HandyControl/Data/Gif/GifFrameDimension.cs b/HandyControl/Data/Gif/GifFrameDimension.cs
new file mode 100644
index 00000000..cc2a6366
--- /dev/null
+++ b/HandyControl/Data/Gif/GifFrameDimension.cs
@@ -0,0 +1,29 @@
+using System;
+
+namespace HandyControl.Data
+{
+ internal class GifFrameDimension
+ {
+ public GifFrameDimension(Guid guid) => Guid = guid;
+
+ public Guid Guid { get; }
+
+ public static GifFrameDimension Time { get; } = new GifFrameDimension(new Guid("{6aedbd6d-3fb5-418a-83a6-7f45229dc872}"));
+
+ public static GifFrameDimension Resolution { get; } = new GifFrameDimension(new Guid("{84236f7b-3bd3-428f-8dab-4ea1439ca315}"));
+
+ public static GifFrameDimension Page { get; } = new GifFrameDimension(new Guid("{7462dc86-6180-4c7e-8e3f-ee7333a7a483}"));
+
+ public override bool Equals(object o) => o is GifFrameDimension format && Guid == format.Guid;
+
+ public override int GetHashCode() => Guid.GetHashCode();
+
+ public override string ToString()
+ {
+ if (Equals(this, Time)) return "Time";
+ if (Equals(this, Resolution)) return "Resolution";
+ if (Equals(this, Page)) return "Page";
+ return "[FrameDimension: " + Guid + "]";
+ }
+ }
+}
\ No newline at end of file
diff --git a/HandyControl/Data/Gif/GifImageInfo.cs b/HandyControl/Data/Gif/GifImageInfo.cs
new file mode 100644
index 00000000..6a786fec
--- /dev/null
+++ b/HandyControl/Data/Gif/GifImageInfo.cs
@@ -0,0 +1,97 @@
+using System;
+using HandyControl.Controls;
+
+namespace HandyControl.Data
+{
+ public class GifImageInfo
+ {
+ private const int PropertyTagFrameDelay = 0x5100;
+
+ private int _frame;
+
+ private readonly int[] _frameDelay;
+
+ public int FrameCount { get; }
+
+ internal GifImage Image { get; }
+
+ public bool Animated { get; }
+
+ public EventHandler FrameChangedHandler { get; set; }
+
+ internal int FrameTimer { get; set; }
+
+ public bool FrameDirty { get; private set; }
+
+ public int Frame
+ {
+ get => _frame;
+ set
+ {
+ if (_frame != value)
+ {
+ if (value < 0 || value >= FrameCount)
+ {
+ throw new ArgumentException("InvalidFrame");
+ }
+
+ if (Animated)
+ {
+ _frame = value;
+ FrameDirty = true;
+
+ OnFrameChanged(EventArgs.Empty);
+ }
+ }
+ }
+ }
+
+ public GifImageInfo(GifImage image)
+ {
+ Image = image;
+ Animated = ImageAnimator.CanAnimate(image);
+
+ if (Animated)
+ {
+ FrameCount = image.GetFrameCount(GifFrameDimension.Time);
+
+ var frameDelayItem = image.GetPropertyItem(PropertyTagFrameDelay);
+
+ // If the image does not have a frame delay, we just return 0.
+ //
+ if (frameDelayItem != null)
+ {
+ // Convert the frame delay from byte[] to int
+ //
+ var values = frameDelayItem.Value;
+ _frameDelay = new int[FrameCount];
+ for (int i = 0; i < FrameCount; ++i)
+ {
+ _frameDelay[i] = values[i * 4] + 256 * values[i * 4 + 1] + 256 * 256 * values[i * 4 + 2] + 256 * 256 * 256 * values[i * 4 + 3];
+ }
+ }
+ }
+ else
+ {
+ FrameCount = 1;
+ }
+ if (_frameDelay == null)
+ {
+ _frameDelay = new int[FrameCount];
+ }
+ }
+
+ public int FrameDelay(int frame) => _frameDelay[frame];
+
+ internal void UpdateFrame()
+ {
+ if (FrameDirty)
+ {
+ Image.SelectActiveFrame(GifFrameDimension.Time, Frame);
+ FrameDirty = false;
+ }
+ }
+
+ protected void OnFrameChanged(EventArgs e) => FrameChangedHandler?.Invoke(Image, e);
+ }
+}
\ No newline at end of file
diff --git a/HandyControl/Data/Gif/GifPropertyItem.cs b/HandyControl/Data/Gif/GifPropertyItem.cs
new file mode 100644
index 00000000..e6061635
--- /dev/null
+++ b/HandyControl/Data/Gif/GifPropertyItem.cs
@@ -0,0 +1,13 @@
+namespace HandyControl.Data
+{
+ public class GifPropertyItem
+ {
+ public int Id { get; set; }
+
+ public int Len { get; set; }
+
+ public short Type { get; set; }
+
+ public byte[] Value { get; set; }
+ }
+}
\ No newline at end of file
diff --git a/HandyControl/Data/Gif/GifPropertyItemInternal.cs b/HandyControl/Data/Gif/GifPropertyItemInternal.cs
new file mode 100644
index 00000000..c2643091
--- /dev/null
+++ b/HandyControl/Data/Gif/GifPropertyItemInternal.cs
@@ -0,0 +1,114 @@
+using System;
+using System.Runtime.InteropServices;
+using HandyControl.Tools;
+
+namespace HandyControl.Data
+{
+ [StructLayout(LayoutKind.Sequential)]
+ public class GifPropertyItemInternal : IDisposable
+ {
+ public int id;
+ public int len;
+ public short type;
+ public IntPtr value = IntPtr.Zero;
+
+ internal GifPropertyItemInternal()
+ {
+ }
+
+ public byte[] Value
+ {
+ get
+ {
+ if (len == 0)
+ return null;
+
+ var bytes = new byte[len];
+
+ Marshal.Copy(value,
+ bytes,
+ 0,
+ len);
+ return bytes;
+ }
+ }
+
+ public void Dispose()
+ {
+ Dispose(true);
+ }
+
+ ~GifPropertyItemInternal()
+ {
+ Dispose(false);
+ }
+
+ private void Dispose(bool disposing)
+ {
+ if (value != IntPtr.Zero)
+ {
+ Marshal.FreeHGlobal(value);
+ value = IntPtr.Zero;
+ }
+
+ if (disposing)
+ GC.SuppressFinalize(this);
+ }
+
+ internal static GifPropertyItemInternal ConvertFromPropertyItem(GifPropertyItem propItem)
+ {
+ var propItemInternal = new GifPropertyItemInternal
+ {
+ id = propItem.Id,
+ len = 0,
+ type = propItem.Type
+ };
+
+ var propItemValue = propItem.Value;
+ if (propItemValue != null)
+ {
+ var length = propItemValue.Length;
+ propItemInternal.len = length;
+ propItemInternal.value = Marshal.AllocHGlobal(length);
+ Marshal.Copy(propItemValue, 0, propItemInternal.value, length);
+ }
+
+ return propItemInternal;
+ }
+
+ internal static GifPropertyItem[] ConvertFromMemory(IntPtr propdata, int count)
+ {
+ var props = new GifPropertyItem[count];
+
+ for (var i = 0; i < count; i++)
+ {
+ GifPropertyItemInternal propcopy = null;
+ try
+ {
+ propcopy = (GifPropertyItemInternal) ExternDllHelper.PtrToStructure(propdata,
+ typeof(GifPropertyItemInternal));
+
+ props[i] = new GifPropertyItem
+ {
+ Id = propcopy.id,
+ Len = propcopy.len,
+ Type = propcopy.type,
+ Value = propcopy.Value
+ };
+
+ // this calls Marshal.Copy and creates a copy of the original memory into a byte array.
+
+ propcopy.value = IntPtr.Zero; // we dont actually own this memory so dont free it.
+ }
+ finally
+ {
+ propcopy?.Dispose();
+ }
+
+ propdata = (IntPtr) ((long) propdata + Marshal.SizeOf(typeof(GifPropertyItemInternal)));
+ }
+
+ return props;
+ }
+ }
+}
\ No newline at end of file
diff --git a/HandyControl/Data/OperationResult!1.cs b/HandyControl/Data/Operation/OperationResult!1.cs
similarity index 100%
rename from HandyControl/Data/OperationResult!1.cs
rename to HandyControl/Data/Operation/OperationResult!1.cs
diff --git a/HandyControl/Data/OperationResult.cs b/HandyControl/Data/Operation/OperationResult.cs
similarity index 100%
rename from HandyControl/Data/OperationResult.cs
rename to HandyControl/Data/Operation/OperationResult.cs
diff --git a/HandyControl/HandyControl.csproj b/HandyControl/HandyControl.csproj
index 9f9179d0..9f632c61 100644
--- a/HandyControl/HandyControl.csproj
+++ b/HandyControl/HandyControl.csproj
@@ -49,6 +49,7 @@
+
@@ -78,15 +79,22 @@
-
+
+
+
+
+
+
+
+
-
-
+
+
True
True
@@ -124,6 +132,7 @@
+
@@ -141,7 +150,7 @@
-
+
diff --git a/HandyControl/Tools/ColorHelper.cs b/HandyControl/Tools/ColorHelper.cs
new file mode 100644
index 00000000..6163f7bc
--- /dev/null
+++ b/HandyControl/Tools/ColorHelper.cs
@@ -0,0 +1,13 @@
+using System.Windows.Media;
+
+namespace HandyControl.Tools
+{
+ public class ColorHelper
+ {
+ private const int Win32RedShift = 0;
+ private const int Win32GreenShift = 8;
+ private const int Win32BlueShift = 16;
+
+ public static int ToWin32(Color c) => c.R << Win32RedShift | c.G << Win32GreenShift | c.B << Win32BlueShift;
+ }
+}
\ No newline at end of file
diff --git a/HandyControl/Tools/ExternDllHelper.cs b/HandyControl/Tools/ExternDllHelper.cs
new file mode 100644
index 00000000..c1e327ea
--- /dev/null
+++ b/HandyControl/Tools/ExternDllHelper.cs
@@ -0,0 +1,332 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.ConstrainedExecution;
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+using System.Security.Permissions;
+using System.Threading;
+
+namespace HandyControl.Tools
+{
+ internal class ExternDllHelper
+ {
+ private const string Gdi32 = "gdi32.dll";
+
+ // ReSharper disable once InconsistentNaming
+ public const int E_FAIL = unchecked((int) 0x80004005);
+
+ [ReflectionPermission(SecurityAction.Assert, Unrestricted = true), SecurityPermission(SecurityAction.Assert, Flags = SecurityPermissionFlag.UnmanagedCode)]
+ public static object PtrToStructure(IntPtr lparam, Type cls) => Marshal.PtrToStructure(lparam, cls);
+
+ [DllImport(Gdi32, CharSet = CharSet.Auto, SetLastError = true)]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ public static extern bool DeleteObject(IntPtr hObject);
+
+ [ComImport, Guid("0000000C-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+ public interface IStream
+ {
+ int Read(
+ [In]
+ IntPtr buf,
+ [In]
+ int len);
+
+
+ int Write(
+ [In]
+ IntPtr buf,
+ [In]
+ int len);
+
+ [return: MarshalAs(UnmanagedType.I8)]
+ long Seek(
+ [In, MarshalAs(UnmanagedType.I8)]
+ long dlibMove,
+ [In]
+ int dwOrigin);
+
+
+ void SetSize(
+ [In, MarshalAs(UnmanagedType.I8)]
+ long libNewSize);
+
+ [return: MarshalAs(UnmanagedType.I8)]
+ long CopyTo(
+ [In, MarshalAs(UnmanagedType.Interface)]
+ IStream pstm,
+ [In, MarshalAs(UnmanagedType.I8)]
+ long cb,
+ [Out, MarshalAs(UnmanagedType.LPArray)]
+ long[] pcbRead);
+
+
+ void Commit(
+ [In]
+ int grfCommitFlags);
+
+
+ void Revert();
+
+
+ void LockRegion(
+ [In, MarshalAs(UnmanagedType.I8)]
+ long libOffset,
+ [In, MarshalAs(UnmanagedType.I8)]
+ long cb,
+ [In]
+ int dwLockType);
+
+
+ void UnlockRegion(
+ [In, MarshalAs(UnmanagedType.I8)]
+ long libOffset,
+ [In, MarshalAs(UnmanagedType.I8)]
+ long cb,
+ [In]
+ int dwLockType);
+
+
+ void Stat(
+ [In]
+ IntPtr pStatstg,
+ [In]
+ int grfStatFlag);
+
+ [return: MarshalAs(UnmanagedType.Interface)]
+ IStream Clone();
+ }
+
+ [SuppressMessage("ReSharper", "InconsistentNaming")]
+ public class StreamConsts
+ {
+ public const int LOCK_WRITE = 0x1;
+ public const int LOCK_EXCLUSIVE = 0x2;
+ public const int LOCK_ONLYONCE = 0x4;
+ public const int STATFLAG_DEFAULT = 0x0;
+ public const int STATFLAG_NONAME = 0x1;
+ public const int STATFLAG_NOOPEN = 0x2;
+ public const int STGC_DEFAULT = 0x0;
+ public const int STGC_OVERWRITE = 0x1;
+ public const int STGC_ONLYIFCURRENT = 0x2;
+ public const int STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE = 0x4;
+ public const int STREAM_SEEK_SET = 0x0;
+ public const int STREAM_SEEK_CUR = 0x1;
+ public const int STREAM_SEEK_END = 0x2;
+ }
+
+ internal class Gdip
+ {
+ private const string Gdiplus = "gdiplus.dll";
+
+ private const string ThreadDataSlotName = "system.drawing.threaddata";
+
+ private static IntPtr InitToken;
+
+ private static bool Initialized => InitToken != IntPtr.Zero;
+
+ static Gdip()
+ {
+ Initialize();
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ private struct StartupInput
+ {
+ private int GdiplusVersion;
+
+ private readonly IntPtr DebugEventCallback;
+
+ private bool SuppressBackgroundThread;
+
+ private bool SuppressExternalCodecs;
+
+ public static StartupInput GetDefault()
+ {
+ var result = new StartupInput
+ {
+ GdiplusVersion = 1,
+ SuppressBackgroundThread = false,
+ SuppressExternalCodecs = false
+ };
+ return result;
+ }
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ private struct StartupOutput
+ {
+ private readonly IntPtr hook;
+
+ private readonly IntPtr unhook;
+ }
+
+ [ResourceExposure(ResourceScope.None)]
+ [ResourceConsumption(ResourceScope.AppDomain, ResourceScope.AppDomain)]
+ [SuppressMessage("Microsoft.Performance", "CA1804:RemoveUnusedLocals")]
+ private static void Initialize()
+ {
+ var input = StartupInput.GetDefault();
+
+ var status = GdiplusStartup(out InitToken, ref input, out _);
+
+ if (status != Ok)
+ {
+ throw StatusException(status);
+ }
+
+ var currentDomain = AppDomain.CurrentDomain;
+ currentDomain.ProcessExit += OnProcessExit;
+
+ if (!currentDomain.IsDefaultAppDomain())
+ {
+ currentDomain.DomainUnload += OnProcessExit;
+ }
+ }
+
+ [PrePrepareMethod]
+ [ResourceExposure(ResourceScope.AppDomain)]
+ [ResourceConsumption(ResourceScope.AppDomain)]
+ private static void OnProcessExit(object sender, EventArgs e) => Shutdown();
+
+ [SuppressMessage("Microsoft.Reliability", "CA2001:AvoidCallingProblematicMethods")]
+ [ResourceExposure(ResourceScope.AppDomain)]
+ [ResourceConsumption(ResourceScope.AppDomain)]
+ private static void Shutdown()
+ {
+ if (Initialized)
+ {
+ ClearThreadData();
+ // unhook our shutdown handlers as we do not need to shut down more than once
+ var currentDomain = AppDomain.CurrentDomain;
+ currentDomain.ProcessExit -= OnProcessExit;
+ if (!currentDomain.IsDefaultAppDomain())
+ {
+ currentDomain.DomainUnload -= OnProcessExit;
+ }
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ private static void ClearThreadData()
+ {
+ var slot = Thread.GetNamedDataSlot(ThreadDataSlotName);
+ Thread.SetData(slot, null);
+ }
+
+ //----------------------------------------------------------------------------------------
+ // Status codes
+ //----------------------------------------------------------------------------------------
+ internal const int Ok = 0;
+ internal const int GenericError = 1;
+ internal const int InvalidParameter = 2;
+ internal const int OutOfMemory = 3;
+ internal const int ObjectBusy = 4;
+ internal const int InsufficientBuffer = 5;
+ internal const int NotImplemented = 6;
+ internal const int Win32Error = 7;
+ internal const int WrongState = 8;
+ internal const int Aborted = 9;
+ internal const int FileNotFound = 10;
+ internal const int ValueOverflow = 11;
+ internal const int AccessDenied = 12;
+ internal const int UnknownImageFormat = 13;
+ internal const int FontFamilyNotFound = 14;
+ internal const int FontStyleNotFound = 15;
+ internal const int NotTrueTypeFont = 16;
+ internal const int UnsupportedGdiplusVersion = 17;
+ internal const int GdiplusNotInitialized = 18;
+ internal const int PropertyNotFound = 19;
+ internal const int PropertyNotSupported = 20;
+
+ [DllImport(Gdiplus, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
+ [ResourceExposure(ResourceScope.None)]
+ internal static extern int GdipImageGetFrameDimensionsCount(HandleRef image, out int count);
+
+ internal static Exception StatusException(int status)
+ {
+ switch (status)
+ {
+ case GenericError: return new ExternalException("GdiplusGenericError");
+ case InvalidParameter: return new ArgumentException("GdiplusInvalidParameter");
+ case OutOfMemory: return new OutOfMemoryException("GdiplusOutOfMemory");
+ case ObjectBusy: return new InvalidOperationException("GdiplusObjectBusy");
+ case InsufficientBuffer: return new OutOfMemoryException("GdiplusInsufficientBuffer");
+ case NotImplemented: return new NotImplementedException("GdiplusNotImplemented");
+ case Win32Error: return new ExternalException("GdiplusGenericError");
+ case WrongState: return new InvalidOperationException("GdiplusWrongState");
+ case Aborted: return new ExternalException("GdiplusAborted");
+ case FileNotFound: return new FileNotFoundException("GdiplusFileNotFound");
+ case ValueOverflow: return new OverflowException("GdiplusOverflow");
+ case AccessDenied: return new ExternalException("GdiplusAccessDenied");
+ case UnknownImageFormat: return new ArgumentException("GdiplusUnknownImageFormat");
+ case PropertyNotFound: return new ArgumentException("GdiplusPropertyNotFoundError");
+ case PropertyNotSupported: return new ArgumentException("GdiplusPropertyNotSupportedError");
+ case FontFamilyNotFound: return new ArgumentException("GdiplusFontFamilyNotFound");
+ case FontStyleNotFound: return new ArgumentException("GdiplusFontStyleNotFound");
+ case NotTrueTypeFont: return new ArgumentException("GdiplusNotTrueTypeFont_NoName");
+ case UnsupportedGdiplusVersion: return new ExternalException("GdiplusUnsupportedGdiplusVersion");
+ case GdiplusNotInitialized: return new ExternalException("GdiplusNotInitialized");
+ }
+
+ return new ExternalException("GdiplusUnknown");
+ }
+
+ [DllImport(Gdiplus, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
+ [ResourceExposure(ResourceScope.None)]
+ internal static extern int GdipImageGetFrameDimensionsList(HandleRef image, IntPtr buffer, int count);
+
+ [DllImport(Gdiplus, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
+ [ResourceExposure(ResourceScope.None)]
+ internal static extern int GdipImageGetFrameCount(HandleRef image, ref Guid dimensionId, int[] count);
+
+ [DllImport(Gdiplus, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
+ [ResourceExposure(ResourceScope.None)]
+ internal static extern int GdipGetPropertyItemSize(HandleRef image, int propid, out int size);
+
+ [DllImport(Gdiplus, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
+ [ResourceExposure(ResourceScope.None)]
+ internal static extern int GdipGetPropertyItem(HandleRef image, int propid, int size, IntPtr buffer);
+
+ [DllImport(Gdiplus, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
+ [ResourceExposure(ResourceScope.Machine)]
+ internal static extern int GdipCreateHBITMAPFromBitmap(HandleRef nativeBitmap, out IntPtr hbitmap, int argbBackground);
+
+ [DllImport(Gdiplus, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
+ [ResourceExposure(ResourceScope.None)]
+ internal static extern int GdipImageSelectActiveFrame(HandleRef image, ref Guid dimensionId, int frameIndex);
+
+ [DllImport(Gdiplus, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
+ [ResourceExposure(ResourceScope.Machine)]
+ internal static extern int GdipCreateBitmapFromFile(string filename, out IntPtr bitmap);
+
+ [DllImport(Gdiplus, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
+ [ResourceExposure(ResourceScope.None)]
+ internal static extern int GdipImageForceValidation(HandleRef image);
+
+ [DllImport(Gdiplus, SetLastError = true, ExactSpelling = true, EntryPoint = "GdipDisposeImage", CharSet = CharSet.Unicode)]
+ [ResourceExposure(ResourceScope.None)]
+ private static extern int IntGdipDisposeImage(HandleRef image);
+
+ internal static int GdipDisposeImage(HandleRef image)
+ {
+ if (!Initialized) return Ok;
+ var result = IntGdipDisposeImage(image);
+ return result;
+ }
+
+ [DllImport(Gdiplus, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
+ [ResourceExposure(ResourceScope.Process)]
+ private static extern int GdiplusStartup(out IntPtr token, ref StartupInput input, out StartupOutput output);
+
+ [DllImport(Gdiplus, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
+ [ResourceExposure(ResourceScope.None)]
+ internal static extern int GdipGetImageRawFormat(HandleRef image, ref Guid format);
+
+ [DllImport(Gdiplus, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
+ [ResourceExposure(ResourceScope.Machine)]
+ internal static extern int GdipCreateBitmapFromStream(IStream stream, out IntPtr bitmap);
+ }
+ }
+}
\ No newline at end of file
diff --git a/HandyControl/Tools/GifImageAnimator.cs b/HandyControl/Tools/GifImageAnimator.cs
new file mode 100644
index 00000000..17e2219c
--- /dev/null
+++ b/HandyControl/Tools/GifImageAnimator.cs
@@ -0,0 +1,271 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Threading;
+using HandyControl.Controls;
+
+namespace HandyControl.Data
+{
+ internal class ImageAnimator
+ {
+ private static List ImageInfoList;
+
+ private static readonly ReaderWriterLock RwImgListLock = new ReaderWriterLock();
+
+ private static Thread AnimationThread;
+
+ private static bool AnyFrameDirty;
+
+ [ThreadStatic]
+ private static int ThreadWriterLockWaitCount;
+
+ public static bool CanAnimate(GifImage image)
+ {
+ if (image == null)
+ {
+ return false;
+ }
+
+ lock (image)
+ {
+ var dimensions = image.FrameDimensionsList;
+
+ if (dimensions.Select(guid => new GifFrameDimension(guid)).Contains(GifFrameDimension.Time))
+ {
+ return image.GetFrameCount(GifFrameDimension.Time) > 1;
+ }
+ }
+
+ return false;
+ }
+
+ public static void Animate(GifImage image, EventHandler onFrameChangedHandler)
+ {
+ if (image == null)
+ {
+ return;
+ }
+
+ GifImageInfo imageInfo;
+
+ // See comment in the class header about locking the image ref.
+ lock (image)
+ {
+ // could we avoid creating an ImageInfo object if FrameCount == 1 ?
+ imageInfo = new GifImageInfo(image);
+ }
+
+ // If the image is already animating, stop animating it
+ StopAnimate(image, onFrameChangedHandler);
+
+ // Acquire a writer lock to modify the image info list. If the thread has a reader lock we need to upgrade
+ // it to a writer lock; acquiring a reader lock in this case would block the thread on itself.
+ // If the thread already has a writer lock its ref count will be incremented w/o placing the request in the
+ // writer queue. See ReaderWriterLock.AcquireWriterLock method in the MSDN.
+
+ var readerLockHeld = RwImgListLock.IsReaderLockHeld;
+ var lockDowngradeCookie = new LockCookie();
+
+ ThreadWriterLockWaitCount++;
+
+ try
+ {
+ if (readerLockHeld)
+ {
+ lockDowngradeCookie = RwImgListLock.UpgradeToWriterLock(Timeout.Infinite);
+ }
+ else
+ {
+ RwImgListLock.AcquireWriterLock(Timeout.Infinite);
+ }
+ }
+ finally
+ {
+ ThreadWriterLockWaitCount--;
+ }
+
+ try
+ {
+ if (imageInfo.Animated)
+ {
+ // Construct the image array
+ //
+ if (ImageInfoList == null)
+ {
+ ImageInfoList = new List();
+ }
+
+ // Add the new image
+ //
+ imageInfo.FrameChangedHandler = onFrameChangedHandler;
+ ImageInfoList.Add(imageInfo);
+
+ // Construct a new timer thread if we haven't already
+ //
+ if (AnimationThread == null)
+ {
+ AnimationThread = new Thread(AnimateImages50Ms)
+ {
+ Name = typeof(ImageAnimator).Name,
+ IsBackground = true
+ };
+ AnimationThread.Start();
+ }
+ }
+ }
+ finally
+ {
+ if (readerLockHeld)
+ {
+ RwImgListLock.DowngradeFromWriterLock(ref lockDowngradeCookie);
+ }
+ else
+ {
+ RwImgListLock.ReleaseWriterLock();
+ }
+ }
+ }
+
+ public static void StopAnimate(GifImage image, EventHandler onFrameChangedHandler)
+ {
+ // Make sure we have a list of images
+ if (image == null || ImageInfoList == null)
+ {
+ return;
+ }
+
+ // Acquire a writer lock to modify the image info list - See comments on Animate() about this locking.
+
+ var readerLockHeld = RwImgListLock.IsReaderLockHeld;
+ var lockDowngradeCookie = new LockCookie();
+
+ ThreadWriterLockWaitCount++;
+
+ try
+ {
+ if (readerLockHeld)
+ {
+ lockDowngradeCookie = RwImgListLock.UpgradeToWriterLock(Timeout.Infinite);
+ }
+ else
+ {
+ RwImgListLock.AcquireWriterLock(Timeout.Infinite);
+ }
+ }
+ finally
+ {
+ ThreadWriterLockWaitCount--;
+ }
+
+ try
+ {
+ // Find the corresponding reference and remove it
+ for (int i = 0; i < ImageInfoList.Count; i++)
+ {
+ var imageInfo = ImageInfoList[i];
+
+ if (Equals(image, imageInfo.Image))
+ {
+ if ((onFrameChangedHandler == imageInfo.FrameChangedHandler) || (onFrameChangedHandler != null && onFrameChangedHandler.Equals(imageInfo.FrameChangedHandler)))
+ {
+ ImageInfoList.Remove(imageInfo);
+ }
+ break;
+ }
+ }
+ }
+ finally
+ {
+ if (readerLockHeld)
+ {
+ RwImgListLock.DowngradeFromWriterLock(ref lockDowngradeCookie);
+ }
+ else
+ {
+ RwImgListLock.ReleaseWriterLock();
+ }
+ }
+ }
+
+ public static void UpdateFrames()
+ {
+ if (!AnyFrameDirty || ImageInfoList == null)
+ {
+ return;
+ }
+ if (ThreadWriterLockWaitCount > 0)
+ {
+ // Cannot acquire reader lock at this time, frames update will be missed.
+ return;
+ }
+
+ RwImgListLock.AcquireReaderLock(Timeout.Infinite);
+
+ try
+ {
+ foreach (var imageInfo in ImageInfoList)
+ {
+ // See comment in the class header about locking the image ref.
+ lock (imageInfo.Image)
+ {
+ imageInfo.UpdateFrame();
+ }
+ }
+ AnyFrameDirty = false;
+ }
+ finally
+ {
+ RwImgListLock.ReleaseReaderLock();
+ }
+ }
+
+ [SuppressMessage("Microsoft.Performance", "CA1804:RemoveUnusedLocals")]
+ private static void AnimateImages50Ms()
+ {
+ while (true)
+ {
+ // Acquire reader-lock to access imageInfoList, elemens in the list can be modified w/o needing a writer-lock.
+ // Observe that we don't need to check if the thread is waiting or a writer lock here since the thread this
+ // method runs in never acquires a writer lock.
+ RwImgListLock.AcquireReaderLock(Timeout.Infinite);
+ try
+ {
+ foreach (var imageInfo in ImageInfoList)
+ {
+ // Frame delay is measured in 1/100ths of a second. This thread
+ // sleeps for 50 ms = 5/100ths of a second between frame updates,
+ // so we increase the frame delay count 5/100ths of a second
+ // at a time.
+ //
+ imageInfo.FrameTimer += 5;
+ if (imageInfo.FrameTimer >= imageInfo.FrameDelay(imageInfo.Frame))
+ {
+ imageInfo.FrameTimer = 0;
+
+ if (imageInfo.Frame + 1 < imageInfo.FrameCount)
+ {
+ imageInfo.Frame++;
+ }
+ else
+ {
+ imageInfo.Frame = 0;
+ }
+
+ if (imageInfo.FrameDirty)
+ {
+ AnyFrameDirty = true;
+ }
+ }
+ }
+ }
+ finally
+ {
+ RwImgListLock.ReleaseReaderLock();
+ }
+
+ Thread.Sleep(50);
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/HandyControlDemo/Data/MessageToken.cs b/HandyControlDemo/Data/MessageToken.cs
index cec6fd20..8f205798 100644
--- a/HandyControlDemo/Data/MessageToken.cs
+++ b/HandyControlDemo/Data/MessageToken.cs
@@ -54,6 +54,8 @@
public static readonly string TagDemoCtl = nameof(TagDemoCtl);
+ public static readonly string GifImageDemoCtl = nameof(GifImageDemoCtl);
+
public static readonly string ButtonDemoCtl = nameof(ButtonDemoCtl);
public static readonly string ToggleButtonDemoCtl = nameof(ToggleButtonDemoCtl);
diff --git a/HandyControlDemo/Data/MessageToken.tt b/HandyControlDemo/Data/MessageToken.tt
index ad670bea..9bbcd97a 100644
--- a/HandyControlDemo/Data/MessageToken.tt
+++ b/HandyControlDemo/Data/MessageToken.tt
@@ -29,7 +29,8 @@ var controlList = new List
"DateTimePickerDemoCtl",
"CalendarWithClockDemoCtl",
"SearchBarDemoCtl",
- "TagDemoCtl"
+ "TagDemoCtl",
+ "GifImageDemoCtl"
};
var styleList = new List
{
diff --git a/HandyControlDemo/HandyControlDemo.csproj b/HandyControlDemo/HandyControlDemo.csproj
index e2b3e522..275c70b5 100644
--- a/HandyControlDemo/HandyControlDemo.csproj
+++ b/HandyControlDemo/HandyControlDemo.csproj
@@ -129,6 +129,9 @@
DateTimePickerDemoCtl.xaml
+
+ GifImageDemoCtl.xaml
+
GrowlDemoCtl.xaml
@@ -383,6 +386,10 @@
Designer
MSBuild:Compile
+
+ Designer
+ MSBuild:Compile
+
Designer
MSBuild:Compile
@@ -599,6 +606,8 @@
TextTemplatingFileGenerator
MessageToken.cs
+
+
diff --git a/HandyControlDemo/Properties/Langs/Lang.Designer.cs b/HandyControlDemo/Properties/Langs/Lang.Designer.cs
index 262255af..4c27efc1 100644
--- a/HandyControlDemo/Properties/Langs/Lang.Designer.cs
+++ b/HandyControlDemo/Properties/Langs/Lang.Designer.cs
@@ -47,7 +47,7 @@ namespace HandyControlDemo.Properties.Langs {
}
///
- /// 重写当前线程的 CurrentUICulture 属性
+ /// 使用此强类型资源类，为所有资源查找
/// 重写当前线程的 CurrentUICulture 属性。
///
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
@@ -384,6 +384,15 @@ namespace HandyControlDemo.Properties.Langs {
}
}
+ ///
+ /// 查找类似 Gif图片 的本地化字符串。
+ ///
+ public static string GifImage {
+ get {
+ return ResourceManager.GetString("GifImage", resourceCulture);
+ }
+ }
+
///
/// 查找类似 分组框 的本地化字符串。
///
diff --git a/HandyControlDemo/Properties/Langs/Lang.en.resx b/HandyControlDemo/Properties/Langs/Lang.en.resx
index 4b1f050b..8e97e24f 100644
--- a/HandyControlDemo/Properties/Langs/Lang.en.resx
+++ b/HandyControlDemo/Properties/Langs/Lang.en.resx
@@ -429,4 +429,7 @@
Tag
+
+ GifImage
+
\ No newline at end of file
diff --git a/HandyControlDemo/Properties/Langs/Lang.resx b/HandyControlDemo/Properties/Langs/Lang.resx
index ddc9a2b9..a81739de 100644
--- a/HandyControlDemo/Properties/Langs/Lang.resx
+++ b/HandyControlDemo/Properties/Langs/Lang.resx
@@ -409,4 +409,7 @@
标签
+
+ Gif图片
+
\ No newline at end of file
diff --git a/HandyControlDemo/Resources/Img/LeftMainContent/Animation_16x.png b/HandyControlDemo/Resources/Img/LeftMainContent/Animation_16x.png
new file mode 100644
index 0000000000000000000000000000000000000000..e4b217498b815e520b69da2e78eadfdc4a38f7f0
GIT binary patch
literal 494
zcmVDI|1-2}0;prg>CgM$<)g*@I^7auykr6>pv#wAN@EEv*1g)0}+TKwQ}^9RoP
z@6G*#O_|MR``{2aH2(r{76{)vj+!6=nV=ytnUB@&4s
zo6W-aNWPgFc}AlV`u#q56h%Qgo&Hcf9-jiZlR&WUEXZ|TR4NrL77Oqs5((t<`DXyX
zNhSrl(r4Y9%_c0%LMoL)GMPlL*Mn)AEayKNA6X&EvMjKIuJi=Jt*WZfb^TQo#XkW4
zYMN%yN8QF3@I&;EbVE8MZE;h0JQxf-!!VYE#KX+;H~+!)csveHA_zecKsZ>>c{m)_
kf|Ix&{tDj!=p-8)@0?rXnr7Cj>Hq)$07*qoM6N<$g6I6y!2kdN
literal 0
HcmV?d00001
diff --git a/HandyControlDemo/Resources/Img/car_chase.gif b/HandyControlDemo/Resources/Img/car_chase.gif
new file mode 100644
index 0000000000000000000000000000000000000000..ff9290f2f97a269358b56a5296861b66d9f58b07
GIT binary patch
literal 4689837
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໐w3_foD&<2N;VYK0ji?`
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