1 | /****************************************************************************** |
---|
2 | * $Id: Torrent.m 7508 2008-12-26 05:57:51Z livings124 $ |
---|
3 | * |
---|
4 | * Copyright (c) 2006-2008 Transmission authors and contributors |
---|
5 | * |
---|
6 | * Permission is hereby granted, free of charge, to any person obtaining a |
---|
7 | * copy of this software and associated documentation files (the "Software"), |
---|
8 | * to deal in the Software without restriction, including without limitation |
---|
9 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
---|
10 | * and/or sell copies of the Software, and to permit persons to whom the |
---|
11 | * Software is furnished to do so, subject to the following conditions: |
---|
12 | * |
---|
13 | * The above copyright notice and this permission notice shall be included in |
---|
14 | * all copies or substantial portions of the Software. |
---|
15 | * |
---|
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
---|
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
---|
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
---|
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
---|
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
---|
21 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
---|
22 | * DEALINGS IN THE SOFTWARE. |
---|
23 | *****************************************************************************/ |
---|
24 | |
---|
25 | #import "Torrent.h" |
---|
26 | #import "GroupsController.h" |
---|
27 | #import "FileListNode.h" |
---|
28 | #import "NSStringAdditions.h" |
---|
29 | #import "utils.h" //tr_httpIsValidURL |
---|
30 | |
---|
31 | @interface Torrent (Private) |
---|
32 | |
---|
33 | - (id) initWithHash: (NSString *) hashString path: (NSString *) path torrentStruct: (tr_torrent *) torrentStruct lib: (tr_session *) lib |
---|
34 | publicTorrent: (NSNumber *) publicTorrent |
---|
35 | downloadFolder: (NSString *) downloadFolder |
---|
36 | useIncompleteFolder: (NSNumber *) useIncompleteFolder incompleteFolder: (NSString *) incompleteFolder |
---|
37 | ratioSetting: (NSNumber *) ratioSetting ratioLimit: (NSNumber *) ratioLimit |
---|
38 | waitToStart: (NSNumber *) waitToStart |
---|
39 | orderValue: (NSNumber *) orderValue groupValue: (NSNumber *) groupValue addedTrackers: (NSNumber *) addedTrackers; |
---|
40 | |
---|
41 | - (BOOL) shouldUseIncompleteFolderForName: (NSString *) name; |
---|
42 | - (void) updateDownloadFolder; |
---|
43 | |
---|
44 | - (void) createFileList; |
---|
45 | - (void) insertPath: (NSMutableArray *) components forParent: (FileListNode *) parent fileSize: (uint64_t) size |
---|
46 | index: (NSInteger) index flatList: (NSMutableArray *) flatFileList; |
---|
47 | |
---|
48 | - (void) completenessChange: (NSNumber *) status; |
---|
49 | |
---|
50 | - (void) quickPause; |
---|
51 | - (void) endQuickPause; |
---|
52 | |
---|
53 | - (NSString *) etaString: (NSInteger) eta; |
---|
54 | |
---|
55 | - (void) updateAllTrackers: (NSMutableArray *) trackers; |
---|
56 | |
---|
57 | + (void) trashFile: (NSString *) path; |
---|
58 | |
---|
59 | - (void) setTimeMachineExclude: (BOOL) exclude forPath: (NSString *) path; |
---|
60 | |
---|
61 | @end |
---|
62 | |
---|
63 | void completenessChangeCallback(tr_torrent * torrent, tr_completeness status, void * torrentData) |
---|
64 | { |
---|
65 | [(Torrent *)torrentData performSelectorOnMainThread: @selector(completenessChange:) |
---|
66 | withObject: [[NSNumber alloc] initWithInt: status] waitUntilDone: NO]; |
---|
67 | } |
---|
68 | |
---|
69 | int trashDataFile(const char * filename) |
---|
70 | { |
---|
71 | [Torrent trashFile: [NSString stringWithUTF8String: filename]]; |
---|
72 | return 0; |
---|
73 | } |
---|
74 | |
---|
75 | @implementation Torrent |
---|
76 | |
---|
77 | - (id) initWithPath: (NSString *) path location: (NSString *) location deleteTorrentFile: (torrentFileState) torrentDelete |
---|
78 | lib: (tr_session *) lib |
---|
79 | { |
---|
80 | self = [self initWithHash: nil path: path torrentStruct: NULL lib: lib |
---|
81 | publicTorrent: torrentDelete != TORRENT_FILE_DEFAULT ? [NSNumber numberWithBool: torrentDelete == TORRENT_FILE_SAVE] : nil |
---|
82 | downloadFolder: location |
---|
83 | useIncompleteFolder: nil incompleteFolder: nil |
---|
84 | ratioSetting: nil ratioLimit: nil |
---|
85 | waitToStart: nil orderValue: nil groupValue: nil addedTrackers: nil]; |
---|
86 | |
---|
87 | if (self) |
---|
88 | { |
---|
89 | //if the public and private torrent files are the same, then there is no public torrent |
---|
90 | if ([[self torrentLocation] isEqualToString: path]) |
---|
91 | { |
---|
92 | fPublicTorrent = NO; |
---|
93 | [fPublicTorrentLocation release]; |
---|
94 | fPublicTorrentLocation = nil; |
---|
95 | } |
---|
96 | else if (!fPublicTorrent) |
---|
97 | [Torrent trashFile: path]; |
---|
98 | else; |
---|
99 | } |
---|
100 | return self; |
---|
101 | } |
---|
102 | |
---|
103 | - (id) initWithTorrentStruct: (tr_torrent *) torrentStruct location: (NSString *) location lib: (tr_session *) lib |
---|
104 | { |
---|
105 | self = [self initWithHash: nil path: nil torrentStruct: torrentStruct lib: lib |
---|
106 | publicTorrent: [NSNumber numberWithBool: NO] |
---|
107 | downloadFolder: location |
---|
108 | useIncompleteFolder: nil incompleteFolder: nil |
---|
109 | ratioSetting: nil ratioLimit: nil |
---|
110 | waitToStart: nil orderValue: nil groupValue: nil addedTrackers: nil]; |
---|
111 | |
---|
112 | return self; |
---|
113 | } |
---|
114 | |
---|
115 | - (id) initWithHistory: (NSDictionary *) history lib: (tr_session *) lib |
---|
116 | { |
---|
117 | self = [self initWithHash: [history objectForKey: @"TorrentHash"] |
---|
118 | path: [history objectForKey: @"TorrentPath"] torrentStruct: NULL lib: lib |
---|
119 | publicTorrent: [history objectForKey: @"PublicCopy"] |
---|
120 | downloadFolder: [history objectForKey: @"DownloadFolder"] |
---|
121 | useIncompleteFolder: [history objectForKey: @"UseIncompleteFolder"] |
---|
122 | incompleteFolder: [history objectForKey: @"IncompleteFolder"] |
---|
123 | ratioSetting: [history objectForKey: @"RatioSetting"] |
---|
124 | ratioLimit: [history objectForKey: @"RatioLimit"] |
---|
125 | waitToStart: [history objectForKey: @"WaitToStart"] |
---|
126 | orderValue: [history objectForKey: @"OrderValue"] |
---|
127 | groupValue: [history objectForKey: @"GroupValue"] |
---|
128 | addedTrackers: [history objectForKey: @"AddedTrackers"]]; |
---|
129 | |
---|
130 | if (self) |
---|
131 | { |
---|
132 | //start transfer |
---|
133 | NSNumber * active; |
---|
134 | if ((active = [history objectForKey: @"Active"]) && [active boolValue]) |
---|
135 | { |
---|
136 | fStat = tr_torrentStat(fHandle); |
---|
137 | [self startTransfer]; |
---|
138 | } |
---|
139 | |
---|
140 | //upgrading from versions < 1.30: get old added, activity, and done dates |
---|
141 | NSDate * date; |
---|
142 | if ((date = [history objectForKey: @"Date"])) |
---|
143 | tr_torrentSetAddedDate(fHandle, [date timeIntervalSince1970]); |
---|
144 | if ((date = [history objectForKey: @"DateActivity"])) |
---|
145 | tr_torrentSetActivityDate(fHandle, [date timeIntervalSince1970]); |
---|
146 | if ((date = [history objectForKey: @"DateCompleted"])) |
---|
147 | tr_torrentSetDoneDate(fHandle, [date timeIntervalSince1970]); |
---|
148 | } |
---|
149 | return self; |
---|
150 | } |
---|
151 | |
---|
152 | - (NSDictionary *) history |
---|
153 | { |
---|
154 | NSMutableDictionary * history = [NSMutableDictionary dictionaryWithObjectsAndKeys: |
---|
155 | [NSNumber numberWithBool: fPublicTorrent], @"PublicCopy", |
---|
156 | [self hashString], @"TorrentHash", |
---|
157 | fDownloadFolder, @"DownloadFolder", |
---|
158 | [NSNumber numberWithBool: fUseIncompleteFolder], @"UseIncompleteFolder", |
---|
159 | [NSNumber numberWithBool: [self isActive]], @"Active", |
---|
160 | [NSNumber numberWithInt: fRatioSetting], @"RatioSetting", |
---|
161 | [NSNumber numberWithFloat: fRatioLimit], @"RatioLimit", |
---|
162 | [NSNumber numberWithBool: fWaitToStart], @"WaitToStart", |
---|
163 | [NSNumber numberWithInt: fOrderValue], @"OrderValue", |
---|
164 | [NSNumber numberWithInt: fGroupValue], @"GroupValue", |
---|
165 | [NSNumber numberWithBool: fAddedTrackers], @"AddedTrackers", nil]; |
---|
166 | |
---|
167 | if (fIncompleteFolder) |
---|
168 | [history setObject: fIncompleteFolder forKey: @"IncompleteFolder"]; |
---|
169 | |
---|
170 | if (fPublicTorrent) |
---|
171 | [history setObject: [self publicTorrentLocation] forKey: @"TorrentPath"]; |
---|
172 | |
---|
173 | return history; |
---|
174 | } |
---|
175 | |
---|
176 | - (void) dealloc |
---|
177 | { |
---|
178 | [[NSNotificationCenter defaultCenter] removeObserver: self]; |
---|
179 | |
---|
180 | if (fFileStat) |
---|
181 | tr_torrentFilesFree(fFileStat, [self fileCount]); |
---|
182 | |
---|
183 | [fPreviousFinishedIndexes release]; |
---|
184 | [fPreviousFinishedIndexesDate release]; |
---|
185 | |
---|
186 | [fNameString release]; |
---|
187 | [fHashString release]; |
---|
188 | |
---|
189 | [fDownloadFolder release]; |
---|
190 | [fIncompleteFolder release]; |
---|
191 | |
---|
192 | [fPublicTorrentLocation release]; |
---|
193 | |
---|
194 | [fIcon release]; |
---|
195 | |
---|
196 | [fFileList release]; |
---|
197 | [fFlatFileList release]; |
---|
198 | |
---|
199 | [fQuickPauseDict release]; |
---|
200 | |
---|
201 | [super dealloc]; |
---|
202 | } |
---|
203 | |
---|
204 | - (NSString *) description |
---|
205 | { |
---|
206 | return [@"Torrent: " stringByAppendingString: [self name]]; |
---|
207 | } |
---|
208 | |
---|
209 | - (void) closeRemoveTorrent |
---|
210 | { |
---|
211 | //allow the file to be index by Time Machine |
---|
212 | [self setTimeMachineExclude: NO forPath: [[self downloadFolder] stringByAppendingPathComponent: [self name]]]; |
---|
213 | |
---|
214 | tr_torrentRemove(fHandle); |
---|
215 | } |
---|
216 | |
---|
217 | - (void) changeIncompleteDownloadFolder: (NSString *) folder |
---|
218 | { |
---|
219 | fUseIncompleteFolder = folder != nil; |
---|
220 | |
---|
221 | [fIncompleteFolder release]; |
---|
222 | fIncompleteFolder = fUseIncompleteFolder ? [folder retain] : nil; |
---|
223 | |
---|
224 | [self updateDownloadFolder]; |
---|
225 | } |
---|
226 | |
---|
227 | - (void) changeDownloadFolder: (NSString *) folder |
---|
228 | { |
---|
229 | if (fDownloadFolder && [folder isEqualToString: fDownloadFolder]) |
---|
230 | return; |
---|
231 | |
---|
232 | [fDownloadFolder release]; |
---|
233 | fDownloadFolder = [folder retain]; |
---|
234 | |
---|
235 | [self updateDownloadFolder]; |
---|
236 | } |
---|
237 | |
---|
238 | - (NSString *) downloadFolder |
---|
239 | { |
---|
240 | return [NSString stringWithUTF8String: tr_torrentGetDownloadDir(fHandle)]; |
---|
241 | } |
---|
242 | |
---|
243 | - (void) getAvailability: (int8_t *) tab size: (NSInteger) size |
---|
244 | { |
---|
245 | tr_torrentAvailability(fHandle, tab, size); |
---|
246 | } |
---|
247 | |
---|
248 | - (void) getAmountFinished: (float *) tab size: (NSInteger) size |
---|
249 | { |
---|
250 | tr_torrentAmountFinished(fHandle, tab, size); |
---|
251 | } |
---|
252 | |
---|
253 | - (NSIndexSet *) previousFinishedPieces |
---|
254 | { |
---|
255 | //if the torrent hasn't been seen in a bit, and therefore hasn't been refreshed, return nil |
---|
256 | if (fPreviousFinishedIndexesDate && [fPreviousFinishedIndexesDate timeIntervalSinceNow] > -2.0) |
---|
257 | return fPreviousFinishedIndexes; |
---|
258 | else |
---|
259 | return nil; |
---|
260 | } |
---|
261 | |
---|
262 | -(void) setPreviousFinishedPieces: (NSIndexSet *) indexes |
---|
263 | { |
---|
264 | [fPreviousFinishedIndexes release]; |
---|
265 | fPreviousFinishedIndexes = [indexes retain]; |
---|
266 | |
---|
267 | [fPreviousFinishedIndexesDate release]; |
---|
268 | fPreviousFinishedIndexesDate = indexes != nil ? [[NSDate alloc] init] : nil; |
---|
269 | } |
---|
270 | |
---|
271 | - (void) update |
---|
272 | { |
---|
273 | //get previous status values before update |
---|
274 | BOOL wasChecking = NO, wasError = NO, wasStalled = NO; |
---|
275 | if (fStat != NULL) |
---|
276 | { |
---|
277 | wasChecking = [self isChecking]; |
---|
278 | wasError = [self isError]; |
---|
279 | wasStalled = fStalled; |
---|
280 | } |
---|
281 | |
---|
282 | fStat = tr_torrentStat(fHandle); |
---|
283 | |
---|
284 | //check to stop for ratio |
---|
285 | CGFloat stopRatio; |
---|
286 | if ([self isSeeding] && (stopRatio = [self actualStopRatio]) != INVALID && [self ratio] >= stopRatio) |
---|
287 | { |
---|
288 | [self setRatioSetting: NSOffState]; |
---|
289 | [[NSNotificationCenter defaultCenter] postNotificationName: @"TorrentStoppedForRatio" object: self]; |
---|
290 | |
---|
291 | [self stopTransfer]; |
---|
292 | fStat = tr_torrentStat(fHandle); |
---|
293 | |
---|
294 | fFinishedSeeding = YES; |
---|
295 | } |
---|
296 | |
---|
297 | //check if stalled (stored because based on time and needs to check if it was previously stalled) |
---|
298 | fStalled = [self isActive] && [fDefaults boolForKey: @"CheckStalled"] |
---|
299 | && [self stalledMinutes] > [fDefaults integerForKey: @"StalledMinutes"]; |
---|
300 | |
---|
301 | //update queue for checking (from downloading to seeding), stalled, or error |
---|
302 | if ((wasChecking && ![self isChecking]) || (wasStalled != fStalled) || (!wasError && [self isError] && [self isActive])) |
---|
303 | [[NSNotificationCenter defaultCenter] postNotificationName: @"UpdateQueue" object: self]; |
---|
304 | } |
---|
305 | |
---|
306 | - (void) startTransfer |
---|
307 | { |
---|
308 | fWaitToStart = NO; |
---|
309 | fFinishedSeeding = NO; |
---|
310 | |
---|
311 | if (![self isActive] && [self alertForFolderAvailable] && [self alertForRemainingDiskSpace]) |
---|
312 | { |
---|
313 | tr_torrentStart(fHandle); |
---|
314 | [self update]; |
---|
315 | } |
---|
316 | } |
---|
317 | |
---|
318 | - (void) stopTransfer |
---|
319 | { |
---|
320 | fWaitToStart = NO; |
---|
321 | |
---|
322 | if ([self isActive]) |
---|
323 | { |
---|
324 | tr_torrentStop(fHandle); |
---|
325 | [self update]; |
---|
326 | |
---|
327 | [[NSNotificationCenter defaultCenter] postNotificationName: @"UpdateQueue" object: self]; |
---|
328 | } |
---|
329 | } |
---|
330 | |
---|
331 | - (void) sleep |
---|
332 | { |
---|
333 | if ((fResumeOnWake = [self isActive])) |
---|
334 | tr_torrentStop(fHandle); |
---|
335 | } |
---|
336 | |
---|
337 | - (void) wakeUp |
---|
338 | { |
---|
339 | if (fResumeOnWake) |
---|
340 | tr_torrentStart(fHandle); |
---|
341 | } |
---|
342 | |
---|
343 | - (void) manualAnnounce |
---|
344 | { |
---|
345 | tr_torrentManualUpdate(fHandle); |
---|
346 | } |
---|
347 | |
---|
348 | - (BOOL) canManualAnnounce |
---|
349 | { |
---|
350 | return tr_torrentCanManualUpdate(fHandle); |
---|
351 | } |
---|
352 | |
---|
353 | - (void) resetCache |
---|
354 | { |
---|
355 | tr_torrentVerify(fHandle); |
---|
356 | [self update]; |
---|
357 | } |
---|
358 | |
---|
359 | - (CGFloat) ratio |
---|
360 | { |
---|
361 | return fStat->ratio; |
---|
362 | } |
---|
363 | |
---|
364 | - (NSInteger) ratioSetting |
---|
365 | { |
---|
366 | return fRatioSetting; |
---|
367 | } |
---|
368 | |
---|
369 | - (void) setRatioSetting: (NSInteger) setting |
---|
370 | { |
---|
371 | fRatioSetting = setting; |
---|
372 | } |
---|
373 | |
---|
374 | - (CGFloat) ratioLimit |
---|
375 | { |
---|
376 | return fRatioLimit; |
---|
377 | } |
---|
378 | |
---|
379 | - (void) setRatioLimit: (CGFloat) limit |
---|
380 | { |
---|
381 | if (limit >= 0) |
---|
382 | fRatioLimit = limit; |
---|
383 | } |
---|
384 | |
---|
385 | - (CGFloat) actualStopRatio |
---|
386 | { |
---|
387 | if (fRatioSetting == NSOnState) |
---|
388 | return fRatioLimit; |
---|
389 | else if (fRatioSetting == NSMixedState && [fDefaults boolForKey: @"RatioCheck"]) |
---|
390 | return [fDefaults floatForKey: @"RatioLimit"]; |
---|
391 | else |
---|
392 | return INVALID; |
---|
393 | } |
---|
394 | |
---|
395 | - (CGFloat) progressStopRatio |
---|
396 | { |
---|
397 | CGFloat stopRatio, ratio; |
---|
398 | if ((stopRatio = [self actualStopRatio]) == INVALID || (ratio = [self ratio]) >= stopRatio) |
---|
399 | return 1.0; |
---|
400 | else if (stopRatio > 0.0) |
---|
401 | return ratio / stopRatio; |
---|
402 | else |
---|
403 | return 0.0; |
---|
404 | } |
---|
405 | |
---|
406 | - (tr_speedlimit) speedMode: (BOOL) upload |
---|
407 | { |
---|
408 | return tr_torrentGetSpeedMode(fHandle, upload ? TR_UP : TR_DOWN); |
---|
409 | } |
---|
410 | |
---|
411 | - (void) setSpeedMode: (tr_speedlimit) mode upload: (BOOL) upload |
---|
412 | { |
---|
413 | tr_torrentSetSpeedMode(fHandle, upload ? TR_UP : TR_DOWN, mode); |
---|
414 | } |
---|
415 | |
---|
416 | - (NSInteger) speedLimit: (BOOL) upload |
---|
417 | { |
---|
418 | return tr_torrentGetSpeedLimit(fHandle, upload ? TR_UP : TR_DOWN); |
---|
419 | } |
---|
420 | |
---|
421 | - (void) setSpeedLimit: (NSInteger) limit upload: (BOOL) upload |
---|
422 | { |
---|
423 | tr_torrentSetSpeedLimit(fHandle, upload ? TR_UP : TR_DOWN, limit); |
---|
424 | } |
---|
425 | |
---|
426 | - (void) setMaxPeerConnect: (uint16_t) count |
---|
427 | { |
---|
428 | NSAssert(count > 0, @"max peer count must be greater than 0"); |
---|
429 | |
---|
430 | tr_torrentSetPeerLimit(fHandle, count); |
---|
431 | } |
---|
432 | |
---|
433 | - (uint16_t) maxPeerConnect |
---|
434 | { |
---|
435 | return tr_torrentGetPeerLimit(fHandle); |
---|
436 | } |
---|
437 | |
---|
438 | - (void) setWaitToStart: (BOOL) wait |
---|
439 | { |
---|
440 | fWaitToStart = wait; |
---|
441 | } |
---|
442 | |
---|
443 | - (BOOL) waitingToStart |
---|
444 | { |
---|
445 | return fWaitToStart; |
---|
446 | } |
---|
447 | |
---|
448 | - (void) revealData |
---|
449 | { |
---|
450 | [[NSWorkspace sharedWorkspace] selectFile: [self dataLocation] inFileViewerRootedAtPath: nil]; |
---|
451 | } |
---|
452 | |
---|
453 | - (void) revealPublicTorrent |
---|
454 | { |
---|
455 | if (fPublicTorrent) |
---|
456 | [[NSWorkspace sharedWorkspace] selectFile: fPublicTorrentLocation inFileViewerRootedAtPath: nil]; |
---|
457 | } |
---|
458 | |
---|
459 | - (void) trashData |
---|
460 | { |
---|
461 | tr_torrentDeleteLocalData(fHandle, trashDataFile); |
---|
462 | } |
---|
463 | |
---|
464 | - (void) trashTorrent |
---|
465 | { |
---|
466 | if (fPublicTorrent) |
---|
467 | { |
---|
468 | [Torrent trashFile: fPublicTorrentLocation]; |
---|
469 | [fPublicTorrentLocation release]; |
---|
470 | fPublicTorrentLocation = nil; |
---|
471 | |
---|
472 | fPublicTorrent = NO; |
---|
473 | } |
---|
474 | } |
---|
475 | |
---|
476 | - (void) moveTorrentDataFileTo: (NSString *) folder |
---|
477 | { |
---|
478 | NSString * oldFolder = [self downloadFolder]; |
---|
479 | if (![oldFolder isEqualToString: folder] || ![fDownloadFolder isEqualToString: folder]) |
---|
480 | { |
---|
481 | //check if moving inside itself |
---|
482 | NSArray * oldComponents = [oldFolder pathComponents], |
---|
483 | * newComponents = [folder pathComponents]; |
---|
484 | NSInteger count; |
---|
485 | |
---|
486 | if ((count = [oldComponents count]) < [newComponents count] |
---|
487 | && [[newComponents objectAtIndex: count] isEqualToString: [self name]] |
---|
488 | && [oldComponents isEqualToArray: |
---|
489 | [newComponents objectsAtIndexes: [NSIndexSet indexSetWithIndexesInRange: NSMakeRange(0, count)]]]) |
---|
490 | { |
---|
491 | NSAlert * alert = [[NSAlert alloc] init]; |
---|
492 | [alert setMessageText: NSLocalizedString(@"A folder cannot be moved to inside itself.", |
---|
493 | "Move inside itself alert -> title")]; |
---|
494 | [alert setInformativeText: [NSString stringWithFormat: |
---|
495 | NSLocalizedString(@"The move operation of \"%@\" cannot be done.", |
---|
496 | "Move inside itself alert -> message"), [self name]]]; |
---|
497 | [alert addButtonWithTitle: NSLocalizedString(@"OK", "Move inside itself alert -> button")]; |
---|
498 | |
---|
499 | [alert runModal]; |
---|
500 | [alert release]; |
---|
501 | |
---|
502 | return; |
---|
503 | } |
---|
504 | |
---|
505 | [self quickPause]; |
---|
506 | |
---|
507 | //allow if file can be moved or does not exist |
---|
508 | if ([[NSFileManager defaultManager] movePath: [oldFolder stringByAppendingPathComponent: [self name]] |
---|
509 | toPath: [folder stringByAppendingPathComponent: [self name]] handler: nil] |
---|
510 | || ![[NSFileManager defaultManager] fileExistsAtPath: [oldFolder stringByAppendingPathComponent: [self name]]]) |
---|
511 | { |
---|
512 | //get rid of both incomplete folder and old download folder, even if move failed |
---|
513 | fUseIncompleteFolder = NO; |
---|
514 | if (fIncompleteFolder) |
---|
515 | { |
---|
516 | [fIncompleteFolder release]; |
---|
517 | fIncompleteFolder = nil; |
---|
518 | } |
---|
519 | [self changeDownloadFolder: folder]; |
---|
520 | |
---|
521 | [[NSNotificationCenter defaultCenter] postNotificationName: @"UpdateStats" object: nil]; |
---|
522 | |
---|
523 | [self endQuickPause]; |
---|
524 | } |
---|
525 | else |
---|
526 | { |
---|
527 | [self endQuickPause]; |
---|
528 | |
---|
529 | NSAlert * alert = [[NSAlert alloc] init]; |
---|
530 | [alert setMessageText: NSLocalizedString(@"There was an error moving the data file.", "Move error alert -> title")]; |
---|
531 | [alert setInformativeText: [NSString stringWithFormat: |
---|
532 | NSLocalizedString(@"The move operation of \"%@\" cannot be done.", |
---|
533 | "Move error alert -> message"), [self name]]]; |
---|
534 | [alert addButtonWithTitle: NSLocalizedString(@"OK", "Move error alert -> button")]; |
---|
535 | |
---|
536 | [alert runModal]; |
---|
537 | [alert release]; |
---|
538 | } |
---|
539 | } |
---|
540 | } |
---|
541 | |
---|
542 | - (void) copyTorrentFileTo: (NSString *) path |
---|
543 | { |
---|
544 | [[NSFileManager defaultManager] copyPath: [self torrentLocation] toPath: path handler: nil]; |
---|
545 | } |
---|
546 | |
---|
547 | - (BOOL) alertForRemainingDiskSpace |
---|
548 | { |
---|
549 | if ([self allDownloaded] || ![fDefaults boolForKey: @"WarningRemainingSpace"]) |
---|
550 | return YES; |
---|
551 | |
---|
552 | NSFileManager * fileManager = [NSFileManager defaultManager]; |
---|
553 | NSString * downloadFolder = [self downloadFolder]; |
---|
554 | |
---|
555 | NSString * volumeName; |
---|
556 | if ((volumeName = [[fileManager componentsToDisplayForPath: downloadFolder] objectAtIndex: 0])) |
---|
557 | { |
---|
558 | NSDictionary * systemAttributes = [fileManager attributesOfFileSystemForPath: downloadFolder error: NULL]; |
---|
559 | uint64_t remainingSpace = [[systemAttributes objectForKey: NSFileSystemFreeSize] unsignedLongLongValue]; |
---|
560 | |
---|
561 | //if the remaining space is greater than the size left, then there is enough space regardless of preallocation |
---|
562 | if (remainingSpace < [self sizeLeft] && remainingSpace < tr_torrentGetBytesLeftToAllocate(fHandle)) |
---|
563 | { |
---|
564 | NSAlert * alert = [[NSAlert alloc] init]; |
---|
565 | [alert setMessageText: [NSString stringWithFormat: |
---|
566 | NSLocalizedString(@"Not enough remaining disk space to download \"%@\" completely.", |
---|
567 | "Torrent disk space alert -> title"), [self name]]]; |
---|
568 | [alert setInformativeText: [NSString stringWithFormat: NSLocalizedString(@"The transfer will be paused." |
---|
569 | " Clear up space on %@ or deselect files in the torrent inspector to continue.", |
---|
570 | "Torrent disk space alert -> message"), volumeName]]; |
---|
571 | [alert addButtonWithTitle: NSLocalizedString(@"OK", "Torrent disk space alert -> button")]; |
---|
572 | [alert addButtonWithTitle: NSLocalizedString(@"Download Anyway", "Torrent disk space alert -> button")]; |
---|
573 | |
---|
574 | [alert setShowsSuppressionButton: YES]; |
---|
575 | [[alert suppressionButton] setTitle: NSLocalizedString(@"Do not check disk space again", |
---|
576 | "Torrent disk space alert -> button")]; |
---|
577 | |
---|
578 | NSInteger result = [alert runModal]; |
---|
579 | if ([[alert suppressionButton] state] == NSOnState) |
---|
580 | [fDefaults setBool: NO forKey: @"WarningRemainingSpace"]; |
---|
581 | [alert release]; |
---|
582 | |
---|
583 | return result != NSAlertFirstButtonReturn; |
---|
584 | } |
---|
585 | } |
---|
586 | return YES; |
---|
587 | } |
---|
588 | |
---|
589 | - (BOOL) alertForFolderAvailable |
---|
590 | { |
---|
591 | #warning check for change from incomplete to download folder first |
---|
592 | if (access(tr_torrentGetDownloadDir(fHandle), 0)) |
---|
593 | { |
---|
594 | NSAlert * alert = [[NSAlert alloc] init]; |
---|
595 | [alert setMessageText: [NSString stringWithFormat: |
---|
596 | NSLocalizedString(@"The folder for downloading \"%@\" cannot be used.", |
---|
597 | "Folder cannot be used alert -> title"), [self name]]]; |
---|
598 | [alert setInformativeText: [NSString stringWithFormat: |
---|
599 | NSLocalizedString(@"\"%@\" cannot be used. The transfer will be paused.", |
---|
600 | "Folder cannot be used alert -> message"), [self downloadFolder]]]; |
---|
601 | [alert addButtonWithTitle: NSLocalizedString(@"OK", "Folder cannot be used alert -> button")]; |
---|
602 | [alert addButtonWithTitle: [NSLocalizedString(@"Choose New Location", |
---|
603 | "Folder cannot be used alert -> location button") stringByAppendingEllipsis]]; |
---|
604 | |
---|
605 | if ([alert runModal] != NSAlertFirstButtonReturn) |
---|
606 | { |
---|
607 | NSOpenPanel * panel = [NSOpenPanel openPanel]; |
---|
608 | |
---|
609 | [panel setPrompt: NSLocalizedString(@"Select", "Folder cannot be used alert -> prompt")]; |
---|
610 | [panel setAllowsMultipleSelection: NO]; |
---|
611 | [panel setCanChooseFiles: NO]; |
---|
612 | [panel setCanChooseDirectories: YES]; |
---|
613 | [panel setCanCreateDirectories: YES]; |
---|
614 | |
---|
615 | [panel setMessage: [NSString stringWithFormat: NSLocalizedString(@"Select the download folder for \"%@\"", |
---|
616 | "Folder cannot be used alert -> select destination folder"), [self name]]]; |
---|
617 | |
---|
618 | [[NSNotificationCenter defaultCenter] postNotificationName: @"MakeWindowKey" object: nil]; |
---|
619 | [panel beginSheetForDirectory: nil file: nil types: nil modalForWindow: [NSApp keyWindow] modalDelegate: self |
---|
620 | didEndSelector: @selector(destinationChoiceClosed:returnCode:contextInfo:) contextInfo: nil]; |
---|
621 | } |
---|
622 | |
---|
623 | [alert release]; |
---|
624 | |
---|
625 | return NO; |
---|
626 | } |
---|
627 | return YES; |
---|
628 | } |
---|
629 | |
---|
630 | - (void) destinationChoiceClosed: (NSOpenPanel *) openPanel returnCode: (NSInteger) code contextInfo: (void *) context |
---|
631 | { |
---|
632 | if (code != NSOKButton) |
---|
633 | return; |
---|
634 | |
---|
635 | [self changeDownloadFolder: [[openPanel filenames] objectAtIndex: 0]]; |
---|
636 | |
---|
637 | [self startTransfer]; |
---|
638 | [self update]; |
---|
639 | |
---|
640 | [[NSNotificationCenter defaultCenter] postNotificationName: @"UpdateStats" object: nil]; |
---|
641 | } |
---|
642 | |
---|
643 | - (BOOL) alertForMoveFolderAvailable |
---|
644 | { |
---|
645 | if (access([fDownloadFolder UTF8String], 0)) |
---|
646 | { |
---|
647 | NSAlert * alert = [[NSAlert alloc] init]; |
---|
648 | [alert setMessageText: [NSString stringWithFormat: |
---|
649 | NSLocalizedString(@"The folder for moving the completed \"%@\" cannot be used.", |
---|
650 | "Move folder cannot be used alert -> title"), [self name]]]; |
---|
651 | [alert setInformativeText: [NSString stringWithFormat: |
---|
652 | NSLocalizedString(@"\"%@\" cannot be used. The file will remain in its current location.", |
---|
653 | "Move folder cannot be used alert -> message"), fDownloadFolder]]; |
---|
654 | [alert addButtonWithTitle: NSLocalizedString(@"OK", "Move folder cannot be used alert -> button")]; |
---|
655 | |
---|
656 | [alert runModal]; |
---|
657 | [alert release]; |
---|
658 | |
---|
659 | return NO; |
---|
660 | } |
---|
661 | |
---|
662 | return YES; |
---|
663 | } |
---|
664 | |
---|
665 | - (NSImage *) icon |
---|
666 | { |
---|
667 | if (!fIcon) |
---|
668 | { |
---|
669 | fIcon = [[[NSWorkspace sharedWorkspace] iconForFileType: [self isFolder] ? NSFileTypeForHFSTypeCode('fldr') |
---|
670 | : [[self name] pathExtension]] retain]; |
---|
671 | [fIcon setFlipped: YES]; |
---|
672 | } |
---|
673 | return fIcon; |
---|
674 | } |
---|
675 | |
---|
676 | - (NSString *) name |
---|
677 | { |
---|
678 | return fNameString; |
---|
679 | } |
---|
680 | |
---|
681 | - (BOOL) isFolder |
---|
682 | { |
---|
683 | return fInfo->isMultifile; |
---|
684 | } |
---|
685 | |
---|
686 | - (uint64_t) size |
---|
687 | { |
---|
688 | return fInfo->totalSize; |
---|
689 | } |
---|
690 | |
---|
691 | - (uint64_t) sizeLeft |
---|
692 | { |
---|
693 | return fStat->leftUntilDone; |
---|
694 | } |
---|
695 | |
---|
696 | - (NSString *) trackerAddressAnnounce |
---|
697 | { |
---|
698 | return fStat->announceURL ? [NSString stringWithUTF8String: fStat->announceURL] : nil; |
---|
699 | } |
---|
700 | |
---|
701 | - (NSDate *) lastAnnounceTime |
---|
702 | { |
---|
703 | NSInteger date = fStat->lastAnnounceTime; |
---|
704 | return date > 0 ? [NSDate dateWithTimeIntervalSince1970: date] : nil; |
---|
705 | } |
---|
706 | |
---|
707 | - (NSInteger) nextAnnounceTime |
---|
708 | { |
---|
709 | NSInteger date = fStat->nextAnnounceTime; |
---|
710 | NSTimeInterval difference; |
---|
711 | switch (date) |
---|
712 | { |
---|
713 | case 0: |
---|
714 | return STAT_TIME_NONE; |
---|
715 | case 1: |
---|
716 | return STAT_TIME_NOW; |
---|
717 | default: |
---|
718 | difference = [[NSDate dateWithTimeIntervalSince1970: date] timeIntervalSinceNow]; |
---|
719 | return difference > 0 ? (NSInteger)difference : STAT_TIME_NONE; |
---|
720 | } |
---|
721 | } |
---|
722 | |
---|
723 | - (NSString *) announceResponse |
---|
724 | { |
---|
725 | return [NSString stringWithUTF8String: fStat->announceResponse]; |
---|
726 | } |
---|
727 | |
---|
728 | - (NSString *) trackerAddressScrape |
---|
729 | { |
---|
730 | return fStat->scrapeURL ? [NSString stringWithUTF8String: fStat->scrapeURL] : nil; |
---|
731 | } |
---|
732 | |
---|
733 | - (NSDate *) lastScrapeTime |
---|
734 | { |
---|
735 | NSInteger date = fStat->lastScrapeTime; |
---|
736 | return date > 0 ? [NSDate dateWithTimeIntervalSince1970: date] : nil; |
---|
737 | } |
---|
738 | |
---|
739 | - (NSInteger) nextScrapeTime |
---|
740 | { |
---|
741 | NSInteger date = fStat->nextScrapeTime; |
---|
742 | NSTimeInterval difference; |
---|
743 | switch (date) |
---|
744 | { |
---|
745 | case 0: |
---|
746 | return STAT_TIME_NONE; |
---|
747 | case 1: |
---|
748 | return STAT_TIME_NOW; |
---|
749 | default: |
---|
750 | difference = [[NSDate dateWithTimeIntervalSince1970: date] timeIntervalSinceNow]; |
---|
751 | return difference > 0 ? (NSInteger)difference : STAT_TIME_NONE; |
---|
752 | } |
---|
753 | } |
---|
754 | |
---|
755 | - (NSString *) scrapeResponse |
---|
756 | { |
---|
757 | return [NSString stringWithUTF8String: fStat->scrapeResponse]; |
---|
758 | } |
---|
759 | |
---|
760 | - (NSMutableArray *) allTrackers: (BOOL) separators |
---|
761 | { |
---|
762 | NSInteger count = fInfo->trackerCount, capacity = count; |
---|
763 | if (separators) |
---|
764 | capacity += fInfo->trackers[count-1].tier + 1; |
---|
765 | NSMutableArray * allTrackers = [NSMutableArray arrayWithCapacity: capacity]; |
---|
766 | |
---|
767 | for (NSInteger i = 0, tier = -1; i < count; i++) |
---|
768 | { |
---|
769 | if (separators && tier != fInfo->trackers[i].tier) |
---|
770 | { |
---|
771 | tier = fInfo->trackers[i].tier; |
---|
772 | [allTrackers addObject: [NSNumber numberWithInt: fAddedTrackers ? tier : tier + 1]]; |
---|
773 | } |
---|
774 | |
---|
775 | [allTrackers addObject: [NSString stringWithUTF8String: fInfo->trackers[i].announce]]; |
---|
776 | } |
---|
777 | |
---|
778 | return allTrackers; |
---|
779 | } |
---|
780 | |
---|
781 | - (NSString *) trackerList |
---|
782 | { |
---|
783 | return [[self allTrackers: NO] componentsJoinedByString: @"\n"]; |
---|
784 | } |
---|
785 | |
---|
786 | - (BOOL) updateAllTrackersForAdd: (NSMutableArray *) trackers |
---|
787 | { |
---|
788 | //find added tracker at end of first tier |
---|
789 | NSInteger i; |
---|
790 | for (i = 1; i < [trackers count]; i++) |
---|
791 | if ([[trackers objectAtIndex: i] isKindOfClass: [NSNumber class]]) |
---|
792 | break; |
---|
793 | i--; |
---|
794 | |
---|
795 | NSString * tracker = [trackers objectAtIndex: i]; |
---|
796 | |
---|
797 | tracker = [tracker stringByTrimmingCharactersInSet: [NSCharacterSet whitespaceAndNewlineCharacterSet]]; |
---|
798 | |
---|
799 | if ([tracker rangeOfString: @"://"].location == NSNotFound) |
---|
800 | { |
---|
801 | tracker = [@"http://" stringByAppendingString: tracker]; |
---|
802 | [trackers replaceObjectAtIndex: i withObject: tracker]; |
---|
803 | } |
---|
804 | |
---|
805 | if (!tr_httpIsValidURL([tracker UTF8String])) |
---|
806 | return NO; |
---|
807 | |
---|
808 | [self updateAllTrackers: trackers]; |
---|
809 | |
---|
810 | fAddedTrackers = YES; |
---|
811 | return YES; |
---|
812 | } |
---|
813 | |
---|
814 | - (void) updateAllTrackersForRemove: (NSMutableArray *) trackers |
---|
815 | { |
---|
816 | //check if no user-added groups |
---|
817 | if ([[trackers objectAtIndex: 0] intValue] != 0) |
---|
818 | fAddedTrackers = NO; |
---|
819 | |
---|
820 | [self updateAllTrackers: trackers]; |
---|
821 | } |
---|
822 | |
---|
823 | - (BOOL) hasAddedTrackers |
---|
824 | { |
---|
825 | return fAddedTrackers; |
---|
826 | } |
---|
827 | |
---|
828 | - (NSString *) comment |
---|
829 | { |
---|
830 | return [NSString stringWithUTF8String: fInfo->comment]; |
---|
831 | } |
---|
832 | |
---|
833 | - (NSString *) creator |
---|
834 | { |
---|
835 | return [NSString stringWithUTF8String: fInfo->creator]; |
---|
836 | } |
---|
837 | |
---|
838 | - (NSDate *) dateCreated |
---|
839 | { |
---|
840 | NSInteger date = fInfo->dateCreated; |
---|
841 | return date > 0 ? [NSDate dateWithTimeIntervalSince1970: date] : nil; |
---|
842 | } |
---|
843 | |
---|
844 | - (NSInteger) pieceSize |
---|
845 | { |
---|
846 | return fInfo->pieceSize; |
---|
847 | } |
---|
848 | |
---|
849 | - (NSInteger) pieceCount |
---|
850 | { |
---|
851 | return fInfo->pieceCount; |
---|
852 | } |
---|
853 | |
---|
854 | - (NSString *) hashString |
---|
855 | { |
---|
856 | return fHashString; |
---|
857 | } |
---|
858 | |
---|
859 | - (BOOL) privateTorrent |
---|
860 | { |
---|
861 | return fInfo->isPrivate; |
---|
862 | } |
---|
863 | |
---|
864 | - (NSString *) torrentLocation |
---|
865 | { |
---|
866 | return [NSString stringWithUTF8String: fInfo->torrent]; |
---|
867 | } |
---|
868 | |
---|
869 | - (NSString *) publicTorrentLocation |
---|
870 | { |
---|
871 | return fPublicTorrentLocation; |
---|
872 | } |
---|
873 | |
---|
874 | - (NSString *) dataLocation |
---|
875 | { |
---|
876 | return [[self downloadFolder] stringByAppendingPathComponent: [self name]]; |
---|
877 | } |
---|
878 | |
---|
879 | - (BOOL) publicTorrent |
---|
880 | { |
---|
881 | return fPublicTorrent; |
---|
882 | } |
---|
883 | |
---|
884 | - (CGFloat) progress |
---|
885 | { |
---|
886 | return fStat->percentComplete; |
---|
887 | } |
---|
888 | |
---|
889 | - (CGFloat) progressDone |
---|
890 | { |
---|
891 | return fStat->percentDone; |
---|
892 | } |
---|
893 | |
---|
894 | - (CGFloat) progressLeft |
---|
895 | { |
---|
896 | return (CGFloat)[self sizeLeft] / [self size]; |
---|
897 | } |
---|
898 | |
---|
899 | - (CGFloat) checkingProgress |
---|
900 | { |
---|
901 | return fStat->recheckProgress; |
---|
902 | } |
---|
903 | |
---|
904 | - (NSInteger) eta |
---|
905 | { |
---|
906 | return fStat->eta; |
---|
907 | } |
---|
908 | |
---|
909 | - (NSInteger) etaRatio |
---|
910 | { |
---|
911 | if (![self isSeeding]) |
---|
912 | return TR_ETA_UNKNOWN; |
---|
913 | |
---|
914 | CGFloat uploadRate = [self uploadRate]; |
---|
915 | if (uploadRate < 0.1) |
---|
916 | return TR_ETA_UNKNOWN; |
---|
917 | |
---|
918 | CGFloat stopRatio = [self actualStopRatio], ratio = [self ratio]; |
---|
919 | if (stopRatio == INVALID || ratio >= stopRatio) |
---|
920 | return TR_ETA_UNKNOWN; |
---|
921 | |
---|
922 | CGFloat haveDownloaded = (CGFloat)([self downloadedTotal] > 0 ? [self downloadedTotal] : [self haveVerified]); |
---|
923 | CGFloat needUploaded = haveDownloaded * (stopRatio - ratio); |
---|
924 | return needUploaded / uploadRate / 1024.0; |
---|
925 | } |
---|
926 | |
---|
927 | - (CGFloat) notAvailableDesired |
---|
928 | { |
---|
929 | return 1.0 - (CGFloat)fStat->desiredAvailable / [self sizeLeft]; |
---|
930 | } |
---|
931 | |
---|
932 | - (BOOL) isActive |
---|
933 | { |
---|
934 | return fStat->activity != TR_STATUS_STOPPED; |
---|
935 | } |
---|
936 | |
---|
937 | - (BOOL) isSeeding |
---|
938 | { |
---|
939 | return fStat->activity == TR_STATUS_SEED; |
---|
940 | } |
---|
941 | |
---|
942 | - (BOOL) isChecking |
---|
943 | { |
---|
944 | return fStat->activity == TR_STATUS_CHECK || fStat->activity == TR_STATUS_CHECK_WAIT; |
---|
945 | } |
---|
946 | |
---|
947 | - (BOOL) isCheckingWaiting |
---|
948 | { |
---|
949 | return fStat->activity == TR_STATUS_CHECK_WAIT; |
---|
950 | } |
---|
951 | |
---|
952 | - (BOOL) allDownloaded |
---|
953 | { |
---|
954 | return [self progressDone] >= 1.0; |
---|
955 | } |
---|
956 | |
---|
957 | - (BOOL) isComplete |
---|
958 | { |
---|
959 | return [self progress] >= 1.0; |
---|
960 | } |
---|
961 | |
---|
962 | - (BOOL) isError |
---|
963 | { |
---|
964 | return fStat->error != TR_OK; |
---|
965 | } |
---|
966 | |
---|
967 | - (NSString *) errorMessage |
---|
968 | { |
---|
969 | if (![self isError]) |
---|
970 | return @""; |
---|
971 | |
---|
972 | NSString * error; |
---|
973 | if (!(error = [NSString stringWithUTF8String: fStat->errorString]) |
---|
974 | && !(error = [NSString stringWithCString: fStat->errorString encoding: NSISOLatin1StringEncoding])) |
---|
975 | error = [NSString stringWithFormat: @"(%@)", NSLocalizedString(@"unreadable error", "Torrent -> error string unreadable")]; |
---|
976 | |
---|
977 | return error; |
---|
978 | } |
---|
979 | |
---|
980 | - (NSArray *) peers |
---|
981 | { |
---|
982 | int totalPeers; |
---|
983 | tr_peer_stat * peers = tr_torrentPeers(fHandle, &totalPeers); |
---|
984 | |
---|
985 | NSMutableArray * peerDicts = [NSMutableArray arrayWithCapacity: totalPeers]; |
---|
986 | |
---|
987 | for (int i = 0; i < totalPeers; i++) |
---|
988 | { |
---|
989 | tr_peer_stat * peer = &peers[i]; |
---|
990 | NSMutableDictionary * dict = [NSMutableDictionary dictionaryWithCapacity: 10]; |
---|
991 | |
---|
992 | [dict setObject: [NSNumber numberWithInt: peer->from] forKey: @"From"]; |
---|
993 | [dict setObject: [NSString stringWithUTF8String: peer->addr] forKey: @"IP"]; |
---|
994 | [dict setObject: [NSNumber numberWithInt: peer->port] forKey: @"Port"]; |
---|
995 | [dict setObject: [NSNumber numberWithFloat: peer->progress] forKey: @"Progress"]; |
---|
996 | [dict setObject: [NSNumber numberWithBool: peer->isSeed] forKey: @"Seed"]; |
---|
997 | [dict setObject: [NSNumber numberWithBool: peer->isEncrypted] forKey: @"Encryption"]; |
---|
998 | [dict setObject: [NSString stringWithUTF8String: peer->client] forKey: @"Client"]; |
---|
999 | [dict setObject: [NSString stringWithUTF8String: peer->flagStr] forKey: @"Flags"]; |
---|
1000 | |
---|
1001 | if (peer->isUploadingTo) |
---|
1002 | [dict setObject: [NSNumber numberWithFloat: peer->rateToPeer] forKey: @"UL To Rate"]; |
---|
1003 | if (peer->isDownloadingFrom) |
---|
1004 | [dict setObject: [NSNumber numberWithFloat: peer->rateToClient] forKey: @"DL From Rate"]; |
---|
1005 | |
---|
1006 | [peerDicts addObject: dict]; |
---|
1007 | } |
---|
1008 | |
---|
1009 | tr_torrentPeersFree(peers, totalPeers); |
---|
1010 | |
---|
1011 | return peerDicts; |
---|
1012 | } |
---|
1013 | |
---|
1014 | - (NSUInteger) webSeedCount |
---|
1015 | { |
---|
1016 | return fInfo->webseedCount; |
---|
1017 | } |
---|
1018 | |
---|
1019 | - (NSArray *) webSeeds |
---|
1020 | { |
---|
1021 | const NSInteger webSeedCount = fInfo->webseedCount; |
---|
1022 | NSMutableArray * webSeeds = [NSMutableArray arrayWithCapacity: webSeedCount]; |
---|
1023 | |
---|
1024 | float * dlSpeeds = tr_torrentWebSpeeds(fHandle); |
---|
1025 | |
---|
1026 | for (NSInteger i = 0; i < webSeedCount; i++) |
---|
1027 | { |
---|
1028 | NSMutableDictionary * dict = [NSMutableDictionary dictionaryWithCapacity: 2]; |
---|
1029 | |
---|
1030 | [dict setObject: [NSString stringWithUTF8String: fInfo->webseeds[i]] forKey: @"Address"]; |
---|
1031 | |
---|
1032 | if (dlSpeeds[i] != -1.0) |
---|
1033 | [dict setObject: [NSNumber numberWithFloat: dlSpeeds[i]] forKey: @"DL From Rate"]; |
---|
1034 | |
---|
1035 | [webSeeds addObject: dict]; |
---|
1036 | } |
---|
1037 | |
---|
1038 | tr_free(dlSpeeds); |
---|
1039 | |
---|
1040 | return webSeeds; |
---|
1041 | } |
---|
1042 | |
---|
1043 | - (NSString *) progressString |
---|
1044 | { |
---|
1045 | NSString * string; |
---|
1046 | |
---|
1047 | if (![self allDownloaded]) |
---|
1048 | { |
---|
1049 | CGFloat progress; |
---|
1050 | if ([self isFolder] && [fDefaults boolForKey: @"DisplayStatusProgressSelected"]) |
---|
1051 | { |
---|
1052 | string = [NSString stringWithFormat: NSLocalizedString(@"%@ of %@ selected", "Torrent -> progress string"), |
---|
1053 | [NSString stringForFileSize: [self haveTotal]], [NSString stringForFileSize: [self totalSizeSelected]]]; |
---|
1054 | progress = 100.0 * [self progressDone]; |
---|
1055 | } |
---|
1056 | else |
---|
1057 | { |
---|
1058 | string = [NSString stringWithFormat: NSLocalizedString(@"%@ of %@", "Torrent -> progress string"), |
---|
1059 | [NSString stringForFileSize: [self haveTotal]], [NSString stringForFileSize: [self size]]]; |
---|
1060 | progress = 100.0 * [self progress]; |
---|
1061 | } |
---|
1062 | |
---|
1063 | string = [NSString localizedStringWithFormat: @"%@ (%.2f%%)", string, progress]; |
---|
1064 | } |
---|
1065 | else |
---|
1066 | { |
---|
1067 | NSString * downloadString; |
---|
1068 | if (![self isComplete]) //only multifile possible |
---|
1069 | { |
---|
1070 | if ([fDefaults boolForKey: @"DisplayStatusProgressSelected"]) |
---|
1071 | downloadString = [NSString stringWithFormat: NSLocalizedString(@"%@ selected", "Torrent -> progress string"), |
---|
1072 | [NSString stringForFileSize: [self haveTotal]]]; |
---|
1073 | else |
---|
1074 | { |
---|
1075 | downloadString = [NSString stringWithFormat: NSLocalizedString(@"%@ of %@", "Torrent -> progress string"), |
---|
1076 | [NSString stringForFileSize: [self haveTotal]], [NSString stringForFileSize: [self size]]]; |
---|
1077 | |
---|
1078 | downloadString = [NSString localizedStringWithFormat: @"%@ (%.2f%%)", downloadString, 100.0 * [self progress]]; |
---|
1079 | } |
---|
1080 | } |
---|
1081 | else |
---|
1082 | downloadString = [NSString stringForFileSize: [self size]]; |
---|
1083 | |
---|
1084 | NSString * uploadString = [NSString stringWithFormat: NSLocalizedString(@"uploaded %@ (Ratio: %@)", |
---|
1085 | "Torrent -> progress string"), [NSString stringForFileSize: [self uploadedTotal]], |
---|
1086 | [NSString stringForRatio: [self ratio]]]; |
---|
1087 | |
---|
1088 | string = [downloadString stringByAppendingFormat: @", %@", uploadString]; |
---|
1089 | } |
---|
1090 | |
---|
1091 | //add time when downloading |
---|
1092 | if (fStat->activity == TR_STATUS_DOWNLOAD || ([self isSeeding] |
---|
1093 | && (fRatioSetting == NSOnState || (fRatioSetting == NSMixedState && [fDefaults boolForKey: @"RatioCheck"])))) |
---|
1094 | { |
---|
1095 | NSInteger eta = fStat->activity == TR_STATUS_DOWNLOAD ? [self eta] : [self etaRatio]; |
---|
1096 | string = [string stringByAppendingFormat: @" - %@", [self etaString: eta]]; |
---|
1097 | } |
---|
1098 | |
---|
1099 | return string; |
---|
1100 | } |
---|
1101 | |
---|
1102 | - (NSString *) statusString |
---|
1103 | { |
---|
1104 | NSString * string; |
---|
1105 | |
---|
1106 | if ([self isError]) |
---|
1107 | { |
---|
1108 | string = NSLocalizedString(@"Error", "Torrent -> status string"); |
---|
1109 | NSString * errorString = [self errorMessage]; |
---|
1110 | if (errorString && ![errorString isEqualToString: @""]) |
---|
1111 | string = [string stringByAppendingFormat: @": %@", errorString]; |
---|
1112 | } |
---|
1113 | else |
---|
1114 | { |
---|
1115 | switch (fStat->activity) |
---|
1116 | { |
---|
1117 | case TR_STATUS_STOPPED: |
---|
1118 | if (fWaitToStart) |
---|
1119 | { |
---|
1120 | string = ![self allDownloaded] |
---|
1121 | ? [NSLocalizedString(@"Waiting to download", "Torrent -> status string") stringByAppendingEllipsis] |
---|
1122 | : [NSLocalizedString(@"Waiting to seed", "Torrent -> status string") stringByAppendingEllipsis]; |
---|
1123 | } |
---|
1124 | else if (fFinishedSeeding) |
---|
1125 | string = NSLocalizedString(@"Seeding complete", "Torrent -> status string"); |
---|
1126 | else |
---|
1127 | string = NSLocalizedString(@"Paused", "Torrent -> status string"); |
---|
1128 | break; |
---|
1129 | |
---|
1130 | case TR_STATUS_CHECK_WAIT: |
---|
1131 | string = [NSLocalizedString(@"Waiting to check existing data", "Torrent -> status string") stringByAppendingEllipsis]; |
---|
1132 | break; |
---|
1133 | |
---|
1134 | case TR_STATUS_CHECK: |
---|
1135 | string = [NSString localizedStringWithFormat: NSLocalizedString(@"Checking existing data (%.2f%%)", |
---|
1136 | "Torrent -> status string"), 100.0 * [self checkingProgress]]; |
---|
1137 | break; |
---|
1138 | |
---|
1139 | case TR_STATUS_DOWNLOAD: |
---|
1140 | if ([self totalPeersConnected] != 1) |
---|
1141 | string = [NSString stringWithFormat: NSLocalizedString(@"Downloading from %d of %d peers", |
---|
1142 | "Torrent -> status string"), [self peersSendingToUs], [self totalPeersConnected]]; |
---|
1143 | else |
---|
1144 | string = [NSString stringWithFormat: NSLocalizedString(@"Downloading from %d of 1 peer", |
---|
1145 | "Torrent -> status string"), [self peersSendingToUs]]; |
---|
1146 | |
---|
1147 | NSInteger webSeedCount = fStat->webseedsSendingToUs; |
---|
1148 | if (webSeedCount > 0) |
---|
1149 | { |
---|
1150 | NSString * webSeedString; |
---|
1151 | if (webSeedCount == 1) |
---|
1152 | webSeedString = NSLocalizedString(@"web seed", "Torrent -> status string"); |
---|
1153 | else |
---|
1154 | webSeedString = [NSString stringWithFormat: NSLocalizedString(@"%d web seeds", "Torrent -> status string"), |
---|
1155 | webSeedCount]; |
---|
1156 | |
---|
1157 | string = [string stringByAppendingFormat: @" + %@", webSeedString]; |
---|
1158 | } |
---|
1159 | |
---|
1160 | break; |
---|
1161 | |
---|
1162 | case TR_STATUS_SEED: |
---|
1163 | if ([self totalPeersConnected] != 1) |
---|
1164 | string = [NSString stringWithFormat: NSLocalizedString(@"Seeding to %d of %d peers", "Torrent -> status string"), |
---|
1165 | [self peersGettingFromUs], [self totalPeersConnected]]; |
---|
1166 | else |
---|
1167 | string = [NSString stringWithFormat: NSLocalizedString(@"Seeding to %d of 1 peer", "Torrent -> status string"), |
---|
1168 | [self peersGettingFromUs]]; |
---|
1169 | } |
---|
1170 | |
---|
1171 | if (fStalled) |
---|
1172 | string = [NSLocalizedString(@"Stalled", "Torrent -> status string") stringByAppendingFormat: @", %@", string]; |
---|
1173 | } |
---|
1174 | |
---|
1175 | //append even if error |
---|
1176 | if ([self isActive] && ![self isChecking]) |
---|
1177 | { |
---|
1178 | if (fStat->activity == TR_STATUS_DOWNLOAD) |
---|
1179 | string = [string stringByAppendingFormat: @" - %@: %@, %@: %@", |
---|
1180 | NSLocalizedString(@"DL", "Torrent -> status string"), [NSString stringForSpeed: [self downloadRate]], |
---|
1181 | NSLocalizedString(@"UL", "Torrent -> status string"), [NSString stringForSpeed: [self uploadRate]]]; |
---|
1182 | else |
---|
1183 | string = [string stringByAppendingFormat: @" - %@: %@", |
---|
1184 | NSLocalizedString(@"UL", "Torrent -> status string"), [NSString stringForSpeed: [self uploadRate]]]; |
---|
1185 | } |
---|
1186 | |
---|
1187 | return string; |
---|
1188 | } |
---|
1189 | |
---|
1190 | - (NSString *) shortStatusString |
---|
1191 | { |
---|
1192 | NSString * string; |
---|
1193 | |
---|
1194 | switch (fStat->activity) |
---|
1195 | { |
---|
1196 | case TR_STATUS_STOPPED: |
---|
1197 | if (fWaitToStart) |
---|
1198 | { |
---|
1199 | string = ![self allDownloaded] |
---|
1200 | ? [NSLocalizedString(@"Waiting to download", "Torrent -> status string") stringByAppendingEllipsis] |
---|
1201 | : [NSLocalizedString(@"Waiting to seed", "Torrent -> status string") stringByAppendingEllipsis]; |
---|
1202 | } |
---|
1203 | else if (fFinishedSeeding) |
---|
1204 | string = NSLocalizedString(@"Seeding complete", "Torrent -> status string"); |
---|
1205 | else |
---|
1206 | string = NSLocalizedString(@"Paused", "Torrent -> status string"); |
---|
1207 | break; |
---|
1208 | |
---|
1209 | case TR_STATUS_CHECK_WAIT: |
---|
1210 | string = [NSLocalizedString(@"Waiting to check existing data", "Torrent -> status string") stringByAppendingEllipsis]; |
---|
1211 | break; |
---|
1212 | |
---|
1213 | case TR_STATUS_CHECK: |
---|
1214 | string = [NSString localizedStringWithFormat: NSLocalizedString(@"Checking existing data (%.2f%%)", |
---|
1215 | "Torrent -> status string"), 100.0 * [self checkingProgress]]; |
---|
1216 | break; |
---|
1217 | |
---|
1218 | case TR_STATUS_DOWNLOAD: |
---|
1219 | string = [NSString stringWithFormat: @"%@: %@, %@: %@", |
---|
1220 | NSLocalizedString(@"DL", "Torrent -> status string"), [NSString stringForSpeed: [self downloadRate]], |
---|
1221 | NSLocalizedString(@"UL", "Torrent -> status string"), [NSString stringForSpeed: [self uploadRate]]]; |
---|
1222 | break; |
---|
1223 | |
---|
1224 | case TR_STATUS_SEED: |
---|
1225 | string = [NSString stringWithFormat: @"%@: %@, %@: %@", |
---|
1226 | NSLocalizedString(@"Ratio", "Torrent -> status string"), [NSString stringForRatio: [self ratio]], |
---|
1227 | NSLocalizedString(@"UL", "Torrent -> status string"), [NSString stringForSpeed: [self uploadRate]]]; |
---|
1228 | } |
---|
1229 | |
---|
1230 | return string; |
---|
1231 | } |
---|
1232 | |
---|
1233 | - (NSString *) remainingTimeString |
---|
1234 | { |
---|
1235 | if (![self isActive] || ([self isSeeding] |
---|
1236 | && !(fRatioSetting == NSOnState || (fRatioSetting == NSMixedState && [fDefaults boolForKey: @"RatioCheck"])))) |
---|
1237 | return [self shortStatusString]; |
---|
1238 | |
---|
1239 | return [self etaString: [self isSeeding] ? [self etaRatio] : [self eta]]; |
---|
1240 | } |
---|
1241 | |
---|
1242 | - (NSString *) stateString |
---|
1243 | { |
---|
1244 | switch (fStat->activity) |
---|
1245 | { |
---|
1246 | case TR_STATUS_STOPPED: |
---|
1247 | return NSLocalizedString(@"Paused", "Torrent -> status string"); |
---|
1248 | |
---|
1249 | case TR_STATUS_CHECK: |
---|
1250 | return [NSString localizedStringWithFormat: NSLocalizedString(@"Checking existing data (%.2f%%)", |
---|
1251 | "Torrent -> status string"), 100.0 * [self checkingProgress]]; |
---|
1252 | |
---|
1253 | case TR_STATUS_CHECK_WAIT: |
---|
1254 | return [NSLocalizedString(@"Waiting to check existing data", "Torrent -> status string") stringByAppendingEllipsis]; |
---|
1255 | |
---|
1256 | case TR_STATUS_DOWNLOAD: |
---|
1257 | return NSLocalizedString(@"Downloading", "Torrent -> status string"); |
---|
1258 | |
---|
1259 | case TR_STATUS_SEED: |
---|
1260 | return NSLocalizedString(@"Seeding", "Torrent -> status string"); |
---|
1261 | } |
---|
1262 | } |
---|
1263 | |
---|
1264 | - (NSInteger) seeders |
---|
1265 | { |
---|
1266 | return fStat->seeders; |
---|
1267 | } |
---|
1268 | |
---|
1269 | - (NSInteger) leechers |
---|
1270 | { |
---|
1271 | return fStat->leechers; |
---|
1272 | } |
---|
1273 | |
---|
1274 | - (NSInteger) completedFromTracker |
---|
1275 | { |
---|
1276 | return fStat->timesCompleted; |
---|
1277 | } |
---|
1278 | |
---|
1279 | - (NSInteger) totalPeersConnected |
---|
1280 | { |
---|
1281 | return fStat->peersConnected; |
---|
1282 | } |
---|
1283 | |
---|
1284 | - (NSInteger) totalPeersTracker |
---|
1285 | { |
---|
1286 | return fStat->peersFrom[TR_PEER_FROM_TRACKER]; |
---|
1287 | } |
---|
1288 | |
---|
1289 | - (NSInteger) totalPeersIncoming |
---|
1290 | { |
---|
1291 | return fStat->peersFrom[TR_PEER_FROM_INCOMING]; |
---|
1292 | } |
---|
1293 | |
---|
1294 | - (NSInteger) totalPeersCache |
---|
1295 | { |
---|
1296 | return fStat->peersFrom[TR_PEER_FROM_CACHE]; |
---|
1297 | } |
---|
1298 | |
---|
1299 | - (NSInteger) totalPeersPex |
---|
1300 | { |
---|
1301 | return fStat->peersFrom[TR_PEER_FROM_PEX]; |
---|
1302 | } |
---|
1303 | |
---|
1304 | - (NSInteger) totalPeersKnown |
---|
1305 | { |
---|
1306 | return fStat->peersKnown; |
---|
1307 | } |
---|
1308 | |
---|
1309 | - (NSInteger) peersSendingToUs |
---|
1310 | { |
---|
1311 | return fStat->peersSendingToUs; |
---|
1312 | } |
---|
1313 | |
---|
1314 | - (NSInteger) peersGettingFromUs |
---|
1315 | { |
---|
1316 | return fStat->peersGettingFromUs; |
---|
1317 | } |
---|
1318 | |
---|
1319 | - (CGFloat) downloadRate |
---|
1320 | { |
---|
1321 | return fStat->pieceDownloadSpeed; |
---|
1322 | } |
---|
1323 | |
---|
1324 | - (CGFloat) uploadRate |
---|
1325 | { |
---|
1326 | return fStat->pieceUploadSpeed; |
---|
1327 | } |
---|
1328 | |
---|
1329 | - (CGFloat) totalRate |
---|
1330 | { |
---|
1331 | return [self downloadRate] + [self uploadRate]; |
---|
1332 | } |
---|
1333 | |
---|
1334 | - (uint64_t) haveVerified |
---|
1335 | { |
---|
1336 | return fStat->haveValid; |
---|
1337 | } |
---|
1338 | |
---|
1339 | - (uint64_t) haveTotal |
---|
1340 | { |
---|
1341 | return [self haveVerified] + fStat->haveUnchecked; |
---|
1342 | } |
---|
1343 | |
---|
1344 | - (uint64_t) totalSizeSelected |
---|
1345 | { |
---|
1346 | return fStat->sizeWhenDone; |
---|
1347 | } |
---|
1348 | |
---|
1349 | - (uint64_t) downloadedTotal |
---|
1350 | { |
---|
1351 | return fStat->downloadedEver; |
---|
1352 | } |
---|
1353 | |
---|
1354 | - (uint64_t) uploadedTotal |
---|
1355 | { |
---|
1356 | return fStat->uploadedEver; |
---|
1357 | } |
---|
1358 | |
---|
1359 | - (uint64_t) failedHash |
---|
1360 | { |
---|
1361 | return fStat->corruptEver; |
---|
1362 | } |
---|
1363 | |
---|
1364 | - (CGFloat) swarmSpeed |
---|
1365 | { |
---|
1366 | return fStat->swarmSpeed; |
---|
1367 | } |
---|
1368 | |
---|
1369 | - (NSInteger) orderValue |
---|
1370 | { |
---|
1371 | return fOrderValue; |
---|
1372 | } |
---|
1373 | |
---|
1374 | - (void) setOrderValue: (NSInteger) orderValue |
---|
1375 | { |
---|
1376 | fOrderValue = orderValue; |
---|
1377 | } |
---|
1378 | |
---|
1379 | - (NSInteger) groupValue |
---|
1380 | { |
---|
1381 | return fGroupValue; |
---|
1382 | } |
---|
1383 | |
---|
1384 | - (void) setGroupValue: (NSInteger) goupValue |
---|
1385 | { |
---|
1386 | fGroupValue = goupValue; |
---|
1387 | } |
---|
1388 | |
---|
1389 | - (NSInteger) groupOrderValue |
---|
1390 | { |
---|
1391 | return [[GroupsController groups] rowValueForIndex: fGroupValue]; |
---|
1392 | } |
---|
1393 | |
---|
1394 | - (void) checkGroupValueForRemoval: (NSNotification *) notification |
---|
1395 | { |
---|
1396 | if (fGroupValue != -1 && [[[notification userInfo] objectForKey: @"Index"] intValue] == fGroupValue) |
---|
1397 | fGroupValue = -1; |
---|
1398 | } |
---|
1399 | |
---|
1400 | - (NSArray *) fileList |
---|
1401 | { |
---|
1402 | return fFileList; |
---|
1403 | } |
---|
1404 | |
---|
1405 | - (NSInteger) fileCount |
---|
1406 | { |
---|
1407 | return fInfo->fileCount; |
---|
1408 | } |
---|
1409 | |
---|
1410 | - (void) updateFileStat |
---|
1411 | { |
---|
1412 | if (fFileStat) |
---|
1413 | tr_torrentFilesFree(fFileStat, [self fileCount]); |
---|
1414 | |
---|
1415 | fFileStat = tr_torrentFiles(fHandle, NULL); |
---|
1416 | } |
---|
1417 | |
---|
1418 | - (CGFloat) fileProgress: (FileListNode *) node |
---|
1419 | { |
---|
1420 | if ([self isComplete]) |
---|
1421 | return 1.0; |
---|
1422 | |
---|
1423 | if (!fFileStat) |
---|
1424 | [self updateFileStat]; |
---|
1425 | |
---|
1426 | NSIndexSet * indexSet = [node indexes]; |
---|
1427 | |
---|
1428 | if ([indexSet count] == 1) |
---|
1429 | return fFileStat[[indexSet firstIndex]].progress; |
---|
1430 | |
---|
1431 | uint64_t have = 0; |
---|
1432 | for (NSInteger index = [indexSet firstIndex]; index != NSNotFound; index = [indexSet indexGreaterThanIndex: index]) |
---|
1433 | have += fFileStat[index].bytesCompleted; |
---|
1434 | |
---|
1435 | NSAssert([node size], @"director in torrent file has size 0"); |
---|
1436 | return (CGFloat)have / [node size]; |
---|
1437 | } |
---|
1438 | |
---|
1439 | - (NSArray *) flatFileList |
---|
1440 | { |
---|
1441 | return fFlatFileList; |
---|
1442 | } |
---|
1443 | |
---|
1444 | - (BOOL) canChangeDownloadCheckForFile: (NSInteger) index |
---|
1445 | { |
---|
1446 | if (!fFileStat) |
---|
1447 | [self updateFileStat]; |
---|
1448 | |
---|
1449 | return [self fileCount] > 1 && fFileStat[index].progress < 1.0; |
---|
1450 | } |
---|
1451 | |
---|
1452 | - (BOOL) canChangeDownloadCheckForFiles: (NSIndexSet *) indexSet |
---|
1453 | { |
---|
1454 | if ([self fileCount] <= 1 || [self isComplete]) |
---|
1455 | return NO; |
---|
1456 | |
---|
1457 | if (!fFileStat) |
---|
1458 | [self updateFileStat]; |
---|
1459 | |
---|
1460 | for (NSInteger index = [indexSet firstIndex]; index != NSNotFound; index = [indexSet indexGreaterThanIndex: index]) |
---|
1461 | if (fFileStat[index].progress < 1.0) |
---|
1462 | return YES; |
---|
1463 | return NO; |
---|
1464 | } |
---|
1465 | |
---|
1466 | - (NSInteger) checkForFiles: (NSIndexSet *) indexSet |
---|
1467 | { |
---|
1468 | BOOL onState = NO, offState = NO; |
---|
1469 | for (NSInteger index = [indexSet firstIndex]; index != NSNotFound; index = [indexSet indexGreaterThanIndex: index]) |
---|
1470 | { |
---|
1471 | if (tr_torrentGetFileDL(fHandle, index) || ![self canChangeDownloadCheckForFile: index]) |
---|
1472 | onState = YES; |
---|
1473 | else |
---|
1474 | offState = YES; |
---|
1475 | |
---|
1476 | if (onState && offState) |
---|
1477 | return NSMixedState; |
---|
1478 | } |
---|
1479 | return onState ? NSOnState : NSOffState; |
---|
1480 | } |
---|
1481 | |
---|
1482 | - (void) setFileCheckState: (NSInteger) state forIndexes: (NSIndexSet *) indexSet |
---|
1483 | { |
---|
1484 | NSUInteger count = [indexSet count]; |
---|
1485 | tr_file_index_t * files = malloc(count * sizeof(tr_file_index_t)); |
---|
1486 | for (NSUInteger index = [indexSet firstIndex], i = 0; index != NSNotFound; index = [indexSet indexGreaterThanIndex: index], i++) |
---|
1487 | files[i] = index; |
---|
1488 | |
---|
1489 | tr_torrentSetFileDLs(fHandle, files, count, state != NSOffState); |
---|
1490 | free(files); |
---|
1491 | |
---|
1492 | [self update]; |
---|
1493 | [[NSNotificationCenter defaultCenter] postNotificationName: @"TorrentFileCheckChange" object: self]; |
---|
1494 | } |
---|
1495 | |
---|
1496 | - (void) setFilePriority: (NSInteger) priority forIndexes: (NSIndexSet *) indexSet |
---|
1497 | { |
---|
1498 | const NSUInteger count = [indexSet count]; |
---|
1499 | tr_file_index_t * files = malloc(count * sizeof(tr_file_index_t)); |
---|
1500 | for (NSUInteger index = [indexSet firstIndex], i = 0; index != NSNotFound; index = [indexSet indexGreaterThanIndex: index], i++) |
---|
1501 | files[i] = index; |
---|
1502 | |
---|
1503 | tr_torrentSetFilePriorities(fHandle, files, count, priority); |
---|
1504 | free(files); |
---|
1505 | } |
---|
1506 | |
---|
1507 | - (BOOL) hasFilePriority: (NSInteger) priority forIndexes: (NSIndexSet *) indexSet |
---|
1508 | { |
---|
1509 | for (NSInteger index = [indexSet firstIndex]; index != NSNotFound; index = [indexSet indexGreaterThanIndex: index]) |
---|
1510 | if (priority == tr_torrentGetFilePriority(fHandle, index) && [self canChangeDownloadCheckForFile: index]) |
---|
1511 | return YES; |
---|
1512 | return NO; |
---|
1513 | } |
---|
1514 | |
---|
1515 | - (NSSet *) filePrioritiesForIndexes: (NSIndexSet *) indexSet |
---|
1516 | { |
---|
1517 | BOOL low = NO, normal = NO, high = NO; |
---|
1518 | NSMutableSet * priorities = [NSMutableSet setWithCapacity: 3]; |
---|
1519 | |
---|
1520 | for (NSInteger index = [indexSet firstIndex]; index != NSNotFound; index = [indexSet indexGreaterThanIndex: index]) |
---|
1521 | { |
---|
1522 | if (![self canChangeDownloadCheckForFile: index]) |
---|
1523 | continue; |
---|
1524 | |
---|
1525 | NSInteger priority = tr_torrentGetFilePriority(fHandle, index); |
---|
1526 | if (priority == TR_PRI_LOW) |
---|
1527 | { |
---|
1528 | if (low) |
---|
1529 | continue; |
---|
1530 | low = YES; |
---|
1531 | } |
---|
1532 | else if (priority == TR_PRI_HIGH) |
---|
1533 | { |
---|
1534 | if (high) |
---|
1535 | continue; |
---|
1536 | high = YES; |
---|
1537 | } |
---|
1538 | else |
---|
1539 | { |
---|
1540 | if (normal) |
---|
1541 | continue; |
---|
1542 | normal = YES; |
---|
1543 | } |
---|
1544 | |
---|
1545 | [priorities addObject: [NSNumber numberWithInt: priority]]; |
---|
1546 | if (low && normal && high) |
---|
1547 | break; |
---|
1548 | } |
---|
1549 | return priorities; |
---|
1550 | } |
---|
1551 | |
---|
1552 | - (NSDate *) dateAdded |
---|
1553 | { |
---|
1554 | time_t date = fStat->addedDate; |
---|
1555 | return [NSDate dateWithTimeIntervalSince1970: date]; |
---|
1556 | } |
---|
1557 | |
---|
1558 | - (NSDate *) dateCompleted |
---|
1559 | { |
---|
1560 | time_t date = fStat->doneDate; |
---|
1561 | return date != 0 ? [NSDate dateWithTimeIntervalSince1970: date] : nil; |
---|
1562 | } |
---|
1563 | |
---|
1564 | - (NSDate *) dateActivity |
---|
1565 | { |
---|
1566 | time_t date = fStat->activityDate; |
---|
1567 | return date != 0 ? [NSDate dateWithTimeIntervalSince1970: date] : nil; |
---|
1568 | } |
---|
1569 | |
---|
1570 | - (NSDate *) dateActivityOrAdd |
---|
1571 | { |
---|
1572 | NSDate * date = [self dateActivity]; |
---|
1573 | return date ? date : [self dateAdded]; |
---|
1574 | } |
---|
1575 | |
---|
1576 | - (NSInteger) stalledMinutes |
---|
1577 | { |
---|
1578 | time_t start = fStat->startDate; |
---|
1579 | if (start == 0) |
---|
1580 | return -1; |
---|
1581 | |
---|
1582 | NSDate * started = [NSDate dateWithTimeIntervalSince1970: start], |
---|
1583 | * activity = [self dateActivity]; |
---|
1584 | |
---|
1585 | NSDate * laterDate = activity ? [started laterDate: activity] : started; |
---|
1586 | return -1 * [laterDate timeIntervalSinceNow] / 60; |
---|
1587 | } |
---|
1588 | |
---|
1589 | - (BOOL) isStalled |
---|
1590 | { |
---|
1591 | return fStalled; |
---|
1592 | } |
---|
1593 | |
---|
1594 | - (NSInteger) stateSortKey |
---|
1595 | { |
---|
1596 | if (![self isActive]) //paused |
---|
1597 | return 0; |
---|
1598 | else if ([self isSeeding]) //seeding |
---|
1599 | return 1; |
---|
1600 | else //downloading |
---|
1601 | return 2; |
---|
1602 | } |
---|
1603 | |
---|
1604 | - (tr_torrent *) torrentStruct |
---|
1605 | { |
---|
1606 | return fHandle; |
---|
1607 | } |
---|
1608 | |
---|
1609 | @end |
---|
1610 | |
---|
1611 | @implementation Torrent (Private) |
---|
1612 | |
---|
1613 | //if a hash is given, attempt to load that; otherwise, attempt to open file at path |
---|
1614 | - (id) initWithHash: (NSString *) hashString path: (NSString *) path torrentStruct: (tr_torrent *) torrentStruct lib: (tr_session *) lib |
---|
1615 | publicTorrent: (NSNumber *) publicTorrent |
---|
1616 | downloadFolder: (NSString *) downloadFolder |
---|
1617 | useIncompleteFolder: (NSNumber *) useIncompleteFolder incompleteFolder: (NSString *) incompleteFolder |
---|
1618 | ratioSetting: (NSNumber *) ratioSetting ratioLimit: (NSNumber *) ratioLimit |
---|
1619 | waitToStart: (NSNumber *) waitToStart |
---|
1620 | orderValue: (NSNumber *) orderValue groupValue: (NSNumber *) groupValue addedTrackers: (NSNumber *) addedTrackers |
---|
1621 | { |
---|
1622 | if (!(self = [super init])) |
---|
1623 | return nil; |
---|
1624 | |
---|
1625 | fDefaults = [NSUserDefaults standardUserDefaults]; |
---|
1626 | |
---|
1627 | fPublicTorrent = path && (publicTorrent ? [publicTorrent boolValue] : ![fDefaults boolForKey: @"DeleteOriginalTorrent"]); |
---|
1628 | if (fPublicTorrent) |
---|
1629 | fPublicTorrentLocation = [path retain]; |
---|
1630 | |
---|
1631 | fDownloadFolder = downloadFolder ? downloadFolder : [fDefaults stringForKey: @"DownloadFolder"]; |
---|
1632 | fDownloadFolder = [[fDownloadFolder stringByExpandingTildeInPath] retain]; |
---|
1633 | |
---|
1634 | fUseIncompleteFolder = useIncompleteFolder ? [useIncompleteFolder boolValue] |
---|
1635 | : [fDefaults boolForKey: @"UseIncompleteDownloadFolder"]; |
---|
1636 | if (fUseIncompleteFolder) |
---|
1637 | { |
---|
1638 | fIncompleteFolder = incompleteFolder ? incompleteFolder : [fDefaults stringForKey: @"IncompleteDownloadFolder"]; |
---|
1639 | fIncompleteFolder = [[fIncompleteFolder stringByExpandingTildeInPath] retain]; |
---|
1640 | } |
---|
1641 | |
---|
1642 | if (torrentStruct) |
---|
1643 | { |
---|
1644 | fHandle = torrentStruct; |
---|
1645 | fInfo = tr_torrentInfo(fHandle); |
---|
1646 | |
---|
1647 | NSString * currentDownloadFolder = [self shouldUseIncompleteFolderForName: [NSString stringWithUTF8String: fInfo->name]] |
---|
1648 | ? fIncompleteFolder : fDownloadFolder; |
---|
1649 | tr_torrentSetDownloadDir(fHandle, [currentDownloadFolder UTF8String]); |
---|
1650 | } |
---|
1651 | else |
---|
1652 | { |
---|
1653 | //set libtransmission settings for initialization |
---|
1654 | tr_ctor * ctor = tr_ctorNew(lib); |
---|
1655 | tr_ctorSetPaused(ctor, TR_FORCE, YES); |
---|
1656 | tr_ctorSetPeerLimit(ctor, TR_FALLBACK, [fDefaults integerForKey: @"PeersTorrent"]); |
---|
1657 | |
---|
1658 | tr_info info; |
---|
1659 | if (hashString) |
---|
1660 | { |
---|
1661 | tr_ctorSetMetainfoFromHash(ctor, [hashString UTF8String]); |
---|
1662 | if (tr_torrentParse(lib, ctor, &info) == TR_OK) |
---|
1663 | { |
---|
1664 | NSString * currentDownloadFolder = [self shouldUseIncompleteFolderForName: [NSString stringWithUTF8String: info.name]] |
---|
1665 | ? fIncompleteFolder : fDownloadFolder; |
---|
1666 | tr_ctorSetDownloadDir(ctor, TR_FORCE, [currentDownloadFolder UTF8String]); |
---|
1667 | |
---|
1668 | fHandle = tr_torrentNew(lib, ctor, NULL); |
---|
1669 | } |
---|
1670 | tr_metainfoFree(&info); |
---|
1671 | } |
---|
1672 | if (!fHandle && path) |
---|
1673 | { |
---|
1674 | tr_ctorSetMetainfoFromFile(ctor, [path UTF8String]); |
---|
1675 | if (tr_torrentParse(lib, ctor, &info) == TR_OK) |
---|
1676 | { |
---|
1677 | NSString * currentDownloadFolder = [self shouldUseIncompleteFolderForName: [NSString stringWithUTF8String: info.name]] |
---|
1678 | ? fIncompleteFolder : fDownloadFolder; |
---|
1679 | tr_ctorSetDownloadDir(ctor, TR_FORCE, [currentDownloadFolder UTF8String]); |
---|
1680 | |
---|
1681 | fHandle = tr_torrentNew(lib, ctor, NULL); |
---|
1682 | } |
---|
1683 | tr_metainfoFree(&info); |
---|
1684 | } |
---|
1685 | |
---|
1686 | tr_ctorFree(ctor); |
---|
1687 | |
---|
1688 | if (!fHandle) |
---|
1689 | { |
---|
1690 | [self release]; |
---|
1691 | return nil; |
---|
1692 | } |
---|
1693 | |
---|
1694 | fInfo = tr_torrentInfo(fHandle); |
---|
1695 | } |
---|
1696 | |
---|
1697 | tr_torrentSetCompletenessCallback(fHandle, completenessChangeCallback, self); |
---|
1698 | |
---|
1699 | fNameString = [[NSString alloc] initWithUTF8String: fInfo->name]; |
---|
1700 | fHashString = [[NSString alloc] initWithUTF8String: fInfo->hashString]; |
---|
1701 | |
---|
1702 | fRatioSetting = ratioSetting ? [ratioSetting intValue] : NSMixedState; |
---|
1703 | fRatioLimit = ratioLimit ? [ratioLimit floatValue] : [fDefaults floatForKey: @"RatioLimit"]; |
---|
1704 | fFinishedSeeding = NO; |
---|
1705 | |
---|
1706 | fWaitToStart = waitToStart && [waitToStart boolValue]; |
---|
1707 | fResumeOnWake = NO; |
---|
1708 | |
---|
1709 | fOrderValue = orderValue ? [orderValue intValue] : tr_sessionCountTorrents(lib) - 1; |
---|
1710 | fGroupValue = groupValue ? [groupValue intValue] : [[GroupsController groups] groupIndexForTorrent: self]; |
---|
1711 | |
---|
1712 | fAddedTrackers = addedTrackers ? [addedTrackers boolValue] : NO; |
---|
1713 | |
---|
1714 | [self createFileList]; |
---|
1715 | |
---|
1716 | [[NSNotificationCenter defaultCenter] addObserver: self selector: @selector(checkGroupValueForRemoval:) |
---|
1717 | name: @"GroupValueRemoved" object: nil]; |
---|
1718 | |
---|
1719 | [self update]; |
---|
1720 | |
---|
1721 | //mark incomplete files to be ignored by Time Machine |
---|
1722 | [self setTimeMachineExclude: ![self allDownloaded] forPath: [[self downloadFolder] stringByAppendingPathComponent: [self name]]]; |
---|
1723 | |
---|
1724 | return self; |
---|
1725 | } |
---|
1726 | |
---|
1727 | - (void) createFileList |
---|
1728 | { |
---|
1729 | if ([self isFolder]) |
---|
1730 | { |
---|
1731 | NSInteger count = [self fileCount]; |
---|
1732 | NSMutableArray * fileList = [[NSMutableArray alloc] initWithCapacity: count], |
---|
1733 | * flatFileList = [[NSMutableArray alloc] initWithCapacity: count]; |
---|
1734 | |
---|
1735 | for (NSInteger i = 0; i < count; i++) |
---|
1736 | { |
---|
1737 | tr_file * file = &fInfo->files[i]; |
---|
1738 | |
---|
1739 | NSMutableArray * pathComponents = [[[NSString stringWithUTF8String: file->name] pathComponents] mutableCopy]; |
---|
1740 | NSString * path = [pathComponents objectAtIndex: 0]; |
---|
1741 | NSString * name = [pathComponents objectAtIndex: 1]; |
---|
1742 | [pathComponents removeObjectsAtIndexes: [NSIndexSet indexSetWithIndexesInRange: NSMakeRange(0, 2)]]; |
---|
1743 | |
---|
1744 | if ([pathComponents count] > 0) |
---|
1745 | { |
---|
1746 | //determine if folder node already exists |
---|
1747 | NSEnumerator * enumerator = [fileList objectEnumerator]; |
---|
1748 | FileListNode * node; |
---|
1749 | while ((node = [enumerator nextObject])) |
---|
1750 | if ([[node name] isEqualToString: name] && [node isFolder]) |
---|
1751 | break; |
---|
1752 | |
---|
1753 | if (!node) |
---|
1754 | { |
---|
1755 | node = [[FileListNode alloc] initWithFolderName: name path: path]; |
---|
1756 | [fileList addObject: node]; |
---|
1757 | [node release]; |
---|
1758 | } |
---|
1759 | |
---|
1760 | [node insertIndex: i withSize: file->length]; |
---|
1761 | [self insertPath: pathComponents forParent: node fileSize: file->length index: i flatList: flatFileList]; |
---|
1762 | } |
---|
1763 | else |
---|
1764 | { |
---|
1765 | FileListNode * node = [[FileListNode alloc] initWithFileName: name path: path size: file->length index: i]; |
---|
1766 | [fileList addObject: node]; |
---|
1767 | [flatFileList addObject: node]; |
---|
1768 | [node release]; |
---|
1769 | } |
---|
1770 | |
---|
1771 | [pathComponents release]; |
---|
1772 | } |
---|
1773 | |
---|
1774 | fFileList = [[NSArray alloc] initWithArray: fileList]; |
---|
1775 | [fileList release]; |
---|
1776 | |
---|
1777 | fFlatFileList = [[NSArray alloc] initWithArray: flatFileList]; |
---|
1778 | [flatFileList release]; |
---|
1779 | } |
---|
1780 | else |
---|
1781 | { |
---|
1782 | FileListNode * node = [[FileListNode alloc] initWithFileName: [self name] path: @"" size: [self size] index: 0]; |
---|
1783 | fFileList = [[NSArray arrayWithObject: node] retain]; |
---|
1784 | fFlatFileList = [fFileList copy]; |
---|
1785 | [node release]; |
---|
1786 | } |
---|
1787 | } |
---|
1788 | |
---|
1789 | - (void) insertPath: (NSMutableArray *) components forParent: (FileListNode *) parent fileSize: (uint64_t) size |
---|
1790 | index: (NSInteger) index flatList: (NSMutableArray *) flatFileList |
---|
1791 | { |
---|
1792 | NSString * name = [components objectAtIndex: 0]; |
---|
1793 | BOOL isFolder = [components count] > 1; |
---|
1794 | |
---|
1795 | FileListNode * node = nil; |
---|
1796 | if (isFolder) |
---|
1797 | { |
---|
1798 | NSEnumerator * enumerator = [[parent children] objectEnumerator]; |
---|
1799 | while ((node = [enumerator nextObject])) |
---|
1800 | if ([[node name] isEqualToString: name] && [node isFolder]) |
---|
1801 | break; |
---|
1802 | } |
---|
1803 | |
---|
1804 | //create new folder or file if it doesn't already exist |
---|
1805 | if (!node) |
---|
1806 | { |
---|
1807 | if (isFolder) |
---|
1808 | node = [[FileListNode alloc] initWithFolderName: name path: [parent fullPath]]; |
---|
1809 | else |
---|
1810 | { |
---|
1811 | node = [[FileListNode alloc] initWithFileName: name path: [parent fullPath] size: size index: index]; |
---|
1812 | [flatFileList addObject: node]; |
---|
1813 | } |
---|
1814 | |
---|
1815 | [parent insertChild: node]; |
---|
1816 | [node release]; |
---|
1817 | } |
---|
1818 | |
---|
1819 | if (isFolder) |
---|
1820 | { |
---|
1821 | [node insertIndex: index withSize: size]; |
---|
1822 | |
---|
1823 | [components removeObjectAtIndex: 0]; |
---|
1824 | [self insertPath: components forParent: node fileSize: size index: index flatList: flatFileList]; |
---|
1825 | } |
---|
1826 | } |
---|
1827 | |
---|
1828 | - (BOOL) shouldUseIncompleteFolderForName: (NSString *) name |
---|
1829 | { |
---|
1830 | return fUseIncompleteFolder && |
---|
1831 | ![[NSFileManager defaultManager] fileExistsAtPath: [fDownloadFolder stringByAppendingPathComponent: name]]; |
---|
1832 | } |
---|
1833 | |
---|
1834 | - (void) updateDownloadFolder |
---|
1835 | { |
---|
1836 | //remove old Time Machine location |
---|
1837 | [self setTimeMachineExclude: NO forPath: [[self downloadFolder] stringByAppendingPathComponent: [self name]]]; |
---|
1838 | |
---|
1839 | NSString * folder = [self shouldUseIncompleteFolderForName: [self name]] ? fIncompleteFolder : fDownloadFolder; |
---|
1840 | tr_torrentSetDownloadDir(fHandle, [folder UTF8String]); |
---|
1841 | |
---|
1842 | [self setTimeMachineExclude: ![self allDownloaded] forPath: [folder stringByAppendingPathComponent: [self name]]]; |
---|
1843 | } |
---|
1844 | |
---|
1845 | //status has been retained |
---|
1846 | - (void) completenessChange: (NSNumber *) status |
---|
1847 | { |
---|
1848 | fStat = tr_torrentStat(fHandle); //don't call update yet to avoid auto-stop |
---|
1849 | |
---|
1850 | BOOL canMove; |
---|
1851 | switch ([status intValue]) |
---|
1852 | { |
---|
1853 | case TR_SEED: |
---|
1854 | case TR_PARTIAL_SEED: |
---|
1855 | canMove = YES; |
---|
1856 | |
---|
1857 | //move file from incomplete folder to download folder |
---|
1858 | if (fUseIncompleteFolder && ![[self downloadFolder] isEqualToString: fDownloadFolder] |
---|
1859 | && (canMove = [self alertForMoveFolderAvailable])) |
---|
1860 | { |
---|
1861 | [self quickPause]; |
---|
1862 | |
---|
1863 | if ([[NSFileManager defaultManager] movePath: [[self downloadFolder] stringByAppendingPathComponent: [self name]] |
---|
1864 | toPath: [fDownloadFolder stringByAppendingPathComponent: [self name]] handler: nil]) |
---|
1865 | [self updateDownloadFolder]; |
---|
1866 | else |
---|
1867 | canMove = NO; |
---|
1868 | |
---|
1869 | [self endQuickPause]; |
---|
1870 | } |
---|
1871 | |
---|
1872 | if (!canMove) |
---|
1873 | { |
---|
1874 | fUseIncompleteFolder = NO; |
---|
1875 | |
---|
1876 | [fDownloadFolder release]; |
---|
1877 | fDownloadFolder = fIncompleteFolder; |
---|
1878 | fIncompleteFolder = nil; |
---|
1879 | } |
---|
1880 | |
---|
1881 | //allow to be backed up by Time Machine |
---|
1882 | [self setTimeMachineExclude: NO forPath: [[self downloadFolder] stringByAppendingPathComponent: [self name]]]; |
---|
1883 | |
---|
1884 | [[NSNotificationCenter defaultCenter] postNotificationName: @"TorrentFinishedDownloading" object: self]; |
---|
1885 | break; |
---|
1886 | |
---|
1887 | case TR_LEECH: |
---|
1888 | //do not allow to be backed up by Time Machine |
---|
1889 | [self setTimeMachineExclude: YES forPath: [[self downloadFolder] stringByAppendingPathComponent: [self name]]]; |
---|
1890 | |
---|
1891 | [[NSNotificationCenter defaultCenter] postNotificationName: @"TorrentRestartedDownloading" object: self]; |
---|
1892 | break; |
---|
1893 | } |
---|
1894 | [status release]; |
---|
1895 | |
---|
1896 | [self update]; |
---|
1897 | } |
---|
1898 | |
---|
1899 | - (void) quickPause |
---|
1900 | { |
---|
1901 | if (fQuickPauseDict) |
---|
1902 | return; |
---|
1903 | |
---|
1904 | fQuickPauseDict = [[NSDictionary alloc] initWithObjectsAndKeys: |
---|
1905 | [NSNumber numberWithInt: [self speedMode: YES]], @"UploadSpeedMode", |
---|
1906 | [NSNumber numberWithInt: [self speedLimit: YES]], @"UploadSpeedLimit", |
---|
1907 | [NSNumber numberWithInt: [self speedMode: NO]], @"DownloadSpeedMode", |
---|
1908 | [NSNumber numberWithInt: [self speedLimit: NO]], @"DownloadSpeedLimit", nil]; |
---|
1909 | |
---|
1910 | [self setSpeedMode: TR_SPEEDLIMIT_SINGLE upload: YES]; |
---|
1911 | [self setSpeedLimit: 0 upload: YES]; |
---|
1912 | [self setSpeedMode: TR_SPEEDLIMIT_SINGLE upload: NO]; |
---|
1913 | [self setSpeedLimit: 0 upload: NO]; |
---|
1914 | } |
---|
1915 | |
---|
1916 | - (void) endQuickPause |
---|
1917 | { |
---|
1918 | if (!fQuickPauseDict) |
---|
1919 | return; |
---|
1920 | |
---|
1921 | [self setSpeedMode: [[fQuickPauseDict objectForKey: @"UploadSpeedMode"] intValue] upload: YES]; |
---|
1922 | [self setSpeedLimit: [[fQuickPauseDict objectForKey: @"UploadSpeedLimit"] intValue] upload: YES]; |
---|
1923 | [self setSpeedMode: [[fQuickPauseDict objectForKey: @"DownloadSpeedMode"] intValue] upload: NO]; |
---|
1924 | [self setSpeedLimit: [[fQuickPauseDict objectForKey: @"DownloadSpeedLimit"] intValue] upload: NO]; |
---|
1925 | |
---|
1926 | [fQuickPauseDict release]; |
---|
1927 | fQuickPauseDict = nil; |
---|
1928 | } |
---|
1929 | |
---|
1930 | - (NSString *) etaString: (NSInteger) eta |
---|
1931 | { |
---|
1932 | switch (eta) |
---|
1933 | { |
---|
1934 | case TR_ETA_NOT_AVAIL: |
---|
1935 | case TR_ETA_UNKNOWN: |
---|
1936 | return NSLocalizedString(@"remaining time unknown", "Torrent -> eta string"); |
---|
1937 | default: |
---|
1938 | return [NSString stringWithFormat: NSLocalizedString(@"%@ remaining", "Torrent -> eta string"), |
---|
1939 | [NSString timeString: eta showSeconds: YES maxFields: 2]]; |
---|
1940 | } |
---|
1941 | } |
---|
1942 | |
---|
1943 | - (void) updateAllTrackers: (NSMutableArray *) trackers |
---|
1944 | { |
---|
1945 | //get count |
---|
1946 | NSInteger count = 0; |
---|
1947 | NSEnumerator * enumerator = [trackers objectEnumerator]; |
---|
1948 | id object; |
---|
1949 | while ((object = [enumerator nextObject])) |
---|
1950 | if (![object isKindOfClass: [NSNumber class]]) |
---|
1951 | count++; |
---|
1952 | |
---|
1953 | //recreate the tracker structure |
---|
1954 | tr_tracker_info * trackerStructs = tr_new(tr_tracker_info, count); |
---|
1955 | NSInteger tier = 0, i = 0; |
---|
1956 | enumerator = [trackers objectEnumerator]; |
---|
1957 | while ((object = [enumerator nextObject])) |
---|
1958 | { |
---|
1959 | if (![object isKindOfClass: [NSNumber class]]) |
---|
1960 | { |
---|
1961 | trackerStructs[i].tier = tier; |
---|
1962 | trackerStructs[i].announce = (char *)[object UTF8String]; |
---|
1963 | i++; |
---|
1964 | } |
---|
1965 | else |
---|
1966 | tier++; |
---|
1967 | } |
---|
1968 | |
---|
1969 | tr_torrentSetAnnounceList(fHandle, trackerStructs, count); |
---|
1970 | tr_free(trackerStructs); |
---|
1971 | } |
---|
1972 | |
---|
1973 | + (void) trashFile: (NSString *) path |
---|
1974 | { |
---|
1975 | //attempt to move to trash |
---|
1976 | if (![[NSWorkspace sharedWorkspace] performFileOperation: NSWorkspaceRecycleOperation |
---|
1977 | source: [path stringByDeletingLastPathComponent] destination: @"" |
---|
1978 | files: [NSArray arrayWithObject: [path lastPathComponent]] tag: nil]) |
---|
1979 | { |
---|
1980 | //if cannot trash, just delete it (will work if it's on a remote volume) |
---|
1981 | NSError * error; |
---|
1982 | if (![[NSFileManager defaultManager] removeItemAtPath: path error: &error]) |
---|
1983 | NSLog(@"Could not trash %@: %@", path, [error localizedDescription]); |
---|
1984 | } |
---|
1985 | } |
---|
1986 | |
---|
1987 | - (void) setTimeMachineExclude: (BOOL) exclude forPath: (NSString *) path |
---|
1988 | { |
---|
1989 | CSBackupSetItemExcluded((CFURLRef)[NSURL fileURLWithPath: path], exclude, true); |
---|
1990 | } |
---|
1991 | |
---|
1992 | @end |
---|