/src/ChooseToolDefaultsDialog.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.SystemLayer;

using System;

using System.Collections.Generic;

using System.Drawing;

using System.Windows.Forms;



namespace PaintDotNet

{

    internal class ChooseToolDefaultsDialog

        : PdnBaseForm

    {

        private Button _cancelButton;

        private Button _saveButton;

        private Label _introText;

        private Label _defaultToolText;

        private Button _resetButton;

        private Button _loadFromToolBarButton;

        private ToolChooserStrip _toolChooserStrip;

        private Type _toolType = Tool.DefaultToolType;

        private AppEnvironment _toolBarAppEnvironment;

        private Type _toolBarToolType;

        private HeaderLabel _bottomSeparator;

        private readonly List<ToolConfigRow> _toolConfigRows = new List<ToolConfigRow>();



        private sealed class ToolConfigRow

        {

            private readonly ToolConfigStrip _toolConfigStrip;

            private readonly HeaderLabel _headerLabel;

            private readonly ToolBarConfigItems _toolBarConfigItems;



            public ToolBarConfigItems ToolBarConfigItems

            {

                get

                {

                    return _toolBarConfigItems;

                }

            }



            public HeaderLabel HeaderLabel

            {

                get

                {

                    return _headerLabel;

                }

            }



            public ToolConfigStrip ToolConfigStrip

            {

                get

                {

                    return _toolConfigStrip;

                }

            }



            private string GetHeaderResourceName()

            {

                string resName1 = _toolBarConfigItems.ToString();

                string resName2 = resName1.Replace(", ", "");

                return "ChooseToolDefaultsDialog.ToolConfigRow." + resName2 + ".HeaderLabel.Text";

            }



            public ToolConfigRow(ToolBarConfigItems toolBarConfigItems)

            {

                _toolBarConfigItems = toolBarConfigItems;



                _headerLabel = new HeaderLabel

                                   {

                                       Name = "headerLabel:" + toolBarConfigItems,

                                       Text = PdnResources.GetString(GetHeaderResourceName()),

                                       RightMargin = 0

                                   };



                _toolConfigStrip = new ToolConfigStrip

                                       {

                                           Name = "toolConfigStrip:" + toolBarConfigItems,

                                           AutoSize = true,

                                           Dock = DockStyle.None,

                                           GripStyle = ToolStripGripStyle.Hidden,

                                           LayoutStyle = ToolStripLayoutStyle.HorizontalStackWithOverflow,

                                           ToolBarConfigItems = _toolBarConfigItems

                                       };

            }

        }



        public void SetToolBarSettings(Type newToolType, AppEnvironment newToolBarAppEnvironment)

        {

            _toolBarToolType = newToolType;

            _toolBarAppEnvironment = newToolBarAppEnvironment.Clone();

        }



        public void LoadUIFromAppEnvironment(AppEnvironment newAppEnvironment)

        {

            SuspendLayout();



            foreach (ToolConfigRow row in _toolConfigRows)

            {

                row.ToolConfigStrip.LoadFromAppEnvironment(newAppEnvironment);

            }



            ResumeLayout();

        }



        public void SetDefaultToolType(Type newDefaultToolType)

        {

            _toolChooserStrip.SelectTool(newDefaultToolType);

        }



        public AppEnvironment CreateAppEnvironmentFromUI()

        {

            var newAppEnvironment = new AppEnvironment();



            foreach (ToolConfigRow row in _toolConfigRows)

            {

                if ((row.ToolBarConfigItems & ToolBarConfigItems.AlphaBlending) != 0)

                {

                    newAppEnvironment.AlphaBlending = row.ToolConfigStrip.AlphaBlending;

                }



                if ((row.ToolBarConfigItems & ToolBarConfigItems.Antialiasing) != 0)

                {

                    newAppEnvironment.AntiAliasing = row.ToolConfigStrip.AntiAliasing;

                }



                if ((row.ToolBarConfigItems & ToolBarConfigItems.Brush) != 0)

                {

                    newAppEnvironment.BrushInfo = row.ToolConfigStrip.BrushInfo;

                }



                if ((row.ToolBarConfigItems & ToolBarConfigItems.ColorPickerBehavior) != 0)

                {

                    newAppEnvironment.ColorPickerClickBehavior = row.ToolConfigStrip.ColorPickerClickBehavior;

                }



                if ((row.ToolBarConfigItems & ToolBarConfigItems.FloodMode) != 0)

                {

                    newAppEnvironment.FloodMode = row.ToolConfigStrip.FloodMode;

                }



                if ((row.ToolBarConfigItems & ToolBarConfigItems.Gradient) != 0)

                {

                    newAppEnvironment.GradientInfo = row.ToolConfigStrip.GradientInfo;

                }



                if ((row.ToolBarConfigItems & ToolBarConfigItems.Pen) != 0 ||

                    (row.ToolBarConfigItems & ToolBarConfigItems.PenCaps) != 0)

                {

                    newAppEnvironment.PenInfo = row.ToolConfigStrip.PenInfo;

                }



                if ((row.ToolBarConfigItems & ToolBarConfigItems.Resampling) != 0)

                {

                    newAppEnvironment.ResamplingAlgorithm = row.ToolConfigStrip.ResamplingAlgorithm;

                }



                if ((row.ToolBarConfigItems & ToolBarConfigItems.SelectionCombineMode) != 0)

                {

                    newAppEnvironment.SelectionCombineMode = row.ToolConfigStrip.SelectionCombineMode;

                }



                if ((row.ToolBarConfigItems & ToolBarConfigItems.SelectionDrawMode) != 0)

                {

                    newAppEnvironment.SelectionDrawModeInfo = row.ToolConfigStrip.SelectionDrawModeInfo;

                }



                if ((row.ToolBarConfigItems & ToolBarConfigItems.ShapeType) != 0)

                {

                    newAppEnvironment.ShapeDrawType = row.ToolConfigStrip.ShapeDrawType;

                }



                if ((row.ToolBarConfigItems & ToolBarConfigItems.Text) != 0)

                {

                    newAppEnvironment.FontInfo = row.ToolConfigStrip.FontInfo;

                    newAppEnvironment.FontSmoothing = row.ToolConfigStrip.FontSmoothing;

                    newAppEnvironment.TextAlignment = row.ToolConfigStrip.FontAlignment;

                }



                if ((row.ToolBarConfigItems & ToolBarConfigItems.Tolerance) != 0)

                {

                    newAppEnvironment.Tolerance = row.ToolConfigStrip.Tolerance;

                }

            }



            return newAppEnvironment;

        }



        public Type ToolType

        {

            get

            {

                return _toolType;

            }



            set

            {

                _toolChooserStrip.SelectTool(value);

                _toolType = value;

            }

        }



        public ChooseToolDefaultsDialog()

        {

            UI.InitScaling(this);

            SuspendLayout();



            InitializeComponent();



            _toolConfigRows.Add(new ToolConfigRow(ToolBarConfigItems.ShapeType | ToolBarConfigItems.Brush | ToolBarConfigItems.Pen | ToolBarConfigItems.PenCaps));

            _toolConfigRows.Add(new ToolConfigRow(ToolBarConfigItems.SelectionCombineMode | ToolBarConfigItems.SelectionDrawMode));

            _toolConfigRows.Add(new ToolConfigRow(ToolBarConfigItems.Text));

            _toolConfigRows.Add(new ToolConfigRow(ToolBarConfigItems.Gradient));

            _toolConfigRows.Add(new ToolConfigRow(ToolBarConfigItems.Tolerance | ToolBarConfigItems.FloodMode));

            _toolConfigRows.Add(new ToolConfigRow(ToolBarConfigItems.ColorPickerBehavior));

            _toolConfigRows.Add(new ToolConfigRow(ToolBarConfigItems.Resampling));

            _toolConfigRows.Add(new ToolConfigRow(ToolBarConfigItems.AlphaBlending | ToolBarConfigItems.Antialiasing));



            foreach (ToolConfigRow t in _toolConfigRows)

            {

                Controls.Add(t.HeaderLabel);

                Controls.Add(t.ToolConfigStrip);

            }



            ResumeLayout();

            PerformLayout();



            _toolChooserStrip.SetTools(DocumentWorkspace.ToolInfos);



            RegisterFormHotKey(

                Keys.Escape,

                delegate

                    {

                    _cancelButton.PerformClick();

                    return true;

                });

        }



        protected override void OnLoad(EventArgs e)

        {

            _saveButton.Select();

            base.OnLoad(e);

        }



        public override void LoadResources()

        {

            Text = PdnResources.GetString("ChooseToolDefaultsDialog.Text");

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



            _introText.Text = PdnResources.GetString("ChooseToolDefaultsDialog.IntroText.Text");

            _defaultToolText.Text = PdnResources.GetString("ChooseToolDefaultsDialog.DefaultToolText.Text");



            _loadFromToolBarButton.Text = PdnResources.GetString("ChooseToolDefaultsDialog.LoadFromToolBarButton.Text");

            _cancelButton.Text = PdnResources.GetString("Form.CancelButton.Text");

            _saveButton.Text = PdnResources.GetString("Form.SaveButton.Text");

            _resetButton.Text = PdnResources.GetString("Form.ResetButton.Text");



            base.LoadResources();

        }



        protected override void OnLayout(LayoutEventArgs levent)

        {

            int leftMargin = UI.ScaleWidth(8);

            int rightMargin = UI.ScaleWidth(8);

            int topMargin = UI.ScaleHeight(8);

            int bottomMargin = UI.ScaleHeight(8);

            int buttonHMargin = UI.ScaleWidth(7);

            int afterIntroTextVMargin = UI.ScaleHeight(16);

            int afterHeaderVMargin = UI.ScaleHeight(3);

            int hMargin = UI.ScaleWidth(7);

            int vMargin = UI.ScaleHeight(7);

            int insetWidth = ClientSize.Width - leftMargin - rightMargin;



            _introText.Location = new Point(leftMargin, topMargin);

            _introText.Width = insetWidth;

            _introText.Height = _introText.GetPreferredSize(_introText.Size).Height;



            _defaultToolText.Location = new Point(

                leftMargin,

                _introText.Bottom + afterIntroTextVMargin);



            _toolChooserStrip.Location = new Point(

                _defaultToolText.Right + hMargin, 

                _defaultToolText.Top + (_defaultToolText.Height - _toolChooserStrip.Height) / 2);



            int y = vMargin + Math.Max(_defaultToolText.Bottom, _toolChooserStrip.Bottom);

            int maxInsetWidth = insetWidth;



            foreach (ToolConfigRow t in _toolConfigRows)

            {

                t.HeaderLabel.Location = new Point(leftMargin, y);

                t.HeaderLabel.Width = insetWidth;

                y = t.HeaderLabel.Bottom + afterHeaderVMargin;



                t.ToolConfigStrip.Location = new Point(leftMargin + 3, y);

                Size preferredSize = t.ToolConfigStrip.GetPreferredSize(

                    new Size(t.ToolConfigStrip.Width, 1));



                t.ToolConfigStrip.Size = preferredSize;



                maxInsetWidth = Math.Max(maxInsetWidth, t.ToolConfigStrip.Width);



                y = t.ToolConfigStrip.Bottom + vMargin;

            }



            y += vMargin;



            _bottomSeparator.Location = new Point(leftMargin, y);

            _bottomSeparator.Width = insetWidth;

            _bottomSeparator.Visible = false;



            y += _bottomSeparator.Height;



            _cancelButton.Location = new Point(ClientSize.Width - rightMargin - _cancelButton.Width, y);



            _saveButton.Location = new Point(

                _cancelButton.Left - buttonHMargin - _saveButton.Width,

                _cancelButton.Top);



            _resetButton.Location = new Point(leftMargin, _saveButton.Top);



            _loadFromToolBarButton.Location = new Point(_resetButton.Right + buttonHMargin, _resetButton.Top);



            y = _resetButton.Bottom + bottomMargin;



            ClientSize = new Size(leftMargin + maxInsetWidth + rightMargin, y);



            if (IsHandleCreated && maxInsetWidth > insetWidth)

            {

                BeginInvoke(new Procedure(PerformLayout), null);

            }



            base.OnLayout(levent);

        }



        private void InitializeComponent()

        {

            _cancelButton = new Button();

            _saveButton = new Button();

            _introText = new Label();

            _defaultToolText = new Label();

            _resetButton = new Button();

            _loadFromToolBarButton = new Button();

            _toolChooserStrip = new ToolChooserStrip();

            _bottomSeparator = new HeaderLabel();

            SuspendLayout();

            // 

            // cancelButton

            // 

            _cancelButton.Name = "_cancelButton";

            _cancelButton.AutoSize = true;

            _cancelButton.Click += CancelButtonClick;

            _cancelButton.TabIndex = 3;

            _cancelButton.FlatStyle = FlatStyle.System;

            // 

            // saveButton

            // 

            _saveButton.Name = "_saveButton";

            _saveButton.AutoSize = true;

            _saveButton.Click += SaveButtonClick;

            _saveButton.TabIndex = 2;

            _saveButton.FlatStyle = FlatStyle.System;

            // 

            // introText

            // 

            _introText.Name = "_introText";

            _introText.TabStop = false;

            // 

            // defaultToolText

            // 

            _defaultToolText.Name = "_defaultToolText";

            _defaultToolText.AutoSize = true;

            _defaultToolText.TabStop = false;

            // 

            // resetButton

            // 

            _resetButton.Name = "_resetButton";

            _resetButton.AutoSize = true;

            _resetButton.Click += ResetButtonClick;

            _resetButton.TabIndex = 0;

            _resetButton.FlatStyle = FlatStyle.System;

            //

            // loadFromToolBarButton

            //

            _loadFromToolBarButton.Name = "_loadFromToolBarButton";

            _loadFromToolBarButton.AutoSize = true;

            _loadFromToolBarButton.Click += LoadFromToolBarButtonClick;

            _loadFromToolBarButton.FlatStyle = FlatStyle.System;

            _loadFromToolBarButton.TabIndex = 1;

            //

            // toolChooserStrip

            //

            _toolChooserStrip.Name = "_toolChooserStrip";

            _toolChooserStrip.Dock = DockStyle.None;

            _toolChooserStrip.GripStyle = ToolStripGripStyle.Hidden;

            _toolChooserStrip.ShowChooseDefaults = false;

            _toolChooserStrip.UseToolNameForLabel = true;

            _toolChooserStrip.ToolClicked += ToolChooserStripToolClicked;

            //

            // bottomSeparator

            //

            _bottomSeparator.Name = "_bottomSeparator";

            _bottomSeparator.RightMargin = 0;

            // 

            // ChooseToolDefaultsDialog

            // 

            AcceptButton = _saveButton;

            AutoScaleDimensions = new SizeF(96F, 96F);

            AutoScaleMode = AutoScaleMode.Dpi;

            CancelButton = _cancelButton;

            ClientSize = new Size(448, 173);

            Controls.Add(_resetButton);

            Controls.Add(_loadFromToolBarButton);

            Controls.Add(_introText);

            Controls.Add(_defaultToolText);

            Controls.Add(_saveButton);

            Controls.Add(_cancelButton);

            Controls.Add(_toolChooserStrip);

            Controls.Add(_bottomSeparator);

            FormBorderStyle = FormBorderStyle.FixedDialog;

            Location = new Point(0, 0);

            MinimizeBox = false;

            MaximizeBox = false;

            Name = "ChooseToolDefaultsDialog";

            ShowInTaskbar = false;

            StartPosition = FormStartPosition.CenterParent;

            ResumeLayout(false);

            PerformLayout();

        }



        private void LoadFromToolBarButtonClick(object sender, EventArgs e)

        {

            ToolType = _toolBarToolType;

            LoadUIFromAppEnvironment(_toolBarAppEnvironment);

        }



        private void ToolChooserStripToolClicked(object sender, ToolClickedEventArgs e)

        {

            ToolType = e.ToolType;

        }



        private void ResetButtonClick(object sender, EventArgs e)

        {

            var defaults = new AppEnvironment();

            defaults.SetToDefaults();

            ToolType = Tool.DefaultToolType;

            LoadUIFromAppEnvironment(defaults);

        }



        private void CancelButtonClick(object sender, EventArgs e)

        {

            DialogResult = DialogResult.Cancel;

            Close();

        }



        private void SaveButtonClick(object sender, EventArgs e)

        {

            DialogResult = DialogResult.Yes;

            Close();

        }

    }

}