public InputDialog(string text, string hint = hint, InputDataType type = InputDataType.String) : base(0.30, 0.30)
{
Hint = hint;
Dtype = type;
init();
label2.Text = text; //0xE8C9
}
public override bool IsEntireEntityBodyIsPreloaded()
{
if (_inputDataType == InputDataType.Unknown)
{
_inputDataType = (InputDataType)MonoInternal.GetInputDataType(_request);
}
return(_inputDataType == InputDataType.Memory);
}
private AbstractSectorDataFile CreateHeaderDataFile(string fullPath, InputDataType inputDataType)
{
return(new HeaderDataFile(
fullPath,
this.streamFactory,
SectorDataReaderFactory.Create(inputDataType)
));
}
public void TestItReturnsCorrectParser(InputDataType dataType, Type expectedParserType)
{
Assert.Equal(
expectedParserType,
factory.GetParserForFile(
SectorDataFileFactoryFactory.Make(new List <string>()).Create("Test", dataType)
).GetType()
);
}
public int SendDataReportMode(InputDataType mode)
{
if (mode == InputDataType.STATUS_INFO || mode == InputDataType.READ_MEMORY_REGISTERS)
{
Debug.LogError("Passed " + mode.ToString() + " to SendDataReportMode!");
return(-2);
}
return(SendWithType(OutputDataType.DATA_REPORT_MODE, new byte[] { 0x00, (byte)mode }));
}
public static DataConverterBase GetInstance(InputDataType dataType)
{
switch (dataType)
{
case InputDataType.Json:
return new JsonDataConverter();
case InputDataType.DataRow:
return new DataRowDataConverter();
}
throw new Exception("Unknow Data Type.");
}
public MonoWorkerRequest(string root, string vroot, IntPtr request, IntPtr response)
: base(string.Empty, string.Empty, null)
{
_root = root;
_vroot = vroot;
_request = request;
_response = response;
_inputDataType = InputDataType.Unknown;
_offset = 0;
InitRequestHeader();
}
public InputEvent(object inputData, List<Enums.VirtualKeyCode> modifiers, string inputDataStringRepresentation, InputDataType inputDataType, InputType inputType, int cycleCount = 1, int duration = 0)
{
if (inputDataType == InputDataType.VirtualKey)
InputData = (VirtualKeyCode)(Enums.VirtualKeyCode)inputData;
else
InputData = inputData;
Modifiers = modifiers != null ? modifiers.Select(item => (VirtualKeyCode)item).ToList() : null;
InputDataStringRepresentation = inputDataStringRepresentation;
InputDataType = inputDataType;
InputType = inputType;
CycleCount = cycleCount;
Duration = duration;
}
/// \brief Sets the Data Reporting mode of the Wii Remote.
/// \param mode The data reporting mode desired. This can be any InputDataType except for
/// InputDataType::STATUS_INFO, InputDataType::READ_MEMORY_REGISTERS, or InputDataType::ACKNOWLEDGE_OUTPUT_REPORT.
/// Said data types are not data reporting modes so it doesn't make sense to use them here.
/// \return On success, the total size of the data written (> 0), <= 0 on failure.
/// \sa SendWithType(OutputDataType, byte[])
public int SendDataReportMode(InputDataType mode)
{
if (mode == InputDataType.STATUS_INFO || mode == InputDataType.READ_MEMORY_REGISTERS || mode == InputDataType.ACKNOWLEDGE_OUTPUT_REPORT)
{
Debug.LogError("Passed " + mode.ToString() + " to SendDataReportMode!");
return(-2);
}
last_report_type = mode;
ExpectingSecondInterleavedPacket = false;
return(SendWithType(OutputDataType.DATA_REPORT_MODE, new byte[] { 0x00, (byte)mode }));
}
public FileListInclusionRule(
IEnumerable <string> fileList,
bool ignoreMissing,
string exceptWhereExists,
InputDataType inputDataType,
OutputGroup outputGroup
)
{
this.FileList = fileList;
this.IgnoreMissing = ignoreMissing;
this.ExceptWhereExists = exceptWhereExists;
this.InputDataType = inputDataType;
this.outputGroup = outputGroup;
}
/// The size, in bytes, of a given Wii Remote InputDataType when reported by the Wiimote.
///
/// This is at most 21 bytes.
public static int GetInputDataTypeSize(InputDataType type)
{
switch (type)
{
case InputDataType.STATUS_INFO:
return(6);
case InputDataType.READ_MEMORY_REGISTERS:
return(21);
case InputDataType.ACKNOWLEDGE_OUTPUT_REPORT:
return(4);
case InputDataType.REPORT_BUTTONS:
return(2);
case InputDataType.REPORT_BUTTONS_ACCEL:
return(5);
case InputDataType.REPORT_BUTTONS_EXT8:
return(10);
case InputDataType.REPORT_BUTTONS_ACCEL_IR12:
return(17);
case InputDataType.REPORT_BUTTONS_EXT19:
return(21);
case InputDataType.REPORT_BUTTONS_ACCEL_EXT16:
return(21);
case InputDataType.REPORT_BUTTONS_IR10_EXT9:
return(21);
case InputDataType.REPORT_BUTTONS_ACCEL_IR10_EXT6:
return(21);
case InputDataType.REPORT_EXT21:
return(21);
case InputDataType.REPORT_INTERLEAVED:
return(21);
case InputDataType.REPORT_INTERLEAVED_ALT:
return(21);
}
return(0);
}
// The size, in bytes, of a given Wiimote InputDataType when reported by the Wiimote.
// This is at most 21 bytes.
public static int GetInputDataTypeSize(InputDataType type)
{
switch (type)
{
case InputDataType.STATUS_INFO:
return(6);
case InputDataType.READ_MEMORY_REGISTERS:
return(21);
case InputDataType.REPORT_BUTTONS_IR10_EXT9:
return(21);
case InputDataType.REPORT_BUTTONS_ACCEL_IR10_EXT6:
return(21);
}
return(0);
}
public HttpRequestResult <bool> ValidateInputDataTypes()
{
if (InputDataType.Count() == Rule.LeftSide.Count())
{
return(new HttpRequestResult <bool>(true));
}
if (InputDataType.Count() > Rule.LeftSide.Count())
{
return(new HttpRequestResult <bool>("Per daug antecedentų."));
}
if (InputDataType.Count() < Rule.LeftSide.Count())
{
return(new HttpRequestResult <bool>("Nepakankamai antecedentų."));
}
return(new HttpRequestResult <bool>("Netinkami antecedentai."));
}
public FolderInclusionRule(
string folder,
bool recursive,
InputDataType inputDataType,
OutputGroup outputGroup,
bool excludeList = true,
List <string> includeExcludeFiles = null,
Regex includePattern = null
)
{
Folder = folder;
Recursive = recursive;
InputDataType = inputDataType;
this.outputGroup = outputGroup;
IncludePattern = includePattern;
ExcludeList = excludeList;
IncludeExcludeFiles = includeExcludeFiles != null
? includeExcludeFiles.ToList()
: new List <string>();
}
public static AbstractSectorDataReader Create(InputDataType dataType)
{
return(dataType switch
{
InputDataType.ESE_AGREEMENTS => new EseSectorDataReader(),
InputDataType.ESE_FREETEXT => new EseSectorDataReader(),
InputDataType.ESE_GROUND_NETWORK => new EseSectorDataReader(),
InputDataType.ESE_POSITIONS_MENTOR => new EseSectorDataReader(),
InputDataType.ESE_OWNERSHIP => new EseSectorDataReader(),
InputDataType.ESE_POSITIONS => new EseSectorDataReader(),
InputDataType.ESE_PRE_POSITIONS => new EseSectorDataReader(),
InputDataType.ESE_SECTORLINES => new EseSectorDataReader(),
InputDataType.ESE_SIDS => new EseSectorDataReader(),
InputDataType.ESE_STARS => new EseSectorDataReader(),
InputDataType.ESE_VRPS => new EseSectorDataReader(),
InputDataType.RWY_ACTIVE_RUNWAY => new EseSectorDataReader(),
InputDataType.SCT_AIRPORT_BASIC => new SctSectorDataReader(),
InputDataType.SCT_ARTCC => new SctSectorDataReader(),
InputDataType.SCT_ARTCC_HIGH => new SctSectorDataReader(),
InputDataType.SCT_ARTCC_LOW => new SctSectorDataReader(),
InputDataType.SCT_COLOUR_DEFINITIONS => new SctSectorDataReader(),
InputDataType.SCT_RUNWAY_CENTRELINES => new SctSectorDataReader(),
InputDataType.SCT_FIXES => new SctSectorDataReader(),
InputDataType.SCT_GEO => new SctSectorDataReader(),
InputDataType.SCT_INFO => new SctSectorDataReader(),
InputDataType.SCT_LABELS => new SctSectorDataReader(),
InputDataType.SCT_NDBS => new SctSectorDataReader(),
InputDataType.SCT_REGIONS => new SctSectorDataReader(),
InputDataType.SCT_RUNWAYS => new SctSectorDataReader(),
InputDataType.SCT_SIDS => new SctSectorDataReader(),
InputDataType.SCT_STARS => new SctSectorDataReader(),
InputDataType.SCT_LOWER_AIRWAYS => new SctSectorDataReader(),
InputDataType.SCT_UPPER_AIRWAYS => new SctSectorDataReader(),
InputDataType.SCT_VORS => new SctSectorDataReader(),
InputDataType.FILE_HEADERS => new FileHeaderDataReader(),
_ => throw new ArgumentException("Unknown data type for SectorDataReaderFactory")
});
/// The size, in bytes, of a given Wii Remote InputDataType when reported by the Wiimote.
///
/// This is at most 21 bytes.
public static int GetInputDataTypeSize(InputDataType type)
{
switch (type)
{
case InputDataType.STATUS_INFO:
return 6;
case InputDataType.READ_MEMORY_REGISTERS:
return 21;
case InputDataType.ACKNOWLEDGE_OUTPUT_REPORT:
return 4;
case InputDataType.REPORT_BUTTONS:
return 2;
case InputDataType.REPORT_BUTTONS_ACCEL:
return 5;
case InputDataType.REPORT_BUTTONS_EXT8:
return 10;
case InputDataType.REPORT_BUTTONS_ACCEL_IR12:
return 17;
case InputDataType.REPORT_BUTTONS_EXT19:
return 21;
case InputDataType.REPORT_BUTTONS_ACCEL_EXT16:
return 21;
case InputDataType.REPORT_BUTTONS_IR10_EXT9:
return 21;
case InputDataType.REPORT_BUTTONS_ACCEL_IR10_EXT6:
return 21;
case InputDataType.REPORT_EXT21:
return 21;
case InputDataType.REPORT_INTERLEAVED:
return 21;
case InputDataType.REPORT_INTERLEAVED_ALT:
return 21;
}
return 0;
}
/// \brief Sets the Data Reporting mode of the Wii Remote.
/// \param mode The data reporting mode desired. This can be any InputDataType except for
/// InputDataType::STATUS_INFO, InputDataType::READ_MEMORY_REGISTERS, or InputDataType::ACKNOWLEDGE_OUTPUT_REPORT.
/// Said data types are not data reporting modes so it doesn't make sense to use them here.
/// \return On success, the total size of the data written (> 0), <= 0 on failure.
/// \sa SendWithType(OutputDataType, byte[])
public int SendDataReportMode(InputDataType mode)
{
if (mode == InputDataType.STATUS_INFO || mode == InputDataType.READ_MEMORY_REGISTERS || mode == InputDataType.ACKNOWLEDGE_OUTPUT_REPORT)
{
Debug.LogError("Passed " + mode.ToString() + " to SendDataReportMode!");
return -2;
}
last_report_type = mode;
ExpectingSecondInterleavedPacket = false;
return SendWithType(OutputDataType.DATA_REPORT_MODE, new byte[] { 0x00, (byte)mode });
}
public ElementForInputData(string inputEvent, InputDataType inputDataType)
{
this.inputEvent = inputEvent;
this.inputDataType = inputDataType;
}
public DryFilmCost(object data, InputDataType dataType)
: base(data, dataType)
{
}
public OtherRateCost(object data, InputDataType dataType)
: base(data, dataType)
{
}
public BOMCost(object data, InputDataType dataType)
: base(data, dataType)
{
}
public void SetDataHint(InputDataType data, string hint, int hintColor = 0xD3D3D3, int textColor = 0x000000)
{
DataType = data;
SetHint(hint, hintColor, textColor);
}
public void ReceiveInput(InputDataType type, object inputData)
{
//Debug.Log($"received input in player: {type},{inputData}");
switch (type)
{
case InputDataType.orientation:
if (activateLogging)
{
Debug.Log($"device orientation {gameObject.name}, {(Vector3)inputData}");
}
if (sinInitialRotation == float.MinValue)
{
Debug.Log("calculating new initial pos");
sinInitialRotation = Mathf.Cos(((Vector3)inputData).x * Mathf.Deg2Rad);
}
//TODO: find a fix for holding phone inverted.
float sinRotation = Mathf.Cos(((Vector3)inputData).x * Mathf.Deg2Rad);
currentRotation = Mathf.Clamp(sinRotation - sinInitialRotation, -steeringRangeInPercent, steeringRangeInPercent) / steeringRangeInPercent;
//Debug.Log($"calculated deviceorientation {((Vector3)inputData).x}, {sinRotation} - {sinInitialRotation} : +-{steeringRangeInPercent}= {currentRotation}");
break;
case InputDataType.tap:
//Debug.Log($"received string {(string)inputData}");
switch ((string)inputData)
{
case "tap-area-boost":
if (canBoost)
{
boostActive = true;
canBoost = false;
playerManager.SendMessageToClient(this, PlayerClientAction.boost_activated);
Invoke("ReactivateBoost", reactivateBoostTime);
}
break;
case "tap-area-stealth":
if (canActivateStealth)
{
EnableStealth();
}
break;
case "tap-area-fire":
if (projectileReady)
{
projectile.Fire(transform.position, transform.rotation);
projectileReady = false;
playerManager.SendMessageToClient(this, PlayerClientAction.fire_activated);
}
break;
case "tap-area-reset_orientation":
sinInitialRotation = float.MinValue;
break;
default:
//do nothing, tap not recognized.
break;
}
break;
case InputDataType.proximity:
Debug.Log($"received proximity {activateStealthDelay}");
//false indicates sensor is blocked / covered.
if ((bool)inputData == false)
{
EnableStealth();
}
break;
default:
break;
}
}
public DrillBitCost(object data, InputDataType dataType)
: base(data, dataType)
{
}
public AbstractSectorDataFile(string fullPath, InputDataType dataType)
{
FullPath = fullPath;
DataType = dataType;
}
public void TestItReturnsCorrectReader(InputDataType inputType, Type expectedReaderType)
{
Assert.Equal(expectedReaderType, SectorDataReaderFactory.Create(inputType).GetType());
}
/// <summary>
/// Starts input
/// </summary>
/// <param name="device">Device object</param>
/// <param name="ProtocolClass">Class of device to operate with</param>
/// <param name="DataType">Type of data to input</param>
/// <param name="InputTask">Data processing task</param>
/// <param name="ErrorMessage">Error</param>
/// <returns>Returns true if device was succesfully started and stopped </returns>
public static bool Launch(DeviceInput device,
ProtocolClassID ProtocolClass,
string PrefferedSerialNumber,
InputDataType DataType,
DeviceInputTask InputTask,
ref string ErrorMessage)
{
if (Running == true)
{
return(false);
}
try
{
Running = true;
if (device == null)
{
ErrorMessage = "Device is null";
return(false);
}
#region Getting library versions
//Getting HAL library Version information
int Version = 0, Release = 0;
device.GetHALVersion(ref Version, ref Release);
Console.WriteLine("Mitsar.HAL version: {0}.{1}", Version, Release);
Console.WriteLine();
Console.WriteLine("Assemblies_____________");
Console.WriteLine(GetAssemblyDescription("Mitsar.Essentials"));
Console.WriteLine(GetAssemblyDescription("Mitsar.HAL"));
Console.WriteLine();
#endregion
#region Getting available hardware and selecting device
DeviceDescription SelectedDescription = null;
//Detecting Hardware
List <DeviceDescription> descriptions = new List <DeviceDescription>();
Console.WriteLine("Enumerating devices for protocol " + ProtocolClass);
device.Enumerate(HardwareClassID.EEG, ProtocolClass, ref descriptions);
//Showing all discovered devices
if (descriptions != null)
{
Console.WriteLine("Devices found ______________");
foreach (DeviceDescription desc in descriptions)
{
Console.WriteLine(desc.ToString());
Console.WriteLine("Driver Name: " + desc.GetDeviceDriverName());
Console.WriteLine("Driver SerialNumber: " + desc.DriverSerialNumber);
Console.WriteLine("State: " + desc.State.ToString());
Console.WriteLine();
}
}
else
{
ErrorMessage = "No devices found";
return(false);
}
Console.WriteLine("________________________");
//Selecting device description
if (descriptions.Count == 0)
{
ErrorMessage = "Error: No devices found";
return(false);
}
else
{
if (string.IsNullOrEmpty(PrefferedSerialNumber) == false)
{
Console.Write("Searching for device with serial number " + PrefferedSerialNumber + "...");
//Choosing EEG Device
foreach (DeviceDescription desc in descriptions)
{
if (desc.DriverSerialNumber == PrefferedSerialNumber)
{
SelectedDescription = desc;
break;
}
}
if (SelectedDescription != null)
{
Console.WriteLine(" found " + SelectedDescription.ToString());
}
else
{
Console.WriteLine(" not found");
}
}
if (SelectedDescription == null)
{
Console.Write("Searching for any device...");
//Choosing EEG Device
foreach (DeviceDescription desc in descriptions)
{
if (desc.HardwareClass == HardwareClassID.EEG)
{
SelectedDescription = desc;
break;
}
}
if (SelectedDescription != null)
{
Console.WriteLine(" found " + SelectedDescription.ToString());
}
else
{
Console.WriteLine(" not found");
}
}
if (SelectedDescription == null)
{
ErrorMessage = "Error: No devices found";
return(false);
}
}
#endregion
#region Opening, Powering and detecting device version
//Opening HAL
Console.Write("Opening...");
if (device.Open(SelectedDescription) == true)
{
Console.WriteLine("OK");
}
else
{
return(false);
}
//Powering HAL
Console.Write("Powering...");
if (device.PowerOn() == true)
{
Console.WriteLine("OK");
}
else
{
return(false);
}
//Identifying HAL
Console.Write("Indentifing...");
if (device.Identify() == true)
{
Console.WriteLine("OK");
}
else
{
return(false);
}
if (device.ActiveDeviceDescription.Resource.Version == 0)
{
ErrorMessage = "Error: Unknown version " + device.ActiveDeviceDescription.Resource.ReservedVersion;
return(false);
}
Console.WriteLine();
Console.WriteLine("Device vendor: " + device.ActiveDeviceDescription.Resource.Vendor);
Console.WriteLine("Device version: " + device.ActiveDeviceDescription.Resource.Version);
Console.WriteLine("Device serial number: " + device.ActiveDeviceDescription.Resource.SerialNumber);
#endregion
#region Loading and setting up calibration
Console.Write("Getting calibration...");
Resource_MultiChannel mresource = device.ActiveDeviceDescription.Resource as Resource_MultiChannel;
//If internal device calibration is supported
if (mresource.IsROMSupported() == true)
{//ROM supported - reading from ROM
byte[] buf = null;
//Reading calibration data from device's memory to buffer
if (device.ReadMemory(ref buf) == true)
{//if ROM read successfully - transfer to calibration
//Decoding buffer to calibtaion data
CalibrationProfileIOResult result = CalibrationProfile.ReadFromBuffer(ref device.ActiveDeviceDescription.Calibration, mresource, buf);
if (result == CalibrationProfileIOResult.OK) //Translate OK
{
//After successfull read version and serial must be assigned to CalibrationFile
device.ActiveDeviceDescription.Calibration.Parameters.Version = device.ActiveDeviceDescription.Resource.Version;
device.ActiveDeviceDescription.Calibration.Parameters.FullSerialNumber = device.ActiveDeviceDescription.Resource.SerialNumber;
//Serial is not validated because received from already validated device resource
Console.WriteLine("OK");
}
else //ROM translate or check sum error
{
device.ActiveDeviceDescription.Calibration.Clear();
}
}//ROM Access error
else
{
device.ActiveDeviceDescription.Calibration.Clear();
}
}//if ROM supported
else
{
Console.WriteLine(" not supported");
}
Console.WriteLine("");
//else calibration must be read from calibration file eeg.cal
//CalibrationFile.Read(ref device.ActiveDeviceDescription.Calibration, "eeg.cal");
#endregion
#region Configuring device
//Setting input mode to global input mode. EEG(data) or Impedance
mresource.DataType = DataType;
//Test signal mode disabled
mresource.TestSignal = false;
//Setting up referent operation mode
//Getting list of supported referent types
List <ReferentOperationMode> RefModeList = mresource.GetReferentOperationModeList(false);
Console.Write("Supported referents: ");
foreach (ReferentOperationMode refmode in RefModeList)
{
Console.Write(refmode + " ");
}
Console.WriteLine();
//Selecting first supported mode
//mresource.EmitterFactory.RefMode = ReferentOperationMode.RefElectrode;
//mresource.EmitterFactory.RefMode = ReferentOperationMode.Joined;
//RefModeList[0];
mresource.EmitterFactory.RefMode = RefModeList[0];
mresource.EmitterFactory.ImpedanceChannelEnabled = true;
mresource.EmitterFactory.AccelerometerChannelEnabled = true;
//Setting up sampling frequency
//GEtting list of supported sampling frequencies
List <double> FreqList = mresource.GetSamplingFrequencyList(false);
Console.Write("Supported frequencies: ");
foreach (double freq in FreqList)
{
Console.Write(freq + " ");
}
Console.WriteLine();
//Selecting first frequency in list, generally nominal
//int SamplingFrequency = (int)mresource.GetNominalSamplingFrequency();
int SamplingFrequency = (int)FreqList[0];
mresource.EmitterFactory.SamplingFrequency = SamplingFrequency;
//Setting other data buffer parameters
//Getting BYTES PER SAMPLE FROM FIRST ENCOUNTERED DATA CHANNEL
mresource.DataBuffer.BytesPerTick = mresource.Interface_GetBytesPerSample(UID.NOP);
mresource.DataBuffer.TicksMin = 2;
mresource.DataBuffer.TicksMax = 100;
mresource.DataBuffer.TicksSkip = 10;// 10;
//Enable Front panel LED in Impedace Test mode
mresource.FrontLedEnabled = true;
mresource.FrontLedThesholdEnabled = false;
//Set edge value, can be changed in any time
//All impedances above this value will be highligted
//Only 5, 10, 20, 40 values are indicated
mresource.FrontLedThesholdValue = 10;
Console.WriteLine();
#endregion
#region Starting data input
Console.Write("Starting...");
if (device.Start() == true)
{
Console.WriteLine("OK");
}
else
{
return(false);
}
Console.WriteLine("Emitters__________________");
StringBuilder sb = new StringBuilder();
sb.AppendLine("UID\tIndex\tAlign\tBPS\tHigh\tLow\tNotch\tUnitsPerSample");
foreach (EmitterDescription emm in mresource.EmitterFactory)
{
sb.Append(emm.UID.ToString());
sb.Append("\t");
sb.Append(emm.HardwareIndex.ToString());
sb.Append("\t");
sb.Append(emm.Align.ToString());
sb.Append("\t");
sb.Append(emm.BytesPerSample.ToString());
sb.Append("\t");
sb.Append(emm.HardHighPass.ToString());
sb.Append("\t");
sb.Append(emm.HardLowPass.ToString());
sb.Append("\t");
sb.Append(emm.HardNotch.ToString());
sb.Append("\t");
sb.Append(emm.UnitsPerSample.ToString());
sb.AppendLine("\t");
}
Console.WriteLine(sb.ToString());
Console.WriteLine("Calibration_____________");
//sb.Clear();
foreach (EmitterDescription emm in mresource.EmitterFactory)
{
sb.Append(emm.UID.ToString());
sb.Append("\t");
if (emm.CalEntryLink != null)
{
sb.Append(emm.CalEntryLink.ToString());
sb.Append("\t");
}
else
{
sb.Append(" no calibration");
}
sb.AppendLine("\t");
}
Console.WriteLine(sb.ToString());
Console.WriteLine("Input parameters_____________");
Console.WriteLine("Data Type: " + mresource.DataType.ToString());
Console.WriteLine("Sampling Frequency: " + mresource.EmitterFactory.SamplingFrequency.ToString());
Console.WriteLine("BytesPerTick: " + mresource.DataBuffer.BytesPerTick.ToString());
Console.WriteLine("Minimum ticks to transmit: " + mresource.DataBuffer.TicksMin.ToString());
Console.WriteLine("Maximum ticks to transmit: " + mresource.DataBuffer.TicksMax.ToString());
Console.WriteLine("Internal number of channels: " + mresource.InputHardwareChannelCountInternal.ToString());
Console.WriteLine("External number of channels: " + mresource.InputHardwareChannelCountExternal.ToString());
Console.WriteLine();
#endregion
//Start Data asquisition task
Console.WriteLine("Executing input task...");
if (InputTask != null)
{
InputTask();
}
bool DisplayImpedances = false;
#region Displaying impedances
if (DisplayImpedances)
{
Console.WriteLine("----- EmitterFactory -----");
foreach (EmitterDescription em in mresource.EmitterFactory)
{
///Console.WriteLine(em.UID + "\t RF=" + em.ImpedancePreliminaryValue + "\t R=" + em.ImpedanceResultValue);
Console.WriteLine(em.UID + "\t RValue=" + em.ImpedanceResultValue);//;;em.ImpedancePreliminaryValue + "\t R=" + em.ImpedanceResultValue);
}
Console.WriteLine("----- ImpedanceArray -----");
foreach (ImpedanceElement el in mresource.ImpedanceArray)
{
Console.WriteLine(el.LogicalUID +
// " Name= " + el.Name +
// " Active:" + el.Active +
// " InMontage:" + el.PresentInMontage +
//" REF:" + el.HardwareReferent +
// " LED:" + el.LedState + " (" + el.LedIndex + ")" +
// " PVal:" + el.PreliminaryValue +
"\t RValue:" + el.ResultValue);
}
}
#endregion
#region Displaying power mode
Console.WriteLine("Power mode: " + device.ActiveDeviceDescription.Resource.PowerMode);
#endregion
Console.WriteLine("Complete");
return(true);
}
finally
{
//Memorizing error code
HALErrorCode errorcode = device.HALError.Code;
Running = false;
#region Finalising device
if (device != null)
{
if (device.IsStarted)
{
Console.Write("Stopping...");
if (device.Stop() == true)
{
Console.WriteLine("OK");
}
}
if (device.IsPowered)
{
Console.Write("Powering off...");
if (device.PowerOff() == true)
{
Console.WriteLine("OK");
}
}
if (device.IsOpened)
{
Console.Write("Closing...");
if (device.Close() == true)
{
Console.WriteLine("OK");
}
}
if (errorcode != HALErrorCode.OK)
{
ErrorMessage = "Error: " + errorcode.ToString();
}
}
#endregion
}
}//Launch
public RouterCost(object data, InputDataType dataType)
: base(data, dataType)
{
}
public SectorDataFile(string fullPath, IInputStreamFactory streamFactory, InputDataType dataType, AbstractSectorDataReader reader)
: base(fullPath, dataType)
{
this.streamFactory = streamFactory;
this.reader = reader;
}
public LabelForInputDataWithLabel(string inputEvent, string IDText, InputDataType inputDataType, bool localizeLabel = true) : base(inputEvent, inputDataType)
{
this.IDText = IDText;
this.localizeLabel = localizeLabel;
}
public NavbarInfoElement(UnityEvent unityEvent, string inputEvent, string IDText, InputDataType inputDataType, bool localizeLabel = true) : base(inputEvent, IDText, inputDataType, localizeLabel)
{
this.unityEvent = unityEvent;
}
public AbstractSectorDataFile Create(string fullPath, InputDataType inputDataType)
{
return(inputDataType == InputDataType.FILE_HEADERS
? this.CreateHeaderDataFile(fullPath, inputDataType)
: this.CreateStandardDataFile(fullPath, inputDataType));
}
public CostItemRateCost(object data, InputDataType dataType)
: base(data, dataType)
{
}
public static Boolean ValidateTextBox(Label lbl, TextBox tb, Boolean AllowEmpty, InputDataType dt)
{
String str = CLanguage.getValue("ERROR_TEXT_VALIDATE");
String fmt = String.Format(str, lbl.Content);
if (tb.IsEnabled)
{
if (AllowEmpty)
{
return(true);
}
if (tb.Text.Trim().Equals(""))
{
CMessageBox.Show(fmt, "ERROR", MessageBoxButton.OK, MessageBoxImage.Error);
tb.Focus();
return(false);
}
Regex regex = null;
if (dt == InputDataType.InputTypeZeroPossitiveDecimal)
{
regex = new Regex(@"^\d+(\.\d{1,2})?$");
}
else if (dt == InputDataType.InputTypeZeroPossitiveInt)
{
regex = new Regex(@"^\d+$");
}
Boolean result = regex.IsMatch(tb.Text);
if (!result)
{
CMessageBox.Show(fmt, "ERROR", MessageBoxButton.OK, MessageBoxImage.Error);
tb.Focus();
return(false);
}
}
return(true);
}
public ConfigFileSection(string jsonPath, InputDataType dataType, string outputGroupDescriptor = null)
{
this.JsonPath = jsonPath;
this.DataType = dataType;
this.OutputGroupDescriptor = outputGroupDescriptor;
}
