public void TestSimpleCondtionWithOneParam()
{
var ace = JsonConvert.DeserializeObject <C2Ace>(@" {
""Params"": [
{
""Script"": ""AddCmpParam"",
""Text"": ""Comaprison"",
""Description"": ""How to compare the count to"",
""DefaultValue"": null,
""ComboItems"": []
}
],
""Id"": ""1"",
""Flags"": ""cf_trigger cf_fake_trigger, cf_static cf_not_invertible cf_deprecated cf_incompatible_with_triggers cf_looping"",
""ListName"": ""Compare count"",
""Category"": ""General"",
""DisplayString"": ""Compare count"",
""Description"": ""Compare a number with the count of the stack"",
""ScriptName"": ""CompareCount""
}");
var c3addon = new C3Addon {
Type = PluginType.SingleGlobalPlugin,
};
c3addon.Conditions = new Dictionary <string, Condition>();
c3addon.Template = TemplateFactory.Insatnce.CreateTemplate(c3addon.Type);
C2AddonConverter.Insatnce.C2AcesToCondition(c3addon, ace);
var cnd = c3addon.Conditions.FirstOrDefault().Value;
Console.WriteLine(cnd.Ace);
Console.WriteLine();
Console.WriteLine(cnd.Language);
Console.WriteLine();
Console.WriteLine(cnd.Code);
}
public void TestSimpleActionWithOneParam()
{
var ace = JsonConvert.DeserializeObject <C2Ace>(@"{
""Params"": [ {
""Script"": ""AddAnyTypeParam"",
""Text"": ""Element"",
""Description"": ""Element to push"",
""DefaultValue"": null,
""ComboItems"": []
}],
""Id"": ""0"",
""Flags"": ""af_none"",
""ListName"": ""Push"",
""Category"": ""General"",
""DisplayString"": ""Push {0}"",
""Description"": ""Push an element to the top of the stack"",
""ScriptName"": ""Push""
}");
var c3addon = new C3Addon {
Type = PluginType.SingleGlobalPlugin,
};
c3addon.Actions = new Dictionary <string, Action>();
c3addon.Template = TemplateFactory.Insatnce.CreateTemplate(c3addon.Type);
C2AddonConverter.Insatnce.C2AcesToAction(c3addon, ace);
var action = c3addon.Actions.FirstOrDefault().Value;
Console.WriteLine(action.Ace);
Console.WriteLine();
Console.WriteLine(action.Language);
Console.WriteLine();
Console.WriteLine(action.Code);
}
private static void WriteThirdPartyFile(C3Addon addon, string path)
{
var sb = new StringBuilder();
if (addon.ThirdPartyFiles.Any())
{
foreach (var file in addon.ThirdPartyFiles)
{
sb.AppendLine($"@@START {file.Key}|{file.Value.Extention}|{file.Value.Rootfolder.ToString().ToLower()}|{file.Value.C3Folder.ToString().ToLower()}|{file.Value.C2Folder.ToString().ToLower()}|{file.Value.FileType}|{file.Value.Compress.ToString()}|{file.Value.PlainText.ToString()}");
sb.AppendLine("@@TEMPLATE");
sb.AppendLine(file.Value.PluginTemplate);
sb.AppendLine("@@CONTENT");
sb.AppendLine(file.Value.Content);
sb.AppendLine("@@BYTES");
if (file.Value.Bytes != null)
{
sb.AppendLine(Convert.ToBase64String(file.Value.Bytes));
}
sb.AppendLine($"@@END {file.Key}");
sb.AppendLine();
}
}
File.WriteAllText(Path.Combine(path, "third_party_files.c3idex"), sb.ToString());
}
public void TestSimpleAction()
{
var ace = JsonConvert.DeserializeObject <C2Ace>(@"{
""Params"": [],
""Id"": ""2"",
""Flags"": ""af_none"",
""ListName"": ""Clear"",
""Category"": ""General"",
""DisplayString"": ""Clear"",
""Description"": ""Clears the stack"",
""ScriptName"": ""Clear""
}");
var c3addon = new C3Addon {
Type = PluginType.SingleGlobalPlugin,
};
c3addon.Actions = new Dictionary <string, Action>();
c3addon.Template = TemplateFactory.Insatnce.CreateTemplate(c3addon.Type);
C2AddonConverter.Insatnce.C2AcesToAction(c3addon, ace);
var action = c3addon.Actions.FirstOrDefault().Value;
Console.WriteLine(action.Ace);
Console.WriteLine();
Console.WriteLine(action.Language);
Console.WriteLine();
Console.WriteLine(action.Code);
}
/// <summary>
/// generates the string for the ace json
/// </summary>
/// <param name="addon"></param>
/// <returns></returns>
private string CompileAce(C3Addon addon)
{
var categoryAce = new List <string>();
var categoryList = addon.Categories;
foreach (var category in categoryList)
{
var actions = addon.Actions.Values.Where(x => x.Category == category);
var conditions = addon.Conditions.Values.Where(x => x.Category == category);
var expressions = addon.Expressions.Values.Where(x => x.Category == category);
var actionString = string.Join(",\n", actions.Select(x => x.Ace));
var conditionString = string.Join(",\n", conditions.Select(x => x.Ace));
var expressionString = string.Join(",\n", expressions.Select(x => x.Ace));
var template = $@"""{category}"": {{
""conditions"":[
{conditionString}
],
""actions"":[
{actionString}
],
""expressions"":[
{expressionString}
]
}}";
categoryAce.Add(template);
}
return($@"{{
{string.Join(",\n", categoryAce)}
}}");
}
private static void PopulateFile(C3Addon addon, string section, string content)
{
switch (section)
{
case "ADDON.JSON": addon.AddonJson = content; break;
case "PLUGIN_EDIT.JS": addon.PluginEditTime = content; break;
case "PLUGIN_RUN.JS": addon.PluginRunTime = content; break;
case "TYPE_EDIT.JS": addon.TypeEditTime = content; break;
case "TYPE_RUN.JS": addon.TypeRunTime = content; break;
case "INSTANCE_EDIT.JS": addon.InstanceEditTime = content; break;
case "INSTANCE_RUN.JS": addon.InstanceRunTime = content; break;
case "LANG_PROP.JSON": addon.LanguageProperties = content; break;
case "LANG_CAT.JSON": addon.LanguageCategories = content; break;
case "C2RUNTIME.JS": addon.C2RunTime = content; break;
}
}
private void CreateThemeFiles(C3Addon addon, string folderName)
{
//generate file strings
_addonFiles = new Dictionary <string, string>();
//generate simple files
LogManager.CompilerLog.Insert($"generating addon.json");
_addonFiles.Add(Path.Combine(OptionsManager.CurrentOptions.CompilePath, folderName, "addon.json"), addon.AddonJson);
LogManager.CompilerLog.Insert($"generating addon.json => complete");
LogManager.CompilerLog.Insert($"generating css ");
_addonFiles.Add(Path.Combine(OptionsManager.CurrentOptions.CompilePath, folderName, "theme.css"), addon.ThemeCss);
LogManager.CompilerLog.Insert($"generating css => complete");
LogManager.CompilerLog.Insert($"generating en-US.json");
_addonFiles.Add(Path.Combine(OptionsManager.CurrentOptions.CompilePath, folderName, "lang", "en-US.json"), addon.ThemeLangauge);
LogManager.CompilerLog.Insert($"generating en-US.json => complete");
//write files to path
foreach (var file in _addonFiles)
{
System.IO.File.WriteAllText(file.Key, file.Value);
LogManager.CompilerLog.Insert($"writing file => {file.Key}");
}
LogManager.CompilerLog.Insert($"compilation complete...");
}
/// <summary>
/// removes the passed in addon, based on guid id
/// </summary>
/// <param name="addon"></param>
public static void DeleteAddon(C3Addon addon)
{
CurrentAddon = null;
DataAccessFacade.Insatnce.AddonData.Delete(addon);
LoadAllAddons();
WindowManager.ChangeWindow(ApplicationWindows.DashboardWindow);
}
private static void ReadEffectParam(C3Addon addon, string path)
{
addon.Effect.Parameters = new Dictionary <string, EffectParameter>();
try
{
var text = File.ReadAllLines(Path.Combine(path, "effect_parameters.c3idex"));
var state = ParserState.Idle;
var id = string.Empty;
var declaration = string.Empty;
var section = string.Empty;
var temp = new Dictionary <string, StringBuilder>();
foreach (var line in text)
{
//check for end
if (line.Contains("@@END"))
{
state = ParserState.End;
PopulateEffectParam(addon, id, declaration, temp["JSON"].ToString(), temp["LANG"].ToString());
}
//check for parsing
if (state == ParserState.Start)
{
if (line.Contains("@@JSON"))
{
section = "JSON";
}
else if (line.Contains("@@LANG"))
{
section = "LANG";
}
else
{
temp[section].AppendLine(line);
}
}
//check for start
if (line.Contains("@@START"))
{
id = line.Replace("@@START", string.Empty).Trim().Split('|')[0];
declaration = line.Replace("@@START", string.Empty).Trim().Split('|')[1];
state = ParserState.Start;
temp = new Dictionary <string, StringBuilder>
{
{ "JSON", new StringBuilder() },
{ "LANG", new StringBuilder() }
};
}
}
}
catch (Exception ex)
{
LogManager.AddErrorLog(ex);
throw;
}
}
//todo: add effect validation here
//todo: move this into the validate addons helper
/// <summary>
/// run some simple validations for addon
/// </summary>
/// <param name="addon"></param>
/// <returns></returns>
private bool ValidateFiles(C3Addon addon)
{
if (addon.Type == PluginType.Effect)
{
if (!AddonValidator.Insatnce.Validate(addon))
{
return(false);
}
}
else if (addon.Type == PluginType.Theme)
{
//todo: validate css
}
else
{
if (string.IsNullOrWhiteSpace(addon.LanguageProperties))
{
LogManager.CompilerLog.Insert("generate properties json has not been ran, generate the json in the langauge view");
return(false);
}
if (string.IsNullOrWhiteSpace(addon.LanguageCategories))
{
LogManager.CompilerLog.Insert("generate category json has not been ran, generate the json in the langauge view");
return(false);
}
var placeholder = new Regex("{(\\d+)}|{\\.\\.\\.}");
var dpPlaceholder = new Regex("\"display-text\":.*");
foreach (var action in addon.Actions)
{
var paramCount = action.Value.Ace.Count(x => x == '{') - 1;
var displayText = dpPlaceholder.Matches(action.Value.Language)[0].Value;
var displayCount = placeholder.Matches(string.IsNullOrWhiteSpace(displayText) ? action.Value.Language : displayText).Count;
if (paramCount != displayCount)
{
LogManager.CompilerLog.Insert($"invalid amount of parameter placeholder in display text for {action.Value.Id}, {paramCount} parameters expected {displayCount} placeholders {{#}} in display text");
return(false);
}
}
foreach (var condition in addon.Conditions)
{
var paramCount = condition.Value.Ace.Count(x => x == '{') - 1;
var displayCount = placeholder.Matches(condition.Value.Language).Count;
if (paramCount != displayCount)
{
LogManager.CompilerLog.Insert($"invalid amount parameter placeholder in display text for {condition.Value.Id}, {paramCount} parameters expected {displayCount} placeholders {{#}} in display text");
return(false);
}
}
}
return(true);
}
/// <summary>
/// changes the id of the passe din addon, and upsert it back to duplicate it
/// </summary>
/// <param name="addon"></param>
public static void DuplicateAddon(C3Addon addon, string name = null)
{
var clone = (C3Addon)addon.Clone();
addon.CreateDate = DateTime.Now;
DataAccessFacade.Insatnce.AddonData.Upsert(clone);
LoadAllAddons();
}
private static void WriteThemeCss(C3Addon addon, string path)
{
var css = string.Empty;
if (addon.ThemeCss != null)
{
css = addon.ThemeCss;
}
File.WriteAllText(Path.Combine(path, $"theme_css.c3idex"), css);
}
private static void PopulateEffectParam(C3Addon addon, string id, string declaration, string json, string lang)
{
addon.Effect.Parameters.Add(id, new EffectParameter()
{
Key = id,
VariableDeclaration = declaration,
Json = json,
Lang = lang
});
}
private static void WriteEffectCode(C3Addon addon, string path)
{
var code = string.Empty;
if (addon.Effect != null)
{
code = addon.Effect.Code;
}
File.WriteAllText(Path.Combine(path, $"effect_code.c3idex"), code);
}
private static void WriteThemeLanguage(C3Addon addon, string path)
{
var lang = string.Empty;
if (addon.ThemeLangauge != null)
{
lang = addon.ThemeLangauge;
}
File.WriteAllText(Path.Combine(path, $"theme_lang.c3idex"), lang);
}
public void C2AcesToCondition(C3Addon addon, C2Ace ace)
{
try
{
var condition = new Condition
{
Category = ace.Category.ToLower(),
Id = ace.ScriptName.SplitCamelCase("-"),
DisplayText = ace.DisplayString,
ListName = ace.ListName,
Description = ace.Description,
Highlight = "false",
C2Id = ace.Id,
Deprecated = ace.Flags.Contains("cf_deprecated").ToString().ToLower(),
Trigger = ace.Flags.Contains("cf_trigger").ToString().ToLower(),
FakeTrigger = ace.Flags.Contains("cf_fake_trigger").ToString().ToLower(),
Static = ace.Flags.Contains("cf_static").ToString().ToLower(),
Looping = ace.Flags.Contains("cf_looping").ToString().ToLower(),
Invertible = (!ace.Flags.Contains("cf_not_invertible")).ToString().ToLower(),
TriggerCompatible = (!ace.Flags.Contains("cf_incompatible_with_triggers")).ToString().ToLower(),
};
if (ace.Params.Any())
{
condition.Ace = C2TemplateHelper.ConditionAceImport(condition);
condition.Language = TemplateCompiler.Insatnce.CompileTemplates(addon.Template.ActionLanguage, condition);
condition.Code = TemplateCompiler.Insatnce.CompileTemplates(addon.Template.ActionCode, condition);
var paramId = 0;
//action params
foreach (var param in ace.Params)
{
var paramType = ResolveParamType(param);
condition = paramType == "combo"
? AceParameterHelper.Insatnce.GenerateParam(condition, $"param{paramId}", paramType, param.DefaultValue, $"param{paramId}", param.Description, param.ComboItems)
: AceParameterHelper.Insatnce.GenerateParam(condition, $"param{paramId}", paramType, param.DefaultValue, $"param{paramId}", param.Description);
paramId++;
}
}
else
{
condition.Ace = C2TemplateHelper.ConditionAceImport(condition);
condition.Language = TemplateCompiler.Insatnce.CompileTemplates(addon.Template.ActionLanguage, condition);
condition.Code = TemplateCompiler.Insatnce.CompileTemplates(addon.Template.ActionCode, condition);
}
addon.Conditions.Add(condition.Id, condition);
}
catch (Exception ex)
{
LogManager.AddImportLogMessage($"ERROR => \n{ex.Message}");
LogManager.AddImportLogMessage($"STACK TRACE => \n{ex.StackTrace}");
return;
}
}
public void ReconstructAdoon(C3Addon addon)
{
if (addon.Type != PluginType.Effect && addon.Type != PluginType.Theme)
{
addon.AddonJson = string.Join("\n", FileIndex["addon.json"].Select(x => x.Value.Line));
addon.PluginEditTime = string.Join("\n", FileIndex["edittime_plugin.js"].Select(x => x.Value.Line));
addon.PluginRunTime = string.Join("\n", FileIndex["runtime_plugin.js"].Select(x => x.Value.Line));
addon.InstanceEditTime = string.Join("\n", FileIndex["edittime_instance.js"].Select(x => x.Value.Line));
addon.InstanceRunTime = string.Join("\n", FileIndex["runtime_instance.js"].Select(x => x.Value.Line));
addon.TypeEditTime = string.Join("\n", FileIndex["edittime_type.js"].Select(x => x.Value.Line));
addon.TypeRunTime = string.Join("\n", FileIndex["runtime_type.js"].Select(x => x.Value.Line));
if (FileIndex.ContainsKey("c2runtime.js"))
{
addon.C2RunTime = string.Join("\n", FileIndex["c2runtime.js"].Select(x => x.Value.Line));
}
foreach (var act in addon.Actions)
{
addon.Actions[act.Key].Ace = string.Join("\n", FileIndex[$"act_{act.Key}_ace"].Select(x => x.Value.Line));
addon.Actions[act.Key].Language = string.Join("\n", FileIndex[$"act_{act.Key}_lang"].Select(x => x.Value.Line));
addon.Actions[act.Key].Code = string.Join("\n", FileIndex[$"act_{act.Key}_code"].Select(x => x.Value.Line));
}
foreach (var cnd in addon.Conditions)
{
addon.Conditions[cnd.Key].Ace = string.Join("\n", FileIndex[$"cnd_{cnd.Key}_ace"].Select(x => x.Value.Line));
addon.Conditions[cnd.Key].Language = string.Join("\n", FileIndex[$"cnd_{cnd.Key}_lang"].Select(x => x.Value.Line));
addon.Conditions[cnd.Key].Code = string.Join("\n", FileIndex[$"cnd_{cnd.Key}_code"].Select(x => x.Value.Line));
}
foreach (var exp in addon.Expressions)
{
addon.Expressions[exp.Key].Ace = string.Join("\n", FileIndex[$"exp_{exp.Key}_ace"].Select(x => x.Value.Line));
addon.Expressions[exp.Key].Language = string.Join("\n", FileIndex[$"exp_{exp.Key}_lang"].Select(x => x.Value.Line));
addon.Expressions[exp.Key].Code = string.Join("\n", FileIndex[$"exp_{exp.Key}_code"].Select(x => x.Value.Line));
}
addon.LanguageProperties = string.Join("\n", FileIndex["lang_property.js"].Select(x => x.Value.Line));
addon.LanguageCategories = string.Join("\n", FileIndex["lang_category.js"].Select(x => x.Value.Line));
}
else if (addon.Type != PluginType.Theme)
{
addon.Effect.Code = string.Join("\n", FileIndex["fxcode.js"].Select(x => x.Value.Line));
foreach (var param in addon.Effect.Parameters)
{
addon.Effect.Parameters[param.Key].Json = string.Join("\n", FileIndex[$"fxparam_{param.Key}_json"].Select(x => x.Value.Line));
addon.Effect.Parameters[param.Key].Lang = string.Join("\n", FileIndex[$"fxparam_{param.Key}_lang"].Select(x => x.Value.Line));
}
}
AddonManager.CurrentAddon = addon;
DataAccessFacade.Insatnce.AddonData.Upsert(addon);
}
public async void GlobalFindAndReplaceAll(C3Addon addon, string text, string replaceText = "")
{
var results = await Task.Run(() =>
{
return(FileIndex.Values.SelectMany(x => x.Values.Where(rec => rec.Line.Contains(text))));
});
var searchResults = results as SearchResult[] ?? results.ToArray();
GlobalReplace(addon, searchResults);
}
/// <summary>
/// generate the c3addon zip file
/// </summary>
/// <param name="addon"></param>
/// <param name="addonAddonFolder"></param>
private void CreateC3AddonFile(C3Addon addon, string addonAddonFolder)
{
var outputPath = OptionsManager.CurrentOptions.C3AddonPath;
var c3addonFile = System.IO.Path.Combine(outputPath, $"{addon.Class.ToLower()}_{addon.MajorVersion}_{addon.MinorVersion}_{addon.RevisionVersion}_{addon.BuildVersion}.c3addon");
if (System.IO.File.Exists(c3addonFile))
{
File.Delete(c3addonFile);
}
ZipFile.CreateFromDirectory(addonAddonFolder, c3addonFile);
}
private static void PopulateCondition(C3Addon addon, string id, string category, string ace, string lang, string code)
{
addon.Conditions.Add(id, new Models.Condition()
{
Id = id,
Ace = ace,
Language = lang,
Code = code,
Category = category
});
}
private static void WriteAddonFiles(C3Addon addon, string path)
{
var sb = new StringBuilder();
sb.AppendLine("@@START ADDON.JSON");
sb.AppendLine(addon.AddonJson);
sb.AppendLine("@@END ADDON.JSON");
sb.AppendLine();
sb.AppendLine("@@START PLUGIN_EDIT.JS");
sb.AppendLine(addon.PluginEditTime);
sb.AppendLine("@@END PLUGIN_EDIT.JS");
sb.AppendLine();
sb.AppendLine("@@START PLUGIN_RUN.JS");
sb.AppendLine(addon.PluginRunTime);
sb.AppendLine("@@END PLUGIN_RUN.JS");
sb.AppendLine();
sb.AppendLine("@@START TYPE_EDIT.JS");
sb.AppendLine(addon.TypeEditTime);
sb.AppendLine("@@END TYPE_EDIT.JS");
sb.AppendLine();
sb.AppendLine("@@START TYPE_RUN.JS");
sb.AppendLine(addon.TypeRunTime);
sb.AppendLine("@@END TYPE_RUN.JS");
sb.AppendLine();
sb.AppendLine("@@START INSTANCE_EDIT.JS");
sb.AppendLine(addon.InstanceEditTime);
sb.AppendLine("@@END INSTANCE_EDIT.JS");
sb.AppendLine();
sb.AppendLine("@@START INSTANCE_RUN.JS");
sb.AppendLine(addon.InstanceRunTime);
sb.AppendLine("@@END INSTANCE_RUN.JS");
sb.AppendLine();
sb.AppendLine("@@START LANG_PROP.JSON");
sb.AppendLine(addon.LanguageProperties);
sb.AppendLine("@@END LANG_PROP.JSON");
sb.AppendLine();
sb.AppendLine("@@START LANG_CAT.JSON");
sb.AppendLine(addon.LanguageCategories);
sb.AppendLine("@@END LANG_CAT.JSON");
sb.AppendLine();
File.WriteAllText(Path.Combine(path, "addon.c3idex"), sb.ToString());
}
/// <summary>
/// generates the string for expressions
/// </summary>
/// <param name="addon"></param>
/// <returns></returns>
private string CompileExpressions(C3Addon addon)
{
var expressions = addon.Expressions.Select(x => x.Value.Code);
var expressionString = string.Join(",\n\n", expressions);
var pluginType = addon.Type == PluginType.Behavior ? "Behaviors" : "Plugins";
return($@"""use strict"";
{{
self.C3.{pluginType}.{addon.AddonId}.Exps = {{
{expressionString}
}};
}}");
}
public void ParseAddon(C3Addon addon)
{
FileIndex = new Dictionary <string, SortedList <int, SearchResult> >();
if (addon.Type != PluginType.Effect && addon.Type != PluginType.Theme)
{
UpdateFileIndex("addon.json", addon.AddonJson, ApplicationWindows.AddonWindow);
UpdateFileIndex("edittime_plugin.js", addon.PluginEditTime, ApplicationWindows.PluginWindow);
UpdateFileIndex("runtime_plugin.js", addon.PluginRunTime, ApplicationWindows.PluginWindow);
UpdateFileIndex("edittime_instance.js", addon.InstanceEditTime, ApplicationWindows.InstanceWindow);
UpdateFileIndex("runtime_instance.js", addon.InstanceRunTime, ApplicationWindows.InstanceWindow);
UpdateFileIndex("edittime_type.js", addon.TypeEditTime, ApplicationWindows.TypeWindow);
UpdateFileIndex("runtime_type.js", addon.TypeRunTime, ApplicationWindows.TypeWindow);
UpdateFileIndex("c2runtime.js", addon.C2RunTime, ApplicationWindows.C2Runtime);
foreach (var action in addon.Actions)
{
UpdateFileIndex($"act_{action.Key}_ace", action.Value.Ace, ApplicationWindows.ActionWindow);
UpdateFileIndex($"act_{action.Key}_lang", action.Value.Language, ApplicationWindows.ActionWindow);
UpdateFileIndex($"act_{action.Key}_code", action.Value.Code, ApplicationWindows.ActionWindow);
}
foreach (var conditions in addon.Conditions)
{
UpdateFileIndex($"cnd_{conditions.Key}_ace", conditions.Value.Ace, ApplicationWindows.ConditionWindow);
UpdateFileIndex($"cnd_{conditions.Key}_lang", conditions.Value.Language, ApplicationWindows.ConditionWindow);
UpdateFileIndex($"cnd_{conditions.Key}_code", conditions.Value.Code, ApplicationWindows.ConditionWindow);
}
foreach (var expression in addon.Expressions)
{
UpdateFileIndex($"exp_{expression.Key}_ace", expression.Value.Ace, ApplicationWindows.ExpressionWindow);
UpdateFileIndex($"exp_{expression.Key}_lang", expression.Value.Language, ApplicationWindows.ExpressionWindow);
UpdateFileIndex($"exp_{expression.Key}_code", expression.Value.Code, ApplicationWindows.ExpressionWindow);
}
UpdateFileIndex("lang_property.js", addon.LanguageProperties, ApplicationWindows.LanguageWindow);
UpdateFileIndex("lang_category.js", addon.LanguageCategories, ApplicationWindows.LanguageWindow);
}
else if (addon.Type != PluginType.Theme)
{
UpdateFileIndex("fxcode.js", addon.Effect.Code, ApplicationWindows.EffectCodeWindow);
foreach (var param in addon.Effect.Parameters)
{
UpdateFileIndex($"fxparam_{param.Key}_json", addon.Effect.Parameters[param.Key].Json, ApplicationWindows.EffectParameterWindow);
UpdateFileIndex($"fxparam_{param.Key}_lang", addon.Effect.Parameters[param.Key].Lang, ApplicationWindows.EffectParameterWindow);
}
}
}
public void C2AcesToAction(C3Addon addon, C2Ace ace)
{
try
{
var action = new Action
{
Category = ace.Category.ToLower(),
Id = ace.ScriptName.SplitCamelCase("-"),
DisplayText = ace.DisplayString,
ListName = ace.ListName,
Description = ace.Description,
Highlight = "false",
C2Id = ace.Id,
Deprecated = ace.Flags.Contains("af_deprecated").ToString().ToLower()
};
if (ace.Params.Any())
{
action.Ace = TemplateCompiler.Insatnce.CompileTemplates(C2TemplateHelper.ActionAceImport, action);
action.Language = TemplateCompiler.Insatnce.CompileTemplates(addon.Template.ActionLanguage, action);
action.Code = TemplateCompiler.Insatnce.CompileTemplates(addon.Template.ActionCode, action);
var paramId = 0;
//action params
foreach (var param in ace.Params)
{
var paramType = ResolveParamType(param);
action = paramType == "combo"
? AceParameterHelper.Insatnce.GenerateParam(action, $"param{paramId}", paramType, param.DefaultValue, $"param{paramId}", param.Description, param.ComboItems)
: AceParameterHelper.Insatnce.GenerateParam(action, $"param{paramId}", paramType, param.DefaultValue, $"param{paramId}", param.Description);
paramId++;
}
}
else
{
action.Ace = TemplateCompiler.Insatnce.CompileTemplates(C2TemplateHelper.ActionAceImport, action);
action.Language = TemplateCompiler.Insatnce.CompileTemplates(addon.Template.ActionLanguage, action);
action.Code = TemplateCompiler.Insatnce.CompileTemplates(addon.Template.ActionCode, action);
}
addon.Actions.Add(action.Id, action);
}
catch (Exception ex)
{
LogManager.AddImportLogMessage($"ERROR => \n{ex.Message}");
LogManager.AddImportLogMessage($"STACK TRACE => \n{ex.StackTrace}");
return;
}
}
/// <summary>
/// compiles the addon and creates a c3addon export file
/// </summary>
/// <param name="addon"></param>
public async void ExportAddon(C3Addon addon)
{
//compile addon
await AddonCompiler.Insatnce.CompileAddon(addon, false);
if (AddonCompiler.Insatnce.IsCompilationValid)
{
//export c3addon file
CreateC3AddonFile(addon, addon.AddonFolder);
}
else
{
NotificationManager.PublishErrorNotification("compilation failed, no .c3addon file created, please test your addon to get error information");
}
}
public void GlobalReplace(C3Addon addon, IEnumerable <SearchResult> replaceResults)
{
var affectedFiles = new HashSet <string>(replaceResults.Select(x => x.Document));
foreach (var affectedFile in affectedFiles)
{
var fileReplacments = replaceResults.Where(x => x.Document.Equals(affectedFile));
foreach (var fileReplacment in fileReplacments)
{
FileIndex[affectedFile].AddOrUpdate(fileReplacment.LineNumber, fileReplacment);
}
}
ReconstructAdoon(addon);
}
private static void WriteEffectProperties(C3Addon addon, string path)
{
var sb = new StringBuilder();
if (addon.Effect != null)
{
sb.AppendLine($"BlendsBackground|{addon.Effect.BlendsBackground}");
sb.AppendLine($"CrossSampling|{addon.Effect.CrossSampling}");
sb.AppendLine($"PreservesOpaqueness|{addon.Effect.PreservesOpaqueness}");
sb.AppendLine($"Animated|{addon.Effect.Animated}");
sb.AppendLine($"MustPredraw|{addon.Effect.MustPredraw}");
sb.AppendLine($"ExtendBoxHorizontal|{addon.Effect.ExtendBoxHorizontal}");
sb.AppendLine($"ExtendBoxVertical|{addon.Effect.ExtendBoxVertical}");
}
File.WriteAllText(Path.Combine(path, $"effect_properties.c3idex"), sb.ToString());
}
/// <summary>
/// sets the cuurent addon
/// </summary>
/// <param name="addon"></param>
public static void LoadAddon(C3Addon addon)
{
//check for empty id
if (string.IsNullOrWhiteSpace(addon.AddonId))
{
addon.AddonId = $"{addon.Author}_{addon.Class}";
}
//load addon
CurrentAddon = addon;
NotificationManager.PublishNotification($"{addon.Name} loaded successfully");
foreach (var callback in _addonLoadedCallback)
{
callback?.Invoke(addon);
}
}
private static void WriteC2AddonFiles(C3Addon addon, string path)
{
//break if no c2 data is defined
if (string.IsNullOrWhiteSpace(addon.C2RunTime))
{
return;
}
var sb = new StringBuilder();
sb.AppendLine("@@START C2RUNTIME.JS");
sb.AppendLine(addon.C2RunTime);
sb.AppendLine("@@END C2RUNTIME.JS");
sb.AppendLine();
File.WriteAllText(Path.Combine(path, "c2runtime.c3idex"), sb.ToString());
}
private static void ReadThemeCss(C3Addon addon, string path)
{
try
{
var text = File.ReadAllText(Path.Combine(path, "theme_css.c3idex"));
if (!text.Any())
{
return;
}
addon.ThemeCss = text;
}
catch (Exception ex)
{
LogManager.AddErrorLog(ex);
throw;
}
}
