/// <summary>
/// Get sheet info from the imported spreadsheet.
/// </summary>
/// <param name="fileUploadId">File upload Id.</param>
/// <param name="sheetId">Selected sheet info.</param>
/// <param name="headerRowNo">Header row no.</param>
/// <param name="dataRowNo">Data row number to start reading data.</param>
/// <param name="lastRowNo">Optional last row number to read.</param>
/// <param name="fileFormat">Imported file fileFormat ( Excel or CSV)</param>
/// <returns>
/// Sheet Info.
/// </returns>
public SampleTable GetSampleTable(string fileUploadId, ImportFormat fileFormat, string sheetId, int headerRowNo, int dataRowNo, int?lastRowNo)
{
// Get service
IDataFileReaderService service = _readerActivator(fileFormat);
// Settings
DataFileReaderSettings settings = new DataFileReaderSettings
{
ImportFormat = fileFormat,
HeadingRowNumber = headerRowNo,
FirstDataRowNumber = dataRowNo,
LastDataRowNumber = lastRowNo,
SheetId = sheetId
};
// Open stream
using (Stream stream = FileRepositoryHelper.GetTemporaryFileDataStream(fileUploadId))
{
// Build sample
SampleDataCreator creator = new SampleDataCreator( );
SampleTable sampleTable = creator.CreateSample(stream, settings, service);
// Trim titles
foreach (var col in sampleTable.Columns)
{
col.Name = col.Name?.Trim( ) ?? "";
}
return(sampleTable);
}
}
/// <summary>
/// Get the format to import
/// </summary>
/// <param name="selectedFormat">Selected format in format selecting dialog</param>
/// <returns>The format to import</returns>
private static ImportFormat GetSelectedImportFormat(string selectedFormat)
{
ImportFormat format = ImportFormat.DWG;
switch (selectedFormat)
{
case "DWG":
format = ImportFormat.DWG;
break;
case "IMAGE":
format = ImportFormat.IMAGE;
break;
case "GBXML":
format = ImportFormat.GBXML;
break;
case "Inventor":
format = ImportFormat.Inventor;
break;
default:
break;
}
return(format);
}
public ImportFormat GetImportFormat(int inputFormatID)
{
DataRow[] Fmt = ImportFormatDT.Select("ID = " + inputFormatID);
DataRow fmtDr = Fmt[0];
ImportFormat iFmt = new ImportFormat();
iFmt.lineDelimiter = DB.RowField(fmtDr, "lineDelim");
iFmt.valueDelimiter = DB.RowField(fmtDr, "valueDelim");
iFmt.textDelimiter = DB.RowField(fmtDr, "textDelim");
string FmtType = DB.RowField(fmtDr, "type");
if (FmtType.Equals("named", StringComparison.InvariantCultureIgnoreCase))
{
iFmt.delimiterNamed = true;
iFmt.FirstLine = 1;
}
else
{
iFmt.delimiterNamed = false;
iFmt.FirstLine = 0;
}
string Format = DB.RowField(fmtDr, "format");
if (Format.Equals("delimited", StringComparison.InvariantCultureIgnoreCase))
{
iFmt.FileFormat = ImportFormat.FileFormatEnum.Delimited;
}
else if (Format.Equals("flat", StringComparison.InvariantCultureIgnoreCase))
{
iFmt.FileFormat = ImportFormat.FileFormatEnum.FlatFile;
}
DataRow[] formatColumns = fmtDr.GetChildRows("ImportFormat_Column");
int fmtCount = formatColumns.Length; // - 1;
// TODO: NotImplemented statement: ICSharpCode.SharpRefactory.Parser.AST.VB.ReDimStatement
iFmt.fmtCols = new formatColumn[fmtCount];
for (int z = 0; z <= fmtCount - 1; z++)
{
DataRow iFmtRow = formatColumns[z];
formatColumn iFmtC = new formatColumn();
iFmtC.ColumnName = DB.RowField(iFmtRow, "OrderCol");
iFmtC.refColumnName = DB.RowField(iFmtRow, "LogCol");
int ColNum = -1;
if (DB.RowField(iFmtRow, "ColNum") != "")
{
ColNum = DB.RowFieldInt(iFmtRow, "ColNum");
}
iFmtC.ColumnNumber = ColNum; //iFmtC.ColumnNumber = DB.RowFieldInt(iFmtRow, "ColNum");
iFmtC.Enabled = DB.RowFieldBool(iFmtRow, "enabled");
iFmtC.Type = DB.RowField(iFmtRow, "type");
iFmtC.Format = DB.RowField(iFmtRow, "format");
iFmtC.StartPos = DB.RowFieldInt(iFmtRow, "spos");
iFmtC.EndPos = DB.RowFieldInt(iFmtRow, "epos");
iFmt.fmtCols[z] = iFmtC;
}
return(iFmt);
}
public static ImportRun RunTest(EntityType entityType, string fileName, ImportFormat importFormat, string sheetName = null)
{
string fileToken;
using (Stream stream = SheetTestHelper.GetStream(fileName))
{
fileToken = FileRepositoryHelper.AddTemporaryFile(stream);
}
EntityType type = entityType;
ImportConfig importConfig = CreateImportConfig(type, importFormat, sheetName);
ImportRun importRun = CreateImportRun(importConfig, fileToken);
ISpreadsheetInspector inspector = Factory.Current.Resolve <ISpreadsheetInspector>( );
SpreadsheetInfo info = inspector.GetSpreadsheetInfo(fileToken, importFormat);
SampleTable sample = inspector.GetSampleTable(fileToken, importFormat, sheetName, 1, 2, null);
AddAllFields(importConfig, sample);
// Run import
IImportRunWorker worker = Factory.Current.Resolve <IImportRunWorker>( );
worker.StartImport(importRun.Id);
return(importRun);
}
/// <summary>
/// Get spreadsheet Information from the imported file.
/// </summary>
/// <param name="fileUploadId">
/// File upload Id.
/// </param>
/// <param name="fileFormat">
/// Imported file fileFormat ( Excel or CSV)
/// </param>
/// <returns>Spreadsheet info
/// </returns>
public SpreadsheetInfo GetSpreadsheetInfo(string fileUploadId, ImportFormat fileFormat)
{
// Get service
IDataFileReaderService service = _readerActivator(fileFormat);
// Load info about sheets
IReadOnlyList <SheetInfo> sheets;
using (Stream stream = FileRepositoryHelper.GetTemporaryFileDataStream(fileUploadId))
{
// Settings
DataFileReaderSettings settings = new DataFileReaderSettings
{
ImportFormat = fileFormat
};
IDataFile dataFile = service.OpenDataFile(stream, settings);
sheets = dataFile.GetSheets( );
}
var spreadsheetInfo = new SpreadsheetInfo
{
ImportFileFormat = fileFormat,
SheetCollection = sheets
};
return(spreadsheetInfo);
}
/// <summary>
/// Imports songs from other systems
/// </summary>
/// <param name="settings"></param>
/// <param name="importFormat">Import type</param>
public SongImporter(Settings settings, ImportFormat importFormat)
{
_settings = settings;
_format = importFormat;
OpenInEditor = new List <string>();
InitializeComponent();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="commandData">Revit command data</param>
/// <param name="importFormat">Format to import</param>
public ImportData(ExternalCommandData commandData, ImportFormat importFormat)
{
m_commandData = commandData;
m_activeDoc = commandData.Application.ActiveUIDocument.Document;
m_importFormat = importFormat;
m_filter = String.Empty;
Initialize();
}
void OnGUI()
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.HelpBox("Import voxel models from other applications.", MessageType.Info);
EditorGUILayout.EndHorizontal();
EditorGUILayout.Separator();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Format", GUILayout.Width(120));
importFormat = (ImportFormat)EditorGUILayout.EnumPopup(importFormat);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("File name", GUILayout.Width(120));
importFilename = EditorGUILayout.TextField(importFilename);
if (GUILayout.Button("Open...", GUILayout.Width(80)))
{
importFilename = EditorUtility.OpenFilePanel("Select model File (*.qb)", "", "qb");
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent("Color-Voxel Map", "Optional color to voxel mapping."), GUILayout.Width(120));
mapping = (ColorToVoxelMap)EditorGUILayout.ObjectField(mapping, typeof(ColorToVoxelMap), false);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent("Ignore Offset", "Model can specify an offset for the center."), GUILayout.Width(120));
importIgnoreOffset = EditorGUILayout.Toggle(importIgnoreOffset);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent("Scale", "Scale applied to the model."), GUILayout.Width(120));
scale = EditorGUILayout.Vector3Field("", scale);
EditorGUILayout.EndHorizontal();
EditorGUILayout.Separator();
GUI.enabled = !string.IsNullOrEmpty(importFilename);
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("Generate ColorMap Asset"))
{
GenerateColorMapAsset();
GUIUtility.ExitGUI();
}
if (GUILayout.Button("Generate Model Asset"))
{
GenerateModelAsset();
GUIUtility.ExitGUI();
}
if (GUILayout.Button("Generate Prefab"))
{
GeneratePrefab();
GUIUtility.ExitGUI();
}
GUI.enabled = false;
EditorGUILayout.EndHorizontal();
}
private static IDataFileReaderService ResolveDataReader(IComponentContext context, ImportFormat importFormat)
{
ImportFormat baseFormat = importFormat & ~ImportFormat.Zip;
var res = context.ResolveKeyed <IDataFileReaderService>(baseFormat);
if ((importFormat & ImportFormat.Zip) == ImportFormat.Zip)
{
res = new ZipFileReaderService(res);
}
return(res);
}
/// <summary>
/// 创建导入器
/// </summary>
/// <param name="format">导入格式</param>
/// <returns></returns>
public IImport Create(ImportFormat format)
{
switch (format)
{
case ImportFormat.Xlsx:
return(CreateExcel2007Import(_path, _sheetName));
case ImportFormat.Xls:
return(CreateExcel2003Import(_path, _sheetName));
}
throw new NotImplementedException();
}
private DataTable ImportFlatFile(string FileContents, ImportFormat iFmt)
{
string[] fileLines = FileContents.Split(iFmt.lineDelimiter.ToCharArray());
DataTable tmpDt = iFmt.CreateTempTable();
for (int line = iFmt.FirstLine; line <= fileLines.Length - 1; line++)
{
DataRow nr = tmpDt.NewRow();
foreach (formatColumn fc in iFmt.fmtCols)
{
if (fc.Enabled)
{
string value = fileLines[line].Substring(fc.StartPos, fc.EndPos);
if (fc.Type.Equals("date", StringComparison.InvariantCultureIgnoreCase) ||
fc.Type.Equals("datetime", StringComparison.InvariantCultureIgnoreCase))
{
nr[fc.ColumnName] = txtFieldDate(value, fc.Format);
}
else if (fc.Type.Equals("string", StringComparison.InvariantCultureIgnoreCase) ||
fc.Type.Equals("str", StringComparison.InvariantCultureIgnoreCase))
{
nr[fc.ColumnName] = value;
}
else if (fc.Type.Equals("double", StringComparison.InvariantCultureIgnoreCase) ||
fc.Type.Equals("single", StringComparison.InvariantCultureIgnoreCase))
{
nr[fc.ColumnName] = txtFieldDouble(value);
}
else if (fc.Type.Equals("int", StringComparison.InvariantCultureIgnoreCase) ||
fc.Type.Equals("integer", StringComparison.InvariantCultureIgnoreCase) ||
fc.Type.Equals("long", StringComparison.InvariantCultureIgnoreCase) ||
fc.Type.Equals("short", StringComparison.InvariantCultureIgnoreCase))
{
nr[fc.ColumnName] = txtFieldInt(value);
}
else if (fc.Type.Equals("bool", StringComparison.InvariantCultureIgnoreCase) ||
fc.Type.Equals("boolean", StringComparison.InvariantCultureIgnoreCase) ||
fc.Type.Equals("bit", StringComparison.InvariantCultureIgnoreCase))
{
nr[fc.ColumnName] = txtFieldBool(value, fc.Format);
}
else
{
nr[fc.ColumnName] = value;
}
}
}
tmpDt.Rows.Add(nr);
}
return(tmpDt);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="commandData">Revit command data</param>
/// <param name="importFormat">Format to import</param>
public ImportImageData(ExternalCommandData commandData, ImportFormat importFormat)
: base(commandData, importFormat)
{
if (OptionalFunctionalityUtils.IsPDFImportAvailable())
{
m_filter = "All Image Files (*.bmp, *.gif, *.jpg, *.jpeg, *.pdf, *.png, *.tif)|*.bmp;*.gif;*.jpg;*.jpeg;*.pdf;*.png;*.tif";
}
else
{
m_filter = "All Image Files (*.bmp, *.gif, *.jpg, *.jpeg, *.png, *.tif)|*.bmp;*.gif;*.jpg;*.jpeg;*.png;*.tif";
}
m_title = "Import Image";
}
private static ImportConfig CreateImportConfig(EntityType entityType, ImportFormat importFormat, string sheetId)
{
ApiResourceMapping resourceMapping = new ApiResourceMapping( );
resourceMapping.MappedType = entityType;
resourceMapping.MappingSourceReference = sheetId;
resourceMapping.ImportHeadingRow = 1;
resourceMapping.ImportDataRow = 2;
ImportConfig importConfig = new ImportConfig( );
importConfig.ImportConfigMapping = resourceMapping;
importConfig.ImportFileType_Enum = importFormat == ImportFormat.CSV ? ImportFileTypeEnum_Enumeration.ImportFileTypeCsv : ImportFileTypeEnum_Enumeration.ImportFileTypeExcel;
return(importConfig);
}
public static string OpenImportDialog(ImportFormat format)
{
string filter;
switch (format)
{
case ImportFormat.RB1:
filter = "RB1 File (*.txt)\0*.txt\0\0";
break;
default:
return(null);
}
return(Dialogs.ShowFileDialog("Import data", filter, lastDirPath, false));
}
public DataTable ImportFile(string FileName, int ImportFormatID)
{
string FileContents = GetFileContents(FileName);
DataTable tmpDt = null;
ImportFormat ifmt = GetImportFormat(ImportFormatID);
if (ifmt.FileFormat == ImportFormat.FileFormatEnum.Delimited)
{
tmpDt = ImportDelimitedFile(FileContents, ifmt);
}
else if (ifmt.FileFormat == ImportFormat.FileFormatEnum.FlatFile)
{
}
return(tmpDt);
}
/// <summary>
/// Get reader settings from the config entity.
/// </summary>
/// <param name="importConfig">The import config entity.</param>
/// <returns>Reader settings</returns>
private static DataFileReaderSettings CreateReaderSettings(ImportConfig importConfig)
{
ImportFormat importFormat = ImportHelpers.GetImportFormat(importConfig);
ApiResourceMapping mapping = importConfig.ImportConfigMapping;
DataFileReaderSettings settings = new DataFileReaderSettings
{
ImportFormat = importFormat,
HeadingRowNumber = mapping.ImportHeadingRow ?? 1,
FirstDataRowNumber = mapping.ImportDataRow ?? 2,
LastDataRowNumber = mapping.ImportLastDataRow, // default is null
SheetId = mapping.MappingSourceReference
};
return(settings);
}
private string ImportFormatToString(ImportFormat importFormat)
{
switch (importFormat)
{
case ImportFormat.LIBGEN_NONFICTION:
return("libgen-nonfiction");
case ImportFormat.LIBGEN_FICTION:
return("libgen-fiction");
case ImportFormat.LIBGEN_SCIMAG:
return("libgen-scimag");
default:
return(null);
}
}
/// <summary>
/// Export according to selected format
/// </summary>
/// <param name="selectedFormat">Selected format</param>
/// <returns></returns>
public DialogResult Import(string selectedFormat)
{
DialogResult dialogResult = DialogResult.OK;
ImportFormat format = GetSelectedImportFormat(selectedFormat);
try
{
switch (format)
{
case ImportFormat.DWG:
ImportDWGData importDWGData = new ImportDWGData(m_commandData, format);
using (ImportDWGForm importForm = new ImportDWGForm(importDWGData))
{
dialogResult = importForm.ShowDialog();
}
break;
case ImportFormat.IMAGE:
ImportImageData importIMAGEData = new ImportImageData(m_commandData, format);
dialogResult = Import(importIMAGEData);
break;
case ImportFormat.GBXML:
ImportGBXMLData importGBXMLData = new ImportGBXMLData(m_commandData, format);
dialogResult = Import(importGBXMLData);
break;
case ImportFormat.Inventor:
ImportInventorData importInventorData = new ImportInventorData(m_commandData, format);
dialogResult = Import(importInventorData);
break;
default:
break;
}
}
catch (Exception)
{
String errorMessage = "Failed to import " + format + " format";
TaskDialog.Show("Error", errorMessage, TaskDialogCommonButtons.Ok);
}
return(dialogResult);
}
public override IQueryResult Execute(IGraphDB myGraphDB,
IGraphQL myGraphQL,
GQLPluginManager myPluginManager,
String myQuery,
SecurityToken mySecurityToken,
Int64 myTransactionToken)
{
var sw = Stopwatch.StartNew();
IEnumerable <IVertexView> result = null;
var plugin = myPluginManager.GetAndInitializePlugin <IGraphDBImport>(ImportFormat.ToUpper());
if (plugin != null)
{
try
{
result = plugin.Import(SourceLocation,
myGraphDB,
myGraphQL,
mySecurityToken,
myTransactionToken,
ParallelTasks,
Comments,
Offset,
Limit,
VerbosityType,
Options);
return(QueryResult.Success(myQuery, SonesGQLConstants.GQL, result, (ulong)sw.ElapsedMilliseconds));
}
catch (ASonesException ex)
{
return(QueryResult.Failure(myQuery, SonesGQLConstants.GQL, ex, result, (ulong)sw.ElapsedMilliseconds));
}
catch (Exception ex)
{
return(QueryResult.Failure(myQuery, SonesGQLConstants.GQL, new UnknownException(ex), result, (ulong)sw.ElapsedMilliseconds));
}
}
return(QueryResult.Failure(myQuery, ImportFormat, new ImportFormatDoesNotExistsException(ImportFormat)));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="csvStream">The sheet to read.</param>
/// <param name="settings">Processing settings.</param>
internal CsvFileReader(Stream csvStream, DataFileReaderSettings settings)
{
if (csvStream == null)
{
throw new ArgumentNullException("csvStream");
}
if (settings == null)
{
throw new ArgumentNullException("settings");
}
// Strip zip flag (or others)
_importFormat = settings.ImportFormat & (ImportFormat.CSV | ImportFormat.Tab);
if (_importFormat != ImportFormat.CSV && settings.ImportFormat != ImportFormat.Tab)
{
throw new ArgumentException("settings");
}
_csvStream = csvStream;
_settings = settings;
OpenCsvFile( );
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="commandData">Revit command data</param>
/// <param name="format">Format to import</param>
public ImportDWGData(ExternalCommandData commandData, ImportFormat format)
: base(commandData, format)
{
Initialize();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="commandData">Revit command data</param>
/// <param name="importFormat">Format to import</param>
public ImportData(ExternalCommandData commandData, ImportFormat importFormat)
{
m_commandData = commandData;
m_activeDoc = commandData.Application.ActiveUIDocument.Document;
m_importFormat = importFormat;
m_filter = String.Empty;
Initialize();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="commandData">Revit command data</param>
/// <param name="importFormat">Format to import</param>
public ImportImageData(ExternalCommandData commandData, ImportFormat importFormat)
: base(commandData, importFormat)
{
m_filter = "All Image Files (*.bmp, *.gif, *.jpg, *.jpeg, *.png, *.tif)|*.bmp;*.gif;*.jpg;*.jpeg;*.png;*.tif";
m_title = "Import Image";
}
private DataTable ImportDelimitedFile(string FileContents, ImportFormat iFmt)
{
string[] fileLines = FileContents.Split(iFmt.lineDelimiter.ToCharArray());
DataTable tmpDt = iFmt.CreateTempTable();
string[] columnHeader = fileLines[0].Split(iFmt.valueDelimiter.ToCharArray());
if (iFmt.delimiterNamed)
{
for (int columnNumber = 0; columnNumber <= columnHeader.Length - 1; columnNumber++)
{
string columnName = columnHeader[columnNumber];
foreach (formatColumn r in iFmt.fmtCols)
{
if (columnName == r.refColumnName)
{
r.ColumnNumber = columnNumber;
}
}
}
}
//validate
foreach (formatColumn r in iFmt.fmtCols)
{
if (r.Enabled && (r.ColumnNumber < 0))
{
//if any enabled rows dont have a colnum, then the import cant continue
throw(new Exception("Not all required columns found in header... (" + r.ColumnName + ")"));
}
}
for (int line = iFmt.FirstLine; line <= fileLines.Length - 1; line++)
{
string[] Values = fileLines[line].Split(iFmt.valueDelimiter.ToCharArray());
DataRow nr = tmpDt.NewRow();
foreach (formatColumn fc in iFmt.fmtCols)
{
if (fc.ColumnNumber < Values.Length)
{
string value = Values[fc.ColumnNumber];
if (iFmt.textDelimiter.Length > 0)
{
value = value.Replace(iFmt.textDelimiter, "");
}
if (fc.Type.Equals("date", StringComparison.InvariantCultureIgnoreCase) ||
fc.Type.Equals("datetime", StringComparison.InvariantCultureIgnoreCase))
{
nr[fc.ColumnName] = txtFieldDate(value, fc.Format);
}
else if (fc.Type.Equals("string", StringComparison.InvariantCultureIgnoreCase) ||
fc.Type.Equals("str", StringComparison.InvariantCultureIgnoreCase))
{
nr[fc.ColumnName] = value;
}
else if (fc.Type.Equals("double", StringComparison.InvariantCultureIgnoreCase) ||
fc.Type.Equals("single", StringComparison.InvariantCultureIgnoreCase))
{
nr[fc.ColumnName] = txtFieldDouble(value);
}
else if (fc.Type.Equals("int", StringComparison.InvariantCultureIgnoreCase) ||
fc.Type.Equals("integer", StringComparison.InvariantCultureIgnoreCase) ||
fc.Type.Equals("long", StringComparison.InvariantCultureIgnoreCase) ||
fc.Type.Equals("short", StringComparison.InvariantCultureIgnoreCase))
{
nr[fc.ColumnName] = txtFieldInt(value);
}
else if (fc.Type.Equals("bool", StringComparison.InvariantCultureIgnoreCase) ||
fc.Type.Equals("boolean", StringComparison.InvariantCultureIgnoreCase) ||
fc.Type.Equals("bit", StringComparison.InvariantCultureIgnoreCase))
{
nr[fc.ColumnName] = txtFieldBool(value, fc.Format);
}
else
{
nr[fc.ColumnName] = value;
}
}
}
if (Values.Length == columnHeader.Length)
{
tmpDt.Rows.Add(nr);
}
}
return(tmpDt);
}
public ImportResult(ImportFormat importFormat, string importFilePath)
{
this.importFormat = importFormat;
this.importFilePath = importFilePath;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="commandData">Revit command data</param>
/// <param name="format">Format to import</param>
public ImportDWGData(ExternalCommandData commandData, ImportFormat format)
: base(commandData, format)
{
Initialize();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="commandData">Revit command data</param>
/// <param name="importFormat">Format to import</param>
public ImportGBXMLData(ExternalCommandData commandData, ImportFormat importFormat)
: base(commandData, importFormat)
{
m_filter = "XML Documents (*.xml)|*.xml";
m_title = "Import GBXML";
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="commandData">Revit command data</param>
/// <param name="importFormat">Format to import</param>
public ImportGBXMLData(ExternalCommandData commandData, ImportFormat importFormat)
: base(commandData, importFormat)
{
m_filter = "XML Documents (*.xml)|*.xml";
m_title = "Import GBXML";
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="commandData">Revit command data</param>
/// <param name="importFormat">Format to import</param>
public ImportInventorData(ExternalCommandData commandData, ImportFormat importFormat)
: base(commandData, importFormat)
{
m_filter = "Autodesk Exchange Files (*.adsk)|*.adsk";
m_title = "Import Inventor File";
}
public ImportOperations(ImportFormat importFormat, string importFilePath)
{
this.importFormat = importFormat;
this.importFilePath = importFilePath;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="commandData">Revit command data</param>
/// <param name="importFormat">Format to import</param>
public ImportImageData(ExternalCommandData commandData, ImportFormat importFormat)
: base(commandData, importFormat)
{
m_filter = "All Image Files (*.bmp, *.gif, *.jpg, *.jpeg, *.png, *.tif)|*.bmp;*.gif;*.jpg;*.jpeg;*.png;*.tif";
m_title = "Import Image";
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="commandData">Revit command data</param>
/// <param name="importFormat">Format to import</param>
public ImportInventorData(ExternalCommandData commandData, ImportFormat importFormat)
: base(commandData, importFormat)
{
m_filter = "Autodesk Exchange Files (*.adsk)|*.adsk";
m_title = "Import Inventor File";
}
