I search for “lolcat translator” and found better results, including a CPAN module. Reading through the code gave me an idea for how to implement a jQuery LOLCAT plugin of my own.

Check out the demo or download the plugin.

A few answers to some unasked questions:

• Yes, the translation table is extensible. Pass an object to the $.lolcat() call.
• Yes, this should keep all bound event handlers, since only text nodes are replaced with translated text.
• Yes, I spent way too much time on this.

First the PHP:

Simple, right?

Now for the Javascript (with a little help from jQuery):

Okay, it takes a little more effort and “unset” is a horrible function name for what it’s doing. But it’s worth it, right? Right?!

In April and May, I spent some time working on database design for a complete rewrite of my company’s software. The schema is very complex and presented lots of interesting challenges.

In May, I started building the system – with my coworkers – using the symfony framework and Doctrine ORM. I tested out several other frameworks and ORM’s, but ultimately we decided on symfony and Doctrine. The symfony framework is very mature and easily extensible. Doctrine, on the other hand, is quirky and a little bloated. It just so happens that symfony is built for Doctrine or Propel ORM and Doctrine seemed the lesser of two evils.

In October, I started building a ubiquitous chat component using XMPP for my company’s software. The chat is based on Openfire and Strophe. The chat itself is similar to Facebook’s chat.

In November, I attended the first WordCamp Phoenix. Throughout the day, there were some good speakers (Jim Christian, John Hawkins, Brent Spore, Dave Moyer, Merlin Mann) and some that were awful (Lorelle VanFossen and Jayson Cote). My friend’s sister-in-law (both attended WordCamp) knows Matt Mullenweg (the creator of WordPress), so we all had lunch together. It was a pretty cool experience overall.

Also in November, I put an online store together for a client using Magento. I didn’t have much time to dive into it because the project had such a quick turnaround time, but I could do some pretty awesome things with it. I’m looking for reasons to play around with it more.

I wrote a number of cool jQuery plugins in 2009:

• Undoable: handles undo and redo
• AJAXList: Create a very customizable autocomplete list via AJAX
• Caret: Cursor selection getter and setter
• FakeSelect: Creates a <select>-like dropdown menu from a <ul> element
• Tristate: Creates a tri-state input (checked, unchecked, default) for forms
• IP Address: Creates an IP address input for forms

I’m hoping 2010 is just as great as 2009 was.

But all of those solutions fall short in one way or another.

So I decided to write a jQuery plugin that would turn a plain old text input into an IP address form widget that operates like one you’d find in your operating system.

The plugin parses out existing text in the input (in case the user is editing an existing IP) and creates 4 new text inputs. As the user types the IP address, the cursor jumps to the next box. But if I left it there, it would be pretty lame, right?

The plugin also adds event handlers to the inputs to limit keys. There are also event handlers that will allow right and left arrows to jump between inputs and backspace will continue across inputs as well.

I had to write another plugin to get the cursor handling working correctly, so it’s required for the IP address plugin.

As the user is typing, if all 4 IP octets have a value, the original IP address will be repopulated with the IP address from the widget.

Check out the demo or download from Google Code (requires jquery.caret, a cursor position plugin).

I browsed through the gallery, looking for anything that might be useful to me and my normal browsing experience. I found a couple good ones: Google Alerter, RSS Subscription Extension and Docs PDF/PowerPoint Viewer (by Google).

I searched for a Facebook ad blocker, but the one I found only blocked profile ads – not very useful. So I tried writing my own and found that it was much simpler than I expected.

There were really only two files that I needed to create: manifest.json (a manifest file that tells Google Chrome important info about your extension) and facebook.css (a content script that hides the ads using CSS, obviously).

The manifest.json file looks like this:

I used Chrome’s Developer Tools (Ctrl-Shift-I or Page menu > Developer > Developer Tools) to find good CSS rules for blocking the sponsored ads on the homepage, profile page and app pages. I also had to fix the profile page, which broke when I hid the ad sidebar there. Here’s what facebook.css looks like:

After saving the two files to an empty directory, I opened chrome://extensions in Chrome. Under “Developer mode”, I hit the Load unpacked extension… button and navigated to that directory. Chrome added the plugin and I could refresh it if I needed to make a change to the CSS or manifest.json file.

After everything was tested and working, I packed the extension and was done. Overall, I think the whole process took about 15 minutes, but most of that was looking at documentation.

Here’s the extension, if you want to play around with it.

What does that mean? I’m not entirely sure.

(Demo)

Here’s the goal…

I want to be easily able to add a function to the undo queue.  When I press the undo key combination, that function will run again and it will be placed in the redo queue:

This is really not ideal.  While some functions toggle correctly, not all do.

What I really is to be able to define a function for undo and a function for redo:

I really think I can get away with both of them.

Check out the demo and let me know what you think. (Hint: Open the Firebug console)

The goal for this plugin was to create a event handler for text and page zooming in a browser window.  While this can’t be accomplished entirely without some better event support in the browsers, I can watch for keyboard and mouse shortcuts that result in zooming.

This plugin itself doesn’t care if you zoomed in or out. It just runs the callback function when you zoom. Maybe at a later point, I’ll add that feature.

Without any further ado, here’s the plugin code:

Because we’re dealing with browser implementations of keyboard shortcuts, I decided to use jQuery.browser (which uses navigator.useragent) to deal with the browsers individually. Much to my surprise (and delight), Internet Explorer and Firefox handle zooming identically.

Lines 2 – 30 deal with zooming through keyboard shortcuts. The character codes are as follows:
42: * (numpad)
43: + (numpad)
45: – (numpad)
48: 0 (numpad in FF and IE)
96: 0
107: + (numpad in FF and IE)
109: – (numpad in FF and IE)
187: +
189: -

Lines 32-38 deal with scrollwheel zooming in Firefox and IE. Opera doesn’t run the callback function for the scrollwheel when the CTRL key is pressed (which is how scrollwheel zooming is done in Opera). Safari 2 (which is what I have) doesn’t support scrollwheel zooming at all.

Further testing needs to be done in Safari 3, but this plugin works pretty well as is. Here’s how you’d use it:

Here’s the download and the demo.

UPDATE: You can find the latest version of the plugin here.

You could then assign a handler like so:

So much more needs to be added to this and I’m not even sure I’m headed the right direction. For example, I can address another way of zooming (CTRL-scrollwheel), but I doubt I can capture use of the menu in the browser. Also, I could probably assign different keys to zoom. I might have to come up with a different solution entirely.

Pass in a SQL date and the function trims leading zeros and returns a reformatted date.

Crazy Europeans may want to change the replace regex with ‘$3/$2/$1′.

Great concept, right? No need to tell it where to send the data or what fields to send, since the form already contains that info. It’s mostly unobtrusive, so any browser that doesn’t have JS enabled would still be able to submit.

So my immediate response was, “Very cool. I’m sure a jQuery plugin either exists or could be created pretty easily to handle that.”

I built the following plugin in maybe 30 minutes, and had it tested in another 15.

There are some of you that are wondering, “Why is this necessary? I can write my own jQuery.ajax() code every time.” Yep, and that’s part the problem I’m trying to solve. The plugin is a shortcut for most of the jQuery.ajax() code you’d normally write and it makes unobtrusive form submission dead simple:

The function takes one parameter, an object that extends the jQuery.ajax method.

Here’s a demo and the download.

2008-09-23: Updated window.location to window.location.href (Thanks Samori)