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); } } } }