Changeset 12702


Ignore:
Timestamp:
Aug 20, 2011, 9:17:12 PM (10 years ago)
Author:
jordan
Message:

(trunk web) Torrent class cleanup:

  1. remove some of its unnecessary coupling to other classes
  2. make more of its method names consistent with each other
  3. make its field names consistent with the RPC spec
  4. better grouping of methods by relevance
  5. syntactical cleanup
Location:
trunk/web/javascript
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/web/javascript/file-row.js

    r12690 r12702  
    9191                var i = this.getIndex( );
    9292                var t = this.getTorrent( );
    93                 this.readAttributes( t._file_model[i] );
     93                this.readAttributes( t._files[i] );
    9494                this.refreshHTML();
    9595        },
     
    9999        },
    100100        isEditable: function () {
    101                 return (this.getTorrent()._file_model.length>1) && !this.isDone();
     101                return (this.getTorrent()._files.length>1) && !this.isDone();
    102102        },
    103103
     
    105105        {
    106106                var me = this;
    107                 var file = torrent._file_model[i];
     107                var file = torrent._files[i];
    108108                var name = file.name.substring (file.name.lastIndexOf('/')+1);
    109109
    110110                var root = document.createElement('li');
    111                 root.id = 't' + this._torrent.id() + 'f' + this._index;
     111                root.id = 't' + this._torrent.getId() + 'f' + this._index;
    112112                root.classNameConst = 'inspector_torrent_file_list_entry ' + ((i%2)?'odd':'even');
    113113                root.className = root.classNameConst;
  • trunk/web/javascript/torrent-renderer.js

    r12700 r12702  
    2020        var pct = 0;
    2121        if( t.needsMetaData( ) )
    22                 pct = t._metadataPercentComplete * 100;
     22                pct = t.getMetadataPercentComplete() * 100;
    2323        else if( !t.isDone( ) )
    2424                pct = Math.round( t.getPercentDone() * 100 );
    2525        else if( seed_ratio_limit > 0 )
    26                 pct = Math.round( t._upload_ratio * 100 / seed_ratio_limit );
     26                pct = Math.round( t.getUploadRatio() * 100 / seed_ratio_limit );
    2727        else
    2828                pct = 100;
     
    7373TorrentRendererHelper.formatUL = function( t )
    7474{
    75         return 'UL: ' + Transmission.fmt.speedBps( t.uploadSpeed( ) );
     75        return 'UL: ' + Transmission.fmt.speedBps( t.getUploadSpeed( ) );
    7676}
    7777
    7878TorrentRendererHelper.formatDL = function( t )
    7979{
    80         return 'DL: ' + Transmission.fmt.speedBps( t.downloadSpeed( ) );
     80        return 'DL: ' + Transmission.fmt.speedBps( t.getDownloadSpeed( ) );
    8181}
    8282
     
    135135                if( t.isDownloading( ) )
    136136                        return [ 'Downloading from',
    137                                  t.peersSendingToUs(),
     137                                 t.getPeersSendingToUs(),
    138138                                 'of',
    139                                  t._peers_connected,
     139                                 t.getPeersConnected(),
    140140                                 'peers',
    141141                                 '-',
     
    145145                if( t.isSeeding( ) )
    146146                        return [ 'Seeding to',
    147                                  t.peersGettingFromUs(),
     147                                 t.getPeersGettingFromUs(),
    148148                                 'of',
    149                                  t._peers_connected,
     149                                 t.getPeersConnected(),
    150150                                 'peers',
    151151                                 '-',
    152152                                 TorrentRendererHelper.formatUL(t) ].join(' ');
    153153
    154                 if( t.state() === Torrent._StatusCheck )
     154                if( t.isChecking( ) )
    155155                        return [ 'Verifying local data (',
    156                                  Transmission.fmt.percentString( 100.0 * t._recheckProgress ),
     156                                 Transmission.fmt.percentString( 100.0 * t.getRecheckProgress() ),
    157157                                 '% tested)' ].join('');
    158158
    159                 return t.stateStr( );
     159                return t.getStateString( );
    160160        },
    161161
     
    163163        {
    164164                if( t.needsMetaData() ) {
    165                         var percent = 100 * t._metadataPercentComplete;
     165                        var percent = 100 * t.getMetadataPercentComplete();
    166166                        return [ "Magnetized transfer - retrieving metadata (",
    167167                                 Transmission.fmt.percentString( percent ),
     
    170170
    171171                var c;
    172                 var is_done = ( t.isDone( ) )
    173                            || ( t.state() === Torrent._StatusSeeding );
     172                var sizeWhenDone = t.getSizeWhenDone()
     173                var totalSize = t.getTotalSize()
     174                var is_done = ( t.isDone( ) ) || ( t.isSeeding() )
     175
    174176                if( is_done ) {
    175                         if( t._size == t._sizeWhenDone ) // seed: '698.05 MiB'
    176                                 c = [ Transmission.fmt.size( t._size ) ];
     177                        if( totalSize == sizeWhenDone ) // seed: '698.05 MiB'
     178                                c = [ Transmission.fmt.size( totalSize ) ];
    177179                        else // partial seed: '127.21 MiB of 698.05 MiB (18.2%)'
    178                                 c = [ Transmission.fmt.size( t._sizeWhenDone ),
     180                                c = [ Transmission.fmt.size( sizeWhenDone ),
    179181                                      ' of ',
    180                                       Transmission.fmt.size( t._size ),
     182                                      Transmission.fmt.size( t.getTotalSize() ),
    181183                                      ' (', t.getPercentDoneStr, '%)' ];
    182184                        // append UL stats: ', uploaded 8.59 GiB (Ratio: 12.3)'
    183185                        c.push( ', uploaded ',
    184                                 Transmission.fmt.size( t._upload_total ),
     186                                Transmission.fmt.size( t.getUploadedEver() ),
    185187                                ' (Ratio ',
    186                                 Transmission.fmt.ratioString( t._upload_ratio ),
     188                                Transmission.fmt.ratioString( t.getUploadRatio() ),
    187189                                ')' );
    188190                } else { // not done yet
    189                         c = [ Transmission.fmt.size( t._sizeWhenDone - t._leftUntilDone ),
    190                               ' of ', Transmission.fmt.size( t._sizeWhenDone ),
     191                        c = [ Transmission.fmt.size( sizeWhenDone - t.getLeftUntilDone() ),
     192                              ' of ', Transmission.fmt.size( sizeWhenDone ),
    191193                              ' (', t.getPercentDoneStr(), '%)' ];
    192194                }
    193195
    194196                // maybe append eta
    195                 if( t.isActive() && ( !is_done || t.seedRatioLimit(controller)>0 ) ) {
     197                if( !t.isStopped() && ( !is_done || t.seedRatioLimit(controller)>0 ) ) {
    196198                        c.push(' - ');
    197                         if (t._eta < 0 || this._eta >= Torrent._InfiniteTimeRemaining )
     199                        var eta = t.getETA()
     200                        if (eta < 0 || eta >= (999*60*60) /* arbitrary */ )
    198201                                c.push( 'remaining time unknown' );
    199202                        else
    200                                 c.push( Transmission.fmt.timeInterval(t._eta),
     203                                c.push( Transmission.fmt.timeInterval(t.getETA()),
    201204                                        ' remaining' );
    202205                }
     
    208211        {
    209212                // name
    210                 setInnerHTML( root._name_container, t.name() );
     213                setInnerHTML( root._name_container, t.getName() );
    211214
    212215                // progressbar
     
    214217
    215218                // peer details
    216                 var has_error = t._error !== Torrent._ErrNone;
     219                var has_error = t.getError() !== Torrent._ErrNone;
    217220                var e = root._peer_details_container;
    218221                $(e).toggleClass('error',has_error);
     
    224227
    225228                // pause/resume button
    226                 var is_stopped = t.state() === Torrent._StatusStopped;
    227                 e = root._pause_resume_button_image;
    228                 e.alt = is_stopped ? 'Resume' : 'Pause';
    229                 e.className = is_stopped ? 'torrent_resume' : 'torrent_pause';
     229                var is_stopped = t.isStopped()
     230                e = root._pause_resume_button_image
     231                e.alt = is_stopped ? 'Resume' : 'Pause'
     232                e.className = is_stopped ? 'torrent_resume' : 'torrent_pause'
    230233        }
    231234};
     
    272275                if( t.isSeeding( ) )
    273276                        return TorrentRendererHelper.formatUL(t);
    274                 return t.stateStr( );
     277                return t.getStateString( );
    275278        },
    276279
     
    278281        {
    279282                // name
    280                 var is_stopped = t.state() === Torrent._StatusStopped;
     283                var is_stopped = t.isStopped()
    281284                var e = root._name_container;
    282285                $(e).toggleClass( 'paused', is_stopped );
    283                 setInnerHTML( e, t.name() );
     286                setInnerHTML( e, t.getName() );
    284287
    285288                // peer details
    286                 var has_error = t._error !== Torrent._ErrNone;
     289                var has_error = t.getError() !== Torrent._ErrNone;
    287290                e = root._details_container;
    288291                $(e).toggleClass('error', has_error );
  • trunk/web/javascript/torrent.js

    r12690 r12702  
    11/*
    2  *      Copyright © Dave Perrett and Malcolm Jarvis
     2 *      Copyright © Jordan Lee, Dave Perrett and Malcolm Jarvis
    33 *      This code is licensed under the GPL version 2.
    44 *      For details, see http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
     
    77 */
    88
    9 function Torrent( controller, data) {
    10         this.initialize( controller, data);
    11 }
    12 
    13 // Constants
    14 Torrent._StatusStopped         = 0; /* torrent is stopped */
    15 Torrent._StatusCheckWait       = 1; /* waiting in queue to check files */
    16 Torrent._StatusCheck           = 2; /* checking files */
    17 Torrent._StatusDownloadWait    = 3; /* queued to download */
    18 Torrent._StatusDownload        = 4; /* downloading */
    19 Torrent._StatusSeedWait        = 5; /* queeud to seed */
    20 Torrent._StatusSeed            = 6; /* seeding */
    21 
    22 Torrent._InfiniteTimeRemaining = 215784000; // 999 Hours - may as well be infinite
    23 
    24 Torrent._RatioUseGlobal        = 0;
    25 Torrent._RatioUseLocal         = 1;
    26 Torrent._RatioUnlimited        = 2;
    27 
    28 Torrent._ErrNone               = 0;
    29 Torrent._ErrTrackerWarning     = 1;
    30 Torrent._ErrTrackerError       = 2;
    31 Torrent._ErrLocalError         = 3;
    32 
    33 Torrent._TrackerInactive       = 0;
    34 Torrent._TrackerWaiting        = 1;
    35 Torrent._TrackerQueued         = 2;
    36 Torrent._TrackerActive         = 3;
    37 
    38 
    39 Torrent._StaticFields = [ 'hashString', 'id' ]
    40 
    41 Torrent._MetaDataFields = [ 'addedDate', 'comment', 'creator', 'dateCreated',
    42                 'isPrivate', 'name', 'totalSize', 'pieceCount', 'pieceSize' ]
    43 
    44 Torrent._DynamicFields = [ 'downloadedEver', 'error', 'errorString', 'eta',
    45     'haveUnchecked', 'haveValid', 'leftUntilDone', 'metadataPercentComplete',
    46     'peers', 'peersConnected', 'peersGettingFromUs', 'peersSendingToUs',
    47     'queuePosition', 'rateDownload', 'rateUpload', 'recheckProgress',
    48     'sizeWhenDone', 'status', 'trackerStats', 'desiredAvailable',
    49     'uploadedEver', 'uploadRatio', 'seedRatioLimit', 'seedRatioMode',
    50     'downloadDir', 'isFinished' ]
     9
     10function Torrent(controller, data)
     11{
     12        this.initialize(controller, data)
     13}
     14
     15/***
     16****
     17****  Constants
     18****
     19***/
     20
     21// Torrent.fields.status
     22Torrent._StatusStopped         = 0
     23Torrent._StatusCheckWait       = 1
     24Torrent._StatusCheck           = 2
     25Torrent._StatusDownloadWait    = 3
     26Torrent._StatusDownload        = 4
     27Torrent._StatusSeedWait        = 5
     28Torrent._StatusSeed            = 6
     29
     30// Torrent.fields.seedRatioMode
     31Torrent._RatioUseGlobal        = 0
     32Torrent._RatioUseLocal         = 1
     33Torrent._RatioUnlimited        = 2
     34
     35// Torrent.fields.error
     36Torrent._ErrNone               = 0
     37Torrent._ErrTrackerWarning     = 1
     38Torrent._ErrTrackerError       = 2
     39Torrent._ErrLocalError         = 3
     40
     41// TrackerStats' announceState
     42Torrent._TrackerInactive       = 0
     43Torrent._TrackerWaiting        = 1
     44Torrent._TrackerQueued         = 2
     45Torrent._TrackerActive         = 3
     46
     47
     48// fields whose values never change and are always known
     49Torrent._StaticFields = [
     50        'hashString', 'id' ]
     51
     52// fields whose values never change and are known upon constructon OR
     53// when a magnet torrent finishes downloading its metadata
     54Torrent._MetaDataFields = [
     55        'addedDate', 'comment', 'creator', 'dateCreated',
     56        'isPrivate', 'name', 'totalSize', 'pieceCount', 'pieceSize' ]
     57
     58// torrent fields whose values change all the time
     59Torrent._DynamicFields = [
     60        'desiredAvailable', 'downloadDir', 'downloadedEver', 'error',
     61        'errorString', 'eta', 'haveUnchecked', 'haveValid', 'isFinished',
     62        'leftUntilDone', 'metadataPercentComplete', 'peers', 'peersConnected',
     63        'peersGettingFromUs', 'peersSendingToUs', 'queuePosition',
     64        'rateDownload', 'rateUpload', 'recheckProgress', 'seedRatioLimit',
     65        'seedRatioMode', 'sizeWhenDone', 'status', 'trackerStats',
     66        'uploadedEver', 'uploadRatio', 'webseedsSendingToUs' ]
     67
     68// tracker stats fields whose values change all the time
     69Torrent._TrackerStatFields = [
     70        'announce', 'announceState', 'downloadCount', 'hasAnnounced',
     71        'hasScraped', 'host', 'isBackup', 'lastAnnouncePeerCount',
     72        'lastAnnounceResult', 'lastAnnounceSucceeded', 'lastAnnounceTime',
     73        'lastScrapeResult', 'lastScrapeSucceeded', 'lastScrapeTime',
     74        'leecherCount', 'nextAnnounceTime', 'seederCount'
     75]
     76
     77
     78/***
     79****
     80****  Methods
     81****
     82***/
    5183
    5284Torrent.prototype =
    5385{
    54         initMetaData: function( data ) {
    55                 this._date          = data.addedDate;
    56                 this._comment       = data.comment;
    57                 this._creator       = data.creator;
    58                 this._creator_date  = data.dateCreated;
    59                 this._is_private    = data.isPrivate;
    60                 this._name          = data.name;
    61                 this._name_lc       = this._name.toLowerCase( );
    62                 this._size          = data.totalSize;
    63                 this._pieceCount    = data.pieceCount;
    64                 this._pieceSize     = data.pieceSize;
    65 
    66                 if( data.files ) {
    67                         for( var i=0, row; row=data.files[i]; ++i ) {
    68                                 this._file_model[i] = {
     86        initialize: function(controller, data)
     87        {
     88                this.fields = { }
     89                this._files = [ ]
     90
     91                // these fields are set in the ctor and never change
     92                for(var i=0, key; key=Torrent._StaticFields[i]; ++i)
     93                        if(key in data)
     94                                this.fields[key] = data[key]
     95
     96                this.initMetaData(data)
     97                this._trackerStats = this.buildTrackerStats(data.trackerStats)
     98                this.refresh(data)
     99        },
     100
     101        buildTrackerStats: function(trackerStats) {
     102                result = []
     103                for(var i=0, tracker; tracker=trackerStats[i]; ++i) {
     104                        tier = result[tracker.tier] || []
     105                        tier[tier.length] = tracker
     106                        result[tracker.tier] = tier
     107                }
     108                return result
     109        },
     110
     111        initMetaData: function(data) {
     112
     113                var f = this.fields
     114
     115                // populate the metadata fields
     116                for(var i=0, key; key=Torrent._MetaDataFields[i]; ++i) {
     117                        if(key in data) {
     118                                f[key] = data[key]
     119                                if(key == 'name')
     120                                        f.collatedName = data.name.toLowerCase()
     121                        }
     122                }
     123
     124                // populate the files array
     125                if(data.files) {
     126                        for(var i=0, row; row=data.files[i]; ++i) {
     127                                this._files[i] = {
    69128                                        'index': i,
    70129                                        'torrent': this,
    71130                                        'length': row.length,
    72131                                        'name': row.name
    73                                 };
     132                                }
    74133                        }
    75134                }
    76135        },
    77136
    78         /*
    79          * Constructor
    80          */
    81         initialize: function( controller, data) {
    82                 this._id            = data.id;
    83                 this._hashString    = data.hashString;
    84                 this._sizeWhenDone  = data.sizeWhenDone;
    85                 this._trackerStats  = this.buildTrackerStats(data.trackerStats);
    86                 this._file_model    = [ ];
    87                 this.initMetaData( data );
    88 
    89                 // Update all the labels etc
    90                 this.refresh(data);
    91         },
    92 
    93         buildTrackerStats: function(trackerStats) {
    94                 result = [];
    95                 for( var i=0, tracker; tracker=trackerStats[i]; ++i ) {
    96                         tier = result[tracker.tier] || [];
    97                         tier[tier.length] = {
    98                                 'host': tracker.host,
    99                                 'announce': tracker.announce,
    100                                 'hasAnnounced': tracker.hasAnnounced,
    101                                 'lastAnnounceTime': tracker.lastAnnounceTime,
    102                                 'lastAnnounceSucceeded': tracker.lastAnnounceSucceeded,
    103                                 'lastAnnounceResult': tracker.lastAnnounceResult,
    104                                 'lastAnnouncePeerCount': tracker.lastAnnouncePeerCount,
    105                                 'announceState': tracker.announceState,
    106                                 'nextAnnounceTime': tracker.nextAnnounceTime,
    107                                 'isBackup': tracker.isBackup,
    108                                 'hasScraped': tracker.hasScraped,
    109                                 'lastScrapeTime': tracker.lastScrapeTime,
    110                                 'lastScrapeSucceeded': tracker.lastScrapeSucceeded,
    111                                 'lastScrapeResult': tracker.lastScrapeResult,
    112                                 'seederCount': tracker.seederCount,
    113                                 'leecherCount': tracker.leecherCount,
    114                                 'downloadCount': tracker.downloadCount
    115                         };
    116                         result[tracker.tier] = tier;
    117                 }
    118                 return result;
    119         },
    120 
    121         /*--------------------------------------------
    122          *
    123          *  S E T T E R S   /   G E T T E R S
    124          *
    125          *--------------------------------------------*/
    126 
    127         activity: function() { return this.downloadSpeed() + this.uploadSpeed(); },
    128         comment: function() { return this._comment; },
    129         completed: function() { return this._completed; },
    130         creator: function() { return this._creator; },
    131         dateAdded: function() { return this._date; },
    132         downloadSpeed: function() { return this._download_speed; },
    133         downloadTotal: function() { return this._download_total; },
    134         hash: function() { return this._hashString; },
    135         id: function() { return this._id; },
    136         isActiveFilter: function() { return this.peersGettingFromUs() > 0
    137                                          || this.peersSendingToUs() > 0
    138                                          || this.webseedsSendingToUs() > 0
    139                                          || this.state() == Torrent._StatusCheck; },
    140         isStopped: function() { return this.state() === Torrent._StatusStopped; },
    141         isActive: function() { return this.state() != Torrent._StatusStopped; },
    142         isDownloading: function() { return this.state() == Torrent._StatusDownload; },
    143         isFinished: function() { return this._isFinishedSeeding; },
    144         isDone: function() { return this._leftUntilDone < 1; },
    145         isSeeding: function() { return this.state() == Torrent._StatusSeed; },
    146         name: function() { return this._name; },
    147         queuePosition: function() { return this._queue_position; },
    148         webseedsSendingToUs: function() { return this._webseeds_sending_to_us; },
    149         peersSendingToUs: function() { return this._peers_sending_to_us; },
    150         peersGettingFromUs: function() { return this._peers_getting_from_us; },
    151         needsMetaData: function(){ return this._metadataPercentComplete < 1 },
     137        fireDataChanged: function()
     138        {
     139                $(this).trigger('dataChanged',[])
     140        },
     141
     142        refreshMetaData: function(data)
     143        {
     144                this.initMetaData(data)
     145                this.fireDataChanged()
     146        },
     147
     148        refresh: function(data)
     149        {
     150                // FIXME: unnecessary coupling... this should be handled by transmission.js
     151                if(this.needsMetaData() && (data.metadataPercentComplete >= 1))
     152                        transmission.refreshMetaData([ this.getId() ])
     153
     154                var f = this.fields
     155
     156                // refresh the dynamic fields
     157                for(var i=0, key; key=Torrent._DynamicFields[i]; ++i)
     158                        if(key in data)
     159                                f[key] = data[key]
     160
     161                this._trackerStats = this.buildTrackerStats(data.trackerStats)
     162
     163                if (data.fileStats)
     164                        this.refreshFiles(data)
     165
     166                this.fireDataChanged()
     167        },
     168
     169        refreshFiles: function(data) {
     170                for(var i=0; i<data.fileStats.length; ++i) {
     171                        var src = data.fileStats[i]
     172                        var tgt = this._files[i]
     173                        if(!tgt)
     174                                tgt = this._files[i] = { }
     175                        tgt.wanted = src.wanted
     176                        tgt.priority = src.priority
     177                        tgt.bytesCompleted = src.bytesCompleted
     178                }
     179        },
     180
     181        /****
     182        *****
     183        ****/
     184
     185        // simple accessors
     186        getCollatedName: function() { return this.fields.collatedName },
     187        getComment: function() { return this.fields.comment },
     188        getCreator: function() { return this.fields.creator },
     189        getDateAdded: function() { return this.fields.addedDate },
     190        getDateCreated: function() { return this.fields.dateCreated },
     191        getDesiredAvailable: function() { return this.fields.desiredAvailable },
     192        getDownloadDir: function() { return this.fields.downloadDir },
     193        getDownloadSpeed: function() { return this.fields.rateDownload },
     194        getDownloadedEver: function() { return this.fields.downloadedEver },
     195        getError: function() { return this.fields.error },
     196        getErrorString: function() { return this.fields.errorString },
     197        getETA: function() { return this.fields.eta },
     198        getHashString: function() { return this.fields.hashString },
     199        getHaveValid: function() { return this.fields.haveValid },
     200        getHave: function() { return this.getHaveValid() + this.fields.haveUnchecked },
     201        getId: function() { return this.fields.id },
     202        getLeftUntilDone: function() { return this.fields.leftUntilDone },
     203        getMetadataPercentComplete: function() { return this.fields.metadataPercentComplete },
     204        getName: function() { return this.fields.name },
     205        getPeers: function() { return this.fields.peers },
     206        getPeersConnected: function() { return this.fields.peersConnected },
     207        getPeersGettingFromUs: function() { return this.fields.peersGettingFromUs },
     208        getPeersSendingToUs: function() { return this.fields.peersSendingToUs },
     209        getPieceCount: function() { return this.fields.pieceCount },
     210        getPieceCount: function() { return this.fields.pieceCount },
     211        getPieceSize: function() { return this.fields.pieceSize },
     212        getPrivateFlag: function() { return this.fields.isPrivate },
     213        getQueuePosition: function() { return this.fields.queuePosition },
     214        getRecheckProgress: function() { return this.fields.recheckProgress },
     215        getSeedRatioLimit: function() { return this.fields.seedRatioLimit },
     216        getSeedRatioMode: function() { return this.fields.seedRatioMode },
     217        getSizeWhenDone: function() { return this.fields.sizeWhenDone },
     218        getStatus: function() { return this.fields.status },
     219        getTotalSize: function() { return this.fields.totalSize },
     220        getUploadSpeed: function() { return this.fields.rateUpload },
     221        getUploadRatio: function() { return this.fields.uploadRatio },
     222        getUploadedEver: function() { return this.fields.uploadedEver },
     223        getWebseedsSendingToUs: function() { return this.fields.webseedsSendingToUs },
     224        isFinished: function() { return this.fields.isFinished },
     225
     226        // derived accessors
     227        isSeeding: function() { return this.getStatus() === Torrent._StatusSeed },
     228        isStopped: function() { return this.getStatus() === Torrent._StatusStopped },
     229        isChecking: function() { return this.getStatus() === Torrent._StatusCheck },
     230        isDownloading: function() { return this.getStatus() === Torrent._StatusDownload },
     231        isDone: function() { return this.getLeftUntilDone() < 1 },
     232        needsMetaData: function(){ return this.getMetadataPercentComplete() < 1 },
     233        getActivity: function() { return this.getDownloadSpeed() + this.getUploadSpeed() },
     234        getPercentDoneStr: function() { return Transmission.fmt.percentString(100*this.getPercentDone()) },
    152235        getPercentDone: function() {
    153                 if( !this._sizeWhenDone ) return 1.0;
    154                 if( !this._leftUntilDone ) return 1.0;
    155                 return ( this._sizeWhenDone - this._leftUntilDone ) / this._sizeWhenDone;
    156         },
    157         getPercentDoneStr: function() {
    158                 return Transmission.fmt.percentString( 100 * this.getPercentDone() );
    159         },
    160         size: function() { return this._size; },
    161         state: function() { return this._state; },
    162         stateStr: function() {
    163                 switch( this.state() ) {
    164                         case Torrent._StatusStopped:        return this.isFinished() ? 'Seeding complete' : 'Paused';
    165                         case Torrent._StatusCheckWait:      return 'Queued for verification';
    166                         case Torrent._StatusCheck:          return 'Verifying local data';
    167                         case Torrent._StatusDownloadWait:   return 'Queued for download';
    168                         case Torrent._StatusDownload:       return 'Downloading';
    169                         case Torrent._StatusSeedWait:       return 'Queued for seeding';
    170                         case Torrent._StatusSeed:           return 'Seeding';
    171                         default:                            return 'error';
    172                 }
    173         },
    174         trackerStats: function() { return this._trackerStats; },
    175         uploadSpeed: function() { return this._upload_speed; },
    176         uploadTotal: function() { return this._upload_total; },
     236                var finalSize = this.getSizeWhenDone()
     237                if(!finalSize) return 1.0
     238                var left = this.getLeftUntilDone()
     239                if(!left) return 1.0
     240                return (finalSize - left) / finalSize
     241        },
     242        getStateString: function() {
     243                switch(this.getStatus()) {
     244                        case Torrent._StatusStopped:        return this.isFinished() ? 'Seeding complete' : 'Paused'
     245                        case Torrent._StatusCheckWait:      return 'Queued for verification'
     246                        case Torrent._StatusCheck:          return 'Verifying local data'
     247                        case Torrent._StatusDownloadWait:   return 'Queued for download'
     248                        case Torrent._StatusDownload:       return 'Downloading'
     249                        case Torrent._StatusSeedWait:       return 'Queued for seeding'
     250                        case Torrent._StatusSeed:           return 'Seeding'
     251                        default:                            return 'error'
     252                }
     253        },
     254        trackerStats: function() { return this._trackerStats },
    177255        seedRatioLimit: function(controller){
    178                 switch( this._seed_ratio_mode ) {
    179                         case Torrent._RatioUseGlobal: return controller.seedRatioLimit();
    180                         case Torrent._RatioUseLocal:  return this._seed_ratio_limit;
    181                         default:                      return -1;
     256                switch(this.getSeedRatioMode()) {
     257                        case Torrent._RatioUseGlobal: return controller.seedRatioLimit()
     258                        case Torrent._RatioUseLocal:  return this.getSeedRatioLimit()
     259                        default:                      return -1
    182260                }
    183261        },
    184262        getErrorMessage: function() {
    185                 if( this._error  == Torrent._ErrTrackerWarning )
    186                         return 'Tracker returned a warning: ' + this._error_string;
    187                 if( this._error  == Torrent._ErrTrackerError )
    188                         return 'Tracker returned an error: ' + this._error_string;
    189                 if( this._error  == Torrent._ErrLocalError )
    190                         return 'Error: ' + this._error_string;
    191                 return null;
    192         },
    193 
    194 
    195         /*--------------------------------------------
    196          *
    197          *  I N T E R F A C E   F U N C T I O N S
    198          *
    199          *--------------------------------------------*/
    200 
    201         fireDataChanged: function()
    202         {
    203                 $(this).trigger('dataChanged',[]);
    204         },
    205 
    206         refreshMetaData: function(data)
    207         {
    208                 this.initMetaData( data );
    209                 this.fireDataChanged();
    210         },
    211 
    212         refresh: function(data)
    213         {
    214                 if( this.needsMetaData() && ( data.metadataPercentComplete >= 1 ) )
    215                         transmission.refreshMetaData( [ this._id ] );
    216 
    217                 this._completed               = data.haveUnchecked + data.haveValid;
    218                 this._verified                = data.haveValid;
    219                 this._leftUntilDone           = data.leftUntilDone;
    220                 this._download_total          = data.downloadedEver;
    221                 this._upload_total            = data.uploadedEver;
    222                 this._upload_ratio            = data.uploadRatio;
    223                 this._seed_ratio_limit        = data.seedRatioLimit;
    224                 this._seed_ratio_mode         = data.seedRatioMode;
    225                 this._download_speed          = data.rateDownload;
    226                 this._upload_speed            = data.rateUpload;
    227                 this._peers                   = data.peers;
    228                 this._peers_connected         = data.peersConnected;
    229                 this._peers_getting_from_us   = data.peersGettingFromUs;
    230                 this._peers_sending_to_us     = data.peersSendingToUs;
    231                 this._queue_position          = data.queuePosition;
    232                 this._webseeds_sending_to_us  = data.webseedsSendingToUs;
    233                 this._sizeWhenDone            = data.sizeWhenDone;
    234                 this._recheckProgress         = data.recheckProgress;
    235                 this._error                   = data.error;
    236                 this._error_string            = data.errorString;
    237                 this._eta                     = data.eta;
    238                 this._trackerStats            = this.buildTrackerStats(data.trackerStats);
    239                 this._state                   = data.status;
    240                 this._download_dir            = data.downloadDir;
    241                 this._metadataPercentComplete = data.metadataPercentComplete;
    242                 this._isFinishedSeeding       = data.isFinished;
    243                 this._desiredAvailable        = data.desiredAvailable;
    244 
    245                 if (data.fileStats)
    246                         this.refreshFileModel( data );
    247 
    248                 this.fireDataChanged();
    249         },
    250 
    251         refreshFileModel: function(data) {
    252                 for( var i=0; i<data.fileStats.length; ++i ) {
    253                         var src = data.fileStats[i];
    254                         var tgt = this._file_model[i];
    255                         if( !tgt )
    256                                 tgt = this._file_model[i] = { };
    257                         tgt.wanted = src.wanted;
    258                         tgt.priority = src.priority;
    259                         tgt.bytesCompleted = src.bytesCompleted;
    260                 }
    261         },
     263                var str = this.getErrorString()
     264                switch(this.getError()) {
     265                        case Torrent._ErrTrackerWarning:
     266                                return 'Tracker returned a warning: ' + str
     267                        case Torrent._ErrTrackerError:
     268                                return 'Tracker returned an error: ' + str
     269                        case Torrent._ErrLocalError:
     270                                return 'Error: ' + str
     271                        default:
     272                                return null
     273                }
     274        },
     275
     276        /****
     277        *****
     278        ****/
    262279
    263280        /**
     
    266283         * @return true if it passes the test, false if it fails
    267284         */
    268         test: function( filter, search )
    269         {
    270                 var pass = false;
    271                 var s = this.state( );
    272 
    273                 switch( filter )
     285        test: function(filter, search)
     286        {
     287                var pass = false
     288                var s = this.getStatus()
     289
     290                switch(filter)
    274291                {
    275292                        case Prefs._FilterActive:
    276                                 pass = this.isActiveFilter();
    277                                 break;
     293                                pass = this.getPeersGettingFromUs() > 0
     294                                    || this.getPeersSendingToUs() > 0
     295                                    || this.getWebseedsSendingToUs() > 0
     296                                    || this.isChecking()
     297                                break
    278298                        case Prefs._FilterSeeding:
    279                                 pass = ( s == Torrent._StatusSeed ) || ( s == Torrent._StatusSeedWait );
    280                                 break;
     299                                pass = (s == Torrent._StatusSeed) || (s == Torrent._StatusSeedWait)
     300                                break
    281301                        case Prefs._FilterDownloading:
    282                                 pass = ( s == Torrent._StatusDownload ) || ( s == Torrent._StatusDownloadWait );
    283                                 break;
     302                                pass = (s == Torrent._StatusDownload) || (s == Torrent._StatusDownloadWait)
     303                                break
    284304                        case Prefs._FilterPaused:
    285                                 pass = !this.isActive();
    286                                 break;
     305                                pass = this.isStopped()
     306                                break
    287307                        case Prefs._FilterFinished:
    288                                 pass = this.isFinished();
    289                                 break;
     308                                pass = this.isFinished()
     309                                break
    290310                        default:
    291                                 pass = true;
    292                                 break;
    293                 }
    294 
    295                 if( !pass )
    296                         return false;
    297 
    298                 if( !search || !search.length )
    299                         return pass;
    300 
    301                 return this._name_lc.indexOf( search.toLowerCase() ) !== -1;
     311                                pass = true
     312                                break
     313                }
     314
     315                if(!pass)
     316                        return false
     317
     318                if(!search || !search.length)
     319                        return pass
     320
     321                return this.getCollatedName().indexOf(search.toLowerCase()) !== -1
    302322        }
    303 };
    304 
    305 /** Helper function for Torrent.sortTorrents(). */
    306 Torrent.compareById = function( a, b ) {
    307         return a.id() - b.id();
    308 };
    309 
    310 /** Helper function for sortTorrents(). */
    311 Torrent.compareByName = function( a, b ) {
    312         var i = a._name_lc.compareTo( b._name_lc );
    313         if( i )
    314                 return i;
    315         return Torrent.compareById( a, b );
    316 };
    317 
    318 /** Helper function for sortTorrents(). */
    319 Torrent.compareByQueue = function( a, b )
    320 {
    321         return a.queuePosition( ) - b.queuePosition();
    322 };
    323 
    324 /** Helper function for sortTorrents(). */
    325 Torrent.compareByAge = function( a, b )
    326 {
    327         var a_age = a.dateAdded();
    328         var b_age = b.dateAdded();
    329         if( a_age != b_age )
    330                 return a_age - b_age;
    331 
    332         return Torrent.compareByQueue( a, b );
    333 };
    334 
    335 /** Helper function for sortTorrents(). */
    336 Torrent.compareByState = function( a, b )
    337 {
    338         var a_state = a.state( );
    339         var b_state = b.state( );
    340         if( a_state != b_state )
    341                 return b_state - a_state;
    342 
    343         return Torrent.compareByQueue( a, b );
    344 };
    345 
    346 /** Helper function for sortTorrents(). */
    347 Torrent.compareByActivity = function( a, b )
    348 {
    349         var a_activity = a.activity( );
    350         var b_activity = b.activity( );
    351         if( a_activity != b_activity )
    352                 return a_activity - b_activity;
    353 
    354         return Torrent.compareByState( a, b );
    355 };
    356 
    357 /** Helper function for sortTorrents(). */
    358 Torrent.compareByRatio = function( a, b ) {
    359         var a_ratio = Math.ratio( a._upload_total, a._download_total );
    360         var b_ratio = Math.ratio( b._upload_total, b._download_total );
    361         if( a_ratio != b_ratio )
    362                 return a_ratio - b_ratio;
    363         return Torrent.compareByState( a, b );
    364 };
    365 
    366 Torrent.compareByProgress = function( a, b ) {
    367         if( a.getPercentDone() !== b.getPercentDone() )
    368                 return a.getPercentDone() - b.getPercentDone();
    369         return Torrent.compareByRatio( a, b );
    370 };
     323}
     324
     325
     326/***
     327****
     328****  SORTING
     329****
     330***/
     331
     332Torrent.compareById = function(ta, tb)
     333{
     334        return ta.getId() - tb.getId()
     335}
     336Torrent.compareByName = function(ta, tb)
     337{
     338        var i = ta.getCollatedName().compareTo(tb.getCollatedName())
     339        return i || Torrent.compareById(ta, tb)
     340}
     341Torrent.compareByQueue = function(ta, tb)
     342{
     343        return ta.getQueuePosition() - tb.getQueuePosition()
     344}
     345Torrent.compareByAge = function(ta, tb)
     346{
     347        var a = ta.getDateAdded()
     348        var b = tb.getDateAdded()
     349        return (b - a) || Torrent.compareByQueue(ta, tb)
     350}
     351Torrent.compareByState = function(ta, tb)
     352{
     353        var a = ta.getStatus()
     354        var b = tb.getStatus()
     355        return (b - a) || Torrent.compareByQueue(ta, tb)
     356}
     357Torrent.compareByActivity = function(ta, tb)
     358{
     359        var a = ta.getActivity()
     360        var b = tb.getActivity()
     361        return (a - b) || Torrent.compareByState(ta, tb)
     362}
     363Torrent.compareByRatio = function(a, b)
     364{
     365        var a = Math.ratio(ta.getUploadedEver(), ta.getDownloadedEver())
     366        var b = Math.ratio(tb.getUploadedEver(), tb.getDownloadedEver())
     367        return (a - b) || Torrent.compareByState(ta, tb)
     368}
     369Torrent.compareByProgress = function(ta, tb)
     370{
     371        var a = ta.getPercentDone()
     372        var b = tb.getPercentDone()
     373        return (a - b) || Torrent.compareByRatio(ta, tb)
     374}
    371375
    372376/**
     
    375379 * @param sortDirection Prefs._SortAscending or Prefs._SortDescending
    376380 */
    377 Torrent.sortTorrents = function( torrents, sortMethod, sortDirection )
    378 {
    379         switch( sortMethod )
     381Torrent.sortTorrents = function(torrents, sortMethod, sortDirection)
     382{
     383        switch(sortMethod)
    380384        {
    381385                case Prefs._SortByActivity:
    382                         torrents.sort( this.compareByActivity );
    383                         break;
     386                        torrents.sort(this.compareByActivity)
     387                        break
    384388                case Prefs._SortByAge:
    385                         torrents.sort( this.compareByAge );
    386                         break;
     389                        torrents.sort(this.compareByAge)
     390                        break
    387391                case Prefs._SortByQueue:
    388                         torrents.sort( this.compareByQueue );
    389                         break;
     392                        torrents.sort(this.compareByQueue)
     393                        break
    390394                case Prefs._SortByProgress:
    391                         torrents.sort( this.compareByProgress );
    392                         break;
     395                        torrents.sort(this.compareByProgress)
     396                        break
    393397                case Prefs._SortByState:
    394                         torrents.sort( this.compareByState );
    395                         break;
     398                        torrents.sort(this.compareByState)
     399                        break
    396400                case Prefs._SortByName:
    397                         torrents.sort( this.compareByName );
    398                         break;
     401                        torrents.sort(this.compareByName)
     402                        break
    399403                case Prefs._SortByRatio:
    400                         torrents.sort( this.compareByRatio );
    401                         break;
     404                        torrents.sort(this.compareByRatio)
     405                        break
    402406                default:
    403                         console.warn( "unknown sort method: " + sortMethod );
    404                         break;
     407                        console.warn("unknown sort method: " + sortMethod)
     408                        break
    405409        }
    406410
    407         if( sortDirection === Prefs._SortDescending )
    408                 torrents.reverse( );
    409 
    410         return torrents;
    411 };
     411        if(sortDirection === Prefs._SortDescending)
     412                torrents.reverse()
     413
     414        return torrents
     415}
  • trunk/web/javascript/transmission.js

    r12700 r12702  
    468468                var sel = this.getSelectedTorrents( );
    469469                for( var i=0, tor; tor=sel[i]; ++i )
    470                         delete ret[ tor.id() ];
     470                        delete ret[ tor.getId() ];
    471471                return ret;
    472472        },
     
    863863                var rows = [ ];
    864864                for( var i=0, row; row=this._files[i]; ++i )
    865                         if( row.isEditable() && (torrent._file_model[i].wanted !== wanted) )
     865                        if( row.isEditable() && (torrent._files[i].wanted !== wanted) )
    866866                                rows.push( row );
    867867                if( rows.length > 1 ) {
     
    10201020        updateSelectedData: function()
    10211021        {
    1022                 var ids = jQuery.map(this.getSelectedTorrents( ), function(t) { return t.id(); } );
     1022                var ids = jQuery.map(this.getSelectedTorrents( ), function(t) { return t.getId(); } );
    10231023                if( ids.length > 0 )
    10241024                        this.periodicTorrentUpdate( ids );
     
    13961396
    13971397                name = torrents.length == 1
    1398                         ? torrents[0].name()
     1398                        ? torrents[0].getName()
    13991399                        : torrents.length+' Transfers Selected';
    14001400
    14011401                if( torrents.length == 1 )
    14021402                {
     1403                        var text
    14031404                        var t = torrents[0];
    14041405                        var err = t.getErrorMessage( );
    14051406                        if( err )
    14061407                                error = err;
    1407                         if( t._comment)
    1408                                 comment = t._comment ;
    1409                         if( t._creator )
    1410                                 creator = t._creator ;
    1411                         if( t._download_dir)
    1412                                 download_dir = t._download_dir;
    1413 
    1414                         hash = t.hash();
    1415                         pieces = [ t._pieceCount, 'pieces @', Transmission.fmt.mem(t._pieceSize) ].join(' ');
    1416                         date_created = Transmission.fmt.timestamp( t._creator_date );
     1408                        if(( text = t.getComment()))
     1409                                comment = text
     1410                        if(( text = t.getCreator()))
     1411                                creator = text
     1412                        if(( text = t.getDownloadDir()))
     1413                                download_dir = text
     1414
     1415                        hash = t.getHashString();
     1416                        pieces = [ t.getPieceCount(), 'pieces @', Transmission.fmt.mem(t.getPieceSize()) ].join(' ');
     1417                        date_created = Transmission.fmt.timestamp( t.getDateCreated() );
    14171418                }
    14181419
    14191420                for( var i=0, t; t=torrents[i]; ++i ) {
    1420                         sizeWhenDone         += t._sizeWhenDone;
    1421                         sizeDone             += t._sizeWhenDone - t._leftUntilDone;
    1422                         total_completed      += t.completed();
    1423                         total_verified       += t._verified;
    1424                         total_size           += t.size();
    1425                         total_upload         += t.uploadTotal();
    1426                         total_download       += t.downloadTotal();
    1427                         total_upload_speed   += t.uploadSpeed();
    1428                         total_download_speed += t.downloadSpeed();
    1429                         total_upload_peers   += t.peersGettingFromUs();
    1430                         total_download_peers += t.peersSendingToUs();
    1431                         total_availability   += t._sizeWhenDone - t._leftUntilDone + t._desiredAvailable;
    1432 
    1433                         var s = t.stateStr();
     1421                        var sizeWhenDone = t.getSizeWhenDone()
     1422                        var left = t.getLeftUntilDone()
     1423                        sizeWhenDone         += sizeWhenDone
     1424                        sizeDone             += sizeWhenDone - left;
     1425                        total_completed      += t.getHave();
     1426                        total_verified       += t.getHaveValid();
     1427                        total_size           += t.getTotalSize();
     1428                        total_upload         += t.getUploadedEver();
     1429                        total_download       += t.getDownloadedEver();
     1430                        total_upload_speed   += t.getUploadSpeed();
     1431                        total_download_speed += t.getDownloadSpeed();
     1432                        total_upload_peers   += t.getPeersGettingFromUs();
     1433                        total_download_peers += t.getPeersSendingToUs();
     1434                        total_availability   += sizeWhenDone - left + t.getDesiredAvailable();
     1435
     1436                        var s = t.getStateString();
    14341437                        if( total_state.indexOf( s ) == -1 )
    14351438                                total_state.push( s );
    14361439
    1437                         if( t._is_private )
     1440                        if( t.getPrivateFlag( ) )
    14381441                                have_private = true;
    14391442                        else
     
    15161519                this.clearFileList( );
    15171520                this._files_torrent = torrent;
    1518                 var n = torrent._file_model.length;
     1521                var n = torrent._files.length;
    15191522                this._files = new Array( n );
    15201523                var fragment = document.createDocumentFragment( );
     
    15421545                if( $(this._inspector_peers_list).is(':visible') ) {
    15431546                        for( var k=0, torrent; torrent=torrents[k]; ++k ) {
     1547                                var peers = torrent.getPeers()
    15441548                                html.push( '<div class="inspector_group">' );
    15451549                                if( torrents.length > 1 ) {
    1546                                         html.push( '<div class="inspector_torrent_label">', torrent._name, '</div>' );
     1550                                        html.push( '<div class="inspector_torrent_label">', torrent.getName(), '</div>' );
    15471551                                }
    1548                                 if( torrent._peers.length == 0 ) {
     1552                                if( peers.length == 0 ) {
    15491553                                        html.push( '<br></div>' ); // firefox won't paint the top border if the div is empty
    15501554                                        continue;
     
    15601564                                           '<th class="clientCol">Client</th>',
    15611565                                           '</tr>' );
    1562                                 for( var i=0, peer; peer=torrent._peers[i]; ++i ) {
     1566                                for( var i=0, peer; peer=peers[i]; ++i ) {
    15631567                                        var parity = ((i+1) % 2 == 0 ? 'even' : 'odd');
    15641568                                        html.push( '<tr class="inspector_peer_entry ', parity, '">',
     
    15891593                                html.push( '<div class="inspector_group">' );
    15901594                                if( torrents.length > 1 ) {
    1591                                         html.push( '<div class="inspector_torrent_label">', torrent._name, '</div>' );
     1595                                        html.push( '<div class="inspector_torrent_label">', torrent.getName(), '</div>' );
    15921596                                }
    15931597                                for( var i=0, tier; tier=torrent._trackerStats[i]; ++i ) {
     
    17711775                                t.refreshMetaData( this );
    17721776                                if( selected_torrents.indexOf(t) != -1 )
    1773                                         refresh_files_for.push( t.id( ) );
     1777                                        refresh_files_for.push( t.getId( ) );
    17741778                        }
    17751779                } );
     
    17991803                                t.refresh(o);
    18001804                                if( selected_torrents.indexOf(t) != -1 )
    1801                                         refresh_files_for.push(t.id());
     1805                                        refresh_files_for.push(t.getId());
    18021806                        }
    18031807                }
     
    18231827                        var t = this._torrents[o.id];
    18241828                        if( t !== null ) {
    1825                                 t.refreshFileModel( o );
     1829                                t.refreshFiles( o );
    18261830                                if( t === this._files_torrent )
    18271831                                        this.refreshFileView();
     
    18891893                for( var i=0, row; row=new_torrents[i]; ++i ) {
    18901894                        var t = new Torrent( this, row );
    1891                         this._torrents[t.id()] = t;
     1895                        this._torrents[t.getId()] = t;
    18921896                }
    18931897
     
    18961900
    18971901        deleteTorrents: function(torrent_ids){
     1902
    18981903                if(typeof torrent_ids == 'undefined')
    1899                         return false;
    1900                 var tr = this;
    1901                 var removedAny = false;
    1902                 $.each( torrent_ids, function(index, id){
    1903                         var torrent = tr._torrents[id];
    1904 
    1905                         if(torrent) {
    1906                                 removedAny = true;
    1907                                 var e = torrent.view;
    1908                                 if( e ) {
    1909                                         var row_index;
    1910                                         for( var i=0, row; row = tr._rows[i]; ++i ) {
    1911                                                 if( row._id == torrent._id )
    1912                                                 {
    1913                                                         row_index = i;
    1914                                                         e = tr._rows[row_index];
    1915                                                         break;
    1916                                                 }
    1917                                         }
    1918                                         delete e._torrent; //remove circular refernce to help IE garbage collect
    1919                                         tr._rows.splice(row_index, 1)
    1920                                         e.remove();
    1921                                 }
    1922 
    1923                                 delete tr._torrents[torrent.id()];
     1904                        return false
     1905
     1906                var keep = [ ]
     1907                var elements = [ ]
     1908
     1909                for(var i=0, row; row=this._rows[i]; ++i) {
     1910                        var tor = row.getTorrent()
     1911                        var tid = tor ? tor.getId() : -1
     1912                        if( torrent_ids.indexOf( tid ) == -1 )
     1913                                keep.push( row )
     1914                        else {
     1915                                delete this._torrents[ tid ]
     1916                                $(row.getElement()).remove()
    19241917                        }
    1925                 });
    1926 
    1927                 return removedAny;
     1918                }
     1919
     1920                this._rows = keep
     1921
     1922                return remove.length > 0
    19281923        },
    19291924
     
    19551950                var downSpeed = 0;
    19561951                for( var i=0, row; row=torrents[i]; ++i ) {
    1957                         upSpeed += row.uploadSpeed( );
    1958                         downSpeed += row.downloadSpeed( );
     1952                        upSpeed += row.getUploadSpeed( );
     1953                        downSpeed += row.getDownloadSpeed( );
    19591954                }
    19601955
     
    20352030                {
    20362031                        var torrent = torrents[0];
    2037                         var header = 'Remove ' + torrent.name() + '?';
     2032                        var header = 'Remove ' + torrent.getName() + '?';
    20382033                        var message = 'Once removed, continuing the transfer will require the torrent file. Are you sure you want to remove it?';
    20392034                        dialog.confirm( header, message, 'Remove', 'transmission.removeTorrents', torrents );
     
    20522047                {
    20532048                        var torrent = torrents[0],
    2054                                 header = 'Remove ' + torrent.name() + ' and delete data?',
     2049                                header = 'Remove ' + torrent.getName() + ' and delete data?',
    20552050                                message = 'All data downloaded for this torrent will be deleted. Are you sure you want to remove it?';
    20562051                        dialog.confirm( header, message, 'Remove', 'transmission.removeTorrentsAndData', torrents );
     
    20652060
    20662061        removeTorrents: function( torrents ) {
    2067                 var torrent_ids = jQuery.map(torrents, function(t) { return t.id(); } );
     2062                var torrent_ids = jQuery.map(torrents, function(t) { return t.getId(); } );
    20682063                var tr = this;
    20692064                this.remote.removeTorrents( torrent_ids, function(){ tr.refreshTorrents() } );
     
    20922087        },
    20932088        startTorrents: function( torrents, force ) {
    2094                 var torrent_ids = jQuery.map(torrents, function(t) { return t.id(); } );
     2089                var torrent_ids = jQuery.map(torrents, function(t) { return t.getId(); } );
    20952090                var tr = this;
    20962091                this.remote.startTorrents( torrent_ids, force, function(){ tr.refreshTorrents(torrent_ids) } );
     
    21002095        },
    21012096        verifyTorrents: function( torrents ) {
    2102                 var torrent_ids = jQuery.map(torrents, function(t) { return t.id(); } );
     2097                var torrent_ids = jQuery.map(torrents, function(t) { return t.getId(); } );
    21032098                var tr = this;
    21042099                this.remote.verifyTorrents( torrent_ids, function(){ tr.refreshTorrents(torrent_ids) } );
     
    21092104        },
    21102105        reannounceTorrents: function( torrents ) {
    2111                 var torrent_ids = jQuery.map(torrents, function(t) { return t.id(); } );
     2106                var torrent_ids = jQuery.map(torrents, function(t) { return t.getId(); } );
    21122107                var tr = this;
    21132108                this.remote.reannounceTorrents( torrent_ids, function(){ tr.refreshTorrents(torrent_ids) } );
     
    21242119        },
    21252120        stopTorrents: function( torrents ) {
    2126                 var torrent_ids = jQuery.map(torrents, function(t) { return t.id(); } );
     2121                var torrent_ids = jQuery.map(torrents, function(t) { return t.getId(); } );
    21272122                var tr = this;
    21282123                this.remote.stopTorrents( torrent_ids,  function(){ tr.refreshTorrents(torrent_ids )} );
     
    21492144        // Queue
    21502145        moveTop: function( ) {
    2151                 var torrent_ids = jQuery.map(this.getSelectedTorrents( ), function(t) { return t.id(); } );
     2146                var torrent_ids = jQuery.map(this.getSelectedTorrents( ), function(t) { return t.getId(); } );
    21522147                var tr = this;
    21532148                this.remote.moveTorrentsToTop( torrent_ids, function(){ tr.refreshTorrents(torrent_ids )} );
    21542149        },
    21552150        moveUp: function( ) {
    2156                 var torrent_ids = jQuery.map(this.getSelectedTorrents( ), function(t) { return t.id(); } );
     2151                var torrent_ids = jQuery.map(this.getSelectedTorrents( ), function(t) { return t.getId(); } );
    21572152                var tr = this;
    21582153                this.remote.moveTorrentsUp( torrent_ids, function(){ tr.refreshTorrents(torrent_ids )} );
    21592154        },
    21602155        moveDown: function( ) {
    2161                 var torrent_ids = jQuery.map(this.getSelectedTorrents( ), function(t) { return t.id(); } );
     2156                var torrent_ids = jQuery.map(this.getSelectedTorrents( ), function(t) { return t.getId(); } );
    21622157                var tr = this;
    21632158                this.remote.moveTorrentsDown( torrent_ids, function(){ tr.refreshTorrents(torrent_ids )} );
    21642159        },
    21652160        moveBottom: function( ) {
    2166                 var torrent_ids = jQuery.map(this.getSelectedTorrents( ), function(t) { return t.id(); } );
     2161                var torrent_ids = jQuery.map(this.getSelectedTorrents( ), function(t) { return t.getId(); } );
    21672162                var tr = this;
    21682163                this.remote.moveTorrentsToBottom( torrent_ids, function(){ tr.refreshTorrents(torrent_ids )} );
     
    22632258                        for( var i=0, row; row=this._rows[i]; ++i ) {
    22642259                                if( row.isVisible( ) ) {
    2265                                         var isActive = row.getTorrent().isActive( );
     2260                                        var isStopped = row.getTorrent().isStopped( );
    22662261                                        var isSelected = row.isSelected();
    2267                                         if( isActive ) haveActive = true;
    2268                                         if( !isActive ) havePaused = true;
     2262                                        if( !isStopped ) haveActive = true;
     2263                                        if( isStopped ) havePaused = true;
    22692264                                        if( isSelected ) haveSelection = true;
    2270                                         if( isSelected && isActive ) haveActiveSelection = true;
    2271                                         if( isSelected && !isActive ) havePausedSelection = true;
     2265                                        if( isSelected && !isStopped ) haveActiveSelection = true;
     2266                                        if( isSelected && isStopped ) havePausedSelection = true;
    22722267                                }
    22732268                        }
  • trunk/web/javascript/transmission.remote.js

    r12690 r12702  
    192192        changeFileCommand: function( command, rows ) {
    193193                var remote = this;
    194                 var torrent_ids = [ rows[0].getTorrent().id() ];
     194                var torrent_ids = [ rows[0].getTorrent().getId() ];
    195195                var files = [ ];
    196196                for( var i=0, row; row=rows[i]; ++i )
     
    245245                if( torrents != null )
    246246                        for( var i=0, len=torrents.length; i<len; ++i )
    247                                 o.arguments.ids.push( torrents[i].id() );
     247                                o.arguments.ids.push( torrents[i].getId() );
    248248                this.sendRequest( o, function( ) {
    249249                        remote._controller.refreshTorrents();
Note: See TracChangeset for help on using the changeset viewer.