//============================================================================*
// CompareTo()
//============================================================================*
public override int CompareTo(Object obj)
{
if (obj == null)
{
return(1);
}
//----------------------------------------------------------------------------*
// Base Class
//----------------------------------------------------------------------------*
cSupply Supply = (cSupply)obj;
int rc = base.CompareTo(Supply);
//----------------------------------------------------------------------------*
// Type
//----------------------------------------------------------------------------*
if (rc == 0)
{
cPowder Powder = (cPowder)Supply;
rc = cDataFiles.ComparePartNumbers(m_strType, Powder.m_strType);
}
return(rc);
}
//============================================================================*
// Copy()
//============================================================================*
public void Copy(cPowder Powder, bool fCopyBase = true)
{
if (fCopyBase)
{
base.Copy(Powder);
}
m_strType = Powder.m_strType;
m_eShape = Powder.m_eShape;
}
//============================================================================*
// Synch() - Powder
//============================================================================*
public bool Synch(cPowder Powder)
{
if (m_Powder != null && m_Powder.CompareTo(Powder) == 0)
{
m_Powder = Powder;
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);
}
//============================================================================*
// Synch() - Powder
//============================================================================*
public bool Synch(cPowder Powder)
{
if (m_Supply.SupplyType != cSupply.eSupplyTypes.Powder)
{
return(false);
}
if ((m_Supply as cPowder).CompareTo(Powder) == 0)
{
m_Supply = Powder;
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(cPowder Powder1, cPowder Powder2)
{
if (Powder1 == null)
{
if (Powder2 != null)
{
return(-1);
}
else
{
return(0);
}
}
else
{
if (Powder2 == null)
{
return(1);
}
}
return(Powder1.CompareTo(Powder2));
}
//============================================================================*
// 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;
}
//============================================================================*
// VerifyBatch()
//============================================================================*
public bool VerifyBatch(cBatch Batch, cFirearm.eFireArmType eFirearmType, cCaliber Caliber, cBullet Bullet, cPowder Powder)
{
//----------------------------------------------------------------------------*
// Make sure the batch shouldn't be hidden
//----------------------------------------------------------------------------*
/*
* if ((m_DataFiles.Preferences.HideUncheckedCalibers && !Batch.Load.Caliber.Checked) ||
* (m_DataFiles.Preferences.HideUncheckedSupplies && !Batch.Load.Bullet.Checked) ||
* (m_DataFiles.Preferences.HideUncheckedSupplies && !Batch.Load.Powder.Checked) ||
* (m_DataFiles.Preferences.HideUncheckedSupplies && !Batch.Load.Primer.Checked) ||
* (m_DataFiles.Preferences.HideUncheckedSupplies && !Batch.Load.Case.Checked) ||
* Batch.Archived)
* return (false);
*/
//----------------------------------------------------------------------------*
// Check the filters
//----------------------------------------------------------------------------*
if (Batch.Load.FirearmType != eFirearmType)
{
return(false);
}
if (Caliber != null && Batch.Load.Caliber != Caliber)
{
return(false);
}
if (Bullet != null && Batch.Load.Bullet != Bullet)
{
return(false);
}
if (Powder != null && Batch.Load.Powder != Powder)
{
return(false);
}
return(true);
}
//============================================================================*
// Populate()
//============================================================================*
public void Populate(cFirearm.eFireArmType eFireArmType, cCaliber Caliber, cBullet Bullet, cPowder Powder)
{
if (Populating)
{
return;
}
Populating = true;
Items.Clear();
ListViewItem SelectItem = null;
foreach (cBatch Batch in m_DataFiles.BatchList)
{
if (Batch.Archived && !m_DataFiles.Preferences.ShowArchivedBatches)
{
continue;
}
if (m_DataFiles.Preferences.HideUncheckedCalibers && !Batch.Load.Caliber.Checked)
{
continue;
}
if (m_DataFiles.Preferences.HideUncheckedSupplies && (!Batch.Load.Bullet.Checked || !Batch.Load.Case.Checked || !Batch.Load.Powder.Checked || !Batch.Load.Primer.Checked))
{
continue;
}
ListViewItem Item = AddBatch(Batch, eFireArmType, Caliber, Bullet, Powder);
if (Item != null && m_DataFiles.Preferences.LastBatchSelected != null && m_DataFiles.Preferences.LastBatchSelected.CompareTo(Batch) == 0)
{
SelectItem = Item;
}
}
Focus();
if (SelectItem != null && SelectItem.Index >= 0)
{
SelectItem.Selected = true;
EnsureVisible(SelectItem.Index);
}
else
{
if (Items.Count > 0)
{
Items[0].Selected = true;
m_DataFiles.Preferences.LastBatchSelected = (cBatch)Items[0].Tag;
EnsureVisible(Items[0].Index);
}
}
Populating = false;
}
//============================================================================*
// VerifyLoad()
//============================================================================*
public bool VerifyLoad(cLoad Load, cFirearm.eFireArmType eFirearmType, cCaliber Caliber, cBullet Bullet, cPowder Powder)
{
if (Load == null)
{
return(false);
}
//----------------------------------------------------------------------------*
// See if we need to show this load regardless of other considerations
//----------------------------------------------------------------------------*
if (m_fShowBatchLoad && m_Batch.Load.CompareTo(Load) == 0)
{
return(true);
}
//----------------------------------------------------------------------------*
// Check Filters
//----------------------------------------------------------------------------*
if ((eFirearmType != cFirearm.eFireArmType.None && Load.FirearmType != eFirearmType) ||
(Caliber != null && Load.Caliber.CompareTo(Caliber) != 0) ||
(Bullet != null && Load.Bullet.CompareTo(Bullet) != 0) ||
(Powder != null && Load.Powder.CompareTo(Powder) != 0))
{
return(false);
}
//----------------------------------------------------------------------------*
// Check Inventory
//----------------------------------------------------------------------------*
if (!m_DataFiles.VerifyLoadQuantities(m_Batch, Load))
{
return(false);
}
//----------------------------------------------------------------------------*
// Make sure the caliber is not hidden
//----------------------------------------------------------------------------*
if (m_DataFiles.Preferences.HideUncheckedCalibers && !Load.Caliber.Checked)
{
return(false);
}
//----------------------------------------------------------------------------*
// Make sure the supplies are not hidden
//----------------------------------------------------------------------------*
if (m_DataFiles.Preferences.HideUncheckedSupplies)
{
if (!Load.Bullet.Checked || !Load.Powder.Checked || !Load.Primer.Checked || !Load.Case.Checked)
{
return(false);
}
}
return(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);
}
//============================================================================*
// cPowderForm() - Constructor
//============================================================================*
public cPowderForm(cPowder Powder, cDataFiles DataFiles, bool fViewOnly = false)
{
InitializeComponent();
m_DataFiles = DataFiles;
m_fViewOnly = fViewOnly;
if (Powder == null)
{
if (m_fViewOnly)
{
return;
}
m_fAdd = true;
if (m_DataFiles.Preferences.LastPowder == null)
{
m_Powder = new cPowder();
}
else
{
if (m_DataFiles.Preferences.LastPowder != null)
{
m_Powder = new cPowder(m_DataFiles.Preferences.LastPowder);
}
m_Powder.Model = "";
m_Powder.Shape = cPowder.ePowderShapes.Other;
m_Powder.Cost = 0.0;
m_Powder.Quantity = 0;
m_Powder.TransactionList.Clear();
m_Powder.RecalculateInventory(m_DataFiles);
}
PowderOKButton.Text = "Add";
}
else
{
m_Powder = new cPowder(Powder);
m_strOriginalModel = m_Powder.Model;
if (m_fViewOnly)
{
PowderOKButton.Visible = false;
int nButtonX = (this.Size.Width / 2) - (PowderCancelButton.Width / 2);
PowderCancelButton.Location = new Point(nButtonX, PowderCancelButton.Location.Y);
PowderCancelButton.Text = "Close";
}
else
{
PowderOKButton.Text = "Update";
}
}
SetClientSizeCore(GeneralGroupBox.Location.X + GeneralGroupBox.Width + 10, PowderCancelButton.Location.Y + PowderCancelButton.Height + 20);
//----------------------------------------------------------------------------*
// Set Control Event Handlers
//----------------------------------------------------------------------------*
if (!m_fViewOnly)
{
FirearmTypeCombo.SelectedIndexChanged += OnFirearmTypeChanged;
CrossUseCheckBox.Click += OnCrossUseClicked;
ManufacturerCombo.SelectedIndexChanged += OnManufacturerSelected;
ModelTextBox.TextChanged += OnModelChanged;
ShapeCombo.SelectedIndexChanged += OnShapeChanged;
QuantityTextBox.TextChanged += OnQuantityChanged;
CostTextBox.TextChanged += OnPriceChanged;
}
else
{
ModelTextBox.ReadOnly = true;
QuantityTextBox.ReadOnly = true;
CostTextBox.ReadOnly = true;
}
InventoryButton.Click += OnInventoryClicked;
//----------------------------------------------------------------------------*
// Fill in powder data
//----------------------------------------------------------------------------*
SetInputParameters();
FirearmTypeCombo.Value = m_Powder.FirearmType;
CrossUseCheckBox.Checked = m_Powder.CrossUse;
PopulateManufacturerCombo();
ModelTextBox.Text = m_Powder.Model;
if ((int)m_Powder.Shape < ShapeCombo.Items.Count)
{
ShapeCombo.SelectedIndex = (int)m_Powder.Shape;
}
else
{
if (ShapeCombo.Items.Count > 0)
{
ShapeCombo.SelectedIndex = 0;
}
}
PopulateInventoryData();
//----------------------------------------------------------------------------*
// 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;
CostLabel.Text = "Value:";
}
else
{
InventoryButton.Visible = false;
CostLabel.Text = String.Format("Cost ({0}):", m_DataFiles.Preferences.Currency);
}
InventoryGroupBox.Text = "Inventory Info";
//----------------------------------------------------------------------------*
// Set title and text fields
//----------------------------------------------------------------------------*
string strTitle;
if (Powder == null)
{
strTitle = "Add";
}
else
{
if (m_fViewOnly)
{
strTitle = "View";
}
else
{
strTitle = "Edit";
}
}
strTitle += " Powder";
Text = strTitle;
SetStaticToolTips();
m_fInitialized = true;
UpdateButtons();
if (!m_fViewOnly)
{
FirearmTypeCombo.Focus();
}
else
{
PowderCancelButton.Focus();
}
}
//============================================================================*
// Append()
//============================================================================*
public int Append(cPowder Powder, bool fCountOnly = false)
{
int nUpdateCount = base.Append(Powder, fCountOnly);
return(nUpdateCount);
}
//============================================================================*
// cPowder() - Copy Constructor
//============================================================================*
public cPowder(cPowder Powder)
: base(Powder)
{
Copy(Powder, false);
}
//============================================================================*
// PopulateLoadDataPowderCombo()
//============================================================================*
private void PopulateLoadDataPowderCombo()
{
cCaliber.CurrentFirearmType = LoadDataFirearmTypeCombo.Value;
m_fPopulating = true;
LoadDataPowderCombo.Items.Clear();
cFirearm.eFireArmType eFirearmType = LoadDataFirearmTypeCombo.Value;
cCaliber Caliber = null;
if (LoadDataCaliberCombo.SelectedIndex > 0)
{
Caliber = (cCaliber)LoadDataCaliberCombo.SelectedItem;
}
cBullet Bullet = null;
if (LoadDataBulletCombo.SelectedIndex > 0)
{
Bullet = (cBullet)LoadDataBulletCombo.SelectedItem;
}
LoadDataPowderCombo.Items.Add("Any Powder");
cPowder SelectPowder = null;
foreach (cLoad Load in m_DataFiles.LoadList)
{
if ((Caliber == null || Load.Caliber.CompareTo(Caliber) == 0) &&
(eFirearmType == cFirearm.eFireArmType.None || Load.FirearmType == eFirearmType) &&
(Bullet == null || Load.Bullet.CompareTo(Bullet) == 0))
{
if (Load.Powder.CrossUse || Load.Powder.FirearmType == eFirearmType)
{
if (LoadDataPowderCombo.Items.IndexOf(Load.Powder) < 0)
{
LoadDataPowderCombo.Items.Add(Load.Powder);
if (Load.Powder.CompareTo(m_DataFiles.Preferences.LastLoadDataPowderSelected) == 0)
{
SelectPowder = Load.Powder;
}
}
}
}
}
if (SelectPowder != null)
{
LoadDataPowderCombo.SelectedItem = SelectPowder;
}
else
{
if (LoadDataPowderCombo.Items.Count > 0)
{
LoadDataPowderCombo.SelectedIndex = 0;
}
}
if (LoadDataPowderCombo.SelectedIndex < 0)
{
LoadDataPowderCombo.SelectedIndex = 0;
}
m_fPopulating = false;
PopulateLoadDataListView();
}
//============================================================================*
// Populate()
//============================================================================*
public void Populate(cLoad Load, cFirearm.eFireArmType eFirearmType, cCaliber Caliber, cBullet Bullet, cPowder Powder)
{
Populating = true;
Items.Clear();
ListViewItem SelectItem = null;
foreach (cLoad CheckLoad in m_DataFiles.LoadList)
{
if (CheckLoad.CompareTo(Load) == 0)
{
ListViewItem Item = AddLoad(CheckLoad, eFirearmType, Caliber, Bullet, Powder);
SelectItem = Item;
}
}
if (SelectItem != null)
{
SelectItem.Selected = true;
EnsureVisible(SelectItem.Index);
}
else
{
if (Items.Count > 0)
{
Items[0].Selected = true;
m_DataFiles.Preferences.LastBatchLoadSelected = (cLoad)Items[0].Tag;
EnsureVisible(Items[0].Index);
}
}
Populating = false;
}
//============================================================================*
// Populate()
//============================================================================*
public void Populate(cFirearm.eFireArmType eFirearmType, cCaliber Caliber, cBullet Bullet, cPowder Powder)
{
Populating = true;
//----------------------------------------------------------------------------*
// LoadsListView Items
//----------------------------------------------------------------------------*
Items.Clear();
while (Columns.Count > 5)
{
Columns.RemoveAt(5);
}
ListViewItem SelectItem = null;
foreach (cLoad Load in m_DataFiles.LoadList)
{
ListViewItem Item = AddLoad(Load, eFirearmType, Caliber, Bullet, Powder);
if (Item != null && Load.CompareTo(m_DataFiles.Preferences.LastLoadSelected) == 0)
{
SelectItem = Item;
}
}
if (SelectItem != null)
{
SelectItem.Selected = true;
}
else
{
if (Items.Count > 0)
{
Items[0].Selected = true;
m_DataFiles.Preferences.LastLoadSelected = (cLoad)Items[0].Tag;
}
}
if (SelectedItems.Count > 0)
{
SelectedItems[0].EnsureVisible();
}
Populating = false;
}
//============================================================================*
// AddLoad()
//============================================================================*
public ListViewItem AddLoad(cLoad Load, cFirearm.eFireArmType eFirearmType, cCaliber Caliber, cBullet Bullet, cPowder Powder)
{
//----------------------------------------------------------------------------*
// Verify that the load should be added
//----------------------------------------------------------------------------*
if (!VerifyLoad(Load, eFirearmType, Caliber, Bullet, Powder))
{
return(null);
}
//----------------------------------------------------------------------------*
// Create the Item
//----------------------------------------------------------------------------*
ListViewItem Item = new ListViewItem();
SetLoadData(Item, Load);
//----------------------------------------------------------------------------*
// Add the item and exit
//----------------------------------------------------------------------------*
AddItem(Item);
return(Item);
}
//============================================================================*
// UpdateLoad()
//============================================================================*
public ListViewItem UpdateLoad(cLoad Load, cFirearm.eFireArmType eFirearmType, cCaliber Caliber, cBullet Bullet, cPowder Powder, bool fSelect = false)
{
//----------------------------------------------------------------------------*
// Find the Item
//----------------------------------------------------------------------------*
ListViewItem Item = null;
foreach (ListViewItem CheckItem in Items)
{
if ((CheckItem.Tag as cLoad).Equals(Load))
{
Item = CheckItem;
break;
}
}
//----------------------------------------------------------------------------*
// If the item was not found, add it
//----------------------------------------------------------------------------*
if (Item == null)
{
return(AddLoad(Load, eFirearmType, Caliber, Bullet, Powder, fSelect));
}
//----------------------------------------------------------------------------*
// Otherwise, update the Item Data
//----------------------------------------------------------------------------*
SetLoadData(Item, Load);
Item.Selected = fSelect;
if (SelectedItems.Count > 0)
{
SelectedItems[0].EnsureVisible();
}
Focus();
return(Item);
}
//============================================================================*
// UpdateBatch()
//============================================================================*
public ListViewItem UpdateBatch(cBatch Batch, cFirearm.eFireArmType eFirearmType, cCaliber Caliber, cBullet Bullet, cPowder Powder, bool fSelect = false)
{
//----------------------------------------------------------------------------*
// Find the Item
//----------------------------------------------------------------------------*
ListViewItem Item = null;
foreach (ListViewItem CheckItem in Items)
{
if ((CheckItem.Tag as cBatch).CompareTo(Batch) == 0)
{
Item = CheckItem;
break;
}
}
//----------------------------------------------------------------------------*
// If the item was not found, add it
//----------------------------------------------------------------------------*
if (Item == null)
{
return(null);
}
//----------------------------------------------------------------------------*
// Otherwise, update the Item Data
//----------------------------------------------------------------------------*
SetBatchData(Item, Batch);
Item.Selected = fSelect;
if (SelectedItems.Count > 0)
{
SelectedItems[0].EnsureVisible();
}
Focus();
return(Item);
}
//============================================================================*
// VerifyLoad()
//============================================================================*
public bool VerifyLoad(cLoad Load, cFirearm.eFireArmType eFirearmType, cCaliber Caliber, cBullet Bullet, cPowder Powder)
{
//----------------------------------------------------------------------------*
// Check the filters
//----------------------------------------------------------------------------*
if (Load.FirearmType != eFirearmType ||
(Caliber != null && Load.Caliber.CompareTo(Caliber) != 0) ||
(Bullet != null && Load.Bullet.CompareTo(Bullet) != 0) ||
(Powder != null && Load.Powder.CompareTo(Powder) != 0))
{
return(false);
}
//----------------------------------------------------------------------------*
// Make sure the components aren't hidden
//----------------------------------------------------------------------------*
if ((m_DataFiles.Preferences.HideUncheckedCalibers && !Load.Caliber.Checked))
{
return(false);
}
if (m_DataFiles.Preferences.HideUncheckedSupplies &&
(!Load.Bullet.Checked || !Load.Powder.Checked || !Load.Primer.Checked || !Load.Case.Checked))
{
return(false);
}
//----------------------------------------------------------------------------*
// Good to go!
//----------------------------------------------------------------------------*
return(true);
}
//============================================================================*
// AddBatch()
//============================================================================*
public ListViewItem AddBatch(cBatch Batch, cFirearm.eFireArmType eFireArmType, cCaliber Caliber, cBullet Bullet, cPowder Powder, bool fSelect = false)
{
if (!VerifyBatch(Batch, eFireArmType, Caliber, Bullet, Powder))
{
return(null);
}
//----------------------------------------------------------------------------*
// Create the ListViewItem
//----------------------------------------------------------------------------*
ListViewItem Item = new ListViewItem();
SetBatchData(Item, Batch);
//----------------------------------------------------------------------------*
// Add the item and exit
//----------------------------------------------------------------------------*
AddItem(Item, fSelect);
return(Item);
}
//============================================================================*
// AddLoad()
//============================================================================*
public ListViewItem AddLoad(cLoad Load, cFirearm.eFireArmType eFirearmType, cCaliber Caliber, cBullet Bullet, cPowder Powder, bool fSelect = false)
{
if (!VerifyLoad(Load, eFirearmType, Caliber, Bullet, Powder))
{
return(null);
}
//----------------------------------------------------------------------------*
// Create the ListViewItem
//----------------------------------------------------------------------------*
ListViewItem Item = new ListViewItem();
SetLoadData(Item, Load);
//----------------------------------------------------------------------------*
// Add the item to the list and exit
//----------------------------------------------------------------------------*
AddItem(Item, fSelect);
return(Item);
}
//============================================================================*
// 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);
}
}
cPowder Powder1 = (cPowder)(Object1 as ListViewItem).Tag;
cPowder Powder2 = (cPowder)(Object2 as ListViewItem).Tag;
if (Powder1 == null)
{
if (Powder2 == null)
{
return(0);
}
else
{
return(-1);
}
}
else
{
if (Powder2 == null)
{
return(1);
}
}
bool fSpecial = false;
int rc = 0;
switch (SortColumn)
{
//----------------------------------------------------------------------------*
// Manufacturer
//----------------------------------------------------------------------------*
case 0:
rc = Powder1.Manufacturer.CompareTo(Powder2.Manufacturer);
if (rc == 0)
{
string strPart1 = Powder1.Model;
string strPart2 = Powder2.Model;
if (strPart1.Length != strPart2.Length)
{
string strPad = "";
if (strPart1.Length < strPart2.Length)
{
while (strPart1.Length + strPad.Length < strPart2.Length)
{
strPad += " ";
}
strPart1 = strPad + strPart1;
}
else
{
while (strPart2.Length + strPad.Length < strPart1.Length)
{
strPad += " ";
}
strPart2 = strPad + strPart2;
}
}
rc = strPart1.CompareTo(strPart2);
}
fSpecial = true;
break;
//----------------------------------------------------------------------------*
// Model
//----------------------------------------------------------------------------*
case 1:
if (rc == 0)
{
string strPart1 = Powder1.Model;
string strPart2 = Powder2.Model;
if (strPart1.Length != strPart2.Length)
{
string strPad = "";
if (strPart1.Length < strPart2.Length)
{
while (strPart1.Length + strPad.Length < strPart2.Length)
{
strPad += " ";
}
strPart1 = strPad + strPart1;
}
else
{
while (strPart2.Length + strPad.Length < strPart1.Length)
{
strPad += " ";
}
strPart2 = strPad + strPart2;
}
}
rc = strPart1.CompareTo(strPart2);
}
if (rc == 0)
{
rc = Powder1.Manufacturer.CompareTo(Powder2.Manufacturer);
}
fSpecial = true;
break;
//----------------------------------------------------------------------------*
// Quantity
//----------------------------------------------------------------------------*
case 4:
double dQuantity1 = Powder1.Quantity;
double dQuantity2 = Powder2.Quantity;
if (m_DataFiles.Preferences.TrackInventory)
{
dQuantity1 = Powder1.QuantityOnHand;
dQuantity2 = Powder2.QuantityOnHand;
}
rc = dQuantity1.CompareTo(dQuantity2);
fSpecial = true;
break;
//----------------------------------------------------------------------------*
// Cost
//----------------------------------------------------------------------------*
case 5:
double dCost1 = 0.0;
if ((Object1 as ListViewItem).Text != "-")
{
Double.TryParse((Object1 as ListViewItem).SubItems[5].Text, out dCost1);
}
double dCost2 = 0.0;
if ((Object2 as ListViewItem).Text != "-")
{
Double.TryParse((Object2 as ListViewItem).SubItems[5].Text, out dCost2);
}
rc = dCost1.CompareTo(dCost2);
fSpecial = true;
break;
}
//----------------------------------------------------------------------------*
// Return results
//----------------------------------------------------------------------------*
if (fSpecial)
{
if (SortingOrder == SortOrder.Descending)
{
return(0 - rc);
}
return(rc);
}
return(base.Compare(Object1, Object2));
}
//============================================================================*
// 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();
}
