//============================================================================*
// CompareTo()
//============================================================================*
public override int CompareTo(Object obj)
{
if (obj == null)
{
return(1);
}
//----------------------------------------------------------------------------*
// Base Class
//----------------------------------------------------------------------------*
cSupply Supply = (cSupply)obj;
int rc = base.CompareTo(Supply);
//----------------------------------------------------------------------------*
// Model
//----------------------------------------------------------------------------*
if (rc == 0)
{
cPrimer Primer = (cPrimer)Supply;
rc = cDataFiles.ComparePartNumbers(m_strModel, Primer.m_strModel);
}
//----------------------------------------------------------------------------*
// Return results
//----------------------------------------------------------------------------*
return(rc);
}
//============================================================================*
// Synch() - Primer
//============================================================================*
public bool Synch(cPrimer Primer)
{
if (m_Primer != null && m_Primer.CompareTo(Primer) == 0)
{
m_Primer = Primer;
return(true);
}
return(false);
}
//============================================================================*
// cLoad() - Copy Constructor
//============================================================================*
public cLoad(cLoad Load)
{
m_eFirearmType = Load.m_eFirearmType;
m_Caliber = Load.m_Caliber;
m_Bullet = Load.m_Bullet;
m_Powder = Load.m_Powder;
m_Case = Load.m_Case;
m_Primer = Load.m_Primer;
m_fChecked = Load.m_fChecked;
m_fIdentity = Load.m_fIdentity;
m_ChargeList = new cChargeList(Load.m_ChargeList);
}
//============================================================================*
// Copy()
//============================================================================*
public void Copy(cPrimer Primer, bool fCopyBase = true)
{
if (fCopyBase)
{
base.Copy(Primer);
}
m_strModel = Primer.m_strModel;
m_eSize = Primer.m_eSize;
m_fStandard = Primer.m_fStandard;
m_fMagnum = Primer.m_fMagnum;
m_fMilitary = Primer.m_fMilitary;
m_fBenchRest = Primer.m_fBenchRest;
}
//============================================================================*
// Synch() - Primer
//============================================================================*
public bool Synch(cPrimer Primer)
{
if (m_Supply.SupplyType != cSupply.eSupplyTypes.Primers)
{
return(false);
}
if ((m_Supply as cPrimer).CompareTo(Primer) == 0)
{
m_Supply = Primer;
return(true);
}
return(false);
}
//============================================================================*
// PopulateChargeListView()
//============================================================================*
private void PopulateChargeListView()
{
//----------------------------------------------------------------------------*
// ChargeListView Data
//----------------------------------------------------------------------------*
cFirearm.eFireArmType FirearmType = m_Load.FirearmType;
cCaliber Caliber = m_Load.Caliber;
cPowder Powder = m_Load.Powder;
cBullet Bullet = MatchBulletRadioButton.Checked ? m_Load.Bullet : null;
cPrimer Primer = MatchPrimerRadioButton.Checked ? m_Load.Primer : null;
cCase Case = MatchCaseRadioButton.Checked ? m_Load.Case : null;
m_ChargeListView.Populate(FirearmType, Caliber, Bullet, m_Load.Bullet.Weight, Powder, Primer, Case);
UpdateButtons();
}
//============================================================================*
// Comparer()
//============================================================================*
public static int Comparer(cPrimer Primer1, cPrimer Primer2)
{
if (Primer1 == null)
{
if (Primer2 != null)
{
return(-1);
}
else
{
return(0);
}
}
else
{
if (Primer2 == null)
{
return(1);
}
}
return(Primer1.CompareTo(Primer2));
}
//============================================================================*
// Populate()
//============================================================================*
public void Populate(cFirearm.eFireArmType eFirearmType, cCaliber Caliber, cBullet Bullet, double dBulletWeight, cPowder Powder, cPrimer Primer, cCase Case)
{
Populating = true;
//----------------------------------------------------------------------------*
// LoadsListView Items
//----------------------------------------------------------------------------*
Items.Clear();
while (Columns.Count > 3)
{
Columns.RemoveAt(3);
}
ListViewItem SelectItem = null;
foreach (cLoad Load in m_DataFiles.LoadList)
{
if (Load.FirearmType == eFirearmType &&
(Caliber == null || Load.Caliber.CompareTo(Caliber) == 0) &&
(Bullet == null || Load.Bullet.CompareTo(Bullet) == 0) &&
(Load.Bullet.Weight == dBulletWeight) &&
(Powder == null || Load.Powder.CompareTo(Powder) == 0) &&
(Case == null || Load.Case.CompareTo(Case) == 0) &&
(Primer == null || Load.Primer.CompareTo(Primer) == 0))
{
ListViewItem Item = AddLoad(Load);
if (Item != null && Load.CompareTo(m_DataFiles.Preferences.LastCopyLoadSelected) == 0)
{
SelectItem = Item;
}
}
}
if (SelectItem != null)
{
SelectItem.Selected = true;
}
else
{
if (Items.Count > 0)
{
Items[0].Selected = true;
m_DataFiles.Preferences.LastCopyLoadSelected = (cLoad)Items[0].Tag;
Items[0].EnsureVisible();
}
}
Populating = false;
}
//============================================================================*
// OnPrintPage()
//============================================================================*
private void OnPrintPage(object sender, PrintPageEventArgs e)
{
//----------------------------------------------------------------------------*
// Create the fonts
//----------------------------------------------------------------------------*
// Font TitleFont = new Font("Trebuchet MS", 16, FontStyle.Bold);
Font SupplyTypeFont = new Font("Trebuchet MS", 14, FontStyle.Bold);
Font HeaderFont = new Font("Trebuchet MS", 10, FontStyle.Bold);
Font DataFont = new Font("Trebuchet MS", 8, FontStyle.Regular);
//----------------------------------------------------------------------------*
// Calculate Column Header Name Widths
//----------------------------------------------------------------------------*
string strText;
SizeF TextSize;
foreach (cPrintColumn PrintColumn in m_BulletColumns)
{
TextSize = e.Graphics.MeasureString(PrintColumn.Name, HeaderFont);
if (TextSize.Width > PrintColumn.Width)
{
PrintColumn.Width = TextSize.Width;
}
}
foreach (cPrintColumn PrintColumn in m_PowderColumns)
{
TextSize = e.Graphics.MeasureString(PrintColumn.Name, HeaderFont);
if (TextSize.Width > PrintColumn.Width)
{
PrintColumn.Width = TextSize.Width;
}
}
foreach (cPrintColumn PrintColumn in m_CaseColumns)
{
TextSize = e.Graphics.MeasureString(PrintColumn.Name, HeaderFont);
if (TextSize.Width > PrintColumn.Width)
{
PrintColumn.Width = TextSize.Width;
}
}
foreach (cPrintColumn PrintColumn in m_PrimerColumns)
{
TextSize = e.Graphics.MeasureString(PrintColumn.Name, HeaderFont);
if (TextSize.Width > PrintColumn.Width)
{
PrintColumn.Width = TextSize.Width;
}
}
//----------------------------------------------------------------------------*
// Calculate Header Widths for Supplies
//----------------------------------------------------------------------------*
foreach (cSupply Supply in m_SupplyList)
{
switch (Supply.SupplyType)
{
case cSupply.eSupplyTypes.Bullets:
TextSize = e.Graphics.MeasureString((Supply as cBullet).ToString(), DataFont);
if (TextSize.Width > m_BulletColumns[0].Width)
{
m_BulletColumns[0].Width = TextSize.Width;
}
break;
case cSupply.eSupplyTypes.Powder:
TextSize = e.Graphics.MeasureString((Supply as cPowder).ToString(), DataFont);
if (TextSize.Width > m_PowderColumns[0].Width)
{
m_PowderColumns[0].Width = TextSize.Width;
}
break;
case cSupply.eSupplyTypes.Primers:
TextSize = e.Graphics.MeasureString((Supply as cPrimer).ToShortString(), DataFont);
if (TextSize.Width > m_PrimerColumns[0].Width)
{
m_PrimerColumns[0].Width = TextSize.Width;
}
TextSize = e.Graphics.MeasureString((Supply as cPrimer).SizeString, DataFont);
if (TextSize.Width > m_PrimerColumns[1].Width)
{
m_PrimerColumns[1].Width = TextSize.Width;
}
TextSize = e.Graphics.MeasureString("0.00/1000", DataFont);
if (TextSize.Width > m_PrimerColumns[3].Width)
{
m_PrimerColumns[3].Width = TextSize.Width;
}
break;
case cSupply.eSupplyTypes.Cases:
TextSize = e.Graphics.MeasureString((Supply as cCase).Manufacturer.Name, DataFont);
if (TextSize.Width > m_CaseColumns[0].Width)
{
m_CaseColumns[0].Width = TextSize.Width;
}
TextSize = e.Graphics.MeasureString((Supply as cCase).Caliber.ToString(), DataFont);
if (TextSize.Width > m_CaseColumns[2].Width)
{
m_CaseColumns[2].Width = TextSize.Width;
}
break;
}
}
//----------------------------------------------------------------------------*
// Loop through the supply types
//----------------------------------------------------------------------------*
Rectangle PageRect = e.PageBounds;
int nXDPI = (int)((double)PageRect.Width / 8.5);
int nYDPI = (int)((double)PageRect.Height / 11);
PageRect.X += (int)((double)nXDPI * 0.5);
PageRect.Width -= ((int)((double)nXDPI * 0.5) * 2);
PageRect.Y += (int)((double)nYDPI * 0.5);
PageRect.Height -= ((int)((double)nYDPI * 0.5) * 2);
float nY = PageRect.Top;
float nX = PageRect.Left;
bool fPageHeader = false;
for (int nSupplyType = 0; nSupplyType < (int)cSupply.eSupplyTypes.NumSupplyTypes; nSupplyType++)
{
cSupply.eSupplyTypes eSupplyType = (cSupply.eSupplyTypes)nSupplyType;
//----------------------------------------------------------------------------*
// Loop through the supplies in the list
//----------------------------------------------------------------------------*
bool fHeader = false;
foreach (cSupply Supply in m_SupplyList)
{
if (nY > PageRect.Bottom)
{
e.HasMorePages = true;
return;
}
//----------------------------------------------------------------------------*
// If this supply is not the right type, or has already been printed, skip
// to the next supply in the list
//----------------------------------------------------------------------------*
if (Supply.Printed || Supply.SupplyType != eSupplyType)
{
continue;
}
Supply.Printed = true;
//----------------------------------------------------------------------------*
// Draw the page header if needed
//----------------------------------------------------------------------------*
if (!fPageHeader)
{
//----------------------------------------------------------------------------*
// Draw the Title
//----------------------------------------------------------------------------*
nY = cPrintObject.PrintReportTitle("Load Shopping List", e, PageRect);
if (m_DataFiles.Preferences.TrackInventory)
{
strText = m_DataFiles.CostText;
TextSize = e.Graphics.MeasureString(strText, HeaderFont);
e.Graphics.DrawString(strText, HeaderFont, Brushes.Black, (PageRect.Width / 2) - (TextSize.Width / 2), nY);
nY += TextSize.Height;
}
nY += HeaderFont.Height;
fPageHeader = true;
fHeader = false;
}
//----------------------------------------------------------------------------*
// Draw the supply type header if needed
//----------------------------------------------------------------------------*
if (!fHeader)
{
//----------------------------------------------------------------------------*
// Draw the supply type
//----------------------------------------------------------------------------*
switch (eSupplyType)
{
//----------------------------------------------------------------------------*
// Bullets
//----------------------------------------------------------------------------*
case cSupply.eSupplyTypes.Bullets:
strText = "Bullets";
TextSize = e.Graphics.MeasureString(strText, SupplyTypeFont);
nY += (TextSize.Height * (float)0.5);
e.Graphics.DrawString(strText, SupplyTypeFont, Brushes.Black, nX, nY);
nY += (TextSize.Height * (float)1.5);
nX = PageRect.Left;
foreach (cPrintColumn PrintColumn in m_BulletColumns)
{
e.Graphics.DrawString(PrintColumn.Name, HeaderFont, Brushes.Black, nX, nY);
nX += (PrintColumn.Width + 20);
}
TextSize = e.Graphics.MeasureString(m_BulletColumns[0].Name, HeaderFont);
nY += TextSize.Height;
e.Graphics.DrawLine(Pens.Black, PageRect.Left, nY, nX, nY);
nX = PageRect.Left;
break;
//----------------------------------------------------------------------------*
// Powder
//----------------------------------------------------------------------------*
case cSupply.eSupplyTypes.Powder:
strText = "Powder";
TextSize = e.Graphics.MeasureString(strText, SupplyTypeFont);
nY += (TextSize.Height * (float)0.5);
e.Graphics.DrawString(strText, SupplyTypeFont, Brushes.Black, nX, nY);
nY += (TextSize.Height * (float)1.5);
nX = PageRect.Left;
foreach (cPrintColumn PrintColumn in m_PowderColumns)
{
e.Graphics.DrawString(PrintColumn.Name, HeaderFont, Brushes.Black, nX, nY);
nX += (PrintColumn.Width + 20);
}
TextSize = e.Graphics.MeasureString(m_PowderColumns[0].Name, HeaderFont);
nY += TextSize.Height;
e.Graphics.DrawLine(Pens.Black, PageRect.Left, nY, nX, nY);
nX = PageRect.Left;
break;
//----------------------------------------------------------------------------*
// Primers
//----------------------------------------------------------------------------*
case cSupply.eSupplyTypes.Primers:
strText = "Primers";
TextSize = e.Graphics.MeasureString(strText, SupplyTypeFont);
nY += (TextSize.Height * (float)0.5);
e.Graphics.DrawString(strText, SupplyTypeFont, Brushes.Black, nX, nY);
nY += (TextSize.Height * (float)1.5);
nX = PageRect.Left;
foreach (cPrintColumn PrintColumn in m_PrimerColumns)
{
e.Graphics.DrawString(PrintColumn.Name, HeaderFont, Brushes.Black, nX, nY);
nX += (PrintColumn.Width + 20);
}
TextSize = e.Graphics.MeasureString(m_PrimerColumns[0].Name, HeaderFont);
nY += TextSize.Height;
e.Graphics.DrawLine(Pens.Black, PageRect.Left, nY, nX, nY);
nX = PageRect.Left;
break;
//----------------------------------------------------------------------------*
// Cases
//----------------------------------------------------------------------------*
case cSupply.eSupplyTypes.Cases:
strText = "Cases";
TextSize = e.Graphics.MeasureString(strText, SupplyTypeFont);
nY += (TextSize.Height * (float)0.5);
e.Graphics.DrawString(strText, SupplyTypeFont, Brushes.Black, nX, nY);
nY += (TextSize.Height * (float)1.5);
nX = PageRect.Left;
foreach (cPrintColumn PrintColumn in m_CaseColumns)
{
e.Graphics.DrawString(PrintColumn.Name, HeaderFont, Brushes.Black, nX, nY);
nX += (PrintColumn.Width + 20);
}
TextSize = e.Graphics.MeasureString(m_CaseColumns[0].Name, HeaderFont);
nY += TextSize.Height;
e.Graphics.DrawLine(Pens.Black, PageRect.Left, nY, nX, nY);
nX = PageRect.Left;
break;
}
fHeader = true;
}
//----------------------------------------------------------------------------*
// Draw the supply info
//----------------------------------------------------------------------------*
switch (eSupplyType)
{
//----------------------------------------------------------------------------*
// Bullets
//----------------------------------------------------------------------------*
case cSupply.eSupplyTypes.Bullets:
cBullet Bullet = (cBullet)Supply;
//----------------------------------------------------------------------------*
// Bullet Name
//----------------------------------------------------------------------------*
strText = Bullet.ToString();
nX = PageRect.Left;
e.Graphics.DrawString(strText, DataFont, Brushes.Black, nX, nY);
nX += (m_BulletColumns[0].Width + 20);
//----------------------------------------------------------------------------*
// Bullet Diameter
//----------------------------------------------------------------------------*
strText = String.Format("{0:F3}", Bullet.Diameter);
TextSize = e.Graphics.MeasureString(strText, DataFont);
e.Graphics.DrawString(strText, DataFont, Brushes.Black, nX + (m_BulletColumns[1].Width / 2) - (TextSize.Width / 2), nY);
nX += (m_BulletColumns[1].Width + 20);
//----------------------------------------------------------------------------*
// Bullet Weight
//----------------------------------------------------------------------------*
strText = String.Format("{0:G0}", Bullet.Weight);
TextSize = e.Graphics.MeasureString(strText, DataFont);
e.Graphics.DrawString(strText, DataFont, Brushes.Black, nX + (m_BulletColumns[2].Width / 2) - (TextSize.Width / 2), nY);
nX += (m_BulletColumns[2].Width + 20);
//----------------------------------------------------------------------------*
// Qty on Hand
//----------------------------------------------------------------------------*
double dQuantity = m_DataFiles.SupplyQuantity(Supply);
if (m_DataFiles.Preferences.TrackInventory)
{
if (dQuantity != 0.0)
{
strText = String.Format("{0:G0}", dQuantity);
}
else
{
strText = "-";
}
}
else
{
strText = "-";
}
TextSize = e.Graphics.MeasureString(strText, DataFont);
e.Graphics.DrawString(strText, DataFont, Brushes.Black, nX + (m_BulletColumns[3].Width / 2) - (TextSize.Width / 2), nY);
nX += (m_BulletColumns[3].Width + 20);
//----------------------------------------------------------------------------*
// Estimated Cost
//----------------------------------------------------------------------------*
if (dQuantity != 0.0)
{
strText = String.Format("{0}{1:F2}/100", m_DataFiles.Preferences.Currency, m_DataFiles.SupplyCostEach(Supply) * 100.0);
}
else
{
strText = "-";
}
TextSize = e.Graphics.MeasureString(strText, DataFont);
e.Graphics.DrawString(strText, DataFont, Brushes.Black, nX + m_BulletColumns[4].Width - TextSize.Width, nY);
nX = PageRect.Left;
nY += TextSize.Height;
break;
//----------------------------------------------------------------------------*
// Powder
//----------------------------------------------------------------------------*
case cSupply.eSupplyTypes.Powder:
cPowder Powder = (cPowder)Supply;
//----------------------------------------------------------------------------*
// Powder Name
//----------------------------------------------------------------------------*
strText = Powder.ToString();
nX = PageRect.Left;
e.Graphics.DrawString(strText, DataFont, Brushes.Black, nX, nY);
nX += (m_PowderColumns[0].Width + 20);
//----------------------------------------------------------------------------*
// Powder Type
//----------------------------------------------------------------------------*
strText = Powder.FirearmType.ToString();
e.Graphics.DrawString(strText, DataFont, Brushes.Black, nX, nY);
nX += (m_PowderColumns[1].Width + 20);
//----------------------------------------------------------------------------*
// Powder shape
//----------------------------------------------------------------------------*
strText = Powder.Shape.ToString();
e.Graphics.DrawString(strText, DataFont, Brushes.Black, nX, nY);
nX += (m_PowderColumns[2].Width + 20);
//----------------------------------------------------------------------------*
// Qty on Hand
//----------------------------------------------------------------------------*
dQuantity = cDataFiles.StandardToMetric(m_DataFiles.SupplyQuantity(Powder) / 7000.0, cDataFiles.eDataType.CanWeight);
if (m_DataFiles.Preferences.TrackInventory)
{
if (dQuantity != 0.0)
{
strText = String.Format("{0:F3}", dQuantity);
}
else
{
strText = "-";
}
}
else
{
strText = "-";
}
TextSize = e.Graphics.MeasureString(strText, DataFont);
e.Graphics.DrawString(strText, DataFont, Brushes.Black, nX + (m_PowderColumns[3].Width / 2) - (TextSize.Width / 2), nY);
nX += (m_PowderColumns[3].Width + 20);
//----------------------------------------------------------------------------*
// Estimated Cost
//----------------------------------------------------------------------------*
if (dQuantity != 0.0)
{
strText = String.Format("{0}{1:F2}/{2}", m_DataFiles.Preferences.Currency, cDataFiles.StandardToMetric(m_DataFiles.SupplyCostEach(Powder) * 7000.0, cDataFiles.eDataType.CanWeight), cDataFiles.MetricString(cDataFiles.eDataType.CanWeight));
}
else
{
strText = "-";
}
TextSize = e.Graphics.MeasureString(strText, DataFont);
e.Graphics.DrawString(strText, DataFont, Brushes.Black, nX + m_PowderColumns[4].Width - TextSize.Width, nY);
nX = PageRect.Left;
nY += TextSize.Height;
break;
//----------------------------------------------------------------------------*
// Primers
//----------------------------------------------------------------------------*
case cSupply.eSupplyTypes.Primers:
cPrimer Primer = (cPrimer)Supply;
//----------------------------------------------------------------------------*
// Primer
//----------------------------------------------------------------------------*
strText = Primer.ToShortString();
nX = PageRect.Left;
e.Graphics.DrawString(strText, DataFont, Brushes.Black, nX, nY);
nX += (m_PrimerColumns[0].Width + 20);
//----------------------------------------------------------------------------*
// Size
//----------------------------------------------------------------------------*
strText = Primer.Size.ToString();
TextSize = e.Graphics.MeasureString(strText, DataFont);
e.Graphics.DrawString(strText, DataFont, Brushes.Black, nX, nY);
nX += (m_PrimerColumns[1].Width + 20);
//----------------------------------------------------------------------------*
// Magnum
//----------------------------------------------------------------------------*
strText = Primer.Magnum ? "Yes" : "No";
TextSize = e.Graphics.MeasureString(strText, DataFont);
e.Graphics.DrawString(strText, DataFont, Brushes.Black, nX + (m_PrimerColumns[2].Width / 2) - (TextSize.Width / 2), nY);
nX += (m_PrimerColumns[2].Width + 20);
//----------------------------------------------------------------------------*
// Qty on Hand
//----------------------------------------------------------------------------*
dQuantity = m_DataFiles.SupplyQuantity(Supply);
if (m_DataFiles.Preferences.TrackInventory)
{
if (dQuantity != 0.0)
{
strText = String.Format("{0:G0}", dQuantity);
}
else
{
strText = "-";
}
}
else
{
strText = "-";
}
TextSize = e.Graphics.MeasureString(strText, DataFont);
e.Graphics.DrawString(strText, DataFont, Brushes.Black, nX + (m_PrimerColumns[3].Width / 2) - (TextSize.Width / 2), nY);
nX += (m_PrimerColumns[3].Width + 20);
//----------------------------------------------------------------------------*
// Estimated Cost
//----------------------------------------------------------------------------*
if (dQuantity != 0.0)
{
strText = String.Format("{0}{1:F2}/1000", m_DataFiles.Preferences.Currency, m_DataFiles.SupplyCostEach(Supply) * 1000);
}
else
{
strText = "-";
}
TextSize = e.Graphics.MeasureString(strText, DataFont);
e.Graphics.DrawString(strText, DataFont, Brushes.Black, nX + m_PrimerColumns[4].Width - TextSize.Width, nY);
nX = PageRect.Left;
nY += TextSize.Height;
break;
//----------------------------------------------------------------------------*
// Cases
//----------------------------------------------------------------------------*
case cSupply.eSupplyTypes.Cases:
cCase Case = (cCase)Supply;
//----------------------------------------------------------------------------*
// Manufacturer
//----------------------------------------------------------------------------*
strText = Case.Manufacturer.ToString();
nX = PageRect.Left;
e.Graphics.DrawString(strText, DataFont, Brushes.Black, nX, nY);
nX += (m_CaseColumns[0].Width + 20);
//----------------------------------------------------------------------------*
// Match
//----------------------------------------------------------------------------*
strText = "Y";
TextSize = e.Graphics.MeasureString(strText, DataFont);
if (Case.Match)
{
e.Graphics.DrawString(strText, DataFont, Brushes.Black, nX + (m_CaseColumns[1].Width / 2) - (TextSize.Width / 2), nY);
}
nX += (m_CaseColumns[1].Width + 20);
//----------------------------------------------------------------------------*
// Caliber
//----------------------------------------------------------------------------*
strText = Case.Caliber.ToString();
TextSize = e.Graphics.MeasureString(strText, DataFont);
e.Graphics.DrawString(strText, DataFont, Brushes.Black, nX, nY);
nX += (m_CaseColumns[2].Width + 20);
//----------------------------------------------------------------------------*
// Qty on Hand
//----------------------------------------------------------------------------*
dQuantity = m_DataFiles.SupplyQuantity(Supply);
if (m_DataFiles.Preferences.TrackInventory)
{
if (dQuantity != 0.0)
{
strText = String.Format("{0:G0}", dQuantity);
}
else
{
strText = "-";
}
}
else
{
strText = "-";
}
TextSize = e.Graphics.MeasureString(strText, DataFont);
e.Graphics.DrawString(strText, DataFont, Brushes.Black, nX + (m_CaseColumns[3].Width / 2) - (TextSize.Width / 2), nY);
nX += (m_CaseColumns[3].Width + 20);
//----------------------------------------------------------------------------*
// Estimated Cost
//----------------------------------------------------------------------------*
if (dQuantity != 0.0)
{
strText = String.Format("{0}{1:F2}/100", m_DataFiles.Preferences.Currency, m_DataFiles.SupplyCostEach(Supply) * 100);
}
else
{
strText = "-";
}
TextSize = e.Graphics.MeasureString(strText, DataFont);
e.Graphics.DrawString(strText, DataFont, Brushes.Black, nX + m_CaseColumns[4].Width - TextSize.Width, nY);
nX = PageRect.Left;
nY += TextSize.Height;
break;
}
}
}
e.HasMorePages = false;
ResetPrintedFlag();
}
//============================================================================*
// cPrimerForm() - Constructor
//============================================================================*
public cPrimerForm(cPrimer Primer, cDataFiles DataFiles, bool fViewOnly = false)
{
InitializeComponent();
m_fViewOnly = fViewOnly;
m_DataFiles = DataFiles;
if (Primer == null)
{
if (m_fViewOnly)
{
return;
}
if (m_DataFiles.Preferences.LastPrimer != null)
{
m_Primer = new cPrimer(m_DataFiles.Preferences.LastPrimer);
m_Primer.Model = "";
m_Primer.TransactionList.Clear();
m_Primer.RecalculateInventory(m_DataFiles);
}
else
{
m_Primer = new cPrimer();
}
PrimerOKButton.Text = "Add";
}
else
{
m_Primer = new cPrimer(Primer);
if (m_fViewOnly)
{
PrimerOKButton.Visible = false;
int nButtonX = (this.Size.Width / 2) - (PrimerCancelButton.Width / 2);
PrimerCancelButton.Location = new Point(nButtonX, PrimerCancelButton.Location.Y);
PrimerCancelButton.Text = "Close";
}
else
{
PrimerOKButton.Text = "Update";
}
}
m_OriginalManufacturer = m_Primer.Manufacturer;
m_strOriginalModel = m_Primer.Model;
SetClientSizeCore(GeneralGroupBox.Location.X + GeneralGroupBox.Width + 10, PrimerCancelButton.Location.Y + PrimerCancelButton.Height + 20);
//----------------------------------------------------------------------------*
// Set Control Event Handlers
//----------------------------------------------------------------------------*
if (!m_fViewOnly)
{
FirearmTypeCombo.SelectedIndexChanged += OnFirearmTypeSelected;
CrossUseCheckBox.Click += OnCrossUseClicked;
ManufacturerCombo.SelectedIndexChanged += OnManufacturerChanged;
SizeCombo.SelectedIndexChanged += OnSizeChanged;
StandardCheckBox.Click += OnPrimerTypeClicked;
MagnumCheckBox.Click += OnPrimerTypeClicked;
BenchRestCheckBox.Click += OnPrimerTypeClicked;
MilitaryCheckBox.Click += OnPrimerTypeClicked;
ModelTextBox.TextChanged += OnModelChanged;
QuantityTextBox.TextChanged += OnQuantityChanged;
CostTextBox.TextChanged += OnPriceChanged;
PrimerOKButton.Click += OnOKClicked;
}
else
{
ModelTextBox.ReadOnly = true;
QuantityTextBox.ReadOnly = true;
CostTextBox.ReadOnly = true;
}
InventoryButton.Click += OnInventoryClicked;
//----------------------------------------------------------------------------*
// Populate Firearm Type Combo
//----------------------------------------------------------------------------*
FirearmTypeCombo.Value = m_Primer.FirearmType;
CrossUseCheckBox.Checked = m_Primer.CrossUse;
//----------------------------------------------------------------------------*
// Populate Primer Size Combo
//----------------------------------------------------------------------------*
if (!m_fViewOnly)
{
SizeCombo.Items.Clear();
SizeCombo.Items.Add("Small");
SizeCombo.Items.Add("Large");
SizeCombo.SelectedIndex = (int)m_Primer.Size;
}
else
{
SizeCombo.Items.Clear();
SizeCombo.Items.Add(m_Primer.ShortSizeString);
SizeCombo.SelectedIndex = 0;
}
//----------------------------------------------------------------------------*
// Set Labels for inventory tracking if needed
//----------------------------------------------------------------------------*
if (m_DataFiles.Preferences.TrackInventory)
{
QuantityLabel.Text = "Qty on Hand:";
QuantityTextBox.BorderStyle = BorderStyle.None;
QuantityTextBox.Font = new Font(QuantityTextBox.Font, FontStyle.Bold);
QuantityTextBox.Location = new Point(QuantityTextBox.Location.X, QuantityTextBox.Location.Y + 3);
QuantityTextBox.Enabled = false;
CostTextBox.BorderStyle = BorderStyle.None;
CostTextBox.Font = new Font(CostTextBox.Font, FontStyle.Bold);
CostTextBox.TextAlign = HorizontalAlignment.Left;
CostTextBox.Location = new Point(CostTextBox.Location.X, CostTextBox.Location.Y + 3);
CostTextBox.Enabled = false;
InventoryGroupBox.Text = "Inventory Info";
CostLabel.Text = "Value:";
}
else
{
InventoryButton.Visible = false;
CostLabel.Text = String.Format("Cost ({0}):", m_DataFiles.Preferences.Currency);
}
//----------------------------------------------------------------------------*
// Fill in Primer data
//----------------------------------------------------------------------------*
ModelTextBox.Text = m_Primer.Model;
StandardCheckBox.Checked = m_Primer.Standard;
MagnumCheckBox.Checked = m_Primer.Magnum;
MilitaryCheckBox.Checked = m_Primer.Military;
BenchRestCheckBox.Checked = m_Primer.BenchRest;
PopulateInventoryData();
//----------------------------------------------------------------------------*
// Set title and text fields
//----------------------------------------------------------------------------*
string strTitle;
if (Primer == null)
{
strTitle = "Add";
}
else
if (m_fViewOnly)
{
strTitle = "View";
}
else
{
strTitle = "Edit";
}
strTitle += " Primer";
Text = strTitle;
PopulateManufacturerCombo();
UpdateButtons();
m_fInitialized = true;
}
//============================================================================*
// ResolveIdentities()
//============================================================================*
public bool ResolveIdentities(cDataFiles DataFiles)
{
bool fChanged = false;
//----------------------------------------------------------------------------*
// Caliber
//----------------------------------------------------------------------------*
if (m_Caliber.Identity)
{
foreach (cCaliber Caliber in DataFiles.CaliberList)
{
if (!Caliber.Identity && Caliber.CompareTo(m_Caliber) == 0)
{
m_Caliber = Caliber;
fChanged = true;
break;
}
}
}
//----------------------------------------------------------------------------*
// Bullet
//----------------------------------------------------------------------------*
if (m_Bullet.Identity)
{
foreach (cBullet Bullet in DataFiles.BulletList)
{
if (!Bullet.Identity && m_Bullet.CompareTo(Bullet) == 0)
{
m_Bullet = Bullet;
fChanged = true;
break;
}
}
}
//----------------------------------------------------------------------------*
// Case
//----------------------------------------------------------------------------*
if (m_Case.Identity)
{
foreach (cCase Case in DataFiles.CaseList)
{
if (!Case.Identity && m_Case.CompareTo(Case) == 0)
{
m_Case = Case;
fChanged = true;
break;
}
}
}
//----------------------------------------------------------------------------*
// Powder
//----------------------------------------------------------------------------*
if (m_Powder.Identity)
{
foreach (cPowder Powder in DataFiles.PowderList)
{
if (!Powder.Identity && m_Powder.CompareTo(Powder) == 0)
{
m_Powder = Powder;
fChanged = true;
break;
}
}
}
//----------------------------------------------------------------------------*
// Primer
//----------------------------------------------------------------------------*
if (m_Primer.Identity)
{
foreach (cPrimer Primer in DataFiles.PrimerList)
{
if (!Primer.Identity && m_Primer.CompareTo(Primer) == 0)
{
m_Primer = Primer;
fChanged = true;
break;
}
}
}
//----------------------------------------------------------------------------*
// Charge List
//----------------------------------------------------------------------------*
fChanged = m_ChargeList.ResolveIdentities(DataFiles) ? true : fChanged;
return(fChanged);
}
//============================================================================*
// cPrimer() - Copy Constructor
//============================================================================*
public cPrimer(cPrimer Primer)
: base(Primer)
{
Copy(Primer, false);
}
//============================================================================*
// Compare()
//============================================================================*
public override int Compare(Object Object1, Object Object2)
{
if (Object1 == null)
{
if (Object2 == null)
{
return(0);
}
else
{
return(-1);
}
}
else
{
if (Object2 == null)
{
return(1);
}
}
cPrimer Primer1 = (cPrimer)(Object1 as ListViewItem).Tag;
cPrimer Primer2 = (cPrimer)(Object2 as ListViewItem).Tag;
if (Primer1 == null)
{
if (Primer2 == null)
{
return(0);
}
else
{
return(-1);
}
}
else
{
if (Primer2 == null)
{
return(1);
}
}
bool fSpecial = false;
int rc = 0;
switch (SortColumn)
{
//----------------------------------------------------------------------------*
// Manufacturer
//----------------------------------------------------------------------------*
case 0:
rc = Primer1.Manufacturer.CompareTo(Primer2.Manufacturer);
if (rc == 0)
{
rc = Primer1.Model.CompareTo(Primer2.Model);
}
fSpecial = true;
break;
//----------------------------------------------------------------------------*
// Quantity
//----------------------------------------------------------------------------*
case 8:
double dQuantity1 = Primer1.Quantity;
double dQuantity2 = Primer2.Quantity;
if (m_DataFiles.Preferences.TrackInventory)
{
dQuantity1 = Primer1.QuantityOnHand;
dQuantity2 = Primer2.QuantityOnHand;
}
rc = dQuantity1.CompareTo(dQuantity2);
fSpecial = true;
break;
//----------------------------------------------------------------------------*
// Cost
//----------------------------------------------------------------------------*
case 9:
double dCost1 = 0.0;
if ((Object1 as ListViewItem).Text != "-")
{
Double.TryParse((Object1 as ListViewItem).SubItems[9].Text, out dCost1);
}
double dCost2 = 0.0;
if ((Object2 as ListViewItem).Text != "-")
{
Double.TryParse((Object2 as ListViewItem).SubItems[9].Text, out dCost2);
}
rc = dCost1.CompareTo(dCost2);
fSpecial = true;
break;
}
if (fSpecial)
{
if (SortingOrder == SortOrder.Descending)
{
return(0 - rc);
}
return(rc);
}
return(base.Compare(Object1, Object2));
}