public PluginAbout(PluginObject plugin)
{
InitializeComponent();
this.name.Text += plugin.Name;
this.description.Text += plugin.Description;
this.creator.Text += plugin.Creator;
}
private static DependencyGraphObject V1(Dictionary <string, object> deserialized)
{
// This is a naive implementation. Once a V2 is necessary, we can revisit this.
return(new DependencyGraphObject(
deserialized ["version"] as string,
PluginObject.From(deserialized ["plugin"] as Dictionary <string, object>),
DependenciesObject.From(deserialized ["dependencies"] as Dictionary <string, object>)
));
}
private static void CleanPluginUpgrade()
{
Update.PeriodicUpdateManager.Continue();
PluginObject pluginObject = Update.PeriodicUpdateManager.PluginDescriptor();
if (pluginObject != null)
{
Detail.Runner.StartCoroutine(new Custodian(pluginObject.Manifest).Clean());
}
}
public static void loadPlugins(ExceptionListener exceptionListener = null)
{
string[] importantPlugins = new ConfigManager().getConfig().plugins.important;
string[] normalPlugins = new ConfigManager().getConfig().plugins.normal;
List <PluginObject> pluginsList = new List <PluginObject>();
foreach (string i in importantPlugins)
{
string pluginsBaseDir = AppDomain.CurrentDomain.BaseDirectory + "plugins\\";
try
{
PluginObject pluginObject = new PluginObject(pluginsBaseDir + i + ".dll", true, i);
pluginsList.Add(pluginObject);
Log.i("Plugin \"" + i + "\" (important) load success");
}
catch (Exception e)
{
Log.i("Plugin \"" + i + "\" (important) load unsuccess");
Log.i("Please put plugin in " + pluginsBaseDir);
GetExceptionListener().OnException(e);
}
}
foreach (string i in normalPlugins)
{
string pluginsBaseDir = AppDomain.CurrentDomain.BaseDirectory + "plugins\\";
try
{
PluginObject pluginObject = new PluginObject(pluginsBaseDir + i + ".dll", false, i);
pluginsList.Add(pluginObject);
Log.i("Plugin \"" + i + "\" (normal) load success");
}
catch (Exception e)
{
Log.i("Plugin \"" + i + "\" (normal) load unsuccess");
Log.i("Please put plugin in " + pluginsBaseDir);
GetExceptionListener().OnException(e);
}
}
TempData.pluginsList = pluginsList;
}
public void SaveElement(EngineNS.IO.XmlNode node, EngineNS.IO.XmlHolder holder)
{
if (PluginObject != null)
{
var uiElement = PluginObject as System.Windows.FrameworkElement;
if (uiElement == null)
{
return;
}
node.AddAttrib("Type", uiElement.GetType().Assembly.FullName + "|" + uiElement.GetType().FullName);
node.AddAttrib("GridRow", Grid.GetRow(uiElement).ToString());
node.AddAttrib("GridColumn", Grid.GetColumn(uiElement).ToString());
node.AddAttrib("HorizontalAlignment", uiElement.HorizontalAlignment.ToString());
node.AddAttrib("VerticalAlignment", uiElement.VerticalAlignment.ToString());
var atts = PluginObject.GetType().GetCustomAttributes(typeof(System.Runtime.InteropServices.GuidAttribute), false);
if (atts.Length > 0)
{
var guidAtt = (System.Runtime.InteropServices.GuidAttribute)atts[0];
node.AddAttrib("Id", guidAtt.Value);
}
}
}
private DependencyGraphObject(string version, PluginObject pluginObject, DependenciesObject dependenciesObject)
{
Version = version;
Plugin = pluginObject;
Dependencies = dependenciesObject;
}
/// <summary>
/// Read a receipt from disk.
/// </summary>
/// <param name="Location">Filename to read from</param>
/// <param name="EngineDir">Engine directory for expanded variables</param>
public static TargetReceipt Read(FileReference Location, DirectoryReference EngineDir)
{
JsonObject RawObject = JsonObject.Read(Location);
// Read the initial fields
string TargetName = RawObject.GetStringField("TargetName");
TargetType TargetType = RawObject.GetEnumField <TargetType>("TargetType");
UnrealTargetPlatform Platform = UnrealTargetPlatform.Parse(RawObject.GetStringField("Platform"));
UnrealTargetConfiguration Configuration = RawObject.GetEnumField <UnrealTargetConfiguration>("Configuration");
// Try to read the build version
BuildVersion Version;
if (!BuildVersion.TryParse(RawObject.GetObjectField("Version"), out Version))
{
throw new JsonParseException("Invalid 'Version' field");
}
// Read the project path
FileReference ProjectFile;
string RelativeProjectFile;
if (RawObject.TryGetStringField("Project", out RelativeProjectFile))
{
ProjectFile = FileReference.Combine(Location.Directory, RelativeProjectFile);
}
else
{
ProjectFile = null;
}
// Read the launch executable
string Architecture;
if (!RawObject.TryGetStringField("Architecture", out Architecture))
{
Architecture = "";
}
// Create the receipt
TargetReceipt Receipt = new TargetReceipt(ProjectFile, TargetName, TargetType, Platform, Configuration, Version, Architecture);
// Get the project directory
DirectoryReference ProjectDir = Receipt.ProjectDir;
// Read the launch executable
string Launch;
if (RawObject.TryGetStringField("Launch", out Launch))
{
Receipt.Launch = ExpandPathVariables(Launch, EngineDir, ProjectDir);
}
// Read the build products
JsonObject[] BuildProductObjects;
if (RawObject.TryGetObjectArrayField("BuildProducts", out BuildProductObjects))
{
foreach (JsonObject BuildProductObject in BuildProductObjects)
{
string Path;
BuildProductType Type;
if (BuildProductObject.TryGetStringField("Path", out Path) && BuildProductObject.TryGetEnumField("Type", out Type))
{
FileReference File = ExpandPathVariables(Path, EngineDir, ProjectDir);
string Module;
BuildProductObject.TryGetStringField("Module", out Module);
Receipt.AddBuildProduct(File, Type);
}
}
}
// Read the runtime dependencies
JsonObject[] RuntimeDependencyObjects;
if (RawObject.TryGetObjectArrayField("RuntimeDependencies", out RuntimeDependencyObjects))
{
foreach (JsonObject RuntimeDependencyObject in RuntimeDependencyObjects)
{
string Path;
if (RuntimeDependencyObject.TryGetStringField("Path", out Path))
{
FileReference File = ExpandPathVariables(Path, EngineDir, ProjectDir);
StagedFileType Type;
if (!RuntimeDependencyObject.TryGetEnumField("Type", out Type))
{
// Previous format included an optional IgnoreIfMissing flag, which was only used for debug files. We can explicitly reference them as DebugNonUFS files now.
bool bIgnoreIfMissing;
if (RuntimeDependencyObject.TryGetBoolField("IgnoreIfMissing", out bIgnoreIfMissing))
{
bIgnoreIfMissing = false;
}
Type = bIgnoreIfMissing? StagedFileType.DebugNonUFS : StagedFileType.NonUFS;
}
Receipt.RuntimeDependencies.Add(File, Type);
}
}
}
// Read the enabled/disabled plugins
JsonObject[] PluginObjects;
if (RawObject.TryGetObjectArrayField("Plugins", out PluginObjects))
{
foreach (JsonObject PluginObject in PluginObjects)
{
string PluginName;
if (PluginObject.TryGetStringField("Name", out PluginName))
{
bool PluginEnabled;
if (PluginObject.TryGetBoolField("Enabled", out PluginEnabled))
{
Receipt.PluginNameToEnabledState.Add(PluginName, PluginEnabled);
}
}
}
}
// Read the additional properties
JsonObject[] AdditionalPropertyObjects;
if (RawObject.TryGetObjectArrayField("AdditionalProperties", out AdditionalPropertyObjects))
{
foreach (JsonObject AdditionalPropertyObject in AdditionalPropertyObjects)
{
string Name;
if (AdditionalPropertyObject.TryGetStringField("Name", out Name))
{
string Value;
if (AdditionalPropertyObject.TryGetStringField("Value", out Value))
{
Receipt.AdditionalProperties.Add(new ReceiptProperty(Name, Value));
}
}
}
}
return(Receipt);
}
private DependencyGraphObject(string version, PluginObject pluginObject, DependenciesObject dependenciesObject)
{
Version = version;
Plugin = pluginObject;
Dependencies = dependenciesObject;
}
public void Closed()
{
PluginObject?.Closed();
OnClosed?.Invoke();
}
public bool?CanClose()
{
return(PluginObject?.CanClose());
}
