/// <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);
