public TextToolboxNode(string text)
{
Text = text;
//TODO: Use additional filters to limit to a specific host
ToolboxItemFilterAttribute[] filters = new ToolboxItemFilterAttribute [1];
filters[0] = new ToolboxItemFilterAttribute ("AspNetEdit.RawText", ToolboxItemFilterType.Require);
base.ItemFilters = filters;
}
public override bool Equals(object obj)
{
if (obj == this)
{
return(true);
}
ToolboxItemFilterAttribute attribute = obj as ToolboxItemFilterAttribute;
return(((attribute != null) && attribute.FilterType.Equals(this.FilterType)) && attribute.FilterString.Equals(this.FilterString));
}
/// <include file='doc\ToolboxItemFilterAttribute.uex' path='docs/doc[@for="ToolboxItemFilterAttribute.Equals"]/*' />
public override bool Equals(object obj)
{
if (obj == this)
{
return(true);
}
ToolboxItemFilterAttribute other = obj as ToolboxItemFilterAttribute;
return(other != null && other.FilterType.Equals(FilterType) && other.FilterString.Equals(FilterString));
}
public override bool Match(object obj)
{
ToolboxItemFilterAttribute attribute = obj as ToolboxItemFilterAttribute;
if (attribute == null)
{
return(false);
}
if (!attribute.FilterString.Equals(this.FilterString))
{
return(false);
}
return(true);
}
/// <include file='doc\ToolboxItemFilterAttribute.uex' path='docs/doc[@for="ToolboxItemFilterAttribute.Match"]/*' />
public override bool Match(object obj)
{
ToolboxItemFilterAttribute other = obj as ToolboxItemFilterAttribute;
if (other == null)
{
return(false);
}
// different filter string kills a match immediately.
//
if (!other.FilterString.Equals(FilterString))
{
return(false);
}
return(true);
}
//evaluate a filter attribute against a list, and check whther permitted
private bool FilterPermitted(ToolboxItemFilterAttribute desFa, ICollection filterAgainst, object rootDesigner)
{
switch (desFa.FilterType) {
case ToolboxItemFilterType.Allow:
//this is really for matching some other filter string against
return true;
case ToolboxItemFilterType.Custom:
IToolboxUser tbUser = rootDesigner as IToolboxUser;
if (tbUser == null)
throw new ArgumentException ("Host's root designer does not support IToolboxUser interface.");
return EvaluateCustomFilter (tbUser);
case ToolboxItemFilterType.Prevent:
//if host and toolboxitem have same filterstring, then not permitted
foreach (ToolboxItemFilterAttribute itemFa in filterAgainst)
if (desFa.Match (itemFa))
return false;
return true;
case ToolboxItemFilterType.Require:
//if host and toolboxitem have same filterstring, then permitted, unless one is prevented
foreach (ToolboxItemFilterAttribute itemFa in filterAgainst)
if (desFa.Match (itemFa) && (desFa.FilterType != ToolboxItemFilterType.Prevent))
return true;
return false;
}
throw new InvalidOperationException ("Unexpected ToolboxItemFilterType value.");
}
//evaluate a filter attribute against a list, and check whether permitted
private bool FilterPermitted (ItemToolboxNode node, ToolboxItemFilterAttribute desFa,
ICollection<ToolboxItemFilterAttribute> filterAgainst, IToolboxConsumer consumer)
{
switch (desFa.FilterType) {
case ToolboxItemFilterType.Allow:
//this is really for matching some other filter string against
return true;
case ToolboxItemFilterType.Custom:
return consumer.CustomFilterSupports (node);
case ToolboxItemFilterType.Prevent:
//if host and toolboxitem have same filterstring, then not permitted
foreach (ToolboxItemFilterAttribute itemFa in filterAgainst)
if (desFa.Match (itemFa))
return false;
return true;
case ToolboxItemFilterType.Require:
//if host and toolboxitem have same filterstring, then permitted, unless one is prevented
foreach (ToolboxItemFilterAttribute itemFa in filterAgainst)
if (desFa.Match (itemFa) && (desFa.FilterType != ToolboxItemFilterType.Prevent))
return true;
return false;
}
throw new InvalidOperationException ("Unexpected ToolboxItemFilterType value.");
}
/// <include file='doc\ToolboxItem.uex' path='docs/doc[@for="ToolboxItem.ValidatePropertyValue"]/*' />
/// <devdoc>
/// This is called whenever a value is set in the property dictionary. It gives you a chance
/// to change the value of an object before comitting it, our reject it by throwing an
/// exception.
/// </devdoc>
protected virtual object ValidatePropertyValue(string propertyName, object value) {
switch (propertyName) {
case "AssemblyName":
ValidatePropertyType(propertyName, value, typeof(AssemblyName), true);
break;
case "Bitmap":
ValidatePropertyType(propertyName, value, typeof(Bitmap), true);
break;
case "Company":
case "Description":
case "DisplayName":
case "TypeName":
ValidatePropertyType(propertyName, value, typeof(string), true);
if (value == null) value = string.Empty;
break;
case "Filter":
ValidatePropertyType(propertyName, value, typeof(ICollection), true);
int filterCount = 0;
ICollection col = (ICollection)value;
if (col != null) {
foreach (object f in col) {
if (f is ToolboxItemFilterAttribute) {
filterCount++;
}
}
}
ToolboxItemFilterAttribute[] filter = new ToolboxItemFilterAttribute[filterCount];
if (col != null) {
filterCount = 0;
foreach (object f in col) {
ToolboxItemFilterAttribute tfa = f as ToolboxItemFilterAttribute;
if (tfa != null) {
filter[filterCount++] = tfa;
}
}
}
value = filter;
break;
case "IsTransient":
ValidatePropertyType(propertyName, value, typeof(bool), false);
break;
}
return value;
}
/// <include file='doc\ToolboxItem.uex' path='docs/doc[@for="ToolboxItem.FilterPropertyValue"]/*' />
/// <devdoc>
/// Filters a property value before returning it. This allows a property to always clone values,
/// or to provide a default value when none exists.
/// </devdoc>
protected virtual object FilterPropertyValue(string propertyName, object value) {
switch (propertyName) {
case "AssemblyName":
if (value != null) value = ((AssemblyName)value).Clone();
break;
case "DisplayName":
case "TypeName":
if (value == null) value = string.Empty;
break;
case "Filter":
if (value == null) value = new ToolboxItemFilterAttribute[0];
break;
case "IsTransient":
if (value == null) value = false;
break;
}
return value;
}
protected virtual object ValidatePropertyValue (string propertyName, object value)
{
switch (propertyName) {
case "AssemblyName":
ValidatePropertyType (propertyName, value, typeof (AssemblyName), true);
break;
case "Bitmap":
ValidatePropertyType (propertyName, value, typeof (Bitmap), true);
break;
case "Company":
case "Description":
case "DisplayName":
case "TypeName":
ValidatePropertyType (propertyName, value, typeof (string), true);
if (value == null)
value = String.Empty;
break;
case "IsTransient":
ValidatePropertyType (propertyName, value, typeof (bool), false);
break;
case "Filter":
ValidatePropertyType (propertyName, value, typeof (ToolboxItemFilterAttribute[]), true);
if (value == null)
value = new ToolboxItemFilterAttribute [0];
break;
case "DependentAssemblies":
ValidatePropertyType (propertyName, value, typeof (AssemblyName[]), true);
break;
default:
break;
}
return value;
}
/// <summary>
/// Remove a filter from the specified <see cref="ModelingToolboxItem"/>
/// </summary>
/// <param name="items">A list of existing items</param>
/// <param name="itemIndexDictionary">A dictionary mapping from the item identifier to an index in the
/// <paramref name="items"/> list. The dictionary should be created with <see cref="CreateIdentifierToIndexMap"/></param>
/// <param name="itemId">The identifer of the item to modify</param>
/// <param name="filterString">The filter string for the filter to remove</param>
public static void RemoveFilterAttribute(IList<ModelingToolboxItem> items, IDictionary<string, int> itemIndexDictionary, string itemId, string filterString)
{
int itemIndex;
if (itemIndexDictionary.TryGetValue(itemId, out itemIndex))
{
ModelingToolboxItem itemBase = items[itemIndex];
ICollection baseFilters = itemBase.Filter;
int baseFilterCount = baseFilters.Count;
if (baseFilterCount != 0)
{
int removeCount = 0;
foreach (object filter in baseFilters)
{
ToolboxItemFilterAttribute filterAttribute = filter as ToolboxItemFilterAttribute;
if (filterAttribute == null || filterAttribute.FilterString == filterString)
{
++removeCount;
}
}
if (removeCount == baseFilterCount)
{
itemBase.Filter = null;
}
else
{
ToolboxItemFilterAttribute[] newFilters = new ToolboxItemFilterAttribute[baseFilterCount - removeCount];
int nextIndex = 0;
foreach (object filter in baseFilters)
{
ToolboxItemFilterAttribute filterAttribute = filter as ToolboxItemFilterAttribute;
if (filterAttribute != null && filterAttribute.FilterString != filterString)
{
newFilters[nextIndex] = filterAttribute;
++nextIndex;
}
}
itemBase.Filter = newFilters;
}
}
}
}
/// <summary>
/// Add a filter to the specified <see cref="ModelingToolboxItem"/>
/// </summary>
/// <param name="items">A list of existing items</param>
/// <param name="itemIndexDictionary">A dictionary mapping from the item identifier to an index in the
/// <paramref name="items"/> list. The dictionary should be created with <see cref="CreateIdentifierToIndexMap"/></param>
/// <param name="itemId">The identifer of the item to modify</param>
/// <param name="filterAttribute">The filter attribute to add</param>
public static void AddFilterAttribute(IList<ModelingToolboxItem> items, IDictionary<string, int> itemIndexDictionary, string itemId, ToolboxItemFilterAttribute filterAttribute)
{
int itemIndex;
if (itemIndexDictionary.TryGetValue(itemId, out itemIndex))
{
ModelingToolboxItem itemBase = items[itemIndex];
ICollection baseFilters = itemBase.Filter;
int baseFilterCount = (baseFilters != null) ? baseFilters.Count : 0;
ToolboxItemFilterAttribute[] newFilters = new ToolboxItemFilterAttribute[baseFilterCount + 1];
if (baseFilterCount != 0)
{
baseFilters.CopyTo(newFilters, 0);
}
newFilters[baseFilterCount] = filterAttribute;
itemBase.Filter = newFilters;
}
}
protected virtual object ValidatePropertyValue(string propertyName, object value)
{
switch (propertyName)
{
case "AssemblyName":
this.ValidatePropertyType(propertyName, value, typeof(System.Reflection.AssemblyName), true);
return value;
case "Bitmap":
this.ValidatePropertyType(propertyName, value, typeof(System.Drawing.Bitmap), true);
return value;
case "Company":
case "Description":
case "DisplayName":
case "TypeName":
this.ValidatePropertyType(propertyName, value, typeof(string), true);
if (value == null)
{
value = string.Empty;
}
return value;
case "Filter":
{
this.ValidatePropertyType(propertyName, value, typeof(ICollection), true);
int num = 0;
ICollection is2 = (ICollection) value;
if (is2 != null)
{
foreach (object obj2 in is2)
{
if (obj2 is ToolboxItemFilterAttribute)
{
num++;
}
}
}
ToolboxItemFilterAttribute[] attributeArray = new ToolboxItemFilterAttribute[num];
if (is2 != null)
{
num = 0;
foreach (object obj3 in is2)
{
ToolboxItemFilterAttribute attribute = obj3 as ToolboxItemFilterAttribute;
if (attribute != null)
{
attributeArray[num++] = attribute;
}
}
}
value = attributeArray;
return value;
}
case "IsTransient":
this.ValidatePropertyType(propertyName, value, typeof(bool), false);
return value;
}
return value;
}
protected virtual object FilterPropertyValue(string propertyName, object value)
{
string str = propertyName;
if (str != null)
{
if (!(str == "AssemblyName"))
{
if ((str == "DisplayName") || (str == "TypeName"))
{
if (value == null)
{
value = string.Empty;
}
return value;
}
if (str == "Filter")
{
if (value == null)
{
value = new ToolboxItemFilterAttribute[0];
}
return value;
}
if ((str == "IsTransient") && (value == null))
{
value = false;
}
return value;
}
if (value != null)
{
value = ((System.Reflection.AssemblyName) value).Clone();
}
}
return value;
}
private static ICollection MergeFilter(ToolboxItem item)
{
ICollection filter = item.Filter;
ArrayList list = new ArrayList();
foreach (Attribute attribute in TypeDescriptor.GetAttributes(item))
{
if (attribute is ToolboxItemFilterAttribute)
{
list.Add(attribute);
}
}
if ((filter == null) || (filter.Count == 0))
{
return list;
}
if (list.Count > 0)
{
Hashtable hashtable = new Hashtable(list.Count + filter.Count);
foreach (Attribute attribute2 in list)
{
hashtable[attribute2.TypeId] = attribute2;
}
foreach (Attribute attribute3 in filter)
{
hashtable[attribute3.TypeId] = attribute3;
}
ToolboxItemFilterAttribute[] array = new ToolboxItemFilterAttribute[hashtable.Values.Count];
hashtable.Values.CopyTo(array, 0);
return array;
}
return filter;
}
public virtual ICollection GetFilter(ICollection creators)
{
ICollection is2 = this._filter;
if (this._filter == null)
{
if (this._dataObject.GetDataPresent("CF_TOOLBOXITEMCONTAINER"))
{
byte[] data = (byte[]) this._dataObject.GetData("CF_TOOLBOXITEMCONTAINER");
if (data != null)
{
BinaryReader reader = new BinaryReader(new MemoryStream(data));
if (reader.ReadInt16() != 1)
{
this._filter = new ToolboxItemFilterAttribute[0];
}
else
{
short num2 = reader.ReadInt16();
ToolboxItemFilterAttribute[] attributeArray = new ToolboxItemFilterAttribute[num2];
for (short i = 0; i < num2; i = (short) (i + 1))
{
string filterString = reader.ReadString();
short num4 = reader.ReadInt16();
attributeArray[i] = new ToolboxItemFilterAttribute(filterString, (ToolboxItemFilterType) num4);
}
this._filter = attributeArray;
}
}
else
{
this._filter = new ToolboxItemFilterAttribute[0];
}
return this._filter;
}
if (creators != null)
{
foreach (ToolboxItemCreator creator in creators)
{
if (this._dataObject.GetDataPresent(creator.Format))
{
ToolboxItem item = creator.Create(this._dataObject);
if (item != null)
{
return MergeFilter(item);
}
}
}
}
}
return is2;
}
