Diff for /chimera/NSBrowserView.mm between versions 1.1 and 1.29

version 1.1, 2002/01/31 20:18:48 version 1.29, 2002/04/08 22:30:20
Line 36 Line 36
  * ***** END LICENSE BLOCK ***** */   * ***** END LICENSE BLOCK ***** */
   
 #import "NSBrowserView.h"  #import "NSBrowserView.h"
   #import "ProgressDlgController.h"
   #import "FindDlgController.h"
 #import "nsCocoaBrowserService.h"  #import "nsCocoaBrowserService.h"
   
 // Embedding includes  // Embedding includes
Line 55 Line 57
 #include "nsXPIDLString.h"  #include "nsXPIDLString.h"
 #include "nsCOMPtr.h"  #include "nsCOMPtr.h"
   
   // Printing
   #include "nsIWebBrowserPrint.h"
   #include "nsIPrintSettings.h"
   
   // Saving of links/images/docs
   #include "nsIWebBrowserFocus.h"
   #include "nsIDOMHTMLDocument.h"
   #include "nsIDOMNSDocument.h"
   #include "nsIDOMLocation.h"
   #include "nsIURL.h"
   #include "nsIWebBrowserPersist.h"
   #include "nsIProperties.h"
   #include "nsIRequest.h"
   #include "nsIChannel.h"
   #include "nsIHttpChannel.h"
   #include "nsIPref.h"
   #include "nsIMIMEService.h"
   #include "nsIMIMEInfo.h"
   #include "nsISHistory.h"
   #include "nsIHistoryEntry.h"
   #include "nsISHEntry.h"
   #include "nsNetUtil.h"
   
   // Cut/copy/paste
   #include "nsIClipboardCommands.h"
   #include "nsIInterfaceRequestorUtils.h"
   
   const char* persistContractID = "@mozilla.org/embedding/browser/nsWebBrowserPersist;1";
   const char* dirServiceContractID = "@mozilla.org/file/directory_service;1";
   
 class nsCocoaBrowserListener : public nsSupportsWeakReference,  class nsCocoaBrowserListener : public nsSupportsWeakReference,
                                public nsIInterfaceRequestor,                                 public nsIInterfaceRequestor,
                               public nsIWebBrowserChrome,                                           public nsIWebBrowserChrome,
                               public nsIEmbeddingSiteWindow,                               public nsIWindowCreator,
                                            public nsIEmbeddingSiteWindow,
                                public nsIWebProgressListener                                 public nsIWebProgressListener
 {  {
 public:  public:
Line 69  public: Line 101  public:
   NS_DECL_ISUPPORTS    NS_DECL_ISUPPORTS
   NS_DECL_NSIINTERFACEREQUESTOR    NS_DECL_NSIINTERFACEREQUESTOR
   NS_DECL_NSIWEBBROWSERCHROME    NS_DECL_NSIWEBBROWSERCHROME
     NS_DECL_NSIWINDOWCREATOR
   NS_DECL_NSIEMBEDDINGSITEWINDOW    NS_DECL_NSIEMBEDDINGSITEWINDOW
   NS_DECL_NSIWEBPROGRESSLISTENER    NS_DECL_NSIWEBPROGRESSLISTENER
   
Line 100  nsCocoaBrowserListener::~nsCocoaBrowserL Line 133  nsCocoaBrowserListener::~nsCocoaBrowserL
   }    }
 }  }
   
NS_IMPL_ISUPPORTS5(nsCocoaBrowserListener,NS_IMPL_ISUPPORTS6(nsCocoaBrowserListener,
                    nsIInterfaceRequestor,                     nsIInterfaceRequestor,
                    nsIWebBrowserChrome,                     nsIWebBrowserChrome,
              nsIWindowCreator,
                    nsIEmbeddingSiteWindow,                     nsIEmbeddingSiteWindow,
                    nsIWebProgressListener,                     nsIWebProgressListener,
                   nsISupportsWeakReference)           nsISupportsWeakReference)
   
 // Implementation of nsIInterfaceRequestor  // Implementation of nsIInterfaceRequestor
 NS_IMETHODIMP   NS_IMETHODIMP 
Line 120  nsCocoaBrowserListener::GetInterface(con Line 154  nsCocoaBrowserListener::GetInterface(con
   return QueryInterface(aIID, aInstancePtr);    return QueryInterface(aIID, aInstancePtr);
 }  }
   
   // Implementation of nsIWindowCreator.  The CocoaBrowserService forwards requests
   // for a new window that have a parent to us, and we take over from there.  
   /* nsIWebBrowserChrome createChromeWindow (in nsIWebBrowserChrome parent, in PRUint32 chromeFlags); */
   NS_IMETHODIMP 
   nsCocoaBrowserListener::CreateChromeWindow(nsIWebBrowserChrome *parent, 
                                              PRUint32 chromeFlags, 
                                              nsIWebBrowserChrome **_retval)
   {
     if (parent != this) {
       printf("Mismatch in nsCocoaBrowserListener::CreateChromeWindow.  We should be the owning parent.\n");
       return NS_ERROR_FAILURE;
     }
     
     NSBrowserView* childView = [mContainer createBrowserWindow: chromeFlags];
     if (!childView) {
       printf("No NSBrowserView hooked up for a newly created window yet.\n");
       return NS_ERROR_FAILURE;
     }
     
     nsCocoaBrowserListener* listener = [childView getCocoaBrowserListener];
     if (!listener) {
       printf("Uh-oh! No listener yet for a newly created window (nsCocoaBrowserlistener)\n");
       return NS_ERROR_FAILURE;
     }
     
     printf("made a chrome window.\n");
     
     *_retval = listener;
     NS_IF_ADDREF(*_retval);
     return NS_OK;
   }
   
 // Implementation of nsIWebBrowserChrome  // Implementation of nsIWebBrowserChrome
 /* void setStatus (in unsigned long statusType, in wstring status); */  /* void setStatus (in unsigned long statusType, in wstring status); */
 NS_IMETHODIMP   NS_IMETHODIMP 
Line 225  nsCocoaBrowserListener::ShowAsModal() Line 291  nsCocoaBrowserListener::ShowAsModal()
   }    }
   
   mIsModal = PR_TRUE;    mIsModal = PR_TRUE;
  int result = [NSApp runModalForWindow:window];  //int result = [NSApp runModalForWindow:window];
   mIsModal = PR_FALSE;    mIsModal = PR_FALSE;
   
  return (nsresult)result;  return NS_OK;
 }  }
   
 /* boolean isWindowModal (); */  /* boolean isWindowModal (); */
Line 246  nsCocoaBrowserListener::IsWindowModal(PR Line 312  nsCocoaBrowserListener::IsWindowModal(PR
 NS_IMETHODIMP   NS_IMETHODIMP 
 nsCocoaBrowserListener::ExitModalEventLoop(nsresult aStatus)  nsCocoaBrowserListener::ExitModalEventLoop(nsresult aStatus)
 {  {
  [NSApp stopModalWithCode:(int)aStatus];//  [NSApp stopModalWithCode:(int)aStatus];
   
   return NS_OK;    return NS_OK;
 }  }
Line 505  nsCocoaBrowserListener::OnLocationChange Line 571  nsCocoaBrowserListener::OnLocationChange
                                          nsIRequest *aRequest,                                            nsIRequest *aRequest, 
                                          nsIURI *location)                                           nsIURI *location)
 {  {
  nsXPIDLCString spec;  if (!location)
   
  location->GetSpec(getter_Copies(spec)); 
  if (!spec) { 
     return NS_ERROR_FAILURE;      return NS_ERROR_FAILURE;
  }    
  nsCAutoString spec;
   location->GetSpec(spec);
   const char* cstr = spec.get();    const char* cstr = spec.get();
   NSString* str = [NSString stringWithCString:cstr];    NSString* str = [NSString stringWithCString:cstr];
   NSURL* url = [NSURL URLWithString:str];    NSURL* url = [NSURL URLWithString:str];
Line 533  nsCocoaBrowserListener::OnStatusChange(n Line 597  nsCocoaBrowserListener::OnStatusChange(n
                                        nsresult aStatus,                                          nsresult aStatus, 
                                        const PRUnichar *aMessage)                                         const PRUnichar *aMessage)
 {  {
     nsCAutoString msg; msg.AssignWithConversion(aMessage);
     
     NSString* str = [NSString stringWithCString:msg.get()];
     
     NSEnumerator* enumerator = [mListeners objectEnumerator];
     id obj;
    
     while ((obj = [enumerator nextObject])) {
       [obj onStatusChange: str];
     }
   
   return NS_OK;    return NS_OK;
 }  }
   
Line 567  nsCocoaBrowserListener::SetContainer(id  Line 642  nsCocoaBrowserListener::SetContainer(id 
   [mContainer retain];    [mContainer retain];
 }  }
   
   // Implementation of a header sniffer class that is used when saving Web pages and images.
   class nsHeaderSniffer :  public nsIWebProgressListener
   {
   public:
       nsHeaderSniffer(nsIWebBrowserPersist* aPersist, nsIFile* aFile, nsIURI* aURL,
                       nsIDOMDocument* aDocument, nsIInputStream* aPostData, PRBool aBypassCache,
                       NSView* aFilterView, NSPopUpButton* aFilterList)
       {
           NS_INIT_REFCNT();
           mPersist = aPersist;
           mTmpFile = aFile;
           mURL = aURL;
           mDocument = aDocument;
           mPostData = aPostData;
           mBypassCache = aBypassCache;
           mFilterView = aFilterView;
           mFilterList = aFilterList;
       }
                     
       virtual ~nsHeaderSniffer() 
       {
       };
   
       NS_DECL_ISUPPORTS
       NS_DECL_NSIWEBPROGRESSLISTENER
     
   protected:
       void PerformSave();
       
   private:
       nsIWebBrowserPersist* mPersist; // Weak. It owns us as a listener.
       nsCOMPtr<nsIFile> mTmpFile;
       nsCOMPtr<nsIURI> mURL;
       nsCOMPtr<nsIDOMDocument> mDocument;
       nsCOMPtr<nsIInputStream> mPostData;
       PRBool mBypassCache;
       nsCString mContentType;
       nsCString mContentDisposition;
       NSView* mFilterView;
       NSPopUpButton* mFilterList;
   };
   
   NS_IMPL_ISUPPORTS1(nsHeaderSniffer, nsIWebProgressListener)
   
   // Implementation of nsIWebProgressListener
   /* void onStateChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in long aStateFlags, in unsigned long aStatus); */
   NS_IMETHODIMP 
   nsHeaderSniffer::OnStateChange(nsIWebProgress *aWebProgress, 
                                         nsIRequest *aRequest, 
                                         PRInt32 aStateFlags, 
                                         PRUint32 aStatus)
   {
       if (aStateFlags & nsIWebProgressListener::STATE_START) {
           nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
           channel->GetContentType(mContentType);
          
           // Get the content-disposition if we're an HTTP channel.
           nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel));
           if (httpChannel)
               httpChannel->GetResponseHeader(nsCAutoString("content-disposition"), mContentDisposition);
           
           mPersist->CancelSave();
           PRBool exists;
           mTmpFile->Exists(&exists);
           if (exists)
               mTmpFile->Remove(PR_FALSE);
           PerformSave();
       }
       return NS_OK;
   }
   
   void nsHeaderSniffer::PerformSave()
   {
       // Are we an HTML document? If so, we will want to append an accessory view to
       // the save dialog to provide the user with the option of doing a complete
       // save vs. a single file save.
       PRBool isHTML = (mDocument && mContentType.Equals("text/html") ||
                        mContentType.Equals("text/xml") ||
                        mContentType.Equals("application/xhtml+xml"));
       
       // Next find out the directory that we should start in.
       nsCOMPtr<nsIPrefService> prefs(do_GetService("@mozilla.org/preferences-service;1"));
       if (!prefs)
           return;
       nsCOMPtr<nsIPrefBranch> dirBranch;
       prefs->GetBranch("browser.download.", getter_AddRefs(dirBranch));
       PRInt32 filterIndex = 0;
       if (dirBranch) {
           nsresult rv = dirBranch->GetIntPref("save_converter_index", &filterIndex);
           if (NS_FAILED(rv))
               filterIndex = 0;
       }
       if (mFilterList)
           [mFilterList selectItemAtIndex: filterIndex];
           
       // We need to figure out what file name to use.
       nsCAutoString defaultFileName;
       
       if (!mContentDisposition.IsEmpty()) {
           // (1) Use the HTTP header suggestion.
           PRInt32 index = mContentDisposition.Find("filename=");
           if (index >= 0) {
               // Take the substring following the prefix.
               index += 9;
               nsCAutoString filename;
               mContentDisposition.Right(filename, mContentDisposition.Length() - index);
               defaultFileName = filename;
           }
       }
       
       if (defaultFileName.IsEmpty()) {
           nsCOMPtr<nsIURL> url(do_QueryInterface(mURL));
           if (url)
               url->GetFileName(defaultFileName); // (2) For file URLs, use the file name.
       }
       
       if (defaultFileName.IsEmpty() && mDocument && isHTML) {
           nsCOMPtr<nsIDOMHTMLDocument> htmlDoc(do_QueryInterface(mDocument));
           nsAutoString title;
           if (htmlDoc)
               htmlDoc->GetTitle(title); // (3) Use the title of the document.
           defaultFileName.AssignWithConversion(title);
       }
       
       if (defaultFileName.IsEmpty()) {
           // (4) Use the caller provided name. XXXdwh
       }
   
       if (defaultFileName.IsEmpty())
           // (5) Use the host.
           mURL->GetHost(defaultFileName);
       
       // One last case to handle about:blank and other fruity untitled pages.
       if (defaultFileName.IsEmpty())
           defaultFileName = "untitled";
           
       // Validate the file name to ensure legality.
       for (PRUint32 i = 0; i < defaultFileName.Length(); i++)
           if (defaultFileName[i] == ':' || defaultFileName[i] == '/')
               defaultFileName.SetCharAt(i, ' ');
               
       // Make sure the appropriate extension is appended to the suggested file name.
       nsCOMPtr<nsIURI> fileURI(do_CreateInstance("@mozilla.org/network/standard-url;1"));
       nsCOMPtr<nsIURL> fileURL(do_QueryInterface(fileURI));
       if (!fileURL)
           return;
       fileURL->SetFilePath(defaultFileName);
       
       nsCAutoString fileExtension;
       fileURL->GetFileExtension(fileExtension);
       
       PRBool setExtension = PR_FALSE;
       if (mContentType.Equals("text/html")) {
           if (fileExtension.IsEmpty() || (!fileExtension.Equals("htm") && !fileExtension.Equals("html"))) {
               defaultFileName += ".html";
               setExtension = PR_TRUE;
           }
       }
       
       if (!setExtension && fileExtension.IsEmpty()) {
           nsCOMPtr<nsIMIMEService> mimeService(do_GetService("@mozilla.org/mime;1"));
           if (!mimeService)
               return;
           nsCOMPtr<nsIMIMEInfo> mimeInfo;
           mimeService->GetFromMIMEType(mContentType.get(), getter_AddRefs(mimeInfo));
           
           PRUint32 extCount;
           char** extList;
           mimeInfo->GetFileExtensions(&extCount, &extList);
           
           if (extCount > 0) {
               defaultFileName += ".";
               defaultFileName += extList[0];
           }
       }
       
       // Now it's time to pose the save dialog.
       NSSavePanel* savePanel = [NSSavePanel savePanel];
       NSString* file = nil;
       if (!defaultFileName.IsEmpty())
           file = [[NSString alloc] initWithCString: defaultFileName.get()];
           
       if (isHTML)
           [savePanel setAccessoryView: mFilterView];
           
       if ([savePanel runModalForDirectory: nil file: file] == NSFileHandlingPanelCancelButton)
           return;
          
       // Release the file string.
       [file release];
       
       // Update the filter index.
       if (isHTML && mFilterList) {
           filterIndex = [mFilterList indexOfSelectedItem];
           dirBranch->SetIntPref("save_converter_index", filterIndex);
       }
       
       // Convert the content type to text/plain if it was selected in the filter.
       if (isHTML && filterIndex == 2)
           mContentType = "text/plain";
       
       nsCOMPtr<nsISupports> sourceData;
       if (isHTML && filterIndex != 1)
           sourceData = do_QueryInterface(mDocument);
       else
           sourceData = do_QueryInterface(mURL);
           
       nsCOMPtr<nsIWebBrowserPersist> webPersist(do_CreateInstance(persistContractID));
       ProgressDlgController* progressDialog = [[ProgressDlgController alloc] initWithWindowNibName: @"ProgressDialog"];
       [progressDialog setWebPersist: webPersist 
                       source: sourceData.get()
                       destination: [savePanel filename]
                       contentType: mContentType.get()
                       postData: mPostData
                       bypassCache: mBypassCache];
                       
       [progressDialog showWindow: progressDialog];
   }
   
   /* void onProgressChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in long aCurSelfProgress, in long aMaxSelfProgress, in long aCurTotalProgress, in long aMaxTotalProgress); */
   NS_IMETHODIMP 
   nsHeaderSniffer::OnProgressChange(nsIWebProgress *aWebProgress, 
                                            nsIRequest *aRequest, 
                                            PRInt32 aCurSelfProgress, 
                                            PRInt32 aMaxSelfProgress, 
                                            PRInt32 aCurTotalProgress, 
                                            PRInt32 aMaxTotalProgress)
   {
     return NS_OK;
   }
   
   /* void onLocationChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in nsIURI location); */
   NS_IMETHODIMP 
   nsHeaderSniffer::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 
   nsHeaderSniffer::OnStatusChange(nsIWebProgress *aWebProgress, 
                                          nsIRequest *aRequest, 
                                          nsresult aStatus, 
                                          const PRUnichar *aMessage)
   {
     return NS_OK;
   }
   
   /* void onSecurityChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in long state); */
   NS_IMETHODIMP 
   nsHeaderSniffer::OnSecurityChange(nsIWebProgress *aWebProgress, 
                                                         nsIRequest *aRequest, 
                                     PRInt32 state)
   {
     return NS_OK;
   }
   
   
 @implementation NSBrowserView  @implementation NSBrowserView
   
Line 608  nsCocoaBrowserListener::SetContainer(id  Line 942  nsCocoaBrowserListener::SetContainer(id 
   return self;    return self;
 }  }
   
   - (void)destroyWebBrowser
   {
     nsCOMPtr<nsIBaseWindow> baseWin = do_QueryInterface(_webBrowser);
     baseWin->Destroy();
   }
   
 - (void)dealloc   - (void)dealloc 
 {  {
     [super dealloc];
     
   NS_RELEASE(_listener);    NS_RELEASE(_listener);
   NS_IF_RELEASE(_webBrowser);    NS_IF_RELEASE(_webBrowser);
  nsCocoaBrowserService::TermEmbedding();  
  nsCocoaBrowserService::BrowserClosed();
  [super dealloc];  
   printf("NSBrowserView died.\n");
 }  }
   
 - (void)setFrame:(NSRect)frameRect   - (void)setFrame:(NSRect)frameRect 
Line 769  nsCocoaBrowserListener::SetContainer(id  Line 1112  nsCocoaBrowserListener::SetContainer(id 
     return nsnull;      return nsnull;
   }    }
   
  nsXPIDLCString spec;  nsCAutoString spec;
  uri->GetSpec(getter_Copies(spec));  uri->GetSpec(spec);
       
   const char* cstr = spec.get();    const char* cstr = spec.get();
   NSString* str = [NSString stringWithCString:cstr];    NSString* str = [NSString stringWithCString:cstr];
Line 779  nsCocoaBrowserListener::SetContainer(id  Line 1122  nsCocoaBrowserListener::SetContainer(id 
   return url;    return url;
 }  }
   
   - (nsCocoaBrowserListener*)getCocoaBrowserListener
   {
     return _listener;
   }
   
 - (nsIWebBrowser*)getWebBrowser  - (nsIWebBrowser*)getWebBrowser
 {  {
   NS_IF_ADDREF(_webBrowser);    NS_IF_ADDREF(_webBrowser);
Line 805  nsCocoaBrowserListener::SetContainer(id  Line 1153  nsCocoaBrowserListener::SetContainer(id 
   
 }  }
   
   -(void) saveInternal: (nsIURI*)aURI
           withDocument: (nsIDOMDocument*)aDocument
           bypassCache: (BOOL)aBypassCache
           filterView: (NSView*)aFilterView
           filterList: (NSPopUpButton*)aFilterList
   {
       // Create our web browser persist object.  This is the object that knows
       // how to actually perform the saving of the page (and of the images
       // on the page).
       nsCOMPtr<nsIWebBrowserPersist> webPersist(do_CreateInstance(persistContractID));
       if (!webPersist)
           return;
       
       // Make a temporary file object that we can save to.
       nsCOMPtr<nsIProperties> dirService(do_GetService(dirServiceContractID));
       if (!dirService)
           return;
       nsCOMPtr<nsIFile> tmpFile;
       dirService->Get("TmpD", NS_GET_IID(nsIFile), getter_AddRefs(tmpFile));
       static short unsigned int tmpRandom = 0;
       nsCAutoString tmpNo; tmpNo.AppendInt(tmpRandom++);
       nsCAutoString saveFile("-sav");
       saveFile += tmpNo;
       saveFile += "tmp";
       tmpFile->Append(saveFile.get()); 
       
       // Get the post data if we're an HTML doc.
       nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(_webBrowser));
       nsCOMPtr<nsISHistory> sessionHistory;
       webNav->GetSessionHistory(getter_AddRefs(sessionHistory));
       nsCOMPtr<nsIHistoryEntry> entry;
       PRInt32 sindex;
       sessionHistory->GetIndex(&sindex);
       sessionHistory->GetEntryAtIndex(sindex, PR_FALSE, getter_AddRefs(entry));
       nsCOMPtr<nsISHEntry> shEntry(do_QueryInterface(entry));
       nsCOMPtr<nsIInputStream> postData;
       if (shEntry)
           shEntry->GetPostData(getter_AddRefs(postData));
       
       nsHeaderSniffer* sniffer = new nsHeaderSniffer(webPersist, tmpFile, aURI, 
                                                      aDocument, postData, aBypassCache,
                                                      aFilterView, aFilterList);
       if (!sniffer)
           return;
       webPersist->SetProgressListener(sniffer);
       webPersist->SaveURI(aURI, nsnull, tmpFile);
   }
   
   -(void)printDocument
   {
       nsCOMPtr<nsIDOMWindow> domWindow;
       _webBrowser->GetContentDOMWindow(getter_AddRefs(domWindow));
       nsCOMPtr<nsIInterfaceRequestor> ir(do_QueryInterface(domWindow));
       nsCOMPtr<nsIWebBrowserPrint> print;
       ir->GetInterface(NS_GET_IID(nsIWebBrowserPrint), getter_AddRefs(print));
       print->Print(nsnull, nsnull);
   }
   
   -(void)findInPage:(NSString*)inText
   {
       nsCOMPtr<nsIWebBrowserFocus> wbf(do_QueryInterface(_webBrowser));
       nsCOMPtr<nsIDOMWindow> rootWindow;
       nsCOMPtr<nsIDOMWindow> focusedWindow;
       _webBrowser->GetContentDOMWindow(getter_AddRefs(rootWindow));
       wbf->GetFocusedWindow(getter_AddRefs(focusedWindow));
       if (!focusedWindow)
           focusedWindow = rootWindow;
       nsCOMPtr<nsIWebBrowserFind> webFind(do_GetInterface(_webBrowser));
       nsCOMPtr<nsIWebBrowserFindInFrames> framesFind(do_QueryInterface(webFind));
       framesFind->SetRootSearchFrame(rootWindow);
       framesFind->SetCurrentSearchFrame(focusedWindow);
       
       PRUnichar* text = (PRUnichar*)nsMemory::Alloc(([inText length]+1)*sizeof(PRUnichar));
       if ( text ) {
         [inText getCharacters:text];
         text[[inText length]] = 0;
         webFind->SetSearchString(text);
         PRBool found;
         webFind->FindNext(&found);
         nsMemory::Free(text);
       }
   }
   
   -(void)findAgain
   {
   }
   
   -(void)saveDocument: (NSView*)aFilterView filterList: (NSPopUpButton*)aFilterList
   {
       nsCOMPtr<nsIWebBrowserFocus> wbf(do_QueryInterface(_webBrowser));
       nsCOMPtr<nsIDOMWindow> domWindow;
       wbf->GetFocusedWindow(getter_AddRefs(domWindow));
       if (!domWindow)
           _webBrowser->GetContentDOMWindow(getter_AddRefs(domWindow));
       if (!domWindow)
           return;
       
       nsCOMPtr<nsIDOMDocument> domDocument;
       domWindow->GetDocument(getter_AddRefs(domDocument));
       if (!domDocument)
           return;
       nsCOMPtr<nsIDOMNSDocument> nsDoc(do_QueryInterface(domDocument));
       if (!nsDoc)
           return;
       nsCOMPtr<nsIDOMLocation> location;
       nsDoc->GetLocation(getter_AddRefs(location));
       if (!location)
           return;
       nsAutoString urlStr;
       location->GetHref(urlStr);
       nsCAutoString urlCStr; urlCStr.AssignWithConversion(urlStr);
       nsCOMPtr<nsIURI> url;
       nsresult rv = NS_NewURI(getter_AddRefs(url), urlCStr.get());
       if (NS_FAILED(rv))
           return;
           
   #if 0
       nsCOMPtr<nsIDocument> doc(do_QueryInterface(domDocument));
       if (!doc)
           return;
       nsCOMPtr<nsIURI> url;
       doc->GetDocumentURL(getter_AddRefs(url));
   #endif
        
       [self saveInternal: url.get()
             withDocument: domDocument
             bypassCache: NO
             filterView: aFilterView
             filterList: aFilterList];
   }
   
   
   -(IBAction)cut:(id)aSender
   {
       nsCOMPtr<nsIClipboardCommands> clipboard(do_GetInterface(_webBrowser));
       clipboard->CutSelection();
   }
   
   -(IBAction)copy:(id)aSender
   {
       nsCOMPtr<nsIClipboardCommands> clipboard(do_GetInterface(_webBrowser));
       clipboard->CopySelection();
   }
   
   -(IBAction)paste:(id)aSender
   {
       nsCOMPtr<nsIClipboardCommands> clipboard(do_GetInterface(_webBrowser));
       clipboard->Paste();
   }
   
   -(IBAction)clear:(id)aSender
   {
       nsCOMPtr<nsIClipboardCommands> clipboard(do_GetInterface(_webBrowser));
       clipboard->SelectNone();
   }
   
   -(IBAction)selectAll:(id)aSender
   {
       nsCOMPtr<nsIClipboardCommands> clipboard(do_GetInterface(_webBrowser));
       clipboard->SelectAll();
   }
   
   -(IBAction)undo:(id)aSender
   {
     NSLog(@"Undo not yet implemented");
   }
   
   -(NSString*)getCurrentURLSpec
   {
       NSString* empty = @"";
       nsCOMPtr<nsIDOMWindow> domWindow;
       _webBrowser->GetContentDOMWindow(getter_AddRefs(domWindow));
       if (!domWindow)
           return empty;
       
       nsCOMPtr<nsIDOMDocument> domDocument;
       domWindow->GetDocument(getter_AddRefs(domDocument));
       if (!domDocument)
           return empty;
       nsCOMPtr<nsIDOMNSDocument> nsDoc(do_QueryInterface(domDocument));
       if (!nsDoc)
           return empty;
       nsCOMPtr<nsIDOMLocation> location;
       nsDoc->GetLocation(getter_AddRefs(location));
       if (!location)
           return empty;
       nsAutoString urlStr;
       location->GetHref(urlStr);
       nsCAutoString urlCStr; urlCStr.AssignWithConversion(urlStr);
       
       return [NSString stringWithCString: urlCStr.get()];
   }
   
   - (void)setActive: (BOOL)aIsActive
   {
       nsCOMPtr<nsIWebBrowserFocus> wbf(do_QueryInterface(_webBrowser));
       if (aIsActive)
           wbf->Activate();
       else
           wbf->Deactivate();
   }
 @end  @end
   

Removed from v.1.1  
changed lines
  Added in v.1.29


FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>