public void onStepLoad(IStep step, Assembly assembly)
		{
			var assemblyInvoke = (ascx_AssemblyInvoke)step.FirstControl;
			assemblyInvoke.loadAssembly(assembly);
			assemblyInvoke.setExecuteMethodOnDoubleClick(true);
			//PublicDI.log.error("type:{0}:", assemblyInvoke.GetType().FullName);
		}

 void ITestStream.Do(DoGrammarStructure structure, IStep step)
 {
     _paragraphResults.ForExceptionText(text =>
     {
         _document.Add(new ExceptionTag(text));
     });
 }

 public ProgressDialog(string title,IStep step)
     : base(Font.MediumFont, title)
 {
     this.step = step;
     progressLine = 1;
     CreateProcessThread ();
 }

 public void ReadExpected(ITestContext context, IStep step, SetRow row)
 {
     Cell.ReadArgument(context, step, x =>
     {
         row.Values[Cell.Key] = x;
     });
 }

        protected override void execute(IWebElement element, IDictionary<string, object> cellValues, IStep step, ITestContext context)
        {
            assertCondition(element.Enabled, DisabledElementMessage);
            assertCondition(element.Displayed, HiddenElementMessage);

            element.Click();
        }

        protected override void execute(IWebElement element, IDictionary<string, object> cellValues, IStep step, ITestContext context)
        {
            // TODO -- StoryTeller needs to pull this all inside the Cell
            if (!cellValues.ContainsKey(_cell.Key))
            {
                // already caught as a syntax error
                return;
            }

            var handler = ElementHandlers.FindHandler(element);
            var expectedValue = cellValues[_cell.Key];

            var matchingHandler = handler as IMatchingHandler ?? new BasicMatchingHandler(handler, context);

            if (matchingHandler.MatchesData(element, expectedValue))
            {
                context.IncrementRights();
            }
            else
            {
                context.ResultsFor(step).MarkFailure(_cell.Key);
                context.IncrementWrongs();
            }

            context.ResultsFor(step).SetActual(_cell.Key, handler.GetData(CurrentContext, element));
        }

 public SentenceTag(Sentence sentence, IStep step)
     : base("div")
 {
     _sentence = sentence;
     _step = step;
     this.AddSafeClassName(sentence.Name);
     AddClass("sentence");
 }

        public void Execute(IStep containerStep, ITestContext context)
        {
            context.PerformAction(containerStep, _before);

            containerStep.LeafFor(_leafName).AllSteps().Each(step => { context.RunStep(InnerGrammar, step); });

            context.PerformAction(containerStep, _after);
        }

        private void SetStep(IStep step)
        {
            TopMost = step.TopMost;
            _steps.Push(step);
            step.Initialize(_state);

            SetUI(step);
        }

 public void AddStepBefore(Type target, IStep step)
 {
     for (int i = 0; i < _steps.Count; i++) {
         if (_steps [i].GetType () == target) {
             _steps.Insert (i, step);
             return;
         }
     }
 }

        public void Parse(string template, IStep step, IEnumerable<Cell> cells)
        {
            MatchCollection matches = Regex.Matches(template, @"\{(\w+)\}");

            List<string> keys = getKeys(matches);
            validate(template, cells, keys);

            parse(template, matches, cells, step);
        }

        public void step2_loadFiles(IStep step)
        {
        	O2Thread.mtaThread(
        		() => 	{				        	
				        	var testFiles = Files.getFilesFromDir_returnFullPath(PublicDI.config.O2TempDir,"*.cs", true);
				        	var searchTargets = (ascx_SearchTargets)step.Controller.steps[2].FirstControl;
				        	searchTargets.loadFiles(testFiles);
				        });
        }

 public void InvokefMethod(IStep step, string clause)
 {
     "Given a string"
         .Given(() => clause = "Given foo");
     "When the do extension method is invoked"
         .When(() => step = clause.f(() => { }));
     "Then a step is returned"
         .Then(() => step.Should().NotBeNull());
 }

        public CellTag(Cell cell, IStep step)
            : base("span")
        {
            if (step == null) throw new ArgumentNullException("step");

            _cell = cell;
            _step = step;

            AddClass(HtmlClasses.INPUT);
        }

		public void AddStepBefore (Type target, IStep step)
		{
			for (int i = 0; i < _steps.Count; i++) {
				if (target.IsInstanceOfType (_steps [i])) {
					_steps.Insert (i, step);
					return;
				}
			}
			string msg = String.Format ("Step {0} could not be inserted before (not found) {1}", step, target);
			throw new InvalidOperationException (msg);
		}

        public Continuation Invoke(IStep step, StepContext stepContext)
        {
            if (step == null) throw new ArgumentNullException("step");
              if (stepContext == null) throw new ArgumentNullException("stepContext");

              var handler = _locator.GetStepHandler(step.GetType());

              if (handler == null) throw new ArgumentException("No handler for Step: " + step.GetType(), "step");

              return handler.Handle(step, stepContext);
        }

        public override void Execute(IStep containerStep, ITestContext context)
        {
            _callback = value =>
            {
                var returnCell = GetCells().Where(x => x.IsResult).FirstOrDefault();

                if (returnCell != null) returnCell.RecordActual(value, containerStep, context);
            };

            _method.Call(_target, containerStep, context, _callback);
        }

        protected override void execute(IWebElement element, IDictionary<string, object> cellValues, IStep step, ITestContext context)
        {
            assertCondition(element.Enabled, DisabledElementMessage);

            // TODO -- start a convenience class for extensions on IWebElement
            bool isShown = element.Displayed || element.IsHiddenInput();

            assertCondition(isShown, HiddenElementMessage);

            var data = cellValues[Config.CellName];
            ElementHandlers.FindHandler(element).EnterData(CurrentContext, element, data);
        }

 public void AddStepAfter(IStep target, IStep step)
 {
     for (int i = 0; i < _steps.Count; i++) {
         if (_steps [i] == target) {
             if (i == _steps.Count - 1)
                 _steps.Add (step);
             else
                 _steps.Insert (i + 1, step);
             return;
         }
     }
 }

		public void confirmBackupAction(IStep step)
		{			
			O2Thread.mtaThread(
			()=> {
				step.set_Text("");				
				var sourceDirectory = step.getPathFromStep(0);
				var targetDirectory = step.getPathFromStep(1);
				var targetFile = calculateTargetFileName(sourceDirectory, targetDirectory);
				step.append_Text("You are about to create a backup of the folder: {1}{1}\t{0} {1}{1} ", sourceDirectory, Environment.NewLine);
                step.append_Text("into the file: {1}{1}\t{0}{1}{1}", targetFile, Environment.NewLine);
                step.append_Text("Do you want to processed");
			});
		}