### Manage Popup Window with JavaScript

Source: https://github.com/dev4s/watin/blob/master/source/UnitTests/html/main.html

Provides functions to get and manage a popup window reference. Ensure the popup window is initialized before calling GetPopupWindow.

```javascript
var popupWindow;
function GetPopupWindow() { return popupWindow; }
```

--------------------------------

### Instantiate and Navigate Browsers

Source: https://context7.com/dev4s/watin/llms.txt

Demonstrates creating browser instances, navigating URLs, and handling authentication dialogs.

```csharp
using WatiN.Core;

// Create a new Internet Explorer instance and navigate to a URL
using (IE browser = new IE("http://www.example.com"))
{
    // Browser is ready with page loaded
    Console.WriteLine("Page title: " + browser.Title);
    Console.WriteLine("Current URL: " + browser.Url);

    // Navigate to another page
    browser.GoTo("http://www.google.com");

    // Navigate back and forward
    browser.Back();
    browser.Forward();

    // Refresh the page
    browser.Refresh();

    // Browser automatically closes when disposed
}

// Create browser in new process (isolated session)
using (IE ie = new IE("http://www.example.com", createInNewProcess: true))
{
    // Operations in isolated process
}

// Create browser with authentication
var logonHandler = new LogonDialogHandler("domain\\username", "password");
using (IE ie = new IE("https://secure.example.com", logonHandler))
{
    // Authenticated session
}
```

--------------------------------

### Configure WatiN Settings

Source: https://context7.com/dev4s/watin/llms.txt

Adjust global timeouts, highlighting, dialog handling, and browser behavior. Use Settings.Clone() or temporary instance swapping for scoped configuration changes.

```csharp
using WatiN.Core;

// Configure timeout settings
Settings.AttachToBrowserTimeOut = 60;  // Attach timeout in seconds
Settings.WaitUntilExistsTimeOut = 30;  // Element wait timeout
Settings.WaitForCompleteTimeOut = 30;  // Page load timeout

// Configure element highlighting
Settings.HighLightElement = true;
Settings.HighLightColor = "yellow";

// Configure dialog handling
Settings.AutoCloseDialogs = true;
Settings.AutoStartDialogWatcher = true;

// Configure browser behavior
Settings.MakeNewIeInstanceVisible = true;
Settings.MakeNewIe8InstanceNoMerge = true;
Settings.AutoMoveMousePointerToTopLeft = false;

// Configure Firefox settings
Settings.CloseExistingFireFoxInstances = false;

// Reset to defaults
Settings.Reset();

// Clone current settings
ISettings backup = Settings.Clone();

// Use custom settings temporarily
ISettings originalSettings = Settings.Instance;
try
{
    Settings.WaitUntilExistsTimeOut = 5;  // Quick timeout
    // Perform operations with short timeout
}
finally
{
    Settings.Instance = originalSettings;
}
```

--------------------------------

### Interact with Buttons and Links

Source: https://context7.com/dev4s/watin/llms.txt

Demonstrates clicking elements, handling navigation, and checking element states. Use ClickNoWait for scenarios where the action does not trigger a full page reload.

```csharp
using WatiN.Core;

using (IE browser = new IE("http://www.example.com"))
{
    // Find and click a button
    Button submitButton = browser.Button(Find.ById("submit"));
    submitButton.Click();

    // Click button by value text
    Button loginButton = browser.Button(Find.ByValue("Login"));
    loginButton.Click();

    // Click without waiting for page load (useful for popups/dialogs)
    Button popupButton = browser.Button(Find.ById("showPopup"));
    popupButton.ClickNoWait();

    // Find and click a link
    Link homeLink = browser.Link(Find.ByText("Home"));
    homeLink.Click();

    // Get link URL before clicking
    Link aboutLink = browser.Link(Find.ByText("About"));
    string url = aboutLink.Url;
    Console.WriteLine("Link URL: " + url);
    aboutLink.Click();

    // Double-click an element
    Div item = browser.Div(Find.ById("selectable-item"));
    item.DoubleClick();

    // Check if element is enabled before clicking
    Button saveButton = browser.Button(Find.ById("save"));
    if (saveButton.Enabled)
    {
        saveButton.Click();
    }
}
```

--------------------------------

### Manage Browser Instances and State

Source: https://context7.com/dev4s/watin/llms.txt

Attach to existing browser windows, control window properties, and manage cookies or cache.

```csharp
using WatiN.Core;

// Attach to existing IE window by title
IE browser = Browser.AttachTo<IE>(Find.ByTitle("My Application"));

// Attach by URL
IE browserByUrl = Browser.AttachTo<IE>(Find.ByUrl("http://www.example.com"));

// Attach with timeout
IE browserWithTimeout = Browser.AttachTo<IE>(
    Find.ByTitle("Slow Loading Page"), timeout: 60);

// Check if browser exists
bool exists = Browser.Exists<IE>(Find.ByTitle("My App"));

// Get all open IE instances
IECollection allBrowsers = IE.InternetExplorers();
foreach (IE ie in allBrowsers)
{
    Console.WriteLine(ie.Title + " - " + ie.Url);
}

// Browser window management
using (IE ie = new IE("http://www.example.com"))
{
    // Bring to front
    ie.BringToFront();

    // Resize window
    ie.SizeWindow(1024, 768);

    // Maximize/minimize
    ie.ShowWindow(NativeMethods.WindowShowStyle.Maximize);
    ie.ShowWindow(NativeMethods.WindowShowStyle.Minimize);
    ie.ShowWindow(NativeMethods.WindowShowStyle.Restore);

    // Control visibility
    ie.Visible = true;

    // Control auto-close behavior
    ie.AutoClose = false;  // Keep browser open after disposal

    // Cookie management
    ie.ClearCookies();  // Clear all cookies
    ie.ClearCookies("http://www.example.com");  // Site-specific

    // Get/set cookies
    string cookie = ie.GetCookie("http://www.example.com", "sessionId");
    ie.SetCookie("http://www.example.com", "myCookie=value; path=/");

    // Clear cache
    ie.ClearCache();

    // Force close all IE instances
    ie.ForceClose();
}
```

--------------------------------

### Manage Element Waiting and Existence

Source: https://context7.com/dev4s/watin/llms.txt

Use these methods to handle asynchronous page loading and verify element states. Ensure the browser instance is initialized before performing these operations.

```csharp
using WatiN.Core;
using System.Text.RegularExpressions;

using (IE browser = new IE("http://www.example.com/dynamic"))
{
    // Check if element exists (does not wait)
    Button submitBtn = browser.Button(Find.ById("submit"));
    if (submitBtn.Exists)
    {
        submitBtn.Click();
    }

    // Wait until element exists (default 30 seconds)
    Div results = browser.Div(Find.ById("results"));
    results.WaitUntilExists();

    // Wait with custom timeout (in seconds)
    Div slowContent = browser.Div(Find.ById("slowLoading"));
    slowContent.WaitUntilExists(60);

    // Wait until element is removed from DOM
    Div loadingIndicator = browser.Div(Find.ById("loading"));
    loadingIndicator.WaitUntilRemoved();
    loadingIndicator.WaitUntilRemoved(timeout: 10);

    // Wait until attribute has specific value
    Div status = browser.Div(Find.ById("status"));
    status.WaitUntil("innertext", "Complete");
    status.WaitUntil("className", "success", timeout: 15);

    // Wait until attribute matches regex
    status.WaitUntil("innertext", new Regex("(Complete|Done)"));

    // Wait using constraint
    Button enabledBtn = browser.Button(Find.ById("action"));
    enabledBtn.WaitUntil(Find.By("disabled", "false"));

    // Wait using predicate
    enabledBtn.WaitUntil<Button>(btn => btn.Enabled);

    // Check page contains text
    bool hasText = browser.ContainsText("Welcome");

    // Refresh element reference after DOM changes
    Div dynamicDiv = browser.Div(Find.ById("dynamic"));
    dynamicDiv.Refresh();
}
```

--------------------------------

### Navigate and Extract Data from HTML Tables

Source: https://context7.com/dev4s/watin/llms.txt

Demonstrates finding tables, iterating through rows and cells, and locating specific rows by content or regex. Ensure the target URL is valid and the table has the expected ID.

```csharp
using WatiN.Core;
using System.Text.RegularExpressions;

using (IE browser = new IE("http://www.example.com/data"))
{
    // Find a table
    Table dataTable = browser.Table(Find.ById("users"));

    // Get all rows in the table (including nested tables)
    TableRowCollection allRows = dataTable.TableRows;
    Console.WriteLine("Total rows: " + allRows.Count);

    // Get only rows belonging to this table (not nested)
    TableRowCollection ownRows = dataTable.OwnTableRows;

    // Iterate through rows and cells
    foreach (TableRow row in ownRows)
    {
        foreach (TableCell cell in row.TableCells)
        {
            Console.Write(cell.Text + "\t");
        }
        Console.WriteLine();
    }

    // Find a specific row by cell content
    TableRow userRow = dataTable.FindRow("john@example.com", inColumn: 1);
    if (userRow != null)
    {
        string userName = userRow.TableCells[0].Text;
        Console.WriteLine("Found user: " + userName);
    }

    // Find row using regex
    TableRow patternRow = dataTable.FindRow(new Regex(@"\d{3}-\d{4}"), inColumn: 2);

    // Find row in own table rows only (ignoring nested tables)
    TableRow ownRow = dataTable.FindRowInOwnTableRows("Active", inColumn: 3);

    // Access specific cell
    TableRow firstRow = ownRows[0];
    TableCell emailCell = firstRow.TableCells[1];
    string email = emailCell.Text;

    // Find row by constraint
    TableRow specificRow = dataTable.OwnTableRow(
        Find.ByExistenceOfRelatedElement<TableRow>(
            row => row.OwnTableCell(Find.ByText("Admin"))));

    // Work with table bodies
    TableBodyCollection bodies = dataTable.OwnTableBodies;
    TableBody mainBody = dataTable.OwnTableBody(Find.First());
}
```

--------------------------------

### Manage Element Collections in WatiN

Source: https://context7.com/dev4s/watin/llms.txt

Demonstrates retrieving, filtering, and iterating over various element collections like links, divs, and buttons.

```csharp
using WatiN.Core;
using System.Text.RegularExpressions;

using (IE browser = new IE("http://www.example.com"))
{
    // Get all elements of a type
    LinkCollection allLinks = browser.Links;
    Console.WriteLine("Total links: " + allLinks.Count);

    // Iterate through collection
    foreach (Link link in allLinks)
    {
        Console.WriteLine(link.Text + " -> " + link.Url);
    }

    // Access by index
    Link firstLink = allLinks[0];
    Link lastLink = allLinks[allLinks.Count - 1];

    // Filter collection
    LinkCollection navLinks = browser.Links.Filter(Find.ByClass("nav-link"));
    LinkCollection externalLinks = browser.Links.Filter(
        Find.ByUrl(new Regex("^https?://(?!www\\.example\\.com)")));

    // Get first matching element
    Link firstMatch = browser.Links.First(Find.ByClass("highlight"));

    // Check if any elements match
    bool hasErrors = browser.Divs.Exists(Find.ByClass("error"));

    // Get element collections for various types
    DivCollection divs = browser.Divs;
    SpanCollection spans = browser.Spans;
    TableCollection tables = browser.Tables;
    ButtonCollection buttons = browser.Buttons;
    TextFieldCollection textFields = browser.TextFields;
    CheckBoxCollection checkBoxes = browser.CheckBoxes;
    RadioButtonCollection radioButtons = browser.RadioButtons;
    SelectListCollection selectLists = browser.SelectLists;
    ImageCollection images = browser.Images;

    // Generic element collection
    ElementCollection allElements = browser.Elements;
    ElementCollection specificElements = browser.Elements.Filter(
        Find.ByClass("interactive"));
}
```

--------------------------------

### Demo Page CSS

Source: https://github.com/dev4s/watin/blob/master/examples/Creating a DateTime control/TestProject/WebSite/DatePickerPage.htm

CSS styles for the demo page, including body font, margins, and styles for demo headers and icon lists. This is for presentation purposes.

```css
body{
  font: 62.5% "Trebuchet MS", sans-serif;
  margin: 50px;
}
.demoHeaders {
  margin-top: 2em;
}
#dialog_link {
  padding: .4em 1em .4em 20px;
  text-decoration: none;
  position: relative;
}
#dialog_link span.ui-icon {
  margin: 0 5px 0 0;
  position: absolute;
  left: .2em;
  top: 50%;
  margin-top: -8px;
}
ul#icons {
  margin: 0;
  padding: 0;
}
ul#icons li {
  margin: 2px;
  position: relative;
  padding: 4px 0;
  cursor: pointer;
  float: left;
  list-style: none;
}
ul#icons span.ui-icon {
  float: left;
  margin: 0 4px;
}
```

--------------------------------

### Initialize jQuery UI Widgets

Source: https://github.com/dev4s/watin/blob/master/examples/Creating a DateTime control/TestProject/WebSite/index.html

This script initializes multiple jQuery UI widgets on the page. Ensure jQuery and jQuery UI libraries are included before this script.

```javascript
$(function(){
  // Accordion
  $("#accordion").accordion({ header: "h3" });

  // Tabs
  $('#tabs').tabs();

  // Dialog
  $('#dialog').dialog({
    autoOpen: false,
    width: 600,
    buttons: {
      "Ok": function() {
        $(this).dialog("close");
      },
      "Cancel": function() {
        $(this).dialog("close");
      }
    }
  });

  // Dialog Link
  $('#dialog_link').click(function(){
    $('#dialog').dialog('open');
    return false;
  });

  // Datepicker
  $('#datepicker').datepicker({ inline: true });

  // Slider
  $('#slider').slider({
    range: true,
    values: [17, 67]
  });

  // Progressbar
  $("#progressbar").progressbar({ value: 20 });

  //hover states on the static widgets
  $('#dialog_link, ul#icons li').hover(
    function() {
      $(this).addClass('ui-state-hover');
    },
    function() {
      $(this).removeClass('ui-state-hover');
    }
  );
});
```

--------------------------------

### Progressbar Widget Initialization

Source: https://github.com/dev4s/watin/blob/master/examples/Creating a DateTime control/TestProject/WebSite/index.html

Initializes a progressbar widget with a specified initial value.

```javascript
$("#progressbar").progressbar({ value: 20 });
```

--------------------------------

### Open Modal Dialog with JavaScript

Source: https://github.com/dev4s/watin/blob/master/source/UnitTests/html/main.html

Opens a modal dialog using window.showModalDialog. The second and third arguments are for dialog arguments and window features, respectively.

```javascript
function fnOpen() { window.showModalDialog("popup.html", "", "") }
```

--------------------------------

### Navigate DOM and Access Element Properties

Source: https://context7.com/dev4s/watin/llms.txt

Shows how to traverse the DOM tree to find related elements and retrieve specific element attributes and state information.

```csharp
using WatiN.Core;

using (IE browser = new IE("http://www.example.com"))
{
    TextField input = browser.TextField(Find.ById("email"));

    // Navigate to parent
    Element parent = input.Parent;
    Div parentDiv = (Div)input.Parent;

    // Navigate to siblings
    Element nextSibling = input.NextSibling;
    Element prevSibling = input.PreviousSibling;

    // Find ancestor by type
    Form form = input.Ancestor<Form>();
    Table table = input.Ancestor<Table>();

    // Find ancestor by constraint
    Div container = input.Ancestor<Div>(Find.ByClass("form-group"));

    // Find ancestor by predicate
    Div matchingDiv = input.Ancestor<Div>(div => div.ClassName.Contains("container"));

    // Find ancestor by tag name
    Element tableAncestor = input.Ancestor("table");
    Element divWithClass = input.Ancestor("div", Find.ByClass("wrapper"));

    // Get element properties
    string tagName = input.TagName;
    string outerHtml = input.OuterHtml;
    string innerHtml = input.InnerHtml;
    string text = input.Text;
    string id = input.Id;
    string name = input.Name;
    string className = input.ClassName;
    string title = input.Title;

    // Check element state
    bool exists = input.Exists;
    bool enabled = input.Enabled;
    bool complete = input.Complete;

    // Get style information
    Style style = input.Style;
    string backgroundColor = style.BackgroundColor;
    string display = style.Display;
}
```

--------------------------------

### Perform SelectList Operations

Source: https://context7.com/dev4s/watin/llms.txt

Covers selecting options by text, value, or regex, and managing multi-select lists. Requires System.Text.RegularExpressions for regex-based selection.

```csharp
using WatiN.Core;
using System.Text.RegularExpressions;

using (IE browser = new IE("http://www.example.com/form"))
{
    // Find a select list
    SelectList countryList = browser.SelectList(Find.ById("country"));

    // Select by visible text
    countryList.Select("United States");

    // Select by value attribute
    countryList.SelectByValue("US");

    // Select using regex
    countryList.Select(new Regex("United.*"));

    // Get selected item text
    string selectedCountry = countryList.SelectedItem;
    Console.WriteLine("Selected: " + selectedCountry);

    // Get selected option element
    Option selectedOption = countryList.SelectedOption;
    string optionValue = selectedOption.Value;

    // Get all available options
    StringCollection allOptions = countryList.AllContents;
    foreach (string option in allOptions)
    {
        Console.WriteLine(option);
    }

    // Check if multiple selection is allowed
    bool allowsMultiple = countryList.Multiple;

    // For multi-select lists
    SelectList skillsList = browser.SelectList(Find.ById("skills"));
    if (skillsList.Multiple)
    {
        skillsList.Select("C#");
        skillsList.Select("JavaScript");
        skillsList.Select("SQL");

        // Get all selected items
        StringCollection selectedItems = skillsList.SelectedItems;

        // Clear all selections
        skillsList.ClearList();
    }

    // Work with individual options
    Option firstOption = countryList.Option(Find.First());
    Option usOption = countryList.Option(Find.ByValue("US"));
    bool isSelected = usOption.Selected;
}
```

--------------------------------

### Slider Widget Configuration

Source: https://github.com/dev4s/watin/blob/master/examples/Creating a DateTime control/TestProject/WebSite/index.html

Configures a range slider widget with initial values.

```javascript
$('#slider').slider({
  range: true,
  values: [17, 67]
});
```

--------------------------------

### Manage PopUp Windows and Delays

Source: https://github.com/dev4s/watin/blob/master/source/UnitTests/html/popup.html

Use these functions to trigger modal dialogs and introduce blocking delays during test execution.

```javascript
function fnOpen() { window.showModalDialog("popup.html", "", "") } function closeWindowDelayed() { pause(2000); window.close(); } function pause(millis) { var date = new Date(); var curDate = null; do { curDate = new Date(); } while (curDate - date < millis) }
```

--------------------------------

### Dialog Widget Configuration

Source: https://github.com/dev4s/watin/blob/master/examples/Creating a DateTime control/TestProject/WebSite/index.html

Configures a dialog widget with options for auto-opening, width, and buttons. The buttons object defines actions for 'Ok' and 'Cancel'.

```javascript
$('#dialog').dialog({
  autoOpen: false,
  width: 600,
  buttons: {
    "Ok": function() {
      $(this).dialog("close");
    },
    "Cancel": function() {
      $(this).dialog("close");
    }
  }
});
```

--------------------------------

### Handle Browser Dialogs

Source: https://context7.com/dev4s/watin/llms.txt

Use dialog handlers to automate interactions with alerts, prompts, and authentication windows. Add handlers to the DialogWatcher before triggering the dialog action.

```csharp
using WatiN.Core;
using WatiN.Core.DialogHandlers;

using (IE browser = new IE())
{
    // Handle logon dialog (HTTP authentication)
    var logonHandler = new LogonDialogHandler(@"domain\username", "password");
    browser.DialogWatcher.Add(logonHandler);
    browser.GoTo("https://secure.example.com");

    // Handle alert dialogs
    var alertHandler = new AlertDialogHandler();
    browser.DialogWatcher.Add(alertHandler);
    browser.Button(Find.ById("showAlert")).ClickNoWait();
    alertHandler.WaitUntilExists();
    string alertText = alertHandler.Message;
    alertHandler.OKButton.Click();

    // Handle confirmation dialogs
    var confirmHandler = new ConfirmDialogHandler();
    browser.DialogWatcher.Add(confirmHandler);
    browser.Button(Find.ById("showConfirm")).ClickNoWait();
    confirmHandler.WaitUntilExists();
    confirmHandler.OKButton.Click();  // or CancelButton.Click()

    // Handle prompt dialogs
    var promptHandler = new PromptDialogHandler("my response");
    browser.DialogWatcher.Add(promptHandler);
    browser.Button(Find.ById("showPrompt")).ClickNoWait();
    promptHandler.WaitUntilExists();
    promptHandler.OKButton.Click();

    // Handle file download dialog
    var downloadHandler = new FileDownloadHandler(@"C:\Downloads\file.zip");
    browser.DialogWatcher.Add(downloadHandler);
    browser.Link(Find.ByText("Download")).ClickNoWait();
    downloadHandler.WaitUntilFileDownloadDialogIsHandled(60);

    // Handle certificate warning
    var certHandler = new CertificateWarningHandler();
    browser.DialogWatcher.Add(certHandler);

    // Use dialog handler once
    using (new UseDialogOnce(browser.DialogWatcher, alertHandler))
    {
        browser.Button(Find.ById("trigger")).ClickNoWait();
    }

    // Remove dialog handler
    browser.DialogWatcher.Remove(logonHandler);
}
```

--------------------------------

### Accordion Widget Configuration

Source: https://github.com/dev4s/watin/blob/master/examples/Creating a DateTime control/TestProject/WebSite/index.html

Configures the accordion widget with a specified header selector.

```javascript
$("#accordion").accordion({ header: "h3" });
```

--------------------------------

### Datepicker Widget Initialization

Source: https://github.com/dev4s/watin/blob/master/examples/Creating a DateTime control/TestProject/WebSite/index.html

Initializes the datepicker widget with inline display enabled.

```javascript
$('#datepicker').datepicker({ inline: true });
```

--------------------------------

### Access and Interact with Frames and IFrames

Source: https://context7.com/dev4s/watin/llms.txt

Provides methods to access frames and iframes by name, ID, or index, and interact with elements within them. Nested frames can also be accessed. Ensure the correct frame or iframe is targeted.

```csharp
using WatiN.Core;

using (IE browser = new IE("http://www.example.com/frames"))
{
    // Access frame by name
    Frame mainFrame = browser.Frame(Find.ByName("mainContent"));

    // Access frame by ID
    Frame navFrame = browser.Frame(Find.ById("navigation"));

    // Access frame by index
    Frame firstFrame = browser.Frames[0];

    // Access iframe
    Frame iframeContent = browser.Frame(Find.ById("embedded-content"));

    // Interact with elements inside the frame
    TextField searchBox = mainFrame.TextField(Find.ById("search"));
    searchBox.TypeText("search term");

    Button searchBtn = mainFrame.Button(Find.ByValue("Search"));
    searchBtn.Click();

    // Access nested frames
    Frame outerFrame = browser.Frame(Find.ByName("outer"));
    Frame innerFrame = outerFrame.Frame(Find.ByName("inner"));

    // Get frame properties
    string frameName = mainFrame.Name;
    string frameId = mainFrame.Id;
    string frameUrl = mainFrame.Url;

    // Iterate through all frames
    foreach (Frame frame in browser.Frames)
    {
        Console.WriteLine("Frame: " + frame.Name + " - " + frame.Url);
    }
}
```

--------------------------------

### Manage CheckBox and RadioButton States

Source: https://context7.com/dev4s/watin/llms.txt

Shows how to toggle checkbox states and select radio buttons within groups. Use Find.ByName and Find.ByValue to target specific radio buttons.

```csharp
using WatiN.Core;

using (IE browser = new IE("http://www.example.com/form"))
{
    // Find and check a checkbox
    CheckBox termsCheckbox = browser.CheckBox(Find.ById("acceptTerms"));
    termsCheckbox.Checked = true;

    // Uncheck a checkbox
    CheckBox newsletterCheckbox = browser.CheckBox(Find.ById("newsletter"));
    newsletterCheckbox.Checked = false;

    // Toggle checkbox state
    CheckBox optInCheckbox = browser.CheckBox(Find.ById("optIn"));
    optInCheckbox.Checked = !optInCheckbox.Checked;

    // Check current state
    bool isChecked = termsCheckbox.Checked;
    Console.WriteLine("Terms accepted: " + isChecked);

    // Find checkbox by associated label
    CheckBox rememberMe = browser.CheckBox(Find.ByLabelText("Remember me"));
    rememberMe.Checked = true;

    // Work with radio buttons
    RadioButton maleRadio = browser.RadioButton(Find.ById("male"));
    RadioButton femaleRadio = browser.RadioButton(Find.ById("female"));

    // Select a radio button
    maleRadio.Checked = true;

    // Find radio button by value
    RadioButton optionB = browser.RadioButton(
        Find.ByName("choice") & Find.ByValue("B"));
    optionB.Checked = true;

    // Check which radio is selected in a group
    RadioButtonCollection genderOptions = browser.RadioButtons.Filter(
        Find.ByName("gender"));
    foreach (RadioButton radio in genderOptions)
    {
        if (radio.Checked)
        {
            Console.WriteLine("Selected: " + radio.Id);
        }
    }
}
```

--------------------------------

### Fire Element Events and Execute JavaScript

Source: https://context7.com/dev4s/watin/llms.txt

Trigger standard, keyboard, mouse, and custom events on elements. Includes methods for debugging via highlighting and retrieving JavaScript references.

```csharp
using WatiN.Core;
using System.Collections.Specialized;

using (IE browser = new IE("http://www.example.com"))
{
    // Fire standard events
    TextField input = browser.TextField(Find.ById("myInput"));
    input.Focus();
    input.Blur();
    input.Change();

    // Keyboard events
    input.KeyDown();
    input.KeyPress();
    input.KeyUp();

    // Keyboard events with specific character
    input.KeyDown('A');
    input.KeyPress('A');
    input.KeyUp('A');

    // Mouse events
    Div element = browser.Div(Find.ById("hoverTarget"));
    element.MouseEnter();
    element.MouseDown();
    element.MouseUp();

    // Fire custom event
    element.FireEvent("onclick");
    element.FireEvent("onmouseover");

    // Fire event without waiting for completion
    element.FireEventNoWait("onclick");

    // Fire event with custom properties
    var eventProps = new NameValueCollection
    {
        { "keyCode", "13" },
        { "charCode", "13" }
    };
    input.FireEvent("onkeypress", eventProps);

    // Highlight element for debugging
    element.Highlight(true);
    System.Threading.Thread.Sleep(1000);
    element.Highlight(false);

    // Flash element multiple times
    element.Flash(5);

    // Get JavaScript element reference
    string jsRef = element.GetJavascriptElementReference();
}
```

--------------------------------

### Tabs Widget Initialization

Source: https://github.com/dev4s/watin/blob/master/examples/Creating a DateTime control/TestProject/WebSite/index.html

Initializes the tabs widget on an element.

```javascript
$('#tabs').tabs();
```

--------------------------------

### Create Array of Elements with JavaScript

Source: https://github.com/dev4s/watin/blob/master/source/UnitTests/html/main.html

Creates a JavaScript array and pushes specific DOM elements identified by their IDs. This can be used to group elements for further processing.

```javascript
function toArray() { var elements = new Array(); elements.push(document.getElementById('popupid')); elements.push(document.getElementById('Select1')); return elements; }
```

--------------------------------

### Page Object Pattern for Maintainable Tests

Source: https://context7.com/dev4s/watin/llms.txt

Organizes tests using the Page Object pattern for better maintainability. Define page classes with declarative element definitions and page actions. Ensure the Page attribute's UrlRegex matches the target page.

```csharp
using WatiN.Core;

// Define a page class
[Page(UrlRegex = "login\.example\.com")]
public class LoginPage : Page
{
    // Declarative element definitions using attributes
    [FindBy(Id = "username"), Description("Username field")]
    public TextField UsernameField;

    [FindBy(Id = "password"), Description("Password field")]
    public TextField PasswordField;

    [FindBy(Id = "loginBtn"), Description("Login button")]
    public Button LoginButton;

    // Or use properties with Document accessor
    public Link ForgotPasswordLink
    {
        get { return Document.Link(Find.ByText("Forgot Password?")); }
    }

    // Page actions
    public void Login(string username, string password)
    {
        UsernameField.TypeText(username);
        PasswordField.TypeText(password);
        LoginButton.Click();
    }
}

[Page(UrlRegex = "dashboard\.example\.com", IsSecure = true)]
public class DashboardPage : Page
{
    [FindBy(Id = "welcomeMsg")]
    public Span WelcomeMessage;

    [FindBy(Id = "logoutBtn")]
    public Button LogoutButton;

    public string GetWelcomeText()
    {
        return WelcomeMessage.Text;
    }
}

// Use page objects in tests
public class LoginTests
{
    public void TestSuccessfulLogin()
    {
        using (IE browser = new IE("http://login.example.com"))
        {
            // Get typed page object
            LoginPage loginPage = browser.Page<LoginPage>();

            // Perform login
            loginPage.Login("testuser", "password123");

            // Navigate to dashboard page
            DashboardPage dashboard = browser.Page<DashboardPage>();

            // Verify login succeeded
            string welcome = dashboard.GetWelcomeText();
            Assert.IsTrue(welcome.Contains("testuser"));
        }
    }
}
```

--------------------------------

### Initialize jQuery UI Datepicker

Source: https://github.com/dev4s/watin/blob/master/examples/Creating a DateTime control/TestProject/WebSite/DatePickerPage.htm

Basic initialization of the datepicker widget on an element with the ID 'date'. Ensure jQuery and jQuery UI are included in your project.

```javascript
$(function() {
  $('#date').datepicker();
});
```

--------------------------------

### DOM Manipulation and Navigation

Source: https://github.com/dev4s/watin/blob/master/source/UnitTests/html/TestEvents.html

Functions for opening modal dialogs, injecting or removing elements, and handling user input.

```javascript
function fnOpen() { window.showModalDialog("TestEvents.html", "", "") }
```

```javascript
function injectElement() { window.setTimeout(function() { div = document.getElementById("injectElementDiv"); div.innerHTML = "<div id='seconddiv'><input type=text id=injectedTextField value='Injection Succeeded' /></div>"; }, 3000); }
```

```javascript
function removeElement1() { window.setTimeout(function() { div = document.getElementById("textFieldToRemoveDiv"); div.innerHTML = ""; }, 3000); }
```

```javascript
function removeElement() { window.setTimeout(function() { div = document.getElementById("textFieldToRemoveDiv"); div.parentNode.removeChild(div); }, 3000); }
```

```javascript
function ClickHref() { text = document.getElementById("hrefclickresult"); text.value = "success"; }
```

```javascript
function fnPrompt() { document.getElementById("promptResult").value = prompt("input"); }
```

--------------------------------

### Interact with Text Fields

Source: https://context7.com/dev4s/watin/llms.txt

Covers common operations for text inputs, textareas, and password fields including typing, clearing, and property validation.

```csharp
using WatiN.Core;

using (IE browser = new IE("http://www.example.com/form"))
{
    // Find and type text into a text field
    TextField nameField = browser.TextField(Find.ById("name"));
    nameField.TypeText("John Doe");

    // Get the current value
    string currentValue = nameField.Value;
    Console.WriteLine("Current value: " + currentValue);

    // Set value directly (without simulating keystrokes)
    nameField.Value = "Jane Doe";

    // Append text to existing content
    nameField.AppendText(" Jr.");

    // Clear the field
    nameField.Clear();

    // Check field properties
    bool isEnabled = nameField.Enabled;
    bool isReadOnly = nameField.ReadOnly;
    int maxLength = nameField.MaxLength;

    // Select all text in the field
    nameField.Select();

    // Work with password fields (same API)
    TextField passwordField = browser.TextField(Find.ById("password"));
    passwordField.TypeText("secretpassword123");

    // Work with textarea
    TextField bioField = browser.TextField(Find.ById("bio"));
    bioField.TypeText("This is my biography...");
}
```

--------------------------------

### Event Reporting and Dialog Handling

Source: https://github.com/dev4s/watin/blob/master/source/UnitTests/html/TestEvents.html

Functions to report element IDs and event properties, or trigger standard browser dialogs.

```javascript
function reportId(element) { report = document.getElementById("Report"); report.value = "button.id = " + element.id; buttonValue = document.getElementById("eventButtonValue"); buttonValue.value = window.event.button; scrElement = document.getElementById("eventScrElement"); scrElement.value = window.event.srcElement.value; return true }
```

```javascript
function ShowConfirmDialog() { var answer = confirm('Do you want to do xyz?'); report = document.getElementById("ReportConfirmResult") if (answer == true) report.value = "OK" else report.value = "Cancel"; }
```

```javascript
function ShowAlertDialog() { alert('This is an alert!'); }
```

--------------------------------

### Keyboard Event Handlers

Source: https://github.com/dev4s/watin/blob/master/source/UnitTests/html/TestEvents.html

Functions to update checkbox states and capture key codes during keyboard events.

```javascript
function keyDown() { checkbox = document.getElementById("chkKeyDown"); checkbox.checked = true; return true }
```

```javascript
function keyPress(e) { checkbox = document.getElementById("chkKeyPress"); checkbox.checked = true; keycodes = document.getElementById("txtKeycodeId"); if (!e) e = window.event; var keycode = e.charCode || e.keyCode; charfromkeycode = String.fromCharCode(keycode); keycodes.value = keycodes.value + charfromkeycode; return true }
```

```javascript
function keyUp() { checkbox = document.getElementById("chkKeyUp"); checkbox.checked = true; return true }
```

--------------------------------

### Dialog Link Click Handler

Source: https://github.com/dev4s/watin/blob/master/examples/Creating a DateTime control/TestProject/WebSite/index.html

Attaches a click event handler to a dialog link to open the dialog. Returns false to prevent default link behavior.

```javascript
$('#dialog_link').click(function(){
  $('#dialog').dialog('open');
  return false;
});
```

--------------------------------

### JavaScript Redirect with Delay

Source: https://github.com/dev4s/watin/blob/master/source/UnitTests/html/intro.html

Use this JavaScript to automatically submit a form after a specified delay. Ensure the form element exists on the page.

```javascript
function CallNextPage() { document.forms[0].submit(); }
setTimeout('CallNextPage()', 5000);
```

--------------------------------

### Hover States for UI Elements

Source: https://github.com/dev4s/watin/blob/master/examples/Creating a DateTime control/TestProject/WebSite/index.html

Applies hover effects to dialog links and list items, adding and removing a CSS class.

```javascript
$('#dialog_link, ul#icons li').hover(
  function() {
    $(this).addClass('ui-state-hover');
  },
  function() {
    $(this).removeClass('ui-state-hover');
  }
);
```

--------------------------------

### Locate Elements with Find Class

Source: https://context7.com/dev4s/watin/llms.txt

Utilizes the Find class to locate DOM elements using various attributes, regular expressions, and CSS selectors.

```csharp
using WatiN.Core;
using System.Text.RegularExpressions;

using (IE browser = new IE("http://www.example.com"))
{
    // Find by ID
    TextField usernameField = browser.TextField(Find.ById("username"));

    // Find by name
    TextField passwordField = browser.TextField(Find.ByName("password"));

    // Find by text content
    Link homeLink = browser.Link(Find.ByText("Home"));

    // Find by CSS class
    Div container = browser.Div(Find.ByClass("container"));

    // Find by partial class match
    Div highlighted = browser.Div(Find.ByClass("highlight", exactMatch: false));

    // Find by URL
    Link watinLink = browser.Link(Find.ByUrl("http://watin.sourceforge.net"));

    // Find by value attribute
    Button submitBtn = browser.Button(Find.ByValue("Submit"));

    // Find by title attribute
    Element tooltip = browser.Element(Find.ByTitle("Click here"));

    // Find using regular expression
    Link dynamicLink = browser.Link(Find.ById(new Regex("link_\\d+")));

    // Find by custom attribute
    Element custom = browser.Element(Find.By("data-testid", "my-element"));

    // Find by CSS selector
    Element selected = browser.Element(Find.BySelector("div.container > p.intro"));

    // Combine constraints with AND
    TextField emailField = browser.TextField(
        Find.ByName("email") & Find.ByClass("required"));

    // Find by index (zero-based)
    Link thirdLink = browser.Link(Find.ByClass("nav-link") & Find.ByIndex(2));

    // Find by label text
    CheckBox termsBox = browser.CheckBox(Find.ByLabelText("I accept the terms"));
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.