private void Target_SizeChanged(object sender, SizeChangedEventArgs e)
{
var isActive = IsActive;
var targetRatio = WidthHeightRatio;
if (e.NewSize.Height == 0 ||
e.NewSize.Width == 0 ||
targetRatio == 0
)
{
IsActive = false;
}
else
{
var ratio = e.NewSize.Width / e.NewSize.Height;
IsActive = ActiveInHigher
? ratio >= targetRatio
: ratio <= targetRatio
;
Debug.WriteLine($"AspectRatio: {ratio}, Target: {Target}");
}
if (isActive != IsActive)
{
SetActive(IsActive);
IsActiveChanged?.Invoke(this, EventArgs.Empty);
}
}
private void OnIsActiveChanged()
{
//获取或设置一个值，该值指示对象是否为活动的。
UpdateCommand.IsActive = IsActive;
IsActiveChanged?.Invoke(this, new EventArgs());
}
protected virtual async void OnActiveChanged()
{
IsActiveChanged?.Invoke(this, EventArgs.Empty);
if (_isLoaded)
{
return;
}
_isLoaded = true;
SetViewTitle(out _viewTitle, out _viewHeader);
RaisePropertyChanged(() => ViewTitle);
RaisePropertyChanged(() => ViewHeader);
this.ShowBusy("Initializing...");
try
{
await InitializeAsync();
}
catch (Exception ex)
{
Logger.Exception(ex);
}
finally
{
this.HideBusy();
}
}
/// <summary>
/// Method invoked when the parent agent's behaviour changes
/// </summary>
/// <param name="newBehaviour">New behaviour of the parent agent</param>
private void ParentAgentOnBehaviourChanged(string newBehaviour)
{
var isActive = ParentAgent.Source.AgentSupportWaypoints(ParentAgent);
WaypointsParent.gameObject.SetActive(isActive);
IsActiveChanged?.Invoke(isActive);
}
/// <summary>
/// Provides derived classes an opportunity to handle changes to the IsActive property.
/// </summary>
protected virtual void OnIsActiveChanged(bool oldValue, bool newValue)
{
if (newValue)
{
LastActivationTimeStamp = DateTime.Now;
}
IsActiveChanged?.Invoke(this, EventArgs.Empty);
}
protected virtual void OnIsActiveChanged()
{
RefreshCommand.IsActive = IsActive; //set the command as active
IsActiveChanged?.Invoke(this, new EventArgs()); //invoke the event for all listeners
if (IsActive && AppCommand.RefreshOnActive)
{
RefreshCommand.Execute();
}
}
private void RaiseIsActiveChanged()
{
if (IsActive && !_isActivated)
{
_isActivated = true;
LoadSettings();
}
IsActiveChanged?.Invoke(this, EventArgs.Empty);
}
private void OnIsActiveChanged()
{
ImportFGCommand.IsActive = IsActive;
ExportFGCommand.IsActive = IsActive;
PrintLblCommand.IsActive = IsActive;
DeleteFGCommand.IsActive = IsActive;
OKCommand.IsActive = IsActive;
XOKCommand.IsActive = IsActive;
IsActiveChanged?.Invoke(this, new EventArgs());
}
protected virtual Task OnToggle()
{
if (IsRemovable ||
IsStatic)
{
return(Task.CompletedTask);
}
IsActive = !IsActive;
return(IsActiveChanged.InvokeAsync(IsActive));
}
protected override Task OnParametersSetAsync()
{
if (IsRemovable &&
!IsActive)
{
IsActive = true;
return(IsActiveChanged.InvokeAsync(IsActive));
}
return(Task.CompletedTask);
}
private void RaiseIsActiveChanged()
{
IsActiveChanged?.Invoke(this, EventArgs.Empty);
if (IsActive)
{
OnAppearing();
}
else
{
OnDisappearing();
}
}
private void OnIsActiveChanged()
{
IsActiveChanged?.Invoke(this, EventArgs.Empty);
if (IsActive)
{
OnIsActive();
}
else
{
OnIsNotActive();
}
}
/// <summary>
/// 切换
/// </summary>
/// <param name="isActive"></param>
public void Toggle(bool?isActive = null)
{
if (isActive != null)
{
IsActive = isActive.Value;
}
else
{
IsActive = !IsActive;
}
IsActiveChanged.InvokeAsync(IsActive);
StateHasChanged();
}
protected virtual void RaiseIsActiveChanged()
{
if (IsActive && !_isActivated)
{
_isActivated = true;
IsBusy = false;
_hasItems = true;
_pageNumber = 0;
LoadMoreItems();
}
IsActiveChanged?.Invoke(this, EventArgs.Empty);
}
private void OnIsActiveChanged()
{
SaveCommand.RaiseCanExecuteChanged();
CompileCommand.IsActive = IsActive;
CompileCommand.RaiseCanExecuteChanged();
RedoCommand.IsActive = IsActive;
RedoCommand.RaiseCanExecuteChanged();
UndoCommand.IsActive = IsActive;
UndoCommand.RaiseCanExecuteChanged();
IsActiveChanged?.Invoke(this, new EventArgs());
}
private void OnIsActiveChanged()
{
OnCancelCommand.IsActive = IsActive;
OnAddCommand.IsActive = IsActive;
OnEditCommand.IsActive = IsActive;
OnDeleteCommand.IsActive = IsActive;
OnSaveCommand.IsActive = IsActive;
OnFirstNavCommand.IsActive = IsActive;
OnPreviousNavCommand.IsActive = IsActive;
OnNextNavCommand.IsActive = IsActive;
OnLastNavCommand.IsActive = IsActive;
IsActiveChanged?.Invoke(this, new EventArgs());
}
protected void SetActiveInvertible(bool isActive)
{
var oldVal = IsActive;
var valInvertApplied = Inverted ? !isActive : isActive;
if (oldVal == valInvertApplied)
{
return;
}
IsActive = valInvertApplied;
SetActive(valInvertApplied);
IsActiveChanged?.Invoke(this, EventArgs.Empty);
}
/// <summary>
/// Sets <see cref="IsActive"/> and raises the <see cref="IsActiveChanged"/> event.
/// </summary>
/// <param name="value">The new value to set <see cref="IsActive"/>.</param>
/// <param name="sender">The sender setting the value.</param>
public static void SetIsActive(bool value, StreamDeckAction sender)
{
try
{
_syncRoot.Wait();
if (SamplerClearer.IsActive != value)
{
SamplerClearer.IsActive = value;
IsActiveChanged?.Invoke(sender, EventArgs.Empty);
}
}
finally
{
_syncRoot.Release();
}
}
private void OnIsActiveChanged()
{
if (IsActive)
{
if (!IsInited)
{
IsInited = true;
OnInit();
}
OnActivated();
}
else
{
OnInactivated();
}
IsActiveChanged?.Invoke(this, new EventArgs());
}
private void Item_PointerMoved(object sender, Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
{
var collisionRect = CollisionRect;
var oldIsActive = IsActive;
if (!collisionRect.IsEmpty)
{
var pt = e.GetCurrentPoint((UIElement)sender);
SetActive(IsActive = collisionRect.Contains(pt.Position));
}
else
{
SetActive(IsActive = e.Pointer.IsInRange);
}
if (oldIsActive != IsActive)
{
IsActiveChanged?.Invoke(this, EventArgs.Empty);
}
}
protected override async Task OnAfterRenderAsync(bool firstRender)
{
if (firstRender)
{
// Register resize-handler to window
await WindowService.EventManager
.AddResizeHandlerAsync(WindowResizeHandler);
}
// Ensure that the dropdown isn't cut off
EnsureCorrectDropDownPosition();
if (_callbackId > -1)
{
// Ensure that callback is cleaned up
await ElementService.RemoveClickOutsideOfElementHandlerAsync(_callbackId);
_callbackId = -1;
}
if (IsActive)
{
// Register callback if user clicks outside of dropdown
_callbackId = await ElementService.AddClickOutsideOfElementHandlerAsync(
new[]
{
_targetReference.Current,
_contentReference.Current
},
() =>
{
_callbackId = -1;
IsActive = false;
IsActiveChanged.InvokeAsync(false); // Notify parent that dropdown closed
StateHasChanged();
});
}
}
/// <inheritdoc/>
public override void DeserializeFromJson(JSONNode agentNode)
{
var waypointsNode = agentNode["waypoints"] as JSONArray;
if (waypointsNode == null)
{
return;
}
foreach (var waypointNode in waypointsNode.Children)
{
var mapWaypointPrefab =
ScenarioManager.Instance.GetExtension <ScenarioWaypointsManager>().waypointPrefab;
var waypointInstance = ScenarioManager.Instance.prefabsPools
.GetInstance(mapWaypointPrefab).GetComponent <ScenarioWaypoint>();
waypointInstance.transform.position = waypointNode["position"].ReadVector3();
var waitTime = waypointNode["waitTime"];
if (waitTime == null)
{
waitTime = waypointNode["wait_time"];
}
waypointInstance.WaitTime = waitTime;
waypointInstance.Speed = waypointNode["speed"];
var ordinalNumber = waypointNode["ordinalNumber"];
if (ordinalNumber == null)
{
ordinalNumber = waypointNode["ordinal_number"];
}
int index = ordinalNumber;
//TODO sort waypoints
AddWaypoint(waypointInstance, index);
DeserializeTrigger(waypointInstance.LinkedTrigger, waypointNode["trigger"]);
}
WaypointsParent.gameObject.SetActive(true);
IsActiveChanged?.Invoke(true);
}
private void OnIsActiveChanged()
{
//OnAddCommand.IsActive = IsActive;
IsActiveChanged?.Invoke(this, new EventArgs());
}
protected virtual void OnIsActiveChanged(bool value)
{
IsActiveChanged?.Invoke(this, value);
}
private void OnActiveChanged(object sender, EventArgs e)
{
IsActiveChanged?.Invoke(sender, e);
}
protected virtual void RaiseIsActiveChanged()
{
IsActiveChanged?.Invoke(this, EventArgs.Empty);
}
protected virtual void DoIsActiveChanged(EventArgs e)
{
IsActiveChanged?.Invoke(this, e);
}
private void RaisActiveChanged()
{
IsActiveChanged?.Invoke(this, new EventArgs());
}
private void OnIsActiveChanged()
{
IsActiveChanged?.Invoke(this, EventArgs.Empty);
}
private void OnAcitvateChanged()
{
UpdateCommand.IsActive = IsActive;
IsActiveChanged?.Invoke(this, new EventArgs());
}
