public override void ShowDialog(
PropertyValue propertyValue,
IInputElement commandSource)
{
OpenFileDialog ofd = new OpenFileDialog();
ofd.Multiselect = false;
if (ofd.ShowDialog() == true)
{
propertyValue.StringValue = ofd.FileName;
}
}
/// <summary>
/// After the parameters have been validated, store it in the
/// PropertyValues collection.
/// </summary>
/// <remarks>
/// All these will be looked at again (and processed into runtime
/// data structures) by Style.Seal(). We keep them around even after
/// that point should we need to serialize this data back out.
/// </remarks>
internal void AddToPropertyValues(string childName, DependencyProperty dp, object value, PropertyValueType valueType)
{
// Store original data
PropertyValue propertyValue = new PropertyValue();
propertyValue.ValueType = valueType;
propertyValue.Conditions = null; // Delayed - derived class is responsible for this item.
propertyValue.ChildName = childName;
propertyValue.Property = dp;
propertyValue.ValueInternal = value;
PropertyValues.Add(propertyValue);
}
/// <summary>
/// Given a set of values for the PropertyValue struct, put that in
/// to the PropertyValueList, overwriting any existing entry.
/// </summary>
private void UpdatePropertyValueList(
DependencyProperty dp,
PropertyValueType valueType,
object value)
{
// Check for existing value on dp
int existingIndex = -1;
for( int i = 0; i < PropertyValues.Count; i++ )
{
if( PropertyValues[i].Property == dp )
{
existingIndex = i;
break;
}
}
if( existingIndex >= 0 )
{
// Overwrite existing value for dp
PropertyValue propertyValue = PropertyValues[existingIndex];
propertyValue.ValueType = valueType;
propertyValue.ValueInternal = value;
// Put back modified struct
PropertyValues[existingIndex] = propertyValue;
}
else
{
// Store original data
PropertyValue propertyValue = new PropertyValue();
propertyValue.ValueType = valueType;
propertyValue.ChildName = StyleHelper.SelfName;
propertyValue.Property = dp;
propertyValue.ValueInternal = value;
PropertyValues.Add(propertyValue);
}
}
public FrameworkElementFactoryProperty(PropertyValue propertyValue, FrameworkElementFactoryMarkupObject item): base(item.Manager)
{
_propertyValue = propertyValue;
_item = item;
}
private void UpdatePropertyValueList(DependencyProperty dp, PropertyValueType valueType, object value)
{
int count = -1;
int i = 0;
while (i < this.PropertyValues.Count)
{
if (this.PropertyValues[i].Property != dp)
{
i++;
}
else
{
count = i;
break;
}
}
if (count < 0)
{
PropertyValue propertyValue = new PropertyValue();
propertyValue.ValueType = valueType;
propertyValue.ChildName = null;
propertyValue.Property = dp;
propertyValue.ValueInternal = value;
lock (this.synchronized)
{
this.PropertyValues.Add(propertyValue);
}
}
else
{
lock (this.synchronized)
{
PropertyValue item = this.PropertyValues[count];
item.ValueType = valueType;
item.ValueInternal = value;
this.PropertyValues[count] = item;
}
}
}
//
// All table datastructures read-lock-free/write-lock
// UpdateTables writes the datastructures, locks set by callers
//
// This method
// 1. Adds a ChildValueLookup entry to the given ChildRecord.
// This is used in value computation.
// 2. Optionally adds a ChildPropertyDependent entry to the given
// ContainerRecordFromProperty list. This is used to invalidate
// container dependents.
// 3. Optionally adds a ChildPropertyDependent entry to the given
// ResourceDependents list. This is used when invalidating resource
// references
//
internal static void UpdateTables(
ref PropertyValue propertyValue,
ref FrugalStructList<ChildRecord> childRecordFromChildIndex,
ref FrugalStructList<ItemStructMap<TriggerSourceRecord>> triggerSourceRecordFromChildIndex,
ref FrugalStructList<ChildPropertyDependent> resourceDependents,
ref HybridDictionary dataTriggerRecordFromBinding,
HybridDictionary childIndexFromChildName,
ref bool hasInstanceValues)
{
//
// Record instructions for Child/Self value computation
//
// Query for child index (may be 0 if "self")
int childIndex = QueryChildIndexFromChildName(propertyValue.ChildName, childIndexFromChildName);
if (childIndex == -1)
{
throw new InvalidOperationException(SR.Get(SRID.NameNotFound, propertyValue.ChildName));
}
object value = propertyValue.ValueInternal;
bool requiresInstanceStorage = RequiresInstanceStorage(ref value);
propertyValue.ValueInternal = value;
childRecordFromChildIndex.EnsureIndex(childIndex);
ChildRecord childRecord = childRecordFromChildIndex[childIndex];
int mapIndex = childRecord.ValueLookupListFromProperty.EnsureEntry(propertyValue.Property.GlobalIndex);
ChildValueLookup valueLookup = new ChildValueLookup();
valueLookup.LookupType = (ValueLookupType)propertyValue.ValueType; // Maps directly to ValueLookupType for applicable values
valueLookup.Conditions = propertyValue.Conditions;
valueLookup.Property = propertyValue.Property;
valueLookup.Value = propertyValue.ValueInternal;
childRecord.ValueLookupListFromProperty.Entries[mapIndex].Value.Add(ref valueLookup);
// Put back modified struct
childRecordFromChildIndex[childIndex] = childRecord;
//
// Container property invalidation
//
switch ((ValueLookupType)propertyValue.ValueType)
{
case ValueLookupType.Simple:
{
hasInstanceValues |= requiresInstanceStorage;
}
break;
case ValueLookupType.Trigger:
case ValueLookupType.PropertyTriggerResource:
{
if( propertyValue.Conditions != null )
{
// Record the current property as a dependent to each on of the
// properties in the condition. This is to facilitate the invalidation
// of the current property in the event that any one of the properties
// in the condition change. This will allow the current property to get
// re-evaluated.
for (int i = 0; i < propertyValue.Conditions.Length; i++)
{
int sourceChildIndex = propertyValue.Conditions[i].SourceChildIndex;
triggerSourceRecordFromChildIndex.EnsureIndex(sourceChildIndex);
ItemStructMap<TriggerSourceRecord> triggerSourceRecordMap = triggerSourceRecordFromChildIndex[sourceChildIndex];
if (propertyValue.Conditions[i].Property == null)
{
throw new InvalidOperationException(SR.Get(SRID.MissingTriggerProperty));
}
int index = triggerSourceRecordMap.EnsureEntry(propertyValue.Conditions[i].Property.GlobalIndex);
AddPropertyDependent(childIndex, propertyValue.Property,
ref triggerSourceRecordMap.Entries[index].Value.ChildPropertyDependents);
// Store the triggerSourceRecordMap back into the list after it has been updated
triggerSourceRecordFromChildIndex[sourceChildIndex] = triggerSourceRecordMap;
}
// If value is a resource reference, add dependent on resource changes
if ((ValueLookupType)propertyValue.ValueType == ValueLookupType.PropertyTriggerResource)
{
AddResourceDependent(childIndex, propertyValue.Property, propertyValue.ValueInternal, ref resourceDependents);
}
}
// values in a Trigger may require per-instance storage
if ((ValueLookupType)propertyValue.ValueType != ValueLookupType.PropertyTriggerResource)
{
hasInstanceValues |= requiresInstanceStorage;
}
}
break;
case ValueLookupType.DataTrigger:
case ValueLookupType.DataTriggerResource:
{
if( propertyValue.Conditions != null )
{
if (dataTriggerRecordFromBinding == null)
{
dataTriggerRecordFromBinding = new HybridDictionary();
}
// Record container conditional child property dependents
for (int i = 0; i < propertyValue.Conditions.Length; i++)
{
DataTriggerRecord record = (DataTriggerRecord)dataTriggerRecordFromBinding[propertyValue.Conditions[i].Binding];
if (record == null)
{
record = new DataTriggerRecord();
dataTriggerRecordFromBinding[propertyValue.Conditions[i].Binding] = record;
}
// Add dependent on trigger
AddPropertyDependent(childIndex, propertyValue.Property,
ref record.Dependents);
}
// If value is a resource reference, add dependent on resource changes
if ((ValueLookupType)propertyValue.ValueType == ValueLookupType.DataTriggerResource)
{
AddResourceDependent(childIndex, propertyValue.Property, propertyValue.ValueInternal, ref resourceDependents);
}
}
// values in a DataTrigger may require per-instance storage
if ((ValueLookupType)propertyValue.ValueType != ValueLookupType.DataTriggerResource)
{
hasInstanceValues |= requiresInstanceStorage;
}
}
break;
case ValueLookupType.TemplateBinding:
{
TemplateBindingExtension templateBinding = (TemplateBindingExtension)propertyValue.ValueInternal;
DependencyProperty destinationProperty = propertyValue.Property; // Child
DependencyProperty sourceProperty = templateBinding.Property; // Container
// Record the current property as a dependent to the aliased
// property on the container. This is to facilitate the
// invalidation of the current property in the event that the
// aliased container property changes. This will allow the current
// property to get re-evaluated.
int sourceChildIndex = 0; // TemplateBinding is always sourced off of the container
triggerSourceRecordFromChildIndex.EnsureIndex(sourceChildIndex);
ItemStructMap<TriggerSourceRecord> triggerSourceRecordMap = triggerSourceRecordFromChildIndex[sourceChildIndex];
int index = triggerSourceRecordMap.EnsureEntry(sourceProperty.GlobalIndex);
AddPropertyDependent(childIndex, destinationProperty, ref triggerSourceRecordMap.Entries[index].Value.ChildPropertyDependents);
// Store the triggerSourceRecordMap back into the list after it has been updated
triggerSourceRecordFromChildIndex[sourceChildIndex] = triggerSourceRecordMap;
}
break;
case ValueLookupType.Resource:
{
AddResourceDependent(childIndex, propertyValue.Property, propertyValue.ValueInternal, ref resourceDependents);
}
break;
}
}
private void ProcessVisualTriggers(Style style)
{
// Walk down to bottom of based-on chain
if (style == null)
{
return;
}
ProcessVisualTriggers(style._basedOn);
if (style._visualTriggers != null)
{
// Merge in "self" and child TriggerBase PropertyValues while walking
// back up the tree. "Based-on" style rules are always added first
// (lower priority)
int triggerCount = style._visualTriggers.Count;
for (int i = 0; i < triggerCount; i++)
{
TriggerBase trigger = style._visualTriggers[i];
// Set things up to handle Setter values
for (int j = 0; j < trigger.PropertyValues.Count; j++)
{
PropertyValue propertyValue = trigger.PropertyValues[j];
// Check for trigger rules that act on container
if (propertyValue.ChildName != StyleHelper.SelfName)
{
throw new InvalidOperationException(SR.Get(SRID.StyleTriggersCannotTargetTheTemplate));
}
TriggerCondition[] conditions = propertyValue.Conditions;
for (int k = 0; k < conditions.Length; k++)
{
if (conditions[k].SourceName != StyleHelper.SelfName)
{
throw new InvalidOperationException(SR.Get(SRID.TriggerOnStyleNotAllowedToHaveSource, conditions[k].SourceName));
}
}
// Track properties on the container that are being driven by
// the Style so that they can be invalidated during style changes
StyleHelper.AddContainerDependent(propertyValue.Property, true /*fromVisualTrigger*/, ref this.ContainerDependents);
StyleHelper.UpdateTables(ref propertyValue, ref ChildRecordFromChildIndex,
ref TriggerSourceRecordFromChildIndex, ref ResourceDependents, ref _dataTriggerRecordFromBinding,
null /*_childIndexFromChildID*/, ref _hasInstanceValues);
}
// Set things up to handle TriggerActions
if (trigger.HasEnterActions || trigger.HasExitActions)
{
if (trigger is Trigger)
{
StyleHelper.AddPropertyTriggerWithAction(trigger, ((Trigger)trigger).Property, ref this.PropertyTriggersWithActions);
}
else if (trigger is MultiTrigger)
{
MultiTrigger multiTrigger = (MultiTrigger)trigger;
for (int k = 0; k < multiTrigger.Conditions.Count; k++)
{
Condition triggerCondition = multiTrigger.Conditions[k];
StyleHelper.AddPropertyTriggerWithAction(trigger, triggerCondition.Property, ref this.PropertyTriggersWithActions);
}
}
else if (trigger is DataTrigger)
{
StyleHelper.AddDataTriggerWithAction(trigger, ((DataTrigger)trigger).Binding, ref this.DataTriggersWithActions);
}
else if (trigger is MultiDataTrigger)
{
MultiDataTrigger multiDataTrigger = (MultiDataTrigger)trigger;
for (int k = 0; k < multiDataTrigger.Conditions.Count; k++)
{
Condition dataCondition = multiDataTrigger.Conditions[k];
StyleHelper.AddDataTriggerWithAction(trigger, dataCondition.Binding, ref this.DataTriggersWithActions);
}
}
else
{
throw new InvalidOperationException(SR.Get(SRID.UnsupportedTriggerInStyle, trigger.GetType().Name));
}
}
// Set things up to handle EventTrigger
EventTrigger eventTrigger = trigger as EventTrigger;
if (eventTrigger != null)
{
if (eventTrigger.SourceName != null && eventTrigger.SourceName.Length > 0)
{
throw new InvalidOperationException(SR.Get(SRID.EventTriggerOnStyleNotAllowedToHaveTarget, eventTrigger.SourceName));
}
StyleHelper.ProcessEventTrigger(eventTrigger,
null /*_childIndexFromChildID*/,
ref _triggerActions,
ref EventDependents,
null /*_templateFactoryRoot*/,
null,
ref _eventHandlersStore,
ref _hasLoadedChangeHandler);
}
}
}
}