public static void InitializeSapModel(ref SapObject mySAPObject, ref cSapModel mySapModel, string units)
{
long ret = 0;
//TO DO: Grab open Instance if already open!!!
//Create SAP2000 Object
mySAPObject = new SAP2000v20.SapObject();
// get enum from Units
eUnits Units = (eUnits)Enum.Parse(typeof(eUnits), units);
//Start Application
mySAPObject.ApplicationStart(Units, true);
//Create SapModel object
mySapModel = mySAPObject.SapModel;
//initialize the model
ret = mySapModel.InitializeNewModel(Units);
//create new blank model
ret = mySapModel.File.NewBlank();
//SET UP ... SET UP ... SET UP ... SET UP
DefineMaterials(ref mySapModel);
}
/// <summary>
/// Initialization Method - reads all constants from Configuration file
/// </summary>
/// <param name="units">Desired units to work in [default is Points]</param>
/// <param name="xMaxBorder">X Max Limit for Ricochet Calculations</param>
/// <param name="yMaxBorder">Y Max Limit for Ricochet Calculations</param>
/// <param name="ricochetFactor">Ricochet Factor to use in calculations</param>
public void InitializeRicochetCalc(eUnits units = eUnits.Pts, double xMaxBorder = -1, double yMaxBorder = -1, double ricochetFactor = -1)
{
if (!IsInitialized)
{
_xMinBorder = 0;
_yMinBorder = 0;
_ricocheFactor = (ricochetFactor > 0) ? ricochetFactor
: Configuration.Attributes.GetValue <double>(Configuration.Names.KEY_RICOCHET_FACTOR);
switch (units)
{
case eUnits.Mm:
_xMaxBorder = (xMaxBorder > 0) ? xMaxBorder
: Configuration.Attributes.GetValue <double>(Configuration.Names.TABLE_WIDTH);
_yMaxBorder = (yMaxBorder > 0) ? yMaxBorder
: Configuration.Attributes.GetValue <double>(Configuration.Names.TABLE_HEIGHT);
break;
case eUnits.Pts:
_xMaxBorder = (xMaxBorder > 0) ? xMaxBorder
: Configuration.Attributes.GetValue <double>(Configuration.Names.FOOSBOT_AXE_X_SIZE);
_yMaxBorder = (yMaxBorder > 0) ? yMaxBorder
: Configuration.Attributes.GetValue <double>(Configuration.Names.FOOSBOT_AXE_Y_SIZE);
break;
default:
throw new NotSupportedException(String.Format(
"[{0}] Units [{1}] are not supported by RicochetCalc.",
MethodBase.GetCurrentMethod().Name, units.ToString()));
}
IsInitialized = true;
}
}
/// <summary>
/// This function starts the application.
/// When the model is not visible it does not appear on screen and it does not appear in the Windows task bar.
/// If no filename is specified, you can later open a model or create a model through the API.
/// The file name must have an .sdb, .$2k, .s2k, .xls, or .mdb extension.
/// Files with .sdb extensions are opened as standard SAP2000 files.
/// Files with .$2k and .s2k extensions are imported as text files.
/// Files with .xls extensions are imported as Microsoft Excel files.
/// Files with .mdb extensions are imported as Microsoft Access files.
/// </summary>
/// <param name="units">The database units used when a new model is created.
/// Data is internally stored in the program in the database units.</param>
/// <param name="visible">True: The application is visible when started.
/// False: The application is hidden when started.</param>
/// <param name="modelPath">The full path of a model file to be opened when the application is started.
/// If no file name is specified, the application starts without loading an existing model.</param>
/// <exception cref="CSiException">API_DEFAULT_ERROR_CODE</exception>
private void applicationStart(eUnits units = eUnits.kip_in_F,
bool visible = true,
string modelPath = "")
{
#if BUILD_ETABS2015 || BUILD_ETABS2016 || BUILD_ETABS2017
_callCode = _sapObject.ApplicationStart();
if (_seed == null)
{
return;
}
Model.InitializeNewModel(units);
if (!string.IsNullOrWhiteSpace(modelPath))
{
Model.File.Open(modelPath);
}
if (!visible)
{
Hide();
}
#else
_callCode = _sapObject.ApplicationStart(EnumLibrary.Convert <eUnits, CSiProgram.eUnits>(units), visible, modelPath);
#endif
if (throwCurrentApiException(_callCode))
{
throw new CSiException(API_DEFAULT_ERROR_CODE);
}
}
/// <summary>
/// Performs the application-specific steps of initializing the default installed program.
/// This initializes SapObject and SapModel.
/// </summary>
/// <param name="units">The database units used when a new model is created.
/// Data is internally stored in the program in the database units.</param>
/// <param name="visible">True: The application is visible when started.
/// False: The application is hidden when started.</param>
/// <param name="modelPath">The full path of a model file to be opened when the application is started.
/// If no file name is specified, the application starts without loading an existing model.</param>
/// <returns><c>true</c> if program is successfully initialized, <c>false</c> otherwise.</returns>
private bool initializeProgramFromLatestInstallation(eUnits units = eUnits.kip_in_F,
bool visible = true,
string modelPath = "")
{
try
{
Helper helper = Helper.Initialize();
_sapObject = helper.CreateObjectProgId(TYPE_NAME);
// start Sap2000 application
applicationStart(units, visible, modelPath);
// create SapModel object
_sapModel = _sapObject.SapModel;
_seed = new CSiApiSeed(_sapObject, _sapModel);
#if BUILD_ETABS2015 || BUILD_ETABS2016 || BUILD_ETABS2017
delayedETABSInitialization(units, visible, modelPath);
#endif
// TODO: Assign path of installation to Path property.
return(IsInitialized);
}
catch (Exception ex)
{
resetObject();
throw new CSiException("Cannot start a new instance of the program.", ex);
// TODO: Replace the exception with a logger.
//return false;
}
}
/// <summary>
/// Defines if given coordinates in table range.
/// </summary>
/// <param name="xCoordinate">X cooridanate to compare</param>
/// <param name="units">Units to work in (mm/pts only) [default is mm]</param>
/// <returns>[True] if in range, [False] otherwise</returns>
public bool IsCoordinatesXInRange(int xCoordinate, eUnits units = eUnits.Mm)
{
VerifyUnitsSupported(units);
int max = (units == eUnits.Mm) ? XMaxMm : XMaxPts;
return(xCoordinate >= 0 && xCoordinate <= max);
}
/// <summary>
/// Defines if given coordinates in table range.
/// </summary>
/// <param name="yCoordinate">Y cooridanate to compare</param>
/// <param name="units">Units to work in (mm/pts only) [default is mm]</param>
/// <returns>[True] if in range, [False] otherwise</returns>
public bool IsCoordinatesYInRange(int yCoordinate, eUnits units = eUnits.Mm)
{
VerifyUnitsSupported(units);
int max = (units == eUnits.Mm) ? YMaxMm : YMaxPts;
return(yCoordinate >= 0 && yCoordinate <= max);
}
/// <summary>
/// This function starts the program.
/// When the model is not visible it does not appear on screen and it does not appear in the Windows task bar.
/// If no filename is specified, you can later open a model or create a model through the API.
/// The file name must have an .sdb, .$2k, .s2k, .xls, or .mdb extension.
/// Files with .sdb extensions are opened as standard SAP2000 files.
/// Files with .$2k and .s2k extensions are imported as text files.
/// Files with .xls extensions are imported as Microsoft Excel files.
/// Files with .mdb extensions are imported as Microsoft Access files.
/// </summary>
/// <param name="applicationPath">The application path. If not specified, then the default installed application will be used.</param>
/// <param name="units">The database units used when a new model is created.
/// Data is internally stored in the program in the database units.</param>
/// <param name="visible">True: The application is visible when started.
/// False: The application is hidden when started.</param>
/// <param name="modelPath">The full path of a model file to be opened when the application is started.
/// If no file name is specified, the application starts without loading an existing model.</param>
/// <returns><c>true</c> if the program is successfully initialied, <c>false</c> otherwise.</returns>
/// <exception cref="IO.IOException">The following CSi program path is invalid: " + Path</exception>
private bool initializeProgram(string applicationPath = "",
eUnits units = eUnits.kip_in_F,
bool visible = true,
string modelPath = "")
{
if (string.IsNullOrWhiteSpace(applicationPath))
{
#if BUILD_ETABS2013
// TODO: Consider ETABS2013 deprecation
#elif BUILD_SAP2000v16
// TODO: Consider SAP2000v16 deprecation
// No action needed, allow method to continute to next option.
#else
#endif
#if !BUILD_SAP2000v18 && !BUILD_SAP2000v17 && !BUILD_SAP2000v16 && !BUILD_CSiBridgev18 && !BUILD_CSiBridgev17 && !BUILD_CSiBridgev16 && !BUILD_ETABS2015
return(initializeProgramFromLatestInstallation(units, visible, modelPath));
#else
return(false);
#endif
}
if (!IO.File.Exists(applicationPath))
{
throw new IO.IOException("The following CSi program path is invalid: " + applicationPath);
}
return(initializeProgramSpecific(applicationPath, units, visible, modelPath));
}
/// <summary>
/// Ricochet Calculator Constructor
/// </summary>
/// <param name="doInit">Perform initialization flag [default is false]</param>
/// <param name="units">Desired units to work in [default is Points]</param>
public RicochetCalc(bool doInit = false, eUnits units = eUnits.Pts)
{
IsInitialized = false;
if (doInit)
{
InitializeRicochetCalc(units);
}
}
/// <summary>
/// Sets the units presently specified for the model.
/// </summary>
/// <param name="units">The units.</param>
/// <exception cref="CSiException"></exception>
/// <exception cref="MPT.CSI.API.Core.Support.CSiException"></exception>
public void SetPresentUnits(eUnits units)
{
_callCode = _sapModel.SetPresentUnits(EnumLibrary.Convert <eUnits, CSiProgram.eUnits>(units));
if (throwCurrentApiException(_callCode))
{
throw new CSiException();
}
}
/// <summary>
/// Ricochet Calculator Constructor
/// </summary>
/// <param name="doInit">Perform initialization flag [default is false]</param>
/// <param name="units">Desired units to work in [default is Points]</param>
public RicochetCalc(bool doInit = false, eUnits units = eUnits.Pts)
{
IsInitialized = false;
if (doInit)
{
InitializeRicochetCalc(units);
}
}
/// <summary>
/// This function starts the application.
/// When the model is not visible it does not appear on screen and it does not appear in the Windows task bar.
/// If no filename is specified, you can later open a model or create a model through the API.
/// The file name must have an .sdb, .$2k, .s2k, .xls, or .mdb extension.
/// Files with .sdb extensions are opened as standard SAP2000 files.
/// Files with .$2k and .s2k extensions are imported as text files.
/// Files with .xls extensions are imported as Microsoft Excel files.
/// Files with .mdb extensions are imported as Microsoft Access files.
/// </summary>
/// <param name="units">The database units used when a new model is created.
/// Data is internally stored in the program in the database units.</param>
/// <param name="visible">True: The application is visible when started.
/// False: The application is hidden when started.</param>
/// <param name="filePath">The full path of a model file to be opened when the application is started.
/// If no file name is specified, the application starts without loading an existing model.</param>
/// <exception cref="CSiException"></exception>
public void ApplicationStart(eUnits units = eUnits.kip_in_F,
bool visible = true,
string filePath = "")
{
_callCode = _sapObject.ApplicationStart(EnumLibrary.Convert <eUnits, CSiProgram.eUnits>(units), visible, filePath);
if (throwCurrentApiException(_callCode))
{
throw new CSiException();
}
}
//Initialize Model
public int InitializeUnits(eUnits units = eUnits.N_mm_C)
{
int ret;
//Initialize Model
MySapObjectModel.InitializeNewModel((eUnits)units);
//Create New Blank Model
ret = MySapObjectModel.File.NewBlank();
return(ret);
}
/// <summary>
/// This function clears the previous model and initializes the program for a new model.
/// If it is later needed, you should save your previous model prior to calling this function.
/// After calling the InitializeNewModel function, it is not necessary to also call the ApplicationStart function because the functionality of the ApplicationStart function is included in the InitializeNewModel function.
/// </summary>
/// <param name="units">The database units for the new model.
/// All data is internally stored in the model in these units.</param>
/// <returns><c>true</c> if a nuew model is successfully initialized, <c>false</c> otherwise.</returns>
public bool InitializeNewModel(eUnits units = eUnits.kip_in_F)
{
_callCode = _sapModel.InitializeNewModel(EnumLibrary.Convert <eUnits, CSiProgram.eUnits>(units));
if (!apiCallIsSuccessful(_callCode))
{
return(false);
}
_file = new CSiFile(_seed);
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="CSiApplication"/> class using the default installed application.
/// When the model is not visible it does not appear on screen and it does not appear in the Windows task bar.
/// If no filename is specified, you can later open a model or create a model through the API.
/// The file name must have an .sdb, .$2k, .s2k, .xls, or .mdb extension.
/// Files with .sdb extensions are opened as standard SAP2000 files.
/// Files with .$2k and .s2k extensions are imported as text files.
/// Files with .xls extensions are imported as Microsoft Excel files.
/// Files with .mdb extensions are imported as Microsoft Access files.
/// </summary>
/// <param name="units">The database units used when a new model is created.
/// Data is internally stored in the program in the database units.</param>
/// <param name="visible">True: The application is visible when started.
/// False: The application is hidden when started.</param>
/// <param name="modelPath">The full path of a model file to be opened when the application is started.
/// If no file name is specified, the application starts without loading an existing model.</param>
/// <param name="numberOfExitAttempts">The number of exit attempts before the library stops attempting to exit the application.</param>
/// <param name="intervalBetweenExitAttempts">The interval between exit attempts of the application.</param>
public CSiApplication(eUnits units = eUnits.kip_in_F,
bool visible = true,
string modelPath = "",
int numberOfExitAttempts = 1,
int intervalBetweenExitAttempts = 0)
{
_numberOfExitAttempts = numberOfExitAttempts;
_intervalBetweenExitAttempts = intervalBetweenExitAttempts;
initializeProgram("", units, visible, modelPath);
}
public void CSiApplication_Application_Start_with_Custom_Units()
{
bool programWasOpened;
eUnits units = eUnits.kgf_mm_C;
using (CSiApplication app = new CSiApplication(CSiData.pathApp, units: units))
{
Assert.That(app.IsInitialized);
programWasOpened = app.IsInitialized;
Assert.AreEqual(units, app.Model.GetPresentUnits());
}
Assert.IsTrue(programWasOpened);
}
/// <summary>
/// Performs the rest of the applicationStart method for ETABS once the seed object has been created.
/// </summary>
/// <param name="units"></param>
/// <param name="visible"></param>
/// <param name="modelPath"></param>
private void delayedETABSInitialization(eUnits units = eUnits.kip_in_F,
bool visible = true,
string modelPath = "")
{
Model.InitializeNewModel(units);
if (!string.IsNullOrWhiteSpace(modelPath))
{
Model.File.Open(modelPath);
}
if (!visible)
{
Hide();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CSiApplication" /> class using the default installed application.
/// When the model is not visible it does not appear on screen and it does not appear in the Windows task bar.
/// If no filename is specified, you can later open a model or create a model through the API.
/// The file name must have an .sdb, .$2k, .s2k, .xls, or .mdb extension.
/// Files with .sdb extensions are opened as standard SAP2000 files.
/// Files with .$2k and .s2k extensions are imported as text files.
/// Files with .xls extensions are imported as Microsoft Excel files.
/// Files with .mdb extensions are imported as Microsoft Access files.
/// </summary>
/// <param name="units">The database units used when a new model is created.
/// Data is internally stored in the program in the database units.</param>
/// <param name="visible">True: The application is visible when started.
/// False: The application is hidden when started.</param>
/// <param name="modelPath">The full path of a model file to be opened when the application is started.
/// If no file name is specified, the application starts without loading an existing model.</param>
/// <param name="numberOfExitAttempts">The number of exit attempts before the library stops attempting to exit the application.</param>
/// <param name="intervalBetweenExitAttempts">The interval between exit attempts of the application.</param>
protected CSiApplication(eUnits units = eUnits.kip_in_F,
bool visible = true,
string modelPath = "",
int numberOfExitAttempts = 1,
int intervalBetweenExitAttempts = 0)
{
_apiApp = new ApiCSiApplication(units,
visible,
modelPath,
numberOfExitAttempts,
intervalBetweenExitAttempts);
NumberOfExitAttempts = numberOfExitAttempts;
IntervalBetweenExitAttempts = intervalBetweenExitAttempts;
}
/// <summary>
/// Verify if units are supported by surveyor
/// </summary>
/// <param name="units">Units type</param>
/// <exception cref="NotSupportedException">Thrown in case units not supported</exception>
private void VerifyUnitsSupported(eUnits units)
{
switch (units)
{
case eUnits.Mm:
case eUnits.Pts:
return;
default:
throw new NotSupportedException(String.Format(
"[{0}] Units of type {1} are not supported by {2} class",
MethodBase.GetCurrentMethod().Name, units.ToString(), GetType().Name));
}
}
/// <summary>
/// Performs the application-specific steps of initializing the program at the provided file path.
/// This initializes SapObject and SapModel.
/// </summary>
/// <param name="applicationPath">Path to the CSi application that the class manipulates.
/// Make sure this is a valid path before using this method.</param>
/// <param name="units">The database units used when a new model is created.
/// Data is internally stored in the program in the database units.</param>
/// <param name="visible">True: The application is visible when started.
/// False: The application is hidden when started.</param>
/// <param name="modelPath">The full path of a model file to be opened when the application is started.
/// If no file name is specified, the application starts without loading an existing model.</param>
/// <returns><c>true</c> if program is successfully initialized, <c>false</c> otherwise.</returns>
private bool initializeProgramSpecific(string applicationPath,
eUnits units = eUnits.kip_in_F,
bool visible = true,
string modelPath = "")
{
try
{
#if BUILD_ETABS2013
// Create program object
Assembly myAssembly = Assembly.LoadFrom(applicationPath);
// Create an instance of ETABSObject and get a reference to cOAPI interface
_sapObject = DirectCast(myAssembly.CreateInstance(TYPE_NAME), cOAPI);
#elif BUILD_SAP2000v16
// NOTE: No path is needed for SAP2000v16. Instead, the tested program will automatically use the
// version currently installed. To change the version, say for testing, run the desired v16 version as
// administrator first in order to register.
_sapObject = new SAP2000v16.SapObject;
#else
// Old Method: 32bit OAPI clients can only call 32bit ETABS 2014 and 64bit OAPI clients can only call 64bit ETABS 2014
// Create program object
// _SapObject = DirectCast(myAssembly.CreateInstance("CSI.SAP2000.API.SapObject"), cOAPI)
// New Method: 32bit & 64bit API clients can call 32 & 64bit program versions
// Use the OAPI helper class to get a reference to cOAPI interface
Helper helper = Helper.Initialize();
_sapObject = helper.CreateObject(applicationPath);
#endif
// start Sap2000 application
applicationStart(units, visible, modelPath);
// create SapModel object
_sapModel = _sapObject.SapModel;
_seed = new CSiApiSeed(_sapObject, _sapModel);
#if BUILD_ETABS2015 || BUILD_ETABS2016 || BUILD_ETABS2017
delayedETABSInitialization(units, visible, modelPath);
#endif
Path = applicationPath;
return(IsInitialized);
}
catch (Exception ex)
{
resetObject();
throw new CSiException("Cannot start a new instance of the program from " + applicationPath, ex);
// TODO: Replace the exception with a logger.
//return false;
}
}
public static bool NewModel(eUnits units = eUnits.Ton_m_C)
{
mySapModel = mySapObject.SapModel;
int flag = default(int);
flag = mySapModel.InitializeNewModel(units);
flag = mySapModel.File.NewBlank();
if (flag != 0)
{
return(false);
}
//SetDefaultMaterials();
return(true);
}
public static bool StartApplication(bool attachToInstance, bool isVisible, eUnits units = eUnits.Ton_m_C)
{
if (attachToInstance == false)
{
try
{
cHelper myHelper = new Helper();
mySapObject = myHelper.CreateObject(ProgramPath);
}
catch (Exception ex)
{
throw ex;
}
}
else
{
try
{
mySapObject = (cOAPI)System.Runtime.InteropServices.Marshal.GetActiveObject("CSI.SAP2000.API.SapObject");
}
catch
{
try
{
if (mySapObject == null)
{
cHelper myHelper = new Helper();
mySapObject = myHelper.CreateObject(ProgramPath);
}
}
catch (Exception ex)
{
throw ex;
}
}
}
if (isVisible == true)
{
mySapObject.Visible();
}
else
{
mySapObject.Hide();
}
mySapObject.ApplicationStart(units);
mySapModel = mySapObject.SapModel;
return(true);
}
public FNC(ushort maxBitWidth, ushort maxBitHeight, int rasterByteCount) : base(Lookups.StructuredFieldID <FNC>(), 0, 0, null)
{
Data = new byte[28];
PatternTech = ePatternTech.LaserMatrixNBitWide;
XUnitBase = eUnitBase.RelativeMetrics;
YUnitBase = eUnitBase.RelativeMetrics;
XUnits = eUnits.OneThousandUnitsPerEm;
YUnits = eUnits.OneThousandUnitsPerEm;
MaxBoxWidthIndex = maxBitWidth;
MaxBoxHeightIndex = maxBitHeight;
FNORGLength = 26; // Constant
FNIRGLength = 28; // Constant for raster
PatternAlignment = ePatternAlignment.OneByte;
RasterDataCount = rasterByteCount;
FNPRGLength = 22; // Constant
FNMRGLength = 8; // Constant for raster
XShapeResolution = eUnits.ThreeHundredPPI;
YShapeResolution = eUnits.ThreeHundredPPI;
}
public static void GrabOpenSAP(ref cSapModel mySapModel, ref string ModelUnits, string DynInputUnits = "kip_ft_F")
{
//dimension the SapObject as cOAPI type
cOAPI mySapObject = null;
//Use ret to check if functions return successfully (ret = 0) or fail (ret = nonzero)
var ret = 0;
//attach to a running instance of SAP2000
try
{
//get the active SapObject
//try the code form the example
//mySapObject =(cOAPI) Marshal.GetActiveObject("CSI.SAP2000.API.SapObject");
//get the active SapObject
mySapObject = (cOAPI)System.Runtime.InteropServices.Marshal.GetActiveObject("CSI.SAP2000.API.SapObject");
}
catch (Exception ex)
{
Console.WriteLine("No running instance of the program found or failed to attach.");
return;
}
//Create SapModel object
mySapModel = mySapObject.SapModel;
// get enum from Units & Set to model
if (!String.IsNullOrEmpty(DynInputUnits))
{
eUnits Units = (eUnits)Enum.Parse(typeof(eUnits), DynInputUnits);
try
{
ret = mySapModel.SetPresentUnits(Units);
}
catch (Exception ex)
{
string message = ex.Message;
}
}
ModelUnits = mySapModel.GetPresentUnits().ToString();
}
public static void GrabOpenSAP(ref cSapModel mySapModel, ref string ModelUnits, string DynInputUnits = "kip_ft_F")
{
Process[] SapInstances = Process.GetProcessesByName("SAP2000");
//http://docs.csiamerica.com/help-files/sap2000-oapi/SAP2000_API_Fuctions/General_Functions/SetAsActiveObject.htm
if (SapInstances.LongLength >= 1)
{
SapObject Obj;
object getObj = ROTHelper.GetActiveObject("SAP2000v20.SapObject");
if (getObj == null)
{
Obj = new SapObject();
getObj = ROTHelper.GetActiveObject("SAP2000v20.SapObject");
}
if (getObj != null)
{
Obj = (SapObject)getObj;
mySapModel = Obj.SapModel;
// get enum from Units & Set to model
if (!String.IsNullOrEmpty(DynInputUnits))
{
eUnits Units = (eUnits)Enum.Parse(typeof(eUnits), DynInputUnits);
try
{
int ret = mySapModel.SetPresentUnits(Units);
}
catch (Exception ex) {
string message = ex.Message;
}
}
ModelUnits = mySapModel.GetPresentUnits().ToString();
}
//SET UP ... SET UP ... SET UP ... SET UP
try
{
DefineMaterials(ref mySapModel);
}
catch { }
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CSiApplication" /> class using the default installed application.
/// When the model is not visible it does not appear on screen and it does not appear in the Windows task bar.
/// If no filename is specified, you can later open a model or create a model through the API.
/// The file name must have an .sdb, .$2k, .s2k, .xls, or .mdb extension.
/// Files with .sdb extensions are opened as standard SAP2000 files.
/// Files with .$2k and .s2k extensions are imported as text files.
/// Files with .xls extensions are imported as Microsoft Excel files.
/// Files with .mdb extensions are imported as Microsoft Access files.
/// </summary>
/// <param name="units">The database units used when a new model is created.
/// Data is internally stored in the program in the database units.</param>
/// <param name="visible">True: The application is visible when started.
/// False: The application is hidden when started.</param>
/// <param name="modelPath">The full path of a model file to be opened when the application is started.
/// If no file name is specified, the application starts without loading an existing model.</param>
/// <param name="numberOfExitAttempts">The number of exit attempts before the library stops attempting to exit the application.</param>
/// <param name="intervalBetweenExitAttempts">The interval between exit attempts of the application.</param>
/// <returns>CSiApplication.</returns>
public static CSiApplication Factory(eUnits units = eUnits.kip_in_F,
bool visible = true,
string modelPath = "",
int numberOfExitAttempts = 1,
int intervalBetweenExitAttempts = 0)
{
try
{
CSiApplication app = new CSiApplication(units,
visible,
modelPath,
numberOfExitAttempts,
intervalBetweenExitAttempts);
return(app);
}
catch (Exception e)
{
Console.WriteLine(e);
return(null);
}
}
/// <summary>
/// Verify if units are supported by surveyor
/// </summary>
/// <param name="units">Units type</param>
/// <exception cref="NotSupportedException">Thrown in case units not supported</exception>
private void VerifyUnitsSupported(eUnits units)
{
switch(units)
{
case eUnits.Mm:
case eUnits.Pts:
return;
default:
throw new NotSupportedException(String.Format(
"[{0}] Units of type {1} are not supported by {2} class",
MethodBase.GetCurrentMethod().Name, units.ToString(), GetType().Name));
}
}
public void GetDatabaseUnits()
{
eUnits units = _app.Model.GetDatabaseUnits();
Assert.AreEqual(eUnits.kip_in_F, units);
}
// /////////////////////////////////////////////////////////////////////
/// <summary>
/// Returns the requested TLE data field as a double or
/// as a text string in the units requested.
/// </summary>
/// <remarks>
/// The numeric return values are cached; requesting the same field
/// repeatedly incurs minimal overhead.
/// </remarks>
/// <param name="fld">The TLE field to retrieve</param>
/// <param name="units">Specifies the units desired</param>
/// <param name="str">If non-null, the field is returned as
/// a string.</param>
/// <param name="AppendUnits">
/// If true, units are appended to text string.
/// </param>
/// <returns>
/// The requested field, converted to the requested units if necessary.
/// </returns>
public double getField(eField fld,
eUnits units,
ref string str,
bool AppendUnits)
{
if (str != null)
{
// Return requested field in string form.
str = m_Field[fld].ToString();
if (AppendUnits)
str += getUnits(fld);
return 0.0;
}
else
{
// Return requested field in floating-point form.
// Return cache contents if it exists, else populate cache.
int key = Key(units, fld);
if (m_Cache.ContainsKey(key))
{
// return cached value
return (double)m_Cache[key];
}
else
{
// Value not in cache; add it
double valNative = Double.Parse(m_Field[fld].ToString());
double valConv = ConvertUnits(valNative, fld, units);
m_Cache[key] = valConv;
return valConv;
}
}
}
public Timer(eUnits t, Int64 timeAvg, Int64 timeVar)
{
throw new NotImplementedException();
}
/// <summary>
/// Initialization Method - reads all constants from Configuration file
/// </summary>
/// <param name="units">Desired units to work in [default is Points]</param>
/// <param name="xMaxBorder">X Max Limit for Ricochet Calculations</param>
/// <param name="yMaxBorder">Y Max Limit for Ricochet Calculations</param>
/// <param name="ricochetFactor">Ricochet Factor to use in calculations</param>
public void InitializeRicochetCalc(eUnits units = eUnits.Pts, double xMaxBorder = -1, double yMaxBorder = -1, double ricochetFactor = -1)
{
if (!IsInitialized)
{
_xMinBorder = 0;
_yMinBorder = 0;
_ricocheFactor = (ricochetFactor > 0) ? ricochetFactor
: Configuration.Attributes.GetValue<double>(Configuration.Names.KEY_RICOCHET_FACTOR);
switch(units)
{
case eUnits.Mm:
_xMaxBorder = (xMaxBorder > 0) ? xMaxBorder
: Configuration.Attributes.GetValue<double>(Configuration.Names.TABLE_WIDTH);
_yMaxBorder = (yMaxBorder > 0) ? yMaxBorder
: Configuration.Attributes.GetValue<double>(Configuration.Names.TABLE_HEIGHT);
break;
case eUnits.Pts:
_xMaxBorder = (xMaxBorder > 0) ? xMaxBorder
: Configuration.Attributes.GetValue<double>(Configuration.Names.FOOSBOT_AXE_X_SIZE);
_yMaxBorder = (yMaxBorder > 0) ? yMaxBorder
: Configuration.Attributes.GetValue<double>(Configuration.Names.FOOSBOT_AXE_Y_SIZE);
break;
default:
throw new NotSupportedException(String.Format(
"[{0}] Units [{1}] are not supported by RicochetCalc.",
MethodBase.GetCurrentMethod().Name, units.ToString()));
}
IsInitialized = true;
}
}
/// <summary>
/// This function clears the previous model and initializes the program for a new model.
/// If it is later needed, you should save your previous model prior to calling this function.
/// After calling the InitializeNewModel function, it is not necessary to also call the ApplicationStart function because the functionality of the ApplicationStart function is included in the InitializeNewModel function.
/// </summary>
/// <param name="units">The database units for the new model.
/// All data is internally stored in the model in these units.</param>
/// <returns><c>true</c> if a nuew model is successfully initialized, <c>false</c> otherwise.</returns>
public bool InitializeNewModel(eUnits units = eUnits.kip_in_F)
{
UnitsInitial = units;
return(_apiModel.InitializeNewModel(units));
}
// what units to convert to
// ///////////////////////////////////////////////////////////////////////////
// Convert the given field into the requested units. It is assumed that
// the value being converted is in the TLE format's "native" form.
protected double ConvertUnits(double valNative, // value to convert
eField fld, // what field the value is
eUnits units)
{
if (fld == eField.FLD_I ||
fld == eField.FLD_RAAN ||
fld == eField.FLD_ARGPER ||
fld == eField.FLD_M)
{
// The native TLE format is DEGREES
if (units == eUnits.U_RAD)
return valNative * Globals.RADS_PER_DEG;
}
return valNative; // return value in unconverted native format
}
// Generates key for cache
private int Key(eUnits u, eField f)
{
return ((int)u * 100) + (int)f;
}
/// <summary>
/// Defines if given coordinates in table range.
/// </summary>
/// <param name="xCoordinate">X coordinate to compare</param>
/// <param name="units">Units to work in (mm/pts only) [default is mm]</param>
/// <returns>[True] if in range, [False] otherwise</returns>
public bool IsCoordinatesXInRange(int xCoordinate, eUnits units = eUnits.Mm)
{
VerifyUnitsSupported(units);
int max = (units == eUnits.Mm) ? XMaxMm : XMaxPts;
return (xCoordinate >= 0 && xCoordinate <= max);
}
/// <summary>
/// Sets the units presently specified for the model.
/// </summary>
/// <param name="units">The units.</param>
/// <exception cref="CSiException"><see cref="CSiApiBase.API_DEFAULT_ERROR_CODE" /></exception>
/// <exception cref="MPT.CSI.API.Core.Support.CSiException"></exception>
public void SetPresentUnits(eUnits units)
{
_apiModel.SetPresentUnits(units);
UnitsPresent = units;
}
public void InitializeNewModel(eUnits units)
{
}
/// <summary>
/// Defines if given coordinates in table range.
/// </summary>
/// <param name="yCoordinate">Y coordinate to compare</param>
/// <param name="units">Units to work in (mm/pts only) [default is mm]</param>
/// <returns>[True] if in range, [False] otherwise</returns>
public bool IsCoordinatesYInRange(int yCoordinate, eUnits units = eUnits.Mm)
{
VerifyUnitsSupported(units);
int max = (units == eUnits.Mm) ? YMaxMm : YMaxPts;
return (yCoordinate >= 0 && yCoordinate <= max);
}
public Timer(eUnits t, int timeAvg)
{
throw new NotImplementedException();
}
public void SetPresentUnits(eUnits units)
{
}
public Timer(eUnits t, int timeAvg, int timeVar, bool recreate, bool recAutostart)
{
throw new NotImplementedException();
}
public void GetPresentUnits()
{
eUnits units = _app.Model.GetPresentUnits();
Assert.AreEqual(eUnits.kip_in_F, units);
}
/// <summary>
/// Defines if given coordinates in table range.
/// </summary>
/// <param name="xCoordinate">X coordinate to compare</param>
/// <param name="yCoordinate">Y coordinate to compare</param>
/// <param name="units">Units to work in (mm/pts only) [default is mm]</param>
/// <returns>[True] if in range, [False] otherwise</returns>
public bool IsCoordinatesInRange(int xCoordinate, int yCoordinate, eUnits units = eUnits.Mm)
{
return (IsCoordinatesXInRange(xCoordinate, units) && IsCoordinatesYInRange(yCoordinate, units));
}
