mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-10 20:05:49 +00:00
ab44cf7456
is the top left since that's what webpages expect.
610 lines
16 KiB
Plaintext
610 lines
16 KiB
Plaintext
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla 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/MPL/
|
|
*
|
|
* 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 Chimera 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):
|
|
* Simon Fraser <sfraser@netscape.com>
|
|
*
|
|
* 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 MPL, 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 MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
#import <Cocoa/Cocoa.h>
|
|
|
|
#import "NSString+Utils.h"
|
|
|
|
// Embedding includes
|
|
#include "nsIWebBrowser.h"
|
|
#include "nsIWebNavigation.h"
|
|
#include "nsIURI.h"
|
|
#include "nsIDOMWindow.h"
|
|
//#include "nsIWidget.h"
|
|
|
|
// XPCOM and String includes
|
|
#include "nsCRT.h"
|
|
#include "nsString.h"
|
|
#include "nsCOMPtr.h"
|
|
|
|
#import "CHBrowserView.h"
|
|
|
|
#include "nsCocoaBrowserListener.h"
|
|
|
|
|
|
nsCocoaBrowserListener::nsCocoaBrowserListener(CHBrowserView* aView)
|
|
: mView(aView), mContainer(nsnull), mIsModal(PR_FALSE), mChromeFlags(0)
|
|
{
|
|
NS_INIT_ISUPPORTS();
|
|
mListeners = [[NSMutableArray alloc] init];
|
|
}
|
|
|
|
nsCocoaBrowserListener::~nsCocoaBrowserListener()
|
|
{
|
|
[mListeners release];
|
|
mView = nsnull;
|
|
if (mContainer) {
|
|
[mContainer release];
|
|
}
|
|
}
|
|
|
|
NS_IMPL_ISUPPORTS9(nsCocoaBrowserListener,
|
|
nsIInterfaceRequestor,
|
|
nsIWebBrowserChrome,
|
|
nsIWindowCreator,
|
|
nsIEmbeddingSiteWindow,
|
|
nsIEmbeddingSiteWindow2,
|
|
nsIWebProgressListener,
|
|
nsISupportsWeakReference,
|
|
nsIContextMenuListener,
|
|
nsITooltipListener)
|
|
|
|
// Implementation of nsIInterfaceRequestor
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::GetInterface(const nsIID &aIID, void** aInstancePtr)
|
|
{
|
|
if (aIID.Equals(NS_GET_IID(nsIDOMWindow))) {
|
|
nsCOMPtr<nsIWebBrowser> browser = dont_AddRef([mView getWebBrowser]);
|
|
if (browser)
|
|
return browser->GetContentDOMWindow((nsIDOMWindow **) 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) {
|
|
#if DEBUG
|
|
NSLog(@"Mismatch in nsCocoaBrowserListener::CreateChromeWindow. We should be the owning parent.");
|
|
#endif
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
CHBrowserView* childView = [mContainer createBrowserWindow: chromeFlags];
|
|
if (!childView) {
|
|
#if DEBUG
|
|
NSLog(@"No CHBrowserView hooked up for a newly created window yet.");
|
|
#endif
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
nsCocoaBrowserListener* listener = [childView getCocoaBrowserListener];
|
|
if (!listener) {
|
|
#if DEBUG
|
|
NSLog(@"Uh-oh! No listener yet for a newly created window (nsCocoaBrowserlistener)");
|
|
return NS_ERROR_FAILURE;
|
|
#endif
|
|
}
|
|
|
|
#if DEBUG
|
|
NSLog(@"Made a chrome window.");
|
|
#endif
|
|
|
|
*_retval = listener;
|
|
NS_IF_ADDREF(*_retval);
|
|
return NS_OK;
|
|
}
|
|
|
|
// Implementation of nsIContextMenuListener
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::OnShowContextMenu(PRUint32 aContextFlags, nsIDOMEvent* aEvent, nsIDOMNode* aNode)
|
|
{
|
|
[mContainer onShowContextMenu: aContextFlags domEvent: aEvent domNode: aNode];
|
|
return NS_OK;
|
|
}
|
|
|
|
// Implementation of nsITooltipListener
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::OnShowTooltip(PRInt32 aXCoords, PRInt32 aYCoords, const PRUnichar *aTipText)
|
|
{
|
|
NSPoint where;
|
|
where.x = aXCoords; where.y = aYCoords;
|
|
[mContainer onShowTooltip:where withText:[NSString stringWithPRUnichars:aTipText]];
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::OnHideTooltip()
|
|
{
|
|
[mContainer onHideTooltip];
|
|
return NS_OK;
|
|
}
|
|
|
|
// Implementation of nsIWebBrowserChrome
|
|
/* void setStatus (in unsigned long statusType, in wstring status); */
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::SetStatus(PRUint32 statusType, const PRUnichar *status)
|
|
{
|
|
if (!mContainer) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NSString* str = nsnull;
|
|
if (status && (*status != PRUnichar(0))) {
|
|
str = [NSString stringWithPRUnichars:status];
|
|
}
|
|
|
|
[mContainer setStatus:str ofType:(NSStatusType)statusType];
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* attribute nsIWebBrowser webBrowser; */
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::GetWebBrowser(nsIWebBrowser * *aWebBrowser)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aWebBrowser);
|
|
if (!mView) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
*aWebBrowser = [mView getWebBrowser];
|
|
|
|
return NS_OK;
|
|
}
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::SetWebBrowser(nsIWebBrowser * aWebBrowser)
|
|
{
|
|
if (!mView) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
[mView setWebBrowser:aWebBrowser];
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* attribute unsigned long chromeFlags; */
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::GetChromeFlags(PRUint32 *aChromeFlags)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aChromeFlags);
|
|
*aChromeFlags = mChromeFlags;
|
|
return NS_OK;
|
|
}
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::SetChromeFlags(PRUint32 aChromeFlags)
|
|
{
|
|
// XXX Do nothing with them for now
|
|
mChromeFlags = aChromeFlags;
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void destroyBrowserWindow (); */
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::DestroyBrowserWindow()
|
|
{
|
|
// XXX Could send this up to the container, but for now,
|
|
// we just destroy the enclosing window.
|
|
NSWindow* window = [mView window];
|
|
|
|
if (window) {
|
|
[window close];
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void sizeBrowserTo (in long aCX, in long aCY); */
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::SizeBrowserTo(PRInt32 aCX, PRInt32 aCY)
|
|
{
|
|
if (mContainer) {
|
|
NSSize size;
|
|
|
|
size.width = (float)aCX;
|
|
size.height = (float)aCY;
|
|
|
|
[mContainer sizeBrowserTo:size];
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void showAsModal (); */
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::ShowAsModal()
|
|
{
|
|
if (!mView) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NSWindow* window = [mView window];
|
|
|
|
if (!window) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
mIsModal = PR_TRUE;
|
|
//int result = [NSApp runModalForWindow:window];
|
|
mIsModal = PR_FALSE;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* boolean isWindowModal (); */
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::IsWindowModal(PRBool *_retval)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(_retval);
|
|
|
|
*_retval = mIsModal;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void exitModalEventLoop (in nsresult aStatus); */
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::ExitModalEventLoop(nsresult aStatus)
|
|
{
|
|
// [NSApp stopModalWithCode:(int)aStatus];
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
// Implementation of nsIEmbeddingSiteWindow2
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::Blur()
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
// Implementation of nsIEmbeddingSiteWindow
|
|
/* void setDimensions (in unsigned long flags, in long x, in long y, in long cx, in long cy); */
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::SetDimensions(PRUint32 flags, PRInt32 x, PRInt32 y, PRInt32 cx, PRInt32 cy)
|
|
{
|
|
if (!mView)
|
|
return NS_ERROR_FAILURE;
|
|
|
|
NSWindow* window = [mView window];
|
|
if (!window)
|
|
return NS_ERROR_FAILURE;
|
|
|
|
if (flags & nsIEmbeddingSiteWindow::DIM_FLAGS_POSITION) {
|
|
NSPoint origin;
|
|
origin.x = (float)x;
|
|
origin.y = (float)y;
|
|
|
|
// websites assume the origin is the topleft of the window and that the screen origin
|
|
// is "topleft" (quickdraw coordinates). As a result, we have to convert it.
|
|
GDHandle screenDevice = ::GetMainDevice();
|
|
Rect screenRect = (**screenDevice).gdRect;
|
|
short screenHeight = screenRect.bottom - screenRect.top;
|
|
origin.y = screenHeight - origin.y;
|
|
|
|
[window setFrameTopLeftPoint:origin];
|
|
}
|
|
|
|
if (flags & nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_OUTER) {
|
|
NSRect frame = [window frame];
|
|
frame.size.width = (float)cx;
|
|
frame.size.height = (float)cy;
|
|
[window setFrame:frame display:YES];
|
|
}
|
|
else if (flags & nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_INNER) {
|
|
NSSize size;
|
|
size.width = (float)cx;
|
|
size.height = (float)cy;
|
|
[window setContentSize:size];
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void getDimensions (in unsigned long flags, out long x, out long y, out long cx, out long cy); */
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::GetDimensions(PRUint32 flags, PRInt32 *x, PRInt32 *y, PRInt32 *cx, PRInt32 *cy)
|
|
{
|
|
if (!mView)
|
|
return NS_ERROR_FAILURE;
|
|
|
|
NSWindow* window = [mView window];
|
|
if (!window)
|
|
return NS_ERROR_FAILURE;
|
|
|
|
NSRect frame = [window frame];
|
|
if (flags & nsIEmbeddingSiteWindow::DIM_FLAGS_POSITION) {
|
|
if ( x )
|
|
*x = (PRInt32)frame.origin.x;
|
|
if ( y )
|
|
*y = (PRInt32)frame.origin.y;
|
|
}
|
|
if (flags & nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_OUTER) {
|
|
if ( cx )
|
|
*cx = (PRInt32)frame.size.width;
|
|
if ( cy )
|
|
*cy = (PRInt32)frame.size.height;
|
|
}
|
|
else if (flags & nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_INNER) {
|
|
NSView* contentView = [window contentView];
|
|
NSRect contentFrame = [contentView frame];
|
|
if ( cx )
|
|
*cx = (PRInt32)contentFrame.size.width;
|
|
if ( cy )
|
|
*cy = (PRInt32)contentFrame.size.height;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void setFocus (); */
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::SetFocus()
|
|
{
|
|
if (!mView) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NSWindow* window = [mView window];
|
|
if (!window) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
[window makeKeyAndOrderFront:window];
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* attribute boolean visibility; */
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::GetVisibility(PRBool *aVisibility)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aVisibility);
|
|
|
|
if (!mView) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NSWindow* window = [mView window];
|
|
if (!window) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
*aVisibility = [window isMiniaturized];
|
|
|
|
return NS_OK;
|
|
}
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::SetVisibility(PRBool aVisibility)
|
|
{
|
|
if (!mView) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NSWindow* window = [mView window];
|
|
if (!window) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
if (aVisibility) {
|
|
[window deminiaturize:window];
|
|
}
|
|
else {
|
|
[window miniaturize:window];
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* attribute wstring title; */
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::GetTitle(PRUnichar * *aTitle)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aTitle);
|
|
|
|
if (!mContainer) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NSString* title = [mContainer title];
|
|
unsigned int length = [title length];
|
|
if (length) {
|
|
*aTitle = (PRUnichar*)nsMemory::Alloc((length+1)*sizeof(PRUnichar));
|
|
if (!*aTitle) {
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
[title getCharacters:*aTitle];
|
|
}
|
|
else {
|
|
*aTitle = nsnull;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::SetTitle(const PRUnichar * aTitle)
|
|
{
|
|
NS_ENSURE_ARG(aTitle);
|
|
|
|
if (!mContainer) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NSString* str = [NSString stringWithPRUnichars:aTitle];
|
|
[mContainer setTitle:str];
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* [noscript] readonly attribute voidPtr siteWindow; */
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::GetSiteWindow(void * *aSiteWindow)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aSiteWindow);
|
|
*aSiteWindow = nsnull;
|
|
if (!mView) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NSWindow* window = [mView window];
|
|
if (!window) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
*aSiteWindow = (void*)window;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
//
|
|
// Implementation of nsIWebProgressListener
|
|
//
|
|
|
|
/* void onStateChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in unsigned long aStateFlags, in unsigned long aStatus); */
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::OnStateChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest,
|
|
PRUint32 aStateFlags, PRUint32 aStatus)
|
|
{
|
|
NSEnumerator* enumerator = [mListeners objectEnumerator];
|
|
id<NSBrowserListener> obj;
|
|
|
|
if (aStateFlags & nsIWebProgressListener::STATE_IS_NETWORK) {
|
|
if (aStateFlags & nsIWebProgressListener::STATE_START) {
|
|
while ((obj = [enumerator nextObject]))
|
|
[obj onLoadingStarted];
|
|
}
|
|
else if (aStateFlags & nsIWebProgressListener::STATE_STOP) {
|
|
while ((obj = [enumerator nextObject]))
|
|
[obj onLoadingCompleted:(NS_SUCCEEDED(aStatus))];
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void onProgressChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in long aCurSelfProgress, in long aMaxSelfProgress, in long aCurTotalProgress, in long aMaxTotalProgress); */
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::OnProgressChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest,
|
|
PRInt32 aCurSelfProgress, PRInt32 aMaxSelfProgress,
|
|
PRInt32 aCurTotalProgress, PRInt32 aMaxTotalProgress)
|
|
{
|
|
NSEnumerator* enumerator = [mListeners objectEnumerator];
|
|
id<NSBrowserListener> obj;
|
|
while ((obj = [enumerator nextObject]))
|
|
[obj onProgressChange:aCurTotalProgress outOf:aMaxTotalProgress];
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void onLocationChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in nsIURI location); */
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::OnLocationChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest,
|
|
nsIURI *location)
|
|
{
|
|
if (!location)
|
|
return NS_ERROR_FAILURE;
|
|
|
|
nsCAutoString spec;
|
|
location->GetSpec(spec);
|
|
NSString* str = [NSString stringWithCString:spec.get()];
|
|
|
|
NSEnumerator* enumerator = [mListeners objectEnumerator];
|
|
id<NSBrowserListener> obj;
|
|
while ((obj = [enumerator nextObject]))
|
|
[obj onLocationChange:str];
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void onStatusChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in nsresult aStatus, in wstring aMessage); */
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::OnStatusChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, nsresult aStatus,
|
|
const PRUnichar *aMessage)
|
|
{
|
|
NSString* str = [NSString stringWithPRUnichars:aMessage];
|
|
|
|
NSEnumerator* enumerator = [mListeners objectEnumerator];
|
|
id<NSBrowserListener> obj;
|
|
while ((obj = [enumerator nextObject]))
|
|
[obj onStatusChange: str];
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void onSecurityChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in unsigned long state); */
|
|
NS_IMETHODIMP
|
|
nsCocoaBrowserListener::OnSecurityChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, PRUint32 state)
|
|
{
|
|
NSEnumerator* enumerator = [mListeners objectEnumerator];
|
|
id<NSBrowserListener> obj;
|
|
while ((obj = [enumerator nextObject]))
|
|
[obj onSecurityStateChange: state];
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsCocoaBrowserListener::AddListener(id <NSBrowserListener> aListener)
|
|
{
|
|
[mListeners addObject:aListener];
|
|
}
|
|
|
|
void
|
|
nsCocoaBrowserListener::RemoveListener(id <NSBrowserListener> aListener)
|
|
{
|
|
[mListeners removeObject:aListener];
|
|
}
|
|
|
|
void
|
|
nsCocoaBrowserListener::SetContainer(id <NSBrowserContainer> aContainer)
|
|
{
|
|
[mContainer autorelease];
|
|
|
|
mContainer = aContainer;
|
|
|
|
[mContainer retain];
|
|
}
|
|
|