mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-25 17:43:44 +00:00
652 lines
26 KiB
Plaintext
652 lines
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)
|
|
{
|
|
if (aStateFlags & STATE_STOP) {
|
|
//it appears as if we finished.
|
|
[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
|