File: System\Windows\Controls\Image.cs
Web Access
Project: src\src\Microsoft.DotNet.Wpf\src\PresentationFramework\PresentationFramework.csproj (PresentationFramework)
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
//
// Description: Contains the Image class.
//              Layout Spec at Image.xml
//
 
using MS.Internal;
using MS.Internal.PresentationFramework;
using MS.Internal.Telemetry.PresentationFramework;
using MS.Utility;
using System.Diagnostics;
using System.ComponentModel;
#if OLD_AUTOMATION
using System.Windows.Automation.Provider;
#endif
using System.Windows.Threading;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Documents;
using System.Windows.Markup;
using System.Windows.Navigation;
 
using System;
 
namespace System.Windows.Controls
{
    /// <summary>
    /// </summary>
    [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)]
#if OLD_AUTOMATION
    [Automation(AccessibilityControlType = "Image")]
#endif
    public class Image : FrameworkElement, IUriContext, IProvidePropertyFallback
    {
        //-------------------------------------------------------------------
        //
        //  Constructors
        //
        //-------------------------------------------------------------------
 
        #region Constructors
 
        /// <summary>
        ///     Default DependencyObject constructor
        /// </summary>
        /// <remarks>
        ///     Automatic determination of current Dispatcher. Use alternative constructor
        ///     that accepts a Dispatcher for best performance.
        /// </remarks>
        public Image() : base()
        {
        }
 
        #endregion
 
        //-------------------------------------------------------------------
        //
        //  Public Methods
        //
        //-------------------------------------------------------------------
 
        //-------------------------------------------------------------------
        //
        //  Public Properties
        //
        //-------------------------------------------------------------------
 
        #region Public Properties
 
        /// <summary>
        /// Gets/Sets the Source on this Image.
        ///
        /// The Source property is the ImageSource that holds the actual image drawn.
        /// </summary>
        public ImageSource Source
        {
            get { return (ImageSource) GetValue(SourceProperty); }
            set { SetValue(SourceProperty, value); }
        }
 
        /// <summary>
        /// Gets/Sets the Stretch on this Image.
        /// The Stretch property determines how large the Image will be drawn.
        /// </summary>
        /// <seealso cref="Image.StretchProperty" />
        public Stretch Stretch
        {
            get { return (Stretch) GetValue(StretchProperty); }
            set { SetValue(StretchProperty, value); }
        }
 
        /// <summary>
        /// Gets/Sets the stretch direction of the Viewbox, which determines the restrictions on
        /// scaling that are applied to the content inside the Viewbox.  For instance, this property
        /// can be used to prevent the content from being smaller than its native size or larger than
        /// its native size.
        /// </summary>
        /// <seealso cref="Viewbox.StretchDirectionProperty" />
        public StretchDirection StretchDirection
        {
            get { return (StretchDirection)GetValue(StretchDirectionProperty); }
            set { SetValue(StretchDirectionProperty, value); }
        }
 
        /// <summary>
        /// DependencyProperty for Image Source property.
        /// </summary>
        /// <seealso cref="Image.Source" />
        [CommonDependencyProperty]
        public static readonly DependencyProperty SourceProperty =
                DependencyProperty.Register(
                        "Source",
                        typeof(ImageSource),
                        typeof(Image),
                        new FrameworkPropertyMetadata(
                                null,
                                FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsRender,
                                new PropertyChangedCallback(OnSourceChanged),
                                null),
                        null);
 
        /// <summary>
        /// RoutedEvent for when DPI of the screen the Image is on, changes.
        /// </summary>
        public static readonly RoutedEvent DpiChangedEvent;
 
 
        /// <summary>
        /// DependencyProperty for Stretch property.
        /// </summary>
        /// <seealso cref="Viewbox.Stretch" />
        [CommonDependencyProperty]
        public static readonly DependencyProperty StretchProperty =
                Viewbox.StretchProperty.AddOwner(typeof(Image));
 
        /// <summary>
        /// DependencyProperty for StretchDirection property.
        /// </summary>
        /// <seealso cref="Viewbox.Stretch" />
        public static readonly DependencyProperty StretchDirectionProperty =
                Viewbox.StretchDirectionProperty.AddOwner(typeof(Image));
 
 
        /// <summary>
        /// ImageFailedEvent is a routed event.
        /// </summary>
        public static readonly RoutedEvent ImageFailedEvent =
            EventManager.RegisterRoutedEvent(
                            "ImageFailed",
                            RoutingStrategy.Bubble,
                            typeof(EventHandler<ExceptionRoutedEventArgs>),
                            typeof(Image));
 
        /// <summary>
        /// Raised when there is a failure in image.
        /// </summary>
        public event EventHandler<ExceptionRoutedEventArgs> ImageFailed
        {
            add { AddHandler(ImageFailedEvent, value); }
            remove { RemoveHandler(ImageFailedEvent, value); }
        }
 
        /// <summary>
        ///     This event is raised after the DPI of the screen on which the Image is displayed, changes.
        /// </summary>
        public event DpiChangedEventHandler DpiChanged
        {
            add { AddHandler(Image.DpiChangedEvent, value); }
            remove { RemoveHandler(Image.DpiChangedEvent, value); }
        }
 
        #endregion
 
        //-------------------------------------------------------------------
        //
        //  Protected Methods
        //
        //-------------------------------------------------------------------
 
        #region Protected Methods
 
        /// <summary>
        /// Creates AutomationPeer (<see cref="UIElement.OnCreateAutomationPeer"/>)
        /// </summary>
        protected override System.Windows.Automation.Peers.AutomationPeer OnCreateAutomationPeer()
        {
            return new System.Windows.Automation.Peers.ImageAutomationPeer(this);
        }
 
        /// <summary>
        /// OnDpiChanged is called when the DPI at which this Image is rendered, changes.
        /// </summary>
        protected override void OnDpiChanged(DpiScale oldDpi, DpiScale newDpi)
        {
            _hasDpiChangedEverFired = true;
            RaiseEvent(new DpiChangedEventArgs(oldDpi, newDpi, Image.DpiChangedEvent, this));
        }
 
        /// <summary>
        /// Updates DesiredSize of the Image.  Called by parent UIElement.  This is the first pass of layout.
        /// </summary>
        /// <remarks>
        /// Image will always return its natural size, if it fits within the constraint.  If not, it will return
        /// as large a size as it can.  Remember that image can later arrange at any size and stretch/align.
        /// </remarks>
        /// <param name="constraint">Constraint size is an "upper limit" that Image should not exceed.</param>
        /// <returns>Image's desired size.</returns>
        protected override Size MeasureOverride(Size constraint)
        {
            // A) Image element will fire the Image.DpiChanged event the first time a measure happens in order to support the app
            // loading the best image for that DPI.
            // B) When per-monitor DPI is enabled for an application and a DPI changes (due to moving to a new monitor, or changing the DPI of a monitor), the Image.DpiChanged event
            // will be raised by a tree walk performed by the root visual.
            // If the root visual has already raised this event on the image (B), then we don't want to raise it again in Measure (A).
            // Developers can most efficiently load images for initial display by using BitmapCreateOption = DelayCreation when create a BitmapSource.
            // This will enable only a single decode, instead of sometimes 2.
            if (!_hasDpiChangedEverFired)
            {
                // Marking it true here as well as inside OnDpiChanged in case someone overrides OnDpiChanged but doesn't call base.OnDpiChanged
                _hasDpiChangedEverFired = true;
                DpiScale dpiInfo = GetDpi();
                OnDpiChanged(dpiInfo, dpiInfo);
            }
            
            return MeasureArrangeHelper(constraint);
        }
 
        /// <summary>
        /// Override for <seealso cref="FrameworkElement.ArrangeOverride" />.
        /// </summary>
        protected override Size ArrangeOverride(Size arrangeSize)
        {
            return MeasureArrangeHelper(arrangeSize);
        }
 
        //
        // protected override void OnArrange(Size arrangeSize)
        // Because Image does not have children and it is inexpensive to compute it's alignment/size,
        // it does not need an OnArrange override.  It will simply use its own RenderSize (set when its
        // Arrange is called) in OnRender.
        //
 
        /// <summary>
        /// The Stretch property determines how large the Image will be drawn. The values for Stretch are:
        /// <DL><DT>None</DT>        <DD>Image draws at natural size and will clip / overdraw if too large.</DD>
        ///     <DT>Fill</DT>        <DD>Image will draw at RenderSize.  Aspect Ratio may be distorted.</DD>
        ///     <DT>Uniform</DT>     <DD>Image will scale uniformly up or down to fit within RenderSize.</DD>
        ///     <DT>UniformFill</DT> <DD>Image will scale uniformly to fill RenderSize, clipping / overdrawing in the larger dimension.</DD></DL>
        /// AlignmentX and AlignmentY properties are used to position the Image when its size
        /// is different the RenderSize.
        /// </summary>
        protected override void OnRender(DrawingContext dc)
        {
            ImageSource imageSource = Source;
 
            if (imageSource == null)
            {
                return;
            }
 
            //computed from the ArrangeOverride return size
            dc.DrawImage(imageSource, new Rect(new Point(), RenderSize));
        }
 
        #endregion Protected Methods
 
        #region IUriContext implementation
        /// <summary>
        ///     Accessor for the base uri of the Image
        /// </summary>
        Uri IUriContext.BaseUri
        {
            get
            {
                return BaseUri;
            }
            set
            {
                BaseUri = value;
            }
        }
 
        /// <summary>
        ///    Implementation for BaseUri
        /// </summary>
        protected virtual Uri BaseUri
        {
            get
            {
                return (Uri)GetValue(BaseUriHelper.BaseUriProperty);
            }
            set
            {
                SetValue(BaseUriHelper.BaseUriProperty, value);
            }
        }
 
        #endregion IUriContext implementation
 
        //-------------------------------------------------------------------
        //
        //  Private Methods
        //
        //-------------------------------------------------------------------
 
        #region Private Methods
 
        /// <summary>
        /// Contains the code common for MeasureOverride and ArrangeOverride.
        /// </summary>
        /// <param name="inputSize">input size is the parent-provided space that Image should use to "fit in", according to other properties.</param>
        /// <returns>Image's desired size.</returns>
        private Size MeasureArrangeHelper(Size inputSize)
        {
            ImageSource imageSource = Source;
            Size naturalSize = new Size();
 
            if (imageSource == null)
            {
                return naturalSize;
            }
 
            try
            {
                UpdateBaseUri(this, imageSource);
 
                naturalSize = imageSource.Size;
            }
            catch(Exception e)
            {
                SetCurrentValue(SourceProperty, null);
                RaiseEvent(new ExceptionRoutedEventArgs(ImageFailedEvent, this, e));
            }
 
            //get computed scale factor
            Size scaleFactor = Viewbox.ComputeScaleFactor(inputSize,
                                                          naturalSize,
                                                          this.Stretch,
                                                          this.StretchDirection);
 
            // Returns our minimum size & sets DesiredSize.
            return new Size(naturalSize.Width * scaleFactor.Width, naturalSize.Height * scaleFactor.Height);
        }
 
        //
        //  This property
        //  1. Finds the correct initial size for the _effectiveValues store on the current DependencyObject
        //  2. This is a performance optimization
        //
        internal override int EffectiveValuesInitialSize
        {
            get { return 19; }
        }
 
        #endregion Private Methods
 
        //-------------------------------------------------------------------
        //
        //  Private Fields
        //
        //-------------------------------------------------------------------
        #region Private Fields
 
        private BitmapSource _bitmapSource;
 
        // The DpiChanged event is raised in two situations:  
        // (a) the first time the Image is measured, and (b) when the effective DPI changes.
        // This allows the app to choose a bitmap matching (a) the initial DPI, or (b) the new DPI after a change.
        // This boolean detects (a).
        private bool _hasDpiChangedEverFired = false;
 
        #endregion Private Fields
 
 
        //-------------------------------------------------------------------
        //
        //  Static Constructors & Delegates
        //
        //-------------------------------------------------------------------
 
        #region Static Constructors & Delegates
 
        static Image()
        {
            Style style = CreateDefaultStyles();
            StyleProperty.OverrideMetadata(typeof(Image), new FrameworkPropertyMetadata(style));
 
            //
            // The Stretch & StretchDirection properties are AddOwner'ed from a class which is not
            // base class for Image so the metadata with flags get lost. We need to override them
            // here to make it work again.
            //
            StretchProperty.OverrideMetadata(
                typeof(Image),
                new FrameworkPropertyMetadata(
                    Stretch.Uniform,
                    FrameworkPropertyMetadataOptions.AffectsMeasure
                    )
                );
 
            StretchDirectionProperty.OverrideMetadata(
                typeof(Image),
                new FrameworkPropertyMetadata(
                    StretchDirection.Both,
                    FrameworkPropertyMetadataOptions.AffectsMeasure
                    )
                );
            Image.DpiChangedEvent = Window.DpiChangedEvent.AddOwner(typeof(Image));
 
            ControlsTraceLogger.AddControl(TelemetryControls.Image);
        }
 
        private static Style CreateDefaultStyles()
        {
            Style style = new Style(typeof(Image), null);
            style.Setters.Add (new Setter(FlowDirectionProperty, FlowDirection.LeftToRight));
            style.Seal();
            return style;
        }
 
        private void OnSourceDownloaded(object sender, EventArgs e)
        {
            DetachBitmapSourceEvents();
            InvalidateMeasure();
            InvalidateVisual(); //ensure re-rendering
        }
 
        private void OnSourceFailed(object sender, ExceptionEventArgs e)
        {
            DetachBitmapSourceEvents();
            SetCurrentValue(SourceProperty, null);
            RaiseEvent(new ExceptionRoutedEventArgs(ImageFailedEvent, this, e.ErrorException));
        }
 
        private void AttachBitmapSourceEvents(BitmapSource bitmapSource)
        {
            DownloadCompletedEventManager.AddHandler(bitmapSource, OnSourceDownloaded);
            DownloadFailedEventManager.AddHandler(bitmapSource, OnSourceFailed);
            DecodeFailedEventManager.AddHandler(bitmapSource, OnSourceFailed);
 
            _bitmapSource = bitmapSource;
        }
 
        private void DetachBitmapSourceEvents()
        {
            if (_bitmapSource != null)
            {
                DownloadCompletedEventManager.RemoveHandler(_bitmapSource, OnSourceDownloaded);
                DownloadFailedEventManager.RemoveHandler(_bitmapSource, OnSourceFailed);
                DecodeFailedEventManager.RemoveHandler(_bitmapSource, OnSourceFailed);
                _bitmapSource = null;
            }
        }
 
        private static void OnSourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (!e.IsASubPropertyChange)
            {
                Image image = (Image)d;
                ImageSource oldValue = (ImageSource)e.OldValue;
                ImageSource newValue = (ImageSource)e.NewValue;
 
                UpdateBaseUri(d, newValue);
 
                image.DetachBitmapSourceEvents();
 
                BitmapSource newBitmapSource = newValue as BitmapSource;
                if (newBitmapSource != null && newBitmapSource.CheckAccess() && !newBitmapSource.IsFrozen)
                {
                    image.AttachBitmapSourceEvents(newBitmapSource);
                }
            }
        }
 
        private static void UpdateBaseUri(DependencyObject d, ImageSource source)
        {
            if ((source is IUriContext) && (!source.IsFrozen) && (((IUriContext)source).BaseUri == null))
            {
                Uri baseUri = BaseUriHelper.GetBaseUriCore(d);
                if (baseUri != null)
                {
                    ((IUriContext)source).BaseUri = BaseUriHelper.GetBaseUriCore(d);
                }
            }
        }
 
        #endregion
 
        #region IProvidePropertyFallback
 
        /// <summary>
        /// Says if the type can provide fallback value for the given property
        /// </summary>
        bool IProvidePropertyFallback.CanProvidePropertyFallback(string property)
        {
            return string.Equals(property, "Source", StringComparison.Ordinal);
        }
 
        /// <summary>
        /// Returns the fallback value for the given property.
        /// </summary>
        object IProvidePropertyFallback.ProvidePropertyFallback(string property, Exception cause)
        {
            if (string.Equals(property, "Source", StringComparison.Ordinal))
            {
                RaiseEvent(new ExceptionRoutedEventArgs(ImageFailedEvent, this, cause));
            }
 
            // For now we do not have a static that represents a bad-image, so just return a null.
            return null;
        }
 
        #endregion IProvidePropertyFallback
 
        #region BitmapSource events
 
        /// <summary>
        /// Manager for the BitmapSource.DownloadCompleted event.
        /// </summary>
        private class DownloadCompletedEventManager : WeakEventManager
        {
            #region Constructors
 
            //
            //  Constructors
            //
 
            private DownloadCompletedEventManager()
            {
            }
 
            #endregion Constructors
 
            #region Public Methods
 
            //
            //  Public Methods
            //
 
            /// <summary>
            /// Add a handler for the given source's event.
            /// </summary>
            public static void AddHandler(BitmapSource source, EventHandler<EventArgs> handler)
            {
                ArgumentNullException.ThrowIfNull(handler);
 
                CurrentManager.ProtectedAddHandler(source, handler);
            }
 
            /// <summary>
            /// Remove a handler for the given source's event.
            /// </summary>
            public static void RemoveHandler(BitmapSource source, EventHandler<EventArgs> handler)
            {
                ArgumentNullException.ThrowIfNull(handler);
 
                CurrentManager.ProtectedRemoveHandler(source, handler);
            }
 
            #endregion Public Methods
 
            #region Protected Methods
 
            //
            //  Protected Methods
            //
 
            /// <summary>
            /// Return a new list to hold listeners to the event.
            /// </summary>
            protected override ListenerList NewListenerList()
            {
                return new ListenerList<EventArgs>();
            }
 
            /// <summary>
            /// Listen to the given source for the event.
            /// </summary>
            protected override void StartListening(object source)
            {
                BitmapSource typedSource = (BitmapSource)source;
                typedSource.DownloadCompleted += new EventHandler(OnDownloadCompleted);
            }
 
            /// <summary>
            /// Stop listening to the given source for the event.
            /// </summary>
            protected override void StopListening(object source)
            {
                BitmapSource typedSource = (BitmapSource)source;
                if (typedSource.CheckAccess() && !typedSource.IsFrozen)
                {
                    typedSource.DownloadCompleted -= new EventHandler(OnDownloadCompleted);
                }
            }
 
            #endregion Protected Methods
 
            #region Private Properties
 
            //
            //  Private Properties
            //
 
            // get the event manager for the current thread
            private static DownloadCompletedEventManager CurrentManager
            {
                get
                {
                    Type managerType = typeof(DownloadCompletedEventManager);
                    DownloadCompletedEventManager manager = (DownloadCompletedEventManager)GetCurrentManager(managerType);
 
                    // at first use, create and register a new manager
                    if (manager == null)
                    {
                        manager = new DownloadCompletedEventManager();
                        SetCurrentManager(managerType, manager);
                    }
 
                    return manager;
                }
            }
 
            #endregion Private Properties
 
            #region Private Methods
 
            //
            //  Private Methods
            //
 
            // event handler for DownloadCompleted event
            private void OnDownloadCompleted(object sender, EventArgs args)
            {
                DeliverEvent(sender, args);
            }
 
            #endregion Private Methods
        }
 
        /// <summary>
        /// Manager for the BitmapSource.DownloadFailed event.
        /// </summary>
        private class DownloadFailedEventManager : WeakEventManager
        {
            #region Constructors
 
            //
            //  Constructors
            //
 
            private DownloadFailedEventManager()
            {
            }
 
            #endregion Constructors
 
            #region Public Methods
 
            //
            //  Public Methods
            //
 
            /// <summary>
            /// Add a handler for the given source's event.
            /// </summary>
            public static void AddHandler(BitmapSource source, EventHandler<ExceptionEventArgs> handler)
            {
                ArgumentNullException.ThrowIfNull(handler);
 
                CurrentManager.ProtectedAddHandler(source, handler);
            }
 
            /// <summary>
            /// Remove a handler for the given source's event.
            /// </summary>
            public static void RemoveHandler(BitmapSource source, EventHandler<ExceptionEventArgs> handler)
            {
                ArgumentNullException.ThrowIfNull(handler);
 
                CurrentManager.ProtectedRemoveHandler(source, handler);
            }
 
            #endregion Public Methods
 
            #region Protected Methods
 
            //
            //  Protected Methods
            //
 
            /// <summary>
            /// Return a new list to hold listeners to the event.
            /// </summary>
            protected override ListenerList NewListenerList()
            {
                return new ListenerList<ExceptionEventArgs>();
            }
 
            /// <summary>
            /// Listen to the given source for the event.
            /// </summary>
            protected override void StartListening(object source)
            {
                BitmapSource typedSource = (BitmapSource)source;
                typedSource.DownloadFailed += new EventHandler<ExceptionEventArgs>(OnDownloadFailed);
            }
 
            /// <summary>
            /// Stop listening to the given source for the event.
            /// </summary>
            protected override void StopListening(object source)
            {
                BitmapSource typedSource = (BitmapSource)source;
                if (typedSource.CheckAccess() && !typedSource.IsFrozen)
                {
                    typedSource.DownloadFailed -= new EventHandler<ExceptionEventArgs>(OnDownloadFailed);
                }
            }
 
            #endregion Protected Methods
 
            #region Private Properties
 
            //
            //  Private Properties
            //
 
            // get the event manager for the current thread
            private static DownloadFailedEventManager CurrentManager
            {
                get
                {
                    Type managerType = typeof(DownloadFailedEventManager);
                    DownloadFailedEventManager manager = (DownloadFailedEventManager)GetCurrentManager(managerType);
 
                    // at first use, create and register a new manager
                    if (manager == null)
                    {
                        manager = new DownloadFailedEventManager();
                        SetCurrentManager(managerType, manager);
                    }
 
                    return manager;
                }
            }
 
            #endregion Private Properties
 
            #region Private Methods
 
            //
            //  Private Methods
            //
 
            // event handler for DownloadFailed event
            private void OnDownloadFailed(object sender, ExceptionEventArgs args)
            {
                DeliverEvent(sender, args);
            }
 
            #endregion Private Methods
        }
 
        /// <summary>
        /// Manager for the BitmapSource.DecodeFailed event.
        /// </summary>
        private class DecodeFailedEventManager : WeakEventManager
        {
            #region Constructors
 
            //
            //  Constructors
            //
 
            private DecodeFailedEventManager()
            {
            }
 
            #endregion Constructors
 
            #region Public Methods
 
            //
            //  Public Methods
            //
 
            /// <summary>
            /// Add a handler for the given source's event.
            /// </summary>
            public static void AddHandler(BitmapSource source, EventHandler<ExceptionEventArgs> handler)
            {
                ArgumentNullException.ThrowIfNull(handler);
 
                CurrentManager.ProtectedAddHandler(source, handler);
            }
 
            /// <summary>
            /// Remove a handler for the given source's event.
            /// </summary>
            public static void RemoveHandler(BitmapSource source, EventHandler<ExceptionEventArgs> handler)
            {
                ArgumentNullException.ThrowIfNull(handler);
 
                CurrentManager.ProtectedRemoveHandler(source, handler);
            }
 
            #endregion Public Methods
 
            #region Protected Methods
 
            //
            //  Protected Methods
            //
 
            /// <summary>
            /// Return a new list to hold listeners to the event.
            /// </summary>
            protected override ListenerList NewListenerList()
            {
                return new ListenerList<ExceptionEventArgs>();
            }
 
            /// <summary>
            /// Listen to the given source for the event.
            /// </summary>
            protected override void StartListening(object source)
            {
                BitmapSource typedSource = (BitmapSource)source;
                typedSource.DecodeFailed += new EventHandler<ExceptionEventArgs>(OnDecodeFailed);
            }
 
            /// <summary>
            /// Stop listening to the given source for the event.
            /// </summary>
            protected override void StopListening(object source)
            {
                BitmapSource typedSource = (BitmapSource)source;
                if (typedSource.CheckAccess() && !typedSource.IsFrozen)
                {
                    typedSource.DecodeFailed -= new EventHandler<ExceptionEventArgs>(OnDecodeFailed);
                }
            }
 
            #endregion Protected Methods
 
            #region Private Properties
 
            //
            //  Private Properties
            //
 
            // get the event manager for the current thread
            private static DecodeFailedEventManager CurrentManager
            {
                get
                {
                    Type managerType = typeof(DecodeFailedEventManager);
                    DecodeFailedEventManager manager = (DecodeFailedEventManager)GetCurrentManager(managerType);
 
                    // at first use, create and register a new manager
                    if (manager == null)
                    {
                        manager = new DecodeFailedEventManager();
                        SetCurrentManager(managerType, manager);
                    }
 
                    return manager;
                }
            }
 
            #endregion Private Properties
 
            #region Private Methods
 
            //
            //  Private Methods
            //
 
            // event handler for DecodeFailed event
            private void OnDecodeFailed(object sender, ExceptionEventArgs args)
            {
                DeliverEvent(sender, args);
            }
 
            #endregion Private Methods
        }
 
        #endregion BitmapSource events
    }
}