Projects

Grouping a datagridview: the DataGridViewGrouper component

Robert Verpalen — Fri, 19 Dec 2008 06:56:00 GMT

Complete Source Code: http://blogs.vbcity.com/hotdog/archive/2008/12/19/9225.aspx

Note: the code is now rewritten to be 2.0 compatible (the project was written in vs2008 with compatibility set on framework 2.0), but older designers may still have trouble compiling because of the use of newer syntax (such as automatic properties). All 'var' keywords should be replaced, but they tend to sneak in because they are so easy to use ;)
If the newer syntax is a problem for many of you, drop me a note and I'll try to remove all of those syntaxes too.

Example:
Assuming you have a form with a datagridview called dataGridView1, add this code (after setting its datasource):

Code CopyHideScrollFull

var grouper = new Subro.Controls.DataGridViewGrouper(dataGridView1);
grouper.SetGroupOn("NameOfThePropertyToGroupOn");

Functionality:
The DataGridViewGrouper is a component that can be added in the forms designer or in runtime to add grouping to any existing (databound) DataGridView. Grouping can be done on existing properties of the underlying data or with a custom value function. The displayed data can be altered through the exposed Display event.
Grouped rows can be quickly selected by double clicking the group header, and the rows can be collapsed and expanded by the user.

Usage:
3 simple steps
- Add the component to the designer or create it in runtime
- Set its DataGridView property to any existing databound DataGridView
-In runtime set the GroupOn property or call any of the SetGroupOn methods to start grouping

Other settings include
-the sorting of the groups (asc,desc or none, using the lists original sources order as leading)
-if the count of rows has to be shown (the shown information can be altered by catching the Display event)
-if the property name on which is grouped has to be shown (can also be altered by the Display event)
-besides the options above, the shown group value can also be altered in the Display event.

Background:
For a while now I was facing a request to add grouping to an overview in a DataGridView. And as you may have noticed: there is no grouping functionality in the default System.Windows.Forms.DataGridView.
Now there are ways of course, by adding DataGridViewRows manually and creating the groups by adding rows, but that would screw up the underlying data binding and automatic buffering/formatting/filtering/sorting, etc. Wanted to keep the bound functionality intact, but still create group rows. The solution in itself is simply to create a wrapper source that includes those rows and the grouped rows underneath and asign that to the grid, leaving the original source unaltered, and override the grouping rows painting/editing. A theory simple enough in itself, of course the implementation was a bit more work, but still less difficult than expected.
The grouping source was created easily enough, especially with the great functionality of Linq. The trick was in seperating what the grid saw from the underlying functionality. By inheriting from BindingSource all tools were available for that job. The DataSource and DataMember properties are set by the original values of the same properties in the Grid, therefor exposing the proper 'Columns'. All adding and removing had to be done in the underlying datagrid source, so those values were overridden.
The DataGridViewGrouper component itself is assigned to a grid and the Source of the grid itself is set to the grouped source. When a group row has to be painted, it is handled by the component, the other rows follow the default behaviour. Editing for a grouprow is simply cancelled. If the original source is a BindingSource, the source's positioning is synchronized.
Note that the index of the datagridview row won't be the same as the index in the original source, so you shouldn't be getting an object out of the original source directly with the row index. Then again, you should never do that anyway ;) Use the Grid.Rows[position].DataBoundItem property instead.

Source Code

TODO:
* Now the component synchronizes navigation if the source is another BindingSource. Will look later to synchronize with any CurrencyManager.
* Adding code comments :p

Feedback visualizer

Robert Verpalen — Fri, 22 Feb 2008 03:54:00 GMT

Source Code: http://blogs.vbcity.com/hotdog/archive/2008/02/22/8983.aspx

Many times I've found it useful to have a process give feedback information to find out if everything was performing as wanted. And also one should be able to visualize, save and/or mail that information if wanted. Often you only want to show the information under certain conditions (an error occured, but you want to show the entire feedback)
The classes contained here: http://blogs.vbcity.com/hotdog/archive/2008/02/22/8983.aspx , provides that generic functionality. An example on how to use can be found at the bottom.

The main collection is contained in a FeedbackCollection class instance. Each individual Feedback item in that collection can in turn contain a subcollection of children.
Screenshots will follow later when I've retrieved the password to the ftp site :p

PS, this text is a bit incomplete since I'm slightly cross because the original text, which was a lot more elaborate than this bit, was lost when I thought to simply be able to press 'post' upon which all my work was lost because apparently I wasn't logged in any more (and no, it did not restore...). And almost always I copy first, except now ;) But will add some more info later on.

Feedback (visualizer) sourcecode

Robert Verpalen — Fri, 22 Feb 2008 01:09:00 GMT

Code CopyHideScrollFull

using System;
using System.Collections;
using System.Collections.Generic;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.ComponentModel;
using System.IO;
using Subro.Exceptions;

namespace Subro.Interaction
{

/// <summary>
/// A single feedback item. A feedback item can provide information
/// on status, progress and datetimes of execution
/// </summary>
public class Feedback
{

public Feedback(string Message):this()
{

this.message = Message;

}
public Feedback()
{

this.lastupdate = this.DateTime;

}
/// <summary>
/// The time the feedback object was created
/// </summary>
public readonly DateTime DateTime = DateTime.Now;
DateTime lastupdate;
/// <summary>
/// The last time the Feedback was updated (for example by updating the progress)
/// </summary>
public DateTime LastUpdate
{

get { return lastupdate; }

}

private void SetLastUpdate()
{

lastupdate = DateTime.Now;

}

/// <summary>
/// The main information of this feedback
/// </summary>
string message;
public string Message
{

get { return message; }
set
{

message = value;
NotifyUpdate();

}

int progress;
/// <summary>
/// The progress of this item. The total progress is in relation
/// to the the value set at <see cref="ProgressTarget"/>
/// <seealso cref="ProgressTarget"/>
/// <see cref="ProgressPercentage"/>
/// </summary>
public int Progress
{

get { return progress; }
set
{

progress = value;
IsProgressUpdate = true;
NotifyUpdate();

}

public event EventHandler Updated;

public void NotifyUpdate()
{

SetLastUpdate();
if (Updated != null)

Updated(this, EventArgs.Empty);

}

int progresstarget = 100;
bool progressinpercentage = true;
/// <summary>
/// Normal target of process is 100 as in 100 percent. Whatever value this
/// is set to, progress relates to it.
/// For example: if looping through a number of lines,
/// you can set this target to the number of lines and <see cref="Progress"/> to
/// the line being processed
/// </summary>
public int ProgressTarget
{

get { return progresstarget; }
set
{

progresstarget = value;
progressinpercentage = false;
NotifyUpdate();

}

/// <summary>
/// The relative progress of this item.
/// </summary>
public float ProgressPercentage
{

get
{

if (!IsProgressUpdate) return 1;
return (float)progress / progresstarget;

}

public string GetProgressString()
{

if (progressinpercentage)

return ProgressPercentage.ToString("###%");

return progress.ToString() + "/" + progresstarget.ToString();

}

/// <summary>
/// Increase the <see cref="Progress"/> by one
/// </summary>
public void Increase()
{

Progress++;

}

public void ShowAlive()
{

IsAliveIndicator = true;

}
public bool IsProgressUpdate = false;
public int alivecount;
public int AliveCount { get { return alivecount; } }
public bool IsAliveIndicator
{

get { return alivecount > 0; }
set
{

if (value)
{

if (++alivecount == 0)

alivecount++;

NotifyUpdate();

}
else

alivecount = 0;

}

}
public override string ToString()
{

return string.Format("{0}\t{1}", DateTime, message);

}

/// <summary>
/// The level, this can be a custom level or set with <see cref="FeedbackLevel"/>.
/// 0 = normal negative value is not so important, positive value is more important
/// </summary>
public int Level = (int)FeedBackLevel.Normal;
public FeedBackLevel FeedbackLevel
{

get
{

try
{

return (FeedBackLevel)Level;

}
catch
{

return FeedBackLevel.Custom;

}

}
set
{

Level = (int)value;

}

public bool IsNormalLevel { get { return Level == (int)FeedBackLevel.Normal; } }

public virtual bool CanShowExtraInfo
{

get { return HasChildren; }

}
public void ShowExtraInfo()
{

ShowExtraInfo(null);

}
public virtual void ShowExtraInfo(IWin32Window Owner)
{

children.Show(Owner);

}
protected virtual void AppendExtraInfo(AppendInfoSettings info)
{

children.AppendFeedbackText(info);

}

public virtual FeedbackItemPainter GetPainter(FeedbackItemInfo info)
{

return new FeedbackItemPainter(info);

}

internal void AppendInfo(AppendInfoSettings info,int RowNumber)
{

var sb = info.StringBuilder;
sb.Append("<DIV>");
bool bold = Level > 0, smaller = Level < 0;
if (bold) sb.Append("");
else if (smaller) sb.Append("");
sb.Append("").Append(DateTime)

.Append("");

if (IsProgressUpdate)
{

int p = (int)(ProgressPercentage * 100);
sb.Append(@"")

.Append("")
.Append("")
.Append(GetProgressString()).Append("")
.Append("");

}
sb.Append("").Append(message)

.Append("");

if (CanShowExtraInfo)
{

string ExtraInfoAnchor = "ExtraInfo" + RowNumber.ToString();
if (info.AllowScripts)
{

sb.Append(@"<A style='margin-left:5' href='javascript:' onclick=""

this.index=1-this.index;
var

index = this.index,
modes=new Array('none',''),
texts=new Array('Show details','Hide details');

this.nextSibling.style.display=modes[index];
this.innerText=texts[index];""
index=1>Hide details</A>");

}
sb.Append("<div style='margin-left:20;background-color:lightblue;'>")

.Append("<a name='").Append(ExtraInfoAnchor).Append("'></a>");

AppendExtraInfo(info);
sb.Append("</div>");

}
if (bold) sb.Append("");
else if (smaller) sb.Append("");
sb.Append("</DIV>");

}

FeedbackCollection children;
/// <summary>
/// Use this colleciton to add children. NB calling this function the first time will
/// create the collection
/// </summary>
public FeedbackCollection Children
{

get
{

if (children == null)
{

children = new FeedbackCollection();
children.Parent = this;

}
return children;

}

public bool HasChildren
{

get { return children != null && children.Count > 0; }

}

#region static

#region mail

public delegate void SendMailDelegate(string Subject, string Body, bool IsHTML);
static SendMailDelegate sendmail = delegate(string Subject, string Body, bool IsHTML)
{

System.Net.Mail.MailMessage sm = new System.Net.Mail.MailMessage();
sm.IsBodyHtml = IsHTML;
sm.Body = Body;
sm.Subject = Subject;
System.Net.Mail.SmtpClient smtp = new System.Net.Mail.SmtpClient();
smtp.Send(sm);

};
public static SendMailDelegate DefaultSendMailMethod
{

get { return sendmail; }
set
{

if (value == null)

throw new ArgumentNullException();

sendmail = value;

}

#endregion

#region Exceptions
public delegate void ShowExceptionDelegate(Exception ex);
static ShowExceptionDelegate showex =

delegate(Exception ex)
{

string m = ex.Message + "\r\n----------------\r\nStack:\r\n"

+ ex.StackTrace;

MessageBox.Show(m);

};

public static ShowExceptionDelegate DefaultShowExceptionMethod
{

get { return showex; }
set
{

if (value == null) throw new ArgumentNullException();
showex = value;

}

}
#endregion

public static implicit operator Feedback(string value)
{

return new Feedback(value);

}

#endregion

}

/// <summary>
/// General settings when the text of feedback is obtained.
/// <seealso cref="FeedbackCollection.GetTotalFeedbackText"/>
/// <see cref="Feedback.AppendInfo"/>
/// </summary>
public class AppendInfoSettings
{

public AppendInfoSettings():this(new StringBuilder())
{
}
public AppendInfoSettings(StringBuilder sb)
{

this.StringBuilder = sb;

}
public readonly StringBuilder StringBuilder;
public bool AllowScripts;
public int MaxLines;

public AppendInfoSettings Append(string Value)
{

StringBuilder.Append(Value);
return this;

}

public AppendInfoSettings Append<T>(T Value)
{

StringBuilder.Append(Value);
return this;

}

/// <summary>
/// A collection of <see cref="Feedback"/> items. Besides being a collection
/// for different Feedback items, this class contains the methods to
/// visualize the feedback
/// </summary>
public class FeedbackCollection : BindingList<Feedback>
{

public FeedbackCollection() { }
public FeedbackCollection(int MaximumValues)
{

maxcount = MaximumValues;

}

/// <summary>
/// This value can be set to indicate that this set is a childset of
/// another Feedback item
/// </summary>
public Feedback Parent;

#region Add/Update

protected override void InsertItem(int index, Feedback fb)
{

base.InsertItem(index, fb);
CheckMaxValues();

}

protected override void OnListChanged(ListChangedEventArgs e)
{

base.OnListChanged(e);
if (Parent != null)

Parent.NotifyUpdate();

}

public Feedback Add(string Text)
{

Feedback fb = new Feedback(Text);
Add(fb);
return fb;

}
public Feedback Add(string Text, FeedBackLevel Level)
{

Feedback fb = new Feedback(Text);
fb.FeedbackLevel = Level;
Add(fb);
return fb;

}
public void Add(Feedback fb, int Progress)
{

fb.Progress = Progress;
Add(fb);

}

public ExceptionFeedback Add(Exception ex)
{

ExceptionFeedback ef = new ExceptionFeedback(ex);
Add(ef);
return ef;

}

#endregion

#region Zero result

/// <summary>
/// By default this value is <c>false</c>, but the executing (batch) code
/// can set this value to indicate that all in all nothing has happened.
/// (eg, code to import file did not find a file)
/// To include a reason, use <see cref="SetZeroResult"/>
/// </summary>
public bool ZeroResult
{

get { return lastzeroresult != null; }
set
{

if (ZeroResult != value)
{

if (value)

SetZeroResult("No reason specified");

else

LastZeroResult = null;

}

ZeroResultFeedback lastzeroresult;

internal ZeroResultFeedback LastZeroResult
{

get
{

return lastzeroresult;

}
set
{

if (lastzeroresult == value) return;
/*
if (Parent != null)
{

if (value != null)

Parent.LastZeroResult = value;

else if (Parent.lastzeroresult == lastzeroresult)

Parent.LastZeroResult = null;

}*/
lastzeroresult = value;

}

public class ZeroResultFeedback : Feedback
{

public readonly string Reason;
public ZeroResultFeedback(string reason)

: base("Batch has zero result: [" + reason + "]")

{

this.FeedbackLevel = FeedBackLevel.Important;
this.Reason = reason;

}

/// <summary>
/// The reason that was indicated that the code where this feedback
/// was used with did not actually do anything.
/// This value can be set when using <see cref="SetZeroResult"/>
/// </summary>
public string ZeroResultReason
{

get
{

if (ZeroResult) return lastzeroresult.Reason;
return null;

}

}
public void SetZeroResult(string reason)
{

ZeroResultFeedback fb = new ZeroResultFeedback(reason);
Add(fb);
LastZeroResult = fb;

}
#endregion

public Feedback Last
{

get
{

return this[Count - 1];

}

public DateTime StartTime
{

get
{

if (Count == 0) return DateTime.MinValue;
return this[0].DateTime;

}

public DateTime EndTime
{

get
{

if (Count == 0) return DateTime.MinValue;
return Last.LastUpdate;

}

public TimeSpan Duration
{

get { return EndTime.Subtract(StartTime); }

}

private int maxcount;

/// <summary>
/// The maximum amount of entries allowed
/// </summary>
public int MaximumValues
{

get { return maxcount; }
set
{

maxcount = value;
CheckMaxValues();

}

void CheckMaxValues()
{

if (maxcount > 0)
{

while (Count > maxcount)

RemoveAt(0);

}

#region Save/Mail

/// <summary>
/// Description is used when saving or mailing the list, so
/// this should contain information about the contents
/// </summary>
public string Description = "Feedback list";
public string Save()
{

string file = Application.CommonAppDataPath + @"\Feedback\";
if (!Directory.Exists(file)) Directory.CreateDirectory(file);
string notallowed = " /\\", descr = Description;

if (descr != null)

for (int i = 0; i < notallowed.Length; i++)
{

descr = descr.Replace(notallowed[i], '_');

}

else

descr = "feedback";

file += descr + ".htm";
Save(file);
return file;

}
public void Save(string file)
{

lock (this)
{

StreamWriter sw = new StreamWriter(file, true, System.Text.Encoding.ASCII);
sw.Write(GetTotalFeedBackText());
sw.Close();
Add("List saved to " + file);

}

public void Mail()
{

Mail(

(ZeroResult
? "Zero result "
: null)
+ "Batch Feedback '" + Description + "'");

}

public void Mail(string Subject)
{

Feedback.DefaultSendMailMethod(Subject,GetTotalFeedBackText(false),true);

}

public void MailExceptions()
{

Feedback.DefaultSendMailMethod("Errors in " + Description,

AppendFeedbackText(
new AppendInfoSettings(),EnumerateAll<ExceptionFeedback>(true)).ToString(),
true
);

}

public string GetTotalFeedBackText()
{

return GetTotalFeedBackText(true);

}
public string GetTotalFeedBackText(bool AllowScripts)
{

return AppendFeedbackText(new AppendInfoSettings { AllowScripts=AllowScripts}).ToString();

}

public bool HasExceptions()
{

foreach (Feedback fb in this)
{

if (fb.FeedbackLevel== FeedBackLevel.Exception) return true;
if (fb.HasChildren && fb.Children.HasExceptions())

return true;

}
return false;

}

public IEnumerable<Feedback> EnumerateAll<FeedbackType>()

where FeedbackType : Feedback

{

return EnumerateAll<FeedbackType>(true);

}
public IEnumerable<Feedback> EnumerateAll<FeedbackType>(bool IncludeChildren)

where FeedbackType : Feedback

{

foreach (Feedback fb in this)
{

if (fb is FeedbackType) yield return fb;
if (IncludeChildren && fb.HasChildren)
{

foreach (FeedbackType f in fb.Children.EnumerateAll<FeedbackType>(true))
{

yield return f;

}

public StringBuilder AppendFeedbackText(StringBuilder sb, bool AllowScripts)
{

return AppendFeedbackText(new AppendInfoSettings(sb) { AllowScripts = AllowScripts });

}
public StringBuilder AppendFeedbackText(AppendInfoSettings info)
{

return AppendFeedbackText(info, this);

}
public StringBuilder AppendFeedbackText(AppendInfoSettings info, IEnumerable<Feedback> list)
{

var sb = info.StringBuilder;
sb.Append("<DIV style=\"border='1px black solid'\">");
if (Parent == null)

sb.Append("\tFeedback ")
.Append(Description)
.Append(". Info created on ").Append(DateTime.Now);

if (ZeroResult)

sb.Append("<div style=\"border:'1 solid black';background-color:cyan\">Finished with zero result: ")

.Append(ZeroResultReason)
.Append("</div>");

sb.Append("<HR>");
int i = 0;
foreach (Feedback fb in list)
{

fb.AppendInfo(info, i++);
if (info.MaxLines > 0 && i == info.MaxLines) break;

}
sb.Append("</DIV>");
return sb;

}

public void ShowHTML()
{

if (System.Threading.Thread.CurrentThread.GetApartmentState() == System.Threading.ApartmentState.STA)
{

Form f = new Form();
WebBrowser wb = new WebBrowser();
wb.Dock = DockStyle.Fill;
f.Controls.Add(wb);
wb.DocumentText = GetTotalFeedBackText();
f.WindowState = FormWindowState.Maximized;
f.Show();

}
else

//Unfortunately, using the webbrowser requires an STA
//if this is not the case of the current thread, save and show with explorer
System.Diagnostics.Process.Start(Save());

}
#endregion

/// <summary>
/// Creates a <see cref="FeedbackForm"/> with a <see cref="FeedbackControl"/> and shows it or
/// shows an existing form if it was already created
/// </summary>
public FeedbackForm Show()
{

return Show((IWin32Window)null);

}
public FeedbackForm Show(IWin32Window Owner)
{

if (Owner is Control)

return Show(Owner as Control);

if (frm == null)
{

CreateFeedbackForm();
frm.Show(Owner);

}
else

frm.Activate();

return frm;

}

delegate FeedbackForm show(Control owner);

public FeedbackForm Show(Control Owner)
{

if (Owner == null) return Show();
if (Owner.InvokeRequired)

return (FeedbackForm)

Owner.Invoke(new show(Show), Owner);

if (frm == null)
{

CreateFeedbackForm(Owner);

Form f = Owner.FindForm();
if (f != null)
{

if (f.IsMdiContainer)

frm.MdiParent = f;

else if (f.IsMdiChild)

frm.MdiParent = f.MdiParent;

}

if (frm.MdiParent == null)

frm.Show(Owner);

else

frm.Show();

}
else

frm.Activate();

return frm;

}
FeedbackForm frm;

public void ShowDialog()
{

ShowDialog(null);

}

public void ShowDialog(IWin32Window Owner)
{

CreateFeedbackForm().ShowDialog(Owner);

}

/// <summary>
/// creates a feedbackform based on this collection
/// </summary>
/// <returns></returns>
public FeedbackForm CreateFeedbackForm()
{

createForm();
return frm;

}

void createForm()
{

if (frm == null)

frm = new FeedbackForm(this);

}
/// <summary>
/// This overload of <see cref="CreateFeedbackForm()"/> makes sure
/// the <see cref="FeedbackForm"/> is created on the same thread
/// as the <c>ThreadControl</c>
/// </summary>
public FeedbackForm CreateFeedbackForm(Control ThreadControl)
{

if (ThreadControl == null || !ThreadControl.InvokeRequired)

return CreateFeedbackForm();

CloseFeedbackForm();
ThreadControl.Invoke(new System.Threading.ThreadStart(createForm));
return frm;

}

/// <summary>
/// If a <see cref="FeedbackForm"/> is shown, this method will close it
/// </summary>
public void CloseFeedbackForm()
{

if (frm != null)
{

try
{

if (frm.InvokeRequired)

frm.Invoke(new System.Threading.ThreadStart(frm.Dispose));

else

frm.Dispose();

}
catch { }
frm = null;

}

}
/*

internal void FormClosed()
{

frm = null;

}

* */

}
/// <summary>
/// Basically just a form with a <see cref="FeedbackControl"/>
/// </summary>
public class FeedbackForm : Form
{

FeedbackControl fc = new FeedbackControl();

public FeedbackForm()
{

Text = DefaultText;
KeyPreview = true;
fc.CollectionChanged += new EventHandler(fc_CollectionChanged);
fc.Dock = DockStyle.Fill;
Controls.Add(fc);

}

public FeedbackForm(FeedbackCollection collection)

: this()

{

this.Collection = collection;

}

public Feedback Add(Feedback fb)
{

return fc.Add(fb);

}

public FeedbackCollection Collection
{

get { return fc.Collection; }
set { fc.Collection = value; }

}

void fc_CollectionChanged(object sender, EventArgs e)
{

SetText();

}

const string DefaultText = "Feedback information";
void SetText()
{

string text = DefaultText;
if(Collection!=null && Collection.Description!=null)

text = "[" + Collection.Description + "] " + text;

Text = text;

}

public static Size DefaultFormSize = new Size(300, 300);
protected override Size DefaultSize
{

get
{

return DefaultFormSize;

}

protected override void OnKeyDown(KeyEventArgs e)
{

if (e.KeyCode == Keys.Escape) Close();
base.OnKeyDown(e);

}

protected override void OnClosed(EventArgs e)
{

Collection.CloseFeedbackForm();

}

/// <summary>
/// A control containing a <see cref="FeedbackListBox"/> and
/// some extra linklabels for extra gui options
/// </summary>
public class FeedbackControl : Control
{

FeedbackListBox lb = new FeedbackListBox();
BottomPanel pnlBottom;
public FeedbackControl()
{

lb.Dock = DockStyle.Fill;
lb.CollectionChanged += new EventHandler(lb_DataSourceChanged);
Controls.Add(lb);

pnlBottom = new BottomPanel();
Controls.Add(pnlBottom);

}

void lb_DataSourceChanged(object sender, EventArgs e)
{

pnlBottom.Visible = Collection != null;

}

/// <summary>
/// By Asigning a collection, the listbox will update
/// itself when messages are received.
/// NB: each collection can have only one FeedbackControl asigned to it.
/// </summary>
[DefaultValue(null)]
public FeedbackCollection Collection
{

get { return lb.Collection; }
set
{

lb.Collection = value;

}

public event EventHandler CollectionChanged
{

add { lb.CollectionChanged += value; }
remove { lb.CollectionChanged -= value; }

}

class BottomPanel : Panel
{

LinkLabel

llMail = new LinkLabel(),
llSave = new LinkLabel(),
llShow = new LinkLabel();

public BottomPanel()
{

Dock = DockStyle.Bottom;
Padding = new Padding(1);
Height = 20;
AddLabel(llMail);
AddLabel(llSave);
AddLabel(llShow);

llMail.Click += new EventHandler(llMail_Click);
llMail.Text = "Mail list";
llSave.Click += new EventHandler(llSave_Click);
llSave.Text = "Save list";
llShow.Click += new EventHandler(llShow_Click);
llShow.Text = "Show overview";

}

void llShow_Click(object sender, EventArgs e)
{

if (InvokeRequired)

Invoke(new EventHandler(llShow_Click), sender, e);

else

coll.ShowHTML();

}

new FeedbackControl Parent
{

get { return base.Parent as FeedbackControl; }

}
FeedbackCollection coll
{

get { return Parent.Collection; }

}
void llSave_Click(object sender, EventArgs e)
{

if (InvokeRequired)

Invoke(new EventHandler(llSave_Click), sender, e);

else

try
{

SaveFileDialog sf = new SaveFileDialog();
sf.Filter = "HTML file|*.htm;*.html";

if (sf.ShowDialog(this) == DialogResult.OK)
{

coll.Save(sf.FileName);

}

}
catch (Exception ex)
{

MessageBox.Show("Error saving list:\r\n" + ex.Message);

}

void llMail_Click(object sender, EventArgs e)
{

if (InvokeRequired)

Invoke(new EventHandler(llMail_Click), sender, e);

else

try
{

coll.Mail();

}
catch (Exception ex)
{

MessageBox.Show("Error mailing list:\r\n" + ex.Message);

}

void AddLabel(LinkLabel ll)
{

ll.Dock = DockStyle.Left;
Controls.Add(ll);

}

public Feedback Add(Feedback fb)
{

return lb.Add(fb);

}

public int Count
{

get { return lb.Count; }

}

public Feedback this[int Index]
{

get { return lb[Index]; }

}

public class FeedbackAlivePanel : Panel
{

PulseRectangle pr = new PulseRectangle();
public FeedbackAlivePanel()
{

SetStyle(ControlStyles.UserPaint
| ControlStyles.AllPaintingInWmPaint, true);

}

protected override void OnResize(EventArgs eventargs)
{

pr.Bounds = Bounds;
Increase();

}

public void Increase()
{

Invalidate();

}

protected override void OnPaint(PaintEventArgs e)
{

pr.Paint(e.Graphics);

}

/// <summary>
/// A listbox specifically for feedback items. The items are graphically shown to clearly
/// outline their type of feedback
/// </summary>
public class FeedbackListBox : ListBox
{

public FeedbackListBox()
{

DrawMode = DrawMode.OwnerDrawFixed;
SetStyle(ControlStyles.AllPaintingInWmPaint

| ControlStyles.OptimizedDoubleBuffer, true);

items = new ItemCollection(this);

}

public Feedback this[int index]
{

get
{

if (coll == null)

throw new Exception("No collection has been started yet");

return coll[index];

}

[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility .Hidden)]
public new ItemCollection Items
{

get { return items; }

}

ItemCollection items;
public class ItemCollection
{

public readonly FeedbackListBox Owner;
public ItemCollection(FeedbackListBox Owner)
{

this.Owner = Owner;

}

public Feedback this[int Index]
{

get
{

return Owner[Index];

}

public int Count { get { return Owner.Count; } }

public void Add(Feedback fb)
{

Owner.Add(fb);

}

public int IndexOf(Feedback fb)
{

return Owner.IndexOf(fb);

}

public Feedback Add(Feedback fb)
{

if (coll == null) Collection = new FeedbackCollection();
coll.Add(fb);
return fb;

}

void Collection_ListChanged(object sender, ListChangedEventArgs e)
{

switch (e.ListChangedType)
{

case ListChangedType.ItemAdded:
case ListChangedType.ItemChanged:
case ListChangedType.ItemDeleted:

//this inbetween class is used because in threading environments
//the collection can be updated before the invoke is finished
update(new updateinfo
{

Index=e.NewIndex,
Item=((FeedbackCollection)sender)[e.NewIndex],
Type= e.ListChangedType

});
break;

}

class updateinfo
{

public int Index;
public Feedback Item;
public ListChangedType Type;

}

Queue<updateinfo> updates = new Queue<updateinfo>();
volatile bool updating;
void update(updateinfo info)
{

lock (updates)

updates.Enqueue(info);

try
{

if (!updating && !IsDisposed)

BeginInvoke((Void)delegate()
{

update();

});

}
catch (Exception ex)
{

Console.WriteLine(ex.Message);

}

void update()
{

if (updating) return;
updating = true;
updateinfo info ;
while(updates.Count>0)
{

lock(updates)

info = updates.Dequeue();

switch (info.Type)
{

case ListChangedType.ItemAdded:

Init(info.Item, info.Index);
break;

case ListChangedType.ItemChanged:

Update(info.Item, info.Index);
break;

case ListChangedType.ItemDeleted:

Remove(info);
break;

}

}
Application.DoEvents();
updating = false;

}

void Init(Feedback fb, int index)
{

fb.Updated += new EventHandler(Feedback_Updated);
base.Items.Insert(index, fb);
SetIndex(index);

}
void Remove(updateinfo inf)
{

inf.Item.Updated -= new EventHandler(Feedback_Updated);
base.Items.RemoveAt(inf.Index);

}

void Feedback_Updated(object sender, EventArgs e)
{

var u = new updateinfo();
u.Item= (Feedback)sender;
u.Index=IndexOf(u.Item);
u.Type =u.Index==-1 ? ListChangedType.ItemDeleted : ListChangedType.ItemChanged;
update(u);

}

delegate void Void();

void UpdateSummary()
{
}

void Update(Feedback fb, int index)
{

if (fb.IsAliveIndicator)

UpdatePulse(fb);

//System.Diagnostics.Debug.Assert(index >= 0);
if (index >= 0)
{

Rectangle r = GetRectangle(index);
Invalidate(r);

SetIndex(index);
Application.DoEvents();

}
else

fb.Updated -= new EventHandler(Feedback_Updated);

}

Rectangle GetRectangle(int index)
{

Rectangle r = ClientRectangle;
r.Height = this.ItemHeight;
r.Y = r.Height*index;
return r;

}
void SetIndex(int index)
{

SelectedIndex = index;

}

public int IndexOf(Feedback fb)
{

if (coll == null) return -1;
return coll.IndexOf(fb);

}
public int Count
{

get
{

if (coll == null) return 0;
return coll.Count;

}

protected override void OnDrawItem(DrawItemEventArgs e)
{

object item = base.Items[e.Index];
Feedback fb = (Feedback)item ;
FeedbackItemInfo inf = new FeedbackItemInfo(fb,e,coll.StartTime,this);
fb.GetPainter(inf).Paint();

}

public event EventHandler CollectionChanged;

FeedbackCollection coll;
[DefaultValue(null)]
public FeedbackCollection Collection
{

get
{

return coll;

}
set
{

if (coll == value) return;
BeginUpdate();
base.Items.Clear();
if(coll!=null)

coll.ListChanged += new ListChangedEventHandler(Collection_ListChanged);

//base.DataSource =  DataSource not used because of threading problems
coll = value;
if (coll != null)
{

coll.ListChanged += new ListChangedEventHandler(Collection_ListChanged);
for (int i = 0; i < coll.Count; i++)
{

Init(coll[i], i);

}

}
EndUpdate();
if (CollectionChanged != null)

CollectionChanged(this, EventArgs.Empty);

}

}
[DesignerSerializationVisibility(DesignerSerializationVisibility .Hidden)]
public new FeedbackCollection DataSource
{

get { return coll; }

}

Dictionary<Feedback, PulseRectangle> pulses;
void UpdatePulse(Feedback fb)
{

GetPulse(fb).Update();

}

public PulseRectangle GetPulse(Feedback fb)
{

if (pulses == null)

pulses = new Dictionary<Feedback, PulseRectangle>();

PulseRectangle pr;
if (!pulses.TryGetValue(fb, out pr))
{

pr = new PulseRectangle();
pr.Count = 20;
pulses.Add(fb, pr);

}
return pr;

}

protected override void OnClick(EventArgs e)
{

if (mouseonbutton != null)
{

mouseonbutton.ShowExtraInfo(this);

}
base.OnClick(e);

}

Feedback mouseonbutton;

protected override void OnMouseMove(MouseEventArgs e)
{

Feedback onbutton = null;

if (Count > 0 && FeedbackItemPainter.ExtraInfoButtonArea.Contains(e.X,e.Y))
{

int index = IndexFromPoint(e.Location);
if (index != -1 && index < Count)

onbutton = this[index];

}

if (mouseonbutton != onbutton)
{

if (onbutton != null && onbutton.CanShowExtraInfo)

mouseonbutton = onbutton;

else

mouseonbutton = null;

Cursor = mouseonbutton != null ? Cursors.Hand : null;

}

public class FeedbackItemInfo
{

public readonly DrawItemEventArgs DrawItemEventArgs;
public readonly bool IsSelected;
public readonly Feedback Item;
public readonly int Index;
public readonly Rectangle Bounds;
public readonly DateTime CollectionStartTime;
public readonly FeedbackListBox Owner;

public FeedbackItemInfo(Feedback Item, DrawItemEventArgs e, DateTime CollectionStartTime, FeedbackListBox Owner)
{

this.Item = Item;
this.DrawItemEventArgs = e;
this.IsSelected = (e.State & DrawItemState.Selected) > 0;
this.Index = e.Index;
this.Owner = Owner;
this.Bounds = e.Bounds;
this.CollectionStartTime = CollectionStartTime;

}

public class FeedbackItemPainter
{

Rectangle r;
public FontFamily FontFamily;
public readonly Rectangle MessageArea;
public readonly FeedbackItemInfo Info;
public readonly Graphics Graphics;
public FeedbackItemPainter(FeedbackItemInfo info)
{

this.Info = info;
this.r = info.Bounds;
this.FontFamily = info.DrawItemEventArgs.Font.FontFamily;
MessageArea = new Rectangle(MessageOffset, r.Y, r.Width - MessageOffset, r.Height);
this.Graphics = info.DrawItemEventArgs.Graphics;

}

public const int

ExtraInfoOffset = 75,
ExtraInfoWidth = 10,
ProgressWidth = 40,
MessageOffset = 90,
TimeOffset = 32;

public static readonly Rectangle ExtraInfoButtonArea = new Rectangle(ExtraInfoOffset, 0, ExtraInfoWidth, int.MaxValue);

public void DrawDateTime()
{

DrawDateTime(Info.Index > 0,Brushes.Black);

}
public virtual void DrawDateTime(bool Relative,Brush b)
{

//clear background
ClearDateTimeBackGround(Brushes.White);
//draw text
if (Relative)

DrawRelativeTime(Info.Item.LastUpdate.Subtract(Info.CollectionStartTime),b);

else

DrawAbsoluteTime(b);

}

void DrawAbsoluteTime(Brush b)
{

Graphics.DrawString(

Info.Item.DateTime.ToShortDateString() + " " + Info.Item.DateTime.ToString("hh:mm.ss"),
GetFont(6.5f), b, r.Left, r.Top + 1);

}

void DrawRelativeTime(TimeSpan diff,Brush b)
{

Graphics.DrawString(

string.Format("+{0:00}:{1:00}.{2:00}.{3:000}",

diff.Hours, diff.Minutes, diff.Seconds, diff.Milliseconds),
GetFont(7.2f)
, b, r.Left, r.Top);

}

public Font GetFont(float size)
{

return new Font(FontFamily, size);

}

public virtual void ClearDateTimeBackGround(Brush b)
{

Graphics.FillRectangle(b, DateTimeArea);

}

public Rectangle DateTimeArea
{

get
{

return new Rectangle(r.Left, r.Top, r.Left + ExtraInfoOffset, r.Height);

}

public virtual Color GetBackgroundColor()
{

if(Info.IsSelected)

return Color.Blue;

return Color.White;

}

public void DrawSelectionRectangle()
{

DrawSelectionRectangle(GetBackgroundColor());

}
public virtual void DrawSelectionRectangle(Color c)
{

Graphics.DrawRectangle(new Pen(c), r);
ClearMessageBackGround(c);

}

public void ClearMessageBackGround(Color c)
{

Graphics.FillRectangle(new SolidBrush(c), MessageArea);

}

public void DrawExtraInfoButton()
{

Rectangle rectEI = ExtraInfoButtonArea;
rectEI.Y = r.Y;
rectEI.Height = r.Height;
DrawExtraInfoButton(rectEI);

}

public virtual void DrawExtraInfoButton(Rectangle r)
{

ControlPaint.DrawButton(Graphics, r, ButtonState.Normal);
r.X += 2;
Graphics.DrawString("i", GetFont(7), Brushes.Blue, r);

}

public void DrawMessage()
{

DrawMessage(offset);

}

public void DrawMessage(int Offset)
{

Color c = Info.IsSelected ? Color.WhiteSmoke : Color.Black;
Rectangle r = MessageArea;
r.X += Offset;
r.Width -= Offset;
DrawMessage(r, new SolidBrush(c));

}
public virtual void DrawMessage(Rectangle r,Brush b)
{

Font f = GetFont(7);
if (Info.Item.Level > 0)

f = new Font(f, FontStyle.Bold);

Graphics.DrawString(Info.Item.Message, f, b, r);

}

int offset;

public virtual void PaintProgress()
{

RectangleF rectProg = GetProgressRectangle();
rectProg.X++;
rectProg.Inflate(0, -1);
Graphics.FillRectangle(Brushes.White, rectProg);
Pen p = Pens.Black;
Graphics.DrawRectangle(p, Rectangle.Round(rectProg));
float penwidth = .5f;
rectProg.Inflate(-penwidth, -penwidth);
rectProg.Width *= Info.Item.ProgressPercentage;
Graphics.FillRectangle(Brushes.Green, rectProg);
Font f = GetFont(7);
Graphics.DrawString(Info.Item.GetProgressString(), f,

Brushes.Navy, rectProg.Left + 1, rectProg.Top - 1);

}

public virtual void PaintAlive()
{

Rectangle r = GetProgressRectangle();
r.Inflate(0, -1);
PulseRectangle pr = Info.Owner.GetPulse(Info.Item);
pr.Bounds = r;
pr.Paint(Graphics);

}

protected Rectangle GetProgressRectangle()
{

Rectangle r = MessageArea;
r.X += offset;
offset += ProgressWidth + 2;
r.Width = ProgressWidth;
return r;

}

protected void IncreaseOffset(int by)
{

offset += by;

}

public virtual void Paint()
{

DrawDateTime();

if (Info.Item.CanShowExtraInfo)
{

DrawExtraInfoButton();

}

DrawSelectionRectangle();

//draw progress
if (Info.Item.Progress > 0)
{

PaintProgress();

}

//draw alive
if (Info.Item.IsAliveIndicator)
{

PaintAlive();

}

//draw message
DrawMessage();

}

public class PulseRectangle
{

private Rectangle bounds;

public Rectangle Bounds
{

get { return bounds; }
set
{

if (bounds == value) return;
Rectangle r = bounds;
bounds = value;
if (r.Width != value.Width || ps == null)

Update();

else

FillDrawPoints();

}

void transform(int x, int y)
{

if (x == 0 && y == 0) return;
for (int i = 0; i < ps.Length; i++)
{

ps[i].X -= x;
ps[i].Y -= y;

}

/// <summary>
/// The number of points to draw.
/// Call Update manually after setting this value
/// </summary>
public int Count = 200;

private Point[] ps, drawpoints;
public void Update()
{

Random r = new Random();
double step = (double)bounds.Width / Count;
ps = new Point[Count];
drawpoints = null;
for (int i = 0; i < Count; i++)

ps[i] = new Point((int)(step * i), r.Next(100));

FillDrawPoints();

}
/// <summary>
/// The pen with which the pulses are drawn
/// </summary>
public Pen Pen = Pens.LightGreen;

public Brush BackGroundBrush = Brushes.Black;

void FillDrawPoints()
{

int left = bounds.Left, h = bounds.Height, top = bounds.Top;
drawpoints = new Point[ps.Length];
for (int i = 0; i < ps.Length; i++)
{

drawpoints[i].X = ps[i].X + left;
drawpoints[i].Y = top + (int)(h * ps[i].Y / 100);

}

}
public void Paint(Graphics g)
{

if (ps == null) Update();
g.FillRectangle(BackGroundBrush, bounds);
g.DrawLines(Pen, drawpoints);

}

/// <summary>
/// The importance of the feedback
/// </summary>
public enum FeedBackLevel
{

Custom = 100,
Trivial = -100,
Normal = 0,
SuperNormal = 200,
Exception = 500,
Important = 1000

}

public interface IFeedBackSupporter
{

FeedbackCollection Feedback { get; }

}

#region Specific feedback
public class FileReferenceFeedback : Feedback
{

public readonly string File;
public FileReferenceFeedback(string MessagePrefix, string File)

: base(
MessagePrefix
+ System.IO.Path.GetFileName(File)
+ " in "
+ System.IO.Path.GetDirectoryName(File))

{

this.File = File;

}
public FileReferenceFeedback(string File)

: this("File: ", File)

{

}

public override bool CanShowExtraInfo
{

get
{

return true;

}

public override void ShowExtraInfo(IWin32Window Owner)
{

System.Diagnostics.Process.Start("Explorer", "/select," + File);

}

public class ExceptionFeedback : Feedback
{

public readonly Exception Exception;
public ExceptionFeedback(Exception ex)
{

Exception = ex;
FeedbackLevel = FeedBackLevel.Exception;
System.Diagnostics.StackTrace stack = new System.Diagnostics.StackTrace(ex);
Message = "Error '" + ex.Message + "' occured on " + stack.GetFrame(0);

}

public override bool CanShowExtraInfo
{

get
{

return true;

}

public override void ShowExtraInfo(IWin32Window Owner)
{

DefaultShowExceptionMethod(Exception);

}

class ErrorPainter : FeedbackItemPainter
{

public ErrorPainter(FeedbackItemInfo inf)

: base(inf)

{
}

public override void DrawMessage(Rectangle r, Brush b)
{

Rectangle ri = r;
ri.Width = ri.Height;
Graphics.DrawIcon(SystemIcons.Error, ri);
r.X = ri.Right;
base.DrawMessage(r,Info.IsSelected ? Brushes.Orange : Brushes.Red);

}

public override FeedbackItemPainter GetPainter(FeedbackItemInfo info)
{

return new ErrorPainter(info);

}

protected override void AppendExtraInfo(AppendInfoSettings info)
{

new ExceptionInfo(Exception).AppendMessage(info.StringBuilder);

}

#endregion

}

. . .

Also needed: (this is used to show complete exception information in HTML, you could also strip the exception adding functionality, but I use this class a lot to quickly debug and get better stacktraces than the default .net block of code.

Code CopyHideScrollFull

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Diagnostics;
using System.Data.SqlClient;
using System.IO;

namespace Subro.Exceptions
{

public class ExceptionInfo : IExtraInfo
{

/// <summary>
/// The original Exception where this info object is based on
///
public readonly Exception Exception;
public ExceptionInfo(Exception ex)
{

this.Exception = ex;

//get stack trace information
StackTrace st = new StackTrace(Exception, true);
frames = new ErrorFrame[st.FrameCount];
for (int i = 0; i < frames.Length; i++)
{

frames[i] = new ErrorFrame(st.GetFrame(i));
if (usercodeindex == -1 && frames[i].IsUserCode)

usercodeindex = i;

}

//determine total exception count
while (ex != null)
{

exceptioncount++;
ex = ex.InnerException;

}

#region General properties
/// <summary>
/// The date/time of the exception. This is not the time the exception
/// was thrown, but rather when the ExceptionInfo object was created.
/// For most debugging purposes that difference in time does not matter, but
/// when the exact time is required, do not rely on this value!
///
public readonly DateTime DateTime = DateTime.Now;

ErrorFrame[] frames;
/// <summary>
/// Gets the different StackFrames that led to this
///
public ErrorFrame[] Frames
{

get { return frames; }

}

public int FrameCount
{

get { return frames.Length; }

}

int usercodeindex = -1;
/// <summary>
/// Returns the index of the first frame that occured in user code (and thus
/// the first frame that is actually debuggable ;-) )
///
public int UserFrameIndex
{

get { return usercodeindex; }

}

/// <summary>
/// Information about the last step before this error occured. The returned
/// object contains information about that step, such as the method that was running.
/// When running in debug, the pdb files also provide info on the original code filename and line number
///
public ErrorFrame LastFrame
{

get
{

if (frames.Length > 0) return frames[0];
return null;

}

/// <summary>
/// Where <see cref="LastFrame"/> returns the last step in general, this property
/// returns the last step in non-system code
/// <seealso cref="UserFrameIndex"/>
///
public ErrorFrame LastUserFrame
{

get
{

if (usercodeindex == -1) return null;
return frames[usercodeindex];

}

/// <summary>
/// The exception type
///
public string Type
{

get { return Exception.GetType().Name; }

}
#endregion

#region Mail NB: framework specific
/// This mail section was created in .net 2.0, you might
/// want to remove this part or alter it if using earlier versions

/// <summary>
/// Sends an email to the specified address
///
/// <param name="To">
public void Send(string To)
{

System.Net.Mail.MailMessage m = GetExceptionMail();
m.To.Add(To);
System.Net.Mail.SmtpClient client = new System.Net.Mail.SmtpClient("mail");
client.Send(m);

}

/// <summary>
/// Send the exception info (in html format) to the addressee.
/// NB, some presumtions were made when trying to create a quick and
/// dirty send method. Safest way it to use <see cref="FillMailMessage"/> or
/// <see cref="GetExceptionMail"/> and do the sending manually
///
/// <param name="ex">
/// <param name="To">
public static void Send(Exception ex, string To)
{

GetInfo(ex).Send(To);

}

/// <summary>
/// Gets a mailmessage instance containing the Exception info.
/// The from address is tried to be set to a custom address. If this
/// fails (or if you want to set a custom one), you'll have to set the From
/// address manually.
///
/// <returns>
public static System.Net.Mail.MailMessage GetExceptionMail(Exception ex)
{

return GetInfo(ex).GetExceptionMail();

}
System.Net.Mail.MailMessage GetExceptionMail()
{

System.Net.Mail.MailMessage m = new System.Net.Mail.MailMessage();
FillMailMessage(m);
try
{

m.From = new System.Net.Mail.MailAddress("Exceptions@" + Environment.UserDomainName);

}
catch { }
return m;

}

/// <summary>
/// Sets the body of the message to hold the exeption info
///
/// <param name="m">
public void FillMailMessage(System.Net.Mail.MailMessage m)
{

m.IsBodyHtml = true;
m.Body = GetTotalMessage();

}
#endregion

#region ExtraInfo NB

/// <summary>
/// This class can hold extra info for an <see cref="ExceptionInfo"/>
/// Its main purpose is to output this extra info to the html text
///
public abstract class ExtraInfo : IExtraInfo
{

/// <summary>
/// With this method, the extra info writes itself (in html format) to
/// the stringbuilder
///
/// <param name="sb">
public abstract void AppendHTML(StringBuilder sb, ExceptionInfo ei);

public static implicit operator ExtraInfo(string text)
{

return new TextInfo(text);

}

public class ValuesInfo : ExtraInfo
{

List<ValueEntry> values = new List<ValueEntry>();
class ValueEntry
{

public string Name, Text;

}
public string Header;

public void AddText(string text)
{

AddValue(null, text);

}
public void AddValue(string Name, string Value)
{

ValueEntry v = new ValueEntry();
v.Name = Name;
v.Text = Value;
values.Add(v);

}

public override void AppendHTML(StringBuilder sb, ExceptionInfo ei)
{

ei.openBlock(1, 1);
if (Header != null)

sb.Append("").Append(Header).Append(":");

if (values.Count > 0)
{

ei.openBlock(1, 1);
foreach (ValueEntry ve in values)
{

if (ve.Name == null)

sb.Append(ve.Text);

else

ei.appendInfo(ve.Name, ve.Text);

}
ei.closeBlock();

}

/// <summary>
/// Adds plain text as extrainfo
///
public class TextInfo : ExtraInfo
{

public string Text;
public TextInfo(string text) { Text = text; }
public override void AppendHTML(StringBuilder sb, ExceptionInfo ei)
{

sb.Append(Text);

}

#region SQL extra info

/// <summary>
/// Used to display the history of sql strings.
///
public class SQlStringInfo : ExtraInfo
{

List<string> list = new List<string>();
public void Add(string sql)
{

list.Add(sql);

}

public void AddRange(IEnumerable<string> values)
{

list.AddRange(values);

}

public override void AppendHTML(StringBuilder sb, ExceptionInfo ei)
{

ei.openBlock(1);
sb.Append("Recent sql strings:");
ei.openBlock("border:'gray 1 solid';margin-left:15");
int i = 0;
foreach (var sql in list)
{

sb.Append("--")

.Append(i++ + 1)
.Append("--")
.Append(sql)
.Append(" ");

}
ei.closeBlock();
ei.closeBlock();

}

/// <summary>
/// Add one or more sql strings to the list to be displayed in the recent
/// sql list.
/// This is usefull when you keep a list of recent executed sql strings somewhere
/// and want to include them in the exception output
///
/// <param name="SQL">
public void AddSQL(IEnumerable<string> SQL)
{

if (sqls == null)
{

sqls = new SQlStringInfo();
AddExtraInfo(sqls);

}
sqls.AddRange(SQL);

}

SQlStringInfo sqls;
#endregion

/// <summary>
/// Add <see cref="ExtraInfo"/>. You can also use a string as parameter
///
/// <param name="ei">
public void AddExtraInfo(IExtraInfo ei)
{

if (extrainfo == null) extrainfo = new List<IExtraInfo>();
extrainfo.Add(ei);

}

List<IExtraInfo> extrainfo;

/// <summary>
/// returns the amount of <see cref="ExtraInfo"/> objects added
///
public int ExtraInfoCount
{

get
{

if (extrainfo == null) return 0;
return extrainfo.Count;

}

#region HTML
const string ExtraInfoAnchor = "ExtraInfo";
protected virtual void appendExtraInfo()
{

if (extrainfo != null)
{

appendBR();
appendHR();
openBlock(2);
sb.Append("<A name='").Append(ExtraInfoAnchor)

.Append("'>Extra Info <HR>");

openBlock("margin-left:10;font-size:smaller");
foreach (IExtraInfo ei in extrainfo)
{

ei.AppendHTML(sb, this);

}
closeBlock();
closeBlock();

}

}
#endregion

#endregion

#region Static
/// <summary>
/// Rather than creating a new instance manually, use
/// this method to choose the proper exception object
///
/// <param name="ex">
/// <returns>
public static ExceptionInfo GetInfo(Exception ex)
{

if (ex == null) return null;
if (ex is SqlException) return new SqlExceptionInfo(ex as SqlException);
if (ex is ReflectionTypeLoadException) return new ReflectionTypeLoadExceptionInfo(ex as ReflectionTypeLoadException);
return new ExceptionInfo(ex);

}
public static implicit operator ExceptionInfo(Exception ex)
{

return GetInfo(ex);

}
#endregion

#region Inner Exceptions
int exceptioncount;
/// <summary>
/// returns the total number of exceptions (Main Exception + all inner exceptions)
///
public int ExceptionCount
{

get { return exceptioncount; }

}
#endregion

#region html information
/// BEWARE: this code is manufactured to quickly create the html information
/// and is not nicely constructed for reusability.
/// A bit more friendly code for html is used in the AutoFormatter (http://blogs.vbcity.com/hotdog/archive/2005/12/30/5759.aspx) ,
/// but did not use that here to keep the code portable for fresh applications

/// <summary>
/// Gets information about this exception and all inner exceptions in HTML format
///
/// <returns>
public string GetTotalMessage()
{

return AppendMessage(new StringBuilder()).ToString();

}

/// <summary>
/// This stringbuilder is only used in the html functions
///
protected StringBuilder sb;
protected void openBlock()
{

openBlock(null);

}
protected void openBlock(int Border)
{

openBlock(Border, 0);

}
protected void openBlock(int Border, int Indent)
{

openBlock("Border='" + Border + "px black solid'"

+ (Indent > 0 ? "margin-left=" + (Indent * 20) : null)
);

}
protected void openBlock(string Style)
{

openclose(false, Style);

}
protected void closeBlock()
{

openclose(true, null);

}
void openclose(bool close, string Style)
{

sb.Append("<");
if (close) sb.Append("/");
sb.Append("DIV");
if (Style != null)

sb.Append(" Style=\"").Append(Style).Append("\"");

sb.Append(">");

}

public StringBuilder AppendMessage(StringBuilder builder)
{

sb = builder;
openBlock(2);
appendTop();
appendInfo("Exception info created on", DateTime.ToString());
appendInfo("Application", AppDomain.CurrentDomain.FriendlyName);
openBlock("font-size:smaller;margin-left:20");
appendHeaderBottom();
closeBlock();
Exception ex = Exception;
int depth = 0;
while (append(ex, depth++)) { ex = ex.InnerException; }
appendExtraInfo();
appendBottom();
closeBlock();
sb = null;
return builder;

}

void appendMessage()
{
}

void IExtraInfo.AppendHTML(StringBuilder sb, ExceptionInfo ei)
{

this.sb = sb;
openBlock(2, 1);
appendTitle("Exception Info");
try
{

AppendMessage(sb);

}
catch (Exception ex)
{

appendTitle("Error obtaining exception info: " + ex.Message);

}
closeBlock();

}

/// <summary>
/// Gives inheriting classes the possibility to append html text at the top
/// of the info block, inside the main border
///
protected virtual void appendTop()
{
}
/// <summary>
/// Gives inheriting classes the possibility to append html inside the header
/// of the info block.
/// The base functionality adds links to the main and inner exceptions (if there are any)
///
protected virtual void appendHeaderBottom()
{

if (exceptioncount > 1)
{

for (int i = 0; i < exceptioncount; i++)
{

openHeaderLink(AnchorNamePrefix + i);
AppendExceptionTitle(i);
sb.Append("");

}

}
if (extrainfo != null)
{

openHeaderLink(ExtraInfoAnchor);
sb.Append("Extra Info");

}

/// <summary>
/// Gives inheriting classes the possibility to append html inside the header
/// of the Exception info block.
///
protected virtual void appendExceptionHeader()
{
}

/// <summary>
/// Used to add links in the header
///
/// <param name="href">
/// <param name="name">
protected virtual void openHeaderLink(string href)
{

sb.Append("<A style='margin-left:15' href='#").Append(href)

.Append("'>");

}

/// <summary>
/// Gives inheriting classes the possibility to append html text at the
/// end of the exception info, but before the main block is closed
///
protected virtual void appendBottom()
{
}

/// <summary>
/// The prefix of the name that is added per depth so that code can
/// point directly to one of the inner exceptions
/// The Name for the first exception is ExDepth0 , the second ExDepth1 and so forth.
/// Pointing to it in a href is subseqeuntly done with href = "#ExDepthX" where X is the inner exception index
///
public const string AnchorNamePrefix = "ExDepth";

void AppendExceptionTitle(int depth)
{

if (depth == 0)

sb.Append("Main Exception");

else

sb.Append("Inner Exception [").Append(depth).Append("]");

}

bool append(Exception ex, int depth)
{

if (ex == null) return false;
appendHR();
//add anchor information
sb.Append("<A NAME=\"").Append(AnchorNamePrefix).Append(depth)

.Append("\" style='font-size:smaller'>");

AppendExceptionTitle(depth);
sb.Append(": ")

.Append(ex.Message)
.Append("");

openBlock(1, 1);
if (depth > 0)
{

ExceptionInfo ei = GetInfo(ex);
ei.sb = sb;
ei.appendHeader();
try
{

ei.appendExtraInfo();

}
catch (Exception ex2)
{

appendTitle("Error writing extra info: " + ex2.Message);

}

}
else

appendHeader();

closeBlock();
return true;

}

const string

usercodecolor = "lightblue",
systemcodecolor = "beige";

void appendHeader()
{

openBlock("border:'1 green solid';");
appendInfo("Type", Type);
if (usercodeindex >= 0)
{

ErrorFrame ef = LastUserFrame;
appendInfo("Last user code", ef.FullMethodSignature + " (Line " + ef.Line + " in '" + ef.FileName + "')");

}
appendExceptionHeader();
if (frames.Length > 0)
{

appendTitle("Stack");
sb.Append("Legend: ");
for (int i = 0; i < 2; i++)
{

sb.Append("<span style=\"background-color:")

.Append(i == 0 ? systemcodecolor : usercodecolor)
.Append("border='1 black solid';margin-left:15\">")
.Append(i == 0 ? "No debug information" : "With debug information")
.Append("");

}
sb.Append("");
openBlock("margin-left:40;font-size:smaller");
foreach (ErrorFrame ef in frames)
{

appendStack(ef);

}
closeBlock();

}
else

sb.Append("--No StackTrace available--");

closeBlock();

}
protected void appendTitle(string Name)
{

sb.Append("").Append(Name).Append(": ");

}
protected void appendInfo(string Name, string Value)
{

appendTitle(Name);
sb.Append("")

.Append(Value).Append(" ");

}
protected void appendHR()
{

sb.Append("<HR>");

}
protected void appendBR()
{

sb.Append(" ");

}

void appendStack(ErrorFrame ef)
{

openBlock("border:'1 solid black';background-color:"

+ (ef.IsUserCode ? usercodecolor : systemcodecolor)
);

sb.Append("");
appendInfo("Method", ef.MethodName);
sb.Append("");
appendInfo("NameSpace", ef.NameSpace);
appendInfo("Full Signature", ef.MethodSignature);

if (ef.IsUserCode)
{

appendTitle("File");
sb.Append("<A href='")

.Append(ef.FileName).Append("'>").Append(ef.FileName).Append("")
.Append(" ");

appendInfo("Line", ef.Line.ToString());
appendTitle("Code snippet");
openBlock("border='1 black dotted';margin-left=25");
ef.AppendCode(sb, CodeSnippetExtraLines);
closeBlock();

}
closeBlock();

}

/// <summary>
/// Only applies when getting html text. This is the number of lines on
/// each side of the offending line, that should be included in code snippets
///
public int CodeSnippetExtraLines = 3;
#endregion

public override string ToString()
{

return Exception.ToString();

}

#region IO

/// <summary>
/// Shows the exception in html format by outputting to a default file first
/// and then opening it with the default browser.
/// (a form could have been used to do this, but tried to keep this info
/// class usable for Console applications as well)
///
public void ShowException()
{

ShowExceptionFile("default");

}

/// <summary>
/// Shows the exception in a browser, see <see cref="ShowException()"/> for more info
///
/// <param name="ex">
public static void ShowException(Exception ex)
{

GetInfo(ex).ShowException();

}

/// <summary>
/// First outputs the file (see <see cref="CreateExceptionFile"/>), then opens
/// it with the default connected viewer.
/// NB: the file is NOT appended. Existing info will be overwritten
/// NB2: if no writing is necessary
///
/// <param name="file">
public void ShowExceptionFile(string file)
{

ShowExceptionFile(file, false);

}
/// <summary>
/// Same as <see cref="ShowExceptionFile(string)"/>, but with the option
/// to choose whether to append or not
///
/// <param name="file">
/// <param name="append">
public void ShowExceptionFile(string file, bool append)
{

CreateExceptionFile(file, append);
ShowFile(file);

}

/// <summary>
/// All this does is run the file (using System.Diagnostics.Process.Start)
/// If an exception file is to be shown, make sure it is created first, or
/// use <see cref="ShowExceptionFile"/> to create and show the file instead
/// of this method
///
/// <param name="file">
public void ShowFile(string file)
{

CheckFile(ref file);
Process.Start(file);

}

/// <summary>
/// Appends complete directory information to a name (see code for details ;-) )
///
/// <param name="file">
public void CheckFile(ref string file)
{

FileInfo fi = new FileInfo(file);
if (fi.FullName.Length > file.Length)
{

//no directory provided -> use application directory
string dir =

Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData)
+ "\\Exceptions"
+ "\\" + AppDomain.CurrentDomain.FriendlyName
+ "\\";

if (!Directory.Exists(dir))

Directory.CreateDirectory(dir);

file = dir + file;

}
if (fi.Extension.Length == 0) file += ".htm";

}

/// <summary>
/// Outputs the exception to the specified file. Make sure the extension can
/// be read by explorer. If no extension is provided, ".htm" is used
///
/// <param name="file">
/// <param name="append">
public void CreateExceptionFile(string file, bool append)
{

CheckFile(ref file);
using (StreamWriter sw = new

StreamWriter(file, append, System.Text.Encoding.ASCII))
sw.Write(GetTotalMessage());

}
#endregion

}

public class SqlExceptionInfo : ExceptionInfo
{

public new readonly SqlException Exception;
public SqlExceptionInfo(SqlException ex)

: base(ex)

{

Exception = ex;

}

#region HTML

const string AnchorSQL = "sqlinfo";

protected override void appendExceptionHeader()
{

base.appendTop();
appendTitle("SQL Errors (" + Exception.Errors.Count + ")");
openBlock("border:'1 gray solid';font-size:0.6em;margin-left:40;margin-right:20");
for (int i = 0; i < Exception.Errors.Count; i++)
{

appendSQLError(i);

}
closeBlock();

}
protected override void appendHeaderBottom()
{

base.appendHeaderBottom();
openHeaderLink(AnchorSQL);
sb.Append("SQL info").Append("");

}

void appendSQLError(int index)
{

if (index > 0) appendHR();
SqlError se = Exception.Errors[index];
appendInfo("SQL class (severity)", se.Class.ToString());
appendInfo("Server", se.Server);
appendInfo("T-sql line number:", se.LineNumber.ToString());
appendInfo("Message", se.Message);
appendInfo("Procedure", se.Procedure);
appendInfo("Source", se.Source);
appendInfo("Sql error number", se.Number.ToString());

}

#endregion

}

public class ReflectionTypeLoadExceptionInfo : ExceptionInfo
{

public readonly ReflectionTypeLoadException ReflectionTypeLoadException;
public ReflectionTypeLoadExceptionInfo(ReflectionTypeLoadException Exception)

: base(Exception)

{

this.ReflectionTypeLoadException = Exception;
foreach (Exception e in ReflectionTypeLoadException.LoaderExceptions)
{

try
{

AddExtraInfo(GetInfo(e));

}
catch (Exception ex)
{

AddExtraInfo(new TextInfo("Error obtaining exception info: " + ex.Message));
AddExtraInfo(new TextInfo(e.Message));

}

/// <summary>
/// Wrapper around a <see cref="StackFrame"/>. Not that much added functionality, but
/// some properties instead of methods to be able to use easy databinding
///
public class ErrorFrame
{

public readonly StackFrame Base;
public ErrorFrame(StackFrame frame)
{

Base = frame;

}

public int Line
{

get { return Base.GetFileLineNumber(); }

}
public string FileName
{

get { return Base.GetFileName(); }

}

public string MethodName
{

get { return Base.GetMethod().Name; }

}

public string MethodSignature
{

get { return Base.GetMethod().ToString(); }

}

public string FullMethodSignature
{

get { return NameSpace + " - " + MethodSignature; }

}

public string NameSpace
{

get { return Base.GetMethod().ReflectedType.FullName; }

}

public bool IsUserCode
{

get { return Line > 0; }

}

public MethodBase GetMethod()
{

return Base.GetMethod();

}

public string GetCode()
{

return GetCode(2);

}
/// <summary>
///
///
/// <param name="Lines">indicates the amount of lines before and after the Errorline to show
public string GetCode(int Lines)
{

if (!IsUserCode)

return "No code available for a system method";

string file = FileName;
if (file == null || !File.Exists(file))

return "File not found!";

try
{

return AppendCode(new StringBuilder(), Lines).ToString();

}
catch (Exception ex)
{

return "Error obtaining code information: " + ex.Message;

}

internal StringBuilder AppendCode(StringBuilder sb, int Lines)
{

int line = Line, from = line - Lines, to = line + Lines, curline = 0; ;
int len = sb.Length;
const string space = " ";
string tab = null;
for (int tabcount = 0; tabcount < 4; tabcount++)
{

tab += space;

}
StreamReader sr = null;
try
{

sr = new StreamReader(FileName);
string l;
while ((l = sr.ReadLine()) != null)
{

if (++curline >= from)
{

if (curline > to) break;
if (line == curline) sb.Append("");
sb.Append(l.Replace("\t", tab).Replace(" ", space));
if (line == curline) sb.Append("");
sb.Append(" ");

}

}
catch (Exception ex)
{

sb.Length = len;
sb.Append("Error obtaining code information: ")

.Append(ex.Message);

}
finally
{

if (sr != null) sr.Close();

}
return sb;

}

public interface IExtraInfo
{

void AppendHTML(StringBuilder sb, ExceptionInfo ei);

}

}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Diagnostics;
using System.Data.SqlClient;
using System.IO;

namespace Subro.Exceptions
{

public class ExceptionInfo : IExtraInfo
{

/// <summary>
/// The original Exception where this info object is based on
///
public readonly Exception Exception;
public ExceptionInfo(Exception ex)
{

this.Exception = ex;

//get stack trace information
StackTrace st = new StackTrace(Exception, true);
frames = new ErrorFrame[st.FrameCount];
for (int i = 0; i < frames.Length; i++)
{

frames[i] = new ErrorFrame(st.GetFrame(i));
if (usercodeindex == -1 && frames[i].IsUserCode)

usercodeindex = i;

}

//determine total exception count
while (ex != null)
{

exceptioncount++;
ex = ex.InnerException;

}

ErrorFrame[] frames;
/// <summary>
/// Gets the different StackFrames that led to this
///
public ErrorFrame[] Frames
{

get { return frames; }

}

public int FrameCount
{

get { return frames.Length; }

}

get { return usercodeindex; }

}

get
{

if (frames.Length > 0) return frames[0];
return null;

}

get
{

if (usercodeindex == -1) return null;
return frames[usercodeindex];

}

/// <summary>
/// The exception type
///
public string Type
{

get { return Exception.GetType().Name; }

}
#endregion

#region Mail NB: framework specific
/// This mail section was created in .net 2.0, you might
/// want to remove this part or alter it if using earlier versions

/// <summary>
/// Sends an email to the specified address
///
/// <param name="To">
public void Send(string To)
{

System.Net.Mail.MailMessage m = GetExceptionMail();
m.To.Add(To);
System.Net.Mail.SmtpClient client = new System.Net.Mail.SmtpClient("mail");
client.Send(m);

}

GetInfo(ex).Send(To);

}

return GetInfo(ex).GetExceptionMail();

}
System.Net.Mail.MailMessage GetExceptionMail()
{

System.Net.Mail.MailMessage m = new System.Net.Mail.MailMessage();
FillMailMessage(m);
try
{

m.From = new System.Net.Mail.MailAddress("Exceptions@" + Environment.UserDomainName);

}
catch { }
return m;

}

/// <summary>
/// Sets the body of the message to hold the exeption info
///
/// <param name="m">
public void FillMailMessage(System.Net.Mail.MailMessage m)
{

m.IsBodyHtml = true;
m.Body = GetTotalMessage();

}
#endregion

#region ExtraInfo NB

public static implicit operator ExtraInfo(string text)
{

return new TextInfo(text);

}

public class ValuesInfo : ExtraInfo
{

List<ValueEntry> values = new List<ValueEntry>();
class ValueEntry
{

public string Name, Text;

}
public string Header;

public void AddText(string text)
{

AddValue(null, text);

}
public void AddValue(string Name, string Value)
{

ValueEntry v = new ValueEntry();
v.Name = Name;
v.Text = Value;
values.Add(v);

}

public override void AppendHTML(StringBuilder sb, ExceptionInfo ei)
{

ei.openBlock(1, 1);
if (Header != null)

sb.Append("").Append(Header).Append(":");

if (values.Count > 0)
{

ei.openBlock(1, 1);
foreach (ValueEntry ve in values)
{

if (ve.Name == null)

sb.Append(ve.Text);

else

ei.appendInfo(ve.Name, ve.Text);

}
ei.closeBlock();

}

/// <summary>
/// Adds plain text as extrainfo
///
public class TextInfo : ExtraInfo
{

public string Text;
public TextInfo(string text) { Text = text; }
public override void AppendHTML(StringBuilder sb, ExceptionInfo ei)
{

sb.Append(Text);

}

#region SQL extra info

/// <summary>
/// Used to display the history of sql strings.
///
public class SQlStringInfo : ExtraInfo
{

List<string> list = new List<string>();
public void Add(string sql)
{

list.Add(sql);

}

public void AddRange(IEnumerable<string> values)
{

list.AddRange(values);

}

public override void AppendHTML(StringBuilder sb, ExceptionInfo ei)
{

ei.openBlock(1);
sb.Append("Recent sql strings:");
ei.openBlock("border:'gray 1 solid';margin-left:15");
int i = 0;
foreach (var sql in list)
{

sb.Append("--")

.Append(i++ + 1)
.Append("--")
.Append(sql)
.Append(" ");

}
ei.closeBlock();
ei.closeBlock();

}

if (sqls == null)
{

sqls = new SQlStringInfo();
AddExtraInfo(sqls);

}
sqls.AddRange(SQL);

}

SQlStringInfo sqls;
#endregion

/// <summary>
/// Add <see cref="ExtraInfo"/>. You can also use a string as parameter
///
/// <param name="ei">
public void AddExtraInfo(IExtraInfo ei)
{

if (extrainfo == null) extrainfo = new List<IExtraInfo>();
extrainfo.Add(ei);

}

List<IExtraInfo> extrainfo;

/// <summary>
/// returns the amount of <see cref="ExtraInfo"/> objects added
///
public int ExtraInfoCount
{

get
{

if (extrainfo == null) return 0;
return extrainfo.Count;

}

#region HTML
const string ExtraInfoAnchor = "ExtraInfo";
protected virtual void appendExtraInfo()
{

if (extrainfo != null)
{

appendBR();
appendHR();
openBlock(2);
sb.Append("<A name='").Append(ExtraInfoAnchor)

.Append("'>Extra Info <HR>");

openBlock("margin-left:10;font-size:smaller");
foreach (IExtraInfo ei in extrainfo)
{

ei.AppendHTML(sb, this);

}
closeBlock();
closeBlock();

}

}
#endregion

#endregion

}
public static implicit operator ExceptionInfo(Exception ex)
{

return GetInfo(ex);

}
#endregion

#region Inner Exceptions
int exceptioncount;
/// <summary>
/// returns the total number of exceptions (Main Exception + all inner exceptions)
///
public int ExceptionCount
{

get { return exceptioncount; }

}
#endregion

/// <summary>
/// Gets information about this exception and all inner exceptions in HTML format
///
/// <returns>
public string GetTotalMessage()
{

return AppendMessage(new StringBuilder()).ToString();

}

/// <summary>
/// This stringbuilder is only used in the html functions
///
protected StringBuilder sb;
protected void openBlock()
{

openBlock(null);

}
protected void openBlock(int Border)
{

openBlock(Border, 0);

}
protected void openBlock(int Border, int Indent)
{

openBlock("Border='" + Border + "px black solid'"

+ (Indent > 0 ? "margin-left=" + (Indent * 20) : null)
);

}
protected void openBlock(string Style)
{

openclose(false, Style);

}
protected void closeBlock()
{

openclose(true, null);

}
void openclose(bool close, string Style)
{

sb.Append("<");
if (close) sb.Append("/");
sb.Append("DIV");
if (Style != null)

sb.Append(" Style=\"").Append(Style).Append("\"");

sb.Append(">");

}

public StringBuilder AppendMessage(StringBuilder builder)
{

}

void appendMessage()
{
}

void IExtraInfo.AppendHTML(StringBuilder sb, ExceptionInfo ei)
{

this.sb = sb;
openBlock(2, 1);
appendTitle("Exception Info");
try
{

AppendMessage(sb);

}
catch (Exception ex)
{

appendTitle("Error obtaining exception info: " + ex.Message);

}
closeBlock();

}

if (exceptioncount > 1)
{

for (int i = 0; i < exceptioncount; i++)
{

openHeaderLink(AnchorNamePrefix + i);
AppendExceptionTitle(i);
sb.Append("");

}

}
if (extrainfo != null)
{

openHeaderLink(ExtraInfoAnchor);
sb.Append("Extra Info");

}

/// <summary>
/// Gives inheriting classes the possibility to append html inside the header
/// of the Exception info block.
///
protected virtual void appendExceptionHeader()
{
}

/// <summary>
/// Used to add links in the header
///
/// <param name="href">
/// <param name="name">
protected virtual void openHeaderLink(string href)
{

sb.Append("<A style='margin-left:15' href='#").Append(href)

.Append("'>");

}

/// <summary>
/// Gives inheriting classes the possibility to append html text at the
/// end of the exception info, but before the main block is closed
///
protected virtual void appendBottom()
{
}

void AppendExceptionTitle(int depth)
{

if (depth == 0)

sb.Append("Main Exception");

else

sb.Append("Inner Exception [").Append(depth).Append("]");

}

bool append(Exception ex, int depth)
{

if (ex == null) return false;
appendHR();
//add anchor information
sb.Append("<A NAME=\"").Append(AnchorNamePrefix).Append(depth)

.Append("\" style='font-size:smaller'>");

AppendExceptionTitle(depth);
sb.Append(": ")

.Append(ex.Message)
.Append("");

openBlock(1, 1);
if (depth > 0)
{

ExceptionInfo ei = GetInfo(ex);
ei.sb = sb;
ei.appendHeader();
try
{

ei.appendExtraInfo();

}
catch (Exception ex2)
{

appendTitle("Error writing extra info: " + ex2.Message);

}

}
else

appendHeader();

closeBlock();
return true;

}

const string

usercodecolor = "lightblue",
systemcodecolor = "beige";

void appendHeader()
{

openBlock("border:'1 green solid';");
appendInfo("Type", Type);
if (usercodeindex >= 0)
{

ErrorFrame ef = LastUserFrame;
appendInfo("Last user code", ef.FullMethodSignature + " (Line " + ef.Line + " in '" + ef.FileName + "')");

}
appendExceptionHeader();
if (frames.Length > 0)
{

appendTitle("Stack");
sb.Append("Legend: ");
for (int i = 0; i < 2; i++)
{

sb.Append("<span style=\"background-color:")

.Append(i == 0 ? systemcodecolor : usercodecolor)
.Append("border='1 black solid';margin-left:15\">")
.Append(i == 0 ? "No debug information" : "With debug information")
.Append("");

}
sb.Append("");
openBlock("margin-left:40;font-size:smaller");
foreach (ErrorFrame ef in frames)
{

appendStack(ef);

}
closeBlock();

}
else

sb.Append("--No StackTrace available--");

closeBlock();

}
protected void appendTitle(string Name)
{

sb.Append("").Append(Name).Append(": ");

}
protected void appendInfo(string Name, string Value)
{

appendTitle(Name);
sb.Append("")

.Append(Value).Append(" ");

}
protected void appendHR()
{

sb.Append("<HR>");

}
protected void appendBR()
{

sb.Append(" ");

}

void appendStack(ErrorFrame ef)
{

openBlock("border:'1 solid black';background-color:"

+ (ef.IsUserCode ? usercodecolor : systemcodecolor)
);

if (ef.IsUserCode)
{

appendTitle("File");
sb.Append("<A href='")

.Append(ef.FileName).Append("'>").Append(ef.FileName).Append("")
.Append(" ");

appendInfo("Line", ef.Line.ToString());
appendTitle("Code snippet");
openBlock("border='1 black dotted';margin-left=25");
ef.AppendCode(sb, CodeSnippetExtraLines);
closeBlock();

}
closeBlock();

}

public override string ToString()
{

return Exception.ToString();

}

#region IO

ShowExceptionFile("default");

}

/// <summary>
/// Shows the exception in a browser, see <see cref="ShowException()"/> for more info
///
/// <param name="ex">
public static void ShowException(Exception ex)
{

GetInfo(ex).ShowException();

}

ShowExceptionFile(file, false);

CreateExceptionFile(file, append);
ShowFile(file);

}

CheckFile(ref file);
Process.Start(file);

}

/// <summary>
/// Appends complete directory information to a name (see code for details ;-) )
///
/// <param name="file">
public void CheckFile(ref string file)
{

FileInfo fi = new FileInfo(file);
if (fi.FullName.Length > file.Length)
{

//no directory provided -> use application directory
string dir =

Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData)
+ "\\Exceptions"
+ "\\" + AppDomain.CurrentDomain.FriendlyName
+ "\\";

if (!Directory.Exists(dir))

Directory.CreateDirectory(dir);

file = dir + file;

}
if (fi.Extension.Length == 0) file += ".htm";

}

CheckFile(ref file);
using (StreamWriter sw = new

StreamWriter(file, append, System.Text.Encoding.ASCII))
sw.Write(GetTotalMessage());

}
#endregion

}

public class SqlExceptionInfo : ExceptionInfo
{

public new readonly SqlException Exception;
public SqlExceptionInfo(SqlException ex)

: base(ex)

{

Exception = ex;

}

#region HTML

const string AnchorSQL = "sqlinfo";

protected override void appendExceptionHeader()
{

appendSQLError(i);

}
closeBlock();

}
protected override void appendHeaderBottom()
{

base.appendHeaderBottom();
openHeaderLink(AnchorSQL);
sb.Append("SQL info").Append("");

}

void appendSQLError(int index)
{

}

#endregion

}

public class ReflectionTypeLoadExceptionInfo : ExceptionInfo
{

public readonly ReflectionTypeLoadException ReflectionTypeLoadException;
public ReflectionTypeLoadExceptionInfo(ReflectionTypeLoadException Exception)

: base(Exception)

{

this.ReflectionTypeLoadException = Exception;
foreach (Exception e in ReflectionTypeLoadException.LoaderExceptions)
{

try
{

AddExtraInfo(GetInfo(e));

}
catch (Exception ex)
{

AddExtraInfo(new TextInfo("Error obtaining exception info: " + ex.Message));
AddExtraInfo(new TextInfo(e.Message));

}

public readonly StackFrame Base;
public ErrorFrame(StackFrame frame)
{

Base = frame;

}

public int Line
{

get { return Base.GetFileLineNumber(); }

}
public string FileName
{

get { return Base.GetFileName(); }

}

public string MethodName
{

get { return Base.GetMethod().Name; }

}

public string MethodSignature
{

get { return Base.GetMethod().ToString(); }

}

public string FullMethodSignature
{

get { return NameSpace + " - " + MethodSignature; }

}

public string NameSpace
{

get { return Base.GetMethod().ReflectedType.FullName; }

}

public bool IsUserCode
{

get { return Line > 0; }

}

public MethodBase GetMethod()
{

return Base.GetMethod();

}

public string GetCode()
{

return GetCode(2);

}
/// <summary>
///
///
/// <param name="Lines">indicates the amount of lines before and after the Errorline to show
public string GetCode(int Lines)
{

if (!IsUserCode)

return "No code available for a system method";

string file = FileName;
if (file == null || !File.Exists(file))

return "File not found!";

try
{

return AppendCode(new StringBuilder(), Lines).ToString();

}
catch (Exception ex)
{

return "Error obtaining code information: " + ex.Message;

}

internal StringBuilder AppendCode(StringBuilder sb, int Lines)
{

int line = Line, from = line - Lines, to = line + Lines, curline = 0; ;
int len = sb.Length;
const string space = " ";
string tab = null;
for (int tabcount = 0; tabcount < 4; tabcount++)
{

tab += space;

}
StreamReader sr = null;
try
{

sr = new StreamReader(FileName);
string l;
while ((l = sr.ReadLine()) != null)
{

if (++curline >= from)
{

if (curline > to) break;
if (line == curline) sb.Append("");
sb.Append(l.Replace("\t", tab).Replace(" ", space));
if (line == curline) sb.Append("");
sb.Append(" ");

}

}
catch (Exception ex)
{

sb.Length = len;
sb.Append("Error obtaining code information: ")

.Append(ex.Message);

}
finally
{

if (sr != null) sr.Close();

}
return sb;

}

public interface IExtraInfo
{

void AppendHTML(StringBuilder sb, ExceptionInfo ei);

}

Example Usage

Code CopyHideScrollFull

Subro.Interaction.FeedbackCollection fbc = new Subro.Interaction.FeedbackCollection();

//A thread is not obligatory of course, but for batch usage the thread
//should be thread safe, this example shows that the feedback visualizer
//is thread safe
Thread t = new Thread(delegate()
{

//shows
fbc.Add("Start");

//feedback with progress bar
Subro.Interaction.Feedback fb = fbc.Add("Working towards a known target");
int target = 150;
fb.ProgressTarget = target;
for (int i = 0; i <= target; i++)
{

Thread.Sleep(10);
fb.Progress = i;

}

fb = fbc.Add("busy with something");
for (int i = 0; i < 100; i++)
{

//Show alive shows a 'pulse' line to indicate that
//the process is still busy (used when the exact progress is unknown)
fb.ShowAlive();
Thread.Sleep(10);

//Each feedback item in turn can have 'children' attached
//this means that information you want to have accessible,
//but not necessarily shown each time can be added easily.
//each child item in turn of course can also posses child items
//when the feedback is shown, an 'i' button will appear to
//indicate there is extra information available
fb.Children.Add("Proccessed " + i.ToString());

}

//special feedback items such as excpetions are available as
//well. Exception example
fbc.Add(new Exception("If something went wrong, you would find the exception info here"));

//of course custom feedback items (inheriting from Feedback)
//could be added as well, where you can show your own custom
//info, eg, you could show your own form when the information
//button is clicked by overriding the ShowExtraInfo method

//instead of, or after, showing, the results could also be
//saved (or mailed), eg for saving:
fbc.Save(@"c:\temp\testresults.htm");

});
t.IsBackground = true;
t.Start();

//if no feedbackform was created, the feedback would still
//be gathered, without the (relatively small) overhead of the feedback
fbc.ShowDialog();
//other options are non modal Show and ShowHTML
//The latter outputs all feedback to a html page with the complete overview

Subro.Interaction.FeedbackCollection fbc = new Subro.Interaction.FeedbackCollection();

//A thread is not obligatory of course, but for batch usage the thread
//should be thread safe, this example shows that the feedback visualizer
//is thread safe
Thread t = new Thread(delegate()
{

//shows
fbc.Add("Start");

//feedback with progress bar
Subro.Interaction.Feedback fb = fbc.Add("Working towards a known target");
int target = 150;
fb.ProgressTarget = target;
for (int i = 0; i <= target; i++)
{

Thread.Sleep(10);
fb.Progress = i;

}

fb = fbc.Add("busy with something");
for (int i = 0; i < 100; i++)
{

//Show alive shows a 'pulse' line to indicate that
//the process is still busy (used when the exact progress is unknown)
fb.ShowAlive();
Thread.Sleep(10);

}

//special feedback items such as excpetions are available as
//well. Exception example
fbc.Add(new Exception("If something went wrong, you would find the exception info here"));

//instead of, or after, showing, the results could also be
//saved (or mailed), eg for saving:
fbc.Save(@"c:\temp\testresults.htm");

});
t.IsBackground = true;
t.Start();

Continuous Control

Robert Verpalen — Thu, 26 Oct 2006 08:48:00 GMT

In short: the continuous control is a control that in the designer can take any control (or multiple controls) and when bound to a bindingsource shows it as list of that entity of controls. Those having used access know the concept as a subform.

Click here for the source code: http://blogs.vbcity.com/hotdog/archive/2006/10/26/6567.aspx (last update 6/12/06)

For a Step by step quick example guide, click here
(The quick quickversion: add this control to a form, add a bindingsource, set the bindingsource property of the control to that bindingsource, drop some controls onto the continuous control (make sure they have databindings to the same source if they need to updated per record) and you're set to go.)

If, by any chance you want to know about how the control came to be, (or if you're simply have absolutely nothing interesting to do ;-) ), visit this link: http://blogs.vbcity.com/hotdog/archive/2006/10/26/6571.aspx

Sample code will follow later

Screenshots:

Designer view with some controls dropped onto it

Simple runtime:

runtime with some options enabled:

Addition history
1/12/06:
* HeaderPanel option
* LeftToRight option
* fixed a small design time deviation when ShowSelectButtons was enabled
5/12/06:
* Insertbuttons (ability to show insert buttons between each item)
6/12/06:
* DragDrop (autodrag to always allow drag and AllowReorder to automatically drag items to other positions)

Source code continuous form

Robert Verpalen — Thu, 26 Oct 2006 08:04:00 GMT

Code CopyHideScrollFull

#define IncludeDesignTimeSupport

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

//Legal mumbo jumbo:
//(c) 2006 R.Verpalen, Subro Software
//the control and code can be freely used, but the source may only be distributed through a site of the creator
//at this time, that means blogs.vbcity.com/hotdog
//That also means personal alterations are for your own use only ;-)

namespace Subro.Controls
{

/// <summary>
/// Continuous control: drag any control or number of controls onto it's design surface, attach
/// a bindingsource and a continous 'subform' is the result
/// </summary>
/// <remarks>
/// Needed references:
/// the default windows forms: System,System.Drawing,System.Windows.Forms
/// for design time functionality: System.Design
/// Although the class can't be designed directly (due to the way
/// visual studio handles the designer creation), but inheriting classes
/// and instances dropped onto another designer support full design
/// time functionality
/// </remarks>
///

#if IncludeDesignTimeSupport

[Designer(typeof(ContinuousControlDesigner))]
[Designer(typeof(ContinuousControlDocumentDesigner), typeof(System.ComponentModel.Design.IRootDesigner))]

#endif

[DefaultProperty("BindingSource")]
public partial class ContinuousControl : Panel, ISupportInitialize
{

#region constructor

Panel scrollpanel = new Panel();

public ContinuousControl()
{

Init();

}

void Init()
{

this.Name = "ContinuousControl";
this.MinimumSize = new Size(100, 24);
base.BorderStyle = DefaultBorderStyle;
scrollpanel.AutoScroll = true;
scrollpanel.Dock = DockStyle.Fill;
scrollpanel.BackColor = Color.Gray;
Controls.Add(scrollpanel);
mainpanel = new MainPanel(this);
instance = new ControlInstance(this);
this.NavigatorStyle = GetDefaultNavigatorStyle();
valfailedaction = GetDefaultValidationFailedAction();

}

#endregion

#region designer support

//this region contains the small designer part that's always
//included for easy compilation
//the actual design time support is in the partial class further down
//and can be omitted if wanted for the final release.

//properties windows category constants
protected const string CategoryPrefix = " ";
protected const string DataCategory = CategoryPrefix + "Data";
protected const string ItemCategory = CategoryPrefix + "Item settings";
protected const string NavigatorCategory = CategoryPrefix + "Navigator";
protected const string HeaderCategory = CategoryPrefix + "Header";
protected const string BehaviorCategory = CategoryPrefix + "Behavior";

#if IncludeDesignTimeSupport

/// <summary>
/// Only used for design time functionality for inheritors
/// </summary>
protected IComponent _Instance;

#endif

#endregion

#region supporting controls

ControlInstance instance;

/// <summary>
/// Direct access to the controls of the main record instance.
/// Controls added in design time are also serialized through this property
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public ControlCollection InstanceControls
{

get { return instance.Controls; }

}

#if IncludeDesignTimeSupport

[Designer(typeof(InstanceDesigner))]
[System.ComponentModel.Design.Serialization.DesignerSerializer(

typeof(System.ComponentModel.Design.Serialization.CodeDomSerializer),
typeof(System.ComponentModel.Design.Serialization.CodeDomSerializer))] //this serializer is attached to make sure the inheriting classes will not serialize properties of the protected instance

#endif

class ControlInstance : Control
{

public readonly ContinuousControl owner;
public ControlInstance(ContinuousControl Owner)
{

BackColor = Owner.BackColor;
Owner.mainpanel.Controls.Add(this);
this.owner = Owner;

}

Brush nonfocusbrush;
public override Color BackColor
{

get
{

return base.BackColor;

}
set
{

base.BackColor = value;
nonfocusbrush = new System.Drawing.Drawing2D.HatchBrush(

System.Drawing.Drawing2D.HatchStyle.Percent05 | System.Drawing.Drawing2D.HatchStyle.LightUpwardDiagonal,
ControlPaint.Light(value),
value);

}

public bool ChildPaint;
/*
protected override void OnPaintBackground(PaintEventArgs pevent)
{

if (ChildPaint && !DesignMode)

pevent.Graphics.FillRectangle(nonfocusbrush, ClientRectangle);

else
{

base.OnPaintBackground(pevent);
//ControlPaint.DrawBorder(pevent.Graphics, ClientRectangle, Color.Navy, ButtonBorderStyle.Solid);

}

}*/

public ContinuousControl Owner
{

get { return owner; }

}

protected override Size DefaultSize
{

get
{

return owner == null ? Size.Empty : owner.ItemSize;

}

object Current
{

get { return owner.source.Current; }

}

protected override void OnLayout(LayoutEventArgs levent)
{

if (!owner.IsInitializing)

Reset();

base.OnLayout(levent);

}

void Reset()
{

owner.ResetItemSize();

}

protected override void OnMouseDown(MouseEventArgs e)
{

if (e.Button == MouseButtons.Left)

Owner.mainpanel.CheckDragStart();

base.OnMouseDown(e);

}

protected override void OnMouseMove(MouseEventArgs e)
{

if (e.Button == MouseButtons.Left)

Owner.mainpanel.CheckDragStart();

base.OnMouseMove(e);

}

internal bool Validate()
{

owner.source.EndEdit();

Focus();
if (!Focused)
{

bool AllowContinue;
owner.OnRecordValidationFailed(out AllowContinue);
return AllowContinue;

}
return true;

}

internal void CancelCurrentEdit()
{

owner.source.CurrencyManager.CancelCurrentEdit();

}

bool suspendlocationchange;
/// <summary>
/// Sets the focus control to the proper position.
/// This procedure is executed when the <see cref="BindingSource"/>'s
/// position is changes or when a layout property is changed
/// </summary>
void SetInstanceLocation()
{

if (IsInitializing) return;

#if IncludeDesignTimeSupport

if (this.DesignMode)
{

SetDesignTimeInstanceSize();

}
else

#endif

if (instance != null && !suspendlocationchange)
{

SuspendLayout();

InvalidateSelectionArea(instance.Bounds);
bool vis = SelectedIndex != -1;
instance.Visible = vis;
if (vis)
{

instance.Bounds = GetNonPaddedItemBounds(SelectedIndex);
scrollpanel.ScrollControlIntoView(instance);

}
InvalidateSelectionArea(instance.Bounds);

ResumeLayout();

}

MainPanel mainpanel;

class MainPanel : ContainerControl
{

public readonly ContinuousControl Owner;
public MainPanel(ContinuousControl Owner)
{

this.Owner = Owner;
Size = Size.Empty;
Height = 0;
Dock = DockStyle.Top;
SetStyle(

ControlStyles.OptimizedDoubleBuffer
| ControlStyles.UserPaint
| ControlStyles.AllPaintingInWmPaint
, true);

Owner.scrollpanel.Controls.Add(this);

}

protected override bool ProcessTabKey(bool forward)
{

if (!Owner.handletabs)

return base.ProcessTabKey(forward);

return ProccessTabKey(forward, ActiveControl);

}

bool ProccessTabKey(bool forward, Control current)
{

bool wrap = forward ? Owner.SelectedIndex < Owner.Count - 1 : Owner.SelectedIndex > 0;
bool res = SelectNextControl(current, forward, true, true, false);

if (!res && wrap)
{

if (forward)

Owner.SelectedIndex++;

else

Owner.SelectedIndex--;

return SelectNextControl(null, forward, true, true, false);

}
return res;

}
#region Paint

public new void Paint(Graphics g)
{

if (Owner.ItemSize.Height == 0)
{

if (Owner.DrawStartInsertButton)

DrawInsertButton(-1, g);

return;

}
Point p = Owner.scrollpanel.AutoScrollPosition;
p.X *= -1;
p.Y *= -1;
int from = Owner.GetIndex(p);
p.Offset(Parent.Width, Parent.Height);
int sel = Owner.SelectedIndex;
int to = Owner.GetIndex(p) + 1;
if (to > Owner.Count && !Owner.DesignMode) to = Owner.Count;

for (int i = from; i < to; i++)
{

if (i == -1)
{

//first insert button
DrawInsertButton(i, g);
continue;

}

Rectangle bounds = Owner.GetNonPaddedItemBounds(i);

bool selected = i == sel;

if (!Owner.DesignMode)
{

if (selected ||

(Owner.multiselect && Owner.GetItem(i).SelectedVersion == Owner.selectionversion))

{

selected = true;
g.FillRectangle(SelectionBrush, Owner.GetSelectionBounds(bounds));

}

if (i != sel)
{

Bitmap bmp = Owner.GetBitmap(i);
g.DrawImage(bmp, bounds.Location);

}

}
else if (i > 0)
{

g.DrawRectangle(Pens.Black, bounds);

}

//select buttons
if (Owner.showselectbuttons)
{

DrawSelectButton(bounds, g, selected);

}

//insert buttons
if (Owner.ShowInsertButtons)
{

bool last = i == Owner.Count - 1;
if ((Owner.DrawInsertButtonsBetweenItems && !last)

|| (Owner.DrawEndInsertButton && last))
DrawInsertButton(i, g);

}

//delete button
if (Owner.ShowDeleteButtonPerItem)
{

DrawDeleteButton(i, g);

}

//drag insert
if (Owner.DragInsertIndex == i)
{

DrawDragInsert(i, g);

}

if (to == Owner.Count && Owner.DragInsertIndex == to)

DrawDragInsert(to, g);

}

void DrawInsertButton(int Index, Graphics g)
{

Rectangle bounds = Owner.GetInsertButtonBounds(Index);

DrawButton(bounds, g, Owner.insertbuttonicon,

InsertButtonFocused == Index, Owner.source != null && !Owner.source.AllowNew, InsertButtonPushed == Index);

}

void DrawSelectButton(Rectangle bounds, Graphics g, bool IsSelected)
{

if (Owner.lefttoright)
{

bounds.Y = 0;
bounds.Height = SelectButtonWidth;

}
else
{

bounds.X = 0;
bounds.Width = SelectButtonWidth;

}
g.DrawRectangle(new Pen(Owner.instance.BackColor), bounds);
if (IsSelected)
{

g.DrawImage(Owner.SelectedRecordImage,

bounds.X + (bounds.Width - Owner.SelectedRecordImage.Width) / 2,
bounds.Top + (bounds.Height - Owner.SelectedRecordImage.Height) / 2);

}

void DrawButton(Rectangle bounds,

Graphics g,
Icon ic,
bool IsSelected, bool IsInActive, bool IsPushed)

{

if (IsInActive)
{

ControlPaint.DrawButton(g, bounds, ButtonState.Inactive);

}
else if (IsSelected)
{

ControlPaint.DrawButton(g, bounds,

IsPushed
? ButtonState.Pushed
: ButtonState.Normal);

}
else

ControlPaint.DrawBorder(g, bounds, Color.Gray, ButtonBorderStyle.Outset);

g.DrawIcon(ic, bounds.X + (bounds.Width - ic.Width) / 2, bounds.Y + (bounds.Height - ic.Height) / 2);

}

void DrawDeleteButton(int Index, Graphics g)
{

Rectangle bounds = Owner.GetDeleteButtonBounds(Index);
DrawButton(bounds, g, Owner.deletebuttonicon,

Index == DeleteButtonFocused,
Owner.source != null && !Owner.source.AllowRemove,
DeleteButtonPushed == DeleteButtonFocused);

}

protected override void OnPaint(PaintEventArgs e)
{

Paint(e.Graphics);
base.OnPaint(e);

}

public Brush SelectionBrush = new SolidBrush(SystemColors.Highlight);

#endregion

#region DragDrop

public override bool AllowDrop
{

get
{

return base.AllowDrop;

}
set
{

base.AllowDrop = value;

}

bool UseDrag
{

get
{

return AllowDrop || Owner.autodrag;

}

Point DragStartPoint;

public void CheckDragStart()
{

if (!UseDrag) return;
Point p = LocalMousePosition;
int diff = Math.Abs(DragStartPoint.X - p.X)

+ Math.Abs(DragStartPoint.Y - p.Y);

if (diff > 3)
{

Owner.OnDragStart(Owner.GetIndex(DragStartPoint));
DragStartPoint = Point.Empty;

}

protected override void OnDragEnter(DragEventArgs e)
{

Owner.OnDragEnter(e);

}

protected override void OnDragOver(DragEventArgs e)
{

Owner.OnDragOver(e);

}

protected override void OnDragLeave(EventArgs e)
{

Owner.OnDragLeave(e);

}

protected override void OnDragDrop(DragEventArgs e)
{

DragStartPoint = Point.Empty;
Owner.OnDragDrop(e);

}

const int DragInsertHeight = 3;

Rectangle GetDragInsertBounds(int Index)
{

Rectangle res = Owner.GetItemBounds(Index);
float half = DragInsertHeight / 2f;
if (Index == 0)

half = 0;

else if (Index == Owner.Count)

half = DragInsertHeight;

if (Owner.lefttoright)
{

res.Y = 0;
res.Height = Height;
res.X -= (int)Math.Ceiling(half);
res.Width = DragInsertHeight;

}
else
{

res.X = 0;
res.Width = Width;
res.Y -= (int)Math.Ceiling(half);
res.Height = DragInsertHeight;

}
return res;

}

void DrawDragInsert(int Index, Graphics g)
{

g.FillRectangle(Brushes.Yellow, GetDragInsertBounds(Index));

}

public void InvalidateDragInsert(int Index)
{

Invalidate(GetDragInsertBounds(Index));

}

#endregion

public void SetSize()
{

int i = Owner.Count;
if (i == 0)

Size = Size.Empty;

else
{

Rectangle r = Owner.GetItemBounds(i);
int diff = 0;
if (Owner.ShowInsertButtons && !Owner.DrawInsertButtonsBetweenItems)
{

if (Owner.DrawStartInsertButton)

diff += InsertButtonHeight;

if (Owner.DrawEndInsertButton)

diff += InsertButtonHeight;

}
Size = new Size(

Owner.lefttoright ? r.Left + diff : r.Right,
Owner.lefttoright ? r.Bottom : r.Top + diff);

}

#region buttons

int DeleteButtonFocused = -1;
int DeleteButtonPushed = -1;
int? InsertButtonFocused;
int? InsertButtonPushed;
int GetDeleteButtonFocused()
{

Point p = LocalMousePosition;
int index = Owner.GetIndex(p);
if (Owner.GetDeleteButtonBounds(index).Contains(p))

return index;

return -1;

}
int? GetInsertButtonFocused()
{

Point p = LocalMousePosition;
int index = Owner.GetIndex(p);
if (Owner.GetInsertButtonBounds(index).Contains(p))

return index;

return null;

}

Point LocalMousePosition
{

get
{

return PointToClient(Control.MousePosition);

}

bool CheckButtonFocus()
{

if (Owner.ShowDeleteButtonPerItem)
{

int i = GetDeleteButtonFocused();
if (i != DeleteButtonFocused)
{

InvalidateDeleteButton();
DeleteButtonFocused = i;
InvalidateDeleteButton();

}
if (i != -1) return true;

}

if (Owner.ShowInsertButtons)
{

int? i = GetInsertButtonFocused();
if (i != InsertButtonFocused)
{

InvalidateInsertButton();
InsertButtonFocused = i;
InvalidateInsertButton();

}
if (i != null) return true;

}
return false;

}

void InvalidateDeleteButton()
{

if (DeleteButtonFocused != -1)

Invalidate(Owner.GetDeleteButtonBounds(DeleteButtonFocused));

}

void InvalidateInsertButton()
{

if (InsertButtonFocused != null)

Invalidate(Owner.GetInsertButtonBounds(InsertButtonFocused.Value));

}

#endregion

#region Mouse events
protected override void OnMouseMove(MouseEventArgs e)
{

if (!DragStartPoint.IsEmpty)
{

CheckDragStart();

}
CheckButtonFocus();
base.OnMouseMove(e);

}

protected override void OnMouseLeave(EventArgs e)
{

if (Owner.ShowDeleteButtonPerItem)

CheckButtonFocus();

base.OnMouseLeave(e);

}

protected override void OnMouseDown(MouseEventArgs e)
{

if (e.Button == MouseButtons.Left)
{

DeleteButtonPushed = DeleteButtonFocused;
InsertButtonPushed = InsertButtonFocused;
if (DeleteButtonFocused != -1)
{

InvalidateDeleteButton();

}
else if (InsertButtonFocused != null)

InvalidateInsertButton();

else
{

if (UseDrag)

DragStartPoint = LocalMousePosition;

SelectPointed();

}

}
base.OnMouseDown(e);

}

protected override void OnMouseUp(MouseEventArgs e)
{

if (DeleteButtonPushed != -1 && DeleteButtonPushed == DeleteButtonFocused)
{

Owner.source.RemoveAt(DeleteButtonPushed);

}
if (InsertButtonPushed != null && InsertButtonFocused == InsertButtonPushed)
{

//insert
Owner.OnInsertItem(InsertButtonPushed.Value + 1);

}
DeleteButtonPushed = -1;
InsertButtonPushed = null;
DragStartPoint = Point.Empty;
base.OnMouseUp(e);

}
#endregion

#region selection

bool IsMultiSelectClick
{

get
{

if (Owner.multiselect)

//return (ModifierKeys & (Keys.Control | Keys.Shift)) > 0;
return ModifierKeys == Keys.Control;

return false;

}

void SelectPointed()
{

Point p = LocalMousePosition;
int index = Owner.GetIndex(p);

if (IsMultiSelectClick)
{

Owner.SwitchSelect(index);
return;

}

Owner.SelectedIndex = index;

Owner.instance.Focus();

Rectangle r = Owner.GetItemBounds(index);
p.X -= r.X;
p.Y -= r.Y;
Control c = GetChild(Owner.instance, Control.MousePosition);
if (c != null)
{

InvokeOnClick(c, EventArgs.Empty);
c.Focus();

}

Control GetChild(Control c, Point p)
{

Control child = c.GetChildAtPoint(c.PointToClient(p));
if (child == null) return c;
return GetChild(child, p);

}

#endregion

}

#endregion

#region item collection

List<Item> items = new List<Item>();

class Item
{

public Bitmap Bitmap;
public int SelectedVersion;
public void Clear()
{

Bitmap = null;

}

void ResetIndex(int Index)
{

if (IsItemCreated(Index))
{

if (Index == SelectedIndex)
{

items[Index].Bitmap = createBitmap();

}
else
{

items[Index].Clear();
mainpanel.Invalidate(GetItemBounds(Index));

}

bool IsItemCreated(int Index)
{

return Index < items.Count;

}

Item GetItem(int Index)
{

while (items.Count <= Index)

items.Add(new Item());

return items[Index];

}

void ResetItems()
{

items.Clear();

}

#endregion

#region bitmaps

Bitmap GetBitmap(int Index)
{

Item res = GetItem(Index);
if (res.Bitmap == null)

res.Bitmap = createBitmap(Index);

else if (!VariableSize && res.Bitmap.Size != ItemSize)
{

res.Bitmap = null;
return GetBitmap(Index);

}
return res.Bitmap;

}

Bitmap createBitmap(int Index)
{

if (source == null) return null;

int pos = source.Position;
suspendlocationchange = true;
SuspendLayout();
try
{

source.Position = Index;
return createBitmap();

}
finally
{

source.Position = pos;
suspendlocationchange = false;
ResumeLayout(false);

}

}
Bitmap createBitmap()
{

try
{

Bitmap bmp = new Bitmap(instance.Width, instance.Height);
instance.ChildPaint = true;
instance.DrawToBitmap(bmp, new Rectangle(Point.Empty, instance.Size));
return bmp;

}
catch (Exception ex)
{

return GetErrorBitmap(SelectedIndex, ex);

}
finally
{

instance.ChildPaint = false;

}

protected override void OnEnabledChanged(EventArgs e)
{

base.OnEnabledChanged(e);
for (int i = 0; i < items.Count; i++)
{

items[i].Clear();

}
mainpanel.Invalidate();

}

/*
Bitmap GetEmptyBitmap()
{

Size size = ItemSize;
return new Bitmap(size.Width, size.Height);

}*/

private Bitmap GetErrorBitmap(int Index, Exception ex)
{

Rectangle r = GetItemBounds(Index);
Bitmap bmp = new Bitmap(r.Width, r.Height);
Graphics g = Graphics.FromImage(bmp);
Icon icon = SystemIcons.Error;
g.DrawIcon(icon, 0, 0);
return bmp;

}

[System.Runtime.InteropServices.DllImport("shell32.dll")]
extern static IntPtr ExtractIcon(int hInst, string lpszExeFileName, int nIconIndex);
public static Icon GetIcon(int index)
{

return GetIcon("shell32.dll", index);

}
public static Icon GetIcon(string dll, int index)
{

IntPtr handle = ExtractIcon(0, dll, index);
Icon ic = Icon.FromHandle(handle);
Bitmap bmp = new Bitmap(16, 16);
Graphics.FromImage(bmp).DrawIcon(ic, new Rectangle(0, 0, bmp.Width, bmp.Height));
return Icon.FromHandle(bmp.GetHicon());

}

public static Bitmap GetTriangleBitmap(bool lefttoright, int width, int height, Brush FillColor)
{

Bitmap res = new Bitmap(width, height);
Graphics g = Graphics.FromImage(res);
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
System.Drawing.Drawing2D.GraphicsPath gp = new System.Drawing.Drawing2D.GraphicsPath();
if (lefttoright)
{

gp.AddLine(0, 0, width / 2, height);
gp.AddLine(width / 2, height, width, 0);
gp.AddLine(width, 0, 0, 0);

}
else
{

gp.AddLine(0, 0, width, height / 2);
gp.AddLine(width, height / 2, 0, height);
gp.AddLine(0, height, 0, 0);

}
g.FillPath(FillColor, gp);
g.DrawPath(Pens.Black, gp);

return res;

}

#endregion

#region scrolling

[DefaultValue(true)]
public new bool AutoScroll
{

get { return scrollpanel.AutoScroll; }
set { scrollpanel.AutoScroll = value; }

}

[DefaultValue(false)]
public override bool AutoSize
{

get
{

return base.AutoSize;

}
set
{

if (value == AutoSize) return;
if (!DesignMode)
{

if (value)
{

scrollpanel.Dock = DockStyle.Fill;

}
else
{

scrollpanel.Dock = DockStyle.Top;

}

}
scrollpanel.AutoSize = value;
base.AutoSize = value;

}

#endregion

#region source

private BindingSource source;

[Category(DataCategory)]
[DefaultValue(null)]
public BindingSource BindingSource
{

get { return source; }
set
{

if (source != null)
{

source.ListChanged -= new ListChangedEventHandler(source_ListChanged);
source.PositionChanged -= new EventHandler(source_PositionChanged);

}
source = value;
ResetList();
if (source != null)
{

source.ListChanged += new ListChangedEventHandler(source_ListChanged);
source.PositionChanged += new EventHandler(source_PositionChanged);

}
if (navigator != null)

navigator.BindingSource = source;

OnBindingSourceChanged();

}

public event EventHandler BindingSourceChanged;
protected virtual void OnBindingSourceChanged()
{

if (BindingSourceChanged != null)

BindingSourceChanged(this, EventArgs.Empty);

}

int previousposition = -1;
void source_PositionChanged(object sender, EventArgs e)
{

if (suspendlocationchange) return;

if (multiselect)
{

selectionversion++;
if (previousposition != -1 && ModifierKeys == Keys.Shift)
{

int pos = source.Position;
int from = Math.Min(pos, previousposition), to = Math.Max(pos, previousposition);
for (int i = from; i <= to; i++)
{

GetItem(i).SelectedVersion = selectionversion;

}

if (items.Count > 200)

mainpanel.Invalidate();

else
{

InvalidateSelected(selectionversion - 1);
InvalidateSelected(selectionversion);

}

SetInstanceLocation();
previousposition = source.Position;

}

[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public int SelectedIndex
{

get
{

if (source == null) return -1;
return source.Position;

}
set
{

if (source != null)
{

Control c = GetActiveControl();
if (!instance.Validate())
{

return;

}
ResetIndex(SelectedIndex);

source.Position = value;
if (c != null)
{

c.Select();

}

Control GetActiveControl()
{

Form f = FindForm();
if (f == null) return null;
return GetActiveControl(f);

}
Control GetActiveControl(ContainerControl cc)
{

Control c = cc.ActiveControl;
if (c is ContainerControl)

return GetActiveControl(c as ContainerControl);

return c;

}

[Browsable(false)]
public int Count
{

get
{

if (source == null) return 0;
return source.Count;

}

void RefreshItems()
{

if (DesignMode || IsInitializing) return;
ResetItems();
InvalidateMainPanel();

}

public void ResetList()
{

if (DesignMode || IsInitializing) return;
previousposition = -1;
RefreshItems();
OnResetList();

}

protected virtual void OnResetList()
{
}

bool IsBindingSuspended
{

get
{

return source != null && source.IsBindingSuspended;

}

int editing;
public void BeginUpdate()
{

editing++;

}

public void EndUpdate()
{

if (--editing <= 0)
{

editing = 0;
if (needreset)
{

needreset = false;
ResetList();

}

}
bool needreset;

void source_ListChanged(object sender, ListChangedEventArgs e)
{

if (editing > 0)
{

needreset = true;
return;

}

if (e.ListChangedType == ListChangedType.ItemAdded)
{

if (IsItemCreated(e.NewIndex))

items.Insert(e.NewIndex, new Item());

mainpanel.SetSize();

}
else if (e.ListChangedType == ListChangedType.ItemDeleted)
{

if (e.NewIndex < items.Count)
{

items.RemoveAt(e.NewIndex);
mainpanel.Invalidate();
mainpanel.SetSize();

}
else if (items.Count == 0)

SetInstanceLocation();

}
else if (e.ListChangedType == ListChangedType.ItemMoved)
{

ResetIndex(e.OldIndex);
ResetIndex(e.NewIndex);

}
else if (e.ListChangedType == ListChangedType.Reset)
{

ResetList();

}
else if (e.ListChangedType == ListChangedType.ItemChanged)
{

ResetIndex(e.NewIndex);

}

#endregion

#region item sizing

Size? itemsize;
[Category(ItemCategory)]
public Size ItemSize
{

get
{

if (itemsize == null)
{

itemsize = GetItemSize();
if (instance != null && !DesignMode)

instance.Size = itemsize.Value;

}
return itemsize.Value;

}
set
{

if (value.IsEmpty)

itemsize = null;

else

itemsize = value;

}

}
bool ShouldSerializeItemSize()
{

return FixedItemSize;// itemsize != null && !GetItemBounds().Equals(itemsize.Value);

}
void ResetItemSize()
{

if (FixedItemSize) return;
itemsize = null;
if (VariableSize && !DesignMode && SelectedIndex > -1)

ResetIndex(SelectedIndex);

//sizewithbounds = null;
InvalidateMainPanel();

}

[Category(ItemCategory)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public bool FixedItemSize
{

get { return itemsizemode == ItemSizeMode.Fixed; }
set
{

if (value == FixedItemSize) return;
if (value)

ItemSizeMode = ItemSizeMode.Fixed;

else

ItemSizeMode = ItemSizeMode.Automatic;

}

static Padding DefaultItemPadding = new Padding(1);
private Padding itemPadding = DefaultItemPadding;
[Category(ItemCategory)]
public Padding ItemPadding
{

get { return itemPadding; }
set
{

itemPadding = value;
if (!IsInitializing)

SetInstanceLocation();

else if (DesignMode)

Invalidate();

else

mainpanel.Invalidate();

}

}
bool ShouldSerializeItemPadding()
{

return itemPadding != DefaultItemPadding;

}
void ResetItemPadding()
{

itemPadding = DefaultItemPadding;

}
/*
private Size? sizewithbounds;
[Category(ItemCategory)]
public Size ItemSizeWithPadding
{

get
{

if (sizewithbounds == null)
{

sizewithbounds = GetItemSizeWithBounds();

}
return sizewithbounds.Value;

}

*/
[Browsable(false)]
public bool VariableSize
{

get { return itemsizemode == ItemSizeMode.Variable || itemsizemode == ItemSizeMode.VariableUserSizable; }

}

private ItemSizeMode itemsizemode;
[Category(ItemCategory)]
[DefaultValue(ItemSizeMode.Automatic)]
public ItemSizeMode ItemSizeMode
{

get { return itemsizemode; }
set { itemsizemode = value; }

}

Size GetItemSizeWithBounds()
{

Size size = ItemSize;
if (size.IsEmpty) return size;
size.Width += itemPadding.Horizontal;
size.Height += itemPadding.Vertical;
return size;

}

Size GetItemSize()
{

//if (controls.Count == 0) return Size.Empty;
Size size = new Size();
foreach (Control c in instance.Controls)
{

size.Width = Math.Max(size.Width, c.Right);
size.Height = Math.Max(size.Height, c.Bottom);

}
return size;

}

int GetItemTop(int Index)
{

if (lefttoright)
{

if (showselectbuttons) return SelectButtonWidth;
return 0;

}

int res;
if (VariableSize && !DesignMode)
{

if (Index > 0)
{

res = AddReoccuringHeight(GetBitmap(--Index).Height)

+ GetItemTop(Index);

}
else

res = 0;

}
else

res = GetItemHeight() * Index;

if (DrawStartInsertButton)

res += InsertButtonHeight;

return res;

}

int GetItemLeft(int Index)
{

int res = 0;
if (!lefttoright)
{

if (showselectbuttons)

res += SelectButtonWidth;

return res;

}

if (VariableSize && !DesignMode)
{

if (Index > 0)
{

res = AddReoccuringWidth(GetBitmap(--Index).Width)

+ GetItemLeft(Index);

}

}
else
{

res += GetItemWidth();
res *= Index;

}
if (DrawStartInsertButton)

res += InsertButtonHeight;

return res;

}

int AddReoccuringWidth(int w)
{

w += itemPadding.Horizontal;
if (ShowDeleteButtonPerItem) w += DeleteButtonWidth;
if (lefttoright && DrawInsertButtonsBetweenItems)
{

w += InsertButtonHeight;

}
return w;

}

int GetItemWidth()
{

return AddReoccuringWidth(ItemSize.Width);

}

int AddReoccuringHeight(int h)
{

h += itemPadding.Vertical;
if (!lefttoright && DrawInsertButtonsBetweenItems)
{

h += InsertButtonHeight;

}
return h;

}

int GetItemHeight()
{

return AddReoccuringHeight(ItemSize.Height);

}

/// <summary>
/// Gets which item is at the specified point of the mainpanel
/// </summary>
/// <param name="p"></param>
/// <returns></returns>
int GetIndex(Point p)
{

int t, xy;
if (lefttoright)
{

t = GetItemWidth();
xy = p.X;

}
else
{

t = GetItemHeight();
xy = p.Y;

}
if (ShowInsertButtons && (insertbuttonstyle & InsertButtonStyles.BeginOnly) > 0)
{

xy -= InsertButtonHeight;

}
if (xy < 0) return -1;
return xy / t;

}

Size PadSize(Size size)
{

size.Width += itemPadding.Horizontal;
size.Height += itemPadding.Vertical;
return size;

}

Rectangle GetItemBounds(int Index)
{

return GetItemBounds(Index, 0, 0, true);

}

Rectangle GetItemBounds(int Index, int LeftOffset, int TopOffset, bool padded)
{

Size size;
if (VariableSize && Index > -1 && GetItem(Index).Bitmap != null)

size = GetItem(Index).Bitmap.Size;

else

size = ItemSize;

if (padded) size = PadSize(size);

return new Rectangle(

GetItemLeft(Index) + LeftOffset,
GetItemTop(Index) + TopOffset
, size.Width
, size.Height);

}
Rectangle GetNonPaddedItemBounds(int Index)
{

return GetItemBounds(Index, ItemPadding.Left, ItemPadding.Top, false);

}

protected override Size DefaultSize
{

get
{

return new Size(100, 150);

}

#endregion

#region Item validation

protected virtual void OnRecordValidationFailed(out bool AllowContinue)
{

if (RecordValidationFailed != null)
{

HandledEventArgs e = new HandledEventArgs(false);
RecordValidationFailed(this, e);
if (e.Handled)
{

AllowContinue = true;
return;

}

}
switch (valfailedaction)
{

case ValidationFailedActions.AskUser:

AllowContinue = MessageBox.Show("The current input does not validate correctly. If you continue to another record the changes will be lost. Do you wish to continue?"

, null, MessageBoxButtons.YesNoCancel) == DialogResult.Yes;

break;

case ValidationFailedActions.DiscardChanges:

AllowContinue = true;
break;

default:

AllowContinue = false;
break;

}

}
public event HandledEventHandler RecordValidationFailed;

public enum ValidationFailedActions
{

AskUser, DiscardChanges, BlockRecordChange

}

private ValidationFailedActions valfailedaction;
[Category(BehaviorCategory)]
public ValidationFailedActions ValidationFailedAction
{

get { return valfailedaction; }
set { valfailedaction = value; }

}
bool ShouldSerializeValidationFailedAction()
{

return valfailedaction != GetDefaultValidationFailedAction();

}

protected virtual ValidationFailedActions GetDefaultValidationFailedAction()
{

return ValidationFailedActions.BlockRecordChange;

}

#endregion

#region Key handling

bool In(Keys value, params Keys[] keys)
{

return Array.IndexOf<Keys>(keys, value) != -1;

}

protected override bool IsInputKey(Keys keyData)
{

return In(keyData, Keys.Up, Keys.Down, Keys.PageDown, Keys.PageUp, Keys.Escape)
|| base.IsInputKey(keyData);

}
private bool handletabs = false;
[DefaultValue(false)]
[Description("If true, all records are walked through when tab is pressed before the control loses focus")]
public bool HandleTabs
{

get { return handletabs; }
set { handletabs = value; }

}

protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
{

if (source != null)
{

if (keyData == Keys.Up)
{

if (!lefttoright)

SelectedIndex--;

}
else if (keyData == Keys.Down)
{

if (!lefttoright)

SelectedIndex++;

}
else if (keyData == Keys.Left)
{

if (lefttoright)

SelectedIndex--;

}
else if (keyData == Keys.Right)
{

if (lefttoright)

SelectedIndex++;

}
else if (keyData == Keys.PageUp)

SelectedIndex -= CountPerPage;

else if (keyData == Keys.PageDown)

SelectedIndex += CountPerPage;

else if (keyData == Keys.Escape)

instance.CancelCurrentEdit();

}
return base.ProcessCmdKey(ref msg, keyData);

}

int CountPerPage
{

get
{

return (int)Math.Ceiling((double)scrollpanel.Height / ItemSize.Height);

}

#endregion

#region additional properties

const BorderStyle DefaultBorderStyle = BorderStyle.Fixed3D;
[DefaultValue(DefaultBorderStyle)]
public new BorderStyle BorderStyle
{

get { return base.BorderStyle; }
set { base.BorderStyle = value; }

}

#endregion

#region Navigator

BindingNavigator navigator;

public enum NavigatorStyles
{

None,
Simple,
Extended

}

private NavigatorStyles navstyle;

[Category(NavigatorCategory)]
public NavigatorStyles NavigatorStyle
{

get { return navstyle; }
set
{

if (navstyle == value) return;
ShowNavigator = value != NavigatorStyles.None;
if (ShowNavigator)

ShowFullNavigatorOptions = value == NavigatorStyles.Extended;

}

}
bool ShouldSerializeNavigatorStyle()
{

return navstyle != GetDefaultNavigatorStyle();

}

protected virtual NavigatorStyles GetDefaultNavigatorStyle()
{

return NavigatorStyles.None;

}

[Category(NavigatorCategory)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public bool ShowNavigator
{

get
{

return navigator != null;

}
set
{

if (value == ShowNavigator) return;
if (value)
{

navigator = new BindingNavigator(source);
navigator.DeleteItem.Click += new EventHandler(DeleteItem_Click);
navigator.GripStyle = ToolStripGripStyle.Hidden;

SetNavigatormode(false);

navigator.Width = navigator.Height = 20;

//if (!DesignMode)
Controls.Add(navigator);

navstyle = NavigatorStyles.Simple;

}
else
{

navigator.Dispose();
navigator = null;
navstyle = NavigatorStyles.None;

}

}
bool ShouldSerializeShowNavigator()
{

return GetDefaultNavigatorStyle() != NavigatorStyles.None;

}

[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public BindingNavigator BindingNavigator
{

get { return navigator; }

}

bool showfulloptions;

[Category(NavigatorCategory)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public bool ShowFullNavigatorOptions
{

get { return showfulloptions; }
set
{

if (showfulloptions == value) return;
if (!value && navigator == null)

return;

SetNavigatormode(value);
navstyle = value ? NavigatorStyles.Extended : NavigatorStyles.Simple;

}

}
bool ShouldSerializeShowFullNavigatorOptions()
{

return (GetDefaultNavigatorStyle() == NavigatorStyles.Extended)
!= showfulloptions;

}

private void SetNavigatormode(bool Full)
{

ShowNavigator = true;
showfulloptions = Full;
foreach (ToolStripItem it in navigator.Items)
{

if (it != navigator.AddNewItem && it != navigator.DeleteItem)

it.Visible = Full;

}
if (!dockmanualset)

navigator.Dock = GetDefaultNavigatorDock();

}

DockStyle GetDefaultNavigatorDock()
{

if (ShowFullNavigatorOptions) return DockStyle.Bottom;
return DockStyle.Left;

}

void DeleteItem_Click(object sender, EventArgs e)
{

DeleteItems(GetSelectedItems(selectionversion));

}
bool dockmanualset;
[Category(NavigatorCategory)]
public DockStyle NavigatorLocation
{

get
{

if (!ShowNavigator) return DockStyle.Left;
return navigator.Dock;

}
set
{

ShowNavigator = value != DockStyle.None;
if (!ShowNavigator) return;
if (value == DockStyle.Fill)

value = GetDefaultNavigatorDock();

navigator.Dock = value;
dockmanualset = ShouldSerializeNavigatorLocation();

}

}
bool ShouldSerializeNavigatorLocation()
{

return navigator != null && NavigatorLocation != GetDefaultNavigatorDock();

}

#endregion

#region Delete button

[DefaultValue(false)]
[Category(ItemCategory)]
public bool ShowDeleteButtonPerItem
{

get { return deletebuttonicon != null; }
set
{

if (ShowDeleteButtonPerItem == value) return;
if (value)

DeleteButtonIcon = GetDeleteButtonImage();

else

DeleteButtonIcon = null;

InvalidateMainPanel();

}

void InvalidateMainPanel()
{

#if IncludeDesignTimeSupport

if (DesignMode)
{

SetDesignTimeInstanceSize();
mainpanel.Invalidate();

}
else

#endif

if (!IsInitializing)
{

mainpanel.SetSize();
SetInstanceLocation();
mainpanel.Invalidate();

}

private Icon deletebuttonicon;
[Category(ItemCategory)]
public Icon DeleteButtonIcon
{

get { return deletebuttonicon; }
set
{

deletebuttonicon = value;
mainpanel.Invalidate();

}

}
bool ShouldSerializeDeleteButtonIcon()
{

return deletebuttonicon != null && deletebuttonicon != DefaultDeleteButtonImage;

}

public static Icon DefaultDeleteButtonImage;

static Icon GetDeleteButtonImage()
{

if (DefaultDeleteButtonImage == null)

DefaultDeleteButtonImage = GetIcon(131);

return DefaultDeleteButtonImage;

}

const int DeleteButtonWidth = 16;
Rectangle GetDeleteButtonBounds(int Index)
{

Rectangle res = new Rectangle(

GetItemLeft(Index) + ItemSize.Width + itemPadding.Left + 1,
GetItemTop(Index) + itemPadding.Top,
DeleteButtonWidth, DeleteButtonWidth);

if (lefttoright && DrawInsertButtonsBetweenItems)

res.X += InsertButtonHeight;

return res;

}

#endregion

#region Insert buttons

public enum InsertButtonStyles
{

None,
BeginOnly = 1,
EndOnly = 2,
AfterEachItem = 4 | EndOnly,
BeforeEachItem = 8 | BeginOnly,
BeforeAndAfterEachItem = AfterEachItem | BeforeEachItem

}

private InsertButtonStyles insertbuttonstyle;
[DefaultValue(InsertButtonStyles.None)]
[Category(ItemCategory)]
public InsertButtonStyles InsertButtonStyle
{

get { return insertbuttonstyle; }
set
{

if (insertbuttonstyle == value) return;
insertbuttonstyle = value;
ShowInsertButtons = value != InsertButtonStyles.None;
InvalidateMainPanel();

}

bool DrawInsertButtonsBetweenItems
{

get
{

return ShowInsertButtons && (insertbuttonstyle & InsertButtonStyles.BeforeAndAfterEachItem) > InsertButtonStyles.EndOnly;

}

bool DrawStartInsertButton
{

get
{

return ShowInsertButtons && (insertbuttonstyle & InsertButtonStyles.BeginOnly) > 0;

}

bool DrawEndInsertButton
{

get
{

return (insertbuttonstyle & InsertButtonStyles.EndOnly) > 0;

}

public class InsertItemEventArgs : HandledEventArgs
{

public readonly int Index;
public InsertItemEventArgs(int Index)
{

this.Index = Index;

}

void OnInsertItem(int Index)
{

OnInsertItem(new InsertItemEventArgs(Index));

}

public event EventHandler<InsertItemEventArgs> InsertItem;

protected virtual void OnInsertItem(InsertItemEventArgs e)
{

if (InsertItem != null)
{

InsertItem(this, e);
if (e.Handled) return;

}
source.AddNew();
MoveItem(Count - 1, e.Index);

}

void MoveItem(int Old, int New)
{

if (Old == New) return;
SuspendLayout();
source.SuspendBinding();
object o = source[Old];
source.RemoveAt(Old);
if (New > Old)

New--;

source.Insert(New, o);
source.ResumeBinding();
InvalidateMainPanel();
ResumeLayout();
source.Position = New;

}

[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
[DefaultValue(false)]
[Category(ItemCategory)]
public bool ShowInsertButtons
{

get { return insertbuttonicon != null; }
set
{

if (ShowInsertButtons == value) return;
if (value)
{

insertbuttonicon = GetInsertButtonImage();
if (insertbuttonstyle == InsertButtonStyles.None)

insertbuttonstyle = InsertButtonStyles.BeforeAndAfterEachItem;

}
else

insertbuttonicon = null;

InvalidateMainPanel();

}

private Icon insertbuttonicon;
[Category(ItemCategory)]
public Icon InsertButtonIcon
{

get { return insertbuttonicon; }
set
{

insertbuttonicon = value;
mainpanel.Invalidate();

}

}
bool ShouldSerializeInsertButtonIcon()
{

return insertbuttonicon != null && insertbuttonicon != DefaultInsertButtonImage;

}

public static Icon DefaultInsertButtonImage;

static Icon GetInsertButtonImage()
{

if (DefaultInsertButtonImage == null)
{

Bitmap bmp = new Bitmap(typeof(BindingNavigator), "BindingNavigator.AddNew.bmp");
bmp.MakeTransparent();
DefaultInsertButtonImage = Icon.FromHandle(bmp.GetHicon());

}
return DefaultInsertButtonImage;

}

const int InsertButtonHeight = 16;
Rectangle GetInsertButtonBounds(int Index)
{

Rectangle res = GetNonPaddedItemBounds(Index);

if (lefttoright)
{

res.X = Index == -1 ? 1 : res.Right + 1;
res.Width = InsertButtonHeight;

}
else
{

res.Y = Index == -1 ? 1 : res.Bottom + 1;
res.Height = InsertButtonHeight;

}
return res;

}

#endregion

#region Selection

int selectionversion = 1;

private bool multiselect;
[DefaultValue(false)]
[Category(DataCategory)]
public bool AllowMultiSelect
{

get { return multiselect; }
set
{

if (value == multiselect) return;
multiselect = value;
selectionversion++;

}

void InvalidateSelectionArea(Rectangle itembounds)
{

mainpanel.Invalidate(GetSelectionBounds(itembounds));

}
/// <summary>
/// Gets the bounds that the selection background occupies
/// </summary>
Rectangle GetSelectionBounds(Rectangle itembounds)
{

if (lefttoright)
{

itembounds.Y = 0;
itembounds.X -= itemPadding.Left;
itembounds.Width = GetItemWidth();
itembounds.Height = Height;
itembounds.Inflate(2, 0);

}
else
{

itembounds.X = 0;
itembounds.Y -= ItemPadding.Top;
itembounds.Width = Width;
itembounds.Height = GetItemHeight();
itembounds.Inflate(0, 2);

}
return itembounds;

}

private bool lefttoright;
[DefaultValue(false)]
[Category(BehaviorCategory)]
public bool LeftToRight
{

get { return lefttoright; }
set
{

if (lefttoright == value) return;
lefttoright = value;
selrecimage = null;
if (!DesignMode)
{

mainpanel.Dock = value ? DockStyle.Left : DockStyle.Top;
RefreshItems();

}

#if IncludeDesignTimeSupport

else

SetDesignTimeInstanceSize();

#endif

}

const int SelectButtonWidth = 14;

Bitmap selrecimage;
Bitmap SelectedRecordImage
{

get
{

if (selrecimage == null)
{

CreateSelectRecordImage();

}
return selrecimage;

}

}// = new Bitmap(typeof(BindingNavigator), "BindingNavigator.MoveNext.bmp");

void CreateSelectRecordImage()
{

selrecimage = GetTriangleBitmap(lefttoright, 10, 10, Brushes.LightGray);

}

private bool showselectbuttons = false;
[DefaultValue(false)]
[Category(ItemCategory)]
public bool ShowSelectButtons
{

get { return showselectbuttons; }
set
{

if (showselectbuttons == value) return;
showselectbuttons = value;
ResetItemSize();

}

void InvalidateSelected(int version)
{

for (int i = 0; i < items.Count; i++)
{

if (items[i].SelectedVersion == version)

InvalidateSelectionArea(GetItemBounds(i));

}

void SwitchSelect(int index)
{

int curindex = SelectedIndex;

Item item = GetItem(index);
bool selected = item.SelectedVersion == selectionversion;
if (selected)
{

//deselect
item.SelectedVersion--;
if (index == curindex)
{
}

}
else
{

//select
item.SelectedVersion = selectionversion;

//make sure current item has the proper version
if (curindex != -1)

GetItem(curindex).SelectedVersion = selectionversion;

}

InvalidateSelectionArea(GetItemBounds(index));

}

System.Collections.IEnumerable GetSelectedItems(int selectionversion)
{

int sel = SelectedIndex;
for (int i = 0; i < items.Count; i++)
{

if (i != sel && items[i].SelectedVersion == selectionversion)

yield return source[i];

}

}
public System.Collections.IEnumerable GetSelectedItems()
{

if (source == null)

yield break;

yield return source.Current;
if (multiselect)
{

foreach (object o in GetSelectedItems(selectionversion))
{

yield return o;

}

void DeleteItems(System.Collections.IEnumerable Items)
{

List<object> list = new List<object>((IEnumerable<object>)Items);
foreach (object o in list)
{

source.Remove(o);

}

}
public void DeleteSelectedItems()
{

if (!multiselect)
{

source.RemoveCurrent();

}
else
{

DeleteItems(GetSelectedItems());

}

#endregion

#region DragDrop

[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
[Category(BehaviorCategory)]
public override bool AllowDrop
{

get
{

return mainpanel.AllowDrop;

}
set
{

mainpanel.AllowDrop = value;

}

private bool autodrag;
[Category(BehaviorCategory)]
[DefaultValue(false)]
public bool AutoDrag
{

get { return autodrag; }
set { autodrag = value; }

}

void SetAllowDrop()
{

AllowDrop = allowreorder;

}

private bool allowreorder;
[DefaultValue(false)]
[Category(BehaviorCategory)]
public bool AllowReordering
{

get { return allowreorder; }
set
{

allowreorder = value;
SetAllowDrop();

}

public class DragStartEventArgs : HandledEventArgs
{

public readonly int Index;
public object DragObject;
public DragStartEventArgs(int Index)
{

this.Index = Index;

}

public string DragObjectTypeName
{

get
{

if (DragObject == null) return null;
return DragObject.GetType().FullName;

}

public event EventHandler<DragStartEventArgs> DragStart;

//DragStartEventArgs currentdrag;
void OnDragStart(int Index)
{

if (Index < 0) return;
DragStartEventArgs e = new DragStartEventArgs(Index);
e.DragObject = source.Current;
OnDragStart(e);

}

protected virtual void OnDragStart(DragStartEventArgs e)
{

if (DragStart != null)
{

DragStart(this, e);
if (e.Handled) return;

}
if (e.DragObject != null)
{

DoDragDrop(e.DragObject, DragDropEffects.All);

}

public Type GetItemType()
{

if (source == null) return null;
return ListBindingHelper.GetListItemType(source.DataSource, source.DataMember);

}

int GetIndex(DragEventArgs e)
{

Point p = GetClientPoint(e);
int i = GetIndex(p);
if (i < 0 || i == source.Position) return -1;
float margin;
if (lefttoright)
{

margin = ((float)p.X - GetItemLeft(i)) / GetItemWidth();

}
else
{

margin = ((float)p.Y - GetItemTop(i)) / GetItemHeight();

}
if (margin > .5)

i++;

if (i > Count)

i = Count;

return i;

}

Point GetClientPoint(DragEventArgs e)
{

Point p = new Point(e.X, e.Y);
return mainpanel.PointToClient(p);

}

int? DragInsertIndex;

protected override void OnDragOver(DragEventArgs e)
{

if (e.Data.GetDataPresent(GetItemType()))
{

object o = e.Data.GetData(GetItemType());
if (allowreorder && o == source.Current)
{

int i = GetIndex(e);

if (DragInsertIndex != i)

ClearDragInsertIndex();

if (i != -1)
{

e.Effect = DragDropEffects.Move;
DragInsertIndex = i;
mainpanel.InvalidateDragInsert(i);
return;

}

}
e.Effect = DragDropEffects.None;
base.OnDragOver(e);

}

void ClearDragInsertIndex()
{

if (DragInsertIndex != null)
{

int i = DragInsertIndex.Value;
DragInsertIndex = null;
mainpanel.InvalidateDragInsert(i);

}

protected override void OnDragLeave(EventArgs e)
{

ClearDragInsertIndex();
base.OnDragLeave(e);

}

protected override void OnDragDrop(DragEventArgs e)
{

if (DragInsertIndex != null)
{

MoveItem(source.Position, DragInsertIndex.Value);
ClearDragInsertIndex();

}
base.OnDragDrop(e);

}

#endregion

#region Header

Header header;
[DefaultValue(false)]
[Category(HeaderCategory)]
public bool ShowHeader
{

get { return header != null; }
set
{

if (ShowHeader == value) return;
if (value)
{

InitHeader();

}
else
{

header.Dispose();
header = null;

}

void InitHeader()
{

header = new Header();
header.Height = headerheight;
Controls.Add(header);

#if IncludeDesignTimeSupport

InitHeaderDesigner();

#endif

if (navigator != null)

navigator.SendToBack();

}

const int DefaultHeaderHeight = 30;
private int headerheight = DefaultHeaderHeight;
[Category(HeaderCategory)]
[DefaultValue(DefaultHeaderHeight)]
public int HeaderHeight
{

get { return headerheight; }
set
{

headerheight = value;
if (header != null)

header.Height = value;

}

/// <summary>
/// Direct access to the controls of header portion of the control
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public ControlCollection HeaderControlCollection
{

get
{

if (header == null) return null;
return header.Controls;

}

/// <summary>
/// Meant for the designer serialization for header controls
/// </summary>
[DefaultValue(null)]
[Browsable(false)]
public Control[] HeaderControls
{

get
{

if (header == null) return null;
Control[] ctr = new Control[header.Controls.Count];
for (int i = 0; i < ctr.Length; i++)
{

ctr[i] = header.Controls[i];

}
return ctr;

}
set
{

ShowHeader = value != null && value.Length > 0;
if (ShowHeader)

header.Controls.AddRange(value);

}

#if IncludeDesignTimeSupport

[Designer(typeof(DropOnlyDesigner))]
[System.ComponentModel.Design.Serialization.DesignerSerializer(

#endif

class Header : Panel
{

public Header()
{

Dock = DockStyle.Top;

}

Pen p = Pens.Black;
protected override void OnPaint(PaintEventArgs e)
{

base.OnPaint(e);
int y = Bottom - 1;
e.Graphics.DrawLine(p, 0, y, Width, y);

}

#endregion

#region ISupportInitialize Members

int initializing;
/// <summary>
/// Indicates if the control is inside the initialization state.
/// (in other words, between the BeginInit and EndInit inside the designer generated code)
/// </summary>
protected bool IsInitializing
{

get
{

return initializing > 0;

}

void ISupportInitialize.BeginInit()
{

initializing++;

}

void ISupportInitialize.EndInit()
{

if (--initializing == 0)
{

if (itemsize != null)

ResetItemSize();

ResetList();

}

#endregion

}

public enum ItemSizeMode
{

/// <summary>
/// Default mode: each item has the same size based on the layout of the controls added to it
/// </summary>
Automatic,
/// <summary>
/// The size for each item is variable. The size per item is determined by the layout of the controls
/// </summary>
Variable,
/// <summary>
/// The size for each item is variable. The user can change the size of an item in runtime.
/// </summary>
VariableUserSizable,
/// <summary>
/// Each item is fixed on whatever size is assigned to the ItemSize property
/// </summary>
Fixed

}

}

#region Design time support (needs a reference to System.Design)

//this part contains the functionality for design time support
//if wanted this part could be omitted in final distrubution code
//(wouldn't bother to myself, but perhaps it is needed in the future
// for compact framework distrubution or the likes)
#if IncludeDesignTimeSupport

namespace Subro.Controls
{

using System.ComponentModel.Design;
using System.Windows.Forms.Design;
using System.Windows.Forms.Design.Behavior;

partial class ContinuousControl
{

#region designer

void SetDesignTimeInstanceSize()
{

/*
instance.Left = GetItemLeft(0);
instance.Width = scrollpanel.Width - instance.Left;
instance.Height = scrollpanel.Height;*/
instance.Location = GetDesignerOffset();
instance.Width = scrollpanel.Width - instance.Left;
instance.Height = scrollpanel.Height - instance.Top;
instance.Invalidate();

}

void InitDesignEnvironment()
{

mainpanel.Dock = DockStyle.Fill;
instance.Dock = DockStyle.None;
instance.Anchor = AnchorStyles.Left | AnchorStyles.Right | AnchorStyles.Top | AnchorStyles.Bottom;
SetDesignTimeInstanceSize();

}

void InitHeaderDesigner()
{

if (Site == null) return;
INestedContainer cont = (INestedContainer)GetService(typeof(INestedContainer));
if (cont != null)

cont.Add(header, "Header");

}

class ContinuousControlDesigner : ControlDesigner
{

public override void Initialize(IComponent component)
{

ContinuousControl cc = (component as ContinuousControl);
if (component.GetType() == typeof(ContinuousControl))

cc.Init(); //for inheriting controls, Init allready is done in the constructor

base.Initialize(component);

if (!EnableDesignMode(cc.instance, "Controls"))

MessageBox.Show("Could not create child designer");

//designercontrols = new List<Control>(cc.GetDesignerControls());

IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost));
foreach (Control dc in cc.GetDesignerControls())
{

IDesigner id = host.GetDesigner(dc);
if (id == null)
{

EnableDesignMode(dc, dc.Name);

}

}
class ContinuousControlDocumentDesigner : DocumentDesigner
{

public override void Initialize(IComponent component)
{

ContinuousControl cc = component as ContinuousControl;
cc._Instance = cc.instance;
base.Initialize(component);
cc._Instance = null;

}

/// <summary>
/// inheriting classes can override this function to add any
/// controls that should be exposed to the designer this control
/// is dropped on
/// </summary>
/// <returns></returns>
protected virtual IEnumerable<Control> GetDesignerControls()
{

yield break;

}

class DropOnlyDesigner : ParentControlDesigner
{

protected virtual ContinuousControl Owner
{

get
{

return Control.Parent as ContinuousControl;

}

protected override void PreFilterProperties(System.Collections.IDictionary properties)
{

PropertyDescriptor pdo = (PropertyDescriptor)properties["Owner"];
if (pdo == null)

pdo = (PropertyDescriptor)properties["Parent"];

properties.Clear();

properties.Add("Owner", pdo);

}

public override GlyphCollection GetGlyphs(GlyphSelectionType selectionType)
{

GlyphCollection coll = base.GetGlyphs(selectionType);
if (selectionType == GlyphSelectionType.SelectedPrimary)
{

coll.Add(CreateGlyph(Owner));

}
return coll;

}

#region select owner glyph

SelectParentGlyph CreateGlyph()
{

return CreateGlyph(Control.Parent);

}
SelectParentGlyph CreateGlyph(Control ParentControl)
{

Rectangle r = BehaviorService.ControlRectInAdornerWindow(ParentControl);
r.X = r.Right;
r.Width = 30;
return new SelectParentGlyph(r, ParentControl);

}

class SelectParentGlyph : Glyph
{

SelectParentBehavior beh;
public readonly Control Owner;
Rectangle bounds;
public SelectParentGlyph(Rectangle rect, Control Owner)

: base(new SelectParentBehavior())

{

beh = Behavior as SelectParentBehavior;
this.Owner = Owner;
this.bounds = rect;

}

public override Cursor GetHitTest(Point p)
{

if (bounds.Contains(p))

return Cursors.Hand;

return null;

}

public override void Paint(PaintEventArgs pe)
{

if (textsize == null)
{

SizeF size = pe.Graphics.MeasureString(Text, font, bounds.Width, sf);
textsize = Size.Ceiling(size);
bounds.Size = textsize.Value;

}
pe.Graphics.DrawRectangle(Pens.Black, bounds);
pe.Graphics.DrawString(Text, font, Brushes.Black, Bounds, sf);

}

Size? textsize;
string Text = "Select Owner";
StringFormat sf = new StringFormat(StringFormatFlags.DirectionVertical);
Font font = new Font(FontFamily.GenericSansSerif, 7);

public override Rectangle Bounds
{

get
{

return bounds;

}

protected void SelectParent()
{

try
{

IServiceProvider provider = Owner.Site;
if (provider == null) throw new Exception(Owner.Name + " does not contain a service provider");
ISelectionService sel = (ISelectionService)provider.GetService(typeof(ISelectionService));
sel.SetSelectedComponents(new Control[] { Owner }, SelectionTypes.Primary);

}
catch (Exception ex)
{

MessageBox.Show(ex.Message);

}

protected class SelectParentBehavior : Behavior
{

public override bool OnMouseDown(Glyph g, MouseButtons button, Point mouseLoc)
{

SelectParentGlyph sog = g as SelectParentGlyph;
if (sog == null)

return base.OnMouseDown(g, button, mouseLoc);

sog.SelectParent();
return false;

}

#endregion

}

class InstanceDesigner : DropOnlyDesigner
{

new ControlInstance Control
{

get
{

return base.Control as ControlInstance;

}

protected override ContinuousControl Owner
{

get { return Control.owner; }

}

DesignerVerb selectowner;
ISelectionService selservice;
public override void Initialize(IComponent component)
{

base.Initialize(component);
Owner.InitDesignEnvironment();

if (selectowner == null)
{

selectowner = new DesignerVerb("Select owner", new EventHandler(SelectOwner));
Verbs.Add(selectowner);
selservice = (ISelectionService)GetService(typeof(ISelectionService));

}

void DeleteOwner(object sender, EventArgs e)
{

Host.DestroyComponent(Owner);

}
void SelectOwner(object sender, EventArgs e)
{

SelectOwner();

}
void SelectOwner()
{

selservice.SetSelectedComponents(new IComponent[] { Owner }, SelectionTypes.Primary);

}

protected override Control GetParentForComponent(IComponent component)
{

return Owner;

}

IDesignerHost host;
IDesignerHost Host
{

get
{

if (host == null)

host = (IDesignerHost)GetService(typeof(IDesignerHost));

return host;

}

protected override void PreFilterAttributes(System.Collections.IDictionary attributes)
{

foreach (object var in attributes)
{

}
base.PreFilterAttributes(attributes);

}

protected override void OnPaintAdornments(PaintEventArgs pe)
{

base.OnPaintAdornments(pe);

if (Control == null) return;

pe.Graphics.FillRectangle(

new SolidBrush(Owner.scrollpanel.BackColor),
Control.ClientRectangle);

Point p = Owner.GetDesignerOffset();
pe.Graphics.TranslateTransform(-p.X, -p.Y);

Rectangle bounds = Owner.GetNonPaddedItemBounds(0);

pe.Graphics.FillRectangle(

new SolidBrush(Control.BackColor),
bounds);

Owner.mainpanel.Paint(pe.Graphics);

}

Point GetDesignerOffset()
{

Rectangle r = GetNonPaddedItemBounds(0);
return r.Location;

}

#endregion

}

}

#endif

#endregion

LabelProvider

Robert Verpalen — Thu, 01 Jun 2006 04:33:00 GMT

For the description of most controls we use labels and I for one don't like to add a label manually for each control. Been using a component that paints values, but never got around to put it in a nice coat and with design time support up until now. The design time being the most work (although greatly alleviated by finding out how to use the isComplete parameter of the InstanceDescriptor ;-) ), the component is easy in use and deployment.
Usage: drop it to your form (or container control) and you get a new property on each control (”Label on LabelProviderName”).
You can simply type in the labeltext and a label will be painted on its parent.

To set more details, when the text is set a LabelInfo object will be created automatically. A plus sign appears in front of the property once it has been set, to indicate it can be expanded. Other properties for the label such as the Alignment, Font and Color can then be set.
To make things complete, the LabelProvider component itself also contains a set of those properties. This is the leading set. Unless a property is set specifically for a single label, the settings of the main component will be used for all labels. (The effects can be easily tried out in the designer)

Per request some quick setup instructions:
Usage
Add this code to your project (or a dll containing this code). The component will automatically show up in the visual studio 2005 toolbox. Drag the LabelProvider to your form or control in the form designer.
Now each control you select will have an additional property: ”Label on ...”, where ... is the name of the component. The text you type in in this property, will become the label for that control.

That's it for the normal label usage. For more settings, you can change the settings on the component itself. Or you can change the settings per label: press the [+] in front of the “Label on ...“ property for additional settings

Added per 22-9-6:
ability to show icon (or show only icon, then a tooltip will be shown for the text, thus the labelprovider becomes an infoprovider)
Changable cursor
Click event
Blinking possibility

Small thing added on 19-10-6:
text is drawn as disabled if the attached control is disabled

Code CopyHideScrollFull

using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.ComponentModel.Design.Serialization;
using System.Drawing;
using System.Drawing.Design;
using System.Windows.Forms;
using System.Windows.Forms.Design;
using System.Reflection;

namespace Subro.Controls
{

[ProvideProperty("Label", typeof(Control))]
[ToolboxBitmap(typeof(Label))]
[DefaultEvent("LabelClicked")]
public class LabelProvider : Component, IExtenderProvider
{

#region Constructors
public LabelProvider()

: this(null)

{
}
public LabelProvider(IContainer container)
{

if (container != null)

container.Add(this);

defsettings.SettingChanged += new EventHandler(defsettings_SettingChanged);

}
#endregion
#region IExtenderProvider Members
public bool CanExtend(object extendee)
{

return extendee is Control;

}

int IndexOf(Control c)
{

for (int i = 0; i < list.Count; i++)
{

if (list[i].Control == c) return i;

}
return -1;

}
[DefaultValue(null)]
public LabelInfo GetLabel(Control c)
{

int i = IndexOf(c);
if (i == -1)
{

return null;

}
return list[i].LabelInfo;

}

public void SetLabel(Control c, LabelInfo value)
{

int i = IndexOf(c);
if (value == null)
{

if (i == -1) return;
list[i].Dispose();
list.RemoveAt(i);

}
else if (i == -1)
{

list.Add(new ControlLabel(this, c, value));

}
else
{

list[i].LabelInfo = value;

}

public class LabelClickedEventArgs : EventArgs
{

public readonly Control Control;
public readonly LabelInfo LabelInfo;
public LabelClickedEventArgs(Control c, LabelInfo inf)
{

this.Control = c;
this.LabelInfo = inf;

}

public event EventHandler<LabelClickedEventArgs> LabelClicked;

void OnLabelClicked(ControlLabel l)
{

if (LabelClicked != null)

LabelClicked(this, new LabelClickedEventArgs(l.Control, l.LabelInfo));

}

class ControlLabel : IDisposable
{

public readonly Control Control;

LabelProvider Owner;
public ControlLabel(LabelProvider Owner, Control c, LabelInfo li)
{

if (c == null) throw new ArgumentNullException();
this.Control = c;
this.LabelInfo = li;
this.Owner = Owner;
li.DefaultSettings = Owner.defsettings;
ResetParent();
Control.ParentChanged += ehParentChanged;
Control.LocationChanged += ehLocationChanged;
Control.EnabledChanged += new EventHandler(Control_EnabledChanged);

}

#region enter/leave

bool focused, cursorchanged;
public bool Focused
{

get { return focused; }

}

Control ParentControl
{

get { return Parent.Parent; }

}
Cursor beforeEnter;
public void CheckEnterLeave(Point p)
{

CheckEnterLeave(bounds.Contains(p));

}
void CheckEnterLeave(bool hasfocus)
{

if (hasfocus != focused)
{

if (hasfocus)
{

if (inf.Cursor != null && inf.Cursor != ParentControl.Cursor)
{

beforeEnter = ParentControl.Cursor;
ParentControl.Cursor = inf.Cursor;
cursorchanged = true;

}
if (!inf.ShowText)

Parent.ShowTooltip(this, new Point((int)bounds.Right,(int)bounds.Top));

}
else
{

if (cursorchanged)
{

ParentControl.Cursor = beforeEnter;
cursorchanged = false;

}
Parent.RemoveTooltip(this);

}
focused = hasfocus;

}

public void Click()
{

Owner.OnLabelClicked(this);

}

#endregion
#region label
LabelInfo inf;
public LabelInfo LabelInfo
{

get
{

return inf;

}
set
{

RemoveInfoEvents();
inf = value;
if (inf != null)

inf.SettingChanged += ehSettingChanged;

Invalidate(true);

}

}
void LabelInfo_SettingChanged(object sender, EventArgs e)
{

Invalidate(true);

}
void Control_EnabledChanged(object sender, EventArgs e)
{

Invalidate(false);

}
EventHandler ehSettingChanged
{

get
{

return new EventHandler(LabelInfo_SettingChanged);

}

}
void RemoveInfoEvents()
{

if (inf != null)
{

inf.SettingChanged -= ehSettingChanged;

}

RectangleF bounds;
void Invalidate(bool ClearBounds)
{

if (ClearBounds)
{

if (!bounds.IsEmpty) bounds = new RectangleF();
StopBlink();

}
if (Parent != null)

Parent.Invalidate(this);

}

public bool BoundsSet
{

get { return !bounds.IsEmpty; }

}

public RectangleF Bounds
{

get { return bounds; }

}
#endregion

#region label bounds
public bool ContainsLabel
{

get
{

return inf != null &&

(!string.IsNullOrEmpty(inf.Text) || inf.ShowIcon);

}

}
public void Paint(Graphics g)
{

if (!ContainsLabel) return;
if (bounds.IsEmpty) InitBounds(g);
if (blinker != null && blinker.ShouldHide) return;
inf.Paint(g, bounds,this.Control.Enabled);

}
void InitBounds(Graphics g)
{

bounds = inf.GetBounds(g, Control.Bounds);
InitBlink(inf.Blink);

}

private void InitBlink(LabelInfo.BlinkInfo blinkInfo)
{

if (blinkInfo == null || blinkInfo.Style == BlinkStyle.None || blinkInfo.Rate == 0) return;
blinker = new Blinker(blinkInfo, this);

}

void StopBlink()
{

if (blinker != null)
{

blinker.Stop();
blinker = null;

}

}
Blinker blinker;
class Blinker
{

bool hide;
LabelInfo.BlinkInfo inf;

ControlLabel Owner;
DateTime start = DateTime.Now;
bool hasend;
DateTime end;
public Blinker(LabelInfo.BlinkInfo inf, ControlLabel Owner)
{

this.inf = inf;
this.Owner = Owner;
hasend = inf.Style == BlinkStyle.LimitedTime && inf.Duration > 0;
if (hasend) end = start.AddMilliseconds(inf.Duration);
SetTimer();

}

System.Threading.Timer timer;

public bool ShouldHide
{

get { return hide; }

}

void Invalidate()
{

if (Owner.Control.InvokeRequired)

Owner.Control.Invoke(new System.Threading.ThreadStart(Invalidate));

else

Owner.Invalidate(false);

}
void SwitchHide(object state)
{

if (hasend && DateTime.Now >= end)

Stop();

else if (!stopped)
{

hide = !hide;
Invalidate();

}

void SetTimer()
{

timer =

new System.Threading.Timer(
new System.Threading.TimerCallback(SwitchHide),

null, inf.Rate, inf.Rate);

}

bool stopped;
public void Stop()
{

stopped = true;
if (hide)
{

hide = false;
Invalidate();

}
//timer.Dispose();
//timer = null;

}

}
#endregion
#region location changed

void Control_LocationChanged(object sender, EventArgs e)
{

Invalidate(true);

}
EventHandler ehLocationChanged
{

get { return new EventHandler(Control_LocationChanged); }

}
#endregion
#region Parent
ParentReference Parent;
void RemoveFromParent()
{

if (Parent != null)
{

Parent.Remove(this);

}

}
void ResetParent()
{

RemoveFromParent();
Parent = Owner.GetParentReference(this);

}
void Control_ParentChanged(object sender, EventArgs e)
{

ResetParent();

}
EventHandler ehParentChanged
{

get
{

return new EventHandler(Control_ParentChanged);

}

}
#endregion
#region IDisposable Members

bool isdisposed;
public bool IsDisposed { get { return isdisposed; } }

public void Dispose()
{

Control.ParentChanged -= ehParentChanged;
Control.LocationChanged -= ehLocationChanged;
Control.EnabledChanged -= new EventHandler(Control_EnabledChanged);
RemoveInfoEvents();
RemoveFromParent();
CheckEnterLeave(false);
isdisposed = true;

}
#endregion

}
List<ParentReference> parents = new List<ParentReference>();
ParentReference GetParentReference(ControlLabel cl)
{

Control Parent = cl.Control.Parent;
if (Parent == null) return null;
ParentReference pr = null;
for (int i = 0; i < parents.Count; i++)
{

if (parents[i].Parent == Parent)
{

pr = parents[i];
break;

}

}
if (pr == null)
{

pr = new ParentReference(Parent, this);
parents.Add(pr);

}
pr.Add(cl);
return pr;

}
class ParentReference
{

public Control Parent;
LabelProvider Owner;
public ParentReference(Control Parent, LabelProvider Owner)
{

this.Parent = Parent;
this.Parent.Paint += ehPaint;
this.Owner = Owner;
Parent.MouseMove += new MouseEventHandler(Parent_MouseMove);
Parent.MouseLeave += new EventHandler(Parent_MouseLeave);
Parent.Click += new EventHandler(Parent_Click);

}

#region focus
void Parent_MouseMove(object sender, MouseEventArgs e)
{

CheckBounds();

}
void Parent_MouseLeave(object sender, EventArgs e)
{

CheckBounds();

}
void CheckBounds()
{

Point p = Parent.PointToClient(Control.MousePosition);
foreach (ControlLabel c in children)
{

c.CheckEnterLeave(p);

}

}
void Parent_Click(object sender, EventArgs e)
{

foreach (ControlLabel c in GetFocusedControls())
{

c.Click();

}

IEnumerable<ControlLabel> GetFocusedControls()
{

for (int i = 0; i < children.Count; i++)
{

ControlLabel c = children[i];
if (!c.IsDisposed && c.Focused) yield return c;
if (c.IsDisposed) i--;

}

}
#endregion

#region Paint
PaintEventHandler ehPaint
{

get
{

return new PaintEventHandler(Parent_Paint);

}

}
void Parent_Paint(object sender, PaintEventArgs e)
{

foreach (ControlLabel cl in children)
{

cl.Paint(e.Graphics);

}

}
public void Invalidate(ControlLabel cl)
{

if (cl.BoundsSet)

Parent.Invalidate(new Region(cl.Bounds));

else

Invalidate();

}
/// <summary>
/// Invalidates all current labels
///
public void Invalidate()
{

Region r = new Region();
foreach (ControlLabel cl in children)
{

if (cl.BoundsSet)
{

r.Union(cl.Bounds);

}
else
{

Parent.Invalidate();
return;

}

}
Parent.Invalidate(r);

}

#endregion

#region Children

List<ControlLabel> children = new List<ControlLabel>();
public void Add(ControlLabel cl)
{

children.Add(cl);
Invalidate(cl);

}
public void Remove(ControlLabel cl)
{

children.Remove(cl);
Invalidate(cl);
if (children.Count == 0)
{

Dispose();

}

#endregion

#region tooltip
ToolTip tt;

public void ShowTooltip(ControlLabel c, Point p)
{

if (tt == null)
{

tt = new ToolTip();
tt.ShowAlways = true;

}

tt.Show(c.LabelInfo.Text, Parent, p.X, p.Y, 5000);
//tt.SetToolTip(c.Control, c.LabelInfo.Text);

}
public void RemoveTooltip(ControlLabel c)
{

if (tt == null) return;
tt.Hide(Parent);
//tt.SetToolTip(c.Control, null);

}

#endregion
public void Dispose()
{

Parent.Paint -= ehPaint;
Parent.MouseMove -= new MouseEventHandler(Parent_MouseMove);
Parent.MouseLeave -= new EventHandler(Parent_MouseLeave);
Parent.Click -= new EventHandler(Parent_Click);
Owner.parents.Remove(this);
if (tt != null)
{

tt.Dispose();
tt = null;

}

List<ControlLabel> list = new List<ControlLabel>();

#endregion
#region Default settings
private LabelInfo defsettings = new LabelInfo(null);
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public LabelInfo DefaultSettings
{

get { return defsettings; }

}
void defsettings_SettingChanged(object sender, EventArgs e)
{

foreach (ParentReference p in parents)
{

p.Invalidate();

}

}
public override ISite Site
{

get
{

return base.Site;

}
set
{

defsettings.DesignTime = value != null && value.DesignMode;
base.Site = value;

}

}
#endregion
#region Designer
public class LabelLayoutEditor : UITypeEditor
{

public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
{

return UITypeEditorEditStyle.DropDown;

}
IWindowsFormsEditorService iw;
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{

iw = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
LayoutPicker f = new LayoutPicker();
if (value != null)

f.Result = (LabelLayout)value;

if (context.Instance is LabelInfo)
{

LabelInfo inf = context.Instance as LabelInfo;
if (inf.DefaultSettings != null && inf.DefaultSettings.Layout != LabelLayout.NotSet)
{

f.RevertValue = inf.DefaultSettings.Layout;

}

}
f.TablePanel.LayoutChosen += new EventHandler<LayoutPicker.LayoutPickerTable.LayoutChosenEventArgs>(TablePanel_LayoutChosen);
iw.DropDownControl(f);

return f.Result;

}
void TablePanel_LayoutChosen(object sender, LayoutPicker.LayoutPickerTable.LayoutChosenEventArgs e)
{

iw.CloseDropDown();

}

}
#endregion

}
[TypeConverter(typeof(LabelInfo.LabelInfoConverter))]
public class LabelInfo
{

#region Constructor
public LabelInfo(string Text)
{

this.Text = Text;
Init();

}
#endregion
#region setings
enum LabelInfoSettings
{

Font, Padding, Layout, ForeColor, BackColor, Icon, ShowIcon, ShowText, Cursor, BlinkStyle, BlinkRate, BlinkDuration

}
object[] settings;
void Init()
{

Array arr = Enum.GetValues(typeof(LabelInfoSettings));
settings = new object[arr.Length];

}

bool designtime;
internal bool DesignTime
{

get
{

if (owner != null) return owner.DesignTime;
return designtime;

}
set
{

if (designtime == value) return;
designtime = value;
if (designtime)
{

if (blink == null)

blink = new BlinkInfo(this);

}

}
object GetSetting(LabelInfoSettings setting)
{

int i = (int)setting;
if (settings[i] == null)
{

if (owner != null)

return owner.GetSetting(setting);

return GetDefaultSetting(setting);

}
return settings[i];

}

T GetSetting<T>(LabelInfoSettings setting)
{

object o = GetSetting(setting);
if (IsNullValue(setting, o))

return GetDefaultSetting<T>(setting);

return (T)o;

}
object GetDefaultSetting(LabelInfoSettings setting)
{

switch (setting)
{

case LabelInfoSettings.Font:

return DefaultFont;

case LabelInfoSettings.Padding:

return 5;

case LabelInfoSettings.Layout:

return LabelLayout.Default;

case LabelInfoSettings.ForeColor:

return Color.Black;

case LabelInfoSettings.BackColor:

return Color.Empty;

case LabelInfoSettings.Icon:

return DefaultIcon;

case LabelInfoSettings.ShowIcon:

return false;

case LabelInfoSettings.ShowText:

return true;

case LabelInfoSettings.BlinkDuration:

return 5000;

case LabelInfoSettings.BlinkRate:

return 500;

case LabelInfoSettings.BlinkStyle:

return BlinkStyle.None;

}
return null;

}
T GetDefaultSetting<T>(LabelInfoSettings setting)
{

return (T)GetDefaultSetting(setting);

}
bool IsNullValue(LabelInfoSettings setting, object value)
{

if (value == null) return true;
if (value is ValueType)
{

if (setting == LabelInfoSettings.Layout)

return (LabelLayout)value == LabelLayout.NotSet;

if (value is Color)

return ((Color)value).IsEmpty;

if (value is bool)

return false;

return (int)Convert.ChangeType(value, typeof(int)) == 0;

}
return false;

}
bool HasSetting(LabelInfoSettings setting)
{

return settings[(int)setting] != null;

}
void SetSetting(LabelInfoSettings setting, object value)
{

object cur = GetSetting(setting);
if (IsNullValue(setting, value))
{

if (cur == null) return;
value = null;

}
else if (value.Equals(cur))

return;

settings[(int)setting] = value;
OnSettingChanged();

}
void ResetSetting(LabelInfoSettings setting)
{

settings[(int)setting] = owner == null ? GetDefaultSetting(setting) : null;

}
bool ShouldSerializeSetting(LabelInfoSettings setting)
{

object o = settings[(int)setting];
return !IsNullValue(setting, o);

}

public event EventHandler SettingChanged;
void OnSettingChanged()
{

if (SettingChanged != null)

SettingChanged(this, EventArgs.Empty);

}
#endregion

#region Text
private string text;
[NotifyParentProperty(true)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public string Text
{

get { return text; }
set
{

if (value != null && value.Trim().Length == 0)

text = null;

else

text = value;

if (TextChanged != null)

TextChanged(this, EventArgs.Empty);

OnSettingChanged();

}

}
public override string ToString()
{

return text;

}
public event EventHandler TextChanged;
#endregion
#region Layout
[AmbientValue(LabelLayout.NotSet)]
public LabelLayout Layout
{

get
{

return GetSetting<LabelLayout>(LabelInfoSettings.Layout);

}
set
{

SetSetting(LabelInfoSettings.Layout, value);

}

bool ShouldSerializeLayout()
{

return ShouldSerializeSetting(LabelInfoSettings.Layout);

}

#endregion
#region Color
/// <summary>
/// The font color. NB: setting this value will overwrite the <see cref="ForeBrush"/> setting
///
[AmbientValue(typeof(Color), "Empty")]
public Color Color
{

get
{

return GetSetting<Color>(LabelInfoSettings.ForeColor);

}
set
{

SetSetting(LabelInfoSettings.ForeColor, value);
brush = null;

}

}
bool ShouldSerializeColor()
{

return ShouldSerializeSetting(LabelInfoSettings.ForeColor);

}
void ResetColor()
{

ResetSetting(LabelInfoSettings.ForeColor);

}

[AmbientValue(typeof(Color), "Empty")]
public Color BackColor
{

get
{

return GetSetting<Color>(LabelInfoSettings.BackColor);

}
set
{

SetSetting(LabelInfoSettings.BackColor, value);
backbrush = null;

}

}
bool ShouldSerializeBackColor()
{

return ShouldSerializeSetting(LabelInfoSettings.BackColor);

}
void ResetBackColor()
{

ResetSetting(LabelInfoSettings.BackColor);

}
#endregion
#region Brush

private Brush brush, backbrush;
/// <summary>
/// In designtime, a solidbrush can be set through a color picker, but in runtime, the more advanced
/// brushes can be set as well
///
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
[AmbientValue(null)]
public Brush ForeBrush
{

get
{

if (brush == null)
{

if (owner == null)

brush = new SolidBrush(Color);

else

return owner.ForeBrush;

}
return brush;

}
set
{

brush = value;
OnSettingChanged();

}

}
Brush GetForeBrush()
{

if (brush != null)

return brush;

if (HasSetting(LabelInfoSettings.ForeColor))

return new SolidBrush(Color);

return ForeBrush;

}
/// <summary>
/// In designtime, a solidbrush can be set through a color picker, but in runtime, the more advanced
/// brushes can be set as well
///
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
[AmbientValue(null)]
public Brush BackBrush
{

get
{

if (backbrush == null && owner != null)

return owner.BackBrush;

return backbrush;

}
set
{

backbrush = value;
OnSettingChanged();

}

}
Brush GetBackBrush()
{

if (backbrush != null)

return backbrush;

if (HasSetting(LabelInfoSettings.BackColor))

return new SolidBrush(BackColor);

if (owner != null)

return owner.GetBackBrush();

return BackBrush;

}
#endregion
#region Bounds

static bool HasLayout(LabelLayout layoutFlags, LabelLayout CheckBit)
{

return (layoutFlags & CheckBit) == CheckBit;

}
const int IconPadding = 0;
public void Paint(Graphics g, RectangleF rect,bool Enabled)
{

Brush b = GetBackBrush();
if (b != null)

g.FillRectangle(b, rect);

if (ShowIcon)
{

Point p = new Point((int)rect.X, (int)(rect.Y + (rect.Height - Icon.Height) * .5));
if(Enabled)

g.DrawIcon(Icon, p.X, p.Y);

else

ControlPaint.DrawImageDisabled(g, Icon.ToBitmap(), p.X, p.Y, Color.Empty);

rect.Offset(Icon.Width + IconPadding, 0);

}
if (ShowText)
{

if (Enabled)

g.DrawString(text, Font, GetForeBrush(), rect);

else

ControlPaint.DrawStringDisabled(g, text, Font, Color.LightGray, rect, null);

}

/// <summary>
/// Calculates where the label should be situated on its parent
///
/// <param name="g">
/// <returns>
public RectangleF GetBounds(Graphics g, Rectangle RelateTo)
{

SizeF

sizeI = ShowIcon ? Icon.Size : new SizeF(),
size = ShowText ? g.MeasureString(text, Font) : new SizeF();

if (!sizeI.IsEmpty)
{

if (size.IsEmpty)

size = sizeI;

else
{

size.Width += IconPadding + sizeI.Width;
if (sizeI.Height > size.Height) size.Height = sizeI.Height;

}

return GetBounds(size, RelateTo, Padding, Layout);

}
public static RectangleF GetBounds(SizeF size, Rectangle RelateTo, int padding, LabelLayout layout)
{

PointF pf = RelateTo.Location;
int
h = RelateTo.Height,
w = RelateTo.Width;
if (HasLayout(layout, LabelLayout.Left))

pf.X -= padding + size.Width;

else if (HasLayout(layout, LabelLayout.Right))

pf.X += padding + w;

else if (HasLayout(layout, LabelLayout.Center))

pf.X += (w - size.Width) / 2;

else if (HasLayout(layout, LabelLayout.RightFromCenter))

pf.X += w - size.Width;

if (HasLayout(layout, LabelLayout.Top))

pf.Y -= padding + size.Height;

else if (HasLayout(layout, LabelLayout.Bottom))

pf.Y += h + padding;

else if (HasLayout(layout, LabelLayout.Middle))

pf.Y += (h - size.Height) / 2;

else if (HasLayout(layout, LabelLayout.UnderMiddle))

pf.Y += h - size.Height;

return new RectangleF(pf, size);

}
public static void PaintSymbol(Graphics g, Rectangle bounds, LabelLayout Layout)
{

float perc = .50f;
RectangleF rect = bounds;
rect.Width *= perc;
rect.Height *= perc;
rect.X = (bounds.Width - rect.Width) / 2;
rect.Y = (bounds.Height - rect.Height) / 2;
int PenWidth = 2;
Rectangle r = Rectangle.Round(rect);
g.DrawRectangle(new Pen(Color.Navy, PenWidth), r);
SizeF size = rect.Size;
perc = .3f;
size.Width *= perc;
size.Height *= perc;
rect = LabelInfo.GetBounds(size, r, PenWidth + 1, Layout);
r = Rectangle.Round(rect);
g.DrawRectangle(new Pen(Color.YellowGreen, PenWidth), r);

}
#endregion
#region defaults
private LabelInfo owner;
/// <summary>
/// For design time support, the owner is set to determine the defaults
///
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public LabelInfo DefaultSettings
{

get { return owner; }
set { owner = value; }

}
#endregion
#region Font
static Font DefaultFont = new Font("Times New Roman", 10);
[AmbientValue(null)]
public Font Font
{

get
{

return GetSetting(LabelInfoSettings.Font);

}
set
{

SetSetting(LabelInfoSettings.Font, value);

}

}
bool ShouldSerializeFont()
{

return ShouldSerializeSetting(LabelInfoSettings.Font);

}
void ResetFont()
{

ResetSetting(LabelInfoSettings.Font);

}
#endregion
#region Cursor

[AmbientValue(null)]
public Cursor Cursor
{

get
{

return GetSetting<Cursor>(LabelInfoSettings.Cursor);

}
set
{

SetSetting(LabelInfoSettings.Cursor, value);

}

}
bool ShouldSerializeCursor()
{

return ShouldSerializeSetting(LabelInfoSettings.Cursor);

}
void ResetCursor()
{

ResetSetting(LabelInfoSettings.Cursor);

}
#endregion
#region Padding
/// <summary>
/// The amount of space that should exist between the end of the text and the control
///
[AmbientValue(-1)]
public int Padding
{

get
{

return GetSetting<int>(LabelInfoSettings.Padding);

}
set
{

SetSetting(LabelInfoSettings.Padding, value);

}

}
bool ShouldSerializePadding()
{

return ShouldSerializeSetting(LabelInfoSettings.Padding);

}
void ResetPadding()
{

ResetSetting(LabelInfoSettings.Padding);

}
#endregion
#region Icon
[System.Runtime.InteropServices.DllImport("shell32.dll")]
extern static IntPtr ExtractIcon(int hInst, string lpszExeFileName, int nIconIndex);
static Icon GetIcon(int index)
{

//IntPtr handle = ExtractIcon(0, "user32.dll", index);
IntPtr handle = ExtractIcon(0, "shell32.dll", index);
Icon ic = Icon.FromHandle(handle);
Bitmap bmp = new Bitmap(16, 16);
Graphics.FromImage(bmp).DrawIcon(ic, new Rectangle(0, 0, bmp.Width, bmp.Height));
return Icon.FromHandle(bmp.GetHicon());

}
static Icon DefaultIcon = GetIcon(73);

[AmbientValue(null)]
public Icon Icon
{

get
{

return GetSetting<Icon>(LabelInfoSettings.Icon);

}
set
{

SetSetting(LabelInfoSettings.Icon, value);

}

}
bool ShouldSerializeIcon()
{

return ShouldSerializeSetting(LabelInfoSettings.Icon);

}
void ResetIcon()
{

ResetSetting(LabelInfoSettings.Icon);

}
#endregion
#region ShowIcon
[AmbientValue(false)]
public bool ShowIcon
{

get
{

return GetSetting<bool>(LabelInfoSettings.ShowIcon);

}
set
{

SetSetting(LabelInfoSettings.ShowIcon, value);

}

}
bool ShouldSerializeShowIcon()
{

return ShouldSerializeSetting(LabelInfoSettings.ShowIcon);

}
void ResetShowIcon()
{

ResetSetting(LabelInfoSettings.ShowIcon);

}
#endregion
#region ShowText
[AmbientValue(true)]
public bool ShowText
{

get
{

return GetSetting<bool>(LabelInfoSettings.ShowText);

}
set
{

SetSetting(LabelInfoSettings.ShowText, value);

}

}
bool ShouldSerializeShowText()
{

return ShouldSerializeSetting(LabelInfoSettings.ShowText);

}
void ResetShowText()
{

ResetSetting(LabelInfoSettings.ShowText);

}
#endregion
#region Blink

BlinkInfo blink;
[AmbientValue(null)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public BlinkInfo Blink
{

get
{

if (blink == null)
{

blink = new BlinkInfo(this);

}
return blink;

}

}
bool ShouldSerializeBlink()
{

return

ShouldSerializeSetting(LabelInfoSettings.BlinkStyle)
|| ShouldSerializeSetting(LabelInfoSettings.BlinkRate)
|| ShouldSerializeSetting(LabelInfoSettings.BlinkDuration);

}

[AmbientValue(null)]
[TypeConverter(typeof(ExpandableObjectConverter))]
public class BlinkInfo
{

public readonly LabelInfo Owner;
public BlinkInfo(LabelInfo Owner)
{

this.Owner = Owner;

}

#region Style
[AmbientValue(true)]
public BlinkStyle Style
{

get
{

return Owner.GetSetting<BlinkStyle>(LabelInfoSettings.BlinkStyle);

}
set
{

Owner.SetSetting(LabelInfoSettings.BlinkStyle, value);

}

}
bool ShouldSerializeStyle()
{

return Owner.ShouldSerializeSetting(LabelInfoSettings.BlinkStyle);

}
void ResetStyle()
{

Owner.ResetSetting(LabelInfoSettings.BlinkStyle);

}
#endregion
#region Rate
[AmbientValue(0)]
public int Rate
{

get
{

return Owner.GetSetting<int>(LabelInfoSettings.BlinkRate);

}
set
{

Owner.SetSetting(LabelInfoSettings.BlinkRate, value);

}

}
bool ShouldSerializeRate()
{

return Owner.ShouldSerializeSetting(LabelInfoSettings.BlinkRate);

}
void ResetRate()
{

Owner.ResetSetting(LabelInfoSettings.BlinkRate);

}
#endregion
#region Duration
[AmbientValue(0)]
public int Duration
{

get
{

return Owner.GetSetting<int>(LabelInfoSettings.BlinkDuration);

}
set
{

Owner.SetSetting(LabelInfoSettings.BlinkDuration, value);

}

}
bool ShouldSerializeDuration()
{

return Owner.ShouldSerializeSetting(LabelInfoSettings.BlinkDuration);

}
void ResetDuration()
{

Owner.ResetSetting(LabelInfoSettings.BlinkDuration);

}
#endregion

public override string ToString()
{

if (Style == BlinkStyle.None) return "None";
string res = "Blink every " + Rate + " milliseconds";
if (Style == BlinkStyle.LimitedTime) res += " for a timespan of " + Duration + " milliseconds";
return res;

}

}
#endregion
#region Type Converter
public class DefaultInstanceConverter<T> : ExpandableObjectConverter
{

public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{

return base.CanConvertTo(context, destinationType)
|| destinationType == typeof(InstanceDescriptor);

}

public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
{

if (value is T && destinationType == typeof(InstanceDescriptor))
{

return GetInstanceDescriptor((T)value);

}
return base.ConvertTo(context, culture, value, destinationType);

}

protected virtual InstanceDescriptor GetInstanceDescriptor(T obj)
{

ConstructorInfo ci = obj.GetType().GetConstructor(Type.EmptyTypes);
if (ci == null)

throw new Exception(obj.GetType().FullName + " does not contain parameterless constructors");

return new InstanceDescriptor(ci, null, false);

}

public class LabelInfoConverter : DefaultInstanceConverter<LabelInfo>
{

protected override InstanceDescriptor GetInstanceDescriptor(LabelInfo li)
{

if (string.IsNullOrEmpty(li.text)) return null;
bool isComplete = true;
foreach (LabelInfoSettings s in Enum.GetValues(typeof(LabelInfoSettings)))
{

if (li.ShouldSerializeSetting(s))
{

isComplete = false;
break;

}

}
return new InstanceDescriptor(

typeof(LabelInfo).GetConstructor(new Type[] { typeof(string) }),

new object[] { li.text }, isComplete);

}

public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
{

return base.CanConvertFrom(context, sourceType)
|| sourceType == typeof(string);

}
public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
{

Control c = context.Instance as Control;
if (c != null && value is string)
{

string txt = value as string;
LabelInfo li = context.PropertyDescriptor.GetValue(c) as LabelInfo;
if (li == null)
{

li = new LabelInfo(txt);
context.PropertyDescriptor.SetValue(c, li);

}
else

li.Text = txt;

return li;

}
return base.ConvertFrom(context, culture, value);

}
public override bool IsValid(ITypeDescriptorContext context, object value)
{

LabelInfo inf = value as LabelInfo;
if (inf == null) return false;
return !string.IsNullOrEmpty(inf.text);

}

}
#endregion

}

public enum BlinkStyle
{

None,
Permanent,
LimitedTime

}

[Flags]
[Editor(typeof(LabelProvider.LabelLayoutEditor), typeof(UITypeEditor))]
public enum LabelLayout
{

NotSet = 0,
Top = 1,
AboveMiddle = 2,
Middle = 4,
UnderMiddle = 8,
Bottom = 16,
Left = 32,
LeftFromCenter = 64,
Center = 128,
RightFromCenter = 256,
Right = 512,
Default = LabelLayout.Left | LabelLayout.AboveMiddle

}
#region LayoutPicker
/// <summary>
/// Control to select a <see cref="LabelLayout"/>. Used in design time for LabelLayout properties
///
[ToolboxItem(false)]
public class LayoutPicker : UserControl
{

public LayoutPicker()
{

table.Dock = DockStyle.Fill;
Controls.Add(table);

}
LayoutPickerTable table = new LayoutPickerTable();
[Browsable(false)]
public LayoutPickerTable TablePanel
{

get
{

return table;

}

}
[DefaultValue(LabelLayout.Default)]
public LabelLayout Result
{

get { return table.Result; }
set { table.Result = value; }

}
LabelLayout revertvalue;
[DefaultValue(LabelLayout.NotSet)]
public LabelLayout RevertValue
{

get { return revertvalue; }
set
{

revertvalue = value;
if ((revertvalue == LabelLayout.NotSet) == (lblRevert == null))

return;

if (lblRevert == null)
{

lblRevert = new Label();
lblRevert.ForeColor = Color.Blue;
lblRevert.Dock = DockStyle.Bottom;
lblRevert.Font = new Font(lblRevert.Font, FontStyle.Underline);
lblRevert.Click += new EventHandler(lblRevert_Click);
lblRevert.Text = "Set to parent";
lblRevert.TextAlign = ContentAlignment.MiddleCenter;
lblRevert.Cursor = Cursors.Hand;
Controls.Add(lblRevert);

}
else
{

lblRevert.Dispose();
lblRevert = null;

}

}
void lblRevert_Click(object sender, EventArgs e)
{

Result = revertvalue;
table.InvokeLayoutChosen(false);

}
Label lblRevert;
public class LayoutPickerTable : TableLayoutPanel
{

Label MiddleControl = new Label();
int cnt = 5;
public LayoutPickerTable()

: this(LabelLayout.Default)

{
}
public LayoutPickerTable(LabelLayout Current)
{

res = startvalue = Current;
RowCount = ColumnCount = cnt;
float perc = 100 / cnt;
for (int i = 0; i < cnt; i++)
{

ColumnStyles.Add(new ColumnStyle(SizeType.Percent, perc));
RowStyles.Add(new RowStyle(SizeType.Percent, perc));

}

for (int i = 0; i < cnt; i++)
{

AddButton(i, 0);
AddButton(i, cnt - 1);
if (i > 0 && i < cnt - 1)
{

AddButton(0, i);
AddButton(cnt - 1, i);

}

MiddleControl.Dock = DockStyle.Fill;
MiddleControl.BackColor = Color.Gray;
MiddleControl.TextAlign = ContentAlignment.BottomCenter;
Controls.Add(MiddleControl, 1, 1);
SetRowSpan(MiddleControl, 3);
SetColumnSpan(MiddleControl, 3);
MiddleControl.Paint += new PaintEventHandler(MiddleControl_Paint);

}
void Navigate(int Col, int Row, LayoutButton b)
{

TableLayoutPanelCellPosition cell = GetCellPosition(b);
Navigate(Col, Row, cell.Column, cell.Row);

}
void Navigate(int Col, int Row, int curcol, int currow)
{

currow = Math.Max(0, Math.Min(cnt - 1, Row + currow));
curcol = Math.Max(0, Math.Min(cnt - 1, Col + curcol));
LayoutButton b = GetControlFromPosition(curcol, currow) as LayoutButton;
if (b == null)
{

Navigate(Col, Row, curcol, currow);

}
else

b.Focus();

}
protected override void OnKeyDown(KeyEventArgs e)
{

if (e.KeyCode == Keys.Cancel)
{

Cancel();

}

}
void Cancel()
{

Result = startvalue;
OnLayoutChosen(true);

}

void MiddleControl_Paint(object sender, PaintEventArgs e)
{

LabelInfo.PaintSymbol(e.Graphics, MiddleControl.Bounds, res);

}
LabelLayout startvalue;
class LayoutButton : Button
{

public new readonly LabelLayout Layout;
public LayoutButton(LabelLayout Layout)
{

this.Layout = Layout;

}
public override Color BackColor
{

get
{

if (Selected)

return Color.Gray;

return Control.DefaultBackColor;

}
set
{

//base.BackColor = value;

}

}
public bool Selected
{

get
{

if (Parent == null) return false;
return Owner.res == Layout;

}

}
LayoutPickerTable Owner
{

get { return Parent as LayoutPickerTable; }

}
protected override bool IsInputKey(Keys keyData)
{

switch (keyData)
{

case Keys.Down:

Owner.Navigate(0, 1, this);
break;

case Keys.Up:

Owner.Navigate(0, -1, this);
break;

case Keys.Left:

Owner.Navigate(-1, 0, this);
break;

case Keys.Right:

Owner.Navigate(1, 0, this);
break;

default:

return base.IsInputKey(keyData);

}
return true;

}

void AddButton(int Column, int Row)
{

LabelLayout lay = GetLayout(Column, Row);
LayoutButton b = new LayoutButton(lay);
b.Dock = DockStyle.Fill;
b.TabStop = false;
b.Click += new EventHandler(b_Click);
Controls.Add(b, Column, Row);
buttons.Add(b);

}

LabelLayout GetLayout(int col, int row)
{

res = 0;
if (col == 0)

res |= LabelLayout.Left;

else if (col == cnt - 1)

res |= LabelLayout.Right;

else

res |= (LabelLayout)((int)LabelLayout.LeftFromCenter << col - 1);

if (row == 0)

res |= LabelLayout.Top;

else if (row == cnt - 1)

res |= LabelLayout.Bottom;

else

res |= (LabelLayout)((int)LabelLayout.AboveMiddle << row - 1);

return res;

}
void b_Click(object sender, EventArgs e)
{

LayoutButton b = sender as LayoutButton;
Result = b.Layout;
OnLayoutChosen(false);

}
void OnLayoutChosen(bool Cancelled)
{

if (LayoutChosen != null)

LayoutChosen(this, new LayoutChosenEventArgs(Result, Cancelled));

}
public void InvokeLayoutChosen(bool Cancelled)
{

OnLayoutChosen(Cancelled);

}
public class LayoutChosenEventArgs : EventArgs
{

public readonly bool Cancelled;
public readonly LabelLayout Result;
public LayoutChosenEventArgs(LabelLayout Result, bool Cancelled)
{

this.Result = Result;
this.Cancelled = Cancelled;

}

}
public event EventHandler<LayoutChosenEventArgs> LayoutChosen;
LabelLayout res;
List<LayoutButton> buttons = new List<LayoutButton>();
public LabelLayout Result
{

get { return res; }
set
{

LayoutButton b = GetSelectedButton();
res = value;
MiddleControl.Text = res.ToString();
if (b != null)

b.Invalidate();

if ((b = GetSelectedButton()) != null)

b.Invalidate();

}

LayoutButton GetSelectedButton()
{

foreach (LayoutButton btn in buttons)
{

if (btn.Selected)

return btn;

}
return null;

}

}
#endregion

}

Obtaining all types in a solution in both runtime and designtime

Robert Verpalen — Fri, 31 Mar 2006 06:49:00 GMT

Often, mostly for designers, I want to get a list of available types. Mostly specific types and from all Assemblies. Had multiple code functions for that and that multiple times, because for different projects I tended to rewrite them (argh? yes argh ). But... now I decided to just storm ahead and create some default functionality.

Why, that's easy, I can almost hear you say. Just use Assembly.GetTypes.... Right....Some issues there: I want all referenced assemblies as well and, it should work in design time. And off course some filtering, assignable to other (interface) types.

The design mode is the difficult part. Most seemed to be 'straight forward' enough: use an IServiceProvider to obtain an IDesignerHost. The IServiceProvider could normally be obtained from the ISite of a component or Control. And if none was provider it could be obtained from LicenseManager.CurrentContext. Then the IDesignerhost exposed a RootComponentClassName property which could lead to the type and thus to the assembly from which the design time. For some scenarios, eg when using an UITypeEditor, the LicenseManager.CurrentContext will not be set, but then it can be specifically set inside the editor.
But... this would only work the first time when the component was added to the form. After that, the RootComponentClassName would contain only the name of the form, not the full namespace.
After some fiddling around and playing the guitar very badly, because I don't know how, it turned out that the IDesignerHost would contain the full name after loading had completed. Knowing that, it was a matter of working around, but the code should continue as well... So a wrapper control would be best while wrapping anyway.

The result is in the code below. There is one difference still between design time and runtime: runtime uses the EntryAssembly (the main executable) and design time the Assembly in which the design is taking place. This is intented: when assigning a type to a property, the assembly must know the type for the code to compile. In runtime, the appdomain has the main assembly loaded and the types can be used throughout the entire appdomain.

The classes included:
-The TypeEnumerator itself is the main component. It can be used as a component, just as an instance to get types, or as a DataSource.
-The TypeEnumeratorSettings holds properties for the filtering. It can be exchanged with the other classes.
-The TypeSelector is a listbox holding control which uses the TypeEnumerator to display the types and enable the use to select them.
-The TypeEditor is an UITypeEditor which can extend a designer for properties with the 'Type' type, or the 'Type[]' type. The TypeSelector and TypeEnumerator for example use it for setting their FilterType(s)

Code CopyHideScrollFull

namespace ReflectionWrappers
{

//references needed:
//-System.windows.forms
//-System.Drawing
using System;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Drawing.Design;
using System.Reflection;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Windows.Forms.Design;
/// <summary>
/// Class to enemurate available types. This class can be used directly, as a component, and as a DataSource
/// </summary>
public class TypeEnumerator : Component, IListSource, ISupportInitialize
{

public static Assembly GetTopAssembly()
{

return GetTopAssembly(null);

}
public static Assembly GetTopAssembly(IServiceProvider provider)
{

IDesignerHost host = null;
return GetTopAssembly(ref provider, ref host, false);

}
static Assembly GetTopAssembly(ref IServiceProvider provider, ref IDesignerHost id, bool SupressErrors)
{

id = null;
Assembly a;
if (LicenseManager.UsageMode == LicenseUsageMode.Designtime
|| (a = Assembly.GetEntryAssembly()) == null)
{

if (id == null)
{

if (provider == null)

provider = LicenseManager.CurrentContext;

id = (IDesignerHost)provider.GetService(typeof(IDesignerHost));

}
try
{

if (id == null || id.RootComponentClassName == null)
{

throw new Exception("An assembly was tried to be obtained in design time, but no designer was (fully) loaded yet. When using this functionality in a control or component, please call it after intialization is completed. The TypeSelector control contains functionality on how to go about");

}
//id.RootComponent.GetType() would return the base class being edited,
//not the actual form or component. RootComponentClassName should contain the
//proper namespace
Type type = Type.GetType(id.RootComponentClassName, false);
if (type == null)
{

if (id.Loading)
{

throw new Exception("The proper type could not be obtained in design time. The designer was still loading, please call this function after loading is completed. Assign to the Load event to be able to actually use the new values");

}
throw new Exception("An assembly was tried to be obtained in design time, but the proper type could not be determined: " + id.RootComponentClassName + ".\nMake sure the current project has been build if you just added or changed a reference. If this error persists, you might have to reload the solution (aka restart visual studio)");

}
a = type.Assembly;

}
catch
{

if (SupressErrors)

return null;

throw;

}

}
return a;

}

public TypeEnumerator()

: this(new TypeEnumeratorSettings())

{

//Source : http://blogs.vbcity.com/hotdog/archive/2006/03/31/5943.aspx

}
public TypeEnumerator(TypeEnumeratorSettings Settings)
{

this.Settings = Settings;

}
public TypeEnumerator(Assembly InAssembly)

: this(InAssembly, null)

{
}
public TypeEnumerator(params Type[] FilterTypes)

: this(null, FilterTypes)

{
}
public TypeEnumerator(Assembly InAssembly, params Type[] FilterTypes)

: this()

{

settings.Filter.FilterTypes = FilterTypes;

}

public TypeEnumerator(IContainer container)

: this()

{

if (container != null)

container.Add(this);

}
/// <summary>
/// Used for designer instances
/// </summary>
/// <param name="ServiceProvider"></param>
public TypeEnumerator(IServiceProvider ServiceProvider)

: this()

{

this.ServiceProvider = ServiceProvider;

}

private IServiceProvider provider;
/// <summary>
/// For design time only: the service provider that can give the current designer (IDesignerHost)
/// If this value is not specified, the <see cref="Site"/> property is used, but in some cases (eg an <see cref="UITypeEditor"/>),
/// this component itself will not be in designmode, and the Site will not be available. In those cases
/// the proper provider can be set (or if possible, the assembly itself ;-) )
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public IServiceProvider ServiceProvider
{

get
{

if (provider != null)

return provider;

if (Site != null)

return Site;

if (Container != null)
{

if (Container is ISite)

return ((ISite)Container);

}
return null;

}
set { provider = value; }

}
Type[] types;
bool listchanged=true;
protected void OnListChanged(bool ClearList)
{

listchanged |= ClearList;
if (suspendlistchange || Initializing)

return;

if (ListChanged != null)

ListChanged(this, EventArgs.Empty);

}
public event EventHandler ListChanged;

/// <summary>
/// Returns all non system types out of the toplevel assembly.
/// To specify further settings, use an instance of the TypeEnumerator
/// </summary>
/// <returns></returns>
public static IEnumerable<Type> GetAllTypes()
{

return new TypeEnumerator().GetTypes();

}

IEnumerable<Type> GetTypes()
{

foreach (Assembly a in GetAssemblies())
{

foreach (Type t in GetTypes(a))
{

yield return t;

}

}
private TypeEnumeratorSettings settings;
[Description("The settings on which the obtaining of specified types is based")]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public TypeEnumeratorSettings Settings
{

get { return settings; }
set
{

if (value == null)
{

if (DesignMode)

value = new TypeEnumeratorSettings();

else

throw new ArgumentNullException();

}
if (settings == value) return;
PropertyChangedEventHandler handler = new PropertyChangedEventHandler(settings_PropertyChanged);
if (settings != null)

settings.PropertyChanged -= handler;

settings = value;
settings.PropertyChanged += handler;
OnListChanged(true);

}

}
void settings_PropertyChanged(object sender, PropertyChangedEventArgs e)
{

OnListChanged(true);

}
bool suspendlistchange;
public Type[] GetList()
{

if (listchanged && !Initializing)
{

Cursor cur = Cursor.Current;
Cursor.Current = Cursors.WaitCursor;
suspendlistchange = true;
try
{

List<Type> list = new List<Type>();
foreach (Type t in GetTypes())
{

list.Add(t);

}
types = list.ToArray();
listchanged = false;

}
finally
{

suspendlistchange = false;
Cursor.Current = cur;

}

}
return types;

}
public Type[] Types
{

get { return GetList(); }

}
/// <summary>
/// Fires when the component is ready for use. Will only fire if the types are asked for (with <see cref="GetList"/> or <see cref="Types"/>)
/// or if BeginEdit and EndEdit is used.
/// If the component is used in a designer, beginedit and endedit are used automatically in which case
/// Load will fire as well.
/// </summary>
public event EventHandler Load;
bool InitTopAssembly()
{

if (settings.TopAssembly != null)

return true;

provider = ServiceProvider;
IDesignerHost host = null;
try
{

suspendlistchange = true;
settings.TopAssembly = GetTopAssembly(ref provider, ref host, false);

}
catch
{

if (host != null && host.Loading)
{

host.LoadComplete += new EventHandler(host_LoadComplete);
return false;

}
throw;

}
finally
{

suspendlistchange = false;

}
if (Load != null)

Load(this, EventArgs.Empty);

return true;

}
/// <summary>
/// Gets all assemblies according to the specified settings.
/// </summary>
/// <returns></returns>
public IEnumerable<Assembly> GetAssemblies()
{

if (!InitTopAssembly())

yield break;

yield return settings.TopAssembly;
if (settings.IncludeReferencedAssemblies)
{

//bool designtime = LicenseManager.UsageMode == LicenseUsageMode.Designtime;
foreach (AssemblyName a in settings.TopAssembly.GetReferencedAssemblies())
{

if (settings.IncludeSystemAssemblies
||
(!a.Name.StartsWith("System.") && a.Name != "mscorlib" && a.Name != "System"))
{

yield return Assembly.Load(a);

}

}
void host_LoadComplete(object sender, EventArgs e)
{

InitTopAssembly();
OnListChanged(false);

}
/// <summary>
/// Checks if the specified type should be included according to the current settings
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
public virtual bool CheckType(Type t)
{

if (settings.HasFilter &&

!settings.Filter.ValidateType(t, false))
return false;

if (settings.HasExlusionRules

&& settings.Exclude.ValidateType(t, true))
return false;

return true;

}

IEnumerable<Type> GetTypes(Assembly a)
{

foreach (Type t in a.GetTypes())
{

if (CheckType(t))

yield return t;

}

}
#region IListSource Members
public bool ContainsListCollection
{

get { return true; }

}
System.Collections.IList IListSource.GetList()
{

return GetList();

}
#endregion
#region ISupportInitialize Members
public bool Initializing
{

get { return initcount > 0; }

}
int initcount = 0;
public void BeginInit()
{

initcount++;

}
public void EndInit()
{

if (--initcount <= 0)
{

initcount = 0;
InitTopAssembly();
if (listchanged)

OnListChanged(true);

}

#endregion

}
[TypeConverter(typeof(ComponentConverter))]
public class TypeEnumeratorSettings : INotifyPropertyChanged
{

private Assembly topAssembly;
[Description("The Assembly in which to (begin the) search. If this value is null, the top assembly where this value is called is used")]
[DesignerSerializationVisibility( DesignerSerializationVisibility.Hidden)]
public Assembly TopAssembly
{

get { return topAssembly; }
set
{

if (topAssembly == value) return;
topAssembly = value;
OnPropertyChanged("TopAssembly");

}

private bool includeReferencedAssemblies = true;
[DefaultValue(true)]
[Description("")]
public bool IncludeReferencedAssemblies
{

get { return includeReferencedAssemblies; }
set
{

if (includeReferencedAssemblies == value) return;
includeReferencedAssemblies = value;
OnPropertyChanged("IncludeReferencedAssemblies");

}

}
private bool includeSystemAssemblies = false;
[DefaultValue(false)]
[Description("If you want to include types in the referenced system assemblies, set this value to true. By default only non-framework-system code is included")]
public bool IncludeSystemAssemblies
{

get { return includeSystemAssemblies; }
set
{

if (includeSystemAssemblies == value) return;
includeSystemAssemblies = value;
OnPropertyChanged("IncludeSystemAssemblies");

}

}
#region Filter
private TypeFilter filtersettings,exclude;

[DesignerSerializationVisibility( DesignerSerializationVisibility.Content)]
[Description("Only types that correspond with the settings included in this property are included in the list.")]
public TypeFilter Filter
{

get
{

if(filtersettings==null)

filtersettings = new TypeFilter(this,"Filter");

return filtersettings;

}

}
[DefaultValue(false)]
public bool HasFilter
{

get { return filtersettings != null && !filtersettings.AllowAll; }

}

[DefaultValue(null)]
[Description("The type(s) to which the types in this list must be assignable")]
[Editor(typeof(TypeEditor), typeof(UITypeEditor))]
public Type[] FilterTypes
{

get {

if (filtersettings == null) return null;
return filtersettings.FilterTypes;

}
set
{

Filter.FilterTypes = value;
OnPropertyChanged("FilterTypes");

}

[DefaultValue(true)]
public bool AllowAbstract
{

get { return exclude == null || !exclude.FilterAbstract; }
set
{

if (value != AllowAbstract)

Exclude.FilterAbstract = !value;

}

[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
[Description("Types that correspond with the settings in this property are excluded from the selection")]
public TypeFilter Exclude
{

get
{

if (exclude == null)

exclude = new TypeFilter(this,"Excluded");

return exclude;

}

}
[DefaultValue(false)]
public bool HasExlusionRules
{

get { return exclude != null && !exclude.AllowAll; }

}

[TypeConverter(typeof(ComponentConverter))]
public class TypeFilter:INotifyPropertyChanged
{

public readonly TypeEnumeratorSettings Owner;
public readonly string AssignedProperty;
internal TypeFilter(TypeEnumeratorSettings owner,string MyPropery)
{

this.Owner = owner;
AssignedProperty = MyPropery;

}

private Type[] filterTypes;
[DefaultValue(null)]
[Description("The type(s) to which the types in this list must be assignable")]
[Editor(typeof(TypeEditor), typeof(UITypeEditor))]
public Type[] FilterTypes
{

get { return filterTypes; }
set
{

if (value != null && value.Length == 0) value = null;
if (filterTypes == value) return;
filterTypes = value;
OnPropertyChanged("FilterTypes");

}

/// <summary>
/// Checks if the specified type validates against this filter
/// </summary>
/// <param name="t"></param>
/// <param name="IsExclusion"></param>
/// <returns></returns>
public bool ValidateType(Type t,bool IsExclusion)
{

//check filter types
if (filterTypes != null)
{

foreach (Type ft in filterTypes)
{

if (ft.IsAssignableFrom(t)==IsExclusion) return IsExclusion;

}

//check flags
if (typeattr != DefaultTypeAttributes)
{

TypeAttributes res = typeattr & t.Attributes;
if (IsExclusion)

return res > 0;

else

return res == typeattr;

}
return true;

}

#region INotifyPropertyChanged Members
public event PropertyChangedEventHandler PropertyChanged;
void OnPropertyChanged(string name)
{

if (PropertyChanged != null)
{

PropertyChanged(this, new PropertyChangedEventArgs(name));

}
Owner.OnPropertyChanged(AssignedProperty);

}
#endregion

public const TypeAttributes DefaultTypeAttributes = (TypeAttributes)0;
private TypeAttributes typeattr = DefaultTypeAttributes;
/// <summary>
/// The <see cref="System.Reflection.TypeAttributes"/> to check the Type against
/// </summary>
[DefaultValue(DefaultTypeAttributes)]
[Browsable(false)]
[DesignerSerializationVisibility( DesignerSerializationVisibility.Hidden)]
[Description("Attributes on which to filter. Flagwise so multiple properties can be combined")]
public TypeAttributes FilterAttributes
{

get { return typeattr; }
set
{

typeattr = value;

}

[DefaultValue(true)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public bool AllowAll
{

get
{

return

filterTypes == null
&& typeattr == DefaultTypeAttributes
;

}
set
{

if (value)
{

filterTypes = null;
typeattr = DefaultTypeAttributes;

}

public bool FilterOnAttribute(TypeAttributes ta)
{

return typeattr != DefaultTypeAttributes && (typeattr & ta) > 0;

}
public bool SetAttribute(TypeAttributes ta, bool On)
{

if (FilterOnAttribute(ta) == On) return false;
if (On)

typeattr |= ta;

else

typeattr ^= ta;

OnPropertyChanged("Filter" + ta.ToString());
return true;

}

[DefaultValue(false)]
public bool FilterAbstract
{

get
{

return FilterOnAttribute(TypeAttributes.Abstract);

}
set
{

SetAttribute(TypeAttributes.Abstract, value);

}

[DefaultValue(false)]
public bool FilterPublic
{

get
{

return FilterOnAttribute(TypeAttributes.Public);

}
set
{

SetAttribute(TypeAttributes.Public, value);

}

[DefaultValue(false)]
public bool FilterNestedPublic
{

get
{

return FilterOnAttribute(TypeAttributes.NestedPublic);

}
set
{

SetAttribute(TypeAttributes.NestedPublic, value);

}

public override string ToString()
{

if (AllowAll) return null;
return "Filter set";

}

#endregion

#region INotifyPropertyChanged Members
public event PropertyChangedEventHandler PropertyChanged;
void OnPropertyChanged(string name)
{

if (PropertyChanged != null)
{

PropertyChanged(this, new PropertyChangedEventArgs(name));

}

}
#endregion

}

/// <summary>
/// Listbox style control to select types
/// </summary>
[DefaultEvent("SelectionFinal")]
public class TypeSelector : UserControl,ISupportInitialize
{

ListBox lb = new ListBox();
Panel pnlControls = new Panel();
CheckBox
chkIncludeSystem = new CheckBox(),
chkIncludeReferencedAssemblies = new CheckBox();
ToolTip tt = new ToolTip();
public TypeSelector()

: this(new TypeEnumerator())

{
}
public TypeSelector(TypeEnumerator Enumerator)
{

if (Enumerator == null)

throw new ArgumentNullException();

SuspendLayout();
te = Enumerator;
te.BeginInit();
if (te.ServiceProvider == null)

te.ServiceProvider = Site;

te.Load += new EventHandler(te_ListChanged);
te.ListChanged += new EventHandler(te_ListChanged);
te.EndInit();
lb.Dock = DockStyle.Fill;
lb.DisplayMember = "Name";
lb.SelectedIndexChanged += new EventHandler(lb_SelectedIndexChanged);
lb.Click += new EventHandler(lb_Click);
lb.DoubleClick += new EventHandler(lb_DoubleClick);
lb.DataSourceChanged += new EventHandler(lb_DataSourceChanged);
lb.BorderStyle = BorderStyle.None;
lb.MouseMove += new MouseEventHandler(lb_MouseMove);
lb.MouseLeave += new EventHandler(lb_MouseLeave);
Controls.Add(lb);
//pnlControls.Height = 20;
pnlControls.AutoSize = true;
pnlControls.Dock = DockStyle.Bottom;
pnlControls.BorderStyle = BorderStyle.None;
Controls.Add(pnlControls);
chkIncludeReferencedAssemblies.DataBindings.Add("Checked", te.Settings, "IncludeReferencedAssemblies");
AddControl(chkIncludeReferencedAssemblies);
chkIncludeSystem.DataBindings.Add("Checked", te.Settings, "IncludeSystemAssemblies");
AddControl(chkIncludeSystem);
ShortNotation = false;
tt.ShowAlways = true;
tt.InitialDelay = 200;
tt.ReshowDelay = 500;
tt.SetToolTip(chkIncludeReferencedAssemblies, "If this value is false, only the types in the main assembly will be shown");
tt.SetToolTip(chkIncludeSystem, "Determines if System/framework types should be included");
selectionmode = GetDefaultSelectionMode();
base.BorderStyle = BorderStyle.FixedSingle;
Padding = new Padding(1);
ResumeLayout();

}
void AddControl(Control c)
{

c.Dock = DockStyle.Bottom;
c.Height = 16;
c.Font = new System.Drawing.Font(c.Font.FontFamily, 7);
pnlControls.Controls.Add(c);

}
void AddControl(CheckBox c)
{

AddControl((Control)c);
c.TabStop = false;
c.AutoEllipsis = true;
c.DataBindings[0].DataSourceUpdateMode = DataSourceUpdateMode.OnPropertyChanged;

}
void lb_SelectedIndexChanged(object sender, EventArgs e)
{

if (SelectedItemChanged != null)

SelectedItemChanged(this, e);

}
void lb_Click(object sender, EventArgs e)
{

OnSelectionFinal(FinalSelectionMode.SingleClick, e);

}
int lastmouseindex = -1;
void lb_MouseMove(object sender, MouseEventArgs e)
{

SetLBToolTip();

}
void lb_MouseLeave(object sender, EventArgs e)
{

SetLBToolTip();

}
void SetLBToolTip()
{

System.Drawing.Point p = lb.PointToClient(MousePosition);
int i = lb.IndexFromPoint(p);
if (i == lastmouseindex) return;
lastmouseindex = i;
if (i != -1)

tt.Show(lb.Items[i].ToString(), lb, p);

else

tt.Hide(lb);

}

public event EventHandler SelectedItemChanged;
void lb_DoubleClick(object sender, EventArgs e)
{

OnSelectionFinal(FinalSelectionMode.DoubleClick, e);

}
private bool allowusersettings = true;
[DefaultValue(true)]
[Description("true if the user can adapt the criteria (default), otherwise false")]
public bool AllowUserSettings
{

get { return allowusersettings; }
set
{

pnlControls.Visible = allowusersettings = value;

}

}
[DefaultValue(BorderStyle.FixedSingle)]
public new BorderStyle BorderStyle
{

get { return base.BorderStyle; }
set { base.BorderStyle = value; }

}
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public Type SelectedType
{

get { return lb.SelectedItem as Type; }
set
{

if (value == null)

lb.SelectedItems.Clear();

else

lb.SelectedItem = value;

}

[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public Type[] SelectedTypes
{

get
{

if (lb.SelectedItems.Count == 0) return null;
Type[] types = new Type[lb.SelectedItems.Count];
for (int i = 0; i < types.Length; i++)
{

types[i] = (Type)lb.SelectedItems[i];

}
return types;

}
set
{

lb.SelectedItems.Clear();
if (value == null) return;
foreach (Type t in value)
{

lb.SelectedItems.Add(t);

}

[Editor(typeof(TypeEditor), typeof(UITypeEditor))]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
[DefaultValue(null)]
public Type[] FilterTypes
{

get { return te.Settings.Filter.FilterTypes; }
set
{

te.Settings.Filter.FilterTypes = value;

}

[DefaultValue(false)]
public bool MultiSelect
{

get { return lb.SelectionMode == System.Windows.Forms.SelectionMode.MultiExtended; }
set
{

lb.SelectionMode =
value
? System.Windows.Forms.SelectionMode.MultiExtended
: System.Windows.Forms.SelectionMode.One;
//only reset selectionmode if no manual change was made
if (!selectionmanualset)

ResetSelectionMode();

}

}
private bool shortnotation;
[DefaultValue(false)]
[Description("If true, the descriptions will be shown in shorter format")]
public bool ShortNotation
{

get { return shortnotation; }
set
{

shortnotation = value;
chkIncludeSystem.Text = value ? "System" : "Include system assemblies";
chkIncludeReferencedAssemblies.Text = value ? "References" : "Include referenced assemblies";
if (llClear != null)

llClear.Text = value ? "Clear" : "Clear selection";

}

Button btnOK;
/// <summary>
/// Used for designers: indicates if an ok button should be shown
/// </summary>
[DefaultValue(false)]
public bool ShowOk
{

get { return btnOK != null; }
set
{

if (ShowOk == value) return;
if (value)
{

btnOK = new Button();
btnOK.Text = "OK";
btnOK.AutoSize = true;
AddControl(btnOK);
btnOK.Click += new EventHandler(btnOK_Click);

}
else
{

btnOK.Dispose();
btnOK = null;

}

}
LinkLabel llClear;
[Description("Show a label to clear the selection..")]
[DefaultValue(false)]
public bool ShowClear
{

get { return llClear != null; }
set
{

if (ShowClear == value) return;
if (value)
{

llClear = new LinkLabel();
llClear.Click += new EventHandler(llClear_Click);
ShortNotation = shortnotation;
AddControl(llClear);
llClear.BringToFront();

}
else
{

llClear.Dispose();
llClear = null;

}

}
void llClear_Click(object sender, EventArgs e)
{

SelectedType = null;
OnSelectionFinal(FinalSelectionMode.ClearSelection, e);

}
/// <summary>
/// Fires when the selection is final.
///
/// How the selection is made, can be set by using <see cref="SelectionMode"/>
/// Default settings:
/// A doubleclick on an item is always considered final. A single click is considered final
/// when not using multiselect.
/// If <see cref="ShowOk"/> is used, the ok click is considered final as well
/// </summary>
public event EventHandler SelectionFinal;
[Flags]
public enum FinalSelectionMode
{

Default = 0,
SingleClick = 1,
DoubleClick = 2,
/// <summary>
/// If showOK is used.
/// </summary>
OK = 4,
ClearSelection = 8

}
private FinalSelectionMode selectionmode;
bool selectionmanualset;
public FinalSelectionMode SelectionMode
{

get { return selectionmode; }
set
{

//for the default value, fill in the actual default value
if (value == FinalSelectionMode.Default)

value = GetDefaultSelectionMode();

selectionmode = value;
selectionmanualset = true;

}

}
bool ShouldSerializeSelectionMode()
{

return selectionmode != GetDefaultSelectionMode();

}
public void ResetSelectionMode()
{

selectionmode = GetDefaultSelectionMode();

}
public FinalSelectionMode GetDefaultSelectionMode()
{

return GetDefaultSelectionMode(MultiSelect);

}
public FinalSelectionMode GetDefaultSelectionMode(bool Multiselect)
{

FinalSelectionMode fs = FinalSelectionMode.DoubleClick | FinalSelectionMode.OK;
if (!MultiSelect)

fs |= FinalSelectionMode.SingleClick;

return fs;

}
void OnSelectionFinal(FinalSelectionMode mode, EventArgs e)
{

if (SelectionFinal != null
&& (mode & selectionmode) > 0)
{

SelectionFinal(this, e);

}

}
void btnOK_Click(object sender, EventArgs e)
{

OnSelectionFinal(FinalSelectionMode.OK, e);

}
void te_ListChanged(object sender, EventArgs e)
{

this.Cursor = Cursors.WaitCursor;
try
{

lb.Items.Clear();
lb.Items.AddRange(te.Types);

}
finally
{

this.Cursor = null;

}

}
void lb_DataSourceChanged(object sender, EventArgs e)
{

//remember selected items
//looks silly, but it works ;-)
//the selecteditemcollection is updated and the listbox knows it. uhuh.
SelectedTypes = SelectedTypes;
//clear/set tooltip
SetLBToolTip();

}

private TypeEnumerator te;
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public TypeEnumeratorSettings Settings
{

get
{

return te.Settings;

}

}
[Browsable(false)]
public TypeEnumerator Enumerator
{

get { return te; }

}
protected override System.Drawing.Size DefaultSize
{

get
{

return new System.Drawing.Size(100, 150);

}

#region ISupportInitialize Members

public void BeginInit()
{

te.BeginInit();

}

public void EndInit()
{

te.EndInit();

}

#endregion

}
/// <summary>
/// An <see cref="UITypeEditor"/> for selecting Type or Types. If the target property is an array, multiselect is used, otherwise single select
/// </summary>
public class TypeEditor : UITypeEditor
{

private TypeSelector Selector;
public TypeEnumeratorSettings Settings
{

get
{

return Selector.Settings;

}

}
public TypeEditor()
{
}
protected virtual TypeSelector CreateSelector(IServiceProvider provider)
{

TypeEnumerator te = new TypeEnumerator(provider);
return new TypeSelector(te);

}
public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
{

return UITypeEditorEditStyle.DropDown;

}
IWindowsFormsEditorService iw;
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{

if (Selector == null)
{

Selector = CreateSelector(provider);
Selector.SelectionFinal += new EventHandler(Selector_SelectionFinal);
Selector.ShortNotation = true;

}
bool multiselect = context.PropertyDescriptor.PropertyType.IsArray;
Selector.MultiSelect = multiselect;
Selector.ShowOk = multiselect;
Selector.ShowClear = true;
//set current value
if (value == null)

Selector.SelectedType = null;

else if (multiselect)

Selector.SelectedTypes = (Type[])value;

else

Selector.SelectedType = (Type)value;

//show dropdown
iw = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
iw.DropDownControl(Selector);
//return value
return multiselect ? (object)Selector.SelectedTypes : Selector.SelectedType;

}
void Selector_SelectionFinal(object sender, EventArgs e)
{

iw.CloseDropDown();

}

. . .

drag and drop outlook attachments

Robert Verpalen — Thu, 16 Mar 2006 10:35:00 GMT

Wanted to have a wrapper around the drag and drop outlook attachments for the File Select Control, but that turned somewhat harder than expected. Saving one attachment was easy enough. It could be done completely managed (found some other examples that do the same on the net), but saving multiple wasn't to be found in .net (at least not as far as I could find :-/) and even though the File Select control doesn't support multiple files (yet), the wrapper certainly should :p

The problem is that with the windows forms DataObject created when dropping, you can only get data on the default index. The only solution seemed to be using the unmanaged wrappers.Luckily the first step was easy: the DataObject explicitely implements the ComTypes.IDataObject interface and thus could be parsed. Getting the proper formatter and all seemed to be a bigger headache. To make a long story (and more than half a day of trial and error frustration to create the entire wrapper) short, a combination of using the .net DataObject and the unmanaged wrappers lead to the solution (see below in this post to read just that part).

The entire wrapper: (for an example, see the File Select Control mentioned above)

Code CopyHideScrollFull

namespace Subro.Outlook
{

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.IO;
//the interopservices are needed to get to unmanaged code to get the streams
//for attachments if there are more. (for one, it can be done problemless with managed code)
using System.Runtime.InteropServices;
using ct =System.Runtime.InteropServices.ComTypes;
using System.Runtime.InteropServices.ComTypes;

///

/// Wrapper around the drop data from attachments from outlook
///

public class OutlookAttachmentDropCatcher
{

public static string[] GetFiles(DragEventArgs e)
{

return new OutlookAttachmentDropCatcher(e).GetFiles();

}

///

/// The name to identify a file group when dragging outlook files
///

public const string GroupIdentifier = "FileGroupDescriptor";
///

/// The name to identify the raw data of the attachments in the clipboard
///

DataFormats.Format ContentsIdentifier = DataFormats.GetFormat("FileContents");

///

/// The drop data with which this OutlookAttachment object was created
///

public readonly DataObject DropData;
public OutlookAttachmentDropCatcher(DragEventArgs e)

: this((DataObject)e.Data)

{

}
public OutlookAttachmentDropCatcher(DataObject Data)
{

//Source: http://blogs.vbcity.com/hotdog/archive/2006/03/16/5896.aspx
//check there for updates....
DropData = Data;
MemoryStream s = (MemoryStream)Data.GetData(GroupIdentifier);
ReadHeaders(s);
s.Close();

}

#region COM structs

struct FILETIME
{

int dwLowDateTime;
int dwHighDateTime;

public FILETIME(BinaryReader br)
{

dwLowDateTime = br.ReadInt32();
dwHighDateTime = br.ReadInt32();

}

struct CLSID
{

byte[] ID;
public CLSID(BinaryReader br)
{

ID = br.ReadBytes(16);

}

}
struct SizeL
{

public int X, Y;
public SizeL(BinaryReader br)
{

X = br.ReadInt32();
Y = br.ReadInt32();

}

}
struct FILEDESCRIPTOR
{

int dwFlags;
CLSID clsid;
SizeL sizel;
SizeL pointl;
int dwFileAttributes;
FILETIME ftCreationTime;
FILETIME ftLastAccessTime;
FILETIME ftLastWriteTime;
int nFileSizeHigh;
int nFileSizeLow;
public string FileName;

public FILEDESCRIPTOR(BinaryReader br)
{

//these flags aren't really filled when coming
//from outlook, but who knows....someday it might be used :p
dwFlags = br.ReadInt32();
clsid = new CLSID(br);
sizel = new SizeL(br);
pointl = new SizeL(br);
dwFileAttributes = br.ReadInt32();
ftCreationTime = new FILETIME(br);
ftLastAccessTime = new FILETIME(br);
ftLastWriteTime = new FILETIME(br);
nFileSizeHigh = br.ReadInt32();
nFileSizeLow = br.ReadInt32();

const int MAX_PATH = 256;
byte[] bytes = br.ReadBytes(MAX_PATH);
int i = 0;
for (; i < MAX_PATH && bytes[i] != 0; i++)
{ }
FileName = Encoding.ASCII.GetString(bytes, 0, i);

br.ReadInt32(); //not entirely sure what this entry does...

}

struct FILEGROUPDESCRIPTOR
{

uint cItems;
FILEDESCRIPTOR[] fgd;
public readonly string[] Names;

public FILEGROUPDESCRIPTOR(MemoryStream s)
{

BinaryReader br = new BinaryReader(s);
cItems = br.ReadUInt32();
fgd = new FILEDESCRIPTOR[cItems];
Names = new string[cItems];
for (int i = 0; i < cItems; i++)
{

fgd[i] = new FILEDESCRIPTOR(br);
Names[i] = fgd[i].FileName;

}

#endregion

FILEGROUPDESCRIPTOR descriptor;
void ReadHeaders(MemoryStream s)
{

descriptor = new FILEGROUPDESCRIPTOR(s);

}

string tempfolder = Environment.GetFolderPath(Environment.SpecialFolder.InternetCache) + @"\OLK3D2\";
///

/// The folder where temporary files are stored (when dragging files from outlook)
///

string TempFolder
{

get
{

return tempfolder;

}
set
{

if (value == null) throw new ArgumentNullException();
tempfolder = value;
if (!tempfolder.EndsWith(@"\")) tempfolder += @"\";

}

///

/// Gets the stream of the specified attachment (without saving)
/// NB: Name must be one of the attachment names (see )
///

///
///
public MemoryStream GetStream(string Name)
{

return GetStream(IndexOf(Name));

}

public int IndexOf(string AttachmentName)
{

return Array.IndexOf<string>(descriptor.Names, AttachmentName);

}

///

/// Gets the stream of the FIRST attachment
///

///
public MemoryStream GetStream()
{

return GetStream(0);

}

///

/// Gets the stream at Index of the available attachments
///

///
///
public MemoryStream GetStream(int Index)
{

if (Index == 0)
{

//the first is easy: just copy the formatted .net data
MemoryStream ms = (MemoryStream)DropData.GetData(ContentsIdentifier.Name);
return ms;

}
return GetHigherAttachment(Index);

}
#region unmanaged

MemoryStream GetHigherAttachment(int Index)
{

//this is where it gets ugly :p

ct.IDataObject data = (ct.IDataObject)DropData;
STGMEDIUM medium;

#region possible errors (not used)
/*
unchecked
{

const int

S_OK = 0,
DV_E_LINDEX = (int)0x80040068,
DV_E_FORMATETC = (int)0x80040064,
DV_E_TYMED = (int)0x80040069,
//DV_E_DVASPECT = -2147221397,
E_INVALIDARG = (int)0x80070057,
E_UNEXPECTED = (int)0x8000FFFF,
OLE_E_NOTRUNNING = (int)0x80040005,
E_OUTOFMEMORY = (int)0x8007000E;

}*/
#endregion

//find the proper format
IEnumFORMATETC formats = data.EnumFormatEtc(DATADIR.DATADIR_GET);
int cnt = DropData.GetFormats().Length;
FORMATETC[] resF = new FORMATETC[cnt];
int[] resI = new int[cnt];
formats.Next(cnt, resF, resI);
int index = Array.IndexOf<string>(DropData.GetFormats(), ContentsIdentifier.Name);
FORMATETC format = resF[index];

//set the index to get
format.lindex = Index;

//get the istream object
data.GetData(ref format, out medium);
IStream stream = (IStream)Marshal.GetObjectForIUnknown(medium.unionmember);

//read the istream into a memorystream (saving could have been done directly, but this is the more general approach)
MemoryStream ms = new MemoryStream();
const int Block_Length = 1024;
byte[] bytes = new byte[Block_Length];
ulong count = 0;
IntPtr countptr = Marshal.AllocHGlobal(8);
Marshal.StructureToPtr(count, countptr, true);
try
{

for (; ; )
{

stream.Read(bytes, Block_Length, countptr);
count = (uint)Marshal.PtrToStructure(countptr, typeof(uint));
if (count == 0) break;
ms.Write(bytes, 0, (int)count);

}

}
finally
{

Marshal.FreeHGlobal(countptr);

}

return ms;

}

#endregion

///

/// The number of dropped attachments
///

public int AttachmentCount
{

get { return descriptor.Names.Length; }

}

///

/// Returns the attachment names
///

///
public string[] GetNames()
{

return descriptor.Names;

}

///

/// Saves the file to the temp directory and returns the full location.
/// NB: Name must be one of the attachments (see )
///

///
///
public string GetFile(string Name)
{

return GetFile(IndexOf(Name));

}

///

/// Saves the FIRST file to the temp directory and returns its url. You can use this function
/// if you are sure there's only one attachment
///

///
public string GetFile()
{

return GetFile(0);

}

///

/// Saves the files at the Index position of the available attachments
///

///
///
public string GetFile(int Index)
{

string Name = descriptor.Names[Index];
string url = tempfolder + Name;
return SaveAttachment(Name, url);

}

private bool alwaysoverwrite = true;
///

/// Indicates if (temporary) files may always be overwritten when saving
///

public bool AlwaysOverWrite
{

get { return alwaysoverwrite; }
set { alwaysoverwrite = value; }

}

///

/// Saves the Attachment to the specified location
/// NB: Name must be one of the attachments (see )
///

///
///
public string SaveAttachment(string AttachmentName, string Path)
{

return SaveAttachment(AttachmentName, Path, alwaysoverwrite);

}

public string SaveAttachment(int AttachmentIndex, string Path)
{

return SaveAttachment(AttachmentIndex, Path, alwaysoverwrite);

}
public string SaveAttachment(string AttachmentName, string Path, bool AlwaysOverWrite)
{

return SaveAttachment(IndexOf(AttachmentName), Path, AlwaysOverWrite);

}
public string SaveAttachment(int AttachmentIndex, string Path, bool AlwaysOverWrite)
{

if (!AlwaysOverWrite && File.Exists(Path))
{

switch (MessageBox.Show("Temporary file for " + descriptor.Names[AttachmentIndex] + " allready exists. Overwrite?", "file exists", MessageBoxButtons.YesNoCancel))
{

case DialogResult.No:

return Path;

case DialogResult.Cancel:

return null;

}

File.WriteAllBytes(Path, GetStream(AttachmentIndex).ToArray());
return Path;

}

///

/// saves all files to the temporary directory and returns the url's
///

///
public string[] GetFiles()
{

string[] files = new string[descriptor.Names.Length];
int i = 0;
foreach (string name in descriptor.Names)
{

files[i++] = GetFile(name);

}
return files;

}

The specific multiple attachments code:

Code CopyHideScrollFull

#region unmanaged

MemoryStream GetHigherAttachment(int Index)
{

//this is where it gets ugly :p

ct.IDataObject data = (ct.IDataObject)DropData;
STGMEDIUM medium;

#region possible errors (not used)
/*
unchecked
{

const int

}*/
#endregion

//set the index to get
format.lindex = Index;

//get the istream object
data.GetData(ref format, out medium);
IStream stream = (IStream)Marshal.GetObjectForIUnknown(medium.unionmember);

for (; ; )
{

stream.Read(bytes, Block_Length, countptr);
count = (uint)Marshal.PtrToStructure(countptr, typeof(uint));
if (count == 0) break;
ms.Write(bytes, 0, (int)count);

}

}
finally
{

Marshal.FreeHGlobal(countptr);

}

return ms;

}

#endregion

Wrapper around registering file extensions

Robert Verpalen — Tue, 07 Mar 2006 07:01:00 GMT

Want to assign your application to a certain file extension? The .net setup project has all those options build in. hoorray. But if you want to have that control in your own program, you'll have to do it with a (bunch of) registry settings. no hoorray. It can be a bother to get the setup right. So.. time for another wrapper. There might be others available, but couldn't really find reusable code at first glance.

The wrapper supports simply quickly assigning a application to a certain extension, but also the other properties such as iconfile, printto and some others can be set (and obtained of course). Enumerating all or filtered extensions is currently made in .net 2.0 format, because well... using the yield return is more efficient than keeping an entire list of the FileExtension objects :)
The current functionality works as far as I've tested it, but additional options probably will be included at a later time (requests perhaps?)

Update 18-3-6 : Added the FileData class and some extra functionality around obtaining icons (some icons are indexed inside eg. shell32.dll. if they are loaded with the filename, only the first icon is loaded). (The FileData class is used in the FileSelect Control)

The complete functional code:

Code CopyHideScrollFull

#define Net20 //remove or comment this line to remove any functionality only available in .net 2.0 (and higher)

namespace Subro.IO
{

using System;

#if Net20

using System.Collections.Generic;

#else
using System.Collections;
#endif

using System.Text;
using Microsoft.Win32;
using System.Drawing;
using System.IO;
using System.Windows.Forms;
/// <summary>
/// Information around a registered file extension.
/// Use the static functions to get lists
/// </summary>
public partial class FileExtension : FileRegKey
{

public FileExtension(string Extension)

: base(Extension)

{
}
/// <summary>
/// The extension this <see cref="FileExtension"/> class holds information for
/// </summary>
public string Extension
{

get { return Name; }
set
{

Name = value;

}

}
protected override bool CheckValue(ref string value)
{

if (!CheckExtension(value))

throw new Exception("Invalid Extension format: " + value
+ ".\nFormat should be a dot followed by one or more allowed characters (Vague isn't it? See the AllowedCharacters constant for a list. Of course letters and digits are also allowed).");

return base.CheckValue(ref value);

}
#region Registry

protected override void onKeyChanged()
{

setStarter();
base.onKeyChanged();

}
public override void Refresh()
{

starter = null;
base.Refresh();

}
/// <summary>
/// The value defined in the main registry entry that points
/// to the key that contains the start information. This value can be the
/// same as that of other extensions to use the same data (eg, .zip,.pkzip,.tar can point to the same location)
/// NB, changing this property means creating a new <see cref="Starter"/>
///
/// In general it's more user friendly to assign this through the <see cref="Starter"/> property unless
/// assigning to an existing info entry
/// </summary>
public string AssociatedName
{

get
{

return DefaultValue as string;

}
set
{

if (value == null) throw new ArgumentNullException();
if (DefaultValue != null && AssociatedName.ToLower() == value.ToLower())

return;

DefaultValue = value;
setStarter();

}

}
#endregion
private FileStarter starter;
/// <summary>
/// The <see cref="FileStarter"/> information associated with this file
/// </summary>
public FileStarter Starter
{

get
{

GetKey();
if (starter == null) //create a default starter

AssociatedName = Extension.Substring(1) + " Files";

return starter;

}
set
{

starter = value;
AssociatedName = value == null ? null : value.Name;

}

private void setStarter()
{

if (Exists())
{

string subname = AssociatedName;
if (subname != null)
{

if (starter == null || starter.Name.ToLower() != subname.ToLower())

starter = new FileStarter(subname);

return;

}

}
starter = null;

}
/// <summary>
/// Gets the description of the associated file
/// You can set this property through the <see cref="Starter"/> property.
/// If no <see cref="Starter"/> is assigned, the contenttype is returned
/// </summary>
public string Description
{

get
{

GetKey();
if (starter == null) return ContentType;
return starter.Description;

}

}
/// <summary>
/// Gets the icon-name of the associated <see cref="Starter"/>
/// </summary>
/// <returns></returns>
public string GetIconName()
{

GetKey();
if (starter == null) return null;
return starter.IconFileName;

}
/// <summary>
/// Gets the icon of the associated <see cref="Starter"/>
/// </summary>
/// <returns></returns>
public Icon GetIcon()
{

GetKey();
if (starter == null) return GetDefaultIcon();
return starter.GetIcon();

}
static Icon defaultIcon;
/// <summary>
/// Gets the icon used for unknown file types
/// </summary>
/// <returns></returns>
public static Icon GetDefaultIcon()
{

if (defaultIcon == null)
{

defaultIcon = ExtractIcon("shell32.dll");

}
return defaultIcon;

}
public static Icon ExtractIcon(string File)
{

return ExtractIcon(File, 0);

}
public static Icon ExtractIcon(string File, int Index)
{

//In .net 2.0 there's a static method Icon.ExtractAssociatedIcon, but this does not support
//indexes (only the first icon is extracted)
//that's why for version 2.0 as well as the prior ones, the dllimport below is used
IntPtr h = ExtractIcon(0, File, Index);
return Icon.FromHandle(h);

}
[System.Runtime.InteropServices.DllImport("shell32.dll")]
extern static IntPtr ExtractIcon(int hInst, string lpszExeFileName, int nIconIndex);

const string ContentTypeValue = "Content Type";
/// <summary>
/// The content type description for the current entry.
/// </summary>
public string ContentType
{

get
{

return GetValue(ContentTypeValue) as string;

}
set
{

SetValue(ContentTypeValue, value);

}

/// <summary>
/// Returns the extension and the descriptive text
/// </summary>
/// <returns></returns>
public override string ToString()
{

return Extension + ": " + Description;

}

}
/// <summary>
/// Base class for <see cref="FileExtension"/> and <see cref="FileStarter"/>
/// </summary>
public class FileRegKey : RegKey
{

public FileRegKey(string Name)

: base(Registry.ClassesRoot, Name)

{
}

}
/// <summary>
/// Wrapper around a <see cref="Microsoft.Win32.RegistryKey"/>
/// </summary>
public class RegKey
{

public readonly RegKey Root;
private RegistryKey rootkey;
public RegistryKey RootKey
{

get
{

if (Root == null)

return rootkey;

return Root.RegistryKey;

}

}
public string FullName
{

get
{

return (Root == null
? rootkey.Name
: Root.FullName)
+ @"\" + name;

}

}
public RegKey(RegKey BaseDir, string Name)
{

if (BaseDir == null) throw new ArgumentNullException();
Root = BaseDir;
this.Name = Name;

}
public RegKey(RegistryKey BaseDir, string Name)
{

if (BaseDir == null) throw new ArgumentNullException();
this.rootkey = BaseDir;
this.Name = Name;

}
private string name;
/// <summary>
/// The name of the key.
/// NB, changing the name looks up or creates a new key, it will not
/// rename the existing one
/// </summary>
internal string Name
{

get { return name; }
set
{

if (name != null && !AllowNameChange()) return; //throw instead?
if (value == null)

throw new ArgumentNullException();

if (CheckValue(ref value))
{

name = value;
Refresh();

}

}
protected virtual bool AllowNameChange()
{

return true;

}
/// <summary>
/// Normally the registry key is looked up once and the values buffered, but if an external program has altered
/// the registry, you can force a refresh with this method
/// </summary>
public virtual void Refresh()
{

regkey = null;
regkeysSearched = false;

}
protected virtual bool CheckValue(ref string value)
{

return true;

}
/// <summary>
/// Indicates if this key already exists
/// </summary>
/// <returns></returns>
public bool Exists()
{

GetKey();
return regkey != null;

}
bool regkeysSearched;
RegistryKey regkey;
/// <summary>
/// Gets the corresponding registry key (if any)
/// </summary>
public RegistryKey RegistryKey
{

get
{

GetKey();
return regkey;

}

}
/// <summary>
/// The default value for the current entry
/// </summary>
public object DefaultValue
{

get
{

return GetValue(null);

}
set
{

SetValue(null, value);

}

}
public object GetValue(string Name)
{

GetKey();
if (regkey == null) return null;
return regkey.GetValue(Name);

}
public void SetValue(string Name, object value)
{

Writable = true;
RegistryKey.SetValue(Name, value);

}
/// <summary>
/// Forcibly creates this subkey
/// </summary>
public void Create()
{

if (!Exists())
{

if (Root != null) Root.Writable = true;
RootKey.CreateSubKey(name);
Refresh();

}

}
/// <summary>
/// Forces a flush of the changes if values have been changed
/// </summary>
public void Flush()
{

if (regkey != null) regkey.Flush();

}
/// <summary>
/// Writes any changes to disk
/// </summary>
public void Close()
{

if (regkey != null) regkey.Close();

}
/// <summary>
/// Gets a <see cref="RegKey"/> indicating a subkey for this item.
/// If it doesn't exist, it will be created if a value is set.
/// You can also use <see cref="CreateSubKey"/> to ensure it is created.
/// </summary>
/// <param name="Name"></param>
/// <returns></returns>
public RegKey GetSubKey(string Name)
{

return new RegKey(this, Name);

}
/// <summary>
/// Same as <see cref="GetSubKey"/>, but this method forces the creation
/// where <see cref="GetSubKey"/> just returns the object which will create
/// itself when needed (a value is set)
/// </summary>
/// <param name="Name"></param>
/// <returns></returns>
public RegKey CreateSubKey(string Name)
{

RegKey key = GetSubKey(Name);
if (!key.Exists())

key.Create();

return key;

}
/// <summary>
/// Get the registry information if not done so already after the last Refresh
/// </summary>
protected void GetKey()
{

if (!regkeysSearched)
{

regkeysSearched = true;
if (Root == null)
{

if (rootkey == null)

throw new Exception("No root was specified!");

}
else if (Root.Exists())
{

//RegistryKey classes = ;
rootkey = Root.RegistryKey;

}
if (rootkey != null)

regkey = rootkey.OpenSubKey(name, writable);

onKeyChanged();

}

}
private bool writable;
/// <summary>
/// The current state of the registry key. This property can be set manually, but
/// this isn't really necessary. Normally a key is opened as readonly and switched
/// to writable only when required.
/// NB: when set to writable, this key will be created when it doesn't exist yet (see <see cref="Create"/>)
/// </summary>
public bool Writable
{

get { return writable; }
set
{

if (writable == value) return;
writable = value;
if (value)
{

Create();

}
Refresh();

}

protected virtual void onKeyChanged()
{
}

}
/// <summary>
/// The extra info for a <see cref="FileExtension"/>. This is a reusable entry that
/// can be used for multiple extensions.
/// eg, one starter can be used for ".zip",".tar",".gz", etc.
/// </summary>
public class FileStarter : FileRegKey
{

public FileStarter(string Name)

: base(Name)

{
}
/// <summary>
/// The description of the files that are started by this entry
/// </summary>
public string Description
{

get { return DefaultValue as string; }
set
{

DefaultValue = value;

}

}
const string showextValueName = "AlwaysShowExt";
/// <summary>
/// Self descriptive really eh :p
/// </summary>
public bool AlwaysShowExtension
{

get
{

object o = GetValue(showextValueName);
if (o == null) return false;
return (int)o == 1;

}
set
{

if (AlwaysShowExtension == value) return;
if (value)

SetValue(showextValueName, 1);

else if (Exists())

this.RegistryKey.DeleteValue(showextValueName);

}

}
const string defaultIconEntry = "DefaultIcon";
/// <summary>
/// The name of the icon associated with this type
/// </summary>
public string IconFileName
{

get
{

RegKey key = GetIconEntry();
if (key == null) return null;
return key.DefaultValue as string;

}
set
{

RegKey key = GetIconEntry();
if (key != null)

key.DefaultValue = value;

}

}
/// <summary>
/// Loads the icon specified in <see cref="IconFileName"/>
/// </summary>
/// <returns></returns>
public System.Drawing.Icon GetIcon()
{

string file = IconFileName;
if (file != null)
{

if (File.Exists(file))

return new System.Drawing.Icon(file);

else
{

int p = file.LastIndexOf(',');
int i;
if (p != -1 && int.TryParse(file.Substring(p + 1), out i))
{

return FileExtension.ExtractIcon(file.Substring(0, p), i);

}

}
return FileExtension.GetDefaultIcon();

}
public RegKey GetIconEntry()
{

return GetSubKey(defaultIconEntry);

}
protected override void onKeyChanged()
{

shell = shellex = null;
base.onKeyChanged();

}
FileStarterShell shell, shellex;
/// <summary>
/// Contains the actual start information
/// </summary>
public FileStarterShell Shell
{

get
{

if (shell == null)

shell = new FileStarterShell(this, false);

return shell;

}

}
/// <summary>
/// The application or command used to open the file.
/// If you assign this value manually, don't forget to add a "%1" if you want
/// to include the file to open
/// </summary>
public string OpenCommand
{

get { return Shell.OpenCommand; }
set { Shell.OpenCommand = value; }

}
/// <summary>
/// Contains the start information if it has to use ShellEx.
/// Normally you don't have to use this and can use <see cref="Shell"/> instead
/// </summary>
public FileStarterShell ShellEx
{

get
{

if (shellex == null)

shellex = new FileStarterShell(this, true);

return shellex;

}

}
/// <summary>
/// The actual shell info to start a <see cref="FileStarter"/> application
/// </summary>
public class FileStarterShell : RegKey
{

public FileStarterShell(FileStarter owner, bool Ex)

: base(owner, Ex ? "shellEx" : "shell")

{

Open = AddMenu("open");
Edit = AddMenu("edit");
PrintTo = AddMenu("printto");
Play = AddMenu("play");

}
/// <summary>
/// Commands to normally open a file (doubleclick in explorer)
/// </summary>
public readonly FileStarterShellMenu Open;
/// <summary>
/// Commands to edit a file (edit in the right click explorer menu)
/// </summary>
public readonly FileStarterShellMenu Edit;
/// <summary>
/// Commands when to print (print in right click explorer menu)
/// </summary>
public readonly FileStarterShellMenu PrintTo;
/// <summary>
/// Commands with which to play (play in right click explorer menu, used for media files)
/// </summary>
public readonly FileStarterShellMenu Play;
/// <summary>
/// Returns the menu with the specified name.
/// The default menus such as Open and PrintTo can also be obtained directly
/// </summary>
/// <param name="MenuName"></param>
/// <returns></returns>
public FileStarterShellMenu this[string MenuName]
{

get
{

string search = MenuName.ToLower();
foreach (FileStarterShellMenu f in menus)
{

if (f.Name == search) return f;

}
return AddMenu(MenuName);

}

}
/// <summary>
/// An extra function around the indexed property to make it easier to find ;-)
/// </summary>
/// <param name="MenuName"></param>
/// <returns></returns>
public FileStarterShellMenu GetMenu(string MenuName)
{

return this[MenuName];

}
private FileStarterShellMenu AddMenu(string name)
{

FileStarterShellMenu m = new FileStarterShellMenu(this, name);
menus.Add(m);
return m;

}

#if Net20

List<FileStarterShellMenu> menus = new List<FileStarterShellMenu>();

#else
ArrayList menus = new ArrayList();
#endif

/// <summary>
/// sets the commandline (application) to open the file
/// </summary>
public string OpenCommand
{

get { return Open.Command; }
set { Open.Command = value; }

}
protected override bool AllowNameChange()
{

return false;

}

}
public class FileStarterShellMenu : RegKey
{

public readonly FileStarterShell Owner;
internal FileStarterShellMenu(FileStarterShell owner, string Name)

: base(owner, Name)

{

this.Owner = owner;
commandKey = new RegKey(this, "command");

}
protected override bool AllowNameChange()
{

return false;

}
readonly RegKey commandKey;
/// <summary>
/// Assign the command to start up with the specified application
/// </summary>
/// <param name="path"></param>
public void SetApplication(string path)
{

Command = path + @" %1";

}
public string Command
{

get { return commandKey.DefaultValue as string; }
set { commandKey.DefaultValue = value; }

}

}
/// <summary>
/// This part of the class contains the static functions
/// </summary>
public partial class FileExtension
{

#if Net20

public static IEnumerable<FileExtension> EnumerateExtensionInfo()
{

foreach (string subkeyname in GetRegisteredExtensions())
{

yield return new FileExtension(subkeyname);

}

}
/// <summary>
/// Returns the names of all the registered extensions (including the general '*').
/// The StartsWith value indicates what to search for (null or "." returns all, "ex" returns ".exe",".ex_" etc)
/// </summary>
/// <returns></returns>
public static IEnumerable<string> GetRegisteredExtensions(string StartsWith)
{

return GetRegisteredExtensions(StartsWith, false);

}
public static IEnumerable<string> GetRegisteredExtensions()
{

return GetRegisteredExtensions(".", true);

}
/// <summary>
///
/// </summary>
/// <param name="StartsWith"></param>
/// <param name="IncludeDefault"><c>true</c> if the general '*' entry should be included, otherwise <c>false</c></param>
/// <returns></returns>
public static IEnumerable<string> GetRegisteredExtensions(string StartsWith, bool IncludeDefault)
{

if (IncludeDefault)

yield return "*";

RegistryKey classes = Registry.ClassesRoot;
foreach (string subkeyname in classes.GetSubKeyNames())
{

if (subkeyname.StartsWith(StartsWith))

yield return subkeyname;

}

#endif

/// <summary>
/// Characters that are allowed besides characters or digits.
/// </summary>
public const string AllowedCharacters = "-_";
/// <summary>
/// Checks if the specified Extension has a valid setup
/// </summary>
/// <param name="Extension"></param>
/// <returns></returns>
public static bool CheckExtension(string Extension)
{

if (Extension == "*") return true;
//check extension type (could have used regex, but went for the speed)
if (Extension.Length < 2) return false;
if (Extension[0] != '.') return false;
for (int i = 1; i < Extension.Length; i++)
{

if (!char.IsLetterOrDigit(Extension[i]))
{

if (AllowedCharacters.IndexOf(Extension[i]) == -1)

return false;

}

}
return true;

}
static RegistryKey RenameKey(RegistryKey key, string NewName)
{

//must be a better way than this to simply rename...
string name = key.Name;
return key;

}

/// <summary>
/// Sets the application as the name for the startup group
/// </summary>
/// <param name="Application"></param>
/// <param name="Extension"></param>
public static FileExtension RegisterApplication(string Application, string Extension)
{

FileExtension ext = new FileExtension(Extension);
ext.Starter.Shell.Open.SetApplication(Application);
return ext;

}
/// <summary>
/// assigns the specified extension to an existing application group
/// </summary>
/// <param name="StarterGroup"></param>
/// <param name="Extension"></param>
public static FileExtension AssignExtension(string StarterGroup, string Extension)
{

FileExtension ext = new FileExtension(Extension);
ext.AssociatedName = StarterGroup;
return ext;

}

/// <summary>
/// Wrapper around the <see cref="System.IO.FileInfo"/>, with some extra functionality such as the extension
/// </summary>
public class FileData
{

private FileInfo file;
public FileData() { }
public FileData(string File)
{

FileName = File;

}
/// <summary>
/// The filename for which this info is set
/// </summary>
public string FileName
{

get { return file == null ? null : file.FullName; }
set
{

if (FileName == value) return;
if (value == null || value.Trim().Length == 0)
{

file = null;

}
else
{

file = new FileInfo(value);

}
valid = file != null && file.Exists;
icon = null;
ext = null;
if (FileChanged != null)

FileChanged(this, EventArgs.Empty);

}

}
public event EventHandler FileChanged;
bool valid;
/// <summary>
/// Indicates whether a file is set and exists
/// </summary>
public bool IsValid
{

get { return valid; }

}
/// <summary>
/// Returns the underlying <see cref="FileInfo"/> object
/// </summary>
public FileInfo Info
{

get { return file; }

}
/// <summary>
/// The folder in which the file is held
/// </summary>
public string Folder
{

get { return file != null ? file.DirectoryName : null; }
set
{

if (file == null || Folder == value) return;
FileName = value + @"\" + (valid ? file.Name : null);

}

}
FileExtension ext;
/// <summary>
/// returns the extension information. NB: getting some properies of the Extension
/// causes registry entries to be created (by design).
/// If that is not the intention, check Extension.Exists() first.
/// </summary>
public FileExtension ExtensionInfo
{

get
{

if (ext == null && valid && FileExtension.CheckExtension(Extension))

ext = new FileExtension(Extension);

return ext;

}

}
public string Extension
{

get
{

if (file == null) return null;
return file.Extension;

}

Icon icon;
public Icon AssociatedIcon
{

get
{

if (icon == null)
{

#if Net20

if (valid)

try
{

icon = Icon.ExtractAssociatedIcon(FileName); //long live this new functionality!

}
catch { }

if(icon ==null)

#endif

if (ExtensionInfo != null)

icon = ext.GetIcon();

}
return icon;

}

#if Net20

public void DrawFile(Graphics g, Rectangle bounds, Font Font, bool IncludeIcon)
{

if (IncludeIcon)
{

int hw = Math.Min(32, bounds.Height - 2);
int y = (bounds.Height - hw) / 2;
Rectangle rIcon = new Rectangle(1, y, hw, hw);
if (AssociatedIcon != null)

g.DrawIcon(AssociatedIcon, rIcon);

else
{

rIcon.Inflate(-2, -2);
Pen pen = Pens.Red;
g.DrawRectangle(pen, rIcon);
g.DrawLine(pen, rIcon.X, rIcon.Y, rIcon.Right, rIcon.Bottom);
g.DrawLine(pen, rIcon.X, rIcon.Bottom, rIcon.Right, rIcon.Y);

}

hw = rIcon.Right + 4;
bounds.Offset(hw, 0);
bounds.Width -= hw;

}
string text = FileName;
SizeF s = g.MeasureString(text, Font);
if (s.Width < bounds.Width)
{

g.DrawString(text, Font, Brushes.Black, bounds);

}
else
{

TextFormatFlags flags = TextFormatFlags.SingleLine | TextFormatFlags.Right | TextFormatFlags.EndEllipsis;
TextRenderer.DrawText(g, file.Name, Font, bounds, Color.Black, flags);
s = TextRenderer.MeasureText(g, file.Name, Font, bounds.Size, flags);
float rem = bounds.Width - s.Width;
if (rem > 3)
{

bounds.Width = (int)rem;
Font = new Font(Font.FontFamily, Font.Size - 2, FontStyle.Italic);
TextRenderer.DrawText(g, file.DirectoryName, Font, bounds, Color.Black, flags);

}

#endif

}

. . .

Example code:
Will also post a little 'admin' program that uses the classes and some more examples some time in the future (not saying near future mind you :p)

Code CopyHideScrollFull

//simply assigning an application
FileExtension.RegisterApplication(@"t:\bla.bat", ".test2");

//Assigning an application and setting the icon
FileStarter starter = FileExtension.RegisterApplication(@"t:\bla.bat", ".test2").Starter;
starter.IconFileName = "FullFileNameOfTheIcon";

As said, the FileStarter class points to where it all happens.
That entry and not the extension entry decides the icon, the description and the right click options in windows explorer.

Those right click menu options are another interesting option to a file.
The default menu option 'open' also applies to opening by doubleclicking and some other entries belong to the defaults as well (printto and play to name a few), But creating new options for the right click menu is easy enough as well, they are subkeys of the shell entry just like the rest. Of course, this is also included in the wrapper:

Code CopyHideScrollFull

//this sets a test menu option only for the extension ".test2"
//you could also set it for ALL files by using: new FileExtension("*");
FileExtension ext = new FileExtension(".test2");
ext.Starter.Shell["Test menu"].Command = @"t:\bla.bat";

AutoFormatter 2.0 (Rtf to HTML conversion)

Robert Verpalen — Fri, 30 Dec 2005 12:14:00 GMT

(First introduced here: http://blogs.vbcity.com/hotdog/archive/2004/09/11/280.aspx , )
This is the second version of the AutoFormatter. Mainly intended for easily posting code blocks to .. let's say a blog, it can also be used for rtf conversion in general.

DOWNLOAD/INSTALL

Run exe (22-1-2006) The other options all want to access the internet to check for updates. Download or run this exe to use a version that does not try to do so. That also means of course that you might not use the last version

---While testing the .application extension link did not seem to be processed properly, so you might have some problems with the links below
Run directly Run AutoFormatter directly from the internet. You can visit this page first to check if the required framework is installed or for more info on ClickOnce deployment.

Setup Setup application to run on your local machine. If installed this way updates can be automatically downloaded.

SOURCE CODE
AutoFormatter.zip (version 7-1-2006) The zip contains the source code. Written visual C# 2005 express edition. This executable may from time to time be newer than the executable, because well... it's too much work to update the source as well for some minor changes :p

Requirements: .net framework 2.0 (click here for the msdn download page) If the setup file is used, a check for the framework is automatically performed

Screenshots:
rtf
Advanced options
Preview

Note to upgraders from 1.0 : AF2.0 uses the improved applicationsettings functionality of the .net 2.0 framework and no longer the xml dataset. That means old settings are not ported, but they weren't that many, so hopefully that won't be seen as a drawback.

Some development info:

At first the AF was a quick and dirty way to be able to post code onto my blog, but since more people than just me seem to be using it (maybe just 2 people, but hey, that's still more than just me), decided to try and make it a 'complete' tool with better functionality. Also rewritten and cleaned most of it up, so that expanding shouldn't be too much of a problem.
The AutoFormatter contains custom objects that can parse themselves to html format. Eg there's a style class with a minimum of properties/attributes, which are the ones being used by the codeblock, such as background-color and onClick. The properties/attributes themselves are fields of the class type CanAppend, which is parsed automatically if a value is set. Other properties are therefore easily added in the html classes without having to add any parsing code.
I'm pretty content with how it turned out now. Some features will be added in the future, but I like its current look and feel.
The original plan was to use the .net 2.0 build in html elements (of System.Windows.Forms, used in the browser control), but they turned out to be insufficient adaptable for the set goal. Turned out those objects in turn used mshtml objects in the background. Those had all the html options with them and are included in the framework. Rewrote the code to use mshtml which worked great. Unfortunately, some of its behaviour I did not like. The goal was to keep the produced code to a minumum and the mshtml sometimes bloated for example the border settings. Besides that it was a tad slower (not much really, mainly the initializing the first time) . All and all I wanted to keep total control and went back to creating custom classes. Just wanted to say that here in case you were wondering why the available options weren't used ;-)

TODO (per 17/1/2006):
-Create file directly
-Upload the file
-Support (embedded) images. This will be done in combination with the creating/uploading of a file
-custom replacements from rtf characters to html tags
~~-custom style settings~~ (implemented on a basic level per 7-1-2006)
-Assigning class ids so css sheets can be used to set the default styles (and ability to create css info)
~~-ColorPicker should support choosing transparant.~~ (Implemented per 7-1-2006)
~~-Unicode characters~~ (Implemented per 22-1-2006)
-Bullet list
-Keywords (C#,TSQL,VB, and any custom set)

About the keywords. That is, defining sets of keywords that get a specific formatting (eg for TSQL: “select“,“from“,“update“, etc. get a style of “color:blue“) Not too big a problem, but still much work. The real problem is if people really need it? What this would do, is format keywords after the rtf formatting is applied, so as an extra. The setup would be to simply select 'none' or a file of keyword settings to apply. The keyword file would contain pairs of keywords and style settings, where the style is the normal html style tag. (and cascading to quickly apply a style to multiple keywords).
So, if any of you are interested in such features, please drop me a note, so I know it wouldn't be a useless feature. cheers.