private MinerConfiguration CreateMinerConfiguration(int port, string coinSymbol, DeviceKind includeKinds)
{
CoinConfiguration coinConfiguration = engineConfiguration.CoinConfigurations.Single(c => c.Coin.Symbol.Equals(coinSymbol));
IList <DeviceConfiguration> enabledConfigurations = engineConfiguration.DeviceConfigurations.Where(c => c.Enabled && c.CoinSymbol.Equals(coinSymbol)).ToList();
MinerConfiguration minerConfiguration = new MinerConfiguration()
{
ExecutablePath = MinerPath.GetPathToInstalledMiner(),
Algorithm = coinConfiguration.Coin.Algorithm,
ApiPort = port,
ApiListen = true,
AllowedApiIps = engineConfiguration.XgminerConfiguration.AllowedApiIps,
CoinName = coinConfiguration.Coin.Name,
DisableGpu = engineConfiguration.XgminerConfiguration.DisableGpu
};
SetupConfigurationPools(minerConfiguration, coinConfiguration);
int deviceCount = SetupConfigurationDevices(minerConfiguration, includeKinds, enabledConfigurations);
if (deviceCount == 0)
{
return(null);
}
SetupConfigurationArguments(minerConfiguration, coinConfiguration);
return(minerConfiguration);
}
private void AddCoinConfiguration(CryptoCoin cryptoCoin)
{
CoinConfiguration configuration = configurations.SingleOrDefault(c => c.Coin.Symbol.Equals(cryptoCoin.Symbol));
if (configuration != null)
{
coinListBox.SelectedIndex = configurations.IndexOf(configuration);
}
else
{
configuration = new CoinConfiguration();
configuration.Coin = knownCoins.SingleOrDefault(c => c.Symbol.Equals(cryptoCoin.Symbol, StringComparison.OrdinalIgnoreCase));
//user may have manually entered a coin
if (configuration.Coin == null)
{
configuration.Coin = new CryptoCoin();
configuration.Coin.Name = cryptoCoin.Name;
configuration.Coin.Symbol = cryptoCoin.Symbol;
configuration.Coin.Algorithm = cryptoCoin.Algorithm;
}
configuration.Pools.Add(new MiningPool());
configurations.Add(configuration);
coinListBox.Items.Add(configuration.Coin.Name);
coinListBox.SelectedIndex = configurations.IndexOf(configuration);
}
hostEdit.Focus();
}
private EngineConfiguration CreateEngineConfiguration()
{
EngineConfiguration engineConfiguration;
engineConfiguration = new EngineConfiguration();
engineConfiguration.XgminerConfiguration.MinerBackend = MinerBackend.Cgminer;
if (minerComboBox.SelectedIndex == 1)
{
engineConfiguration.XgminerConfiguration.MinerBackend = MinerBackend.Bfgminer;
}
CoinConfiguration coinConfiguration = new CoinConfiguration();
CryptoCoin coin = coins.Single(c => c.Name.Equals(coinComboBox.Text));
coinConfiguration.Coin = coin;
coinConfiguration.Enabled = true;
MiningPool miningPool = new MiningPool();
miningPool.Host = hostEdit.Text;
miningPool.Port = Int32.Parse(portEdit.Text);
miningPool.Username = usernameEdit.Text;
miningPool.Password = passwordEdit.Text;
coinConfiguration.Pools.Add(miningPool);
engineConfiguration.CoinConfigurations.Add(coinConfiguration);
return(engineConfiguration);
}
private void addPoolButton_Click(object sender, EventArgs e)
{
CoinConfiguration configuration = configurations[coinListBox.SelectedIndex];
miningPoolBindingSource.Add(new MiningPool());
poolListBox.SelectedIndex = configuration.Pools.Count - 1;
hostEdit.Focus();
}
private void adjustProfitCombo_SelectedIndexChanged(object sender, EventArgs e)
{
if (coinConfigurationBindingSource.Current == null)
{
return;
}
CoinConfiguration currentConfiguration = (CoinConfiguration)coinConfigurationBindingSource.Current;
currentConfiguration.ProfitabilityAdjustmentType = (CoinConfiguration.AdjustmentType)((ComboBox)sender).SelectedIndex;
}
private void coinConfigurationBindingSource_CurrentChanged(object sender, EventArgs e)
{
if (coinConfigurationBindingSource.Current == null)
{
return;
}
CoinConfiguration currentConfiguration = (CoinConfiguration)coinConfigurationBindingSource.Current;
adjustProfitCombo.SelectedIndex = (int)currentConfiguration.ProfitabilityAdjustmentType;
}
private void MoveCoinToIndex(string coinName, int index)
{
CoinConfiguration configuration = configurations.Single(
config => config.Coin.Name.Equals(coinName, StringComparison.OrdinalIgnoreCase));
configurations.Remove(configuration);
configurations.Insert(index, configuration);
coinListBox.Items.Remove(coinName);
coinListBox.Items.Insert(index, coinName);
coinListBox.SelectedIndex = index;
}
private void coinListBox_SelectedIndexChanged(object sender, EventArgs e)
{
if (coinListBox.SelectedIndex >= 0)
{
CoinConfiguration configuration = configurations[coinListBox.SelectedIndex];
coinConfigurationBindingSource.DataSource = configuration;
miningPoolBindingSource.DataSource = configuration.Pools;
poolListBox.DataSource = miningPoolBindingSource;
poolListBox.DisplayMember = "Host";
}
UpdateButtonStates();
}
private MinerConfiguration CreateMinerConfiguration(int port, string coinSymbol)
{
CoinConfiguration coinConfiguration = engineConfiguration.CoinConfigurations.Single(c => c.Coin.Symbol.Equals(coinSymbol));
IEnumerable <DeviceConfiguration> coinGpuConfigurations = engineConfiguration.DeviceConfigurations.Where(c => c.Enabled && c.CoinSymbol.Equals(coinSymbol));
MinerConfiguration minerConfiguration = new MinerConfiguration();
minerConfiguration.MinerBackend = engineConfiguration.XgminerConfiguration.MinerBackend;
minerConfiguration.ExecutablePath = MinerPath.GetPathToInstalledMiner(minerConfiguration.MinerBackend);
minerConfiguration.ErupterDriver = engineConfiguration.XgminerConfiguration.ErupterDriver;
minerConfiguration.Pools = coinConfiguration.Pools;
minerConfiguration.Algorithm = coinConfiguration.Coin.Algorithm;
minerConfiguration.ApiPort = port;
minerConfiguration.ApiListen = true;
minerConfiguration.AllowedApiIps = engineConfiguration.XgminerConfiguration.AllowedApiIps;
minerConfiguration.CoinName = coinConfiguration.Coin.Name;
minerConfiguration.DisableGpu = engineConfiguration.XgminerConfiguration.DisableGpu;
foreach (DeviceConfiguration coinGpuConfiguration in coinGpuConfigurations)
{
minerConfiguration.DeviceIndexes.Add(coinGpuConfiguration.DeviceIndex);
}
string arguments = string.Empty;
//apply algorithm-specific parameters
if (engineConfiguration.XgminerConfiguration.AlgorithmFlags.ContainsKey(coinConfiguration.Coin.Algorithm))
{
arguments = String.Format("{0} {1}", arguments,
engineConfiguration.XgminerConfiguration.AlgorithmFlags[coinConfiguration.Coin.Algorithm]);
}
//apply coin-specific parameters
if (!string.IsNullOrEmpty(coinConfiguration.MinerFlags))
{
arguments = string.Format("{0} {1}", arguments, coinConfiguration.MinerFlags);
}
if (engineConfiguration.XgminerConfiguration.DesktopMode)
{
arguments = arguments + " -I D";
}
minerConfiguration.Arguments = arguments;
return(minerConfiguration);
}
private readonly Random random = new Random(Guid.NewGuid().GetHashCode()); //seed so we don't keep getting the same indexes
private void AddDonationPool(string coinSymbol, MinerConfiguration minerConfiguration)
{
MiningPool donationPool = null;
CoinConfiguration donationConfiguration = this.donationConfigurations.SingleOrDefault(dc => dc.Coin.Symbol.Equals(coinSymbol, StringComparison.OrdinalIgnoreCase));
if (donationConfiguration != null)
{
//inclusive lower, exclusive upper
int index = random.Next(0, donationConfiguration.Pools.Count);
donationPool = donationConfiguration.Pools[index];
}
if (donationPool != null)
{
donationPool.Quota = 1; //1% donation
minerConfiguration.Pools.Add(donationPool);
}
}
private void ApplyProfitabilityAdjustments(IEnumerable <CoinInformation> coinInformation)
{
foreach (CoinInformation configuredProfitableCoin in coinInformation)
{
CoinConfiguration coinConfiguration = engineConfiguration.CoinConfigurations.Single(c => c.Coin.Symbol.Equals(configuredProfitableCoin.Symbol));
if (coinConfiguration.ProfitabilityAdjustmentType == CoinConfiguration.AdjustmentType.Addition)
{
configuredProfitableCoin.AdjustedProfitability += coinConfiguration.ProfitabilityAdjustment;
configuredProfitableCoin.AverageProfitability += coinConfiguration.ProfitabilityAdjustment;
configuredProfitableCoin.Profitability += coinConfiguration.ProfitabilityAdjustment;
}
else if (coinConfiguration.ProfitabilityAdjustmentType == CoinConfiguration.AdjustmentType.Multiplication)
{
configuredProfitableCoin.AdjustedProfitability *= coinConfiguration.ProfitabilityAdjustment;
configuredProfitableCoin.AverageProfitability *= coinConfiguration.ProfitabilityAdjustment;
configuredProfitableCoin.Profitability *= coinConfiguration.ProfitabilityAdjustment;
}
}
}
private void SetupConfigurationPools(MinerConfiguration minerConfiguration, CoinConfiguration coinConfiguration)
{
//minerConfiguration.Pools = coinConfiguration.Pools;
foreach (MiningPool pool in coinConfiguration.Pools)
{
pool.Quota = 0;
minerConfiguration.Pools.Add(pool);
}
//using bfgminer quotas for failover, that way we can augment for donations
minerConfiguration.Pools.First().Quota = 100 - donationPercent;
if (donationPercent > 0)
{
AddDonationPool(coinConfiguration.Coin.Symbol, minerConfiguration);
}
foreach (MiningPool pool in minerConfiguration.Pools)
{
pool.QuotaEnabled = donationPercent > 0;
}
}
private void removeCoinButton_Click(object sender, EventArgs e)
{
DialogResult promptResult = MessageBox.Show("Remove the selected coin configuration?", "Confirm", MessageBoxButtons.YesNo);
if (promptResult == System.Windows.Forms.DialogResult.Yes)
{
//required to clear bindings if this was the last coin in the list
coinConfigurationBindingSource.DataSource = typeof(CoinConfiguration);
miningPoolBindingSource.DataSource = typeof(MiningPool);
CoinConfiguration configuration = configurations[coinListBox.SelectedIndex];
configurations.Remove(configuration);
coinListBox.Items.RemoveAt(coinListBox.SelectedIndex);
//select a coin - otherwise nothing will be selected
if (configurations.Count > 0)
{
coinListBox.SelectedIndex = 0;
}
}
}
private readonly Random random = new Random(Guid.NewGuid().GetHashCode()); //seed so we don't keep getting the same indexes
private void AddDonationPool(string coinSymbol, MinerConfiguration minerConfiguration)
{
MiningPool donationPool = null;
CoinConfiguration donationConfiguration = this.donationConfigurations.SingleOrDefault(dc => dc.Coin.Symbol.Equals(coinSymbol, StringComparison.OrdinalIgnoreCase));
if (donationConfiguration != null)
{
//inclusive lower, exclusive upper
//int index = random.Next(0, donationConfiguration.Pools.Count);
//for now just use the first pool, too many donors is *not* an issue
//if it becomes an issue we can revert to the above
int index = 0;
donationPool = donationConfiguration.Pools[index];
}
if (donationPool != null)
{
donationPool.Quota = donationPercent;
minerConfiguration.Pools.Add(donationPool);
}
}
private void HandleCoinButtonClick(object sender, EventArgs e)
{
string clickedSymbol = (string)((ToolStripButton)sender).Tag;
CoinConfiguration configuration = configurations.SingleOrDefault(c => c.Coin.Symbol.Equals(clickedSymbol));
if (configuration != null)
{
coinListBox.SelectedIndex = configurations.IndexOf(configuration);
}
else
{
configuration = new CoinConfiguration();
configuration.Coin = knownCoins.Single(c => c.Symbol.Equals(clickedSymbol));
configuration.Pools.Add(new MiningPool());
configurations.Add(configuration);
coinListBox.Items.Add(configuration.Coin.Name);
coinListBox.SelectedIndex = configurations.IndexOf(configuration);
}
hostEdit.Focus();
}
private MinerConfiguration CreateMinerConfiguration(int port, string coinSymbol, DeviceKind includeKinds)
{
CoinConfiguration coinConfiguration = engineConfiguration.CoinConfigurations.Single(c => c.Coin.Symbol.Equals(coinSymbol));
IList <DeviceConfiguration> enabledConfigurations = engineConfiguration.DeviceConfigurations.Where(c => c.Enabled && c.CoinSymbol.Equals(coinSymbol)).ToList();
MinerConfiguration minerConfiguration = new MinerConfiguration();
minerConfiguration.ExecutablePath = MinerPath.GetPathToInstalledMiner();
//minerConfiguration.Pools = coinConfiguration.Pools;
foreach (MiningPool pool in coinConfiguration.Pools)
{
pool.Quota = 0;
minerConfiguration.Pools.Add(pool);
}
//using bfgminer quotas for failover, that way we can augment for donations
minerConfiguration.Pools.First().Quota = 100;
if (donating)
{
minerConfiguration.Pools.First().Quota--; //99%
AddDonationPool(coinSymbol, minerConfiguration);
}
minerConfiguration.Algorithm = coinConfiguration.Coin.Algorithm;
minerConfiguration.ApiPort = port;
minerConfiguration.ApiListen = true;
minerConfiguration.AllowedApiIps = engineConfiguration.XgminerConfiguration.AllowedApiIps;
minerConfiguration.CoinName = coinConfiguration.Coin.Name;
minerConfiguration.DisableGpu = engineConfiguration.XgminerConfiguration.DisableGpu;
int deviceCount = 0;
for (int i = 0; i < enabledConfigurations.Count; i++)
{
DeviceConfiguration enabledConfiguration = enabledConfigurations[i];
Device device = devices.SingleOrDefault(d => d.Equals(enabledConfiguration));
if ((includeKinds & device.Kind) == 0)
{
continue;
}
deviceCount++;
//don't actually add stratum device as a device index
if (device.Kind != DeviceKind.PXY)
{
minerConfiguration.DeviceDescriptors.Add(device);
}
else
{
//only enable the stratum proxy if these devices contain the PXY device
minerConfiguration.StratumProxy = engineConfiguration.XgminerConfiguration.StratumProxy;
minerConfiguration.StratumProxyPort = engineConfiguration.XgminerConfiguration.StratumProxyPort;
minerConfiguration.StratumProxyStratumPort = engineConfiguration.XgminerConfiguration.StratumProxyStratumPort;
}
}
if (deviceCount == 0)
{
return(null);
}
string arguments = string.Empty;
//apply algorithm-specific parameters
if (engineConfiguration.XgminerConfiguration.AlgorithmFlags.ContainsKey(coinConfiguration.Coin.Algorithm))
{
arguments = String.Format("{0} {1}", arguments,
engineConfiguration.XgminerConfiguration.AlgorithmFlags[coinConfiguration.Coin.Algorithm]);
}
//apply coin-specific parameters
if (!string.IsNullOrEmpty(coinConfiguration.MinerFlags))
{
arguments = string.Format("{0} {1}", arguments, coinConfiguration.MinerFlags);
}
if (engineConfiguration.XgminerConfiguration.DesktopMode)
{
arguments = arguments + " -I D";
}
if (donating)
{
arguments = arguments + " --load-balance";
}
minerConfiguration.Arguments = arguments;
return(minerConfiguration);
}
public static void Seed(List <CoinConfiguration> configurations)
{
//BTC
CoinConfiguration donationConfiguration = new CoinConfiguration();
donationConfiguration.Coin.Symbol = "BTC";
MiningPool donationPool = new MiningPool()
{
Host = "stratum+tcp://stratum.mining.eligius.st",
Port = 3334,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
donationPool = new MiningPool()
{
Host = "stratum+tcp://mint.bitminter.com",
Port = 3333,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
donationPool = new MiningPool()
{
Host = "stratum+tcp://stratum.bitcoin.cz",
Port = 3333,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
configurations.Add(donationConfiguration);
//LTC
donationConfiguration = new CoinConfiguration();
donationConfiguration.Coin.Symbol = "LTC";
donationPool = new MiningPool()
{
Host = "stratum+tcp://world.wemineltc.com",
Port = 3333,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
donationPool = new MiningPool()
{
Host = "stratum+tcp://primary.coinhuntr.com",
Port = 3333,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
configurations.Add(donationConfiguration);
//BQC
donationConfiguration = new CoinConfiguration();
donationConfiguration.Coin.Symbol = "BQC";
donationPool = new MiningPool()
{
Host = "http://de1.bigbbq.cc",
Port = 8446,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
configurations.Add(donationConfiguration);
//FTC
donationConfiguration = new CoinConfiguration();
donationConfiguration.Coin.Symbol = "FTC";
donationPool = new MiningPool()
{
Host = "stratum+tcp://stratum.wemineftc.com",
Port = 4444,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
donationPool = new MiningPool()
{
Host = "http://feathercoin.is-a-geek.com",
Port = 8341,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
configurations.Add(donationConfiguration);
//MEC
donationConfiguration = new CoinConfiguration();
donationConfiguration.Coin.Symbol = "MEC";
donationPool = new MiningPool()
{
Host = "stratum+tcp://us.miningpool.co",
Port = 9002,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
donationPool = new MiningPool()
{
Host = "stratum+tcp://au1.miningpool.co",
Port = 9001,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
configurations.Add(donationConfiguration);
//PPC
donationConfiguration = new CoinConfiguration();
donationConfiguration.Coin.Symbol = "PPC";
donationPool = new MiningPool()
{
Host = "stratum+tcp://stratum.d7.lt",
Port = 3333,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
//NVC
donationConfiguration = new CoinConfiguration();
donationConfiguration.Coin.Symbol = "NVC";
donationPool = new MiningPool()
{
Host = "stratum+tcp://stratum.khore.org",
Port = 3334,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
configurations.Add(donationConfiguration);
//CAP
donationConfiguration = new CoinConfiguration();
donationConfiguration.Coin.Symbol = "CAP";
donationPool = new MiningPool()
{
Host = "stratum+tcp://cap.coinmine.pl",
Port = 8102,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
configurations.Add(donationConfiguration);
//ZET
donationConfiguration = new CoinConfiguration();
donationConfiguration.Coin.Symbol = "ZET";
donationPool = new MiningPool()
{
Host = "stratum+tcp://mine1.coinmine.pl",
Port = 6000,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
configurations.Add(donationConfiguration);
//UNO
donationConfiguration = new CoinConfiguration();
donationConfiguration.Coin.Symbol = "UNO";
donationPool = new MiningPool()
{
Host = "stratum+tcp://de1.miningpool.co",
Port = 10701,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
//DOGE
donationConfiguration = new CoinConfiguration();
donationConfiguration.Coin.Symbol = "DOGE";
donationPool = new MiningPool()
{
Host = "stratum+tcp://stratum.dogehouse.org",
Port = 3333,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
configurations.Add(donationConfiguration);
}
private void SetupConfigurationArguments(MinerConfiguration minerConfiguration, CoinConfiguration coinConfiguration)
{
string arguments = string.Empty;
//apply algorithm-specific parameters
if (engineConfiguration.XgminerConfiguration.AlgorithmFlags.ContainsKey(coinConfiguration.Coin.Algorithm))
{
arguments = String.Format("{0} {1}", arguments,
engineConfiguration.XgminerConfiguration.AlgorithmFlags[coinConfiguration.Coin.Algorithm]);
}
//apply coin-specific parameters
if (!string.IsNullOrEmpty(coinConfiguration.MinerFlags))
{
arguments = string.Format("{0} {1}", arguments, coinConfiguration.MinerFlags);
}
if (engineConfiguration.XgminerConfiguration.DesktopMode)
{
arguments = arguments + " -I D";
}
if (donationPercent > 0)
{
arguments = arguments + " --load-balance";
}
minerConfiguration.LaunchArguments = arguments;
}
private static List <CoinConfiguration> InitializeDonationConfigurations()
{
List <CoinConfiguration> result = new List <CoinConfiguration>();
//BTC
CoinConfiguration donationConfiguration = new CoinConfiguration();
donationConfiguration.Coin.Symbol = "BTC";
MiningPool donationPool = new MiningPool()
{
Host = "stratum+tcp://stratum.mining.eligius.st",
Port = 3334,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
donationPool = new MiningPool()
{
Host = "stratum+tcp://mint.bitminter.com",
Port = 3333,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
donationPool = new MiningPool()
{
Host = "stratum+tcp://stratum.bitcoin.cz",
Port = 3333,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
result.Add(donationConfiguration);
//LTC
donationConfiguration = new CoinConfiguration();
donationConfiguration.Coin.Symbol = "LTC";
donationPool = new MiningPool()
{
Host = "stratum+tcp://world.wemineltc.com",
Port = 3333,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
donationPool = new MiningPool()
{
Host = "stratum+tcp://primary.coinhuntr.com",
Port = 3333,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
result.Add(donationConfiguration);
//BQC
donationConfiguration = new CoinConfiguration();
donationConfiguration.Coin.Symbol = "BQC";
donationPool = new MiningPool()
{
Host = "http://de1.bigbbq.cc",
Port = 8446,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
result.Add(donationConfiguration);
//FTC
donationConfiguration = new CoinConfiguration();
donationConfiguration.Coin.Symbol = "FTC";
donationPool = new MiningPool()
{
Host = "stratum+tcp://stratum.wemineftc.com",
Port = 4444,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
donationPool = new MiningPool()
{
Host = "http://feathercoin.is-a-geek.com",
Port = 8341,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
result.Add(donationConfiguration);
//MEC
donationConfiguration = new CoinConfiguration();
donationConfiguration.Coin.Symbol = "MEC";
donationPool = new MiningPool()
{
Host = "stratum+tcp://us.miningpool.co",
Port = 9002,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
donationPool = new MiningPool()
{
Host = "stratum+tcp://au1.miningpool.co",
Port = 9001,
Username = "******",
Password = "******"
};
donationConfiguration.Pools.Add(donationPool);
result.Add(donationConfiguration);
return(result);
}
public void InspectDetails(Device device, CoinConfiguration coinConfiguration, CoinInformation coinInformation,
List <DeviceInformationResponse> deviceInformation, PoolInformationResponse poolInformation,
List <DeviceDetailsResponse> deviceDetails)
{
this.deviceDetails = deviceDetails;
this.deviceInformation = deviceInformation;
noDetailsPanel.Visible = false;
double hashrate = 0;
foreach (DeviceInformationResponse individualDevice in deviceInformation)
{
hashrate += individualDevice.AverageHashrate;
}
hashrateLabel.Text = hashrate.ToHashrateString();
workersGridView.Visible = (device.Kind == DeviceKind.PXY) &&
(deviceInformation.Count > 0);
workersTitleLabel.Visible = workersGridView.Visible;
//Internet or Coin API could be down
if (coinInformation != null)
{
}
//device may not be configured
if (coinConfiguration != null)
{
cryptoCoinBindingSource.DataSource = coinConfiguration.Coin;
}
else
{
cryptoCoinBindingSource.DataSource = new CryptoCoin();
}
deviceInformationResponseBindingSource.DataSource = deviceInformation;
//may not be hashing yet
if (deviceDetails != null)
{
deviceDetailsResponseBindingSource.DataSource = deviceDetails;
}
else
{
deviceDetailsResponseBindingSource.DataSource = new DeviceDetailsResponse();
}
deviceBindingSource.DataSource = device;
switch (device.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;
}
nameLabel.Width = this.Width - nameLabel.Left - closeDetailsButton.Width;
acceptedLabel.Text = deviceInformation.Sum(d => d.AcceptedShares).ToString();
rejectedLabel.Text = deviceInformation.Sum(d => d.RejectedShares).ToString();
errorsLabel.Text = deviceInformation.Sum(d => d.HardwareErrors).ToString();
utilityLabel.Text = deviceInformation.Sum(d => d.Utility).ToString();
DeviceInformationResponse deviceInfo = (DeviceInformationResponse)deviceInformationResponseBindingSource.Current;
if (deviceInfo != null)
{
if (deviceInfo.Temperature > 0)
{
tempLabel.Text = deviceInfo.Temperature + "°";
}
else
{
tempLabel.Text = String.Empty;
}
if (deviceInfo.FanPercent > 0)
{
fanLabel.Text = deviceInfo.FanPercent + "%";
}
else
{
fanLabel.Text = String.Empty;
}
}
else
{
tempLabel.Text = String.Empty;
fanLabel.Text = String.Empty;
}
UpdateColumnVisibility();
//may not be hashing yet
if (poolInformation != null)
{
poolInformationResponseBindingSource.DataSource = poolInformation;
}
else
{
poolInformationResponseBindingSource.DataSource = new PoolInformationResponse();
}
}
