public void Initialize(string cssSelector, string markerClass)
{
_cssSelector = cssSelector;
_markerClass = markerClass;
ActualConstraint = new MarkerConstraint(markerClass);
}
/// <summary>
/// Gets previously saved constraint-specific data from the context.
/// </summary>
/// <param name="constraint">The constraint that wishes to retrieve its state</param>
/// <returns>The saved data, or null if none saved</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="constraint"/> is null</exception>
public object GetData(Constraint constraint)
{
object value;
if (data != null && data.TryGetValue(constraint, out value))
return value;
return null;
}
/// <summary>
/// Creates a new NOT constraint.
/// </summary>
/// <param name="inner">The inner constraint</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="inner"/> is null</exception>
public NotConstraint(Constraint inner)
{
if (inner == null)
throw new ArgumentNullException("inner");
this.inner = inner;
}
/// <summary>
/// Creates a new finder filtered by an additional constraint.
/// </summary>
/// <param name="constraint">The additional constraint</param>
/// <returns>The filtered element finder</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="constraint"/> is null</exception>
public ElementFinder Filter(Constraint constraint)
{
if (constraint == null)
throw new ArgumentNullException("constraint");
return FilterImpl(constraint);
}
public IE TryFindIe(Constraint findBy, SimpleTimer timer)
{
var action = new TryFuncUntilTimeOut(timer)
{
SleepTime = TimeSpan.FromMilliseconds(500)
};
return action.Try(() => FindIEPartiallyInitialized(findBy));
}
/// <summary>
/// Creates a new OR constraint.
/// </summary>
/// <param name="first">The first constraint</param>
/// <param name="second">The second constraint</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="first"/> or <paramref name="second"/> is null</exception>
public OrConstraint(Constraint first, Constraint second)
{
if (first == null)
throw new ArgumentNullException("first");
if (second == null)
throw new ArgumentNullException("second");
this.first = first;
this.second = second;
}
/// <summary>
/// Creates an element finder.
/// </summary>
/// <param name="domContainer">The DOM container</param>
/// <param name="factory">The factory to get the element(s) to search in</param>
/// <param name="elementTags">The element tags considered by the finder, or null if all tags considered</param>
/// <param name="constraint">The constraint used by the finder to filter elements, or null if no additional constraint</param>
public NativeElementFinder(NativeElementCollectionFactory factory, DomContainer domContainer, IList<ElementTag> elementTags, Constraint constraint)
: base(elementTags, constraint)
{
if (factory == null)
throw new ArgumentNullException("factory");
if (domContainer == null)
throw new ArgumentNullException("domContainer");
this.factory = factory;
this.domContainer = domContainer;
}
/// <summary>
/// Gets the id hint. Only returns an Id if <paramref name="constraint"/> is an <see cref="AttributeConstraint"/> on an exact Id or
/// if the <paramref name="constraint"/> is an <see cref="AndConstraint"/> with an <see cref="AttributeConstraint"/> on an exact Id
/// and an <see cref="AnyConstraint"/>.
/// </summary>
/// <param name="constraint">The constraint to get the id Hint from.</param>
/// <returns></returns>
public static string GetIdHint(Constraint constraint)
{
var andConstraint = constraint as AndConstraint;
if (andConstraint != null)
{
var left = new IdHinter(andConstraint.First);
var right = new IdHinter(andConstraint.Second);
return left.GetIdHint(right);
}
return new IdHinter(constraint).GetIdHint();
}
public IE FindIEPartiallyInitialized(Constraint findBy)
{
var allBrowsers = new ShellWindows2();
var context = new ConstraintContext();
foreach (IWebBrowser2 browser in allBrowsers)
{
var ie = CreateBrowserInstance(new IEBrowser(browser));
if (ie.Matches(findBy, context))
return ie;
}
return null;
}
/// <summary>
/// Saves constraint-specific data in the context.
/// </summary>
/// <param name="constraint">The constraint that wishes to store its state</param>
/// <param name="value">The value to be stored, or null if none</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="constraint"/> is null</exception>
public void SetData(Constraint constraint, object value)
{
if (value == null)
{
if (data != null)
data.Remove(constraint);
}
else
{
if (data == null)
data = new Dictionary<Constraint, object>();
data[constraint] = value;
}
}
public Browser Find(Constraint findBy, int timeout, bool waitForComplete)
{
Logger.LogAction((LogFunction log) => { log("Busy finding Internet Explorer matching constraint {0}", findBy); });
var timer = new SimpleTimer(TimeSpan.FromSeconds(timeout));
var ie = TryFindIe(findBy, timer);
if (ie != null)
{
return FinishInitializationAndWaitForComplete(ie, timer, waitForComplete);
}
throw new BrowserNotFoundException("IE", findBy.ToString(), timeout);
}
private static void SelectByTextOrValueMultiple(this SelectList selectList, Constraint constraint)
{
// This is copied from SelectList.SelectMultiple
var options = selectList.Options.Filter(constraint);
if (options.Count == 0)
throw new SelectListItemNotFoundException(constraint.ToString(), selectList);
foreach (var option in options)
{
if (option.Selected) continue;
option.SetAttributeValue("selected", "true");
}
selectList.FireEvent("onchange");
}
public Browser Find(Constraint findBy, int timeout, bool waitForComplete)
{
Logger.LogAction("Busy finding FireFox matching constraint {0}", findBy);
var action = new TryFuncUntilTimeOut(TimeSpan.FromSeconds(timeout)) { SleepTime = TimeSpan.FromMilliseconds(500) };
var fireFox = action.Try(() => FindFireFox(findBy));
if (fireFox != null)
{
if (waitForComplete) fireFox.WaitForComplete();
return fireFox;
}
throw new BrowserNotFoundException("FireFox", findBy.ToString(), timeout);
}
public WatiNWindow (Constraint windowHandle)
{
this.windowHandle = windowHandle;
try
{
if (!WatiN.Core.Browser.Exists<IE>(windowHandle))
throw new MissingWindowException("No such window found: " + windowHandle);
browser = WatiN.Core.Browser.AttachTo<IE>(windowHandle);
}
catch (WatiN.Core.Exceptions.BrowserNotFoundException)
{
throw new MissingWindowException("No such window found: " + windowHandle);
}
}
public FireFox FindFireFox(Constraint findBy)
{
var clientPort = FireFox.GetClientPort();
clientPort.ConnectToExisting();
var ffBrowser = new FFBrowser(clientPort);
var windowCount = ffBrowser.WindowCount;
for (var i = 0; i < windowCount; i++)
{
((FireFoxClientPort)ffBrowser.ClientPort).DefineDefaultJSVariablesForWindow(i);
ffBrowser.ClientPort.InitializeDocument();
var firefox = CreateBrowserInstance(ffBrowser);
if (firefox.Matches(findBy))
return firefox;
}
clientPort.CloseConnection();
return null;
}
private HtmlDialog FindHtmlDialog(Constraint findBy, int timeout)
{
Logger.LogAction("Busy finding HTMLDialog matching criteria: {0}", findBy);
var action = new TryFuncUntilTimeOut(TimeSpan.FromSeconds(timeout))
{
SleepTime = TimeSpan.FromMilliseconds(500)
};
var result = action.Try(() => HtmlDialogs.First(findBy));
if (result == null)
{
throw new HtmlDialogNotFoundException(findBy.ToString(), timeout);
}
return result;
}
/// <summary>
/// Find a HtmlDialog by an attribute within the given <paramref name="timeout" /> period.
/// Currently Find.ByUrl and Find.ByTitle are supported.
/// </summary>
/// <param name="findBy">The url of the html page shown in the dialog</param>
/// <param name="timeout">Number of seconds before the search times out.</param>
public HtmlDialog HtmlDialog(Constraint findBy, int timeout)
{
return FindHtmlDialog(findBy, timeout);
}
/// <summary>
/// Find a HtmlDialog by an attribute. Currently
/// Find.ByUrl and Find.ByTitle are supported.
/// </summary>
/// <param name="findBy">The url of the html page shown in the dialog</param>
public HtmlDialog HtmlDialog(Constraint findBy)
{
return FindHtmlDialog(findBy, Settings.AttachToBrowserTimeOut);
}
private IdHinter(Constraint constraint)
{
_constraint = constraint ?? Find.Any;
AsAttributeConstraint = constraint as AttributeConstraint;
}
/// <summary>
/// If the constraint can only match on element with a particular id, returns the id,
/// otherwise returns null.
/// </summary>
/// <returns>The id or null if the constraint could match elements with no particular id</returns>
protected virtual string GetElementIdHint(Constraint constraint)
{
return IdHinter.GetIdHint(constraint);
}
protected override ElementFinder FilterImpl(Constraint findBy)
{
throw new NotImplementedException("Didn't expect filtering on static element");
}
/// <inheritdoc />
protected override ElementFinder FilterImpl(Constraint findBy)
{
return new NativeElementFinder(factory, domContainer, ElementTags, Constraint & findBy);
}
/// <summary>
/// Creates an element finder.
/// </summary>
/// <param name="elementTags">The element tags considered by the finder, or null if all tags considered</param>
/// <param name="findBy">The constraint used by the finder to filter elements, or null if no additional constraint</param>
public ElementFinder(IList<ElementTag> elementTags, Constraint findBy)
{
this.elementTags = new ReadOnlyCollection<ElementTag>(elementTags ?? new[] { ElementTag.Any });
this.findBy = findBy ?? Find.Any;
}
/// <summary> /// Creates a new finder filtered by an additional constraint. /// </summary> /// <param name="findBy">The additional constraint, not null</param> /// <returns>The filtered element finder</returns> public abstract ElementFinder FilterImpl(Constraint findBy);
public static Chrome AttachToChrome(Constraint findBy)
{
throw new System.NotImplementedException();
}
public bool Exists(Constraint constraint)
{
return null != FindIEPartiallyInitialized(constraint);
}
public ReEntryException(Constraint constraint) : base(CreateMessage(constraint)) {}
/// <summary>
/// Combines this constraint with another one to produce a new constraint that is satisfied only when
/// either (or both) constraint is satisfied.
/// </summary>
/// <remarks>
/// <para>
/// The operation is short-circuiting: if the first constraint is satisfied for
/// a given value then the second constraint is not evaluated.
/// </para>
/// </remarks>
/// <param name="constraint">The other constraint</param>
/// <returns>The combined constraint</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="constraint"/> is null</exception>
/// <seealso cref="And"/>
public Constraint Or(Constraint constraint)
{
if (constraint == null)
throw new ArgumentNullException("constraint");
return new OrConstraint(this, constraint);
}
private static string CreateMessage(Constraint constraint)
{
return string.Format(Resources.ReEntryException_MessageFormat, constraint.GetType(), constraint);
}
private static void Combine(ref Constraint constraint, Constraint otherConstraint)
{
if (otherConstraint != null)
{
constraint = constraint != null ? constraint & otherConstraint : otherConstraint;
}
}
