Basically, you can have any border width from 0 to 960 pixels. Any value greater are ignored and the border remains 960 pixels wide.

To better illustrate the point, here is my example:

var error = {
    alert: function(text) {
        document.write(text);
    }
}
alert("Crash");
with (error) {
    alert("Bang");
}

The error object has a member function called alert, which writes out the text to the document, but the global (window) object also as an alert function which displays the text in a dialog.

So which alert function will be called in the scope of the “with” statement?

Well, it is error.alert, but it is not obvious if you are just scanning through the code, and worse, what if you actually meant to call window.alert?

So, use “with” care!

N.B. The “with” statement is particularly helpful when using “Math” functions.

For example, you can reduce this:

...
p2.Latitude = Math.asin(Math.sin(lat) * Math.cos(d) + Math.cos(lat) * Math.sin(d) * Math.cos(brng));
p2.Longitude = ((lon + Math.atan2(Math.sin(brng) * Math.sin(d) * Math.cos(lat), Math.cos(d) - Math.sin(lat) * Math.sin(p2.Latitude))) * 180) / Math.PI;
p2.Latitude = (p2.Latitude * 180) / Math.PI;
...

Down to:

with (Math) {
...
p2.Latitude = asin(sin(lat) * cos(d) + cos(lat) * sin(d) * cos(brng));
p2.Longitude = ((lon + atan2(sin(brng) * sin(d) * cos(lat), cos(d) - sin(lat) * sin(p2.Latitude))) * 180) / PI;
p2.Latitude = (p2.Latitude * 180) / PI;
...
}

The resulting code is lighter and easier to read.

He is back with a series of presentations on JavaScript, and here are the links to the episodes:

• Volume One: The Early Years
• Chapter 2: And Then There Was JavaScript
• Act III: Function the Ultimate
• Episode IV: The Metamorphosis of Ajax
• Part V: The End of All Things

Enjoy!

Read more about this release:

• Announcing Microsoft Ajax Library (Preview 6) and the Microsoft Ajax Minifier
• How the Script Loader in the Microsoft Ajax Library will make your life wonderful
• Entirely unobtrusive and imperative templates with Microsoft Ajax Library Preview 6
• Using the New Microsoft Ajax Minifier

ADSUtil.vbs Set W3SVC/Filters/Compression/deflate/HcDoStaticCompression FALSE
ADSUtil.vbs Set W3SVC/Filters/Compression/deflate/HcDoOnDemandCompression FALSE
ADSUtil.vbs Set W3SVC/Filters/Compression/deflate/HcDoDynamicCompression FALSE

To create your own AJAX validation control:

1. Create a new class which inherits UPDN.AjaxValidator:

public class YourValidator : UPDN.AjaxValidator { /*...*/ }

2. Provide a public static method to perform the validation, the signature of the method should be:

public static ValidationResult YourValidationMethod(string value)

3. Override OnServerValidate to call your public static validation method:

protected override bool OnServerValidate(string value)
{
    var result = YourValidationMethod(value);
    return result.IsValid;
}

4. Override GetScriptReferences to include your client-side script:

protected override void GetScriptReferences(ScriptReferenceCollection references)
{
    base.GetScriptReferences(references);
    references.Add(new ScriptReference("~/Scripts/YourValidator.js"));
}

5. Create the client-side control for your validation control, which inherits UPDN.AjaxValidator:

Type.registerNamespace("Example");
Example.YourValidator = function(element) {
    Example.YourValidator.initializeBase(this, [element]);
};
Example.YourValidator.prototype = {
    // Override validate to do pre-validation checks.
    validate: function(val, args, event) {
        Example.YourValidator.callBaseMethod(this, "validate", [val, args, event]);
    },
    // Override validated to do post-validation stuff.
    validated: function(result, event) {
        var val = this.get_element();
        // Do your custom validation message display stuff here!
    }
};
Example.YourValidator.registerClass("Example.YourValidator", UPDN.AjaxValidator);

6. Expose the YourValidationMethod method in YourValidator class as a “Page Method” in the code-behind:

[WebMethod]
public static ValidationResult YourValidationPageMethod(string domain)
{
    return YourValidator.YourValidationMethod(domain);
}

7. Add reference to your validation control in Web.config:

<pages>
    <controls>
    ...
        <add tagPrefix="example" namespace="Example"/>
    </controls>
</pages>

8. Add the validation control to your page, set the PageMethodName property to “YourValidationPageMethod”:

<example:YourValidator runat="server" ID="YourValidator1" ControlToValidate="TextBox1" Display="Dynamic" ErrorMessage="Your error message" PageMethodName="YourValidationMethod" ProgressIndicatorCssClass="wait" />

Download the (VS.NET 2008) solution from my SkyDrive.

Luckily, Sizzle is the selector engine that powers the jQuery library, and it is designed to be easily dropped into a host library, and that includes the Selenium framework.

Okay, I’ll stop repeating what you already knew, and tell you how I integrated Sizzle into the Selenium framework:

1. Start Selenium IDE, open the Options dialog.

2. Click the [Browse...] button for the “Selenium Core extensions” field, locate and select ”sizzle.js”.

3. Create or update “user-extensions.js”, adding the following snippet:

function eval_css(locator, inDocument) {
    var results = [];
    window.Sizzle(locator, inDocument, results);
    return results
}

This bit of code simply overrides the eval_css() function in htmlutils.js to use the Sizzle engine.

4. Click the [Browse...] button again, this time locate and select ”user-extensions.js”.

5. Close and restart Selenium IDE.

Now, try out the Sizzle selectors, for example:

Navigate to http://www.google.co.uk/preferences?hl=en

Insert a new command, in the Target field, enter:

css=:checkbox[name=lr]:last

Now click the [Find] button and you should see the checkbox for Vietnamese highlighted.

I have not (yet) tried this with Selenium RC, but if you want to have a go, please refer to Using User-Extensions With Selenium RC.