Changeset 27985

Timestamp:

04/07/2014 09:03:18 AM (11 years ago)

Author:

ocean90

Message:

Widget Customizer: Move WidgetCustomizer to wp.customize.Widgets. First pass.

see #27690.

Location:

trunk/src

Files:

• wp-admin/css/customize-controls.css (modified) (1 diff)
• wp-admin/css/customize-widgets.css (modified) (2 diffs)
• wp-admin/js/customize-widgets.js (modified) (46 diffs)
• wp-includes/class-wp-customize-control.php (modified) (2 diffs)
• wp-includes/class-wp-customize-widgets.php (modified) (6 diffs)
• wp-includes/js/customize-preview-widgets.js (modified) (2 diffs)

trunk/src/wp-admin/css/customize-controls.css

@@ -491 +491 @@
     -webkit-border-radius: 2px;
     border: 1px solid #eee;
+    -webkit-border-radius: 2px;
     border-radius: 2px;
 }

trunk/src/wp-admin/css/customize-widgets.css

@@ -108 +108 @@
     display: none;
 }
-
-
-/* MP6-compat */
-#customize-theme-controls .accordion-section-content .widget {
-    color: black;
-}
-
 
 /**
@@ -327 +320 @@
 body.adding-widget .add-new-widget,
 body.adding-widget .add-new-widget:hover {
-    background: #EEE;
+    background: #eee;
     border-color: #999;
     color: #333;

trunk/src/wp-admin/js/customize-widgets.js

@@ -1 @@
-/*global wp, Backbone, _, jQuery, WidgetCustomizer_exports */
-/*exported WidgetCustomizer */
-var WidgetCustomizer = ( function ($) {
-    'use strict';
-
-    var Widget,
-        WidgetCollection,
-        Sidebar,
-        SidebarCollection,
-        OldPreviewer,
-        builtin_form_sync_handlers,
-        customize = wp.customize, self = {
-        nonce: null,
-        i18n: {
-            save_btn_label: '',
-            save_btn_tooltip: '',
-            remove_btn_label: '',
-            remove_btn_tooltip: '',
-            error: ''
-        },
-        available_widgets: [], // available widgets for instantiating
-        registered_widgets: [], // all widgets registered
-        active_sidebar_control: null,
-        previewer: null,
-        saved_widget_ids: {},
-        registered_sidebars: [],
-        tpl: {
-            move_widget_area: '',
-            widget_reorder_nav: ''
-        }
-    };
-    $.extend( self, WidgetCustomizer_exports );
-
-    // Lots of widgets expect this old ajaxurl global to be available
-    if ( typeof window.ajaxurl === 'undefined' ) {
-        window.ajaxurl = wp.ajax.settings.url;
-    }
+/* global _wpCustomizeWidgetsSettings */
+(function( wp, $ ){
+
+    if ( ! wp || ! wp.customize ) { return; }
+
+    // Set up our namespace...
+    var api = wp.customize,
+        l10n, OldPreviewer;
+
+    api.Widgets = api.Widgets || {};
+
+    // Link settings
+    api.Widgets.data = _wpCustomizeWidgetsSettings || {};
+    l10n = api.Widgets.data.l10n;
+    delete api.Widgets.data.l10n;
 
     /**
      * Set up model
      */
-    Widget = self.Widget = Backbone.Model.extend( {
+    api.Widgets.WidgetModel = Backbone.Model.extend({
         id: null,
         temp_id: null,
@@ -55 +33 @@
         width: null,
         height: null
-    } );
-
-    WidgetCollection = self.WidgetCollection = Backbone.Collection.extend( {
-        model: Widget,
+    });
+
+    api.Widgets.WidgetCollection = Backbone.Collection.extend({
+        model: api.Widgets.WidgetModel,
 
         // Controls searching on the current widget collection
@@ -81 +59 @@
             // Useful for resetting the views when you clean the input
             if ( this.terms === '' ) {
-                this.reset( WidgetCustomizer_exports.available_widgets );
+                this.reset( api.Widgets.data.availableWidgets );
             }
 
@@ -94 +72 @@
 
             // Start with a full collection
-            this.reset( WidgetCustomizer_exports.available_widgets, { silent: true } );
+            this.reset( api.Widgets.data.availableWidgets, { silent: true } );
 
             // Escape the term string for RegExp meta characters
@@ -112 +90 @@
             this.reset( results );
         }
-    } );
-    self.available_widgets = new WidgetCollection( self.available_widgets );
-
-    Sidebar = self.Sidebar = Backbone.Model.extend( {
+    });
+    api.Widgets.availableWidgets = new api.Widgets.WidgetCollection( api.Widgets.data.availableWidgets );
+
+    api.Widgets.SidebarModel = Backbone.Model.extend({
         after_title: null,
         after_widget: null,
@@ -125 +103 @@
         name: null,
         is_rendered: false
-    } );
-
-    SidebarCollection = self.SidebarCollection = Backbone.Collection.extend( {
-        model: Sidebar
-    } );
-    self.registered_sidebars = new SidebarCollection( self.registered_sidebars );
+    });
+
+    api.Widgets.SidebarCollection = Backbone.Collection.extend({
+        model: api.Widgets.SidebarModel
+    });
+    api.Widgets.registeredSidebars = new api.Widgets.SidebarCollection( api.Widgets.data.registeredSidebars );
 
     /**
@@ -137 +115 @@
      * listeners for the widget-synced event.
      */
-    builtin_form_sync_handlers = {
+    api.Widgets.formSyncHandlers = {
 
         /**
          * @param {jQuery.Event} e
-         * @param {jQuery} widget_el
-         * @param {String} new_form
-         */
-        rss: function ( e, widget_el, new_form ) {
-            var old_widget_error = widget_el.find( '.widget-error:first' ),
-                new_widget_error = $( '<div>' + new_form + '</div>' ).find( '.widget-error:first' );
-
-            if ( old_widget_error.length && new_widget_error.length ) {
-                old_widget_error.replaceWith( new_widget_error );
-            } else if ( old_widget_error.length ) {
-                old_widget_error.remove();
-            } else if ( new_widget_error.length ) {
-                widget_el.find( '.widget-content:first' ).prepend( new_widget_error );
+         * @param {jQuery} widget
+         * @param {String} newForm
+         */
+        rss: function ( e, widget, newForm ) {
+            var oldWidgetError = widget.find( '.widget-error:first' ),
+                newWidgetError = $( '<div>' + newForm + '</div>' ).find( '.widget-error:first' );
+
+            if ( oldWidgetError.length && newWidgetError.length ) {
+                oldWidgetError.replaceWith( newWidgetError );
+            } else if ( oldWidgetError.length ) {
+                oldWidgetError.remove();
+            } else if ( newWidgetError.length ) {
+                widget.find( '.widget-content:first' ).prepend( newWidgetError );
             }
         }
@@ -159 +137 @@
 
     /**
-     * On DOM ready, initialize some meta functionality independent of specific
-     * customizer controls.
+     * Widget Form control
+     * Note that 'widget_form' must match the WP_Widget_Form_Customize_Control::$type
      */
-    self.init = function () {
-        this.availableWidgetsPanel.setup();
-
-        // Highlight widget control
-        this.previewer.bind( 'highlight-widget-control', self.highlightWidgetFormControl );
-
-        // Open and focus widget control
-        this.previewer.bind( 'focus-widget-control', self.focusWidgetFormControl );
-    };
-    wp.customize.bind( 'ready', function () {
-        self.init();
+    api.Widgets.WidgetControl = api.Control.extend({
+        /**
+         * Set up the control
+         */
+        ready: function() {
+            var control = this;
+            control._setupModel();
+            control._setupWideWidget();
+            control._setupControlToggle();
+            control._setupWidgetTitle();
+            control._setupReorderUI();
+            control._setupHighlightEffects();
+            control._setupUpdateUI();
+            control._setupRemoveUI();
+        },
+
+        /**
+         * Handle changes to the setting
+         */
+        _setupModel: function() {
+            var control = this, remember_saved_widget_id;
+
+            api.Widgets.savedWidgetIds = api.Widgets.savedWidgetIds || [];
+
+            // Remember saved widgets so we know which to trash (move to inactive widgets sidebar)
+            remember_saved_widget_id = function() {
+                api.Widgets.savedWidgetIds[control.params.widget_id] = true;
+            };
+            api.bind( 'ready', remember_saved_widget_id );
+            api.bind( 'saved', remember_saved_widget_id );
+
+            control._update_count = 0;
+            control.is_widget_updating = false;
+            control.live_update_mode = true;
+
+            // Update widget whenever model changes
+            control.setting.bind( function( to, from ) {
+                if ( ! _( from ).isEqual( to ) && ! control.is_widget_updating ) {
+                    control.updateWidget( { instance: to } );
+                }
+            } );
+        },
+
+        /**
+         * Add special behaviors for wide widget controls
+         */
+        _setupWideWidget: function() {
+            var control = this,
+                widget_inside,
+                widget_form,
+                customize_sidebar,
+                position_widget,
+                theme_controls_container;
+
+            if ( ! control.params.is_wide ) {
+                return;
+            }
+
+            widget_inside = control.container.find( '.widget-inside' );
+            widget_form = widget_inside.find( '> .form' );
+            customize_sidebar = $( '.wp-full-overlay-sidebar-content:first' );
+            control.container.addClass( 'wide-widget-control' );
+
+            control.container.find( '.widget-content:first' ).css( {
+                'max-width': control.params.width,
+                'min-height': control.params.height
+            } );
+
+            /**
+             * Keep the widget-inside positioned so the top of fixed-positioned
+             * element is at the same top position as the widget-top. When the
+             * widget-top is scrolled out of view, keep the widget-top in view;
+             * likewise, don't allow the widget to drop off the bottom of the window.
+             * If a widget is too tall to fit in the window, don't let the height
+             * exceed the window height so that the contents of the widget control
+             * will become scrollable (overflow:auto).
+             */
+            position_widget = function() {
+                var offset_top = control.container.offset().top,
+                    window_height = $( window ).height(),
+                    form_height = widget_form.outerHeight(),
+                    top;
+                widget_inside.css( 'max-height', window_height );
+                top = Math.max(
+                    0, // prevent top from going off screen
+                    Math.min(
+                        Math.max( offset_top, 0 ), // distance widget in panel is from top of screen
+                        window_height - form_height // flush up against bottom of screen
+                    )
+                );
+                widget_inside.css( 'top', top );
+            };
+
+            theme_controls_container = $( '#customize-theme-controls' );
+            control.container.on( 'expand', function() {
+                position_widget();
+                customize_sidebar.on( 'scroll', position_widget );
+                $( window ).on( 'resize', position_widget );
+                theme_controls_container.on( 'expanded collapsed', position_widget );
+            } );
+            control.container.on( 'collapsed', function() {
+                customize_sidebar.off( 'scroll', position_widget );
+                $( window ).off( 'resize', position_widget );
+                theme_controls_container.off( 'expanded collapsed', position_widget );
+            } );
+
+            // Reposition whenever a sidebar's widgets are changed
+            api.each( function ( setting ) {
+                if ( 0 === setting.id.indexOf( 'sidebars_widgets[' ) ) {
+                    setting.bind( function() {
+                        if ( control.container.hasClass( 'expanded' ) ) {
+                            position_widget();
+                        }
+                    } );
+                }
+            } );
+        },
+
+        /**
+         * Show/hide the control when clicking on the form title, when clicking
+         * the close button
+         */
+        _setupControlToggle: function() {
+            var control = this, close_btn;
+
+            control.container.find( '.widget-top' ).on( 'click', function ( e ) {
+                e.preventDefault();
+                var sidebar_widgets_control = control.getSidebarWidgetsControl();
+                if ( sidebar_widgets_control.is_reordering ) {
+                    return;
+                }
+                control.toggleForm();
+            } );
+
+            close_btn = control.container.find( '.widget-control-close' );
+            // @todo Hitting Enter on this link does nothing; will be resolved in core with <http://core.trac.wordpress.org/ticket/26633>
+            close_btn.on( 'click', function ( e ) {
+                e.preventDefault();
+                control.collapseForm();
+                control.container.find( '.widget-top .widget-action:first' ).focus(); // keyboard accessibility
+            } );
+        },
+
+        /**
+         * Update the title of the form if a title field is entered
+         */
+        _setupWidgetTitle: function() {
+            var control = this, update_title;
+
+            update_title = function() {
+                var title = control.setting().title,
+                    in_widget_title = control.container.find( '.in-widget-title' );
+
+                if ( title ) {
+                    in_widget_title.text( ': ' + title );
+                } else {
+                    in_widget_title.text( '' );
+                }
+            };
+            control.setting.bind( update_title );
+            update_title();
+        },
+
+        /**
+         * Set up the widget-reorder-nav
+         */
+        _setupReorderUI: function() {
+            var control = this,
+                select_sidebar_item,
+                move_widget_area,
+                reorder_nav,
+                update_available_sidebars;
+
+            /**
+             * select the provided sidebar list item in the move widget area
+             *
+             * @param {jQuery} li
+             */
+            select_sidebar_item = function ( li ) {
+                li.siblings( '.selected' ).removeClass( 'selected' );
+                li.addClass( 'selected' );
+                var is_self_sidebar = ( li.data( 'id' ) === control.params.sidebar_id );
+                control.container.find( '.move-widget-btn' ).prop( 'disabled', is_self_sidebar );
+            };
+
+            /**
+             * Add the widget reordering elements to the widget control
+             */
+            control.container.find( '.widget-title-action' ).after( $( api.Widgets.data.tpl.widgetReorderNav ) );
+            move_widget_area = $(
+                _.template( api.Widgets.data.tpl.moveWidgetArea, {
+                    sidebars: _( api.Widgets.registeredSidebars.toArray() ).pluck( 'attributes' )
+                } )
+            );
+            control.container.find( '.widget-top' ).after( move_widget_area );
+
+            /**
+             * Update available sidebars when their rendered state changes
+             */
+            update_available_sidebars = function() {
+                var sidebar_items = move_widget_area.find( 'li' ), self_sidebar_item;
+                self_sidebar_item = sidebar_items.filter( function(){
+                    return $( this ).data( 'id' ) === control.params.sidebar_id;
+                } );
+                sidebar_items.each( function() {
+                    var li = $( this ),
+                        sidebar_id,
+                        sidebar_model;
+
+                    sidebar_id = li.data( 'id' );
+                    sidebar_model = api.Widgets.registeredSidebars.get( sidebar_id );
+                    li.toggle( sidebar_model.get( 'is_rendered' ) );
+                    if ( li.hasClass( 'selected' ) && ! sidebar_model.get( 'is_rendered' ) ) {
+                        select_sidebar_item( self_sidebar_item );
+                    }
+                } );
+            };
+            update_available_sidebars();
+            api.Widgets.registeredSidebars.on( 'change:is_rendered', update_available_sidebars );
+
+            /**
+             * Handle clicks for up/down/move on the reorder nav
+             */
+            reorder_nav = control.container.find( '.widget-reorder-nav' );
+            reorder_nav.find( '.move-widget, .move-widget-down, .move-widget-up' ).on( 'click keypress', function ( event ) {
+                if ( event.type === 'keypress' && ( event.which !== 13 && event.which !== 32 ) ) {
+                    return;
+                }
+                $( this ).focus();
+
+                if ( $( this ).is( '.move-widget' ) ) {
+                    control.toggleWidgetMoveArea();
+                } else {
+                    var is_move_down = $( this ).is( '.move-widget-down' ),
+                        is_move_up = $( this ).is( '.move-widget-up' ),
+                        i = control.getWidgetSidebarPosition();
+
+                    if ( ( is_move_up && i === 0 ) || ( is_move_down && i === control.getSidebarWidgetsControl().setting().length - 1 ) ) {
+                        return;
+                    }
+
+                    if ( is_move_up ) {
+                        control.moveUp();
+                    } else {
+                        control.moveDown();
+                    }
+
+                    $( this ).focus(); // re-focus after the container was moved
+                }
+            } );
+
+            /**
+             * Handle selecting a sidebar to move to
+             */
+            control.container.find( '.widget-area-select' ).on( 'click keypress', 'li', function ( e ) {
+                if ( event.type === 'keypress' && ( event.which !== 13 && event.which !== 32 ) ) {
+                    return;
+                }
+                e.preventDefault();
+                select_sidebar_item( $( this ) );
+            } );
+
+            /**
+             * Move widget to another sidebar
+             */
+            control.container.find( '.move-widget-btn' ).click( function() {
+                control.getSidebarWidgetsControl().toggleReordering( false );
+
+                var old_sidebar_id = control.params.sidebar_id,
+                    new_sidebar_id = control.container.find( '.widget-area-select li.selected' ).data( 'id' ),
+                    old_sidebar_widgets_setting,
+                    new_sidebar_widgets_setting,
+                    old_sidebar_widget_ids,
+                    new_sidebar_widget_ids,
+                    i;
+
+                old_sidebar_widgets_setting = api( 'sidebars_widgets[' + old_sidebar_id + ']' );
+                new_sidebar_widgets_setting = api( 'sidebars_widgets[' + new_sidebar_id + ']' );
+                old_sidebar_widget_ids = Array.prototype.slice.call( old_sidebar_widgets_setting() );
+                new_sidebar_widget_ids = Array.prototype.slice.call( new_sidebar_widgets_setting() );
+
+                i = control.getWidgetSidebarPosition();
+                old_sidebar_widget_ids.splice( i, 1 );
+                new_sidebar_widget_ids.push( control.params.widget_id );
+
+                old_sidebar_widgets_setting( old_sidebar_widget_ids );
+                new_sidebar_widgets_setting( new_sidebar_widget_ids );
+
+                control.focus();
+            } );
+        },
+
+        /**
+         * Highlight widgets in preview when interacted with in the customizer
+         */
+        _setupHighlightEffects: function() {
+            var control = this;
+
+            // Highlight whenever hovering or clicking over the form
+            control.container.on( 'mouseenter click', function() {
+                control.setting.previewer.send( 'highlight-widget', control.params.widget_id );
+            } );
+
+            // Highlight when the setting is updated
+            control.setting.bind( function() {
+                control.setting.previewer.send( 'highlight-widget', control.params.widget_id );
+            } );
+
+            // Highlight when the widget form is expanded
+            control.container.on( 'expand', function() {
+                control.scrollPreviewWidgetIntoView();
+            } );
+        },
+
+        /**
+         * Set up event handlers for widget updating
+         */
+        _setupUpdateUI: function() {
+            var control = this,
+                widget_root,
+                widget_content,
+                save_btn,
+                update_widget_debounced,
+                form_update_event_handler;
+
+            widget_root = control.container.find( '.widget:first' );
+            widget_content = widget_root.find( '.widget-content:first' );
+
+            // Configure update button
+            save_btn = control.container.find( '.widget-control-save' );
+            save_btn.val( l10n.saveBtnLabel );
+            save_btn.attr( 'title', l10n.saveBtnTooltip );
+            save_btn.removeClass( 'button-primary' ).addClass( 'button-secondary' );
+            save_btn.on( 'click', function ( e ) {
+                e.preventDefault();
+                control.updateWidget( { disable_form: true } );
+            } );
+
+            update_widget_debounced = _.debounce( function() {
+                // @todo For compatibility with other plugins, should we trigger a click event? What about form submit event?
+                control.updateWidget();
+            }, 250 );
+
+            // Trigger widget form update when hitting Enter within an input
+            control.container.find( '.widget-content' ).on( 'keydown', 'input', function( e ) {
+                if ( 13 === e.which ) { // Enter
+                    e.preventDefault();
+                    control.updateWidget( { ignore_active_element: true } );
+                }
+            } );
+
+            // Handle widgets that support live previews
+            widget_content.on( 'change input propertychange', ':input', function ( e ) {
+                if ( control.live_update_mode ) {
+                    if ( e.type === 'change' ) {
+                        control.updateWidget();
+                    } else if ( this.checkValidity && this.checkValidity() ) {
+                        update_widget_debounced();
+                    }
+                }
+            } );
+
+            // Remove loading indicators when the setting is saved and the preview updates
+            control.setting.previewer.channel.bind( 'synced', function() {
+                control.container.removeClass( 'previewer-loading' );
+            } );
+            api.Widgets.Previewer.bind( 'widget-updated', function ( updated_widget_id ) {
+                if ( updated_widget_id === control.params.widget_id ) {
+                    control.container.removeClass( 'previewer-loading' );
+                }
+            } );
+
+            // Update widget control to indicate whether it is currently rendered (cf. Widget Visibility)
+            api.Widgets.Previewer.bind( 'rendered-widgets', function ( rendered_widgets ) {
+                var is_rendered = !! rendered_widgets[control.params.widget_id];
+                control.container.toggleClass( 'widget-rendered', is_rendered );
+            } );
+
+            form_update_event_handler = api.Widgets.formSyncHandlers[ control.params.widget_id_base ];
+            if ( form_update_event_handler ) {
+                $( document ).on( 'widget-synced', function ( e, widget_el ) {
+                    if ( widget_root.is( widget_el ) ) {
+                        form_update_event_handler.apply( document, arguments );
+                    }
+                } );
+            }
+        },
+
+        /**
+         * Set up event handlers for widget removal
+         */
+        _setupRemoveUI: function() {
+            var control = this,
+                remove_btn,
+                replace_delete_with_remove;
+
+            // Configure remove button
+            remove_btn = control.container.find( 'a.widget-control-remove' );
+            // @todo Hitting Enter on this link does nothing; will be resolved in core with <http://core.trac.wordpress.org/ticket/26633>
+            remove_btn.on( 'click', function ( e ) {
+                e.preventDefault();
+
+                // Find an adjacent element to add focus to when this widget goes away
+                var adjacent_focus_target;
+                if ( control.container.next().is( '.customize-control-widget_form' ) ) {
+                    adjacent_focus_target = control.container.next().find( '.widget-action:first' );
+                } else if ( control.container.prev().is( '.customize-control-widget_form' ) ) {
+                    adjacent_focus_target = control.container.prev().find( '.widget-action:first' );
+                } else {
+                    adjacent_focus_target = control.container.next( '.customize-control-sidebar_widgets' ).find( '.add-new-widget:first' );
+                }
+
+                control.container.slideUp( function() {
+                    var sidebars_widgets_control = api.Widgets.getSidebarWidgetControlContainingWidget( control.params.widget_id ),
+                        sidebar_widget_ids,
+                        i;
+
+                    if ( ! sidebars_widgets_control ) {
+                        throw new Error( 'Unable to find sidebars_widgets_control' );
+                    }
+                    sidebar_widget_ids = sidebars_widgets_control.setting().slice();
+                    i = _.indexOf( sidebar_widget_ids, control.params.widget_id );
+                    if ( -1 === i ) {
+                        throw new Error( 'Widget is not in sidebar' );
+                    }
+                    sidebar_widget_ids.splice( i, 1 );
+                    sidebars_widgets_control.setting( sidebar_widget_ids );
+                    adjacent_focus_target.focus(); // keyboard accessibility
+                } );
+            } );
+
+            replace_delete_with_remove = function() {
+                remove_btn.text( l10n.removeBtnLabel ); // wp_widget_control() outputs the link as "Delete"
+                remove_btn.attr( 'title', l10n.removeBtnTooltip );
+            };
+            if ( control.params.is_new ) {
+                api.bind( 'saved', replace_delete_with_remove );
+            } else {
+                replace_delete_with_remove();
+            }
+        },
+
+        /**
+         * Find all inputs in a widget container that should be considered when
+         * comparing the loaded form with the sanitized form, whose fields will
+         * be aligned to copy the sanitized over. The elements returned by this
+         * are passed into this._getInputsSignature(), and they are iterated
+         * over when copying sanitized values over to the the form loaded.
+         *
+         * @param {jQuery} container element in which to look for inputs
+         * @returns {jQuery} inputs
+         * @private
+         */
+        _getInputs: function ( container ) {
+            return $( container ).find( ':input[name]' );
+        },
+
+        /**
+         * Iterate over supplied inputs and create a signature string for all of them together.
+         * This string can be used to compare whether or not the form has all of the same fields.
+         *
+         * @param {jQuery} inputs
+         * @returns {string}
+         * @private
+         */
+        _getInputsSignature: function ( inputs ) {
+            var inputs_signatures = _( inputs ).map( function ( input ) {
+                input = $( input );
+                var signature_parts;
+                if ( input.is( ':checkbox, :radio' ) ) {
+                    signature_parts = [ input.attr( 'id' ), input.attr( 'name' ), input.prop( 'value' ) ];
+                } else {
+                    signature_parts = [ input.attr( 'id' ), input.attr( 'name' ) ];
+                }
+                return signature_parts.join( ',' );
+            } );
+            return inputs_signatures.join( ';' );
+        },
+
+        /**
+         * Get the property that represents the state of an input.
+         *
+         * @param {jQuery|DOMElement} input
+         * @returns {string}
+         * @private
+         */
+        _getInputStatePropertyName: function ( input ) {
+            input = $( input );
+            if ( input.is( ':radio, :checkbox' ) ) {
+                return 'checked';
+            } else {
+                return 'value';
+            }
+        },
+
+        /***********************************************************************
+         * Begin public API methods
+         **********************************************************************/
+
+        /**
+         * @return {wp.customize.controlConstructor.sidebar_widgets[]}
+         */
+        getSidebarWidgetsControl: function() {
+            var control = this, setting_id, sidebar_widgets_control;
+
+            setting_id = 'sidebars_widgets[' + control.params.sidebar_id + ']';
+            sidebar_widgets_control = api.control( setting_id );
+            if ( ! sidebar_widgets_control ) {
+                throw new Error( 'Unable to locate sidebar_widgets control for ' + control.params.sidebar_id );
+            }
+            return sidebar_widgets_control;
+        },
+
+        /**
+         * Submit the widget form via Ajax and get back the updated instance,
+         * along with the new widget control form to render.
+         *
+         * @param {object} [args]
+         * @param {Object|null} [args.instance=null]  When the model changes, the instance is sent here; otherwise, the inputs from the form are used
+         * @param {Function|null} [args.complete=null]  Function which is called when the request finishes. Context is bound to the control. First argument is any error. Following arguments are for success.
+         * @param {Boolean} [args.ignore_active_element=false] Whether or not updating a field will be deferred if focus is still on the element.
+         */
+        updateWidget: function ( args ) {
+            var control = this,
+                instance_override,
+                complete_callback,
+                widget_root,
+                update_number,
+                widget_content,
+                params,
+                data,
+                inputs,
+                processing,
+                jqxhr,
+                is_changed;
+
+            args = $.extend( {
+                instance: null,
+                complete: null,
+                ignore_active_element: false
+            }, args );
+
+            instance_override = args.instance;
+            complete_callback = args.complete;
+
+            control._update_count += 1;
+            update_number = control._update_count;
+
+            widget_root = control.container.find( '.widget:first' );
+            widget_content = widget_root.find( '.widget-content:first' );
+
+            // Remove a previous error message
+            widget_content.find( '.widget-error' ).remove();
+
+            control.container.addClass( 'widget-form-loading' );
+            control.container.addClass( 'previewer-loading' );
+            processing = api.state( 'processing' );
+            processing( processing() + 1 );
+
+            if ( ! control.live_update_mode ) {
+                control.container.addClass( 'widget-form-disabled' );
+            }
+
+            params = {};
+            params.action = 'update-widget';
+            params.wp_customize = 'on';
+            params.nonce = api.Widgets.data.nonce;
+
+            data = $.param( params );
+            inputs = control._getInputs( widget_content );
+
+            // Store the value we're submitting in data so that when the response comes back,
+            // we know if it got sanitized; if there is no difference in the sanitized value,
+            // then we do not need to touch the UI and mess up the user's ongoing editing.
+            inputs.each( function() {
+                var input = $( this ),
+                    property = control._getInputStatePropertyName( this );
+                input.data( 'state' + update_number, input.prop( property ) );
+            } );
+
+            if ( instance_override ) {
+                data += '&' + $.param( { 'sanitized_widget_setting': JSON.stringify( instance_override ) } );
+            } else {
+                data += '&' + inputs.serialize();
+            }
+            data += '&' + widget_content.find( '~ :input' ).serialize();
+
+            jqxhr = $.post( wp.ajax.settings.url, data, function ( r ) {
+                var message,
+                    sanitized_form,
+                    sanitized_inputs,
+                    has_same_inputs_in_response,
+                    is_live_update_aborted = false;
+
+                // Check if the user is logged out.
+                if ( '0' === r ) {
+                    api.Widgets.Previewer.preview.iframe.hide();
+                    api.Widgets.Previewer.login().done( function() {
+                        control.updateWidget( args );
+                        api.Widgets.Previewer.preview.iframe.show();
+                    } );
+                    return;
+                }
+
+                // Check for cheaters.
+                if ( '-1' === r ) {
+                    api.Widgets.Previewer.cheatin();
+                    return;
+                }
+
+                if ( r.success ) {
+                    sanitized_form = $( '<div>' + r.data.form + '</div>' );
+                    sanitized_inputs = control._getInputs( sanitized_form );
+                    has_same_inputs_in_response = control._getInputsSignature( inputs ) === control._getInputsSignature( sanitized_inputs );
+
+                    // Restore live update mode if sanitized fields are now aligned with the existing fields
+                    if ( has_same_inputs_in_response && ! control.live_update_mode ) {
+                        control.live_update_mode = true;
+                        control.container.removeClass( 'widget-form-disabled' );
+                        control.container.find( 'input[name="savewidget"]' ).hide();
+                    }
+
+                    // Sync sanitized field states to existing fields if they are aligned
+                    if ( has_same_inputs_in_response && control.live_update_mode ) {
+                        inputs.each( function ( i ) {
+                            var input = $( this ),
+                                sanitized_input = $( sanitized_inputs[i] ),
+                                property = control._getInputStatePropertyName( this ),
+                                submitted_state,
+                                sanitized_state,
+                                can_update_state;
+
+                            submitted_state = input.data( 'state' + update_number );
+                            sanitized_state = sanitized_input.prop( property );
+                            input.data( 'sanitized', sanitized_state );
+
+                            can_update_state = (
+                                submitted_state !== sanitized_state &&
+                                ( args.ignore_active_element || ! input.is( document.activeElement ) )
+                            );
+                            if ( can_update_state ) {
+                                input.prop( property, sanitized_state );
+                            }
+                        } );
+                        $( document ).trigger( 'widget-synced', [ widget_root, r.data.form ] );
+
+                    // Otherwise, if sanitized fields are not aligned with existing fields, disable live update mode if enabled
+                    } else if ( control.live_update_mode ) {
+                        control.live_update_mode = false;
+                        control.container.find( 'input[name="savewidget"]' ).show();
+                        is_live_update_aborted = true;
+                    // Otherwise, replace existing form with the sanitized form
+                    } else {
+                        widget_content.html( r.data.form );
+                        control.container.removeClass( 'widget-form-disabled' );
+                        $( document ).trigger( 'widget-updated', [ widget_root ] );
+                    }
+
+                    /**
+                     * If the old instance is identical to the new one, there is nothing new
+                     * needing to be rendered, and so we can preempt the event for the
+                     * preview finishing loading.
+                     */
+                    is_changed = ! is_live_update_aborted && ! _( control.setting() ).isEqual( r.data.instance );
+                    if ( is_changed ) {
+                        control.is_widget_updating = true; // suppress triggering another updateWidget
+                        control.setting( r.data.instance );
+                        control.is_widget_updating = false;
+                    } else {
+                        // no change was made, so stop the spinner now instead of when the preview would updates
+                        control.container.removeClass( 'previewer-loading' );
+                    }
+
+                    if ( complete_callback ) {
+                        complete_callback.call( control, null, { no_change: ! is_changed, ajax_finished: true } );
+                    }
+                } else {
+                    message = l10n.error;
+                    if ( r.data && r.data.message ) {
+                        message = r.data.message;
+                    }
+                    if ( complete_callback ) {
+                        complete_callback.call( control, message );
+                    } else {
+                        widget_content.prepend( '<p class="widget-error"><strong>' + message + '</strong></p>' );
+                    }
+                }
+            } );
+            jqxhr.fail( function ( jqXHR, textStatus ) {
+                if ( complete_callback ) {
+                    complete_callback.call( control, textStatus );
+                }
+            } );
+            jqxhr.always( function() {
+                control.container.removeClass( 'widget-form-loading' );
+                inputs.each( function() {
+                    $( this ).removeData( 'state' + update_number );
+                } );
+
+                processing( processing() - 1 );
+            } );
+        },
+
+        /**
+         * Expand the accordion section containing a control
+         * @todo it would be nice if accordion had a proper API instead of having to trigger UI events on its elements
+         */
+        expandControlSection: function() {
+            var section = this.container.closest( '.accordion-section' );
+            if ( ! section.hasClass( 'open' ) ) {
+                section.find( '.accordion-section-title:first' ).trigger( 'click' );
+            }
+        },
+
+        /**
+         * Expand the widget form control
+         */
+        expandForm: function() {
+            this.toggleForm( true );
+        },
+
+        /**
+         * Collapse the widget form control
+         */
+        collapseForm: function() {
+            this.toggleForm( false );
+        },
+
+        /**
+         * Expand or collapse the widget control
+         *
+         * @param {boolean|undefined} [do_expand] If not supplied, will be inverse of current visibility
+         */
+        toggleForm: function ( do_expand ) {
+            var control = this, widget, inside, complete;
+
+            widget = control.container.find( 'div.widget:first' );
+            inside = widget.find( '.widget-inside:first' );
+            if ( typeof do_expand === 'undefined' ) {
+                do_expand = ! inside.is( ':visible' );
+            }
+
+            // Already expanded or collapsed, so noop
+            if ( inside.is( ':visible' ) === do_expand ) {
+                return;
+            }
+
+            if ( do_expand ) {
+                // Close all other widget controls before expanding this one
+                api.control.each( function ( other_control ) {
+                    if ( control.params.type === other_control.params.type && control !== other_control ) {
+                        other_control.collapseForm();
+                    }
+                } );
+
+                complete = function() {
+                    control.container.removeClass( 'expanding' );
+                    control.container.addClass( 'expanded' );
+                    control.container.trigger( 'expanded' );
+                };
+                if ( control.params.is_wide ) {
+                    inside.fadeIn( 'fast', complete );
+                } else {
+                    inside.slideDown( 'fast', complete );
+                }
+                control.container.trigger( 'expand' );
+                control.container.addClass( 'expanding' );
+            } else {
+                control.container.trigger( 'collapse' );
+                control.container.addClass( 'collapsing' );
+                complete = function() {
+                    control.container.removeClass( 'collapsing' );
+                    control.container.removeClass( 'expanded' );
+                    control.container.trigger( 'collapsed' );
+                };
+                if ( control.params.is_wide ) {
+                    inside.fadeOut( 'fast', complete );
+                } else {
+                    inside.slideUp( 'fast', function() {
+                        widget.css( { width:'', margin:'' } );
+                        complete();
+                    } );
+                }
+            }
+        },
+
+        /**
+         * Expand the containing sidebar section, expand the form, and focus on
+         * the first input in the control
+         */
+        focus: function() {
+            var control = this;
+            control.expandControlSection();
+            control.expandForm();
+            control.container.find( '.widget-content :focusable:first' ).focus();
+        },
+
+        /**
+         * Get the position (index) of the widget in the containing sidebar
+         *
+         * @throws Error
+         * @returns {Number}
+         */
+        getWidgetSidebarPosition: function() {
+            var control = this,
+                sidebar_widget_ids,
+                position;
+
+            sidebar_widget_ids = control.getSidebarWidgetsControl().setting();
+            position = _.indexOf( sidebar_widget_ids, control.params.widget_id );
+            if ( position === -1 ) {
+                throw new Error( 'Widget was unexpectedly not present in the sidebar.' );
+            }
+            return position;
+        },
+
+        /**
+         * Move widget up one in the sidebar
+         */
+        moveUp: function() {
+            this._moveWidgetByOne( -1 );
+        },
+
+        /**
+         * Move widget up one in the sidebar
+         */
+        moveDown: function() {
+            this._moveWidgetByOne( 1 );
+        },
+
+        /**
+         * @private
+         *
+         * @param {Number} offset 1|-1
+         */
+        _moveWidgetByOne: function ( offset ) {
+            var control = this,
+                i,
+                sidebar_widgets_setting,
+                sidebar_widget_ids,
+                adjacent_widget_id;
+
+            i = control.getWidgetSidebarPosition();
+
+            sidebar_widgets_setting = control.getSidebarWidgetsControl().setting;
+            sidebar_widget_ids = Array.prototype.slice.call( sidebar_widgets_setting() ); // clone
+            adjacent_widget_id = sidebar_widget_ids[i + offset];
+            sidebar_widget_ids[i + offset] = control.params.widget_id;
+            sidebar_widget_ids[i] = adjacent_widget_id;
+
+            sidebar_widgets_setting( sidebar_widget_ids );
+        },
+
+        /**
+         * Toggle visibility of the widget move area
+         *
+         * @param {Boolean} [toggle]
+         */
+        toggleWidgetMoveArea: function ( toggle ) {
+            var control = this, move_widget_area;
+            move_widget_area = control.container.find( '.move-widget-area' );
+            if ( typeof toggle === 'undefined' ) {
+                toggle = ! move_widget_area.hasClass( 'active' );
+            }
+            if ( toggle ) {
+                // reset the selected sidebar
+                move_widget_area.find( '.selected' ).removeClass( 'selected' );
+                move_widget_area.find( 'li' ).filter( function() {
+                    return $( this ).data( 'id' ) === control.params.sidebar_id;
+                } ).addClass( 'selected' );
+                control.container.find( '.move-widget-btn' ).prop( 'disabled', true );
+            }
+            move_widget_area.toggleClass( 'active', toggle );
+        },
+
+        /**
+         * Inside of the customizer preview, scroll the widget into view
+         */
+        scrollPreviewWidgetIntoView: function() {
+            // @todo scrollIntoView() provides a robust but very poor experience. Animation is needed. See https://github.com/x-team/wp-widget-customizer/issues/16
+        },
+
+        /**
+         * Highlight the widget control and section
+         */
+        highlightSectionAndControl: function() {
+            var control = this, target_element;
+
+            if ( control.container.is( ':hidden' ) ) {
+                target_element = control.container.closest( '.control-section' );
+            } else {
+                target_element = control.container;
+            }
+
+            $( '.widget-customizer-highlighted' ).removeClass( 'widget-customizer-highlighted' );
+            target_element.addClass( 'widget-customizer-highlighted' );
+            setTimeout( function() {
+                target_element.removeClass( 'widget-customizer-highlighted' );
+            }, 500 );
+        }
+
     } );
 
     /**
      * Sidebar Widgets control
-     * Note that 'sidebar_widgets' must match the Sidebar_Widgets_WP_Customize_Control::$type
+     * Note that 'sidebar_widgets' must match the WP_Widget_Area_Customize_Control::$type
      */
-    customize.controlConstructor.sidebar_widgets = customize.Control.extend( {
-
+    api.Widgets.SidebarControl = api.Control.extend({
         /**
          * Set up the control
@@ -199 +1066 @@
         _setupModel: function() {
             var control = this,
-                registered_sidebar = self.registered_sidebars.get( control.params.sidebar_id );
+                registered_sidebar = api.Widgets.registeredSidebars.get( control.params.sidebar_id );
 
             control.setting.bind( function( new_widget_ids, old_widget_ids ) {
@@ -210 +1077 @@
                 new_widget_ids = _( new_widget_ids ).filter( function ( new_widget_id ) {
                     var parsed_widget_id = parse_widget_id( new_widget_id );
-                    return !! self.available_widgets.findWhere( { id_base: parsed_widget_id.id_base } );
+                    return !! api.Widgets.availableWidgets.findWhere( { id_base: parsed_widget_id.id_base } );
                 } );
 
                 widget_form_controls = _( new_widget_ids ).map( function ( widget_id ) {
-                    var widget_form_control = self.getWidgetFormControlForWidget( widget_id );
+                    var widget_form_control = api.Widgets.getWidgetFormControlForWidget( widget_id );
                     if ( ! widget_form_control ) {
                         widget_form_control = control.addWidget( widget_id );
@@ -251 +1118 @@
 
                     // Using setTimeout so that when moving a widget to another sidebar, the other sidebars_widgets settings get a chance to update
-                    setTimeout( function () {
+                    setTimeout( function() {
                         var is_present_in_another_sidebar = false,
                             removed_control,
@@ -260 +1127 @@
 
                         // Check if the widget is in another sidebar
-                        wp.customize.each( function ( other_setting ) {
+                        api.each( function ( other_setting ) {
                             if ( other_setting.id === control.setting.id || 0 !== other_setting.id.indexOf( 'sidebars_widgets[' ) || other_setting.id === 'sidebars_widgets[wp_inactive_widgets]' ) {
                                 return;
@@ -277 +1144 @@
                         }
 
-                        removed_control = self.getWidgetFormControlForWidget( removed_widget_id );
+                        removed_control = api.Widgets.getWidgetFormControlForWidget( removed_widget_id );
 
                         // Detect if widget control was dragged to another sidebar
@@ -288 +1155 @@
                         // Delete any widget form controls for removed widgets
                         if ( removed_control && ! was_dragged_to_another_sidebar ) {
-                            wp.customize.control.remove( removed_control.id );
+                            api.control.remove( removed_control.id );
                             removed_control.container.remove();
                         }
@@ -294 +1161 @@
                         // Move widget to inactive widgets sidebar (move it to trash) if has been previously saved
                         // This prevents the inactive widgets sidebar from overflowing with throwaway widgets
-                        if ( self.saved_widget_ids[removed_widget_id] ) {
-                            inactive_widgets = wp.customize.value( 'sidebars_widgets[wp_inactive_widgets]' )().slice();
+                        if ( api.Widgets.savedWidgetIds[removed_widget_id] ) {
+                            inactive_widgets = api.value( 'sidebars_widgets[wp_inactive_widgets]' )().slice();
                             inactive_widgets.push( removed_widget_id );
-                            wp.customize.value( 'sidebars_widgets[wp_inactive_widgets]' )( _( inactive_widgets ).unique() );
+                            api.value( 'sidebars_widgets[wp_inactive_widgets]' )( _( inactive_widgets ).unique() );
                         }
 
                         // Make old single widget available for adding again
                         removed_id_base = parse_widget_id( removed_widget_id ).id_base;
-                        widget = self.available_widgets.findWhere( { id_base: removed_id_base } );
+                        widget = api.Widgets.availableWidgets.findWhere( { id_base: removed_id_base } );
                         if ( widget && ! widget.get( 'is_multi' ) ) {
                             widget.set( 'is_disabled', false );
@@ -312 +1179 @@
 
             // Update the model with whether or not the sidebar is rendered
-            self.previewer.bind( 'rendered-sidebars', function ( rendered_sidebars ) {
+            api.Widgets.Previewer.bind( 'rendered-sidebars', function ( rendered_sidebars ) {
                 var is_rendered = !! rendered_sidebars[control.params.sidebar_id];
                 registered_sidebar.set( 'is_rendered', is_rendered );
@@ -322 +1189 @@
                 section = $( section_selector );
                 if ( this.get( 'is_rendered' ) ) {
-                    section.stop().slideDown( function () {
+                    section.stop().slideDown( function() {
                         $( this ).css( 'height', 'auto' ); // so that the .accordion-section-content won't overflow
                     } );
@@ -339 +1206 @@
          * Allow widgets in sidebar to be re-ordered, and for the order to be previewed
          */
-        _setupSortable: function () {
+        _setupSortable: function() {
             var control = this;
             control.is_reordering = false;
@@ -351 +1218 @@
                 axis: 'y',
                 connectWith: '.accordion-section-content:has(.customize-control-sidebar_widgets)',
-                update: function () {
+                update: function() {
                     var widget_container_ids = control.section_content.sortable( 'toArray' ), widget_ids;
                     widget_ids = $.map( widget_container_ids, function ( widget_container_id ) {
@@ -366 +1233 @@
             control.control_section.find( '.accordion-section-title' ).droppable( {
                 accept: '.customize-control-widget_form',
-                over: function () {
+                over: function() {
                     if ( ! control.control_section.hasClass( 'open' ) ) {
                         control.control_section.addClass( 'open' );
-                        control.section_content.toggle( false ).slideToggle( 150, function () {
+                        control.section_content.toggle( false ).slideToggle( 150, function() {
                             control.section_content.sortable( 'refreshPositions' );
                         } );
@@ -391 +1258 @@
          * Set up UI for adding a new widget
          */
-        _setupAddition: function () {
+        _setupAddition: function() {
             var control = this;
 
@@ -405 +1272 @@
                 // @todo Use an control.is_adding state
                 if ( ! $( 'body' ).hasClass( 'adding-widget' ) ) {
-                    self.availableWidgetsPanel.open( control );
+                    api.Widgets.availableWidgetsPanel.open( control );
                 } else {
-                    self.availableWidgetsPanel.close();
+                    api.Widgets.availableWidgetsPanel.close();
                 }
             } );
@@ -415 +1282 @@
          * Add classes to the widget_form controls to assist with styling
          */
-        _applyCardinalOrderClassNames: function () {
+        _applyCardinalOrderClassNames: function() {
             var control = this;
             control.section_content.find( '.customize-control-widget_form' )
@@ -460 +1327 @@
          * @return {wp.customize.controlConstructor.widget_form[]}
          */
-        getWidgetFormControls: function () {
+        getWidgetFormControls: function() {
             var control = this, form_controls;
 
             form_controls = _( control.setting() ).map( function ( widget_id ) {
                 var setting_id = widget_id_to_setting_id( widget_id ),
-                    form_control = customize.control( setting_id );
+                    form_control = api.control( setting_id );
 
                 if ( ! form_control ) {
@@ -488 +1355 @@
                 widget_number = parsed_widget_id.number,
                 widget_id_base = parsed_widget_id.id_base,
-                widget = self.available_widgets.findWhere( {id_base: widget_id_base} ),
+                widget = api.Widgets.availableWidgets.findWhere( {id_base: widget_id_base} ),
                 setting_id,
                 is_existing_widget,
@@ -540 +1407 @@
 
             // Only create setting if it doesn't already exist (if we're adding a pre-existing inactive widget)
-            is_existing_widget = wp.customize.has( setting_id );
+            is_existing_widget = api.has( setting_id );
             if ( ! is_existing_widget ) {
                 setting_args = {
@@ -546 +1413 @@
                     previewer: control.setting.previewer
                 };
-                wp.customize.create( setting_id, setting_id, {}, setting_args );
-            }
-
-            Constructor = wp.customize.controlConstructor[customize_control_type];
+                api.create( setting_id, setting_id, {}, setting_args );
+            }
+
+            Constructor = api.controlConstructor[customize_control_type];
             widget_form_control = new Constructor( setting_id, {
                 params: {
@@ -566 +1433 @@
                 previewer: control.setting.previewer
             } );
-            wp.customize.control.add( setting_id, widget_form_control );
+            api.control.add( setting_id, widget_form_control );
 
             // Make sure widget is removed from the other sidebars
-            wp.customize.each( function ( other_setting ) {
+            api.each( function ( other_setting ) {
                 if ( other_setting.id === control.setting.id ) {
                     return;
@@ -591 +1458 @@
             }
 
-            customize_control.slideDown( function () {
+            customize_control.slideDown( function() {
                 if ( is_existing_widget ) {
                     widget_form_control.expandForm();
@@ -615 +1482 @@
     } );
 
-    /**
-     * Widget Form control
-     * Note that 'widget_form' must match the Widget_Form_WP_Customize_Control::$type
-     */
-    customize.controlConstructor.widget_form = customize.Control.extend( {
-
-        /**
-         * Set up the control
-         */
-        ready: function() {
-            var control = this;
-            control._setupModel();
-            control._setupWideWidget();
-            control._setupControlToggle();
-            control._setupWidgetTitle();
-            control._setupReorderUI();
-            control._setupHighlightEffects();
-            control._setupUpdateUI();
-            control._setupRemoveUI();
-        },
-
-        /**
-         * Handle changes to the setting
-         */
-        _setupModel: function () {
-            var control = this, remember_saved_widget_id;
-
-            // Remember saved widgets so we know which to trash (move to inactive widgets sidebar)
-            remember_saved_widget_id = function () {
-                self.saved_widget_ids[control.params.widget_id] = true;
-            };
-            wp.customize.bind( 'ready', remember_saved_widget_id );
-            wp.customize.bind( 'saved', remember_saved_widget_id );
-
-            control._update_count = 0;
-            control.is_widget_updating = false;
-            control.live_update_mode = true;
-
-            // Update widget whenever model changes
-            control.setting.bind( function( to, from ) {
-                if ( ! _( from ).isEqual( to ) && ! control.is_widget_updating ) {
-                    control.updateWidget( { instance: to } );
-                }
-            } );
-        },
-
-        /**
-         * Add special behaviors for wide widget controls
-         */
-        _setupWideWidget: function () {
-            var control = this,
-                widget_inside,
-                widget_form,
-                customize_sidebar,
-                position_widget,
-                theme_controls_container;
-
-            if ( ! control.params.is_wide ) {
-                return;
-            }
-
-            widget_inside = control.container.find( '.widget-inside' );
-            widget_form = widget_inside.find( '> .form' );
-            customize_sidebar = $( '.wp-full-overlay-sidebar-content:first' );
-            control.container.addClass( 'wide-widget-control' );
-
-            control.container.find( '.widget-content:first' ).css( {
-                'max-width': control.params.width,
-                'min-height': control.params.height
-            } );
-
-            /**
-             * Keep the widget-inside positioned so the top of fixed-positioned
-             * element is at the same top position as the widget-top. When the
-             * widget-top is scrolled out of view, keep the widget-top in view;
-             * likewise, don't allow the widget to drop off the bottom of the window.
-             * If a widget is too tall to fit in the window, don't let the height
-             * exceed the window height so that the contents of the widget control
-             * will become scrollable (overflow:auto).
-             */
-            position_widget = function () {
-                var offset_top = control.container.offset().top,
-                    window_height = $( window ).height(),
-                    form_height = widget_form.outerHeight(),
-                    top;
-                widget_inside.css( 'max-height', window_height );
-                top = Math.max(
-                    0, // prevent top from going off screen
-                    Math.min(
-                        Math.max( offset_top, 0 ), // distance widget in panel is from top of screen
-                        window_height - form_height // flush up against bottom of screen
-                    )
-                );
-                widget_inside.css( 'top', top );
-            };
-
-            theme_controls_container = $( '#customize-theme-controls' );
-            control.container.on( 'expand', function () {
-                position_widget();
-                customize_sidebar.on( 'scroll', position_widget );
-                $( window ).on( 'resize', position_widget );
-                theme_controls_container.on( 'expanded collapsed', position_widget );
-            } );
-            control.container.on( 'collapsed', function () {
-                customize_sidebar.off( 'scroll', position_widget );
-                $( window ).off( 'resize', position_widget );
-                theme_controls_container.off( 'expanded collapsed', position_widget );
-            } );
-
-            // Reposition whenever a sidebar's widgets are changed
-            wp.customize.each( function ( setting ) {
-                if ( 0 === setting.id.indexOf( 'sidebars_widgets[' ) ) {
-                    setting.bind( function () {
-                        if ( control.container.hasClass( 'expanded' ) ) {
-                            position_widget();
-                        }
-                    } );
-                }
-            } );
-        },
-
-        /**
-         * Show/hide the control when clicking on the form title, when clicking
-         * the close button
-         */
-        _setupControlToggle: function() {
-            var control = this, close_btn;
-
-            control.container.find( '.widget-top' ).on( 'click', function ( e ) {
-                e.preventDefault();
-                var sidebar_widgets_control = control.getSidebarWidgetsControl();
-                if ( sidebar_widgets_control.is_reordering ) {
-                    return;
-                }
-                control.toggleForm();
-            } );
-
-            close_btn = control.container.find( '.widget-control-close' );
-            // @todo Hitting Enter on this link does nothing; will be resolved in core with <http://core.trac.wordpress.org/ticket/26633>
-            close_btn.on( 'click', function ( e ) {
-                e.preventDefault();
-                control.collapseForm();
-                control.container.find( '.widget-top .widget-action:first' ).focus(); // keyboard accessibility
-            } );
-        },
-
-        /**
-         * Update the title of the form if a title field is entered
-         */
-        _setupWidgetTitle: function () {
-            var control = this, update_title;
-
-            update_title = function () {
-                var title = control.setting().title,
-                    in_widget_title = control.container.find( '.in-widget-title' );
-
-                if ( title ) {
-                    in_widget_title.text( ': ' + title );
-                } else {
-                    in_widget_title.text( '' );
-                }
-            };
-            control.setting.bind( update_title );
-            update_title();
-        },
-
-        /**
-         * Set up the widget-reorder-nav
-         */
-        _setupReorderUI: function () {
-            var control = this,
-                select_sidebar_item,
-                move_widget_area,
-                reorder_nav,
-                update_available_sidebars;
-
-            /**
-             * select the provided sidebar list item in the move widget area
-             *
-             * @param {jQuery} li
-             */
-            select_sidebar_item = function ( li ) {
-                li.siblings( '.selected' ).removeClass( 'selected' );
-                li.addClass( 'selected' );
-                var is_self_sidebar = ( li.data( 'id' ) === control.params.sidebar_id );
-                control.container.find( '.move-widget-btn' ).prop( 'disabled', is_self_sidebar );
-            };
-
-            /**
-             * Add the widget reordering elements to the widget control
-             */
-            control.container.find( '.widget-title-action' ).after( $( self.tpl.widget_reorder_nav ) );
-            move_widget_area = $(
-                _.template( self.tpl.move_widget_area, {
-                    sidebars: _( self.registered_sidebars.toArray() ).pluck( 'attributes' )
-                } )
-            );
-            control.container.find( '.widget-top' ).after( move_widget_area );
-
-            /**
-             * Update available sidebars when their rendered state changes
-             */
-            update_available_sidebars = function () {
-                var sidebar_items = move_widget_area.find( 'li' ), self_sidebar_item;
-                self_sidebar_item = sidebar_items.filter( function(){
-                    return $( this ).data( 'id' ) === control.params.sidebar_id;
-                } );
-                sidebar_items.each( function () {
-                    var li = $( this ),
-                        sidebar_id,
-                        sidebar_model;
-
-                    sidebar_id = li.data( 'id' );
-                    sidebar_model = self.registered_sidebars.get( sidebar_id );
-                    li.toggle( sidebar_model.get( 'is_rendered' ) );
-                    if ( li.hasClass( 'selected' ) && ! sidebar_model.get( 'is_rendered' ) ) {
-                        select_sidebar_item( self_sidebar_item );
-                    }
-                } );
-            };
-            update_available_sidebars();
-            self.registered_sidebars.on( 'change:is_rendered', update_available_sidebars );
-
-            /**
-             * Handle clicks for up/down/move on the reorder nav
-             */
-            reorder_nav = control.container.find( '.widget-reorder-nav' );
-            reorder_nav.find( '.move-widget, .move-widget-down, .move-widget-up' ).on( 'click keypress', function ( event ) {
-                if ( event.type === 'keypress' && ( event.which !== 13 && event.which !== 32 ) ) {
-                    return;
-                }
-                $( this ).focus();
-
-                if ( $( this ).is( '.move-widget' ) ) {
-                    control.toggleWidgetMoveArea();
-                } else {
-                    var is_move_down = $( this ).is( '.move-widget-down' ),
-                        is_move_up = $( this ).is( '.move-widget-up' ),
-                        i = control.getWidgetSidebarPosition();
-
-                    if ( ( is_move_up && i === 0 ) || ( is_move_down && i === control.getSidebarWidgetsControl().setting().length - 1 ) ) {
-                        return;
-                    }
-
-                    if ( is_move_up ) {
-                        control.moveUp();
-                    } else {
-                        control.moveDown();
-                    }
-
-                    $( this ).focus(); // re-focus after the container was moved
-                }
-            } );
-
-            /**
-             * Handle selecting a sidebar to move to
-             */
-            control.container.find( '.widget-area-select' ).on( 'click keypress', 'li', function ( e ) {
-                if ( event.type === 'keypress' && ( event.which !== 13 && event.which !== 32 ) ) {
-                    return;
-                }
-                e.preventDefault();
-                select_sidebar_item( $( this ) );
-            } );
-
-            /**
-             * Move widget to another sidebar
-             */
-            control.container.find( '.move-widget-btn' ).click( function () {
-                control.getSidebarWidgetsControl().toggleReordering( false );
-
-                var old_sidebar_id = control.params.sidebar_id,
-                    new_sidebar_id = control.container.find( '.widget-area-select li.selected' ).data( 'id' ),
-                    old_sidebar_widgets_setting,
-                    new_sidebar_widgets_setting,
-                    old_sidebar_widget_ids,
-                    new_sidebar_widget_ids,
-                    i;
-
-                old_sidebar_widgets_setting = customize( 'sidebars_widgets[' + old_sidebar_id + ']' );
-                new_sidebar_widgets_setting = customize( 'sidebars_widgets[' + new_sidebar_id + ']' );
-                old_sidebar_widget_ids = Array.prototype.slice.call( old_sidebar_widgets_setting() );
-                new_sidebar_widget_ids = Array.prototype.slice.call( new_sidebar_widgets_setting() );
-
-                i = control.getWidgetSidebarPosition();
-                old_sidebar_widget_ids.splice( i, 1 );
-                new_sidebar_widget_ids.push( control.params.widget_id );
-
-                old_sidebar_widgets_setting( old_sidebar_widget_ids );
-                new_sidebar_widgets_setting( new_sidebar_widget_ids );
-
-                control.focus();
-            } );
-        },
-
-        /**
-         * Highlight widgets in preview when interacted with in the customizer
-         */
-        _setupHighlightEffects: function() {
-            var control = this;
-
-            // Highlight whenever hovering or clicking over the form
-            control.container.on( 'mouseenter click', function () {
-                control.setting.previewer.send( 'highlight-widget', control.params.widget_id );
-            } );
-
-            // Highlight when the setting is updated
-            control.setting.bind( function () {
-                control.setting.previewer.send( 'highlight-widget', control.params.widget_id );
-            } );
-
-            // Highlight when the widget form is expanded
-            control.container.on( 'expand', function () {
-                control.scrollPreviewWidgetIntoView();
-            } );
-        },
-
-        /**
-         * Set up event handlers for widget updating
-         */
-        _setupUpdateUI: function () {
-            var control = this,
-                widget_root,
-                widget_content,
-                save_btn,
-                update_widget_debounced,
-                form_update_event_handler;
-
-            widget_root = control.container.find( '.widget:first' );
-            widget_content = widget_root.find( '.widget-content:first' );
-
-            // Configure update button
-            save_btn = control.container.find( '.widget-control-save' );
-            save_btn.val( self.i18n.save_btn_label );
-            save_btn.attr( 'title', self.i18n.save_btn_tooltip );
-            save_btn.removeClass( 'button-primary' ).addClass( 'button-secondary' );
-            save_btn.on( 'click', function ( e ) {
-                e.preventDefault();
-                control.updateWidget( { disable_form: true } );
-            } );
-
-            update_widget_debounced = _.debounce( function () {
-                // @todo For compatibility with other plugins, should we trigger a click event? What about form submit event?
-                control.updateWidget();
-            }, 250 );
-
-            // Trigger widget form update when hitting Enter within an input
-            control.container.find( '.widget-content' ).on( 'keydown', 'input', function( e ) {
-                if ( 13 === e.which ) { // Enter
-                    e.preventDefault();
-                    control.updateWidget( { ignore_active_element: true } );
-                }
-            } );
-
-            // Handle widgets that support live previews
-            widget_content.on( 'change input propertychange', ':input', function ( e ) {
-                if ( control.live_update_mode ) {
-                    if ( e.type === 'change' ) {
-                        control.updateWidget();
-                    } else if ( this.checkValidity && this.checkValidity() ) {
-                        update_widget_debounced();
-                    }
-                }
-            } );
-
-            // Remove loading indicators when the setting is saved and the preview updates
-            control.setting.previewer.channel.bind( 'synced', function () {
-                control.container.removeClass( 'previewer-loading' );
-            } );
-            self.previewer.bind( 'widget-updated', function ( updated_widget_id ) {
-                if ( updated_widget_id === control.params.widget_id ) {
-                    control.container.removeClass( 'previewer-loading' );
-                }
-            } );
-
-            // Update widget control to indicate whether it is currently rendered (cf. Widget Visibility)
-            self.previewer.bind( 'rendered-widgets', function ( rendered_widgets ) {
-                var is_rendered = !! rendered_widgets[control.params.widget_id];
-                control.container.toggleClass( 'widget-rendered', is_rendered );
-            } );
-
-            form_update_event_handler = builtin_form_sync_handlers[ control.params.widget_id_base ];
-            if ( form_update_event_handler ) {
-                $( document ).on( 'widget-synced', function ( e, widget_el ) {
-                    if ( widget_root.is( widget_el ) ) {
-                        form_update_event_handler.apply( document, arguments );
-                    }
-                } );
-            }
-        },
-
-        /**
-         * Set up event handlers for widget removal
-         */
-        _setupRemoveUI: function () {
-            var control = this,
-                remove_btn,
-                replace_delete_with_remove;
-
-            // Configure remove button
-            remove_btn = control.container.find( 'a.widget-control-remove' );
-            // @todo Hitting Enter on this link does nothing; will be resolved in core with <http://core.trac.wordpress.org/ticket/26633>
-            remove_btn.on( 'click', function ( e ) {
-                e.preventDefault();
-
-                // Find an adjacent element to add focus to when this widget goes away
-                var adjacent_focus_target;
-                if ( control.container.next().is( '.customize-control-widget_form' ) ) {
-                    adjacent_focus_target = control.container.next().find( '.widget-action:first' );
-                } else if ( control.container.prev().is( '.customize-control-widget_form' ) ) {
-                    adjacent_focus_target = control.container.prev().find( '.widget-action:first' );
-                } else {
-                    adjacent_focus_target = control.container.next( '.customize-control-sidebar_widgets' ).find( '.add-new-widget:first' );
-                }
-
-                control.container.slideUp( function() {
-                    var sidebars_widgets_control = self.getSidebarWidgetControlContainingWidget( control.params.widget_id ),
-                        sidebar_widget_ids,
-                        i;
-
-                    if ( ! sidebars_widgets_control ) {
-                        throw new Error( 'Unable to find sidebars_widgets_control' );
-                    }
-                    sidebar_widget_ids = sidebars_widgets_control.setting().slice();
-                    i = _.indexOf( sidebar_widget_ids, control.params.widget_id );
-                    if ( -1 === i ) {
-                        throw new Error( 'Widget is not in sidebar' );
-                    }
-                    sidebar_widget_ids.splice( i, 1 );
-                    sidebars_widgets_control.setting( sidebar_widget_ids );
-                    adjacent_focus_target.focus(); // keyboard accessibility
-                } );
-            } );
-
-            replace_delete_with_remove = function () {
-                remove_btn.text( self.i18n.remove_btn_label ); // wp_widget_control() outputs the link as "Delete"
-                remove_btn.attr( 'title', self.i18n.remove_btn_tooltip );
-            };
-            if ( control.params.is_new ) {
-                wp.customize.bind( 'saved', replace_delete_with_remove );
-            } else {
-                replace_delete_with_remove();
-            }
-        },
-
-        /**
-         * Find all inputs in a widget container that should be considered when
-         * comparing the loaded form with the sanitized form, whose fields will
-         * be aligned to copy the sanitized over. The elements returned by this
-         * are passed into this._getInputsSignature(), and they are iterated
-         * over when copying sanitized values over to the the form loaded.
-         *
-         * @param {jQuery} container element in which to look for inputs
-         * @returns {jQuery} inputs
-         * @private
-         */
-        _getInputs: function ( container ) {
-            return $( container ).find( ':input[name]' );
-        },
-
-        /**
-         * Iterate over supplied inputs and create a signature string for all of them together.
-         * This string can be used to compare whether or not the form has all of the same fields.
-         *
-         * @param {jQuery} inputs
-         * @returns {string}
-         * @private
-         */
-        _getInputsSignature: function ( inputs ) {
-            var inputs_signatures = _( inputs ).map( function ( input ) {
-                input = $( input );
-                var signature_parts;
-                if ( input.is( ':checkbox, :radio' ) ) {
-                    signature_parts = [ input.attr( 'id' ), input.attr( 'name' ), input.prop( 'value' ) ];
-                } else {
-                    signature_parts = [ input.attr( 'id' ), input.attr( 'name' ) ];
-                }
-                return signature_parts.join( ',' );
-            } );
-            return inputs_signatures.join( ';' );
-        },
-
-        /**
-         * Get the property that represents the state of an input.
-         *
-         * @param {jQuery|DOMElement} input
-         * @returns {string}
-         * @private
-         */
-        _getInputStatePropertyName: function ( input ) {
-            input = $( input );
-            if ( input.is( ':radio, :checkbox' ) ) {
-                return 'checked';
-            } else {
-                return 'value';
-            }
-        },
-
-        /***********************************************************************
-         * Begin public API methods
-         **********************************************************************/
-
-        /**
-         * @return {wp.customize.controlConstructor.sidebar_widgets[]}
-         */
-        getSidebarWidgetsControl: function () {
-            var control = this, setting_id, sidebar_widgets_control;
-
-            setting_id = 'sidebars_widgets[' + control.params.sidebar_id + ']';
-            sidebar_widgets_control = customize.control( setting_id );
-            if ( ! sidebar_widgets_control ) {
-                throw new Error( 'Unable to locate sidebar_widgets control for ' + control.params.sidebar_id );
-            }
-            return sidebar_widgets_control;
-        },
-
-        /**
-         * Submit the widget form via Ajax and get back the updated instance,
-         * along with the new widget control form to render.
-         *
-         * @param {object} [args]
-         * @param {Object|null} [args.instance=null]  When the model changes, the instance is sent here; otherwise, the inputs from the form are used
-         * @param {Function|null} [args.complete=null]  Function which is called when the request finishes. Context is bound to the control. First argument is any error. Following arguments are for success.
-         * @param {Boolean} [args.ignore_active_element=false] Whether or not updating a field will be deferred if focus is still on the element.
-         */
-        updateWidget: function ( args ) {
-            var control = this,
-                instance_override,
-                complete_callback,
-                widget_root,
-                update_number,
-                widget_content,
-                params,
-                data,
-                inputs,
-                processing,
-                jqxhr,
-                is_changed;
-
-            args = $.extend( {
-                instance: null,
-                complete: null,
-                ignore_active_element: false
-            }, args );
-
-            instance_override = args.instance;
-            complete_callback = args.complete;
-
-            control._update_count += 1;
-            update_number = control._update_count;
-
-            widget_root = control.container.find( '.widget:first' );
-            widget_content = widget_root.find( '.widget-content:first' );
-
-            // Remove a previous error message
-            widget_content.find( '.widget-error' ).remove();
-
-            control.container.addClass( 'widget-form-loading' );
-            control.container.addClass( 'previewer-loading' );
-            processing = wp.customize.state( 'processing' );
-            processing( processing() + 1 );
-
-            if ( ! control.live_update_mode ) {
-                control.container.addClass( 'widget-form-disabled' );
-            }
-
-            params = {};
-            params.action = 'update-widget';
-            params.wp_customize = 'on';
-            params.nonce = self.nonce;
-
-            data = $.param( params );
-            inputs = control._getInputs( widget_content );
-
-            // Store the value we're submitting in data so that when the response comes back,
-            // we know if it got sanitized; if there is no difference in the sanitized value,
-            // then we do not need to touch the UI and mess up the user's ongoing editing.
-            inputs.each( function () {
-                var input = $( this ),
-                    property = control._getInputStatePropertyName( this );
-                input.data( 'state' + update_number, input.prop( property ) );
-            } );
-
-            if ( instance_override ) {
-                data += '&' + $.param( { 'sanitized_widget_setting': JSON.stringify( instance_override ) } );
-            } else {
-                data += '&' + inputs.serialize();
-            }
-            data += '&' + widget_content.find( '~ :input' ).serialize();
-
-            jqxhr = $.post( wp.ajax.settings.url, data, function ( r ) {
-                var message,
-                    sanitized_form,
-                    sanitized_inputs,
-                    has_same_inputs_in_response,
-                    is_live_update_aborted = false;
-
-                // Check if the user is logged out.
-                if ( '0' === r ) {
-                    self.previewer.preview.iframe.hide();
-                    self.previewer.login().done( function() {
-                        control.updateWidget( args );
-                        self.previewer.preview.iframe.show();
-                    } );
-                    return;
-                }
-
-                // Check for cheaters.
-                if ( '-1' === r ) {
-                    self.previewer.cheatin();
-                    return;
-                }
-
-                if ( r.success ) {
-                    sanitized_form = $( '<div>' + r.data.form + '</div>' );
-                    sanitized_inputs = control._getInputs( sanitized_form );
-                    has_same_inputs_in_response = control._getInputsSignature( inputs ) === control._getInputsSignature( sanitized_inputs );
-
-                    // Restore live update mode if sanitized fields are now aligned with the existing fields
-                    if ( has_same_inputs_in_response && ! control.live_update_mode ) {
-                        control.live_update_mode = true;
-                        control.container.removeClass( 'widget-form-disabled' );
-                        control.container.find( 'input[name="savewidget"]' ).hide();
-                    }
-
-                    // Sync sanitized field states to existing fields if they are aligned
-                    if ( has_same_inputs_in_response && control.live_update_mode ) {
-                        inputs.each( function ( i ) {
-                            var input = $( this ),
-                                sanitized_input = $( sanitized_inputs[i] ),
-                                property = control._getInputStatePropertyName( this ),
-                                submitted_state,
-                                sanitized_state,
-                                can_update_state;
-
-                            submitted_state = input.data( 'state' + update_number );
-                            sanitized_state = sanitized_input.prop( property );
-                            input.data( 'sanitized', sanitized_state );
-
-                            can_update_state = (
-                                submitted_state !== sanitized_state &&
-                                ( args.ignore_active_element || ! input.is( document.activeElement ) )
-                            );
-                            if ( can_update_state ) {
-                                input.prop( property, sanitized_state );
-                            }
-                        } );
-                        $( document ).trigger( 'widget-synced', [ widget_root, r.data.form ] );
-
-                    // Otherwise, if sanitized fields are not aligned with existing fields, disable live update mode if enabled
-                    } else if ( control.live_update_mode ) {
-                        control.live_update_mode = false;
-                        control.container.find( 'input[name="savewidget"]' ).show();
-                        is_live_update_aborted = true;
-                    // Otherwise, replace existing form with the sanitized form
-                    } else {
-                        widget_content.html( r.data.form );
-                        control.container.removeClass( 'widget-form-disabled' );
-                        $( document ).trigger( 'widget-updated', [ widget_root ] );
-                    }
-
-                    /**
-                     * If the old instance is identical to the new one, there is nothing new
-                     * needing to be rendered, and so we can preempt the event for the
-                     * preview finishing loading.
-                     */
-                    is_changed = ! is_live_update_aborted && ! _( control.setting() ).isEqual( r.data.instance );
-                    if ( is_changed ) {
-                        control.is_widget_updating = true; // suppress triggering another updateWidget
-                        control.setting( r.data.instance );
-                        control.is_widget_updating = false;
-                    } else {
-                        // no change was made, so stop the spinner now instead of when the preview would updates
-                        control.container.removeClass( 'previewer-loading' );
-                    }
-
-                    if ( complete_callback ) {
-                        complete_callback.call( control, null, { no_change: ! is_changed, ajax_finished: true } );
-                    }
-                } else {
-                    message = self.i18n.error;
-                    if ( r.data && r.data.message ) {
-                        message = r.data.message;
-                    }
-                    if ( complete_callback ) {
-                        complete_callback.call( control, message );
-                    } else {
-                        widget_content.prepend( '<p class="widget-error"><strong>' + message + '</strong></p>' );
-                    }
-                }
-            } );
-            jqxhr.fail( function ( jqXHR, textStatus ) {
-                if ( complete_callback ) {
-                    complete_callback.call( control, textStatus );
-                }
-            } );
-            jqxhr.always( function () {
-                control.container.removeClass( 'widget-form-loading' );
-                inputs.each( function () {
-                    $( this ).removeData( 'state' + update_number );
-                } );
-
-                processing( processing() - 1 );
-            } );
-        },
-
-        /**
-         * Expand the accordion section containing a control
-         * @todo it would be nice if accordion had a proper API instead of having to trigger UI events on its elements
-         */
-        expandControlSection: function () {
-            var section = this.container.closest( '.accordion-section' );
-            if ( ! section.hasClass( 'open' ) ) {
-                section.find( '.accordion-section-title:first' ).trigger( 'click' );
-            }
-        },
-
-        /**
-         * Expand the widget form control
-         */
-        expandForm: function () {
-            this.toggleForm( true );
-        },
-
-        /**
-         * Collapse the widget form control
-         */
-        collapseForm: function () {
-            this.toggleForm( false );
-        },
-
-        /**
-         * Expand or collapse the widget control
-         *
-         * @param {boolean|undefined} [do_expand] If not supplied, will be inverse of current visibility
-         */
-        toggleForm: function ( do_expand ) {
-            var control = this, widget, inside, complete;
-
-            widget = control.container.find( 'div.widget:first' );
-            inside = widget.find( '.widget-inside:first' );
-            if ( typeof do_expand === 'undefined' ) {
-                do_expand = ! inside.is( ':visible' );
-            }
-
-            // Already expanded or collapsed, so noop
-            if ( inside.is( ':visible' ) === do_expand ) {
-                return;
-            }
-
-            if ( do_expand ) {
-                // Close all other widget controls before expanding this one
-                wp.customize.control.each( function ( other_control ) {
-                    if ( control.params.type === other_control.params.type && control !== other_control ) {
-                        other_control.collapseForm();
-                    }
-                } );
-
-                complete = function () {
-                    control.container.removeClass( 'expanding' );
-                    control.container.addClass( 'expanded' );
-                    control.container.trigger( 'expanded' );
-                };
-                if ( control.params.is_wide ) {
-                    inside.fadeIn( 'fast', complete );
-                } else {
-                    inside.slideDown( 'fast', complete );
-                }
-                control.container.trigger( 'expand' );
-                control.container.addClass( 'expanding' );
-            } else {
-                control.container.trigger( 'collapse' );
-                control.container.addClass( 'collapsing' );
-                complete = function () {
-                    control.container.removeClass( 'collapsing' );
-                    control.container.removeClass( 'expanded' );
-                    control.container.trigger( 'collapsed' );
-                };
-                if ( control.params.is_wide ) {
-                    inside.fadeOut( 'fast', complete );
-                } else {
-                    inside.slideUp( 'fast', function() {
-                        widget.css( { width:'', margin:'' } );
-                        complete();
-                    } );
-                }
-            }
-        },
-
-        /**
-         * Expand the containing sidebar section, expand the form, and focus on
-         * the first input in the control
-         */
-        focus: function () {
-            var control = this;
-            control.expandControlSection();
-            control.expandForm();
-            control.container.find( '.widget-content :focusable:first' ).focus();
-        },
-
-        /**
-         * Get the position (index) of the widget in the containing sidebar
-         *
-         * @throws Error
-         * @returns {Number}
-         */
-        getWidgetSidebarPosition: function () {
-            var control = this,
-                sidebar_widget_ids,
-                position;
-
-            sidebar_widget_ids = control.getSidebarWidgetsControl().setting();
-            position = _.indexOf( sidebar_widget_ids, control.params.widget_id );
-            if ( position === -1 ) {
-                throw new Error( 'Widget was unexpectedly not present in the sidebar.' );
-            }
-            return position;
-        },
-
-        /**
-         * Move widget up one in the sidebar
-         */
-        moveUp: function () {
-            this._moveWidgetByOne( -1 );
-        },
-
-        /**
-         * Move widget up one in the sidebar
-         */
-        moveDown: function () {
-            this._moveWidgetByOne( 1 );
-        },
-
-        /**
-         * @private
-         *
-         * @param {Number} offset 1|-1
-         */
-        _moveWidgetByOne: function ( offset ) {
-            var control = this,
-                i,
-                sidebar_widgets_setting,
-                sidebar_widget_ids,
-                adjacent_widget_id;
-
-            i = control.getWidgetSidebarPosition();
-
-            sidebar_widgets_setting = control.getSidebarWidgetsControl().setting;
-            sidebar_widget_ids = Array.prototype.slice.call( sidebar_widgets_setting() ); // clone
-            adjacent_widget_id = sidebar_widget_ids[i + offset];
-            sidebar_widget_ids[i + offset] = control.params.widget_id;
-            sidebar_widget_ids[i] = adjacent_widget_id;
-
-            sidebar_widgets_setting( sidebar_widget_ids );
-        },
-
-        /**
-         * Toggle visibility of the widget move area
-         *
-         * @param {Boolean} [toggle]
-         */
-        toggleWidgetMoveArea: function ( toggle ) {
-            var control = this, move_widget_area;
-            move_widget_area = control.container.find( '.move-widget-area' );
-            if ( typeof toggle === 'undefined' ) {
-                toggle = ! move_widget_area.hasClass( 'active' );
-            }
-            if ( toggle ) {
-                // reset the selected sidebar
-                move_widget_area.find( '.selected' ).removeClass( 'selected' );
-                move_widget_area.find( 'li' ).filter( function () {
-                    return $( this ).data( 'id' ) === control.params.sidebar_id;
-                } ).addClass( 'selected' );
-                control.container.find( '.move-widget-btn' ).prop( 'disabled', true );
-            }
-            move_widget_area.toggleClass( 'active', toggle );
-        },
-
-        /**
-         * Inside of the customizer preview, scroll the widget into view
-         */
-        scrollPreviewWidgetIntoView: function () {
-            // @todo scrollIntoView() provides a robust but very poor experience. Animation is needed. See https://github.com/x-team/wp-widget-customizer/issues/16
-        },
-
-        /**
-         * Highlight the widget control and section
-         */
-        highlightSectionAndControl: function() {
-            var control = this, target_element;
-
-            if ( control.container.is( ':hidden' ) ) {
-                target_element = control.container.closest( '.control-section' );
-            } else {
-                target_element = control.container;
-            }
-
-            $( '.widget-customizer-highlighted' ).removeClass( 'widget-customizer-highlighted' );
-            target_element.addClass( 'widget-customizer-highlighted' );
-            setTimeout( function () {
-                target_element.removeClass( 'widget-customizer-highlighted' );
-            }, 500 );
-        }
-
+    $.extend( api.controlConstructor, {
+        widget_form: api.Widgets.WidgetControl,
+        sidebar_widgets: api.Widgets.SidebarControl
+    });
+
+    api.bind( 'ready', function() {
+        // Set up the widgets panel
+        api.Widgets.availableWidgetsPanel.setup();
+
+        // Highlight widget control
+        api.Widgets.Previewer.bind( 'highlight-widget-control', api.Widgets.highlightWidgetFormControl );
+
+        // Open and focus widget control
+        api.Widgets.Previewer.bind( 'focus-widget-control', api.Widgets.focusWidgetFormControl );
     } );
 
@@ -1524 +1501 @@
      * Capture the instance of the Previewer since it is private
      */
-    OldPreviewer = wp.customize.Previewer;
-    wp.customize.Previewer = OldPreviewer.extend( {
+    OldPreviewer = api.Previewer;
+    api.Previewer = OldPreviewer.extend({
         initialize: function( params, options ) {
-            self.previewer = this;
+            api.Widgets.Previewer = this;
             OldPreviewer.prototype.initialize.call( this, params, options );
             this.bind( 'refresh', this.refresh );
@@ -1538 +1515 @@
      * @param {string} widgetId
      */
-    self.highlightWidgetFormControl = function( widgetId ) {
-        var control = self.getWidgetFormControlForWidget( widgetId );
+    api.Widgets.highlightWidgetFormControl = function( widgetId ) {
+        var control = api.Widgets.getWidgetFormControlForWidget( widgetId );
 
         if ( control ) {
@@ -1551 +1528 @@
      * @param {string} widgetId
      */
-    self.focusWidgetFormControl = function( widgetId ) {
-        var control = self.getWidgetFormControlForWidget( widgetId );
+    api.Widgets.focusWidgetFormControl = function( widgetId ) {
+        var control = api.Widgets.getWidgetFormControlForWidget( widgetId );
 
         if ( control ) {
@@ -1564 +1541 @@
      * @return {object|null}
      */
-    self.getSidebarWidgetControlContainingWidget = function ( widget_id ) {
+    api.Widgets.getSidebarWidgetControlContainingWidget = function ( widget_id ) {
         var found_control = null;
         // @todo this can use widget_id_to_setting_id(), then pass into wp.customize.control( x ).getSidebarWidgetsControl()
-        wp.customize.control.each( function ( control ) {
+        api.control.each( function ( control ) {
             if ( control.params.type === 'sidebar_widgets' && -1 !== _.indexOf( control.setting(), widget_id ) ) {
                 found_control = control;
             }
         } );
+
         return found_control;
     };
@@ -1580 +1558 @@
      * @return {object|null}
      */
-    self.getWidgetFormControlForWidget = function ( widget_id ) {
+    api.Widgets.getWidgetFormControlForWidget = function ( widget_id ) {
         var found_control = null;
         // @todo We can just use widget_id_to_setting_id() here
-        wp.customize.control.each( function ( control ) {
+        api.control.each( function ( control ) {
             if ( control.params.type === 'widget_form' && control.params.widget_id === widget_id ) {
                 found_control = control;
             }
         } );
+
         return found_control;
-    };
-
-    /**
-     * @returns {Window}
-     */
-    self.getPreviewWindow = function (){
-        return $( '#customize-preview' ).find( 'iframe' ).prop( 'contentWindow' );
     };
 
@@ -1601 +1573 @@
      * Available Widgets Panel
      */
-    self.availableWidgetsPanel = {
+    api.Widgets.availableWidgetsPanel = {
         active_sidebar_widgets_control: null,
         selected_widget_tpl: null,
@@ -1610 +1582 @@
          * Set up event listeners
          */
-        setup: function () {
+        setup: function() {
             var panel = this;
 
@@ -1616 +1588 @@
             panel.filter_input = $( '#available-widgets-filter' ).find( 'input' );
 
-            self.available_widgets.on( 'change update', panel.update_available_widgets_list );
+            api.Widgets.availableWidgets.on( 'change update', panel.update_available_widgets_list );
             panel.update_available_widgets_list();
 
@@ -1630 +1602 @@
 
             // Close the panel if the URL in the preview changes
-            self.previewer.bind( 'url', function () {
+            api.Widgets.Previewer.bind( 'url', function() {
                 panel.close();
             } );
@@ -1648 +1620 @@
                 var first_visible_widget;
 
-                self.available_widgets.doSearch( event.target.value );
+                api.Widgets.availableWidgets.doSearch( event.target.value );
 
                 // Remove a widget from being selected if it is no longer visible
@@ -1672 +1644 @@
 
             // Select a widget when it is focused on
-            panel.container.find( ' > .widget-tpl' ).on( 'focus', function () {
+            panel.container.find( ' > .widget-tpl' ).on( 'focus', function() {
                 panel.select( this );
             } );
@@ -1726 +1698 @@
          */
         update_available_widgets_list: function() {
-            var panel = self.availableWidgetsPanel;
+            var panel = api.Widgets.availableWidgetsPanel;
 
             // First hide all widgets...
@@ -1732 +1704 @@
 
             // ..and then show only available widgets which could be filtered
-            self.available_widgets.each( function ( widget ) {
+            api.Widgets.availableWidgets.each( function ( widget ) {
                 var widget_tpl = $( '#widget-tpl-' + widget.id );
                 widget_tpl.toggle( ! widget.get( 'is_disabled' ) );
@@ -1762 +1734 @@
 
             widget_id = $( panel.selected_widget_tpl ).data( 'widget-id' );
-            widget = self.available_widgets.findWhere( {id: widget_id} );
+            widget = api.Widgets.availableWidgets.findWhere( {id: widget_id} );
             if ( ! widget ) {
                 throw new Error( 'Widget unexpectedly not found.' );
@@ -1786 +1758 @@
             $( 'body' ).addClass( 'adding-widget' );
             panel.container.find( '.widget-tpl' ).removeClass( 'selected' );
-            self.available_widgets.doSearch( '' );
+            api.Widgets.availableWidgets.doSearch( '' );
             panel.filter_input.focus();
         },
@@ -1840 +1812 @@
     }
 
-    return self;
-}( jQuery ));
+})( window.wp, jQuery );

trunk/src/wp-includes/class-wp-customize-control.php

@@ -918 +918 @@
         ?>
         <span class="button-secondary add-new-widget" tabindex="0">
-            <?php esc_html_e( 'Add a Widget' ); ?>
+            <?php _e( 'Add a Widget' ); ?>
         </span>
 
         <span class="reorder-toggle" tabindex="0">
-            <span class="reorder"><?php esc_html_e( 'Reorder' ); ?></span>
-            <span class="reorder-done"><?php esc_html_e( 'Done' ); ?></span>
+            <span class="reorder"><?php _ex( 'Reorder', 'Reorder widgets in Customizer' ); ?></span>
+            <span class="reorder-done"><?php _ex( 'Done', 'Cancel reordering widgets in Customizer'  ); ?></span>
         </span>
         <?php
@@ -941 +941 @@
     public $height;
     public $is_wide = false;
-    public $is_live_previewable = false;
 
     public function to_json() {
         parent::to_json();
-        $exported_properties = array( 'widget_id', 'widget_id_base', 'sidebar_id', 'width', 'height', 'is_wide', 'is_live_previewable' );
+        $exported_properties = array( 'widget_id', 'widget_id_base', 'sidebar_id', 'width', 'height', 'is_wide' );
         foreach ( $exported_properties as $key ) {
             $this->json[ $key ] = $this->$key;

trunk/src/wp-includes/class-wp-customize-widgets.php

@@ -407 +407 @@
                 $id_base           = $GLOBALS['wp_registered_widget_controls'][$widget_id]['id_base'];
 
-                assert( false !== is_active_widget( $registered_widget['callback'], $registered_widget['id'], false, false ) );
-
                 $control = new WP_Widget_Form_Customize_Control( $this->manager, $setting_id, array(
                     'label'          => $registered_widget['name'],
@@ -600 +598 @@
             array( '{description}', '{btn}' ),
             array(
-                ( 'Select an area to move this widget into:' ), // @todo translate
-                esc_html_x( 'Move', 'move widget' ),
+                __( 'Select an area to move this widget into:' ),
+                _x( 'Move', 'Move widget' ),
             ),
             '<div class="move-widget-area">
@@ -616 +614 @@
         );
 
-        /*
-         * Why not wp_localize_script? Because we're not localizing,
-         * and it forces values into strings.
-         */
         global $wp_scripts;
 
-        $exports = array(
-            'nonce'               => wp_create_nonce( 'update-widget' ),
-            'registered_sidebars' => array_values( $GLOBALS['wp_registered_sidebars'] ),
-            'registered_widgets'  => $GLOBALS['wp_registered_widgets'],
-            'available_widgets'   => $available_widgets, // @todo Merge this with registered_widgets
-            'i18n' => array(
-                'save_btn_label'     => __( 'Apply' ),
-                // @todo translate? do we want these tooltips?
-                'save_btn_tooltip'   => ( 'Save and preview changes before publishing them.' ),
-                'remove_btn_label'   => __( 'Remove' ),
-                'remove_btn_tooltip' => ( 'Trash widget by moving it to the inactive widgets sidebar.' ),
-                'error'              => __( 'An error has occurred. Please reload the page and try again.' ),
+        $settings = array(
+            'nonce'                => wp_create_nonce( 'update-widget' ),
+            'registeredSidebars'   => array_values( $GLOBALS['wp_registered_sidebars'] ),
+            'registeredWidgets'    => $GLOBALS['wp_registered_widgets'],
+            'availableWidgets'     => $available_widgets, // @todo Merge this with registered_widgets
+            'l10n' => array(
+                'saveBtnLabel'     => __( 'Apply' ),
+                'saveBtnTooltip'   => __( 'Save and preview changes before publishing them.' ),
+                'removeBtnLabel'   => __( 'Remove' ),
+                'removeBtnTooltip' => __( 'Trash widget by moving it to the inactive widgets sidebar.' ),
+                'error'            => __( 'An error has occurred. Please reload the page and try again.' ),
             ),
-            'tpl'                 => array(
-                'widget_reorder_nav' => $widget_reorder_nav_tpl,
-                'move_widget_area'   => $move_widget_area_tpl,
+            'tpl' => array(
+                'widgetReorderNav' => $widget_reorder_nav_tpl,
+                'moveWidgetArea'   => $move_widget_area_tpl,
             ),
         );
 
-        foreach ( $exports['registered_widgets'] as &$registered_widget ) {
+        foreach ( $settings['registeredWidgets'] as &$registered_widget ) {
             unset( $registered_widget['callback'] ); // may not be JSON-serializeable
         }
@@ -648 +641 @@
             'customize-widgets',
             'data',
-            sprintf( 'var WidgetCustomizer_exports = %s;', json_encode( $exports ) )
+            sprintf( 'var _wpCustomizeWidgetsSettings = %s;', json_encode( $settings ) )
         );
     }
@@ -663 +656 @@
         <div id="available-widgets">
             <div id="available-widgets-filter">
-                <label class="screen-reader-text" for="widgets-search"><?php _e( 'Find Widgets' ); ?></label>
-                <input type="search" id="widgets-search" placeholder="<?php esc_attr_e( 'Find widgets&hellip;' ) ?>" />
+                <label class="screen-reader-text" for="widgets-search"><?php _e( 'Search Widgets' ); ?></label>
+                <input type="search" id="widgets-search" placeholder="<?php esc_attr_e( 'Search widgets&hellip;' ) ?>" />
             </div>
             <?php foreach ( $this->get_available_widgets() as $available_widget ): ?>
                 <div id="widget-tpl-<?php echo esc_attr( $available_widget['id'] ) ?>" data-widget-id="<?php echo esc_attr( $available_widget['id'] ) ?>" class="widget-tpl <?php echo esc_attr( $available_widget['id'] ) ?>" tabindex="0">
-                    <?php echo $available_widget['control_tpl']; // xss ok ?>
+                    <?php echo $available_widget['control_tpl']; ?>
                 </div>
             <?php endforeach; ?>
@@ -827 +820 @@
             $available_widgets[] = $available_widget;
         }
+
         return $available_widgets;
     }

trunk/src/wp-includes/js/customize-preview-widgets.js

@@ -1 @@
-(function( $, wp ){
+(function( wp, $ ){
 
     if ( ! wp || ! wp.customize ) { return; }
@@ -125 +125 @@
     });
 
-})( jQuery, window.wp );
+})( window.wp, jQuery );