/src/DocumentWorkspace.cs

/////////////////////////////////////////////////////////////////////////////////

// Paint.NET                                                                   //

// Copyright (C) dotPDN LLC, Rick Brewster, Tom Jackson, and contributors.     //

// Portions Copyright (C) Microsoft Corporation. All Rights Reserved.          //

// See src/Resources/Files/License.txt for full licensing and attribution      //

// details.                                                                    //

// .                                                                           //

/////////////////////////////////////////////////////////////////////////////////



using PaintDotNet.Base;

using PaintDotNet.HistoryFunctions;

using PaintDotNet.HistoryMementos;

using PaintDotNet.SystemLayer;

using PaintDotNet.Tools;

using System;

using System.Collections;

using System.Collections.Generic;

using System.ComponentModel;

using System.Drawing;

using System.Drawing.Imaging;

using System.Globalization;

using System.IO;

using System.Reflection;

using System.Runtime.Serialization;

using System.Security;

using System.Threading;

using System.Windows.Forms;



namespace PaintDotNet

{

    /// <summary>

    /// Builds on DocumentView by adding application-specific elements.

    /// </summary>

    internal class DocumentWorkspace

        : DocumentView,

          IHistoryWorkspace,

          IThumbnailProvider

    {

        public static readonly DateTime NeverSavedDateTime = DateTime.MinValue;



        private static Type[] _tools; // TODO: move to Tool class?

        private static ToolInfo[] _toolInfos;



        private ZoomBasis _zoomBasis;

        private AppWorkspace _appWorkspace;

        private SaveConfigToken _saveConfigToken;

        private readonly Selection _selection = new Selection();

        private Surface _scratchSurface;

        private readonly SelectionRenderer _selectionRenderer;

        private readonly Hashtable _staticToolData = Hashtable.Synchronized(new Hashtable());

        private Type _preNullTool;

        private int _nullToolCount;

        private int _zoomChangesCount;

        private readonly HistoryStack _history;

        private Layer _activeLayer;

        private System.Windows.Forms.Timer _toolPulseTimer;

        private DateTime _lastSaveTime = NeverSavedDateTime;

        private int _suspendToolCursorChanges;



        private readonly string _contextStatusBarWithAngleFormat = PdnResources.GetString("StatusBar.Context.SelectedArea.Text.WithAngle.Format");

        private readonly string _contextStatusBarFormat = PdnResources.GetString("StatusBar.Context.SelectedArea.Text.Format");



        public void SuspendToolCursorChanges()

        {

            ++_suspendToolCursorChanges;

        }



        public void ResumeToolCursorChanges()

        {

            --_suspendToolCursorChanges;



            if (_suspendToolCursorChanges <= 0 && Tool != null)

            {

                Cursor = Tool.Cursor;

            }

        }



        public ImageResource StatusIcon { get; private set; }



        public string StatusText { get; private set; }



        public void SetStatus(string newStatusText, ImageResource newStatusIcon)

        {

            StatusText = newStatusText;

            StatusIcon = newStatusIcon;

            OnStatusChanged();

        }



        public event EventHandler StatusChanged;

        protected virtual void OnStatusChanged()

        {

            if (StatusChanged != null)

            {

                StatusChanged(this, EventArgs.Empty);

            }

        }



        static DocumentWorkspace()

        {

            InitializeTools();

            InitializeToolInfos();

        }



        public DateTime LastSaveTime

        {

            get

            {

                return _lastSaveTime;

            }

        }



        public bool IsZoomChanging

        {

            get

            {

                return (_zoomChangesCount > 0);

            }

        }





        private void BeginZoomChanges()

        {

            ++_zoomChangesCount;

        }







        private void EndZoomChanges() 

        {

            --_zoomChangesCount;

        }





        protected override void OnSizeChanged(EventArgs e)

        {

            PerformLayout();

            base.OnSizeChanged(e);

        }



        protected override void OnLayout(LayoutEventArgs e)

        {

            if (_zoomBasis == ZoomBasis.FitToWindow)

            {

                ZoomToWindow();



                // This bizarre ordering of setting PanelAutoScroll prevents some very weird layout/scroll-without-scrollbars stuff.

                PanelAutoScroll = true;

                PanelAutoScroll = false;

            }



            base.OnLayout(e);

        }



        protected override void OnResize(EventArgs e)

        {

            if (_zoomBasis == ZoomBasis.FitToWindow)

            {

                PerformLayout();

            }



            base.OnResize(e);

        }



        public DocumentWorkspace()

        {

            FileType = null;

            FilePath = null;

            _activeLayer = null;

            _history = new HistoryStack(this);



            InitializeComponent();



            // hook the DocumentWorkspace with its selectedPath ...

            _selectionRenderer = new SelectionRenderer(RendererList, Selection, this);

            RendererList.Add(_selectionRenderer, true);

            _selectionRenderer.EnableOutlineAnimation = true;

            _selectionRenderer.EnableSelectionTinting = false;

            _selectionRenderer.EnableSelectionOutline = true;



            _selection.Changed += SelectionChanged;



            _zoomBasis = ZoomBasis.FitToWindow;

        }



        protected override void OnUnitsChanged()

        {

            if (!Selection.IsEmpty)

            {

                UpdateSelectionInfoInStatusBar();

            }



            base.OnUnitsChanged();

        }



        public void UpdateStatusBarToToolHelpText(Tool tool)

        {

            if (tool == null)

            {

                SetStatus(string.Empty, null);

            }

            else

            {

                string toolName = tool.Name;

                string helpText = tool.HelpText;



                string contextFormat = PdnResources.GetString("StatusBar.Context.Help.Text.Format");

                string contextText = string.Format(contextFormat, toolName, helpText);



                SetStatus(contextText, PdnResources.GetImageResource("Icons.MenuHelpHelpTopicsIcon.png"));

            }

        }



        public void UpdateStatusBarToToolHelpText()

        {

            UpdateStatusBarToToolHelpText(Tool);

        }



        private void UpdateSelectionInfoInStatusBar()

        {

            if (Selection.IsEmpty)

            {

                UpdateStatusBarToToolHelpText();

            }

            else

            {

                string newStatusText;



                int area;

                Rectangle bounds;



                using (PdnRegion tempSelection = Selection.CreateRegionRaw())

                {

                    tempSelection.Intersect(Document.Bounds);

                    bounds = Utility.GetRegionBounds(tempSelection);

                    area = tempSelection.GetArea();

                }



                string unitsAbbreviationXY;

                string xString;

                string yString;

                string unitsAbbreviationWH;

                string widthString;

                string heightString;



                Document.CoordinatesToStrings(Units, bounds.X, bounds.Y, out xString, out yString, out unitsAbbreviationXY);

                Document.CoordinatesToStrings(Units, bounds.Width, bounds.Height, out widthString, out heightString, out unitsAbbreviationWH);



                var nfi = (NumberFormatInfo)CultureInfo.CurrentCulture.NumberFormat.Clone();



                string areaString;

                if (Units == MeasurementUnit.Pixel)

                {

                    nfi.NumberDecimalDigits = 0;

                    areaString = area.ToString("N", nfi);

                }

                else

                {

                    nfi.NumberDecimalDigits = 2;

                    double areaD = Document.PixelAreaToPhysicalArea(area, Units);

                    areaString = areaD.ToString("N", nfi);

                }



                string pluralUnits = PdnResources.GetString("MeasurementUnit." + Units + ".Plural");

                var moveTool = Tool as MoveToolBase;



                if (moveTool != null && moveTool.HostShouldShowAngle)

                {

                    var nfi2 = (NumberFormatInfo)nfi.Clone();

                    nfi2.NumberDecimalDigits = 2;

                    float angle = moveTool.HostAngle;



                    while (angle > 180.0f)

                    {

                        angle -= 360.0f;

                    }



                    while (angle < -180.0f)

                    {

                        angle += 360.0f;

                    }



                    newStatusText = string.Format(

                        _contextStatusBarWithAngleFormat,

                        xString,

                        unitsAbbreviationXY,

                        yString,

                        unitsAbbreviationXY,

                        widthString,

                        unitsAbbreviationWH,

                        heightString,

                        unitsAbbreviationWH,

                        areaString,

                        pluralUnits.ToLower(),

                        moveTool.HostAngle.ToString("N", nfi2));

                }

                else

                {

                    newStatusText = string.Format(

                        _contextStatusBarFormat,

                        xString,

                        unitsAbbreviationXY,

                        yString,

                        unitsAbbreviationXY,

                        widthString,

                        unitsAbbreviationWH,

                        heightString,

                        unitsAbbreviationWH,

                        areaString,

                        pluralUnits.ToLower());

                }



                SetStatus(newStatusText, PdnResources.GetImageResource("Icons.SelectionIcon.png"));

            }

        }



        private void SelectionChanged(object sender, EventArgs e)

        {

            UpdateRulerSelectionTinting();

            UpdateSelectionInfoInStatusBar();

        }



        private void InitializeComponent()

        {

            _toolPulseTimer = new System.Windows.Forms.Timer {Interval = 16};

            _toolPulseTimer.Tick += ToolPulseTimerTick;

        }



        protected override void Dispose(bool disposing)

        {

            if (disposing)

            {

                if (Tool != null)

                {

                    Tool.Dispose();

                    Tool = null;

                }

            }



            base.Dispose(disposing);

        }



        public void PerformActionAsync(DocumentWorkspaceAction action)

        {

            BeginInvoke(new Procedure<DocumentWorkspaceAction>(PerformAction), new object[] { action });

        }



        public void PerformAction(DocumentWorkspaceAction action)

        {

            bool nullTool = false;



            if ((action.ActionFlags & ActionFlags.KeepToolActive) != ActionFlags.KeepToolActive)

            {

                PushNullTool();

                Update();

                nullTool = true;

            }



            try

            {

                using (new WaitCursorChanger(this))

                {

                    HistoryMemento ha = action.PerformAction(this);



                    if (ha != null)

                    {

                        History.PushNewMemento(ha);

                    }

                }

            }



            finally

            {

                if (nullTool)

                {

                    PopNullTool();

                }

            }

        }



        /// <summary>

        /// Executes a HistoryFunction in the context of this DocumentWorkspace.

        /// </summary>

        /// <param name="function">The HistoryFunction to execute.</param>

        /// <remarks>

        /// Depending on the HistoryFunction, the currently active tool may be refreshed.

        /// </remarks>

        public HistoryFunctionResult ExecuteFunction(HistoryFunction function)

        {

            HistoryFunctionResult result;



            bool nullTool = false;



            if ((function.ActionFlags & ActionFlags.KeepToolActive) != ActionFlags.KeepToolActive)

            {

                PushNullTool();

                Update();

                nullTool = true;

            }



            try

            {

                using (new WaitCursorChanger(this))

                {

                    HistoryMemento hm = null;

                    string errorText;



                    try

                    {

                        bool cancelled = false;



                        if ((function.ActionFlags & ActionFlags.ReportsProgress) != ActionFlags.ReportsProgress)

                        {

                            hm = function.Execute(this);

                        }

                        else

                        {

                            var pd = new ProgressDialog();

                            bool pdLoaded = false;

                            bool closeAtLoad = false;



                            EventHandler loadCallback =

                                delegate

                                    {

                                    pdLoaded = true;



                                    if (closeAtLoad)

                                    {

                                        pd.Close();

                                    }

                                };



                            ProgressEventHandler progressCallback =

                                delegate(object sender, ProgressEventArgs e)

                                {

                                    if (!pdLoaded)

                                    {

                                    }

                                    else

                                    {

                                        double newValue = Utility.Clamp(e.Percent, 0.0, 100.0);

                                        pd.Value = newValue;

                                    }

                                };



                            EventHandler<EventArgs<HistoryMemento>> finishedCallback =

                                delegate(object sender, EventArgs<HistoryMemento> e)

                                {

                                    hm = e.Data;



                                    if (pdLoaded)

                                    {

                                        // TODO: fix ProgressDialog's very weird interface

                                        pd.ExternalFinish();

                                        pd.Close();

                                    }

                                    else

                                    {

                                        closeAtLoad = true;

                                    }

                                };



                            EventHandler cancelClickCallback =

                                delegate

                                    {

                                    cancelled = true;

                                    function.RequestCancel();

                                    //pd.Cancellable = false;

                                };



                            pd.Text = PdnInfo.GetBareProductName();

                            pd.Description = PdnResources.GetString("ExecuteFunction.ProgressDialog.Description.Text");

                            pd.Load += loadCallback;

                            pd.Cancellable = false; //function.Cancellable;

                            pd.CancelClick += cancelClickCallback;

                            function.Progress += progressCallback;

                            function.BeginExecute(this, this, finishedCallback);

                            pd.ShowDialog(this);

                            pd.Dispose();

                        }



                        if (hm == null && !cancelled)

                        {

                            result = HistoryFunctionResult.SuccessNoOp;

                        }

                        else if (hm == null && cancelled)

                        {

                            result = HistoryFunctionResult.Cancelled;

                        }

                        else

                        {

                            result = HistoryFunctionResult.Success;

                        }



                        errorText = null;

                    }



                    catch (HistoryFunctionNonFatalException hfnfex)

                    {

                        if (hfnfex.InnerException is OutOfMemoryException)

                        {

                            result = HistoryFunctionResult.OutOfMemory;

                        }

                        else

                        {

                            result = HistoryFunctionResult.NonFatalError;

                        }



                        if (hfnfex.LocalizedErrorText != null)

                        {

                            errorText = hfnfex.LocalizedErrorText;

                        }

                        else

                        {

                            if (hfnfex.InnerException is OutOfMemoryException)

                            {

                                errorText = PdnResources.GetString("ExecuteFunction.GenericOutOfMemory");

                            }

                            else

                            {

                                errorText = PdnResources.GetString("ExecuteFunction.GenericError");

                            }

                        }

                    }



                    if (errorText != null)

                    {

                        Utility.ErrorBox(this, errorText);

                    }



                    if (hm != null)

                    {

                        History.PushNewMemento(hm);

                    }

                }

            }



            finally

            {

                if (nullTool)

                {

                    PopNullTool();

                }

            }



            return result;

        }



        public override void ZoomIn()

        {

            ZoomBasis = ZoomBasis.ScaleFactor;

            base.ZoomIn();

        }



        public override void ZoomIn(double factor)

        {

            ZoomBasis = ZoomBasis.ScaleFactor;

            base.ZoomIn(factor);

        }



        public override void ZoomOut()

        {

            ZoomBasis = ZoomBasis.ScaleFactor;

            base.ZoomOut();

        }



        public override void ZoomOut(double factor)

        {

            ZoomBasis = ZoomBasis.ScaleFactor;

            base.ZoomOut(factor);

        }



        // TODO:

        /// <summary>

        /// Same as PerformAction(Type) except it lets you rename the HistoryMemento's name.

        /// </summary>

        /// <param name="actionType"></param>

        /// <param name="newName"></param>

        /// <param name="icon"></param>

        public void PerformAction(Type actionType, string newName, ImageResource icon)

        {

            using (new WaitCursorChanger(this))

            {

                ConstructorInfo ci = actionType.GetConstructor(new[] { typeof(DocumentWorkspace) });

                object actionAsObject = ci.Invoke(new object[] { this });

                var action = actionAsObject as DocumentWorkspaceAction;



                if (action == null)

                {

                }

                else

                {

                    bool nullTool = false;



                    if ((action.ActionFlags & ActionFlags.KeepToolActive) != ActionFlags.KeepToolActive)

                    {

                        PushNullTool();

                        Update();

                        nullTool = true;

                    }



                    try

                    {

                        HistoryMemento ha = action.PerformAction(this);



                        if (ha != null)

                        {

                            ha.Name = newName;

                            ha.Image = icon;

                            History.PushNewMemento(ha);

                        }

                    }



                    finally

                    {

                        if (nullTool)

                        {

                            PopNullTool();

                        }

                    }

                }

            }

        }

        

        public event EventHandler ZoomBasisChanging;

        protected virtual void OnZoomBasisChanging()

        {

            if (ZoomBasisChanging != null)

            {

                ZoomBasisChanging(this, EventArgs.Empty);

            }

        }



        public event EventHandler ZoomBasisChanged;

        protected virtual void OnZoomBasisChanged()

        {

            if (ZoomBasisChanged != null)

            {

                ZoomBasisChanged(this, EventArgs.Empty);

            }

        }



        public ZoomBasis ZoomBasis

        {

            get

            {

                return _zoomBasis;

            }



            set

            {

                if (_zoomBasis == value) return;

                OnZoomBasisChanging();

                _zoomBasis = value;



                switch (_zoomBasis)

                {

                    case ZoomBasis.FitToWindow:

                        ZoomToWindow();



                        // Enable PanelAutoScroll only long enough to recenter the view

                        PanelAutoScroll = true;

                        PanelAutoScroll = false;



                        // this would be unset by the scalefactor changes in ZoomToWindow

                        _zoomBasis = ZoomBasis.FitToWindow;

                        break;



                    case ZoomBasis.ScaleFactor:

                        PanelAutoScroll = true;

                        break;



                    default:

                        throw new InvalidEnumArgumentException();

                }



                OnZoomBasisChanged();

            }

        }



        public void ZoomToSelection()

        {

            if (Selection.IsEmpty)

            {

                ZoomToWindow();

            }

            else

            {

                using (PdnRegion region = Selection.CreateRegion())

                {

                    ZoomToRectangle(region.GetBoundsInt());

                }

            }

        }



        public void ZoomToRectangle(Rectangle selectionBounds)

        {

            var selectionCenter = new PointF((selectionBounds.Left + selectionBounds.Right + 1) / 2,

                (selectionBounds.Top + selectionBounds.Bottom + 1) / 2);



            ScaleFactor zoom = ScaleFactor.Min(ClientRectangleMin.Width, selectionBounds.Width + 2,

                                               ClientRectangleMin.Height, selectionBounds.Height + 2,

                                               ScaleFactor.MinValue);



            // Zoom out to fit the image

            ZoomBasis = ZoomBasis.ScaleFactor;

            ScaleFactor = zoom;



            var cornerPosition = new PointF(selectionCenter.X - (VisibleDocumentRectangleF.Width / 2),

                                               selectionCenter.Y - (VisibleDocumentRectangleF.Height / 2));



            DocumentScrollPositionF = cornerPosition;

        }



        protected override void HandleMouseWheel(Control sender, MouseEventArgs e)

        {

            if (ModifierKeys == Keys.Control)

            {

                double mouseDelta = (double)e.Delta / 120.0f;

                Rectangle visibleDocBoundsStart = VisibleDocumentBounds;

                Point mouseDocPt = MouseToDocument(sender, new Point(e.X, e.Y));

                RectangleF visibleDocDocRect1 = VisibleDocumentRectangleF;



                var mouseNPt = new PointF(

                    (mouseDocPt.X - visibleDocDocRect1.X) / visibleDocDocRect1.Width,

                    (mouseDocPt.Y - visibleDocDocRect1.Y) / visibleDocDocRect1.Height);



                const double factor = 1.12;

                double mouseFactor = Math.Pow(factor, Math.Abs(mouseDelta));



                if (e.Delta > 0)

                {

                    ZoomIn(mouseFactor);

                }

                else if (e.Delta < 0)

                {

                    ZoomOut(mouseFactor);

                }



                RectangleF visibleDocDocRect2 = VisibleDocumentRectangleF;



                var scrollPt2 = new PointF(

                    mouseDocPt.X - visibleDocDocRect2.Width * mouseNPt.X,

                    mouseDocPt.Y - visibleDocDocRect2.Height * mouseNPt.Y);



                DocumentScrollPositionF = scrollPt2;



                Rectangle visibleDocBoundsEnd = VisibleDocumentBounds;



                if (visibleDocBoundsEnd != visibleDocBoundsStart)

                {

                    // Make sure the screen updates, otherwise it can get a little funky looking

                    Update();

                }

            }



            base.HandleMouseWheel(sender, e);

        }



        public void SelectClosestVisibleLayer(Layer layer)

        {

            int oldLayerIndex = Document.Layers.IndexOf(layer);

            int newLayerIndex = oldLayerIndex;



            // find the closest layer that is still visible

            for (int i = 0; i < Document.Layers.Count; ++i)

            {

                int lower = oldLayerIndex - i;

                int upper = oldLayerIndex + i;



                if (lower >= 0 && lower < Document.Layers.Count && ((Layer)Document.Layers[lower]).Visible)

                {

                    newLayerIndex = lower;

                    break;

                }



                if (upper < 0 || upper >= Document.Layers.Count || !((Layer) Document.Layers[upper]).Visible) continue;

                newLayerIndex = upper;

                break;

            }



            if (newLayerIndex != oldLayerIndex)

            {

                ActiveLayer = (Layer)Document.Layers[newLayerIndex];

            }

        }



        public void UpdateRulerSelectionTinting()

        {

            if (!RulersEnabled) return;

            Rectangle bounds = Selection.GetBounds();

            SetHighlightRectangle(bounds);

        }



        private void LayerRemovingHandler(object sender, IndexEventArgs e)

        {

            var layer = (Layer)Document.Layers[e.Index];

            layer.PropertyChanging -= LayerPropertyChangingHandler;

            layer.PropertyChanged -= LayerPropertyChangedHandler;



            // pick a new valid layer!

            int newLayerIndex;



            if (e.Index == Document.Layers.Count - 1)

            {

                newLayerIndex = e.Index - 1;

            }

            else

            {

                newLayerIndex = e.Index + 1;

            }



            if (newLayerIndex >= 0 && newLayerIndex < Document.Layers.Count)

            {

                ActiveLayer = (Layer)Document.Layers[newLayerIndex];

            }

            else

            {

                if (Document.Layers.Count == 0)

                {

                    ActiveLayer = null;

                }

                else

                {

                    ActiveLayer = (Layer)Document.Layers[0];

                }

            }

        }



        private static void LayerRemovedHandler(object sender, IndexEventArgs e)

        {

        }



        private void LayerInsertedHandler(object sender, IndexEventArgs e)

        {

            var layer = (Layer)Document.Layers[e.Index];

            ActiveLayer = layer;

            layer.PropertyChanging += LayerPropertyChangingHandler;

            layer.PropertyChanged += LayerPropertyChangedHandler;

        }



        private void LayerPropertyChangingHandler(object sender, PropertyEventArgs e)

        {

            string nameFormat = PdnResources.GetString("LayerPropertyChanging.HistoryMementoNameFormat");

            string haName = string.Format(nameFormat, e.PropertyName);



            var lpha = new LayerPropertyHistoryMemento(

                haName,

                PdnResources.GetImageResource("Icons.MenuLayersLayerPropertiesIcon.png"),

                this,

                Document.Layers.IndexOf(sender));



            History.PushNewMemento(lpha);

        }



        private void LayerPropertyChangedHandler(object sender, PropertyEventArgs e)

        {

            var layer = (Layer)sender;



            if (!layer.Visible && 

                layer == ActiveLayer && 

                Document.Layers.Count > 1 &&

                !History.IsExecutingMemento)

            {

                SelectClosestVisibleLayer(layer);

            }

        }



        private void ToolPulseTimerTick(object sender, EventArgs e)

        {

            if (FindForm() == null || FindForm().WindowState == FormWindowState.Minimized)

            {

                return;

            }



            if (Tool != null && Tool.Active)

            {

                Tool.PerformPulse();

            }

        }



        protected override void OnLoad(EventArgs e)

        {

            if (_appWorkspace == null)

            {

                throw new InvalidOperationException("Must set the Workspace property");

            }



            base.OnLoad(e);

        }



        public event EventHandler ActiveLayerChanging;

        protected void OnLayerChanging()

        {

            if (ActiveLayerChanging != null)

            {

                ActiveLayerChanging(this, EventArgs.Empty);

            }

        }



        public event EventHandler ActiveLayerChanged;

        protected void OnLayerChanged()

        {

            Focus();



            if (ActiveLayerChanged != null)

            {

                ActiveLayerChanged(this, EventArgs.Empty);

            }

        }



        public Layer ActiveLayer

        {

            get

            {

                return _activeLayer;

            }



            set

            {

                OnLayerChanging();



                bool deactivateTool = Tool != null && Tool.DeactivateOnLayerChange;



                if (deactivateTool)

                {

                    PushNullTool();

                    EnableToolPulse = false;

                }



                try

                {

                    // Verify that the layer is in the document (sanity checking)

                    if (Document != null)

                    {

                        if (value != null && !Document.Layers.Contains(value))

                        {

                            throw new InvalidOperationException("ActiveLayer was changed to a layer that is not contained within the Document");

                        }

                    }

                    else

                    {   

                        // Document == null

                        if (value != null)

                        {

                            throw new InvalidOperationException("ActiveLayer was set to non-null while Document was null");

                        }

                    }



                    // Finally, set the field.

                    _activeLayer = value;

                }



                finally

                {

                    if (deactivateTool)

                    {

                        PopNullTool();

                        EnableToolPulse = true;

                    }

                }



                OnLayerChanged();

            }

        }



        public int ActiveLayerIndex

        {

            get

            {

                return Document.Layers.IndexOf(ActiveLayer);

            }



            set

            {

                ActiveLayer = (Layer)Document.Layers[value];

            }

        }



        public bool EnableToolPulse

        {

            get

            {

                return _toolPulseTimer.Enabled;

            }



            set

            {

                _toolPulseTimer.Enabled = value;

            }

        }



        public HistoryStack History

        {

            get

            {

                return _history;

            }

        }



        public Tool Tool { get; private set; }



        public Type GetToolType()

        {

            return Tool != null ? Tool.GetType() : null;

        }



        public void SetToolFromType(Type toolType)

        {

            if (toolType == GetToolType())

            {

                return;

            }

            if (toolType == null)

            {

                SetTool(null);

            }

            else

            {

                Tool newTool = CreateTool(toolType);

                SetTool(newTool);

            }

        }



        public void PushNullTool()

        {

            if (_nullToolCount == 0)

            {

                _preNullTool = GetToolType();

                SetTool(null);

                _nullToolCount = 1;

            }

            else

            {

                ++_nullToolCount;

            }

        }



        public void PopNullTool()

        {

            --_nullToolCount;



            if (_nullToolCount == 0)

            {

                SetToolFromType(_preNullTool);

                _preNullTool = null;

            }

            else if (_nullToolCount < 0)

            {

                throw new InvalidOperationException("PopNullTool() call was not matched with PushNullTool()");

            }

        }



        public Type PreviousActiveToolType { get; private set; }



        public void SetTool(Tool copyMe)

        {

            OnToolChanging();



            if (Tool != null)

            {

                PreviousActiveToolType = Tool.GetType();

                Tool.CursorChanged -= ToolCursorChangedHandler;

                Tool.PerformDeactivate();

                Tool.Dispose();

                Tool = null;

            }



            if (copyMe == null)

            {

                EnableToolPulse = false;

            }

            else

            {

                Tracing.LogFeature("SetTool(" + copyMe.GetType().FullName + ")");

                Tool = CreateTool(copyMe.GetType());

                Tool.PerformActivate();

                Tool.CursorChanged += ToolCursorChangedHandler;



                if (_suspendToolCursorChanges <= 0)

                {

                    Cursor = Tool.Cursor;

                }



                EnableToolPulse = true;

            }



            OnToolChanged();

        }



        public Tool CreateTool(Type toolType)

        {

            return CreateTool(toolType, this);

        }



        private static Tool CreateTool(Type toolType, DocumentWorkspace dc)

        {

            ConstructorInfo ci = toolType.GetConstructor(new[] { typeof(DocumentWorkspace) });

            var tool = (Tool)ci.Invoke(new object[] { dc });

            return tool;

        }



        private static void InitializeTools()

        {

            // add all the tools

            _tools = new[] 

            {

                typeof(RectangleSelectTool),

                typeof(MoveTool),

                typeof(LassoSelectTool),

                typeof(MoveSelectionTool),



                typeof(EllipseSelectTool),

                typeof(ZoomTool),



                typeof(MagicWandTool),

                typeof(PanTool),



                typeof(PaintBucketTool),

                typeof(GradientTool),



                typeof(PaintBrushTool),

                typeof(EraserTool),

                typeof(PencilTool),

                typeof(ColorPickerTool),

                typeof(CloneStampTool), 

                typeof(RecolorTool),

                typeof(TextTool),



                typeof(LineTool),

                typeof(RectangleTool),

                typeof(RoundedRectangleTool),

                typeof(EllipseTool),

                typeof(FreeformShapeTool),

            };

        }



        private static void InitializeToolInfos()

        {

            int i = 0;

            _toolInfos = new ToolInfo[_tools.Length];



            foreach (Type toolType in _tools)

            {

                using (Tool tool = CreateTool(toolType, null))

                {

                    _toolInfos[i] = tool.Info;

                    ++i;

                }

            }

        }



        public static Type[] Tools

        {

            get

            {

                return (Type[])_tools.Clone();

            }

        }



        public static ToolInfo[] ToolInfos

        {

            get

            {

                return (ToolInfo[])_toolInfos.Clone();

            }

        }



        public event EventHandler ToolChanging;

        protected void OnToolChanging()

        {

            if (ToolChanging != null)

            {

                ToolChanging(this, EventArgs.Empty);

            }

        }



        public event EventHandler ToolChanged;

        protected void OnToolChanged()

        {

            if (ToolChanged != null)

            {

                ToolChanged(this, EventArgs.Empty);

            }

        }



        private void ToolCursorChangedHandler(object sender, EventArgs e)

        {

            if (_suspendToolCursorChanges <= 0)

            {

                Cursor = Tool.Cursor;

            }

        }



        // Note: static tool data is removed whenever the Document changes

        // TODO: shouldn't this be moved to the Tool class somehow?

        public object GetStaticToolData(Type toolType)

        {

            return _staticToolData[toolType];

        }



        public void SetStaticToolData(Type toolType, object data)

        {

            _staticToolData[toolType] = data;

        }



        public AppWorkspace AppWorkspace

        {

            get

            {

                return _appWorkspace;

            }



            set

            {

                _appWorkspace = value;

            }

        }



        public Selection Selection

        {

            get

            {

                return _selection;

            }

        }



        public bool EnableOutlineAnimation

        {

            get

            {

                return _selectionRenderer.EnableOutlineAnimation;

            }



            set

            {

                _selectionRenderer.EnableOutlineAnimation = value;

            }

        }



        public bool EnableSelectionOutline

        {

            get

            {

                return _selectionRenderer.EnableSelectionOutline;

            }



            set

            {

                _selectionRenderer.EnableSelectionOutline = value;

            }

        }



        public bool EnableSelectionTinting

        {

            get

            {

                return _selectionRenderer.EnableSelectionTinting;

            }



            set

            {

                _selectionRenderer.EnableSelectionTinting = value;

            }

        }



        public void ResetOutlineWhiteOpacity()

        {

            _selectionRenderer.ResetOutlineWhiteOpacity();

        }



        public event EventHandler FilePathChanged;

        protected virtual void OnFilePathChanged()

        {

            if (FilePathChanged != null)

            {

                FilePathChanged(this, EventArgs.Empty);

            }

        }



        public string FilePath { get; private set; }



        public string GetFriendlyName()

        {

            string friendlyName = FilePath != null ? Path.GetFileName(FilePath) : PdnResources.GetString("Untitled.FriendlyName");



            return friendlyName;

        }



        public FileType FileType { get; private set; }



        public SaveConfigToken SaveConfigToken

        {

            get

            {

                if (_saveConfigToken == null)

                {

                    return null;

                }

                return (SaveConfigToken)_saveConfigToken.Clone();

            }

        }



        public event EventHandler SaveOptionsChanged;

        protected virtual void OnSaveOptionsChanged()

        {

            if (SaveOptionsChanged != null)

            {

                SaveOptionsChanged(this, EventArgs.Empty);

            }

        }



        /// <summary>

        /// Sets the FileType and SaveConfigToken parameters that are used if the

        /// user chooses "Save" from the File menu. These are not used by the

        /// DocumentControl class and should be used by whoever actually goes

        /// to save the Document instance.

        /// </summary>

        /// <param name="fileType"></param>

        /// <param name="saveParameters"></param>

        /// <param name="newFilePath"></param>

        /// <param name="newFileType"></param>

        /// <param name="newSaveConfigToken"></param>

        public void SetDocumentSaveOptions(string newFilePath, FileType newFileType, SaveConfigToken newSaveConfigToken)

        {

            FilePath = newFilePath;

            OnFilePathChanged();



            FileType = newFileType;



            if (newSaveConfigToken == null)

            {

                _saveConfigToken = null;

            }

            else

            {

                _saveConfigToken = (SaveConfigToken)newSaveConfigToken.Clone();

            }



            OnSaveOptionsChanged();

        }



        public void GetDocumentSaveOptions(out string filePathResult, out FileType fileTypeResult, out SaveConfigToken saveConfigTokenResult)

        {

            filePathResult = FilePath;

            fileTypeResult = FileType;



            if (_saveConfigToken == null)

            {

                saveConfigTokenResult = null;

            }

            else

            {

                saveConfigTokenResult = (SaveConfigToken)_saveConfigToken.Clone();

            }

        }



        private bool _isScratchSurfaceBorrowed;

        private string _borrowScratchSurfaceReason = string.Empty;



        /// The scratch, stencil, accumulation, whatever buffer. This is used by many parts

        /// of Paint.NET as a temporary area for which to store data.

        /// This surface is 'owned' by any Tool that is active. If you want to use this you

        /// must first deactivate the Tool using PushNullTool() and then reactivate it when 

        /// you are finished by calling PopNullTool().

        /// Tools should use Tool.ScratchSurface instead of these API's.



        public Surface BorrowScratchSurface(string reason)

        {

            if (_isScratchSurfaceBorrowed)

            {

                throw new InvalidOperationException(

                    "ScratchSurface already borrowed: '" + 

                    _borrowScratchSurfaceReason + 

                    "' (trying to borrow for: '" + reason + "')");

            }



            Tracing.Ping("Borrowing scratchSurface: " + reason);

            _isScratchSurfaceBorrowed = true;

            _borrowScratchSurfaceReason = reason;

            return _scratchSurface;

        }



        public void ReturnScratchSurface(Surface borrowedScratchSurface)

        {

            if (!_isScratchSurfaceBorrowed)

            {

                throw new InvalidOperationException("ScratchSurface wasn't borrowed");

            }



            if (_scratchSurface != borrowedScratchSurface)

            {

                throw new InvalidOperationException("returned ScratchSurface doesn't match the real one");

            }



            Tracing.Ping("Returning scratchSurface: " + this._borrowScratchSurfaceReason);

            _isScratchSurfaceBorrowed = false;

            _borrowScratchSurfaceReason = string.Empty;

        }



        /// <summary>

        /// Updates any pertinent EXIF tags, such as "Creation Software", to be

        /// relevant or up-to-date.

        /// </summary>

        /// <param name="document"></param>

        private static void UpdateExifTags(Document document)

        {

            // We want it to say "Creation Software: Paint.NET vX.Y"

            // I have verified that other image editing software overwrites this tag,

            // and does not just add it when it does not exist.

            PropertyItem pi = Exif.CreateAscii(ExifTagID.Software, PdnInfo.GetProductName(false));

            document.Metadata.ReplaceExifValues(ExifTagID.Software, new[] { pi });

        }

        

        private ZoomBasis _savedZb;

        private ScaleFactor _savedSf;

        private int _savedAli;

        protected override void OnDocumentChanging(Document newDocument)

        {

            base.OnDocumentChanging(newDocument);



            _savedZb = ZoomBasis;

            _savedSf = ScaleFactor;



            if (ActiveLayer != null)

            {

                _savedAli = ActiveLayerIndex;

            }

            else

            {

                _savedAli = -1;

            }



            if (newDocument != null)

            {

                UpdateExifTags(newDocument);

            }



            if (Document != null)

            {

                foreach (Layer layer in Document.Layers)

                {

                    layer.PropertyChanging -= LayerPropertyChangingHandler;

                    layer.PropertyChanged -= LayerPropertyChangedHandler;

                }



                Document.Layers.RemovingAt -= LayerRemovingHandler;

                Document.Layers.RemovedAt -= LayerRemovedHandler;

                Document.Layers.Inserted -= LayerInsertedHandler;

            }

            

            _staticToolData.Clear();



            PushNullTool(); // matching Pop is in OnDocumetChanged()

            ActiveLayer = null;



            if (_scratchSurface != null)

            {

                if (_isScratchSurfaceBorrowed)

                {

                    throw new InvalidOperationException("scratchSurface is currently borrowed: " + _borrowScratchSurfaceReason);

                }



                if (newDocument == null || newDocument.Size != _scratchSurface.Size)

                {

                    _scratchSurface.Dispose();

                    _scratchSurface = null;

                }

            }



            if (!Selection.IsEmpty)

            {

                Selection.Reset();

            }

        }



        protected override void OnDocumentChanged()

        {

            // if the ActiveLayer is not in this new document, then

            // we try to set ActiveLayer to the first layer in this

            // new document. But if the document contains no layers,

            // or is null, we just null the ActiveLayer.

            if (Document == null)

            {

                ActiveLayer = null;

            }

            else

            {

                if (Tool != null)

                {

                    throw new InvalidOperationException("Tool was not deactivated while Document was being changed");

                }



                if (_scratchSurface != null)

                {

                    if (_isScratchSurfaceBorrowed)

                    {

                        throw new InvalidOperationException("scratchSurface is currently borrowed: " + _borrowScratchSurfaceReason);

                    }



                    if (_scratchSurface.Size != Document.Size)

                    {

                        _scratchSurface.Dispose();

                        _scratchSurface = null;

                    }

                }



                _scratchSurface = new Surface(Document.Size);



                Selection.ClipRectangle = Document.Bounds;



                foreach (Layer layer in Document.Layers)

                {

                    layer.PropertyChanging += LayerPropertyChangingHandler;

                    layer.PropertyChanged += LayerPropertyChangedHandler;

                }



                Document.Layers.RemovingAt += LayerRemovingHandler;

                Document.Layers.RemovedAt += LayerRemovedHandler;

                Document.Layers.Inserted += LayerInsertedHandler;



                if (!Document.Layers.Contains(ActiveLayer))

                {

                    if (Document.Layers.Count > 0)

                    {

                        if (_savedAli >= 0 && _savedAli < Document.Layers.Count)

                        {

                            ActiveLayer = (Layer)Document.Layers[_savedAli];

                        }

                        else

                        {

                            ActiveLayer = (Layer)Document.Layers[0];

                        }

                    }

                    else

                    {

                        ActiveLayer = null;

                    }

                }



                // we invalidate each layer so that the layer previews refresh themselves

                foreach (Layer layer in Document.Layers)

                {

                    layer.Invalidate();

                }



                bool oldDirty = Document.Dirty;

                Document.Invalidate();

                Document.Dirty = oldDirty;



                ZoomBasis = _savedZb;

                if (_savedZb == ZoomBasis.ScaleFactor)

                {

                    ScaleFactor = _savedSf;

                }

            }



            PopNullTool();

            AutoScrollPosition = new Point(0, 0);



            base.OnDocumentChanged();

        }



        /// <summary>

        /// Takes the current Document from this DocumentWorkspace instance and adds it to the MRU list.

        /// </summary>

        /// <param name="fileName"></param>

        public void AddToMruList()

        {

            using (new PushNullToolMode(this))

            {

                string fullFileName = Path.GetFullPath(FilePath);

                int edgeLength = AppWorkspace.MostRecentFiles.IconSize;

                Surface thumb1 = RenderThumbnail(edgeLength, true, true);



                // Put it inside a square bitmap

                var thumb = new Surface(4 + edgeLength, 4 + edgeLength);



                thumb.Clear(ColorBgra.Transparent);



                var dstRect = new Rectangle((thumb.Width - thumb1.Width) / 2,

                    (thumb.Height - thumb1.Height) / 2, thumb1.Width, thumb1.Height);



                thumb.CopySurface(thumb1, dstRect.Location);



                using (var ra = new RenderArgs(thumb))

                {

                    // Draw black border

                    var borderRect = new Rectangle(dstRect.Left - 1, dstRect.Top - 1, dstRect.Width + 2, dstRect.Height + 2);

                    --borderRect.Width;

                    --borderRect.Height;

                    ra.Graphics.DrawRectangle(Pens.Black, borderRect);



                    Rectangle shadowRect = Rectangle.Inflate(borderRect, 1, 1);

                    ++shadowRect.Width;

                    ++shadowRect.Height;

                    Utility.DrawDropShadow1Px(ra.Graphics, shadowRect);



                    thumb1.Dispose();

                    thumb1 = null;



                    var mrf = new MostRecentFile(fullFileName, Utility.FullCloneBitmap(ra.Bitmap));



                    if (AppWorkspace.MostRecentFiles.Contains(fullFileName))

                    {

                        AppWorkspace.MostRecentFiles.Remove(fullFileName);

                    }



                    AppWorkspace.MostRecentFiles.Add(mrf);

                    AppWorkspace.MostRecentFiles.SaveMruList();

                }

            }

        }



        /// <summary>

        /// Shows an OpenFileDialog or SaveFileDialog and populates the InitialDirectory from the global

        /// settings repository if possible.

        /// </summary>

        /// <param name="owner"></param>

        /// <param name="fd">The FileDialog to show.</param>

        /// <remarks>

        /// The FileDialog should already have its InitialDirectory populated as a suggestion of where to start.

        /// </remarks>

        public static DialogResult ShowFileDialog(Control owner, IFileDialog fd)

        {

            string initialDirectory = Settings.CurrentUser.GetString(SettingNames.LastFileDialogDirectory, fd.InitialDirectory);



            // TODO: spawn this in a background thread, if it doesn't respond within ~500ms?, assume the dir doesn't exist

            bool dirExists = false;



            try 

            {

                var dirInfo = new DirectoryInfo(initialDirectory);



                using (new WaitCursorChanger(owner))

                {

                    dirExists = dirInfo.Exists;



                    if (!dirInfo.Exists)

                    {

                        initialDirectory = fd.InitialDirectory;

                    }

                }

            }



            catch (Exception)

            {

                initialDirectory = fd.InitialDirectory;

            }



            fd.InitialDirectory = initialDirectory;



            var ouc = new OurFileDialogUICallbacks();

            DialogResult result = fd.ShowDialog(owner, ouc);



            if (result == DialogResult.OK)

            {

                string fileName;

                

                if (fd is IFileOpenDialog)

                {

                    string[] fileNames = ((IFileOpenDialog)fd).FileNames;



                    fileName = fileNames.Length > 0 ? fileNames[0] : null;

                }

                else if (fd is IFileSaveDialog)

                {

                    fileName = ((IFileSaveDialog)fd).FileName;

                }

                else

                {

                    throw new InvalidOperationException();

                }



                if (fileName != null)

                {

                    string newDir = Path.GetDirectoryName(fileName);

                    Settings.CurrentUser.SetString(SettingNames.LastFileDialogDirectory, newDir);

                }

                else

                {

                    throw new FileNotFoundException();

                }

            }



            return result;

        }



        private sealed class OurFileDialogUICallbacks

            : IFileDialogUICallbacks

        {

            public FileOverwriteAction ShowOverwritePrompt(IWin32Window owner, string pathName)

            {

                FileOverwriteAction returnVal;



                string title = PdnResources.GetString("SaveAs.OverwriteConfirmation.Title");

                string textFormat = PdnResources.GetString("SaveAs.OverwriteConfirmation.Text.Format");

                string fileName;



                try

                {

                    fileName = Path.GetFileName(pathName);

                }



                catch (Exception)

                {

                    fileName = pathName;

                }



                string text = string.Format(textFormat, fileName);



                DialogResult result = MessageBox.Show(owner, text, title, MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button2);



                switch (result)

                {

                    case DialogResult.Yes:

                        returnVal = FileOverwriteAction.Overwrite;

                        break;



                    case DialogResult.No:

                        returnVal = FileOverwriteAction.Cancel;

                        break;



                    default:

                        throw new InvalidEnumArgumentException();

                }



                return returnVal;

            }



            public bool ShowError(IWin32Window owner, string filePath, Exception ex)

            {

                if (!(ex is PathTooLongException))

                {

                    return false;

                }

                string title = PdnInfo.GetBareProductName();

                string message = PdnResources.GetString("FileDialog.PathTooLongException.Message");



                MessageBox.Show(owner, message, title, MessageBoxButtons.OK, MessageBoxIcon.Error);



                return true;

            }



            public IFileTransferProgressEvents CreateFileTransferProgressEvents()

            {

                return new OurProgressEvents();

            }

        }



        private sealed class OurProgressEvents

            : IFileTransferProgressEvents

        {

            private TransferProgressDialog _progressDialog;

            private ICancelable _cancelSink;

            private int _itemCount;

            private int _itemOrdinal;

            private string _itemName = string.Empty;

            private long _totalWork;

            private long _totalProgress;

            private const int MaxPBValue = 200; // granularity of progress bar. 100 means 1%, 200 means 0.5%, etc.

            private bool _cancelRequested;



            private ManualResetEvent _operationEnded = new ManualResetEvent(false);



            [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "cancelSink")]

            public void BeginOperation(IWin32Window owner, EventHandler callWhenUIShown, ICancelable cancelSink)

            {

                if (_progressDialog != null)

                {

                    throw new InvalidOperationException("Operation already in progress");

                }



                _progressDialog = new TransferProgressDialog

                                      {

                                          Text =

                                              PdnResources.GetString(

                                                  "DocumentWorkspace.ShowFileDialog.TransferProgress.Title"),

                                          Icon =

                                              Utility.ImageToIcon(

                                                  PdnResources.GetImageResource("Icons.MenuFileOpenIcon.png").Reference),

                                          ItemText =

                                              PdnResources.GetString(

                                                  "DocumentWorkspace.ShowFileDialog.ItemText.Initializing"),

                                          ProgressBar =

                                              {

                                                  Style = ProgressBarStyle.Marquee,

                                                  Maximum = MaxPBValue

                                              }

                                      };



                _progressDialog.CancelClicked +=

                    delegate

                        {

                        _cancelRequested = true;

                        _cancelSink.RequestCancel();

                        UpdateUI();

                    };



                EventHandler progressDialogShown =

                    (sender, e) => callWhenUIShown(this, EventArgs.Empty);



                _cancelSink = cancelSink;

                _itemOrdinal = 0;

                _cancelRequested = false;

                _itemName = string.Empty;

                _itemCount = 0;

                _itemOrdinal = 0;

                _totalProgress = 0;

                _totalWork = 0;



                _progressDialog.Shown += progressDialogShown;

                _progressDialog.ShowDialog(owner);

                _progressDialog.Shown -= progressDialogShown;



                _progressDialog.Dispose();

                _progressDialog = null;

                _cancelSink = null;

            }



            [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "itemCount")]

            public void SetItemCount(int itemCount)

            {

                if (_progressDialog.InvokeRequired)

                {

                    _progressDialog.BeginInvoke(new Procedure<int>(SetItemCount), new object[] { itemCount });

                }

                else

                {

                    _itemCount = itemCount;

                    UpdateUI();

                }

            }



            [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "itemOrdinal")]

            public void SetItemOrdinal(int itemOrdinal)

            {

                if (_progressDialog.InvokeRequired)

                {

                    _progressDialog.BeginInvoke(new Procedure<int>(SetItemOrdinal), new object[] { itemOrdinal });

                }

                else

                {

                    _itemOrdinal = itemOrdinal;

                    _totalWork = 0;

                    _totalProgress = 0;

                    UpdateUI();

                }

            }



            public void SetItemInfo(string itemInfo)

            {

                if (_progressDialog.InvokeRequired)

                {

                    _progressDialog.BeginInvoke(new Procedure<string>(SetItemInfo), new object[] { itemInfo });

                }

                else

                {

                    _itemName = itemInfo;

                    UpdateUI();

                }

            }



            public void BeginItem()

            {

                if (_progressDialog.InvokeRequired)

                {

                    _progressDialog.BeginInvoke(new Procedure(BeginItem), null);

                }

                else

                {

                    _progressDialog.ProgressBar.Style = ProgressBarStyle.Continuous;

                }

            }



            [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "totalWork")]

            public void SetItemWorkTotal(long totalWork)

            {

                if (_progressDialog.InvokeRequired)

                {

                    _progressDialog.BeginInvoke(new Procedure<long>(SetItemWorkTotal), new object[] { totalWork });

                }

                else

                {

                    _totalWork = totalWork;

                    UpdateUI();

                }

            }



            [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "totalProgress")]

            public void SetItemWorkProgress(long totalProgress)

            {

                if (_progressDialog.InvokeRequired)

                {

                    _progressDialog.BeginInvoke(new Procedure<long>(SetItemWorkProgress), new object[] { totalProgress });

                }

                else

                {

                    _totalProgress = totalProgress;

                    UpdateUI();

                }

            }



            public void EndItem(WorkItemResult result)

            {

                if (_progressDialog.InvokeRequired)

                {

                    _progressDialog.BeginInvoke(new Procedure<WorkItemResult>(EndItem), new object[] { result });

                }

            }



            public void EndOperation(OperationResult result)

            {

                if (_progressDialog.InvokeRequired)

                {

                    _progressDialog.BeginInvoke(new Procedure<OperationResult>(EndOperation), new object[] { result });

                }

                else

                {

                    _progressDialog.Close();

                }

            }



            public WorkItemFailureAction ReportItemFailure(Exception ex)

            {

                if (_progressDialog.InvokeRequired)

                {

                    object result = _progressDialog.Invoke(

                        new Function<WorkItemFailureAction, Exception>(ReportItemFailure), 

                        new object[] { ex });



                    return (WorkItemFailureAction)result;

                }

                else

                {

                    WorkItemFailureAction result = ShowFileTransferFailedDialog(ex);

                    return result;

                }

            }



            private WorkItemFailureAction ShowFileTransferFailedDialog(Exception ex)

            {

                WorkItemFailureAction result;

                Icon formIcon = _progressDialog.Icon;



                string formTitle = PdnResources.GetString("DocumentWorkspace.ShowFileDialog.ItemFailureDialog.Title");



                Image taskImage = PdnResources.GetImageResource("Icons.WarningIcon.png").Reference;



                string introTextFormat = PdnResources.GetString("DocumentWorkspace.ShowFileDialog.ItemFailureDialog.IntroText.Format");

                string introText = string.Format(introTextFormat, ex.Message);



                var retryTB = new TaskButton(

                    PdnResources.GetImageResource("Icons.MenuImageRotate90CWIcon.png").Reference,

                    PdnResources.GetString("DocumentWorkspace.ShowFileDialog.RetryTB.ActionText"),

                    PdnResources.GetString("DocumentWorkspace.ShowFileDialog.RetryTB.ExplanationText"));



                var skipTB = new TaskButton(

                    PdnResources.GetImageResource("Icons.HistoryFastForwardIcon.png").Reference,

                    PdnResources.GetString("DocumentWorkspace.ShowFileDialog.SkipTB.ActionText"),

                    PdnResources.GetString("DocumentWorkspace.ShowFileDialog.SkipTB.ExplanationText"));



                var cancelTB = new TaskButton(

                    PdnResources.GetImageResource("Icons.CancelIcon.png").Reference,

                    PdnResources.GetString("DocumentWorkspace.ShowFileDialog.CancelTB.ActionText"),

                    PdnResources.GetString("DocumentWorkspace.ShowFileDialog.CancelTB.ExplanationText"));



                var taskButtons = new List<TaskButton> {retryTB};



                // Only have the Skip button if there is more than 1 item being transferred.

                // If only 1 item is begin transferred, Skip and Cancel are essentially synonymous.

                if (_itemCount > 1)

                {

                    taskButtons.Add(skipTB);

                }



                taskButtons.Add(cancelTB);



                int width96 = (TaskDialog.DefaultPixelWidth96Dpi * 4) / 3; // 33% wider



                TaskButton clickedTB = TaskDialog.Show(

                    _progressDialog,

                    formIcon,

                    formTitle,

                    taskImage,

                    true,

                    introText,

                    taskButtons.ToArray(),

                    retryTB,

                    cancelTB,

                    width96);



                if (clickedTB == retryTB)

                {

                    result = WorkItemFailureAction.RetryItem;

                }

                else if (clickedTB == skipTB)

                {

                    result = WorkItemFailureAction.SkipItem;

                }

                else

                {

                    result = WorkItemFailureAction.CancelOperation;

                }



                return result;

            }



            private void UpdateUI()

            {

                int itemCount2 = Math.Max(1, _itemCount);



                double startValue = (double)_itemOrdinal / (double)itemCount2;

                double endValue = (double)(_itemOrdinal + 1) / (double)itemCount2;



                long totalWork2 = Math.Max(1, _totalWork);

                double lerp = (double)_totalProgress / (double)totalWork2;



                double newValue = Utility.Lerp(startValue, endValue, lerp);

                var newValueInt = (int)Math.Ceiling(MaxPBValue * newValue);



                if (_cancelRequested)

                {

                    _progressDialog.CancelEnabled = false;

                    _progressDialog.ItemText = PdnResources.GetString("DocumentWorkspace.ShowFileDialog.ItemText.Canceling");

                    _progressDialog.OperationProgress = string.Empty;

                    _progressDialog.ProgressBar.Style = ProgressBarStyle.Marquee;

                }

                else

                {

                    _progressDialog.CancelEnabled = true;

                    _progressDialog.ItemText = _itemName;

                    string progressFormat = PdnResources.GetString("DocumentWorkspace.ShowFileDialog.ProgressText.Format");

                    string progressText = string.Format(progressFormat, _itemOrdinal + 1, _itemCount);

                    _progressDialog.OperationProgress = progressText;

                    _progressDialog.ProgressBar.Style = ProgressBarStyle.Continuous;

                    _progressDialog.ProgressBar.Value = newValueInt;

                }

            }

        }



        public static DialogResult ChooseFile(Control parent, out string fileName)

        {

            return ChooseFile(parent, out fileName, null);

        }



        public static DialogResult ChooseFile(Control parent, out string fileName, string startingDir)

        {

            string[] fileNames;

            DialogResult result = ChooseFiles(parent, out fileNames, false, startingDir);



            fileName = result == DialogResult.OK ? fileNames[0] : null;



            return result;

        }



        public static DialogResult ChooseFiles(Control owner, out string[] fileNames, bool multiselect)

        {

            return ChooseFiles(owner, out fileNames, multiselect, null);

        }



        public static DialogResult ChooseFiles(Control owner, out string[] fileNames, bool multiselect, string startingDir)

        {

            FileTypeCollection fileTypes = FileTypes.GetFileTypes();



            using (IFileOpenDialog ofd = CommonDialogs.CreateFileOpenDialog())

            {

                ofd.InitialDirectory = startingDir ?? GetDefaultSavePath();



                ofd.CheckFileExists = true;

                ofd.CheckPathExists = true;

                ofd.Multiselect = multiselect;



                ofd.Filter = fileTypes.ToString(true, PdnResources.GetString("FileDialog.Types.AllImages"), false, true);

                ofd.FilterIndex = 0;



                DialogResult result = ShowFileDialog(owner, ofd);



                fileNames = result == DialogResult.OK ? ofd.FileNames : new string[0];



                return result;

            }

        }



        /// <summary>

        /// Use this to get a save config token. You should already know the filename and file type.

        /// An existing save config token is optional and will be used to pre-populate the config dialog.

        /// </summary>

        /// <param name="fileType"></param>

        /// <param name="saveConfigToken"></param>

        /// <param name="currentSaveConfigToken"></param>

        /// <param name="newSaveConfigToken"></param>

        /// <param name="currentFileType"></param>

        /// <param name="saveScratchSurface"></param>

        /// <returns>false if the user cancelled, otherwise true</returns>

        private bool GetSaveConfigToken(

            FileType currentFileType, 

            SaveConfigToken currentSaveConfigToken, 

            out SaveConfigToken newSaveConfigToken, 

            Surface saveScratchSurface)

        {

            if (currentFileType.SupportsConfiguration)

            {

                using (var scd = new SaveConfigDialog())

                {

                    scd.ScratchSurface = saveScratchSurface;



                    ProgressEventHandler peh = delegate(object sender, ProgressEventArgs e)

                    {

                        if (e.Percent < 0 || e.Percent >= 100)

                        {

                            AppWorkspace.Widgets.StatusBarProgress.ResetProgressStatusBar();

                            AppWorkspace.Widgets.StatusBarProgress.EraseProgressStatusBar();

                        }

                        else

                        {

                            AppWorkspace.Widgets.StatusBarProgress.SetProgressStatusBar(e.Percent);

                        }

                    };



                    //if (currentFileType.SavesWithProgress)

                    {

                        scd.Progress += peh;

                    }



                    scd.Document = Document;

                    scd.FileType = currentFileType;



                    SaveConfigToken token = currentFileType.GetLastSaveConfigToken();

                    if (currentSaveConfigToken != null &&

                        token.GetType() == currentSaveConfigToken.GetType())

                    {

                        scd.SaveConfigToken = currentSaveConfigToken;

                    }



                    scd.EnableInstanceOpacity = false;



                    // show configuration/preview dialog

                    DialogResult dr = scd.ShowDialog(this);



                    //if (currentFileType.SavesWithProgress)

                    {

                        scd.Progress -= peh;

                        AppWorkspace.Widgets.StatusBarProgress.ResetProgressStatusBar();

                        AppWorkspace.Widgets.StatusBarProgress.EraseProgressStatusBar();

                    }



                    if (dr == DialogResult.OK)

                    {

                        newSaveConfigToken = scd.SaveConfigToken;

                        return true;

                    }

                    newSaveConfigToken = null;

                    return false;

                }

            }

            newSaveConfigToken = currentFileType.GetLastSaveConfigToken();

            return true;

        }



        /// <summary>

        /// Used to set the file name, file type, and save config token

        /// </summary>

        /// <param name="newFileName"></param>

        /// <param name="newFileType"></param>

        /// <param name="newSaveConfigToken"></param>

        /// <param name="saveScratchSurface"></param>

        /// <returns>true if the user clicked through and accepted, or false if they cancelled at any point</returns>

        private bool DoSaveAsDialog(

            out string newFileName, 

            out FileType newFileType, 

            out SaveConfigToken newSaveConfigToken, 

            Surface saveScratchSurface)

        {

            FileTypeCollection fileTypes = FileTypes.GetFileTypes();



            using (IFileSaveDialog sfd = CommonDialogs.CreateFileSaveDialog())

            {

                sfd.AddExtension = true;

                sfd.CheckPathExists = true;

                sfd.OverwritePrompt = true;

                string filter = fileTypes.ToString(false, null, true, false);

                sfd.Filter = filter;



                string localFileName;

                FileType localFileType;

                SaveConfigToken localSaveConfigToken;

                GetDocumentSaveOptions(out localFileName, out localFileType, out localSaveConfigToken);



                if (Document.Layers.Count > 1 && 

                    localFileType != null && 

                    !localFileType.SupportsLayers)

                {

                    localFileType = null;

                }



                if (localFileType == null)

                {

                    localFileType = Document.Layers.Count == 1 ? PdnFileTypes.Png : PdnFileTypes.Pdn;



                    localFileName = Path.ChangeExtension(localFileName, localFileType.DefaultExtension);

                }



                if (localFileName == null)

                {

                    string name = GetDefaultSaveName();

                    string newName = Path.ChangeExtension(name, localFileType.DefaultExtension);

                    localFileName = Path.Combine(GetDefaultSavePath(), newName);

                }



                // If the filename is only an extension (i.e. ".lmnop") then we must treat it specially

                string fileNameOnly = Path.GetFileName(localFileName);

                if (fileNameOnly != null)

                    if (fileNameOnly.Length >= 1 && fileNameOnly[0] == '.')

                    {

                        sfd.FileName = localFileName;

                    }

                    else

                    {

                        sfd.FileName = Path.ChangeExtension(localFileName, null);

                    }



                sfd.FilterIndex = 1 + fileTypes.IndexOfFileType(localFileType);

                sfd.InitialDirectory = Path.GetDirectoryName(localFileName);

                sfd.Title = PdnResources.GetString("SaveAsDialog.Title");



                DialogResult dr1 = ShowFileDialog(this, sfd);

                bool result;



                if (dr1 != DialogResult.OK)

                {

                    result = false;

                }

                else

                {

                    localFileName = sfd.FileName;

                    FileType fileType2 = fileTypes[sfd.FilterIndex - 1];

                    result = GetSaveConfigToken(fileType2, localSaveConfigToken, out localSaveConfigToken, saveScratchSurface);

                    localFileType = fileType2;

                }



                if (result)

                {

                    newFileName = localFileName;

                    newFileType = localFileType;

                    newSaveConfigToken = localSaveConfigToken;

                }

                else

                {

                    newFileName = null;

                    newFileType = null;

                    newSaveConfigToken = null;

                }



                return result;

            }

        }



        /// <summary>

        /// Warns the user that we need to flatten the image.

        /// </summary>

        /// <returns>Returns DialogResult.Yes if they want to proceed or DialogResult.No if they don't.</returns>

        private DialogResult WarnAboutFlattening()

        {

            Icon formIcon = Utility.ImageToIcon(PdnResources.GetImageResource("Icons.MenuFileSaveIcon.png").Reference);

            string formTitle = PdnResources.GetString("WarnAboutFlattening.Title");



            string introText = PdnResources.GetString("WarnAboutFlattening.IntroText");

            Image taskImage = null;



            var flattenTB = new TaskButton(

                PdnResources.GetImageResource("Icons.MenuImageFlattenIcon.png").Reference,

                PdnResources.GetString("WarnAboutFlattening.FlattenTB.ActionText"),

                PdnResources.GetString("WarnAboutFlattening.FlattenTB.ExplanationText"));



            var cancelTB = new TaskButton(

                TaskButton.Cancel.Image,

                PdnResources.GetString("WarnAboutFlattening.CancelTB.ActionText"),

                PdnResources.GetString("WarnAboutFlattening.CancelTB.ExplanationText"));



            TaskButton clickedTB = TaskDialog.Show(

                AppWorkspace,

                formIcon,

                formTitle,

                taskImage,

                true,

                introText,

                new[] { flattenTB, cancelTB },

                flattenTB,

                cancelTB,

                (TaskDialog.DefaultPixelWidth96Dpi * 5) / 4);



            return clickedTB == flattenTB ? DialogResult.Yes : DialogResult.No;

        }

        

        private static string GetDefaultSaveName()

        {

            return PdnResources.GetString("Untitled.FriendlyName");

        }



        private static string GetDefaultSavePath()

        {

            string myPics;



            try

            {

                myPics = Shell.GetVirtualPath(VirtualFolderName.UserPictures, false);

                var dirInfo = new DirectoryInfo(myPics); // validate

            }



            catch (Exception)

            {

                myPics = "";

            }



            string dir = Settings.CurrentUser.GetString(SettingNames.LastFileDialogDirectory, null);



            if (dir == null)

            {

                dir = myPics;

            }

            else

            {

                try

                {

                    var dirInfo = new DirectoryInfo(dir);



                    if (!dirInfo.Exists)

                    {

                        dir = myPics;

                    }

                }



                catch (Exception)

                {

                    dir = myPics;

                }

            }



            return dir;

        }



        public bool DoSave()

        {

            return DoSave(false);

        }



        /// <summary>

        /// Does the dirty work for a File->Save operation. If any of the "Save Options" in the

        /// DocumentWorkspace are null, this will call DoSaveAs(). If the image has more than 1

        /// layer but the file type they want to save with does not support layers, then it will

        /// ask the user about flattening the image.

        /// </summary>

        /// <param name="tryToFlatten">

        /// If true, will ask the user about flattening if the workspace's saveFileType does not 

        /// support layers and the image has more than 1 layer.

        /// If false, then DoSaveAs will be called and the fileType will be prepopulated with

        /// the .PDN type.

        /// </param>

        /// <returns><b>true</b> if the file was saved, <b>false</b> if the user cancelled</returns>

        protected bool DoSave(bool tryToFlatten)

        {

            using (new PushNullToolMode(this))

            {

                string newFileName;

                FileType newFileType;

                SaveConfigToken newSaveConfigToken;



                GetDocumentSaveOptions(out newFileName, out newFileType, out newSaveConfigToken);



                // if they haven't specified a filename, then revert to "Save As" behavior

                if (newFileName == null)

                {

                    return DoSaveAs();

                }



                // if we have a filename but no file type, try to infer the file type

                if (newFileType == null)

                {

                    FileTypeCollection fileTypes = FileTypes.GetFileTypes();

                    string ext = Path.GetExtension(newFileName);

                    int index = fileTypes.IndexOfExtension(ext);

                    FileType inferredFileType = fileTypes[index];

                    newFileType = inferredFileType;

                }



                // if the image has more than 1 layer but is saving with a file type that

                // does not support layers, then we must ask them if we may flatten the

                // image first

                if (Document.Layers.Count > 1 && !newFileType.SupportsLayers)

                {

                    if (!tryToFlatten)

                    {

                        return DoSaveAs();

                    }

                    DialogResult dr = WarnAboutFlattening();



                    if (dr == DialogResult.Yes)

                    {

                        ExecuteFunction(new FlattenFunction());

                    }

                    else

                    {

                        return false;

                    }

                }



                // get the configuration!

                if (newSaveConfigToken == null)

                {

                    Surface scratch = BorrowScratchSurface(GetType().Name + ".DoSave() calling GetSaveConfigToken()");



                    bool result;

                    try

                    {

                        result = GetSaveConfigToken(newFileType, newSaveConfigToken, out newSaveConfigToken, scratch);

                    }



                    finally

                    {

                        ReturnScratchSurface(scratch);

                    }



                    if (!result)

                    {

                        return false;

                    }

                }



                // At this point fileName, fileType, and saveConfigToken must all be non-null



                // if the document supports custom headers, embed a thumbnail in there

                if (newFileType.SupportsCustomHeaders)

                {

                    using (new WaitCursorChanger(this))

                    {

                        Utility.GCFullCollect();

                        const int maxDim = 256;



                        Surface thumb;

                        Surface flattened = BorrowScratchSurface(GetType().Name + ".DoSave() preparing embedded thumbnail");



                        try

                        {

                            Document.Flatten(flattened);



                            if (Document.Width > maxDim || Document.Height > maxDim)

                            {

                                int width;

                                int height;



                                if (Document.Width > Document.Height)

                                {

                                    width = maxDim;

                                    height = (Document.Height * maxDim) / Document.Width;

                                }

                                else

                                {

                                    height = maxDim;

                                    width = (Document.Width * maxDim) / Document.Height;

                                }



                                int thumbWidth = Math.Max(1, width);

                                int thumbHeight = Math.Max(1, height);



                                thumb = new Surface(thumbWidth, thumbHeight);

                                thumb.SuperSamplingFitSurface(flattened);

                            }

                            else

                            {

                                thumb = new Surface(flattened.Size);

                                thumb.CopySurface(flattened);

                            }

                        }



                        finally

                        {

                            ReturnScratchSurface(flattened);

                        }



                        var thumbDoc = new Document(thumb.Width, thumb.Height);

                        var thumbLayer = new BitmapLayer(thumb);

                        var backLayer = new BitmapLayer(thumb.Width, thumb.Height);

                        backLayer.Surface.Clear(ColorBgra.Transparent);

                        thumb.Dispose();

                        thumbDoc.Layers.Add(backLayer);

                        thumbDoc.Layers.Add(thumbLayer);

                        var thumbPng = new MemoryStream();

                        PropertyBasedSaveConfigToken pngToken = PdnFileTypes.Png.CreateDefaultSaveConfigToken();

                        PdnFileTypes.Png.Save(thumbDoc, thumbPng, pngToken, null, null, false);

                        byte[] thumbBytes = thumbPng.ToArray();



                        string thumbString = Convert.ToBase64String(thumbBytes, Base64FormattingOptions.None);

                        thumbDoc.Dispose();



                        string thumbXml = "<thumb png=\"" + thumbString + "\" />";

                        Document.CustomHeaders = thumbXml;

                    }

                }



                // save!

                bool success = false;

                Stream stream = null;



                try

                {

                    stream = new FileStream(newFileName, FileMode.Create, FileAccess.Write);



                    using (new WaitCursorChanger(this))

                    {

                        Utility.GCFullCollect();



                        var sd = new SaveProgressDialog(this);

                        Surface scratch = BorrowScratchSurface(GetType().Name + ".DoSave() handing off scratch surface to SaveProgressDialog.Save()");



                        try

                        {

                            sd.Save(stream, Document, newFileType, newSaveConfigToken, scratch);

                        }



                        finally

                        {

                            ReturnScratchSurface(scratch);

                        }



                        success = true;



                        _lastSaveTime = DateTime.Now;



                        stream.Close();

                        stream = null;

                    }

                }



                catch (UnauthorizedAccessException)

                {

                    Utility.ErrorBox(this, PdnResources.GetString("SaveImage.Error.UnauthorizedAccessException"));

                }



                catch (SecurityException)

                {

                    Utility.ErrorBox(this, PdnResources.GetString("SaveImage.Error.SecurityException"));

                }



                catch (DirectoryNotFoundException)

                {

                    Utility.ErrorBox(this, PdnResources.GetString("SaveImage.Error.DirectoryNotFoundException"));

                }



                catch (IOException)

                {

                    Utility.ErrorBox(this, PdnResources.GetString("SaveImage.Error.IOException"));

                }



                catch (OutOfMemoryException)

                {

                    Utility.ErrorBox(this, PdnResources.GetString("SaveImage.Error.OutOfMemoryException"));

                }



#if !DEBUG

                catch (Exception)

                {

                    Utility.ErrorBox(this, PdnResources.GetString("SaveImage.Error.Exception"));

                }

#endif



                finally

                {

                    if (stream != null)

                    {

                        stream.Close();

                        stream = null;

                    }

                }



                if (success)

                {

                    Shell.AddToRecentDocumentsList(newFileName);

                }

                else

                {

                    return false;

                }



                // reset the dirty bit so they won't be asked to save on quitting

                Document.Dirty = false;



                // some misc. book keeping ...

                AddToMruList();



                // and finally, shout happiness by way of ...

                return true;

            }

        }



        /// <summary>

        /// Does the grunt work to do a File->Save As operation.

        /// </summary>

        /// <returns><b>true</b> if the file was saved correctly, <b>false</b> if the user cancelled</returns>

        public bool DoSaveAs()

        {

            using (new PushNullToolMode(this))

            {

                string newFileName;

                FileType newFileType;

                SaveConfigToken newSaveConfigToken;



                Surface scratch = BorrowScratchSurface(GetType() + ".DoSaveAs() handing off scratch surface to DoSaveAsDialog()");



                bool result;

                try

                {

                    result = DoSaveAsDialog(out newFileName, out newFileType, out newSaveConfigToken, scratch);

                }



                finally

                {

                    ReturnScratchSurface(scratch);

                }



                if (!result)

                {

                    return false;

                }

                string oldFileName;

                FileType oldFileType;

                SaveConfigToken oldSaveConfigToken;



                GetDocumentSaveOptions(out oldFileName, out oldFileType, out oldSaveConfigToken);

                SetDocumentSaveOptions(newFileName, newFileType, newSaveConfigToken);



                bool result2 = DoSave(true);



                if (!result2)

                {

                    SetDocumentSaveOptions(oldFileName, oldFileType, oldSaveConfigToken);

                }



                return result2;

            }

        }



        public static Document LoadDocument(Control owner, string fileName, out FileType fileTypeResult, ProgressEventHandler progressCallback)

        {

            FileTypeCollection fileTypes;

            FileType fileType;



            fileTypeResult = null;



            try

            {

                fileTypes = FileTypes.GetFileTypes();

                int ftIndex = fileTypes.IndexOfExtension(Path.GetExtension(fileName));



                if (ftIndex == -1)

                {

                    Utility.ErrorBox(owner, PdnResources.GetString("LoadImage.Error.ImageTypeNotRecognized"));

                    return null;

                }



                fileType = fileTypes[ftIndex];

                fileTypeResult = fileType;

            }



            catch (ArgumentException)

            {

                string format = PdnResources.GetString("LoadImage.Error.InvalidFileName.Format");

                string error = string.Format(format, fileName);

                Utility.ErrorBox(owner, error);

                return null;

            }



            Document document = null;



            using (new WaitCursorChanger(owner))

            {

                Utility.GCFullCollect();

                Stream stream = null;



                try

                {

                    try

                    {

                        stream = new FileStream(fileName, FileMode.Open, FileAccess.Read);

                        long totalBytes = 0;



                        var siphonStream = new SiphonStream(stream);



                        IOEventHandler ioEventHandler = delegate(object sender, IOEventArgs e)

                                                            {

                                                                if (progressCallback == null)

                                                                {

                                                                }

                                                                else

                                                                {

                                                                    totalBytes += e.Count;

                                                                    double percent =

                                                                        Utility.Clamp(100.0*((double) totalBytes/(double) siphonStream.Length), 0, 100);

                                                                    progressCallback(null, new ProgressEventArgs(percent));

                                                                }

                                                            };



                        siphonStream.IOFinished += ioEventHandler;



                        using (new WaitCursorChanger(owner))

                        {

                            document = fileType.Load(siphonStream);



                            if (progressCallback != null)

                            {

                                progressCallback(null, new ProgressEventArgs(100.0));

                            }

                        }



                        siphonStream.IOFinished -= ioEventHandler;

                        siphonStream.Close();

                    }



                    catch (WorkerThreadException ex)

                    {

                        Type innerExType = ex.InnerException.GetType();

                        ConstructorInfo ci = innerExType.GetConstructor(new[] { typeof(string), typeof(Exception) });



                        if (ci == null)

                        {

                            throw;

                        }

                        else

                        {

                            var ex2 = (Exception)ci.Invoke(new object[] { "Worker thread threw an exception of this type", ex.InnerException });

                            throw ex2;

                        }

                    }

                }



                catch (ArgumentException)

                {

                    Utility.ErrorBox(owner,

                                     fileName.Length == 0

                                         ? PdnResources.GetString("LoadImage.Error.BlankFileName")

                                         : PdnResources.GetString("LoadImage.Error.ArgumentException"));

                }



                catch (UnauthorizedAccessException)

                {

                    Utility.ErrorBox(owner, PdnResources.GetString("LoadImage.Error.UnauthorizedAccessException"));

                }



                catch (SecurityException)

                {

                    Utility.ErrorBox(owner, PdnResources.GetString("LoadImage.Error.SecurityException"));

                }



                catch (FileNotFoundException)

                {

                    Utility.ErrorBox(owner, PdnResources.GetString("LoadImage.Error.FileNotFoundException"));

                }



                catch (DirectoryNotFoundException)

                {

                    Utility.ErrorBox(owner, PdnResources.GetString("LoadImage.Error.DirectoryNotFoundException"));

                }



                catch (PathTooLongException)

                {

                    Utility.ErrorBox(owner, PdnResources.GetString("LoadImage.Error.PathTooLongException"));

                }



                catch (IOException)

                {

                    Utility.ErrorBox(owner, PdnResources.GetString("LoadImage.Error.IOException"));

                }



                catch (SerializationException)

                {

                    Utility.ErrorBox(owner, PdnResources.GetString("LoadImage.Error.SerializationException"));

                }



                catch (OutOfMemoryException)

                {

                    Utility.ErrorBox(owner, PdnResources.GetString("LoadImage.Error.OutOfMemoryException"));

                }



                catch (Exception)

                {

                    Utility.ErrorBox(owner, PdnResources.GetString("LoadImage.Error.Exception"));

                }



                finally

                {

                    if (stream != null)

                    {

                        stream.Close();

                        stream = null;

                    }

                }

            }



            return document;

        }



        public Surface RenderThumbnail(int maxEdgeLength, bool highQuality, bool forceUpToDate)

        {

            if (Document == null)

            {

                var ret = new Surface(maxEdgeLength, maxEdgeLength);

                ret.Clear(ColorBgra.Transparent);

                return ret;

            }



            Size thumbSize = Utility.ComputeThumbnailSize(Document.Size, maxEdgeLength);

            var thumb = new Surface(thumbSize);

            thumb.Clear(ColorBgra.Transparent);



            RenderCompositionTo(thumb, highQuality, forceUpToDate);



            return thumb;

        }



        Surface IThumbnailProvider.RenderThumbnail(int maxEdgeLength)

        {

            return RenderThumbnail(maxEdgeLength, true, false);

        }

    }

}