WordPress.org
Get WordPress

Make WordPress Core

Changeset 23813


Ignore:
Timestamp:
03/27/2013 12:59:41 PM (13 years ago)
Author:
markjaquith
Message:

*Very* rough runthough of revisions.js for JS style, variable names, etc.

Consider this the lawnmower that precedes Daryl's scissors.

see #23497

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/wp-admin/js/revisions.js

    r23769 r23813  
    44        wp.revisions = {
    55
    6                 views : {},
    7 
    8                 Model : Backbone.Model.extend({
    9                         idAttribute : 'ID',
    10                         urlRoot : ajaxurl +     '?action=revisions-data' +
     6                views: {},
     7
     8                Model: Backbone.Model.extend({
     9                        idAttribute: 'ID',
     10                        urlRoot: ajaxurl +      '?action=revisions-data' +
    1111                                '&show_autosaves=true&show_split_view=true&nonce=' + wpRevisionsSettings.nonce,
    1212                        defaults: {
    13                                 ID : 0,
    14                                 revision_date_author : '',
     13                                ID: 0,
     14                                revision_date_author: '',
    1515                                revision_date_author_short: '',
    16                                 revisiondiff : '<div class="diff-loading"><div class="spinner"></div></div>',
    17                                 restoreaction : '',
    18                                 revision_from_date_author : '',
    19                                 revision_toload : false,
    20                                 lines_added : 0,
    21                                 lines_deleted : 0,
    22                                 scope_of_changes : 'none',
    23                                 previous_revision_id : 0
    24                         },
    25 
    26                         url : function() {
    27                                 if ( 1 === REVAPP._compareoneortwo ) {
     16                                revisiondiff: '<div class="diff-loading"><div class="spinner"></div></div>',
     17                                restoreaction: '',
     18                                revision_from_date_author: '',
     19                                revision_toload: false,
     20                                lines_added: 0,
     21                                lines_deleted: 0,
     22                                scope_of_changes: 'none',
     23                                previous_revision_id: 0
     24                        },
     25
     26                        url: function() {
     27                                if ( 1 === REVAPP._compareOneOrTwo ) {
    2828                                        return this.urlRoot +
    2929                                                '&single_revision_id=' + this.id +
    … …  
    4141                app: _.extend({}, Backbone.Events),
    4242
    43                 App : Backbone.Router.extend({
    44                         _revisionDifflView : null,
    45                         _revisions : null,
    46                         _left_handle_revisions : null,
    47                         _right_handle_revisions : null,
    48                         _revisionsInteractions : null,
    49                         _revisionsOptions : null,
    50                         _left_diff : 1,
    51                         _right_diff : 1,
    52                         _autosaves : true,
    53                         _show_split_view : true,
    54                         _compareoneortwo : 1,
    55                         _left_model_loading : false,    //keep track of model loads
    56                         _right_model_loading : false,   //disallow slider interaction, also repeat loads, while loading
    57                         _tickmarkView : null, //the slider tickmarks
    58                         _has_tooltip : false,
    59 
    60                         routes : {
    61                         },
    62 
    63                         reload_toload_revisions : function( model_collection, reverse_direction ) {
    64                                 var self = this;
    65                                 var revisions_to_load = model_collection.where( { revision_toload : true } );
    66                                 var delay=0;
    67                                 //match slider to passed revision_id
    68                                 _.each( revisions_to_load, function( the_model ) {
    69                                         if ( the_model.get( 'ID' )  == wpRevisionsSettings.revision_id ) {
    70                                                 self._right_diff = self._revisions.indexOf( the_model ) + 1;
     43                App: Backbone.Router.extend({
     44                        _revisions: null,
     45                        _leftHandleRevisions: null,
     46                        _rightHandleRevisions: null,
     47                        _revisionsInteractions: null,
     48                        _revisionsOptions: null,
     49                        _leftDiff: 1,
     50                        _rightDiff: 1,
     51                        _autosaves: true,
     52                        _showSplitView: true,
     53                        _compareOneOrTwo: 1,
     54                        _leftModelLoading: false,       // keep track of model loads
     55                        _rightModelLoading: false,      // disallow slider interaction, also repeat loads, while loading
     56                        _tickmarkView: null, // the slider tickmarks
     57
     58                        routes: {
     59                        },
     60
     61                        reloadToLoadRevisions: function( model_collection, reverse_direction ) {
     62                                var self = this,
     63                                    revisionsToLoad = model_collection.where( { revision_toload: true } ),
     64                                    delay = 0;
     65                                // match slider to passed revision_id
     66                                _.each( revisionsToLoad, function( theModel ) {
     67                                        if ( theModel.get( 'ID' )  == wpRevisionsSettings.revision_id ) {
     68                                                self._rightDiff = self._revisions.indexOf( theModel ) + 1;
    7169                                        }
    7270
    7371                                });
    74                                 _.each( revisions_to_load, function( the_model ) {
    75                                                 the_model.urlRoot = model_collection.url;
     72                                _.each( revisionsToLoad, function( theModel ) {
     73                                                theModel.urlRoot = model_collection.url;
    7674                                                _.delay( function() {
    77                                                         the_model.fetch( {
    78                                                                 update : true,
    79                                                                 add : false,
    80                                                                 remove : false,
    81                                                                 success : function( model ) {
     75                                                        theModel.fetch( {
     76                                                                update: true,
     77                                                                add: false,
     78                                                                remove: false,
     79                                                                success: function( model ) {
    8280                                                                        model.set( 'revision_toload', 'false' );
    8381
    84                                                                         //stop spinner when all models are loaded
    85                                                                         if ( 0 === model_collection.where( { revision_toload : true } ).length )
    86                                                                                 self.stop_model_loading_spinner();
     82                                                                        // stop spinner when all models are loaded
     83                                                                        if ( 0 === model_collection.where( { revision_toload: true } ).length )
     84                                                                                self.stopModelLoadingSpinner();
    8785
    8886                                                                        self._tickmarkView.render();
    8987
    90                                                                         var total_changes = model.get( 'lines_added' ) + model.get( 'lines_deleted');
    91                                                                         var scope_of_changes = 'vsmall';
     88                                                                        var total_changes = model.get( 'lines_added' ) + model.get( 'lines_deleted'),
     89                                                                            scope_of_changes = 'vsmall';
    9290
    9391                                                                        // Note: hard coded scope of changes
    … …  
    103101                                                                        }
    104102                                                                        model.set( 'scope_of_changes', scope_of_changes );
    105                                                                         if ( 0 !== self._right_diff &&
    106                                                                                 model.get( 'ID' ) === self._revisions.at( self._right_diff - 1 ).get( 'ID' ) ) {
    107                                                                                 //reload if current model refreshed
     103                                                                        if ( 0 !== self._rightDiff &&
     104                                                                                model.get( 'ID' ) === self._revisions.at( self._rightDiff - 1 ).get( 'ID' ) ) {
     105                                                                                // reload if current model refreshed
    108106                                                                                self._revisionView.render();
    109107                                                                        }
    … …  
    112110                                                } );
    113111                                                }, delay ) ;
    114                                                 delay = delay + 150; //stagger model loads to avoid hammering server with requests
     112                                                delay = delay + 150; // stagger model loads to avoid hammering server with requests
    115113                                        }
    116114                                );
    117115                        },
    118116
    119                         start_left_model_loading : function() {
    120                                 this._left_model_loading = true;
     117                        startLeftModelLoading: function() {
     118                                this._leftModelLoading = true;
    121119                                $('.revisiondiffcontainer').addClass('leftmodelloading');
    122120                        },
    123121
    124                         stop_left_model_loading : function() {
    125                                 this._left_model_loading = false;
    126                         },
    127 
    128                         start_right_model_loading : function() {
    129                                 this._right_model_loading = true;
     122                        stopLeftModelLoading: function() {
     123                                this._leftModelLoading = false;
     124                        },
     125
     126                        startRightModelLoading: function() {
     127                                this._rightModelLoading = true;
    130128                                $('.revisiondiffcontainer').addClass('rightmodelloading');
    131129                        },
    132130
    133                         stop_right_model_loading : function() {
    134                                 this._right_model_loading = false;
    135                         },
    136 
    137                         stop_model_loading_spinner : function() {
     131                        stopRightModelLoading: function() {
     132                                this._rightModelLoading = false;
     133                        },
     134
     135                        stopModelLoadingSpinner: function() {
    138136                                $('.revisiondiffcontainer').removeClass('rightmodelloading');
    139137                                $('.revisiondiffcontainer').removeClass('leftmodelloading');
    140138                        },
    141139
    142                         reloadmodel : function() {
    143                                 if ( 2 === this._compareoneortwo ) {
    144                                         this.reloadleftright();
     140                        reloadModel: function() {
     141                                if ( 2 === this._compareOneOrTwo ) {
     142                                        this.reloadLeftRight();
    145143                                } else {
    146                                         this.reloadmodelsingle();
    147                                 }
    148                         },
    149 
    150                         //load the models for the single handle mode
    151                         reloadmodelsingle : function() {
     144                                        this.reloadModelSingle();
     145                                }
     146                        },
     147
     148                        // load the models for the single handle mode
     149                        reloadModelSingle: function() {
    152150                                var self = this;
    153151                                self._revisions.url = ajaxurl + '?action=revisions-data&compare_to=' + wpRevisionsSettings.post_id +
    154152                                                                                        '&show_autosaves=' + self._autosaves +
    155                                                                                         '&show_split_view=' +  self._show_split_view +
     153                                                                                        '&show_split_view=' +  self._showSplitView +
    156154                                                                                        '&nonce=' + wpRevisionsSettings.nonce;
    157                                 self.start_right_model_loading();
    158                                 self._revisions.fetch({ //reload revision data
    159                                         success : function() {
     155                                self.startRightModelLoading();
     156                                self._revisions.fetch({ // reload revision data
     157                                        success: function() {
    160158                                                console.log('loaded');
    161                                                 //self.stop_right_model_loading();
    162                                                 //REVAPP._right_diff -= 1;
    163                                                 var revisioncount = self._revisions.length;
     159                                                // self.stopRightModelLoading();
     160                                                // REVAPP._rightDiff -= 1;
     161                                                var revisionCount = self._revisions.length;
    164162                                                self._revisionView.model = self._revisions;
    165163                                                self._revisionView.render();
    166                                                 self.reload_toload_revisions( self._revisions );
     164                                                self.reloadToLoadRevisions( self._revisions );
    167165                                                self._tickmarkView.model = self._revisions;
    168166                                                self._tickmarkView.render();
    169                                                 $( '#slider' ).slider( 'option', 'max', revisioncount-1 ); //TODO test this, if autsave option changed
    170                                                 $( '#slider' ).slider( 'value', self._right_diff - 1 ).trigger( 'slide' );
     167                                                $( '#slider' ).slider( 'option', 'max', revisionCount - 1 ); // TODO: test this, if autosave option changed
     168                                                $( '#slider' ).slider( 'value', self._rightDiff - 1 ).trigger( 'slide' );
    171169
    172170                                        },
    173171
    174                                         error : function () {
    175                                                 self.stop_right_model_loading();
     172                                        error: function() {
     173                                                self.stopRightModelLoading();
    176174                                        }
    177175
    … …  
    179177                        },
    180178
    181                         //load the models for the left handle
    182                         reloadleft : function() {
     179                        // load the models for the left handle
     180                        reloadLeft: function() {
    183181                                var self = this;
    184                                 self.start_left_model_loading();
    185                                 self._left_handle_revisions = new wp.revisions.Collection();
    186 
    187                                 self._left_handle_revisions.url =
     182                                self.startLeftModelLoading();
     183                                self._leftHandleRevisions = new wp.revisions.Collection();
     184
     185                                self._leftHandleRevisions.url =
    188186                                        ajaxurl +
    189                                         '?action=revisions-data&compare_to=' + self._revisions.at( self._right_diff - 1 ).get( 'ID' ) +
     187                                        '?action=revisions-data&compare_to=' + self._revisions.at( self._rightDiff - 1 ).get( 'ID' ) +
    190188                                        '&post_id=' + wpRevisionsSettings.post_id +
    191189                                        '&show_autosaves=' + REVAPP._autosaves +
    192                                         '&show_split_view=' +  REVAPP._show_split_view +
     190                                        '&show_split_view=' +  REVAPP._showSplitView +
    193191                                        '&nonce=' + wpRevisionsSettings.nonce +
    194                                         '&right_handle_at='  + ( self._right_diff );
    195 
    196                                 self._left_handle_revisions.fetch({
    197 
    198                                         success : function(){
    199                                                 self.stop_left_model_loading();
    200                                                 self.reload_toload_revisions( self._left_handle_revisions );
    201                                                 self._tickmarkView.model = self._left_handle_revisions;
     192                                        '&right_handle_at='  + ( self._rightDiff );
     193
     194                                self._leftHandleRevisions.fetch({
     195
     196                                        success: function(){
     197                                                self.stopLeftModelLoading();
     198                                                self.reloadToLoadRevisions( self._leftHandleRevisions );
     199                                                self._tickmarkView.model = self._leftHandleRevisions;
    202200                                                $( '#slider' ).slider( 'option', 'max', self._revisions.length );
    203201                                                // ensure right handle not beyond length, in particular if viewing autosaves is switched from on to off
    204202                                                // the number of models in the collection might get shorter, this ensures right handle is not beyond last model
    205                                                 if ( self._right_diff > self._revisions.length )
    206                                                         self._right_diff = self._revisions.length;
     203                                                if ( self._rightDiff > self._revisions.length )
     204                                                        self._rightDiff = self._revisions.length;
    207205                                                },
    208206
    209                                         error : function () {
    210                                                 self.stop_left_model_loading();
     207                                        error: function() {
     208                                                self.stopLeftModelLoading();
    211209                                        }
    212210                                });
    213211                        },
    214212
    215                         //load the models for the right handle
    216                         reloadright : function() {
     213                        // load the models for the right handle
     214                        reloadRight: function() {
    217215                                var self = this;
    218                                 self.start_right_model_loading();
    219                                 self._right_handle_revisions = new wp.revisions.Collection();
    220 
    221                                         self._right_handle_revisions.url =
     216                                self.startRightModelLoading();
     217                                self._rightHandleRevisions = new wp.revisions.Collection();
     218
     219                                        self._rightHandleRevisions.url =
    222220                                                ajaxurl +
    223                                                 '?action=revisions-data&compare_to=' + ( self._revisions.at( self._left_diff ).get( 'ID' ) -1)+
     221                                                '?action=revisions-data&compare_to=' + ( self._revisions.at( self._leftDiff ).get( 'ID' ) - 1 )+
    224222                                                '&post_id=' + wpRevisionsSettings.post_id +
    225223                                                '&show_autosaves=' + REVAPP._autosaves +
    226                                                 '&show_split_view=' +  REVAPP._show_split_view +
     224                                                '&show_split_view=' +  REVAPP._showSplitView +
    227225                                                '&nonce=' + wpRevisionsSettings.nonce;
    228226
    229                                 self._right_handle_revisions.fetch({
    230 
    231                                         success : function(){
    232                                                 self.stop_right_model_loading();
    233                                                 self.reload_toload_revisions( self._right_handle_revisions );
    234                                                 self._tickmarkView.model = self._right_handle_revisions;
     227                                self._rightHandleRevisions.fetch({
     228
     229                                        success: function(){
     230                                                self.stopRightModelLoading();
     231                                                self.reloadToLoadRevisions( self._rightHandleRevisions );
     232                                                self._tickmarkView.model = self._rightHandleRevisions;
    235233                                                $( '#slider' ).slider( 'option', 'max', self._revisions.length );
    236                                                 $( '#slider' ).slider( 'values', [ REVAPP._left_diff, REVAPP._right_diff] ).trigger( 'slide' );
    237 
    238                                                 //REVAPP._revisionView.render();
     234                                                $( '#slider' ).slider( 'values', [ REVAPP._leftDiff, REVAPP._rightDiff] ).trigger( 'slide' );
     235
     236                                                // REVAPP._revisionView.render();
    239237
    240238                                        },
    241239
    242                                         error : function ( response ) {
    243                                                 self.stop_right_model_loading();
     240                                        error: function( response ) {
     241                                                self.stopRightModelLoading();
    244242                                        }
    245243                                });
    … …  
    247245                        },
    248246
    249                         reloadleftright : function() {
    250                                 this.start_right_model_loading();
    251                                 this.start_left_model_loading();
    252                                 this.reloadleft();
    253                                 this.reloadright();
     247                        reloadLeftRight: function() {
     248                                this.startRightModelLoading();
     249                                this.startLeftModelLoading();
     250                                this.reloadLeft();
     251                                this.reloadRight();
    254252                        },
    255253
    … …  
    257255                         * initialize the revision application
    258256                         */
    259                         initialize : function( options ) {
    260                                 var self = this; //store the application instance
     257                        initialize: function( options ) {
     258                                var self = this; // store the application instance
    261259                                if (this._revisions === null) {
    262                                         self._revisions = new wp.revisions.Collection(); //set up collection
    263                                         self.start_right_model_loading();
    264                                         self._revisions.fetch({ //load revision data
    265 
    266                                                 success : function() {
    267                                                         self.stop_right_model_loading();
    268                                                         //self._right_handle_revisions = self._revisions;
     260                                        self._revisions = new wp.revisions.Collection(); // set up collection
     261                                        self.startRightModelLoading();
     262                                        self._revisions.fetch({ // load revision data
     263
     264                                                success: function() {
     265                                                        self.stopRightModelLoading();
     266                                                        // self._rightHandleRevisions = self._revisions;
    269267                                                        self.completeApplicationSetup();
    270268                                                }
    … …  
    274272                        },
    275273
    276                         addTooltip : function( handle, message ) {
     274                        addTooltip: function( handle, message ) {
    277275
    278276                                handle.attr( 'title', '' ).tooltip({
    … …  
    301299/**/
    302300
    303                         completeApplicationSetup : function() {
     301                        completeApplicationSetup: function() {
    304302                                this._revisionView = new wp.revisions.views.View({
    305                                         model : this._revisions
     303                                        model: this._revisions
    306304                                });
    307305                                this._revisionView.render();
    308306                                $( '#slider' ).slider( 'option', 'max', this._revisions.length - 1 );
    309307
    310                                 this.reload_toload_revisions( this._revisions );
     308                                this.reloadToLoadRevisions( this._revisions );
    311309
    312310                                this._revisionsInteractions = new wp.revisions.views.Interact({
    313                                         model : this._revisions
     311                                        model: this._revisions
    314312                                });
    315313                                this._revisionsInteractions.render();
    316314
    317315                                this._tickmarkView = new wp.revisions.views.Tickmarks({
    318                                         model : this._revisions
     316                                        model: this._revisions
    319317                                });
    320318                                this._tickmarkView.render();
    321                                 this._tickmarkView.resetticks();
     319                                this._tickmarkView.resetTicks();
    322320
    323321
    … …  
    334332                                */
    335333                                /*
    336                                 //Options hidden for now, moving to screen options
     334                                // Options hidden for now, moving to screen options
    337335                                this._revisionsOptions = new wp.revisions.views.Options({
    338                                         model : this._revisions
     336                                        model: this._revisions
    339337                                });
    340338                                this._revisionsOptions.render();
    … …  
    346344
    347345        wp.revisions.Collection = Backbone.Collection.extend({
    348                 model : wp.revisions.Model,
    349                 url : ajaxurl + '?action=revisions-data&compare_to=' + wpRevisionsSettings.post_id +
     346                model: wp.revisions.Model,
     347                url: ajaxurl +  '?action=revisions-data&compare_to=' + wpRevisionsSettings.post_id +
    350348                        '&show_autosaves=true&show_split_view=true&nonce=' + wpRevisionsSettings.nonce,
    351349
    352                 initialize : function() {
     350                initialize: function() {
    353351                        }
    354352        } );
    … …  
    356354        _.extend(wp.revisions.views, {
    357355
    358                 //Ticks inside slider view
    359                 //
    360                 Tickmarks : Backbone.View.extend({
    361                         el : $('#diff-slider-ticks')[0],
    362                         tagName : 'diff-slider-ticks-view',
    363                         className : 'diff-slider-ticks-container',
    364                         template : wp.template('revision-ticks'),
    365                         model : wp.revisions.Model,
    366 
    367                         resetticks : function() {
    368                                 var slider_max = $( '#slider' ).slider( 'option', 'max');
    369                                 var slider_width = $( '#slider' ).width();
    370                                 var adjust_max = ( 2 === REVAPP._compareoneortwo ) ? 1 : 0;
    371                                 var tick_width = Math.floor( slider_width / ( slider_max - adjust_max ) );
    372 
    373                                 //TODO: adjust right margins for wider ticks so they stay centered on handle stop point
    374 
    375                                 //set minimum and maximum widths for tick marks
    376                                 tick_width = (tick_width > 50 ) ? 50 : tick_width;
    377                                 tick_width = (tick_width < 10 ) ? 10 : tick_width;
    378 
    379                                 slider_width = tick_width * (slider_max - adjust_max ) +1;
    380 
    381                                 $( '#slider' ).width( slider_width );
    382                                 $( '.diff-slider-ticks-wrapper' ).width( slider_width );
    383                                 $( '#diffslider' ).width( slider_width );
    384                                 $( '#diff-slider-ticks' ).width( slider_width );
    385 
    386                                 var a_tick_width = $( '.revision-tick' ).width();
    387 
    388                                 if ( tick_width !==  a_tick_width ) { // is the width already set correctly?
     356                // Ticks inside slider view
     357                Tickmarks: Backbone.View.extend({
     358                        el: $('#diff-slider-ticks')[0],
     359                        tagName: 'diff-slider-ticks-view',
     360                        className: 'diff-slider-ticks-container',
     361                        template: wp.template('revision-ticks'),
     362                        model: wp.revisions.Model,
     363
     364                        resetTicks: function() {
     365                                var sliderMax = $( '#slider' ).slider( 'option', 'max');
     366                                var sliderWidth = $( '#slider' ).width();
     367                                var adjustMax = ( 2 === REVAPP._compareOneOrTwo ) ? 1 : 0;
     368                                var tickWidth = Math.floor( sliderWidth / ( sliderMax - adjustMax ) );
     369
     370                                // TODO: adjust right margins for wider ticks so they stay centered on handle stop point
     371
     372                                // set minimum and maximum widths for tick marks
     373                                tickWidth = (tickWidth > 50 ) ? 50 : tickWidth;
     374                                tickWidth = (tickWidth < 10 ) ? 10 : tickWidth;
     375
     376                                sliderWidth = tickWidth * (sliderMax - adjustMax ) + 1;
     377
     378                                $( '#slider' ).width( sliderWidth );
     379                                $( '.diff-slider-ticks-wrapper' ).width( sliderWidth );
     380                                $( '#diffslider' ).width( sliderWidth );
     381                                $( '#diff-slider-ticks' ).width( sliderWidth );
     382
     383                                var aTickWidth = $( '.revision-tick' ).width();
     384
     385                                if ( tickWidth !==  aTickWidth ) { // is the width already set correctly?
    389386                                        $( '.revision-tick' ).each( function( ) {
    390                                                 $(this).css( 'margin-right', tick_width - 1 + 'px'); //space the ticks out using right margin
     387                                                $(this).css( 'margin-right', tickWidth - 1 + 'px'); // space the ticks out using right margin
    391388                                        });
    392389
    393                                         if( 2 === REVAPP._compareoneortwo ) {
    394                                                 $( '.revision-tick' ).first().remove(); //TODO - remove the check
     390                                        if( 2 === REVAPP._compareOneOrTwo ) {
     391                                                $( '.revision-tick' ).first().remove(); // TODO - remove the check
    395392                                        }
    396393                                        $( '.revision-tick' ).last().css( 'margin-right', '0' ); // last tick gets no right margin
    … …  
    399396                        },
    400397
    401                         //render the tickmark view
    402                         render : function() {
     398                        // render the tickmark view
     399                        render: function() {
    403400                                var self = this;
    404401
    405402                                if ( null !== self.model ) {
    406                                         var addhtml = "";
    407                                         _.each ( self.model.models, function ( the_model ) {
    408                                                 addhtml = addhtml + self.template ( the_model.toJSON() );
     403                                        var addHtml = "";
     404                                        _.each ( self.model.models, function( theModel ) {
     405                                                addHtml = addHtml + self.template ( theModel.toJSON() );
    409406                                        });
    410                                         self.$el.html( addhtml );
    411 
    412                                 }
    413                                 self.resetticks();
     407                                        self.$el.html( addHtml );
     408
     409                                }
     410                                self.resetTicks();
    414411                                return self;
    415412                        }
    416413                }),
    417414
    418                 //
    419                 //primary revision diff view
    420                 //
    421                 View : Backbone.View.extend({
    422                         el : $('#backbonerevisionsdiff')[0],
    423                         tagName : 'revisionvview',
    424                         className : 'revisionview-container',
    425                         template : wp.template('revision'),
    426                         comparetwochecked : '',
    427                         draggingleft : false,
    428 
    429                         //
    430                         //render the revisions
    431                         //
    432                         render : function() {
    433                                 var addhtml = '';
    434                                 //compare two revisions mode?
    435 
    436                                 if ( 2 === REVAPP._compareoneortwo ) {
     415                // primary revision diff view
     416                View: Backbone.View.extend({
     417                        el: $('#backbonerevisionsdiff')[0],
     418                        tagName: 'revisionvview',
     419                        className: 'revisionview-container',
     420                        template: wp.template('revision'),
     421                        comparetwochecked: '',
     422                        draggingLeft: false,
     423
     424                        // render the revisions
     425                        render: function() {
     426                                var addHtml = '';
     427                                // compare two revisions mode?
     428
     429                                if ( 2 === REVAPP._compareOneOrTwo ) {
    437430                                        this.comparetwochecked = 'checked';
    438                                         if ( this.draggingleft ) {
    439                                                         if ( this.model.at( REVAPP._left_diff ) ) {
    440                                                         addhtml = this.template( _.extend(
    441                                                                 this.model.at( REVAPP._left_diff ).toJSON(),
    442                                                                 { comparetwochecked : this.comparetwochecked } //keep the checkmark checked
     431                                        if ( this.draggingLeft ) {
     432                                                        if ( this.model.at( REVAPP._leftDiff ) ) {
     433                                                        addHtml = this.template( _.extend(
     434                                                                this.model.at( REVAPP._leftDiff ).toJSON(),
     435                                                                { comparetwochecked: this.comparetwochecked } // keep the checkmark checked
    443436                                                        ) );
    444437                                                }
    445                                         } else { //dragging right handle
    446                                                 var thediff = REVAPP._right_diff;
     438                                        } else { // dragging right handle
     439                                                var thediff = REVAPP._rightDiff;
    447440                                                if ( this.model.at( thediff ) ) {
    448                                                         addhtml = this.template( _.extend(
     441                                                        addHtml = this.template( _.extend(
    449442                                                                this.model.at( thediff ).toJSON(),
    450                                                                 { comparetwochecked : this.comparetwochecked } //keep the checkmark checked
     443                                                                { comparetwochecked: this.comparetwochecked } // keep the checkmark checked
    451444                                                        ) );
    452445                                                }
    453446                                        }
    454                                 } else { //end compare two revisions mode, eg only one slider handle
     447                                } else { // end compare two revisions mode, eg only one slider handle
    455448                                        this.comparetwochecked = '';
    456                                         if ( this.model.at( REVAPP._right_diff - 1 ) ) {
    457                                                 addhtml = this.template( _.extend(
    458                                                         this.model.at( REVAPP._right_diff - 1 ).toJSON(),
    459                                                         { comparetwochecked : this.comparetwochecked } //keep the checkmark unchecked
     449                                        if ( this.model.at( REVAPP._rightDiff - 1 ) ) {
     450                                                addHtml = this.template( _.extend(
     451                                                        this.model.at( REVAPP._rightDiff - 1 ).toJSON(),
     452                                                        { comparetwochecked: this.comparetwochecked } // keep the checkmark unchecked
    460453                                                ) );
    461454                                        }
    462455                                }
    463                                 this.$el.html( addhtml );
     456                                this.$el.html( addHtml );
    464457                                if ( this.model.length < 3 ) {
    465                                         $( 'div#comparetworevisions' ).hide(); //don't allow compare two if fewer than three revisions
     458                                        $( 'div#comparetworevisions' ).hide(); // don't allow compare two if fewer than three revisions
    466459                                }
    467460                                if ( this.model.length < 2 ) {
    468                                         $( 'div#diffslider' ).hide(); //don't allow compare two if fewer than three revisions
     461                                        $( 'div#diffslider' ).hide(); // don't allow compare two if fewer than three revisions
    469462                                        $( 'div.diff-slider-ticks-wrapper' ).hide();
    470463                                }
    471464
    472                                 //
    473465                                // add tooltips to the handles
    474                                 //
    475                                 if ( 2 === REVAPP._compareoneortwo ) {
     466                                if ( 2 === REVAPP._compareOneOrTwo ) {
    476467                                        REVAPP.addTooltip ( $( 'a.ui-slider-handle.left-handle' ),
    477                                                 ( REVAPP._right_diff >= REVAPP._revisions.length ) ? '' : REVAPP._revisions.at( REVAPP._left_diff ).get( 'revision_date_author_short' ) );
     468                                                ( REVAPP._rightDiff >= REVAPP._revisions.length ) ? '' : REVAPP._revisions.at( REVAPP._leftDiff ).get( 'revision_date_author_short' ) );
    478469                                        REVAPP.addTooltip ( $( 'a.ui-slider-handle.right-handle' ),
    479                                                 ( REVAPP._right_diff >= REVAPP._revisions.length ) ? '' : REVAPP._revisions.at( REVAPP._right_diff ).get( 'revision_date_author_short' ) );
     470                                                ( REVAPP._rightDiff >= REVAPP._revisions.length ) ? '' : REVAPP._revisions.at( REVAPP._rightDiff ).get( 'revision_date_author_short' ) );
    480471                                } else {
    481472                                        REVAPP.addTooltip ( $( 'a.ui-slider-handle' ),
    482                                                 ( REVAPP._right_diff >= REVAPP._revisions.length ) ? '' : REVAPP._revisions.at( REVAPP._right_diff ).get( 'revision_date_author_short' ) );
    483                                 }
    484 
    485                                 //
     473                                                ( REVAPP._rightDiff >= REVAPP._revisions.length ) ? '' : REVAPP._revisions.at( REVAPP._rightDiff ).get( 'revision_date_author_short' ) );
     474                                }
     475
    486476                                // hide the restore button when on the last sport/current post data
    487                                 //
    488                                 if (  REVAPP._right_diff === REVAPP._revisions.length ){
     477                                if (  REVAPP._rightDiff === REVAPP._revisions.length ){
    489478                                        $( '.restore-button' ).hide();
    490479                                } else {
    … …  
    495484                        },
    496485
    497                         //the compare two button is in this view, add the interaction here
    498                         events : {
    499                                 'click #comparetwo' : 'clickcomparetwo'
    500                         },
    501 
    502                         //
    503                         //turn on/off the compare two mmode
    504                         //
    505                         clickcomparetwo : function(){
     486                        // the compare two button is in this view, add the interaction here
     487                        events: {
     488                                'click #comparetwo': 'clickcomparetwo'
     489                        },
     490
     491                        // turn on/off the compare two mmode
     492                        clickcomparetwo: function(){
    506493                                self = this;
    507494
    508                                 if ( $( 'input#comparetwo' ).is( ':checked' ) ) { //compare 2 mode
    509                                         REVAPP._compareoneortwo = 2 ;
    510 
    511                                         if ( 1 === REVAPP._right_diff )
    512                                                 REVAPP._right_diff = 2;
    513                                                 REVAPP._revisionView.draggingleft = false;
     495                                if ( $( 'input#comparetwo' ).is( ':checked' ) ) { // compare 2 mode
     496                                        REVAPP._compareOneOrTwo = 2 ;
     497
     498                                        if ( 1 === REVAPP._rightDiff )
     499                                                REVAPP._rightDiff = 2;
     500                                                REVAPP._revisionView.draggingLeft = false;
    514501
    515502                                                wpRevisionsSettings.revision_id = ''; // reset passed revision id so switching back to one handle mode doesn't re-select revision
    516                                                 REVAPP.reloadleftright();
    517                                                 REVAPP._revisionView.model = REVAPP._right_handle_revisions;
    518 
    519                                         } else { //compare one mode
    520                                                 REVAPP._compareoneortwo = 1 ;
    521                                                 REVAPP._revisionView.draggingleft = false;
    522                                                 //REVAPP._left_diff = 0;
    523                                                 //REVAPP._right_diff = (REVAPP._revisions.length <= REVAPP._right_diff ) ? REVAPP._right_diff + 1 : REVAPP._right_diff + 1;
    524                                                 REVAPP.reloadmodelsingle();
    525                                         }
    526                                         //REVAPP._revisionView.render();
     503                                                REVAPP.reloadLeftRight();
     504                                                REVAPP._revisionView.model = REVAPP._rightHandleRevisions;
     505
     506                                        } else { // compare one mode
     507                                                REVAPP._compareOneOrTwo = 1 ;
     508                                                REVAPP._revisionView.draggingLeft = false;
     509                                                // REVAPP._leftDiff = 0;
     510                                                // REVAPP._rightDiff = (REVAPP._revisions.length <= REVAPP._rightDiff ) ? REVAPP._rightDiff + 1 : REVAPP._rightDiff + 1;
     511                                                REVAPP.reloadModelSingle();
     512                                        }
     513                                        // REVAPP._revisionView.render();
    527514                                        REVAPP._revisionsInteractions.render();
    528515                                        REVAPP._tickmarkView.render();
    … …  
    531518                }),
    532519
    533                 //
    534                 //options view for show autosaves and show split view options
    535                 //
     520                // options view for show autosaves and show split view options
    536521                /* DISABLED for now
    537                 Options : Backbone.View.extend({
    538                         el : $('#backbonerevisionsoptions')[0],
    539                         tagName : 'revisionoptionsview',
    540                         className : 'revisionoptions-container',
    541                         template : wp.template('revisionoptions'),
    542 
    543                         //render the options view
    544                         render : function() {
    545                                 var addhtml = this.template;
    546                                 this.$el.html( addhtml );
     522                Options: Backbone.View.extend({
     523                        el: $('#backbonerevisionsoptions')[0],
     524                        tagName: 'revisionoptionsview',
     525                        className: 'revisionoptions-container',
     526                        template: wp.template('revisionoptions'),
     527
     528                        // render the options view
     529                        render: function() {
     530                                var addHtml = this.template;
     531                                this.$el.html( addHtml );
    547532                                return this;
    548533                        },
    549534
    550                         //add options interactions
    551                         events : {
    552                                 'click #toggleshowautosaves' : 'toggleshowautosaves',
    553                                 'click #showsplitview' : 'showsplitview'
    554                         },
    555 
    556                         //
    557                         //toggle include autosaves
    558                         //
    559                         toggleshowautosaves : function() {
     535                        // add options interactions
     536                        events: {
     537                                'click #toggleshowautosaves': 'toggleshowautosaves',
     538                                'click #showsplitview': 'showsplitview'
     539                        },
     540
     541                        // toggle include autosaves
     542                        toggleshowautosaves: function() {
    560543                                var self = this;
    561544                                if ( $( '#toggleshowautosaves' ).is( ':checked' ) ) {
    … …  
    565548                                }
    566549
    567                                 //refresh the model data
    568                                 REVAPP.reloadmodel();
    569                         },
    570 
    571                         //
    572                         //toggle showing the split diff view
    573                         //
    574                         showsplitview :  function() {
     550                                // refresh the model data
     551                                REVAPP.reloadModel();
     552                        },
     553
     554                        // toggle showing the split diff view
     555                        showsplitview:  function() {
    575556                                var self = this;
    576557
    577558                                if ( $( 'input#showsplitview' ).is( ':checked' ) ) {
    578                                         REVAPP._show_split_view = 'true';
     559                                        REVAPP._showSplitView = 'true';
    579560                                        $('.revisiondiffcontainer').addClass('diffsplit');
    580561                                } else {
    581                                         REVAPP._show_split_view = '';
     562                                        REVAPP._showSplitView = '';
    582563                                        $('.revisiondiffcontainer').removeClass('diffsplit');
    583564                                }
    584565
    585                                 REVAPP.reloadmodel();
     566                                REVAPP.reloadModel();
    586567                        }
    587568                }),
    588569                */
    589                 //
    590                 //main interactions view
    591                 //
    592                 Interact : Backbone.View.extend({
    593                         el : $('#backbonerevisionsinteract')[0],
    594                         tagName : 'revisionvinteract',
    595                         className : 'revisionvinteract-container',
    596                         template : wp.template('revisionvinteract'),
    597 
    598                         initialize : function() {
    599                         },
    600 
    601                         render : function() {
     570                // main interactions view
     571                Interact: Backbone.View.extend({
     572                        el: $('#backbonerevisionsinteract')[0],
     573                        tagName: 'revisionvinteract',
     574                        className: 'revisionvinteract-container',
     575                        template: wp.template('revisionvinteract'),
     576
     577                        initialize: function() {
     578                        },
     579
     580                        render: function() {
    602581                                var self = this;
    603582
    604                                 var addhtml = this.template;
    605                                 this.$el.html( addhtml );
     583                                var addHtml = this.template;
     584                                this.$el.html( addHtml );
    606585
    607586                                var modelcount = REVAPP._revisions.length;
    608587
    609588                                slider = $( "#slider" );
    610                                 if ( 1 === REVAPP._compareoneortwo ) {
    611                                         //set up the slider with a single handle
     589                                if ( 1 === REVAPP._compareOneOrTwo ) {
     590                                        // set up the slider with a single handle
    612591                                        slider.slider({
    613                                                 value: REVAPP._right_diff-1,
     592                                                value: REVAPP._rightDiff - 1,
    614593                                                min: 0,
    615                                                 max: modelcount-1,
     594                                                max: modelcount - 1,
    616595                                                step: 1,
    617596
    618597
    619                                                 //slide interactions for one handles slider
    620                                                 slide : function( event, ui ) {
    621 
    622                                                         REVAPP._right_diff = ( ui.value + 1 );
     598                                                // slide interactions for one handles slider
     599                                                slide: function( event, ui ) {
     600
     601                                                        REVAPP._rightDiff = ( ui.value + 1 );
    623602                                                        REVAPP._revisionView.render();
    624603                                                        /*
    … …  
    636615                                                                        }
    637616                                                                }
    638                                                         });//.trigger( 'close' ).trigger( 'open' );
     617                                                        });// .trigger( 'close' ).trigger( 'open' );
    639618*/
    640619                                                        }
    … …  
    642621                                        $( '.revisiondiffcontainer' ).removeClass( 'comparetwo' );
    643622
    644                                 } else { //comparing more than one, eg 2
    645                                         //set up the slider with two handles
     623                                } else { // comparing more than one, eg 2
     624                                        // set up the slider with two handles
    646625                                        slider.slider({
    647                                                 values : [ REVAPP._left_diff, REVAPP._right_diff + 1 ],
    648                                                 min : 1,
    649                                                 max : modelcount+1,
    650                                                 step : 1,
     626                                                values: [ REVAPP._leftDiff, REVAPP._rightDiff + 1 ],
     627                                                min: 1,
     628                                                max: modelcount + 1,
     629                                                step: 1,
    651630                                                range: true,
    652631
    653                                                 //in two handled mode when user starts dragging, swap in precalculated diff for handle
    654                                                 start : function (event, ui ) {
    655                                                         var index = $( ui.handle ).index(); //0 (left) or 1 (right)
     632                                                // in two handled mode when user starts dragging, swap in precalculated diff for handle
     633                                                start: function(event, ui ) {
     634                                                        var index = $( ui.handle ).index(); // 0 (left) or 1 (right)
    656635                                                        switch ( index ) {
    657                                                                 case 1: //left handle drag
    658                                                                         if ( REVAPP._left_model_loading ) //left model still loading, prevent sliding left handle
     636                                                                case 1: // left handle drag
     637                                                                        if ( REVAPP._leftModelLoading ) // left model still loading, prevent sliding left handle
    659638                                                                                return false;
    660639
    661                                                                         REVAPP._revisionView.draggingleft = true;
    662 
    663                                                                         if ( REVAPP._revisionView.model !== REVAPP._left_handle_revisions &&
    664                                                                                         null !== REVAPP._left_handle_revisions ) {
    665                                                                                 REVAPP._revisionView.model = REVAPP._left_handle_revisions;
    666                                                                                 REVAPP._tickmarkView.model = REVAPP._left_handle_revisions;
     640                                                                        REVAPP._revisionView.draggingLeft = true;
     641
     642                                                                        if ( REVAPP._revisionView.model !== REVAPP._leftHandleRevisions &&
     643                                                                                        null !== REVAPP._leftHandleRevisions ) {
     644                                                                                REVAPP._revisionView.model = REVAPP._leftHandleRevisions;
     645                                                                                REVAPP._tickmarkView.model = REVAPP._leftHandleRevisions;
    667646                                                                                REVAPP._tickmarkView.render();
    668647                                                                        }
    669648
    670                                                                         REVAPP._left_diff_start = ui.values[ 0 ];
     649                                                                        REVAPP._leftDiffStart = ui.values[ 0 ];
    671650                                                                        break;
    672651
    673                                                                 case 2: //right
    674                                                                         if ( REVAPP._right_model_loading || 0 === REVAPP._right_handle_revisions.length) //right model still loading, prevent sliding right handle
     652                                                                case 2: // right
     653                                                                        if ( REVAPP._rightModelLoading || 0 === REVAPP._rightHandleRevisions.length) // right model still loading, prevent sliding right handle
    675654                                                                                return false;
    676655
    677                                                                         if ( REVAPP._revisionView.model !== REVAPP._right_handle_revisions &&
    678                                                                                         null !== REVAPP._right_handle_revisions ) {
    679                                                                                 REVAPP._revisionView.model = REVAPP._right_handle_revisions;
    680                                                                                 REVAPP._tickmarkView.model = REVAPP._right_handle_revisions;
     656                                                                        if ( REVAPP._revisionView.model !== REVAPP._rightHandleRevisions &&
     657                                                                                        null !== REVAPP._rightHandleRevisions ) {
     658                                                                                REVAPP._revisionView.model = REVAPP._rightHandleRevisions;
     659                                                                                REVAPP._tickmarkView.model = REVAPP._rightHandleRevisions;
    681660                                                                                REVAPP._tickmarkView.render();
    682661                                                                        }
    683662
    684                                                                         REVAPP._revisionView.draggingleft = false;
    685                                                                         REVAPP._right_diff_start = ui.values[ 1 ];
     663                                                                        REVAPP._revisionView.draggingLeft = false;
     664                                                                        REVAPP._rightDiffStart = ui.values[1];
    686665                                                                        break;
    687666                                                        }
    688667                                                },
    689668
    690                                                 //when sliding in two handled mode change appropriate value
    691                                                 slide : function( event, ui ) {
    692                                                         if ( ui.values[ 0 ] === ui.values[ 1 ] ) //prevent compare to self
     669                                                // when sliding in two handled mode change appropriate value
     670                                                slide: function( event, ui ) {
     671                                                        if ( ui.values[0] === ui.values[1] ) // prevent compare to self
    693672                                                                return false;
    694673
    695                                                         var index = $( ui.handle ).index(); //0 (left) or 1 (right)
     674                                                        var index = $( ui.handle ).index(); // 0 (left) or 1 (right)
    696675
    697676                                                        switch ( index ) {
    698                                                                 case 1: //left
    699                                                                         if ( REVAPP._left_model_loading ) //left model still loading, prevent sliding left handle
     677                                                                case 1: // left
     678                                                                        if ( REVAPP._leftModelLoading ) // left model still loading, prevent sliding left handle
    700679                                                                                return false;
    701680
    702                                                                         REVAPP._left_diff = ui.values[ 0 ];
     681                                                                        REVAPP._leftDiff = ui.values[0];
    703682                                                                        break;
    704683
    705                                                                 case 2: //right
    706                                                                         if ( REVAPP._right_model_loading ) //right model still loading, prevent sliding right handle
     684                                                                case 2: // right
     685                                                                        if ( REVAPP._rightModelLoading ) // right model still loading, prevent sliding right handle
    707686                                                                                return false;
    708687
    709                                                                         REVAPP._right_diff = ui.values[ 1 ];
     688                                                                        REVAPP._rightDiff = ui.values[1];
    710689                                                                        break;
    711690                                                        }
    712691
    713                                                         if ( 0 === REVAPP._left_diff ) {
     692                                                        if ( 0 === REVAPP._leftDiff ) {
    714693                                                                $( '.revisiondiffcontainer' ).addClass( 'currentversion' );
    715694
    … …  
    722701                                                },
    723702
    724                                                 //when the user stops sliding  in 2 handle mode, recalculate diffs
    725                                                 stop : function( event, ui ) {
    726                                                         if ( 2 === REVAPP._compareoneortwo ) {
    727                                                                 //calculate and generate a diff for comparing to the left handle
    728                                                                 //and the right handle, swap out when dragging
    729 
    730                                                                 var index = $( ui.handle ).index(); //0 (left) or 1 (right)
     703                                                // when the user stops sliding  in 2 handle mode, recalculate diffs
     704                                                stop: function( event, ui ) {
     705                                                        if ( 2 === REVAPP._compareOneOrTwo ) {
     706                                                                // calculate and generate a diff for comparing to the left handle
     707                                                                // and the right handle, swap out when dragging
     708
     709                                                                var index = $( ui.handle ).index(); // 0 (left) or 1 (right)
    731710
    732711                                                                switch ( index ) {
    733                                                                         case 1: //left
    734 
    735                                                                                 //left handle dragged & changed, reload right handle model
    736                                                                                 if ( REVAPP._left_diff_start !== ui.values[ 0 ] )
    737                                                                                         REVAPP.reloadright();
     712                                                                        case 1: // left
     713
     714                                                                                // left handle dragged & changed, reload right handle model
     715                                                                                if ( REVAPP._leftDiffStart !== ui.values[0] )
     716                                                                                        REVAPP.reloadRight();
    738717
    739718                                                                                break;
    740719
    741                                                                         case 2: //right
    742                                                                                 //REVAPP._right_diff =  ( 1 >= REVAPP._right_diff ) ? 1  : REVAPP._right_diff-1;
    743                                                                                 //right handle dragged & changed, reload left handle model if changed
    744                                                                                 if ( REVAPP._right_diff_start !== ui.values[ 1 ] )
    745                                                                                         REVAPP.reloadleft();
     720                                                                        case 2: // right
     721                                                                                // REVAPP._rightDiff =  ( 1 >= REVAPP._rightDiff ) ? 1 : REVAPP._rightDiff - 1;
     722                                                                                // right handle dragged & changed, reload left handle model if changed
     723                                                                                if ( REVAPP._rightDiffStart !== ui.values[1] )
     724                                                                                        REVAPP.reloadLeft();
    746725
    747726                                                                                break;
    … …  
    757736                        },
    758737
    759                         //next and previous buttons, only available in compare one mode
    760                         events : {
    761                                 'click #next' : 'nextrevision',
    762                                 'click #previous' : 'previousrevision'
    763                         },
    764 
    765                         //go to the next revision
    766                         nextrevision : function() {
    767                                 if ( REVAPP._right_diff < this.model.length ) //unless at right boundry
    768                                         REVAPP._right_diff = REVAPP._right_diff + 1 ;
     738                        // next and previous buttons, only available in compare one mode
     739                        events: {
     740                                'click #next': 'nextRevision',
     741                                'click #previous': 'previousRevision'
     742                        },
     743
     744                        // go to the next revision
     745                        nextRevision: function() {
     746                                if ( REVAPP._rightDiff < this.model.length ) // unless at right boundry
     747                                        REVAPP._rightDiff = REVAPP._rightDiff + 1 ;
    769748
    770749                                REVAPP._revisionView.render();
    771750
    772                                 $( '#slider' ).slider( 'value', REVAPP._right_diff - 1 ).trigger( 'slide' );
    773                         },
    774 
    775                         //go the the previous revision
    776                         previousrevision : function() {
    777                                 if ( REVAPP._right_diff > 1 ) //unless at left boundry
    778                                                 REVAPP._right_diff = REVAPP._right_diff - 1 ;
     751                                $( '#slider' ).slider( 'value', REVAPP._rightDiff - 1 ).trigger( 'slide' );
     752                        },
     753
     754                        // go the the previous revision
     755                        previousRevision: function() {
     756                                if ( REVAPP._rightDiff > 1 ) // unless at left boundry
     757                                        REVAPP._rightDiff = REVAPP._rightDiff - 1 ;
    779758
    780759                                REVAPP._revisionView.render();
    781760
    782                                 $( '#slider' ).slider( 'value', REVAPP._right_diff - 1 ).trigger( 'slide' );
     761                                $( '#slider' ).slider( 'value', REVAPP._rightDiff - 1 ).trigger( 'slide' );
    783762                        }
    784763                })
    785764        });
    786765
    787         //instantiate Revision Application
     766        // instantiate Revision Application
    788767        REVAPP = new wp.revisions.App();
    789768
Note: See TracChangeset for help on using the changeset viewer.