private void PlayerPropertyChange(object sender, PropertyChangeEventArgs e) { if (e.PropertyName != nameof(Player.Position)) { return; } var newPos = (Point)e.NewValue; var oldPos = (Point)e.OldValue; if (propertyChangedRelevant) { PlayerAction action; if (sender is Player senderPlayer) { action = new PlayerAction(senderPlayer, ActionType.Moved, new Point(newPos.X - oldPos.X, newPos.Y - oldPos.Y)); } else { action = new PlayerAction(player, ActionType.Moved, new Point(newPos.X - oldPos.X, newPos.Y - oldPos.Y)); } action.Order = NextOrder; actions.Push(action); player.Role.SetUsedActionPoints(actions.Count); } }
private void OnSourcePropertyChanged(object o, PropertyChangeEventArgs args) { switch (args.PropertyName) { case "Nereid.SourceContents": ThreadAssist.ProxyToMain(delegate { UpdateSourceContents(previous_source); }); break; case "FilterQuery": var source = ServiceManager.SourceManager.ActiveSource; var search_entry = source.Properties.Get <SearchEntry> ("Nereid.SearchEntry") ?? view_container.SearchEntry; if (!search_entry.HasFocus) { ThreadAssist.ProxyToMain(delegate { view_container.SearchEntry.Ready = false; view_container.SearchEntry.Query = source.FilterQuery; view_container.SearchEntry.Ready = true; }); } break; case "Nereid.SimpleUI": SetSimple(ServiceManager.SourceManager.ActiveSource.Properties.Get <bool> ("Nereid.SimpleUI")); break; } }
/// <summary> /// Updates available items when those change on the property. /// </summary> /// <param name="e">Property change details.</param> /// <param name="token">Cancellation token.</param> protected virtual async Task OnPropertyChangeAsync(PropertyChangeEventArgs e, CancellationToken token) { if (e.Change.IncludesItems() && Equals(Row, e.Row)) { await GetAvailableItems(null, token); } }
private void OnPropertyChanged(object o, PropertyChangeEventArgs args) { if (args.PropertyName == "Icon.Name") { UpdateIcon(); } }
/// <summary> /// Updates the visibility and the Required flag of the additional properties /// based on the currently selected operator. Clears their values, if invisible. /// This method is triggered whenever the current operator changes. /// </summary> /// <param name="sender">The event sender.</param> /// <param name="e">Property change event arguments.</param> protected void OnValueChanged(object sender, PropertyChangeEventArgs e) { if (!e.Change.IncludesValue() && !e.Change.IncludesVisible() || additionalProperty == null) { return; } int depCnt = 0; if (!IsNull()) { int.TryParse("" + Value[AttributeAddlProps], out depCnt); } additionalProperty.Visible = Visible && depCnt > 0; additionalProperty.Required = additionalProperty.Visible; if (!additionalProperty.Visible) { additionalProperty.SetValue(null); } if (additionalProperty2 != null) { additionalProperty2.Visible = Visible && depCnt > 1; additionalProperty2.Required = additionalProperty2.Visible; if (!additionalProperty2.Visible) { additionalProperty2.SetValue(null); } } }
// Reflect messages from Documents to our listeners void Document_PropertyChange(object sender, PropertyChangeEventArgs args) { if (PropertyChange != null) { PropertyChange(sender, args); } }
/// <summary> /// Overrides handling of the property change to always update the control /// and also trigger stop editing if the control actually changed the property value. /// </summary> /// <param name="sender">Event sender.</param> /// <param name="e">Property change event arguments.</param> protected override void OnPropertyChange(object sender, PropertyChangeEventArgs e) { // prevent posting value if property value got changed // outside of control (e.g. via cascading selection) if (e.Change == PropertyChange.Value) { PostedValue = null; } // change base behavior to always update the control // e.g. to refresh a required dropdown list bool b = PreventElementUpdate; PreventElementUpdate = false; base.OnPropertyChange(sender, e); PreventElementUpdate = b; // stop the editing (and hence trigger the editing end event), // if the posted value actually changed the property value if (property == sender && PreventElementUpdate && e.Change == PropertyChange.Value && !Equals(e.OldValue, e.NewValue)) { property.Editing = false; } }
private void HandleSelectionChanged(object sender, PropertyEventArgs args_) { PropertyChangeEventArgs args = args_ as PropertyChangeEventArgs; Rectangle invalid = Rectangle.Empty; if (args != null) { if (args.NewValue is Strokes) { invalid = ((Strokes)args.NewValue).GetBoundingBox(); if (args.OldValue is Strokes) { invalid = Rectangle.Union(invalid, ((Strokes)args.OldValue).GetBoundingBox()); } } else if (args.OldValue is Strokes) { invalid = ((Strokes)args.OldValue).GetBoundingBox(); } } // Inflate the invalid region by the width of the border drawn around selected strokes, // sine Strokes.GetBoundingBox only accounts for the width of the strokes' natural DrawingAttributes. invalid.Inflate(SELECTED_BORDER_WIDTH__HIMETRIC, SELECTED_BORDER_WIDTH__HIMETRIC); this.InvalidateInkSpaceRectangle(invalid); }
public void LevelHandler(object sender, PropertyChangeEventArgs args) { if (node != null) { if (level == 0) { level = (int)node.GetProperty("level"); } if (level != (int)node.GetProperty("level")) { if (level != 0 && timeDelay < Time.time) { if (AtavismSettings.Instance.LevelUpPrefab != null) { go = (GameObject)Instantiate(AtavismSettings.Instance.LevelUpPrefab, transform.position, transform.rotation, transform); } } level = (int)node.GetProperty("level"); timeDelay = Time.time + 1f; } } if (go != null) { Destroy(go, AtavismSettings.Instance.LevelUpPrefabDuration); } }
public void ScaleHandler(object sender, PropertyChangeEventArgs args) { AtavismLogger.LogDebugMessage("Got scale"); Vector3 scaleObj = (Vector3)GetComponent <AtavismNode>().GetProperty("scale"); gameObject.transform.localScale = scaleObj; }
/// <summary> /// Overrides handling of the property change to provent posting value if property /// value got changed outside of the control. /// </summary> /// <param name="sender">Event sender.</param> /// <param name="e">Property change event arguments.</param> protected override void OnPropertyChange(object sender, PropertyChangeEventArgs e) { // prevent posting value if property value got changed outside of control if (e.Change == PropertyChange.Value && PostedValue != "false") PreventModelUpdate = true; base.OnPropertyChange(sender, e); }
private void EditorState_SettingChanged(object sender, PropertyChangeEventArgs e) { if (e.PropertyName == nameof(EditorSettings.ActiveLayout)) { this.ActiveLayout = (LayoutOrientation)e.NewValue; } }
public void Remove(string key) { if (m_propertyType != PropertyType.DictionaryType) { Debug.LogError("Function:Remove, PropertyType Error! Current type is" + m_propertyType.ToString()); return; } if (m_dictValue == null) { Debug.LogError("Function:Remove, Dictionary is empty!"); return; } if (!m_dictValue.ContainsKey(key)) { Debug.LogError("Function:Remove, is not contains key!"); return; } PropertyChangeEventArgs msg = new PropertyChangeEventArgs(PropertyChangeType.REMOVE, m_dictValue[key], null, -1); m_dictValue.Remove(key); TriggerChangeEvent(msg); }
private void OnPropertyChanged(object o, PropertyChangeEventArgs args) { if (args.PropertyName == "Name") { SetTitleText(args.NewValue.ToString()); } }
void Document_PropertyChange(object sender, PropertyChangeEventArgs args) { if (args.Property == "ReadOnly") { tsiFileSave.Enabled = (mManager.ActiveDocument != null) && !mManager.ActiveDocument.ReadOnly; } }
public void Insert(int index, object arrayValue) { if (m_propertyType != PropertyType.ArrayValueType) { Debug.LogError("Function:Add, PropertyType Error! Current type is" + m_propertyType.ToString()); return; } if (index < 0 || (index > this.Count)) { Debug.LogError("Function:Remove, index input ERROR!"); return; } if (m_arrayValue == null) { m_arrayValue = new ArrayList(); } PropertyChangeEventArgs msg = new PropertyChangeEventArgs(PropertyChangeType.ADD, null, arrayValue, index); m_arrayValue.Insert(index, arrayValue); TriggerChangeEvent(msg); }
private void OnPropertyChanged(object o, PropertyChangeEventArgs args) { if (args.PropertyName == "UnmapSourceActionLabel") { SetTitleText(args.NewValue.ToString()); } }
public void Remove(T obj) { if (m_propertyType != PropertyType.ListValueType) { Debugging.LogError("Function:Remove, PropertyType Error! Current type is" + m_propertyType.ToString()); return; } if (m_listValue == null) { Debugging.LogError("Function:Remove, Array is empty!"); return; } int index = m_listValue.IndexOf(obj); if (index < 0 || index >= m_listValue.Count) { Debugging.LogError("Function:Remove, index input ERROR!"); return; } PropertyChangeEventArgs msg = new PropertyChangeEventArgs(PropertyChangeType.REMOVE, m_listValue[index], null, index); m_listValue.RemoveAt(index); TriggerChangeEvent(msg); }
private void TriggerChangeEvent(PropertyChangeEventArgs msg) { if (m_changeEvent != null) { m_changeEvent(this, msg); } }
private async Task OnCustomerChanged(object sender, PropertyChangeEventArgs e, CancellationToken token) { if (!e.Change.IncludesValue() || Equals(e.OldValue, e.NewValue) || PersonIdProperty.Value == null && StoreIdProperty.Value == null) { return; } int entityId = StoreIdProperty.Value == null ? // use store or person id PersonIdProperty.Value.Value : StoreIdProperty.Value.Value; await AddressLoader.SetParametersAsync(new Dictionary <string, object>() { { Enumerations.BusinessEntityAddress.Parameters.BusinessEntityId, entityId } }, AddressLoader.LocalCache, token); await BillingAddressObject.AddressIdProperty.ClearInvalidValues(); await ShippingAddressObject.AddressIdProperty.ClearInvalidValues(); var args = new PropertyChangeEventArgs(PropertyChange.Items, null, null, e.Row); await BillingAddressObject.AddressIdProperty.FirePropertyChangeAsync(args, token); await ShippingAddressObject.AddressIdProperty.FirePropertyChangeAsync(args, token); Expression <Func <DataObject, bool> > lookUpEnabled = (obj) => obj.Editable; LookupObject.LookUpAction.SetComputedEnabled(lookUpEnabled, this); }
private void OnBroadcastDisabledChanged(object sender, PropertyEventArgs args) { if (args is PropertyChangeEventArgs) { PropertyChangeEventArgs pcargs = (PropertyChangeEventArgs)args; m_BroadcastDisabled = (bool)pcargs.NewValue; } }
private void UpdateLineTotal(object sender, PropertyChangeEventArgs e) { if (e.Change.IncludesValue()) { LineTotalProperty.SetValue(GetLineTotal(UnitPriceProperty.Value, UnitPriceDiscountProperty.Value, OrderQtyProperty.Value)); } }
void Document_PropertyChange(object sender, PropertyChangeEventArgs args) { if (args.Property == "FileName" || args.Property == "Modified") { TabText = String.Format("{0}{1}", Path.GetFileName(Document.FileName), Document.Modified ? " *" : ""); ToolTipText = Document.FileName; } }
private void CoreFirePropertyChanged(PropertyChangeEventArgs args) { OnPropertyChanged(args); if (PropertyChanged != null) { PropertyChanged(this, args); } }
/// <summary> /// Sets the current text whenever the property value changes. /// </summary> protected override void OnPropertyChange(PropertyChangeEventArgs e) { base.OnPropertyChange(e); if (e.Change.IncludesValue()) { CurrentText = Property.GetStringValue(ValueFormat.EditString, Row); } }
private void CoreFirePropertyChanging(PropertyChangeEventArgs args) { OnPropertyChanging(args); if (PropertyChanging != null) { PropertyChanging(this, args); } IsFrozen.AssertFalse(); }
public void DomainObject_PropertyChanging(object sender, PropertyChangeEventArgs args) { _states.Add(new PropertyChangeState(sender, args.PropertyDefinition, args.OldValue, args.NewValue)); if (_states.Count == _cancelEventNumber) { CancelOperation(); } }
private void DomainObject_PropertyChanged(object sender, PropertyChangeEventArgs args) { _hasChangedEventBeenCalled = true; _changedPropertyDefinition = args.PropertyDefinition; _changedOldValue = args.OldValue; _changedNewValue = args.NewValue; VerifyTransaction(); }
private void OnSourcePropertyChanged(object o, PropertyChangeEventArgs args) { if (args.PropertyName == "Nereid.SourceContents") { Banshee.ServiceStack.Application.Invoke(delegate { UpdateSourceContents(previous_source); }); } }
public void FeetDisplayHandler(object sender, PropertyChangeEventArgs args) { UnityEngine.Debug.Log("Got feet display ID"); ObjectNode node = (ObjectNode)sender; string feetDisplayID = (string)GetComponent<AtavismNode> ().GetProperty (args.PropertyName); EquipmentDisplay display = ClientAPI.ScriptObject.GetComponent<Inventory>().LoadEquipmentDisplay(feetDisplayID); //Material mat = feet.GetComponent<SkinnedMeshRenderer>().material; //mat.SetTexture("_EquipmentTex", display.texture); }
private void OnSourcePropertyChanged(object o, PropertyChangeEventArgs args) { if (args.PropertyName == "Nereid.SourceContents") { Banshee.Base.ThreadAssist.ProxyToMain(delegate { UpdateSourceContents(previous_source); }); } }
public void HandleDeadState(object sender, PropertyChangeEventArgs args) { //Debug.Log ("Got dead update: " + oid); long oid = GetComponent<AtavismNode>().Oid; bool dead = (bool)AtavismClient.Instance.WorldManager.GetObjectNode(oid).GetProperty("deadstate"); if (dead) { PlaySoundEvent(MobSoundEvent.Death); } }
private void OnFilmStripEnabledChanged(object sender, PropertyEventArgs args) { PropertyChangeEventArgs pcea = args as PropertyChangeEventArgs; if (args != null) { this.Visible = (bool)pcea.NewValue; } }
/// <summary> /// Updates the visibility and the Required flag of the additional properties /// based on the currently selected operator. This method is triggered /// whenever the current operator changes. /// </summary> /// <param name="sender">The event sender.</param> /// <param name="e">Property change event arguments.</param> protected void OnValueChanged(object sender, PropertyChangeEventArgs e) { if (!e.Change.IncludesValue() && !e.Change.IncludesVisible() || additionalProperty == null) return; int depCnt = 0; if (!IsNull()) Int32.TryParse("" + Value[AttributeAddlProps], out depCnt); additionalProperty.Visible = Visible && depCnt > 0; additionalProperty.Required = additionalProperty.Visible; if (additionalProperty2 != null) { additionalProperty2.Visible = Visible && depCnt > 1; additionalProperty2.Required = additionalProperty2.Visible; } }
private void TriggerChangeEvent(PropertyChangeEventArgs msg) { if (m_changeEvent != null) m_changeEvent(this, msg); }
public PropertyChangeUndoer(object sender, PropertyChangeEventArgs args) { this.m_Sender = sender; this.m_Change = args; }
public void HandleCombatState(object sender, PropertyChangeEventArgs args) { inCombat = (bool)AtavismClient.Instance.WorldManager.GetObjectNode(oid).GetProperty("combatstate"); if (_animator != null) { AtavismLogger.LogDebugMessage("setting combat state for animator"); _animator.SetBool ("Combat", inCombat); } }
public void XpMaxHandler(object sender, PropertyChangeEventArgs args) { xpmax = (int)ClientAPI.GetPlayerObject().GetProperty(xp_max_prop); }
public void ScaleHandler(object sender, PropertyChangeEventArgs args) { AtavismLogger.LogDebugMessage("Got scale"); Vector3 scaleObj = (Vector3) GetComponent<AtavismNode>().GetProperty("scale"); gameObject.transform.localScale = scaleObj; }
public void WeaponDisplayHandler(object sender, PropertyChangeEventArgs args) { UnityEngine.Debug.Log("Got weapon display ID"); ObjectNode node = (ObjectNode)sender; string displayID = (string)GetComponent<AtavismNode> ().GetProperty (args.PropertyName); // Remove existing item if (attachedItems.ContainsKey(mainHand)) { Destroy(attachedItems[mainHand]); attachedItems.Remove(mainHand); } if (displayID != null && displayID != "") { EquipmentDisplay display = ClientAPI.ScriptObject.GetComponent<Inventory>().LoadEquipmentDisplay(displayID); GameObject weapon = (GameObject) Instantiate(display.model, mainHand.position, mainHand.rotation); weapon.transform.parent = mainHand; attachedItems.Add(mainHand, weapon); } }
/// <summary> /// Retransmits property change events from any of the component properties /// as its own property change event, so that the combined value would be refreshed. /// </summary> /// <param name="property">The component property that was changed.</param> /// <param name="eventArgs">Event arguments that describe the property change.</param> private void ComponentPropertyChange(object property, PropertyChangeEventArgs eventArgs) { FirePropertyChange(eventArgs); }
private void OnSourcePropertyChanged(object o, PropertyChangeEventArgs args) { if (args.PropertyName == "Nereid.SourceContents") { Banshee.Base.ThreadAssist.ProxyToMain (delegate { UpdateSourceContents (previous_source); }); } }
public void HealthMaxHandler(object sender, PropertyChangeEventArgs args) { healthmax = (int)ClientAPI.GetPlayerObject().GetProperty(health_max_prop); }
/// <summary> /// Subclasses must call this method in their constructor in order to set up event listeners /// and to invoke <see cref="SetUpMember"/> on each of the members already present in the /// collection when the <see cref="PropertyCollectionHelper"/> is initialized. /// </summary> /// <remarks> /// This method is not called by the base class constructor, in order to allow subclasses to perform /// any necessary initialization in their own constructors before calls to <see cref="SetUpMember"/> are made. /// </remarks> /// <exception cref="InvalidOperationException"> /// If <see cref="Initialize"/> is called more than once. /// </exception> protected void Initialize() { // A lock is necessary in order to read the items from this.Collection, // and also to synchronize on the PropertyCollectionHelper instead of lock(this). // We can't use lock(this) because the lock ordering cannot be guaranteed. using (Synchronizer.Lock(this.m_Owner.SyncRoot)) { if (this.m_Initialized) throw new InvalidOperationException("The PropertyCollectionHelper has already been initialized."); this.m_Initialized = true; // Set up event listeners. this.m_HandlePropertyChangingDispatch = new EventQueue.PropertyEventDispatcher(this.m_EventQueue, new PropertyEventHandler(this.HandlePropertyChanging)); this.m_HandlePropertyChangedDispatch = new EventQueue.PropertyEventDispatcher(this.m_EventQueue, new PropertyEventHandler(this.HandlePropertyChanged)); // Call HandlePropertyChanged to set up each existing member in the collection. object collection = this.Collection; PropertyEventArgs args = new PropertyChangeEventArgs(this.Property, collection, collection); this.m_HandlePropertyChangedDispatch.Dispatcher(this.m_Owner, args); // Register the event listeners after setting up members so no member can get set up twice. // (Not really a ThreadStart, but we just need a no-args delegate type.) this.m_EventQueue.Post(delegate() { using (Synchronizer.Lock(this.m_Owner.SyncRoot)) { if (!this.m_Disposed) { this.m_Owner.Changing[this.Property].Add(this.m_HandlePropertyChangingDispatch.Dispatcher); this.m_Owner.Changed[this.Property].Add(this.m_HandlePropertyChangedDispatch.Dispatcher); } } }); } }
public void LevelHandler(object sender, PropertyChangeEventArgs args) { level = (int)ClientAPI.GetPlayerObject().GetProperty(level_prop); }
public void WeaponDisplayHandler(object sender, PropertyChangeEventArgs args) { UnityEngine.Debug.Log("Got weapon display ID"); //ObjectNode node = (ObjectNode)sender; string displayID = (string)GetComponent<AtavismNode> ().GetProperty (args.PropertyName); SetWeaponDisplay(displayID); }
private void OnPropertyChanged(object o, PropertyChangeEventArgs args) { if (args.PropertyName == "Name") { SetTitleText (args.NewValue.ToString ()); } }
public void Add(string key, object valueOf) { if (m_propertyType != PropertyType.DictionaryType) { Debug.LogError("Function:Add, PropertyType Error! Current type is" + m_propertyType.ToString()); return; } if (m_dictValue == null) { m_dictValue = new Dictionary<string, object>(); } PropertyChangeEventArgs msg = new PropertyChangeEventArgs(PropertyChangeType.ADD, null, valueOf, -1); m_dictValue.Add(key, valueOf); TriggerChangeEvent(msg); }
private void OnPropertyChanged(object o, PropertyChangeEventArgs args) { if (args.PropertyName == "Icon.Name") { UpdateIcon (); } }
public void HandleDeadState(object sender, PropertyChangeEventArgs args) { dead = (bool)ClientAPI.GetPlayerObject().GameObject.GetComponent<AtavismNode>().GetProperty("deadstate"); }
/// <summary> /// Overrides handling of the property change to always update the control /// and also trigger stop editing if the control actually changed the property value. /// </summary> /// <param name="sender">Event sender.</param> /// <param name="e">Property change event arguments.</param> protected override void OnPropertyChange(object sender, PropertyChangeEventArgs e) { // prevent posting value if property value got changed // outside of control (e.g. via cascading selection) if (e.Change == PropertyChange.Value) PostedValue = null; // change base behavior to always update the control // e.g. to refresh a required dropdown list bool b = PreventElementUpdate; PreventElementUpdate = false; base.OnPropertyChange(sender, e); PreventElementUpdate = b; // stop the editing (and hence trigger the editing end event), // if the posted value actually changed the property value if (property == sender && PreventElementUpdate && e.Change == PropertyChange.Value && !Equals(e.OldValue, e.NewValue)) property.Editing = false; }
public void MovementStateHandler(object sender, PropertyChangeEventArgs args) { AtavismLogger.LogDebugMessage("Got movementstate"); AtavismObjectNode node = (AtavismObjectNode)sender; int state = (int)GetComponent<AtavismNode> ().GetProperty (args.PropertyName); if (isPlayer && state != 2 && transform.position.y < ClientAPI.Instance.WaterHeight) { movementState = 2; } else { movementState = state; } }
public object this[string key] { get { if (m_propertyType != PropertyType.DictionaryType) { Debug.LogError("Function:GetDictionaryValue, PropertyType Error! Current type is" + m_propertyType.ToString()); return null; } if (m_dictValue == null || !m_dictValue.ContainsKey(key)) { Debug.LogError("Function:GetDictionaryValue, is not contain key!"); return null; } return m_dictValue[key]; } set { if (m_propertyType != PropertyType.DictionaryType) { Debug.LogError("Function:SetDictionaryValue, PropertyType Error! Current type is" + m_propertyType.ToString()); } if (m_dictValue == null) { Debug.LogError("Function:SetDictionaryValue, Dictionary is empty!"); return; } if (!m_dictValue.ContainsKey(key)) { Debug.LogError("Function:SetDictionaryValue, is not contain key!"); return; } PropertyChangeEventArgs msg = new PropertyChangeEventArgs(PropertyChangeType.UPDATE, m_dictValue[key], value, -1); m_dictValue[key] = value; TriggerChangeEvent(msg); } }
public void HandleWeaponType(object sender, PropertyChangeEventArgs args) { if (useAnimator) { if (_animator == null) { _animator = (Animator)GetComponentInChildren(typeof(Animator)); } } else { return; } if (weaponType != null && weaponType != "" && weaponType != "Unarmed") { _animator.SetBool (weaponType, false); } weaponType = (string)AtavismClient.Instance.WorldManager.GetObjectNode(oid).GetProperty("weaponType"); if (_animator != null && weaponType != "" && weaponType != "Unarmed") { AtavismLogger.LogDebugMessage("setting combat state for animator"); _animator.SetBool (weaponType, true); } }
public void RemoveAt(int index) { if (m_propertyType != PropertyType.ArrayValueType) { Debug.LogError("Function:RemoveAt, PropertyType Error! Current type is" + m_propertyType.ToString()); return; } if ((m_arrayValue == null) || (index < 0 || index >= m_arrayValue.Count)) { Debug.LogError("Function:RemoveAt, index input ERROR!"); return; } PropertyChangeEventArgs msg = new PropertyChangeEventArgs(PropertyChangeType.REMOVE, m_arrayValue[index], null, index); m_arrayValue.RemoveAt(index); TriggerChangeEvent(msg); }
public void HandleDeadState(object sender, PropertyChangeEventArgs args) { //Debug.Log ("Got dead update: " + oid); dead = (bool)AtavismClient.Instance.WorldManager.GetObjectNode(oid).GetProperty("deadstate"); if (dead) { // Play death animation if (_animation) { _animation.CrossFade (deathAnimation.name); } else if (_animator) { _animator.SetBool ("Dead", true); } target = -1; } //Debug.Log ("Set dead state to: " + dead); }
private void OnSourcePropertyChanged (object o, PropertyChangeEventArgs args) { switch (args.PropertyName) { case "Nereid.SourceContents": ThreadAssist.ProxyToMain (delegate { UpdateSourceContents (previous_source); }); break; case "FilterQuery": var source = ServiceManager.SourceManager.ActiveSource; var search_entry = source.Properties.Get<SearchEntry> ("Nereid.SearchEntry") ?? view_container.SearchEntry; if (!search_entry.HasFocus) { ThreadAssist.ProxyToMain (delegate { view_container.SearchEntry.Ready = false; view_container.SearchEntry.Query = source.FilterQuery; view_container.SearchEntry.Ready = true; }); } break; case "Nereid.SimpleUI": SetSimple (ServiceManager.SourceManager.ActiveSource.Properties.Get<bool> ("Nereid.SimpleUI")); break; } }
public void ManaMaxHandler(object sender, PropertyChangeEventArgs args) { manamax = (int)ClientAPI.GetPlayerObject().GetProperty(mana_max_prop); }