I was told that I should schedule my tweets to avoid such problems. Schedule my tweets!? I’m too lazy for that, besides I don’t tweet that much to justify scheduling a tweet. So I chanced upon a solution that is perfect for me.

The Buffer App, why schedule? when I can buffer! The way it works is that you fill up your buffer and it schedules the tweet for you automatically. No need to mess around with scheduling!  It’s simple and easy to use. Their Chrome extension comes in very handy and they have a free account where you can buffer 10 tweets at a time!

Go to Source

I was told that I should schedule my tweets to avoid such problems. Schedule my tweets!? I’m too lazy for that, besides I don’t tweet that much to justify scheduling a tweet. So I chanced upon a solution that is perfect for me.

The Buffer App, why schedule? when I can buffer! The way it works is that you fill up your buffer and it schedules the tweet for you automatically. No need to mess around with scheduling!  It’s simple and easy to use. Their Chrome extension comes in very handy and they have a free account where you can buffer 10 tweets at a time!

Go to Source

We’ve compiled a neat list of infographics pertaining to blogging and the blogosphere, in the hope that bloggers (and potential ones) like yourself will acquire new knowledge about the blogging universe and perhaps improve on your site. At the very least, we hope these enticing infographics will make you feel intrigued about how far blogs have come along on the net. Enjoy!

The Evolution of The Blogger
If you ever wondered how blog started and become what it is now, check this out. You’ll be amazed to know how many different kind of bloggers there were in the span of two decades. (via Flowtown)

Who’s in the Blogosphere?
Numbers and more numbers… except that it’s presented in colored charts and bars. This infographic is a detailed breakdown of the profile of U.S. bloggers. (via Flowtown)

Anatomy of a WordPress Theme
This piece of infographic is your crash course on how WordPress works. If you’ve been so busy with blogging and don’t have time to figure out how your blogging platform works, just take a quick look at this. (via Yoast)

State of the Blogosphere in 2010
Blogosphere represented as a universe of planets within a galaxy. Well-suited for the vast nature of the blogging community. (via Infographic Lab)

The Power of WordPress
A general introduction of how the WordPress has evolved over the past seven years as well as numerical and chart representations of various WordPress statistics. (via Testking)

The Most Popular Design Blogs
A breakdown of a number of popular design blogs on how many Twitter Followers and Facebook Fans each one has. (via Testking)

Search Benefits of the Blogosphere
A simple infographic promoting the benefits of the blogging community using cutesy birdies on a tree. (via Elliance)

Self-hosted WordPress.org vs. Free WordPress.com
Potential bloggers: Unsure of what kind of WordPress platform to choose? This comprehensive comparison between self-hosted platform and free WordPress will help you in your decision. (via WPBeginner)

Ultimate Guide to Upgrade WordPress
WordPress bloggers will love this clear and clean flowchart detailing the steps to upgrade and safeguard their blogs. (via WPBeginner)

Which Blogging Platform Should You Use?
A survey of bloggers’ preferences for blogging platform. WordPress emerged as the winner. (via WPBeginner)

The Blog Economy
Substantial infographic that profiles the income levels of bloggers, blogging habits along with social media usages. (via Grasshopper Group)

The Blog Tree
Using a tree its leaves as a representation of popularity of a range of blogs, this infographic is indeed one-of-a-kind. (via JESS3)

Corporate Blogging: The Infographic
Infographics can do wonders like compressing a book like Corporate Blogging for Dummies into a flat piece of paper with all the key words atop. (via Marketing Technology Blog)

The Journey of a Successful Blog Post
A straightforward step-by-step process for any blog post to be get its well-deserved crowd. A must-see for all aspiring bloggers aiming to shoot his or her blog to fame. (via HowToMakeMyBlog)

(bellefoong)

Go to Source

Previously on Fubiz

• Munich Sneakers Design
• Nike – I Am The Rules
• Keds Shoes Collection

Copyright Fubiz™ – Suivez nous sur Twitter et Facebook

Go to Source

Have you ever seen those scary looking CSS structural pseudo classes, like li:nth-child(4n+2)? Can you enunciate exactly what that means? If not, don’t worry; I’ll teach you how easy this is to understand — once you work backward!

See What I Mean?

The key to figuring these things out is to work from right to left! Now it’s easy to understand. If you enjoyed this video quick tip, don’t forget that we have a seemingly never-ending span of video quick tip on Nettuts+ – ranging from .NET, to CSS, to JavaScript!

Go to Source

Earlier this morning, I needed to create vertical text for a project I’m working on. After trying out a couple ideas, I took to Twitter to find what sorts of thoughts our followers had on the subject. There were plenty of great responses and ideas that we’ll go over today!

Method 1: <br> Tags

So, one possible (though not recommended) way to achieve vertical text is to add <br> tags after each letter.

<h1>
   N <br />E <br />T <br />T <br />U <br />T <br />S
</h1>

View a Demo

Don’t you use this method. It’s lame and sloppy.

Method 2: Static Wrapping

With this method, we wrap each letter in a span, and then set its display to block within our CSS.

<!DOCTYPE html>
<html>
<head>
<meta charset=utf-8 />
<title>Vertical Text</title>

<style>
  h1 span { display: block; }
</style>
</head>
<body>

  <h1>
   <span> N </span>
   <span> E </span>
   <span> T </span>
   <span> T </span>
   <span> U </span>
   <span> T </span>
   <span> S </span>
  </h1>

</body>
</html>

View Demo

The problem with this solution — other than the frightening mark-up — is that it’s a manual process. If the text is generated dynamically from a CMS, you’re out of luck. Don’t use this method.

Method 3: Use JavaScript

My initial instinct was to dynamically add the span tags with JavaScript. That way, we get around the issues mentioned in method two.

<!DOCTYPE html>
<html>
<head>
<meta charset=utf-8 />
<title>JS Bin</title>

<style>
  h1 span { display: block; }
</style>
</head>
<body>
  <h1> NETTUTS </h1>

  <script>
    var h1 = document.getElementsByTagName('h1')[0];
    h1.innerHTML = '<span>' + h1.innerHTML.split('').join('</span><span>') + '</span>';
  </script>
</body>
</html>

View Demo

This method is definitely an improvement. Above, we split the text into an array, and then wrap each letter in a span. While we could use something like a for statement, or $.map to filter through the array, a far better and quicker solution is to manually join and wrap the text at the same time.

Though better, this solution isn’t recommended.

• Will this break your layout if JavaScript is disabled?
• Ideally, we should be using CSS for this task, if possible.

Method 4: Apply a Width to the Container

Let’s get away from JavaScript if we can. What if we applied a width to the container element, and forced the text to wrap? That could work.

<!DOCTYPE html>
<html>
<head>
<meta charset=utf-8 />
<title>JS Bin</title>

<style>
  h1 {
    width: 50px;
    font-size: 50px;
    word-wrap: break-word;
  }
</style>
</head>
<body>
  <h1> NETTUTS </h1>
</body>
</html>

View Demo

In this scenario, we apply a very narrow width to the h1 tag, and then make its font-size equal to that exact value. Finally, by setting word-wrap equal to break-word, we can force each letter onto its own line. However, word-wrap: break-word is part of the CSS3 specification, and is not compliant across all browsers.

Excluding older browsers, this seemingly solves our problem…but not entirely. The demo above does appear to work, but it’s too risky to play with pixel values. Let’s try something as simple as turning the uppercase letters into lowercase.

Yikes; with this method, we have to be very careful when it comes to the specific values we set. Not recommended.

Method 5: Apply letter-spacing

As a precaution, and to extend method four, why don’t we apply fairly large letter-spacing to get around this issue?

<!DOCTYPE html>
<html>
<head>
<meta charset=utf-8 />
<title>JS Bin</title>

<style>
  h1 {
    width: 50px;
    font-size: 50px;
    word-wrap: break-word;
    letter-spacing: 20px; /* Set large letter-spacing as precaution */
  }
</style>
</head>
<body>
  <h1> Nettuts </h1>
</body>
</html>

View Demo

That seems to fix the issue, though, again, we’re using a bit of CSS3 here.

Method 6: Use ems

Alternatively, there’s a one-liner solution. Remember when we learned that applying overflow: hidden to a parent element would miraculously make it contain its floats? This method is sort of like that! The key is to use ems, and place a space between each letter.

<!DOCTYPE html>
<html>
<head>
<meta charset=utf-8 />
<title>JS Bin</title>

<style>
  h1 {
    width: 1em;
    font-size: 40px;
    letter-spacing: 40px; /* arbitrarily large letter-spacing for safety */
  }
</style>
</head>
<body>
  <h1> N e t t u t s </h1>
</body>
</html>

View Demo

Pretty neat, right? And, this way, you can apply any font size that you wish. Because we’re using ems — which is equal to the x-height of the chosen font — we’re then provided with a lot more flexibility.

But, once again, sometimes more than one letter will end up on a line. You have to be safe; that’s why I’ve applied arbitrarily large letter-spacing to ensure that there’s never more than one letter on a line.

To my knowledge at this time, this is the best, most cross-browser compliant solution.

Conclusion

Shouldn’t there be a CSS3 rule to accomplish this task? What if I could set something along the lines of: font-display: letter-block; which would instruct each letter to be rendered as a block of sorts?

What do you think? Do you have any other alternatives that we should consider? Many people suggested using text-rotation to accomplish the task, but it’s important to remember that this also rotates the text ninety degrees as well, which is not what we’re trying to achieve.

Go to Source

And also, Darcy Clarke has written a piece of  jQuery code which does the magic tag wrapping automatically. You can view the tutorial on CSS3 Rounded Image With jQuery.

Source: CSS3 Rounded Image with jQuery

Go to Source

The other day I was trying to style CSS3 border-radius to image element and I realized that Firefox doesn’t display border-radius on images. Then I figured a way to work around it — wrap a span tag around with the original image as a background-image. Thanks to Darcy Clarke for the jQuery code which does the magic tag wrapping automatically.

View Demo Rounded Images (more…)

Go to Source

Last week, at Martin Place in central Sydney, PR agency One Green Bay covered the floor with an installation made from 219,000 imitation cigarettes. This number represents the number of cigarettes a 20-per-day smoker consumes over the span of 30 years. It’s hard to see in the pictures, but the cigarettes are covered with a transparent panel, which is why you see people walking on top of them.

It was strategically placed in a spot where many people enjoy their cigarette break. The purpose of this display was to raise awareness about how dangerous smoking is, and of course to encourage people to stop smoking, even if they have to seek professional help to do it. I’m usually not a fan of these “in your face” kind of messages, but I like this one. The reflections and serenity that these pictures portray actually make the cigarettes look beautiful. I guess their marketing didn’t work on me, but since I don’t smoke anyway, it doesn’t really matter.

Thanks for the pictures! http://www.zimbio.com

Go to Source

Last week I talked about Cross-Browser CSS Gradient. Today I’m going to show you how to put the CSS gradient feature in a good practical use. Check out my demo to see a set of gradient buttons that I have created with just CSS (no image or Javascript). The buttons are scalable based on the font-size. The button size can be easily adjusted by changing the padding and font-size values. The best part about this method is it can be applied to any HTML element such as div, span, p, a, button, input, etc. (more…)

Go to Source

FarmVille, the massively popular Facebook game, surpassed 80 million monthly active users this week (source: AppData). Facebook has around 400 million users in total.

FarmVille has been a breakout hit, with its active user count growing by around 10 million users per month. Note that this isn’t simply signups: This is a count of people using the app at least once in the 30 day span.

FarmVille’s daily active user count is currently 29.7 million — that’s almost 30 million people using FarmVille every day.

FarmVille’s parent company, Zynga, was valued at 1 billion dollars late last year.

Tags: facebook, farmville

Go to Source

The solution to me was to create the charts from HTML using CSS. There have been some solutions for this problem already but I wanted something very simple and easy to maintain. Hence all the markup I am using is this:

Instead of hard-coding any of the trickery necessary I wrote a PHP script to generate the HTML, the styles and do all the math. So all that is needed to render one of the charts is the following code:

Of course, this can also be turned into a web service – you can get the chart with the following URL:

http://icant.co.uk/csscharts/csscharts.php?values=400,20,30,233,312,78,20,67&height=100&width=600&bargap=0

And if you specify JSON as the format you get it with a callback to a function called csscharts:

http://icant.co.uk/csscharts/csscharts.php?values=400,20,30,233,312,78,20,67&format=json

That way you can use it in JavaScript:

You can see some demos here, get detailed info about the CSS trickery used and of course download the code on GitHub.

Go to Source

1. jQuery Sequential List

This tutorial will show you how to use jQuery to add a sequent of CSS classes to create a graphical list. The second example in this tutorial will show you how to add a comment counter to a comment list using jQuery’s prepend feature. The code is very simple, the following example shows how you can add a counter number to a comment list.

<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript">
$(document).ready(function(){

  $("#commentlist li").each(function (i) {
    i = i 1;
    $(this).prepend('<span class="commentnumber"> #' i '</span>');
   });

});
</script>

To get this markup:

<ol id="commentlist">
	<li><span class="commentnumber"> #1</span>
		...
	</li>
	<li><span class="commentnumber"> #2</span>
		...
	</li>
	<li><span class="commentnumber"> #3</span>
		...
	</li>
</ol>

Check out the demo here

2. jQuery Corners

This jQuery plugin will simple allow you to create rounded corner for your design elements including forms or anchor links without using images or obstructive markup.

Once jQuery and jQuery.corners scripts are loaded, rounding corners is easy.

<div style="background-color:#acc; padding:5px" class="rounded">
  Simple Example
</div>
<script>$(document).ready( function(){
  $('.rounded').corners();
});</script>

Check out the demo here

3. jQuery Checkbox

This jQuery plugin will simple skin checkboxes and radio buttons in a nice way.

Check out the demo here

4. Styling Buttons and Toolbars with the jQuery UI CSS Framework

This tutorial demonstrates how to incorporate the power of jQuery UI CSS framework classes in a custom widget to create and style buttons and toolbars.

Creating a basic button is very simple with the jQuery UI CSS framework and styling it is really easy. All you need to do is add the default “clickable” state by assigning the class ui-state-default. We also want these to have rounded corners, so we added the optional ui-corner-all framework class which adds CSS3 corner-radius properties to all corners without the need for any images or extra markup.

<button class="ui-state-default ui-corner-all" type="submit">Button</button>
<a href="#" class="ui-state-default ui-corner-all">Link</a>

Check out the demo here

5. Create A Colorful Sitemap With jQuery

In this article, Chris Coyier teaches us how to build a visually interesting sitemap that makes the hierarchy clearer through the use of color. The idea here is, when the mouse cursor hovers over a list, that list will brighten up a bit and fade to a unique color. When the mouse cursor is removed, the list will return to its original color.

Check out the demo here

6. Style Author Comments Differently with jQuery

Now you want to apply the custom styling applied to comments left by the author on blogger. The script will loop through all of the comments on the page, if the member link on the current comment matches the member link in the profile page on your blog, then it must be an author comment. The script will then apply an additional class to the comment, allowing you to style it separately.

Check out the demo here

7. asmSelect – Alternative Select Multiple

A progressive enhancement to <select multiple> form elements which is easier for users to understand and interact with than regular <select multiple> form elements. Also, it doesn’t require user to Ctrl-Click or Shift-Click multiple elements. Instead users of your form can add or remove elements individually, without risk of losing those that have already been selected.

Check out the demo here

8. Flexgrid

A lightweight but rich data grid with resizable columns and a scrolling data to match the headers, plus an ability to connect to an xml based data source to load the content. Features include: Resizable columns, Resizable height, Sortable column headers, Cool theme, Can convert an ordinary table, Paging, Show/hide columns and more.

Check out the demo here

9. MaxLength

This plugin makes it easy to apply a "maxlength" attribute to custom elements for example a <textarea>. It also gives you the possibility to add a nice character counter under the element that shows the user how many chars he/she has left before the maxlength is reached, and/or an alert message.

To use this on a simple text area, all you have to do is:

<script type="text/javascript">
  $(document).ready(function(){
    $('#textarea_1_1').maxlength();
  });
</script>

Check out the demo here

10. ClockPick

ClockPick is a timepicker plugin, enabling users to enter a time value into a form field. Using a unique popup div UI, ClockPick gets the job done in about 1/5 the time it takes to enter a time value using a traditional select menu UI.

Check out the demo here

11. jQuery (mb)Menu 1.5

This is a powerful jQuery component to build easily a multilevel tree menu or a contextual menu (right click) in an intuitive way! You can add as many submenus as you want; if your submenu or menu is not declared in the page, the component’ll get it via ajax calling the template page with the id of the menu you need (the value of “menu” attribute) the ajax page should return a well formatted code as the example below for the menu voices code.

Check out the demo here

12. (mb)ContainersPlus 1.0

This is a useful plug in to build full featured and full skinnable containers. The container can be set to draggable, resizable, collapsable and minimizable. The container can be set to draggable and resizable by adding “draggable” and/or “resizable” to the class attribute; there is a custom attribute called buttons that accept: i [iconize], m [minimize], c [close] as value to add buttons to the button-bar. You can also add a left top corner icon by adding the attribute “icon” with the icon path as value.

Check out the demo here

13. Auto line-height for flexible layouts

Adjusts the line-height of a container (such as a div) in proportion to it’s width, relative to the font size.

Check out the demo here

14. UI.Layout

This plugin was inspired by the extJS border-layout, and recreates that functionality as a jQuery plug-in. The UI.Layout plug-in can create any UI look you want – from simple headers or sidebars, to a complex application with toolbars, menus, help-panels, status bars, sub-forms, etc.

Check out the demo here

15. Colorize

Colorize is a jQuery plugin to add background color to alternate table rows, highlight a row/column on mouse over, and colorize a row/column when you click your mouse button over it. You can colorize as many table rows as you want. A repeat mouse click reverts the row to the original background color.

Check out the demo here

16. jQuery 3 State Switch Plugin

jQuery 3 State Switch Plugin(J3SSW) is a jQuery Plugin that expresses the selection and some states of list item using radio button and checkbox at the same time. The applications of J3SSW includes some interfaces for sort key or filter key of any search results.

Check out the demo here

17. Animated Hover

Animated Hover provides animated transitions between hovered items for any jQuery project. Requires jQuery 1.2+ and Dimensions

Check out the demo here

18. jQuery Feed Menu

It’s nice to offer users an alternate way to get at your feeds, here is an easy and standard way of offering your feeds via a nice, compact menu, just like in the location bar, but on your site.

Check out the demo here

19. jquery Hover Sub Tag Cloud

Here is a new way to create your tag cloud Using jQuery and reduce its size, so my demo will introduce “Hover Sub Tags” under each main Tag, for example if you have Ajax as a tag, you can have jquery, mootools, etc… as sub-tags. A Sub Tag Cloud will appear when hovering over the main Tag links.

Check out the demo here

20. jQuery ListNav Plugin

This jQuery plugin supplies an easy way to unobtrusively add a letter-based navigation widget to any UL or OL list. An easily stylable (via CSS) nav bar appears above the list, showing the user the letters A-through-Z. Clicking one of the letters filters the list to show only the items in the list that start with that letter. Hovering over a letter (optionally) shows a count above the letter, indicating how many items will be displayed if that letter is clicked. Other options give you control over the basic functionality.

Check out the demo here

Go to Source

Roman Cortes has a fun parallax effect using just CSS and HTML. Scroll over the bad boy above and see it at work.

Then view the source and have your eyes bleed

I hope he used a tool

Go to Source

Designed for humans first and machines second, microformats are a set of simple, open data formats built upon existing and widely adopted standards.

The official microformat “elevator pitch” tells us nothing useful. That’s not a good sign. It doesn’t get much better on the learn more link, either.

I’m left scratching my head, wondering why I should care. What problem, exactly, do microformats solve for me as a user? As a software developer? There’s lots of hand-wavy talk about data, but precious little in the way of concrete stories or real world examples.

But I have a real world example: a CV. To some human resource departments the standard web interchange format for a CV or Resume is already established — it’s called “Microsoft Word”. I have no beef with Word, but certainly we’d like to pick a more simple, open data format for our personal data than Microsoft Word — and the hResume microformat seems to fit the bill. And if your CV is published on the web in a standard(ish) format, it’s easier to take it with you wherever you need to go.

I had already implemented the tag and identity microformats on Stack Overflow many months ago. I wasn’t convinced of the benefits, but the implementation was so easy that it seemed like more work to argue the point than to actually get it done. Judge for yourself:

<a href="http://www.codinghorror.com/" rel="me">codinghorror.com</a>
<a href="/questions/tagged/captcha" rel="tag">captcha</a>

Fairly clean and simple, right? That was the extent of my experience with microformats. Limited, but positive. Then I read through the hResume microformat spec. You should read it too. Go ahead. I’ll wait here.

My first impression was not positive, to put it mildly. So you want me to take the ambiguous, crappy “HTML” markup we already have and layer some ambiguous, crappy “microformat” markup on top of it? And that’s … a solution? If that’s what microformats are going to be about, I think I might want off the microbus.

Let’s take a look at a representative slice of hResume markup:

<div class="vcard">
  <a class="fn org url" href="http://example.com/">Example</a>
  <div class="adr">
    <span class="type">Work</span>:
    <div class="street-address">169 Maple Ave</div>
    <span class="locality">Anytown</span>,
    <abbr class="region" title="Iowa">IA</abbr>
    <span class="postal-code">50981</span>
    <div class="country-name">USA</div>
  </div>
</div>

As you can see, the crux of microformats is overloading CSS classes. When you give something the “adr” class within the “vcard” class, that means it’s the address data field within the hCard, within the hResume.

While I can see the attraction, this approach makes me uneasy:

1. We’re overloading the class attribute with two meanings. Is “adr” the name of a class that contains styling information, or the name of a data field? Or both? It’s impossible to tell. The minute you introduce a microformat into your HTML, the semantics of the class attribute have been permanently altered.
2. The microformat css class names may overlap with existing css classes. Woe betide the poor developer who has to retrofit a microformat on an established site where “locality” or “region” have already been defined in the CSS and are associated with elements all over the site. And let me tell you, many of the microformat css field names are, uh, conveniently named what you’ve probably already used in your HTML somewhere. In the wrong way, inevitably.
3. There’s no visual indication whatsoever that any given css class is a microformat. If you hire a new developer, how can they possibly be expected to know that “postal-code” isn’t just an arbitrarily chosen CSS class name, it’s a gosh darned officially blessed microformat? What if they decide they don’t like dashes in CSS class names and rename the style “postalcode”? Wave bye bye to your valid microformat. If it seems fragile and obtuse, that’s because it is.
4. The spec is incredibly ambiguous. I read through the hResume, hCard, and hCalendar spec multiple times, checked all the samples, viewed source on existing sites, used all the validators I could find, and I still got huge swaths of the format wrong! For a “simple” and “easy” format, it’s … anything but, in my experience. The specification is full of ambiguities and requires a lot of interpretation to even get close. I’m not the world’s best developer, but I’m theoretically competent, and if I can’t implement hResume without wanting to cut myself and/or writing snarky blog posts like this, how can we expect everyone else to?
5. It doesn’t handle unstructured data well. On Stack Overflow, we have a single “location” field. No city, state, zip, lat, long, and all that jazz: just an unstructured, freeform, enter-whatever-pleases-you “location” field. This was awkward to map in hCard, which practically demands that addresses be chopped up into meticulous little sub-fields. This is a bit ironic for a format supposedly designed to work with the loose, unstructured world wide web. Oh, and this goes double for dates. If you don’t have an ISO datetime value, good luck.

Maybe I have a particular aversion to getting my chocolate data structure mixed up with my peanut butter layout structure, but it totally skeeves me out that the microformat folks actually want us to design our CSS and HTML around these specific, ambiguous and non-namespaced microformat CSS class names. It feels like a hacky overload. While you could argue this is no different than the web and HTML in general — a giant wobbly teetering tower of nasty, patched-together hacks — something about it fundamentally bothers me.

Now, all that said, I still think microformats are useful and worth implementing, if for no other reason than it’s too easy not to. If you have semi-structured data, and it maps well to an existing microformat, why not? Yes, it is kind of a hack, but it might even be a useful hack if Google starts indexing your microformats and presenting them in search results. While I’m unclear on the general benefits of microformats for end users or developers, seeing stuff like this in search results …

… is enough to convince me that microformats are a step in the right direction. Warts and all. While we’re waiting for HTML5 and its mythical data attributes to ship sometime this century, it’s better than nothing.

Go to Source

What?

Let’s take this from the top. What are microformats? Off the homepage of microformats.org comes this definition:

Designed for humans first and machines second, microformats are a set of simple, open data formats built upon existing and widely adopted standards.

A good start, but we need a bit more to clarify. You can find a whole list of definitions on the site, but here’s the summary: microformats are a set of standards for embedding easily extractable data on your pages, using technologies you are comfortable with today. The great part about this is that you probably have content on your site right now that you could mark up with a microformat. The even greater part is that it will only take you a couple of minutes after reading this tutorial.

Why?

So why should you use microformats? What’s the incentive? Well, if you’re convinced that HTML should be semantic just because, then microformats will click with you. Otherwise, I’ll persuade: as we noticed, the whole idea of microformats is to standardize that way data is marked up on a page, so that it can be easily extracted. Currently, there aren’t a whole lot of tools that take advantage of microformats, but I think that will change. Using microformats in your work will prepare your websites for the future, when microformats will be much more widespread. Again, the website has general list of what you can do with microformats. There’s already decent Firefox addon for extracting microformats; it’s called Operator.

Then, Dan Web has created a simple JavaScript library called ‘Sumo’ that extracts microformats for use with JavaScript. You can also try the microformats bookmarklet.

How?

Well, if you’ve gotten this far, it’s obvious you and microformats were meant for each other. So let’s hop right in and look at one. But before we do, here’s the general structure of the microformats we’ll be looking at: generally speaking, if they involve more than one element in our code, they use classes. If they are only concerned with one element, it’s usually the rel attribute that’s used.

hCalendar

hCalendar is an easy way to mark up events. We’ll start with an element that declares our event:

<div class="vevent">

</div>

If you have multiple events, you should wrap them in a div.vcalendar; however, it’s not necessary. There are two required properties for an event: the start date (dtstart) and the summary. Let’s add these:

<div class="vevent">
	<p>This year, our <span class="summary">company holiday dinner</span>
	will begin at <span class="dtstart">2009-12-18T17:30</span>.</p>
</div>

Human-readable, eh? Not that date! You’re right; although microformats are written for people first, dates are one area where it’s important that computers can read it. Common convention would be to write the date with an abbr tag, in which case the title attribute would be the value for the property value:

<abbr class="dtstart" title="2009-12-18T17:30">5:30pm on Friday, December 18.</abbr>

There are other, optional properties you can add, as well. How about an end time, or a location?

<p>We'll meet in the <span class="location"> conference room of the Tower Hotel</span>,
which we have reserved until <abbr class="dtend" title="2009-12-18T20:30">9:30pm</abbr>.</p>

Using the Operator Toolbar in Firefox, we can see that this event is on our page. We can work with it in several ways:

If I choose to export it to Google Calendar, it perfectly carries over the values we have set.

For more about hCalendar, check out the hCalendar documentation,

hCard

Let’s move on to hCard; hCard is a lot more complicated than hCalendar, but we won’t get into all the details. If you want to read more later, check out the docs.

Again, we start with our root:

<div class="vcard">
</div>

For hCard, there are only two required properties; the name (n) and the formatted name (fn). Usually, there are the same element.

<div class="vcard">
	<p class="fn n">John Doe</p>
</div>

Without going too deep, I’ll note that this format implies that ‘John’ is the first name and ‘Doe’ is the last name. If you want to specify this, you can use the given-name and family-name classes:

<span class="given-name">John</span>
<span class="family-name">Doe</span>

Of course, you’ll usually want to add more than just your name. You can add a nickname, photo, email address, birthday, url, telephone number, and address, just to name a few.

<p class="nickname">JayDee</p>
<img src="http://www.johndoe.com/avatar.jpg" class="photo" />
<ul>
	<li class="email"><span class="type">Personal:</span> <span class="value">johndoe@gmail.com</span></li>
	<li class="email"><span class="type">Work:</span> jdoe@example.com</li>
</ul>
<ul>
	<li class="tel"><span class="type">Home</span>: <span class="value">(416) 123-4567</span></li>
	<li class="tel"><span class="type">Work</span> 416-987-6543</li>
</ul>
<p class="bday">January 1, 1980</p>
<a href="http://www.johndoe.com" class="url">My Website</a>
<address class="adr">
	<p class="street-address">123 Main Street</p>
	<p><span class="locality">Toronto</span>, <span class="region">Ontario</span> <span class="postal-code">M2W 4R5</span></p>
	<p class="country">Canada</p>
</address>

There are a few things to note here:

• All the class names I’ve used here are the hCard properties.
• Some properties, like url and photo, take their values from the href or src attributes, and not the text of the element.
• Properties like tel and email can have two child properties: type and value. If only type is defined, value will be implied (as you can see in the second email address and telephone number).

Using Operator, I can export this as a vcard …

… and open it in Outlook.

See? Everything we defined is here!

xFolk

xFolk is a developing microformat for open social bookmarks. From the docs:

Lack of an open, interoperable data standard is a major issue in using social bookmarking services. An open standard would make it possible to easily collect social bookmark data and remix it to invent new services … An open standard would also make it possible to write JavaScripts that work across services as some currently do for del.icio.us, enabling across-the-board improvements in user experience.

To implement xFolk, start by giving each bookmark wrapper a class of ‘xfolkentry’:

<li class="xfolkentry">
</li>

Then, insert the link and a description, giving them classes of ‘taggedLink’ and ‘description’, respectively.

<a class="taggedlink" href="http://net.tutsplus.com" title="Nettuts+">Nettuts</a>,
<span class="description">the best web development blog on the planet</span>.

Yup, simple; I can imagine this being useful on a blog roll, or in a web roundup. Think of a tool that would let you bookmark all of these links at once.

XFN (XHTML Friends Network)

XFN is a simple way to mark up human relationships. Using the rel attribute (which is short for relationship) on your links, you define your relationship with the owner of the page you’re linking to. You can have a relationship with two parties: other people or yourself (well, your other pages). It’s easy to define other pages you own:

<a rel="me" href="http://JohnDoe.posterous.com">My Posterous</a>
<a rel="me" href="http://www.flickr.com/JohnDoe">My Photos</a>
<a rel="me" href="http://twitter.com/JohnDoe">My Tweets</a>

Pretty simple, eh? rel=”me” and you’re done.

Relationships with other people are a bit more detailed, but no more difficult: There are six categories you can take options from: friendship, physical, professional, geographical, family, romantic. I won’t list them all here (a good idea would be to try the link creator), but here are a few examples:

<ul>
	<li><a href="#" rel="met friend">Good friend</a></li>
	<li><a href="#" rel="met muse spouse sweetheart">Darling wife</a></li>
	<li><a href="#" rel="met acquaintance neighbour">Guy next door</a></li>
	<li><a href="#" rel="friend co-worker">Co-worker at Envato</a></li>
</ul>

In the first link, you can tell from the rel attribute that I’ve met the owner of the page I’m linking to and that I am his friend. Next is my (hypothetical) wife, who happens to be my spouse and sweetheart, as well as someone who I have met and who inspires me. I’ve also met the guy next door, but he’s only an acquaintance and neighbor. Finally, although my (again, hypothetical) Co-worker is a friend, notice that I’ve never met him; this would be described as a virtual relationship. I should point out that you shouldn’t use XFN when just linking to a blog post or the like; use it when you’re directly referring to a person, so there name is the text of the link, and the href goes to their home page.

VoteLinks

VoteLinks is an interesting idea: when you link to an article, posting, product, anything, add the rev attribute. Rev? Rev is the opposite of rel; while rel describes what the linked page is to current page (like a ‘friend’ or a ’stylesheet’), rev describes what the current page is to the linked one. With VoteLinks, you can make your page a ‘vote-for’, ‘vote-against’, or ‘vote-abstain’ whatever you are linking to. So, for example:

<p>Check our <a href="#" rev="vote-for">this great blog post by Collis</a> on the netsetter</p>

<p>I got terrible service at <a href="#" rev="vote-against">the Five Seasons Grill</a> last night</p>

<p>What do I think of <a href="#" rev="vote-abstain">his site redesign</a>? </p>

How is this useful? Well, imagine if Google (and other search engines) took VoteLinks into account when displaying items. Currently, their system (put very basically) is the more links, the more visibility on Google. But what if most of those links were votes against the product or page? Or how about a site that crawls the web looking for VoteLinks and shows you the general popularity of pages? It’s all very speculative, but it could be interesting. The problem is, a lot of people need to be using VoteLinks for them to have any effect.

Geo

Geo is very simple; it has two properties: latitude and longitude.

<p class="geo"><strong>Apple :</strong>
	(<span class="latitude">37.33171397409807</span>
	<span class="longitude">-122.03051626682281</span>)
</p>
<p class="geo"><strong>Envato :</strong>
	<abbr class="latitude" title="-37.812528">-37&deg; 48' 45.1008"</abbr>
	<abbr class="longitude" title="144.969076">144&deg; 58' 8.6736"</abbr>.
</p>

As we’ve seen before, you can use the abbr element to mask the real values. And of course, Operator recognizes these.

rel-license

If you’ve ever released anything to the public, you know you need to put a license on it. You can give the rel attribute of a link the value of ‘license’ when linking to the license documentation.

<a href="http://creativecommons.org/licenses/by/2.0/" rel="license">cc by 2.0</a>

What’s the point? Already Yahoo Creative Commons Search and Google Usage Right’s Search both use the rel=’licence’ attribute in their algorithms.

rel-tag

This is an interesting one, because every blogger tags their posts. For this microformat, simply add rel=”tag” to your tag links and be done. Now, using our Operator add-on, we can see content from other sites with the same tags. It’s important to note that the name of the tag is taken from the href of the link, and not the text of the link. So in the following example …

<a href="http://www.example.com/tag/javascript>Client-Side Scripting</a>

… the tag is ‘javascript’ and not ‘client-side scripting.’

Nettuts has implemented this microformat; but you already knew that if you have Operator!

rel-nofollow

Another simple but hopefully effective tag: adding rel=”nofollow” to a link is designed to keep the link from having any affect on your page’s ranking in search engines. Of course, the search engine has to implement this, and Google, Yahoo, and Bing already have. It would be ideal to add this to any links in blog comments, so that they wont’ affect your site, and won’t get any credit for their own.

So, What are you going to do?

We’ve briefly covered a healthy number of microformats; but the question remains: are they worth your time? Not until you start using them! Microformats are made to make page scraping for data easier, but until they’re widely used, there won’t be very many tools for them. Although a lot of these may seem pointless now, hopefully they will be everywhere in a few years. When that happens, the tools to make use of them will be available. Microformats are definitely worth your time: so easy, so inexpensive, so potentially powerful.

Will you implement microformats into your sites?

I’ve hidden a microformat in this tutorial; can you find it?

• Follow us on Twitter, or subscribe to the Nettuts+ RSS Feed for the best web development tutorials on the web.

Go to Source

This is why there are certain techniques that help designers group content and show it only if the user is interested in what you have to offer and interacts with the page.

Today we are making a simple, yet eye-catching accordion with the help of CSS, jQuery and the easing plug-in for some fancy effects.

You can go ahead and download the demo files before we continue with step one.

Step 1 – XHTML

As you can see from the demo, the accordion is divided into four sections, each defined by a LI element with a class name of menu. They are positioned inside the main unordered list (ul.container) and share a common XHTML structure:

demo.html

<li class="menu"> <!-- This LI is positioned inside the main UL -->

<ul> <!-- This UL holds the section title and content  -->

<!-- The click-able section title with a unique background: -->
<li class="button"><a href="#" class="green">Kiwis <span></span></a></li>

<!-- The dropdown list, hidden by default and shown on title click: -->
<li class="dropdown">

<ul> <!-- This list holds the options that are slid down by jQuery -->

<!-- Each option is in its own LI -->
<li><a href="http://en.wikipedia.org/wiki/Kiwifruit">Read on Wikipedia</a></li>
<li><a href="http://www.flickr.com/search/?w=all&amp;q=kiwi&amp;m=text">Flickr Stream</a></li>

</ul> <!-- Closing the elements -->

</li>
</ul>

</li>

Each menu LI contains another UL, which forms a title area (li.button), and a content area (li.dropdown).

We then have an anchor element positioned inside  li.button (button being the assigned class name) . This hyperlink is later bound to a jQuery event handler, which slides open the section’s drop down list once the link is clicked.

It is also worth noting that the dropdown list elements are hidden by default with the display:none CSS property as you will see in a moment.

The accordion explained

Step 2 – CSS

If styled properly, even the simplest idea can make a big difference in the overall feeling your site gives to the visitors.

It is important to take extra care so that the CSS code you produce is valid and that it works well across different browsers. I’ve included all the styles used in the demo below:

demo.css – part 1

body{
	/* Setting default text color, background and a font stack */
	color:#cccccc;
	font-size:13px;
	background: #302b23;
	font-family:Arial, Helvetica, sans-serif;
}

ul{
	margin:0;
	padding:0;
}

ul.container{
	/* The main UL */
	width:240px;
	margin:0 auto;
	padding:50px;
}

li{
	list-style:none;
	text-align:left;
}

li.menu{
	/* The main list elements */
	padding:5px 0;
	width:100%;
}

li.button a{
	/* The section titles */
	display:block;
	font-family:BPreplay,Arial,Helvetica,sans-serif;
	font-size:21px;
	height:34px;
	overflow:hidden;
	padding:10px 20px 0;
	position:relative;
	width:200px;
}

Here we style the main UL – ul.container, which holds the rest of the elements. Lastly, we define the looks of the hyperlinks that act as section titles (notice that the actual background images are not yet assigned).

demo.css – part 2

li.button a:hover{
	/* Removing the inherited underline from the titles */
	text-decoration:none;
}

li.button a span{
	/* This span acts as the right part of the section's background */
	height:44px;
	position:absolute;
	right:0;
	top:0;
	width:4px;
	display:block;
}

/* Setting up different styles for each section color */

li.button a.blue{background:url(img/blue.png) repeat-x top left; color:#074384;}
li.button a.blue span{ background:url(img/blue.png) repeat-x top right;}

li.button a.green{background:url(img/green.png) repeat-x top left; color:#436800;}
li.button a.green span{ background:url(img/green.png) repeat-x top right;}

li.button a.orange{background:url(img/orange.png) repeat-x top left; color:#882e02;}
li.button a.orange span{ background:url(img/orange.png) repeat-x top right;}

li.button a.red{background:url(img/red.png) repeat-x top left; color:#641603;}
li.button a.red span{ background:url(img/red.png) repeat-x top right;}

/* The hover effects */

li.button a:hover{ background-position:bottom left;}
li.button a:hover span{ background-position:bottom right;}

.dropdown{
	/* The expandable lists */
	display:none;
	padding-top:5px;
	width:100%;
}

.dropdown li{
	/* Each element in the expandable list */
	background-color:#373128;
	border:1px solid #40392C;
	color:#CCCCCC;
	margin:5px 0;
	padding:4px 18px;
}

The most interesting part here is how we specify the individual background property for every section color. We also provide a background for the span element, which holds the right part of the background image, as explained in the illustration below.

The buttons

Step 3 – jQuery

After we’ve laid the layout of the accordion, it is time to make it tick. First we need to include a few scripts in the page (this code is put inside the head section of the document):

<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js"></script>
<script type="text/javascript" src="jquery.easing.1.3.js"></script>
<script type="text/javascript" src="script.js"></script>

We first include the jQuery library from Google’s CDN, which will help us write compact and compatible code. Later we include the easing plugin and lastly our own script file, which I’ve covered in detail below.

As you may have noticed from the demo, the slide down effect is not your regular linear movement, but more bounce-like and lively. This is achieved with the help of the easing plug-in for jQuery. It provides a number of interesting effects which can put those lovely details in your web design.

Now lets continue with our own scripts file.

script.js

$(document).ready(function(){
	/* This code is executed after the DOM has been completely loaded */

	/* Changing thedefault easing effect - will affect the slideUp/slideDown methods: */
	$.easing.def = "easeOutBounce";

	/* Binding a click event handler to the links: */
	$('li.button a').click(function(e){

		/* Finding the drop down list that corresponds to the current section: */
		var dropDown = $(this).parent().next();

		/* Closing all other drop down sections, except the current one */
		$('.dropdown').not(dropDown).slideUp('slow');
		dropDown.slideToggle('slow');

		/* Preventing the default event (which would be to navigate the browser to the link's address) */
		e.preventDefault();
	})

});

We first set the easing method that is going to be used by the slideUp/slideDown effects, and then bind a specially crafted function to the click event of the li.button hyperlink. When this link is clicked, we get the corresponding li.dropDown and show it, hiding all the others.

I am using the slideToggle jQuery method, which checks to see if the element is already visible on the page, and decides whether to show or hide it. This way, when you click on an open section of the accordion, it is contracted instead of just staying opened.

After this, we use e.preventDefault() to prevent the browser from navigating away from the page (after all we’ve just clicked a link and this is the normal behavior).

With this our fruity CSS & jQuery accordion is complete!

A CSS & jQuery accordion

Conclusion

This time we created a fresh accordion script that is both easily modifiable end embeddable.

Can you think of any awesome uses of this script?

How would you like to change it?

Go to Source

Chris Coyier authored a post titled Better Pull Quotes: Don’t Repeat Markup a while back. In his post he created great-looking pull quotes without repeating any content — instead he uses jQuery to dynamically create the pull quotes. The following is the MooTools method for doing so.

The HTML

<p><span class="pull-me">As a MooTools "insider", however, I'm excited for what the MooTools team will bring to the table during 2010.</span> We'll be launching the Forge (our public plugin repository), releasing MooTools 2, continuing to grow MooTools More, featuring more community work, and much more. MooTools FTW!</p>

The HTML above features a paragraph of content with a SPAN tag wrapping what I’d like to be the pull quote.

The CSS

.quote { padding:20px; margin:0 0 20px 20px; font-size:20px; font-style:italic; background:#eee; color:#999; display:block; width:200px; float:right; }

You may style the quote any way you’d like. These elements are traditionally large in text with italicized text and a different background color.

The MooTools Javascript

window.addEvent('domready',function() {
	//grab all quotes
	$$('span.pull-me').each(function(span) {
		//inject styled quote into page
		new Element('span',{
			'class': 'quote',
			text: span.get('text')
		}).inject(span.getParent(),'top');
	});
});

We find each element with a “pull-me” CSS class and generate a new element with our “quote” class. We then inject the new element into the original element’s parent. That’s all!

Chris did a great job with the execution of his idea. This is a technique that will likely be used well into the future.

Don’t forget to follow me on Twitter and be sure to visit Script & Style for the best Javascript and CSS articles around!

Sponsor the David Walsh Blog and get your brand in front of several thousand users per day!

Better Pull Quotes with MooTools

Related posts:

1. Highlight Table Rows, Columns, and Cells Using MooTools 1.2.3
2. Bold Web Predictions for 2010
3. MooTools HTML Police: dwMarkupMarine
4. Method Chaining in MooTools and PHP
5. dwImageProtector Plugin for jQuery

Go to Source

In previous tutorials we have learned some techniques on how to convert a design mockup into a complete web-page using xhtml and css, so the following informations will be only a quick review on code. If you want more suggestions on psd-to-html conversion you can take a look at these articles:

• SportNewsPvm Coded, How To Plan A Web Layout For A WordPress Theme
• Create a Nice Web Portfolio Design with a Watercolored Background in Photoshop
• DesignSchool Coded, Free CSS Template With PSD to HTML Tutorial

Below there are the final result of the makingSEO psd-to-html conversion and the link to download the complete CSS Template. Don’t forget, the source files are released under the Creative Common License (CC 3.0 Attribution) also for commercial use.

Final Result, Css Template

Here you can see a preview image and a live demo. You can also download the zip archive with the complete CSS template.

Coding makingSEO

We can partition the layout in five sections: header, down-header, contents, sidebar and footer. Besides we can use two general div, main_container and container. The first to add the top-background and the second to keep in 960 px the segments (header, down header, contents and sidebar).

Now is time for the code. This section of the post will show the essential steps to code the psd template.
In the folder “makingseo” we put in “images” folder and the necessary files: “index.html” and “style.css” and “reset.css” (generally I use the Yahoo! YUI Reset CSS, but in this case we test the reset file included in Blueprint CSS Framework).

Below the complete “reset.css” file (you can optimize it for your needs).

html, body, div, span, object, iframe,
h1, h2, h3, h4, h5, h6, p, blockquote, pre,
a, abbr, acronym, address, code,
del, dfn, em, img, q, dl, dt, dd, ol, ul, li,
fieldset, form, label, legend,
table, caption, tbody, tfoot, thead, tr, th, td {
  margin: 0;
  padding: 0;
  border: 0;
  font-weight: inherit;
  font-style: inherit;
  font-size: 100%;
  font-family: inherit;
  vertical-align: baseline;
}

body {
  line-height: 1.5;
}

table { border-collapse: separate; border-spacing: 0; }
caption, th, td { text-align: left; font-weight: normal; }
table, td, th { vertical-align: middle; }

blockquote:before, blockquote:after, q:before, q:after { content: ""; }
blockquote, q { quotes: "" ""; }

a img { border: none; }

Step 1 – Main Structure

The markup for the main structure (edit “index.html”).

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>makingSEO - Improve Your Business | A free CSS Template | made in PV.M Garage</title>
<link href="reset.css" rel="stylesheet" type="text/css" /><!-- blueprint css reset -->
<link href="style.css" rel="stylesheet" type="text/css" /><!-- css style for makingSEO -->
</head>
<body>

<div id="main_container"><!-- for general background -->
<div class="container clearfix"><!-- to keep in 960 pixels the segments -->

  <div id="header"><!-- here we'll add logo and menu -->
  </div>

  <div id="down_header"><!-- here we'll add slogan, screenshot and call-to action button -->
  </div>

  <div class="contents"><!-- here we'll add the info boxes -->
  </div>

  <div class="sidebar"><!-- here some side informations -->
  </div>

</div><!-- end container -->

<div id="footer"><!-- here the footer -->
</div>

</div><!-- end main_container -->

</body>
</html>

To reproduce background we use the following image.

Below the css rules.

@charset "utf-8";
/* CSS Document */

body {
  background: #f5f5f5;
  font-family: Verdana, Georgia, “Lucida Sans Unicode”, sans-serif;
  font-size: 12px;
  color: #666;
}

/* General */

:focus {
	outline: 0;
}

a {
  text-decoration: none;
}

ul {
	list-style-type:none;
	color: #fff;
}

/* Container */

#main_container {
  background: url("images/bck.jpg") repeat-x top; /* General Background */
}

.container {
  width: 960px; /* here the width for the segments */
  margin: auto;
}

.clearfix:after {
  content: "020";
  display: block;
  height: 0;
  clear: both;
  visibility: hidden;
  overflow: hidden;
}

Step 2 – Header with Logo and Menu

Now we add logo and menu in the header. Below there are the images exported from psd.

Below the (x)html code for header.

<div id="header">
    <div class="logo">
      <h1><a href="#">makingSEO - Improve Your Business</a></h1>
    </div>
    <div class="menu">
      <ul>
        <li><a href="#">Services</a></li>
        <li><a href="#">Tools</a></li>
        <li><a href="#">Strategies</a></li>
        <li><a href="#">Prices</a></li>
        <li><a href="#">Contact Us</a></li>
      </ul>
    </div>
  </div>

And now, the style.

/* Header */

#header {
  height: 156px;
}

.logo {
  float: left;
  background: url("images/light_head.png") no-repeat top left;
  height: 156px;
}

.logo h1 {
  text-indent: -9999px;
  margin-top: 40px;
}

.logo h1 a {
  display: block;
  background: url("images/logo.png") no-repeat top;
  width: 398px;
  height: 61px;
}

.menu ul {
  float: right;
  margin-top: 5px;
  padding-bottom: 10px;
  width: 377px;
  text-align: center;
  background: url("images/dashed_h.png") no-repeat bottom;
}

.menu ul li {
  display: inline;
  padding: 10px 10px 70px 10px;
  background: url("images/dashed_v.png") no-repeat top right;
  margin-left: -5px;
}

.menu ul li a {
  color: #fff;
  padding-bottom: 70px;
}

.menu ul li:hover {
  background: url("images/menu_hov.png") repeat-x top right;
}

Step 3 – Slogan and Screenshot in Down-Header

In Down-Header segment we add a direct slogan, a screenshot of a website that rocks with the help of makingSEO team and a call-to-action button. Below the pictures used to complete this section of the web-page.

Below you can see the html code for the down-header.

  <div id="down_header">
    <div class="d_h_left">
    </div>
    <div class="d_h_right">
      <span class="button"><a href="#"></a></span>
    </div>
  </div>

The style for this segment.

/* Down Header */

#down_header {
   height: 320px;
   padding-top: 25px;
}

.d_h_left {
  float: left;
  width: 520px;
  height: 308px;
  margin-left: -14px;
  background: url("images/screenshot.png") repeat-x top left;
}

.d_h_right {
  float: right;
  width: 450px;
  height: 138px;
  margin: 16px 0 0 4px;
  background: url("images/slogan.png") no-repeat top left;
}

.button a {
  display: block;
  width: 324px;
  height: 70px;
  position: relative;
  top: 145px;
  left: 61px;
  background: url("images/call-but.png") no-repeat 0px -70px;
}

.button a:hover {
  background: url("images/call-but.png") no-repeat 0px 0px; /* CSS Sprites technique for the button*/
}

Step 4 – The Contents

The left side is the core of the web-page in which the visitors have the opportunity to know more about the Company. We use some icones and a soft dashed grid.

We write the html code…

<div class="contents">
    <div class="post_cont">
      <h1 class="top_left"><a href="#">We Study the Best Solutions to Improve Your Visibility</a></h1>
      <p>Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis vitae, justo</p>
    </div>
    <div class="post_cont">
      <h1 class="top_right"><a href="#">In One Month You Could Be in the First Page of Google</a></h1>
      <p>Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim.</p>
      <span class="button_post_g"><a href="#"></a></span>
    </div>
    <div class="post_cont">
      <h1 class="down_left"><a href="#">Organize Your Business with our Experts</a></h1>
      <p>Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet nec, vulputate eget, arcu.</p>
    </div>
    <div class="post_cont">
      <h1 class="down_right"><a href="#">We Study the Best Solutions to Improve Your Visibility</a></h1>
      <p>Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim.</p>
      <span class="button_post_o"><a href="#"></a></span>
    </div>
  </div>

… and the rules for the style of the contents.

/* Contents */

.contents {
  float: left;
  width: 690px;
}

.post_cont {
  width: 310px;
  float: left;
  margin: 0 30px 30px 0;
  background: url("images/dashed_v_g.png") no-repeat right;
  height: 300px;
}

.post_cont h1 a {
  padding-bottom: 0px;
  font-size: 14px;
  color: #424242;
  display: block;
}

.post_cont h1 a:hover {
  color: #d5943f;
}

.post_cont p {
  margin-left: 10px;
  padding: 15px 10px 30px 0;
  background: url("images/dashed_h_g.png") no-repeat top right;
}

h1.top_left a {
  background: url("images/ico_top_left.png") no-repeat left center;
  padding: 20px 5px 20px 85px;
}

h1.top_right a {
  background: url("images/ico_top_right.png") no-repeat left center;
  padding: 20px 5px 20px 70px;
}

h1.down_left a {
  background: url("images/ico_down_left.png") no-repeat left center;
  padding: 20px 5px 20px 72px;
}

h1.down_right a {
  background: url("images/ico_down_right.png") no-repeat left center;
  padding: 20px 5px 20px 72px;
}

span.button_post_g a, span.button_post_o a {
  display: block;
  width: 256px;
  height: 46px;
  position: relative;
  top: -10px;
  left: 83px;
}

span.button_post_g a {
  background: url("images/call-but-post.png") no-repeat right top;
}

span.button_post_o a {
  background: url("images/call-but-post_o.png") no-repeat right top;
}

Step 5 – The Sidebar

Side informations for our page. Below the (x)html code and the style.

  <div class="sidebar">
    <div class="sidecont">
      <h2>Side Info</h2>
      <p>Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.</p>
    </div>
    <div class="sidecont">
      <h2>Blog Posts</h2>
      <ul>
        <li><a href="#">Donec quam felis, ultricies nec, pellentesque eu.</a><span class="side_meta_info">posted by piervix - 12.08</span></li>
        <li><a href="#">Donec quam felis, ultricies nec, pellentesque eu.</a><span class="side_meta_info">posted by piervix - 12.08</span></li>
        <li><a href="#">Donec quam felis, ultricies nec, pellentesque eu.</a><span class="side_meta_info">posted by piervix - 12.08</span></li>
        <li><a href="#">Donec quam felis, ultricies nec, pellentesque eu.</a><span class="side_meta_info">posted by piervix - 12.08</span></li>
      </ul>
    </div>
    <div class="sidecont">
      <h2>Working on...</h2>
       <p>Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem.</p>
      <a href="#"><img src="images/img_side.jpg" alt="" /></a>
    </div>
  </div>

We update the “style.css” files with this lines of code.

/* Sidebar */

.sidebar {
  float: right;
  margin-top: -50px;
  width: 220px;
  background: #fff;
  border: 1px solid #dcdcdc;
  -moz-border-radius: 10px;
  -webkit-border-radius: 10px;
}

.sidecont {
  margin: 18px 10px;
  font-size: 11px;
}

.sidecont img {
  margin-top: 10px;
  border: 3px solid #bdbdbd;
  -moz-border-radius: 3px;
  -webkit-border-radius: 3px;
}

.sidecont h2 {
  font-size: 18px;
}

.sidecont p, .sidecont ul li {
  padding-top: 7px;
}

.sidecont ul li a {
  display: block;
  font-weight: bold;
  color: #666;
}

.sidecont ul li a:hover {
  color: #d5943f;
}

.side_meta_info {
  color: #d5943f;
}

Step 6 – The Footer

This segment isn’t included in the main-container div, this for adding the background in the right way. Take a look at the images used.

Finally the code for the footer and the credits.

<div id="footer">
  <div class="foot_info">
    <div class="foot_col_l_c">
      <h2>Our Tweets <a href="#">/ Follow Us</a></h2>
      <ul>
        <li><a href="#"><strong>@virtuosoblogger</strong> 400+ Beautifully Designed Twitter Icons http://ow.ly/oBb6</a></li>
        <li><a href="#"><strong>@bkmacdaddy</strong> Bit.ly lowers the bar on URL shortening - http://bit.ly/cMBAc</a></li>
        <li><a href="#"><strong>@gaksdesigns</strong> Retro Design and Typography http://bit.ly/1TRunk</a></li>
      </ul>
    </div>
    <div class="foot_col_l_c">
      <h2>Work in progress</h2>
      <ul class="foot_center">
        <li class="foot_ico_1"><a href="#">Sed ut perspiciatis unde omnis iste natus error sit </a></li>
        <li class="foot_ico_2"><a href="#">At enim ad minima veniam, quis nostrum</a></li>
        <li class="foot_ico_3"><a href="#">At vero eos et accusamus et iusto odio dignissimos ducimus qui</a></li>
      </ul>
    </div>
    <div class="foot_right">
      <h2>Work in progress</h2>
      <ul>
        <li><a href="#"><img src="images/img1.jpg" alt="" /></a></li>
        <li><a href="#"><img src="images/img2.jpg" alt="" /></a></li>
        <li><a href="#"><img src="images/img3.jpg" alt="" /></a></li>
        <li><a href="#"><img src="images/img4.jpg" alt="" /></a></li>
      </ul>
    </div>
  </div>
  <div id="credits">
    <p><a href="#">makingSEO</a> is released under a <a href="#"><em>Creative Common License</em></a> also for Commercial Use. We hope you'll support <a href="#">PV.M Garage</a>, it is an awesome place for sharing!</p>
  </div>
</div>

We update the CSS file with the following rules.

/* Footer */

#footer {
  background: url("images/bck_foot.jpg") repeat-x top; /* general background for footer */
}

.foot_info {
  margin: auto;
  width: 960px; /* keep in 960 pixels the footer contents */
}

.foot_col_l_c {
  width: 285px;
  float: left;
  margin: 20px 35px -30px 0px;
  padding: 0px 10px 0px 10px;
  height: 300px;
}

.foot_info h2 {
  font-size: 20px;
  color: #fff;
  margin-bottom: 6px;
  padding: 8px 0px;
  background: url("images/dashed_f.png") no-repeat center bottom;
}

.foot_info h2 a {
  color: #306e8f;
  background: url("images/ico_foot.png") no-repeat top right;
  padding: 10px 45px 10px 0;
}

.foot_info h2 a:hover {
  color: #fff;
}

.foot_col_l_c ul li {
  padding: 8px 0px;
  background: url("images/dashed_f.png") no-repeat center bottom;
}

.foot_col_l_c ul li a {
  color: #fff;
  display: block;
}

.foot_col_l_c ul li a:hover {
  color: #c3dd6c;
}

ul.foot_center li a:hover { /* change hover color */
  color: #d5943f;
}

li.foot_ico_1 a {
  padding-right: 50px;
  margin-right: 11px;
  background: url("images/ico_foot_1.png") no-repeat center right;
}

li.foot_ico_2 a {
  padding-right: 50px;
  margin-right: 8px;
  background: url("images/ico_foot_2.png") no-repeat center right;
}

li.foot_ico_3 a {
  padding-right: 50px;
  margin-right: 12px;
  background: url("images/ico_foot_3.png") no-repeat center right;
}

.foot_right {
  width: 221px;
  float: right;
  margin-top: 20px;
}

.foot_right ul {
  background: url("images/foot_img_bck.png") no-repeat top left;
  margin-left: 5px;
}

.foot_right ul li {
  display: inline;
}

.foot_right img {
  border: 3px solid #fff;
  -moz-border-radius: 3px;
  -webkit-border-radius: 3px;
  margin: 10px 20px 8px 0px;
}

#credits {
  clear: both;
  margin-bottom: 10px;
}

#credits p {
  width: 600px;
  text-align: center;
  margin: auto;
}

#credits p a {
  font-weight: bold;
  color: #666;
  width: 600px;
  text-align: center;
  margin: auto;
  font-size: 11px;
}

#credits p a:hover {
  border-bottom: 1px dotted #666;
}

Conclusions

Yes, this layout is released under the Creative Common License (CC 3.0 Attribution) also for commercial use and you can copy, edit, sell, eat, drink, re-publish it. Remeber it is only a basic xhtml and css template if you have some ideas on how to improve the layout, please share them through the comments (e.g. maybe a slideshow for the screenshit section could be a good solution, but can it save the worls?).

The template has been tested on IE8, Firefox 3.5, Opera and Safari. It have a valid XHTML code.

Thanks fo reading dear friends!

PSD to HTML Services Sponsored on PV.M Garage

I’m sure! You have the necessary skill to convert a PSD mockup in a wonderful website, but if you have many projects in progress you could consider a PSD to HTML Service.

Pixel Crayons

XHTML.pixelcrayons.com (a specialized division of Pixelcrayons) offers high quality hand coded pixel-precise markup services and implementation into skins, themes, CMS, shopping carts and more. They accept files in all common formats (PSD/AI/PNG/PDF) and even existing markup.

Their online Order page details various markup packages offered along with a variety of options for markup and software implementation.

Rapid XHTML

RapidxHTML is a small team of designers and developers, with a wide range of skills and experience. Each of us know our strengths and weaknesses and how these fit into the big picture.

XHTML Chop

XHTML Chop is a team of experienced web design and web programming professionals. They specialize in providing the state-of-the-art PSD to HTML conversion services. they have a talented team that is capable of handling all types of conversion requirements.

XHTMLiT

XHTMLiT service is simple! They are W3C Web Standards experts and they have been building and coding website for over 5 years now. XHTMLiT provide coding services to designers, taking the dirty job away so you can do what you are best at, Design!

Go to Source

The following screenshot shows what we’ll have at the end of the tutorial:

Getting Started

The latest version of jQuery comes with jQuery UI and in this example we only need the core, draggable and droppable components, so make sure only these are selected in the download builder. Once the jQuery UI archive has been downloaded, unpack the js folder from the archive (we don’t need the development bundle or CSS framework in this example) in a working folder.

Now let’s create a basic page, with some text and an image on it, to showcase the behaviour; create the following new page in your code editor:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>Drag to Share Example</title>
    <link rel="stylesheet" type="text/css" href="dragToShare.css">
  </head>
  <body>
    <div id="content">
      <p>Lorem ipsum dolor...</p>
      <img src="rover.png" alt="Mars Rover">
      <p>Lorem ipsum dolor...</p>
    </div>
    <script type="text/javascript" src="js/jquery-1.3.2.min.js"></script>
    <script type="text/javascript" src="js/jquery-ui-1.7.2.custom.min.js"></script>
  </body>
</html>

Save this as dragToShare.html in the folder with the js folder in it. Here we’ve added our layout/example text and an image, both within a container. We’re linking to the jQuery and jQuery UI source files at the bottom of the <body> and a custom style sheet in the <head>. We don’t need many styles at this point as there isn’t much on the page to actually style, but let’s add it next anyway with some basic styles for the page elements in it; in a new file in your code editor add the following:

#content { width:440px; }
#content img { float:right; margin-left:20px; }

Save this tiny file as dragToShare.css in the same folder as our HTML page. Don’t worry, we’ll be adding some more styles to the style sheet very shortly. Our example page should look like this at this point:

Making the Image Draggable

We need to make the image draggable, which we can do with jQuery UI, add the following <script> element after the others:

<script type="text/javascript">
  $(function() {

    var images = $("#content img"),
      title = $("title").text() || document.title;

    //make images draggable
    images.draggable();
  });
</script>

That’s all we need to do! We just cache the selector for the element(s) that we’d like to make draggable, and call the draggable() method on the resulting collection of elements. Now by clicking and holding the mouse button, the image in our example can be dragged around the page. The image will be made draggable as soon as the document is loaded as our code is wrapped in the $(function(){}) shortcut.

As well as caching the selector that returns our images, we’re also caching a selector that stores the title of the page. IE returns an empty string when using jQuery to retrieve the page title so we revert to document.title in this case.

We still have a lot to do before we’re done though; what we need to do first is to let the visitor know that dragging the image does something. Firstly we can use a little CSS to set the ‘move’ mouse pointer when we hover over the image; add the following line to the end of dragToShare.css:

.ui-draggable { cursor:move; }

We’re targeting the class .ui-draggable which is added by jQuery UI with this style so that the image will only inherit the move cursor if the image is made draggable, which won’t happen if JavaScript is switched off or otherwise unavailable. Using the class name instead of the :hover pseudo class is also much better for cross-browser compatibility.

Information Overlay

To really make it obvious that dragging the image does something, we can also add a tooltip to explicitly tell the visitor what to do; after the draggable() method add the following new code:

var createTip = function(e) {
  //create tool tip if it doesn't exist
  ($("#tip").length === 0) ? $("<div>").html("<span>Drag this image to share the page<\/span><span class='arrow'><\/span>").attr("id", "tip").css({ left:e.pageX + 30, top:e.pageY - 16 }).appendTo("body").fadeIn(2000) : null;
};

images.bind("mouseenter", createTip);

images.mousemove(function(e) {

  //move tooltip
  $("#tip").css({ left:e.pageX + 30, top:e.pageY - 16 });
});

images.mouseleave(function() {

  //remove tooltip
  $("#tip").remove();
});

We’ve basically added three new event handlers to our code; the first event handler is the createTip function, which is defined as a variable and passed to jQuery’s bind() method along with the string mouseenter specifying the event. The next two functions are anonymous and are passed inline to jQuery’s mousemove() and mouseleave() helper methods.

In the createTip function we first check whether the tooltip already exists by seeing if a selector for it has a length of 0. If it does (have a length of 0) we know it doesn’t exist and can then create it. We set the innerHTML of the tooltip so that it features a span containing the message to the visitor, and a second empty span which we’ll use for a little decoration when we add the additional CSS in a moment.

We give the tooltip an id so that we can select it efficiently later on and set its CSS left and top properties using the pageX and pageY properties from the event object (e) which is passed to our function automatically. We then append the tooltip to the body of the page and fade it in slowly. To avoid HTML errors, we need to escape the forward-slashes in the raw HTML we add to the tooltip.

The mousemove function is used to make the tooltip track with the pointer, so when the pointer moves, the tooltip moves with it. We use the css method again as well as the pageX and pageY properties. Finally, the mouseleave function simply removes the tooltip from the page.

Styling the Tooltip

Now we can add some CSS for our tooltip; in the interests of progressive enhancement we’ll use the sexy CSS3 rgba style to make out tooltip semi-transparent in capable browsers; at the bottom of dragToShare.css add the following new selectors and rules:

#tip {
  position:absolute; display:none; height:25px; padding:9px 9px 0px;
  color:#fff; font-family:Verdana, Arial, Helvetica, sans-serif;
  font-size:11px; font-weight:bold; border-radius:4px;
  -moz-border-radius:4px; -webkit-border-radius:4px;
  background:#000; background:rgba(0,0,0,.5);
}
#tip .arrow {
  width:0; height:0; line-height:0; border-right:8px solid #000;
  border-right:8px solid rgba(0,0,0,.5); border-top:8px solid transparent;
  border-bottom:8px solid transparent; position:absolute; left:-8px;
  top:9px;
}

That’s all we need. Most of the styles are pretty basic but we use the border-radius styles to give the tooltip rounded corners in gecko and webkit browsers, and as I mentioned before we use rgba to make the tooltip semi-transparent. This is a great effect and while it’s only supported in a few of the common browsers, it’s much more efficient than using an alpha-transparent PNG.

The empty span that we added to the tooltip is styled so that it looks like a speech-bubble arrow pointing to the mouse pointer. This is created using the CSS-shapes technique and as it’s not CSS3 it’s supported in most browsers. It’s even supported in IE6, although the border transparency that we give it isn’t supported. We could fix this easily enough if we really wanted to, but for the purposes of this tutorial I’m not going to deviate to this topic.

Note that we also use rgba for the border-color of our span so that it blends in with the rest of the tooltip. Now, IE (any version) is not going to support these rgba styles, but as we have provided normal colors before the rgba declarations, in both the tip and the span, the tooltip will just appear solid black in IE. Here’s how our tooltip will appear at its best, beautiful isn’t it?

Adding the Drop Targets

Ok, so our visitors now know that they can drag the image somewhere in order to share the page, but where do they drag it to? And where can they share it? We now need to react to the image being dragged and show the drop targets, which will consist of a series of links to social networking sites. We’ve several things we need to do here; we need to add an overlay to the page and create the drop targets first of all.

We could create the drop targets entirely from scratch, on the fly, with jQuery like we did with the tooltip, but out in the wild this would probably result in an unacceptable delay for some visitors. We can minimise this by adding the underlying mark-up for the drop targets to the page, and just showing it when we need to. Directly before the <script> elements at the bottom of the page, add the following code:

We use a simple unordered list as the container for the drop targets where each item corresponds to a single target; I’ve included the social networking sites that I have accounts for, feel free to add more if you wish. Each list item contains a link with its href set to the home page of the social networking site that it represents. We’ll need to modify these URLs later in our script, and while more information could be provided in these links, I thought it cleaner to just provide the basic URL in the mark-up.

We need to style these now as well; add the following new styles to the bottom of our style sheet:

#targets {
  display:none; list-style-type:none; position:absolute; top:10px;
  z-index:99999;
}
#targets li {
  float:left; margin-right:20px; display:block; width:60px; height:60px;
  background:url(iconSprite.png) no-repeat 0 0; position:relative;
}
#targets li#delicious { background-position:0 -60px; }
#targets li#facebook { background-position:0 -120px; }

The outer list container is initially hidden from view so that we can show it when a drag begins. We disable the default icon for list items (a small circle) and position it absolutely at the top of the page. As we want the icons to be visible above the overlay, we set a high z-index on it.

The list items are floated so that they stack up next to each other horizontally and are spaced out with a little margin. The images are set on the list items so an appropriate size is set for them. We’re using a sprite file for the images so we need to set the background position of the delicious and Facebook icons.

Note: the icons used in this example came from the Social.me icon pack by jwloh and are available from here. They aren’t visible yet, but with the CSS we just added they should look something like this:

Wiring up the Drag Behavior

At this point, we’ve got out drop targets in place ready to be shown so we now need to set some of draggable’s configuration options in order to add the overlay and show the drop targets when a drag begins. We can also create a helper element that will be dragged instead of the underlying <img>. Change the draggable() method so that it appears as follows:

//make images draggable
images.draggable({
  //create draggable helper
  helper: function() {
    return $("<div>").attr("id", "helper").html("<span>" + title + "</span><img id='thumb' src='" + $(this).attr("src") + "'>").appendTo("body");
  },
  cursor: "pointer",
  cursorAt: { left: -10, top: 20 },
  zIndex: 99999,
  //show overlay and targets
  start: function() {
    $("<div>").attr("id", "overlay").css("opacity", 0.7).appendTo("body");
	$("#tip").remove();
	$(this).unbind("mouseenter");
	$("#targets").css("left", ($("body").width() / 2) - $("#targets").width() / 2).slideDown();
  },
  //remove targets and overlay
  stop: function() {
    $("#targets").slideUp();
    $(".share", "#targets").remove();
    $("#overlay").remove();
    $(this).bind("mouseenter", createTip);
  }
});

We’ve added an object literal as an argument to the draggable() method containing a series of configuration options; let’s look at each option in detail:

helper

We supply an anonymous function as the value of the helper option; the function must return an element, so we create a new div element, give it an id and insert a string of raw HTML. The HTML we insert creates a new span element containing the title of the page. We also create a new image. The image will act as a thumbnail; again we give it an id for styling purposes and set its src attribute to the src of the original image.

cursor

We set the cursor option to pointer so that an action pointer is shown while the drag is in progress.

cursorAt

We use another object literal with the cursorAt option to position where on the drag helper the icon appears. We set the left and top properties of the object to the pixel values. The values we supply set the cursor so that it appears -10px to the left of the helper, and 20 pixels into it.

zIndex

We set the z-index of the helper element using the zIndex option, which sets the style directly on the element as an inline style. This forces the helper above the overlay, and is required because the overlay is inserted after the helper.

start

This option is one of the draggable component’s built-in event handlers; whenever a drag interaction starts the function we supply as a value to this option is executed. Within this function we create the overlay and append it to the page, remove the tooltip and stop the current image displaying it again, and then position the targets in the center of the viewport before showing them with a nice slideDown animation.

stop

The stop option is another of draggable’s built-in event handlers and is called when the drag stops. All we do here is tidy up, removing the overlay and any text that has been added, sliding up the targets, and rebinding the createTip function to the mouseenter event.

So with these options configured, when we begin dragging the image several things will happen; first of all the overlay will be displayed which will grey out the rest of the page. We also remove the tooltip and prevent it from displayed again if the mouse pointer enters the image again. In most browsers this isn’t a problem – the pointer isn’t considered ‘over’ the image because it’s on top of the drag helper. But IE (even version does consider it over the image still and displays both the helper and the tooltip.

Our helper element, which will be dragged instead of the original image, will also be created and displayed, showing the page title as a label, and a thumbnail version of the original image. The drop targets will also be shown with a nice animation.

At this stage, we need to provide a little CSS for the helper element, thumbnail and the overlay; add the following selectors and rules to the bottom of dragToShare.css:

#overlay {
  background-color:#000; position:absolute; top:0; left:0; width:100%;
  height:100%; z-index:99997;
}
#helper {
  background-color:#c2c2c2; position:absolute; height:35px;
  padding:15px 70px 0 20px; color:#fff;
  font-family:Verdana, Arial, Helvetica, sans-serif; font-weight:bold;
  font-size:18px; border-radius:8px; -moz-border-radius:8px;
  -webkit-border-radius:8px; border:3px solid #7d7d7d;
}
#thumb {
  width:50px; height:50px; position:absolute; right:0; top:0;
  border-left:3px solid #7d7d7d;
}

For the overlay we set the background color to solid black, but remember we use jQuery to make it transparent. It’s positioned and sized to cover the whole page and has its z-index set to just under that of the drag helper and targets.

The helper element has a range of styles set on it to make it presentable. Mostly these are simple everyday styles that don’t warrant discussion, but we do set the border-radius styles here like we did with the tooltip. The height of the helper is fixed, but its width is not, so it will grow or shrink to accommodate all of the alt text from the image that was dragged.

The thumbnail version of the original image is sized and positioned at the far right of the helper. Enough right-padding has been given to the helper element to ensure that the text doesn’t run in to the image. When a drag begins, the page should appear like this:

Making the Targets Droppable

Our final task is to make the target social networking icons to react to having the helper element dropped on to them. We do this using the droppable component of jQuery UI, which we selected when we built our jQuery UI download.

Directly after the draggable method (containing the code we just added) add the droppable method:

//make targets droppable
$("#targets li").droppable({
  tolerance: "pointer",
  //show info when over target
  over: function() {
    $(".share", "#targets").remove();
    $("<span>").addClass("share").text("Share on " + $(this).attr("id")).addClass("active").appendTo($(this)).fadeIn();
  },
  drop: function() {
    var id = $(this).attr("id"),
      currentUrl = window.location.href,
	baseUrl = $(this).find("a").attr("href");

    if (id.indexOf("twitter") != -1) {
      window.location.href = baseUrl + "/home?status=" + title + ": " + currentUrl;
    } else if (id.indexOf("delicious") != -1) {
      window.location.href = baseUrl + "/save?url=" + currentUrl + "&title=" + title;
    } else if (id.indexOf("facebook") != -1) {
      window.location.href = baseUrl + "/sharer.php?u=" + currentUrl + "&t=" + title;
    }
  }
});

Again, we use several different configuration options to tailor the implementation to our needs. The options we use are listed below:

tolerance

The tolerance option is used to set when the drag helper is considered to be over a drop target. We’ve used pointer here so the mouse pointer itself must be over the drop target.

over

We use the over event callback to execute code whenever the drag helper is over a drop target; in this function we first ensure that the element we’re about to create is removed, this is to hide elements that may have been created in a previous drag. We then create a new span element and set its innerText to a message indicating which social network the icon represents.

drop

The drop event callback function is where we actually perform the sharing of the page on whichever social network the visitor dropped the drag helper on. We get the URL of the current page and the URL for the social network from the href of the link in the list item representing the icon. Each of the social networks used in this example are able to accept information via the URL, so for example with Twitter, we can add the text for a status update to the input field on the visitor’s Twitter page, making it easy for the visitor to share the page title and URL. The information to do this is passed in the URL, so starting with the baseUrl we can build the required URL and then navigate to it with the window.location.href property.

We need one line of CSS and then we’re done; to style the share message that we append to the page when the drag helper is over a drop target add the following code:

.share {
  font-weight:bold; position:absolute; font-size:14px;
  font-family:Verdana; margin-left:-38px;
}

We should now find that when we drop the drag helper onto one of the icons, the corresponding page should load with the URL of our page displayed:

Summary

Our work here is done; we can now deploy the code to our web pages to provide an easy way for our visitors to share our content across their social networks. This method is good because it’s easy to implement consisting entirely of client-side code. We don’t need to worry about authentication or anything like that – the visitor will just be prompted to enter their username and password when the external site loads up.

• Follow us on Twitter, or subscribe to the Nettuts+ RSS Feed for more daily web development tuts and articles.

Go to Source

I wrote a post titled Get Slick with MooTools Kwicks ages ago. The post was quite popular and the effect has been used often. Looking back now, the original code doesn’t look as clean as it could. I’ve revised the original Kwicks code so that Kwicks is laid out in the form of a standard MooTools plugin.

The HTML

<div id="kwick">
	<ul id="kwicks">
		<li><a class="kwick john" href="http://en.wikipedia.org/wiki/John_lennon" title="John Lennon"><span>John Lennon</span></a></li>
		<li><a class="kwick paul" href="http://en.wikipedia.org/wiki/Paul_mccartney" title="Paul McCartney"><span>Paul McCartney</span></a></li>
		<li><a class="kwick george" href="http://en.wikipedia.org/wiki/George_harrison" title="George Harrison"><span>George Harrison</span></a></li>
		<li><a class="kwick ringo" href="http://en.wikipedia.org/wiki/Ringo_starr" title="Ringo Starr"><span>Ringo Starr</span></a></li>
	</ul>
</div>

The Kwicks system works based off of an HTML list containing list items with links.

The CSS

#kwick						{ width:590px; }
	#kwicks 				{ height:143px; list-style-type:none; margin:0; padding:0; }
#kwick li 					{ float:left; }
#kwick .kwick 				{ display:block; cursor:pointer; overflow:hidden; height:143px; width:134px; }
#kwick .kwick span 			{ display:none; }

#kwick .john 				{ background:url(kwicks/john.gif) no-repeat; }
#kwick .paul 				{ background:url(kwicks/paul.gif) no-repeat; }
#kwick .george 				{ background:url(kwicks/george.gif) no-repeat; }
#kwick .ringo 				{ background:url(kwicks/ringo.gif) no-repeat; }

The most key of the selectors is “.kwick” which features “overflow:hidden”. Overflow hidden will allow our squeezing of elements.

The MooTools Javascript

var Kwicks = new Class({

	Implements: [Options],

	options: {
		squeezeWidth: 100,
		maxWidth: 285
	},

	initialize: function(list,options) {
		this.setOptions(options);
		this.list = document.id(list);
		this.parse();
	},

	parse: function() {
		//vars
		var items = this.list.getElements('a'),
			fx = new Fx.Elements(items, {wait: false, duration: 250, transition:Fx.Transitions.Cubic.easeOut}),
			startWidths = [],
			options = this.options;
		//kwicks items
		items.each(function(item,i) {
			startWidths.push(item.getStyle('width').toInt());
			item.addEvent('mouseenter',function(){
				var fxSettings = {};
				fxSettings[i] = {
					'width': [item.getStyle('width').toInt(),options.maxWidth]
				};
				items.each(function(sibling,ii) {
					if(sibling != item) {
						var w = sibling.getStyle('width').toInt();
						if (w != options.squeezeWidth) {
							fxSettings[ii] = {
								'width': [w,options.squeezeWidth]
							};
						}
					}
				},this);
				fx.start(fxSettings);
			},this);
		},this);
		//list
		this.list.addEvent('mouseleave',function() {
			var fxSettings = {};
			items.each(function(item,i) {
				fxSettings[i] = {
					width: [item.getStyle('width').toInt(), startWidths[i]]
				};
			});
			fx.start(fxSettings);
		});
	}
});

/* USAGE */
window.addEvent('domready',function() {
	var kwicks = new Kwicks('kwicks');
});

Unlike my original post, this implementation works off of the MooTools Class system. The class is small and features only one real method but the class’ code is also much cleaner than my original implementation!

The Kwicks effect is tasteful, smooth, and attention-grabbing. I recommend adding this to any website that could use a bit of dynamism.

Don’t forget to follow me on Twitter and be sure to visit Script & Style for the best Javascript and CSS articles around!

Sponsor the David Walsh Blog and get your brand in front of several thousand users per day!

MooTools Kwicks Plugin

Related posts:

1. Get Slick with MooTools Kwicks
2. PHP / MooTools 1.2 Accordion Helper
3. Flext: MooTools Auto-Growing Textrea Plugin
4. Six Degrees of Kevin Bacon Using MooTools 1.2
5. MooTools Typewriter Effect Plugin

Go to Source