public override async Task Clear() { await Templates.Clear().ConfigureAwait(false); await Operations.Clear().ConfigureAwait(false); if (CRRoot.Exists) { CRRoot.Delete(true); } }
public async void LoadTemplates() { try { Templates.Clear(); List <Template> rawTemplates = await App.Database.GetAllTemplates(); AssignNumbers(rawTemplates); } catch (Exception ex) { UserDialogs.Instance.Alert("Bład!\r\n\r\n" + ex.ToString(), "Błąd", "OK"); } }
private void ResetExecute() { var settings = mySettingsStore.GetKey <PostfixTemplatesSettings>(SettingsOptimization.OptimizeDefault); settings.DisabledProviders.SnapshotAndFreeze(); foreach (var provider in settings.DisabledProviders.EnumIndexedValues()) { mySettingsStore.RemoveIndexedValue(PostfixSettingsAccessor.DisabledProviders, provider.Key); } Templates.Clear(); FillTemplates(); }
public void Dispose() { Log?.Clear(); Entities?.Clear(); Actions?.Clear(); CalculatedFields?.Clear(); Connections?.Clear(); Environments?.Clear(); Maps?.Clear(); Relationships?.Clear(); Scripts?.Clear(); SearchTypes?.Clear(); Templates?.Clear(); }
public void RefreshTemplates(string selectedTemplateName) { TemplateItem _selectedTemplate = null; try { Templates.Clear(); string _templatesFolder = FileManager.GetTemplatesFolder(); if (Directory.Exists(_templatesFolder)) { string[] _templates = Directory.GetFiles(_templatesFolder, "template.xml", SearchOption.AllDirectories); if (_templates != null && _templates.Count() != 0) { Array.Sort(_templates, new Comparison <string>(delegate(string d1, string d2) { return(string.Compare(TemplateItem.GetTemplateName(d1), TemplateItem.GetTemplateName(d2), true)); })); foreach (string _templatePath in _templates) { TemplateItem _template = new TemplateItem(_templatePath); Templates.Add(_template); if (!string.IsNullOrEmpty(selectedTemplateName) && string.Compare(_template.TemplateName.ToLowerInvariant(), selectedTemplateName.ToLowerInvariant()) == 0) { _selectedTemplate = _template; } } // select first available template by default if nothing selected already if (_selectedTemplate == null && Templates.Count != 0) { _selectedTemplate = Templates[0]; } } } } catch (Exception ex) { Loggy.Logger.DebugException("Refresh templates", ex); } if (_selectedTemplate != null) { _selectedTemplate.IsSelected = true; SelectedTemplate = _selectedTemplate; Helpers.DoEvents(); } }
private void UpdateListView(TreeNodeViewModel <TemplateInfo> selectedTreeNode) { Templates.Clear(); foreach (var value in selectedTreeNode.Values) { Templates.Add(new ListViewModel <TemplateInfo> { Value = value }); } if (Templates.Count > 0) { Templates[0].IsSelected = true; } }
public void Delete() { if (Deleted) { return; } TakeEquipment(); ClearTemplate(); Templates.Clear(); Owner = null; Deleted = true; }
private bool LoadTemplates() { try { Templates.Clear(); var templateFiles = packageFiles .Where(pf => pf.Name.IsMatch($"^{TemplatePackageFile.Path}/.+")); foreach (PackageFile file in templateFiles) { string name = Path.GetFileNameWithoutExtension(file.Name); var reader = new ObjectXmlReader(file.Stream); object model = reader.ReadObject(); if (model is PTemplatePage page) { if (string.IsNullOrEmpty(name)) { name = LayoutExtension.CreatePageName(page, "Template"); } // Name Setting LayoutExtension.SetPageName(page, name); Templates.Add(page); CachingBinder(page.Binder); foreach (var node in ObjectContentTreeHelper.FindContentChildrens <PVisual, PVisual>(page)) { CachingBinder(node.Child.Binder); } } } return(true); } catch { } return(false); }
public void LoadTemplates(string path) { Templates.Clear(); try { string[] names = Directory.GetFiles(path, "*.xml"); foreach (var name in names) { Templates.Add(new LayoutTemplate(name)); } } catch (Exception ex) { Logger.Current.Warn("Failed to load layout templates: " + path, ex); } }
public override void RenderCode(System.IO.StreamWriter writer) { Templates.Clear(); foreach (var property in Generator.Properties) { if (!string.IsNullOrEmpty(property.Type) && !string.IsNullOrEmpty(property.Name)) { if (property.IsAuto) { Templates.Add(property.Name, new AutoPropertyTemplate(property.Type, property.Name)); } else { Templates.Add(property.Name, new PropertyTemplate(property.Type, property.Name, property.Getter, property.Setter)); } } } base.RenderCode(writer); }
/// <summary> /// 转换文本中的div标签为控件 /// </summary> /// <param name="inputStr"></param> /// <returns></returns> string ConvertTagsToControls(string inputStr) { string strReturn = ""; string strTemplate; Controls.Clear(); Templates.Clear(); strTemplate = inputStr; foreach (Match m in TheRegexs[2].Matches(strTemplate)) { strTemplate = strTemplate.Replace(m.Groups[0].ToString(), GetWeControl(m.Groups[0].ToString())); } foreach (Match m in TheRegexs[3].Matches(strTemplate)) { strTemplate = strTemplate.Replace(m.Groups[0].ToString(), GetWeTemplate(m.Groups[0].ToString())); } return(strTemplate); }
public void OnForeignKeyTypesIndexChanged() { if (Templates == null) { Templates = new ObservableCollection <string>(); } if ((ForeignKeyTypesIndex < 0) || (ForeignKeyTypes.Count <= ForeignKeyTypesIndex)) { SelectedTemplate = ""; Templates.Clear(); return; } switch (ForeignKeyTypes[ForeignKeyTypesIndex]) { case NavigationTypeEnum.OneToMany: case NavigationTypeEnum.OptionalToMany: currentTempateFolder = TemplateOneToCollectionFolder; break; case NavigationTypeEnum.OneToOne: case NavigationTypeEnum.OptionalToOne: currentTempateFolder = TemplateOneToOneFolder; break; default: currentTempateFolder = TemplateFolder; break; } Templates.Clear(); SelectedTemplate = ""; string[] files = Directory.GetFiles(currentTempateFolder, TemplateExtention); if (files != null) { foreach (string f in files) { Templates.Add(Path.GetFileName(f)); } } }
async Task ExecuteLoadItemsCommand() { if (IsBusy) { return; } IsBusy = true; try { var items = await DataStore.GetItemsAsync(); Templates.Clear(); foreach (var template in items) { Templates.Add(template); } } // TODO: Add error message and log error on exception. finally { IsBusy = false; } }
public void DoAnalise() { if (Templates == null) { Templates = new ObservableCollection <string>(); } if (Templates.Count < 1) { Templates.Clear(); SelectedTemplate = ""; string[] files = Directory.GetFiles(TemplateFolder, TemplateExtention); if (files != null) { foreach (string f in files) { Templates.Add(Path.GetFileName(f)); } } } if (EntityProperties.Count < 1) { if (SelectedEntity != null) { if (SelectedEntity.CodeElementRef != null) { (SelectedEntity.CodeElementRef as CodeClass).CollectCodeClassMappedScalarNotNullProperties(EntityProperties); OnPropertyChanged("EntityProperties"); } } } if (PrimaryKeyProperties.Count < 1) { CollectPrimaryKeyProperties(); } }
private async void ImportFromReventClassic() { // Show dialog asking the user if they wish to import their old data // Show loading window UiShowImportLoading = true; // Migrate from bool success = DatabaseService.MigrateFromReventClassic(); await Task.Delay(2000); // Hide load window and show import successful for 3 secs if (success == true) { UiShowImportSuccessful = true; UiShowImportLoading = false; await Task.Delay(3000); UiShowImportSuccessful = false; } else { // TODO Show failed message UiShowImportLoading = false; await Task.Delay(3000); // TODO Hide failed message } // Ask if the user wishes to keep their old data (for the classic app) // Refresh data Templates.Clear(); GetTemplates(); }
public void Update() { Templates.Clear(); if (TemplatesProvider.Default.Templates != null) { if (typeof(T2) == typeof(FaseCyclusModel)) { foreach (var t in TemplatesProvider.Default.Templates.FasenTemplates) { Templates.Add(t as T1); } } else if (typeof(T2) == typeof(DetectorModel)) { foreach (var t in TemplatesProvider.Default.Templates.DetectorenTemplates) { Templates.Add(t as T1); } } else if (typeof(T2) == typeof(PeriodeModel)) { foreach (var t in TemplatesProvider.Default.Templates.PeriodenTemplates) { Templates.Add(t as T1); } } else { throw new ArgumentOutOfRangeException(); } } if (Templates.Count > 0) { SelectedTemplate = Templates[0]; } }
private void LoadTemplates() { Templates.Clear(); var path = IOHelper.CheckPath(GlobalConfig.ProgramRoot, "Templates"); var folders = Directory.GetDirectories(path); foreach (var folder in folders) { var cla = new TemplateClassify { Name = Path.GetFileName(folder) }; foreach (var file in IOHelper.GetAllFiles(folder, "*.lt")) { cla.Templates.Add(new TemplateConfig { Caption = Path.GetFileNameWithoutExtension(file), Classify = cla.Name, TemplatePath = file }); } Templates.Add(cla); } }
/// <summary> /// Processes image in gray colors /// </summary> public void ProcessImage(Image <Gray, byte> grayFrame) { // smoothing -> downscaling and upscaling via binary interpolation Image <Gray, byte> smoothedGrayFrame = grayFrame.PyrDown(); smoothedGrayFrame = smoothedGrayFrame.PyrUp(); Image <Gray, byte> cannyFrame = null; if (noiseFilter) { cannyFrame = smoothedGrayFrame.Canny(new Gray(cannyThreshold), new Gray(cannyThreshold)); } if (blur) { grayFrame = smoothedGrayFrame; } // transform into binary image (2 values) CvInvoke.cvAdaptiveThreshold(grayFrame, grayFrame, 255, Emgu.CV.CvEnum.ADAPTIVE_THRESHOLD_TYPE.CV_ADAPTIVE_THRESH_MEAN_C, Emgu.CV.CvEnum.THRESH.CV_THRESH_BINARY, adaptiveThresholdBlockSize + adaptiveThresholdBlockSize % 2 + 1, adaptiveThresholdParameter); // invert grayFrame._Not(); // logic OR will smooth additional noise if (cannyFrame != null) { grayFrame._Or(cannyFrame); } this.binarizedFrame = grayFrame; if (cannyFrame != null) { cannyFrame = cannyFrame.Dilate(3); } // find all contours var sourceContours = grayFrame.FindContours(Emgu.CV.CvEnum.CHAIN_APPROX_METHOD.CV_CHAIN_APPROX_NONE, Emgu.CV.CvEnum.RETR_TYPE.CV_RETR_LIST); // filter all contours contours = FilterContours(sourceContours, cannyFrame, grayFrame.Width, grayFrame.Height); lock (foundTemplates) foundTemplates.Clear(); samples.Clear(); // process all contours in parallel lock (templates) Parallel.ForEach <Contour <Point> >(contours, (contour) => { // create a template sample from each contour and try to find its relevant template var arr = contour.ToArray(); Template sample = new Template(arr, contour.Area, samples.templateSize); lock (samples) samples.Add(sample); if (!onlyFindContours) { // find a template according to the sample FoundTemplateDesc desc = finder.FindTemplate(templates, sample); if (desc != null) { lock (foundTemplates) foundTemplates.Add(desc); } } } ); FilterByIntersection(ref foundTemplates); }
private void PopulateList() { Templates.Clear(); var assembly = typeof(App).GetTypeInfo().Assembly; var stream = assembly.GetManifestResourceStream(sampleListFile); using (var reader = new StreamReader(stream)) { var xmlReader = XmlReader.Create(reader); xmlReader.Read(); Category category = null; var hasAdded = false; var runtimePlatform = Device.RuntimePlatform.ToLower(); while (!xmlReader.EOF) { switch (xmlReader.Name) { case "Category" when xmlReader.IsStartElement() && xmlReader.HasAttributes: { if (!hasAdded && category != null) { Templates.Add(category); category = null; hasAdded = true; } var platform = GetDataFromXmlReader(xmlReader, "Platform"); if (string.IsNullOrEmpty(platform) || platform.ToLower().Contains(runtimePlatform)) { var categoryName = GetDataFromXmlReader(xmlReader, "Name"); var description = GetDataFromXmlReader(xmlReader, "Description"); var icon = $"EssentialUIKit.AppLayout.Icons.{GetDataFromXmlReader(xmlReader, "Icon")}"; category = new Category(categoryName, icon, description); } break; } case "Page" when xmlReader.IsStartElement() && xmlReader.HasAttributes && category != null: { var platform = GetDataFromXmlReader(xmlReader, "Platform"); if (string.IsNullOrEmpty(platform) || platform.ToLower().Contains(runtimePlatform)) { var templateName = GetDataFromXmlReader(xmlReader, "Name"); var description = GetDataFromXmlReader(xmlReader, "Description"); var pageName = GetDataFromXmlReader(xmlReader, "PageName"); bool.TryParse(GetDataFromXmlReader(xmlReader, "LayoutFullscreen"), out var layoutFullScreen); var template = new Template(templateName, description, pageName, layoutFullScreen); Routing.RegisterRoute(templateName, assembly.GetType($"EssentialUIKit.{pageName}")); category.Pages.Add(template); hasAdded = false; } break; } } xmlReader.Read(); } if (!hasAdded) { Templates.Add(category); } } }
/// <summary> /// /// </summary> public void Refresh() { Templates.Clear(); Load(null); LoadTreeState(); }
public async Task Initialize(Dispatcher dispatcher) { // read the settings from storage Settings.CopyFrom(await Storage.LoadSettings()); if (Settings.SystemIdentifier == Guid.Empty) { // this only occurs when the system hasn't had one allocated // so we can create a new one, then save the settings. // (this will force an empty setting file with the System Identifier if needed) Settings.AllocateNewSystemIdentifier(); await Storage.SaveSettings(Settings); } // read the room mappings from storage RoomMappings.Clear(); foreach (var map in await Storage.LoadRoomMappings()) { RoomMappings.Add(map); } Templates.Clear(); foreach (var template in await Storage.LoadTemplates()) { Templates.Add(template); } AddMissingTemplates(); // reload any unmatched messages var messages = await Storage.LoadUnprocessableMessages(DisplayingDate); foreach (var item in messages) { UnprocessableMessages.Add(item); } PmsSimulator.Initialize(Storage); if (!IsSimulation) { FhirApptReader = new FhirAppointmentReader(FhirAppointmentReader.GetServerConnection); SmsProcessor.Initialize(Settings); } logger.Log(1, "Start up"); if (!String.IsNullOrEmpty(Settings.AdministratorPhone)) { logger.Log(1, "Send SMS to " + Settings.AdministratorPhone); try { SmsProcessor.SendMessage(new SmsMessage(Settings.AdministratorPhone, "System is starting")); if (!IsSimulation) { App.AdministratorPhone = Settings.AdministratorPhone; App.SmsSender = SmsProcessor; } } catch (Exception ex) { System.Windows.MessageBox.Show("Error sending message: " + ex.Message); } } // setup the background worker routines ReadSmsMessage = new BackgroundProcess(Settings, serverStatuses.IncomingSmsReader, dispatcher, async() => { // Logic to run on this process // (called every settings.interval) StatusBarMessage = $"Last read SMS messages at {DateTime.Now.ToLongTimeString()}"; var engine = PrepareMessagingEngine(); List <PmsAppointment> appts = new List <PmsAppointment>(); appts.AddRange(Appointments); var messagesReceived = await engine.SmsSender.ReceiveMessages(); serverStatuses.IncomingSmsReader.Use(messagesReceived.Count()); engine.ProcessIncomingMessages(appts, messagesReceived); }); ScanAppointments = new BackgroundProcess(Settings, serverStatuses.AppointmentScanner, dispatcher, async() => { // Logic to run on this process // (called every settings.interval) var engine = PrepareMessagingEngine(); List <PmsAppointment> appts = await FhirApptReader.SearchAppointments(this.DisplayingDate, RoomMappings, Storage); serverStatuses.Oridashi.Use(1); serverStatuses.AppointmentScanner.Use(engine.ProcessTodaysAppointments(appts)); // Now update the UI once we've processed it all Expecting.Clear(); Waiting.Clear(); Appointments.Clear(); foreach (var appt in appts) { Appointments.Add(appt); if (appt.ArrivalStatus == Hl7.Fhir.Model.Appointment.AppointmentStatus.Booked) { Expecting.Add(appt); } else if (appt.ArrivalStatus == Hl7.Fhir.Model.Appointment.AppointmentStatus.Arrived) { Waiting.Add(appt); } } }); ProcessUpcomingAppointments = new BackgroundProcess(Settings, serverStatuses.UpcomingAppointmentProcessor, dispatcher, async() => { // Logic to run on this process // (called every settings.intervalUpcoming) var engine = PrepareMessagingEngine(); List <PmsAppointment> appts = new List <PmsAppointment>(); appts.AddRange(await FhirApptReader.SearchAppointments(this.DisplayingDate.AddDays(1), RoomMappings, Storage)); appts.AddRange(await FhirApptReader.SearchAppointments(this.DisplayingDate.AddDays(2), RoomMappings, Storage)); serverStatuses.Oridashi.Use(1); serverStatuses.UpcomingAppointmentProcessor.Use(engine.ProcessUpcomingAppointments(appts)); }, true); }