public ReflectionController(ModuleDefinition module)
{
m_reader = new AggressiveReflectionReader (module);
m_writer = new ReflectionWriter (module);
m_helper = new ReflectionHelper (module);
m_importer = new DefaultImporter (module);
}
public FolderFileImporter(IImporter parent, string name) : base(parent, name)
{
foreach (var file in Directory.GetFiles(name))
{
Files.Add(CreateImporter(file));
}
}
public ImporterDataPresenter(IImporterDataView dataView, IImporter importer) : base(dataView)
{
_importer = importer;
_sheetsForViewing = new Cache <string, DataTable>();
ImportedSheets = new DataSheetCollection();
_currentSheetName = string.Empty;
}
public Import Import(string currentPath, Quoted path, IImporter importer, Value features, bool isOnce, NodeLocation location)
{
return(new Import(currentPath, path, importer, features, isOnce)
{
Location = location
});
}
/// <summary>
/// Imports a project item from a source file to this project.
/// </summary>
public ProjectItem Import(string fileName, IImporter importer)
{
var result = new ProjectItem(this, fileName, importer);
ProjectItems.Add(result);
return(result);
}
protected override void Context()
{
base.Context();
_dialogCreator = A.Fake <IDialogCreator>();
_importer = IoC.Container.Resolve <IImporter>();
_applicationController = A.Fake <ApplicationController>();
sut = new DataImporter(_dialogCreator, _importer, _applicationController, _dimensionFactory);
_importerConfiguration = new ImporterConfiguration {
FileName = "IntegrationSample1.xlsx", NamingConventions = "{Source}.{Sheet}.{Organ}.{Molecule}"
};
_importerConfiguration.AddToLoadedSheets("Sheet1");
_importerConfigurationMW = new ImporterConfiguration {
FileName = "IntegrationSample1.xlsx", NamingConventions = "{Source}.{Sheet}.{Organ}.{Molecule}"
};
_importerConfigurationMW.AddToLoadedSheets("Sheet1");
_metaDataCategories = (IReadOnlyList <MetaDataCategory>)sut.DefaultMetaDataCategoriesForObservedData();
_dataImporterSettings = new DataImporterSettings();
_dataImporterSettings.NameOfMetaDataHoldingMoleculeInformation = "Molecule";
_dataImporterSettings.NameOfMetaDataHoldingMolecularWeightInformation = "Molecular Weight";
_dataImporterSettings.IgnoreSheetNamesAtImport = true;
_dataImporterSettings.CheckMolWeightAgainstMolecule = false;
_columnInfos = getDefaultColumnInfos();
_metaDataCategories.First(md => md.Name == _dataImporterSettings.NameOfMetaDataHoldingMoleculeInformation).ListOfValues.Add("TestInputMolecule", "233");
}
public Record(IImporter importer, Int32 row)
{
AccountIn = importer["AccountIn", row];
AccountOut = importer["AccountOut", row];
Category = importer["Category", row];
Description = importer["Description", row];
Position = row;
DateTime date;
var dateIsValid = DateTime.TryParse(importer["Date", row], out date);
Date = date;
Double value;
var valueIsValid = Double.TryParse(importer["Value", row], out value);
Value = value;
var microRecordListIsValid = makeMicroRecords(importer, row);
Status = isValid(dateIsValid, valueIsValid, microRecordListIsValid)
? RecordStatus.Fail
: RecordStatus.OnSystem;
}
public JSONImportEmployees(IDbContext db, IDeserializer <IList <Employee> > deserializer, IImporter importer, IWriter writer)
{
this.db = db ?? throw new ArgumentNullException(nameof(db));
this.deserializer = deserializer ?? throw new ArgumentNullException(nameof(deserializer));
this.importer = importer ?? throw new ArgumentNullException(nameof(importer));
this.writer = writer ?? throw new ArgumentNullException(nameof(writer));
}
/// <summary>
/// Instantiates the given WebAssembly file. An importer is used to
/// resolve module imports and an interpreter is used to interpret
/// instructions.
/// </summary>
/// <param name="File">The file to instantiate.</param>
/// <param name="Importer">Resolves module imports.</param>
/// <param name="Interpreter">Interprets instructions.</param>
/// <returns>A module instance.</returns>
public static ModuleInstance Instantiate(
WasmFile File,
IImporter Importer,
InstructionInterpreter Interpreter)
{
var instance = new ModuleInstance(Interpreter);
// Extract the function types.
var allFuncTypes = GetFunctionTypes(File);
// Resolve all imports.
instance.ResolveImports(File, Importer, allFuncTypes);
// Instantiate global variables.
instance.InstantiateGlobals(File);
// Instantiate memories.
instance.InstantiateMemories(File);
// Instantiate function definitions.
instance.InstantiateFunctionDefs(File, allFuncTypes);
// Instantiate function tables.
instance.InstantiateTables(File);
// Export values.
instance.RegisterExports(File);
return(instance);
}
public CsvImportManager
(
IFileDownloadUtilities fileDownloadUtilities,
IZipUtility zipUtility,
IImporter <Cfda> cfdaImporter,
CsvImportSettings importSettings,
IImporter <General> generalImporter,
IImporter <Agency> agencyImporter,
IImporter <CapText> captextImporter,
IImporter <Cpa> cpaImporter,
IImporter <Dun> dunImporter,
IImporter <Ein> einImporter,
IImporter <Finding> findingImporter,
IImporter <FindingText> findingTextImporter,
IImporter <FormattedCapText> formattedCapTextImporter,
IImporter <FormattedFindingsText> formattedFindingsTextImporter,
IImporter <Passthrough> passthroughImporter
)
{
FileDownloadUtilities = fileDownloadUtilities;
ZipUtility = zipUtility;
CfdaImporter = cfdaImporter;
CsvImportSettings = importSettings;
GeneralImporter = generalImporter;
AgencyImporter = agencyImporter;
CapTextImporter = captextImporter;
CpaImporter = cpaImporter;
DunImporter = dunImporter;
EinImporter = einImporter;
FindingImporter = findingImporter;
FindingTextImporter = findingTextImporter;
FormattedCapTextImporter = formattedCapTextImporter;
FormattedFindingsTextImporter = formattedFindingsTextImporter;
PassthroughImporter = passthroughImporter;
}
public Url(Node value, IImporter importer)
{
Importer = importer;
ImportPaths = importer.GetCurrentPathsClone();
Value = value;
}
public NugetFileImporter(IImporter parent, string name) : base(parent, name)
{
Name = System.IO.Path.GetFileNameWithoutExtension(name) ?? Name;
try
{
_fileStream = Parent.Open(name);
{
_archive = new ZipArchive(_fileStream);
var contentPrefix = "Content/Data/";
foreach (var entry in _archive.Entries)
{
if (entry.FullName.StartsWith(contentPrefix, StringComparison.InvariantCultureIgnoreCase))
{
var shortName = entry.FullName.Substring(contentPrefix.Length);
_entries[shortName] = entry;
Files.Add(CreateImporter(shortName));
}
}
}
}
catch (Exception)
{
_fileStream?.Dispose();
throw;
}
}
private void btmImporta_Click(object sender, EventArgs e)
{
if (DialogResult.No == MessageBox.Show(string.Format("Verrà acquisito un nuovo template. " + Environment.NewLine + "Vuoi proseguire ?", ""), "Acquisizione File", MessageBoxButtons.YesNo, MessageBoxIcon.Question))
{
return;
}
try
{
string strFileName;
strFileName = FileService.CaricaFile("pdf", "PDF files (*.pdf)|*.pdf|All files (*.*)|*.*");
if (string.IsNullOrEmpty(strFileName))
{
return;
}
if (!File.Exists(strFileName))
{
throw new FileNotFoundException("Impossibile trovare il file nella posizione indicata.");
}
IImporter.ImportaTemplate(strFileName);
this.LoadTemplate();
}
catch (FileNotFoundException fex)
{
MessageBox.Show("Errore: " + fex.Message, "File inesistente", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
catch (Exception ex)
{
MessageBox.Show("Errore: " + ex.Message);
}
}
public void Add(IImporter importer)
{
if (importer == null)
throw new ArgumentNullException("importer");
base.Add(importer);
}
public Url(Node value, IImporter importer)
{
Importer = importer;
ImportPaths = importer.GetCurrentPathsClone();
Value = value;
}
private static void _Import <T>(IImporter <T> importer, string file, string typename)
{
IEnumerable <T> preprocessed_lines = importer.PreprocessInput(FileReader.ReadFile(file));
Parallel.ForEach(preprocessed_lines,
#if DEBUG
new ParallelOptions {
MaxDegreeOfParallelism = 1
},
#else
new ParallelOptions {
MaxDegreeOfParallelism = Environment.ProcessorCount * 2
},
#endif
line =>
{
try
{
importer.ImportEntity(typename, line, null);
}
catch (Exception e)
{
//Log.WriteLine(LogLevel.Error, "An error occured during import: \n{0}\n", e.Message);
}
});
}
private Boolean makeMicroRecords(IImporter importer, Int32 row)
{
MicroRecord microRecord;
var position = 0;
var isValid = true;
do
{
position++;
microRecord = new MicroRecord(importer, row, position);
if (!microRecord.IsEmpty)
{
break;
}
microRecord.RecordID = ID;
MicroRecordList.Add(microRecord);
isValid &= microRecord.IsValid;
} while (true);
return(isValid);
}
public Url Url(Node value, IImporter importer, int index)
{
return(new Url(value, importer)
{
Index = index
});
}
public Import Import(Quoted path, IImporter importer, Value features, int index)
{
return(new Import(path, importer, features)
{
Index = index
});
}
/// <summary>
/// Generic import method that shows the OpenFileDialog.
/// </summary>
/// <param name="animporter"></param>
private void importPresets(string caption, IImporter animporter)
{
OpenFileDialog nfile = new OpenFileDialog();
nfile.Filter = String.Format("{0}|{1}",
Functions.MEDIAFILES_FILTER_XML, Functions.MEDIAFILES_FILTER_ALL);
nfile.Title = caption;
try {
if (nfile.ShowDialog() == DialogResult.OK)
{
// Make a backup of the file...
if (Config.Settings.MakeBackupsXMLFiles)
{
Functions.CreateBackupFile(Config.Settings.LastUsedPresetFile);
}
animporter.LoadFile(nfile.FileName);
if (animporter.Presets.Count > 0)
{
int oldcount = this.presetdata.Presets.Count;
this.presetdata.AddPresets(animporter.Presets);
if (this.presetdata.Presets.Count > oldcount)
{
MessageBox.Show(String.Format("{0} files were imported...",
(this.presetdata.Presets.Count - oldcount)));
}
}
}
} finally {
nfile.Dispose();
}
}
public Import Import(Quoted path, IImporter importer, int index)
{
return(new Import(path, importer)
{
Index = index
});
}
public Url Url(Node value, IImporter importer, NodeLocation location)
{
return(new Url(value, importer)
{
Location = location
});
}
public Import Import(Quoted path, IImporter importer, Value features, bool isOnce, NodeLocation location)
{
return(new Import(path, importer, features, isOnce)
{
Location = location
});
}
internal static void CopyBuildImport(string importDirectory, IImporter importer)
{
OpenFileDialog openFileDialog = new OpenFileDialog();
if (openFileDialog.ShowDialog() == true)
{
if (Path.GetExtension(openFileDialog.FileName) == ".png")
{
var newFilePath = Path.Combine(importDirectory, Path.GetFileName(openFileDialog.FileName));
if (File.Exists(newFilePath))
{
"Cannot copy to directory, file already exists.".Log();
}
else
{
File.Copy(openFileDialog.FileName, newFilePath);
// We don't need to rebuild everything, only the .png we just imported.
ContentBuilder.BuildFile(newFilePath);
importer.Import(newFilePath);
}
}
else
{
"Incorrect file format".Log();
}
}
}
public virtual void Register(IImporter importer)
{
if (importer == null)
throw new ArgumentNullException("importer");
Importers.Put(importer);
}
private bool ParseImport(string filename)
{
IImporter importer = Importer.GetImporter(filename);
if (importer != null && importer.Open(filename))
{
mainTreeView.Nodes.Clear();
PlayerInfo[] players = importer.GetPlayers();
if (players != null && players.Length > 0)
{
TreeNode node = new TreeNode(Localizator.Dictionary.GetString("PLAYER_LIST"));
node.Tag = players;
mainTreeView.Nodes.Add(node);
}
TypeOfSport[] games = importer.GetTypesOfSport();
if (games != null && games.Length > 0)
{
TreeNode node = new TreeNode(Localizator.Dictionary.GetString("RATING_LISTS"));
node.Tag = games;
mainTreeView.Nodes.Add(node);
foreach (TypeOfSport sport in games)
{
TreeNode child = new TreeNode();
child.Text = sport.Name;
XmlExporter.RatingNode rating_node = new XmlExporter.RatingNode();
rating_node.Game = sport;
rating_node.Ratings.AddRange(importer.GetPlayersRatings(sport));
child.Tag = rating_node;
node.Nodes.Add(child);
}
}
Tournament[] tourns = importer.GetTournaments();
if (tourns != null && tourns.Length > 0)
{
TreeNode node = new TreeNode();
node.Text = Localizator.Dictionary.GetString("TOURNAMENTS");// "Турниры";
node.Tag = tourns;
mainTreeView.Nodes.Add(node);
CompetitionList comps = new CompetitionList();
foreach (Tournament tour in tourns)
{
TreeNode child = new TreeNode();
child.Text = String.Format("{0} - {1}", tour.Info.DateBegin.ToString("dd.MM.yyyy"), tour.Info.Name);
child.Tag = tour;
node.Nodes.Add(child);
foreach (Competition comp in tour.Competitions.Values)
{
TreeNode sub_child = new TreeNode();
sub_child.Text = comp.Info.Name;
sub_child.Tag = comp;
child.Nodes.Add(sub_child);
}
}
mainTreeView.ExpandAll();
}
return(true);
}
return(false);
}
private static void ImportFile(string file, CmdOptions options)
{
Log.WriteLine("Importing {0}", file);
string typename = Path.GetFileNameWithoutExtension(file);
IImporter importer = GetImporter(file, options);
if (importer == null)
{
Log.WriteLine("Unrecognized file type: {0}", typename);
return;
}
if (!importer.IgnoreType() && Global.StorageSchema.CellDescriptors.FirstOrDefault(cd => cd.TypeName == typename) == null)
{
Log.WriteLine("File {0} does not match any types defined in the storage extension.", file);
return;
}
var importer_type = importer.GetType();
var importer_interface_type = importer_type.FindInterfaces((t, _) =>
{
return(t.Name == "IImporter`1" && t.IsGenericType);
}, null).First();
var importer_entry_type = importer_interface_type.GetGenericArguments()[0];
var importer_method = typeof(Importer).GetMethod("_Import", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static).MakeGenericMethod(importer_entry_type);
importer_method.Invoke(null, new object[] { importer, file, typename });
}
} // = new ConcurrentDictionary<string, IConverter>();
public static ImportResults <T> Import <T>(string ImportType, string[] ImportParams = null)
{
IConverter IImporter;
if (ImportParams == null)
{
ImportParams = new string[] { };
}
if (File.Exists(ImportType))
{
var ImportList = ImportParams.ToList();
ImportList.Insert(0, ImportType);
ImportParams = ImportList.ToArray();
IImporter = Converter.FindByExtension(Path.GetExtension(ImportType).Replace(".", ""));
}
else
{
IImporter = Converter.Find(ImportType);
}
var Results = IImporter.Import <T>(ImportParams);
// foreach (var Result in Results.Results)
// {
// Result.App.SourceFilePath = Result.FileName;
// }
return(Results);
}
public virtual IImporter FindImporter(Type type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
IImporter importer = Importers[type];
if (importer != null)
{
return(importer);
}
importer = StockImporters[type];
if (importer == null)
{
importer = FindCompatibleImporter(type);
}
if (importer != null)
{
Register(importer);
return(importer);
}
return(null);
}
public CustomerGroupImporterWorker(
LogWriter logger,
ILogin login,
TaskSchedule task,
ApplicationControl appControl,
DataExpression expression)
: base(logger, login, task, appControl, expression)
{
var difinition = new CustomerGroupFileDefinition(expression);
difinition.GetCustomerDictionary = val
=> Screen.Util.ConvertToDictionary(Screen.Util.GetCustomerList(Login, val), x => x.Code);
difinition.GetDbCsutomerGroups = ()
=> Task.Run(async() => await Screen.Util.GetCustomerGroupListAsync(Login)).Result;
var importer = difinition.CreateImporter(x => new { x.ParentCustomerId, x.ChildCustomerId });
importer.UserId = Login.UserId;
importer.UserCode = Login.UserCode;
importer.CompanyId = Login.CompanyId;
importer.CompanyCode = Login.CompanyCode;
importer.LoadAsync = async() => await Screen.Util.GetCustomerGroupListAsync(Login);
importer.RegisterAsync = async unitOfWork => await Screen.Util.ImportCustomerGroupAsync(Login, unitOfWork);
importer.ErrorLogPath = logger.GetOutputPath();
Importer = importer;
}
public Parser(int optimization, IStylizer stylizer, IImporter importer, bool debug = false)
{
Stylizer = stylizer;
Importer = importer;
Debug = debug;
Tokenizer = new Tokenizer(optimization);
}
/// <summary>
/// Tries to create an importer for these options.
/// </summary>
/// <param name="Result">The importer.</param>
/// <returns><c>true</c> if <c>ImporterName</c> identifies an importer; otherwise, <c>false</c>.</returns>
public bool TryGetImporter(out IImporter Result)
{
if (ImporterName == null ||
ImporterName.Equals(SpectestImporterName, StringComparison.OrdinalIgnoreCase))
{
Result = new SpecTestImporter();
return(true);
}
else if (ImporterName.Equals(SpectestWithSpacesImporterName, StringComparison.OrdinalIgnoreCase))
{
Result = new SpecTestImporter(" ");
return(true);
}
else if (ImporterName.Equals(BaseRuntimeImporterName, StringComparison.OrdinalIgnoreCase))
{
var importer = new PredefinedImporter();
TerminalRuntime.IncludeDefinitionsIn(
Console.OpenStandardInput(),
Console.OpenStandardOutput(),
Console.OpenStandardError(),
importer);
Result = importer;
return(true);
}
else
{
Result = null;
return(false);
}
}
public override void GlobalContext()
{
base.GlobalContext();
_basicFormat = A.Fake <IDataFormat>();
_view = A.Fake <IColumnMappingView>();
_importer = A.Fake <IImporter>();
}
public Parser(int optimization, IStylizer stylizer, IImporter importer, bool debug)
{
Stylizer = stylizer;
Importer = importer;
Debug = debug;
Tokenizer = new Tokenizer(optimization);
}
public void Initialize(
IVhptUserControlFactory vhptUserControlFactory,
IEnumerable<VhptIdentification> vhpts,
IImporter importer)
{
this.InitializeJokeImport(importer);
this.InitializeVhpts(vhpts, vhptUserControlFactory);
}
public void Put(IImporter importer)
{
if (importer == null)
throw new ArgumentNullException("importer");
Remove(importer.OutputType);
Add(importer);
}
public Plugin(IXmlReader xmlReader, IImporter importer, IExporter exporter)
{
_xmlReader = xmlReader;
_importer = importer;
_exporter = exporter;
Name = "ISO Plugin";
Version = "0.1.1";
Owner = "AgGateway & Contributors";
}
public object ImportContent(Stream stream, string fileExt, IImporter importer = null)
{
if (importer == null)
{
importer = GetDefaultImporter(fileExt);
}
return importer.Import(stream);
}
private ImportAction GetImportAction(IImporter importer)
{
if (!_importAction.HasValue)
{
_importAction = importer.Import(this);
}
return _importAction.Value;
}
private Import(string path, IImporter importer, Value features)
{
if (path == null)
throw new ParserException("Imports do not allow expressions");
Importer = importer;
Path = path;
Features = features;
ImportAction = Importer.Import(this); // it is assumed to be css if it cannot be found as less
}
private void btnOpenFile_Click(object sender, EventArgs e)
{
_importer = new ExcelImporter();
_importer.NumberOfPeopleImported = s => lblTotalImported.BeginInvoke(new InvokeDelegate(() => lblTotalImported.Text = s));
lblTotalImported.BeginInvoke(new InvokeDelegate(() => lblTotalImported.Text = ""));
progressBar1.BeginInvoke(new InvokeDelegate(() => progressBar1.Style = ProgressBarStyle.Marquee));
openFileDialog1.ShowDialog();
}
public Url(Node value, IImporter importer)
{
if (value is TextNode)
{
var textValue = value as TextNode;
if (!Regex.IsMatch(textValue.Value, @"^(([a-zA-Z]+:)|(\/))"))
{
textValue.Value = importer.AlterUrl(textValue.Value);
}
}
Value = value;
}
public Url(Node value, IImporter importer)
{
if (value is TextNode)
{
var textValue = value as TextNode;
if (!Regex.IsMatch(textValue.Value, @"^(([a-zA-Z]+:)|(\/))") && importer.Paths.Any())
{
textValue.Value = importer.Paths.Concat(new[] { textValue.Value }).AggregatePaths(importer.CurrentDirectory);
}
}
Value = value;
}
private Import(string path, IImporter importer)
{
Importer = importer;
Path = path;
if (path.EndsWith(".css"))
{
Css = true;
} else
{
Css = !Importer.Import(this); // it is assumed to be css if it cannot be found as less
if (Css && path.EndsWith(".less"))
{
throw new ParsingException("Cannot find less file", Index);
}
}
}
private Import(string path, IImporter importer, Value features)
{
Importer = importer;
Path = path;
Features = features;
if (path.EndsWith(".css"))
{
Css = true;
} else
{
Css = !Importer.Import(this); // it is assumed to be css if it cannot be found as less
if (Css && path.EndsWith(".less"))
{
throw new FileNotFoundException("You are importing a file ending in .less that cannot be found.", path);
}
}
}
void select_SelectedIndexChanged(object sender, EventArgs e) {
ImporterItem item = (select.SelectedItem as ImporterItem);
if (item != null) {
if (importer != null) {
UnwireImporterEvents();
importer.Dispose();
}
IImporterUI<IBilingualDictionary> newUI = null;
if (item.Type.GetInterfaces().Contains(typeof(IDictionarySectionImporter))) {
var si = (IDictionarySectionImporter)item.Type.GetConstructor(new Type[] { }).Invoke(new object[] { });
var dsi = new DualSectionImporter();
newUI = new Controls.DictionarySectionUI(dsi, si);
importer = dsi;
} else if(item.Type.IsSubclassOf(typeof(IBilingualDictionary))) {
importer = (IImporter<IBilingualDictionary>)item.Type.GetConstructor(new Type[] { }).Invoke(new object[] { });
foreach (Type t in importer.GetType().Assembly.GetTypes()) {
var attr = Attribute.GetCustomAttribute(t, typeof(ImporterUIAttribute)) as ImporterUIAttribute;
if (attr != null) {
newUI = (IImporterUI<IBilingualDictionary>)Activator.CreateInstance(t, importer);
break;
}
}
}
WireImporterEvents();
if (newUI == null) {
CurrentUI = new Controls.ErrorUI("No UI for " + item.Name, "");
UnwireImporterEvents();
importer.Dispose();
importer = null;
return;
}
newUI.Finished += this.ImporterUIFinished;
CurrentUI = (Control)newUI;
}
}
private bool GetImportSettings(object ownerViewModel, IImporter importer, out object importSettingsViewModel)
{
importSettingsViewModel = importer.CreateImportSettingsViewModel();
if (importSettingsViewModel == null)
return true;
return _dialogService.ShowModalDialog(ownerViewModel, importSettingsViewModel) == true;
}
public Import(Quoted path, IImporter importer)
: this(path.Value, importer)
{
OriginalPath = path;
}
public Url Url(Node value, IImporter importer, NodeLocation location)
{
return new Url(value, importer) { Location = location };
}
public Import Import(Quoted path, IImporter importer, Value features, bool isOnce, NodeLocation location)
{
return new Import(path, importer, features, isOnce) { Location = location };
}
/// <summary>
/// This is constructor of Form1 instance.
/// </summary>
/// <param name="exporter"></param>
/// <param name="importer"></param>
public Form1(IExporter exporter, IImporter importer)
{
InitializeComponent();
this.exporter = exporter;
this.importer = importer;
}
public Import(Url path, IImporter importer)
: this(path.GetUrl(), importer)
{
OriginalPath = path;
}
public Url Url(Node value, IImporter importer, int index)
{
return new Url(value, importer) { Index = index };
}
public Parser(IStylizer stylizer, IImporter importer, bool debug)
: this(defaultOptimization, stylizer, importer, debug)
{
}
/// <summary>
/// Load the given file.
/// </summary>
/// <param name="file"></param>
public void Load(string file)
{
this._isLoadedFile = true;
this.LoadBlankContent();
this.NamespaceManager = TextDocumentHelper.NameSpace(this._xmldoc.NameTable);
ImportHandler importHandler = new ImportHandler();
m_importer = importHandler.GetFirstImporter(DocumentTypes.SpreadsheetDocument, file);
m_dirInfo = m_importer.DirInfo;
if (m_importer != null)
{
if (m_importer.NeedNewOpenDocument)
this.New();
m_importer.Import(this,file);
if (m_importer.ImportError != null)
if (m_importer.ImportError.Count > 0)
foreach(object ob in m_importer.ImportError)
if (ob is AODLWarning)
{
if (((AODLWarning)ob).Message != null)
Console.WriteLine("Err: {0}", ((AODLWarning)ob).Message);
if (((AODLWarning)ob).Node != null)
{
XmlTextWriter writer = new XmlTextWriter(Console.Out);
writer.Formatting = Formatting.Indented;
((AODLWarning)ob).Node.WriteContentTo(writer);
}
}
}
}
private bool Import(IImporter importer, object ownerViewModel, string fileName, Action<object, Stream> importAction)
{
object importSettingsViewModel;
if (GetImportSettings(ownerViewModel, importer, out importSettingsViewModel))
{
_busyService.ShowBusyIndicatorUntilFinishDrawing();
try
{
using (var stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete))
importAction(importSettingsViewModel, stream);
return true;
}
catch (IOException ioe)
{
_dialogService.ShowError(ownerViewModel, string.Format("Error importing file:\n{0}", ioe.Message), "Cog");
}
catch (ImportException ie)
{
_dialogService.ShowError(ownerViewModel, string.Format("Error importing file:\n{0}", ie.Message), "Cog");
}
}
return false;
}
public Parser(int optimization, IStylizer stylizer, IImporter importer)
: this(optimization, stylizer, importer, defaultDebug)
{
}
/// <summary>
/// Loads the document by using the specified importer.
/// </summary>
/// <param name="file">The the file.</param>
public void Load(string file)
{
this._isLoadedFile = true;
this.Styles = new StyleCollection();
this._fields = new FieldsCollection();
this.Content = new ContentCollection();
this._xmldoc = new XmlDocument();
this._xmldoc.LoadXml(TextDocumentHelper.GetBlankDocument());
this.NamespaceManager = TextDocumentHelper.NameSpace(this._xmldoc.NameTable);
ImportHandler importHandler = new ImportHandler();
m_importer = importHandler.GetFirstImporter(DocumentTypes.TextDocument, file);
m_dirInfo = m_importer.DirInfo;
if (m_importer != null)
{
if (m_importer.NeedNewOpenDocument)
this.New();
m_importer.Import(this,file);
if (m_importer.ImportError != null)
if (m_importer.ImportError.Count > 0)
foreach(object ob in m_importer.ImportError)
if (ob is AODLWarning)
{
if (((AODLWarning)ob).Message != null)
Console.WriteLine("Err: {0}", ((AODLWarning)ob).Message);
if (((AODLWarning)ob).Node != null)
{
XmlTextWriter writer = new XmlTextWriter(Console.Out);
writer.Formatting = Formatting.Indented;
((AODLWarning)ob).Node.WriteContentTo(writer);
}
}
}
this._formCollection.Clearing += FormsCollection_Clear;
this._formCollection.Removed += FormsCollection_Removed;
}
public Import Import(Quoted path, IImporter importer, Value features, int index)
{
return new Import(path, importer, features) { Index = index };
}
public Import Import(Quoted path, IImporter importer, int index)
{
return new Import(path, importer) { Index = index };
}
