Click here to Skip to main content
12,395,188 members (61,303 online)
Click here to Skip to main content
Articles » Languages » C# » General » Downloads

Stats

389.2K views
12.3K downloads
380 bookmarked
Posted

A Simple Wizard Control for .Net 2.0 with Full Designer Support

, 4 Feb 2008 CPOL
This is a simple yet powerful wizard framework for .Net 2.0. Just drag and drop and your component is ready for use.
using System;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Drawing;
using System.Drawing.Design;
using System.Windows.Forms;
using System.Windows.Forms.Design;

namespace WizardBase
{
    internal class WizardStepDesigner : ParentControlDesigner
    {
        private WizardStep wizardStep;

        public override void Initialize(IComponent component)
        {
            wizardStep = (WizardStep) component;
            base.Initialize(component);
        }

        public WizardStepDesigner()
        {
            AutoResizeHandles = true;
        }

        ///<summary>
        ///Gets the design-time action lists supported by the component associated with the designer.
        ///</summary>
        ///
        ///<returns>
        ///The design-time action lists supported by the component associated with the designer.
        ///</returns>
        ///
        public override DesignerActionListCollection ActionLists
        {
            get
            {
                DesignerActionListCollection actionListCollection = new DesignerActionListCollection();
                WizardStepDesignerActionList designerActionList = new WizardStepDesignerActionList(wizardStep);
                actionListCollection.Add(designerActionList);
                return actionListCollection;
            }
        }

        ///<summary>
        ///Indicates if this designer's control can be parented by the control of the specified designer.
        ///</summary>
        ///
        ///<returns>
        ///true if the control managed by the specified designer can parent the control managed by this designer; otherwise, false.
        ///</returns>
        ///
        ///<param name="parentDesigner">The <see cref="T:System.ComponentModel.Design.IDesigner"></see> that manages the control to check. </param>
        public override bool CanBeParentedTo(IDesigner parentDesigner)
        {
            if (parentDesigner == null)
            {
                return false;
            }
            return (parentDesigner.Component is WizardControl);
        }

        internal void OnDragCompleteInternal(DragEventArgs de)
        {
            OnDragComplete(de);
        }

        internal void OnDragDropInternal(DragEventArgs de)
        {
            OnDragDrop(de);
        }

        internal void OnDragEnterInternal(DragEventArgs de)
        {
            OnDragEnter(de);
        }

        internal void OnDragLeaveInternal(EventArgs e)
        {
            OnDragLeave(e);
        }

        internal void OnDragOverInternal(DragEventArgs e)
        {
            OnDragOver(e);
        }

        internal void OnGiveFeedbackInternal(GiveFeedbackEventArgs e)
        {
            OnGiveFeedback(e);
        }

        public override SelectionRules SelectionRules
        {
            get { return (base.SelectionRules & ~(SelectionRules.Moveable | SelectionRules.AllSizeable)); }
        }


        internal class WizardStepDesignerActionList : DesignerActionList
        {
            public WizardStepDesignerActionList(IComponent component) : base(component)
            {
            }

            protected virtual WizardStep WizardStep
            {
                get { return (WizardStep)Component; }
            }

            ///<summary>
            ///Gets or sets a value indicating whether the smart tag panel should automatically be displayed when it is created.
            ///</summary>
            ///
            ///<returns>
            ///true if the panel should be shown when the owning component is created; otherwise, false. The default is false.
            ///</returns>
            ///
            public override bool AutoShow
            {
                get
                {
                    return true;
                }
                set
                {
                    base.AutoShow = value;
                }
            }

            ///<summary>
            ///Returns the collection of <see cref="T:System.ComponentModel.Design.DesignerActionItem"></see> objects contained in the list.
            ///</summary>
            ///
            ///<returns>
            ///A <see cref="T:System.ComponentModel.Design.DesignerActionItem"></see> array that contains the items in this list.
            ///</returns>
            ///
            public override DesignerActionItemCollection GetSortedActionItems()
            {
                DesignerActionItemCollection items = new DesignerActionItemCollection();
                items.Add(new DesignerActionHeaderItem("Appearence", "Appearence"));
                items.Add(new DesignerActionMethodItem(this, "ResetAppearence", "Reset Appearence", "Appearence", true));
                if(WizardStep is StartStep)
                {
                    items.Add(new DesignerActionPropertyItem("StartTitle", "Title", "Appearence"));
                    items.Add(new DesignerActionPropertyItem("StartSubTitle", "SubTitle", "Appearence"));
                    items.Add(new DesignerActionPropertyItem("StartBindingImage", "BindingImage", "Appearence"));
                    items.Add(new DesignerActionPropertyItem("StartIcon", "Icon", "Appearence"));
                    items.Add(new DesignerActionPropertyItem("StartLeftPair", "Left pane appearence", "Appearence"));
                }

                if (WizardStep is LicenceStep)
                {
                    items.Add(new DesignerActionPropertyItem("LicenceTitle", "Title", "Appearence"));
                    items.Add(new DesignerActionPropertyItem("LicenceSubTitle", "SubTitle", "Appearence"));
                    items.Add(new DesignerActionPropertyItem("LicenceBindingImage", "BindingImage", "Appearence"));
                    items.Add(new DesignerActionPropertyItem("LicenceHeaderPair", "HeaderPair", "Appearence"));
                    items.Add(new DesignerActionHeaderItem("Licence", "Licence"));
                    items.Add(new DesignerActionPropertyItem("LicenceAccepted", "Licence Accepted", "Licence"));
                    items.Add(new DesignerActionPropertyItem("LicenceAcceptText", "Licence AcceptText", "Licence"));
                    items.Add(new DesignerActionPropertyItem("LicenceDeclineText", "Licence DeclineText", "Licence"));
                    items.Add(new DesignerActionPropertyItem("LicenceLicenseFile", "License File", "Licence"));
                }

                if (WizardStep is IntermediateStep)
                {
                    items.Add(new DesignerActionPropertyItem("IntermediateTitle", "Title", "Appearence"));
                    items.Add(new DesignerActionPropertyItem("IntermediateSubTitle", "SubTitle", "Appearence"));
                    items.Add(new DesignerActionPropertyItem("IntermediateBindingImage", "BindingImage", "Appearence"));
                    items.Add(new DesignerActionPropertyItem("IntermediateHeaderPair", "HeaderPair", "Appearence"));
                }

                if(WizardStep is FinishStep)
                {
                    items.Add(new DesignerActionPropertyItem("FinishBindingImage", "BindingImage", "Appearence"));
                    items.Add(new DesignerActionPropertyItem("FinishPair", "Pair", "Appearence"));
                }
                return items;
            }

            #region Start page actions

            public virtual Image StartBindingImage
            {
                get { return ((StartStep)WizardStep).BindingImage ; }
                set
                {
                    if (((StartStep)WizardStep).BindingImage != value)
                    {
                        ((StartStep)WizardStep).BindingImage = value;
                        WizardStep.Invalidate();
                    }
                }
            }
            [Editor(typeof(MultilineStringEditor), typeof(UITypeEditor))]
            public virtual string StartTitle
            {
                get { return ((StartStep)WizardStep).Title; }
                set
                {
                    if (((StartStep)WizardStep).Title != value)
                    {
                        ((StartStep)WizardStep).Title = value;
                        WizardStep.Invalidate();
                    }
                }
            }
            [Editor(typeof(MultilineStringEditor), typeof(UITypeEditor))]
            public virtual string StartSubTitle
            {
                get { return ((StartStep)WizardStep).Subtitle; }
                set
                {
                    if (((StartStep)WizardStep).Subtitle != value)
                    {
                        ((StartStep)WizardStep).Subtitle = value;
                        WizardStep.Invalidate();
                    }
                }
            }

            public virtual Image StartIcon
            {
                get { return ((StartStep)WizardStep).Icon; }
                set
                {
                    if (((StartStep)WizardStep).Icon != value)
                    {
                        ((StartStep)WizardStep).Icon = value;
                        WizardStep.Invalidate();
                    }
                }
            }
            public virtual ColorPair StartLeftPair
            {
                get { return ((StartStep) WizardStep).LeftPair; }
                set
                {
                    if (((StartStep)WizardStep).LeftPair != value)
                    {
                        ((StartStep)WizardStep).LeftPair = value;
                        WizardStep.Invalidate();
                    }
                }
            }

            #endregion

            #region Licence page actions

            public virtual Image LicenceBindingImage
            {
                get { return ((LicenceStep)WizardStep).BindingImage; }
                set
                {
                    if (((LicenceStep)WizardStep).BindingImage != value)
                    {
                        ((LicenceStep)WizardStep).BindingImage = value;
                        WizardStep.Invalidate();
                    }
                }
            }
            [Editor(typeof(MultilineStringEditor), typeof(UITypeEditor))]
            public virtual string LicenceTitle
            {
                get { return ((LicenceStep)WizardStep).Title; }
                set
                {
                    if (((LicenceStep)WizardStep).Title != value)
                    {
                        ((LicenceStep)WizardStep).Title = value;
                        WizardStep.Invalidate();
                    }
                }
            }
            [Editor(typeof(MultilineStringEditor), typeof(UITypeEditor))]
            public virtual string LicenceSubTitle
            {
                get { return ((LicenceStep)WizardStep).Subtitle; }
                set
                {
                    if (((LicenceStep)WizardStep).Subtitle != value)
                    {
                        ((LicenceStep)WizardStep).Subtitle = value;
                        WizardStep.Invalidate();
                    }
                }
            }

            public virtual bool? LicenceAccepted
            {
                get { return ((LicenceStep)WizardStep).Accepted; }
                set
                {
                    if (((LicenceStep)WizardStep).Accepted != value)
                    {
                        ((LicenceStep)WizardStep).Accepted = value;
                        WizardStep.Invalidate();
                    }
                }
            }
            [Editor(typeof(CustomFileNameEditor), typeof(UITypeEditor))]
            public virtual string LicenceLicenseFile
            {
                get { return ((LicenceStep)WizardStep).LicenseFile; }
                set
                {
                    if (((LicenceStep)WizardStep).LicenseFile != value)
                    {
                        ((LicenceStep)WizardStep).LicenseFile = value;
                        WizardStep.Invalidate();
                    }
                }
            }

            public virtual string LicenceAcceptText
            {
                get { return ((LicenceStep)WizardStep).AcceptText; }
                set
                {
                    if (((LicenceStep)WizardStep).AcceptText != value)
                    {
                        ((LicenceStep)WizardStep).AcceptText = value;
                        WizardStep.Invalidate();
                    }
                }
            }
            public virtual string LicenceDeclineText
            {
                get { return ((LicenceStep)WizardStep).DeclineText; }
                set
                {
                    if (((LicenceStep)WizardStep).DeclineText != value)
                    {
                        ((LicenceStep)WizardStep).DeclineText = value;
                        WizardStep.Invalidate();
                    }
                }
            }
            public virtual ColorPair LicenceHeaderPair
            {
                get { return ((LicenceStep)WizardStep).HeaderPair; }
                set
                {
                    ((LicenceStep)WizardStep).HeaderPair = value;
                    WizardStep.Invalidate();
                }
            }
            #endregion

            #region Licence page actions

            public virtual Image IntermediateBindingImage
            {
                get { return ((IntermediateStep)WizardStep).BindingImage; }
                set
                {
                    if (((IntermediateStep)WizardStep).BindingImage != value)
                    {
                        ((IntermediateStep)WizardStep).BindingImage = value;
                        WizardStep.Invalidate();
                    }
                }
            }
            [Editor(typeof(MultilineStringEditor), typeof(UITypeEditor))]
            public virtual string IntermediateTitle
            {
                get { return ((IntermediateStep)WizardStep).Title; }
                set
                {
                    if (((IntermediateStep)WizardStep).Title != value)
                    {
                        ((IntermediateStep)WizardStep).Title = value;
                        WizardStep.Invalidate();
                    }
                }
            }
            [Editor(typeof(MultilineStringEditor), typeof(UITypeEditor))]
            public virtual string IntermediateSubTitle
            {
                get { return ((IntermediateStep)WizardStep).Subtitle; }
                set
                {
                    if (((IntermediateStep)WizardStep).Subtitle != value)
                    {
                        ((IntermediateStep)WizardStep).Subtitle = value;
                        WizardStep.Invalidate();
                    }
                }
            }
            public virtual ColorPair IntermediateHeaderPair
            {
                get { return ((IntermediateStep)WizardStep).HeaderPair; }
                set
                {
                    if (((IntermediateStep)WizardStep).HeaderPair != value)
                    {
                        ((IntermediateStep)WizardStep).HeaderPair = value;
                        WizardStep.Invalidate();
                    }
                }
            }

            #endregion

            #region Finish Step actions

            public virtual ColorPair FinishPair
            {
                get { return ((FinishStep)WizardStep).Pair; }
                set
                {
                    if (((FinishStep)WizardStep).Pair != value)
                    {
                        ((FinishStep)WizardStep).Pair = value;
                        WizardStep.Invalidate();
                    }
                }
            }

            public virtual Image FinishBindingImage
            {
                get { return ((FinishStep)WizardStep).BindingImage; }
                set
                {
                    if (((FinishStep)WizardStep).BindingImage != value)
                    {
                        ((FinishStep)WizardStep).BindingImage = value;
                        WizardStep.Invalidate();
                    }
                }
            }

            #endregion



            protected virtual void ResetAppearence()
            {
                WizardStep.Reset();
                WizardStep.Invalidate();
            }
        }
    }
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Manish Ranjan Kumar
Software Developer (Senior)
India India
No Biography provided

You may also be interested in...

| Advertise | Privacy | Terms of Use | Mobile
Web02 | 2.8.160721.1 | Last Updated 4 Feb 2008
Article Copyright 2007 by Manish Ranjan Kumar
Everything else Copyright © CodeProject, 1999-2016
Layout: fixed | fluid