public WSConfigPanel(TinyIoCContainer container)
{
InitializeComponent();
_config = container.Resolve <IPluginConfig>();
_server = container.Resolve <WSServer>();
_plugin = container.Resolve <PluginMain>();
_registry = container.Resolve <Registry>();
ipTxt.Text = _config.WSServerIP;
portTxt.Text = "" + _config.WSServerPort;
sslBox.Checked = _config.WSServerSSL;
sslBox.Enabled = _server.IsSSLPossible();
for (var i = 0; i < regionCb.Items.Count; i++)
{
if ((string)regionCb.Items[i] == _config.TunnelRegion)
{
regionCb.SelectedIndex = i;
break;
}
}
UpdateStatus(null, new WSServer.StateChangedArgs(_server.IsRunning(), _server.IsFailed()));
_server.OnStateChanged += UpdateStatus;
UpdateTunnelStatus(TunnelStatus.Inactive);
lblUrlConfidentWarning.Visible = false;
}
public WSServer(TinyIoCContainer container)
{
_container = container;
_logger = container.Resolve <ILogger>();
_cfg = container.Resolve <IPluginConfig>();
_plugin = container.Resolve <PluginMain>();
}
public void Configurate(IPluginConfig Input)
{
//nothing to configure in this plugin
//only used in conjunction with inputs of type cmpdConfigurate
if (Input.Name == "Number of Input Poses")
{
IValueConfig valueInput = (IValueConfig)Input;
valueInput.GetValue(0, out poseCount);
FInput.SetSubType(0, poseCount - 1, 0.01, 0.0, false, false, false);
int oldPoseCount = FPoseNodes.Count;
for (int i = oldPoseCount - 1; i >= (int)poseCount; i--)
{
FHost.DeletePin(FPoseNodes[i]);
}
for (int i = oldPoseCount - 1; i >= (int)poseCount; i--)
{
FPoseNodes.RemoveAt(i);
FPoses.RemoveAt(i);
}
var guids = new System.Guid[1];
guids[0] = SkeletonNodeIO.GUID;
INodeIn currPoseNode;
for (int i = oldPoseCount; i < (int)poseCount; i++)
{
FHost.CreateNodeInput("Pose " + (i + 1), TSliceMode.Single, TPinVisibility.True, out currPoseNode);
currPoseNode.SetSubType(guids, "Skeleton");
FPoseNodes.Add(currPoseNode);
FPoses.Add(null);
}
}
}
public static CactbotEventSourceConfig LoadConfig(IPluginConfig pluginConfig, RainbowMage.OverlayPlugin.ILogger logger)
{
var result = new CactbotEventSourceConfig();
if (pluginConfig.EventSourceConfigs.ContainsKey("CactbotESConfig"))
{
var obj = pluginConfig.EventSourceConfigs["CactbotESConfig"];
if (obj.TryGetValue("OverlayData", out JToken value))
{
try {
result.OverlayData = value.ToObject <Dictionary <string, JToken> >();
} catch (Exception e) {
logger.Log(LogLevel.Error, Strings.LoadOverlayDataSettingsFailed, e.ToString());
}
}
if (obj.TryGetValue("LastUpdateCheck", out value))
{
try {
result.LastUpdateCheck = value.ToObject <DateTime>();
} catch (Exception e) {
logger.Log(LogLevel.Error, Strings.LoadLastUpdateCheckSettingsFailed, e.ToString());
}
}
}
return(result);
}
public ControlPanel(TinyIoCContainer container)
{
InitializeComponent();
tableLayoutPanel0.PerformLayout();
splitContainer1.SplitterDistance = (int)Math.Round(Height * 0.75);
_container = container;
_logger = container.Resolve <ILogger>();
_pluginMain = container.Resolve <PluginMain>();
_config = container.Resolve <IPluginConfig>();
_registry = container.Resolve <Registry>();
this.checkBoxFollowLog.Checked = _config.FollowLatestLog;
_generalTab = new ConfigTabPage
{
Name = Resources.GeneralTab,
Text = "",
};
_generalTab.Controls.Add(new GeneralConfigTab(container));
_eventTab = new ConfigTabPage
{
Name = Resources.EventConfigTab,
Text = "",
};
_eventTab.Controls.Add(new EventSources.BuiltinEventConfigPanel(container));
_logger.RegisterListener(AddLogEntry);
_registry.EventSourceRegistered += (o, e) => Invoke((Action)(() => AddEventSourceTab(o, e)));
}
/// <summary ref="LoadConfig">
/// Load the configuration from the configuration string.
/// </summary>
/// <param name="configType">The type of configuration.</param>
public void LoadConfig(ConfigType?configType = null)
{
var config = ConfigString;
if (string.IsNullOrEmpty(config))
{
return;
}
switch (configType ?? ConfigType)
{
case ConfigType.Json:
Config = JsonConfig.Deserialize <JsonConfig>(config);
break;
case ConfigType.Xml:
Config = XmlConfig.Deserialize <XmlConfig>(config);
break;
case ConfigType.None:
break;
case ConfigType.String:
break;
default:
throw new ArgumentOutOfRangeException(nameof(configType), configType, null);
}
}
public void Configurate(IPluginConfig Input)
{
if (Input == this.FPinCfgFields)
{
//Clear all field pins
foreach (IStringOut sout in this.FPinOutFields.Values)
{
this.FHost.DeletePin(sout);
}
this.FPinOutFields.Clear();
string fnames;
this.FPinCfgFields.GetString(0, out fnames);
string[] fields = fnames.Split(",".ToCharArray());
//Add field pin only if same name is not added already
foreach (string f in fields)
{
if (f.Length > 0)
{
if (!this.FPinOutFields.ContainsKey(f))
{
IStringOut so;
this.FHost.CreateStringOutput(f, TSliceMode.Dynamic, TPinVisibility.True, out so);
this.FPinOutFields.Add(f, so);
}
}
}
}
}
public void Configurate(IPluginConfig Input)
{
if (Input == FInCount)
{
double inCount;
FInCount.GetValue(0, out inCount);
int idiff = FInList.Count - (int)Math.Round(inCount);
if (idiff > 0) //delete pins
{
for (int i = 0; i < idiff; i++)
{
IStringIn delPin = FInList[FInList.Count - 1];
FInList.Remove(delPin);
FHost.DeletePin(delPin);
}
}
else if (idiff < 0) //create pins
{
for (int i = 0; i > idiff; i--)
{
IStringIn newPin;
FHost.CreateStringInput("Input " + (FInList.Count + 1), TSliceMode.Dynamic, TPinVisibility.True, out newPin);
newPin.SetSubType("", false);
FInList.Add(newPin);
}
}
evaluate = true;
}
}
public void Configurate(IPluginConfig Input)
{
if (Input == null)
{
return;
}
switch (Input.Name)
{
case "Debug Pins":
double pinConfigDebug;
FPinConfigDebug.GetValue(0, out pinConfigDebug);
if (pinConfigDebug == 1d)
{
if (FPinDebugButtons == null)
{
FHost.CreateValueOutput("Buttons (Debug)", 1, null, TSliceMode.Single, TPinVisibility.True, out FPinDebugButtons);
FPinDebugButtons.SetSubType(int.MinValue, int.MinValue, 1, 0, false, false, true);
}
}
else if (FPinDebugButtons != null)
{
FHost.DeletePin(FPinDebugButtons);
FPinDebugButtons = null;
}
break;
}
}
public static MiniParseEventSourceConfig LoadConfig(IPluginConfig Config)
{
var result = new MiniParseEventSourceConfig();
if (Config.EventSourceConfigs.ContainsKey("MiniParse"))
{
var obj = Config.EventSourceConfigs["MiniParse"];
if (obj.TryGetValue("UpdateInterval", out JToken value))
{
result.updateInterval = value.ToObject <int>();
}
if (obj.TryGetValue("SortKey", out value))
{
result.sortKey = value.ToString();
}
if (obj.TryGetValue("SortDesc", out value))
{
result.sortDesc = value.ToObject <bool>();
}
if (obj.TryGetValue("UpdateDpsDuringImport", out value))
{
result.updateDpsDuringImport = value.ToObject <bool>();
}
}
return(result);
}
private static IPluginConfig GetVariantConfingPluginConfig(IPluginConfig rawConfig, ISet <string> flights)
{
var config = new VariantConfigPluginConfig(rawConfig);
config.Initialize(flights.Select(f => new VariantConstraint("flt", f)));
return(config);
}
public static CactbotEventSourceConfig LoadConfig(IPluginConfig pluginConfig)
{
var result = new CactbotEventSourceConfig();
if (pluginConfig.EventSourceConfigs.ContainsKey("CactbotESConfig"))
{
var obj = pluginConfig.EventSourceConfigs["CactbotESConfig"];
if (obj.TryGetValue("OverlayData", out JToken value))
{
result.OverlayData = value.ToObject <Dictionary <string, string> >();
}
if (obj.TryGetValue("RemoteVersionSeen", out value))
{
result.RemoteVersionSeen = value.ToString();
}
if (obj.TryGetValue("UserConfigFile", out value))
{
result.UserConfigFile = value.ToString();
}
if (obj.TryGetValue("WatchFileChanges", out value))
{
result.WatchFileChanges = value.ToObject <bool>();
}
}
return(result);
}
/// <summary ref="LoadConfig">
/// Load the configuration from the configuration string.
/// </summary>
/// <param name="configType">The type of configuration.</param>
public void LoadConfig(ConfigType?configType = null)
{
ConfigString = SecureConfigString;
if (!IgnoreUnsecureConfig && String.IsNullOrWhiteSpace(ConfigString))
{
ConfigString = UnsecureConfigString;
}
if (string.IsNullOrEmpty(ConfigString))
{
return;
}
switch (configType ?? ConfigType)
{
case ConfigType.Xml:
Config = XmlConfig.Deserialize <XmlConfig>(ConfigString);
break;
case ConfigType.None:
break;
case ConfigType.String:
break;
default:
throw new ArgumentOutOfRangeException(nameof(configType), configType, null);
}
}
public void Configurate(IPluginConfig Input)
{
double inputcnt;
this.FPinInNumInputs.GetValue(0, out inputcnt);
int prevcnt = this.FInputCount;
this.FInputCount = Convert.ToInt32(inputcnt);
if (this.FInputCount > prevcnt)
{
//Add new pins, as value is bigger
while (FPinTransforms.Count < this.FInputCount)
{
ITransformIn pin;
int index = FPinTransforms.Count + 1;
//Add new Transform pin
this.FHost.CreateTransformInput("Transform " + index, TSliceMode.Dynamic, TPinVisibility.True, out pin);
this.FPinTransforms.Add(pin);
}
}
else
{
//Remove pins, as value is lower
while (FPinTransforms.Count > this.FInputCount)
{
this.FHost.DeletePin(this.FPinTransforms[this.FPinTransforms.Count - 1]);
this.FPinTransforms.RemoveAt(this.FPinTransforms.Count - 1);
}
}
}
public void Configurate(IPluginConfig Input)
{
if (Input.Name == "Children Count")
{
IValueConfig valueInput = (IValueConfig)Input;
double pinCount;
valueInput.GetValue(0, out pinCount);
int oldChildrenCount = FChildPins.Count;
for (int i = oldChildrenCount - 1; i >= (int)pinCount; i--)
{
FHost.DeletePin(FChildPins[i]);
}
for (int i = oldChildrenCount - 1; i >= (int)pinCount; i--)
{
FChildPins.RemoveAt(i);
}
var guids = new System.Guid[1];
guids[0] = SkeletonNodeIO.GUID;
INodeIn node;
for (int i = oldChildrenCount; i < pinCount; i++)
{
FHost.CreateNodeInput("Child" + (i + 1), TSliceMode.Single, TPinVisibility.True, out node);
node.SetSubType(guids, "Skeleton");
FChildPins.Add(node);
}
}
}
private static void AssertConfigurationIsValid(IPluginConfig config, string[][] configSettings,
string errorMessage)
{
Assert.AreEqual(configSettings.Length, config.Settings.Count,
$"{errorMessage} Incorrect number of settings returned.");
Assert.AreEqual(configSettings[0][0], config.Settings[0].Name, errorMessage);
Assert.AreEqual(configSettings[0][1], config.Settings[0].Value, errorMessage);
Assert.AreEqual(configSettings[1][0], config.Settings[1].Name, errorMessage);
Assert.AreEqual(configSettings[1][1], config[configSettings[1][0]], errorMessage);
// Check for null names using iteration
foreach (var setting in config)
{
Assert.IsNotNull(setting.Name);
}
// Check for null values using enumerator
using (var enumerator = config.GetEnumerator())
{
enumerator.MoveNext(); // move to the first value
Assert.IsNotNull(enumerator?.Current?.Value);
}
Assert.IsNull(config["somebadnametotryandget"], errorMessage);
}
public static CactbotEventSourceConfig LoadConfig(IPluginConfig pluginConfig, RainbowMage.OverlayPlugin.ILogger logger)
{
var result = new CactbotEventSourceConfig();
if (pluginConfig.EventSourceConfigs.ContainsKey("CactbotESConfig"))
{
var obj = pluginConfig.EventSourceConfigs["CactbotESConfig"];
// TODO: add try/catch here
if (obj.TryGetValue("OverlayData", out JToken value))
{
try {
result.OverlayData = value.ToObject <Dictionary <string, JToken> >();
} catch (Exception e) {
logger.Log(LogLevel.Error, "Failed to load OverlayData setting: {0}", e.ToString());
}
}
if (obj.TryGetValue("RemoteVersionSeen", out value))
{
result.RemoteVersionSeen = value.ToString();
}
}
return(result);
}
public OverlayHider(TinyIoCContainer container)
{
this.config = container.Resolve <IPluginConfig>();
this.logger = container.Resolve <ILogger>();
this.main = container.Resolve <PluginMain>();
this.repository = container.Resolve <FFXIVRepository>();
container.Resolve <NativeMethods>().ActiveWindowChanged += ActiveWindowChangedHandler;
container.Resolve <NetworkParser>().OnOnlineStatusChanged += OnlineStatusChanged;
container.Resolve <EventSources.EnmityEventSource>().CombatStatusChanged += CombatStatusChanged;
try
{
repository.RegisterProcessChangedHandler(UpdateFFXIVProcess);
} catch (Exception ex)
{
logger.Log(LogLevel.Error, "Failed to register process watcher for FFXIV; this is only an issue if you're playing FFXIV. As a consequence, OverlayPlugin won't be able to hide overlays if you're not in-game.");
logger.Log(LogLevel.Error, "Details: " + ex.ToString());
}
focusTimer = new Timer();
focusTimer.Tick += (o, e) => ActiveWindowChangedHandler(this, IntPtr.Zero);
focusTimer.Interval = 10000; // 10 seconds
focusTimer.Start();
}
public static PingEventSourceConfig LoadConfig(IPluginConfig pluginConfig)
{
var result = new PingEventSourceConfig();
if (pluginConfig.EventSourceConfigs.ContainsKey("qitana.Ping"))
{
var obj = pluginConfig.EventSourceConfigs["qitana.Ping"];
if (obj.TryGetValue("Enabled", out JToken enabled))
{
result.Enabled = enabled.ToObject <bool>();
}
if (obj.TryGetValue("Interval", out JToken interval))
{
result.Interval = interval.ToObject <int>();
}
if (obj.TryGetValue("Timeout", out JToken timeout))
{
result.Timeout = timeout.ToObject <int>();
}
}
return(result);
}
public override void LoadConfig(IPluginConfig config)
{
Config = CactbotEventSourceConfig.LoadConfig(config, logger);
if (Config.OverlayData == null)
{
Config.OverlayData = new Dictionary <string, JToken>();
}
}
public PluginManager(IPluginConfig config, string rootPath)
{
this.Config = config;
this.Config.PluginChangedState += Config_PluginChangedState;
this.rootPath = rootPath;
this.bridge = new PluginBridge(this);
}
public void Configurate(IPluginConfig Input)
{
string vars;
this.FPinInVarName.GetString(0, out vars);
vars = vars == null ? String.Empty : vars;
string[] arrvars = vars.Split(",".ToCharArray());
List <string> varllst = new List <string>(arrvars);
//Remove old pins
List <IValueFastIn> todelete = new List <IValueFastIn>();
foreach (IValueFastIn pin in this.FPinInVariables)
{
if (!varllst.Contains(pin.Name))
{
todelete.Add(pin);
}
}
foreach (IValueFastIn pin in todelete)
{
this.FHost.DeletePin(pin);
this.FPinInVariables.Remove(pin);
this.FVarNames.Remove(pin.Name);
}
List <string> sorted = new List <string>();
foreach (string v in arrvars)
{
if (!this.FVarNames.Contains(v))
{
IValueFastIn pin;
this.FHost.CreateValueFastInput(v, 1, null, TSliceMode.Dynamic, TPinVisibility.True, out pin);
this.FPinInVariables.Add(pin);
this.FVarNames.Add(v);
}
if (!sorted.Contains(v))
{
sorted.Add(v);
}
}
foreach (IValueFastIn pin in this.FPinInVariables)
{
pin.Order = sorted.IndexOf(pin.Name);
}
//int order = 0;
this.FPinInTerm.Order = arrvars.Length + 1;
this.FInvalidate = true;
}
public override void LoadConfig(IPluginConfig config)
{
this.Config = Registry.Resolve <BuiltinEventConfig>();
this.Config.UpdateIntervalChanged += (o, e) =>
{
this.Start();
};
}
public override void Configurate(IPluginConfig Input, bool FirstFrame)
{
base.Configurate(Input, FirstFrame);
for (int i = 0; i < OutputSlices.Count; i++)
{
FOutputSlices[i].Configurate(Input, FirstFrame);
}
}
public override void LoadConfig(IPluginConfig config)
{
this.Config = MiniParseEventSourceConfig.LoadConfig(config);
this.Config.UpdateIntervalChanged += (o, e) =>
{
this.Start();
};
}
public override void Configurate(IPluginConfig Input, bool FirstFrame)
{
if (Input == FFilenameIn)
{
string fn;
FFilenameIn.GetString(0, out fn);
SetMidiFile(fn);
}
}
public void Configurate(IPluginConfig Input)
{
if (Input.Name == "Selection" && selectedJoints.Count == 0)
{
string[] separator = new string[1];
separator[0] = ",";
configSelectedNames = Input.SpreadAsString.Split(separator, System.StringSplitOptions.None);
}
}
public static void Init()
{
config = Registry.Resolve <IPluginConfig>();
logger = Registry.Resolve <ILogger>();
main = Registry.Resolve <PluginMain>();
NativeMethods.ActiveWindowChanged += ActiveWindowChangedHandler;
NetworkParser.OnOnlineStatusChanged += OnlineStatusChanged;
}
public static BuiltinEventConfig LoadConfig(IPluginConfig Config)
{
var result = new BuiltinEventConfig();
if (Config.EventSourceConfigs.ContainsKey("MiniParse"))
{
var obj = Config.EventSourceConfigs["MiniParse"];
if (obj.TryGetValue("UpdateInterval", out JToken value))
{
result.updateInterval = value.ToObject <int>();
}
if (obj.TryGetValue("EnmityIntervalMs", out value))
{
result.enmityIntervalMs = value.ToObject <int>();
}
if (obj.TryGetValue("SortKey", out value))
{
result.sortKey = value.ToString();
}
if (obj.TryGetValue("SortDesc", out value))
{
result.sortDesc = value.ToObject <bool>();
}
if (obj.TryGetValue("UpdateDpsDuringImport", out value))
{
result.updateDpsDuringImport = value.ToObject <bool>();
}
if (obj.TryGetValue("EndEncounterAfterWipe", out value))
{
result.endEncounterAfterWipe = value.ToObject <bool>();
}
if (obj.TryGetValue("EndEncounterOutOfCombat", out value))
{
result.endEncounterOutOfCombat = value.ToObject <bool>();
}
if (obj.TryGetValue("OverlayData", out value))
{
result.OverlayData = value.ToObject <Dictionary <string, JToken> >();
}
if (obj.TryGetValue("CutsceneDetctionLog", out value))
{
result.cutsceneDetectionLog = value.ToObject <bool>();
}
}
return(result);
}
public void Configurate(IPluginConfig Input)
{
if (Input == FPinCountPin || Input == FPinCountCons)
{
double countPin;
double countCons;
FPinCountPin.GetValue(0, out countPin);
FPinCountCons.GetValue(0, out countCons);
// delete all pins.
for (int i = 0; i < FInputPinList.Count; i++)
{
IValueIn pinToDelete = FInputPinList[i];
FHost.DeletePin(pinToDelete);
}
for (int i = 0; i < FSelectPinList.Count; i++)
{
IValueIn pinToDelete = FSelectPinList[i];
FHost.DeletePin(pinToDelete);
}
for (int i = 0; i < FOutputPinList.Count; i++)
{
IValueOut pinToDelete = FOutputPinList[i];
FHost.DeletePin(pinToDelete);
}
FInputPinList.Clear();
FSelectPinList.Clear();
FOutputPinList.Clear();
// create new pins.
for (int i = 0; i < countCons; i++)
{
for (int j = 0; j < countPin; j++)
{
IValueIn inputPin;
FHost.CreateValueInput("Input " + (i + 1) + "," + (j + 1), 1, null, TSliceMode.Dynamic, TPinVisibility.True, out inputPin);
inputPin.SetSubType(double.MinValue, double.MaxValue, 0.01, 0.0, false, false, false);
FInputPinList.Add(inputPin);
}
IValueIn selectPin;
FHost.CreateValueInput("Select " + (i + 1), 1, null, TSliceMode.Single, TPinVisibility.True, out selectPin);
selectPin.SetSubType(0, double.MaxValue, 1, 1, false, false, true);
FSelectPinList.Add(selectPin);
}
for (int i = 0; i < countPin; i++)
{
IValueOut outputPin;
FHost.CreateValueOutput("Output " + (i + 1), 1, null, TSliceMode.Dynamic, TPinVisibility.True, out outputPin);
outputPin.SetSubType(double.MinValue, double.MaxValue, 0.01, 0, false, false, false);
FOutputPinList.Add(outputPin);
}
}
}
public void Configurate(IPluginConfig Input)
{
//nothing to configure in this plugin
//only used in conjunction with inputs of type cmpdConfigurate
}
public void Configurate(IPluginConfig Input)
{
}
} #endregion constructor/destructor
public void Configurate(IPluginConfig Input)
{
double dblSlots;
FConfigAllocated.GetValue(0, out dblSlots);
nSlots = System.Convert.ToInt32(dblSlots);
}
