private void GetTemplates(DirectoryEntry CAEntry)
{
CAEntry.RefreshCache(new string[] { PropertyIndex.CertificateTemplates });
object[] TemplateNames;
try
{
TemplateNames = (object[])CAEntry.Properties[PropertyIndex.CertificateTemplates].Value;
}
catch
{
//If there's only a single template, it won't cast as an array automatically.
TemplateNames = new object[] { CAEntry.Properties[PropertyIndex.CertificateTemplates].Value };
}
if (TemplateNames != null)
{
for (int x = 0; x < TemplateNames.Length; x++)
{
try
{
Templates.Add(new ADCertificateTemplate(TemplateNames[x].ToString()));
}
catch (CertificateTemplateNotFoundException)
{
//Won't include any templates that don't resolve to a valid certificate template directory entry
}
}
}
}
public void Add(Template template)
{
if (!Deleted)
{
Templates.Add(template);
}
}
public Parameters(bool init = false)
{
if (init)
{
Templates.Add(new Template(null, true));
}
}
public void AddNewTemplateEditor(RazorTemplateViewModel template, bool current = true)
{
Log.Debug("Adding new template editor (current: {0})...", current);
template.AutoExecute = AutoExecute;
template.AutoSave = AutoExecute;
template.Messages = Messages;
template.Executing += OnAutoSave;
Templates.Add(template);
if (!string.IsNullOrWhiteSpace(template.Filename))
{
RecentFiles.Add(template.Filename);
}
if (current)
{
Log.Debug("Setting as current template");
CurrentTemplate = template;
}
template.Execute();
Log.Info("Added new template editor");
}
protected override bool InitializeTemplates()
{
//Initialize templates used in code composition
Templates.Parse(GMacCodeTemplates);
Templates.Parse(BladeTemplates);
Templates.Parse(VectorTemplates);
Templates.Parse(OutermorphismTemplates);
Templates.Parse(StaticTemplates);
Templates.Parse(EqualsTemplates);
Templates.Parse(IsZeroTemplates);
Templates.Parse(InvolutionTemplates);
Templates.Parse(NormTemplates);
Templates.Parse(MiscTemplates);
Templates.Parse(BilinearProductTemplates);
Templates.Parse(FactorizationTemplates);
//Template for encoding grade1 multivectors as variables by basis blade index
Templates.Add("vmv", new ParametricComposer("#", "#", "#Var##index#"));
return(true);
}
public void SaveTemplate(string name)
{
LocalizerTemplateSettings t = new LocalizerTemplateSettings();
t.name = name;
t.BaseCfgFile = BaseCfgFile;
t.LanguageCodes = LanguageCodes;
t.AddLanguageCodePrefixToMultiFiles = AddLanguageCodePrefixToMultiFiles;
t.UseMultiCfgFiles = UseMultiCfgFiles;
t.UseMultiAndBaseCfgFiles = UseMultiAndBaseCfgFiles;
t.MultiCfgFile = MultiCfgFile;
//Add the new template to the array
for (int i = Templates.Count; i-- > 0;)
{
if (Templates[i].name == t.name)
{
Templates.RemoveAt(i);
}
}
Templates.Add(t);
Templates = Templates.OrderBy(x => x.name).ToList();
}
public void Update()
{
Templates.Clear();
#warning This is not so nice. Could be more generic!
if (TemplatesProvider.Default.Templates != null)
{
if (typeof(T2) == typeof(FaseCyclusModel))
{
foreach (var t in TemplatesProvider.Default.Templates.FasenTemplates)
{
Templates.Add(t as T1);
}
}
if (typeof(T2) == typeof(DetectorModel))
{
foreach (var t in TemplatesProvider.Default.Templates.DetectorenTemplates)
{
Templates.Add(t as T1);
}
}
if (typeof(T2) == typeof(PeriodeModel))
{
foreach (var t in TemplatesProvider.Default.Templates.PeriodenTemplates)
{
Templates.Add(t as T1);
}
}
}
if (Templates.Count > 0)
{
SelectedTemplate = Templates[0];
}
}
/// <inheritdoc/>
public override object VisitTemplateDefinition([NotNull] LGFileParser.TemplateDefinitionContext context)
{
var startLine = context.Start.Line;
var stopLine = context.Stop.Line;
var templateNameLine = context.templateNameLine().TEMPLATE_NAME_LINE().GetText();
var(templateName, parameters) = ExtractTemplateNameLine(templateNameLine);
if (_templates.Any(u => u.Name == templateName))
{
var diagnostic = BuildTemplatesDiagnostic(TemplateErrors.DuplicatedTemplateInSameTemplate(templateName), context.templateNameLine());
_templates.Diagnostics.Add(diagnostic);
}
else
{
var templateBody = context.templateBody().GetText();
var sourceRange = new SourceRange(context, _templates.Id);
var template = new Template(templateName, parameters, templateBody, sourceRange);
CheckTemplateName(templateName, context.templateNameLine());
CheckTemplateParameters(parameters, context.templateNameLine());
template.TemplateBodyParseTree = CheckTemplateBody(templateName, templateBody, context.templateBody(), startLine);
_templates.Add(template);
}
return(null);
}
public void LoadExistingTemplates()
{
if (!Directory.Exists(Path.Combine(AppHelper.CachePath, "Templates")))
{
CreateInitialTemplates();
}
var files = Directory.GetFiles(Path.Combine(AppHelper.CachePath, "Templates"), "*.ps1");
foreach (var file in files)
{
TextReader reader = new StreamReader(file);
string firstLine = reader.ReadLine();
reader.Close();
var template = new RunbookTemplate
{
Name = new FileInfo(file).Name.Replace(".ps1", ""),
Path = file
};
if (firstLine.StartsWith("#DESCRIPTION"))
{
template.Description = firstLine.Replace("#DESCRIPTION", "");
template.Description = template.Description.TrimStart(':');
template.Description = template.Description.TrimStart(' ');
}
Templates.Add(template);
}
}
/// <summary>
/// Called when the user wants a new <see cref="TerrainTemplate"/> to be added.
/// </summary>
protected override void OnNewTemplate()
{
string newName = InputBox.Show(this, "Terrain Template Name", Resources.EnterTemplateName);
#region Error handling
if (string.IsNullOrEmpty(newName))
{
return;
}
if (Templates.Contains(newName))
{
Msg.Inform(this, Resources.NameInUse, MsgSeverity.Warn);
return;
}
#endregion
var itemClass = new TerrainTemplate {
Name = newName
};
Templates.Add(itemClass);
OnChange();
OnUpdate();
// Select the new entry
TemplateList.SelectedEntry = itemClass;
}
/// <summary>
/// Loads the templates.
/// </summary>
/// <param name="log">The log result.</param>
private void LoadTemplates(ILogger log)
{
foreach (var templateDir in TemplateFolders)
{
foreach (var filePath in templateDir.Files)
{
try
{
var file = new FileInfo(filePath);
if (!file.Exists)
{
log.Warning("Template [{0}] does not exist ", file);
continue;
}
var templateDescription = AssetSerializer.Load <TemplateDescription>(file.FullName);
templateDescription.FullPath = file.FullName;
Templates.Add(templateDescription);
}
catch (Exception ex)
{
log.Error("Error while loading template from [{0}]", ex, filePath);
}
}
}
}
private void NewTemplateExecute(object obj)
{
var templateViewModel = new TemplateViewModel();
UpdateParserOptions(templateViewModel);
Templates.Add(templateViewModel);
}
protected override bool InitializeTemplates()
{
Templates.Clear();
var codeTemplate1 = new ParametricComposer("<@", "@>");
codeTemplate1.SetTemplateText(
@"public Multivector()
{
}
public Multivector(params double[] coefs)
{
int i = 0;
foreach (var coef in coefs.Take(<@gadim@>))
Coef[i++] = coef;
}
public Multivector(IEnumerable<double> coefs)
{
int i = 0;
foreach (var coef in coefs.Take(<@gadim@>))
Coef[i++] = coef;
}
"
);
Templates.Add("multivector", codeTemplate1);
return(true);
}
protected void AddPageTemplate(PageTemplateInfo pageTemplateInfo)
{
TkDebug.AssertArgumentNull(pageTemplateInfo, nameof(pageTemplateInfo), this);
SetModelCreator(pageTemplateInfo);
Templates.Add(pageTemplateInfo);
}
public void Register(Type baseType, Type subType, params object[] arguments)
{
lock (Lock)
{
if (baseType == null)
{
throw new ArgumentNullException(nameof(baseType));
}
if (subType == null)
{
throw new ArgumentNullException(nameof(subType));
}
if (Templates.ContainsKey(baseType))
{
throw new InjectorException($"This Injector already contains the type {baseType.Name}!");
}
if (!baseType.IsAssignableFrom(subType))
{
throw new ArgumentException($"The type {baseType.Name} is not assignable from {baseType.Name}!");
}
var types = arguments?.Select(a => a.GetType()).ToArray() ?? Type.EmptyTypes;
var ctor = subType.GetConstructor(types);
if (ctor == null)
{
throw new ArgumentException(
$"The type {subType.Name} does not have a public constructor with {types.Length} parameters to call!");
}
Templates.Add(baseType, () => ctor.Invoke(arguments));
}
}
public void AddTemplate()
{
if (NewTemplateData != null)
{
Templates.Add(NewTemplateData);
}
}
public void Paste()
{
foreach (var templateItem in CopiedItems)
{
TemplateModel copiedTemplateItem = new TemplateModel();
copiedTemplateItem.ID = Guid.NewGuid();
copiedTemplateItem.Project_ID = templateItem.Project_ID;
copiedTemplateItem.TemplateName = templateItem.TemplateName;
copiedTemplateItem.Description = templateItem.Description;
copiedTemplateItem.IsChanged = false;
copiedTemplateItem.IsNew = true;
copiedTemplateItem.ChildTemplates = new TD.ObservableItemCollection <TemplateModel>();
if (SelectedItem == null)
{
copiedTemplateItem.Parent_ID = null;
Templates.Add(copiedTemplateItem);
}
// Otherwise get the parent object and add the new template as a child
else
{
copiedTemplateItem.Parent_ID = SelectedItem.ID;
SelectedItem.ChildTemplates.Add(copiedTemplateItem);
}
//SelectedItem = copiedTemplateItem;
}
IsChanged = true;
}
/// <summary>
///
/// </summary>
public void AddSibling()
{
TemplateModel templateItem = new TemplateModel
{
ID = Guid.NewGuid(),
Project_ID = Globals.Project_ID,
TemplateName = "New Template",
Description = "New Template Description",
IsChanged = false,
IsNew = true,
IsDeleted = false,
TemplateType_ID = TypeViewModelLocator.GetTypeVM().GetTypeGroupID("Template"),
ChildTemplates = new TD.ObservableItemCollection <TemplateModel>()
};
if (SelectedItem == null)
{
templateItem.Parent_ID = null;
Templates.Add(templateItem);
}
else if (SelectedItem.Parent_ID == null)
{
templateItem.Parent_ID = null;
Templates.Insert(Templates.IndexOf(SelectedItem) + 1, templateItem);
}
else
{
TemplateModel parentItem = GetTemplate(SelectedItem.Parent_ID);
templateItem.Parent_ID = SelectedItem.Parent_ID;
parentItem.ChildTemplates.Insert(parentItem.ChildTemplates.IndexOf(SelectedItem) + 1, templateItem);
}
}
public void AddTemplate()
{
var ret = new TemplateModel(Templates);
Templates.Add(ret);
Templates.SelectedItem = ret;
}
private void Register(string name, Type t, Action <object> template)
{
if (!Templates.ContainsKey(t))
{
Templates.Add(t, new Dictionary <string, Action <object> >());
}
Templates[t].Add(name ?? DefaultKey, template);
}
private void setTemplate(string key, string template)
{
if (Templates.ContainsKey(key))
{
Templates.Remove(key);
}
Templates.Add(key, template);
}
public void LoadFromFile(string fileName)
{
var model = SolutionModel.FromFile(fileName);
if (model != null)
{
Templates.Add(model);
}
}
public ObjectiveCTemplateProcessor(IPathWriter pathWriter, OdcmModel model, string baseFilePath)
: base(pathWriter, model, baseFilePath)
{
StrategyName = "ObjectiveC";
Templates.Add("Models", ProcessSimpleFile);
Templates.Add("Protocols", ProcessSimpleFile);
Templates.Add("ODataEntities", ProcessSimpleFile);
Templates.Add("EntityCollectionFetcher", EntityTypes);
Templates.Add("EntryPoint", ProcessEntryPoint);
}
public void AddTemplate()
{
var ret = new ProxyTemplateItemModel()
{
Name = "Template"
};
Templates.Add(ret);
SelectedItem = ret;
}
// Adds a build template instance
public void AddTemplate(TemplateInstance instance)
{
Templates.Add(instance);
string body = instance.Template.Contents;
Components = Components
.Where(entry => !body.Contains(entry.Key))
.ToDictionary(kv => kv.Key, kv => kv.Value);
}
public override void RenderCode(System.IO.StreamWriter writer)
{
Templates.Clear();
foreach (var field in Generator.PrivateFields)
{
Templates.Add(field.Name, new PrivateFieldTemplate(field.Type, field.Name));
}
base.RenderCode(writer);
}
public async void LoadTemplatesAsync()
{
var templates = await repository.LoadTemplatesAsync();
Templates.Clear();
foreach (var item in templates)
{
Templates.Add(item);
}
}
public void Initialize()
{
XmlDocument doc = new XmlDocument();
string[] xmlFilesArray = Directory.GetFiles(@"data\xml\classes\");
foreach (string i in xmlFilesArray)
{
doc.Load(i);
XmlNodeList nodes = doc.DocumentElement?.SelectNodes("/list/class");
if (nodes == null)
{
continue;
}
foreach (XmlNode node in nodes)
{
XmlElement ownerElement = node.Attributes?[0].OwnerElement;
if ((ownerElement == null) || (node.Attributes == null) || !"class".Equals(ownerElement.Name))
{
continue;
}
XmlNamedNodeMap attrs = node.Attributes;
ClassId classId = ClassId.Values.FirstOrDefault(x => ((int)x.Id).Equals(Convert.ToInt32(attrs.Item(0).Value)));
StatsSet set = new StatsSet();
for (XmlNode cd = node.FirstChild; cd != null; cd = cd.NextSibling)
{
if ((cd.NextSibling != null) && "set".Equals(cd.NextSibling.Name) && (cd.NextSibling != null))
{
attrs = cd.NextSibling.Attributes;
if (attrs == null)
{
continue;
}
string name = attrs.GetNamedItem("name").Value;
string value = attrs.GetNamedItem("val").Value;
set.Set(name, value);
}
else
{
break;
}
}
PcTemplate pcTempl = new PcTemplate(classId, set);
Templates.Add((int)pcTempl.ClassId.Id, pcTempl);
}
}
Log.Info($"CharTemplateTable: Loaded {Templates.Count} character templates.");
}
/// <summary>
/// 添加模版项，实际上是添加到Templates集合中。
/// 未指定模版名称时，使用模版的散列作为模版名称
/// </summary>
/// <param name="name"></param>
/// <param name="content"></param>
public void AddTemplateItem(String name, String content)
{
if (String.IsNullOrEmpty(name) && String.IsNullOrEmpty(content))
{
throw new ArgumentNullException("content", "名称和模版内容不能同时为空！");
}
if (Status >= TemplateStatus.Process)
{
throw new InvalidOperationException("模版已分析处理，不能再添加模版！");
}
// 未指定模版名称时，使用模版的散列作为模版名称
if (String.IsNullOrEmpty(name))
{
name = Hash(content);
}
TemplateItem item = FindTemplateItem(name);
if (item == null)
{
item = new TemplateItem();
Templates.Add(item);
}
item.Name = name;
item.Content = content;
// 设置类名
var cname = Path.GetFileNameWithoutExtension(name);
// 如果无扩展的名称跟前面的名称不同，并且无扩展名称跟编码后的类名相同，则设置类型为无扩展名称
if (cname != name && cname == GetClassName(cname))
{
// 如果没有别的模版项用这个类名，这里使用
if (!Templates.Any(t => t.ClassName == cname))
{
item.ClassName = cname;
}
}
// 设置程序集名，采用最后一级目录名
if (String.IsNullOrEmpty(AssemblyName))
{
var dname = Path.GetDirectoryName(name);
if (!String.IsNullOrEmpty(dname))
{
dname = Path.GetFileName(dname);
if (!String.IsNullOrEmpty(dname))
{
AssemblyName = dname;
}
}
}
}
private void UpdateModelAndTemplates()
{
Templates.Clear();
CurrentModel = Models.GetCurrent(isForDeck);
TemplatesJson = CurrentModel.GetNamedArray("tmpls");
foreach (var t in TemplatesJson)
{
uint newOrd = (uint)t.GetObject().GetNamedNumber("ord");
Templates.Add(new TemplateInformation(t.GetObject().GetNamedString("name"), newOrd));
}
}
void onGetTemplatesCompleted(object sender, DownloadStringCompletedEventArgs e)
{
if (e.Cancelled || GetTemplatesCompleted == null)
return;
Exception error = e.Error;
if (error == null)
error = GetErrorIfAny(e.Result);
Templates templates = new Templates();
if (error == null)
{
try
{
XDocument xDoc = XDocument.Parse(e.Result);
XElement templatesElem = xDoc.Element("Templates");
if (templatesElem != null)
{
IEnumerable<XElement> templateElems = templatesElem.Elements("Template");
if (templateElems != null)
{
foreach (XElement elem in templateElems)
{
templates.Add(new Template()
{
BaseUrl = elem.Element("BaseUrl") != null ? elem.Element("BaseUrl").Value : null,
DisplayName = elem.Element("DisplayName") != null ? elem.Element("DisplayName").Value : null,
ID = elem.Element("ID") != null ? elem.Element("ID").Value : null,
IsDefault = elem.Element("IsDefault").Value != null ? bool.Parse(elem.Element("IsDefault").Value) : false,
});
}
}
}
}
catch (Exception ex)
{
error = ex;
}
}
GetTemplatesCompleted(this, new GetTemplatesCompletedEventArgs()
{
Templates = templates,
UserState = e.UserState,
Error = error,
});
}
