Waits until element is cickable.

@param elementLocator
identifier of element to be cickable
775995
public static void waitUntilElementIsClickable(final String elementLocator) {
        logger.entering(elementLocator);
        By by = HtmlElementUtils.resolveByType(elementLocator);
        ExpectedCondition<WebElement> condition = ExpectedConditions.elementToBeClickable(by);
        waitForCondition(condition);
        logger.exiting();
    }
594772
public static void assertElementIsNotDisplayed(By locator, WebDriver driver) {
		try {
			waitUntil(ExpectedConditions.visibilityOfElementLocated(locator), driver);
			throw new AssertionError("[assert KO] element " + locator + " is displayed; expected: NOT displayed");
		} catch(TimeoutException e) {
			logger.info("[assert OK] element " + locator + " is NOT displayed as expected");
		}
	}
793980
public void waitForNotVisible(final long time) throws WidgetException {
		try {
			waitForCommand(new ITimerCallback() {

				@Override
				public boolean execute() throws WidgetException {
					return !isVisible();
				}

				@Override
				public String toString() {
					return "Waiting for element with locator: " + locator + " to not be visible";
				}
			}, time);
		} catch (Exception e) {
			throw new WidgetException("Error while waiting for element to be not visible", locator, e);
		}
	}
876716
public void waitForElementPresent(final By by, final int maximumSeconds) {
		WebDriverWait wait = new WebDriverWait(driver, maximumSeconds);
		wait.until(ExpectedConditions.presenceOfElementLocated((by)));
	}
519185
@Override
    public void processElement(Wrapper<Element> elementWrapper) {
        Element element = elementWrapper.getContent();
        element.setAttributes(getSortedAttributes(element));
    }
909683
def wait_for_element(element_id, timeout = $testwise_polling_timeout, interval = $testwise_polling_interval)
      start_time = Time.now
      #TODO might not work with Firefox
      until @web_browser.element_by_id(element_id) do
        sleep(interval)
        if (Time.now - start_time) > timeout
          raise RuntimeError, "failed to find element: #{element_id} for max #{timeout}"
        end
      end
    end
1148642
public boolean getElementExists(By locator) {
		waitForLoaders();
		List<WebElement> foundElements = getWebDriver().findElements(locator);
		return (foundElements.size() > 0);
	}
1188205
def wait_until_visible(self, timeout=None):
        
        try:
            self.utils.wait_until_element_visible(self, timeout)
        except TimeoutException as exception:
            parent_msg = " and parent locator '{}'".format(self.parent) if self.parent else ''
            msg = "Page element of type '%s' with locator %s%s not found or is not visible after %s seconds"
            timeout = timeout if timeout else self.utils.get_explicitly_wait()
            self.logger.error(msg, type(self).__name__, self.locator, parent_msg, timeout)
            exception.msg += "\n  {}".format(msg % (type(self).__name__, self.locator, parent_msg, timeout))
            raise exception
        return self
978695
public static boolean isElementPresent(String locator) {
        logger.entering(locator);
        boolean flag = false;
        try {
            flag = HtmlElementUtils.locateElement(locator) != null;
        } catch (NoSuchElementException e) { // NOSONAR
        }
        logger.exiting(flag);
        return flag;
    }
1139410
def wait_until_stale(self, timeout=None):
        
        timeout = timeout if timeout is not None else self.driver_wrapper.timeout

        def wait():
            """
            Wrapper to wait for element to be stale
            """
            WebDriverWait(self.driver, timeout).until(EC.staleness_of(self.element))
            return self

        return self.execute_and_handle_webelement_exceptions(wait, 'wait for staleness')
714606
public void setDocumentLocator(Locator locator)
  {

    if (DEBUG)
      System.out.println("TransformerHandlerImpl#setDocumentLocator: "
                         + locator.getSystemId());

    this.m_locator = locator;
    
    if(null == m_baseSystemID)
    {
      setSystemId(locator.getSystemId());
    }

    if (m_contentHandler != null)
    {
      m_contentHandler.setDocumentLocator(locator);
    }
  }
325362
@Override
	public WebElement findElement(final By by) {
		return new StaleExceptionResolver<WebElement>() {

			@Override
			public WebElementAdapter execute(WebElement element) {
				return new WebElementAdapter(element.findElement(by),thisObject,by);
			}
		}.waitForElement();
	}
103500
@Override
	public void go() {
		logger.info("Waiting {} seconds for {}...", timeout, element);
		WebDriverWait waiting = new WebDriverWait(getWebDriver(), timeout);
		try {
			waiting.until(ExpectedConditions.presenceOfElementLocated(element));
		} catch (NullPointerException e) {
			fail(String.format("Element %s did not appear within %d seconds.", element, timeout), e);
		}
	}
322538
public function checkField($locator)
    {
        $field = $this->findField($locator);

        if (null === $field) {
            throw new ElementNotFoundException($this->getDriver(), 'form field', 'id|name|label|value', $locator);
        }

        $field->check();
    }
21489
public static void waitUntilAllElementsArePresent(final String... locators) {
        logger.entering(new Object[] { Arrays.toString(locators) });
        Preconditions.checkArgument(locators != null, "Please provide a valid set of locators.");
        for (String eachLocator : locators) {
            waitUntilElementIsPresent(eachLocator);
        }
        logger.exiting();
    }
147251
def wait_for_text(self, locator, text):
        
        for i in range(timeout_seconds):
            try:
                e = self.driver.find_element_by_locator(locator)
                if e.text == text:
                    break
            except:
                pass
            time.sleep(1)
        else:
            raise ElementTextTimeout("%s value timed out" % locator)
        return True
18804
def wait_for_available(self, locator):
        
        for i in range(timeout_seconds):
            try:
                if self.is_element_available(locator):
                    break
            except:
                pass
            time.sleep(1)
        else:
            raise ElementVisiblityTimeout("%s availability timed out" % locator)
        return True