public void InspectDetails(DeviceViewModel deviceViewModel, bool showWorkUtility)
{
noDetailsPanel.Visible = false;
hashrateLabel.Text = deviceViewModel.AverageHashrate.ToHashrateString();
currentRateLabel.Text = deviceViewModel.CurrentHashrate.ToHashrateString();
workersGridView.Visible = (deviceViewModel.Workers.Count > 0);
workersTitleLabel.Visible = workersGridView.Visible;
SetupProxyDetails(deviceViewModel);
SetupNetworkDeviceDetails(deviceViewModel);
//device may not be configured
if (deviceViewModel.Coin != null)
cryptoCoinBindingSource.DataSource = deviceViewModel.Coin;
else
cryptoCoinBindingSource.DataSource = new CryptoCoin();
cryptoCoinBindingSource.ResetBindings(false);
deviceBindingSource.DataSource = deviceViewModel;
deviceBindingSource.ResetBindings(false);
workerBindingSource.DataSource = deviceViewModel.Workers;
workerBindingSource.ResetBindings(false);
SetupDevicePicture(deviceViewModel);
nameLabel.Width = this.Width - nameLabel.Left - closeDetailsButton.Width;
acceptedLabel.Text = deviceViewModel.AcceptedShares.ToString();
rejectedLabel.Text = deviceViewModel.RejectedShares.ToString();
errorsLabel.Text = deviceViewModel.HardwareErrors.ToString();
if (showWorkUtility)
{
utilityLabel.Text = deviceViewModel.WorkUtility.ToString();
utilityDataGridViewTextBoxColumn.DataPropertyName = "WorkUtility";
}
else
{
utilityLabel.Text = deviceViewModel.Utility.ToString();
utilityDataGridViewTextBoxColumn.DataPropertyName = "Utility";
}
utilityPrefixLabel.Text = showWorkUtility ? "Work utility:" : "Utility:";
if (deviceViewModel.Temperature > 0)
tempLabel.Text = deviceViewModel.Temperature + "°";
else
tempLabel.Text = String.Empty;
if (deviceViewModel.FanPercent > 0)
fanLabel.Text = deviceViewModel.FanPercent + "%";
else
fanLabel.Text = String.Empty;
UpdateColumnVisibility();
}
public void ApplyDeviceModels(List<Xgminer.Data.Device> deviceModels, List<NetworkDevices.NetworkDevice> networkDeviceModels,
List<Metadata.DeviceMetadata> deviceMetadata)
{
//add/update Devices from deviceModels
if (deviceModels != null)
{
foreach (Xgminer.Data.Device deviceModel in deviceModels)
{
DeviceViewModel deviceViewModel = Devices.SingleOrDefault(d => d.Equals(deviceModel));
if (deviceViewModel == null)
{
deviceViewModel = new DeviceViewModel();
Devices.Add(deviceViewModel);
}
ObjectCopier.CopyObject(deviceModel, deviceViewModel);
deviceViewModel.Visible = true;
}
}
//add/update Devices from networkDeviceModels
if (networkDeviceModels != null)
{
foreach (NetworkDevices.NetworkDevice networkDeviceModel in networkDeviceModels)
{
DeviceViewModel deviceViewModel = networkDeviceModel.ToViewModel();
if (Devices.SingleOrDefault(d => d.Equals(deviceViewModel)) == null)
{
deviceViewModel.Visible = false;
Devices.Add(deviceViewModel);
}
}
}
//remove entries from Devices not found in deviceModels or networkDeviceModels
foreach (DeviceViewModel deviceViewModel in Devices.ToList())
{
bool found = true;
if (deviceViewModel.Kind == DeviceKind.NET)
found = networkDeviceModels.Any(d => d.ToViewModel().Equals(deviceViewModel));
else
found = deviceModels.Any(d => d.Equals(deviceViewModel));
if (!found)
Devices.Remove(deviceViewModel);
}
//apply metadata
foreach (Metadata.DeviceMetadata metadata in deviceMetadata)
{
DeviceViewModel deviceViewModel = Devices.SingleOrDefault(d => d.Equals(metadata));
if (deviceViewModel != null)
ObjectCopier.CopyObject(metadata, deviceViewModel);
}
}
public static DeviceViewModel ToViewModel(this NetworkDevices.NetworkDevice networkDevice)
{
DeviceViewModel deviceViewModel = new DeviceViewModel
{
Kind = DeviceKind.NET,
Path = String.Format("{0}:{1}", networkDevice.IPAddress, networkDevice.Port),
Name = networkDevice.IPAddress,
Driver = "network"
};
return deviceViewModel;
}
//update percentage-based device stats by weighing each worker
private static void UpdatePercentagesBasedOnWorkers(DeviceViewModel deviceViewModel)
{
double totalHashrate = deviceViewModel.Workers.Sum(w => w.AverageHashrate);
double rejectedPercent = 0;
double errorPercent = 0;
foreach (DeviceViewModel worker in deviceViewModel.Workers)
{
double workerWeight = worker.AverageHashrate / totalHashrate;
errorPercent += worker.HardwareErrorsPercent * workerWeight;
rejectedPercent += worker.RejectedSharesPercent * workerWeight;
}
deviceViewModel.HardwareErrorsPercent = errorPercent;
deviceViewModel.RejectedSharesPercent = rejectedPercent;
}
public DeviceViewModel ApplyDeviceInformationResponseModel(DeviceDescriptor deviceModel, DeviceInformation deviceInformationResponseModel)
{
string[] excludedProperties =
{
"Name", //don't overwrite our "nice" name
"Kind", //we have our own enum Kind
"Enabled" //don't overwrite our own Enabled flag
};
DeviceViewModel deviceViewModel = Devices.SingleOrDefault(d => d.Equals(deviceModel));
if (deviceViewModel != null)
{
if ((deviceModel.Kind == DeviceKind.PXY) || (deviceModel.Kind == DeviceKind.NET))
{
deviceViewModel.PoolIndex = deviceInformationResponseModel.PoolIndex;
//we will get multiple deviceInformationResponseModels for the same deviceModel in the case of a Stratum Proxy
//bfgminer will report back for each Proxy Worker, but we only show a single entry in the ViewModel that rolls
//up the stats for individual Proxy Workers
deviceViewModel.AverageHashrate += deviceInformationResponseModel.AverageHashrate;
deviceViewModel.CurrentHashrate += deviceInformationResponseModel.CurrentHashrate;
deviceViewModel.AcceptedShares += deviceInformationResponseModel.AcceptedShares;
deviceViewModel.RejectedShares += deviceInformationResponseModel.RejectedShares;
deviceViewModel.HardwareErrors += deviceInformationResponseModel.HardwareErrors;
deviceViewModel.Utility += deviceInformationResponseModel.Utility;
deviceViewModel.WorkUtility += deviceInformationResponseModel.WorkUtility;
//now add as a worker
DeviceViewModel workerViewModel = new DeviceViewModel();
ObjectCopier.CopyObject(deviceInformationResponseModel, workerViewModel, excludedProperties);
workerViewModel.WorkerName = deviceInformationResponseModel.Name; //set a default until (if) we get details
deviceViewModel.Workers.Add(workerViewModel);
//recalculate hardware and rejected share percentages - need to be weighted with worker hashrates
UpdatePercentagesBasedOnWorkers(deviceViewModel);
}
else
{
ObjectCopier.CopyObject(deviceInformationResponseModel, deviceViewModel, excludedProperties);
}
}
return(deviceViewModel);
}
private static void ClearDeviceInformation(DeviceViewModel deviceViewModel)
{
deviceViewModel.AverageHashrate = 0;
deviceViewModel.CurrentHashrate = 0;
deviceViewModel.AcceptedShares = 0;
deviceViewModel.RejectedShares = 0;
deviceViewModel.HardwareErrors = 0;
deviceViewModel.Utility = 0;
deviceViewModel.WorkUtility = 0;
deviceViewModel.RejectedSharesPercent = 0;
deviceViewModel.HardwareErrorsPercent = 0;
deviceViewModel.Pool = String.Empty;
deviceViewModel.PoolIndex = -1;
deviceViewModel.FanPercent = 0;
deviceViewModel.Temperature = 0;
deviceViewModel.Intensity = String.Empty;
deviceViewModel.Workers.Clear();
}
public void ApplyDeviceDetailsResponseModels(List <DeviceDescriptor> processDevices, List <DeviceDetails> deviceDetailsList)
{
//for getting Proxy worker names
DeviceViewModel proxyDevice = Devices.SingleOrDefault(d => d.Enabled && (d.Kind == DeviceKind.PXY) && (processDevices.Any(d2 => d2.Equals(d))));
if (proxyDevice != null)
{
foreach (DeviceDetails deviceDetailsResponse in deviceDetailsList)
{
if (deviceDetailsResponse.Name.Equals("PXY"))
{
DeviceViewModel worker = proxyDevice.Workers.SingleOrDefault(w => w.ID == deviceDetailsResponse.ID);
if (worker != null)
{
worker.WorkerName = deviceDetailsResponse.DevicePath;
}
}
}
}
}
public void ApplyDeviceDetailsResponseModels(string coinSymbol, List <DeviceDetails> deviceDetailsList)
{
//for getting Proxy worker names
DeviceViewModel proxyDevice = Devices.SingleOrDefault(d => (d.Kind == DeviceKind.PXY) && (d.Coin != null) && d.Coin.Symbol.Equals(coinSymbol));
if (proxyDevice != null)
{
foreach (DeviceDetails deviceDetailsResponse in deviceDetailsList)
{
if (deviceDetailsResponse.Name.Equals("PXY"))
{
DeviceViewModel worker = proxyDevice.Workers.SingleOrDefault(w => w.ID == deviceDetailsResponse.ID);
if (worker != null)
{
worker.WorkerName = deviceDetailsResponse.DevicePath;
}
}
}
}
}
private void SetupDevicePicture(DeviceViewModel deviceViewModel)
{
switch (deviceViewModel.Kind)
{
case DeviceKind.CPU:
pictureBox1.Image = imageList1.Images[3];
break;
case DeviceKind.GPU:
pictureBox1.Image = imageList1.Images[0];
break;
case DeviceKind.USB:
pictureBox1.Image = imageList1.Images[1];
break;
case DeviceKind.PXY:
pictureBox1.Image = imageList1.Images[2];
break;
case DeviceKind.NET:
pictureBox1.Image = imageList1.Images[4];
break;
}
}
private void SetupNetworkDeviceDetails(DeviceViewModel deviceViewModel)
{
serialTitleLabel.Visible = deviceViewModel.Kind != DeviceKind.NET;
serialValueLabel.Visible = deviceViewModel.Kind != DeviceKind.NET;
processorsTitleLabel.Visible = deviceViewModel.Kind != DeviceKind.NET;
processorsValueLabel.Visible = deviceViewModel.Kind != DeviceKind.NET;
if (deviceViewModel.Kind == DeviceKind.NET)
{
pathValueLabel.Width = Width - pathValueLabel.Left - 6;
}
else
{
pathValueLabel.Width = serialTitleLabel.Left - pathValueLabel.Left - 6;
}
}
//update percentage-based device stats by weighing each worker
private static void UpdatePercentagesBasedOnWorkers(DeviceViewModel deviceViewModel)
{
double totalHashrate = deviceViewModel.Workers.Sum(w => w.AverageHashrate);
double rejectedPercent = 0;
double errorPercent = 0;
foreach (DeviceViewModel worker in deviceViewModel.Workers)
{
double workerWeight = worker.AverageHashrate / totalHashrate;
errorPercent += worker.HardwareErrorsPercent * workerWeight;
rejectedPercent += worker.RejectedSharesPercent * workerWeight;
}
deviceViewModel.HardwareErrorsPercent = errorPercent;
deviceViewModel.RejectedSharesPercent = rejectedPercent;
}
public void ApplyDeviceModels(List<Device> deviceModels)
{
foreach (Device deviceModel in deviceModels)
{
DeviceViewModel deviceViewModel = Devices.SingleOrDefault(d => d.Equals(deviceModel));
if (deviceViewModel == null)
{
deviceViewModel = new DeviceViewModel();
Devices.Add(deviceViewModel);
}
ObjectCopier.CopyObject(deviceModel, deviceViewModel);
}
}
public DeviceViewModel ApplyDeviceInformationResponseModel(Device deviceModel, DeviceInformationResponse deviceInformationResponseModel)
{
DeviceViewModel deviceViewModel = Devices.SingleOrDefault(d => d.Equals(deviceModel));
if (deviceViewModel != null)
{
if (deviceModel.Kind == DeviceKind.PXY)
{
deviceViewModel.PoolIndex = deviceInformationResponseModel.PoolIndex;
//we will get multiple deviceInformationResponseModels for the same deviceModel in the case of a Stratum Proxy
//bfgminer will report back for each Proxy Worker, but we only show a single entry in the ViewModel that rolls
//up the stats for individual Proxy Workers
deviceViewModel.AverageHashrate += deviceInformationResponseModel.AverageHashrate;
deviceViewModel.CurrentHashrate += deviceInformationResponseModel.AverageHashrate;
deviceViewModel.AcceptedShares += deviceInformationResponseModel.AcceptedShares;
deviceViewModel.RejectedShares += deviceInformationResponseModel.RejectedShares;
deviceViewModel.HardwareErrors += deviceInformationResponseModel.HardwareErrors;
deviceViewModel.Utility += deviceInformationResponseModel.Utility;
deviceViewModel.WorkUtility += deviceInformationResponseModel.WorkUtility;
deviceViewModel.RejectedSharesPercent += deviceInformationResponseModel.RejectedSharesPercent;
deviceViewModel.HardwareErrorsPercent += deviceInformationResponseModel.HardwareErrorsPercent;
//now add as a worker
DeviceViewModel workerViewModel = new DeviceViewModel();
ObjectCopier.CopyObject(deviceInformationResponseModel, workerViewModel, "Name", "Kind");
deviceViewModel.Workers.Add(workerViewModel);
}
else
{
ObjectCopier.CopyObject(deviceInformationResponseModel, deviceViewModel, "Name", "Kind");
}
}
return deviceViewModel;
}
public DeviceViewModel ApplyDeviceInformationResponseModel(DeviceDescriptor deviceModel, DeviceInformation deviceInformationResponseModel)
{
string[] excludedProperties =
{
"Name", //don't overwrite our "nice" name
"Kind", //we have our own enum Kind
"Enabled" //don't overwrite our own Enabled flag
};
DeviceViewModel deviceViewModel = Devices.SingleOrDefault(d => d.Equals(deviceModel));
if (deviceViewModel != null)
{
if ((deviceModel.Kind == DeviceKind.PXY) || (deviceModel.Kind == DeviceKind.NET))
{
deviceViewModel.PoolIndex = deviceInformationResponseModel.PoolIndex;
//we will get multiple deviceInformationResponseModels for the same deviceModel in the case of a Stratum Proxy
//bfgminer will report back for each Proxy Worker, but we only show a single entry in the ViewModel that rolls
//up the stats for individual Proxy Workers
deviceViewModel.AverageHashrate += deviceInformationResponseModel.AverageHashrate;
deviceViewModel.CurrentHashrate += deviceInformationResponseModel.CurrentHashrate;
deviceViewModel.AcceptedShares += deviceInformationResponseModel.AcceptedShares;
deviceViewModel.RejectedShares += deviceInformationResponseModel.RejectedShares;
deviceViewModel.HardwareErrors += deviceInformationResponseModel.HardwareErrors;
deviceViewModel.Utility += deviceInformationResponseModel.Utility;
deviceViewModel.WorkUtility += deviceInformationResponseModel.WorkUtility;
//now add as a worker
DeviceViewModel workerViewModel = new DeviceViewModel();
ObjectCopier.CopyObject(deviceInformationResponseModel, workerViewModel, excludedProperties);
workerViewModel.WorkerName = deviceInformationResponseModel.Name; //set a default until (if) we get details
deviceViewModel.Workers.Add(workerViewModel);
//recalculate hardware and rejected share percentages - need to be weighted with worker hashrates
UpdatePercentagesBasedOnWorkers(deviceViewModel);
}
else
{
ObjectCopier.CopyObject(deviceInformationResponseModel, deviceViewModel, excludedProperties);
}
}
return deviceViewModel;
}
private void RenameDevice(DeviceViewModel deviceViewModel, string name)
{
//rename the device in the user metadata
Metadata.DeviceMetadata deviceData = metadataConfiguration.Devices.SingleOrDefault(d => d.Equals(deviceViewModel));
if (deviceData == null)
{
deviceData = new Metadata.DeviceMetadata();
ObjectCopier.CopyObject(deviceViewModel, deviceData);
metadataConfiguration.Devices.Add(deviceData);
}
deviceData.FriendlyName = name;
metadataConfiguration.SaveDeviceMetadataConfiguration();
//rename the device ViewModel itself
deviceViewModel.FriendlyName = name;
}
private ListViewItem GetListViewItemForDeviceViewModel(DeviceViewModel deviceViewModel)
{
foreach (ListViewItem item in deviceListView.Items)
{
if (item.Tag == deviceViewModel)
return item;
}
return null;
}
public void ApplyDeviceModels(List <Xgminer.Data.Device> deviceModels, List <NetworkDevices.NetworkDevice> networkDeviceModels,
List <Metadata.DeviceMetadata> deviceMetadata)
{
//add/update Devices from deviceModels
if (deviceModels != null)
{
foreach (Xgminer.Data.Device deviceModel in deviceModels)
{
DeviceViewModel deviceViewModel = Devices.SingleOrDefault(d => d.Equals(deviceModel));
if (deviceViewModel == null)
{
deviceViewModel = new DeviceViewModel();
Devices.Add(deviceViewModel);
}
ObjectCopier.CopyObject(deviceModel, deviceViewModel);
deviceViewModel.Visible = true;
}
}
//add/update Devices from networkDeviceModels
if (networkDeviceModels != null)
{
foreach (NetworkDevices.NetworkDevice networkDeviceModel in networkDeviceModels)
{
DeviceViewModel deviceViewModel = networkDeviceModel.ToViewModel();
if (Devices.SingleOrDefault(d => d.Equals(deviceViewModel)) == null)
{
//set Visible to false until we have details
deviceViewModel.Visible = false;
//network devices always enabled
deviceViewModel.Enabled = true;
//assume BTC until we have pool info
deviceViewModel.Coin = new CryptoCoin()
{
Name = KnownCoins.BitcoinName,
Symbol = KnownCoins.BitcoinSymbol,
Algorithm = CoinAlgorithm.SHA256
};
Devices.Add(deviceViewModel);
}
}
}
//apply metadata ASAP for MobileMiner
foreach (Metadata.DeviceMetadata metadata in deviceMetadata)
{
DeviceViewModel deviceViewModel = Devices.SingleOrDefault(d => d.Equals(metadata));
if (deviceViewModel != null)
{
ObjectCopier.CopyObject(metadata, deviceViewModel);
}
}
//remove entries from Devices not found in deviceModels or networkDeviceModels
foreach (DeviceViewModel deviceViewModel in Devices.ToList())
{
bool found = true;
if (deviceViewModel.Kind == DeviceKind.NET)
{
found = networkDeviceModels.Any(d => d.ToViewModel().Equals(deviceViewModel));
}
else
{
found = deviceModels.Any(d => d.Equals(deviceViewModel));
}
if (!found)
{
Devices.Remove(deviceViewModel);
}
}
}
private void SetupProxyDetails(DeviceViewModel deviceViewModel)
{
proxyInfoPanel.Visible = false;
if (deviceViewModel.Kind == DeviceKind.PXY)
{
string[] ports = deviceViewModel.Path.Split(':');
if (ports.Length == 2)
{
string localIPAddress = LocalNetwork.GetLocalIPAddress();
proxyGetworkLabel.Text = String.Format("http://{0}:{1}", localIPAddress, ports[0]);
proxyStratumLabel.Text = String.Format("stratum+tcp://{0}:{1}", localIPAddress, ports[1]);
proxyInfoPanel.BringToFront();
proxyInfoPanel.Visible = true;
}
}
}
private static void ApplyCoinInformationToViewModel(List <CoinInformation> coinInformationModels, string coinSymbol, DeviceViewModel deviceViewModel)
{
CoinInformation coinInformationModel = coinInformationModels.SingleOrDefault(c => c.Symbol.Equals(coinSymbol, StringComparison.OrdinalIgnoreCase));
if (coinInformationModel != null)
{
ObjectCopier.CopyObject(coinInformationModel, deviceViewModel, "Name", "Exchange");
}
}
public void ApplyDeviceModels(List <Xgminer.Data.Device> deviceModels, List <NetworkDevices.NetworkDevice> networkDeviceModels,
List <Metadata.DeviceMetadata> deviceMetadata)
{
//add/update Devices from deviceModels
if (deviceModels != null)
{
foreach (Xgminer.Data.Device deviceModel in deviceModels)
{
DeviceViewModel deviceViewModel = Devices.SingleOrDefault(d => d.Equals(deviceModel));
if (deviceViewModel == null)
{
deviceViewModel = new DeviceViewModel();
Devices.Add(deviceViewModel);
}
ObjectCopier.CopyObject(deviceModel, deviceViewModel);
deviceViewModel.Visible = true;
}
}
//add/update Devices from networkDeviceModels
if (networkDeviceModels != null)
{
foreach (NetworkDevices.NetworkDevice networkDeviceModel in networkDeviceModels)
{
DeviceViewModel deviceViewModel = networkDeviceModel.ToViewModel();
if (Devices.SingleOrDefault(d => d.Equals(deviceViewModel)) == null)
{
deviceViewModel.Visible = false;
Devices.Add(deviceViewModel);
}
}
}
//remove entries from Devices not found in deviceModels or networkDeviceModels
foreach (DeviceViewModel deviceViewModel in Devices.ToList())
{
bool found = true;
if (deviceViewModel.Kind == DeviceKind.NET)
{
found = networkDeviceModels.Any(d => d.ToViewModel().Equals(deviceViewModel));
}
else
{
found = deviceModels.Any(d => d.Equals(deviceViewModel));
}
if (!found)
{
Devices.Remove(deviceViewModel);
}
}
//apply metadata
foreach (Metadata.DeviceMetadata metadata in deviceMetadata)
{
DeviceViewModel deviceViewModel = Devices.SingleOrDefault(d => d.Equals(metadata));
if (deviceViewModel != null)
{
ObjectCopier.CopyObject(metadata, deviceViewModel);
}
}
}
public void ApplyDeviceModels(List<Xgminer.Data.Device> deviceModels, List<NetworkDevices.NetworkDevice> networkDeviceModels,
List<Metadata.DeviceMetadata> deviceMetadata)
{
//add/update Devices from deviceModels
if (deviceModels != null)
{
foreach (Xgminer.Data.Device deviceModel in deviceModels)
{
DeviceViewModel deviceViewModel = Devices.SingleOrDefault(d => d.Equals(deviceModel));
if (deviceViewModel == null)
{
deviceViewModel = new DeviceViewModel();
Devices.Add(deviceViewModel);
}
ObjectCopier.CopyObject(deviceModel, deviceViewModel);
deviceViewModel.Visible = true;
}
}
//add/update Devices from networkDeviceModels
if (networkDeviceModels != null)
{
foreach (NetworkDevices.NetworkDevice networkDeviceModel in networkDeviceModels)
{
DeviceViewModel deviceViewModel = networkDeviceModel.ToViewModel();
if (Devices.SingleOrDefault(d => d.Equals(deviceViewModel)) == null)
{
//set Visible to false until we have details
deviceViewModel.Visible = false;
//network devices always enabled
deviceViewModel.Enabled = true;
//assume BTC until we have pool info
deviceViewModel.Coin = new CryptoCoin()
{
Name = KnownCoins.BitcoinName,
Symbol = KnownCoins.BitcoinSymbol,
Algorithm = CoinAlgorithm.SHA256
};
Devices.Add(deviceViewModel);
}
}
}
//apply metadata ASAP for MobileMiner
foreach (Metadata.DeviceMetadata metadata in deviceMetadata)
{
DeviceViewModel deviceViewModel = Devices.SingleOrDefault(d => d.Equals(metadata));
if (deviceViewModel != null)
ObjectCopier.CopyObject(metadata, deviceViewModel);
}
//remove entries from Devices not found in deviceModels or networkDeviceModels
foreach (DeviceViewModel deviceViewModel in Devices.ToList())
{
bool found = true;
if (deviceViewModel.Kind == DeviceKind.NET)
found = networkDeviceModels.Any(d => d.ToViewModel().Equals(deviceViewModel));
else
found = deviceModels.Any(d => d.Equals(deviceViewModel));
if (!found)
Devices.Remove(deviceViewModel);
}
}
private ListViewItem FindOrAddListViewItemForViewModel(DeviceViewModel deviceViewModel)
{
ListViewItem listViewItem = GetListViewItemForDeviceViewModel(deviceViewModel);
if (listViewItem != null)
return listViewItem;
listViewItem = new ListViewItem();
switch (deviceViewModel.Kind)
{
case DeviceKind.CPU:
listViewItem.Group = deviceListView.Groups["cpuListViewGroup"];
listViewItem.ImageIndex = 3;
break;
case DeviceKind.GPU:
listViewItem.Group = deviceListView.Groups["gpuListViewGroup"];
listViewItem.ImageIndex = 0;
break;
case DeviceKind.USB:
listViewItem.Group = deviceListView.Groups["usbListViewGroup"];
listViewItem.ImageIndex = 1;
break;
case DeviceKind.PXY:
listViewItem.Group = deviceListView.Groups["proxyListViewGroup"];
listViewItem.ImageIndex = 2;
break;
case DeviceKind.NET:
listViewItem.Group = deviceListView.Groups["networkListViewGroup"];
listViewItem.ImageIndex = 4;
break;
}
listViewItem.Text = deviceViewModel.Name;
//start at i = 1, skip the first column
for (int i = 1; i < deviceListView.Columns.Count; i++)
{
listViewItem.SubItems.Add(new ListViewItem.ListViewSubItem(listViewItem, String.Empty)
{
Name = deviceListView.Columns[i].Text,
ForeColor = SystemColors.WindowFrame
});
}
listViewItem.SubItems["Coin"].ForeColor = SystemColors.WindowText;
listViewItem.SubItems["Errors"].ForeColor = SystemColors.WindowText;
listViewItem.SubItems["Rejected"].ForeColor = SystemColors.WindowText;
listViewItem.UseItemStyleForSubItems = false;
listViewItem.Checked = deviceViewModel.Enabled;
listViewItem.SubItems["Driver"].Text = deviceViewModel.Driver;
deviceListView.Items.Add(listViewItem);
listViewItem.Tag = deviceViewModel;
return listViewItem;
}
private static void ApplyCoinInformationToViewModel(List<CoinInformation> coinInformationModels, string coinSymbol, DeviceViewModel deviceViewModel)
{
CoinInformation coinInformationModel = coinInformationModels.SingleOrDefault(c => c.Symbol.Equals(coinSymbol, StringComparison.OrdinalIgnoreCase));
if (coinInformationModel != null)
ObjectCopier.CopyObject(coinInformationModel, deviceViewModel, "Name", "Exchange");
}
private void PopulateIncomeForListViewItem(ListViewItem item, DeviceViewModel deviceViewModel)
{
item.SubItems["Daily"].Text = String.Empty;
//check for Coin != null, device may not have a coin configured
if (deviceViewModel.Coin == null)
return;
//check .Mining to allow perks for Remoting when local PC is not mining
if (!((miningEngine.Donating || !miningEngine.Mining) && perksConfiguration.ShowIncomeRates))
return;
if (coinApiInformation == null)
//no internet or error parsing API
return;
CoinInformation info = coinApiInformation.SingleOrDefault(c => c.Symbol.Equals(deviceViewModel.Coin.Symbol, StringComparison.OrdinalIgnoreCase));
if (info != null)
{
double difficulty = (double)item.SubItems["Difficulty"].Tag;
double hashrate = deviceViewModel.CurrentHashrate * 1000;
double fullDifficulty = difficulty * difficultyMuliplier;
double secondsToCalcShare = fullDifficulty / hashrate;
const double secondsPerDay = 86400;
double sharesPerDay = secondsPerDay / secondsToCalcShare;
double rewardPerDay = sharesPerDay * info.Reward;
deviceViewModel.Daily = rewardPerDay;
if (perksConfiguration.ShowExchangeRates && perksConfiguration.ShowIncomeInUsd)
{
//item.SubItems["Exchange"].Tag may be null
double exchangeRate = item.SubItems["Exchange"].Tag == null ? 0 : (double)item.SubItems["Exchange"].Tag;
double fiatPerDay = rewardPerDay * exchangeRate;
if (fiatPerDay > 0.00)
item.SubItems["Daily"].Text = String.Format("${0}", fiatPerDay.ToFriendlyString(true));
}
else
{
if (rewardPerDay > 0.00)
item.SubItems["Daily"].Text = String.Format("{0} {1}", rewardPerDay.ToFriendlyString(), info.Symbol);
}
}
}
private static void ClearDeviceInformation(DeviceViewModel deviceViewModel)
{
deviceViewModel.AverageHashrate = 0;
deviceViewModel.CurrentHashrate = 0;
deviceViewModel.AcceptedShares = 0;
deviceViewModel.RejectedShares = 0;
deviceViewModel.HardwareErrors = 0;
deviceViewModel.Utility = 0;
deviceViewModel.WorkUtility = 0;
deviceViewModel.RejectedSharesPercent = 0;
deviceViewModel.HardwareErrorsPercent = 0;
deviceViewModel.Pool = String.Empty;
deviceViewModel.PoolIndex = -1;
deviceViewModel.FanPercent = 0;
deviceViewModel.Temperature = 0;
deviceViewModel.Intensity = String.Empty;
deviceViewModel.Workers.Clear();
}
private void SaveDeviceTransferObjects(IEnumerable<Remoting.Data.Transfer.Device> devices)
{
remoteViewModel.Devices.Clear();
foreach (Remoting.Data.Transfer.Device dto in devices)
{
DeviceViewModel viewModel = new DeviceViewModel();
ObjectCopier.CopyObject(dto, viewModel, "Workers");
foreach (Remoting.Data.Transfer.Device source in dto.Workers)
{
DeviceViewModel destination = new DeviceViewModel();
ObjectCopier.CopyObject(source, destination, "Workers");
viewModel.Workers.Add(destination);
}
remoteViewModel.Devices.Add(viewModel);
}
}
public void ApplyDeviceModels(List<Device> deviceModels, List<NetworkDevicesConfiguration.NetworkDevice> networkDeviceModels)
{
if (deviceModels != null)
{
foreach (Device deviceModel in deviceModels)
{
DeviceViewModel deviceViewModel = Devices.SingleOrDefault(d => d.Equals(deviceModel));
if (deviceViewModel == null)
{
deviceViewModel = new DeviceViewModel();
Devices.Add(deviceViewModel);
}
ObjectCopier.CopyObject(deviceModel, deviceViewModel);
deviceViewModel.Visible = true;
}
}
if (networkDeviceModels != null)
{
foreach (NetworkDevicesConfiguration.NetworkDevice networkDeviceModel in networkDeviceModels)
{
DeviceViewModel deviceViewModel = new DeviceViewModel
{
Kind = DeviceKind.NET,
Path = String.Format("{0}:{1}", networkDeviceModel.IPAddress, networkDeviceModel.Port),
Name = networkDeviceModel.IPAddress,
Driver = "network"
};
if (Devices.SingleOrDefault(d => d.Equals(deviceViewModel)) == null)
{
deviceViewModel.Visible = false;
Devices.Add(deviceViewModel);
}
}
}
}
