public static void TryLoseFocus(ScreenLayer layer)
{
if (ScreenManager._focusedLayer != layer)
{
return;
}
ScreenManager._focusedLayer?.OnLoseFocus();
List <ScreenLayer> sortedActiveLayers = ScreenManager.SortedActiveLayers;
if (ScreenManager._sortedActiveLayersCopy.Length != sortedActiveLayers.Capacity)
{
ScreenManager._sortedActiveLayersCopy = new ScreenLayer[sortedActiveLayers.Capacity];
}
sortedActiveLayers.CopyTo(ScreenManager._sortedActiveLayersCopy);
for (int index = sortedActiveLayers.Count - 1; index >= 0; --index)
{
ScreenLayer screenLayer = ScreenManager._sortedActiveLayersCopy[index];
if (screenLayer.IsActive && screenLayer.IsFocusLayer && layer != screenLayer)
{
ScreenManager._focusedLayer = screenLayer;
return;
}
}
ScreenManager._sortedActiveLayersCopy.Initialize();
ScreenManager._focusedLayer = (ScreenLayer)null;
}
public static void OnFinalize()
{
ScreenManager.DeactivateAndFinalizeAllScreens();
ScreenManager._screenList = (List <ScreenBase>)null;
ScreenManager._globalLayers = (List <GlobalLayer>)null;
ScreenManager._focusedLayer = (ScreenLayer)null;
}
static ScreenManager()
{
ScreenManager._globalLayers = new List <GlobalLayer>();
ScreenManager._screenList = new List <ScreenBase>();
ScreenManager._pressedMouseButtons = new List <InputKey>();
ScreenManager._focusedLayer = (ScreenLayer)null;
ScreenManager.FirstHitLayer = (ScreenLayer)null;
}
public void RemoveLayer(ScreenLayer layer)
{
if (this.IsActive)
{
layer.LastActiveState = false;
layer.HandleDeactivate();
}
layer.HandleFinalize();
this._layers.Remove(layer);
ScreenManager.RefreshGlobalOrder();
}
public static void TrySetFocus(ScreenLayer layer)
{
if (ScreenManager._focusedLayer != null && ScreenManager._focusedLayer.InputRestrictions.Order > layer.InputRestrictions.Order && layer.IsActive || !layer.IsFocusLayer && !layer.FocusTest())
{
return;
}
if (ScreenManager._focusedLayer != null && ScreenManager._focusedLayer != layer)
{
ScreenManager._focusedLayer.OnLoseFocus();
}
ScreenManager._focusedLayer = layer;
}
public static void SetSuspendLayer(ScreenLayer layer, bool isSuspended)
{
if (isSuspended)
{
layer.HandleDeactivate();
}
else
{
layer.HandleActivate();
}
layer.LastActiveState = !isSuspended;
}
public void AddLayer(ScreenLayer layer)
{
if (this._layers.Contains(layer))
{
return;
}
this._layers.Add(layer);
this._layers.Sort();
if (!this.IsActive)
{
return;
}
layer.LastActiveState = true;
layer.HandleActivate();
}
internal void HandleDeactivate()
{
Debug.Print(this.ToString() + "::HandleDeactivate");
if (!this.IsActive)
{
return;
}
this.IsActive = false;
for (int index = this._layers.Count - 1; index >= 0; --index)
{
ScreenLayer layer = this._layers[index];
if (layer.IsActive)
{
layer.HandleDeactivate();
}
}
this.OnDeactivate();
}
public void SetLayerCategoriesState(string[] categoryIds, bool isActive)
{
for (int index = 0; index < this._layers.Count; ++index)
{
ScreenLayer layer = this._layers[index];
if (((IReadOnlyList <string>)categoryIds).IndexOf <string>(layer._categoryId) >= 0)
{
if (isActive && !layer.IsActive)
{
layer.HandleActivate();
}
else if (!isActive && layer.IsActive)
{
layer.HandleDeactivate();
}
}
}
}
internal void HandlePause()
{
Debug.Print(this.ToString() + "::HandlePause");
if (this.IsPaused)
{
return;
}
for (int index = this._layers.Count - 1; index >= 0; --index)
{
ScreenLayer layer = this._layers[index];
if (layer.IsActive)
{
layer.HandleDeactivate();
}
}
this.IsPaused = true;
this.OnPause();
}
internal void HandleResume()
{
Debug.Print(this.ToString() + "::HandleResume");
if (!this.IsPaused)
{
return;
}
Utilities.ClearOldResourcesAndObjects();
for (int index = this._layers.Count - 1; index >= 0; --index)
{
ScreenLayer layer = this._layers[index];
if (!layer.IsActive)
{
layer.HandleActivate();
}
}
this.IsPaused = false;
this.OnResume();
}
private static void LateUpdate(float dt)
{
ScreenManager.UpdateMouseVisibility();
List <ScreenLayer> sortedActiveLayers = ScreenManager.SortedActiveLayers;
if (ScreenManager._sortedActiveLayersCopy.Length != sortedActiveLayers.Capacity)
{
ScreenManager._sortedActiveLayersCopy = new ScreenLayer[sortedActiveLayers.Capacity];
}
sortedActiveLayers.CopyTo(ScreenManager._sortedActiveLayersCopy);
int count = sortedActiveLayers.Count;
bool flag = false;
for (int index = 0; index < count; ++index)
{
ScreenLayer layer = ScreenManager._sortedActiveLayersCopy[index];
if (ScreenManager.FocusTest(layer))
{
flag = true;
}
layer.LateProcessEvents();
if (!flag)
{
ScreenLayer focusedLayer = ScreenManager._focusedLayer;
}
}
for (int index = 0; index < count; ++index)
{
ScreenLayer screenLayer = ScreenManager._sortedActiveLayersCopy[index];
screenLayer.OnLateUpdate(dt);
if (screenLayer != ScreenManager.FirstHitLayer)
{
screenLayer.Input.ResetLastDownKeys();
}
}
ScreenManager._sortedActiveLayersCopy.Initialize();
ScreenManager.FirstHitLayer?.Input?.UpdateLastDownKeys();
ScreenManager.FirstHitLayer = (ScreenLayer)null;
}
private static void Update()
{
ScreenManager.UpdateMouseVisibility();
List <ScreenLayer> sortedActiveLayers = ScreenManager.SortedActiveLayers;
if (ScreenManager._sortedActiveLayersCopyForUpdate.Length != sortedActiveLayers.Capacity)
{
ScreenManager._sortedActiveLayersCopyForUpdate = new ScreenLayer[sortedActiveLayers.Capacity];
}
sortedActiveLayers.CopyTo(ScreenManager._sortedActiveLayersCopyForUpdate);
for (int index = sortedActiveLayers.Count - 1; index >= 0; --index)
{
ScreenLayer screenLayer = ScreenManager._sortedActiveLayersCopyForUpdate[index];
if (!screenLayer.Finalized)
{
screenLayer.ProcessEvents();
}
}
for (int count = sortedActiveLayers.Count; count < ScreenManager._sortedActiveLayersCopyForUpdate.Length; ++count)
{
ScreenManager._sortedActiveLayersCopyForUpdate[count] = (ScreenLayer)null;
}
}
private static bool FocusTest(ScreenLayer layer) => ScreenManager._focusedLayer == layer;
private static void EarlyUpdate()
{
ScreenManager.UsableArea = EngineApplicationInterface.IScreen.GetUsableAreaPercentages();
ScreenManager.RefreshGlobalOrder();
ScreenManager.UpdateMouseVisibility();
List <ScreenLayer> sortedActiveLayers = ScreenManager.SortedActiveLayers;
if (ScreenManager._sortedActiveLayersCopy.Length != sortedActiveLayers.Capacity)
{
ScreenManager._sortedActiveLayersCopy = new ScreenLayer[sortedActiveLayers.Capacity];
}
sortedActiveLayers.CopyTo(ScreenManager._sortedActiveLayersCopy);
int count = sortedActiveLayers.Count;
TaleWorlds.Library.InputType p1 = TaleWorlds.Library.InputType.None;
for (int index = 0; index < count; ++index)
{
ScreenManager._sortedActiveLayersCopy[index].MouseEnabled = true;
}
bool?mouseInput = ScreenManager.GetMouseInput();
for (int index = count - 1; index >= 0; --index)
{
ScreenLayer layer = ScreenManager._sortedActiveLayersCopy[index];
if (!layer.Finalized)
{
bool?isMousePressed = new bool?();
bool?nullable = mouseInput;
bool flag = false;
if (nullable.GetValueOrDefault() == flag & nullable.HasValue)
{
isMousePressed = new bool?(false);
}
TaleWorlds.Library.InputType handledInputs = TaleWorlds.Library.InputType.None;
InputUsageMask inputUsageMask = layer.InputUsageMask;
if (layer.HitTest())
{
if (ScreenManager.FirstHitLayer == null)
{
ScreenManager.FirstHitLayer = layer;
MouseManager.ActivateMouseCursor(layer.ActiveCursor);
}
if (!p1.HasAnyFlag <TaleWorlds.Library.InputType>(TaleWorlds.Library.InputType.MouseButton) && inputUsageMask.HasAnyFlag <InputUsageMask>(InputUsageMask.MouseButtons))
{
isMousePressed = mouseInput;
handledInputs |= TaleWorlds.Library.InputType.MouseButton;
p1 |= TaleWorlds.Library.InputType.MouseButton;
}
if (!p1.HasAnyFlag <TaleWorlds.Library.InputType>(TaleWorlds.Library.InputType.MouseWheel) && inputUsageMask.HasAnyFlag <InputUsageMask>(InputUsageMask.MouseWheels))
{
handledInputs |= TaleWorlds.Library.InputType.MouseWheel;
p1 |= TaleWorlds.Library.InputType.MouseWheel;
}
}
if (ScreenManager.FocusTest(layer))
{
handledInputs |= TaleWorlds.Library.InputType.Key;
p1 |= TaleWorlds.Library.InputType.Key;
}
layer.EarlyProcessEvents(handledInputs, isMousePressed);
}
}
ScreenManager._sortedActiveLayersCopy.Initialize();
}
public bool HasLayer(ScreenLayer layer) => this._layers.Contains(layer);
