tbf/TBF/UI/TestProgressControls.cs

///
/// Copyright (c) 2013-2015 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
using System.Windows.Forms;
using TBF.UiBridge;
using TBF.BenchControl;
using TBF.UI.Shared;

namespace TBF.UI
{
	public class TestProgressControls
	{
        System.Windows.Forms.Control parent;                /// parent is progressFlowLayoutPanel of the only MainWnd instance
		IList<TestProgressCtrl> progresses;
		TestProgressCtrl currentProgress;

		public TestProgressControls(Control parent)
		{
			this.parent = parent;
			progresses  = null;
			currentProgress = null;

			Bridge.ProcedureSelectedHandler += delegate(object sender, ProcedureSelectedEventArgs args)
			{
                if (Program.MainWnd.InvokeRequired)
                {
    				Program.MainWnd.Invoke(new EventHandler<ProcedureSelectedEventArgs>(OnProcedureSelected), sender, args);
                }
                else OnProcedureSelected(sender, args);
			};
			Bridge.TestSelectedHandler += delegate(object sender, TestSelectedEventArgs args)
			{
                if (Program.MainWnd.InvokeRequired)
                {
    				Program.MainWnd.Invoke(new EventHandler<TestSelectedEventArgs>(OnTestSelected), sender, args);
                }
                else OnTestSelected(sender, args);
			};
			Bridge.TestProgressHandler += delegate(object sender, TestProgressEventArgs args)
			{
                if (Program.MainWnd.InvokeRequired)
                {
    				Program.MainWnd.Invoke(new EventHandler<TestProgressEventArgs>(OnTestProgress), sender, args);
                }
                else OnTestProgress(sender, args);
			};
			Bridge.TestCompletedHandler += delegate(object sender, TestCompletedEventArgs args)
			{
                if (Program.MainWnd.InvokeRequired)
                {
    				Program.MainWnd.Invoke(new EventHandler<TestCompletedEventArgs>(OnTestCompleted), sender, args);
                }
                else OnTestCompleted(sender, args);
			};
			Bridge.ProcedureCompletedHandler += delegate(object sender, ProcedureCompletedEventArgs args)
			{
                if (Program.MainWnd.InvokeRequired)
                {
    				Program.MainWnd.Invoke(new EventHandler<ProcedureCompletedEventArgs>(OnProcedureCompleted), sender, args);
                }
                else OnProcedureCompleted(sender, args);
            };
		}


        void ResetProgressBars(Config.Entities.Procedure procedure)
        {
            foreach (var test in procedure.Tests)
            {
                var component = TbfComponents.FindComponent(test.Method);
                if (component != null)
                {
                    test.IsOuterLoopStart = component is TBF.BenchControl.TestMethods.OuterLoop.Start.Component;
                    test.IsOuterLoopEnd = component is TBF.BenchControl.TestMethods.OuterLoop.End.Component;
                }
            }

            parent.SuspendLayout();

            currentProgress = null;
            parent.Controls.Clear();
            progresses = new List<TestProgressCtrl>();
            bool isOuterLoopMode = false;
            int outerLoopRepeats = 0;

            int i = 0;
            while (i < procedure.Tests.Count)
            {
                Config.Entities.Test test = procedure.Tests[i++];

                if (!isOuterLoopMode && test.IsOuterLoopStart)
                {
                    isOuterLoopMode = true;
                    outerLoopRepeats = (i < procedure.Tests.Count) ? procedure.Tests[i].Repeats : 1;
                    continue;
                }
                else if (isOuterLoopMode && test.IsOuterLoopEnd)
                {
                    isOuterLoopMode = false;
                    continue;
                }

                int repeats = test.Repeats;
                int newI = i;
                for (int r = 1; r <=repeats ; r++)
                {
                    if (isOuterLoopMode)
                    {
                        int j = i - 1;
                        while (j < procedure.Tests.Count)
                        {
                            Config.Entities.Test test2 = procedure.Tests[j++];

                            if (test2.IsOuterLoopEnd)
                            {
                                if (r == repeats) newI = j;
                                break;
                            }

                            string test2Name = global::Results.Utils.GetTestName(test2.Name, test2.Repeats, r);
                            TestProgressCtrl progress =
                                new TestProgressCtrl(test2.Id, test2Name, test2.Part, Utils.TestTitle(test2, r), r, test2.Repeats);
                            progresses.Add(progress);
                            parent.Controls.Add(progress);
                            Console.WriteLine(test2Name);
                        }
                    }
                    else
                    {
                        string testName = global::Results.Utils.GetTestName(test.Name, test.Repeats, r);
                        TestProgressCtrl progress =
                            new TestProgressCtrl(test.Id, testName, test.Part, Utils.TestTitle(test, r), r, test.Repeats);
                        progresses.Add(progress);
                        parent.Controls.Add(progress);
                        Console.WriteLine(testName);
                    }
                }

                i = newI;
            }

            parent.ResumeLayout();
        }


        public void ProcedureSelectedInUI(object sender, ProcedureSelectedEventArgs args)
        {
            ResetProgressBars(args.Procedure);
        }

		void OnProcedureSelected(object sender, ProcedureSelectedEventArgs args)
		{
            ResetProgressBars(args.Procedure);
		}

		void OnTestSelected(object sender, TestSelectedEventArgs args)
		{
			if (progresses != null)
			{
				foreach (var prgrs in progresses)
				{
					if ((prgrs.TestId == args.Test.Id) && (prgrs.RepetitionNr == args.RepetitionNr))
					{
						currentProgress = prgrs;
						currentProgress.Progress = 0;
						currentProgress.TestResult = TestProgressCtrl.Result.NotDone;
						return;
					}
				}
			}
			currentProgress = null;
		}

		void OnTestProgress(object sender, TestProgressEventArgs args)
		{
            foreach (var prgrs in progresses)
            {
				if (prgrs.TestName == args.TestName && prgrs.Part == args.Part)
                {
                    prgrs.Progress = args.Progress;
                    break;
                }
            }
		}

		void OnTestCompleted(object sender, TestCompletedEventArgs args)
		{
			if (currentProgress != null)
			{
				// Test is 'failed' if any meter failed

				/// TODO: Reimplement
				//foreach (var meterTestResult in args.TestResult.Meters)
				//{
				//    if (!meterTestResult.Passed)
				//    {
				//        currentProgress.TestResult = UiControls.TestProgressCtrl.Result.Failed;
				//        return;
				//    }
				//}
				currentProgress.TestResult = TestProgressCtrl.Result.Failed;
			}
		}

		void OnProcedureCompleted(object sender, ProcedureCompletedEventArgs args)
		{
            ResetProgressBars(args.Procedure);
        }
	}
}