public static Point GetElementLocation(IWebElement element)
        {
            Point location = GetElementOrigin(element);
            Size size = GetElementSize(element);

            return new Point(location.X + size.Width / 2, location.Y + size.Height / 2);
        }

        public static IWebElement UntilVisible(IWebElement element, TimeSpan timeOut)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();

            while (true)
            {
                WebDriverException lastException = null;
                try
                {
                    if (element.Displayed)
                    {
                        return element;
                    }
                    System.Threading.Thread.Sleep(100);
                }
                catch (ElementNotVisibleException e)     { lastException = e; }
                catch (NoSuchElementException e)         { lastException = e; }
                catch (StaleElementReferenceException e) { lastException = e; }

                if (sw.Elapsed > timeOut)
                {
                    string exceptionMessage = lastException == null ? "" : lastException.Message;
                    string errorMessage = string.Format("Wait.UntilVisible: Element was not displayed after {0} Milliseconds" +
                                                        "\r\n Error Message:\r\n{1}", timeOut.TotalMilliseconds, exceptionMessage);
                    throw new TimeoutException(errorMessage);
                }
            }
        }

        private void generateSequence(
            TranscriptCmdletBase cmdlet,
            System.Collections.Generic.List<IRecordedCodeSequence> recordingsCollection,
            IRecordedCodeSequence codeSequence,
            IWebElement firstElement,
            IWebElement secondElement)
        {
            Recorder.RecordingCollection = recordingsCollection;

            codeSequence = 
                Recorder.RecordCodeSequence(
                    cmdlet,
                    Recorder.RecordingCollection,
                    firstElement,
                    codeSequence);

            if (null != secondElement) {
                codeSequence = 
                    Recorder.RecordCodeSequence(
                        cmdlet,
                        Recorder.RecordingCollection,
                        secondElement,
                        codeSequence);
            }
            
            Recorder.StoreCodeSequenceInCollection(
                cmdlet,
                Recorder.RecordingCollection,
                codeSequence);
        }

        public void EnterData(ISearchContext context, IWebElement element, object data)
        {
            var options = findOptions(element);
            foreach (var option in options)
            {
                if (option.Text == data.ToString())
                {
                    option.Click();
                    return;
                }
            }

            foreach (var option in options)
            {
                if (option.GetAttribute("value") == data.ToString())
                {
                    option.Click();
                    return;
                }
            }

            var message = "Cannot find the desired option\nThe available options are\nDisplay/Key\n";
            foreach (var option in options)
            {
                message += "\n" + "{0}/{1}".ToFormat(option.Text, option.GetAttribute("value"));
            }

            StoryTellerAssert.Fail(message);
        }

 protected BaseEmailEngager(Context context, IWebElement listItem) : base(context)
 {
     ListItem = listItem;
     DomainName = GetDomainName(listItem);
     CurrentDomain = context.GetDomain(DomainName);
     context.CurrentDomain = CurrentDomain;
 }

 /// <summary>
 /// Like decorator
 /// </summary>
 /// <param name="realWebElement"></param>
 public FakeWebElement(IWebElement realWebElement)
 //public WebElementDecorator(RemoteWebElement realWebElement) // : base(realWebElement.WrappedDriver, "")
 {
     this.DecoratedWebElement = realWebElement as FakeWebElement;
     this.SearchHistory =
         new List<ISearchHistory>();
 }

 protected override void Execute(IWebDriver driver, dynamic context, IWebElement element)
 {
     if (IsFalseExpected)
         Assert.False(element.Enabled);
     else
         Assert.True(element.Enabled);
 }

 protected override void Execute(IWebDriver driver, IWebElement element, CommandDesc command)
 {
     if (element.Selected)
     {
         element.Click();
     }
 }

 public int ColumnCount(IWebElement element)
 {
     IList<IWebElement> tableRows = element.FindElements(By.CssSelector("tr"));
     IWebElement headerRow = tableRows[0];
     IList<IWebElement> tableCols = headerRow.FindElements(By.CssSelector("td"));
     return tableCols.Count();
 }

        public ComponentScopeLocateResult Find(IWebElement scope, ComponentScopeLocateOptions options, SearchOptions searchOptions)
        {
            string labelXPath = new ComponentScopeXPathBuilder(options).
                WrapWithIndex(x => x.Descendant._("label")[y => y.TermsConditionOfContent]);

            IWebElement label = scope.Get(By.XPath(labelXPath).With(searchOptions).Label(options.GetTermsAsString()));

            if (label == null)
            {
                if (searchOptions.IsSafely)
                    return new MissingComponentScopeLocateResult();
                else
                    throw ExceptionFactory.CreateForNoSuchElement(options.GetTermsAsString(), searchContext: scope);
            }

            string elementId = label.GetAttribute("for");
            if (string.IsNullOrEmpty(elementId))
            {
                return new SequalComponentScopeLocateResult(label, new FindFirstDescendantStrategy());
            }
            else
            {
                ComponentScopeLocateOptions idOptions = options.Clone();
                idOptions.Terms = new[] { elementId };
                idOptions.Index = null;
                idOptions.Match = TermMatch.Equals;

                return new SequalComponentScopeLocateResult(scope, new FindByIdStrategy(), idOptions);
            }
        }

 public void WaitForAutocomplete(IWebElement el)
 {
     new WebDriverWait(driver, TimeSpan.FromSeconds(explTimeout)).Until<Boolean>(drv =>
     {
         return (el.Displayed && el.FindElements(By.CssSelector("li")).Count > 0);
     });
 }

 public static void AssertElementsPresent(IWebElement[] elements, string elementDescription)
 {
     if (elements.Length == 0)
     {
         throw new AssertionException(String.Format("AssertElementsPresent Failed: Could not find '{0}'", elementDescription));
     }
 }

 public static void AssertElementPresent(IWebElement element, string elementDescription)
 {
     if (!IsElementPresent(element))
     {
         throw new AssertionException(String.Format("AssertElementPresent Failed: Could not find '{0}'", elementDescription));
     }
 }

        private static IEnumerable<Row> GetTableBody(IWebElement tableElement)
        {
            var bodyElement = tableElement.FindElement(By.TagName("tbody"));
            var bodyRows = bodyElement.FindElements(By.TagName("tr"));

            var rows = new List<Row>();

            for (int rowIndex = 0; rowIndex < bodyRows.Count; rowIndex++)
            {
                var bodyRow = bodyRows[rowIndex];
                var cells = bodyRow.FindElements(By.TagName("td"));

                var row = new Row { Index = rowIndex };

                for (int columnIndex = 0; columnIndex < cells.Count; columnIndex++)
                {
                    var cell = cells[columnIndex];
                    row.Cells.Add(new Cell { ColumnId = columnIndex, Value = cell.Text, WebElement = cell });
                }

                rows.Add(row);
            }

            return rows;
        }

 public static void Check(IWebElement checkbox)
 {
     if (!IsChecked(checkbox))
     {
         checkbox.Click();
     }
 }

        protected override void Execute(IWebDriver driver, dynamic context, IWebElement element)
        {
            var resolvedText = Test.ResolveMacros(Text);
            var resolvedValue = Test.ResolveMacros(Value);

            var isValue = String.IsNullOrWhiteSpace(resolvedText);

            var stringComparison = IsCaseSensitive
                ? StringComparison.InvariantCulture
                : StringComparison.InvariantCultureIgnoreCase;

            var option = isValue
                ? element.GetOptionByValue(resolvedValue, stringComparison)
                : element.GetOptionByText(resolvedText, stringComparison);

            if (option == null)
            {
                var key = isValue ? "Value" : "Text";
                var value = isValue ? resolvedValue : resolvedText;
                var message = String.Format("Unable to locate option by {0}: {1}", key, value);
                throw new Exception(message);
            }

            var isSelected = option.IsSelected();

            if (IsFalseExpected)
                Assert.False(isSelected);
            else
                Assert.True(isSelected);
        }

 public static void OpenInNewTab(IWebElement item)
 {
     var url = item.FindElement(By.TagName("a"));
     url.SendKeys(Keys.Control + Keys.Return);
     url.SendKeys(Keys.Control + Keys.Tab);
     Cons.driver.SwitchTo().Window(Cons.driver.WindowHandles[Cons.driver.WindowHandles.Count - 1]);
 }

 public static Point GetElementPositionWithinUsableViewport(this IWebDriver driver, IWebElement element)
 {
     var elementRect = new Rectangle(element.Location.X, element.Location.Y, element.Size.Width, element.Size.Height);
     var scrollY = elementRect.Top;
     var scrollX = elementRect.Left;
     return new Point(scrollX, scrollY);
 }

        private void HandleElement(IWebElement el, IWebDriver browser, string[] parameters)
        {
            el.Clear();
            var keystroke = KeywordUtility.ReadParameterValue(_variables, parameters[2]);

            el.SendKeys(keystroke);
        }

		public LikeButton(IWebElement like)
		{
			if (like == null)
				throw new NotFoundException("like button not found");
			this.like = like;
			isLiked = UlearnDriver.HasCss(like, "btn-primary");
		}