Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Workflow.Activities/Rules/Design/Dialogs/BasicBrowserDialog.cs

@@ -0,0 +1,383 @@
+#region Using directives
+
+using System;
+using System.CodeDom;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.Data;
+using System.Drawing;
+using System.Text;
+using System.Windows.Forms;
+using System.Windows.Forms.Design;
+using System.Workflow.ComponentModel;
+using System.Workflow.ComponentModel.Design;
+using System.Workflow.Activities.Rules;
+using System.Workflow.Interop;
+using System.Globalization;
+using System.Workflow.Activities.Common;
+
+#endregion
+
+namespace System.Workflow.Activities.Rules.Design
+{
+    #region class BasicBrowserDialog
+
+    internal abstract partial class BasicBrowserDialog : Form
+    {
+        #region members and constructors
+
+        private Activity activity;
+        private string name;
+        private IServiceProvider serviceProvider;
+
+        protected BasicBrowserDialog(Activity activity, string name)
+        {
+            if (activity == null)
+                throw (new ArgumentNullException("activity"));
+
+            this.activity = activity;
+
+            InitializeComponent();
+
+            // set captions
+            this.descriptionLabel.Text = DescriptionText;
+            this.Text = TitleText;
+            this.previewLabel.Text = PreviewLabelText;
+
+            this.newRuleToolStripButton.Enabled = true;
+            this.name = name;
+
+            serviceProvider = activity.Site;
+
+            //Set dialog fonts
+            IUIService uisvc = (IUIService)activity.Site.GetService(typeof(IUIService));
+            if (uisvc != null)
+                this.Font = (Font)uisvc.Styles["DialogFont"];
+
+            HelpRequested += new HelpEventHandler(OnHelpRequested);
+            HelpButtonClicked += new CancelEventHandler(OnHelpClicked);
+
+            this.rulesListView.Select();
+        }
+
+        protected Activity Activity
+        {
+            get
+            {
+                return this.activity;
+            }
+        }
+
+        #endregion
+
+        #region public properties
+
+        public string SelectedName
+        {
+            get
+            {
+                return this.name;
+            }
+        }
+
+        #endregion
+
+        #region event handlers
+
+        private void OnCancel(object sender, EventArgs e)
+        {
+            this.name = null;
+            this.DialogResult = DialogResult.Cancel;
+            this.Close();
+        }
+
+        private void OnOk(object sender, EventArgs e)
+        {
+            object ruleObject = this.rulesListView.SelectedItems[0].Tag;
+            this.name = this.GetObjectName(ruleObject);
+
+            this.DialogResult = DialogResult.OK;
+            this.Close();
+        }
+
+        private void OnHelpClicked(object sender, CancelEventArgs e)
+        {
+            e.Cancel = true;
+            ShowHelp();
+        }
+
+        private void OnHelpRequested(object sender, HelpEventArgs e)
+        {
+            ShowHelp();
+        }
+
+        private void ShowHelp()
+        {
+            if (serviceProvider != null)
+            {
+                IHelpService helpService = serviceProvider.GetService(typeof(IHelpService)) as IHelpService;
+                if (helpService != null)
+                {
+                    helpService.ShowHelpFromKeyword(this.GetType().FullName + ".UI");
+                }
+                else
+                {
+                    IUIService uisvc = serviceProvider.GetService(typeof(IUIService)) as IUIService;
+                    if (uisvc != null)
+                        uisvc.ShowError(Messages.NoHelp);
+                }
+            }
+            else
+            {
+                IUIService uisvc = (IUIService)GetService(typeof(IUIService));
+                if (uisvc != null)
+                    uisvc.ShowError(Messages.NoHelp);
+            }
+        }
+
+        private void OnNew(object sender, EventArgs e)
+        {
+            try
+            {
+                this.OnComponentChanging();
+                object newObject = OnNewInternal();
+                if (newObject != null)
+                {
+                    using (new WaitCursor())
+                    {
+                        ListViewItem listViewItem = this.rulesListView.Items.Add(new ListViewItem());
+                        this.UpdateListViewItem(newObject, listViewItem);
+                        listViewItem.Selected = true;
+                        this.OnComponentChanged();
+                    }
+                }
+            }
+            catch (InvalidOperationException ex)
+            {
+                DesignerHelpers.DisplayError(ex.Message, this.Text, this.activity.Site);
+            }
+        }
+
+        private void OnEdit(object sender, EventArgs e)
+        {
+            try
+            {
+                this.OnComponentChanging();
+                object updatedRuleObject = null;
+                object ruleObject = this.rulesListView.SelectedItems[0].Tag;
+                if (OnEditInternal(ruleObject, out updatedRuleObject))
+                {
+                    using (new WaitCursor())
+                    {
+                        this.UpdateListViewItem(updatedRuleObject, this.rulesListView.SelectedItems[0]);
+                        this.UpdatePreview(this.previewRichTextBox, updatedRuleObject);
+                        this.OnComponentChanged();
+                    }
+                }
+            }
+            catch (InvalidOperationException ex)
+            {
+                DesignerHelpers.DisplayError(ex.Message, this.Text, this.activity.Site);
+            }
+        }
+
+        private void OnRename(object sender, EventArgs e)
+        {
+            try
+            {
+                this.OnComponentChanging();
+                object ruleObject = this.rulesListView.SelectedItems[0].Tag;
+                string newName = OnRenameInternal(ruleObject);
+                if (newName != null)
+                {
+                    using (new WaitCursor())
+                    {
+                        ListViewItem selectedItem = this.rulesListView.SelectedItems[0];
+                        selectedItem.Text = newName;
+                        this.OnComponentChanged();
+                    }
+                }
+            }
+            catch (InvalidOperationException ex)
+            {
+                DesignerHelpers.DisplayError(ex.Message, this.Text, this.activity.Site);
+            }
+        }
+
+        private void OnDelete(object sender, EventArgs e)
+        {
+            MessageBoxOptions mbo = (MessageBoxOptions)0;
+            if (CultureInfo.CurrentUICulture.TextInfo.IsRightToLeft)
+                mbo = MessageBoxOptions.RightAlign | MessageBoxOptions.RtlReading;
+            DialogResult dr = MessageBox.Show(this, this.ConfirmDeleteMessageText, this.ConfirmDeleteTitleText,
+                MessageBoxButtons.OKCancel, MessageBoxIcon.Question, MessageBoxDefaultButton.Button1, mbo);
+            if (dr == DialogResult.OK)
+            {
+                using (new WaitCursor())
+                {
+                    object ruleObject = this.rulesListView.SelectedItems[0].Tag;
+
+                    try
+                    {
+                        this.OnComponentChanging();
+                        int selectionIndex = this.rulesListView.SelectedIndices[0];
+                        object selectedRuleObject = null;
+                        OnDeleteInternal(ruleObject);
+                        this.rulesListView.Items.RemoveAt(selectionIndex);
+                        if (this.rulesListView.Items.Count > 0)
+                        {
+                            int newSelectionIndex = Math.Min(selectionIndex, this.rulesListView.Items.Count - 1);
+                            this.rulesListView.Items[newSelectionIndex].Selected = true;
+                            selectedRuleObject = this.rulesListView.Items[newSelectionIndex].Tag;
+                        }
+                        this.UpdatePreview(this.previewRichTextBox, selectedRuleObject);
+                        this.OnComponentChanged();
+                    }
+                    catch (InvalidOperationException ex)
+                    {
+                        DesignerHelpers.DisplayError(ex.Message, this.Text, this.activity.Site);
+                    }
+                }
+            }
+        }
+
+        private void OnItemSelectionChanged(object sender, ListViewItemSelectionChangedEventArgs e)
+        {
+            if (e.IsSelected)
+                e.Item.Focused = true;
+
+            OnToolbarStatus();
+            this.okButton.Enabled = e.IsSelected;
+
+            object currentRuleObject = null;
+            if (e.IsSelected)
+                currentRuleObject = e.Item.Tag;
+
+            UpdatePreview(this.previewRichTextBox, currentRuleObject);
+        }
+
+        private void OnDoubleClick(object sender, EventArgs e)
+        {
+            if (this.rulesListView.SelectedItems.Count > 0)
+                this.OnOk(sender, e);
+        }
+
+        private void OnToolbarStatus()
+        {
+            if (this.rulesListView.SelectedItems.Count == 1)
+            {
+                this.editToolStripButton.Enabled = true;
+                this.renameToolStripButton.Enabled = true;
+                this.deleteToolStripButton.Enabled = true;
+            }
+            else
+            {
+                this.editToolStripButton.Enabled = false;
+                this.renameToolStripButton.Enabled = false;
+                this.deleteToolStripButton.Enabled = false;
+            }
+        }
+
+        #endregion
+
+        #region helpers
+
+        private bool OnComponentChanging()
+        {
+            bool canChange = true;
+            ISite site = ((IComponent)this.activity).Site;
+            IComponentChangeService changeService = (IComponentChangeService)site.GetService(typeof(IComponentChangeService));
+
+            if (changeService != null)
+            {
+                try
+                {
+                    changeService.OnComponentChanging(this.activity, null);
+                }
+                catch (CheckoutException coEx)
+                {
+                    if (coEx == CheckoutException.Canceled)
+                        canChange = false;
+                    else
+                        throw;
+                }
+            }
+            return canChange;
+        }
+
+        private void OnComponentChanged()
+        {
+            ISite site = ((IComponent)this.activity).Site;
+            IComponentChangeService changeService = (IComponentChangeService)site.GetService(typeof(IComponentChangeService));
+
+            if (changeService != null)
+                changeService.OnComponentChanged(this.activity, null, null, null);
+
+            ConditionHelper.Flush_Rules_DT(site, Helpers.GetRootActivity(this.activity));
+        }
+
+        protected void InitializeListView(IList list, string selectedName)
+        {
+            foreach (object ruleObject in list)
+            {
+                ListViewItem listViewItem = this.rulesListView.Items.Add(new ListViewItem());
+                this.UpdateListViewItem(ruleObject, listViewItem);
+                if (GetObjectName(ruleObject) == selectedName)
+                    listViewItem.Selected = true;
+            }
+
+            if (this.rulesListView.SelectedItems.Count == 0)
+                OnToolbarStatus();
+        }
+
+        #endregion
+
+        #region override methods
+
+        protected abstract string GetObjectName(object ruleObject);
+
+        //commands
+        protected abstract object OnNewInternal();
+        protected abstract bool OnEditInternal(object currentRuleObject, out object updatedRuleObject);
+        protected abstract void OnDeleteInternal(object ruleObject);
+        protected abstract string OnRenameInternal(object ruleObject);
+
+        // populating controls
+        protected abstract void UpdateListViewItem(object ruleObject, ListViewItem listViewItem);
+        protected abstract void UpdatePreview(TextBox previewTextBox, object ruleObject);
+
+        // captions
+        protected abstract string DescriptionText { get; }
+        protected abstract string TitleText { get; }
+        protected abstract string PreviewLabelText { get; }
+        protected abstract string ConfirmDeleteMessageText { get; }
+        protected abstract string ConfirmDeleteTitleText { get; }
+        internal abstract string EmptyNameErrorText { get; }
+        internal abstract string DuplicateNameErrorText { get; }
+        internal abstract string NewNameLabelText { get; }
+        internal abstract string RenameTitleText { get; }
+
+        internal abstract bool IsUniqueName(string ruleName);
+
+        #endregion
+
+        private class WaitCursor : IDisposable
+        {
+            private Cursor oldCursor;
+            public WaitCursor()
+            {
+                Application.DoEvents(); // Force redraw before waiting
+                oldCursor = Cursor.Current;
+                Cursor.Current = Cursors.WaitCursor;
+            }
+            public void Dispose()
+            {
+                Cursor.Current = oldCursor;
+            }
+        }
+    }
+
+    #endregion
+}