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, }); }