MooShell

MooShell, created by Piotr Zalewa (zalun), is the best code pasting tool since Pastebin. MooShell allows you to paste your HTML, CSS, and MooTools javascript into the page and test. MooShell is an excellent utility for troubleshooting an issue or demonstrating your code.

http://mooshell.net/

Up The Moo Herd IV: There’s A Class For This

MooTools contributor Mark Obcena keeto continued his excellent series of “Up the Moo Herd” tutorials with “There’s a Class For This.” This post discusses Class Mutators, Mixins, and MooTools’ inheritance model. Consider this post a must-read for novice and expert MooTools developers.

http://keetology.com/blog/2009/10/27/up-the-moo-herd-iv-theres-a-class-for-this

MooRTE: The Mootools Rich Text Editor

MooRTE is a great MooTools rich text editor. MooRTE is lightweight, customizable, and very easily skinnable. Try MooRTE out in your CMS!

http://siteroller.net/projects/moorte/

Call to Upgrade: MooTools 1.1.2 and MooTools 1.2.4

Remember to upgrade your MooTools 1.1 and MooTools 1.2 builds to 1.1.2 and 1.2.4 respectively. Firefox 3.6 has removed document.getBoxObjectFor which will impact Gecko detection.

http://mootools.net/blog/2009/11/02/upgrade-mootools/

Keep Up the Good Work!

These are just a few of the great MooTools plugins floating around the MooTools community recently. Keep up the good work and we look forward to featuring your plugins in future posts!

Firefox 3.6 and document.getBoxObjectFor

The reason we stress the upgrade to MooTools 1.2.4 and MooTools 1.1.2 is the removal of the document.getBoxObjectFor method in the upcoming Mozilla Firefox 3.6 release. Within the browser detection code of MooTools 1.1 and earlier versions of 1.2, MooTools attempts to identify the Gecko engine by checking for the existence of document.getBoxObjectFor. Mozilla’s removal of this method in Firefox 3.6 effectively breaks Gecko detection in MooTools 1.1 and MooTools 1.2.3 down.

“What Affect Does This Have on My MooTools Build?”

Gecko detection is used within MooTools only twice — both times for event handling:

• Event.relatedTarget - Identifies the related target of any given event. This property is used in multiple places throughout the framework.
• The mousewheel event - Firefox identifies mousewheel events using “DOMMouseScroll” instead of “mousewheel.”

These items are at risk to break without upgrading your MooTools build.

The Solution Moving Forward

We have overhauled our browser detection to be based on the user agent string. This has become the standard practice among JavaScript libraries because of potential issues as Firefox 3.6 demonstrates. As browsers grow closer together, looking at “features” to separate them will become more difficult and risky. From this point forward, browser detection will only be used where it would be impossible not to, in order to give the consistent experience across browsers that one would expect from a world-class JavaScript framework.

“Where Can I Download Upgrades?”

You may download the updated MooTools 1.1.2 build on the MooTools 1.1.2 download page. You may also grab MooTools 1.1.2 from GitHub.

You may download the updated MooTools 1.2.4 build on the MooTools 1.2.4 download page. You may also grab MooTools 1.2.4 from GitHub.

Thank you for upgrading. We look forward to continued success with the MooTools javascript framework!

Today’s release offers no new features, a lot of very minor fixes (to docs and the like), and the restoration of a few changes to the API that weren’t intended (Tips and Fx.Slide, in particular).

Here’s what’s in 1.2.4.2:

• roughly a dozen issues fixed or closed (in lighthouse)
• Numerous documentation updates
• Spinner: Adding a getSpinner method to Request in Spinner’s refactoring of that Class
• Spinner: Fixing default styles
• Form.Validator, Date: Added Ukrainian translations
• Date: Added new Date parser (parses “Thu Oct 22 08:11:23 +0000 2009”)
• Fx.Accordion: handling the alwaysHide option so you can still have returnHeightToAuto set to true (see this discussion)
• Tips: Restoring arguments to the show/hide events; tip no longer defaults to display:none (this restores the previous behavior)
• Fx.Reveal: stores cssText whenever it starts a transition and restores it when it finishes or is canceled, leaving the element without a bunch of inline styles, as if you’d just done setStyle(‘display’, ‘block’/’none’)
• Fx.SmoothScroll: adding a “scrolledTo” event
• Drag: added new ‘stopPropagation’ option
• HtmlTable.Select: ensuring that instances only delegates to immediate children (for nested tables)
• HtmlTable.Sort.js: detects and sorts date columns more accurately, handles negative integers and floats
• Reorganized scripts json so Depender can implement Log

As always, if you find any issues, file tickets and we’ll get on it.

Non-breaking Changes

Before we get started telling you all the yummy stuff we’ve got for you, let us first assure you that the code we released today is 100% backwards compatible with the previous versions. Upgrading should be as simple as dropping the new files in place.

MooTools Core - 1.2.4

This version of the MooTools Core is one of the most tested and refined we’ve ever released. We’ve fixed numerous small bugs, but the ones you may notice most of all are:

• Added Trident 6 (IE8) detection
• Request can take an instance of URI as a url
• JSON.stringify and JSON.parse native methods are now accessible
• DomReady always fires before load event
• Fix for creating a Request in early versions of IE6
• Fixes and optimizations for Element.getOffsets

This short list doesn’t do it justice, there have been roughly 70 commits to the core since 1.2.3, but most of these fixes are minor including adding to documentation, adding more tests, etc. The point here is that the 1.2 branch is increasingly stable, which is why we release it so infrequently.

Gecko (Firefox) Detection in 1.2.4, 1.1.2

MooTools has always used object sniffing to detect rendering engines, and while not perfect, this method has proved very reliable in recent years. However, the upcoming Firefox 3.6 marks a shift in our thinking on this subject because Gecko detection will no longer work on it without an update. We recognize the significance of this, and therefore are releasing updates for both 1.2 and 1.1 because we understand that 1.1 is still in widespread use.

Looking towards 2.0, we have overhauled our browser detection to be based on the user agent string. We realize that this is not without its forward compatibility risks, however it is the standard practice among JavaScript libraries because of potential issues as Firefox 3.6 demonstrates. As browsers grow closer together, looking at “features” to separate them will become more difficult and risky. User agent strings, on the other hand, have remained very consistent in recent years with the exceptions being in mobile browsers and with Google Chrome coming on stage. With 2.0, browser detection will only be used where it would be impossible not to, in order to give the consistent experience across browsers that one would expect from a world-class JavaScript framework.

For those of you still running 1.1, it is imperative that you update to 1.1.2. When we get 1.1.2 up on Google’s JavaScript CDN service, those of you requesting 1.0 or 1.1 from that service should see the upgrade without doing anything. If you do not update your 1.1 scripts, users visiting in Firefox 3.6 and beyond will likely encounter issues.

MooTools More - 1.2.4.1

While MooTools Core has remained pretty much the same since the original 1.2 release, MooTools More continues to add new features that should make building sites even easier. This release is jam-packed with bug fixes and new plugins, and we’re excited to see what the community will do with them. Here’s a quick list:

• over 30 issues fixed or closed (in lighthouse)
• New feature: Element.Delegation - a partial port of event delegation from MooTools 2.0 (does not support custom events or blur/focus)
• New feature: Elements.From converts html strings to DOM elements
• New feature: Depender - a client side MooTools dependency loader ** Related: Depender App - a server side implementation (that’s much faster) - more on this in a later post
• New feature: Mask - masks elements (including the window) with a semi-opaque overlay
• New feature: Spinner - automates the creation of ajax spinners over DOM elements being updated (previously known as Waiter on Clientcide.com)
• New feature: Form.Request, Form.Request.Append - automates creating ajax forms that update HTML in DOM elements (previously Fupdate on Clientcide.com)
• New feature: HtmlTable, HtmlTable.Zebra, HtmlTable.Sort, HtmlTable.Select - interactive and auto-generated html table elements
• New feature: Keyboard - a robust event manager for keyboard groupings
• Added new option to Fx.Accordion: returnHeightToAuto
• FormValidator is now Form.Validator ** Added credit card number validator to FormValidator
• MooTools Lang is now a part of MooTools More (again)
• Added timeDiff method to Date.Extras
• Added ability to ignore scroll position with Element.Position
• Element.setPosition is now Element.position (non-breaking change)
• Added hideAll and showAll methods for OverText
• Added Element.isVisible method
• URI’s get method no longer returns null for missing parts; it returns an empty string.
• Various other tweaks and bug fixes

Get Coding!

This release has a lot of good stuff in it, but it’s worth noting we have a LOT of other things in the oven right now.

The MooTools development team continues to grow and the more people involved with the creation of the framework, the more cool things we can release. If you want to get involved with making MooTools, all you have to do… is start writing code. Get involved on github, in the mailing list, and start getting your own plugins ready for the upcoming release of the MooTools Forge.

MooTools Search Beta: http://mootools.net/search

This enhanced search has been integrated with the MooTools documentation and will help you easily navigate and identify information in the documentation better than the previous documentation search. The new search system also searches multiple domains — this will allow you to find MooTools demos, forum posts, tutorials, screencasts, and anything MooTools-related. Initial supporting domains include MooTools.net, Clientcide, The MooTorial, David Walsh Blog, etc. We will also pay attention to most-searched terms and aim to ensure the search feature is providing sufficient, quality results.

This enhanced search release is considered beta. We will soon be adding further enhancements based on team goals (including full site search, etc.) and feedback provided by our most valued asset: the MooTools community.

Special thanks to Darren Waddell (fakedarren) for all of his hard work in implementing and maintaining the new search system!

MilkChart

MilkChart is an outstanding set of MooTools classes that create robust charts from your static data. Chart types include column, bar, line, scatter, and pie. MilkChart uses the HTML5 <canvas> tag and is only supported on browsers other than IE.

http://code.google.com/p/milkchart/

MooTools Tree Component

MooTools Core Developer Christoph Pojer (cpojer) released Tree Component, an advanced tree structure plugin which allows for drag and drop organization, cookie tree saving, and collapsible branches.

http://cpojer.net/blog/MooTools_Tree_Components

MTMultiSelect

Authored by Justin Donato, MTMultiSelect is a great plugin that allows you to select multiple items from a paginated list. You may also search the list of items to quickly identify the items you’d like to select.

http://www.justindonato.com/demo/mtmultiselect/

MultipleLinks

MultipleLinks is a MooTools class created by Merrick Christensen. MultipleLinks is a tooltip-like plugin that provides the user a list of possible destinations to click to. MutipleLinks is also highly skinnable.

http://thejavascriptblog.com/mootools-multiple-links-class/

Request.Twitter

MooTools Core Developer Scott Kyle (appden) created Request.Twitter, a very small MooTools class to retrieve tweets from Twitter. The class is flexible in that you may define the URL to query so you may retrieve user statuses, search terms, etc. Request.Twitter is an extension of the Request.JSONP class in MooTools More, showing the power MooTools’ valuable inheritance system.

http://appden.com/javascript/get-tweets-with-mootools/

Keep Up the Good Work!

These are just a few of the great MooTools plugins floating around the MooTools community recently. Keep up the good work and we look forward to featuring your future plugins in upcoming posts!

MooTools Core 1.2.4 and 1.1.2

As we turn our attentions towards MooTools 2.0, version 1.2 will not receive any significant upgrades. However, until MooTools 2.0 is released we will continue to support the current version with bug fixes. To that end we’re releasing MooTools Core 1.2.4 which fixes several small bugs and addresses a change coming in the next release of Firefox. Because of this inconvenient Firefox change, we’ll also be releasing MooTools Core 1.1.2, an update to the 1.1.1 release. Sites using 1.1.1 will be able to drop in 1.1.2 without it affecting anything. We’ll post more details on this when we release these two updates.

MooTools More 1.2.4.1

While the 1.2 version of MooTools Core no longer accepts additions, MooTools More, the official plugins collection, continues to be iterated upon constantly. Included in the next version of MooTools More (1.2.4.1) are numerous bug fixes and performance enhancements, along with new widgets, classes, and extensions for you to play with. Here are a few:

• Mask - An overlay class that allows you to put a semi-transparent layer above any element, including the window.
• Spinner - This class automates putting an AJAX indicator over any element.
• Form.Request - This class makes any form element into an AJAX form.
• HtmlTable - This suite of classes let you create HTML tables on the fly, update and alter their contents, make them zebra striped, selectable, and sortable.
• Keyboard - The Keyboard class provides the tools necessary to manage a complex user interface with different keyboard enhancements.

Depender

Another plugin coming in MooTools More 1.2.4.1 is a client side dependency manager. This class allows you to lazy-load files from the MooTools libraries and any other libraries that use similar organization (i.e. those that map their dependencies with the same mechanisms).

In addition to this client side implementation of the dependency loader is a server side version that greatly improves performance. The server side implementation concatenates and (optionally) compresses the files together so that there’s only one request and is far more efficient.

MooTools ART

MooTools ART has been under development off and on for nearly a year now and for the most part has been under wraps. MooTools ART is the foundation for MooTools’ upcoming UI library. Using canvas and VML, it features support for dynamic illustrations, allowing complex UI elements that have numerous interactive states. When released, will come with numerous plugins for stylable windows, buttons, and more.

One of the most interesting ART features is its support for themes using CSS-like syntax in javascript. In conjunction with the default widgets that come with ART we hope to see the MooTools community create numerous interfaces using the system that allows for a fully themable UI by the end of the year.

Forge

Anyone who has been around the MooTools forums or IRC channel has heard that the user plugin catalog (which we call the Forge) is always “coming soon”. Well, this time, we mean it. The MooTools Forge is a new application which will act as a central repository for MooTools plugins created by, well, by you. The Forge will pull your code directly from GitHub, taking into account versioning and dependencies, and providing plugin usage details.

The Forge is currently in the last stages of testing. Look forward to seeing the MooTools forge by the end of October at the latest.

MooShell

MooShell is an outstanding interactive shell editor for debugging your MooTools code created by Piotr Zalewa. Instead of pasting your CSS, javascript, and HTML into static PasteBins, you may use MooShell to show others the issues you are experiencing with your code. You may also quickly experiment with different techniques and share your ideas with others.

MooTools 2.0

Your favorite javascript framework is about to become 1.612903225806452 times as awesome. MooTools 2.0 will feature an optimized Fx library, an improved Class class (one of the foundations of the entire framework) and inheritance model, blazing fast selector engine (Slick), numerous speed optimizations, and many more goodies. Look forward to a more detailed post soon!

MooTools Dependencies Checker

The MooTools Dependency Checker by Arian Stolwijk parses you javascript files to determine which MooTools classes you need to make the file’s javascript code work. Arian’s dependency checker is a great tool for those looking to implement a MooTools plugin or use minified code.

http://www.aryweb.nl/projects/mooDeps/

MooTools InputMask

InputMask is a useful MooTools plugin by Core Developer Christoph Pojer. InputMask allows you to set a template or “mask” for which a string should be formatted like. This plugin is great for date, time, or phone number formatting.

http://cpojer.net/blog/InputMask_Class_for_MooTools

MooTools DatePicker

DatePicker is a great plugin by MonkeyPhysics. DatePicker allows you to provide your users with a calendar to choose dates from instead of making users type in the date. DatePicker is very customizable and allows for easy styling/theming.

http://www.monkeyphysics.com/mootools/script/2/datepicker

MooModernizr

MooModernizr tests the browser’s CSS capabilities — specifically CSS3 feature detection. MooModernizr extends MooTools’ Browser.Features object. MooModernizr is a port of the original Modernizr.

http://www.aryweb.nl/voorbeelden/mooModernizr/

Speed Up Your Moo Part 1: Selectors

MooTools Core Developer Christoph Pojer shares methods for speeding up your applications through the use of optimized CSS selectors. Consider this article a must-read if you use Selectors frequently in your large web applications.

http://cpojer.net/blog/Speed_Up_Your_Moo_Part_1_Selectors

JSCocoaLoader

JSCocoaLoader allows you to develop Espresso.app code editor extensions using MooTools and JSCocoa. JSCocoaLoader’s utility classes are all powered by Mootools, and as a happy side effect your Javascripts can easily take advantage of Mootools many improvements over vanilla Javascript either by requiring a JSCocoaLoader utility class, or by requiring Mootools directly.

http://wiki.github.com/onecrayon/JSCocoaLoader-sugar/mootools-server

Keep Up the Good Work!

These are just a few of the great MooTools plugins floating around the MooTools community recently. Keep up the good work and we look forward to featuring your future plugins in upcoming posts!

The foundation of every great open source project is its community. The MooTools Team creates the base framework code but it’s all of you that take the framework and build outstanding plugins. Here are some great plugins and tutorials that have been released recently.

MooEditable

MooEditable is a WYSIWYG editor created by Lim Chee Aun (cheeaun). MooEditable features the usual bold, italic, strikethrough, and underline controls as well as the ability to add images, links, and lists.

http://cheeaun.github.com/mooeditable/

MooTools Intellisense

The problem: Visual Studio 2008 doesn’t provide Intellisense for MooTools. The solution: Darren Waddell (fakedarren). Darren has created Intellisense for our favorite javascript framework. Grab this package to increase your productivity within Visual Studio!

http://code.google.com/p/mootoolsintellisense/

PageZoom

Lim Chee Aun (cheeaun) also blessed the MooTools community with PageZoom, a flexible zooming widget that allows you to zoom in on any element within the page. The plugin is especially valuable for zooming in on photos.

http://cheeaun.github.com/pagezoom/

Notification Message Dispatch for MooTools

Tobias Svensson has created NotificationCenter, a simple implementation of a notification center for MooTools which is heavily inspired by NSNotificationCenter from Apple’s Cocoa framework.

http://return42.blogspot.com/2009/07/notification-message-dispatch-for.html

PyCow

As the description says: PyCow translates Python code to JavaScript code with the “MooTools way of class declaration”. Examples of PyCow’s mindblowing functionality can be seen at the PygoWave Server Google Code site.

http://code.google.com/p/pygowave-server/wiki/PythonToJavaScriptTranslator

Up the Moo Herd: MooTools Tips and Tricks

MooTools contributor Mark Obcena (Keeto) examines and explains the finer points of the MooTools Core. His articles are detailed, accurate, and must-reads for MooTools developers. Three posts have been published thus far: The DOM Fetcher Functions, Natives, Generics and Extending the Language, Classes: Constructors, Singletons and Privates.

Why You Shouldn’t Return False in MooTools Event Handlers

MooTools Core Developer Sebastian Markbåge explains why returning false in event handlers can cause you problems. Check out Sebastian’s tutorial to learn more about event bubbling and the proper way of handling events.

http://blog.calyptus.eu/seb/2009/07/why-you-shouldnt-return-false-in-mootools-event-handlers/

Keep Up the Good Work!

These are just a few of the great MooTools plugins floating around the MooTools community recently. Keep up the good work and we look forward to featuring your future plugins in upcoming posts!

Slideshow 2

Slideshow 2 by Aeron Glemann is an outstanding photo / slideshow plugin that offers a plethora of options and features — many more than you’d find with the average slideshow or lightbox. Slideshow 2 features Robert Penner easing transitions, photo delays, duration settings, the ability to make Slideshow 2 a lightbox, and an on-photo control panel.

http://www.electricprism.com/aeron/slideshow/

MooTools FileManager

Created by MooTools Core Developer Christoph Pojer, MooTools FileManager is a MooTools-driven file manager that allows for drag and drop file management, Ajax directory loading, file content previews, and much more.

http://cpojer.net/blog/MooTools_based_FileManager

Moousture

Moousture is a MooTools Mouse Gesture library created by Zohaib Sibt-e-Hassan. Moousture allows you to create multiple geture patterns and assign them to any number of elements. http://neofreeman.freepgs.com/Moousture/

Fancy Upload 3

Fancy Upload 3 is the newest iteration of Harlad Kirschner’s popular Flash/MooTools upload tool. Fancy Upload 3 features file-specific options, an additional IFrame-based uploader, Flash 9 and 10 compatibility, and the same base features that made Fancy Upload a must-have plugin.

http://digitarald.de/project/fancyupload/

MooTools.Mode For Coda

If you spend hours with MooTools and the Coda text editor, you’ll love the MooTools.Mode Syntax Mode add-in. This package created by José Prado is free and easy to install.

http://pradador.com/code/coda/moomode.html

Keep Up the Good Work!

These are just a few of the great MooTools plugins floating around the MooTools community recently. Keep up the good work and we look forward to featuring your future plugins in upcoming posts!

MooTools 1.2.3 DOM stuff doesn’t depend on the presence of $ anymore. The method that used to be $ is now called document.id (short for identify). The method $ is still assigned when not already present in the page, and aliased to document.id.

But let me show you how it works:

Let’s say you have mootools.js and a fictional JS library called jLib.js. Both use a method called $.

This is what it used to happen:

Scenario 1: Include mootools first:

<script type="text/javascript" src="mootools.js" />
<script type="text/javascript" src="jLib.js" />

jLib would “steal” the $ method from MooTools. MooTools doesn’t work unless jLib has some sort of no-conflict mode of its own that will allow you to prevent it from “stealing” $ from MooTools.

Scenario 2: Include jLib first:

<script type="text/javascript" src="jLib.js" />
<script type="text/javascript" src="mootools.js" />

MooTools would “steal” the $ method from jLib, which may or may not work without it.

What happens now:

Scenario 1: Include MooTools first:

<script type="text/javascript" src="mootools.js" />
<script type="text/javascript" src="jLib.js" />

MooTools checks if a method called $ exists; if not, it defines it. In this scenario, MooTools defines it as it doesn’t find anything named $, being included first. jLib “steals” the $ method from MooTools. MooTools doesn’t care. MooTools now doesnt need $ to properly function. You can regain control of $ simply by reassigning it to its alias ($ = document.id).

Scenario 2: Include jLib first:

<script type="text/javascript" src="jLib.js" />
<script type="text/javascript" src="mootools.js" />

MooTools checks if a method called $ exists. It does find it, being included last, therefore it doesn’t define it. You can directly use document.id() or assign your own var to it, or manually assign $ to document.id, if you would like MooTools to have control of it.

As you can see, it’s pretty straightforward. In short, MooTools doesn’t need $ to function anymore, and doesn’t steal it from other frameworks when included after them.

Plugins

The above applies for MooTools-Core and MooTools-More. However, MooTools plugins use the $ method, therefore, while not breaking MooTools by including jLib, you will break the MooTools plugins. If you desperately need plugins to be multiple-framework compatible, and you the other frameworks to have control of $, there are a few things you can do.

The first, most obvious and recommended option is to replace every call to $() with document.id() by hand. It doesn’t take more than 10 seconds with a simple find and replace. This is probably what plugin authors should do, if they wish their plugin to be dollar-safe.

Another option is to encapsulate the plugin using a closure. This might come handy if you are processing a plugin that isn’t yours:

var X = new Class({
    initialize: function(element){
        this.element = $(element);
    }
});

it should become:

(function(){

    var $ = document.id;

    this.X = new Class({
        initialize: function(element){
            this.element = $(element);
        }
    });

})();

As you can see, we’ve simply assigned $ as a local variable, using a closure. Everything in that closure will use document.id as its $ method. Remember to export the global variables though, as vars defined in the closure will stay private. I like to export globals using this., but you can use window. as well.

Please note that MooTools will probably remain incompatible with other frameworks that modify native prototypes, as there will probably be more name clashes. This isn’t a cross-framework compatible MooTools version by any means, nor does it want to be. The whole point is not to “steal” the dollar function from other libraries.

And that’s pretty much it about the Dollar Safe Mode™ in MooTools 1.2.3.

The value in making this change is allowing developers to use more than one framework within a page (which is NOT something we recommend or endorse, but we recognize this is not always under the developer’s control). Not relying on the dollar function prevents the need for jQuery.noConflict() when using jQuery and MooTools together, for example. If no other framework is detected, however, $ will be assigned to MooTools. This means that all of your current MooTools code WILL NOT break. It does, however, mean that if you want to use MooTools and jQuery together (without using jQuery’s noConflict mode), instead of using $ in your MooTools code, you’ll have to use document.id().

If you want your MooTools plugins to be cross-framework compatible, you’ll have to replace all the instances of $ with document.id().This change only applies if you’re using more than one framework on your pages. If all you use is MooTools, nothing will change for you. Look forward to more details about Framework compatibility mode in a future post.

MooTools Core & More Updates

While we encourage you to browse LightHouse and the histories for MooTools Core and MooTools More to get the most detailed list of changes, the following significant updates were committed in MooTools 1.2.3:

Core

• Element: MooTools compatibility mode: the $ function is only defined if no pre-existing $ function is found. If an existing $ function is found, you can use document.id()
• Element: changed internal instances of $ to document.id
• Core: fix for server-side MS JScript 5.x; makes MooTools more friendly for server side programming
• Class: Class doesn’t require Browser, removed from scripts.json
• Element: Fixes for set/get Property
• Element.Dimensions: fix for webkit body.scrollTop inconsistency, getBoundingClientRect used whenever possible (not just for Trident), renaming element.position to element.setPosition; adding docs for the method; alias is included in-line for compatibility
• Hash: Hash extend no longer uses the window if no arguments supplied
• Request: clearing Request readystate before calling success or failure;
• Selectors: Added :enabled pseudoselector, was in the Docs but not implemented.
• Docs: Fixed docs headers for first-child, last-child, and only-child.
• Internal: UnitTester test suite is now a git submodule
• Numerous small fixes, speed improvements, documentation tweaks, etc.

More

• Per the change in -core, $ is no longer used (uses document.id instead)
• Element.Measure: trying cssText solution for Element.expose (again).
• Element.Forms: swapping feature detection for browser support per
• Date: Massive refactoring of Date.js and Date.Extras.js
• Drag.Move: Fixing drag with grid issues
• IframeShim: altering zindex assignment in IframeShim to better ensure that it’s always underneath the shimmed element, updating Iframeshim’s empty document creation; fixes https issues in IE6
• FormValidator: reworking formvalidator scroll-to logic to be a little more efficient
• OverText: preventing overtext from focusing on inputs except when they are interacted with (so OverText.update() does not focus an input);now stops polling when elements are hidden (when polling is enabled)
• Fx.Scroll: adding scrollIntoView method - scrolls an element so that it is completely visible; if below the view, scrolls down until it is at the bottom of the screen, if above, scrolls up until it is at the top.
• JSONP: was calling (the deprecated) this.request instead of this.send during retries
• URI: Adding set(‘data’, obj) to set
• Assets: adding error callback for Assets.images
• Tips: removing dependency for Element.Measure for Tips; updating CSS class name in OverText
• Numerous small fixes, speed improvements, documentation tweaks, etc.

MooTools 2.0 is on the Horizon

As mentioned above, 1.2.3 is likely the last update for MooTools 1.2. MooTools 2.0 will introduce numerous performance improvements and new features. We want to stress that MooTools 2.0 will feature 100% compatibility with MooTools 1.2.x.

Thank You!

Thank you for the bug fixes, feature requests, and support during MooTools’ 1.* lifetime. You, the MooTools community, have helped make this framework better with every bug found and question asked on the forum. We look forward to releasing MooTools 2.0 this summer and getting feedback from everyone in this awesome community.

Last week we announced that MooTools merchandise was available for purchase. We’ve seen a great response to the announcement and we’ve received a solid amount of orders. Thank you for your continued support! Now it’s time for us to show you our appreciation.

The MooTools team would like to announce Faces of Moo. Faces of Moo is where we post photos of you and fellow community members wearing your MooTools shirts, hats, and hoodies. What better way to strengthen the MooTools community than by showing its talented members wearing their Moo colors?

What do you need from me?

Please provide the following items:

• Name (if you feel comfortable sharing)
• Location (ex: “Los Angeles, CA, USA”)
• Website URL (if you have one)
• Photo (we will crop/resize as needed, so please provide a large photo)

Easy enough, right?

Where do I send my information?

Please send the information above to mootoolspeople@gmail.com. We’ll get you up on the site as soon as we can.

Thank you!

Again — thank you, thank you, thank you for all of your support and look forward to bigger and better things from the MooTools team!

• T-Shirts
• Hoodies
• Laptop Bags
• Hats

You can purchase these stylish items at: http://mootools.net/merch

Feedback wanted!

Can you think of merchandise you’d like to see in the MooTools store? Be sure to let us know in the comments below!

What are you waiting for?

Grab your MooTools merchandise and represent your framework!

Note: The above link will attempt to send you to the correct store based upon your location. If the above link fails, please visit http://mad4milk.spreadshirt.com/ if you are in the US and http://mad4milk.spreadshirt.net/ if you are in Europe.

• Removed debug statement that enabled IframeShim in all browsers by default
• Fixed a few docs typos
• Removed UTF-8 charset signature on String.QueryString and URI.Relative
• Assets.image now have an onError option and handle image load failure more gracefully
• FormValidator.Inline had issues displaying some of it’s validators when input values changed
• OverText now allows you to specify the element type for the label test (defaults to “label”)
• Fixed an issue with addRequests in Request.Queue; the arguments were reversed (addQueue still worked fine though)

None of these changes should affect your usage of the class, except, possibly, the change to OverText, as the element it previously created for the labels was a div. If you styled these with css and referenced the tag name, you’ll either need to update your css reference or pass in element: “div” as an option when you invoke the class.