////////////////
public ModTagsEditorManager(UIInfoDisplay infoDisplay, MenuUIDefinition menuDef, UIState _uiModInfo)
: base(infoDisplay, menuDef, false)
{
this.TagsUI = new UIModTagsEditorInterface(UITheme.Vanilla, this, _uiModInfo);
this.TagsUI.RefreshControls();
}
public ModTagsModBrowserManager(UIInfoDisplay infoDisplay, MenuUIDefinition menuDef)
: base(infoDisplay, menuDef, true)
{
this.TagsUI = new UIModTagsModBrowserInterface(UITheme.Vanilla, this);
this.TagsUI.RefreshControls();
}
////////////////
public IDictionary <string, MenuContext> GetContexts(MenuUIDefinition menuDef)
{
if (!this.Contexts.ContainsKey(menuDef))
{
this.Contexts[menuDef] = new Dictionary <string, MenuContext>();
}
return(this.Contexts[menuDef]);
}
////////////////
/// <summary></summary>
/// <param name="menuDefinition">Menu context to bind to.</param>
/// <param name="contextName"></param>
/// <param name="myElement">UI element of the widget.</param>
/// <param name="isInner">See `IsInner` property.</param>
public WidgetMenuContext(MenuUIDefinition menuDefinition,
string contextName,
UIElement myElement,
bool isInner)
: base(menuDefinition, contextName)
{
this.MyElement = myElement;
this.IsInner = isInner;
}
/// <summary>
/// Gets a menu UI corresponding to a given menu definition.
/// </summary>
/// <param name="menuDef"></param>
/// <returns></returns>
public static UIState GetMenuUI(MenuUIDefinition menuDef)
{
string menuUiName = Enum.GetName(typeof(MenuUIDefinition), menuDef);
UIState menuUi;
ReflectionHelpers.Get(typeof(MenuUIs), null, menuUiName, out menuUi);
return(menuUi);
}
////////////////
/// <summary>
/// </summary>
/// <param name="menuDefinitionOfContext">Which menu UI this context belongs to.</param>
/// <param name="contextName">Unique name of this context.</param>
/// <param name="displayInfo">Whether to show an info display box at the top.</param>
/// <param name="occludesLogo">Whether the Terraria logo is removed.</param>
protected SessionMenuContext(MenuUIDefinition menuDefinitionOfContext,
string contextName,
bool displayInfo,
bool occludesLogo)
: base(menuDefinitionOfContext, contextName)
{
this.DisplayInfo = displayInfo;
this.OccludesLogo = occludesLogo;
this.OldLogo1 = Main.logoTexture;
this.OldLogo2 = Main.logo2Texture;
this.InfoDisplay = new UIInfoDisplay();
}
/// <summary>
/// Indicates if a menu "context" (menu page) has custom content.
/// </summary>
/// <param name="menuDefinition"></param>
/// <returns></returns>
public static bool ContainsMenuContexts(MenuUIDefinition menuDefinition)
{
var mymod = ModHelpersMod.Instance;
if (mymod == null || mymod.MenuContextMngr == null)
{
return(false);
}
IDictionary <string, MenuContext> contexts = mymod.MenuContextMngr.GetContexts(menuDefinition);
return(contexts != null && contexts.Count > 0);
}
/// <summary>
/// Indicates if a menu "context" (menu page) has custom content.
/// </summary>
/// <param name="menuDefinition"></param>
/// <returns></returns>
public static bool ContainsMenuContexts(MenuUIDefinition menuDefinition)
{
var menuCtxMngr = ModContent.GetInstance <MenuContextServiceManager>();
if (menuCtxMngr == null)
{
return(false);
}
IDictionary <string, MenuContext> contexts = menuCtxMngr.GetContexts(menuDefinition);
return(contexts != null && contexts.Count > 0);
}
////////////////
protected ModTagsEditorMenuContext(MenuUIDefinition menuDef, string contextName)
: base(menuDef, contextName)
{
UIState uiModInfo = MainMenuHelpers.GetMenuUI(menuDef);
if (uiModInfo == null || uiModInfo.GetType().Name != "UIModInfo")
{
throw new ModHelpersException("UI context not UIModInfo, found "
+ (uiModInfo?.GetType().Name ?? "null")
+ " (" + menuDef + ")");
}
this.Manager = new ModTagsEditorManager(this.InfoDisplay, menuDef, uiModInfo);
}
////////////////
public override void ApplyMenuContext(MenuUIDefinition menuDef, string baseContextName)
{
base.ApplyMenuContext(menuDef, baseContextName);
var finishButtonWidgetCtx = new WidgetMenuContext(menuDef,
baseContextName + " Tag Finish Button",
this.EditButton,
false);
var hiddenWidgetCtx = new WidgetMenuContext(menuDef,
baseContextName + " Hidden",
this.HiddenPanel,
false);
MenuContextService.AddMenuContext(hiddenWidgetCtx);
MenuContextService.AddMenuContext(finishButtonWidgetCtx);
}
////////////////
/// <summary>
/// Gets a specific piece of added content for a menu "context" (menu page) by name.
/// </summary>
/// <param name="menuDefinition"></param>
/// <param name="contextName"></param>
/// <returns></returns>
public static MenuContext GetMenuContext(MenuUIDefinition menuDefinition, string contextName)
{
var mymod = ModHelpersMod.Instance;
if (mymod == null || mymod.MenuContextMngr == null)
{
return(null);
}
IDictionary <string, MenuContext> contexts = mymod.MenuContextMngr.GetContexts(menuDefinition);
if (contexts.ContainsKey(contextName))
{
return(contexts[contextName]);
}
return(null);
}
////////////////
/// <summary>
/// Gets a specific piece of added content for a menu "context" (menu page) by name.
/// </summary>
/// <param name="menuDefinition"></param>
/// <param name="contextName"></param>
/// <returns></returns>
public static MenuContext GetMenuContext(MenuUIDefinition menuDefinition, string contextName)
{
var menuCtxMngr = ModContent.GetInstance <MenuContextServiceManager>();
if (menuCtxMngr == null)
{
return(null);
}
IDictionary <string, MenuContext> contexts = menuCtxMngr.GetContexts(menuDefinition);
if (contexts.ContainsKey(contextName))
{
return(contexts[contextName]);
}
return(null);
}
////////////////
private void SwitchToUI(UIState ui)
{
MenuUIDefinition openingUiDef = 0;
MenuUIDefinition closingUiDef = this.CurrentMenuUI;
// Out with the old
if (closingUiDef != 0 && this.Contexts.ContainsKey(closingUiDef))
{
foreach ((string ctxName, MenuContext ctx) in this.Contexts[closingUiDef])
{
ctx.Hide(MainMenuLibraries.GetMenuUI(closingUiDef));
}
}
// Validate
if (ui != null)
{
if (!Enum.TryParse(ui.GetType().Name, out openingUiDef))
{
if (ModLibsUIConfig.Instance.DebugModeMenuInfo)
{
LogLibraries.WarnOnce("Could not get MenuUIDefinition " + ui.GetType().Name);
}
this.CurrentMenuUI = 0;
return;
}
}
else
{
this.PreviousMenuUI = this.CurrentMenuUI;
this.CurrentMenuUI = 0;
}
// In with the new
if (this.Contexts.ContainsKey(openingUiDef))
{
foreach (MenuContext ctx in this.Contexts[openingUiDef].Values.ToArray())
{
ctx.ActivateIfInactive(ui);
ctx.Show(ui);
}
}
this.PreviousMenuUI = this.CurrentMenuUI;
this.CurrentMenuUI = openingUiDef;
}
////////////////
/// <summary>
/// Adds a piece of menu content to a menu "context" (menu page) by name.
/// </summary>
/// <param name="context"></param>
public static void AddMenuContext(MenuContext context)
{
var mymod = ModHelpersMod.Instance;
MenuUIDefinition menuDef = context.MenuDefinitionOfContext;
IDictionary <string, MenuContext> contexts = mymod.MenuContextMngr.GetContexts(menuDef);
contexts[context.ContextName] = context;
UIState ui = Main.MenuUI.CurrentState;
string currUiContextName = ui?.GetType().Name;
if (Enum.GetName(typeof(MenuUIDefinition), menuDef) == currUiContextName)
{
context.ActivateIfInactive(ui);
context.Show(ui);
}
}
////////////////
private void HideAllForCurrentMenuUI()
{
if (this.CurrentMenuUI == 0)
{
return;
}
MenuUIDefinition menuDef = this.CurrentMenuUI;
if (!this.Contexts.ContainsKey(menuDef))
{
LogHelpers.Warn("Missing menu context " + menuDef);
return;
}
IDictionary <string, MenuContext> contexts = this.Contexts[menuDef];
foreach (MenuContext context in contexts.Values)
{
context.Hide(MainMenuHelpers.GetMenuUI(this.CurrentMenuUI));
}
}
////////////////
public virtual void ApplyMenuContext(MenuUIDefinition menuDef, string baseContextName)
{
var thisWidgetCtx = new WidgetMenuContext(menuDef, baseContextName + " Tags Panel", this, false);
MenuContextService.AddMenuContext(thisWidgetCtx);
int i = 0;
foreach (UIMenuButton categoryButton in this.CategoryButtons.Values)
{
var buttonWidgetCtx = new WidgetMenuContext(menuDef,
baseContextName + " Tag Category " + i,
categoryButton,
false);
MenuContextService.AddMenuContext(buttonWidgetCtx);
i++;
}
i = 0;
foreach (UITagMenuButton tagButton in this.TagButtons.Values)
{
var buttonWidgetCtx = new WidgetMenuContext(menuDef,
baseContextName + " Tag " + i,
tagButton,
false);
MenuContextService.AddMenuContext(buttonWidgetCtx);
i++;
}
var resetButtonWidgetCtx = new WidgetMenuContext(menuDef,
baseContextName + " Tag Reset Button",
this.ResetButton,
false);
MenuContextService.AddMenuContext(resetButtonWidgetCtx);
}
////////////////
/// <summary>
/// Adds a piece of menu content to a menu "context" (menu page) by name.
/// </summary>
/// <param name="context"></param>
public static void AddMenuContext(MenuContext context)
{
var menuCtxMngr = ModContent.GetInstance <MenuContextServiceManager>();
if (menuCtxMngr == null)
{
return;
}
MenuUIDefinition menuDef = context.MenuDefinitionOfContext;
IDictionary <string, MenuContext> contexts = menuCtxMngr.GetContexts(menuDef);
contexts[context.ContextName] = context;
UIState ui = Main.MenuUI.CurrentState;
string currUiContextName = ui?.GetType().Name;
if (Enum.GetName(typeof(MenuUIDefinition), menuDef) == currUiContextName)
{
context.ActivateIfInactive(ui);
context.Show(ui);
}
}
private void Update()
{
UIState ui = Main.MenuUI.CurrentState;
string prevUiName, currUiName;
if (this.CurrentMenuUI == 0)
{
prevUiName = null;
}
else
{
MenuUIDefinition prevUiDef = this.CurrentMenuUI;
prevUiName = Enum.GetName(typeof(MenuUIDefinition), prevUiDef);
}
currUiName = ui?.GetType().Name;
if (prevUiName == currUiName)
{
return;
}
this.SwitchToUI(ui);
}
////////////////
protected ModTagsModBrowserMenuContext(MenuUIDefinition menuDef, string contextName)
: base(menuDef, contextName)
{
this.Manager = new ModTagsModBrowserManager(this.InfoDisplay, menuDef);
}
////////////////
private ModUpdatesMenuContext(MenuUIDefinition menuDef, string contextName)
: base(menuDef, contextName, false, false)
{
}
////////////////
protected ModTagsManager(UIInfoDisplay infoDisplay, MenuUIDefinition menuDef, bool canExcludeTags)
{
this.MenuDefinition = menuDef;
this.InfoDisplay = infoDisplay;
this.CanExcludeTags = canExcludeTags;
}
////////////////
protected ModTagsMenuContextBase(MenuUIDefinition menuDef, string contextName)
: base(menuDef, contextName, true, true)
{
}
////////////////
/// <summary></summary>
/// <param name="menuDefinitionOfContext"></param>
/// <param name="contextName"></param>
protected MenuContext(MenuUIDefinition menuDefinitionOfContext, string contextName)
{
this.MenuDefinitionOfContext = menuDefinitionOfContext;
this.ContextName = contextName;
}
