// This block of code attempts to minimize the number of
// type operations and assignments involved in figuring out what
// trigger type we're dealing here.
// Attempted casts are done in the order of decreasing expected frequency.
// rearrange as expectations change.
private static void DetermineTriggerType( TriggerBase triggerBase,
out Trigger trigger, out MultiTrigger multiTrigger,
out DataTrigger dataTrigger, out MultiDataTrigger multiDataTrigger,
out EventTrigger eventTrigger )
{
if( (trigger = (triggerBase as Trigger)) != null )
{
multiTrigger = null;
dataTrigger = null;
multiDataTrigger = null;
eventTrigger = null;
}
else if( (multiTrigger = (triggerBase as MultiTrigger)) != null )
{
dataTrigger = null;
multiDataTrigger = null;
eventTrigger = null;
}
else if( (dataTrigger = (triggerBase as DataTrigger)) != null )
{
multiDataTrigger = null;
eventTrigger = null;
}
else if( (multiDataTrigger = (triggerBase as MultiDataTrigger)) != null )
{
eventTrigger = null;
}
else if( (eventTrigger = (triggerBase as EventTrigger)) != null )
{
; // Do nothing - eventTrigger is now non-null, and everything else has been set to null.
}
else
{
// None of the above - the caller is expected to throw an exception
// stating that the trigger type is not supported.
}
}
public ListBoxHotColor(Color hotColor)
{
var setter = new Setter();
setter.Property = ListBoxItem.BackgroundProperty;
setter.Value = new SolidColorBrush(hotColor);
var trigger = new MultiTrigger();
trigger.Conditions.Add(new Condition(ListBoxItem.IsMouseOverProperty, true));
trigger.Conditions.Add(new Condition(ListBoxItem.IsSelectedProperty, false));
trigger.Setters.Add(setter);
var listBoxStyle = new Style(typeof(ListBoxItem));
listBoxStyle.Triggers.Add(trigger);
_listBoxStyle = listBoxStyle;
}
Controls.MultiTrigger CreateMultiTrigger(MultiTrigger t, Value v, Event e)
{
var result = new Controls.MultiTrigger();
result.ParentPage = this;
result.ParentEvent = e;
result.ParentValue = v;
result.ParentMultiTrigger = t;
foreach (var trigger in t.triggers)
{
result.Triggers.Add(CreateTrigger(trigger, v, e));
}
result.AddTriggerClicked += MultiTrigger_AddTriggerClicked;
result.SettingChanged += MultiTrigger_SettingChanged;
result.RemoveClicked += MultiTrigger_RemoveClicked;
return result;
}
static MultiTrigger GetMultiTriggerFromRow(Value v, DataRow row)
{
MultiTrigger result = null;
string adr = row["address"].ToString();
if (adr.Contains("MultiTrigger"))
{
int eventIndex = adr.IndexOf("MultiTrigger");
int separatorIndex = adr.IndexOf("||", eventIndex);
int slashIndex = adr.IndexOf("/", separatorIndex + 1);
if (slashIndex > separatorIndex || slashIndex == -1)
{
string val = row["value"].ToString();
string strId = null;
if (slashIndex >= 0) strId = adr.Substring(separatorIndex + 2, 2);
else strId = adr.Substring(separatorIndex + 2);
int id;
if (int.TryParse(strId, out id))
{
result = new MultiTrigger();
result.id = id;
}
}
}
return result;
}
private void Value_AddMultiTriggerClicked(Controls.Value val)
{
if (val.ParentValue != null && val.ParentEvent != null)
{
if (val.ParentEvent.values.Contains(val.ParentValue))
{
Controls.Event e = events.Find(x => x.ParentEvent == val.ParentEvent);
if (e != null)
{
int index = e.Values.ToList().FindIndex(x => x.ParentValue == val.ParentValue);
if (index >= 0)
{
Controls.Value v = e.Values[index];
if (v != null)
{
var multitrigger = new MultiTrigger();
val.ParentValue.triggers.Add(multitrigger);
Controls.MultiTrigger uiMultiTrigger = CreateMultiTrigger(multitrigger, val.ParentValue, val.ParentEvent);
var trigger = new Trigger();
multitrigger.triggers.Add(trigger);
Controls.Trigger uiTrigger = CreateTrigger(trigger, uiMultiTrigger.ParentValue, uiMultiTrigger.ParentEvent);
uiTrigger.modifier_COMBO.SelectedItem = "Equal To";
uiMultiTrigger.Triggers.Add(uiTrigger);
val.Triggers.Add(uiMultiTrigger);
}
}
}
}
}
}
void SaveMultiTrigger(MultiTrigger mt, Value v, Event e, DataTable dt)
{
string adr = "/GeneratedData/GeneratedEvents/Event||" + e.id.ToString("00");
adr += "/Value||" + v.id.ToString("00") + "/Triggers";
adr += "/MultiTrigger";
int id = DataTable_Functions.TrakHound.GetUnusedAddressId(adr, dt);
adr = adr + "||" + id.ToString("00");
// Set Attributes
string attr = "";
attr += "id||" + id.ToString("00") + ";";
DataTable_Functions.UpdateTableValue(dt, "address", adr, "attributes", attr);
foreach (var trigger in mt.triggers)
{
SaveTrigger(trigger, v, e, dt, adr);
}
}
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);
}
}
}
}
private void SetTriggerBrush(MultiTrigger trigger, string action, string property)
{
var setter = GetTriggerSetter(trigger, property);
var value = GetBrushValue(action + property);
setter.Value = value;
}
private static Setter GetTriggerSetter(MultiTrigger trigger, string property)
{
return trigger.Setters.OfType<Setter>().FirstOrDefault(s => s.Property.Name == property);
}
public void MultiTriggerBasicTest()
{
Condition condition1 = new Condition { Property = new DependencyPropertyPathElement(Value1Property), Value = 1 };
Condition condition2 = new Condition { Property = new DependencyPropertyPathElement(Value2Property), Value = 2 };
MultiTrigger multiTrigger = new MultiTrigger();
multiTrigger.Conditions.Add(condition1);
multiTrigger.Conditions.Add(condition2);
multiTrigger.Setters.Add(new Setter { Property = new DependencyPropertyPathElement(Value3Property), Value = 3 });
FrameworkElement element = new FrameworkElement();
element.SetValue(Value1Property, 1);
element.SetValue(Value2Property, 2);
Assert.AreEqual(1, element.GetValue(Value1Property));
Assert.AreEqual(2, element.GetValue(Value2Property));
Assert.AreEqual(0, element.GetValue(Value3Property));
element.Triggers.Add(multiTrigger);
Assert.AreEqual(3, element.GetValue(Value3Property));
element.SetValue(Value1Property, 2);
Assert.AreEqual(0, element.GetValue(Value3Property));
element.SetValue(Value1Property, 1);
Assert.AreEqual(3, element.GetValue(Value3Property));
element.Triggers.Remove(multiTrigger);
Assert.AreEqual(0, element.GetValue(Value3Property));
}
public void TriggerOverlapTest()
{
Trigger trigger1 = new Trigger { Property = new DependencyPropertyPathElement(Value1Property), Value = 1 };
trigger1.Setters.Add(new Setter { Property = new DependencyPropertyPathElement(Value3Property), Value = 1 });
MultiTrigger trigger2 = new MultiTrigger();
trigger2.Conditions.Add(new Condition { Property = new DependencyPropertyPathElement(Value1Property), Value = 1 });
trigger2.Conditions.Add(new Condition { Property = new DependencyPropertyPathElement(Value2Property), Value = 2 });
trigger2.Setters.Add(new Setter { Property = new DependencyPropertyPathElement(Value3Property), Value = 2 });
FrameworkElement element = new FrameworkElement();
element.Triggers.Add(trigger1);
element.Triggers.Add(trigger2);
element.SetValue(Value1Property, 1);
element.SetValue(Value2Property, 0);
Assert.AreEqual(1, element.GetValue(Value3Property));
element.SetValue(Value1Property, 1);
element.SetValue(Value2Property, 2);
Assert.AreEqual(2, element.GetValue(Value3Property));
element.SetValue(Value1Property, 1);
element.SetValue(Value2Property, 0);
Assert.AreEqual(1, element.GetValue(Value3Property));
}
// Given a multi property trigger and associated context information,
// evaluate the old and new states of the trigger.
// Note that we can only have a transition only if every property other
// than the changed property is true. If any of the other properties
// are false, then the state is false and we can't have a false->true
// transition.
// Hence this evaluation short-circuits if any property evaluation
// (other than the one being compared) turns out false.
private static void EvaluateOldNewStates( MultiTrigger multiTrigger,
DependencyObject triggerContainer, DependencyProperty changedProperty, DependencyPropertyChangedEventArgs changedArgs,
int sourceChildIndex, Style style, FrameworkTemplate frameworkTemplate,
out bool oldState, out bool newState )
{
int triggerChildId = 0;
DependencyObject evaluationNode = null;
TriggerCondition[] conditions = multiTrigger.TriggerConditions;
// Set up the default condition: A trigger with no conditions will never evaluate to true.
oldState = false;
newState = false;
for( int i = 0; i < conditions.Length; i++ )
{
if( conditions[i].SourceChildIndex != 0 )
{
Debug.Assert( frameworkTemplate != null,
"A trigger outside of a Template is not supposed to have a SourceName. This should have been caught somewhere upstream, like in Style.Seal().");
triggerChildId = conditions[i].SourceChildIndex;
evaluationNode = GetChild(triggerContainer, triggerChildId);
}
else
{
triggerChildId = 0;
evaluationNode = triggerContainer;
}
Debug.Assert(evaluationNode != null,
"Couldn't find the node corresponding to the ID and name given in the trigger. This should have been caught somewhere upstream, like StyleHelper.SealTemplate()." );
if( conditions[i].Property == changedProperty && triggerChildId == sourceChildIndex )
{
// This is the property that changed, and on the object we
// care about. Evaluate states.- see if the condition
oldState = conditions[i].Match(changedArgs.OldValue);
newState = conditions[i].Match(changedArgs.NewValue);
if( oldState == newState )
{
// There couldn't possibly be a transition here, abort. The
// returned values here aren't necessarily the state of the
// triggers, but we only care about a transition today. If
// we care about actual values, we'll need to continue evaluation.
return;
}
}
else
{
object evaluationValue = evaluationNode.GetValue( conditions[i].Property );
if( !conditions[i].Match(evaluationValue) )
{
// A condition other than the one changed has evaluated to false.
// There couldn't possibly be a transition here, short-circuit and abort.
oldState = false;
newState = false;
return;
}
}
}
// We should only get this far only if every property change causes
// a true->false (or vice versa) transition in one of the conditions,
// AND that every other condition evaluated to true.
return;
}
/// <summary>
/// Initializes a new instance of the <see cref="MultiTriggerItem"/> class.
/// </summary>
public MultiTriggerItem(MultiTrigger trigger, FrameworkElement source, TriggerSource triggerSource)
: base(source, TriggerType.MultiTrigger, triggerSource)
{
_trigger = trigger;
_source = source;
}
// Token: 0x060008DF RID: 2271 RVA: 0x0001CD9C File Offset: 0x0001AF9C
private void ProcessVisualTriggers(Style style)
{
if (style == null)
{
return;
}
this.ProcessVisualTriggers(style._basedOn);
if (style._visualTriggers != null)
{
int count = style._visualTriggers.Count;
for (int i = 0; i < count; i++)
{
TriggerBase triggerBase = style._visualTriggers[i];
for (int j = 0; j < triggerBase.PropertyValues.Count; j++)
{
PropertyValue propertyValue = triggerBase.PropertyValues[j];
if (propertyValue.ChildName != "~Self")
{
throw new InvalidOperationException(SR.Get("StyleTriggersCannotTargetTheTemplate"));
}
TriggerCondition[] conditions = propertyValue.Conditions;
for (int k = 0; k < conditions.Length; k++)
{
if (conditions[k].SourceName != "~Self")
{
throw new InvalidOperationException(SR.Get("TriggerOnStyleNotAllowedToHaveSource", new object[]
{
conditions[k].SourceName
}));
}
}
StyleHelper.AddContainerDependent(propertyValue.Property, true, ref this.ContainerDependents);
StyleHelper.UpdateTables(ref propertyValue, ref this.ChildRecordFromChildIndex, ref this.TriggerSourceRecordFromChildIndex, ref this.ResourceDependents, ref this._dataTriggerRecordFromBinding, null, ref this._hasInstanceValues);
}
if (triggerBase.HasEnterActions || triggerBase.HasExitActions)
{
if (triggerBase is Trigger)
{
StyleHelper.AddPropertyTriggerWithAction(triggerBase, ((Trigger)triggerBase).Property, ref this.PropertyTriggersWithActions);
}
else if (triggerBase is MultiTrigger)
{
MultiTrigger multiTrigger = (MultiTrigger)triggerBase;
for (int l = 0; l < multiTrigger.Conditions.Count; l++)
{
Condition condition = multiTrigger.Conditions[l];
StyleHelper.AddPropertyTriggerWithAction(triggerBase, condition.Property, ref this.PropertyTriggersWithActions);
}
}
else if (triggerBase is DataTrigger)
{
StyleHelper.AddDataTriggerWithAction(triggerBase, ((DataTrigger)triggerBase).Binding, ref this.DataTriggersWithActions);
}
else
{
if (!(triggerBase is MultiDataTrigger))
{
throw new InvalidOperationException(SR.Get("UnsupportedTriggerInStyle", new object[]
{
triggerBase.GetType().Name
}));
}
MultiDataTrigger multiDataTrigger = (MultiDataTrigger)triggerBase;
for (int m = 0; m < multiDataTrigger.Conditions.Count; m++)
{
Condition condition2 = multiDataTrigger.Conditions[m];
StyleHelper.AddDataTriggerWithAction(triggerBase, condition2.Binding, ref this.DataTriggersWithActions);
}
}
}
EventTrigger eventTrigger = triggerBase as EventTrigger;
if (eventTrigger != null)
{
if (eventTrigger.SourceName != null && eventTrigger.SourceName.Length > 0)
{
throw new InvalidOperationException(SR.Get("EventTriggerOnStyleNotAllowedToHaveTarget", new object[]
{
eventTrigger.SourceName
}));
}
StyleHelper.ProcessEventTrigger(eventTrigger, null, ref this._triggerActions, ref this.EventDependents, null, null, ref this._eventHandlersStore, ref this._hasLoadedChangeHandler);
}
}
}
}
