/// <summary>
/// Resets writer structure.
/// </summary>
public void ResetWriteStructure()
{
lock (this)
{
_writerTypeStruct = null;
}
}
/** <inheritDoc /> */
public void UpdateReadStructure(int pathIdx, IList <BinaryStructureUpdate> updates)
{
lock (this)
{
_readerTypeStructure = _readerTypeStructure.Merge(pathIdx, updates);
}
}
/** <inheritDoc /> */
public void UpdateWriteStructure(BinaryStructure exp, int pathIdx, IList <BinaryStructureUpdate> updates)
{
lock (this)
{
_writerTypeStruct = _writerTypeStruct.Merge(exp, pathIdx, updates);
}
}
private ConfigurationReadResult ReadBinaryConfiguration([NotNull] Func <BackgroundWorker, byte[]> configurationProvider, bool useWorker = true)
{
if (configurationProvider == null)
{
throw new ArgumentNullException("configurationProvider");
}
try
{
var data = configurationProvider(useWorker ? m_worker : null);
if (data == null)
{
return(new ConfigurationReadResult(null, ReadResult.UnableToRead));
}
var info = BinaryStructure.ReadBinary <ArcticFoxConfiguration.DeviceInfo>(data);
if (info.SettingsVersion < SupportedSettingsVersion || info.FirmwareBuild < MinimumSupportedBuildNumber)
{
return(new ConfigurationReadResult(null, ReadResult.OutdatedFirmware));
}
if (info.SettingsVersion > SupportedSettingsVersion)
{
return(new ConfigurationReadResult(null, ReadResult.OutdatedToolbox));
}
var configuration = BinaryStructure.ReadBinary <ArcticFoxConfiguration>(data);
return(new ConfigurationReadResult(configuration, ReadResult.Success));
}
catch (TimeoutException)
{
return(new ConfigurationReadResult(null, ReadResult.UnableToRead));
}
}
public BinaryInfo(BinaryKind kind, BinaryStructure format, ICollection <InstructionSets> nativeTargets,
bool isDotNet, BinaryClrFlags clrFlags, string dotNetString)
{
Kind = kind;
Structure = format;
NativeTargets = nativeTargets;
IsDotNet = isDotNet;
ClrFlags = clrFlags;
DotNetVersionString = dotNetString;
}
private void WriteConfiguration()
{
var data = BinaryStructure.WriteBinary(m_deviceConfiguration);
try
{
HidConnector.Instance.WriteConfiguration(data, m_worker);
}
catch (TimeoutException)
{
InfoBox.Show("Unable to write configuration.");
}
}
private byte[] PrepairConfiguration(byte[] source, ArcticFoxConfiguration existedConfiguration = null)
{
var result = BinaryStructure.ReadBinary<ArcticFoxConfiguration>(m_encryption.Decode(source));
if (existedConfiguration == null)
{
SetSharedDeviceInfo(result.Info);
}
else
{
result.Info = existedConfiguration.Info;
}
return BinaryStructure.WriteBinary(result);
}
private void SaveAsMenuItem_Click(object sender, EventArgs e)
{
if (m_deviceConfiguration == null)
{
return;
}
var isBinary = ModifierKeys.HasFlag(Keys.Control) && ModifierKeys.HasFlag(Keys.Alt);
using (var sf = new SaveFileDialog {
Filter = FileFilters.ArcticFoxConfigFilter
})
{
if (sf.ShowDialog() != DialogResult.OK)
{
return;
}
try
{
SaveWorkspace();
var cfgCopy = BinaryStructure.Copy(m_deviceConfiguration);
{
cfgCopy.Info.FirmwareVersion = 0;
cfgCopy.Info.HardwareVersion = 0;
cfgCopy.Info.MaxPower = 0;
cfgCopy.Info.NumberOfBatteries = 0;
cfgCopy.Info.ProductId = string.Empty;
}
byte[] bytes;
if (isBinary)
{
bytes = BinaryStructure.WriteBinary(cfgCopy);
}
else
{
using (var ms = new MemoryStream())
{
Serializer.Write(new SerializableConfiguration(BinaryStructure.WriteToDictionary(cfgCopy)), ms);
bytes = ms.ToArray();
}
}
File.WriteAllBytes(sf.FileName, m_encryption.Encode(bytes));
}
catch (Exception ex)
{
Trace.ErrorException("An error occurred during save ArcticFox configuration.", ex);
}
}
}
/** <inheritDoc /> */
public void UpdateWriteStructure(int pathIdx, IList <BinaryStructureUpdate> updates)
{
lock (this)
{
if (_writerTypeStruct == null)
{
// Null struct serves as an indication of a binary type that has never been sent to the cluster,
// which is important for types without any fields.
_writerTypeStruct = BinaryStructure.CreateEmpty();
}
_writerTypeStruct = _writerTypeStruct.Merge(pathIdx, updates);
}
}
private void MonitoringProc()
{
while (true)
{
if (m_stopRequested)
{
return;
}
if (!m_isChartPaused)
{
byte[] bytes;
try
{
bytes = HidConnector.Instance.ReadMonitoringData();
}
catch (Exception)
{
break;
}
var data = BinaryStructure.ReadBinary <MonitoringData>(bytes);
var kvp = CreateMonitoringDataCollection(data);
UpdateUI(() =>
{
try
{
m_isChartUpdating = true;
UpdateSeries(kvp);
}
finally
{
m_isChartUpdating = false;
}
});
}
Thread.Sleep(RequestDataIntervalInMs);
}
if (EnsureConnection())
{
MonitoringProc();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BinaryFullTypeDescriptor"/> class,
/// copying values from specified descriptor.
/// </summary>
/// <param name="desc">The descriptor to copy from.</param>
/// <param name="type">Type.</param>
/// <param name="serializer">Serializer.</param>
/// <param name="isRegistered">Registered flag.</param>
public BinaryFullTypeDescriptor(BinaryFullTypeDescriptor desc, Type type,
IBinarySerializerInternal serializer, bool isRegistered)
{
_type = type;
_typeId = desc._typeId;
_typeName = desc._typeName;
_userType = desc._userType;
_nameMapper = desc._nameMapper;
_idMapper = desc._idMapper;
_serializer = serializer;
_keepDeserialized = desc._keepDeserialized;
_affKeyFieldName = desc._affKeyFieldName;
_isEnum = desc._isEnum;
_isRegistered = isRegistered;
_schema = desc._schema;
_writerTypeStruct = desc._writerTypeStruct;
_readerTypeStructure = desc._readerTypeStructure;
}
private void OpenConfigurationFile(ArcticFoxConfiguration existedConfiguration)
{
string fileName;
using (var op = new OpenFileDialog {
Filter = FileFilters.ArcticFoxConfigFilter
})
{
if (op.ShowDialog() != DialogResult.OK)
{
return;
}
fileName = op.FileName;
}
try
{
var existedInfoBlock = existedConfiguration != null?existedConfiguration.Info.Copy() : null;
var result = existedConfiguration ?? BinaryStructure.ReadBinary <ArcticFoxConfiguration>(m_encryption.Decode(Resources.new_configuration));
var serializableConfiguration = Serializer.Read <SerializableConfiguration>(new MemoryStream(m_encryption.Decode(File.ReadAllBytes(fileName))));
if (serializableConfiguration == null)
{
InfoBox.Show("Most likely you are trying to open an obsolete configuration file. This operation is not supported.");
return;
}
BinaryStructure.ReadFromDictionary(result, serializableConfiguration.GetDictionary());
if (existedInfoBlock != null)
{
result.Info = existedInfoBlock;
}
else
{
SetSharedDeviceInfo(result.Info);
}
OpenWorkspace(result);
}
catch (Exception ex)
{
Trace.Info(ex, "An error occurred during reading saved configuration file.");
InfoBox.Show("Most likely you are trying to open an obsolete configuration file. This operation is not supported.");
}
}
private void DeviceConnected(bool isConnected)
{
try
{
if (HidConnector.Instance.IsDeviceConnected && m_configuration.SynchronizeTimeWhenDeviceIsConnected)
{
var now = DateTime.Now;
var dateTime = new ArcticFoxConfiguration.DateTime
{
Year = (ushort)now.Year,
Month = (byte)now.Month,
Day = (byte)now.Day,
Hour = (byte)now.Hour,
Minute = (byte)now.Minute,
Second = (byte)now.Second
};
var data = BinaryStructure.WriteBinary(dateTime);
HidConnector.Instance.SetDateTime(data);
}
if (HidConnector.Instance.IsDeviceConnected && m_configuration.OpenArcticFoxConfigurationWhenDeviceIsConnected)
{
UpdateUI(() =>
{
var window = m_openedWindow;
if (window == null)
{
ArcticFoxConfigurationButton.PerformClick();
}
else if (window.GetType() == typeof(ArcticFoxConfigurationWindow))
{
NativeMethods.SetForegroundWindow(m_openedWindow.Handle);
}
});
}
}
catch (Exception)
{
// Ignore
}
}
