/// <summary> /// Initializes event handlers. /// </summary> private void InitializeEvents() { NotificationSessionEvents events = _analysisApi.Session.Events; Exporters export = _analysisApi.Exporters; //events of the Session object events.SessionCreate.Before += new EventHandler <EventArgs>(APIBeforeEvent); events.SessionCreate.After += new EventHandler <EventArgs>(APIAfterEvent); events.SessionOpen.Before += new EventHandler <EventArgs>(APIBeforeEvent); events.SessionOpen.After += new EventHandler <EventArgs>(APIAfterEvent); events.RunLoadGraphList.Before += new EventHandler <EventArgs>(APIBeforeEvent); events.RunLoadGraphList.After += new EventHandler <EventArgs>(APIAfterEvent); events.GraphApplyFilterAndGroupBy.Before += new EventHandler <EventArgs>(APIBeforeEvent); events.GraphApplyFilterAndGroupBy.After += new EventHandler <EventArgs>(APIAfterEvent); events.CreateHtmlReport.After += new EventHandler <NotificationsHTMLReportData>(APICreateHtmlReport); events.CreateHtmlReport.Before += new EventHandler <NotificationsHTMLReportData>(APIBeforeEvent); events.SessionCreate.NotifyStatusUpdate += new EventHandler <NotificationProgressData>(APIProgressEvent); events.RunLoadGraphList.NotifyStatusUpdate += new EventHandler <NotificationProgressData>(APIProgressEvent); //events of Exporters object export.CSV.Events.Graph.Before += new EventHandler <EventArgs>(APIBeforeEvent); export.CSV.Events.Graph.After += new EventHandler <EventArgs>(APIAfterEvent); export.CSV.Events.Dictionary.NotifyStatusUpdate += new EventHandler <NotificationStatusData>(APIStatusUpdate); export.CSV.Events.Series.NotifyStatusUpdate += new EventHandler <NotificationStatusData>(APIStatusUpdate); export.CSV.Events.Graph.NotifyStatusUpdate += new EventHandler <NotificationProgressData>(APIProgressEvent); }
void ExecuteExporter(object x, System.Type type) { ExportDelegate v; if (!Exporters.TryGetValue(type, out v)) { if (type.IsArray) { v = ExportArray; } else if (type.GetInterface("System.Collections.IList") != null) { v = ExportIList; } else if (type.GetInterface("System.Collections.IDictionary") != null) { v = ExportIDictionary; } else if (!type.IsPrimitive) // handle user defined types { v = CreateUserTypeExporter(x, type); } else { throw new UnsupportedPrimitiveTypeException(type); } Exporters[type] = v; } v(this, x); }
void Export(Account a, string filename) { if (filename.ToLowerInvariant().EndsWith(".txf")) { TaxReportDialog options = new TaxReportDialog(); options.Month = Settings.TheSettings.FiscalYearStart; options.Owner = App.Current.MainWindow; if (options.ShowDialog() == true) { TxfExporter e = new TxfExporter(this.myMoney); using (StreamWriter sw = new StreamWriter(filename)) { DateTime startDate = new DateTime(options.Year, options.Month + 1, 1); if (options.Month > 0) { // then the FY year ends on the specified year. startDate = startDate.AddYears(-1); } DateTime endDate = startDate.AddYears(1); e.ExportCapitalGains(a, sw, startDate, endDate, options.ConsolidateSecuritiesOnDateSold); } } } else { Exporters e = new Exporters(); List <object> data = new List <object>(); foreach (object row in this.MyMoney.Transactions.GetTransactionsFrom(a)) { data.Add(row); } e.Export(filename, data); } }
private void OnCommandViewExport(object sender, ExecutedRoutedEventArgs e) { Exporters exporter = new Exporters(); exporter.SupportXml = false; exporter.ExportPrompt(loanPayementsView.ToArray()); }
void Export(Account a, string filename) { if (filename.ToLowerInvariant().EndsWith(".txf")) { TaxReportDialog options = new TaxReportDialog(); options.Owner = App.Current.MainWindow; if (options.ShowDialog() == true) { TxfExporter e = new TxfExporter(this.myMoney); using (StreamWriter sw = new StreamWriter(filename)) { e.ExportCapitalGains(a, sw, options.Year, options.ConsolidateSecuritiesOnDateSold); } } } else { Exporters e = new Exporters(); List <object> data = new List <object>(); foreach (object row in this.MyMoney.Transactions.GetTransactionsFrom(a)) { data.Add(row); } e.Export(filename, data); } }
public virtual void Register(IExporter exporter) { if (exporter == null) throw new ArgumentNullException("exporter"); Exporters.Put(exporter); }
public override IExporter Export(IInvoker invoker) { var url = invoker.GetUrl(); var key = ServiceKey(url); var exporter = new DubboExporter(invoker, key, Exporters); Exporters.TryAdd(key, exporter); var isStubSupportEvent = url.GetParameter(Constants.StubEventKey, Constants.DefaultStubEvent); var isCallbackService = url.GetParameter(Constants.IsCallbackService, false); if (isStubSupportEvent && !isCallbackService) { var stubServiceMethods = url.GetParameter(Constants.StubEventMethodsKey, ""); if (string.IsNullOrEmpty(stubServiceMethods)) { if (Logger.WarnEnabled) { Logger.Warn(new Exception("consumer [" + url.GetParameter(Constants.InterfaceKey, "") + "], has set stubproxy support event ,but no stub methods founded.")); } } else { _stubServiceMethods.TryAdd(url.ServiceName, stubServiceMethods); } } OpenServer(url); OptimizeSerialization(url); return(exporter); }
private IInvoker GetInvoker(IChannel channel, IInvocation inv) { var isCallBackServiceInvoke = false; var isStubServiceInvoke = false; var port = channel.Url.Port;//todo url.localaddress var path = inv.GetAttachment(Constants.PathKey); isStubServiceInvoke = "true".Equals(inv.GetAttachment(Constants.StubEventKey), StringComparison.OrdinalIgnoreCase); if (isStubServiceInvoke) { port = channel.Url.Port; } isCallBackServiceInvoke = IsClientSide(channel) && !isStubServiceInvoke; if (isCallBackServiceInvoke) { path = path + "." + inv.GetAttachment(Constants.CallbackServiceKey); inv.Attachments.Add(IsCallbackServiceInvoke, "true"); } var serviceKey = ServiceKey(port, path, inv.GetAttachment(Constants.VersionKey), inv.GetAttachment(Constants.GroupKey)); Exporters.TryGetValue(serviceKey, out var exporter); return(exporter?.GetInvoker()); }
public Plugin() { // register resource manager AddResourceManager(Resources.ResourceManager); // register all the exporters Exporters.Add(new ExporterInfo(typeof(Exporters.ExporterJson), "json", "Json", true)); }
public virtual void Register(IExporter exporter) { if (exporter == null) { throw new ArgumentNullException(nameof(exporter)); } Exporters.Put(exporter); }
public ExportForm(IPersistence persistence, ConnectionManager connectionManager, FavoriteIcons favoriteIcons) { this.persistence = persistence; this.InitializeComponent(); this.treeLoader = new FavoriteTreeListLoader(this.favsTree, this.persistence, this.favoriteIcons); this.treeLoader.LoadRootNodes(); this.connectionManager = connectionManager; this.favoriteIcons = favoriteIcons; this.exporters = new Exporters(this.persistence, this.connectionManager); this.saveFileDialog.Filter = this.exporters.GetProvidersDialogFilter(); }
public static void ExportBy(MSGContainer container, string name, string filename = null) { if (!Exporters.ContainsKey(name)) { throw new Exception(name + " 导出器未找到"); } Type type = Exporters[name]; var exporter = (MSGExporter)Activator.CreateInstance(type, container); ; exporter.ExportTo(filename); }
public ActivityLogPage() { InitializeComponent(); // set the default exporter // TODO: Restore last used Exporter = Exporters.First(); LoadExportSettings(); _band = BandManager.Instance; this.DataContext = BandCloudManager.Instance; }
private void Export_Click(object sender, RoutedEventArgs e) { var Save_File_Dialog = new System.Windows.Forms.SaveFileDialog { Filter = Exporters.Filter, DefaultExt = Exporters.DefaultExtension }; if (Save_File_Dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK) { string SaveFolder = Path.GetDirectoryName(Save_File_Dialog.FileName); // Save Textures foreach (KeyValuePair <string, BitmapSource> Image in TextureList) { using (var FStream = new FileStream(SaveFolder + "\\" + Image.Key + ".png", FileMode.Create)) { var Encoder = new PngBitmapEncoder(); Encoder.Frames.Add(BitmapFrame.Create(Image.Value)); Encoder.Save(FStream); } } // Save Models using (FileStream Stream = new FileStream(Save_File_Dialog.FileName, FileMode.Create)) { //var MP = ModelPoints.Points; //ModelPoints.Points = null; // Don't export vertices var ModelExporter = Exporters.Create(Save_File_Dialog.FileName); if (ModelExporter is ObjExporter) { var OExporter = ModelExporter as ObjExporter; OExporter.MaterialsFile = Path.GetDirectoryName(Save_File_Dialog.FileName) + Path.DirectorySeparatorChar + Path.GetFileNameWithoutExtension(Save_File_Dialog.FileName) + "_Material.mtl"; foreach (var Mat in ModelGroup.Children) { Console.WriteLine("Material: " + (Mat as GeometryModel3D).Material.GetName()); } } ModelExporter.Export(ModelGroup, Stream); //ModelPoints.Points = MP; } } }
private static void ExportFavorite(IFavorite favorite, IPersistence persistence) { FavoriteConfigurationElement favoriteElement = ModelConverterV2ToV1.ConvertToFavorite(favorite, persistence, TestConnectionManager.Instance); ExportOptions options = new ExportOptions { ProviderFilter = ImportTerminals.TERMINALS_FILEEXTENSION, Favorites = new List <FavoriteConfigurationElement> { favoriteElement }, FileName = TEST_FILE, IncludePasswords = true }; Exporters exporters = new Exporters(persistence, TestConnectionManager.Instance); exporters.Export(options); }
public Plugin() { // register resource manager AddResourceManager(Resources.ResourceManager); //Plugin.RegisterTypeHandlers(); //Plugin.RegisterAgentTypes(); // register all the groups we need in the node explorer //Plugin.RegisterNodeDesc(); // register all the file managers _fileManagers.Add(new FileManagerInfo(typeof(Behaviac.Design.FileManagers.FileManagerXML), "Behaviour XML (*.xml)|*.xml", ".xml")); // register all the exporters Exporters.Add(new ExporterInfo(typeof(Behaviac.Design.Exporters.ExporterXml), "xml", "Xml Behavior Exporter", true)); Exporters.Add(new ExporterInfo(typeof(Behaviac.Design.Exporters.ExporterBson), "bson", "Bson Behavior Exporter", true)); Exporters.Add(new ExporterInfo(typeof(PluginBehaviac.Exporters.ExporterCpp), "cpp", "C++ Behavior Exporter", true, true)); Exporters.Add(new ExporterInfo(typeof(PluginBehaviac.Exporters.ExporterCs), "cs", "C# Behavior Exporter", true, true)); }
private void TraceExtensions() { Trace.TraceInformation("Factories {0}:", Factories.Count); Factories.ForEach(x => Trace.TraceInformation(x.ToString())); Trace.TraceInformation("Importers {0}:", Importers.Count); Importers.ForEach(x => Trace.TraceInformation(x.ToString())); Trace.TraceInformation("Exporters: {0}", Exporters.Count); Exporters.ForEach(x => Trace.TraceInformation(x.ToString())); Trace.TraceInformation("Visualizers: {0}", Visualizers.Count); Visualizers.ForEach(x => Trace.TraceInformation(x.ToString())); Trace.TraceInformation("Settings: {0}", Settings.Count); Settings.ForEach(x => Trace.TraceInformation(x.ToString())); Trace.TraceInformation("AttributeProviders: {0}", AttributeProviders.Count); AttributeProviders.ForEach(x => Trace.TraceInformation(x.ToString())); }
private void ReadConfigurationDetails() { XmlNode nameNode = _xmlDocument.SelectSingleNode("/export/name"); if (nameNode != null) { _name = nameNode.InnerText; } XmlNode versionNode = _xmlDocument.SelectSingleNode("/export/version"); if (versionNode != null) { _version = versionNode.InnerText; } _exporters = this.UnpackExporter(_xmlDocument.SelectSingleNode("/export/exporter")); XmlNode descriptionNode = _xmlDocument.SelectSingleNode("/export/description"); if (descriptionNode != null) { _description = descriptionNode.InnerText; } XmlNode screenshotNode = _xmlDocument.SelectSingleNode("/export/screenshot"); if (screenshotNode != null) { _hasScreenshot = true; } XmlNodeList properties = _xmlDocument.SelectNodes("/export/properties/property"); foreach (XmlNode currentProperty in properties) { _properties.Add(currentProperty.Attributes["name"].Value, currentProperty.Attributes["value"].Value); } }
internal void Load(Editor editor, string path) { Verify.DirectoryExists(path, "path"); Trace.TraceInformation("Loading default editor extensions at folder {0}", Path.GetFullPath(path)); var extensions = Directory.GetFiles(path, "*.DLL").Concat(Directory.GetFiles(path, "*.EXE")) .SelectMany(file => LoadExportedTypes(file)) .Select(type => new { Export = type.GetCustomAttributes(typeof(ExportAttribute), false).SingleOrDefault(), Type = type }) .Where(pair => pair.Export != null) .ToLookup(pair => ((ExportAttribute)pair.Export).ContractType, pair => pair.Type); AttributeProviders.AddRange(from type in extensions[typeof(IAttributeProvider)] where !AttributeProviders.Any(x => x.GetType() == type) select(IAttributeProvider) Activator.CreateInstance(type)); Factories.AddRange(from type in extensions[typeof(IFactory)] where !Factories.Any(x => x.Value.GetType() == type) select new Extension <IFactory>(editor, (IFactory)Activator.CreateInstance(type))); Visualizers.AddRange(from type in extensions[typeof(IVisualizer)] where !Visualizers.Any(x => x.Value.GetType() == type) select new Extension <IVisualizer>(editor, (IVisualizer)Activator.CreateInstance(type))); Tools.AddRange(from type in extensions[typeof(ITool)] where !Tools.Any(x => x.Value.GetType() == type) select new Extension <ITool>(editor, (ITool)Activator.CreateInstance(type))); Importers.AddRange(from type in extensions[typeof(IImporter)] where !Importers.Any(x => x.Value.GetType() == type) select new Extension <IImporter>(editor, (IImporter)Activator.CreateInstance(type))); Exporters.AddRange(from type in extensions[typeof(IExporter)] where !Exporters.Any(x => x.Value.GetType() == type) select new Extension <IExporter>(editor, (IExporter)Activator.CreateInstance(type))); Settings.AddRange(from type in extensions[typeof(ISettings)] where !Settings.Any(x => x.Value.GetType() == type) select new Extension <ISettings>(editor, (ISettings)Activator.CreateInstance(type))); TraceExtensions(); Trace.TraceInformation("Extensions Loaded."); }
/// <summary>Adds the specified new exporters.</summary> /// <param name="newExporters">The new exporters.</param> public void Add(params IExporter[] newExporters) => Exporters.AddRange(newExporters);
public override bool Import(Exporters.Exporter exporter, IPackage package) { Exporters.STBLExporter export = exporter as Exporters.STBLExporter; if (export == null) return false; return ImportFromString(export.ConvertToString(package), package); }
internal Extension <IExporter> FindExporter(Type type) { return(Exporters.SingleOrDefault(e => e.IsDefault && e.Value.TargetType == type) ?? Exporters.FirstOrDefault(e => e.Value.TargetType == type)); }
private bool ImportFile(ListItem listItem, Exporters.Exporter exporter) { if (listItem.GetImporter().Import(exporter, CurrentPackage)) { sChanged = true; return true; } else { return false; } }
public override bool Import(Exporters.Exporter exporter, IPackage package) { throw new NotImplementedException(); }
/// <summary> /// Export the the data based off the exporter chosen. /// </summary> /// <param name="exporter">Exporter chosen.</param> private void Export(Exporters exporter) { // No project was selected if (_pm.IsProjectSelected) { IsExporting = true; string dir = _pm.SelectedProject.ProjectFolderPath + @"\"; string filename = ""; //string file = dir + filename; // Determine which exporter to use IExporterWriter writer = null; switch (exporter) { case Exporters.CSV: writer = new CsvExporterWriter(); filename = _pm.SelectedProject.ProjectName + "_export.csv"; break; case Exporters.Matlab: writer = new MatlabExporterWriter(); filename = _pm.SelectedProject.ProjectName; break; case Exporters.PD0: writer = new Pd0ExporterWriter(); filename = _pm.SelectedProject.ProjectName + "_export.pd0"; break; case Exporters.ENS: writer = new EnsExporterWriter(); filename = _pm.SelectedProject.ProjectName + "_export.ens"; break; default: break; } if (writer != null) { AdcpDatabaseReader dbReader = new AdcpDatabaseReader(); int size = dbReader.GetNumberOfEnsembles(_pm.SelectedProject); uint x = 0; try { // Display the busy indicator //IsBusyIndicator = true; // Create the directory if it does not exist if (!Directory.Exists(dir)) { Directory.CreateDirectory(dir); } // Open the file writer.Open(dir, filename, _Options); // Check the max value if (MaxEnsembleNumber > _pm.SelectedProject.GetNumberOfEnsembles()) { MaxEnsembleNumber = (uint)_pm.SelectedProject.GetNumberOfEnsembles(); } // Check the min value uint count = (MaxEnsembleNumber - MinEnsembleNumber) + 1; if (count < 0) { count = 0; } for (x = MinEnsembleNumber; x < count; x++) { // Get the data from the reader DataSet.Ensemble data = dbReader.GetEnsemble(_pm.SelectedProject, x); if (data != null) { // Vessel Mount Options VesselMountScreen(ref data); // Screen the data _screenDataVM.ScreenData(ref data, AdcpCodec.CodecEnum.Binary); // Verify go data if (data.IsEnsembleAvail && data.EnsembleData.EnsembleNumber != 0) { try { // Write the data to the file writer.Write(data); } catch (Exception e) { log.Error(string.Format("Error writing file {0} {1}", dir + filename, x), e); } } } } // Close the writer and save the latest options _Options = writer.Close(); //SaveDatabaseOptions(); // Remove the busy indicator IsExporting = false; } catch (IOException ex) { System.Windows.MessageBox.Show("Export file is open or check file permissions for the folder.\n" + string.Format("{0}", dir + filename), "Export IO Error", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Error); log.Error(string.Format("IO Error exporting file {0} {1}", dir + filename, x), ex); if (writer != null) { writer.Close(); IsExporting = false; } } catch (Exception e) { log.Error(string.Format("Error exporting file {0} {1}", dir + filename, x), e); if (writer != null) { writer.Close(); IsExporting = false; } } } } }
public abstract bool Import(Exporters.Exporter exporter, IPackage package);