private void FillPalletList()
{
int rangeIndex = 0;
int numberOfItems = 0;
using (WCFClient wcfClient = new WCFClient())
{
do
{
DCSBPallet[] dcsbPallets = wcfClient.Client.GetAllPallets(rangeIndex++, ref numberOfItems);
foreach (var dcsbPallet in dcsbPallets)
{
UnitsManager.UnitSystem us = (UnitsManager.UnitSystem)dcsbPallet.UnitSystem;
var palletProperties = new PalletProperties(null,
dcsbPallet.PalletType,
UnitsManager.ConvertLengthFrom(dcsbPallet.Dimensions.M0, us),
UnitsManager.ConvertLengthFrom(dcsbPallet.Dimensions.M1, us),
UnitsManager.ConvertLengthFrom(dcsbPallet.Dimensions.M2, us)
)
{
Color = Color.FromArgb(dcsbPallet.Color),
Weight = UnitsManager.ConvertMassFrom(dcsbPallet.Weight, us)
};
palletProperties.ID.SetNameDesc(dcsbPallet.Name, dcsbPallet.Description);
lbPallets.Items.Add(new ItemBaseWrapper(palletProperties), true);
}
}while ((rangeIndex + 1) * 20 < numberOfItems);
}
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
// font size
GridFontSize = 8;
// fill combo boxes
cbBoxes.Initialize(_doc, this, null);
// initialize orientation
uCtrlCaseOrient.AllowedOrientations = new bool[] { Settings.Default.AllowVerticalX, Settings.Default.AllowVerticalY, Settings.Default.AllowVerticalZ };
// initialize grid
gridSolutions.Selection.SelectionChanged += new SourceGrid.RangeRegionChangedEventHandler(onSelChangeGrid);
// load cases
DCSBCase[] sbCases = WCFClientSingleton.Instance.Client.GetAllCases();
foreach (DCSBCase sbCase in sbCases)
{
try
{
// get values from database
if (!sbCase.HasInnerDims)
{
continue;
}
UnitsManager.UnitSystem us = (UnitsManager.UnitSystem)sbCase.UnitSystem;
double boxLength = UnitsManager.ConvertLengthFrom(sbCase.DimensionsOuter.M0, us);
double boxWidth = UnitsManager.ConvertLengthFrom(sbCase.DimensionsOuter.M1, us);
double boxHeight = UnitsManager.ConvertLengthFrom(sbCase.DimensionsOuter.M2, us);
double innerLength = UnitsManager.ConvertLengthFrom(sbCase.DimensionsInner.M0, us);
double innerWidth = UnitsManager.ConvertLengthFrom(sbCase.DimensionsInner.M1, us);
double innerHeight = UnitsManager.ConvertLengthFrom(sbCase.DimensionsInner.M2, us);
double weight = UnitsManager.ConvertMassFrom(sbCase.Weight, us);
Color[] colors = new Color[6];
for (int i = 0; i < 6; ++i)
{
colors[i] = Color.FromArgb(sbCase.Colors[i]);
}
// instantiate box properties
BoxProperties bProperties = new BoxProperties(null
, boxLength, boxWidth, boxHeight
, innerLength, innerWidth, innerHeight);
bProperties.ID.SetNameDesc(sbCase.Name, sbCase.Description);
bProperties.SetWeight(weight);
bProperties.TapeWidth = new OptDouble(sbCase.ShowTape, sbCase.TapeWidth);
bProperties.TapeColor = Color.FromArgb(sbCase.TapeColor);
bProperties.SetAllColors(colors);
// insert in listbox control
chklbCases.Items.Add(new ItemBaseCB(bProperties), true);
}
catch (Exception ex)
{
_log.Error(ex.Message);
}
}
// update graph control
graphCtrl.DrawingContainer = this;
}
public static double ConvertSurfaceMassFrom(double value, UnitsManager.UnitSystem unitSystem)
{
if (unitSystem == CurrentUnitSystem)
{
return(value);
}
else
{
StandardMeasure <SurfaceDensity> measure = new StandardMeasure <SurfaceDensity>(value, SurfaceMassUnitFromUnitSystem(unitSystem));
return(measure.GetAmount(SurfaceMassUnitFromUnitSystem(CurrentUnitSystem)));
}
}
public static double ConvertMassTo(double value, UnitsManager.UnitSystem unitSystem)
{
if (unitSystem == CurrentUnitSystem)
{
return(value);
}
else
{
StandardMeasure <Mass> measure = new StandardMeasure <Mass>(value, MassUnitFromUnitSystem(CurrentUnitSystem));
return(measure.GetAmount(MassUnitFromUnitSystem(unitSystem)));
}
}
public static double ConvertLengthFrom(double value, UnitsManager.UnitSystem unitSystem)
{
if (unitSystem == CurrentUnitSystem)
{
return(value);
}
else
{
StandardMeasure <Length> measure = new StandardMeasure <Length>(value, LengthUnitFromUnitSystem(unitSystem));
return(measure.GetAmount(LengthUnitFromUnitSystem(CurrentUnitSystem)));
}
}
public static BoxPosition ConvertLengthFrom(BoxPosition value, UnitsManager.UnitSystem unitSystem)
{
if (unitSystem == UnitsManager.CurrentUnitSystem)
{
return(value);
}
else
{
return(new BoxPosition(
ConvertLengthFrom(value.Position, unitSystem), value.DirectionLength, value.DirectionWidth));
}
}
private static IUnit <SurfaceDensity> SurfaceMassUnitFromUnitSystem(UnitsManager.UnitSystem unitSystem)
{
switch (unitSystem)
{
case UnitsManager.UnitSystem.UNIT_METRIC1: return(Cureos.Measures.Quantities.SurfaceDensity.KiloGramPerSquareMeter);
case UnitsManager.UnitSystem.UNIT_METRIC2: return(Cureos.Measures.Quantities.SurfaceDensity.KiloGramPerSquareMeter);
case UnitsManager.UnitSystem.UNIT_IMPERIAL: return(Cureos.Measures.Quantities.SurfaceDensity.PoundPerSquareInch);
case UnitsManager.UnitSystem.UNIT_US: return(Cureos.Measures.Quantities.SurfaceDensity.PoundPerSquareInch);
default: throw new Exception("Invalid unit system!");
}
}
private static IUnit <Mass> MassUnitFromUnitSystem(UnitsManager.UnitSystem unitSystem)
{
switch (unitSystem)
{
case UnitsManager.UnitSystem.UNIT_METRIC1: return(Cureos.Measures.Quantities.Mass.KiloGram);
case UnitsManager.UnitSystem.UNIT_METRIC2: return(Cureos.Measures.Quantities.Mass.KiloGram);
case UnitsManager.UnitSystem.UNIT_IMPERIAL: return(Cureos.Measures.Quantities.Mass.Pound);
case UnitsManager.UnitSystem.UNIT_US: return(Cureos.Measures.Quantities.Mass.Pound);
default: throw new Exception("Invalid unit system!");
}
}
private static IUnit <Length> LengthUnitFromUnitSystem(UnitsManager.UnitSystem unitSystem)
{
switch (unitSystem)
{
case UnitsManager.UnitSystem.UNIT_METRIC1: return(Cureos.Measures.Quantities.Length.MilliMeter);
case UnitsManager.UnitSystem.UNIT_METRIC2: return(Cureos.Measures.Quantities.Length.CentiMeter);
case UnitsManager.UnitSystem.UNIT_IMPERIAL: return(Cureos.Measures.Quantities.Length.Inch);
case UnitsManager.UnitSystem.UNIT_US: return(Cureos.Measures.Quantities.Length.Inch);
default: throw new Exception("Invalid unit system!");
}
}
public static Vector2D ConvertLengthFrom(Vector2D value, UnitsManager.UnitSystem unitSystem)
{
if (unitSystem == CurrentUnitSystem)
{
return(value);
}
else
{
StandardMeasure <Length> measureX = new StandardMeasure <Length>(value.X, LengthUnitFromUnitSystem(unitSystem));
StandardMeasure <Length> measureY = new StandardMeasure <Length>(value.Y, LengthUnitFromUnitSystem(unitSystem));
return(new Vector2D(
measureX.GetAmount(LengthUnitFromUnitSystem(CurrentUnitSystem))
, measureY.GetAmount(LengthUnitFromUnitSystem(CurrentUnitSystem))
));
}
}
private void FillGridPallets(WCFClient wcfClient)
{
// initialize grid
List <string> captions = new List <string>
{
string.Format(Properties.Resources.ID_DIMENSIONS, UnitsManager.UnitString(UnitsManager.UnitType.UT_LENGTH)),
string.Format(Properties.Resources.ID_WEIGHT_WU, UnitsManager.UnitString(UnitsManager.UnitType.UT_MASS))
};
GridInitialize(gridPallets, captions);
// handling delete event
SourceGrid.Cells.Controllers.CustomEvents buttonDelete = new SourceGrid.Cells.Controllers.CustomEvents();
buttonDelete.Click += new EventHandler(OnDeleteItem);
_pallets = wcfClient.Client.GetAllPalletsSearch(SearchString, SearchDescription, RangeIndex, ref _numberOfItems, false);
int iIndex = 0;
foreach (DCSBPallet p in _pallets)
{
UnitsManager.UnitSystem us = (UnitsManager.UnitSystem)p.UnitSystem;
gridPallets.Rows.Insert(++iIndex);
int iCol = 0;
gridPallets[iIndex, iCol++] = new SourceGrid.Cells.Cell(p.Name);
gridPallets[iIndex, iCol++] = new SourceGrid.Cells.Cell(p.Description);
gridPallets[iIndex, iCol++] = new SourceGrid.Cells.Cell(
string.Format("{0:0.##} x {1:0.##} x {2:0.##}",
UnitsManager.ConvertLengthFrom(p.Dimensions.M0, us),
UnitsManager.ConvertLengthFrom(p.Dimensions.M1, us),
UnitsManager.ConvertLengthFrom(p.Dimensions.M2, us))
);
gridPallets[iIndex, iCol++] = new SourceGrid.Cells.Cell(
string.Format("{0:0.###}", UnitsManager.ConvertMassFrom(p.Weight, us))
);
gridPallets[iIndex, iCol] = new SourceGrid.Cells.Button("")
{
Image = Properties.Resources.Delete
};
gridPallets[iIndex, iCol++].AddController(buttonDelete);
}
GridFinalize(gridPallets);
}
public void Draw(Graphics3DControl ctrl, Graphics3D graphics)
{
if (null == _selectedItem)
{
return;
}
// get unit system
UnitsManager.UnitSystem us = (UnitsManager.UnitSystem)_selectedItem.UnitSystem;
// pallet
if (_selectedItem is DCSBPallet dcsbPallet)
{
double palletLength = UnitsManager.ConvertLengthFrom(dcsbPallet.Dimensions.M0, us);
double palletWidth = UnitsManager.ConvertLengthFrom(dcsbPallet.Dimensions.M1, us);
double palletHeight = UnitsManager.ConvertLengthFrom(dcsbPallet.Dimensions.M2, us);
PalletProperties palletProperties = new PalletProperties(null, dcsbPallet.PalletType, palletLength, palletWidth, palletHeight)
{
Color = Color.FromArgb(dcsbPallet.Color)
};
Pallet pallet = new Pallet(palletProperties);
pallet.Draw(graphics, Transform3D.Identity);
graphics.AddDimensions(new DimensionCube(palletLength, palletWidth, palletHeight));
}
}
static public void InsertDefaultItems(DocumentSB docSB)
{
if (null == docSB)
{
return;
}
try
{
using (WCFClient wcfClient = new WCFClient())
{
// pallets
int rangeIndex = 0, numberOfItems = 0;
do
{
DCSBPallet[] pallets = wcfClient.Client.GetAllPalletsAuto(rangeIndex++, ref numberOfItems, true);
foreach (var dcsbPallet in pallets)
{
UnitsManager.UnitSystem us = (UnitsManager.UnitSystem)dcsbPallet.UnitSystem;
PalletProperties palletProperties = docSB.CreateNewPallet(
dcsbPallet.Name, dcsbPallet.Description,
dcsbPallet.PalletType,
UnitsManager.ConvertLengthFrom(dcsbPallet.Dimensions.M0, us),
UnitsManager.ConvertLengthFrom(dcsbPallet.Dimensions.M1, us),
UnitsManager.ConvertLengthFrom(dcsbPallet.Dimensions.M2, us),
UnitsManager.ConvertMassFrom(dcsbPallet.Weight, us),
Color.FromArgb(dcsbPallet.Color));
if (null != dcsbPallet.AdmissibleLoad)
{
palletProperties.AdmissibleLoadWeight = UnitsManager.ConvertMassFrom(dcsbPallet.AdmissibleLoad.Value, us);
}
}
}while ((rangeIndex + 1) * 20 < numberOfItems);
// cases
rangeIndex = 0; numberOfItems = 0;
do
{
DCSBCase[] cases = wcfClient.Client.GetAllCasesAuto(rangeIndex++, ref numberOfItems, true);
foreach (var dcsbCase in cases)
{
UnitsManager.UnitSystem us = (UnitsManager.UnitSystem)dcsbCase.UnitSystem;
var colors = new Color[6];
for (int i = 0; i < 6; ++i)
{
colors[i] = Color.FromArgb(dcsbCase.Colors[i]);
}
BoxProperties bProperties = null;
if (dcsbCase.IsCase)
{
bProperties = docSB.CreateNewCase(dcsbCase.Name, dcsbCase.Description,
UnitsManager.ConvertLengthFrom(dcsbCase.DimensionsOuter.M0, us),
UnitsManager.ConvertLengthFrom(dcsbCase.DimensionsOuter.M1, us),
UnitsManager.ConvertLengthFrom(dcsbCase.DimensionsOuter.M2, us),
UnitsManager.ConvertLengthFrom(dcsbCase.DimensionsInner.M0, us),
UnitsManager.ConvertLengthFrom(dcsbCase.DimensionsInner.M1, us),
UnitsManager.ConvertLengthFrom(dcsbCase.DimensionsInner.M2, us),
UnitsManager.ConvertMassFrom(dcsbCase.Weight, us),
colors);
}
else
{
bProperties = docSB.CreateNewBox(
dcsbCase.Name, dcsbCase.Description,
UnitsManager.ConvertLengthFrom(dcsbCase.DimensionsOuter.M0, us),
UnitsManager.ConvertLengthFrom(dcsbCase.DimensionsOuter.M1, us),
UnitsManager.ConvertLengthFrom(dcsbCase.DimensionsOuter.M2, us),
UnitsManager.ConvertMassFrom(dcsbCase.Weight, us),
colors);
}
bProperties.TapeWidth = new OptDouble(dcsbCase.IsCase && dcsbCase.ShowTape, UnitsManager.ConvertLengthFrom(dcsbCase.TapeWidth, us));
bProperties.TapeColor = Color.FromArgb(dcsbCase.TapeColor);
bProperties.SetNetWeight(
new OptDouble(!dcsbCase.HasInnerDims && dcsbCase.NetWeight.HasValue
, dcsbCase.NetWeight ?? 0.0));
List <Pair <HalfAxis.HAxis, Texture> > textures = new List <Pair <HalfAxis.HAxis, Texture> >();
bProperties.TextureList = textures;
}
}while ((rangeIndex + 1) * 20 < numberOfItems);
// bundles
rangeIndex = 0; numberOfItems = 0;
do
{
DCSBBundle[] bundles = wcfClient.Client.GetAllBundlesAuto(rangeIndex++, ref numberOfItems, true);
foreach (var dcsbBundle in bundles)
{
UnitsManager.UnitSystem us = (UnitsManager.UnitSystem)dcsbBundle.UnitSystem;
docSB.CreateNewBundle(dcsbBundle.Name, dcsbBundle.Description,
UnitsManager.ConvertLengthFrom(dcsbBundle.DimensionsUnit.M0, us),
UnitsManager.ConvertLengthFrom(dcsbBundle.DimensionsUnit.M1, us),
UnitsManager.ConvertLengthFrom(dcsbBundle.DimensionsUnit.M2, us),
UnitsManager.ConvertMassFrom(dcsbBundle.UnitWeight, us),
Color.FromArgb(dcsbBundle.Color),
dcsbBundle.Number);
}
}while ((rangeIndex + 1) * 20 < numberOfItems);
// interlayers
rangeIndex = 0; numberOfItems = 0;
do
{
DCSBInterlayer[] interlayers = wcfClient.Client.GetAllInterlayersAuto(rangeIndex++, ref numberOfItems, true);
foreach (var dcsbInterlayer in interlayers)
{
UnitsManager.UnitSystem us = (UnitsManager.UnitSystem)dcsbInterlayer.UnitSystem;
docSB.CreateNewInterlayer(dcsbInterlayer.Name, dcsbInterlayer.Description,
UnitsManager.ConvertLengthFrom(dcsbInterlayer.Dimensions.M0, us),
UnitsManager.ConvertLengthFrom(dcsbInterlayer.Dimensions.M1, us),
UnitsManager.ConvertLengthFrom(dcsbInterlayer.Dimensions.M2, us),
UnitsManager.ConvertMassFrom(dcsbInterlayer.Weight, us),
Color.FromArgb(dcsbInterlayer.Color)
);
}
}while ((rangeIndex + 1) * 20 < numberOfItems);
// trucks
rangeIndex = 0; numberOfItems = 0;
do
{
DCSBTruck[] trucks = wcfClient.Client.GetAllTrucksAuto(rangeIndex++, ref numberOfItems, true);
foreach (var dcsbTruck in trucks)
{
UnitsManager.UnitSystem us = (UnitsManager.UnitSystem)dcsbTruck.UnitSystem;
docSB.CreateNewTruck(dcsbTruck.Name, dcsbTruck.Description,
UnitsManager.ConvertLengthFrom(dcsbTruck.DimensionsInner.M0, us),
UnitsManager.ConvertLengthFrom(dcsbTruck.DimensionsInner.M1, us),
UnitsManager.ConvertLengthFrom(dcsbTruck.DimensionsInner.M2, us),
UnitsManager.ConvertMassFrom(dcsbTruck.AdmissibleLoad, us),
Color.FromArgb(dcsbTruck.Color)
);
}
}while ((rangeIndex + 1) * 20 < numberOfItems);
// cylinders
rangeIndex = 0; numberOfItems = 0;
do
{
DCSBCylinder[] cylinders = wcfClient.Client.GetAllCylindersAuto(rangeIndex++, ref numberOfItems, true);
foreach (var dcsbCylinder in cylinders)
{
UnitsManager.UnitSystem us = (UnitsManager.UnitSystem)dcsbCylinder.UnitSystem;
docSB.CreateNewCylinder(
dcsbCylinder.Name, dcsbCylinder.Description,
UnitsManager.ConvertLengthFrom(dcsbCylinder.RadiusOuter, us),
UnitsManager.ConvertLengthFrom(dcsbCylinder.RadiusInner, us),
UnitsManager.ConvertLengthFrom(dcsbCylinder.Height, us),
UnitsManager.ConvertMassFrom(dcsbCylinder.Weight, us),
Color.FromArgb(dcsbCylinder.ColorTop), Color.FromArgb(dcsbCylinder.ColorOuter), Color.FromArgb(dcsbCylinder.ColorInner)
);
}
}while ((rangeIndex + 1) * 20 < numberOfItems);
// pallet corners
rangeIndex = 0; numberOfItems = 0;
do
{
DCSBPalletCorner[] palletCorners = wcfClient.Client.GetAllPalletCornersAuto(rangeIndex++, ref numberOfItems, true);
foreach (var dcsbPalletCorner in palletCorners)
{
UnitsManager.UnitSystem us = (UnitsManager.UnitSystem)dcsbPalletCorner.UnitSystem;
docSB.CreateNewPalletCorners(
dcsbPalletCorner.Name, dcsbPalletCorner.Description,
UnitsManager.ConvertLengthFrom(dcsbPalletCorner.Length, us),
UnitsManager.ConvertLengthFrom(dcsbPalletCorner.Width, us),
UnitsManager.ConvertLengthFrom(dcsbPalletCorner.Thickness, us),
UnitsManager.ConvertMassFrom(dcsbPalletCorner.Weight, us),
Color.FromArgb(dcsbPalletCorner.Color)
);
}
}while ((rangeIndex + 1) * 20 < numberOfItems);
// pallet caps
rangeIndex = 0; numberOfItems = 0;
do
{
DCSBPalletCap[] palletCaps = wcfClient.Client.GetAllPalletCapsAuto(rangeIndex++, ref numberOfItems, true);
foreach (var dcsbCap in palletCaps)
{
UnitsManager.UnitSystem us = (UnitsManager.UnitSystem)dcsbCap.UnitSystem;
docSB.CreateNewPalletCap(
dcsbCap.Name, dcsbCap.Description,
UnitsManager.ConvertLengthFrom(dcsbCap.DimensionsOuter.M0, us),
UnitsManager.ConvertLengthFrom(dcsbCap.DimensionsOuter.M1, us),
UnitsManager.ConvertLengthFrom(dcsbCap.DimensionsOuter.M2, us),
UnitsManager.ConvertLengthFrom(dcsbCap.DimensionsInner.M0, us),
UnitsManager.ConvertLengthFrom(dcsbCap.DimensionsInner.M1, us),
UnitsManager.ConvertLengthFrom(dcsbCap.DimensionsInner.M2, us),
UnitsManager.ConvertMassFrom(dcsbCap.Weight, us),
Color.FromArgb(dcsbCap.Color)
);
}
}while ((rangeIndex + 1) * 20 < numberOfItems);
// pallet films
rangeIndex = 0; numberOfItems = 0;
do
{
DCSBPalletFilm[] palletFilms = wcfClient.Client.GetAllPalletFilmsAuto(rangeIndex++, ref numberOfItems, true);
foreach (var dcsbPalletFilm in palletFilms)
{
UnitsManager.UnitSystem us = (UnitsManager.UnitSystem)dcsbPalletFilm.UnitSystem;
docSB.CreateNewPalletFilm(dcsbPalletFilm.Name, dcsbPalletFilm.Description,
dcsbPalletFilm.UseTransparency, dcsbPalletFilm.UseHatching,
dcsbPalletFilm.HatchingSpace, dcsbPalletFilm.HatchingAngle,
Color.FromArgb(dcsbPalletFilm.Color));
}
}while ((rangeIndex + 1) * 20 < numberOfItems);
} // using
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
private void OnFillListCases(object sender, EventArgs e)
{
// sanity check
if (null == ListCases || ListCases.Count < 1)
{
return;
}
// clear check list
chklbCases.Items.Clear();
// fill list of cases
foreach (DCSBCase sbCase in ListCases)
{
try
{
// get values from database
if (!sbCase.HasInnerDims)
{
continue;
}
UnitsManager.UnitSystem us = (UnitsManager.UnitSystem)sbCase.UnitSystem;
double boxLength = UnitsManager.ConvertLengthFrom(sbCase.DimensionsOuter.M0, us);
double boxWidth = UnitsManager.ConvertLengthFrom(sbCase.DimensionsOuter.M1, us);
double boxHeight = UnitsManager.ConvertLengthFrom(sbCase.DimensionsOuter.M2, us);
double innerLength = UnitsManager.ConvertLengthFrom(sbCase.DimensionsInner.M0, us);
double innerWidth = UnitsManager.ConvertLengthFrom(sbCase.DimensionsInner.M1, us);
double innerHeight = UnitsManager.ConvertLengthFrom(sbCase.DimensionsInner.M2, us);
if (uCtrlCaseDimensionsMin.Checked &&
(innerLength < uCtrlCaseDimensionsMin.X ||
innerWidth < uCtrlCaseDimensionsMin.Y ||
innerHeight < uCtrlCaseDimensionsMin.Z))
{
continue;
}
if (uCtrlCaseDimensionsMax.Checked &&
(innerLength > uCtrlCaseDimensionsMax.X ||
innerWidth > uCtrlCaseDimensionsMax.Y ||
innerHeight > uCtrlCaseDimensionsMax.Z))
{
continue;
}
double weight = UnitsManager.ConvertMassFrom(sbCase.Weight, us);
Color[] colors = new Color[6];
for (int i = 0; i < 6; ++i)
{
colors[i] = Color.FromArgb(sbCase.Colors[i]);
}
// instantiate box properties
BoxProperties bProperties = new BoxProperties(null
, boxLength, boxWidth, boxHeight
, innerLength, innerWidth, innerHeight);
bProperties.TapeWidth = new OptDouble(sbCase.ShowTape, sbCase.TapeWidth);
bProperties.TapeColor = Color.FromArgb(sbCase.TapeColor);
bProperties.ID.SetNameDesc(sbCase.Name, sbCase.Description);
bProperties.SetWeight(weight);
bProperties.SetAllColors(colors);
// insert in listbox control
chklbCases.Items.Add(new ItemBaseCB(bProperties), true);
}
catch (Exception ex)
{
_log.Error(ex.Message);
}
}
OnCaseChecked(this, null);
}
void LoadDocumentElement(XmlElement docElement)
{
if (docElement.HasAttribute("Name"))
_name = docElement.Attributes["Name"].Value;
if (docElement.HasAttribute("Description"))
_description = docElement.Attributes["Description"].Value;
if (docElement.HasAttribute("Description"))
_author = docElement.Attributes["Author"].Value;
if (docElement.HasAttribute("DateCreated"))
{
try
{
_dateCreated = System.Convert.ToDateTime(docElement.Attributes["DateCreated"].Value, new CultureInfo("en-US"));
}
catch (Exception /*ex*/)
{
_dateCreated = DateTime.Now;
_log.Debug("Failed to load date of creation correctly: Loading file generated with former version?");
}
}
if (docElement.HasAttribute("UnitSystem"))
_unitSystem = (UnitsManager.UnitSystem)int.Parse(docElement.Attributes["UnitSystem"].Value);
else
_unitSystem = UnitsManager.UnitSystem.UNIT_METRIC1;
foreach (XmlNode docChildNode in docElement.ChildNodes)
{
// load item properties
if (string.Equals(docChildNode.Name, "ItemProperties", StringComparison.CurrentCultureIgnoreCase))
{
foreach (XmlNode itemPropertiesNode in docChildNode.ChildNodes)
{
try
{
if (string.Equals(itemPropertiesNode.Name, "BoxProperties", StringComparison.CurrentCultureIgnoreCase))
LoadBoxProperties(itemPropertiesNode as XmlElement);
else if (string.Equals(itemPropertiesNode.Name, "CylinderProperties", StringComparison.CurrentCultureIgnoreCase))
LoadCylinderProperties(itemPropertiesNode as XmlElement);
else if (string.Equals(itemPropertiesNode.Name, "CaseOfBoxesProperties", StringComparison.CurrentCultureIgnoreCase))
LoadCaseOfBoxesProperties(itemPropertiesNode as XmlElement);
else if (string.Equals(itemPropertiesNode.Name, "PalletProperties", StringComparison.CurrentCultureIgnoreCase))
LoadPalletProperties(itemPropertiesNode as XmlElement);
else if (string.Equals(itemPropertiesNode.Name, "InterlayerProperties", StringComparison.CurrentCultureIgnoreCase))
LoadInterlayerProperties(itemPropertiesNode as XmlElement);
else if (string.Equals(itemPropertiesNode.Name, "PalletCornerProperties", StringComparison.CurrentCultureIgnoreCase))
LoadPalletCornerProperties(itemPropertiesNode as XmlElement);
else if (string.Equals(itemPropertiesNode.Name, "PalletCapProperties", StringComparison.CurrentCultureIgnoreCase))
LoadPalletCapProperties(itemPropertiesNode as XmlElement);
else if (string.Equals(itemPropertiesNode.Name, "PalletFilmProperties", StringComparison.CurrentCultureIgnoreCase))
LoadPalletFilmProperties(itemPropertiesNode as XmlElement);
else if (string.Equals(itemPropertiesNode.Name, "BundleProperties", StringComparison.CurrentCultureIgnoreCase))
LoadBundleProperties(itemPropertiesNode as XmlElement);
else if (string.Equals(itemPropertiesNode.Name, "TruckProperties", StringComparison.CurrentCultureIgnoreCase))
LoadTruckProperties(itemPropertiesNode as XmlElement);
else if (string.Equals(itemPropertiesNode.Name, "PackProperties", StringComparison.CurrentCultureIgnoreCase))
LoadPackProperties(itemPropertiesNode as XmlElement);
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
}
// load analyses
if (string.Equals(docChildNode.Name, "Analyses", StringComparison.CurrentCultureIgnoreCase))
{
foreach (XmlNode analysisNode in docChildNode.ChildNodes)
{
try
{
LoadAnalysis(analysisNode as XmlElement);
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
}
}
}
private Vector2D ConvertLengthFrom(Vector2D v, UnitsManager.UnitSystem us)
{
return(new Vector2D(UnitsManager.ConvertLengthFrom(v.X, us), UnitsManager.ConvertLengthFrom(v.Y, us)));
}
