How to Create a Fall-back Hyperlink Button
15 July 2013
Before CSS3 came along turning HTML 'A' tags into cool dynamic text buttons was not as simple as it is now. However, I had a solution that worked back then. Now I use this old solution to provide fall-back for the old IE browsers.
The first step in providing fall-back buttons for old IE with CSS2 is to follow an HTML pattern. This pattern puts a HTML 'SPAN' within the HTML 'A' tag. The 'SPAN' then wraps all the dynamic text as shown in the example below:
<a class="button"><span>BUTTON TEXT</span></a>
This HTML pattern means you get two items within the DOM to style. For this solution you need both items. As you will see below the outer item, the HTML 'A' tag, mainly provides a hook for the styling of the left hand side of the button. The inner item, the HTML 'SPAN' tag, mainly provides a hook for the styling of the right hand side of the button. I use the word 'mainly' loosely here because the CSS2 pattern works in accord.
.button,
.button:link,
.button:visited
{
background: url("button.gif") no-repeat scroll left top transparent;
padding: 0px 0 0px 28px;
color:#FFFFFF;
display:inline-block;
width:auto;
height:38px;
border:none;
cursor:pointer;
font-size: .9em;
}
.button span,
.button:link span,
.button:visited span
{
background: url("button.gif") no-repeat scroll right top transparent;
padding: 0 40px 0 0;
height: 38px;
display:inline-block;
border:none;
line-height:38px;
margin-right: -20px;
}
.button:hover,
.button:focus,
.button:active
{
background-position: left bottom;
}
.button:hover span,
.button:focus span,
.button:active span
{
background-position: right bottom;
}
You will notice from this CSS example that a background image is being used. Remember, the goal is to get rid of the image text. We get rid of image text because actual text is accessible and image text is not accessible.
This method turned out to be a good way to do buttons a couple of years ago. The background image makes it possible to have round corner and or horizontal gradients and or a graphic next to the dynamic text.
For the background you will need to put the button's normal default state and its hover state onto its own image sprite. I always opt for a silly length so that the dynamic text can also be a dynamic size on the X axis (limited at size silly of course). The sprite needs to be of a height dividable by two.
In your CSS the height and line-height needs to agree with the buttons background height. In the example CSS shown above the button is 40 pixels high. The HTML 'A' tag gets the left padding and the HTML 'SPAN' tag gets the right padding. This then gives you the flexibility to have horizontal centring or an offset to accommodate a graphic.
In the case of round cornered buttons you need a negative right margin on the 'SPAN' tag's CSS.
margin-right: -5px;
That's it. Check out the example CSS2 button.
I am thinking of making a tool soon that will produce the CSS and background image based on a specification given via an HTML form. Please let me know if you are interested in this tool by contacting me.
Read : How to Create a Fall-back Hyperlink Button
Responsive Tables Exploring a Solution
25 November 2012
Tables have a habit of creeping into every other web development project. Finding a way to make them responsive has been a big issue and a hot topic this year. In this article a new way to make tables responsive has been explored and quite possibly a good solution has been found.
Let's Rule Out JavaScript in Making a Table Responsive
Why rule out JavaScript? JavaScript is a great wagon when it comes to progressive enhancements. The problem with JavaScript is it is not always available. If a table has been used in a project there is a good reason behind why it has been used. This is normally because the data is well suited to a table layout - or in other words it is tabular data.
You can choose to try and fix it with JavaScript, however, in this case you have to accept that some visitors will see a broken looking layout. As a Client-side Web Developer you are not doing your job properly if you accept this. Also, when you least expect it, someone will send your client a screen shot, and your client - quite rightly - will demand you fix it.
But First Let's Explore What a Table is
In order to begin to find a candidate solution, we need to understand the problem. We need to start by exploring briefly what the notion of a table is and what a table is used for. The simple answer, of course, is a table is a structure that semantically holds collections of comparable data; and we use tables to present data in such a way that information can be drawn.
This means that for a structure to act as a table it needs to support the concept of columns and of rows. Or otherwise no information can be reliably drawn from the data it holds. A HTML table fits this description perfectly after all it is what it was designed to do - its very name gives that away. The problem is HTML tables do not slim down on small screens. A row remains a row - full stop.
Now we have a good understanding of what the problem is, and while HTML tables fit the description, they do not fit the needs of a responsive layout. This is especially noticeable on mobile phone layouts as I am sure you are aware. This means if we can find an alternative HTML structure that can also fit the description of a table - to semantically holds collections of comparable data and present data in such a way that information can be drawn from it reliably, and fit the needs of a responsive layout then it is definitely worth looking for.
A Responsive Table from a Semantic Combination of HTML Elements
In any document headings (i.e. 'h*' elements) semantically indicate a section of a document. Therefore, an 'h*' element also makes a great contender as a row heading.
<h3>Row 1</h3>
By wrapping each row into an unordered list, we can begin to make a relationship between rows. You may ask what about the table's columns, and the column's headings? Definition lists, if structured well, make this possible - as shown below:
<ul class="responsive-table">
<li class="first-row">
<h3>Row 1</h3>
<dl>
<dt>Heading 1</dt>
<dd>data</dd>
</dl>
<dl>
<dt>Heading 2</dt>
<dd>data</dd>
</dl>
<dl>
<dt>Heading 3</dt>
<dd>data</dd>
</dl>
<dl>
<dt>Heading 4</dt>
<dd>data</dd>
</dl>
</li>
<li>
<h3>Row 2</h3>
<dl>
<dt>Heading 1</dt>
<dd>data</dd>
</dl>
<dl>
<dt>Heading 2</dt>
<dd>data</dd>
</dl>
<dl>
<dt>Heading 3</dt>
<dd>data</dd>
</dl>
<dl>
<dt>Heading 4</dt>
<dd>data</dd>
</dl>
</li>
<li>
<h3>Row 3</h3>
<dl>
<dt>Heading 1</dt>
<dd>data</dd>
</dl>
<dl>
<dt>Heading 2</dt>
<dd>data</dd>
</dl>
<dl>
<dt>Heading 3</dt>
<dd>data</dd>
</dl>
<dl>
<dt>Heading 4</dt>
<dd>data</dd>
</dl>
</li>
</ul>
As you can see, column headings are made constant for each item of each row. This thus creating continuity between each row and therefore, information can reliably be drawn from the data held in the semantic structure - fitting the description of a table. I believe that screen readers would also read this out in a way that makes the table's information attainable.
With a preconception of what a table looks like in a browser you may think that example 1 does not look very table like yet. However, I am sure you will agree information can be drawn from it in the same way that fits the discretion of a table.
At this point you can also see how it can easily take up less width to display - even without any styling.
Let's Style Our Responsive Table to Look Like a Table
Before we move on into the table, we need to fix up the containing unordered list and reset the margin, padding, line height and font-size of the 'ul', 'h*', 'dl', and the 'dd' elements. Once done, we need to make every definition list and h* elements sit next to each other both on the x-axes and on the y-axes. We can do this using the CSS's 'float: left' in combination with percentage widths. You can target each column width with classes if you like, as a proof of concept, I will keep this simple with a 20% width for row headings and 20% width for each column.
The trick to making it look like a normal table on a screen that is large enough to display a normal table is to use the first row's column headings. The conflict is, we do not wish to show any of the other row's headings in this layout. We will do this by making all 'dt' elements invisible except for the first row's 'dt' elements. Finally, the first row of the table needs the 'h*' element's padding at the top to be equivalent line height of the column headings: this gives the correct vertical alignment to the row's heading.
.responsive-table {
width:100%;
}
.responsive-table ,
.responsive-table h3,
.responsive-table dl,
.responsive-table dd{
margin:0;
padding:0;
font-size: 1em;
line-height:1em;
}
.responsive-table li{
list-style:none;
display:block;
clear:both;
}
.responsive-table h3,
.responsive-table dl{
float:left;
display:inline;
width:20%;
}
.responsive-table .first-row h3{
padding-top:1em;
}
.responsive-table dt{
display:none;
font-weight:bold;
}
.responsive-table .first-row dt{
display:inline;
}
You will now see a table that also fits our preconception of what a table should look like in example 2.
Let's Style Our Responsive Table to Fit on Small Screens
For a small screen set the break point of your media query to the place that makes the most sense to the data inside of your table. For this demo I have chosen 600 pixels. For this layout all you need to do is set the 'td' and 'dl' elements to float.
Here is all of the CSS for each layout of the responsive table:
.responsive-table {
width:100%;
}
.responsive-table ,
.responsive-table h3,
.responsive-table dl,
.responsive-table dd{
margin:0;
padding:0;
font-size: 1em;
line-height:1em;
}
.responsive-table li{
list-style:none;
display:block;
clear:both;
padding:5px 0 0;
}
.responsive-table dt{
font-weight:bold;
}
@media all and (max-width:600px){
.responsive-table dt,
.responsive-table dd{
float:left;
display:inline;
padding-left:10px;
}
}
@media all and (min-width:600px){
.responsive-table h3,
.responsive-table dl{
float:left;
display:inline;
width:20%;
}
.responsive-table .first-row h3{
padding-top:1em;
}
.responsive-table dt{
display:none;
}
.responsive-table .first-row dt{
display:inline;
}
}
Please see example 3. To get the best idea of how this looks and works, resize IE9 and up or any other browser on a large screen.
A Tip Worth Noting
If you need to give the table heading a background colour, apply the colour to the unordered list and set the list items back to their intended colour.
Conclusion
With an open way of thinking about what a table is and how else we can construct a table with HTML this approach to a responsive table works. The CSS to present it is very light-weight and much more agile than its HTML table counterpart. What do you think?
Acknowledgements
This solution was co-developed by Neal Stammers and myself.
Read : Responsive Tables Exploring a Solution
Get XML Content the Smart Way
09 November 2012
This article is written to impart a short cut in getting to the content of an XML document from within a JavaScript script quickly and consistently across browsers. You will see that by skipping the XML document's DOM all together time and bytes are saved.
There is also a second good to the solution that is conveyed in this article. To the best of my knowledge earlier than ie9 versions of Internet Explore do not treat RSS feeds as XML. This means in an Ajax's XMLHttpRequest object there is no responseXML document to work with and that can be a gotcha. Of course you may be able to change the header for RSS documents server side. However let's assume you cannot get access to do so as this article is about dealing with XML responses generally.
Getting the Text from XML the Normal Way
When the XMLHttpRequest object of an Ajax call returns with a responseXML you have a document. A handsome document full of information but, getting hold of the information is not so easy. There are traversals to make you dizzy, elements to store, and then there are cross browser issues for getting hold of the text nodes themselves.
An XML Traversal Example:
var items = responseXML.getElementsByTagName('item');
var title[3] = items[3].getElementsByTagName("title")[0];
var desc[3] = items[3].getElementsByTagName("description")[0];
And in reality there will be a for-each loop or for loop in there somewhere. There will be variables storing elements – allsorts going on. It may not be the hardest thing to do but the JavaScript file is growing byte by byte and the cross browser issues are afoot.
The XML Text Node Cross Browser Issue
Some browsers get hold of the text node like this:
.textContentOthers browsers get hold of the text node like this:
.text
This means making a function that will return the content whichever way the browser likes to work is a likely root. In other words, more bytes are added to the JavaScript file just to deal with cross browser differences. It is at this point you realise you are not working smart and are going down the wrong root. But, there is the better solution.
Getting the Text from XML the Smart Way
While the DOM is normally a good thing in this case it only serves to get in the way. Introduce regular expressions to the mix and add a little responseText and your smart cake is well on its way to tasty.
You may ask: What about the lack of single line mode in JavaScript's regular expression? And I would say good question. The answer is 'no problem' and it is all thanks to:
[\s\S]
This means from the group, denoted by the square brackets, of white space characters and not white space characters. That's right anything and including new line characters.
The example below uses regular expression to collect all the items from an RSS feed into an array. Then it takes the index for getting a random item. It then templates the item as appropriate and finally appends the templated item into the DOM of the main HTML page.
new Request({
'url': '/testimonials.rss',
onSuccess: function(responseText){
//split items into an array
var items = responseText.match(/<item>[\s\S]*?<\/item>/g);
// pick an item at random
var rand = Math.floor(Math.random()*items.length);
// template the data
var html = '';
html += /<div class="feed-description">(.*)<\/div>/.exec(items[rand])[1];
html += '<p class="title">' + /<title>(.*)<\/title>/.exec(items[rand])[1] + '</p>';
html += '</div>';
//then wrap and append it to something
var testimonial = new Element('div', {
'class': 'testimonial'
}).set('html', html);
$$('.testimonials')[0].grab(testimonial, 'bottom');
}
}).send();
You can of course template all the items of the feed or nodes of your document the first few items or whatever you need. Using the same method you can get hold of any part of the item or whatever your XML document is. For example:
html += '<a href="' + /<link>(.*)<\/link>/.exec(items[rand])[1] + '">Read more</a>';
will add a link back to the article source as given in the RSS feed.
Conclusion
As XML is often the transport medium given in response to many Ajax requests, it is important to have a good cross browser solution that doesn't necessarily weight down the scripts size. This method is a way of dealing with what has been returned across all browsers without the need of extra functions that only serve to make your solution work a cross browsers. I am finding this approach works very well and it is worth sharing. What do you think about this approach?
Read : Get XML Content the Smart Way
