http://www.cssdrive.com/index.php/menudesigns/category/C20/P0/

Image pure css based drop down menu

http://www.lwis.net/free-css-drop-down-menu/

mtv style

Page loaded with Fade effect

http://jarodtaylor.com/meerkat/demos/demo3.php

creativezone.eyeblaster.com

http://creativezone.eyeblaster.com/

Banner, websites, interactive works showcase

phpform.org

http://www.phpform.org/

pForm – Free HTML Form Builder – Create Web Form Template Online

The web developer’s guide to 3D site building

The ability of the web to deliver 3D content is nothing new: people have been finding ways to create 3D within Flash since ActionScript 1.

But in the last year there’s been a sea-change in terms of the richness and proliferation of 3D content on the web. 3D is here to stay, and it’s time that every web designer and developer sat up and took note. So what’s been happening?

The use of Flash for the delivery of visually rich and immersive content only really opened up with the introduction of AS3 and Flash Player 9. AS3 is a much more robust and powerful programming language than its predecessor and the AVM2 (ActionScript Virtual Machine 2) with Flash Player 9 introduced many advantages.

While there were 3D libraries for AS2, it was with AS3 that open source 3D libraries including Papervision3D and Away3D emerged as a way to bring 3D to Flash with relative ease. Sandy has also developed an AS3 Library plus there’s Alternativa, which is free for non-commercial use.

Flash Player 10

With every version release of the Flash Player, a wealth of new features and possibilities is introduced and Flash Player 10 is no exception. Penetration is sitting at around 75 per cent for most markets, so it shouldn’t be long before publishing for Flash Player 10 will become the norm. Here are a few of the exciting new features it offers to 3D developers.

Native 3D: Until now, 3D hasn’t been a native feature of Flash. And while it will in no way replace the open source 3D libraries, it will offer a superior solution in cases where simple 3D is required. There are no cameras, effects, depth sorting, complex objects or 3D model support.

However, because it’s native it’s very fast and lightweight. For designers who just want simple interactive 3D elements, it offers a whole new range of possibilities. Any display object can now be rotated and animated along the x, y or z axis in 3D space via the Flash IDE or ActionScript.

Pixel Bender: The Pixel Bender toolkit is available free from Adobe. It provides a tool to create, compile and export pixel shaders for use in Flash Player 10 and other CS4 products. Taking various forms of input, the pixel shader is run on every pixel of the input source with the simple task of outputting the value of the pixel after calculations have been performed.

PIXEL BENDER: The Pixel Bender toolkit is used to create shaders that can be used within Flash to create filters and effects

It runs at a lower level than ActionScript and runs calculations in parallel, so it has the ability to perform complex tasks at lightning speed. It’s primarily intended for filters and effects and can be animated, so expect to see a fast uptake for its use in transition effects and the like. Developers can share their filters at the Pixel Bender exchange.

There’s also the ability to pass other types of data such as bitmapData, vectors and byteArrays to the shader. This means that experienced users will be able to harness its speed for doing complex calculations for applications like advanced physics simulations, sound processing and number crunching in 3D engines.

Alchemy: Alchemy enables you to compile existing C and C++ code libraries to AS3 as a SWF or SWC to run within FP10 or AIR 1.5. The compiled libraries can then be accessed directly using AS3. This means developers can tap into thousands of open source C and C++ libraries and compile them to be used in their web applications to expand the possibilities of what’s technically possible.

The compiled library will be ideal for tasks that require intensive calculations. Adobe Labs suggest uses such as audio/video transcoding, data manipulation, XML parsing, cryptographic functions or physics simulation. They suggest performance can be considerably faster than trying to achieve the same result using AS3 alone.

Drawing API: With every recent release of Flash there have been modest updates to the drawing API but with Flash 10, the changes are anything but modest. For starters, there’s a much faster and more powerful way to draw lines using the new drawPath method and the introduction of winding.

Triangle drawing methods have been added, primarily aimed at 3D effects but useful for a lot more besides. Significant improvements to bitmap fills when combined with the new triangle provide a powerful means for distorting bitmaps.

And the list goes on, including a set of new graphics data classes that can act as containers for drawing information and can be passed around, used with any target or reused.

Contemplating what the introduction of all these features means makes you think. On the one hand, there’s excitement at the huge increase in potential, all the new toys to play with and the fact that pretty much any visuals that can be conceived can probably now be realised within ActionScript. Yet at the same time there is trepidation in the spiralling complexity of it all.

The sites of the future that define the next era in Flash will demand a superior level of technical understanding to even be conceived. The role of the purely graphical Flash designer may become limited while designers with technical ability begin to shine.

Source: http://www.techradar.com/

Five Features We Want to See in Ubuntu

Ubuntu isn’t the only Linux operating system, but it’s where the dream of a usable, completely free desktop is closest to reality. If every Ubuntu developer were assembled at one place, here are five things we’d ask them to accomplish.

Ubuntu’s not a single service or application developed by a single-minded team, so our wish list is a bit broader than just asking for five features or tweaks we’d like to see. Ubuntu is an open-source distribution of Linux, improved and developed for by thousands of developers around the world, and it incorporates the efforts of many of the projects it relies on, like the GNOME desktop, open-source drivers, apps like Firefox and Pidgin, and many more.

But let’s say there were a worldwide summit on how Linux could become a viable, convenient desktop for more people, and let’s pretend I had a panel approved at said summit at which I could present to all the devs. I wouldn’t argue about hardware compatibility, or pretend that games are an end-all issue. I’d admit I’m biased toward thinking about Apple computers more than Windows, because Apple has gained ground with a surprisingly similar product, and some corporate, locked-down environments will never switch from Windows.

Then I’d ask for these five things:

An App Store better than Apple’s

One of Linux’s most touted advantages over Windows and Mac systems is that, on distributed systems like Ubuntu, you can install thousands of applications right from your system, without having to Google, download, double-click, and Next, Next, Next through installation screens. That advantage is lost if you put all your applications in a big pile of searchable stuff labeled “Graphics” or “Sound & Video”—or, even worse, ask users to copy-paste repository sources and installation commands into text files and terminals. Those are great backup and uber-geek solutions, but terribly off-putting to those just trying to get a system up and working.

New users are coming to Linux looking for their Windows or Mac equivalents—Photoshop, iTunes, Winamp, AIM—and they’re wondering what other users like them recommend in very particular areas. They’re in a position similar to that of a new iPhone owner when it comes to software. Only certain applications will work on this very particular software setup, and they must be sought out. Apple’s iPhone App Store is an utter mess when it comes to organization, search, and layout, but even its simple Top 10 Paid and Top 10 Free are more guidance than what Ubuntu users are being offered. The default, installed Ubuntu applications are okay, maybe a little esoteric in spots, but Ubuntu’s builders and coders shouldn’t be the taste makers.

Create a clean, tagged, search-friendly database of everything that runs on a standard Ubuntu desktop. Offer wiki-style, group-edited write-ups, reviews, and (maybe) ratings of what the applications do and what non-Linux apps they are similar to, and put it all on the freely accessible web. This kind of thing is already possible with Ubuntu’s apt-url handler—all that’s missing is the common URL.

Integrate dual-booting and virtualization

Show up fresh-faced at an Apple Store and ask how your copy of WordPerfect would run on a Mac, and a T-shirted Genius will gradually guide you into Parallels or VMWare Fusion, or possibly suggest using Boot Camp to occasionally run Windows when needed. Ubuntu isn’t really any different. If Ubuntu wants to reach beyond the technical-minded, it should eliminate the need to learn about partition tables to fit a Windows installation next to Linux.

Create something less imposing and more visually appealing than the default GRUB menu. Keep improving on the Ubuntu installer to better explain what one’s multi-system installation options are. Do your best to make something like installing and running VirtualBox easy for a beginner, or break apart its open-source guts and integrate it so tightly into Ubuntu that an “Open in Windows 7” right-click command isn’t some laughable dream.

A wave of right-brain rethinking

The achievements of a network of left-brain-oriented, technical-minded developers in creating a Unix-based system that installs on just about anything with a processor can never be truly appreciated. Apple created a Unix-based OS that installs on a smaller subset of computer hardware, but has a history and tradition of investing a whole lot of right-brain thought into making technically advanced features look clean and simple. Projects like Mac4LIn are mimicry at its finest, and interfaces like GNOME-Do Docky theme bring both Quicksilver and Dock functionality to Linux. What Linux and Ubuntu really need now, though, is something new.

Palm’s Pre smartphone received generally rave reviews for its “deck of cards” interface, which was actually new and not hard to get used to. While it doesn’t seem to be winning a sales war against the iPhone, Ubuntu has a distinct advantage—it’s free. Something free and designed to look kinda-sorta like XP out of the box once did won’t win hearts and minds. Something with a useful but new look, with advantages in speed, openness, and hardware support, will get notice. To paraphrase what Mac guy John Gruber said about the Android opportunity—set your goals such that you can claim victory with just a fraction of Windows and Apple’s installation base.

Awesome cloud-based backup

When the Linux-based Chrome OS drops, one thing we know it’s going to try for is starting up in “a few seconds.” Ubuntu’s next release, meanwhile, is aiming for 10 seconds. Unless they’re both pitched primarily for mayflies, that’s not an insurmountable difference, but Chrome OS will also offer no-worry backup of all of a user’s documents, emails, SMS messages, and whatever other webapps, because it all gets done through a web browser, or, more likely, a browser running inside a stand-alone application shell.

There are a significant number of folks who aren’t cool with having everything they do in the cloud, and might want hard copies of everything. More likely, it’s probably wise not to use Google as the linchpin of one’s entire productive life, because account lock-outs and password hacks do happen. Backup, however, is one of those things that’s more powerful when there’s a copy far away from your system. Ubuntu already has Ubuntu One, but right now it’s a less convenient Dropbox look-alike, because it’s accessible only through Ubuntu or the web. It’s open source, so Windows and Mac synchronization tools may eventually show up, designed by committee. But if a backup service is getting accolades from true geeks for being paradigm-shifting and mind-freeing, you’d do well to learn its lessons, or potentially open talks in the interest of open-sourcing it.

Good video editing software

This one’s a bit more fiddly, but definitely worth mentioning. Trying to edit a video so that continuous sound played over different clips, two Lifehacker editors found themselves amazed at how difficult, or at least hard to find out, iMovie ’09 had made such a task on a Mac. On Windows, there’s the free Windows Movie Maker, which has actually lost features since the XP version, and then professional packages starting at $450 dollars. In Linux, there are a range of options, almost none of them with a finished feel, and all of them front-loaded with codec, dependency, and interface headaches galore. OpenShot seems like a step in the right direction. While Ubuntu isn’t in the video software business, the many folks who contribute time, thought, and sometimes money to the project could consider this a serious missing link in the Linux application space.

Source: http://lifehacker.com/5355900/five-features-we-want-to-see-in-ubuntu

HTML5 and The Future of the Web

Some have embraced it, some have discarded it as too far in the future, and some have abandoned a misused friend in favor of an old flame in preparation. Whatever side of the debate you’re on, you’ve most likely heard all the blogging chatter surrounding the “new hotness” that is HTML5. It’s everywhere, it’s coming, and you want to know everything you can before it’s old news.

Things like jQuery plugins, formatting techniques, and design trends change very quickly throughout the Web community. And for the most part we’ve all accepted that some of the things we learn today can be obsolete tomorrow, but that’s the nature of our industry.

When looking for some stability, we can usually turn to the code itself as it tends to stay unchanged for a long time (relatively speaking). So when something comes along and changes our code, it’s a big deal; and there are going to be some growing pains we’ll have to work through. Luckily, rumor has it, that we have one less change to worry about.

In this article, I’m hoping to give you some tips and insight into HTML5 to help ease the inevitable pain that comes with transitioning to a slightly different syntax.

Welcome to HTML5.

What are the basics?

The DOCTYPE

When I first started researching HTML5 a few months ago, one of the main things I struggled to find was the doctype. A simple thing, you’d think it would be everywhere, but after much frustration, I finally found it buried within w3.org and here it is:

<!DOCTYPE html>

I was also curious why they chose to “html” rather than “html5″, it seemed like the logical way to tell a browser that the current document was written in HTML5, and offered a good template for the future. But I found that <!DOCTYPE html5> triggers Quirks Mode in IE6, and when taking backwards compatibility into consideration <!DOCTYPE html> is a pretty good choice (in my opinion).

Overall, I really like the new DOCTYPE; it’s small, meaningful, and maybe we’ll actually be able to remember this one by heart and not have to paste it from site to site.

New Elements you should know

At first glance, with HTML5, the new elements immediately jump out and command attention. The W3C really listened to the community and planned for the future when architecting the abundance of new elements available. We have everything from basic structural elements like <header> and <footer> to others like <canvas> and <audio> that tap into, what seems to be, a very powerful API which allows us the freedom to create more user-friendly applications while further distancing ourselves from reliance on Flash for saving data and intense animation.

The new structural elements

• <header>
  The header element contains introductory information to a section or page. This can involve anything from our normal documents headers (branding information) to an entire table of contents.
• <nav>
  The nav element is reserved for a section of a document that contains links to other pages or links to sections of the same page. Not all link groups need to be contained within the <nav> element, just primary navigation.
• <section>
  The section element represents a generic document or application section. It acts much the same way a <div> does by separating off a portion of the document.
• <article>
  The article element represents a portion of a page which can stand alone such as: a blog post, a forum entry, user submitted comments or any independent item of content.
• <aside>
  Aside, represents content related to the main area of the document. This is usually expressed in sidebars that contain elements like related posts, tag clouds, etc. They can also be used for pull quotes.
• <footer>
  The footer element is for marking up the footer of, not only the current page, but each section contained in the page. So, it’s very likely that you’ll be using the <footer> element multiple times within one page.

When you take a look at these new elements, it looks like they’re just replacing our common DIV IDs; and in a way, it’s true. But, the diagram below shows that elements like <header> and <footer> can be used more than once on a single page where they behave more like classes and normal HTML elements that you can use over and over again to retain a semantic structure.

Elements like <header> and <footer> are not just meant to represent the top and bottom of the current document, but they also represent the <header> and <footer> of each document section, much the way we use <thead> and <tfoot> in data tables.

The benefits of using these structural elements is mainly due to the fact that they are extremely well defined and provide a great way to semantically structure your document. However, these elements do need to be used with some careful thought because they can, very easily be overused.

Further Reading on structural HTML5

• Steve Smith on Structural Tags in HTML5
• Lachlan Hunt’s Preview of HTML5
• Elliot Harold on New Elements in HTML5
• Bruce Lawson’s HTML5 Form Demo

Easing the transition from XHTML

Even though HTML 4.01, XHTML 1.0, & HTML5 are all very similar there are some small syntax differences that can, very easily, slip past anyone and invalidate code. Keeping this in mind, HTML5 has some built-in “slack” to make the transition a little easier.

For example, when marking up a form in HTML5, this is the proper syntax for an input text element:

<input type="text" id="name">

But this is also accepted as valid code in an attempt to ease the pain for avid XHTML coders (like myself) who are used to self-closing elements:

<input type="text" id="name"/>

The same rules apply to <meta> and other self closing elements. Legacy elements like <b> and <i> were also left in to help those coming over from HTML 4.01.l

What are the benefits?

With any new technology there has to be benefit; why else would you use it? If your old code works just as well and efficient as the new code there’s no reason to upgrade. No reason at all, trust me, I checked.

Luckily HTML5 is packed with cool new features, code slimming techniques and a lot of stuff I would call very large benefits. Most of which circle around the new APIs and the DOM tree.

Extending the API

The most obvious benefit built into HTML5 is the numerous APIs and the opportunities it opens up for the future of web apps with Holy Grail of application cache and offline capabilities. Google Gears gave us offline data storage and Flash introduced us to the power of application cache (Pandora uses it to save your log in information). With HTML5, these capabilities are now available to use right in the language and can easily be expanded with JavaScript.

HTML5 relies on light scripting to flex its muscles on the Web; this is very possibly the first time, other than jQuery, that one (front-end) technology has fully acknowledged another. Sure, we connect them with classes and IDs but up until now, they have been perceived as separate layers by the principles of progressive enhancement. But as the Web grows we need unity like this across the Web.

Offline Data Storage

The coolest part about HTML5 is definitely its offline capabilities. Programs like Thunderbird and Outlook (and now GMail to an extent) let you browse through your old data while staying offline. With HTML5, you’ll have this same functionality, but in the browser. This is the first serious step towards bridging the gap between the desktop and the Web, and opens all sorts of doors for the future of Web apps.

The W3C has taken the best parts from the various Web technologies and rolled them into, what is being dubbed the most powerful markup language to date.

Some other of the HTML5 APIs

• Drag & Drop
  The drag and drop API defines an event-based drag and drop system. However, it never defines what “drag and drop” is. This API requires JavaScript to fully work as normal think drag and drop functionality.
• Video & Audio
  The audio & video APIs are massive upgrades in media embedding. Although support is limited right now, something like video embedding has never been easier:

  <video width="400" height="360" src="vid.mp4">

• Geolocation
  Geolocation is a very cool API available within HTML5. Its object can be used to programmatically determine location information through a device’s user agent (hint hint: mobile devices).

Further reading on the HTML5 API

• Offline Web Applications
• Offline Application Caching
• Remy Sharp on JavaScript APIs HTML5 (presentation)
• O3D Beach Demo from Google (must have an HTML5 capable browser)

Where can I use it?

Even with the very limited support for HTML5, the Web is far too progressive to not create a testing environment for us to play around. Currently, Safari is our best testing platform, as it supports most of the new elements and APIs. Of course, that may change at anytime so keep and eye on Opera, Chrome and Firefox as well.

Normally you might think since Safari is a Webkit browser, by default, all Webkit browsers would support the same elements, unfortunately, this isn’t the case. While many of the HTML5 features are supported across the board in Webkit browsers, there are some, like <video>, that are not.

Mobile devices

To effectively use HTML5 right now, we need to be able to control the environment in which it is used. Since support is not as widespread as we’d like it doesn’t make real sense for it to be heavily used unless, of course, we can lock down the usage to certain platforms which have HTML5 support. With Webkit leading the way for HTML5, we can safely focus on devices powered by Webkit.

The 3 hottest mobile devices right now: The Palm Pre, iPhone 3Gs and the new Google Android phone all have browsers that are based off the Webkit rendering engine.

Safari is even leading the way on the mobile HTML5 front; The iPhone (with the latest software upgrade) is the only device I could get to properly render the <audio> element. Because these devices are so young and all use the same rendering engine, the likelihood of them pushing a rapid software upgrade is pretty high.

Right now, you can confidently use many of the HTML5 features in iPhone Web app development and mostly likely expect Pre and Android to follow in suit.

Further reading on where you can use HTML5

• HTML5 Features in latest iPhone
• GMail Web app for the iPhone
• GMail for HTML5
• Supported Features in HTML5
• HTML5 Cheat Sheet

How can we move forward?

Even with all the recent hype surrounding HTML5 and how we all want to use it, it is still going to be a very slow transition away from HTML4.01 & XHTML1.0. It will take time to get developers up to speed, test all the features, waiting for all the :ahem: browsers to catch up, and it will take an especially long time for users to transition out of those old browsers. With all that in mind, we know who we are, we’re all reading this article (I’ve read it about 30 times so far) and we know we have to find a legitimate way to move forward without damaging the past.

We can’t make the full switch yet and there’s no use at this point pointing out who is holding up the show. We all know that any responsible developer would not drop support for a browser that is still heavily used. So rather than yell at a brick wall, here are some things I’ve found that might help us move forward in a positive way:

Semantic DIV naming

Semantically aligning your DIV names with that of the new HTML5 elements will help you get used to the names themselves and also the new functionality and nesting that they want you to do with the <header> and <footer> elements. These are akin to learning the intro the Enter Sandman (for the guitarist out there); it’s not very difficult, but it takes a little practice to get it to feel natural.

Before jumping in full-force to HTML5 production sites, I recommend trying the soft transition with changing your DIV names slightly. There’s no downside that I’ve found to doing this, you can even use the new DOCTYPE with very little consequence.

Faking it with JavaScript

First off, I’d like to say: Please don’t do this in production. If the client side scripting fails, it will completely collapse the site in browsers that won’t take CSS applied to the new elements. This is simply not a good option. It is, however, an option and I’m all about knowing your options no matter what they are.

Creating the new elements with JavaScript

Working in jQuery is cool and all, but as it turns out, there is a built in function to JavaScript to deal with creating new elements:

document.createElement('header');
document.createElement('footer');
document.createElement('section');
document.createElement('aside');
document.createElement('nav');
document.createElement('article');
document.createElement('figure');
document.createElement('time');

…and so on in that fashion.

This will allow you to style these elements in Internet Explorer. Again, the downside of using this technique is that, without the all-important JavaScript, the site will not only be unstyled, all the unrecognized elements will default to inline. So your site will literally collapse on itself.

Client side JavaScript is not the answer for using HTML5. Server side javascript, now that’s a completely different story…

Building browser-specific apps

I’ve always promoted building sites for your audience, so depending on your audience, building browser-specific applications may be a real option. As I mentioned above, it’s all about controlling the environment, if we can control the environment we can control features delivered to the user much better. Google is currently attempting to do this with Google Wave.

The idea behind Google’s new monster product is to revolutionize communication, and do so with the newest technology. Google Wave is built in HTML5 and isn’t usable in all browsers yet. But that’s alright since they’re controlling the audience by only releasing it to select developers for testing.

With Wave, Google is pushing HTML5 as far as it will go (and even a little further). They are taking blogs, wikis, instant messaging, e-mail and synchronous communication to the next level by combining them into place.

Here is what the Wave inbox looks like.

Below is a sort of wiki/chat area with all sorts of real-time communication treats for you to check out (once they release it).

Google Wave being powered by HTML5 is definitely the biggest step forward we have seen in this area. They have done a phenomenal job putting together a creative and innovative product.

Focusing on the mobile

Just like Google is currently doing with Wave by selectively releasing it to developers, we can control the viewing environment when working with mobile devices. By grabbing the user agent, we can design specific applications that use HTML5 for supported devices.

Targeting the user agent of a device is not an ideal method in designing for the general mobile web, but when we need to specifically target a device, like the iPhone, Pre or Google’s Android it’s a pretty solid option.

Right now, the best mobile testing platform we have is the iPhone. With the recent software upgrade, it is very close to having full support. But, if you just want to use the new elements, most any of the big 3 mobile platforms will work fine. If you’re looking for API support I suggest testing on the iPhone with the new upgraded software.

Conclusion

With the strong foundations set up by previous versions of (X)HTML and large community activity surrounding Web standards, we’re coming into a new age with a wealth of knowledge and the ability to learn from our past mistakes (and make some new ones). HTML5 is being set up with the expectations of a very powerful markup language and it’s up to us to utilize it in a way that can benefit us all.

There are so many great features to look forward to from new elements to tons of killer APIs. We can make data available offline, easily combine technologies and create very intricate animations all within a familiar landscape. If you have the time, I encourage you to browse through the entire spec and familiarize yourself even further with all the bells and whistles (there are a lot) so we can use HTML5 to build stronger, richer Web applications for years to come.

Here’s to HTML5, let’s hope it lives up to the hype.

source : http://www.smashingmagazine.com/2009/07/16/html5-and-the-future-of-the-web/

Simple Ajax Preview window

Very simple. call external files

HTML CODE

a href =” loremipsum1. html ”
[div id=”previewWin”] [/div]
CSS code
#previewWin {
background-color: #FF9;
width: 400px;
height: 100px;
font: .8em arial, helvetica, sans-serif;
padding: 5px;
position: absolute;
visibility: hidden;
top: 10px;
left: 10px;
border: 1px #CC0 solid;
clip: auto;
overflow: hidden;
}
#previewWin h1, #previewWin h2 {
font-size: 1.0em;
}

Javascript Code

window.onload = initAll;
var xhr = false;
var xPos, yPos;

function initAll() {
var allLinks = document.getElementsByTagName(“a”);

for (var i=0; i< allLinks.length; i++) {
allLinks[i].onmouseover = showPreview;
}
}

function showPreview(evt) {
getPreview(evt);
return false;
}

function hidePreview() {
document.getElementById(“previewWin”).style.visibility = “hidden”;
}

function getPreview(evt) {
if (evt) {
var url = evt.target;
}
else {
evt = window.event;
var url = evt.srcElement;
}
xPos = evt.clientX;
yPos = evt.clientY;

if (window.XMLHttpRequest) {
xhr = new XMLHttpRequest();
}
else {
if (window.ActiveXObject) {
try {
xhr = new ActiveXObject(“Microsoft.XMLHTTP”);
}
catch (e) { }
}
}

if (xhr) {
xhr.onreadystatechange = showContents;
xhr.open(“GET”, url, true);
xhr.send(null);
}
else {
alert(“Sorry, but I couldn’t create an XMLHttpRequest”);
}
}

function showContents() {
var prevWin = document.getElementById(“previewWin”);

if (xhr.readyState == 4) {
prevWin.innerHTML = (xhr.status == 200) ? xhr.responseText : “There was a problem with the request ” + xhr.status;
prevWin.style.top = parseInt(yPos)+2 + “px”;
prevWin.style.left = parseInt(xPos)+2 + “px”;
prevWin.style.visibility = “visible”;
prevWin.onmouseout = hidePreview;
}
}

demo at: http://www.rpi.edu/~zappenj/Ajax/Preview/preview.html

Audio Mixer

http://lab.andre-michelle.com/tonematrix/

http://www.hobnox.com/