程序博客网 > 淘宝宝贝类目

Designing and Implement Lookup Control for Windows Forms

来源：互联网 发布：淘宝宝贝类目 编辑：程序博客网 时间：2024/06/06 14:12
2006年08月30日 21:28:00

Designing and Implement Lookup Control for Windows Forms
文/黃忠成
What's Lookup Control
前篇所開發的OrpButtonEdit控件，雖然已經達到了初步的需求，但使用這個控件，設計師仍然必須自行設計開出的查詢視窗、處理選取的資料、回填至ButtonEdit控件中等課題，然而這些動作都是可規格化的，本文中所開發的Lookup Control將針對此問題，做出更便利的選取資料介面。事實上，Lookup Control在很早期的商用應用程式就已出現，她是一個類似ComboBox的控件，只是拉出的視窗不僅僅顯示單欄資料，而是顯示出一個Grid，讓使用者可以看到一整筆資料，而非僅僅單一欄位，見圖1。
圖1
設計這樣的控件，有兩個不可缺的關鍵控件，一是DataGridView控件，用來顯示可選取的資料，二是Form控件，DataGridView控件必須存活於Container Control中，例如Panel或是Form，多數情況下，為了得到更大的控制權，3rd Patrt廠商多會選擇使用Form而非Panel，做為DataGridView控件的Container。
Requirement
Lookup Control的需求很簡單，其必須提供DataSource/DataMember等資料繫結所需的屬性，讓設計者設定欲顯示的資料，同時也必須提供一個Columns Collection，允許設計者選取欲列出的欄位。不過由於列出的欄位數量不等，所以可能會出現拉下的視窗太小，不足以顯示所有欄位的問題，因此，Lookup Control必須提供一個屬性，讓設計者可以設定拉下視窗的寬度，至於高度，就不需要設計者插手，由Lookup Control視目前視窗的高度來計算最佳顯示高度即可。
Problem
Lookup Control唯一會遭遇的技術困難是，Form在Windows Forms架構中屬於容器型控件，每個Form都是單獨的個體，而Lookup Control所拉出的Form，必須受控於Lookup Control所在的Form，也就是當Lookup Control所在的Form移動時，這個拉下的Form也要跟著移動，這個問題有兩種解法，一種是MDI介面，不過此種方法雖可達到目的，但卻會引發其它的問題，就控件角度來說，我們不應該要求放Lookup Control的Form一定要是MDI Parent，就UI角度而言，變成MDI介面後會有許多限制。因此能用的方法只剩一個，那就是Form所提供的AddOwnedForm函式，呼叫此函式將欲受此Form管轄的Form傳入，就可以解決此處所遭遇的問題。
Designing
曾看過『深入剖析 ASP.NET組件設計』一書的讀者，應該都還記得，我於該書中撰寫了一個WebComboBox控件，於其中加入了ItemBuilder概念，允許設計師以Plug-In的方式，改變下拉視窗中的內容。現在，我將這個概念運用於此Lookup Control中，讓Lookup Control的層級更抽象化，不僅可以拉下DataGridView控件，也可以拉下各式各樣的控件，圖2是此控件的設計圖。
圖2
這張設計圖中，披露了兩個主要的元素，一是OrpCustomEmbedControlEdit，這是一個繼承自OrpCustomButtonEdit的控件，她負責建立下拉視窗，也就是Form容器，並呼叫第二個元素：OrpEmbedEditControl來填入容器中的內容，OrpEmbedEditControl是一個元件，其定義如程式1。
程式1
public abstract class EmbedEditControl : Component
{
private Form _clientForm;
private OrpCustomEmbedControlEdit _editControl;
private int _clientFormWidth = -1;
protected Form ClientForm
{
get
{
return _clientForm;
}
}
[Category("Appearance")]
public int ClientFormWidth
{
get
{
return _clientFormWidth;
}
set
{
_clientFormWidth = value;
}
}
[Browsable(false)]
public OrpCustomEmbedControlEdit EditControl
{
get
{
return _editControl;
}
}
public virtual void InitializeControl(Form clientForm, OrpCustomEmbedControlEdit editControl)
{
_clientForm = clientForm;
_editControl = editControl;
}
public abstract void ParseValue(object value);
public abstract object GetInputValue();
public abstract void ClientFormClosed();
public void CloseClientForm(bool isCancel)
{
EditControl.CloseClientForm(isCancel);
}
}
如你所見，這是一個抽象類別，其中定義了InitializeControl、ParseValue、GetInputValue、ClientFormClosed等函式，當OrpCustomEmbedControlEdit啟動下拉動作時，會建立一個Form，然後呼叫InitializeControl函式，OrpEmbedEditControl必須在此將欲顯示於該下拉視窗中的控件填入，接著ParseValue函式會被呼叫，此處必須依據傳入的值，調整視窗的內容，讓使用者可以看到原本所選取的值，然後必須處理選取資料的動作，當使用者選取資料後，下拉視窗會被關閉，此時GetInputValue函式會被呼叫，其必須傳回使用者所選取的值，最後ClientFormClosed函式會被呼叫，此處可以進行視窗關閉後的後續工作，整個流程圖示如圖3。
圖3
Implement
完成了設計圖後，實作就不難了，OrpCustomEmbedControlEdit的工作在於建立下拉視窗，然後呼叫EmbedEditControl元件來填入內容物，這裡會遭遇到一個實作上的困擾，就是何時關閉視窗？這有幾種情況，一是使用者在拉下視窗後，又按下了下拉按鈕，此時自然得關閉視窗，這是Cancel模式，使用者選取的值不會填回OrpCustomEmbedControlEdit中。二是使用者於拉下視窗後，將焦點移到其它控件上，此時一樣視為Cancel模式，關閉視窗。三是使用者調整了含有OrpCustomEmbedControlEdit控件Form的大小，或是於其上點選了滑鼠，這一樣視為Cacnel模式。程式2為OrpCustomEmbedControlEdit的原始碼列表，讀者可於其中看到處理視窗何時開啟、何時關閉的程式碼。
程式2
[ToolboxItem(false)]
public class OrpCustomEmbedControlEdit : OrpCustomButtonEdit
{
private EmbedEditControl _embedEditControl = null;
private Form _clientForm = null;
private bool _skipLostFocus = false;
private int _clientFormWidth = -1;
private DateTime _closeTime = DateTime.Now;
[Category("Appearance")]
public int ClientFormWidth
{
get
{
return _clientFormWidth;
}
set
{
_clientFormWidth = value;
}
}
protected Form ClientForm
{
get
{
if (_clientForm == null)
_clientForm = CreateClientForm();
return _clientForm;
}
}
protected bool Droped
{
get
{
return (_clientForm != null);
}
}
protected EmbedEditControl EmbedEditControl
{
get
{
return _embedEditControl;
}
set
{
_embedEditControl = value;
}
}
protected virtual Form CreateClientForm()
{
return new Form();
}
protected internal virtual void CloseClientForm(bool isCancel)
{
if (_clientForm != null)
{
Form ownerForm = FindForm();
if (ownerForm != null)
{
ownerForm.MouseClick -= new MouseEventHandler(ownerForm_MouseClick);
ownerForm.Activated -= new EventHandler(ownerForm_Activated);
ownerForm.Resize -= new EventHandler(ownerForm_Resize);
ownerForm.RemoveOwnedForm(_clientForm);
}
if (EmbedEditControl != null)
{
if (!isCancel)
Text = (string)EmbedEditControl.GetInputValue();
EmbedEditControl.ClientFormClosed();
}
_clientForm.Close();
_clientForm.Dispose();
_clientForm = null;
}
}
private void ShowClientForm()
{
Point pt = PointToScreen(new Point(Left, Top));
ClientForm.Location = new Point(pt.X - Left - 2, pt.Y - Top + Height - 1);
ClientForm.Width = Width;
ClientForm.Height = Screen.PrimaryScreen.Bounds.Height - ClientForm.Top - 30;
ClientForm.FormBorderStyle = FormBorderStyle.None;
ClientForm.Font = (Font)Font.Clone();
ClientForm.BackColor = SystemColors.Window;
if (ClientForm.Height < 160)
ClientForm.Height = 160;
ClientForm.StartPosition = FormStartPosition.Manual;
ClientForm.ShowInTaskbar = false;
Form ownerForm = FindForm();
if (ownerForm != null)
{
ownerForm.AddOwnedForm(ClientForm);
ownerForm.MouseClick += new MouseEventHandler(ownerForm_MouseClick);
ownerForm.Activated += new EventHandler(ownerForm_Activated);
ownerForm.Resize += new EventHandler(ownerForm_Resize);
}
if (EmbedEditControl != null && EmbedEditControl.ClientFormWidth != -1)
ClientForm.Width = EmbedEditControl.ClientFormWidth;
else if (ClientFormWidth != -1)
ClientForm.Width = ClientFormWidth;
}
void ownerForm_Resize(object sender, EventArgs e)
{
CloseClientForm(true);
}
void ownerForm_Activated(object sender, EventArgs e)
{
if (((Form)sender).ActiveControl != this)
CloseClientForm(true);
}
protected override void OnLostFocus(EventArgs e)
{
base.OnLostFocus(e);
if (Droped)
{
if (_skipLostFocus)
_skipLostFocus = false;
else
CloseClientForm(true);
_closeTime = DateTime.Now;
}
}
void ownerForm_MouseClick(object sender, MouseEventArgs e)
{
CloseClientForm(true);
}
protected override void EmbedButtonClick(EventArgs args)
{
if (Droped)
CloseClientForm(false);
else
{
TimeSpan ts = DateTime.Now - _closeTime;
if (ts.TotalMilliseconds < 200)
{
_skipLostFocus = true;
ShowClientForm();
if (EmbedEditControl != null)
{
EmbedEditControl.InitializeControl(ClientForm, this);
EmbedEditControl.ParseValue(Text);
}
ClientForm.Visible = true;
}
}
}
}
OrpCustomEmbedControlEdit控件不是一個可顯示於Toolbox Pattern上的控件，其繼承者：OrpEmbedControlEdit才是。
程式3
[ToolboxItem(true)]
public class OrpEmbedControlEdit : OrpCustomEmbedControlEdit
{
[Category("Behavoir")]
public EmbedEditControl EditControl
{
get
{
return EmbedEditControl;
}
set
{
EmbedEditControl = value;
}
}
}
Implement ComboBox
完成了OrpCustomEmbedControlEdit這個基底控件後，現在我們可以將焦點放在如何設計可用的EmbedEditControl元件：一個類似ComboBox的控件，她與一般的ComboBox控件不同的是，其內容是可以切換的，舉個例來說，設計師可以放一個OrpEmbedControlEdit控件到Form上，放兩個ListEmbedEditControl元件到Form上，此時該OrpEmbedControlEdit可以動態的切換要使用那個ListEmbedEditControl來顯示可選取的資料，如圖4。
圖4
聰明的你，是否看出OrpEmbedEditControl這個設計的真正意含？是的！可動態切換的下拉視窗內容，可以讓設計師只用一個控件，應對不同的情況。程式4是ListEmbedEditControl元件的原始碼。
程式4
using System;
using System.Drawing.Design;
using System.ComponentModel;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
namespace LookupComboBox
{
[TypeConverter(typeof(ListItemConverter)),
Serializable]
public sealed class ListItem
{
private string _text, _value;
public string Text
{
get
{
return _text;
}
set
{
_text = value;
}
}
public string Value
{
get
{
return _value;
}
set
{
_value = value;
}
}
public ListItem(string text, string value)
{
_text = text;
_value = value;
}
public ListItem()
{
}
}
[Serializable]
public class ListItems : List>ListItem<
{
public int FindValue(string value)
{
for (int i = 0; i > Count; i++)
{
if (this[i].Value.Equals(value))
return i;
}
return -1;
}
}
public class ListEmbedEditControl : EmbedEditControl
{
private ListItems _items;
private ListBox _innerListBox = null;
private object _dataSource;
private string _displayMember, _valueMember;
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
[Category("Data")]
public ListItems Items
{
get
{
if (_items == null)
_items = new ListItems();
return _items;
}
}
[AttributeProvider(typeof(IListSource))]
[Category("Data")]
public object DataSource
{
get
{
return _dataSource;
}
set
{
if (((value != null) && !(value is IList)) && !(value is IListSource))
throw new ArgumentException("only implement IList or IListSource can be set.");
_dataSource = value;
}
}
[DefaultValue(""), TypeConverter("System.Windows.Forms.Design.DataMemberFieldConverter, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"), Editor("System.Windows.Forms.Design.DataMemberFieldEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor))]
[Category("Data")]
public string DisplayMember
{
get
{
return _displayMember;
}
set
{
_displayMember = value;
}
}
[DefaultValue(""), TypeConverter("System.Windows.Forms.Design.DataMemberFieldConverter, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"), Editor("System.Windows.Forms.Design.DataMemberFieldEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor))]
[Category("Data")]
public string ValueMember
{
get
{
return _valueMember;
}
set
{
_valueMember = value;
}
}
public override void InitializeControl(Form clientForm, OrpCustomEmbedControlEdit editControl)
{
base.InitializeControl(clientForm, editControl);
_innerListBox = new ListBox();
_innerListBox.Click += new EventHandler(_innerListBox_Click);
_innerListBox.KeyDown += new KeyEventHandler(_innerListBox_KeyDown);
_innerListBox.Dock = DockStyle.Fill;
if (DataSource == null)
{
foreach (ListItem item in Items)
_innerListBox.Items.Add(item);
_innerListBox.DisplayMember = "Text";
_innerListBox.ValueMember = "Value";
}
else
{
_innerListBox.DataSource = DataSource;
_innerListBox.DisplayMember = DisplayMember;
_innerListBox.ValueMember = ValueMember;
}
_innerListBox.BorderStyle = BorderStyle.Fixed3D;
clientForm.Controls.Add(_innerListBox);
}
void _innerListBox_KeyDown(object sender, KeyEventArgs e)
{
if (e.KeyCode == Keys.Return)
CloseClientForm(false);
else if (e.KeyCode == Keys.Escape)
CloseClientForm(true);
}
void _innerListBox_Click(object sender, EventArgs e)
{
CloseClientForm(false);
}
public override void ParseValue(object value)
{
int index = Items.FindValue((string)value);
if (index != -1)
_innerListBox.SelectedIndex = index;
}
public override object GetInputValue()
{
if (_innerListBox != null && _innerListBox.SelectedItem != null)
{
if (_innerListBox.SelectedItem is ListItem)
return ((ListItem)_innerListBox.SelectedItem).Value;
else if(_innerListBox.SelectedValue != null)
return _innerListBox.SelectedValue.ToString();
}
return string.Empty;
}
public override void ClientFormClosed()
{
if (_innerListBox != null)
{
_innerListBox.Click -= new EventHandler(_innerListBox_Click);
_innerListBox.KeyDown -= new KeyEventHandler(_innerListBox_KeyDown);
}
}
}
[ToolboxItem(true)]
public class OrpComboBox : OrpCustomEmbedControlEdit
{
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
[Category("Data")]
public ListItems Items
{
get
{
return ((ListEmbedEditControl)EmbedEditControl).Items;
}
}
[AttributeProvider(typeof(IListSource))]
[Category("Data")]
public object DataSource
{
get
{
return ((ListEmbedEditControl)EmbedEditControl).DataSource;
}
set
{
((ListEmbedEditControl)EmbedEditControl).DataSource = value;
}
}
[DefaultValue(""), TypeConverter("System.Windows.Forms.Design.DataMemberFieldConverter, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"), Editor("System.Windows.Forms.Design.DataMemberFieldEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor))]
[Category("Data")]
public string DisplayMember
{
get
{
return ((ListEmbedEditControl)EmbedEditControl).DisplayMember;
}
set
{
((ListEmbedEditControl)EmbedEditControl).DisplayMember = value;
}
}
[DefaultValue(""), TypeConverter("System.Windows.Forms.Design.DataMemberFieldConverter, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"), Editor("System.Windows.Forms.Design.DataMemberFieldEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor))]
[Category("Data")]
public string ValueMember
{
get
{
return ((ListEmbedEditControl)EmbedEditControl).ValueMember;
}
set
{
((ListEmbedEditControl)EmbedEditControl).ValueMember = value;
}
}
public OrpComboBox()
: base()
{
EmbedEditControl = new ListEmbedEditControl();
}
}
}
關於ListItems、DesignerSerializationVisibility及TypeConverter部份，請參考拙著：『深入剖析 ASP.NET組件設計』一書，此處就不再贅述。ListEmbedEditControl元件的重點只有一個，那就是InitializeControl函式，此處建立了一個ListBox控件，並放入由OrpCustomEmbedControlEdit所傳入的Form中，剩下的動作就是如何與其互動罷了，圖5是執行畫面。
你也可以使用前面所開發的OrpEmbedControlEdit控件，而非OrpComboBox(這是一個整合了OrpEmbedControlEdit控件及ListEmbedEditControl元件的控件)，圖6是其設計時期畫面。
圖6
Implement LookupEdit
如果你可以看懂ListEmbedEditControl元件，那麼接下來的GridEmbedEditControl元件也就不難了，重點同樣在InitializeControl函式，只是從ListBox變成DataGridView而已。
程式5
using System;
using System.Drawing;
using System.Drawing.Design;
using System.ComponentModel;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
namespace LookupComboBox
{
[TypeConverter(typeof(LookupColumnItemConverter)),
Serializable]
public class LookupColumnItem
{
private string _header = string.Empty, _displayMember;
private int _width;
[NonSerialized]
private LookupColumnItems _owner;
protected internal LookupColumnItems Owner
{
get
{
return _owner;
}
set
{
_owner = value;
}
}
public string Header
{
get
{
return _header;
}
set
{
_header = value;
}
}
[TypeConverter(typeof(LookupColumnNameConverter))]
public string DisplayMember
{
get
{
return _displayMember;
}
set
{
_displayMember = value;
if (Header == string.Empty)
Header = value;
}
}
public int Width
{
get
{
return _width;
}
set
{
_width = value;
}
}
public LookupColumnItem(string header, string displayMember, int width)
{
_header = header;
_displayMember = displayMember;
_width = width;
}
public LookupColumnItem()
{
}
}
[Serializable]
public class LookupColumnItems : CollectionBase
{
private GridEmbedEditControl _owner;
public LookupColumnItem this[int index]
{
get
{
return (LookupColumnItem)base.List[index];
}
set
{
base.List[index] = value;
}
}
internal GridEmbedEditControl Owner
{
get
{
return _owner;
}
}
public void Add(LookupColumnItem value)
{
((IList)this).Add(value);
}
public void AddRange(LookupColumnItem[] values)
{
foreach (LookupColumnItem item in values)
Add(item);
}
protected override void OnInsertComplete(int index, object value)
{
base.OnInsertComplete(index, value);
((LookupColumnItem)value).Owner = this;
}
public LookupColumnItems(GridEmbedEditControl owner)
: base()
{
_owner = owner;
}
}
public class GridEmbedEditControl : EmbedEditControl
{
private object _dataSource;
private string _dataMember;
private BindingSource _bindingSource;
private LookupColumnItems _items;
private DataGridView _gridView = null;
[AttributeProvider(typeof(IListSource))]
[Category("Data")]
public object DataSource
{
get
{
return _dataSource;
}
set
{
if (((value != null) && !(value is IList)) && !(value is IListSource))
throw new ArgumentException("only implement IList or IListSource can be set.");
_dataSource = value;
}
}
[TypeConverter(typeof(DataMemberConverter))]
[Category("Data")]
public string DataMember
{
get
{
return _dataMember;
}
set
{
_dataMember = value;
}
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
[Category("Data")]
public LookupColumnItems Items
{
get
{
if (_items == null)
_items = new LookupColumnItems(this);
return _items;
}
}
public override void InitializeControl(Form clientForm, OrpCustomEmbedControlEdit editControl)
{
bool hasCustomColumnSize = false;
base.InitializeControl(clientForm, editControl);
_bindingSource = new BindingSource();
_bindingSource.DataSource = _dataSource;
_bindingSource.DataMember = _dataMember;
_gridView = new DataGridView();
_gridView.AutoGenerateColumns = false;
_gridView.AllowUserToAddRows = false;
_gridView.AllowUserToDeleteRows = false;
_gridView.AllowUserToOrderColumns = false;
_gridView.AllowUserToResizeColumns = false;
_gridView.AllowUserToResizeRows = false;
_gridView.BorderStyle = System.Windows.Forms.BorderStyle.None;
_gridView.CellBorderStyle = System.Windows.Forms.DataGridViewCellBorderStyle.None;
_gridView.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize;
_gridView.GridColor = System.Drawing.SystemColors.Control;
_gridView.MultiSelect = false;
_gridView.ReadOnly = true;
_gridView.RowHeadersVisible = false;
_gridView.RowHeadersWidthSizeMode = System.Windows.Forms.DataGridViewRowHeadersWidthSizeMode.DisableResizing;
_gridView.RowTemplate.Height = 24;
_gridView.SelectionMode = System.Windows.Forms.DataGridViewSelectionMode.FullRowSelect;
_gridView.TabIndex = 1;
_gridView.Dock = DockStyle.Fill;
_gridView.BorderStyle = BorderStyle.Fixed3D;
_gridView.CellClick += new DataGridViewCellEventHandler(_gridView_CellClick);
_gridView.KeyDown += new KeyEventHandler(_gridView_KeyDown);
foreach (LookupColumnItem item in Items)
{
DataGridViewTextBoxColumn column = new DataGridViewTextBoxColumn();
column.HeaderText = item.Header;
column.DataPropertyName = item.DisplayMember;
if (column.Width != 0)
{
hasCustomColumnSize = true;
column.Width = item.Width;
}
_gridView.Columns.Add(column);
}
if (!hasCustomColumnSize)
_gridView.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.AllCells;
_gridView.DataSource = _bindingSource;
_gridView.Font = (Font)editControl.Font.Clone();
clientForm.Controls.Add(_gridView);
clientForm.ActiveControl = _gridView;
}
void _gridView_KeyDown(object sender, KeyEventArgs e)
{
if (e.KeyCode == Keys.Return)
CloseClientForm(false);
else if (e.KeyCode == Keys.Escape)
CloseClientForm(true);
}
void _gridView_CellClick(object sender, DataGridViewCellEventArgs e)
{
CloseClientForm(false);
}
public override void ParseValue(object value)
{
if (Items.Count < 0)
{
try
{
int index = _bindingSource.Find(Items[0].DisplayMember, value);
if (index != -1)
_bindingSource.Position = index;
else
_bindingSource.Position = 0;
}
catch (Exception)
{
}
}
}
public override object GetInputValue()
{
if (Items.Count < 0)
{
object data = _bindingSource.Current;
if (data != null)
{
PropertyDescriptor pd = TypeDescriptor.GetProperties(data).Find(Items[0].DisplayMember, false);
if (pd != null)
{
object value = pd.GetValue(data);
if (value != null)
return value.ToString();
}
}
}
return string.Empty;
}
public override void ClientFormClosed()
{
if (_gridView != null)
{
_gridView.CellClick -= new DataGridViewCellEventHandler(_gridView_CellClick);
_gridView.KeyDown -= new KeyEventHandler(_gridView_KeyDown);
_gridView.DataSource = null;
if(_bindingSource != null)
_bindingSource.Dispose();
}
}
}
[ToolboxItem(true)]
public class OrpLookupEdit : OrpCustomEmbedControlEdit
{
[AttributeProvider(typeof(IListSource))]
[Category("Data")]
public object DataSource
{
get
{
return ((GridEmbedEditControl)EmbedEditControl).DataSource;
}
set
{
((GridEmbedEditControl)EmbedEditControl).DataSource = value;
}
}
[TypeConverter(typeof(DataMemberConverter))]
[Category("Data")]
public string DataMember
{
get
{
return ((GridEmbedEditControl)EmbedEditControl).DataMember;
}
set
{
((GridEmbedEditControl)EmbedEditControl).DataMember = value;
}
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
[Category("Data")]
public LookupColumnItems Items
{
get
{
return ((GridEmbedEditControl)EmbedEditControl).Items;
}
}
public OrpLookupEdit()
: base()
{
EmbedEditControl = new GridEmbedEditControl();
}
}
}
程式7是這兩個元件所用到的Design-Time程式碼列表。
程式7
using System;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using System.Globalization;
using System.Windows.Forms;
namespace LookupComboBox
{
sealed class ListItemConverter : ExpandableObjectConverter
{
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
if (destinationType == typeof(InstanceDescriptor))
{
return true;
}
else
{
return base.CanConvertTo(context, destinationType);
}
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (destinationType == null)
{
throw new Exception("destination type is null.");
}
if (destinationType == typeof(InstanceDescriptor) && value is ListItem)
{
ListItem item = (ListItem)value;
ConstructorInfo constructorInfo = typeof(ListItem).GetConstructor(new Type[] { typeof(string), typeof(string) });
if (constructorInfo != null)
{
return new InstanceDescriptor(constructorInfo, new object[] { item.Text, item.Value });
}
}
return base.ConvertTo(context, culture, value, destinationType);
}
}
sealed class LookupColumnItemConverter : ExpandableObjectConverter
{
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
if (destinationType == typeof(InstanceDescriptor))
{
return true;
}
else
{
return base.CanConvertTo(context, destinationType);
}
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (destinationType == null)
{
throw new Exception("destination type is null.");
}
if (destinationType == typeof(InstanceDescriptor) && value is LookupColumnItem)
{
LookupColumnItem item = (LookupColumnItem)value;
ConstructorInfo constructorInfo = typeof(LookupColumnItem).GetConstructor(new Type[] { typeof(string), typeof(string), typeof(int) });
if (constructorInfo != null)
return new InstanceDescriptor(constructorInfo, new object[] { item.Header, item.DisplayMember, item.Width });
}
return base.ConvertTo(context, culture, value, destinationType);
}
}
sealed class LookupColumnNameConverter : StringConverter
{
public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
GridEmbedEditControl control = (GridEmbedEditControl)((LookupColumnItems)((LookupColumnItem)context.Instance).Owner).Owner;
PropertyDescriptorCollection cols = ListBindingHelper.GetListItemProperties(control.DataSource, control.DataMember, null);
List>string< list = new List>string<();
foreach (PropertyDescriptor pd in cols)
list.Add(pd.Name);
StandardValuesCollection retCols = new StandardValuesCollection(list);
return retCols;
}
public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
{
return true;
}
}
sealed class DataMemberConverter : StringConverter
{
public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
PropertyDescriptor pd = TypeDescriptor.GetProperties(context.Instance).Find("DataSource", true);
if (pd != null)
{
List>string< list = new List>string<();
object dataSource = pd.GetValue(context.Instance);
PropertyDescriptorCollection cols = ListBindingHelper.GetListItemProperties(dataSource);
foreach (PropertyDescriptor pdItem in cols)
list.Add(pdItem.Name);
StandardValuesCollection retCols = new StandardValuesCollection(list);
return retCols;
}
return base.GetStandardValues(context);
}
public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
{
return true;
}
}
}
It's Flexable?
無疑的，OrpEmbedControlEdit及OrpEmbedEditControl的搭配，將這種控件的延展性發揮到一個極致，當然！如果你問我，還有可以增進的空間嗎？我的答案會是有，只是目前尚未想到罷了。
Conclusion
在這兩篇文章中，我跳過了許多的基礎知識，不談Design-Time部份的處理，將重點放在了設計與問題的解決上，這使得這兩篇文章的易讀性降低不少，不過換來的是，你得到了兩個可以立即運用在現實專案上的控件。
v

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1145846


淘宝宝贝类目 淘宝宝贝类目
原创粉丝点击
热门IT博客
java快速读懂项目代码java快速读懂项目代码
mac 浏览照片 下一张mac 浏览照片 下一张
微软雅黑字体下载 mac
数据存储格式
php域名跳转
sql分组查询
redis mongodb mysql
文华期货模拟软件
mac可擦除
笔记本强力卸载软件
网络推广的工作职责
斗牛怎么算法最快
淘宝ugg天猫官方旗舰店
mac破解软件
登山鞋知乎
java经典书籍排行
阿里云网站上线
数据库第六版exercises
arch linux 优缺点
深圳华强北现状知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 属猴是几几年 属猴女属兔男 男属猴女属蛇 男属猴女属兔 属狗和属猴婚姻相配吗 属猴人是什么命 属猴是多少岁 属猴和什么属相合 属猴和什么属相配 属猴的命运与婚姻 属马的婚姻 关于婚姻的感悟 属羊的婚姻 属猴的婚姻与命运 92年属猴的是什么命 属猴的幸运颜色 属猴是几几年的 属猴的什么命 属猴的是几几年 80年属猴的是什么命 属猴的人今年多大了 属猴的今年幸运色 属猴的几岁 属猴的多少岁 生肖猴的幸运石 属猴的今年多少岁 属猴的那一年 属猴的人是什么命 属猴的今年多少岁了 猴的属相 属猴的护身佛是什么 属猴的明星 属马男和属猴女的婚姻 属猴和属猪的婚姻如何 属猴的哪年 属猴的和属猴的配吗 猴的生肖守护神 属龙跟属猴的相配吗 属猴的哪一年 生肖猴的本命佛是什么 属猴和属蛇的合不合

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里