Ticket #14370: ticket-14730.diff

django/contrib/admin/media/css/widgets.css

@@ -511 +511 @@
     border-top: 1px solid #ddd;
 }
 
+/* AUTOCOMPLETE */
+/* *** NOTE ***
+   This is mostly culled from css generated by http://jqueryui.com/themeroller
+   */
+.ui-menu {
+    display: block;
+    float: left;
+    list-style: none outside none;
+    margin: 0;
+    padding: 2px;
+}
+.ui-menu .ui-menu-item a {
+    display: block;
+    line-height: 1.5;
+    padding: 0.2em 0.4em;
+    text-decoration: none;
+}
+
+.ui-autocomplete {
+    cursor: default;
+    position: absolute;
+}
+
+form .aligned ul.ui-autocomplete {
+    padding: 2px;
+}
+.ui-widget-content {
+    background: #fcfdfd;
+    border: 1px solid #a6c9e2;
+    color: #222222;
+}
+.ui-menu .ui-menu-item {
+    background: #fcfdfd;
+    clear: left;
+    float: left;
+    margin: 0;
+    padding: 0;
+    width: 100%;
+}
+.ui-menu .ui-menu-item a {
+    border: 1px solid #fcfdfd;
+}
+ul.ui-menu li,
+.ui-autocomplete-value {
+    list-style-type: none;
+}
+.ui-state-hover, .ui-state-focus {
+    color: #fff;
+    background: #417690;
+    border: 1px solid #417690;
+}
+
+.ui-autocomplete-value a {
+    margin-left: 0.5em;
+}
+.djangoautocomplete-wrapper > * { 
+    float: left; 
+}
+.djangoautocomplete-wrapper > ul { 
+    clear: left; 
+}
+.related-lookup {
+    position: relative;
+    top: 4px;
+    left: 2px;
+}

django/contrib/admin/media/js/admin/RelatedObjectLookups.js

@@ -44 +44 @@
 function dismissRelatedLookupPopup(win, chosenId) {
     var name = windowname_to_id(win.name);
     var elem = document.getElementById(name);
-    if (elem.className.indexOf('vManyToManyRawIdAdminField') != -1 && elem.value) {
+    var $ = django && django.jQuery;
+    var autocomplete_elem = !!$ && $(elem);
+    if (!!autocomplete_elem && !!autocomplete_elem.data('djangoautocomplete')) {
+        $.getJSON(
+                autocomplete_elem.data('djangoautocomplete').options.source,
+                {term: chosenId, by_id: 1},
+                function (data) {
+                    // Pass the returned item to the normal
+                    // autocomplete onSelect handler.
+                    autocomplete_elem.data('autocomplete')
+                        .options.select({}, {item: data[0]});
+                });
+    }
+    else if (elem.className.indexOf('vManyToManyRawIdAdminField') != -1 && elem.value) {
         elem.value += ',' + chosenId;
     } else {
-        document.getElementById(name).value = chosenId;
+        elem.value = chosenId;
     }
     win.close();
 }
@@ -79 +92 @@
             elem.options[elem.options.length] = o;
             o.selected = true;
         } else if (elem.nodeName == 'INPUT') {
-            if (elem.className.indexOf('vManyToManyRawIdAdminField') != -1 && elem.value) {
+            var autocomplete_elem = django && django.jQuery && django.jQuery(elem);
+            if (!!autocomplete_elem && !!autocomplete_elem.data('djangoautocomplete')) {
+                django.jQuery.getJSON(
+                    autocomplete_elem.data('djangoautocomplete').options.source,
+                    {term: newId, by_id: 1},
+                    function (data) {
+                        // Pass the returned item to the normal
+                        // autocomplete onSelect handler.
+                        autocomplete_elem.data('autocomplete')
+                            .options.select({}, {item: data[0]});
+                    });
+            } else if (elem.className.indexOf('vManyToManyRawIdAdminField') != -1 && elem.value) {
                 elem.value += ',' + newId;
             } else {
                 elem.value = newId;

new file django/contrib/admin/media/js/admin/autocomplete.js

@@ +1 @@
+(function ($) {
+"use strict";
+
+$.widget("ui.djangoautocomplete", {
+    options: {
+        source: "../autocomplete/$name/",
+        multiple: false,
+        force_selection: true,
+        renderItem: function (ul, item) {
+            return $("<li></li>")
+                .data("item.autocomplete", item)
+                .append($("<a></a>").append(item.label))
+                .appendTo(ul);
+        },
+      is_djangoautocomplete: true
+    },
+    _create: function () {
+        var self = this;
+        this.hidden_input = this.element.prev("input[type=hidden]");
+        this.name = this.hidden_input.attr("name");
+        this.element.autocomplete({
+            appendTo: this.element.parent(),
+            select: function (event, ui) {
+                if (!ui.item) { return; /* unexpected result */ }
+                var item = ui.item.data && ui.item.data("item.autocomplete") || ui.item;
+                self.lastSelected = item;
+                if (self.options.is_djangoautocomplete === true) {
+                    if (self.options.multiple) {
+                        if ($.inArray(item.id, self.values) < 0) {
+                            $('<li></li>')
+                                .addClass("ui-autocomplete-value")
+                                .data("value.autocomplete", item.id)
+                                .append(item.label + '<a href="#">x</a>')
+                                .appendTo(self.values_ul);
+                            self.values.push(item.id);
+                        }
+                    } else {
+                        self.term = item.value;
+                        self.element.val(item.value);
+                    }
+                    return false;
+                }
+            }
+        }).data("autocomplete")._renderItem = this.options.renderItem;
+        this._initSource();
+        if (this.options.multiple) {
+            this._initManyToMany();
+        } else {
+            this.lastSelected = {
+                id: this.hidden_input.val(),
+                value: this.element.val()
+            };
+        }
+        if (this.options.force_selection) {
+            this.element.focusout(function () {
+                if (self.element.val() !== self.lastSelected.value) {
+                    self.element.val("");
+                }
+            });
+        }
+        this.element.closest("form").submit(function () {
+            if (self.options.multiple) {
+                self.hidden_input.val(self.values.join(","));
+            } else if (self.options.force_selection) {
+                self.hidden_input.val(self.element.val() ? self.lastSelected.id : "");
+            } else {
+                self.hidden_input.val(self.element.val());
+            }
+        });
+    },
+    
+    destroy: function () {
+        this.element.autocomplete("destroy");
+        if (this.options.multiple) {
+            this.values_ul.remove();
+        }
+                $.Widget.prototype.destroy.call(this);
+    },
+
+    _setOption: function (key, value) {
+                $.Widget.prototype._setOption.apply(this, arguments);
+        if (key === "source") {
+            this._initSource();
+        }
+    },
+
+    _initSource: function () {
+        var source = typeof this.options.source === "string" ?
+            this.options.source.replace("$name", this.hidden_input.attr("name")) :
+            this.options.source;
+        this.element.autocomplete("option", "source", source);
+    },
+
+    _initManyToMany: function () {
+        var self = this;
+        this.element.bind("autocompleteclose", function (event, ui) {
+            self.element.val("");
+        });
+        this.values = [];
+        if (this.hidden_input.val() !== "") {
+            $.each(this.hidden_input.val().split(","), function (i, id) {
+                self.values.push(parseInt(id, 10));
+            });
+        }
+        this.values_ul = this.element.nextAll("ul.ui-autocomplete-values");
+        this.lastSelected = { id: null, value: null };
+        if (this.values.length && this.values_ul[0]) {
+            this.values_ul.children().each(function (i) {
+                $(this)
+                    .addClass("ui-autocomplete-value")
+                    .data("value.autocomplete", self.values[i])
+                    .append('<a href="#">x</a>');
+            });
+        } else {
+            this.values_ul = $("<ul></ul>").insertAfter(this.element);
+        }
+        this.values_ul.addClass("ui-autocomplete-values");
+        $(".ui-autocomplete-value a", this.values_ul[0]).live("click", function () {
+            var span = $(this).parent(),
+                id = span.data("value.autocomplete");
+            $.each(self.values, function (i, v) {
+                if (v === id) { 
+                    self.values.splice(i, 1); 
+                }
+            });
+            span.remove();
+        });
+    }
+});
+
+})(django.jQuery);

new file django/contrib/admin/media/js/jquery-ui.js

@@ +1 @@
+/*!
+ * jQuery UI 1.8.5
+ *
+ * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * http://docs.jquery.com/UI
+ */
+(function( $, undefined ) {
+
+// prevent duplicate loading
+// this is only a problem because we proxy existing functions
+// and we don't want to double proxy them
+$.ui = $.ui || {};
+if ( $.ui.version ) {
+        return;
+}
+
+$.extend( $.ui, {
+        version: "1.8.5",
+
+        keyCode: {
+                ALT: 18,
+                BACKSPACE: 8,
+                CAPS_LOCK: 20,
+                COMMA: 188,
+                COMMAND: 91,
+                COMMAND_LEFT: 91, // COMMAND
+                COMMAND_RIGHT: 93,
+                CONTROL: 17,
+                DELETE: 46,
+                DOWN: 40,
+                END: 35,
+                ENTER: 13,
+                ESCAPE: 27,
+                HOME: 36,
+                INSERT: 45,
+                LEFT: 37,
+                MENU: 93, // COMMAND_RIGHT
+                NUMPAD_ADD: 107,
+                NUMPAD_DECIMAL: 110,
+                NUMPAD_DIVIDE: 111,
+                NUMPAD_ENTER: 108,
+                NUMPAD_MULTIPLY: 106,
+                NUMPAD_SUBTRACT: 109,
+                PAGE_DOWN: 34,
+                PAGE_UP: 33,
+                PERIOD: 190,
+                RIGHT: 39,
+                SHIFT: 16,
+                SPACE: 32,
+                TAB: 9,
+                UP: 38,
+                WINDOWS: 91 // COMMAND
+        }
+});
+
+// plugins
+$.fn.extend({
+        _focus: $.fn.focus,
+        focus: function( delay, fn ) {
+                return typeof delay === "number" ?
+                        this.each(function() {
+                                var elem = this;
+                                setTimeout(function() {
+                                        $( elem ).focus();
+                                        if ( fn ) {
+                                                fn.call( elem );
+                                        }
+                                }, delay );
+                        }) :
+                        this._focus.apply( this, arguments );
+        },
+
+        scrollParent: function() {
+                var scrollParent;
+                if (($.browser.msie && (/(static|relative)/).test(this.css('position'))) || (/absolute/).test(this.css('position'))) {
+                        scrollParent = this.parents().filter(function() {
+                                return (/(relative|absolute|fixed)/).test($.curCSS(this,'position',1)) && (/(auto|scroll)/).test($.curCSS(this,'overflow',1)+$.curCSS(this,'overflow-y',1)+$.curCSS(this,'overflow-x',1));
+                        }).eq(0);
+                } else {
+                        scrollParent = this.parents().filter(function() {
+                                return (/(auto|scroll)/).test($.curCSS(this,'overflow',1)+$.curCSS(this,'overflow-y',1)+$.curCSS(this,'overflow-x',1));
+                        }).eq(0);
+                }
+
+                return (/fixed/).test(this.css('position')) || !scrollParent.length ? $(document) : scrollParent;
+        },
+
+        zIndex: function( zIndex ) {
+                if ( zIndex !== undefined ) {
+                        return this.css( "zIndex", zIndex );
+                }
+
+                if ( this.length ) {
+                        var elem = $( this[ 0 ] ), position, value;
+                        while ( elem.length && elem[ 0 ] !== document ) {
+                                // Ignore z-index if position is set to a value where z-index is ignored by the browser
+                                // This makes behavior of this function consistent across browsers
+                                // WebKit always returns auto if the element is positioned
+                                position = elem.css( "position" );
+                                if ( position === "absolute" || position === "relative" || position === "fixed" ) {
+                                        // IE returns 0 when zIndex is not specified
+                                        // other browsers return a string
+                                        // we ignore the case of nested elements with an explicit value of 0
+                                        // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
+                                        value = parseInt( elem.css( "zIndex" ) );
+                                        if ( !isNaN( value ) && value != 0 ) {
+                                                return value;
+                                        }
+                                }
+                                elem = elem.parent();
+                        }
+                }
+
+                return 0;
+        },
+        
+        disableSelection: function() {
+                return this.bind(
+                        "mousedown.ui-disableSelection selectstart.ui-disableSelection",
+                        function( event ) {
+                                event.preventDefault();
+                        });
+        },
+
+        enableSelection: function() {
+                return this.unbind( ".ui-disableSelection" );
+        }
+});
+
+$.each( [ "Width", "Height" ], function( i, name ) {
+        var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
+                type = name.toLowerCase(),
+                orig = {
+                        innerWidth: $.fn.innerWidth,
+                        innerHeight: $.fn.innerHeight,
+                        outerWidth: $.fn.outerWidth,
+                        outerHeight: $.fn.outerHeight
+                };
+
+        function reduce( elem, size, border, margin ) {
+                $.each( side, function() {
+                        size -= parseFloat( $.curCSS( elem, "padding" + this, true) ) || 0;
+                        if ( border ) {
+                                size -= parseFloat( $.curCSS( elem, "border" + this + "Width", true) ) || 0;
+                        }
+                        if ( margin ) {
+                                size -= parseFloat( $.curCSS( elem, "margin" + this, true) ) || 0;
+                        }
+                });
+                return size;
+        }
+
+        $.fn[ "inner" + name ] = function( size ) {
+                if ( size === undefined ) {
+                        return orig[ "inner" + name ].call( this );
+                }
+
+                return this.each(function() {
+                        $.style( this, type, reduce( this, size ) + "px" );
+                });
+        };
+
+        $.fn[ "outer" + name] = function( size, margin ) {
+                if ( typeof size !== "number" ) {
+                        return orig[ "outer" + name ].call( this, size );
+                }
+
+                return this.each(function() {
+                        $.style( this, type, reduce( this, size, true, margin ) + "px" );
+                });
+        };
+});
+
+// selectors
+function visible( element ) {
+        return !$( element ).parents().andSelf().filter(function() {
+                return $.curCSS( this, "visibility" ) === "hidden" ||
+                        $.expr.filters.hidden( this );
+        }).length;
+}
+
+$.extend( $.expr[ ":" ], {
+        data: function( elem, i, match ) {
+                return !!$.data( elem, match[ 3 ] );
+        },
+
+        focusable: function( element ) {
+                var nodeName = element.nodeName.toLowerCase(),
+                        tabIndex = $.attr( element, "tabindex" );
+                if ( "area" === nodeName ) {
+                        var map = element.parentNode,
+                                mapName = map.name,
+                                img;
+                        if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
+                                return false;
+                        }
+                        img = $( "img[usemap=#" + mapName + "]" )[0];
+                        return !!img && visible( img );
+                }
+                return ( /input|select|textarea|button|object/.test( nodeName )
+                        ? !element.disabled
+                        : "a" == nodeName
+                                ? element.href || !isNaN( tabIndex )
+                                : !isNaN( tabIndex ))
+                        // the element and all of its ancestors must be visible
+                        && visible( element );
+        },
+
+        tabbable: function( element ) {
+                var tabIndex = $.attr( element, "tabindex" );
+                return ( isNaN( tabIndex ) || tabIndex >= 0 ) && $( element ).is( ":focusable" );
+        }
+});
+
+// support
+$(function() {
+        var div = document.createElement( "div" ),
+                body = document.body;
+
+        $.extend( div.style, {
+                minHeight: "100px",
+                height: "auto",
+                padding: 0,
+                borderWidth: 0
+        });
+
+        $.support.minHeight = body.appendChild( div ).offsetHeight === 100;
+        // set display to none to avoid a layout bug in IE
+        // http://dev.jquery.com/ticket/4014
+        body.removeChild( div ).style.display = "none";
+});
+
+
+
+
+
+// deprecated
+$.extend( $.ui, {
+        // $.ui.plugin is deprecated.  Use the proxy pattern instead.
+        plugin: {
+                add: function( module, option, set ) {
+                        var proto = $.ui[ module ].prototype;
+                        for ( var i in set ) {
+                                proto.plugins[ i ] = proto.plugins[ i ] || [];
+                                proto.plugins[ i ].push( [ option, set[ i ] ] );
+                        }
+                },
+                call: function( instance, name, args ) {
+                        var set = instance.plugins[ name ];
+                        if ( !set || !instance.element[ 0 ].parentNode ) {
+                                return;
+                        }
+        
+                        for ( var i = 0; i < set.length; i++ ) {
+                                if ( instance.options[ set[ i ][ 0 ] ] ) {
+                                        set[ i ][ 1 ].apply( instance.element, args );
+                                }
+                        }
+                }
+        },
+        
+        // will be deprecated when we switch to jQuery 1.4 - use jQuery.contains()
+        contains: function( a, b ) {
+                return document.compareDocumentPosition ?
+                        a.compareDocumentPosition( b ) & 16 :
+                        a !== b && a.contains( b );
+        },
+        
+        // only used by resizable
+        hasScroll: function( el, a ) {
+        
+                //If overflow is hidden, the element might have extra content, but the user wants to hide it
+                if ( $( el ).css( "overflow" ) === "hidden") {
+                        return false;
+                }
+        
+                var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
+                        has = false;
+        
+                if ( el[ scroll ] > 0 ) {
+                        return true;
+                }
+        
+                // TODO: determine which cases actually cause this to happen
+                // if the element doesn't have the scroll set, see if it's possible to
+                // set the scroll
+                el[ scroll ] = 1;
+                has = ( el[ scroll ] > 0 );
+                el[ scroll ] = 0;
+                return has;
+        },
+        
+        // these are odd functions, fix the API or move into individual plugins
+        isOverAxis: function( x, reference, size ) {
+                //Determines when x coordinate is over "b" element axis
+                return ( x > reference ) && ( x < ( reference + size ) );
+        },
+        isOver: function( y, x, top, left, height, width ) {
+                //Determines when x, y coordinates is over "b" element
+                return $.ui.isOverAxis( y, top, height ) && $.ui.isOverAxis( x, left, width );
+        }
+});
+
+})( jQuery );
+/*!
+ * jQuery UI Widget 1.8.5
+ *
+ * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * http://docs.jquery.com/UI/Widget
+ */
+(function( $, undefined ) {
+
+// jQuery 1.4+
+if ( $.cleanData ) {
+        var _cleanData = $.cleanData;
+        $.cleanData = function( elems ) {
+                for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
+                        $( elem ).triggerHandler( "remove" );
+                }
+                _cleanData( elems );
+        };
+} else {
+        var _remove = $.fn.remove;
+        $.fn.remove = function( selector, keepData ) {
+                return this.each(function() {
+                        if ( !keepData ) {
+                                if ( !selector || $.filter( selector, [ this ] ).length ) {
+                                        $( "*", this ).add( [ this ] ).each(function() {
+                                                $( this ).triggerHandler( "remove" );
+                                        });
+                                }
+                        }
+                        return _remove.call( $(this), selector, keepData );
+                });
+        };
+}
+
+$.widget = function( name, base, prototype ) {
+        var namespace = name.split( "." )[ 0 ],
+                fullName;
+        name = name.split( "." )[ 1 ];
+        fullName = namespace + "-" + name;
+
+        if ( !prototype ) {
+                prototype = base;
+                base = $.Widget;
+        }
+
+        // create selector for plugin
+        $.expr[ ":" ][ fullName ] = function( elem ) {
+                return !!$.data( elem, name );
+        };
+
+        $[ namespace ] = $[ namespace ] || {};
+        $[ namespace ][ name ] = function( options, element ) {
+                // allow instantiation without initializing for simple inheritance
+                if ( arguments.length ) {
+                        this._createWidget( options, element );
+                }
+        };
+
+        var basePrototype = new base();
+        // we need to make the options hash a property directly on the new instance
+        // otherwise we'll modify the options hash on the prototype that we're
+        // inheriting from
+//      $.each( basePrototype, function( key, val ) {
+//              if ( $.isPlainObject(val) ) {
+//                      basePrototype[ key ] = $.extend( {}, val );
+//              }
+//      });
+        basePrototype.options = $.extend( true, {}, basePrototype.options );
+        $[ namespace ][ name ].prototype = $.extend( true, basePrototype, {
+                namespace: namespace,
+                widgetName: name,
+                widgetEventPrefix: $[ namespace ][ name ].prototype.widgetEventPrefix || name,
+                widgetBaseClass: fullName
+        }, prototype );
+
+        $.widget.bridge( name, $[ namespace ][ name ] );
+};
+
+$.widget.bridge = function( name, object ) {
+        $.fn[ name ] = function( options ) {
+                var isMethodCall = typeof options === "string",
+                        args = Array.prototype.slice.call( arguments, 1 ),
+                        returnValue = this;
+
+                // allow multiple hashes to be passed on init
+                options = !isMethodCall && args.length ?
+                        $.extend.apply( null, [ true, options ].concat(args) ) :
+                        options;
+
+                // prevent calls to internal methods
+                if ( isMethodCall && options.substring( 0, 1 ) === "_" ) {
+                        return returnValue;
+                }
+
+                if ( isMethodCall ) {
+                        this.each(function() {
+                                var instance = $.data( this, name );
+                                if ( !instance ) {
+                                        throw "cannot call methods on " + name + " prior to initialization; " +
+                                                "attempted to call method '" + options + "'";
+                                }
+                                if ( !$.isFunction( instance[options] ) ) {
+                                        throw "no such method '" + options + "' for " + name + " widget instance";
+                                }
+                                var methodValue = instance[ options ].apply( instance, args );
+                                if ( methodValue !== instance && methodValue !== undefined ) {
+                                        returnValue = methodValue;
+                                        return false;
+                                }
+                        });
+                } else {
+                        this.each(function() {
+                                var instance = $.data( this, name );
+                                if ( instance ) {
+                                        instance.option( options || {} )._init();
+                                } else {
+                                        $.data( this, name, new object( options, this ) );
+                                }
+                        });
+                }
+
+                return returnValue;
+        };
+};
+
+$.Widget = function( options, element ) {
+        // allow instantiation without initializing for simple inheritance
+        if ( arguments.length ) {
+                this._createWidget( options, element );
+        }
+};
+
+$.Widget.prototype = {
+        widgetName: "widget",
+        widgetEventPrefix: "",
+        options: {
+                disabled: false
+        },
+        _createWidget: function( options, element ) {
+                // $.widget.bridge stores the plugin instance, but we do it anyway
+                // so that it's stored even before the _create function runs
+                $.data( element, this.widgetName, this );
+                this.element = $( element );
+                this.options = $.extend( true, {},
+                        this.options,
+                        $.metadata && $.metadata.get( element )[ this.widgetName ],
+                        options );
+
+                var self = this;
+                this.element.bind( "remove." + this.widgetName, function() {
+                        self.destroy();
+                });
+
+                this._create();
+                this._init();
+        },
+        _create: function() {},
+        _init: function() {},
+
+        destroy: function() {
+                this.element
+                        .unbind( "." + this.widgetName )
+                        .removeData( this.widgetName );
+                this.widget()
+                        .unbind( "." + this.widgetName )
+                        .removeAttr( "aria-disabled" )
+                        .removeClass(
+                                this.widgetBaseClass + "-disabled " +
+                                "ui-state-disabled" );
+        },
+
+        widget: function() {
+                return this.element;
+        },
+
+        option: function( key, value ) {
+                var options = key,
+                        self = this;
+
+                if ( arguments.length === 0 ) {
+                        // don't return a reference to the internal hash
+                        return $.extend( {}, self.options );
+                }
+
+                if  (typeof key === "string" ) {
+                        if ( value === undefined ) {
+                                return this.options[ key ];
+                        }
+                        options = {};
+                        options[ key ] = value;
+                }
+
+                $.each( options, function( key, value ) {
+                        self._setOption( key, value );
+                });
+
+                return self;
+        },
+        _setOption: function( key, value ) {
+                this.options[ key ] = value;
+
+                if ( key === "disabled" ) {
+                        this.widget()
+                                [ value ? "addClass" : "removeClass"](
+                                        this.widgetBaseClass + "-disabled" + " " +
+                                        "ui-state-disabled" )
+                                .attr( "aria-disabled", value );
+                }
+
+                return this;
+        },
+
+        enable: function() {
+                return this._setOption( "disabled", false );
+        },
+        disable: function() {
+                return this._setOption( "disabled", true );
+        },
+
+        _trigger: function( type, event, data ) {
+                var callback = this.options[ type ];
+
+                event = $.Event( event );
+                event.type = ( type === this.widgetEventPrefix ?
+                        type :
+                        this.widgetEventPrefix + type ).toLowerCase();
+                data = data || {};
+
+                // copy original event properties over to the new event
+                // this would happen if we could call $.event.fix instead of $.Event
+                // but we don't have a way to force an event to be fixed multiple times
+                if ( event.originalEvent ) {
+                        for ( var i = $.event.props.length, prop; i; ) {
+                                prop = $.event.props[ --i ];
+                                event[ prop ] = event.originalEvent[ prop ];
+                        }
+                }
+
+                this.element.trigger( event, data );
+
+                return !( $.isFunction(callback) &&
+                        callback.call( this.element[0], event, data ) === false ||
+                        event.isDefaultPrevented() );
+        }
+};
+
+})( jQuery );
+/*
+ * jQuery UI Position 1.8.5
+ *
+ * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * http://docs.jquery.com/UI/Position
+ */
+(function( $, undefined ) {
+
+$.ui = $.ui || {};
+
+var horizontalPositions = /left|center|right/,
+        verticalPositions = /top|center|bottom/,
+        center = "center",
+        _position = $.fn.position,
+        _offset = $.fn.offset;
+
+$.fn.position = function( options ) {
+        if ( !options || !options.of ) {
+                return _position.apply( this, arguments );
+        }
+
+        // make a copy, we don't want to modify arguments
+        options = $.extend( {}, options );
+
+        var target = $( options.of ),
+                targetElem = target[0],
+                collision = ( options.collision || "flip" ).split( " " ),
+                offset = options.offset ? options.offset.split( " " ) : [ 0, 0 ],
+                targetWidth,
+                targetHeight,
+                basePosition;
+
+        if ( targetElem.nodeType === 9 ) {
+                targetWidth = target.width();
+                targetHeight = target.height();
+                basePosition = { top: 0, left: 0 };
+        } else if ( targetElem.scrollTo && targetElem.document ) {
+                targetWidth = target.width();
+                targetHeight = target.height();
+                basePosition = { top: target.scrollTop(), left: target.scrollLeft() };
+        } else if ( targetElem.preventDefault ) {
+                // force left top to allow flipping
+                options.at = "left top";
+                targetWidth = targetHeight = 0;
+                basePosition = { top: options.of.pageY, left: options.of.pageX };
+        } else {
+                targetWidth = target.outerWidth();
+                targetHeight = target.outerHeight();
+                basePosition = target.offset();
+        }
+
+        // force my and at to have valid horizontal and veritcal positions
+        // if a value is missing or invalid, it will be converted to center 
+        $.each( [ "my", "at" ], function() {
+                var pos = ( options[this] || "" ).split( " " );
+                if ( pos.length === 1) {
+                        pos = horizontalPositions.test( pos[0] ) ?
+                                pos.concat( [center] ) :
+                                verticalPositions.test( pos[0] ) ?
+                                        [ center ].concat( pos ) :
+                                        [ center, center ];
+                }
+                pos[ 0 ] = horizontalPositions.test( pos[0] ) ? pos[ 0 ] : center;
+                pos[ 1 ] = verticalPositions.test( pos[1] ) ? pos[ 1 ] : center;
+                options[ this ] = pos;
+        });
+
+        // normalize collision option
+        if ( collision.length === 1 ) {
+                collision[ 1 ] = collision[ 0 ];
+        }
+
+        // normalize offset option
+        offset[ 0 ] = parseInt( offset[0], 10 ) || 0;
+        if ( offset.length === 1 ) {
+                offset[ 1 ] = offset[ 0 ];
+        }
+        offset[ 1 ] = parseInt( offset[1], 10 ) || 0;
+
+        if ( options.at[0] === "right" ) {
+                basePosition.left += targetWidth;
+        } else if (options.at[0] === center ) {
+                basePosition.left += targetWidth / 2;
+        }
+
+        if ( options.at[1] === "bottom" ) {
+                basePosition.top += targetHeight;
+        } else if ( options.at[1] === center ) {
+                basePosition.top += targetHeight / 2;
+        }
+
+        basePosition.left += offset[ 0 ];
+        basePosition.top += offset[ 1 ];
+
+        return this.each(function() {
+                var elem = $( this ),
+                        elemWidth = elem.outerWidth(),
+                        elemHeight = elem.outerHeight(),
+                        marginLeft = parseInt( $.curCSS( this, "marginLeft", true ) ) || 0,
+                        marginTop = parseInt( $.curCSS( this, "marginTop", true ) ) || 0,
+                        collisionWidth = elemWidth + marginLeft +
+                                parseInt( $.curCSS( this, "marginRight", true ) ) || 0,
+                        collisionHeight = elemHeight + marginTop +
+                                parseInt( $.curCSS( this, "marginBottom", true ) ) || 0,
+                        position = $.extend( {}, basePosition ),
+                        collisionPosition;
+
+                if ( options.my[0] === "right" ) {
+                        position.left -= elemWidth;
+                } else if ( options.my[0] === center ) {
+                        position.left -= elemWidth / 2;
+                }
+
+                if ( options.my[1] === "bottom" ) {
+                        position.top -= elemHeight;
+                } else if ( options.my[1] === center ) {
+                        position.top -= elemHeight / 2;
+                }
+
+                // prevent fractions (see #5280)
+                position.left = parseInt( position.left );
+                position.top = parseInt( position.top );
+
+                collisionPosition = {
+                        left: position.left - marginLeft,
+                        top: position.top - marginTop
+                };
+
+                $.each( [ "left", "top" ], function( i, dir ) {
+                        if ( $.ui.position[ collision[i] ] ) {
+                                $.ui.position[ collision[i] ][ dir ]( position, {
+                                        targetWidth: targetWidth,
+                                        targetHeight: targetHeight,
+                                        elemWidth: elemWidth,
+                                        elemHeight: elemHeight,
+                                        collisionPosition: collisionPosition,
+                                        collisionWidth: collisionWidth,
+                                        collisionHeight: collisionHeight,
+                                        offset: offset,
+                                        my: options.my,
+                                        at: options.at
+                                });
+                        }
+                });
+
+                if ( $.fn.bgiframe ) {
+                        elem.bgiframe();
+                }
+                elem.offset( $.extend( position, { using: options.using } ) );
+        });
+};
+
+$.ui.position = {
+        fit: {
+                left: function( position, data ) {
+                        var win = $( window ),
+                                over = data.collisionPosition.left + data.collisionWidth - win.width() - win.scrollLeft();
+                        position.left = over > 0 ? position.left - over : Math.max( position.left - data.collisionPosition.left, position.left );
+                },
+                top: function( position, data ) {
+                        var win = $( window ),
+                                over = data.collisionPosition.top + data.collisionHeight - win.height() - win.scrollTop();
+                        position.top = over > 0 ? position.top - over : Math.max( position.top - data.collisionPosition.top, position.top );
+                }
+        },
+
+        flip: {
+                left: function( position, data ) {
+                        if ( data.at[0] === center ) {
+                                return;
+                        }
+                        var win = $( window ),
+                                over = data.collisionPosition.left + data.collisionWidth - win.width() - win.scrollLeft(),
+                                myOffset = data.my[ 0 ] === "left" ?
+                                        -data.elemWidth :
+                                        data.my[ 0 ] === "right" ?
+                                                data.elemWidth :
+                                                0,
+                                atOffset = data.at[ 0 ] === "left" ?
+                                        data.targetWidth :
+                                        -data.targetWidth,
+                                offset = -2 * data.offset[ 0 ];
+                        position.left += data.collisionPosition.left < 0 ?
+                                myOffset + atOffset + offset :
+                                over > 0 ?
+                                        myOffset + atOffset + offset :
+                                        0;
+                },
+                top: function( position, data ) {
+                        if ( data.at[1] === center ) {
+                                return;
+                        }
+                        var win = $( window ),
+                                over = data.collisionPosition.top + data.collisionHeight - win.height() - win.scrollTop(),
+                                myOffset = data.my[ 1 ] === "top" ?
+                                        -data.elemHeight :
+                                        data.my[ 1 ] === "bottom" ?
+                                                data.elemHeight :
+                                                0,
+                                atOffset = data.at[ 1 ] === "top" ?
+                                        data.targetHeight :
+                                        -data.targetHeight,
+                                offset = -2 * data.offset[ 1 ];
+                        position.top += data.collisionPosition.top < 0 ?
+                                myOffset + atOffset + offset :
+                                over > 0 ?
+                                        myOffset + atOffset + offset :
+                                        0;
+                }
+        }
+};
+
+// offset setter from jQuery 1.4
+if ( !$.offset.setOffset ) {
+        $.offset.setOffset = function( elem, options ) {
+                // set position first, in-case top/left are set even on static elem
+                if ( /static/.test( $.curCSS( elem, "position" ) ) ) {
+                        elem.style.position = "relative";
+                }
+                var curElem   = $( elem ),
+                        curOffset = curElem.offset(),
+                        curTop    = parseInt( $.curCSS( elem, "top",  true ), 10 ) || 0,
+                        curLeft   = parseInt( $.curCSS( elem, "left", true ), 10)  || 0,
+                        props     = {
+                                top:  (options.top  - curOffset.top)  + curTop,
+                                left: (options.left - curOffset.left) + curLeft
+                        };
+                
+                if ( 'using' in options ) {
+                        options.using.call( elem, props );
+                } else {
+                        curElem.css( props );
+                }
+        };
+
+        $.fn.offset = function( options ) {
+                var elem = this[ 0 ];
+                if ( !elem || !elem.ownerDocument ) { return null; }
+                if ( options ) { 
+                        return this.each(function() {
+                                $.offset.setOffset( this, options );
+                        });
+                }
+                return _offset.call( this );
+        };
+}
+
+}( jQuery ));
+/*
+ * jQuery UI Autocomplete 1.8.5
+ *
+ * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * http://docs.jquery.com/UI/Autocomplete
+ *
+ * Depends:
+ *      jquery.ui.core.js
+ *      jquery.ui.widget.js
+ *      jquery.ui.position.js
+ */
+(function( $, undefined ) {
+
+$.widget( "ui.autocomplete", {
+        options: {
+                appendTo: "body",
+                delay: 300,
+                minLength: 1,
+                position: {
+                        my: "left top",
+                        at: "left bottom",
+                        collision: "none"
+                },
+                source: null
+        },
+        _create: function() {
+                var self = this,
+                        doc = this.element[ 0 ].ownerDocument;
+                this.element
+                        .addClass( "ui-autocomplete-input" )
+                        .attr( "autocomplete", "off" )
+                        // TODO verify these actually work as intended
+                        .attr({
+                                role: "textbox",
+                                "aria-autocomplete": "list",
+                                "aria-haspopup": "true"
+                        })
+                        .bind( "keydown.autocomplete", function( event ) {
+                                if ( self.options.disabled ) {
+                                        return;
+                                }
+
+                                var keyCode = $.ui.keyCode;
+                                switch( event.keyCode ) {
+                                case keyCode.PAGE_UP:
+                                        self._move( "previousPage", event );
+                                        break;
+                                case keyCode.PAGE_DOWN:
+                                        self._move( "nextPage", event );
+                                        break;
+                                case keyCode.UP:
+                                        self._move( "previous", event );
+                                        // prevent moving cursor to beginning of text field in some browsers
+                                        event.preventDefault();
+                                        break;
+                                case keyCode.DOWN:
+                                        self._move( "next", event );
+                                        // prevent moving cursor to end of text field in some browsers
+                                        event.preventDefault();
+                                        break;
+                                case keyCode.ENTER:
+                                case keyCode.NUMPAD_ENTER:
+                                        // when menu is open or has focus
+                                        if ( self.menu.element.is( ":visible" ) ) {
+                                                event.preventDefault();
+                                        }
+                                        //passthrough - ENTER and TAB both select the current element
+                                case keyCode.TAB:
+                                        if ( !self.menu.active ) {
+                                                return;
+                                        }
+                                        self.menu.select( event );
+                                        break;
+                                case keyCode.ESCAPE:
+                                        self.element.val( self.term );
+                                        self.close( event );
+                                        break;
+                                default:
+                                        // keypress is triggered before the input value is changed
+                                        clearTimeout( self.searching );
+                                        self.searching = setTimeout(function() {
+                                                // only search if the value has changed
+                                                if ( self.term != self.element.val() ) {
+                                                        self.selectedItem = null;
+                                                        self.search( null, event );
+                                                }
+                                        }, self.options.delay );
+                                        break;
+                                }
+                        })
+                        .bind( "focus.autocomplete", function() {
+                                if ( self.options.disabled ) {
+                                        return;
+                                }
+
+                                self.selectedItem = null;
+                                self.previous = self.element.val();
+                        })
+                        .bind( "blur.autocomplete", function( event ) {
+                                if ( self.options.disabled ) {
+                                        return;
+                                }
+
+                                clearTimeout( self.searching );
+                                // clicks on the menu (or a button to trigger a search) will cause a blur event
+                                self.closing = setTimeout(function() {
+                                        self.close( event );
+                                        self._change( event );
+                                }, 150 );
+                        });
+                this._initSource();
+                this.response = function() {
+                        return self._response.apply( self, arguments );
+                };
+                this.menu = $( "<ul></ul>" )
+                        .addClass( "ui-autocomplete" )
+                        .appendTo( $( this.options.appendTo || "body", doc )[0] )
+                        // prevent the close-on-blur in case of a "slow" click on the menu (long mousedown)
+                        .mousedown(function( event ) {
+                                // clicking on the scrollbar causes focus to shift to the body
+                                // but we can't detect a mouseup or a click immediately afterward
+                                // so we have to track the next mousedown and close the menu if
+                                // the user clicks somewhere outside of the autocomplete
+                                var menuElement = self.menu.element[ 0 ];
+                                if ( event.target === menuElement ) {
+                                        setTimeout(function() {
+                                                $( document ).one( 'mousedown', function( event ) {
+                                                        if ( event.target !== self.element[ 0 ] &&
+                                                                event.target !== menuElement &&
+                                                                !$.ui.contains( menuElement, event.target ) ) {
+                                                                self.close();
+                                                        }
+                                                });
+                                        }, 1 );
+                                }
+
+                                // use another timeout to make sure the blur-event-handler on the input was already triggered
+                                setTimeout(function() {
+                                        clearTimeout( self.closing );
+                                }, 13);
+                        })
+                        .menu({
+                                focus: function( event, ui ) {
+                                        var item = ui.item.data( "item.autocomplete" );
+                                        if ( false !== self._trigger( "focus", null, { item: item } ) ) {
+                                                // use value to match what will end up in the input, if it was a key event
+                                                if ( /^key/.test(event.originalEvent.type) ) {
+                                                        self.element.val( item.value );
+                                                }
+                                        }
+                                },
+                                selected: function( event, ui ) {
+                                        var item = ui.item.data( "item.autocomplete" ),
+                                                previous = self.previous;
+
+                                        // only trigger when focus was lost (click on menu)
+                                        if ( self.element[0] !== doc.activeElement ) {
+                                                self.element.focus();
+                                                self.previous = previous;
+                                        }
+
+                                        if ( false !== self._trigger( "select", event, { item: item } ) ) {
+                                                self.term = item.value;
+                                                self.element.val( item.value );
+                                        }
+
+                                        self.close( event );
+                                        self.selectedItem = item;
+                                },
+                                blur: function( event, ui ) {
+                                        // don't set the value of the text field if it's already correct
+                                        // this prevents moving the cursor unnecessarily
+                                        if ( self.menu.element.is(":visible") &&
+                                                ( self.element.val() !== self.term ) ) {
+                                                self.element.val( self.term );
+                                        }
+                                }
+                        })
+                        .zIndex( this.element.zIndex() + 1 )
+                        // workaround for jQuery bug #5781 http://dev.jquery.com/ticket/5781
+                        .css({ top: 0, left: 0 })
+                        .hide()
+                        .data( "menu" );
+                if ( $.fn.bgiframe ) {
+                         this.menu.element.bgiframe();
+                }
+        },
+
+        destroy: function() {
+                this.element
+                        .removeClass( "ui-autocomplete-input" )
+                        .removeAttr( "autocomplete" )
+                        .removeAttr( "role" )
+                        .removeAttr( "aria-autocomplete" )
+                        .removeAttr( "aria-haspopup" );
+                this.menu.element.remove();
+                $.Widget.prototype.destroy.call( this );
+        },
+
+        _setOption: function( key, value ) {
+                $.Widget.prototype._setOption.apply( this, arguments );
+                if ( key === "source" ) {
+                        this._initSource();
+                }
+                if ( key === "appendTo" ) {
+                        this.menu.element.appendTo( $( value || "body", this.element[0].ownerDocument )[0] )
+                }
+        },
+
+        _initSource: function() {
+                var self = this,
+                        array,
+                        url;
+                if ( $.isArray(this.options.source) ) {
+                        array = this.options.source;
+                        this.source = function( request, response ) {
+                                response( $.ui.autocomplete.filter(array, request.term) );
+                        };
+                } else if ( typeof this.options.source === "string" ) {
+                        url = this.options.source;
+                        this.source = function( request, response ) {
+                                if (self.xhr) {
+                                        self.xhr.abort();
+                                }
+                                self.xhr = $.getJSON( url, request, function( data, status, xhr ) {
+                                        if ( xhr === self.xhr ) {
+                                                response( data );
+                                        }
+                                        self.xhr = null;
+                                });
+                        };
+                } else {
+                        this.source = this.options.source;
+                }
+        },
+
+        search: function( value, event ) {
+                value = value != null ? value : this.element.val();
+
+                // always save the actual value, not the one passed as an argument
+                this.term = this.element.val();
+
+                if ( value.length < this.options.minLength ) {
+                        return this.close( event );
+                }
+
+                clearTimeout( this.closing );
+                if ( this._trigger("search") === false ) {
+                        return;
+                }
+
+                return this._search( value );
+        },
+
+        _search: function( value ) {
+                this.element.addClass( "ui-autocomplete-loading" );
+
+                this.source( { term: value }, this.response );
+        },
+
+        _response: function( content ) {
+                if ( content.length ) {
+                        content = this._normalize( content );
+                        this._suggest( content );
+                        this._trigger( "open" );
+                } else {
+                        this.close();
+                }
+                this.element.removeClass( "ui-autocomplete-loading" );
+        },
+
+        close: function( event ) {
+                clearTimeout( this.closing );
+                if ( this.menu.element.is(":visible") ) {
+                        this._trigger( "close", event );
+                        this.menu.element.hide();
+                        this.menu.deactivate();
+                }
+        },
+        
+        _change: function( event ) {
+                if ( this.previous !== this.element.val() ) {
+                        this._trigger( "change", event, { item: this.selectedItem } );
+                }
+        },
+
+        _normalize: function( items ) {
+                // assume all items have the right format when the first item is complete
+                if ( items.length && items[0].label && items[0].value ) {
+                        return items;
+                }
+                return $.map( items, function(item) {
+                        if ( typeof item === "string" ) {
+                                return {
+                                        label: item,
+                                        value: item
+                                };
+                        }
+                        return $.extend({
+                                label: item.label || item.value,
+                                value: item.value || item.label
+                        }, item );
+                });
+        },
+
+        _suggest: function( items ) {
+                var ul = this.menu.element
+                                .empty()
+                                .zIndex( this.element.zIndex() + 1 ),
+                        menuWidth,
+                        textWidth;
+                this._renderMenu( ul, items );
+                // TODO refresh should check if the active item is still in the dom, removing the need for a manual deactivate
+                this.menu.deactivate();
+                this.menu.refresh();
+                this.menu.element.show().position( $.extend({
+                        of: this.element
+                }, this.options.position ));
+
+                menuWidth = ul.width( "" ).outerWidth();
+                textWidth = this.element.outerWidth();
+                ul.outerWidth( Math.max( menuWidth, textWidth ) );
+        },
+
+        _renderMenu: function( ul, items ) {
+                var self = this;
+                $.each( items, function( index, item ) {
+                        self._renderItem( ul, item );
+                });
+        },
+
+        _renderItem: function( ul, item) {
+                return $( "<li></li>" )
+                        .data( "item.autocomplete", item )
+                        .append( $( "<a></a>" ).text( item.label ) )
+                        .appendTo( ul );
+        },
+
+        _move: function( direction, event ) {
+                if ( !this.menu.element.is(":visible") ) {
+                        this.search( null, event );
+                        return;
+                }
+                if ( this.menu.first() && /^previous/.test(direction) ||
+                                this.menu.last() && /^next/.test(direction) ) {
+                        this.element.val( this.term );
+                        this.menu.deactivate();
+                        return;
+                }
+                this.menu[ direction ]( event );
+        },
+
+        widget: function() {
+                return this.menu.element;
+        }
+});
+
+$.extend( $.ui.autocomplete, {
+        escapeRegex: function( value ) {
+                return value.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+        },
+        filter: function(array, term) {
+                var matcher = new RegExp( $.ui.autocomplete.escapeRegex(term), "i" );
+                return $.grep( array, function(value) {
+                        return matcher.test( value.label || value.value || value );
+                });
+        }
+});
+
+}( jQuery ));
+
+/*
+ * jQuery UI Menu (not officially released)
+ * 
+ * This widget isn't yet finished and the API is subject to change. We plan to finish
+ * it for the next release. You're welcome to give it a try anyway and give us feedback,
+ * as long as you're okay with migrating your code later on. We can help with that, too.
+ *
+ * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * http://docs.jquery.com/UI/Menu
+ *
+ * Depends:
+ *      jquery.ui.core.js
+ *  jquery.ui.widget.js
+ */
+(function($) {
+
+$.widget("ui.menu", {
+        _create: function() {
+                var self = this;
+                this.element
+                        .addClass("ui-menu ui-widget ui-widget-content ui-corner-all")
+                        .attr({
+                                role: "listbox",
+                                "aria-activedescendant": "ui-active-menuitem"
+                        })
+                        .click(function( event ) {
+                                if ( !$( event.target ).closest( ".ui-menu-item a" ).length ) {
+                                        return;
+                                }
+                                // temporary
+                                event.preventDefault();
+                                self.select( event );
+                        });
+                this.refresh();
+        },
+        
+        refresh: function() {
+                var self = this;
+
+                // don't refresh list items that are already adapted
+                var items = this.element.children("li:not(.ui-menu-item):has(a)")
+                        .addClass("ui-menu-item")
+                        .attr("role", "menuitem");
+                
+                items.children("a")
+                        .addClass("ui-corner-all")
+                        .attr("tabindex", -1)
+                        // mouseenter doesn't work with event delegation
+                        .mouseenter(function( event ) {
+                                self.activate( event, $(this).parent() );
+                        })
+                        .mouseleave(function() {
+                                self.deactivate();
+                        });
+        },
+
+        activate: function( event, item ) {
+                this.deactivate();
+                if (this.hasScroll()) {
+                        var offset = item.offset().top - this.element.offset().top,
+                                scroll = this.element.attr("scrollTop"),
+                                elementHeight = this.element.height();
+                        if (offset < 0) {
+                                this.element.attr("scrollTop", scroll + offset);
+                        } else if (offset >= elementHeight) {
+                                this.element.attr("scrollTop", scroll + offset - elementHeight + item.height());
+                        }
+                }
+                this.active = item.eq(0)
+                        .children("a")
+                                .addClass("ui-state-hover")
+                                .attr("id", "ui-active-menuitem")
+                        .end();
+                this._trigger("focus", event, { item: item });
+        },
+
+        deactivate: function() {
+                if (!this.active) { return; }
+
+                this.active.children("a")
+                        .removeClass("ui-state-hover")
+                        .removeAttr("id");
+                this._trigger("blur");
+                this.active = null;
+        },
+
+        next: function(event) {
+                this.move("next", ".ui-menu-item:first", event);
+        },
+
+        previous: function(event) {
+                this.move("prev", ".ui-menu-item:last", event);
+        },
+
+        first: function() {
+                return this.active && !this.active.prevAll(".ui-menu-item").length;
+        },
+
+        last: function() {
+                return this.active && !this.active.nextAll(".ui-menu-item").length;
+        },
+
+        move: function(direction, edge, event) {
+                if (!this.active) {
+                        this.activate(event, this.element.children(edge));
+                        return;
+                }
+                var next = this.active[direction + "All"](".ui-menu-item").eq(0);
+                if (next.length) {
+                        this.activate(event, next);
+                } else {
+                        this.activate(event, this.element.children(edge));
+                }
+        },
+
+        // TODO merge with previousPage
+        nextPage: function(event) {
+                if (this.hasScroll()) {
+                        // TODO merge with no-scroll-else
+                        if (!this.active || this.last()) {
+                                this.activate(event, this.element.children(":first"));
+                                return;
+                        }
+                        var base = this.active.offset().top,
+                                height = this.element.height(),
+                                result = this.element.children("li").filter(function() {
+                                        var close = $(this).offset().top - base - height + $(this).height();
+                                        // TODO improve approximation
+                                        return close < 10 && close > -10;
+                                });
+
+                        // TODO try to catch this earlier when scrollTop indicates the last page anyway
+                        if (!result.length) {
+                                result = this.element.children(":last");
+                        }
+                        this.activate(event, result);
+                } else {
+                        this.activate(event, this.element.children(!this.active || this.last() ? ":first" : ":last"));
+                }
+        },
+
+        // TODO merge with nextPage
+        previousPage: function(event) {
+                if (this.hasScroll()) {
+                        // TODO merge with no-scroll-else
+                        if (!this.active || this.first()) {
+                                this.activate(event, this.element.children(":last"));
+                                return;
+                        }
+
+                        var base = this.active.offset().top,
+                                height = this.element.height();
+                                result = this.element.children("li").filter(function() {
+                                        var close = $(this).offset().top - base + height - $(this).height();
+                                        // TODO improve approximation
+                                        return close < 10 && close > -10;
+                                });
+
+                        // TODO try to catch this earlier when scrollTop indicates the last page anyway
+                        if (!result.length) {
+                                result = this.element.children(":first");
+                        }
+                        this.activate(event, result);
+                } else {
+                        this.activate(event, this.element.children(!this.active || this.first() ? ":last" : ":first"));
+                }
+        },
+
+        hasScroll: function() {
+                return this.element.height() < this.element.attr("scrollHeight");
+        },
+
+        select: function( event ) {
+                this._trigger("selected", event, { item: this.active });
+        }
+});
+
+}(jQuery));

new file django/contrib/admin/media/js/jquery-ui.min.js

@@ +1 @@
+/*!
+ * jQuery UI 1.8.5
+ *
+ * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * http://docs.jquery.com/UI
+ */
+(function(c,j){function k(a){return!c(a).parents().andSelf().filter(function(){return c.curCSS(this,"visibility")==="hidden"||c.expr.filters.hidden(this)}).length}c.ui=c.ui||{};if(!c.ui.version){c.extend(c.ui,{version:"1.8.5",keyCode:{ALT:18,BACKSPACE:8,CAPS_LOCK:20,COMMA:188,COMMAND:91,COMMAND_LEFT:91,COMMAND_RIGHT:93,CONTROL:17,DELETE:46,DOWN:40,END:35,ENTER:13,ESCAPE:27,HOME:36,INSERT:45,LEFT:37,MENU:93,NUMPAD_ADD:107,NUMPAD_DECIMAL:110,NUMPAD_DIVIDE:111,NUMPAD_ENTER:108,NUMPAD_MULTIPLY:106,
+NUMPAD_SUBTRACT:109,PAGE_DOWN:34,PAGE_UP:33,PERIOD:190,RIGHT:39,SHIFT:16,SPACE:32,TAB:9,UP:38,WINDOWS:91}});c.fn.extend({_focus:c.fn.focus,focus:function(a,b){return typeof a==="number"?this.each(function(){var d=this;setTimeout(function(){c(d).focus();b&&b.call(d)},a)}):this._focus.apply(this,arguments)},scrollParent:function(){var a;a=c.browser.msie&&/(static|relative)/.test(this.css("position"))||/absolute/.test(this.css("position"))?this.parents().filter(function(){return/(relative|absolute|fixed)/.test(c.curCSS(this,
+"position",1))&&/(auto|scroll)/.test(c.curCSS(this,"overflow",1)+c.curCSS(this,"overflow-y",1)+c.curCSS(this,"overflow-x",1))}).eq(0):this.parents().filter(function(){return/(auto|scroll)/.test(c.curCSS(this,"overflow",1)+c.curCSS(this,"overflow-y",1)+c.curCSS(this,"overflow-x",1))}).eq(0);return/fixed/.test(this.css("position"))||!a.length?c(document):a},zIndex:function(a){if(a!==j)return this.css("zIndex",a);if(this.length){a=c(this[0]);for(var b;a.length&&a[0]!==document;){b=a.css("position");
+if(b==="absolute"||b==="relative"||b==="fixed"){b=parseInt(a.css("zIndex"));if(!isNaN(b)&&b!=0)return b}a=a.parent()}}return 0},disableSelection:function(){return this.bind("mousedown.ui-disableSelection selectstart.ui-disableSelection",function(a){a.preventDefault()})},enableSelection:function(){return this.unbind(".ui-disableSelection")}});c.each(["Width","Height"],function(a,b){function d(f,g,l,m){c.each(e,function(){g-=parseFloat(c.curCSS(f,"padding"+this,true))||0;if(l)g-=parseFloat(c.curCSS(f,
+"border"+this+"Width",true))||0;if(m)g-=parseFloat(c.curCSS(f,"margin"+this,true))||0});return g}var e=b==="Width"?["Left","Right"]:["Top","Bottom"],h=b.toLowerCase(),i={innerWidth:c.fn.innerWidth,innerHeight:c.fn.innerHeight,outerWidth:c.fn.outerWidth,outerHeight:c.fn.outerHeight};c.fn["inner"+b]=function(f){if(f===j)return i["inner"+b].call(this);return this.each(function(){c.style(this,h,d(this,f)+"px")})};c.fn["outer"+b]=function(f,g){if(typeof f!=="number")return i["outer"+b].call(this,f);return this.each(function(){c.style(this,
+h,d(this,f,true,g)+"px")})}});c.extend(c.expr[":"],{data:function(a,b,d){return!!c.data(a,d[3])},focusable:function(a){var b=a.nodeName.toLowerCase(),d=c.attr(a,"tabindex");if("area"===b){b=a.parentNode;d=b.name;if(!a.href||!d||b.nodeName.toLowerCase()!=="map")return false;a=c("img[usemap=#"+d+"]")[0];return!!a&&k(a)}return(/input|select|textarea|button|object/.test(b)?!a.disabled:"a"==b?a.href||!isNaN(d):!isNaN(d))&&k(a)},tabbable:function(a){var b=c.attr(a,"tabindex");return(isNaN(b)||b>=0)&&c(a).is(":focusable")}});
+c(function(){var a=document.createElement("div"),b=document.body;c.extend(a.style,{minHeight:"100px",height:"auto",padding:0,borderWidth:0});c.support.minHeight=b.appendChild(a).offsetHeight===100;b.removeChild(a).style.display="none"});c.extend(c.ui,{plugin:{add:function(a,b,d){a=c.ui[a].prototype;for(var e in d){a.plugins[e]=a.plugins[e]||[];a.plugins[e].push([b,d[e]])}},call:function(a,b,d){if((b=a.plugins[b])&&a.element[0].parentNode)for(var e=0;e<b.length;e++)a.options[b[e][0]]&&b[e][1].apply(a.element,
+d)}},contains:function(a,b){return document.compareDocumentPosition?a.compareDocumentPosition(b)&16:a!==b&&a.contains(b)},hasScroll:function(a,b){if(c(a).css("overflow")==="hidden")return false;b=b&&b==="left"?"scrollLeft":"scrollTop";var d=false;if(a[b]>0)return true;a[b]=1;d=a[b]>0;a[b]=0;return d},isOverAxis:function(a,b,d){return a>b&&a<b+d},isOver:function(a,b,d,e,h,i){return c.ui.isOverAxis(a,d,h)&&c.ui.isOverAxis(b,e,i)}})}})(jQuery);
+;/*!
+ * jQuery UI Widget 1.8.5
+ *
+ * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * http://docs.jquery.com/UI/Widget
+ */
+(function(b,j){if(b.cleanData){var k=b.cleanData;b.cleanData=function(a){for(var c=0,d;(d=a[c])!=null;c++)b(d).triggerHandler("remove");k(a)}}else{var l=b.fn.remove;b.fn.remove=function(a,c){return this.each(function(){if(!c)if(!a||b.filter(a,[this]).length)b("*",this).add([this]).each(function(){b(this).triggerHandler("remove")});return l.call(b(this),a,c)})}}b.widget=function(a,c,d){var e=a.split(".")[0],f;a=a.split(".")[1];f=e+"-"+a;if(!d){d=c;c=b.Widget}b.expr[":"][f]=function(h){return!!b.data(h,
+a)};b[e]=b[e]||{};b[e][a]=function(h,g){arguments.length&&this._createWidget(h,g)};c=new c;c.options=b.extend(true,{},c.options);b[e][a].prototype=b.extend(true,c,{namespace:e,widgetName:a,widgetEventPrefix:b[e][a].prototype.widgetEventPrefix||a,widgetBaseClass:f},d);b.widget.bridge(a,b[e][a])};b.widget.bridge=function(a,c){b.fn[a]=function(d){var e=typeof d==="string",f=Array.prototype.slice.call(arguments,1),h=this;d=!e&&f.length?b.extend.apply(null,[true,d].concat(f)):d;if(e&&d.substring(0,1)===
+"_")return h;e?this.each(function(){var g=b.data(this,a);if(!g)throw"cannot call methods on "+a+" prior to initialization; attempted to call method '"+d+"'";if(!b.isFunction(g[d]))throw"no such method '"+d+"' for "+a+" widget instance";var i=g[d].apply(g,f);if(i!==g&&i!==j){h=i;return false}}):this.each(function(){var g=b.data(this,a);g?g.option(d||{})._init():b.data(this,a,new c(d,this))});return h}};b.Widget=function(a,c){arguments.length&&this._createWidget(a,c)};b.Widget.prototype={widgetName:"widget",
+widgetEventPrefix:"",options:{disabled:false},_createWidget:function(a,c){b.data(c,this.widgetName,this);this.element=b(c);this.options=b.extend(true,{},this.options,b.metadata&&b.metadata.get(c)[this.widgetName],a);var d=this;this.element.bind("remove."+this.widgetName,function(){d.destroy()});this._create();this._init()},_create:function(){},_init:function(){},destroy:function(){this.element.unbind("."+this.widgetName).removeData(this.widgetName);this.widget().unbind("."+this.widgetName).removeAttr("aria-disabled").removeClass(this.widgetBaseClass+
+"-disabled ui-state-disabled")},widget:function(){return this.element},option:function(a,c){var d=a,e=this;if(arguments.length===0)return b.extend({},e.options);if(typeof a==="string"){if(c===j)return this.options[a];d={};d[a]=c}b.each(d,function(f,h){e._setOption(f,h)});return e},_setOption:function(a,c){this.options[a]=c;if(a==="disabled")this.widget()[c?"addClass":"removeClass"](this.widgetBaseClass+"-disabled ui-state-disabled").attr("aria-disabled",c);return this},enable:function(){return this._setOption("disabled",
+false)},disable:function(){return this._setOption("disabled",true)},_trigger:function(a,c,d){var e=this.options[a];c=b.Event(c);c.type=(a===this.widgetEventPrefix?a:this.widgetEventPrefix+a).toLowerCase();d=d||{};if(c.originalEvent){a=b.event.props.length;for(var f;a;){f=b.event.props[--a];c[f]=c.originalEvent[f]}}this.element.trigger(c,d);return!(b.isFunction(e)&&e.call(this.element[0],c,d)===false||c.isDefaultPrevented())}}})(jQuery);
+;/*
+ * jQuery UI Position 1.8.5
+ *
+ * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * http://docs.jquery.com/UI/Position
+ */
+(function(c){c.ui=c.ui||{};var n=/left|center|right/,o=/top|center|bottom/,t=c.fn.position,u=c.fn.offset;c.fn.position=function(b){if(!b||!b.of)return t.apply(this,arguments);b=c.extend({},b);var a=c(b.of),d=a[0],g=(b.collision||"flip").split(" "),e=b.offset?b.offset.split(" "):[0,0],h,k,j;if(d.nodeType===9){h=a.width();k=a.height();j={top:0,left:0}}else if(d.scrollTo&&d.document){h=a.width();k=a.height();j={top:a.scrollTop(),left:a.scrollLeft()}}else if(d.preventDefault){b.at="left top";h=k=0;j=
+{top:b.of.pageY,left:b.of.pageX}}else{h=a.outerWidth();k=a.outerHeight();j=a.offset()}c.each(["my","at"],function(){var f=(b[this]||"").split(" ");if(f.length===1)f=n.test(f[0])?f.concat(["center"]):o.test(f[0])?["center"].concat(f):["center","center"];f[0]=n.test(f[0])?f[0]:"center";f[1]=o.test(f[1])?f[1]:"center";b[this]=f});if(g.length===1)g[1]=g[0];e[0]=parseInt(e[0],10)||0;if(e.length===1)e[1]=e[0];e[1]=parseInt(e[1],10)||0;if(b.at[0]==="right")j.left+=h;else if(b.at[0]==="center")j.left+=h/
+2;if(b.at[1]==="bottom")j.top+=k;else if(b.at[1]==="center")j.top+=k/2;j.left+=e[0];j.top+=e[1];return this.each(function(){var f=c(this),l=f.outerWidth(),m=f.outerHeight(),p=parseInt(c.curCSS(this,"marginLeft",true))||0,q=parseInt(c.curCSS(this,"marginTop",true))||0,v=l+p+parseInt(c.curCSS(this,"marginRight",true))||0,w=m+q+parseInt(c.curCSS(this,"marginBottom",true))||0,i=c.extend({},j),r;if(b.my[0]==="right")i.left-=l;else if(b.my[0]==="center")i.left-=l/2;if(b.my[1]==="bottom")i.top-=m;else if(b.my[1]===
+"center")i.top-=m/2;i.left=parseInt(i.left);i.top=parseInt(i.top);r={left:i.left-p,top:i.top-q};c.each(["left","top"],function(s,x){c.ui.position[g[s]]&&c.ui.position[g[s]][x](i,{targetWidth:h,targetHeight:k,elemWidth:l,elemHeight:m,collisionPosition:r,collisionWidth:v,collisionHeight:w,offset:e,my:b.my,at:b.at})});c.fn.bgiframe&&f.bgiframe();f.offset(c.extend(i,{using:b.using}))})};c.ui.position={fit:{left:function(b,a){var d=c(window);d=a.collisionPosition.left+a.collisionWidth-d.width()-d.scrollLeft();
+b.left=d>0?b.left-d:Math.max(b.left-a.collisionPosition.left,b.left)},top:function(b,a){var d=c(window);d=a.collisionPosition.top+a.collisionHeight-d.height()-d.scrollTop();b.top=d>0?b.top-d:Math.max(b.top-a.collisionPosition.top,b.top)}},flip:{left:function(b,a){if(a.at[0]!=="center"){var d=c(window);d=a.collisionPosition.left+a.collisionWidth-d.width()-d.scrollLeft();var g=a.my[0]==="left"?-a.elemWidth:a.my[0]==="right"?a.elemWidth:0,e=a.at[0]==="left"?a.targetWidth:-a.targetWidth,h=-2*a.offset[0];
+b.left+=a.collisionPosition.left<0?g+e+h:d>0?g+e+h:0}},top:function(b,a){if(a.at[1]!=="center"){var d=c(window);d=a.collisionPosition.top+a.collisionHeight-d.height()-d.scrollTop();var g=a.my[1]==="top"?-a.elemHeight:a.my[1]==="bottom"?a.elemHeight:0,e=a.at[1]==="top"?a.targetHeight:-a.targetHeight,h=-2*a.offset[1];b.top+=a.collisionPosition.top<0?g+e+h:d>0?g+e+h:0}}}};if(!c.offset.setOffset){c.offset.setOffset=function(b,a){if(/static/.test(c.curCSS(b,"position")))b.style.position="relative";var d=
+c(b),g=d.offset(),e=parseInt(c.curCSS(b,"top",true),10)||0,h=parseInt(c.curCSS(b,"left",true),10)||0;g={top:a.top-g.top+e,left:a.left-g.left+h};"using"in a?a.using.call(b,g):d.css(g)};c.fn.offset=function(b){var a=this[0];if(!a||!a.ownerDocument)return null;if(b)return this.each(function(){c.offset.setOffset(this,b)});return u.call(this)}}})(jQuery);
+;/*
+ * jQuery UI Autocomplete 1.8.5
+ *
+ * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * http://docs.jquery.com/UI/Autocomplete
+ *
+ * Depends:
+ *      jquery.ui.core.js
+ *      jquery.ui.widget.js
+ *      jquery.ui.position.js
+ */
+(function(e){e.widget("ui.autocomplete",{options:{appendTo:"body",delay:300,minLength:1,position:{my:"left top",at:"left bottom",collision:"none"},source:null},_create:function(){var a=this,b=this.element[0].ownerDocument;this.element.addClass("ui-autocomplete-input").attr("autocomplete","off").attr({role:"textbox","aria-autocomplete":"list","aria-haspopup":"true"}).bind("keydown.autocomplete",function(c){if(!a.options.disabled){var d=e.ui.keyCode;switch(c.keyCode){case d.PAGE_UP:a._move("previousPage",
+c);break;case d.PAGE_DOWN:a._move("nextPage",c);break;case d.UP:a._move("previous",c);c.preventDefault();break;case d.DOWN:a._move("next",c);c.preventDefault();break;case d.ENTER:case d.NUMPAD_ENTER:a.menu.element.is(":visible")&&c.preventDefault();case d.TAB:if(!a.menu.active)return;a.menu.select(c);break;case d.ESCAPE:a.element.val(a.term);a.close(c);break;default:clearTimeout(a.searching);a.searching=setTimeout(function(){if(a.term!=a.element.val()){a.selectedItem=null;a.search(null,c)}},a.options.delay);
+break}}}).bind("focus.autocomplete",function(){if(!a.options.disabled){a.selectedItem=null;a.previous=a.element.val()}}).bind("blur.autocomplete",function(c){if(!a.options.disabled){clearTimeout(a.searching);a.closing=setTimeout(function(){a.close(c);a._change(c)},150)}});this._initSource();this.response=function(){return a._response.apply(a,arguments)};this.menu=e("<ul></ul>").addClass("ui-autocomplete").appendTo(e(this.options.appendTo||"body",b)[0]).mousedown(function(c){var d=a.menu.element[0];
+c.target===d&&setTimeout(function(){e(document).one("mousedown",function(f){f.target!==a.element[0]&&f.target!==d&&!e.ui.contains(d,f.target)&&a.close()})},1);setTimeout(function(){clearTimeout(a.closing)},13)}).menu({focus:function(c,d){d=d.item.data("item.autocomplete");false!==a._trigger("focus",null,{item:d})&&/^key/.test(c.originalEvent.type)&&a.element.val(d.value)},selected:function(c,d){d=d.item.data("item.autocomplete");var f=a.previous;if(a.element[0]!==b.activeElement){a.element.focus();
+a.previous=f}if(false!==a._trigger("select",c,{item:d})){a.term=d.value;a.element.val(d.value)}a.close(c);a.selectedItem=d},blur:function(){a.menu.element.is(":visible")&&a.element.val()!==a.term&&a.element.val(a.term)}}).zIndex(this.element.zIndex()+1).css({top:0,left:0}).hide().data("menu");e.fn.bgiframe&&this.menu.element.bgiframe()},destroy:function(){this.element.removeClass("ui-autocomplete-input").removeAttr("autocomplete").removeAttr("role").removeAttr("aria-autocomplete").removeAttr("aria-haspopup");
+this.menu.element.remove();e.Widget.prototype.destroy.call(this)},_setOption:function(a,b){e.Widget.prototype._setOption.apply(this,arguments);a==="source"&&this._initSource();if(a==="appendTo")this.menu.element.appendTo(e(b||"body",this.element[0].ownerDocument)[0])},_initSource:function(){var a=this,b,c;if(e.isArray(this.options.source)){b=this.options.source;this.source=function(d,f){f(e.ui.autocomplete.filter(b,d.term))}}else if(typeof this.options.source==="string"){c=this.options.source;this.source=
+function(d,f){a.xhr&&a.xhr.abort();a.xhr=e.getJSON(c,d,function(g,i,h){h===a.xhr&&f(g);a.xhr=null})}}else this.source=this.options.source},search:function(a,b){a=a!=null?a:this.element.val();this.term=this.element.val();if(a.length<this.options.minLength)return this.close(b);clearTimeout(this.closing);if(this._trigger("search")!==false)return this._search(a)},_search:function(a){this.element.addClass("ui-autocomplete-loading");this.source({term:a},this.response)},_response:function(a){if(a.length){a=
+this._normalize(a);this._suggest(a);this._trigger("open")}else this.close();this.element.removeClass("ui-autocomplete-loading")},close:function(a){clearTimeout(this.closing);if(this.menu.element.is(":visible")){this._trigger("close",a);this.menu.element.hide();this.menu.deactivate()}},_change:function(a){this.previous!==this.element.val()&&this._trigger("change",a,{item:this.selectedItem})},_normalize:function(a){if(a.length&&a[0].label&&a[0].value)return a;return e.map(a,function(b){if(typeof b===
+"string")return{label:b,value:b};return e.extend({label:b.label||b.value,value:b.value||b.label},b)})},_suggest:function(a){var b=this.menu.element.empty().zIndex(this.element.zIndex()+1),c;this._renderMenu(b,a);this.menu.deactivate();this.menu.refresh();this.menu.element.show().position(e.extend({of:this.element},this.options.position));a=b.width("").outerWidth();c=this.element.outerWidth();b.outerWidth(Math.max(a,c))},_renderMenu:function(a,b){var c=this;e.each(b,function(d,f){c._renderItem(a,f)})},
+_renderItem:function(a,b){return e("<li></li>").data("item.autocomplete",b).append(e("<a></a>").text(b.label)).appendTo(a)},_move:function(a,b){if(this.menu.element.is(":visible"))if(this.menu.first()&&/^previous/.test(a)||this.menu.last()&&/^next/.test(a)){this.element.val(this.term);this.menu.deactivate()}else this.menu[a](b);else this.search(null,b)},widget:function(){return this.menu.element}});e.extend(e.ui.autocomplete,{escapeRegex:function(a){return a.replace(/[-[\]{}()*+?.,\\^$|#\s]/g,"\\$&")},
+filter:function(a,b){var c=new RegExp(e.ui.autocomplete.escapeRegex(b),"i");return e.grep(a,function(d){return c.test(d.label||d.value||d)})}})})(jQuery);
+(function(e){e.widget("ui.menu",{_create:function(){var a=this;this.element.addClass("ui-menu ui-widget ui-widget-content ui-corner-all").attr({role:"listbox","aria-activedescendant":"ui-active-menuitem"}).click(function(b){if(e(b.target).closest(".ui-menu-item a").length){b.preventDefault();a.select(b)}});this.refresh()},refresh:function(){var a=this;this.element.children("li:not(.ui-menu-item):has(a)").addClass("ui-menu-item").attr("role","menuitem").children("a").addClass("ui-corner-all").attr("tabindex",
+-1).mouseenter(function(b){a.activate(b,e(this).parent())}).mouseleave(function(){a.deactivate()})},activate:function(a,b){this.deactivate();if(this.hasScroll()){var c=b.offset().top-this.element.offset().top,d=this.element.attr("scrollTop"),f=this.element.height();if(c<0)this.element.attr("scrollTop",d+c);else c>=f&&this.element.attr("scrollTop",d+c-f+b.height())}this.active=b.eq(0).children("a").addClass("ui-state-hover").attr("id","ui-active-menuitem").end();this._trigger("focus",a,{item:b})},
+deactivate:function(){if(this.active){this.active.children("a").removeClass("ui-state-hover").removeAttr("id");this._trigger("blur");this.active=null}},next:function(a){this.move("next",".ui-menu-item:first",a)},previous:function(a){this.move("prev",".ui-menu-item:last",a)},first:function(){return this.active&&!this.active.prevAll(".ui-menu-item").length},last:function(){return this.active&&!this.active.nextAll(".ui-menu-item").length},move:function(a,b,c){if(this.active){a=this.active[a+"All"](".ui-menu-item").eq(0);
+a.length?this.activate(c,a):this.activate(c,this.element.children(b))}else this.activate(c,this.element.children(b))},nextPage:function(a){if(this.hasScroll())if(!this.active||this.last())this.activate(a,this.element.children(":first"));else{var b=this.active.offset().top,c=this.element.height(),d=this.element.children("li").filter(function(){var f=e(this).offset().top-b-c+e(this).height();return f<10&&f>-10});d.length||(d=this.element.children(":last"));this.activate(a,d)}else this.activate(a,this.element.children(!this.active||
+this.last()?":first":":last"))},previousPage:function(a){if(this.hasScroll())if(!this.active||this.first())this.activate(a,this.element.children(":last"));else{var b=this.active.offset().top,c=this.element.height();result=this.element.children("li").filter(function(){var d=e(this).offset().top-b+c-e(this).height();return d<10&&d>-10});result.length||(result=this.element.children(":first"));this.activate(a,result)}else this.activate(a,this.element.children(!this.active||this.first()?":last":":first"))},
+hasScroll:function(){return this.element.height()<this.element.attr("scrollHeight")},select:function(a){this._trigger("selected",a,{item:this.active})}})})(jQuery);
+;
+ No newline at end of file

django/contrib/admin/options.py

@@ +1 @@
+import operator
 from django import forms, template
 from django.forms.formsets import all_valid
 from django.forms.models import modelform_factory, modelformset_factory, inlineformset_factory
@@ -13 +14 @@
 from django.db.models.fields import BLANK_CHOICE_DASH
 from django.http import Http404, HttpResponse, HttpResponseRedirect
 from django.shortcuts import get_object_or_404, render_to_response
+from django.utils import simplejson
 from django.utils.decorators import method_decorator
 from django.utils.datastructures import SortedDict
 from django.utils.functional import update_wrapper
@@ -21 +23 @@
 from django.utils.functional import curry
 from django.utils.text import capfirst, get_text_list
 from django.utils.translation import ugettext as _
-from django.utils.translation import ungettext
-from django.utils.encoding import force_unicode
+from django.utils.translation import ungettext, ugettext_lazy
+from django.utils.encoding import force_unicode, smart_str
 
 HORIZONTAL, VERTICAL = 1, 2
 # returns the <ul> class for a given radio_admin field
@@ -50 +52 @@
     models.FileField:       {'widget': widgets.AdminFileWidget},
 }
 
+AUTOCOMPLETE_FIELDS_DEFAULTS = {
+    'limit': 5,
+    'value': lambda o: unicode(o),
+    'label': lambda o: unicode(o),
+    'show_search': True,
+}
+
 csrf_protect_m = method_decorator(csrf_protect)
 
 class BaseModelAdmin(object):
@@ -57 +66 @@
     __metaclass__ = forms.MediaDefiningClass
 
     raw_id_fields = ()
+    autocomplete_fields = {}
     fields = None
     exclude = None
     fieldsets = None
@@ -74 +84 @@
         overrides.update(self.formfield_overrides)
         self.formfield_overrides = overrides
 
+        def build_setting(value):
+            if value in settings['queryset'].model._meta.get_all_field_names():
+                return lambda m: getattr(m, value)
+            return lambda m: value % vars(m)
+
+        autocomplete_fields = {}
+        for (field, values) in self.autocomplete_fields.items():
+            settings = autocomplete_fields[field] = AUTOCOMPLETE_FIELDS_DEFAULTS.copy()
+            settings.update(values)
+            if hasattr(self.model, field):
+                rel = getattr(self.model, field).field.rel
+                settings['id'] = settings.get('id', rel.get_related_field().name)
+                if not settings.get('queryset'):
+                    settings['queryset'] = rel.to._default_manager.complex_filter(rel.limit_choices_to)
+            for option in ('value', 'label'):
+                if isinstance(settings[option], (str, unicode)):
+                    settings[option] = build_setting(settings[option])
+
+        self.autocomplete_fields = autocomplete_fields
+
+
     def formfield_for_dbfield(self, db_field, **kwargs):
         """
         Hook for specifying the form Field instance for a given database Field
@@ -107 +138 @@
             # extra HTML -- the "add other" interface -- to the end of the
             # rendered output. formfield can be None if it came from a
             # OneToOneField with parent_link=True or a M2M intermediary.
-            if formfield and db_field.name not in self.raw_id_fields:
+            if (formfield and db_field.name not in self.raw_id_fields
+                and db_field.name not in self.autocomplete_fields):
                 related_modeladmin = self.admin_site._registry.get(
                                                             db_field.rel.to)
                 can_add_related = bool(related_modeladmin and
@@ -118 +150 @@
 
             return formfield
 
+        elif db_field.name in self.autocomplete_fields:
+            kwargs['widget'] = widgets.AutocompleteWidget(
+                self.autocomplete_fields[db_field.name],
+                using=kwargs.get('using'),
+                force_selection=False)
+
         # If we've got overrides for the formfield defined, use 'em. **kwargs
         # passed to formfield_for_dbfield override the defaults.
         for klass in db_field.__class__.mro():
@@ -153 +191 @@
         db = kwargs.get('using')
         if db_field.name in self.raw_id_fields:
             kwargs['widget'] = widgets.ForeignKeyRawIdWidget(db_field.rel, using=db)
+        elif db_field.name in self.autocomplete_fields:
+            kwargs['widget'] = widgets.AutocompleteWidget(
+                self.autocomplete_fields[db_field.name], using=db)
         elif db_field.name in self.radio_fields:
             kwargs['widget'] = widgets.AdminRadioSelect(attrs={
                 'class': get_ul_class(self.radio_fields[db_field.name]),
@@ -174 +215 @@
         if db_field.name in self.raw_id_fields:
             kwargs['widget'] = widgets.ManyToManyRawIdWidget(db_field.rel, using=db)
             kwargs['help_text'] = ''
+        elif db_field.name in self.autocomplete_fields:
+            kwargs['widget'] = widgets.MultipleAutocompleteWidget(
+                self.autocomplete_fields[db_field.name], using=db)
+            kwargs['help_text'] = ''
         elif db_field.name in (list(self.filter_vertical) + list(self.filter_horizontal)):
             kwargs['widget'] = widgets.FilteredSelectMultiple(db_field.verbose_name, (db_field.name in self.filter_vertical))
 
@@ -266 +311 @@
             url(r'^add/$',
                 wrap(self.add_view),
                 name='%s_%s_add' % info),
+            url(r'^autocomplete/(?P<field>[\w]+)/$',
+                wrap(self.autocomplete_view),
+                name='%s_%s_autocomplete' % info),
             url(r'^(.+)/history/$',
                 wrap(self.history_view),
                 name='%s_%s_history' % info),
@@ -287 +335 @@
 
         js = ['js/core.js', 'js/admin/RelatedObjectLookups.js',
               'js/jquery.min.js', 'js/jquery.init.js']
+        if self.autocomplete_fields:
+            js.insert(3, 'js/jquery-ui.min.js')
         if self.actions is not None:
             js.extend(['js/actions.min.js'])
         if self.prepopulated_fields:
@@ -771 +821 @@
             self.message_user(request, msg)
             return None
 
+    def autocomplete_view(self, request, field, extra_content=None):
+        query = request.GET.get('term', None)
+        
+        if field not in self.autocomplete_fields or query is None:
+            raise Http404
+
+        settings = self.autocomplete_fields[field]
+        queryset = settings['queryset']
+        search_fields = settings['fields']
+        if request.GET.get('by_id', None) is not None:
+            # lookup only via an exact match on id
+            search_fields = ('=%s' % settings['id'],)
+
+        def construct_search(field_name):
+            # use different lookup methods depending on the notation
+            if field_name.startswith('^'):
+                return "%s__istartswith" % field_name[1:]
+            elif field_name.startswith('='):
+                return "%s__iexact" % field_name[1:]
+            elif field_name.startswith('@'):
+                return "%s__search" % field_name[1:]
+            else:
+                return "%s__icontains" % field_name
+        
+        for bit in query.split():
+            or_queries = [models.Q(**{construct_search(
+                smart_str(field_name)): bit})
+                    for field_name in search_fields]
+            queryset = queryset.filter(reduce(operator.or_, or_queries))
+        
+        data = []
+        for o in queryset[:settings['limit']]:
+            data.append({
+                'id': getattr(o, settings['id']),
+                'value': settings['value'](o),
+                'label': settings['label'](o),
+            })
+        
+        return HttpResponse(simplejson.dumps(data))
+    
     @csrf_protect_m
     @transaction.commit_on_success
     def add_view(self, request, form_url='', extra_context=None):

django/contrib/admin/widgets.py

@@ -7 +7 @@
 from django import forms
 from django.forms.widgets import RadioFieldRenderer
 from django.forms.util import flatatt
+from django.utils import simplejson
 from django.utils.html import escape
 from django.utils.text import truncate_words
 from django.utils.translation import ugettext as _
@@ -91 +92 @@
     template_with_clear = (u'<span class="clearable-file-input">%s</span>'
                            % forms.ClearableFileInput.template_with_clear)
 
+def _get_search_icon(model, name, value, params, attrs):
+    related_url = '../../../%s/%s/' % (model._meta.app_label, model._meta.object_name.lower())
+    if params:
+        url = '?' + '&amp;'.join(['%s=%s' % (k, v) for k, v in params.items()])
+    else:
+        url = ''
+    # TODO: "id_" is hard-coded here. This should instead use the correct
+    # API to determine the ID dynamically.
+    output = []
+    output.append('<a href="%s%s" class="related-lookup" id="lookup_id_%s" onclick="return showRelatedObjectLookupPopup(this);"> ' % \
+        (related_url, url, name))
+    output.append('<img src="%simg/admin/selector-search.gif" width="16" height="16" alt="%s" /></a>' % (settings.ADMIN_MEDIA_PREFIX, _('Lookup')))
+    return output
 
 class ForeignKeyRawIdWidget(forms.TextInput):
     """
@@ -105 +119 @@
     def render(self, name, value, attrs=None):
         if attrs is None:
             attrs = {}
-        related_url = '../../../%s/%s/' % (self.rel.to._meta.app_label, self.rel.to._meta.object_name.lower())
-        params = self.url_parameters()
-        if params:
-            url = '?' + '&amp;'.join(['%s=%s' % (k, v) for k, v in params.items()])
-        else:
-            url = ''
         if "class" not in attrs:
             attrs['class'] = 'vForeignKeyRawIdAdminField' # The JavaScript looks for this hook.
         output = [super(ForeignKeyRawIdWidget, self).render(name, value, attrs)]
-        # TODO: "id_" is hard-coded here. This should instead use the correct
-        # API to determine the ID dynamically.
-        output.append('<a href="%s%s" class="related-lookup" id="lookup_id_%s" onclick="return showRelatedObjectLookupPopup(this);"> ' % \
-            (related_url, url, name))
-        output.append('<img src="%simg/admin/selector-search.gif" width="16" height="16" alt="%s" /></a>' % (settings.ADMIN_MEDIA_PREFIX, _('Lookup')))
+
+        output += _get_search_icon(self.rel.to, name, value, self.url_parameters(), attrs)
         if value:
             output.append(self.label_for_value(value))
         return mark_safe(u''.join(output))
@@ -150 +155 @@
         except (ValueError, self.rel.to.DoesNotExist):
             return ''
 
+class AutocompleteWidget(forms.Widget):
+    
+    class Media:
+        js = (
+            settings.ADMIN_MEDIA_PREFIX + 'js/admin/autocomplete.js',
+        )
+
+    def __init__(self, settings, attrs=None, using=None, **js_options):
+        self.settings = settings
+        self.db = using
+        self.js_options = dict(
+            source = settings.get('source'),
+            multiple = settings.get('multiple', False),
+            force_selection = settings.get('force_selection', True),
+        )
+        self.js_options.update(js_options)
+        super(AutocompleteWidget, self).__init__(attrs)
+
+    def get_autocomplete_url(self, name):
+        return '../autocomplete/%s/' % name
+
+    def render(self, name, value, attrs=None, hattrs=None, initial_objects=u''):
+        if value is None:
+            value = ''
+        hidden_id = 'id_hidden_%s' % name
+        hidden_attrs = self.build_attrs(type='hidden', name=name, value=value, id=hidden_id)
+        normal_attrs = self.build_attrs(attrs, type='text')
+        normal_attrs['value'] = self.label_for_value(value)
+        if not self.js_options.get('source'):
+            self.js_options['source'] = self.get_autocomplete_url(name)
+        options = simplejson.dumps(self.js_options)
+        if self.settings.get('show_search'):
+            target_key = self.settings.get('id')
+            search_icon = _get_search_icon(self.settings.get('queryset').model, 
+                                           name, value, {'t': target_key}, attrs)
+            search_icon = u''.join(search_icon) + '\n'
+        else:
+            search_icon = u''
+        return mark_safe(u''.join((
+            u'<div class="djangoautocomplete-wrapper">\n',
+            u'<input%s />\n' % flatatt(hidden_attrs),
+            u'<input%s />\n' % flatatt(normal_attrs),
+            initial_objects,
+            u'</div>\n',
+            search_icon,
+            u'<script type="text/javascript">',
+            u'django.jQuery("#id_%s").djangoautocomplete(%s);' % (name, options),
+            u'</script>\n',
+        )))
+
+    def label_for_value(self, value):
+        qs, key, value_fmt = [self.settings[k] for k in ('queryset','id','value')]
+        if not value:
+            return value
+        try:
+            obj = qs.get(**{key: value})
+            return value_fmt(obj)
+        # XXX this shouldn't happen.
+        except qs.model.DoesNotExist:
+            return value
+
+
 class ManyToManyRawIdWidget(ForeignKeyRawIdWidget):
     """
     A Widget for displaying ManyToMany ids in the "raw_id" interface rather than
@@ -188 +255 @@
                 return True
         return False
 
+class MultipleAutocompleteWidget(AutocompleteWidget):
+
+    def __init__(self, settings, attrs=None, using=None, **js_options):
+        js_options['multiple'] = True
+        super(MultipleAutocompleteWidget, self).__init__(settings, attrs,
+            using, **js_options)
+
+    def render(self, name, value, attrs=None, hattrs=None):
+        if value:
+            initial_objects = self.initial_objects(value)
+            value = ','.join([str(v) for v in value])
+        else:
+            initial_objects = u''
+        return super(MultipleAutocompleteWidget, self).render(
+            name, value, attrs, hattrs, initial_objects)
+
+    def label_for_value(self, value):
+        return ''
+
+    def value_from_datadict(self, data, files, name):
+        value = data.get(name)
+        if value:
+            return value.split(',')
+        return value
+    
+    def initial_objects(self, value):
+        qs, key, label_fmt = [self.settings[k] for k in ('queryset','id','label')]
+        output = [u'<ul class="ui-autocomplete-values">']
+        for obj in qs.filter(**{'%s__in' % key: value}):
+            output.append(u'<li>%s</li>' % label_fmt(obj))
+        output.append(u'</ul>\n')
+        return mark_safe(u'\n'.join(output))
+
+
 class RelatedFieldWidgetWrapper(forms.Widget):
     """
     This class is a wrapper to a given widget to add the add icon for the

docs/ref/contrib/admin/index.txt

@@ -97 +97 @@
     class AuthorAdmin(admin.ModelAdmin):
         date_hierarchy = 'pub_date'
 
+.. versionadded:: 1.3
+
+.. attribute:: ModelAdmin.autocomplete_fields
+
+By default, Django's admin uses a select-box interface (<select>) for fields 
+that are ``ForeignKey`` or ``ManyToMany``.  If you know that your users' 
+browsers will have javascript enabled you can give them autocomplete behavior.
+
+``autocomplete_fields`` is a list of fields you would like to change
+into a smart ``Input`` widget for either a ``ForeignKey`` or ``ManyToManyField``::
+
+    class BookAdmin(admin.ModelAdmin):
+        autocomplete_fields = {
+            'author': { 'fields': ('name',) },
+        }
+
+``autocomplete_fields`` is a dictionary that connects a ``field_name`` to 
+a dictionary of ``field_options``.  The ``field_options`` can have the 
+following keys:
+
+    * ``fields``
+        A tuple of field names used to search for objects associated with 
+        ``field_name``. This key is required.
+
+        Example::
+
+            'fields': ('name', '^user__email',),
+
+    * ``label``
+        A formatting string or subroutine that controls how each choice 
+        is displayed in the list of autocomplete choices.
+
+        Example::
+
+            'label': 'name'
+            'label': '%(name)s [%(gender)s]'
+            'label': lambda o: o.name.lower()
+
+    * ``limit``
+        An integer that limits the size of the autocomplete choices displayed.
+
+    * ``show_search``
+        A boolean that controls the rendering of a clickable search icon.  
+        Defaults to `True`. 
+
+    * ``value``
+       A formatting string or subroutine that controls how a selected item 
+       is displayed.
+
+       Same syntax as the ``label`` option.
+
 .. attribute:: ModelAdmin.date_hierarchy
 
     Set ``date_hierarchy`` to the name of a ``DateField`` or ``DateTimeField``

tests/regressiontests/admin_widgets/models.py

@@ -9 +9 @@
     name = models.CharField(max_length=100)
     birthdate = models.DateTimeField(blank=True, null=True)
     gender = models.CharField(max_length=1, blank=True, choices=[('M','Male'), ('F', 'Female')])
+    user = models.ForeignKey(User, blank=True, null=True)
 
     def __unicode__(self):
         return self.name

tests/regressiontests/admin_widgets/tests.py

@@ -8 +8 @@
 from django.contrib.admin import widgets
 from django.contrib.admin.widgets import (FilteredSelectMultiple,
     AdminSplitDateTime, AdminFileWidget, ForeignKeyRawIdWidget, AdminRadioSelect,
-    RelatedFieldWidgetWrapper, ManyToManyRawIdWidget)
+    RelatedFieldWidgetWrapper, ManyToManyRawIdWidget,
+    AutocompleteWidget, MultipleAutocompleteWidget)
 from django.core.files.storage import default_storage
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.db.models import DateField
 from django.test import TestCase as DjangoTestCase
+from django.utils import simplejson
 from django.utils.html import conditional_escape
 from django.utils.translation import activate, deactivate
 from django.utils.unittest import TestCase
@@ -323 +325 @@
         # Used to fail with a name error.
         w = RelatedFieldWidgetWrapper(w, rel, admin.site)
         self.assertFalse(w.can_add_related)
+
+
+class AutocompleteWidgetTest(DjangoTestCase):
+    def test_render(self):
+        band = models.Band.objects.create(name='Linkin Park')
+        band.album_set.create(
+            name='Hybrid Theory', cover_art=r'albums\hybrid_theory.jpg'
+        )
+
+        widget_settings = {
+            'fields': ('name',),
+            'id': 'id',
+            'limit': 5,
+            'value': lambda o: unicode(o),
+            'label': lambda o: unicode(o),
+            'queryset': models.Band.objects.all(),
+            }
+        w = AutocompleteWidget(widget_settings)
+        field_name = 'test'
+        expected = "\n".join((
+            '<div class="djangoautocomplete-wrapper">',
+            '<input type="hidden" name="test" value="%(band_pk)s" id="id_hidden_%(field_name)s" />',
+            '<input type="text" value="%(band_name)s" />',
+            '</div>',
+            '<script type="text/javascript">django.jQuery("#id_%(field_name)s").djangoautocomplete({"force_selection": true, "multiple": %(multiple)s, "source": "../autocomplete/%(field_name)s/"});</script>',
+            ''
+            )) % {'field_name': field_name,
+                  'band_pk': band.pk,
+                  'band_name': band.name,
+                  'multiple': 'false',
+                  }
+        self.assertEqual(
+            conditional_escape(w.render('test', band.pk, attrs={})),
+            expected,
+        )
+
+
+class MultipleAutocompleteWidgetTest(DjangoTestCase):
+    fixtures = ["admin-widgets-users.xml"]
+    admin_root = '/widget_admin'
+
+    def setUp(self):
+        band = models.Band.objects.create(name='Linkin Park')
+        band.album_set.create(
+            name='Hybrid Theory', cover_art=r'albums\hybrid_theory.jpg'
+        )
+        band2 = models.Band.objects.create(name='Johnny Cash')
+        band2.album_set.create(
+            name='At San Quentin'
+        )
+        self.bands = (band, band2)
+    
+    def _get_expected(self, name, bands, show_search=False):
+        bands = [] if bands is None else bands
+        expected = [
+            '<div class="djangoautocomplete-wrapper">',
+            '<input type="hidden" name="%(field_name)s" value="%(band_pks)s" id="id_hidden_%(field_name)s" />',
+            '<input type="text" value="" />',  # input is for data entry only
+            ]
+        if bands:                
+            expected += ['<ul class="ui-autocomplete-values">']
+            expected += ['<li>%s</li>' % b.name for b in bands]
+            expected += ['</ul>']
+        expected += ['</div>']
+        if show_search:
+            expected += ['<a href="../../../admin_widgets/band/?t=id" class="related-lookup" id="lookup_id_%s" onclick="return showRelatedObjectLookupPopup(this);"> <img src="%simg/admin/selector-search.gif" width="16" height="16" alt="Lookup" /></a>' % (name, settings.ADMIN_MEDIA_PREFIX)]
+        expected += [
+            '<script type="text/javascript">django.jQuery("#id_%(field_name)s").djangoautocomplete({"force_selection": true, "multiple": %(multiple)s, "source": "../autocomplete/%(field_name)s/"});</script>',
+            ''
+            ]
+        expected = "\n".join(expected) % {
+            'field_name': name,
+            'band_pks': ','.join([str(b.pk) for b in bands]),
+            'multiple': 'true',
+            }
+        return expected
+
+    def test_render(self):
+        bands = self.bands
+
+        widget_settings = {
+            'fields': ('name',),
+            'id': 'id',
+            'limit': 5,
+            'value': lambda o: unicode(o),
+            'label': lambda o: unicode(o),
+            'queryset': models.Band.objects.all(),
+            'show_search': False,
+            }
+        with_search_settings = widget_settings.copy()
+        with_search_settings['show_search'] = True
+
+        w = MultipleAutocompleteWidget(widget_settings)
+        expected_multiple = self._get_expected('test_multiple', bands)
+        self.assertEqual(
+            conditional_escape(w.render('test_multiple', [b.pk for b in bands], attrs={})),
+            expected_multiple,
+        )
+
+        w = MultipleAutocompleteWidget(widget_settings)
+        bands_just_one = bands[:1]
+        expected_single = self._get_expected('test_single', bands_just_one)
+        self.assertEqual(
+            conditional_escape(w.render('test_single', [b.pk for b in bands_just_one], attrs={})),
+            expected_single,
+        )
+
+        w = MultipleAutocompleteWidget(widget_settings)
+        bands_none = None
+        expected_none = self._get_expected('test_none', bands_none)
+        self.assertEqual(
+            conditional_escape(w.render('test_none', bands_none, attrs={})),
+            expected_none,
+        )
+
+        w = MultipleAutocompleteWidget(with_search_settings)
+        bands_none = None
+        expected_none = self._get_expected('test_none', bands_none, show_search=True)
+        self.assertEqual(
+            conditional_escape(w.render('test_none', bands_none, attrs={})),
+            expected_none,
+        )
+        
+
+    def test_lookup(self):
+        band = self.bands[1]
+        self.client.login(username="super", password="secret")
+        response = self.client.get('%s/admin_widgets/album/autocomplete/band/?term=johnny' % self.admin_root )
+        self.assertEqual(simplejson.loads(response.content),
+                         [{'id': band.id, 
+                           'value': band.name,
+                           'label': band.name}])
+        response = self.client.get('%s/admin_widgets/album/autocomplete/band/?term=a' % self.admin_root )
+        self.assertEqual(simplejson.loads(response.content),
+                         [{'id': band.id, 
+                           'value': band.name,
+                           'label': band.name} for band in self.bands])
+        response = self.client.get('%s/admin_widgets/album/autocomplete/band/?term=%s&by_id=1' % (self.admin_root, band.id ))
+        self.assertEqual(simplejson.loads(response.content),
+                         [{'id': band.id, 
+                           'value': band.name,
+                           'label': band.name}])
+        
+
+    def test_different_id(self):
+        self.client.login(username="super", password="secret")
+        user = models.User.objects.get(username='testser')
+        user.member_set.create(
+            name='Man Named Sue',
+            user=user,
+        )
+        expected = [{'id': user.email, 
+                     'value': user.username,
+                     'label': user.username}]
+        lookup_url = "%s/admin_widgets/member/autocomplete/user/?term=%%s" % self.admin_root
+        lookup_by_id_url = "%s&by_id=1" % lookup_url
+
+        response = self.client.get(lookup_url % user.username[:2])
+        self.assertEqual(simplejson.loads(response.content),
+                         expected)
+        response = self.client.get(lookup_url % user.email[:2])
+        self.assertEqual(simplejson.loads(response.content),
+                         expected)
+        response = self.client.get(lookup_url % user.first_name[:2])
+        self.assertEqual(simplejson.loads(response.content),
+                         expected)
+        response = self.client.get(lookup_by_id_url % user.email)
+        self.assertEqual(simplejson.loads(response.content),
+                         expected)
+        

tests/regressiontests/admin_widgets/widgetadmin.py

@@ -22 +22 @@
 class EventAdmin(admin.ModelAdmin):
     raw_id_fields = ['band']
 
+
+class AlbumAdmin(admin.ModelAdmin):
+    autocomplete_fields = {
+        'band': { 'fields': ('name',) }
+            }
+
+class MemberAdmin(admin.ModelAdmin):
+    autocomplete_fields = {
+        'user': { 
+            'fields': ('^email', '^username', '^first_name', ),
+            'id': 'email',  # weird id for test_different_id
+            }
+        }
+
+
 site = WidgetAdmin(name='widget-admin')
 
 site.register(models.User)
+site.register(models.Album, AlbumAdmin)
 site.register(models.Car, CarAdmin)
 site.register(models.CarTire, CarTireAdmin)
 site.register(models.Event, EventAdmin)
+site.register(models.Member, MemberAdmin)