private void InitializeUserInterface()
        {
            // add Next Button
            var NextBtn = new UIBarButtonItem ();
            NextBtn.Title = "Next";
            this.NavigationItem.RightBarButtonItem = NextBtn;
            NextBtn.Clicked += (object sender, EventArgs e) => {
                this.NavigationController.PushViewController ( new TankMix_Calculation_Screen_Three(),true);
            };

            // Tank Capacity

            var capacityS = new Section ();

            tcEE = new EntryElement ("Tank Capacity","0",string.Empty);
            tcEE.TextAlignment = UITextAlignment.Right;
            tcEE.KeyboardType = UIKeyboardType.NumbersAndPunctuation;
            tcEE.Changed += (object sender, EventArgs e) => {
                if(string.IsNullOrEmpty(tcEE.Value))
                {
                    HistoryManager.SharedInstance.GetCurrentTankData ().tankcapacity_value.SetValue(double.Parse("0"));
                }else{
                    HistoryManager.SharedInstance.GetCurrentTankData ().tankcapacity_value.SetValue(double.Parse(tcEE.Value));
                }
            };
            tcRG = new TankMixRadioGroupElement (-1);
            var tcRGRoot = new RootElement ("Tank Capacity Unit",tcRG);
            var tcRGRootSection = new Section ("Unit Select");
            foreach(var i in TankCapacity.GetUnitNameList())
            {
                tcRGRootSection.Add (new RadioElement (i));
            }

            tcRG.ValueSelectedEvent += (object sender, EventArgs e) => {

                if(string.IsNullOrEmpty(tcEE.Value))
                {
                    switch(tcRG.Selected)
                    {
                    case 0:
                        HistoryManager.SharedInstance.GetCurrentTankData ().tankcapacity_value.SetValueAndUnit(TankCapacityUnit.Us0gal,double.Parse("0"));
                        break;
                    case 1:
                        HistoryManager.SharedInstance.GetCurrentTankData ().tankcapacity_value.SetValueAndUnit(TankCapacityUnit.Imp0gal,double.Parse("0"));
                        break;
                    case 2:
                        HistoryManager.SharedInstance.GetCurrentTankData ().tankcapacity_value.SetValueAndUnit(TankCapacityUnit.L,double.Parse("0"));
                        break;
                    }
                }else{
                    switch(tcRG.Selected)
                    {
                    case 0:
                        HistoryManager.SharedInstance.GetCurrentTankData ().tankcapacity_value.SetValueAndUnit(TankCapacityUnit.Us0gal,double.Parse(tcEE.Value));
                        break;
                    case 1:
                        HistoryManager.SharedInstance.GetCurrentTankData ().tankcapacity_value.SetValueAndUnit(TankCapacityUnit.Imp0gal,double.Parse(tcEE.Value));
                        break;
                    case 2:
                        HistoryManager.SharedInstance.GetCurrentTankData ().tankcapacity_value.SetValueAndUnit(TankCapacityUnit.L,double.Parse(tcEE.Value));
                        break;
                    }
                }

                //trRG.Selected = tcRG.SelectedValue;
                //Root.Reload(remainderS,UITableViewRowAnimation.Fade);
            };

            tcRGRoot.Add (tcRGRootSection);
            capacityS.Add (tcEE);
            capacityS.Add (tcRGRoot);

            // Tank Remainder
            remainderS = new Section ();

            trEE = new EntryElement ("Tank Remainder at Fill", "0",string.Empty);
            trEE.TextAlignment = UITextAlignment.Right;
            trEE.KeyboardType = UIKeyboardType.NumbersAndPunctuation;
            trEE.Changed += (object sender, EventArgs e) => {
                if(string.IsNullOrEmpty(trEE.Value))
                {
                    HistoryManager.SharedInstance.GetCurrentTankData ().tankremainder_value.SetValue(double.Parse("0"));

                }else{
                    HistoryManager.SharedInstance.GetCurrentTankData ().tankremainder_value.SetValue(double.Parse(trEE.Value));

                }
            };
            trRG = new TankMixRadioGroupElement (-1);
            var trRGRoot = new RootElement ("Tank Remainder Unit", trRG);
            var trRGRootSection = new Section ("Unit Select");
            foreach( var i in TankRemainder.GetUnitNameList())
            {
                trRGRootSection.Add (new RadioElement(i));
            }

            trRG.ValueSelectedEvent += (object sender, EventArgs e) => {

                if(string.IsNullOrEmpty(trEE.Value))
                {
                    switch(trRG.Selected){
                    case 0:
                        HistoryManager.SharedInstance.GetCurrentTankData ().tankremainder_value.SetValueAndUnit(TankRemainderUnit.Us0gal,double.Parse("0"));
                        break;
                    case 1:
                        HistoryManager.SharedInstance.GetCurrentTankData ().tankremainder_value.SetValueAndUnit(TankRemainderUnit.Imp0gal,double.Parse("0"));
                        break;
                    case 2:
                        HistoryManager.SharedInstance.GetCurrentTankData ().tankremainder_value.SetValueAndUnit(TankRemainderUnit.L,double.Parse("0"));
                        break;
                    }
                }else{
                    switch(trRG.Selected){
                    case 0:
                        HistoryManager.SharedInstance.GetCurrentTankData ().tankremainder_value.SetValueAndUnit(TankRemainderUnit.Us0gal,double.Parse(trEE.Value));
                        break;
                    case 1:
                        HistoryManager.SharedInstance.GetCurrentTankData ().tankremainder_value.SetValueAndUnit(TankRemainderUnit.Imp0gal,double.Parse(trEE.Value));
                        break;
                    case 2:
                        HistoryManager.SharedInstance.GetCurrentTankData ().tankremainder_value.SetValueAndUnit(TankRemainderUnit.L,double.Parse(trEE.Value));
                        break;
                    }
                }

                //tcRG.SelectedValue = trRG.SelectedValue;
            };
            trRGRoot.Add (trRGRootSection);
            remainderS.Add (trEE);
            remainderS.Add (trRGRoot);

            // Sump Capacity
            var sumpS = new Section ();
            scEE = new EntryElement ("Sump Capacity","0",string.Empty);
            scEE.TextAlignment = UITextAlignment.Right;
            scEE.KeyboardType = UIKeyboardType.NumbersAndPunctuation;

            scRG = new TankMixRadioGroupElement (-1);
            var scRGRoot = new RootElement ("Sump Capacity Unit",scRG);
            var scRGRootSection = new Section ("Unit Select"){
                new RadioElement ("US Gal"),
                new RadioElement("Imp Gal"),
                new RadioElement ("L"),
            };
            scRG.ValueSelectedEvent += (object sender, EventArgs e) => {
                if(string.IsNullOrEmpty(scEE.Value))
                {
                    switch(scRG.Selected){
                    case 0:
                        HistoryManager.SharedInstance.GetCurrentTankData().sumpcapacity_value.SetValueAndUnit(SumpCapacityUnit.Us0gal,double.Parse("0"));
                        break;
                    case 1:
                        HistoryManager.SharedInstance.GetCurrentTankData().sumpcapacity_value.SetValueAndUnit(SumpCapacityUnit.Imp0gal,double.Parse("0"));
                        break;
                    case 2:
                        HistoryManager.SharedInstance.GetCurrentTankData().sumpcapacity_value.SetValueAndUnit(SumpCapacityUnit.L,double.Parse("0"));
                        break;
                    }
                }else
                {
                    switch(scRG.Selected){
                    case 0:
                        HistoryManager.SharedInstance.GetCurrentTankData().sumpcapacity_value.SetValueAndUnit(SumpCapacityUnit.Us0gal,double.Parse(scEE.Value));
                        break;
                    case 1:
                        HistoryManager.SharedInstance.GetCurrentTankData().sumpcapacity_value.SetValueAndUnit(SumpCapacityUnit.Imp0gal,double.Parse(scEE.Value));
                        break;
                    case 2:
                        HistoryManager.SharedInstance.GetCurrentTankData().sumpcapacity_value.SetValueAndUnit(SumpCapacityUnit.L,double.Parse(scEE.Value));
                        break;
                    }
                }

            };
            scRGRoot.Add (scRGRootSection);
            sumpS.Add (scEE);
            sumpS.Add (scRGRoot);

            Root.Add (capacityS);
            Root.Add (remainderS);
            Root.Add (sumpS);
        }
        private void InitializeUserInterface()
        {
            var Section = new Section ();
            // Tank Input
            var CurTank = HistoryManager.SharedInstance.GetCurrentTankData ();

            Result.TankInput.applicationvolume_value.SetValueAndUnit (CurTank.applicationvolume_value.unit,CurTank.applicationvolume_value.value);
            Result.TankInput.productrate_value.SetValueAndUnit (CurTank.productrate_value.unit,CurTank.productrate_value.value);
            Result.TankInput.adjuvantrate_value.SetValueAndUnit (CurTank.adjuvantrate_value.unit,CurTank.adjuvantrate_value.value);
            Result.TankInput.tankcapacity_value.SetValueAndUnit (CurTank.tankcapacity_value.unit,CurTank.tankcapacity_value.value);
            Result.TankInput.tankremainder_value.SetValueAndUnit (CurTank.tankremainder_value.unit,CurTank.tankremainder_value.value);
            Result.TankInput.sumpcapacity_value.SetValueAndUnit (CurTank.sumpcapacity_value.unit,CurTank.sumpcapacity_value.value);
            Result.TankInput.totalarea_value.SetValueAndUnit (CurTank.totalarea_value.unit,CurTank.totalarea_value.value);
            Result.TankInput.boomwidth_value.SetValueAndUnit (CurTank.boomwidth_value.unit,CurTank.boomwidth_value.value);
            Result.TankInput.swathlength_value.SetValueAndUnit (CurTank.swathlength_value.unit,CurTank.swathlength_value.value);
            Result.TankInput.number_headlands_swaths_value = CurTank.number_headlands_swaths_value;

            // Area Treated By Tank
            var r_AreaTreatedByTank = 0.0;
            r_AreaTreatedByTank = CalculationManager.SharedInstance.AreaTreatedByTank ();
            Result.areatreatedbytank_value.value = r_AreaTreatedByTank;
            if (HistoryManager.SharedInstance.GetCurrentTankData ().tankcapacity_value.unit == TankCapacityUnit.L) {
                Result.areatreatedbytank_value.unit = AreaTreatedByTankUnit.Ha;
                Result.areatreatedbytank_value.Ha = r_AreaTreatedByTank;
                Result.areatreatedbytank_value.Acres = CalculationManager.SharedInstance.HaToAcres (Result.areatreatedbytank_value.Ha);

            } else {
                Result.areatreatedbytank_value.unit = AreaTreatedByTankUnit.Acres;
                Result.areatreatedbytank_value.Acres = r_AreaTreatedByTank;
                Result.areatreatedbytank_value.Ha = CalculationManager.SharedInstance.AcresToHa (Result.areatreatedbytank_value.Acres);
            }
            atbtRG = new TankMixRadioGroupElement (0);
            var atbtRGRoot = new RootElement ("Area Treated By Tank",atbtRG);
            var atbtRGRootSection = new Section ();
            switch (Result.areatreatedbytank_value.unit)
            {
            case AreaTreatedByTankUnit.Acres:
                atbtRGRootSection.Add (new RadioElement (string.Format("{0:00.00}",Result.areatreatedbytank_value.Acres)+ " Acres"));
                atbtRGRootSection.Add (new RadioElement(string.Format("{0:00.00}",Result.areatreatedbytank_value.Ha) + " Ha"));
                break;
            case AreaTreatedByTankUnit.Ha:
                atbtRGRootSection.Add (new RadioElement(string.Format("{0:00.00}",Result.areatreatedbytank_value.Ha) + " Ha"));
                atbtRGRootSection.Add (new RadioElement (string.Format("{0:00.00}",Result.areatreatedbytank_value.Acres)+ " Acres"));
                break;
            }

            atbtRGRoot.Add (atbtRGRootSection);
            Section.Add (atbtRGRoot);

            // Product Amount
            var r_ProductAmount = 0.0;
            r_ProductAmount = CalculationManager.SharedInstance.ProductAmount (Result.areatreatedbytank_value);
            switch(HistoryManager.SharedInstance.GetCurrentTankData().productrate_value.unit)
            {
            case ProductRateUnit.Acres_case:
                Result.productamount_value.SetValueAndUnit (ProductAmountUnit.Case, r_ProductAmount);
                break;
            case ProductRateUnit.G_acre:
                Result.productamount_value.SetValueAndUnit (ProductAmountUnit.G, r_ProductAmount);
                break;
            case ProductRateUnit.G_ha:
                Result.productamount_value.SetValueAndUnit (ProductAmountUnit.G, r_ProductAmount);
                break;
            case ProductRateUnit.L_acre:
                Result.productamount_value.SetValueAndUnit (ProductAmountUnit.L, r_ProductAmount);
                break;
            case ProductRateUnit.L_ha:
                Result.productamount_value.SetValueAndUnit (ProductAmountUnit.L, r_ProductAmount);
                break;
            case ProductRateUnit.Ml_acre:
                Result.productamount_value.SetValueAndUnit (ProductAmountUnit.Ml, r_ProductAmount);
                break;
            case ProductRateUnit.Ml_ha:
                Result.productamount_value.SetValueAndUnit (ProductAmountUnit.Ml, r_ProductAmount);
                break;
            case ProductRateUnit.Oz_acre:
                Result.productamount_value.SetValueAndUnit (ProductAmountUnit.Oz, r_ProductAmount);
                break;
            case ProductRateUnit.Us0fl_oz_acre:
                Result.productamount_value.SetValueAndUnit (ProductAmountUnit.Us0fl_oz, r_ProductAmount);
                break;
            case ProductRateUnit.Us0pint_acre:
                Result.productamount_value.SetValueAndUnit(ProductAmountUnit.L,CalculationManager.SharedInstance.Us_pintToL(r_ProductAmount));
                break;
            case ProductRateUnit.Us0quart_acre:
                Result.productamount_value.SetValueAndUnit(ProductAmountUnit.L,CalculationManager.SharedInstance.Us_quarttToL(r_ProductAmount));
                break;
            }

            paRG = new TankMixRadioGroupElement ((int)(Result.productamount_value.unit));
            var paRGRoot = new RootElement ("Product Amount",paRG);
            var paRGRootSection = new Section (){
                new RadioElement(string.Format("{0:00.00}",Result.productamount_value.Case) + "   Cases"),
                new RadioElement(string.Format("{0:00.00}",Result.productamount_value.L) + "  L"),
                new RadioElement(string.Format("{0:00.00}",Result.productamount_value.Ml)+ "  Ml"),
                new RadioElement(string.Format("{0:00.00}",Result.productamount_value.G) + "  G"),
                new RadioElement(string.Format("{0:00.00}",Result.productamount_value.Us_fl_oz)+ "  US fl oz"),
                new RadioElement(string.Format("{0:00.00}",Result.productamount_value.Oz )+ "  Oz"),
            };
            paRGRoot.Add (paRGRootSection);
            Section.Add (paRGRoot);

            // Adjuvant Amount
            var r_AdjuvantAmount = CalculationManager.SharedInstance.AdjuvantAmount (Result.areatreatedbytank_value);
            switch(HistoryManager.SharedInstance.GetCurrentTankData().adjuvantrate_value.unit)
            {
            case AdjuvantRateUnit.L_acre:
                Result.adjuvantamount_value.SetValueAndUnit (AdjuvantAmountUnit.L, r_AdjuvantAmount);
                break;
            case AdjuvantRateUnit.Ml_acre:
                Result.adjuvantamount_value.SetValueAndUnit (AdjuvantAmountUnit.Ml, r_AdjuvantAmount);
                break;
            case AdjuvantRateUnit.Quart_acre:
                Result.adjuvantamount_value.SetValueAndUnit (AdjuvantAmountUnit.Us_quart, r_AdjuvantAmount);
                break;
            case AdjuvantRateUnit.Us0fl_oz_acre:
                Result.adjuvantamount_value.SetValueAndUnit (AdjuvantAmountUnit.Us_fl_oz, r_AdjuvantAmount);
                break;
            case AdjuvantRateUnit.V_v:
                Result.adjuvantamount_value.SetValueAndUnit (AdjuvantAmountUnit.L, r_AdjuvantAmount);
                break;
            }
            aaRG = new TankMixRadioGroupElement ((int)Result.adjuvantamount_value.unit);
                var aaRGRoot = new RootElement ("Adjuvant Amount", aaRG);
                var aaRGRootSection = new Section (){
                new RadioElement(string.Format("{0:00.00}",Result.adjuvantamount_value.L)+"  L"),
                new RadioElement(string.Format("{0:00.00}",Result.adjuvantamount_value.Ml)+"  mL"),
                new RadioElement(string.Format("{0:00.00}",Result.adjuvantamount_value.Us_fl_oz)+"  US Fl oz"),
                new RadioElement(string.Format("{0:00.00}",Result.adjuvantamount_value.Us_quart)+"  US Quart"),

            };
            aaRGRoot.Add (aaRGRootSection);
            Section.Add (aaRGRoot);

            //Total Water
            var r_totalWater = CalculationManager.SharedInstance.TotalWater();
            ttRG = new TankMixRadioGroupElement ((int)HistoryManager.SharedInstance.GetCurrentTankData().applicationvolume_value.unit);
            switch (HistoryManager.SharedInstance.GetCurrentTankData().applicationvolume_value.unit)
            {
            case ApplicationVolumeUnit.Imp0gpa:
                Result.totalwater_value.SetValueAndUnit (TotalWaterUnit.Imp_gal,r_totalWater);
                break;
            case ApplicationVolumeUnit.L_ha:
                Result.totalwater_value.SetValueAndUnit (TotalWaterUnit.L,r_totalWater);
                break;
            case ApplicationVolumeUnit.US0gpa:
                Result.totalwater_value.SetValueAndUnit (TotalWaterUnit.Us_gal,r_totalWater);
                break;
            }
            var ttRGRoot = new RootElement ("Total Water",ttRG);
            var ttRGRootSection = new Section ("Unit Select"){
                new RadioElement(string.Format("{0:00.00}",Result.totalwater_value.value) + " Us Gal"),
                new RadioElement(string.Format("{0:00.00}",Result.totalwater_value.value) + " Imp Gal"),
            new RadioElement(string.Format("{0:00.00}",Result.totalwater_value.value) + " L"),
            };
            ttRGRoot.Add (ttRGRootSection);
            Section.Add (ttRGRoot);

            // number of tanks needed
            Result.numberOfTanksNeeded = CalculationManager.SharedInstance.NumberOfTankNeeded (Result.totalwater_value);
            //notnRG = new TankMixRadioGroupElement (0);
            notn = new StringElement ("Number of Tanks Needed",string.Format("{0:0.00}",Result.numberOfTanksNeeded));
            Section.Add (notn);
            //var notnRGRoot = new RootElement ("Number of Tanks Needed",notnRG);
            var temp = Result.numberOfTanksNeeded;
            var counter = 0;
            while (temp > 0) {
                temp = temp - 1;
                counter++;
            }
            Result.numberOfFills = counter;

            switch(HistoryManager.SharedInstance.GetCurrentTankData().boomwidth_value.unit)
            {
            case BoomWidthUnit.Ft:
                Result.areaperround_value.SetValueAndUnit (AreaPerRoundUnit.Acres, CalculationManager.SharedInstance.HaToAcres (CalculationManager.SharedInstance.AreaPerRound()));
                break;
            case BoomWidthUnit.M:
                Result.areaperround_value.SetValueAndUnit (AreaPerRoundUnit.Ha,CalculationManager.SharedInstance.AreaPerRound());
                break;

            }
            var notRGAreaRound = new TankMixRadioGroupElement ((int)HistoryManager.SharedInstance.GetCurrentTankData().boomwidth_value.unit);
            var notRGAreaRoundSection = new Section ()
            {
            new RadioElement(string.Format("{0:0.00}",Result.areaperround_value.Ha)+" Ha"),
            new RadioElement(string.Format("{0:0.00}",Result.areaperround_value.Acres)+" Acres"),
            };
            var notRGAreaRoundRoot = new RootElement("Area Per Round",notRGAreaRound);
            notRGAreaRoundRoot.Add (notRGAreaRoundSection);
            var nonRGRootSection = new Section ();
            nonRGRootSection.Add (new RadioElement(string.Format("{0:0.00}",Result.numberOfTanksNeeded)));
            Section.Add (new StringElement("Number of Fills",Result.numberOfFills.ToString()));
            Section.Add (notRGAreaRoundRoot);

            Result.roundpertank = CalculationManager.SharedInstance.RoundsPerTank (Result.areaperround_value);
            Section.Add (new StringElement("Rounds per Tank", string.Format("{0:0.00}",Result.roundpertank)));

            var FillSection = new Section ("Fills");
            var index = 1;
            for(int i=1; i<=Result.numberOfFills; i++)
            {
                var btn = new StringElement ("Fill "+i, string.Empty);
                btn.Tapped += () => {

                    this.NavigationController.PushViewController(new TankMix_CalculationCreateFill (Convert.ToInt32(btn.Caption.Split(' ')[1]),Result.fills,int.Parse(Result.numberOfFills.ToString())),true);

                };
                FillSection.Add (btn);
                index++;
            }
            Root.Add (Section);
            Root.Add (FillSection);

            // Save Btn
            var SaveBtn = new UIBarButtonItem ();
            SaveBtn.Title = "Save";
            SaveBtn.Clicked += (object sender, EventArgs e) => {

                //Set value to NSDefault User
                var r = Result.TankInput.tankcapacity_value.value;
                var keyValue = new object[] { "Application Volume", "Product Rate","Adjuvant Rate",
                    "Tank Capacity", "Tank Remainder", "Sump Capacity",
                    "Total Area","Boom Width","Swath Length"," Headland Swaths"
                };
                var dataValue = new object[] { Result.TankInput.applicationvolume_value.value.ToString(),
                    Result.TankInput.productrate_value.value.ToString(),
                    Result.TankInput.adjuvantrate_value.value.ToString(),
                    Result.TankInput.tankcapacity_value.value.ToString(),
                    Result.TankInput.tankremainder_value.value.ToString(),
                    Result.TankInput.sumpcapacity_value.value.ToString(),
                    Result.TankInput.totalarea_value.value.ToString(),
                    Result.TankInput.boomwidth_value.value.ToString(),
                    Result.TankInput.swathlength_value.value.ToString(),
                    Result.TankInput.number_headlands_swaths_value.ToString(),
                };

                var unitValue = new object[] { Result.TankInput.applicationvolume_value.unit.ToString(),
                    Result.TankInput.productrate_value.unit.ToString(),
                    Result.TankInput.adjuvantrate_value.unit.ToString(),
                    Result.TankInput.tankcapacity_value.unit.ToString(),
                    Result.TankInput.tankremainder_value.unit.ToString(),
                    Result.TankInput.sumpcapacity_value.unit.ToString(),
                    Result.TankInput.totalarea_value.unit.ToString(),
                    Result.TankInput.boomwidth_value.unit.ToString(),
                    Result.TankInput.swathlength_value.unit.ToString(),
                    string.Empty,
                };

                NSDictionary defaultDataValue = NSDictionary.FromObjectsAndKeys(dataValue,keyValue);
                NSDictionary defaultUnitValue = NSDictionary.FromObjectsAndKeys(unitValue,keyValue);
                NSUserDefaults.StandardUserDefaults.SetValueForKey(defaultDataValue,new NSString("LatestData"));
                NSUserDefaults.StandardUserDefaults.SetValueForKey(defaultUnitValue,new NSString("LatestUnit"));

                var a = HistoryManager.SharedInstance.GetResultList();
                a.Add(Result);
                var Alert = new UIAlertView ();
                Alert.Message = "Successfully Saved";
                Alert.AddButton ("Continue");
                Alert.Clicked += (object s, UIButtonEventArgs ee) => {
                    if(ee.ButtonIndex == 0)
                    {
                        this.NavigationController.PopToRootViewController(true);
                    }
                };
                Alert.Show();
            };
            this.NavigationItem.RightBarButtonItem = SaveBtn;
        }
        private void InitializeUserInterface()
        {
            // add Result Button
            var NextBtn = new UIBarButtonItem ();
            NextBtn.Title = "Result";
            NextBtn.TintColor = UIColor.Red;
            this.NavigationItem.RightBarButtonItem = NextBtn;
            NextBtn.Clicked += (object sender, EventArgs e) => {
                this.NavigationController.PushViewController ( new TankMix_Calculation_Screen_Four(),true);
            };

            // Total Area
            var areaS = new Section ();
            taEE = new EntryElement ("Total Area","0",string.Empty);
            taEE.TextAlignment = UITextAlignment.Right;
            taEE.KeyboardType = UIKeyboardType.NumbersAndPunctuation;
            taEE.Changed += (object sender, EventArgs e) => {
                if(string.IsNullOrEmpty(taEE.Value)){
                    HistoryManager.SharedInstance.GetCurrentTankData ().totalarea_value.SetValue(double.Parse("0"));
                }else{
                    HistoryManager.SharedInstance.GetCurrentTankData ().totalarea_value.SetValue(double.Parse(taEE.Value));
                }
            };
            taRG = new TankMixRadioGroupElement (-1);
            var taRGRoot = new RootElement ("Total Area Unit",taRG);
            var taRGRootSection = new Section ("Select Unit");
            foreach(var i in TotalArea.GetUnitNameList())
            {
                taRGRootSection.Add (new RadioElement(i));
            }

            taRG.ValueSelectedEvent += (object sender, EventArgs e) => {
                if(string.IsNullOrEmpty(taEE.Value)){
                    switch(taRG.Selected)
                    {
                    case 0:
                        HistoryManager.SharedInstance.GetCurrentTankData().totalarea_value.SetValueAndUnit(TotalAreaUnit.Acres,double.Parse("0"));
                        break;
                    case 1:
                        HistoryManager.SharedInstance.GetCurrentTankData().totalarea_value.SetValueAndUnit(TotalAreaUnit.Ha,double.Parse("0"));
                        break;
                    }
                }else{
                    switch(taRG.Selected)
                    {
                    case 0:
                        HistoryManager.SharedInstance.GetCurrentTankData().totalarea_value.SetValueAndUnit(TotalAreaUnit.Acres,double.Parse(taEE.Value));
                        break;
                    case 1:
                        HistoryManager.SharedInstance.GetCurrentTankData().totalarea_value.SetValueAndUnit(TotalAreaUnit.Ha,double.Parse(taEE.Value));
                        break;
                    }
                }

            };
            areaS.Add (taEE);
            taRGRoot.Add (taRGRootSection);
            areaS.Add (taRGRoot);

            //Boom Width
            var widthS = new Section ();
            bwEE = new EntryElement ("Boom Width","0",string.Empty);
            bwEE.TextAlignment = UITextAlignment.Right;
            bwEE.KeyboardType = UIKeyboardType.NumbersAndPunctuation;
            bwEE.Changed += (object sender, EventArgs e) => {
                HistoryManager.SharedInstance.GetCurrentTankData ().boomwidth_value.SetValue(double.Parse(bwEE.Value));
            };
            bwRG = new TankMixRadioGroupElement (-1);
            var bwRGRoot = new RootElement ("Boom Width Unit", bwRG);
            var bwRGRootSection = new Section ("Select Unit");
            foreach( var i in BoomWidth.GetUnitNameList())
            {
                bwRGRootSection.Add (new RadioElement(i));
            }

            taRG.ValueSelectedEvent += (object sender, EventArgs e) => {
                if(string.IsNullOrEmpty(bwEE.Value))
                {
                    switch(bwRG.Selected)
                    {
                    case 0:
                        var c = bwEE.Value;
                        HistoryManager.SharedInstance.GetCurrentTankData().boomwidth_value.SetValueAndUnit(BoomWidthUnit.M,double.Parse("0"));
                        break;

                    case 1:
                        HistoryManager.SharedInstance.GetCurrentTankData().boomwidth_value.SetValueAndUnit(BoomWidthUnit.Ft,double.Parse("0"));
                        break;
                    }
                }else{
                    switch(bwRG.Selected)
                    {
                    case 0:
                        var c = bwEE.Value;
                        HistoryManager.SharedInstance.GetCurrentTankData().boomwidth_value.SetValueAndUnit(BoomWidthUnit.M,double.Parse(bwEE.Value));
                        break;

                    case 1:
                        HistoryManager.SharedInstance.GetCurrentTankData().boomwidth_value.SetValueAndUnit(BoomWidthUnit.Ft,double.Parse(bwEE.Value));
                        break;
                    }
                }

            };
            widthS.Add (bwEE);
            bwRGRoot.Add (bwRGRootSection);
            widthS.Add (bwRGRoot);

            // Swath Length
            var lengthS = new Section ();
            slEE = new EntryElement ("Swath Length", "0",string.Empty);
            slEE.TextAlignment = UITextAlignment.Right;
            slEE.KeyboardType = UIKeyboardType.NumbersAndPunctuation;
            slEE.Changed += (object sender, EventArgs e) => {
                if(string.IsNullOrEmpty(slEE.Value))
                {
                    HistoryManager.SharedInstance.GetCurrentTankData ().swathlength_value.SetValue(double.Parse("0"));
                }else{
                    HistoryManager.SharedInstance.GetCurrentTankData ().swathlength_value.SetValue(double.Parse(slEE.Value));
                }

            };
            slRG = new TankMixRadioGroupElement (-1);
            var slRGRoot = new RootElement ("Swath Length Unit",slRG);
            var slRGRootSection = new Section ("Select Unit");
            foreach(var i in SwathLength.GetUnitNameList())
            {
                slRGRootSection.Add (new RadioElement(i));
            }

            slRG.ValueSelectedEvent += (object sender, EventArgs e) => {
                if(string.IsNullOrEmpty(slEE.Value))
                {
                    switch(slRG.Selected)
                    {
                    case 0:
                        HistoryManager.SharedInstance.GetCurrentTankData().swathlength_value.SetValueAndUnit(SwathLengthUnit.Mile,double.Parse("0"));
                        break;
                    case 1:
                        HistoryManager.SharedInstance.GetCurrentTankData().swathlength_value.SetValueAndUnit(SwathLengthUnit.M,double.Parse("0"));
                        break;
                    }
                }else{
                    switch(slRG.Selected)
                    {
                    case 0:
                        HistoryManager.SharedInstance.GetCurrentTankData().swathlength_value.SetValueAndUnit(SwathLengthUnit.Mile,double.Parse(slEE.Value));
                        break;
                    case 1:
                        HistoryManager.SharedInstance.GetCurrentTankData().swathlength_value.SetValueAndUnit(SwathLengthUnit.M,double.Parse(slEE.Value));
                        break;
                    }
                }

            };
            lengthS.Add (slEE);
            slRGRoot.Add (slRGRootSection);
            lengthS.Add (slRGRoot);

            // Number of Headland Swaths
            var numberS = new Section ();
            nhsEE = new EntryElement ("Number of Headland Swaths","0",string.Empty);
            nhsEE.KeyboardType = UIKeyboardType.NumbersAndPunctuation;
            nhsEE.TextAlignment = UITextAlignment.Right;
            nhsEE.Changed += (object sender, EventArgs e) => {
                if(string.IsNullOrEmpty(nhsEE.Value)){
                    HistoryManager.SharedInstance.GetCurrentTankData().number_headlands_swaths_value = double.Parse("0");
                }else{
                    HistoryManager.SharedInstance.GetCurrentTankData().number_headlands_swaths_value = double.Parse(nhsEE.Value);
                }
            };
            numberS.Add (nhsEE);

            Root.Add (areaS);
            Root.Add (widthS);
            Root.Add (lengthS);
            Root.Add (numberS);
        }
        // Create Default User Interface for Screen One
        private void InitializeUserInterface()
        {
            // add Next Button
            var NextBtn = new UIBarButtonItem ();
            NextBtn.Title = "Next";
            this.NavigationItem.RightBarButtonItem = NextBtn;
            NextBtn.Clicked += (object sender, EventArgs e) => {
                this.NavigationController.PushViewController ( new TankMix_Calculation_Screen_Two(),true);
            };

            var volumeS = new Section ();

            // Application Volume
            avEE = new EntryElement ("Application Volume", "0", string.Empty);
            avEE.TextAlignment = UITextAlignment.Right;
            avEE.KeyboardType = UIKeyboardType.NumbersAndPunctuation;
            avEE.Changed += (object sender, EventArgs e) => {
                if(string.IsNullOrEmpty(avEE.Value)){
                    HistoryManager.SharedInstance.GetCurrentTankData ().applicationvolume_value.SetValue(double.Parse("0"));

                }else{
                    HistoryManager.SharedInstance.GetCurrentTankData ().applicationvolume_value.SetValue(double.Parse(avEE.Value));
                }
            };

            avRG = new TankMixRadioGroupElement (-1);
            var avRGRoot = new RootElement ("Application Volume Unit", avRG);
            var avRGRootSection = new Section ("Select Unit");

            foreach( var i in ApplicationVolume.GetUnitNameList())
            {
                avRGRootSection.Add( new RadioElement (i));
            };

            avRG.ValueSelectedEvent +=  (object sender, EventArgs e) =>
            {
                if(string.IsNullOrEmpty( avEE.Value))
                {
                    switch(avRG.Selected)
                    {
                    case 0:
                        HistoryManager.SharedInstance.GetCurrentTankData ().applicationvolume_value.SetValueAndUnit(ApplicationVolumeUnit.US0gpa,double.Parse("0"));
                        break;
                    case 1:
                        HistoryManager.SharedInstance.GetCurrentTankData ().applicationvolume_value.SetValueAndUnit(ApplicationVolumeUnit.Imp0gpa,double.Parse("0"));
                        break;
                    case 2:
                        HistoryManager.SharedInstance.GetCurrentTankData ().applicationvolume_value.SetValueAndUnit(ApplicationVolumeUnit.L_ha,double.Parse("0"));
                        break;
                    }
                }else
                {
                    switch(avRG.Selected)
                    {
                    case 0:
                        HistoryManager.SharedInstance.GetCurrentTankData ().applicationvolume_value.SetValueAndUnit(ApplicationVolumeUnit.US0gpa ,double.Parse(avEE.Value));
                        break;
                    case 1:
                        HistoryManager.SharedInstance.GetCurrentTankData ().applicationvolume_value.SetValueAndUnit(ApplicationVolumeUnit.Imp0gpa,double.Parse(avEE.Value));
                        break;
                    case 2:
                        HistoryManager.SharedInstance.GetCurrentTankData ().applicationvolume_value.SetValueAndUnit(ApplicationVolumeUnit.L_ha,double.Parse(avEE.Value));
                        break;
                    }
                }

            };
            avRGRoot.Add (avRGRootSection);
            // add elements to section
            volumeS.Add (avEE);
            volumeS.Add (avRGRoot);

            // Producate Rate
            var rateS = new Section ();
            prEE = new EntryElement ("Product Rate", "0", string.Empty);
            prEE.TextAlignment = UITextAlignment.Right;
            prEE.KeyboardType = UIKeyboardType.NumbersAndPunctuation;
            prEE.Changed += (object sender, EventArgs e) =>
            {
                if(string.IsNullOrEmpty(prEE.Value))
                {
                    HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValue(double.Parse("0"));
                }else
                {
                    HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValue(double.Parse(prEE.Value));
                }
            };

            prRG = new TankMixRadioGroupElement (-1);
            var prRGRoot = new RootElement ("Product Rate Unit",prRG);
            var prRGRootSection = new Section ("Select Unit");

            foreach(var i in ProductRate.GetUnitNameList())
            {
                prRGRootSection.Add (new RadioElement(i));
            }

            prRG.ValueSelectedEvent += (object sender, EventArgs e) =>
            {
                if(string.IsNullOrEmpty(prEE.Value))
                {
                    switch(prRG.Selected)
                    {
                    case 0:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.Acres_case,double.Parse("0"));
                        break;
                    case 1:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.L_acre,double.Parse("0"));
                        break;
                    case 2:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.G_acre,double.Parse("0"));
                        break;
                    case 3:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.Ml_acre,double.Parse("0"));
                        break;
                    case 4:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.Us0fl_oz_acre,double.Parse("0"));
                        break;
                    case 5:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.Us0pint_acre,double.Parse("0"));
                        break;
                    case 6:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.Us0quart_acre,double.Parse("0"));
                        break;
                    case 7:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.Oz_acre,double.Parse("0"));
                        break;
                    case 8:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.L_ha,double.Parse("0"));
                        break;
                    case 9:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.G_ha,double.Parse("0"));
                        break;
                    case 10:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.Ml_ha,double.Parse("0"));
                        break;
                    }
                }else
                {
                    switch(prRG.Selected)
                    {
                    case 0:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.Acres_case,double.Parse(prEE.Value));
                        break;
                    case 1:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.L_acre,double.Parse(prEE.Value));
                        break;
                    case 2:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.G_acre,double.Parse(prEE.Value));
                        break;
                    case 3:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.Ml_acre,double.Parse(prEE.Value));
                        break;
                    case 4:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.Us0fl_oz_acre,double.Parse(prEE.Value));
                        break;
                    case 5:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.Us0pint_acre,double.Parse(prEE.Value));
                        break;
                    case 6:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.Us0quart_acre,double.Parse(prEE.Value));
                        break;
                    case 7:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.Oz_acre,double.Parse(prEE.Value));
                        break;
                    case 8:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.L_ha,double.Parse(prEE.Value));
                        break;
                    case 9:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.G_ha,double.Parse(prEE.Value));
                        break;
                    case 10:
                        HistoryManager.SharedInstance.GetCurrentTankData ().productrate_value.SetValueAndUnit(ProductRateUnit.Ml_ha,double.Parse(prEE.Value));
                        break;
                    }
                }

            };
            prRGRoot.Add (prRGRootSection);
            rateS.Add (prEE);
            rateS.Add (prRGRoot);

            // Adjuvant Rate
            var adjuvantS = new Section ();
            arEE = new EntryElement ("Adjuvant Rate","0",string.Empty);
            arEE.TextAlignment = UITextAlignment.Right;
            arEE.KeyboardType = UIKeyboardType.NumbersAndPunctuation;
            arEE.Changed += (object sender, EventArgs e) => {
                if(string.IsNullOrEmpty(arEE.Value))
                {
                    HistoryManager.SharedInstance.GetCurrentTankData ().adjuvantrate_value.SetValue(double.Parse("0"));
                }else{
                    HistoryManager.SharedInstance.GetCurrentTankData ().adjuvantrate_value.SetValue(double.Parse(arEE.Value));
                }

            };

            arRG = new TankMixRadioGroupElement (-1);
            var arRGRoot = new RootElement ("Adjuvant Rate Unit",arRG);
            var arRGSection = new Section ("Select Unit");
            foreach( var i in AdjuvantRate.GetUnitNameList())
            {
                arRGSection.Add (new RadioElement(i));
            }

            arRG.ValueSelectedEvent += (object o, EventArgs e)=>{

                if(string.IsNullOrEmpty(arEE.Value))
                {
                    switch (arRG.Selected)
                    {
                    case 0 :
                        HistoryManager.SharedInstance.GetCurrentTankData ().adjuvantrate_value.SetValueAndUnit(AdjuvantRateUnit.V_v,double.Parse("0"));
                        break;
                    case 1:
                        HistoryManager.SharedInstance.GetCurrentTankData ().adjuvantrate_value.SetValueAndUnit(AdjuvantRateUnit.L_acre,double.Parse("0"));
                        break;
                    case 2:
                        HistoryManager.SharedInstance.GetCurrentTankData ().adjuvantrate_value.SetValueAndUnit(AdjuvantRateUnit.Ml_acre, double.Parse("0"));
                        break;
                    case 3:
                        HistoryManager.SharedInstance.GetCurrentTankData ().adjuvantrate_value.SetValueAndUnit(AdjuvantRateUnit.Us0fl_oz_acre,double.Parse("0"));
                        break;
                    case 4:
                        HistoryManager.SharedInstance.GetCurrentTankData ().adjuvantrate_value.SetValueAndUnit(AdjuvantRateUnit.Quart_acre,double.Parse("0"));
                        break;
                    }
                }else
                {
                    switch (arRG.Selected)
                    {
                    case 0 :
                        HistoryManager.SharedInstance.GetCurrentTankData ().adjuvantrate_value.SetValueAndUnit(AdjuvantRateUnit.V_v,double.Parse(arEE.Value));
                        break;
                    case 1:
                        HistoryManager.SharedInstance.GetCurrentTankData ().adjuvantrate_value.SetValueAndUnit(AdjuvantRateUnit.L_acre,double.Parse(arEE.Value));
                        break;
                    case 2:
                        HistoryManager.SharedInstance.GetCurrentTankData ().adjuvantrate_value.SetValueAndUnit(AdjuvantRateUnit.Ml_acre, double.Parse(arEE.Value));
                        break;
                    case 3:
                        HistoryManager.SharedInstance.GetCurrentTankData ().adjuvantrate_value.SetValueAndUnit(AdjuvantRateUnit.Us0fl_oz_acre,double.Parse(arEE.Value));
                        break;
                    case 4:
                        HistoryManager.SharedInstance.GetCurrentTankData ().adjuvantrate_value.SetValueAndUnit(AdjuvantRateUnit.Quart_acre,double.Parse(arEE.Value));
                        break;
                    }
                }

            };
            arRGRoot.Add (arRGSection);
            adjuvantS.Add (arEE);
            adjuvantS.Add (arRGRoot);

            Root.Add (volumeS);
            Root.Add (rateS);
            Root.Add (adjuvantS);
        }