mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/chimera/ProgressDlgController.mm

653 строки
26 KiB
Plaintext
Исходник Ответственный История

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Netscape Public License
* Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/NPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is mozilla.org code.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 2002
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the NPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the NPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#import "ProgressDlgController.h"
#include "nsCOMPtr.h"
#include "nsString.h"
#include "nsCRT.h"
#include "nsIWebBrowserPersist.h"
#include "nsIInputStream.h"
#include "nsIURL.h"
#include "nsILocalFile.h"
#include "nsIDOMHTMLDocument.h"
#include "nsIWebProgressListener.h"
#include "nsIComponentManager.h"
#include "nsIPref.h"
class nsDownloadListener : public nsIWebProgressListener
{
public:
nsDownloadListener(ProgressDlgController* aController,
nsIWebBrowserPersist* aPersist,
nsISupports* aSource,
NSString* aDestination,
const char* aContentType,
nsIInputStream* aPostData,
BOOL aBypassCache)
{
NS_INIT_REFCNT();
mController = aController;
mWebPersist = aPersist;
// The source is either a simple URL or a complete document.
mURL = do_QueryInterface(aSource);
if (!mURL)
mDocument = do_QueryInterface(aSource);
PRUint32 dstLen = [aDestination length];
PRUnichar* tmp = new PRUnichar[dstLen + sizeof(PRUnichar)];
tmp[dstLen] = (PRUnichar)'\0';
[aDestination getCharacters:tmp];
nsAutoString dstStr ( tmp );
delete tmp;
NS_NewLocalFile(dstStr, PR_FALSE, getter_AddRefs(mDestination));
mContentType = aContentType;
mPostData = aPostData;
mBypassCache = aBypassCache;
};
virtual ~nsDownloadListener() {};
NS_DECL_ISUPPORTS
NS_DECL_NSIWEBPROGRESSLISTENER
public:
void BeginDownload();
void InitDialog();
void CancelDownload();
private: // Member variables
ProgressDlgController* mController; // Controller for our UI.
nsCOMPtr<nsIWebBrowserPersist> mWebPersist; // Our web persist object.
nsCOMPtr<nsIURL> mURL; // The URL of our source file. Null if we're saving a complete document.
nsCOMPtr<nsILocalFile> mDestination; // Our destination URL.
nsCString mContentType; // Our content type string.
nsCOMPtr<nsIDOMHTMLDocument> mDocument; // A DOM document. Null if we're only saving a simple URL.
nsCOMPtr<nsIInputStream> mPostData; // For complete documents, this is our post data from session history.
PRBool mBypassCache; // Whether we should bypass the cache or not.
};
NS_IMPL_ISUPPORTS1(nsDownloadListener, nsIWebProgressListener)
/* void onProgressChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in long aCurSelfProgress, in long aMaxSelfProgress, in long aCurTotalProgress, in long aMaxTotalProgress); */
NS_IMETHODIMP
nsDownloadListener::OnProgressChange(nsIWebProgress *aWebProgress,
nsIRequest *aRequest,
PRInt32 aCurSelfProgress,
PRInt32 aMaxSelfProgress,
PRInt32 aCurTotalProgress,
PRInt32 aMaxTotalProgress)
{
[mController setProgressBar:aCurTotalProgress maxProg:aMaxTotalProgress];
return NS_OK;
}
/* void onLocationChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in nsIURI location); */
NS_IMETHODIMP
nsDownloadListener::OnLocationChange(nsIWebProgress *aWebProgress,
nsIRequest *aRequest,
nsIURI *location)
{
return NS_OK;
}
/* void onStatusChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in nsresult aStatus, in wstring aMessage); */
NS_IMETHODIMP
nsDownloadListener::OnStatusChange(nsIWebProgress *aWebProgress,
nsIRequest *aRequest,
nsresult aStatus,
const PRUnichar *aMessage)
{
return NS_OK;
}
/* void onSecurityChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in unsigned long state); */
NS_IMETHODIMP
nsDownloadListener::OnSecurityChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, PRUint32 state)
{
return NS_OK;
}
// Implementation of nsIWebProgressListener
/* void onStateChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in unsigned long aStateFlags, in unsigned long aStatus); */
NS_IMETHODIMP
nsDownloadListener::OnStateChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, PRUint32 aStateFlags,
PRUint32 aStatus)
{
// when the entire download finishes, stop the progress timer and clean up
// the window and controller
if ((aStateFlags & STATE_STOP) && (aStateFlags & STATE_IS_NETWORK)) {
[mController killDownloadTimer];
[mController setDownloadProgress:nil];
}
return NS_OK;
}
void
nsDownloadListener::BeginDownload()
{
if (mWebPersist) {
mWebPersist->SetProgressListener(this);
PRInt32 flags = nsIWebBrowserPersist::PERSIST_FLAGS_NO_CONVERSION |
nsIWebBrowserPersist::PERSIST_FLAGS_REPLACE_EXISTING_FILES;
if (mBypassCache)
flags |= nsIWebBrowserPersist::PERSIST_FLAGS_BYPASS_CACHE;
else
flags |= nsIWebBrowserPersist::PERSIST_FLAGS_FROM_CACHE;
if (mURL)
mWebPersist->SaveURI(mURL, mPostData, mDestination);
else {
PRInt32 encodingFlags = 0;
nsCOMPtr<nsILocalFile> filesFolder;
if (!mContentType.Equals("text/plain")) {
// Create a local directory in the same dir as our file. It
// will hold our associated files.
filesFolder = do_CreateInstance("@mozilla.org/file/local;1");
nsAutoString unicodePath;
mDestination->GetPath(unicodePath);
filesFolder->InitWithPath(unicodePath);
nsAutoString leafName;
filesFolder->GetLeafName(leafName);
nsAutoString nameMinusExt(leafName);
PRInt32 index = nameMinusExt.RFind(".");
if (index >= 0)
nameMinusExt.Left(nameMinusExt, index);
nameMinusExt += NS_LITERAL_STRING(" Files"); // XXXdwh needs to be localizable!
filesFolder->SetLeafName(nameMinusExt);
PRBool exists = PR_FALSE;
filesFolder->Exists(&exists);
if (!exists)
filesFolder->Create(nsILocalFile::DIRECTORY_TYPE, 0755);
}
else
encodingFlags |= nsIWebBrowserPersist::ENCODE_FLAGS_FORMATTED |
nsIWebBrowserPersist::ENCODE_FLAGS_ABSOLUTE_LINKS |
nsIWebBrowserPersist::ENCODE_FLAGS_NOFRAMES_CONTENT;
mWebPersist->SaveDocument(mDocument, mDestination, filesFolder, mContentType.get(),
encodingFlags, 80);
}
}
InitDialog();
}
void
nsDownloadListener::InitDialog()
{
if (!mURL && !mDocument)
return;
if (mWebPersist) {
if (mURL) {
nsCAutoString spec;
mURL->GetSpec(spec);
nsAutoString spec2; spec2.AssignWithConversion(spec.get());
[mController setSourceURL: spec2.get()];
}
else {
nsAutoString spec;
mDocument->GetURL(spec);
[mController setSourceURL: spec.get()];
}
}
nsAutoString pathStr;
mDestination->GetPath(pathStr);
[mController setDestination: pathStr.get()];
[mController setDownloadTimer];
}
void
nsDownloadListener::CancelDownload()
{
if (mWebPersist)
mWebPersist->CancelSave();
}
static NSString *SaveFileToolbarIdentifier = @"Save File Dialog Toolbar";
static NSString *CancelToolbarItemIdentifier = @"Cancel Toolbar Item";
static NSString *PauseResumeToolbarItemIdentifier = @"Pause and Resume Toggle Toolbar Item";
static NSString *ShowFileToolbarItemIdentifier = @"Show File Toolbar Item";
static NSString *OpenFileToolbarItemIdentifier = @"Open File Toolbar Item";
static NSString *LeaveOpenToolbarItemIdentifier = @"Leave Open Toggle Toolbar Item";
@interface ProgressDlgController(Private)
-(void)setupToolbar;
@end
@implementation ProgressDlgController
-(void)setWebPersist:(nsIWebBrowserPersist*)aPersist
source:(nsISupports*)aSource
destination:(NSString*)aDestination
contentType:(const char*)aContentType
postData:(nsIInputStream*)aInputStream
bypassCache:(BOOL)aBypassCache
{
mDownloadListener = new nsDownloadListener(self, aPersist, aSource,
aDestination, aContentType,
aInputStream, aBypassCache);
NS_ADDREF(mDownloadListener);
}
-(void) setProgressBar:(long int)curProgress maxProg:(long int)maxProgress
{
aCurrentProgress = curProgress; // fall back for stat calcs
if (![mProgressBar isIndeterminate]) { //most likely - just update value
if (curProgress == maxProgress) //handles little bug in FTP download size
[mProgressBar setMaxValue:maxProgress];
[mProgressBar setDoubleValue:curProgress];
}
else if (maxProgress > 0) { // ok, we're starting up with good max & cur values
[mProgressBar setIndeterminate:NO];
[mProgressBar setMaxValue:maxProgress];
[mProgressBar setDoubleValue:curProgress];
} // if neither case was true, it's barber pole city.
}
-(void) setSourceURL: (const PRUnichar*)aSource
{
[mFromField setStringValue: [NSString stringWithCharacters:aSource length:nsCRT::strlen(aSource)]];
}
-(void) setDestination: (const PRUnichar*)aDestination
{
[mToField setStringValue: [[NSString stringWithCharacters:aDestination length:nsCRT::strlen(aDestination)] stringByAbbreviatingWithTildeInPath]];
}
- (void)windowDidLoad
{
mDownloadIsPaused = NO;
mDownloadIsComplete = NO;
nsCOMPtr<nsIPref> prefs(do_GetService(NS_PREF_CONTRACTID));
PRBool save = PR_FALSE;
prefs->GetBoolPref("browser.download.progressDnldDialog.keepAlive",&save);
mSaveFileDialogShouldStayOpen = save;
[self setupToolbar];
[mProgressBar setUsesThreadedAnimation:YES];
[mProgressBar startAnimation:self];
if (mDownloadListener)
mDownloadListener->BeginDownload();
}
- (void)setupToolbar
{
NSToolbar *toolbar = [[[NSToolbar alloc] initWithIdentifier:SaveFileToolbarIdentifier] autorelease];
[toolbar setDisplayMode:NSToolbarDisplayModeDefault];
[toolbar setAllowsUserCustomization:YES];
[toolbar setAutosavesConfiguration:YES];
[toolbar setDelegate:self];
[[self window] setToolbar:toolbar];
}
- (NSArray *)toolbarAllowedItemIdentifiers:(NSToolbar *)toolbar
{
return [NSArray arrayWithObjects: CancelToolbarItemIdentifier,
PauseResumeToolbarItemIdentifier,
ShowFileToolbarItemIdentifier,
OpenFileToolbarItemIdentifier,
LeaveOpenToolbarItemIdentifier,
NSToolbarCustomizeToolbarItemIdentifier,
NSToolbarFlexibleSpaceItemIdentifier,
NSToolbarSpaceItemIdentifier,
NSToolbarSeparatorItemIdentifier,
nil];
}
- (NSArray *)toolbarDefaultItemIdentifiers:(NSToolbar *)toolbar
{
return [NSArray arrayWithObjects: CancelToolbarItemIdentifier,
PauseResumeToolbarItemIdentifier,
NSToolbarFlexibleSpaceItemIdentifier,
LeaveOpenToolbarItemIdentifier,
NSToolbarFlexibleSpaceItemIdentifier,
ShowFileToolbarItemIdentifier,
OpenFileToolbarItemIdentifier,
nil];
}
- (BOOL)validateToolbarItem:(NSToolbarItem *)toolbarItem
{
if ([toolbarItem action] == @selector(cancel)) // cancel button
return (!mDownloadIsComplete);
if ([toolbarItem action] == @selector(pauseAndResumeDownload)) // pause/resume button
return (NO); // Hey - it hasn't been hooked up yet. !mDownloadIsComplete when it is.
if ([toolbarItem action] == @selector(showFile)) // show file
return (mDownloadIsComplete);
if ([toolbarItem action] == @selector(openFile)) // open file
return (mDownloadIsComplete);
return YES; // turn it on otherwise.
}
- (NSToolbarItem *) toolbar:(NSToolbar *)toolbar
itemForItemIdentifier:(NSString *)itemIdent
willBeInsertedIntoToolbar:(BOOL)willBeInserted
{
NSToolbarItem *toolbarItem = [[[NSToolbarItem alloc] initWithItemIdentifier:itemIdent] autorelease];
if ( [itemIdent isEqual:CancelToolbarItemIdentifier] ) {
[toolbarItem setLabel:@"Cancel"];
[toolbarItem setPaletteLabel:@"Cancel Download"];
[toolbarItem setToolTip:@"Cancel this file download"];
[toolbarItem setImage:[NSImage imageNamed:@"saveCancel"]];
[toolbarItem setTarget:self];
[toolbarItem setAction:@selector(cancel)];
} else if ( [itemIdent isEqual:PauseResumeToolbarItemIdentifier] ) {
[toolbarItem setLabel:@"Pause"];
[toolbarItem setPaletteLabel:@"Pause Download"];
[toolbarItem setToolTip:@"Pause this FTP file download"];
[toolbarItem setImage:[NSImage imageNamed:@"savePause"]];
[toolbarItem setTarget:self];
[toolbarItem setAction:@selector(pauseAndResumeDownload)];
if ( willBeInserted ) {
pauseResumeToggleToolbarItem = toolbarItem; //establish reference
}
} else if ( [itemIdent isEqual:ShowFileToolbarItemIdentifier] ) {
[toolbarItem setLabel:@"Show File"];
[toolbarItem setPaletteLabel:@"Show File"];
[toolbarItem setToolTip:@"Show the saved file in the Finder"];
[toolbarItem setImage:[NSImage imageNamed:@"saveShowFile"]];
[toolbarItem setTarget:self];
[toolbarItem setAction:@selector(showFile)];
} else if ( [itemIdent isEqual:OpenFileToolbarItemIdentifier] ) {
[toolbarItem setLabel:@"Open File"];
[toolbarItem setPaletteLabel:@"Open File"];
[toolbarItem setToolTip:@"Open the saved file in its default application."];
[toolbarItem setImage:[NSImage imageNamed:@"saveOpenFile"]];
[toolbarItem setTarget:self];
[toolbarItem setAction:@selector(openFile)];
} else if ( [itemIdent isEqual:LeaveOpenToolbarItemIdentifier] ) {
if ( mSaveFileDialogShouldStayOpen ) {
[toolbarItem setLabel:@"Leave Open"];
[toolbarItem setPaletteLabel:@"Toggle Close Behavior"];
[toolbarItem setToolTip:@"Window will stay open when download finishes."];
[toolbarItem setImage:[NSImage imageNamed:@"saveLeaveOpenYES"]];
[toolbarItem setTarget:self];
[toolbarItem setAction:@selector(toggleLeaveOpen)];
} else {
[toolbarItem setLabel:@"Close When Done"];
[toolbarItem setPaletteLabel:@"Toggle Close Behavior"];
[toolbarItem setToolTip:@"Window will close automatically when download finishes."];
[toolbarItem setImage:[NSImage imageNamed:@"saveLeaveOpenNO"]];
[toolbarItem setTarget:self];
[toolbarItem setAction:@selector(toggleLeaveOpen)];
}
if ( willBeInserted ) {
leaveOpenToggleToolbarItem = toolbarItem; //establish reference
}
} else {
toolbarItem = nil;
}
return toolbarItem;
}
-(void)cancel
{
mDownloadListener->CancelDownload();
// clean up downloaded file. - do it here on in CancelDownload?
NSFileManager *fileManager = [NSFileManager defaultManager];
NSString *thePath = [[mToField stringValue] stringByExpandingTildeInPath];
if ([fileManager isDeletableFileAtPath:thePath])
// if we delete it, fantastic. if not, oh well. better to move to trash instead?
[fileManager removeFileAtPath:thePath handler:nil];
mDownloadIsComplete = YES; // don't have to do this again.
}
-(void)pauseAndResumeDownload
{
if ( ! mDownloadIsPaused ) {
//Do logic to pause download
mDownloadIsPaused = YES;
[pauseResumeToggleToolbarItem setLabel:@"Resume"];
[pauseResumeToggleToolbarItem setPaletteLabel:@"Resume Download"];
[pauseResumeToggleToolbarItem setToolTip:@"Resume the paused FTP download"];
[pauseResumeToggleToolbarItem setImage:[NSImage imageNamed:@"saveResume"]];
[self killDownloadTimer];
} else {
//Do logic to resume download
mDownloadIsPaused = NO;
[pauseResumeToggleToolbarItem setLabel:@"Pause"];
[pauseResumeToggleToolbarItem setPaletteLabel:@"Pause Download"];
[pauseResumeToggleToolbarItem setToolTip:@"Pause this FTP file download"];
[pauseResumeToggleToolbarItem setImage:[NSImage imageNamed:@"savePause"]];
[self setDownloadTimer];
}
}
-(void)showFile
{
NSString *theFile = [[mToField stringValue] stringByExpandingTildeInPath];
if ([[NSWorkspace sharedWorkspace] selectFile:theFile
inFileViewerRootedAtPath:[theFile stringByDeletingLastPathComponent]])
return;
// hmmm. it didn't work. that's odd. need localized error messages. for now, just beep.
NSBeep();
}
-(void)openFile
{
NSString *theFile = [[mToField stringValue] stringByExpandingTildeInPath];
if ([[NSWorkspace sharedWorkspace] openFile:theFile])
return;
// hmmm. it didn't work. that's odd. need localized error message. for now, just beep.
NSBeep();
}
-(void)toggleLeaveOpen
{
if ( ! mSaveFileDialogShouldStayOpen ) {
mSaveFileDialogShouldStayOpen = YES;
[leaveOpenToggleToolbarItem setLabel:@"Leave Open"];
[leaveOpenToggleToolbarItem setPaletteLabel:@"Toggle Close Behavior"];
[leaveOpenToggleToolbarItem setToolTip:@"Window will stay open when download finishes."];
[leaveOpenToggleToolbarItem setImage:[NSImage imageNamed:@"saveLeaveOpenYES"]];
} else {
mSaveFileDialogShouldStayOpen = NO;
[leaveOpenToggleToolbarItem setLabel:@"Close When Done"];
[leaveOpenToggleToolbarItem setPaletteLabel:@"Toggle Close Behavior"];
[leaveOpenToggleToolbarItem setToolTip:@"Window will close automatically when download finishes."];
[leaveOpenToggleToolbarItem setImage:[NSImage imageNamed:@"saveLeaveOpenNO"]];
}
nsCOMPtr<nsIPref> prefs(do_GetService(NS_PREF_CONTRACTID));
prefs->SetBoolPref("browser.download.progressDnldDialog.keepAlive", mSaveFileDialogShouldStayOpen);
}
- (void)windowWillClose:(NSNotification *)notification
{
[self autorelease];
}
- (BOOL)windowShouldClose:(NSNotification *)notification
{
[self killDownloadTimer];
if (!mDownloadIsComplete) { //whoops. hard cancel.
[self cancel];
return NO; // let setDownloadProgress handle the close.
}
return YES;
}
- (void)dealloc
{
NS_IF_RELEASE(mDownloadListener);
[super dealloc];
}
- (void)killDownloadTimer
{
if (mDownloadTimer) {
[mDownloadTimer invalidate];
[mDownloadTimer release];
mDownloadTimer = nil;
}
}
- (void)setDownloadTimer
{
[self killDownloadTimer];
mDownloadTimer = [[NSTimer scheduledTimerWithTimeInterval:1.0
target:self
selector:@selector(setDownloadProgress:)
userInfo:nil
repeats:YES] retain];
}
-(NSString *)formatTime:(int)seconds
{
NSMutableString *theTime =[[[NSMutableString alloc] initWithCapacity:8] autorelease];
[theTime setString:@""];
NSString *padZero = [NSString stringWithString:@"0"];
//write out new elapsed time
if (seconds >= 3600){
[theTime appendFormat:@"%d:",(seconds / 3600)];
seconds = seconds % 3600;
}
NSString *elapsedMin = [NSString stringWithFormat:@"%d:",(seconds / 60)];
if ([elapsedMin length] == 2)
[theTime appendString:[padZero stringByAppendingString:elapsedMin]];
else
[theTime appendString:elapsedMin];
seconds = seconds % 60;
NSString *elapsedSec = [NSString stringWithFormat:@"%d",seconds];
if ([elapsedSec length] == 2)
[theTime appendString:elapsedSec];
else
[theTime appendString:[padZero stringByAppendingString:elapsedSec]];
return theTime;
}
// fuzzy time gives back strings like "about 5 seconds"
-(NSString *)formatFuzzyTime:(int)seconds
{
// check for seconds first
if (seconds < 60) {
if (seconds < 7)
return [[[NSString alloc] initWithFormat:[[NSBundle mainBundle] localizedStringForKey:@"UnderSec" value:@"Under %d seconds" table:@"ProgressDialog"],5] autorelease];
if (seconds < 13)
return [[[NSString alloc] initWithFormat:[[NSBundle mainBundle] localizedStringForKey:@"UnderSec" value:@"Under %d seconds" table:@"ProgressDialog"],10] autorelease];
return [[[NSString alloc] initWithString:[[NSBundle mainBundle] localizedStringForKey:@"UnderMin" value:@"Under a minute" table:@"ProgressDialog"]] autorelease];
}
// seconds becomes minutes and we keep checking.
seconds=seconds/60;
if (seconds < 60) {
if (seconds < 2)
return [[[NSString alloc] initWithString:[[NSBundle mainBundle] localizedStringForKey:@"AboutMin" value:@"About a minute" table:@"ProgressDialog"]] autorelease];
// OK, tell the good people how much time we have left.
return [[[NSString alloc] initWithFormat:[[NSBundle mainBundle] localizedStringForKey:@"AboutMins" value:@"About %d minutes" table:@"ProgressDialog"],seconds] autorelease];
}
//this download will never seemingly never end. now seconds become hours.
seconds=seconds/60;
if (seconds < 2)
return [[[NSString alloc] initWithString:[[NSBundle mainBundle] localizedStringForKey:@"AboutHour" value:@"Over an hour" table:@"ProgressDialog"]] autorelease];
return [[[NSString alloc] initWithFormat:[[NSBundle mainBundle] localizedStringForKey:@"AboutHours" value:@"Over %d hours" table:@"ProgressDialog"],seconds] autorelease];
}
-(NSString *)formatBytes:(float)bytes
{ // this is simpler than my first try. I peaked at Omnigroup byte formatting code.
// if bytes are negative, we return question marks.
if (bytes < 0)
return [[[NSString alloc] initWithString:@"???"] autorelease];
// bytes first.
if (bytes < 1024)
return [[[NSString alloc] initWithFormat:@"%.1f bytes",bytes] autorelease];
// kb
bytes = bytes/1024;
if (bytes < 1024)
return [[[NSString alloc] initWithFormat:@"%.1f KB",bytes] autorelease];
// mb
bytes = bytes/1024;
if (bytes < 1024)
return [[[NSString alloc] initWithFormat:@"%.1f MB",bytes] autorelease];
// gb
bytes = bytes/1024;
return [[[NSString alloc] initWithFormat:@"%.1f GB",bytes] autorelease];
}
// this handles lots of things.
- (void)setDownloadProgress:(NSTimer *)downloadTimer;
{
// Ack! we're closing the window with the download still running!
if (mDownloadIsComplete) {
[[self window] performClose:self];
return;
}
// get the elapsed time
NSArray *elapsedTimeArray = [[mElapsedTimeLabel stringValue] componentsSeparatedByString:@":"];
int j = [elapsedTimeArray count];
int elapsedSec = [[elapsedTimeArray objectAtIndex:(j-1)] intValue] + [[elapsedTimeArray objectAtIndex:(j-2)] intValue]*60;
if (j==3) // this download is taking forever.
elapsedSec += [[elapsedTimeArray objectAtIndex:0] intValue]*3600;
// update elapsed time
[mElapsedTimeLabel setStringValue:[self formatTime:(++elapsedSec)]];
// for status field & time left
float maxBytes = ([mProgressBar maxValue]);
float byteSec = aCurrentProgress/elapsedSec;
// OK - if downloadTimer is nil, we're done - fix maxBytes value for status report.
if (!downloadTimer)
maxBytes = aCurrentProgress;
// update status field
NSString *labelString = [[NSBundle mainBundle] localizedStringForKey:@"LabelString"
value:@"%@ of %@ total (at %@/sec)"
table:@"ProgressDialog"];
[mStatusLabel setStringValue: [NSString stringWithFormat:labelString, [self formatBytes:aCurrentProgress], [self formatBytes:maxBytes], [self formatBytes:byteSec]]];
// updating estimated time left field
// if maxBytes < 0, can't calc time left.
// if !downloadTimer, download is finished. either way, make sure time left is 0.
if ((maxBytes > 0) && (downloadTimer)) {
int secToGo = (int)ceil((elapsedSec*maxBytes/aCurrentProgress)-elapsedSec);
[mTimeLeftLabel setStringValue:[self formatFuzzyTime:secToGo]];
}
else if (!downloadTimer) { // download done. Set remaining time to 0, fix progress bar & cancel button
mDownloadIsComplete = YES; // all done.
[mTimeLeftLabel setStringValue:@""];
[self setProgressBar:aCurrentProgress maxProg:aCurrentProgress];
if (!mSaveFileDialogShouldStayOpen)
[[self window] performClose:self]; //close window
[[self window] update]; //redraw window
}
else //maxBytes is undetermined. Set remaining time to question marks.
[mTimeLeftLabel setStringValue:@"???"];
}
@end
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку