C# and Windows Form Programming

C# Image Zoom Extender control

2010-06-25T16:20:00.001-04:00

[ProvideProperty("AfterZoomImage", typeof(PictureBox))]
[ProvideProperty("ZoomFactor", typeof(PictureBox))]
public partial class ImageZoomProvider : Component, IExtenderProvider
{
    public ImageZoomProvider()
    {
        InitializeComponent();
        AnchorStyle = AnchorPoint.TopLeft;
    }


    // Theses will hold references to extended objects.
    private Hashtable pictureBoxes = new Hashtable();
    private Hashtable afterZoomImages = new Hashtable();


    #region "AfterZoomImage"


    [DefaultValue(null)]
    [Description("The image that will be used to display the zoomed image, if set to null the value of the PictureBox.Image property will be used instead")]
    [Category("ImageZoomProvider")]
    public Image GetAfterZoomImage(PictureBox pictureBox)
    {
        if (pictureBox == null)
        {
            throw new ArgumentNullException("pictureBox");
        }
        Image imageAfterZoom = null;
        if (afterZoomImages.Contains(pictureBox))
        {
            imageAfterZoom = afterZoomImages[pictureBox] as Image;
        }
        return imageAfterZoom;
    }


    public void SetAfterZoomImage(PictureBox pictureBox, Image afterZoomImage)
    {
        if (pictureBox == null)
        {
            throw new ArgumentNullException("pictureBox");
        }


        if (afterZoomImage == null)
        {
            if (afterZoomImages.Contains(pictureBox))
                afterZoomImages.Remove(pictureBox);
        }
        else
            afterZoomImages[pictureBox] = afterZoomImage;
    }


    #endregion


    #region IExtenderProvider Members


    public bool CanExtend(object extendee)
    {
        return extendee is PictureBox;
    }


    #endregion


    #region "ZoomFactor"


    [DefaultValue(1)]
    [Description("The factor by which the Image will be zoomed")]
    [Category("ImageZoomProvider")]
    public int GetZoomFactor(PictureBox pictureBox)
    {
        if (pictureBox == null)
        {
            throw new ArgumentNullException("pictureBox");
        }


        object value = pictureBoxes[pictureBox];
        if (value != null)
        {
            return (int)value;
        }
        else
            return ImageZoomProvider.NoZoom;
    }


    public void SetZoomFactor(PictureBox pictureBox, int zoomFactor)
    {


        if (pictureBox == null)
        {
            throw new ArgumentNullException("pictureBox");
        }
        // To Do validate Zoom Factor here.
        if (zoomFactor < 1)
        {
            throw new ArgumentException("ZoomFactor should be greater or equal to 1");
        }
        object oldZoomFactor = pictureBoxes[pictureBox];


        if (oldZoomFactor == null)
        {
            // No zoom factor was associated to this control. Then add zoom factor and set handlers.
            if (zoomFactor != NoZoom)
            {
                pictureBoxes[pictureBox] = zoomFactor;
                if (ZoomOnClick)
                {
                    pictureBox.Click += new EventHandler(OnPictureBoxClick);
                }
                else
                {
                    pictureBox.MouseEnter += new EventHandler(OnPictureBoxMouseEnter);
                    pictureBox.MouseLeave += new EventHandler(OnPictureBoxMouseLeave);
                }
            }
        }
        else
        {
            int oldZoomValue = (int)oldZoomFactor;
            // Zomm Factor has changed ?
            if (oldZoomValue != zoomFactor)
            {
                // update the zoom factor.
                pictureBoxes[pictureBox] = zoomFactor;
                if (zoomFactor == NoZoom)
                {
                    // Remove zoom logic.
                    pictureBoxes.Remove(pictureBox);
                    if (ZoomOnClick)
                    {
                        pictureBox.Click -= new EventHandler(OnPictureBoxClick);
                    }
                    else
                    {
                        pictureBox.MouseEnter -= new EventHandler(OnPictureBoxMouseEnter);
                        pictureBox.MouseLeave -= new EventHandler(OnPictureBoxMouseLeave);
                    }
                }
            }
        }
    }






    #endregion


    #region "Public Properties"


    [DefaultValue(100)]
    [Description("When ZoomOnClick property is false, this value is used as an initial delay debore showing the zoomed picture")]
    [Category("ImageZoomProvider")]
    public int ZoomDelay
    {
        get
        {
            return timer.Interval;
        }
        set
        {
            timer.Interval = value;
        }
    }


    [DefaultValue(100)]
    [Description("When UseAnimation is set to true, this value controls how fast the animation is")]
    [Category("ImageZoomProvider")]
    public int AnimationInterval
    {
        get
        {
            return timerAnimation.Interval;
        }
        set
        {
            timerAnimation.Interval = value;
        }
    }


    private AnchorPoint anchorStyle = AnchorPoint.TopLeft;
    [Category("ImageZoomProvider")]
    [DefaultValue(AnchorPoint.TopLeft)]
    public AnchorPoint AnchorStyle
    {
        get { return anchorStyle; }
        set { anchorStyle = value; }
    }


    private int border = 0;
    [Category("ImageZoomProvider")]
    [DefaultValue(0)]
    [Description("if value is different than 0, a border rectangle will be drawn around the zoomed image")]
    public int Border
    {
        get { return border; }
        set { border = value; }
    }


    [Category("ImageZoomProvider")]
    [DefaultValue(false)]
    [Description("if set to true, the image will grow in steps")]
    public bool UseAnimation { get; set; }


    private ImageZoomForm zoomForm = null;
    private static int noZoom = 1;


    public static int NoZoom
    {
        get { return ImageZoomProvider.noZoom; }
    }


    private bool zoomOnClick = false;
    [DefaultValue(false)]
    [Description("If set to true then zoom will be triggered by mouse click, otherwise mouse hover will trigger the zoom")]
    [Category("ImageZoomProvider")]
    public bool ZoomOnClick
    {
        get { return zoomOnClick; }
        set 
        {
            if (zoomOnClick != value)
            {
                zoomOnClick = value;
                UpdatePictureBoxesHandlers();
            }
        }
    }


    #endregion




    private void UpdatePictureBoxesHandlers()
    {
        if (pictureBoxes != null)
        {
            foreach (PictureBox pictureBox in pictureBoxes.Keys)
            {
                if (ZoomOnClick)
                {
                    pictureBox.MouseEnter -= new EventHandler(OnPictureBoxMouseEnter);
                    pictureBox.MouseLeave -= new EventHandler(OnPictureBoxMouseLeave);
                    pictureBox.Click += new EventHandler(OnPictureBoxClick);
                }
                else
                {
                    pictureBox.Click -= new EventHandler(OnPictureBoxClick);
                    pictureBox.MouseEnter += new EventHandler(OnPictureBoxMouseEnter);
                    pictureBox.MouseLeave += new EventHandler(OnPictureBoxMouseLeave);
                }
            }
        }
    }


    public ImageZoomProvider(IContainer container)
    {
        container.Add(this);
        InitializeComponent();
    }


    void OnPictureBoxClick(object sender, EventArgs e)
    {
        timer.Tag = sender;
        // No delay required. call timer.Tick event Handler.
        ShowZoomedPicture(timer, EventArgs.Empty);
    }


    void OnPictureBoxMouseLeave(object sender, EventArgs e)
    {
        timer.Tag = null;
        timer.Stop();
    }


    void OnPictureBoxMouseEnter(object sender, EventArgs e)
    {
        timer.Tag = sender;
        timer.Start();
    }


    private void ShowZoomedPicture(object sender, EventArgs e)
    {
        // Show zoomed window here.
        timer.Stop();
        if (pictureBoxes.Contains(timer.Tag))
        {
            int zoomFactor = (int)pictureBoxes[timer.Tag];
            PictureBox pictureBox = (PictureBox)timer.Tag;


            if (zoomForm == null)
                zoomForm = new ImageZoomForm();


            // Set zoom properties.
            zoomForm.InitialSize = pictureBox.Size;
            zoomForm.Border = Border;
            zoomForm.ZoomFactor = zoomFactor;


            Image afterZoomImage = GetAfterZoomImage(pictureBox);
            if (afterZoomImage == null)
                afterZoomImage = pictureBox.Image;




            if (zoomForm.Image != afterZoomImage)
                zoomForm.Image = afterZoomImage;




            if (!UseAnimation)
            {
                zoomForm.Size = new Size(zoomFactor * pictureBox.Size.Width,
                    zoomFactor * pictureBox.Size.Height);
                ControlAnchorer.AnchorControl(zoomForm, pictureBox,AnchorStyle);
                zoomForm.Show();
            }
            else
            {
                if (AnchorStyle == AnchorPoint.OverlapCenters || AnchorStyle == AnchorPoint.TopCenter)
                {
                    zoomForm.Size = new Size(zoomFactor * pictureBox.Size.Width,
                    zoomFactor * pictureBox.Size.Height);
                    ControlAnchorer.AnchorControl(zoomForm, pictureBox, AnchorStyle);
                }
                zoomForm.Size = new Size(pictureBox.Size.Width,
                        pictureBox.Size.Height);
                if(AnchorStyle != AnchorPoint.OverlapCenters && AnchorStyle != AnchorPoint.TopCenter)
                    ControlAnchorer.AnchorControl(zoomForm, pictureBox, AnchorStyle);


                originalSize = zoomForm.Size;
                growSize = new Size((zoomFactor -1) * originalSize.Width /3,( zoomFactor-1)  * originalSize.Height/3 );
                counter = 0;


                timerAnimation.Tag = pictureBox;
                timerAnimation.Start();
                zoomForm.Show();
                }
        }
    }


    private Size originalSize = Size.Empty;
    private Size growSize = Size.Empty;
    private int counter = 0;
    private void timerAnimation_Tick(object sender, EventArgs e)
    {
        if (counter < 3)
        {
            zoomForm.Size += growSize;
            //ControlAnchorer.AnchorControl(zoomForm, timerAnimation.Tag as Control, AnchorStyle);
            counter++;
        }
        else
        {
            timerAnimation.Stop();
        }
    }






    internal class ImageZoomForm : Form
    {
        private int border = 0;
        private Size initialSize;
        private int zoomFactor = 1;


        private PictureBox zoomedPicture = null;


        public int Border
        {
            get { return border; }
            set
            { 
                border = value;
                UpdateZoomedPictureSize();
            }
        }


        public Size InitialSize
        {
            get { return initialSize; }
            set
            {
                initialSize = value;
                Size = value;
                UpdateZoomedPictureSize();
            }
        }




        public int ZoomFactor
        {
            get { return zoomFactor; }
            set
            {
                zoomFactor = value;
            }
        }


        private void UpdateZoomedPictureSize()
        {
            if (zoomedPicture != null)
            {
                zoomedPicture.Size = new Size(initialSize.Width  - (border * 2),
                    initialSize.Height  - (border * 2));
                zoomedPicture.Location = new Point(border, border);
            }
        }


        public ImageZoomForm()
        {
            TopMost = true;
            BackColor = Color.Black;
            ShowInTaskbar = false;
            StartPosition = FormStartPosition.Manual;
            FormBorderStyle = FormBorderStyle.None;
            zoomedPicture = new PictureBox();
            zoomedPicture.SizeMode = PictureBoxSizeMode.Zoom;
            zoomedPicture.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right | AnchorStyles.Bottom;
            zoomedPicture.Click += new EventHandler(OnClick);
            Click += new EventHandler(OnClick);
            LostFocus += new EventHandler(OnLostFocus);
            Controls.Add(zoomedPicture);
        }


        void OnLostFocus(object sender, EventArgs e)
        {
            Hide();
        }


        void OnClick(object sender, EventArgs e)
        {
            PictureBox pictureBox = sender as PictureBox;
            if (pictureBox != null)
            {
                ((Form)pictureBox.Parent).Hide();
            }
            else
                ((Form)sender).Hide();
        }


        public Image Image
        {
            get
            {
                return zoomedPicture.Image;
            }
            set
            {
                zoomedPicture.Image = value;
            }
        }


        protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
        {
            if (keyData == Keys.Escape)
            {
                DialogResult = System.Windows.Forms.DialogResult.OK;
                Hide();
                return true;
            }
            else
            {
                return base.ProcessCmdKey(ref msg, keyData);
            }
        }




    }






}




References:
Developing .NET Custom Controls and Designers Using Visual Basic .NET (Second Edition)
Pro .NET 2.0 Windows Forms and Custom Controls in C#

Browse For file or directory custom control in C#

2010-06-24T16:30:00.011-04:00

I had often to create a browse button along with a text box that will display the access path to a folder or a file on File System, So I have decided to create a composite control that will have this feature built in.

Here is a snapshot of the control as run-time.

The control is simply a wrapper for both FolderBrowserDialog and OpenFileDialog classes.

Here is the code:

[DefaultProperty("Text")]
[DefaultEvent("SelectedPathChanged")]
public partial class BrowseButton : UserControl
{   
     /// 
    /// The event will be fired whenever end users change the selected folder of file.
    /// 
    public event EventHandler SelectedPathChanged;


  




     /// 
    /// The event will be fired just before accepting the file or folders end user selected. we give  
    /// developer the chance to catch this event and cancel the selection if necessary.
    /// 

    public event EventHandler<SelectedPathCancelEventArgs> SelectedPathChanging;
    private event EventHandler BrowseTypeChanged;


  
    /// 
    /// Describes and determines how to respond the Browse button click.
    /// 
    public enum BrowseTarget
    {
        /// 
        /// Indicates that selection should be performed against Files.
        /// 
        File,
        /// 
        /// Indicates that selection should be performed against Directories.
        /// 
        Directory
    }


  
    public BrowseButton()
    {
        InitializeComponent();
        BrowseTypeChanged += new EventHandler(BrowseButton_BrowseTypeChanged);
        Text = "Browse";
    }


  




    /// if the user has Set BrowseType property to File and MultiFileSelect is true than set textbox MultiLine property to true as well, so we can display multiple selections.
    void BrowseButton_BrowseTypeChanged(object sender, EventArgs e)

    {
        switch (BrowseType)
        {
            case BrowseTarget.File:
                txtPath.Multiline = MultiFileSelect;
                break;
            case BrowseTarget.Directory:
                txtPath.Multiline = false;
                break;
            default:
                break;
        }
    }
Here is the effect at runtime:


 


    [DefaultValue("")]
    [Category("BrowseButton")]
    [Description("The file filters to display in the dialog box, for example, \"C# files|*.cs|All files|*.*\".")]
    public string FileFilter 
    {
        get
        {
            return ofd.Filter;
        }
        set
        {
            ofd.Filter = value;
        } 
    }


 
    [Editor("System.Windows.Forms.Design.SelectedPathEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", 
        typeof(UITypeEditor))]
    [Description("The path of the folder first selected in the dialog or the last one selected by the user.")]
    [Category("BrowseButton")]
    public string InitialPath
    {
        get
        {
            string val = "";
            switch (target)
            {
                case BrowseTarget.File:
                    val = ofd.InitialDirectory;
                    break;


 
                    case BrowseTarget.Directory:
                    val = fbd.SelectedPath;
                    break;


 
                default:
                    break;
            }
            return val;
        }
        set
        {
            ofd.InitialDirectory = value;
            fbd.SelectedPath = value;
        }
    }


 


 
    [DefaultValue("")]
    [Description("Gets or sets the selected path")]
    [Category("BrowseButton")]
    public string SelectedPath {
        get
        {
            return txtPath.Text;
        }
        set
        {
            if (SelectedPath != value)
            {
                SelectedPathCancelEventArgs e = new SelectedPathCancelEventArgs(value);
                /// Fire selection changing event.
                OnSelectedPathChanging(this, e);
                /// if cancel is not requested than apply the new value.
                if(!e.Cancel)
                    /// this wil trigger SelectedPathChanged event.
                    txtPath.Text = value;
            }
        }
    }


 
    private BrowseTarget target = BrowseTarget.File;
    [DefaultValue(BrowseTarget.File)]
    [Description("Specify the target of the browse, either a file or a directory")]
    [Category("BrowseButton")]
    public BrowseTarget BrowseType
    {
        get
        {
            return target;
        }
        set
        {
            if (target != value)
            {
                target = value;
                if (BrowseTypeChanged != null)
                {
                    BrowseTypeChanged(this, EventArgs.Empty);
                }
            }


 


 
        }
    }
     /// This is the handler for Click event on browse button. FolderBrowserDialog or OpenFileFDialog will be shown based on the value of target.
    private void btnBrowse_Click(object sender, EventArgs e)
    {
        switch (target)
        {
            case BrowseTarget.File:
                if (ofd.ShowDialog() == DialogResult.OK)
                {
                    if (ofd.Multiselect)
                    {
                        StringBuilder builder = new StringBuilder();
                        foreach (string fileName in ofd.FileNames)
                        {
                            builder.AppendLine(fileName);
                        }
                        SelectedPath = builder.ToString();
                    }
                    else
                        SelectedPath = ofd.FileName;
                }
                break;
            case BrowseTarget.Directory:
                if (fbd.ShowDialog() == DialogResult.OK)
                {
                    SelectedPath = fbd.SelectedPath;
                }
                break;
            default:
                break;
        }
    }


 
Here is what is shown in case if target = Directory.


 
and in case target = File:


 


 


    private void txtPath_TextChanged(object sender, EventArgs e)
    {
        OnSelectedPathChanged(this, e);
    }


 
    protected virtual void OnSelectedPathChanged(object sender, EventArgs e)
    {
        if (SelectedPathChanged != null)
            SelectedPathChanged(sender, e);
    }


 
    protected virtual void OnSelectedPathChanging(object sender, SelectedPathCancelEventArgs e)
    {
        if (SelectedPathChanging != null)
            SelectedPathChanging(sender, e);
    }


 
    [Description("The text associated with the control")]
    [Category("BrowseButton")]
    [Browsable(true)]
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
    public override string Text
    {
        get
        {
            return btnBrowse.Text;
        }
        set
        {
            btnBrowse.Text = value;
        }
    }
    // When this property is set to true, the Text box field can not be edited, otherwise yes.
    [DefaultValue(false)]
    [Description("Controls whether the text in the edit control can be changed or not.")]
    public bool ReadOnly
    {
        get
        {
            return txtPath.ReadOnly;
        }
        set
        {
            txtPath.ReadOnly = value;
        }        
    }


 
here are snapshots for both cases:
ReadOnly = true


 
and ReadOnly = false


 


 
    [Description("Controls whether multiple files can be selected in the dialog. This property has an effect when BrowseType = BrowseTarget.File")]
    [DefaultValue(false)]
    [Category("BrowseButton")]
    public bool MultiFileSelect 
    {
        get
        {
            return ofd.Multiselect;
        }
        set
        {
            ofd.Multiselect = value;
            if (target == BrowseTarget.File)
            {
                txtPath.Multiline = value;
            }
        }
    }


 
When MultiFileSelect = true and BrowseType = File than TextBox Height changes to fit the control area.


 
if MultiSelect = false than Textbox will get its standard appearance.




 
}


public class SelectedPathCancelEventArgs : CancelEventArgs
{


 
    public SelectedPathCancelEventArgs(string newPath)
        :base()
    {
        this.newPath = newPath;
    }
    private string newPath = null;
    public string NewPath
    {
        get
        {
            return newPath;
        }
    }
}




You can find here a list of book references:
Pro .NET 2.0 Windows Forms and Custom Controls in C#

Walkthrough on how to create a Control Extender in C#

2010-06-18T09:37:00.152-04:00

In this Post I will discuss the steps required to create a a Extender Provider using C#.

On msdn Extender Provider is defined in the following terms:
"An extender provider is a component that provides properties to other components. For example, the ToolTip control is implemented as an extender provider. When you add a ToolTip control to a Form, all other controls on the Form have a ToolTip property added to their properties list."

We will create an Extender Provider that will provide the following properties to a Form controls.
HelpMessage: a string that will hold any description or helpfull information about the extendee
ErrorMessage: a string that will hold an error description that we want to report to end users about an invalid control value.

To create an Extender Provider component you have to basically:

Implements IExtenderProvider interface.
use ProvidePropertyAttribute to specify the name of the provided property, as well as the type of components that may receive the property.

IExtenderProvider: this is a simple interface with one method to implement, CanExtend(object extendee) with a boolean return value to indicate if the extendee parameter can be extended through your Extender Provider.

ProvidePropertyAttribute: Specifies the name of the property that an implementer of IExtenderProvider offers to other components. (msdn)

Here is some C# example of ProvidePropertyAttribute usage.

[ProvideProperty("DisplayName", typeof(Control))]
public class ControlDisplayNameProvider : IExtenderProvider

    Hashtable displayNames = new Hashtable();   
    // Provides the Get portion of DisplayName.

    public string GetDisplayName(Control myControl) {

        return displayNames[myControl] as string ;

    }

    // Provides the Set portion of MyProperty.
    public void SetDisplayName(Control myControl, string value) {

       displayNames[myControl] = value;
    }

    /* When you inherit from IExtenderProvider, you must implement the 
     * CanExtend method. */
    public bool CanExtend(Object target) {
        // This class can extend only control objects.

        return(target is Control);
    }

 }

Here are some test screenshots for the control at run time.
Control Runtime Settings are:
AutoValidateForm = true,
ValidateControlData event has been subscribed to and implemted the following way in this example.

private bool helpLabel1_ValidateControlData(Control control)
{
bool valid = true;
if (control isTextBox)

   {

       valid = !String.IsNullOrEmpty(((TextBox)control).Text);

   }
elseif (control isListControl)

   {

       valid = ((ListControl)control).SelectedIndex != ListBox.NoMatches;

   }
return valid;

}

Figure1: Click on Ok with all fields empty.

Figure 2: Active control is the text box fir first name field. Error is displayed only for this field.

Figure3: Last name field is active an error is displayed for this field.

Figure4: First name field is populated and is active. Help text is displayed in this case.

Figure 5: All fields are Ok. Gender list box is the active control.

Let's get back to the control we want to implement. As described above the control will provide two properties to the extended objects.

using System;

using System.Collections;

using System.ComponentModel;

using System.ComponentModel.Design;

using System.Drawing;

using System.Windows.Forms;

using System.Windows.Forms.Design;

using System.Text;

namespace CustomControls

{

// <doc>

// <desc>

    // HelpAndValidationProvider offers two extender properties "HelpText" and "Errortext".
   // It monitors the active control and displays the help text for the active control if it is valid or an error
   // message if it's data is invalid.

// </desc>

// </doc>

/// <summary>

/// HelpAndValidationLabel

/// </summary>

[

ProvideProperty("HelpText", typeof(Control)),

ProvideProperty("ErrorText", typeof(Control)),

DefaultEvent("ValidateControlData")

]

public class HelpAndValidationProvider : Control, System.ComponentModel.IExtenderProvider

{

/// <summary>

/// Required designer variable.

/// </summary>

private System.ComponentModel.Container components;

private Hashtable helpTexts;

private Hashtable errorTexts;

private System.Windows.Forms.Control activeControl;

// <doc>

// <desc>

// Creates a new help label object.

// </desc>

// </doc>

public HelpAndValidatiponLabel()

{

// Required for Windows Form Designer support

InitializeComponent();

helpTexts = new Hashtable();

errorTexts = new Hashtable();

AutoValidateFormChanged += new AutoValidateFormDelegate(AutoValidateFormChangedHandler);

}

void AutoValidateFormChangedHandler(bool oldValue, bool newValue)

{

if (this.TopLevelControl != null && this.TopLevelControl is Form)

{

if (newValue)

{

EnableAutoValidation();

}

else

{

RemoveAutoValidation();

}

private void RemoveAutoValidation()

{

Form form = (Form)TopLevelControl;

form.FormClosing -= new FormClosingEventHandler(FormClosing);

}

private void EnableAutoValidation()

{

Form form = (Form)TopLevelControl;

form.FormClosing += new FormClosingEventHandler(FormClosing);

}

void FormClosing(object sender, FormClosingEventArgs e)

{

Form formSender = sender as Form;
// Validate only on dialog Result equal to OK. If user clicks cancel than no validation is needed.

if (formSender != null && formSender.DialogResult == DialogResult.OK)

{

if (e.CloseReason == CloseReason.UserClosing || e.CloseReason == CloseReason.None)

{

string summary;

if (!IsFormValid(out summary))

{

e.Cancel = true;

summaryValidation = true;

this.Text = summary;

Invalidate();

}

bool summaryValidation = false;

private bool IsFormValid(out string errorSummary)

{

bool formIsValid = true;

StringBuilder errors = new StringBuilder();

foreach (Control control in errorTexts.Keys)

{

if (control != null)

{

if (!OnValidateControl(control))

{

formIsValid = false;

errors.AppendLine(errorTexts[control] as string);

// If the control does not have a wrapper panel add one to it.

if (control.Parent != null)

{

if (control.Parent is Panel && control.Parent.Name == control.Name + "Panel")

{

control.Parent.BackColor = Color.Red;

}

else

{

CreateWrapperPanel(control);

}

errorSummary = errors.ToString();

return formIsValid;

}

private delegate void AutoValidateFormDelegate(bool oldValue, bool newValue);

private event AutoValidateFormDelegate AutoValidateFormChanged;

private bool autoValidateForm;

/// <summary>

/// If set to true, the form will be validated upon user request to close the form, and close operation will be canceled

/// if the form is not valid

/// </summary>

[DefaultValue(false)]

[Browsable(false)]

[Category("HelpAndValidationLabel")]
[Description("Set this to true to enable auto validation, this has to be set after the control is added to it parent container, otherwise it will not work.")]

public bool AutoValidateForm

{

get { return autoValidateForm; }

set

{

if (autoValidateForm != value)

{

AutoValidateFormChanged(autoValidateForm, value);

}

autoValidateForm = value;

}

/// <summary>

/// Clean up any resources being used.

/// </summary>

protected override void Dispose(bool disposing)

{

if (disposing)

{

components.Dispose();

}

base.Dispose(disposing);

}

/// <summary>

/// Required method for Designer support - do not modify

/// the contents of this method with the code editor.

/// </summary>

private void InitializeComponent()

{

this.components = new System.ComponentModel.Container();

this.BackColor = System.Drawing.SystemColors.Info;

this.ForeColor = System.Drawing.SystemColors.InfoText;

this.TabStop = false;

}

// <doc>

// <desc>

// Overrides the text property of Control. This label ignores

// the text property, so we add additional attributes here so the

// property does not show up in the properties window and is not

// persisted.

// </desc>

// </doc>

[

Browsable(false),

EditorBrowsable(EditorBrowsableState.Never),

DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)

]

public override string Text

{

get

{

return base.Text;

}

set

{

base.Text = value;

}

// <doc>

// <desc>

// This implements the IExtenderProvider.CanExtend method. The

// help and validation provider will provide two will provide HelpText and ErrorText properties

// to control objects except control objects of type HelpAndValidationProvider.

// </desc>

// </doc>

bool IExtenderProvider.CanExtend(object target)

{

if (target is Control &&

!(target is HelpAndValidationProvider))

{

return true;

}

return false;

}

// <doc>

// <desc>

// This is the extended property for the HelpText property. Extended

// properties are actual methods because they take an additional parameter

// that is the object or control to provide the property for.

// </desc>

// </doc>

[

DefaultValue(""),

Category("HelpAndValidationProvider"),

]

public string GetHelpText(Control control)

{

string text = (string)helpTexts[control];

if (text == null)

{

text = string.Empty;

}

return text;

}

// <doc>

// <desc>

// This is the extended property for the ErrorText property. Extended

// properties are actual methods because they take an additional parameter

// that is the object or control to provide the property for.

// </desc>

// </doc>

[

DefaultValue(""),

Category("HelpAndValidationProvider")

]

public string GetErrorText(Control control)

{

string text = (string)errorTexts[control];

if (text == null)

{

text = string.Empty;

}

return text;

}

// <doc>

// <desc>

// This is an event handler that responds to the OnControlEnter

// event. We attach this to each control we are providing help

// text for.

// </desc>

// </doc>

private void OnControlEnter(object sender, EventArgs e)

{

summaryValidation = false;

activeControl = (Control)sender;

if (activeControl != null)

{

error = !OnValidateControl(activeControl);

}

Invalidate();

}

public delegate bool ValidateControlDelegate(Control control);

public event ValidateControlDelegate ValidateControlData;

/// <summary>

/// Validate a control and returns true if it is valid.

/// </summary>

/// <param name="control">Control to validate</param>

/// <returns>True if the control data is valid</returns>

protected virtual bool OnValidateControl(Control control)

{

bool valid = true;

if (ValidateControlData != null)

{

valid = ValidateControlData(control);

}

return valid;

}

bool error = false;

// <doc>

// <desc>

// This is an event handler that responds to the OnControlLeave

// event. We attach this to each control we are providing help

// text for.

// </desc>

// </doc>

private void OnControlLeave(object sender, EventArgs e)

{

summaryValidation = false;

if (sender == activeControl)

{

if (activeControl.Parent != null && activeControl.Parent is Panel &&

activeControl.Parent.Name == activeControl.Name + "Panel")

{

bool err = !OnValidateControl(activeControl);

if (err == false)

activeControl.Parent.BackColor = Color.Transparent;

else

activeControl.Parent.BackColor = Color.Red;

}

activeControl = null;

Invalidate();

}

// <doc>

// <desc>

// This is the extended property for the HelpText property.

// </desc>

// </doc>

public void SetHelpText(Control control, string value)

{

if (value == null)

{

value = string.Empty;

}

if (value.Length == 0)

{

helpTexts.Remove(control);

control.Enter -= new EventHandler(OnControlEnter);

control.Leave -= new EventHandler(OnControlLeave);

}

else

{

helpTexts[control] = value;

control.Enter += new EventHandler(OnControlEnter);

control.Leave += new EventHandler(OnControlLeave);

}

if (control == activeControl)

{

Invalidate();

}

// <doc>

// <desc>

// This is the extended property for the HelpText property.

// </desc>

// </doc>

public void SetErrorText(Control control, string value)

{

if (value == null)

{

value = string.Empty;

}

if (value.Length == 0)

{

errorTexts.Remove(control);

}

else

{

errorTexts[control] = value;

}

// <doc>

// <desc>

// Overrides Control.OnPaint. Here we draw our

// label.

// </desc>

// </doc>

protected override void OnPaint(PaintEventArgs pe)

{

// Let the base draw. This will cover our back

// color and set any image that the user may have

// provided.

base.OnPaint(pe);

if (summaryValidation)

{

Rectangle re = ClientRectangle;

Rectangle r = ClientRectangle;

r.Inflate(-1,-1);

re.Inflate(-2, -2);

Pen pen = new Pen(ForeColor, 2);

pe.Graphics.DrawRectangle(pen, r);

                pen.Dispose();
     // The value of Text property will have the content of the summary validation string.
   // This is set during validation operation..

pe.Graphics.DrawString(Text, Font, Brushes.Red, re);

return;

}

// Draw a rectangle around our control.

Rectangle rect = ClientRectangle;

rect.Width -= 1;

rect.Height -= 1;

Pen borderPen = new Pen(ForeColor);

pe.Graphics.DrawRectangle(borderPen, rect);

borderPen.Dispose();

// Finally, draw the text over the top of the

// rectangle.

if (activeControl != null)

{

string text = null;

if (error)

{

text = (string)errorTexts[activeControl];

}

else

{

text = (string)helpTexts[activeControl];

}

if (!String.IsNullOrEmpty(text))

{

rect.Inflate(-2, -2);

Brush brush = null;

if (!error)

brush = new SolidBrush(ForeColor);

else

brush = new SolidBrush(Color.Red);

pe.Graphics.DrawString(text, Font, brush, rect);

brush.Dispose();

}

// Surround the active contro with a red border.

if (activeControl.Parent != null)

{

if (activeControl.Parent is Panel &&

activeControl.Parent.Name == activeControl.Name + "Panel")

{

if (error)

activeControl.Parent.BackColor = Color.Red;

else

activeControl.Parent.BackColor = Color.Transparent;

}

else

{

if (error)

{

CreateWrapperPanel(activeControl);

}

/// <summary>

/// This method is called to create a wrapper panel around the control to be able to draw Error

/// rectangle around the control if it is in invalid state.

/// </summary>

private void CreateWrapperPanel(Control control)

{

this.SuspendLayout();

Panel panel = new Panel();

panel.Anchor = control.Anchor;

Point location = control.Location;

location.Offset(-2, -2);

panel.Location = location;

panel.Size = new Size(control.Size.Width + 4, control.Size.Height + 4);

panel.Name = control.Name + "Panel";

Control parent = control.Parent;

parent.Controls.Add(panel);

Control cachedActiveControl = control;

panel.Controls.Add(control);

cachedActiveControl.Location = new Point(2, 2);

panel.BackColor = Color.Red;

this.ResumeLayout(false);

this.PerformLayout();

}

// <doc>

// <desc>

// Returns true if the backColor should be persisted in code gen. We

// override this because we change the default back color.

// </desc>

// <retvalue>

// true if the backColor should be persisted.

// </retvalue>

// </doc>

public bool ShouldSerializeBackColor()

{

return (!BackColor.Equals(SystemColors.Info));

}

protected override void OnSizeChanged(EventArgs e)

{

Refresh();

}

// <doc>

// <desc>

// Returns true if the foreColor should be persisted in code gen. We

// override this because we change the default foreground color.

// </desc>

// <retvalue>

// true if the foreColor should be persisted.

// </retvalue>

// </doc>

public bool ShouldSerializeForeColor()

{

return (!ForeColor.Equals(SystemColors.InfoText));

}

// <doc>

// <desc>

// This is a designer for the HelpAndValidationProvider. This designer provides

// design time feedback for the label. The help label responds

// to changes in the active control, but these events do not

// occur at design time. In order to provide some usable feedback

// that the control is working the right way, this designer listens

// to selection change events and uses those events to trigger active

// control changes.

// </desc>

// </doc>

[System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "FullTrust")]

public class HelpLabelDesigner : System.Windows.Forms.Design.ControlDesigner

{

private bool trackSelection = true;

/// <summary>

/// This property is added to the control's set of properties in the method

/// PreFilterProperties below. Note that on designers, properties that are

/// explictly declared by TypeDescriptor.CreateProperty can be declared as

/// private on the designer. This helps to keep the designer's publi

/// object model clean.

/// </summary>

[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

private bool TrackSelection

{

get

{

return trackSelection;

}

set

{

trackSelection = value;

if (trackSelection)

{

ISelectionService ss = (ISelectionService)GetService(typeof(ISelectionService));

if (ss != null)

{

UpdateHelpLabelSelection(ss);

}

else

{

HelpAndValidationProvider helpLabel = (HelpAndValidationProvider )Control;

if (helpLabel.activeControl != null)

{

helpLabel.activeControl = null;

helpLabel.Invalidate();

}

// <doc>

// <desc>

// Overrides Dispose. Here we remove our handler for the selection changed

// event. With designers, it is critical that they clean up any events they

// have attached. Otherwise, during the course of an editing session many

// designers may get created and never destroyed.

// </desc>

// </doc>

protected override void Dispose(bool disposing)

{

if (disposing)

{

ISelectionService ss = (ISelectionService)GetService(typeof(ISelectionService));

if (ss != null)

{

ss.SelectionChanged -= new EventHandler(OnSelectionChanged);

}

base.Dispose(disposing);

}

// <doc>

// <desc>

// Overrides initialize. Here we add an event handler to the selection service.

// Notice that we are very careful not to assume that the selection service is

// available. It is entirely optional that a service is available and you should

// always degrade gracefully if a service could not be found.

// </desc>

// </doc>

public override void Initialize(IComponent component)

{

base.Initialize(component);

ISelectionService ss = (ISelectionService)GetService(typeof(ISelectionService));

if (ss != null)

{

ss.SelectionChanged += new EventHandler(OnSelectionChanged);

}

private void OnSampleVerb(object sender, EventArgs e)

{

MessageBox.Show("You have just invoked a sample verb. Normally, this would do something interesting.");

}

// <doc>

// <desc>

// Our handler for the selection change event. Here we update the active control within

// the help label.

// </desc>

// </doc>

private void OnSelectionChanged(object sender, EventArgs e)

{

if (trackSelection)

{

ISelectionService ss = (ISelectionService)sender;

UpdateHelpLabelSelection(ss);

}

protected override void PreFilterProperties(IDictionary properties)

{

// Always call base first in PreFilter* methods, and last in PostFilter*

// methods.

base.PreFilterProperties(properties);

// We add a design-time property called "TrackSelection" that is used to track

// the active selection. If the user sets this to true (the default), then

// we will listen to selection change events and update the control's active

// control to point to the current primary selection.

properties["TrackSelection"] = TypeDescriptor.CreateProperty(

this.GetType(), // the type this property is defined on

"TrackSelection", // the name of the property

typeof(bool), // the type of the property

new Attribute[] { CategoryAttribute.Design }); // attributes

}

/// <summary>

/// This is a helper method that, given a selection service, will update the active control

/// of our help label with the currently active selection.

/// </summary>

/// <param name="ss"></param>

private void UpdateHelpLabelSelection(ISelectionService ss)

{

Control c = ss.PrimarySelection as Control;

HelpAndValidationProvider helpLabel = (HelpAndValidationProvider )Control;

if (c != null)

{

helpLabel.activeControl = c;

helpLabel.Invalidate();

}

else

{

if (helpLabel.activeControl != null)

{

helpLabel.activeControl = null;

helpLabel.Invalidate();

}

GroupWise API Project Settings in VS2005

2010-06-16T09:33:00.001-04:00

I Have a project with a reference to: AdminTypeLibrary in Visual Studio 2005, that provide the following class interface:

[CoClass(typeof(SystemClass))]
[Guid("35FC2357-811A-11D0-8A96-00805FC16077")]
public interface System : DIADSystem
{
}

When I try to create the object: System sys = new AdminTypeLibrary.System();
I got the following exception:

"Retrieving the COM class factory for component with CLSID {35FC2358-811A-11D0-8A96-00805FC16077} failed due to the following error: 80040154."

in default project configurations [AnyCPU] in my case this happened on a X64 machine. After investigation I have turned the project settings into X86 configuration and the exception has gone.

Trying to create group wise API objects will fail if your project' configurations [in VS2005] are different than X86.

Control Anchoring Class

2010-06-15T15:49:00.000-04:00

Controls in Windows Forms are arranged on main form using a couple of properties, and one of them is Location property which is described on msdn as "Gets or sets the coordinates of the upper-left corner of the control relative to the upper-left corner of its container."

This means that Location property is used to position a control within its direct parent container.
So if we have two controls [let's say buttons] in a groupbox control which in it turn is hosted in a Windows Form, setting the location of one button in relation to the other will be simply by updating the location of the control we want to position in relation to the location of the button considered as a target.

Things will get difficult if we want to set the position of a Form in relation to a control within another form, for example positioning a new Form in relation to our previous buttons will not be a simple location calculation in relation to the button Location property. We have to set the new Form position in relation to the outermost control that contains the button.

Let's consider the following diagram:

If we want to position a new Form in relation to button1 than we follow this process:

Calculate the position [Location ] of button1 in relation to the containing form [Main Form].
Button1 Location in relation to GroupBox is [X=70, Y=150],
Groupbox location in relation to Main Form is: [X=40, Y=50]
Summing both locations will give:
Button1 location in relation to Main Form : [X= 110, Y= 200]

But the new form is not contained in Main Form than is has to be positioned against computer screen coordinates.

Main Form has the following position: [X=110, Y= 200].
If we want to Set the new Form position at the same point to button1 than we have to Sum up the Main Form coordinates and those of Button1 in relation to Main Form.

the finale position for the new Form will be:
Location = [X=110+110 , Y = 200+200] or [X=220,400]

Here after is the a utility Class that I wrote which can be used to position controls within a form or position a new form against any control in a Form.

public enum AnchorPoint
{
   TopLeft,
   TopRight,
   BottomLeft,
   BottomRight
}

public class ControlAnchorer

{

/// Summary: Anchors a control to a reference control.

/// controlToAnchor: Control to anchor

/// controlReference: Reference control

/// anchorPoint: the corner of the reference control to which the

/// controlToAnchor will be positioned

public static void AnchorControl(Control controlToAnchor, Control controlReference,

AnchorPoint anchorPoint)

{

if (controlToAnchor == null)

throw new ArgumentNullException("controlToAnchor");

if (controlReference == null)

throw new ArgumentNullException("controlReference");

if (controlToAnchor is Form)

{

// Make sure to set start postion to manual to be able to set the form location.

((Form)controlToAnchor).StartPosition = FormStartPosition.Manual;

}

Point location = Point.Empty;

// A top level control will be positioned related to Screen coordinates.

if (IsTopLevelCotrol(controlToAnchor))

{

Control topLevelControl = controlReference.TopLevelControl;

if (topLevelControl == null)

topLevelControl = controlReference;

Point LocationToTopLevelControl = GetPositionInForm(controlReference);

location = topLevelControl.PointToScreen(LocationToTopLevelControl);

}

else

{

if (controlToAnchor.Parent != controlReference.Parent)

{

throw new InvalidOperationException("Can't anchor controls belonging to different containers");

}

else

{

location = controlReference.Location;

}

if (location != Point.Empty)

{

switch (anchorPoint)

{

case AnchorPoint.TopLeft:

break;

case AnchorPoint.TopRight:

location.X += controlReference.Width;

break;

case AnchorPoint.BottomLeft:

location.Y += controlReference.Height;

break;

case AnchorPoint.BottomRight:

location.X += controlReference.Width;

location.Y += controlReference.Height;

break;

default:

break;

}

controlToAnchor.Location = location;

}

Returns the coordonates of a control in reference to the outermost control.

Example if a main form contains a group box, and the groupbox contains a button, calling this

method will return the coordinate of the button in reference to the main form.

private static Point GetPositionInForm(Control control)

{

Point p = control.Location;

Control parent = control.Parent;

while ((parent != control.TopLevelControl))

{

p.Offset(parent.Location.X, parent.Location.Y);

parent = parent.Parent;

}

return p;

}

Returns a boolean indicating if this is a Top level control such as a main Form control

private static bool IsTopLevelCotrol(Control control)

{

bool isTopLevel = true;

if (control == null)

{

isTopLevel = false;

}

else if (control.TopLevelControl != control)

{

isTopLevel = false;

}

return isTopLevel;

}

Example of a progress dialog form with global and detail progress indicators

2010-06-08T12:31:00.005-04:00

When running long operations showing the progress is very important for user experience. But in some cases a long operation can be seen as a set of other sub operations, so displaying the overall process and indicating the specific progress for each sub operation is more user friendly.

I came across such situation and i decided to write this little Form that has built in support for displaying overall and detail progresses and manages to dispatch thread calls into the thread owning the callers.

Using the Form:

// Basic configs.

formProgress = new FormProgress();
formProgress.OperationCancelRequested +=
new FormProgress.OperationCancelRequestedDelegate(formProgress_OperationCancelRequested);
formProgress.ShowPercentageInTitle = true;
formProgress.ShowProgressDetails = true;
formProgress.SupportCancelation = true;
formProgress.ResetOnCancel = true;

// These will be performed likely from other threads , or backgroud worker.
formProgress.OverallProgressHeaderText = "Overall Progress:";
formProgress.OverallProgressPercentage = 30;
formProgress.DetailProgressHeaderText = "Operation n in progress...";
formProgress.DetailProgressPercentage = 20;

Source Code:

private static object syncLock = new object();

public delegate void OperationCancelRequestedDelegate();

public event OperationCancelRequestedDelegate OperationCancelRequested;

private bool showPercentageInTitle;

///

/// If set to true then the global progress percentage will be appended to the title.

///

public bool ShowPercentageInTitle

{

get { return showPercentageInTitle; }

set

{

if (showPercentageInTitle != value)

{

showPercentageInTitle = value;

UpdateTitleDisplay();

}

private bool supportCancelation = false;

///

/// if set to true, a cancel button will apear in the form when clicked raises OperationCancelRequested event.

///

public bool SupportCancelation

{

get

{

return supportCancelation;

}

set

{

supportCancelation = value;

SetControlPropertyValue(btnCancel, "Visible", value);

}

private bool cancelRequested = false;

///

/// Returns a value indicating if canceling the operation is requested.

///

public bool CancelRequested { get { return cancelRequested; } }

private string title;

///

/// Main progress dialog title.

///

public string Title

{

get

{

return this.title;

}

set

{

if (this.title != value)

{

this.title = value;

UpdateTitleDisplay();

}

///

/// Global progress percentage

///

public int OverallProgressPercentage

{

get

{

return mainProgressBar.Value;

}

set

{

if (value != mainProgressBar.Value)

{

if (value < 0 || value > 100)

{

throw new ArgumentOutOfRangeException("OverallProgressPercentage", value,

"OverallProgressPercentage should be between 0 and 100");

}

else

{

SetControlPropertyValue(mainProgressBar, "Value", value);

UpdateTitleDisplay();

}

///

/// Detail progress percentage

///

public int DetailProgressPercentage

{

get

{

return detailProgressBar.Value;

}

set

{

if (value != detailProgressBar.Value)

{

if (value < 0 || value > 100)

{

throw new ArgumentOutOfRangeException("DetailProgressPercentage", value,

"DetailProgressPercentage should be between 0 and 100");

}

else

{

SetControlPropertyValue(detailProgressBar, "Value", value);

}

///

/// Text to be displayed as a global progress header information.

///

public string OverallProgressHeaderText

{

get

{

return lblOverallProgress.Text;

}

set

{

SetControlPropertyValue(lblOverallProgress, "Text", value);

}

///

/// Text to be displayed as a detail progress header information.

///

public string DetailProgressHeaderText

{

get

{

return lblDetailProgress.Text;

}

set

{

SetControlPropertyValue(lblDetailProgress, "Text", value);

}

private bool showProgressDetails = true;

private int orignalGroupDetailsHeight = 0;

///

/// If set to true it will display progress details.

///

public bool ShowProgressDetails

{

get

{

return showProgressDetails;

}

set

{

if (showProgressDetails != value)

{

showProgressDetails = value;

// Set the new details groupbox visibility.

SetControlPropertyValue(groupBoxDetails, "Visible", showProgressDetails);

// Update the control's Height.

int height = this.Height;

if (showProgressDetails)

{

height += orignalGroupDetailsHeight;

}

else

height -= orignalGroupDetailsHeight;

SetControlPropertyValue(this, "Height", height);

}

private void UpdateTitleDisplay()

{

string valueToDisplay = title;

if (showPercentageInTitle)

{

valueToDisplay += (" " + OverallProgressPercentage.ToString() + "%");

}

if (String.IsNullOrEmpty(valueToDisplay))

valueToDisplay = " ";

SetControlPropertyValue(this, "Text", valueToDisplay);

}

private delegate void SetControlPropertyValueDelegate(Control control, System.Reflection.PropertyInfo pInfo, object value);

private void SetControlPropertyValue(Control control, string propertyName, object value)

{

// Set to control thread's access to this Form properties.

lock (syncLock)

{

if (control == null)

{

throw new ArgumentNullException("control");

}

if (String.IsNullOrEmpty(propertyName))

{

throw new ArgumentNullException("propertyName");

}

System.Reflection.PropertyInfo pInfo = control.GetType().GetProperty(propertyName);

if (pInfo == null)

{

throw new Exception("control: " + control.Name + " does not have the property: " + propertyName);

}

if (control.InvokeRequired)

{

control.Invoke(new SetControlPropertyValueDelegate(SetControlPropertyValue),

control, pInfo, value);

}

else

{

pInfo.SetValue(control, value, null);

}

private void SetControlPropertyValue(Control control, System.Reflection.PropertyInfo pInfo, object value)

{

pInfo.SetValue(control, value, null);

}

public FormProgress()

{

InitializeComponent();

// Main title can't be null or empty otherwise the form will become locked and can not be moved.

this.Text = " ";

orignalGroupDetailsHeight = groupBoxDetails.Height;

}

private void btnCancel_Click(object sender, EventArgs e)

{

btnCancel.Text = "Canceling...";

btnCancel.Enabled = false;

this.cancelRequested = true;

// Process all remainig messages for this form.

Application.DoEvents();

lock (syncLock)

{

if (OperationCancelRequested != null)

{

// Make sure to call the target on its own thread.

if (OperationCancelRequested.Target is Control)

{

Control target = OperationCancelRequested.Target as Control;

if (target.InvokeRequired)

{

target.Invoke(OperationCancelRequested, null);

}

else

OperationCancelRequested();

}

else

OperationCancelRequested();

}

if (resetOnCancel)

Reset();

}

private bool resetOnCancel = true;

///

/// If set to true, the value of the progress bars will we set to 0 and labels will be empty.

///

public bool ResetOnCancel

{

get

{

return resetOnCancel;

}

set

{

resetOnCancel = value;

}

private void Reset()

{

btnCancel.Text = "Cancel";

btnCancel.Enabled = true;

lblDetailProgress.Text = "";

lblOverallProgress.Text = "";

Text = " ";

ResetProgress();

}

private void ResetProgress()

{

mainProgressBar.Value = 0;

detailProgressBar.Value = 0;

}

Custom ListBox control with Items Disable/Enable feature

2010-06-01T10:57:00.000-04:00

I run once on a case where I have to show on a System.Windows.Forms.ListBox control some items that end user can not select, but still they have to be shown anyway since end user was expecting them. The point is that System.Windows.Forms.ListBox does not provide such feature, so I have decided to create my own user control and share it.

Here are some snapshots of the control at run time:

Disable item3 [index 2]

Disable Item5 [Index4]

Enabling Item3[index2]

Explaining the code:

This custom ListBox derives from System.Windows.Forms.ListBox, it overrides some methods, mainly drawing items, and selected indices management.

We need first to track the list of disabled items so we display them accordingly [grayed on screen], for this we need a collection like the one used to track the selectedindices.

This will have exactly the same structure.

public class DisabledIndexCollection : IList, ICollection, IEnumerable

public DisabledIndexCollection(ListBox owner)

{

this.owner = owner;

}

This is needed to have a reference to the owner listbox, wich is passed as a "this" parameter when initializing a Netdev.Windows.Forms.ListBox as shown here:

public ListBox()
{
DrawMode = System.Windows.Forms.DrawMode.OwnerDrawFixed;
disabledIndices = new DisabledIndexCollection(this);
}

Drawing ListBox Items:

Painting Listbox items is done by overriding OnDrawItem method in the custom control.

protected override void OnDrawItem(System.Windows.Forms.DrawItemEventArgs e)
{
   base.OnDrawItem(e);
   if (DesignMode && Items.Count == 0)
   {
   if (e.Index == 0)
   {
   // Draw Control name as an item is design mode.
   e.Graphics.FillRectangle(SystemBrushes.Window, e.Bounds);
   e.Graphics.DrawString(this.Name, e.Font, SystemBrushes.WindowText, e.Bounds);
   }
   return;
   }

   if (e.Index != ListBox.NoMatches)
   {
   object item = this.Items[e.Index];
   // Get the text to display, this depends if the list is bound to data and
   // DisplayMember, EnableFormating and FormatString are set.
   string displayValue = GetItemText(item);

   if (disabledIndices.Contains(e.Index))
   {
   e.Graphics.FillRectangle(SystemBrushes.InactiveBorder, e.Bounds);
   e.Graphics.DrawString(displayValue, e.Font, SystemBrushes.GrayText, e.Bounds);
   }
   else
   {
   if (SelectionMode == System.Windows.Forms.SelectionMode.None)
   {
   e.Graphics.FillRectangle(SystemBrushes.Window, e.Bounds);
   e.Graphics.DrawString(displayValue, e.Font, SystemBrushes.WindowText, e.Bounds);
   }
   else
   {
   if ((e.State & DrawItemState.Selected) == DrawItemState.Selected)
   {
   e.Graphics.FillRectangle(SystemBrushes.Highlight, e.Bounds);
   e.DrawFocusRectangle();
   e.Graphics.DrawString(displayValue, e.Font, SystemBrushes.HighlightText, e.Bounds);
   }
   else
   {
   e.Graphics.FillRectangle(SystemBrushes.Window, e.Bounds);
   e.Graphics.DrawString(displayValue, e.Font, SystemBrushes.WindowText, e.Bounds);
   }
   }
   }
   }
}

Enabling and Disabling items is done through two methods:

EnableItem(int index) and DisableItem(int index), where index is the index if the item we want to enable or disable.

Overriding OnSelectedIndexChanged method was required, to prevent the event from being propagated to end users if end user tries to select a disabled item. In such case the event is swallowed.

protected override void OnSelectedIndexChanged(EventArgs e)
{
   // Retreive new value of selected index.
   int currentSelectedIndex = SelectedIndex;
   List selectedDisabledIndices = new List();

   for (int i = 0; i < SelectedIndices.Count; i++)
   {
   // unselect items that are already disabled.
   if (disabledIndices.Contains(SelectedIndices[i]))
   {
   selectedDisabledIndices.Add(SelectedIndices[i]);
   SelectedIndices.Remove(SelectedIndices[i]);
   }
   }
   foreach (int index in selectedDisabledIndices)
   {
   // Fire DisabledItemSelected event for each disabled item that has been selected.
   IndexEventArgs args = new IndexEventArgs(index);
   OnDisabledItemSelected(this, args);
   }
   // if updated selected index is equal to the original one then bubble up the event
   if (currentSelectedIndex == SelectedIndex)
   base.OnSelectedIndexChanged(e);
}

public event EventHandler DisabledItemSelected;

protected virtual void OnDisabledItemSelected(object sender, IndexEventArgs e)
{
   if (DisabledItemSelected != null)
   {
   DisabledItemSelected(sender, e);
   }
}

C# Collapsible Panel

2010-05-16T10:54:00.000-04:00

Having worked with ASP.NET AJAX CollapsiblePanel control extender and finding it practical to fit more content into a relatively small part of a web page or screen real estate, I thought it would be good to have such control for WinForm applications since VS 2005 and VS 2008 toolboxes do not offer such a control.

I wrote for this reason a custom control that I have published on code project web site, you can find it here