kapok

The article on Nifty Corners catched a lot of interest that we didn't expect at all. So, a big Thank you goes to the international webdesign community and in particular Roger Johansson from 456bereastreet.com and Nate Stainer from web-graphics.com that originally launched the link through the blogosphere.

Since its publication, I've worked a lot on Nifty Corners, bringing many improvements: looking back at the solution presented in the first article, seems to me that it was written ages ago. If you hadn't read it, I suggest you to have a look to understand what I'm going to talk about. If you read it, but you're so curious that you couldn't wait, have a look at the final example I prepared for this article. No images were used, just CSS and Javascript.

First, I'm going to present briefly the many improvements I brought to Nifty Corners.

The first and major improvement is that I' ve extended browser support (hat tip John Gallant from positioniseverything.net for the font-size: 1px CSS fix!). Now, Nifty Corners are fully supported also in Internet Explorer 5.5, covering a very wide range of modern browsers: the examples that we'll see in this article have been successfully tested in IE6, IE5.5, Opera 7.6, Firefox 1.0 and Safari 1.1. The support for IE5.0 is partial, only classic nifty corners are displayed well, but I got rid anyway of that not-so-good browser sniffing that was used in the first version.

Talking about support: now Nifty Corners work also on XHTML pages served with mime types of application/xhtml+xml (hat tip Roger Johansson for document.createElementNS hint!). There's also a more robust error detection for the script, and an improved support for class selector.

Second, it's now possible choose the corners to round: you can choose to round one to all corners.

The other improvements I did are all based on the use of borders, togheter with the coloured stripes and margins, to get a quite wide variety of effects. While with the first version it was possible to get rounded corners transparent outside, now it's possible to get them transparent inside. A light form of antialiasing is now possible with Nifty Corners, and you can also get nifty corners with edges. Next, I added a basic vertical padding handling that you could find useful in some case.

We'll cover this new features in depth later through ten examples I prepared. But first, let's see how nifty corners works in general and the usage of the main function of the Javascript library.

Nifty Corners are a combination of CSS and Javascript to get rounded corners without images. The technique is made up of four essential parts:

1. CSS file for the screen
2. CSS file for the print
3. Javascript library to get Nifty Corners
4. The Javascript calls to round the elements you want

The firts three components just don't need changes, whatever you want to accomplish. They need just to be declared in the head section of any HTML page like this:

<link rel="stylesheet" type="text/css" href="niftyCorners.css">
<link rel="stylesheet" type="text/css" href="niftyPrint.css" media="print">
<script type="text/javascript" src="nifty.js"></script>

As you can see, togheter with the support and the possibilities, even the complexity of Javascript and CSS file increased a bit respect the first version, but I've tried to mantain the usage really easy.

Let's see the first example: if you see the code, you'll note that I left embedded the CSS and part of the Javascript to show how the page is build. Here's the embedded Javascript code:

<script type="text/javascript">
window.onload=function(){
if(!NiftyCheck())
    return;
Rounded("div#nifty","all","#FFF","#D4DDFF","smooth");
}
</script>

The function NiftyCheck performs a check for DOM support. If the test has passed, the Rounded function is called, that is now the only one function that you should call to get nifty corners. It accepts five parameters, that are in order:

1. A CSS selector that indicates on wich elements apply the function
2. A string that indicates wich corners to round
3. Outer color of the rounded corners
4. Inner color of the rounded corners
5. An optional fifth parameter, that will contain the options for Nifty Corners

Let's see them in depth.




First parameter: the CSS selector

One of the strenghts of the function is that is capable of accepting a CSS selector to target the elements to round. Are accepted parameters:

• Tag selector, i.e. "p" or "blockquote" or "h2"
• Id selector, with specified tag of the element: for example "div#content" or "p#news" or "li#home"
• Class selector, with specified tag of the element: for example "div.entry" or "h2.highlight"
• Descendant selector, with some limitation: this have to be composed by an id selector followed by a tag selector. Valid examples are: "div#news div" or "ul#menu li"

Second parameter: specifing wich corners to round

Let's see again the Javascript call for the first example:

Rounded("div#nifty","all","#FFF","#D4DDFF","smooth");

The second parameter specify wich corners to round. It accept one or more of the following keywords separated by a space:

• all will round all corners
• top will round top corners
• bottom will round bottom corners
• tl will round top-left corner
• tr will round top-right corner
• bl will round bottom-left corner
• br will round bottom-right corner

You can also combine the keywords. For example, you can use the parameter "top br" to round the top corners and the bottom-right one. Note also that both the parameter "top bottom" and "tl tr bl br" are valid to get all the four corners rounded.

Third and fourth parameters: specifying the colors

Let's look again the Javascript call for the first example:

Rounded("div#nifty","all","#FFF","#D4DDFF","smooth");

The third and fourth parameters are used to specifying respectively outer and inner color. They should be specified in hex code with # symbol, in three or six digits. The good news is that they could also be setted to "transparent". While in the first version you could only get the outer color transparent, now you can also get nifty corners transparent inside. Obviously, you cannot get them both. But transparency inside it's really useful for example to play with elements with background, or avoiding specifying inner color but just the outer color.

Fifth parameter: nifty corners options

Here's the Javascript call for the first example:

Rounded("div#nifty","all","#FFF","#D4DDFF","smooth");

As you can see, there's a fifth parameter setted to "smooth", in order to produce lighly smoothed rounded corners. The fifth parameter is optional, and if specified will render nifty corners in different way. There are some keywords that you could use:

• smooth will produce lighly antialiased nifty corners: the Javascript library will compute automatically the intermediate color to blend the inner and outer color more gently: so, in this case they must be both be specified.
• border (followed by a color in hex code with # symbol, in three or six digits) will make corners with edges. Note that you can also get transparent corners, but just outside the edges.
• small will produce small corners, and could be applied to every kind of corners

The vertical padding handling

Before we start with the examples, let me explaing a good feature I've added to Nifty Corners but is behind the scenes. I' ve added a basic vertical padding handling,you can now specify via CSS a vertical padding to the elements to round: The script will automatically eliminate it before adding nifty corners. This is very useful for three reasons: it's easier adopting nifty corners on existing pages, the pages will degrade better if Javascript is disabled and also to avoid that jump-effect when the page wich use nifty corners is loaded. Optimal values are 5px vertical padding on the elements to round if you're planning to use normal nifty corners and 2px for small ones.

Now that we've covered all the points, we can start with some example.



The examples

Now the fun part.. As in the first article, I did some examples to show the possibilities of Nifty Corners. In this case you'll see how the possibilities increased. For each example will be reported on this page just the Javascript calls to Rounded function, but keep in mind that these calls should be included in the following code:

window.onload=function(){
if(!NiftyCheck())
    return;
/* here the calls to add Nifty Corners */
}

Now, let's start.

Example one: a single div with antialias

This is the example we saw in the opening. The Javascript call is:

Rounded("div#nifty","all","#FFF","#D4DDFF","smooth");

In this case all corners were rounded with a very light antialiasing. Someone over the net tried to produce really antialiased rounded corners without images modifying heavily my original script. But I think that the solution I'm presenting here is the best I could find to blend outer and inner colour more gently, without overcharging too much the CSS, the Javascript, the computing time and the DOM tree of the page.

I'm not so radical about the use of images, and I think that in those case where real antialised rounded corners must be used in a page, the traditional html+CSS+background images method will still be the best way to get them.

Example two: brothers divs

In this example, two divs were rounded. The js calls are:

Rounded("div#content","all","#FFF","#9DD4FF","smooth");
Rounded("div#nav","tr br","#FFF","#FFC79D","smooth");

Note that the small one has only right corners rounded.

Example three: transparent by nature

This one is one of the most significant improvements to nifty corners. You just have to specify outer color and "transparent" for the inner color and you got it:

Rounded("div#box","all","#6385D8","transparent");

A thing about transparency inside: while you can choose the corners to round, and get small and transparent inside nifty corners, it's not possible to get them smoothed or with edges.

Example four: with or without them

In this example, I put two divs sharing the same class in a page. One of them has got an id too, but no additional CSS rules, to show how nifty corners with edges are rendered. In this case two calls to Rounded function are needed, in order to get different inner color for top and bottom corners:

Rounded("div#nifty","top","transparent","#FFC5FF","border #C0C0C0");
Rounded("div#nifty","bottom","transparent","#F0F0E7","small border #C0C0C0");

Note that after the border option should follow the color of them, and at the bottom I setted small corners with edges. A small note on the use of borders: the script will automatically add horizontal borders to the direct children of the element(s) to round with edges, avoiding you to specify them in the CSS and allowing a better degradation in the case Javascript is off but CSS is on. So, if you' re having bad rendering issues with borders, the easiest way to fix is adding an extra wrapper to contain everything of the element to round. This solution is also suggested when the element to round contains lot of elements as direct children, since the script traverses them all for adding vertical borders and could take a little time.

Example five: color explosion

In this example, I used descendant selector and transparency inside to round four elements in one shot, but just on two opposite corners. Here's the only Javascript call:

Rounded("div#news div","tr bl","#FFF","transparent");



Example six: elastic nifty