/src/DocumentWorkspace.cs

Large files files are truncated, but you can click here to view the full file

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

// 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.Data;

using PaintDotNet.Effects;

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.Text;

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 string filePath = null;

        private FileType fileType = null;

        private SaveConfigToken saveConfigToken = null;

        private Selection selection = new Selection();

        private Surface scratchSurface = null;

        private SelectionRenderer selectionRenderer;

        private Hashtable staticToolData = Hashtable.Synchronized(new Hashtable());

        private Tool activeTool;

        private Type previousActiveToolType;

        private Type preNullTool = null;

        private int nullToolCount = 0;

        private int zoomChangesCount = 0;

        private HistoryStack history;

        private Layer activeLayer;

        private System.Windows.Forms.Timer toolPulseTimer;

        private DateTime lastSaveTime = NeverSavedDateTime;

        private int suspendToolCursorChanges = 0;

        private ImageResource statusIcon = null;

        private string statusText = null;



        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()

        {

            ++this.suspendToolCursorChanges;

        }



        public void ResumeToolCursorChanges()

        {

            --this.suspendToolCursorChanges;



            if (this.suspendToolCursorChanges <= 0 && this.activeTool != null)

            {

                Cursor = this.activeTool.Cursor;

            }

        }

        

        public ImageResource StatusIcon

        {

            get

            {

                return this.statusIcon;

            }

        }



        public string StatusText

        {

            get

            {

                return this.statusText;

            }

        }



        public void SetStatus(string newStatusText, ImageResource newStatusIcon)

        {

            this.statusText = newStatusText;

            this.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 this.lastSaveTime;

            }

        }



        public bool IsZoomChanging

        {

            get

            {

                return (this.zoomChangesCount > 0);

            }

        }



        private void BeginZoomChanges()

        {

            ++this.zoomChangesCount;

        }



        private void EndZoomChanges()

        {

            --this.zoomChangesCount;

        }



        protected override void OnSizeChanged(EventArgs e)

        {

            PerformLayout();

            base.OnSizeChanged(e);

        }



        protected override void OnLayout(LayoutEventArgs e)

        {

            if (this.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 (this.zoomBasis == ZoomBasis.FitToWindow)

            {

                PerformLayout();

            }



            base.OnResize(e);

        }



        public DocumentWorkspace()

        {

            this.activeLayer = null;

            this.history = new HistoryStack(this);



            InitializeComponent();



            // hook the DocumentWorkspace with its selectedPath ...

            this.selectionRenderer = new SelectionRenderer(this.RendererList, this.Selection, this);

            this.RendererList.Add(this.selectionRenderer, true);

            this.selectionRenderer.EnableOutlineAnimation = true;

            this.selectionRenderer.EnableSelectionTinting = false;

            this.selectionRenderer.EnableSelectionOutline = true;



            this.selection.Changed += new EventHandler(Selection_Changed);



            this.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(this.activeTool);

        }



        private void UpdateSelectionInfoInStatusBar()

        {

            if (Selection.IsEmpty)

            {

                UpdateStatusBarToToolHelpText();

            }

            else

            {

                string newStatusText;



                int area = 0;

                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);



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



                string areaString;

                if (this.Units == MeasurementUnit.Pixel)

                {

                    nfi.NumberDecimalDigits = 0;

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

                }

                else

                {

                    nfi.NumberDecimalDigits = 2;

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

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

                }



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

                MoveToolBase moveTool = Tool as MoveToolBase;



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

                {

                    NumberFormatInfo 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 Selection_Changed(object sender, EventArgs e)

        {

            UpdateRulerSelectionTinting();

            UpdateSelectionInfoInStatusBar();

        }



        private void InitializeComponent()

        {

            this.toolPulseTimer = new System.Windows.Forms.Timer();

            this.toolPulseTimer.Interval = 16;

            this.toolPulseTimer.Tick += new EventHandler(this.ToolPulseTimer_Tick);

        }



        protected override void Dispose(bool disposing)

        {

            if (disposing)

            {

                if (this.activeTool != null)

                {

                    this.activeTool.Dispose();

                    this.activeTool = 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

                        {

                            ProgressDialog pd = new ProgressDialog();

                            bool pdLoaded = false;

                            bool closeAtLoad = false;



                            EventHandler loadCallback =

                                delegate(object sender, EventArgs e)

                                {

                                    pdLoaded = true;



                                    if (closeAtLoad)

                                    {

                                        pd.Close();

                                    }

                                };



                            ProgressEventHandler progressCallback =

                                delegate(object sender, ProgressEventArgs e)

                                {

                                    if (pdLoaded)

                                    {

                                        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(object sender, EventArgs e)

                                {

                                    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()

        {

            this.ZoomBasis = ZoomBasis.ScaleFactor;

            base.ZoomIn();

        }



        public override void ZoomIn(double factor)

        {

            this.ZoomBasis = ZoomBasis.ScaleFactor;

            base.ZoomIn(factor);

        }



        public override void ZoomOut()

        {

            this.ZoomBasis = ZoomBasis.ScaleFactor;

            base.ZoomOut();

        }



        public override void ZoomOut(double factor)

        {

            this.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>

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

        {

            using (new WaitCursorChanger(this))

            {

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

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

                DocumentWorkspaceAction action = actionAsObject as DocumentWorkspaceAction;



                if (action != null)

                {

                    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 this.zoomBasis;

            }



            set

            {

                if (this.zoomBasis != value)

                {

                    OnZoomBasisChanging();

                    this.zoomBasis = value;



                    switch (this.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

                            this.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)

        {

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

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



            PointF cornerPosition;



            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;



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

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



            DocumentScrollPositionF = cornerPosition;

        }



        protected override void HandleMouseWheel(Control sender, MouseEventArgs e)

        {

            if (Control.ModifierKeys == Keys.Control)

            {

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

                Rectangle visibleDocBoundsStart = this.VisibleDocumentBounds;

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

                RectangleF visibleDocDocRect1 = this.VisibleDocumentRectangleF;



                PointF 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)

                {

                    this.ZoomIn(mouseFactor);

                }

                else if (e.Delta < 0)

                {

                    this.ZoomOut(mouseFactor);

                }



                RectangleF visibleDocDocRect2 = this.VisibleDocumentRectangleF;



                PointF scrollPt2 = new PointF(

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

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



                this.DocumentScrollPositionF = scrollPt2;



                Rectangle visibleDocBoundsEnd = this.VisibleDocumentBounds;



                if (visibleDocBoundsEnd != visibleDocBoundsStart)

                {

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

                    this.Update();

                }

            }



            base.HandleMouseWheel(sender, e);

        }



        public void SelectClosestVisibleLayer(Layer layer)

        {

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

            int newLayerIndex = oldLayerIndex;



            // find the closest layer that is still visible

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

            {

                int lower = oldLayerIndex - i;

                int upper = oldLayerIndex + i;



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

                {

                    newLayerIndex = lower;

                    break;

                }



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

                {

                    newLayerIndex = upper;

                    break;

                }

            }



            if (newLayerIndex != oldLayerIndex)

            {

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

            }

        }



        public void UpdateRulerSelectionTinting()

        {

            if (this.RulersEnabled)

            {

                Rectangle bounds = this.Selection.GetBounds();

                this.SetHighlightRectangle(bounds);

            }

        }



        private void LayerRemovingHandler(object sender, IndexEventArgs e)

        {

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

            layer.PropertyChanging -= LayerPropertyChangingHandler;

            layer.PropertyChanged -= LayerPropertyChangedHandler;



            // pick a new valid layer!

            int newLayerIndex;



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

            {

                newLayerIndex = e.Index - 1;

            }

            else

            {

                newLayerIndex = e.Index + 1;

            }



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

            {

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

            }

            else

            {

                if (this.Document.Layers.Count == 0)

                {

                    this.ActiveLayer = null;

                }

                else

                {

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

                }

            }

        }



        private void LayerRemovedHandler(object sender, IndexEventArgs e)

        {

        }



        private void LayerInsertedHandler(object sender, IndexEventArgs e)

        {

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

            this.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);



            LayerPropertyHistoryMemento lpha = new LayerPropertyHistoryMemento(

                haName,

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

                this,

                this.Document.Layers.IndexOf(sender));



            this.History.PushNewMemento(lpha);

        }



        private void LayerPropertyChangedHandler(object sender, PropertyEventArgs e)

        {

            Layer layer = (Layer)sender;



            if (!layer.Visible && 

                layer == this.ActiveLayer && 

                this.Document.Layers.Count > 1 &&

                !History.IsExecutingMemento)

            {

                SelectClosestVisibleLayer(layer);

            }

        }



        private void ToolPulseTimer_Tick(object sender, EventArgs e)

        {

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

            {

                return;

            }



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

            {

                this.Tool.PerformPulse();

            }

        }



        protected override void OnLoad(EventArgs e)

        {

            if (this.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()

        {

            this.Focus();



            if (ActiveLayerChanged != null)

            {

                ActiveLayerChanged(this, EventArgs.Empty);

            }

        }



        public Layer ActiveLayer

        {

            get

            {

                return this.activeLayer;

            }



            set

            {

                OnLayerChanging();



                bool deactivateTool;



                if (this.Tool != null)

                {

                    deactivateTool = this.Tool.DeactivateOnLayerChange;

                }

                else

                {

                    deactivateTool = false;

                }



                if (deactivateTool)

                {

                    PushNullTool();

                    this.EnableToolPulse = false;

                }



                try

                {

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

                    if (this.Document != null)

                    {

                        if (value != null && !this.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.

                    this.activeLayer = value;

                }



                finally

                {

                    if (deactivateTool)

                    {

                        PopNullTool();

                        this.EnableToolPulse = true;

                    }

                }



                OnLayerChanged();

            }

        }



        public int ActiveLayerIndex

        {

            get

            {

                return Document.Layers.IndexOf(ActiveLayer);

            }



            set

            {

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

            }

        }



        public bool EnableToolPulse

        {

            get

            {

                return this.toolPulseTimer.Enabled;

            }



            set

            {

                this.toolPulseTimer.Enabled = value;

            }

        }



        public HistoryStack History

        {

            get

            {

                return this.history;

            }

        }



        public Tool Tool

        {

            get

            {

                return this.activeTool;

            }

        }



        public Type GetToolType()

        {

            if (Tool != null)

            {

                return Tool.GetType();

            }

            else

            {

                return null;

            }

        }



        public void SetToolFromType(Type toolType)

        {

            if (toolType == GetToolType())

            {

                return;

            }

            else if (toolType == null)

            {

                SetTool(null);

            }

            else

            {

                Tool newTool = CreateTool(toolType);

                SetTool(newTool);

            }

        }



        public void PushNullTool()

        {

            if (this.nullToolCount == 0)

            {

                this.preNullTool = GetToolType();

                this.SetTool(null);

                this.nullToolCount = 1;

            }

            else

            {

                ++this.nullToolCount;

            }

        }



        public void PopNullTool()

        {

            --this.nullToolCount;



            if (this.nullToolCount == 0)

            {

                this.SetToolFromType(this.preNullTool);

                this.preNullTool = null;

            }

            else if (this.nullToolCount < 0)

            {

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

            }

        }



        public Type PreviousActiveToolType

        {

            get

            {

                return this.previousActiveToolType;

            }

        }



        public void SetTool(Tool copyMe)

        {

            OnToolChanging();



            if (this.activeTool != null)

            {

                this.previousActiveToolType = this.activeTool.GetType();

                this.activeTool.CursorChanged -= ToolCursorChangedHandler;

                this.activeTool.PerformDeactivate();

                this.activeTool.Dispose();

                this.activeTool = null;

            }



            if (copyMe == null)

            {

                EnableToolPulse = false;

            }

            else

            {

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

                this.activeTool = CreateTool(copyMe.GetType());

                this.activeTool.PerformActivate();

                this.activeTool.CursorChanged += ToolCursorChangedHandler;



                if (this.suspendToolCursorChanges <= 0)

                {

                    Cursor = this.activeTool.Cursor;

                }



                EnableToolPulse = true;

            }



            OnToolChanged();

        }



        public Tool CreateTool(Type toolType)

        {

            return DocumentWorkspace.CreateTool(toolType, this);

        }



        private static Tool CreateTool(Type toolType, DocumentWorkspace dc)

        {

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

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

            return tool;

        }



        private static void InitializeTools()

        {

            // add all the tools

            tools = new Type[] 

            {

                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 = DocumentWorkspace.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 (this.suspendToolCursorChanges <= 0)

            {

                Cursor = this.activeTool.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 this.appWorkspace;

            }



            set

            {

                this.appWorkspace = value;

            }

        }



        public Selection Selection

        {

            get

            {

                return this.selection;

            }

        }



        public bool EnableOutlineAnimation

        {

            get

            {

                return this.selectionRenderer.EnableOutlineAnimation;

            }



            set

            {

                this.selectionRenderer.EnableOutlineAnimation = value;

            }

        }



        public bool EnableSelectionOutline

        {

            get

            {

                return this.selectionRenderer.EnableSelectionOutline;

            }



            set

            {

                this.selectionRenderer.EnableSelectionOutline = value;

            }

        }



        public bool EnableSelectionTinting

        {

            get

            {

                return this.selectionRenderer.EnableSelectionTinting;

            }



            set

            {

                this.selectionRenderer.EnableSelectionTinting = value;

            }

        }



        public void ResetOutlineWhiteOpacity()

        {

            this.selectionRenderer.ResetOutlineWhiteOpacity();

        }



        public event EventHandler FilePathChanged;

        protected virtual void OnFilePathChanged()

        {

            if (FilePathChanged != null)

            {

                FilePathChanged(this, EventArgs.Empty);

            }

        }



        public string FilePath

        {

            get

            {

                return this.filePath;

            }

        }



        public string GetFriendlyName()

        {

            string friendlyName;



            if (this.filePath != null)

            {

                friendlyName = Path.GetFileName(this.filePath);

            }

            else

            {

                friendlyName = PdnResources.GetString("Untitled.FriendlyName");

            }



            return friendlyName;

        }



        public FileType FileType

        {

            get

            {

                return this.fileType;

            }

        }



        public SaveConfigToken SaveConfigToken

        {

            get

            {

                if (this.saveConfigToken == null)

                {

                    return null;

                }

                else

                {

                    return (SaveConfigToken)this.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>

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

        {

            this.filePath = newFilePath;

            OnFilePathChanged();



            this.fileType = newFileType;



            if (newSaveConfigToken == null)

            {

                this.saveConfigToken = null;

            }

            else

            {

                this.saveConfigToken = (SaveConfigToken)newSaveConfigToken.Clone();

            }



            OnSaveOptionsChanged();

        }



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

        {

            filePathResult = this.filePath;

            fileTypeResult = this.fileType;



            if (this.saveConfigToken == null)

            {

                saveConfigTokenResult = null;

            }

            else

            {

                saveConfigTokenResult = (SaveConfigToken)this.saveConfigToken.Clone();

            }

        }



        private bool isScratchSurfaceBorrowed = false;

        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 (this.isScratchSurfaceBorrowed)

            {

                throw new InvalidOperationException(

                    "ScratchSurface already borrowed: '" + 

                    this.borrowScratchSurfaceReason + 

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

            }



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

            this.isScratchSurfaceBorrowed = true;

            this.borrowScratchSurfaceReason = reason;

            return this.scratchSurface;

        }



        public void ReturnScratchSurface(Surface borrowedScratchSurface)

        {

            if (!this.isScratchSurfaceBorrowed)

            {

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

            }



            if (this.scratchSurface != borrowedScratchSurface)

            {

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

            }



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

            this.isScratchSurfaceBorrowed = false;

            this.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 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 PropertyItem[1] { pi });

        }

        

        private ZoomBasis savedZb;

        private ScaleFactor savedSf;

        private int savedAli;

        protected override void OnDocumentChanging(Document newDocument)

        {

            base.OnDocumentChanging(newDocument);



            this.savedZb = this.ZoomBasis;

            this.savedSf = ScaleFactor;



            if (this.ActiveLayer != null)

            {

                this.savedAli = ActiveLayerIndex;

            }

            else

            {

                this.savedAli = -1;

            }



            if (newDocument != null)

            {

                UpdateExifTags(newDocument);

            }



            if (this.Document != null)

            {

                foreach (Layer layer in this.Document.Layers)

                {

                    layer.PropertyChanging -= LayerPropertyChangingHandler;

                    layer.PropertyChanged -= LayerPropertyChangedHandler;

                }



                this.Document.Layers.RemovingAt -= LayerRemovingHandler;

                this.Document.Layers.RemovedAt -= LayerRemovedHandler;

                this.Document.Layers.Inserted -= LayerInsertedHandler;

            }

            

            this.staticToolData.Clear();



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

            ActiveLayer = null;



            if (this.scratchSurface != null)

            {

                if (this.isScratchSurfaceBorrowed)

                {

                    throw new InvalidOperationException("scratchSurface is currently borrowed: " + this.borrowScratchSurfaceReason);

                }



                if (newDocument == null || newDocument.Size != this.scratchSurface.Size)

                {

                    this.scratchSurface.Dispose();

                    this.scratchSurface = null;

                }

            }



            i…

Large files files are truncated, but you can click here to view the full file