diff --git a/embedding/browser/Makefile.in b/embedding/browser/Makefile.in index dbf56f49347e..b81693d9c3d2 100644 --- a/embedding/browser/Makefile.in +++ b/embedding/browser/Makefile.in @@ -31,4 +31,8 @@ ifdef MOZ_ENABLE_GTK DIRS += gtk endif +ifdef MOZ_ENABLE_PHOTON +DIRS += photon +endif + include $(topsrcdir)/config/rules.mk diff --git a/embedding/browser/photon/Makefile.in b/embedding/browser/photon/Makefile.in new file mode 100644 index 000000000000..8c5e29f0d587 --- /dev/null +++ b/embedding/browser/photon/Makefile.in @@ -0,0 +1,34 @@ +# +# 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 the Mozilla browser. +# +# The Initial Developer of the Original Code is Christopher +# Blizzard. Portions created by Christopher Blizzard are +# Copyright (C) 1999, Mozilla. All Rights Reserved. +# +# Contributor(s): +# Christopher Blizzard + +DEPTH = ../../.. +topsrcdir = @top_srcdir@ +srcdir = @srcdir@ +VPATH = @srcdir@ + +include $(DEPTH)/config/autoconf.mk + +DIRS=src + +ifdef ENABLE_TESTS +DIRS += tests +endif + +include $(topsrcdir)/config/rules.mk diff --git a/embedding/browser/photon/src/Makefile.in b/embedding/browser/photon/src/Makefile.in new file mode 100644 index 000000000000..423347428d85 --- /dev/null +++ b/embedding/browser/photon/src/Makefile.in @@ -0,0 +1,55 @@ +# +# 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 the Mozilla browser. +# +# The Initial Developer of the Original Code is Christopher +# Blizzard. Portions created by Christopher Blizzard are +# Copyright (C) 1999, Mozilla. All Rights Reserved. +# +# Contributor(s): +# Christopher Blizzard + +DEPTH = ../../../.. +topsrcdir = @top_srcdir@ +srcdir = @srcdir@ +VPATH = @srcdir@ + +include $(DEPTH)/config/autoconf.mk + +LIBRARY_NAME = phembedmoz + + +CPPSRCS = \ + MozEmbedChrome.cpp \ + MozEmbedStream.cpp \ + PtMozilla.cpp + +SHARED_LIBRARY_LIBS= \ + $(DIST)/lib/libembed_base_s.$(LIB_SUFFIX) \ + $(NULL) + +EXPORTS = \ + PtMozilla.h + +EXTRA_DSO_LDOPTS = \ + $(MOZ_COMPONENT_LIBS) \ + $(NULL) + +ifndef MOZ_MONOLITHIC_TOOLKIT +EXTRA_DSO_LDOPTS += $(MOZ_PH_LDFLAGS) +else +EXTRA_DSO_LDOPTS += $(TK_LIBS) +endif + +include $(topsrcdir)/config/rules.mk + +CXXFLAGS += $(MOZ_PH_CFLAGS) diff --git a/embedding/browser/photon/src/MozEmbedChrome.cpp b/embedding/browser/photon/src/MozEmbedChrome.cpp new file mode 100644 index 000000000000..996c3c9ccbc6 --- /dev/null +++ b/embedding/browser/photon/src/MozEmbedChrome.cpp @@ -0,0 +1,885 @@ +/* + * 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 mozilla.org code. + * + * The Initial Developer of the Original Code is Christopher Blizzard. + * Portions created by Christopher Blizzard are Copyright (C) + * Christopher Blizzard. All Rights Reserved. + * + * Contributor(s): + * Christopher Blizzard + */ + +#include "MozEmbedChrome.h" +#include "MozEmbedStream.h" +#include "nsCWebBrowser.h" +#include "nsIURI.h" +#include "nsNetUtil.h" +#include "nsIDocShellTreeItem.h" +#include "nsCRT.h" +#include "prlog.h" +#include "prprf.h" +#include "nsIDocumentLoaderFactory.h" +#include "nsIContentViewerContainer.h" +#include "nsIDocShell.h" + +static NS_DEFINE_CID(kSimpleURICID, NS_SIMPLEURI_CID); + +// this is a define to make sure that we don't call certain function +// before the object has been properly initialized + +#define CHECK_IS_INIT() \ + PR_BEGIN_MACRO \ + if (!mIsInitialized) \ + return NS_ERROR_NOT_INITIALIZED; \ + PR_END_MACRO + +static PRLogModuleInfo *mozEmbedLm = NULL; + +nsVoidArray *MozEmbedChrome::sBrowsers = NULL; + +// constructor and destructor +MozEmbedChrome::MozEmbedChrome() +{ + NS_INIT_REFCNT(); + mOwningWidget = nsnull; + mWebBrowser = nsnull; + mNewBrowserCB = nsnull; + mNewBrowserCBData = nsnull; + mDestroyCB = nsnull; + mDestroyCBData = nsnull; + mVisibilityCB = nsnull; + mVisibilityCBData = nsnull; + mLinkCB = nsnull; + mLinkCBData = nsnull; + mJSStatusCB = nsnull; + mJSStatusCBData = nsnull; + mLocationCB = nsnull; + mLocationCBData = nsnull; + mTitleCB = nsnull; + mTitleCBData = nsnull; + mProgressCB = nsnull; + mProgressCBData = nsnull; + mNetCB = nsnull; + mNetCBData = nsnull; + mOpenCB = nsnull; + mOpenCBData = nsnull; + mBounds.x = 0; + mBounds.y = 0; + mBounds.width = 0; + mBounds.height = 0; + mVisibility = PR_FALSE; + mLinkMessage = NULL; + mJSStatus = NULL; + mLocation = NULL; + mTitle = NULL; + mChromeMask = 0; + mOffset = 0; + mDoingStream = PR_FALSE; + if (!mozEmbedLm) + mozEmbedLm = PR_NewLogModule("MozEmbedChrome"); + if (!sBrowsers) + sBrowsers = new nsVoidArray(); + sBrowsers->AppendElement((void *)this); + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::MozEmbedChrome %p\n", this)); +} + +MozEmbedChrome::~MozEmbedChrome() +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::~MozEmbedChrome %p\n", this)); + sBrowsers->RemoveElement((void *)this); +} + +// nsISupports interface + +NS_IMPL_ADDREF(MozEmbedChrome) +NS_IMPL_RELEASE(MozEmbedChrome) + +NS_INTERFACE_MAP_BEGIN(MozEmbedChrome) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIPhEmbed) + NS_INTERFACE_MAP_ENTRY(nsIPhEmbed) + NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor) + NS_INTERFACE_MAP_ENTRY(nsIWebBrowserChrome) + NS_INTERFACE_MAP_ENTRY(nsIURIContentListener) + NS_INTERFACE_MAP_ENTRY(nsIWebProgressListener) + NS_INTERFACE_MAP_ENTRY(nsIBaseWindow) +NS_INTERFACE_MAP_END + +// nsIPhEmbed interface + +NS_IMETHODIMP MozEmbedChrome::Init(PtWidget_t *aOwningWidget) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::Init\n")); + mOwningWidget = aOwningWidget; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::SetNewBrowserCallback(MozEmbedChromeCB *aCallback, void *aData) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetNewBrowserCallback\n")); + mNewBrowserCB = aCallback; + mNewBrowserCBData = aData; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::SetDestroyCallback(MozEmbedDestroyCB *aCallback, void *aData) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetDestroyCallback\n")); + mDestroyCB = aCallback; + mDestroyCBData = aData; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::SetVisibilityCallback(MozEmbedVisibilityCB *aCallback, void *aData) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetVisibilityCallback\n")); + mVisibilityCB = aCallback; + mVisibilityCBData = aData; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::SetLinkChangeCallback (MozEmbedLinkCB *aCallback, void *aData) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetLinkChangeCallback\n")); + mLinkCB = aCallback; + mLinkCBData = aData; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::SetJSStatusChangeCallback (MozEmbedJSStatusCB *aCallback, void *aData) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetJSStatusChangeCallback\n")); + mJSStatusCB = aCallback; + mJSStatusCBData = aData; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::SetLocationChangeCallback (MozEmbedLocationCB *aCallback, void *aData) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetLocationChangeCallback\n")); + mLocationCB = aCallback; + mLocationCBData = aData; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::SetTitleChangeCallback (MozEmbedTitleCB *aCallback, void *aData) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetTitleChangeCB\n")); + mTitleCB = aCallback; + mTitleCBData = aData; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::SetProgressCallback (MozEmbedProgressCB *aCallback, void *aData) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetProgressCallback\n")); + mProgressCB = aCallback; + mProgressCBData = aData; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::SetNetCallback (MozEmbedNetCB *aCallback, void *aData) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetNetCallback\n")); + mNetCB = aCallback; + mNetCBData = aData; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::SetStartOpenCallback (MozEmbedStartOpenCB *aCallback, void *aData) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetStartOpenCallback\n")); + mOpenCB = aCallback; + mOpenCBData = aData; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::GetLinkMessage (char **retval) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::GetLinkMessage\n")); + NS_ENSURE_ARG_POINTER(retval); + *retval = NULL; + if (mLinkMessage) + *retval = nsCRT::strdup(mLinkMessage); + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::GetJSStatus (char **retval) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::GetJSStatus\n")); + NS_ENSURE_ARG_POINTER(retval); + *retval = NULL; + if (mJSStatus) + *retval = nsCRT::strdup(mLinkMessage); + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::GetLocation (char **retval) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::GetLocation\n")); + NS_ENSURE_ARG_POINTER(retval); + *retval = NULL; + if (mLocation) + *retval = nsCRT::strdup(mLocation); + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::GetTitleChar (char **retval) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::GetTitleChar\n")); + NS_ENSURE_ARG_POINTER(retval); + *retval = NULL; + if (mTitle) + *retval = nsCRT::strdup(mTitle); + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::OpenStream (const char *aBaseURI, const char *aContentType) +{ + NS_ENSURE_ARG_POINTER(aBaseURI); + NS_ENSURE_ARG_POINTER(aContentType); + + nsresult rv = NS_OK; + MozEmbedStream *newStream = nsnull; + + nsCOMPtr docLoaderFactory; + nsCOMPtr docShell; + nsCOMPtr viewerContainer; + nsCOMPtr contentViewer; + nsCOMPtr uri; + nsCAutoString docLoaderProgID; + nsCAutoString spec(aBaseURI); + + // check to see if we need to close the current stream + if (mDoingStream) + CloseStream(); + mDoingStream = PR_TRUE; + // create our new stream object + newStream = new MozEmbedStream(); + if (!newStream) + return NS_ERROR_OUT_OF_MEMORY; + // we own this + NS_ADDREF(newStream); + // QI it to the right interface + mStream = do_QueryInterface(newStream); + if (!mStream) + return NS_ERROR_FAILURE; + // ok, now we're just using it for an nsIInputStream interface so + // release our second reference to it. + NS_RELEASE(newStream); + + // get our hands on the docShell + mWebBrowser->GetDocShell(getter_AddRefs(docShell)); + if (!docShell) + return NS_ERROR_FAILURE; + + // QI that to a content viewer container + viewerContainer = do_QueryInterface(docShell); + if (!viewerContainer) + return NS_ERROR_FAILURE; + + // create a new uri object + uri = do_CreateInstance(kSimpleURICID, &rv); + if (NS_FAILED(rv)) + return rv; + rv = uri->SetSpec(spec.GetBuffer()); + if (NS_FAILED(rv)) + return rv; + + // create a new load group + rv = NS_NewLoadGroup(getter_AddRefs(mLoadGroup), nsnull); + if (NS_FAILED(rv)) + return rv; + + // create a new input stream channel + rv = NS_NewInputStreamChannel(getter_AddRefs(mChannel), uri, mStream, aContentType, + 1024 /* len */); + if (NS_FAILED(rv)) + return rv; + + // set the channel's load group + rv = mChannel->SetLoadGroup(mLoadGroup); + if (NS_FAILED(rv)) + return rv; + + // find a document loader for this command plus content type + // combination + + docLoaderProgID = NS_DOCUMENT_LOADER_FACTORY_PROGID_PREFIX; + docLoaderProgID += "view"; + docLoaderProgID += "/"; + docLoaderProgID += aContentType; + + docLoaderFactory = do_CreateInstance(docLoaderProgID, &rv); + if (NS_FAILED(rv)) + return rv; + + // ok, create an instance of the content viewer for that command and + // mime type + rv = docLoaderFactory->CreateInstance("view", + mChannel, + mLoadGroup, + aContentType, + viewerContainer, + nsnull, + getter_AddRefs(mStreamListener), + getter_AddRefs(contentViewer)); + + if (NS_FAILED(rv)) + return rv; + + // set the container viewer container for this content view + rv = contentViewer->SetContainer(viewerContainer); + if (NS_FAILED(rv)) + return rv; + + // embed this sucker. + rv = viewerContainer->Embed(contentViewer, "view", nsnull); + if (NS_FAILED(rv)) + return rv; + + // start our request + rv = mStreamListener->OnStartRequest(mChannel, NULL); + if (NS_FAILED(rv)) + return rv; + + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::AppendToStream (const char *aData, int32 aLen) +{ + MozEmbedStream *embedStream = (MozEmbedStream *)mStream.get(); + nsresult rv; + NS_ENSURE_STATE(mDoingStream); + rv = embedStream->Append(aData, aLen); + if (NS_FAILED(rv)) + return rv; + rv = mStreamListener->OnDataAvailable(mChannel, + NULL, + mStream, + mOffset, /* offset */ + aLen); /* len */ + mOffset += aLen; + if (NS_FAILED(rv)) + return rv; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::CloseStream (void) +{ + nsresult rv; + NS_ENSURE_STATE(mDoingStream); + mDoingStream = PR_FALSE; + rv = mStreamListener->OnStopRequest(mChannel, + NULL, + NS_OK, + NULL); + if (NS_FAILED(rv)) + return rv; + mStream = nsnull; + mLoadGroup = nsnull; + mChannel = nsnull; + mStreamListener = nsnull; + mContentViewer = nsnull; + mOffset = 0; + return NS_OK; +} + +// nsIInterfaceRequestor interface + +NS_IMETHODIMP MozEmbedChrome::GetInterface(const nsIID &aIID, void** aInstancePtr) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::GetInterface\n")); + return QueryInterface(aIID, aInstancePtr); +} + +// nsIWebBrowserChrome interface + +NS_IMETHODIMP MozEmbedChrome::SetJSStatus(const PRUnichar *status) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetJSStatus\n")); + nsString jsStatusString(status); + mJSStatus = jsStatusString.ToNewCString(); + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("js status is %s\n", (const char *)mJSStatus)); + // let any listeners know that the status has changed + if (mJSStatusCB) + mJSStatusCB(mJSStatusCBData); + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::SetJSDefaultStatus(const PRUnichar *status) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetJSDefaultStatus\n")); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP MozEmbedChrome::SetOverLink(const PRUnichar *link) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetOverLink\n")); + nsString linkMessageString(link); + mLinkMessage = linkMessageString.ToNewCString(); + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("message is %s\n", (const char *)mLinkMessage)); + // if there are any listeners, let them know about the change + if (mLinkCB) + mLinkCB(mLinkCBData); + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::GetWebBrowser(nsIWebBrowser * *aWebBrowser) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::GetWebBrowser\n")); + + NS_ENSURE_ARG_POINTER(aWebBrowser); + *aWebBrowser = mWebBrowser; + NS_IF_ADDREF(*aWebBrowser); + + return NS_OK; + +} + +NS_IMETHODIMP MozEmbedChrome::SetWebBrowser(nsIWebBrowser * aWebBrowser) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetWebBrowser\n")); + + NS_ENSURE_ARG_POINTER(aWebBrowser); + mWebBrowser = aWebBrowser; + + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::GetChromeMask(PRUint32 *aChromeMask) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::GetChromeMask\n")); + NS_ENSURE_ARG_POINTER(aChromeMask); + *aChromeMask = mChromeMask; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::SetChromeMask(PRUint32 aChromeMask) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetChromeMask\n")); + mChromeMask = aChromeMask; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::GetNewBrowser(PRUint32 chromeMask, + nsIWebBrowser **_retval) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::GetNewBrowser\n")); + if (mNewBrowserCB) + return mNewBrowserCB(chromeMask, _retval, mNewBrowserCBData); + else + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP MozEmbedChrome::FindNamedBrowserItem(const PRUnichar *aName, + nsIDocShellTreeItem **_retval) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::FindNamedBrowserItem\n")); + NS_ENSURE_ARG_POINTER(_retval); + *_retval = nsnull; + + PRInt32 i = 0; + PRInt32 numBrowsers = sBrowsers->Count(); + + for (i = 0; i < numBrowsers; i++) + { + MozEmbedChrome *chrome = (MozEmbedChrome *)sBrowsers->ElementAt(i); + nsCOMPtr webBrowser; + NS_ENSURE_SUCCESS(chrome->GetWebBrowser(getter_AddRefs(webBrowser)), NS_ERROR_FAILURE); + + nsCOMPtr docShellAsItem(do_QueryInterface(webBrowser)); + NS_ENSURE_TRUE(docShellAsItem, NS_ERROR_FAILURE); + + docShellAsItem->FindItemWithName(aName, NS_STATIC_CAST(nsIWebBrowserChrome *, this), _retval); + if (*_retval) + break; + } + + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::SizeBrowserTo(PRInt32 aCX, PRInt32 aCY) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SizeBrowserTo\n")); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP MozEmbedChrome::ShowAsModal(void) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::ShowAsModal\n")); + return NS_ERROR_NOT_IMPLEMENTED; +} + +// nsIURIContentListener + +NS_IMETHODIMP MozEmbedChrome::OnStartURIOpen(nsIURI *aURI, const char *aWindowTarget, PRBool *aAbortOpen) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::OnStartURIOpen\n")); + NS_ENSURE_ARG_POINTER(aAbortOpen); + NS_ENSURE_ARG_POINTER(aURI); + char *specString = NULL; + nsCAutoString autoString; + nsresult rv; + + rv = aURI->GetSpec(&specString); + if (NS_FAILED(rv)) + return rv; + + autoString = specString; + + if (mOpenCB) + { + *aAbortOpen = mOpenCB(autoString, mOpenCBData); + return NS_OK; + } + else + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP MozEmbedChrome::GetProtocolHandler(nsIURI *aURI, nsIProtocolHandler **aProtocolHandler) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::GetProtocolHandler\n")); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP MozEmbedChrome::DoContent(const char *aContentType, nsURILoadCommand aCommand, + const char *aWindowTarget, nsIChannel *aOpenedChannel, + nsIStreamListener **aContentHandler, PRBool *aAbortProcess) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::DoContent\n")); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP MozEmbedChrome::IsPreferred(const char *aContentType, nsURILoadCommand aCommand, + const char *aWindowTarget, char **aDesiredContentType, + PRBool *aCanHandleContent) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::IsPreferred\n")); + NS_ENSURE_ARG_POINTER(aCanHandleContent); + if (aContentType) + { + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("checking content type %s\n", aContentType)); + if (nsCRT::strcasecmp(aContentType, "text/html") == 0 + || nsCRT::strcasecmp(aContentType, "text/xul") == 0 + || nsCRT::strcasecmp(aContentType, "text/rdf") == 0 + || nsCRT::strcasecmp(aContentType, "text/xml") == 0 + || nsCRT::strcasecmp(aContentType, "text/css") == 0 + || nsCRT::strcasecmp(aContentType, "image/gif") == 0 + || nsCRT::strcasecmp(aContentType, "image/jpeg") == 0 + || nsCRT::strcasecmp(aContentType, "image/png") == 0 + || nsCRT::strcasecmp(aContentType, "image/tiff") == 0 + || nsCRT::strcasecmp(aContentType, "application/http-index-format") == 0) + *aCanHandleContent = PR_TRUE; + } + else + *aCanHandleContent = PR_FALSE; + + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::CanHandleContent(const char *aContentType, nsURILoadCommand aCommand, + const char *aWindowTarget, char **aDesiredContentType, + PRBool *_retval) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::CanHandleContent\n")); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP MozEmbedChrome::GetLoadCookie(nsISupports * *aLoadCookie) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::GetLoadCookie\n")); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP MozEmbedChrome::SetLoadCookie(nsISupports * aLoadCookie) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetLoadCookie\n")); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP MozEmbedChrome::GetParentContentListener(nsIURIContentListener * *aParentContentListener) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::GetParentContentListener\n")); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP MozEmbedChrome::SetParentContentListener(nsIURIContentListener * aParentContentListener) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetParentContentListener\n")); + return NS_ERROR_NOT_IMPLEMENTED; +} + +// nsIWebProgressListener + +NS_IMETHODIMP MozEmbedChrome::OnProgressChange(nsIWebProgress *progress, nsIRequest *request, + PRInt32 curSelfProgress, + PRInt32 maxSelfProgress, PRInt32 curTotalProgress, + PRInt32 maxTotalProgress) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::OnProgressChange\n")); + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("curTotalProgress is %d and maxTotalProgress is %d\n", + curTotalProgress, maxTotalProgress)); + if (maxTotalProgress >= 0) + { + PRUint32 percentage = (curTotalProgress * 100) / maxTotalProgress; + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("%d%% percent\n", percentage)); + } + else + { + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("Unknown percent\n")); + } + + // call our callback if it's been registered + if (mProgressCB) + mProgressCB(mProgressCBData, curTotalProgress, maxTotalProgress); + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::OnStateChange(nsIWebProgress *progress, nsIRequest *request, + PRInt32 aStateFlags, nsresult aStatus) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::OnStateChange\n")); + if (aStateFlags & nsIWebProgressListener::flag_start) + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("flag_start\n")); + if (aStateFlags & nsIWebProgressListener::flag_redirecting) + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("flag_redirecting\n")); + if (aStateFlags & nsIWebProgressListener::flag_negotiating) + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("flag_negotiating\n")); + if (aStateFlags & nsIWebProgressListener::flag_transferring) + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("flag_transferring\n")); + if (aStateFlags & nsIWebProgressListener::flag_stop) + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("flag_stop\n")); + if (aStateFlags & nsIWebProgressListener::flag_is_request) + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("flag_is_request\n")); + if (aStateFlags & nsIWebProgressListener::flag_is_document) + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("flag_is_document\n")); + if (aStateFlags & nsIWebProgressListener::flag_is_network) + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("flag_is_network\n")); + if (aStateFlags & nsIWebProgressListener::flag_is_window) + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("flag_is_window\n")); + + // if we have a callback registered, call it + if (mNetCB) + mNetCB(mNetCBData, aStateFlags, aStatus); + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::OnLocationChange(nsIURI *aLocation) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::OnLocationChange\n")); + char *newURIString = NULL; + NS_ENSURE_ARG_POINTER(aLocation); + aLocation->GetSpec(&newURIString); + mLocation = newURIString; + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("new location is %s\n", (const char *)mLocation)); + // if there are any listeners let them know about the location change + if (mLocationCB) + mLocationCB(mLocationCBData); + return NS_ERROR_NOT_IMPLEMENTED; +} + +// nsIBaseWindow interface + +NS_IMETHODIMP MozEmbedChrome::InitWindow(nativeWindow parentNativeWindow, + nsIWidget * parentWidget, + PRInt32 x, PRInt32 y, + PRInt32 cx, PRInt32 cy) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::InitWindow\n")); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP MozEmbedChrome::Create(void) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::Create\n")); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP MozEmbedChrome::Destroy(void) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::Destory\n")); + if (mDestroyCB) + mDestroyCB(mDestroyCBData); + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::SetPosition(PRInt32 x, PRInt32 y) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetPosition\n")); + mBounds.x = x; + mBounds.y = y; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::GetPosition(PRInt32 *x, PRInt32 *y) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::GetPosition\n")); + NS_ENSURE_ARG_POINTER(x); + NS_ENSURE_ARG_POINTER(y); + *x = mBounds.x; + *y = mBounds.y; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::SetSize(PRInt32 cx, PRInt32 cy, PRBool fRepaint) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetSize\n")); + mBounds.width = cx; + mBounds.height = cy; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::GetSize(PRInt32 *cx, PRInt32 *cy) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::GetSize\n")); + NS_ENSURE_ARG_POINTER(cx); + NS_ENSURE_ARG_POINTER(cy); + *cx = mBounds.width; + *cy = mBounds.height; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::SetPositionAndSize(PRInt32 x, PRInt32 y, + PRInt32 cx, PRInt32 cy, + PRBool fRepaint) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetPositionAndSize %d %d %d %d\n", + x, y, cx, cy)); + mBounds.x = x; + mBounds.y = y; + mBounds.width = cx; + mBounds.height = cy; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::GetPositionAndSize(PRInt32 *x, PRInt32 *y, + PRInt32 *cx, PRInt32 *cy) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::GetPositionAndSize %d %d %d %d\n", + mBounds.x, mBounds.y, mBounds.width, mBounds.height)); + NS_ENSURE_ARG_POINTER(x); + NS_ENSURE_ARG_POINTER(y); + NS_ENSURE_ARG_POINTER(cx); + NS_ENSURE_ARG_POINTER(cy); + *x = mBounds.x; + *y = mBounds.y; + *cx = mBounds.width; + *cy = mBounds.height; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::Repaint(PRBool force) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedCHrome::Repaint\n")); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP MozEmbedChrome::GetParentWidget(nsIWidget * *aParentWidget) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::GetParentWidget\n")); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP MozEmbedChrome::SetParentWidget(nsIWidget * aParentWidget) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetParentWidget\n")); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP MozEmbedChrome::GetParentNativeWindow(nativeWindow *aParentNativeWindow) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::GetParentNativeWindow\n")); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP MozEmbedChrome::SetParentNativeWindow(nativeWindow aParentNativeWindow) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetParentNativeWindow\n")); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP MozEmbedChrome::GetVisibility(PRBool *aVisibility) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::GetVisibility\n")); + NS_ENSURE_ARG_POINTER(aVisibility); + *aVisibility = mVisibility; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::SetVisibility(PRBool aVisibility) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetVisibility for %p\n", this)); + if (mVisibilityCB) + mVisibilityCB(aVisibility, mVisibilityCBData); + mVisibility = aVisibility; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::GetMainWidget(nsIWidget * *aMainWidget) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::GetMainWidget\n")); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP MozEmbedChrome::SetFocus(void) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetFocus\n")); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP MozEmbedChrome::FocusAvailable(nsIBaseWindow *aCurrentFocus, + PRBool *aTookFocus) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::FocusAvailable\n")); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP MozEmbedChrome::GetTitle(PRUnichar * *aTitle) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::GetTitle\n")); + NS_ENSURE_ARG_POINTER(aTitle); + *aTitle = nsnull; + if (mTitle) + *aTitle = mTitleUnicode.ToNewUnicode(); + return NS_OK; +} + +NS_IMETHODIMP MozEmbedChrome::SetTitle(const PRUnichar * aTitle) +{ + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("MozEmbedChrome::SetTitle\n")); + nsString newTitleString(aTitle); + mTitleUnicode = aTitle; + mTitle = newTitleString.ToNewCString(); + PR_LOG(mozEmbedLm, PR_LOG_DEBUG, ("title is %s\n", (const char *)mTitle)); + // if there's a callback, call it to let it know that the title has + // changed. + if (mTitleCB) + mTitleCB(mTitleCBData); + return NS_OK; +} + +NS_IMETHODIMP +MozEmbedChrome::SetPersistence(PRBool aPersistX, PRBool aPersistY, + PRBool aPersistCX, PRBool aPersistCY, + PRBool aPersistSizeMode) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +MozEmbedChrome::GetPersistence(PRBool* aPersistX, PRBool* aPersistY, + PRBool* aPersistCX, PRBool* aPersistCY, + PRBool* aPersistSizeMode) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} diff --git a/embedding/browser/photon/src/MozEmbedChrome.h b/embedding/browser/photon/src/MozEmbedChrome.h new file mode 100644 index 000000000000..f3d56d80a96a --- /dev/null +++ b/embedding/browser/photon/src/MozEmbedChrome.h @@ -0,0 +1,134 @@ +/* + * 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 mozilla.org code. + * + * The Initial Developer of the Original Code is Christopher Blizzard. + * Portions created by Christopher Blizzard are Copyright (C) + * Christopher Blizzard. All Rights Reserved. + * + * Contributor(s): + * Christopher Blizzard + */ + +#ifndef __MozEmbedChrome_h +#define __MozEmbedChrome_h + +// needed for the ever helpful nsCOMPtr +#include + +// we will implement these interfaces +#include "nsIPhEmbed.h" +#include "nsIWebBrowserChrome.h" +#include "nsIBaseWindow.h" +#include "nsIURIContentListener.h" +#include "nsIWebProgressListener.h" +#include "nsIWebProgress.h" +#include "nsIInterfaceRequestor.h" +#include "nsIInputStream.h" +#include "nsILoadGroup.h" +#include "nsIChannel.h" +#include "nsIContentViewer.h" +#include "nsIStreamListener.h" + +// utility classes +#include "nsXPIDLString.h" +#include "nsString.h" +#include "nsVoidArray.h" + +class MozEmbedChrome : public nsIPhEmbed, + public nsIWebBrowserChrome, + public nsIBaseWindow, + public nsIURIContentListener, + public nsIWebProgressListener, + public nsIInterfaceRequestor +{ +public: + + MozEmbedChrome(); + virtual ~MozEmbedChrome(); + + // nsIPhEmbed + + NS_IMETHOD Init (PtWidget_t *aOwningWidget); + NS_IMETHOD SetNewBrowserCallback (MozEmbedChromeCB *aCallback, void *aData); + NS_IMETHOD SetDestroyCallback (MozEmbedDestroyCB *aCallback, void *aData); + NS_IMETHOD SetVisibilityCallback (MozEmbedVisibilityCB *aCallback, void *aData); + NS_IMETHOD SetLinkChangeCallback (MozEmbedLinkCB *aCallback, void *aData); + NS_IMETHOD SetJSStatusChangeCallback (MozEmbedJSStatusCB *aCallback, void *aData); + NS_IMETHOD SetLocationChangeCallback (MozEmbedLocationCB *aCallback, void *aData); + NS_IMETHOD SetTitleChangeCallback (MozEmbedTitleCB *aCallback, void *aData); + NS_IMETHOD SetProgressCallback (MozEmbedProgressCB *aCallback, void *aData); + NS_IMETHOD SetNetCallback (MozEmbedNetCB *aCallback, void *aData); + NS_IMETHOD SetStartOpenCallback (MozEmbedStartOpenCB *aCallback, void *aData); + NS_IMETHOD GetLinkMessage (char **retval); + NS_IMETHOD GetJSStatus (char **retval); + NS_IMETHOD GetLocation (char **retval); + NS_IMETHOD GetTitleChar (char **retval); + NS_IMETHOD OpenStream (const char *aBaseURI, const char *aContentType); + NS_IMETHOD AppendToStream (const char *aData,int32 aLen); + NS_IMETHOD CloseStream (void); + + NS_DECL_ISUPPORTS + + NS_DECL_NSIINTERFACEREQUESTOR + + NS_DECL_NSIWEBBROWSERCHROME + + NS_DECL_NSIURICONTENTLISTENER + + NS_DECL_NSIWEBPROGRESSLISTENER + + NS_DECL_NSIBASEWINDOW + +private: + PtWidget_t *mOwningWidget; + nsCOMPtr mWebBrowser; + MozEmbedChromeCB *mNewBrowserCB; + void *mNewBrowserCBData; + MozEmbedDestroyCB *mDestroyCB; + void *mDestroyCBData; + MozEmbedVisibilityCB *mVisibilityCB; + void *mVisibilityCBData; + MozEmbedLinkCB *mLinkCB; + void *mLinkCBData; + MozEmbedJSStatusCB *mJSStatusCB; + void *mJSStatusCBData; + MozEmbedLocationCB *mLocationCB; + void *mLocationCBData; + MozEmbedTitleCB *mTitleCB; + void *mTitleCBData; + MozEmbedProgressCB *mProgressCB; + void *mProgressCBData; + MozEmbedNetCB *mNetCB; + void *mNetCBData; + MozEmbedStartOpenCB *mOpenCB; + void *mOpenCBData; + nsRect mBounds; + PRBool mVisibility; + nsXPIDLCString mLinkMessage; + nsXPIDLCString mJSStatus; + nsXPIDLCString mLocation; + nsXPIDLCString mTitle; + nsString mTitleUnicode; + PRUint32 mChromeMask; + static nsVoidArray *sBrowsers; + nsCOMPtr mStream; + nsCOMPtr mLoadGroup; + nsCOMPtr mChannel; + nsCOMPtr mContentViewer; + nsCOMPtr mStreamListener; + PRUint32 mOffset; + PRBool mDoingStream; +}; + +#endif /* __MozEmbedChrome_h */ + diff --git a/embedding/browser/photon/src/MozEmbedStream.cpp b/embedding/browser/photon/src/MozEmbedStream.cpp new file mode 100644 index 000000000000..3581a456f09f --- /dev/null +++ b/embedding/browser/photon/src/MozEmbedStream.cpp @@ -0,0 +1,149 @@ +/* + * 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 mozilla.org code. + * + * The Initial Developer of the Original Code is Christopher Blizzard. + * Portions created by Christopher Blizzard are Copyright (C) + * Christopher Blizzard. All Rights Reserved. + * + * Contributor(s): + * Christopher Blizzard + */ + +#include "MozEmbedStream.h" +#include "nsMemory.h" + +// nsIInputStream interface + +NS_IMPL_ADDREF(MozEmbedStream) +NS_IMPL_RELEASE(MozEmbedStream) + +NS_INTERFACE_MAP_BEGIN(MozEmbedStream) + NS_INTERFACE_MAP_ENTRY(nsISupports) + NS_INTERFACE_MAP_ENTRY(nsIInputStream) +NS_INTERFACE_MAP_END + +MozEmbedStream::MozEmbedStream() +{ + NS_INIT_REFCNT(); + mLength = 0; + mBuffer = 0; +} + +MozEmbedStream::~MozEmbedStream() +{ + if (mBuffer) + nsMemory::Free(mBuffer); +} + +NS_IMETHODIMP MozEmbedStream::Available(PRUint32 *_retval) +{ + NS_ENSURE_ARG_POINTER(_retval); + *_retval = mLength; + return NS_OK; +} + +NS_IMETHODIMP MozEmbedStream::Read(char * aBuf, PRUint32 aCount, PRUint32 *_retval) +{ + PRUint32 bytesToRead; + + NS_ENSURE_ARG_POINTER(aBuf); + NS_ENSURE_ARG_POINTER(_retval); + *_retval = 0; + + // shortcut? + if (aCount == 0) + return NS_OK; + + // check to see how many bytes we can read + if (aCount > mLength) + bytesToRead = mLength; + else + bytesToRead = aCount; + + // copy our data + *_retval = bytesToRead; + memcpy(aBuf, mBuffer, bytesToRead); + + // see if we can truncate the buffer entirely + if (bytesToRead == mBufLen) + { + mBuffer = nsnull; + mLength = 0; + mBufLen = 0; + return NS_OK; + } + // truncate it some, then + memmove(mBuffer, &mBuffer[bytesToRead], (mLength - bytesToRead)); + mLength -= bytesToRead; + + return NS_OK; +} + +// nsIBaseStream interface + +NS_IMETHODIMP MozEmbedStream::Close(void) +{ + if (mBuffer) + nsMemory::Free(mBuffer); + mLength = 0; + mBufLen = 0; + return NS_OK; +} + +NS_METHOD MozEmbedStream::Append(const char *aData, PRUint32 aLen) +{ + // shortcut? + if (aLen == 0 || aData == NULL) + return NS_OK; + mLength += aLen; + // first time + if (!mBuffer) + { + mBuffer = (char *)nsMemory::Alloc(mLength); + mBufLen = mLength; + if (!mBuffer) + { + mLength = 0; + mBufLen = 0; + return NS_ERROR_OUT_OF_MEMORY; + } + memcpy(mBuffer, aData, aLen); + return NS_OK; + } + else + { + // see if we need to realloc + if (mLength > mBufLen) + { + char *newBuffer; + newBuffer = (char *)nsMemory::Realloc(mBuffer, mLength); + if (!newBuffer) + { + mLength = 0; + mBufLen = 0; + nsMemory::Free(mBuffer); + mBuffer = NULL; + return NS_ERROR_OUT_OF_MEMORY; + } + mBuffer = newBuffer; + mBufLen = mLength; + memcpy(&mBuffer[mLength - aLen], aData, aLen); + } + else + // no realloc required and don't have to update mBufLen, just + // update + memcpy(&mBuffer[mLength - aLen], aData, aLen); + } + + return NS_OK; +} diff --git a/embedding/browser/photon/src/MozEmbedStream.h b/embedding/browser/photon/src/MozEmbedStream.h new file mode 100644 index 000000000000..4ee604ad64e7 --- /dev/null +++ b/embedding/browser/photon/src/MozEmbedStream.h @@ -0,0 +1,46 @@ +/* + * 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 mozilla.org code. + * + * The Initial Developer of the Original Code is Christopher Blizzard. + * Portions created by Christopher Blizzard are Copyright (C) + * Christopher Blizzard. All Rights Reserved. + * + * Contributor(s): + * Christopher Blizzard + */ + +#include "nsISupports.h" +#include "nsIInputStream.h" + +class MozEmbedStream : public nsIInputStream +{ + public: + + MozEmbedStream(); + virtual ~MozEmbedStream(); + + // nsISupports + NS_DECL_ISUPPORTS + // nsIInputStream + NS_DECL_NSIINPUTSTREAM + // nsIBaseStream + NS_DECL_NSIBASESTREAM + + NS_METHOD Append(const char *aData, PRUint32 aLen); + + private: + + char * mBuffer; + PRUint32 mLength; + PRUint32 mBufLen; +}; diff --git a/embedding/browser/photon/src/PtMozilla.cpp b/embedding/browser/photon/src/PtMozilla.cpp new file mode 100644 index 000000000000..96baf9967f08 --- /dev/null +++ b/embedding/browser/photon/src/PtMozilla.cpp @@ -0,0 +1,381 @@ +#include +#include +#include "nsIWebBrowser.h" +#include "nsCWebBrowser.h" +#include "nsIWebBrowserChrome.h" +#include "MozEmbedChrome.h" +#include "nsIComponentManager.h" +#include "nsIWebNavigation.h" +#include "nsString.h" +#include "nsIEventQueueService.h" +#include "nsIServiceManager.h" +#include "nsISupportsArray.h" +#include "nsEmbedAPI.h" +#include "nsVoidArray.h" + +#include +#include "PtMozilla.h" +#include + +PtWidgetClass_t *PtCreateMozillaClass( void ); +#ifndef _PHSLIB + PtWidgetClassRef_t __PtMozilla = { NULL, PtCreateMozillaClass }; + PtWidgetClassRef_t *PtMozilla = &__PtMozilla; +#endif + +static NS_DEFINE_CID(kEventQueueServiceCID, NS_EVENTQUEUESERVICE_CID); + + +static PRBool NS_SetupRegistryCalled = PR_FALSE; +static PRBool ThreadQueueSetup = PR_FALSE; + +extern "C" void NS_SetupRegistry(); + + +int +mozilla_handle_event_queue(int fd, void *data, unsigned mode) +{ + nsIEventQueue *eventQueue = (nsIEventQueue *)data; + eventQueue->ProcessPendingEvents(); +} + +// connect function +static void mozilla_init( PtWidget_t *widget ) +{ + PtMozillaWidget_t *moz = (PtMozillaWidget_t *)widget; + int rv; + char *component_path = NULL; + + // --------- Mozilla related stuff ------------ + +#if 0 + // check to see if NS_SetupRegistry has been called + if (!NS_SetupRegistryCalled) + { + NS_SetupRegistry(); + NS_SetupRegistryCalled = PR_TRUE; + } +#else + // init our embedding + NS_InitEmbedding(component_path); +#endif + + // check to see if we have to set up our thread event queue + if (!ThreadQueueSetup) + { + nsIEventQueueService* eventQService; + rv = nsServiceManager::GetService(kEventQueueServiceCID, NS_GET_IID(nsIEventQueueService), (nsISupports **)&eventQService); + if (NS_OK == rv) + { + nsIEventQueue *eventQueue; + // create the event queue + rv = eventQService->CreateThreadEventQueue(); + rv = eventQService->GetThreadEventQueue(NS_CURRENT_THREAD, &eventQueue); + + PtAppAddFd(NULL, eventQueue->GetEventQueueSelectFD(), Pt_FD_READ|Pt_FD_NOPOLL, mozilla_handle_event_queue, eventQueue); + NS_RELEASE(eventQService); + NS_RELEASE(eventQueue); + } + ThreadQueueSetup = PR_TRUE; + } + + PtSuperClassConnect(PtContainer, widget); +} + +static void +mozilla_embed_handle_title_change(PtWidget_t *widget) +{ + PtMozillaWidget_t *moz = (PtMozillaWidget_t *)widget; + char *retval = NULL; + PtCallbackList_t *cb; + PtCallbackInfo_t cbinfo; + PtMozillaTitleCb_t t; + + if (moz->title_cb) + { + memset(&cbinfo, 0, sizeof(cbinfo)); + cbinfo.cbdata = &t; + cbinfo.reason = Pt_CB_MOZ_TITLE; + cb = moz->title_cb; + + moz->embed_private->embed->GetTitleChar(&retval); + t.title = retval; + PtInvokeCallbackList(cb, widget, &cbinfo); + } +} + + +static void +mozilla_embed_handle_location_change(PtWidget_t *widget) +{ + PtMozillaWidget_t *moz = (PtMozillaWidget_t *)widget; + char *retval = NULL; + PtCallbackList_t *cb; + PtCallbackInfo_t cbinfo; + PtMozillaUrlCb_t u; + + if (moz->url_cb) + { + memset(&cbinfo, 0, sizeof(cbinfo)); + cbinfo.cbdata = &u; + cbinfo.reason = Pt_CB_MOZ_URL; + cb = moz->url_cb; + + moz->embed_private->embed->GetLocation(&retval); + u.url = retval; + PtInvokeCallbackList(cb, widget, &cbinfo); + } +} + +static void +mozilla_embed_handle_link_change(PtWidget_t *widget) +{ + PtMozillaWidget_t *moz = (PtMozillaWidget_t *)widget; + char *retval = NULL; + PtCallbackList_t *cb; + PtCallbackInfo_t cbinfo; + PtMozillaStatusCb_t s; + + if (moz->status_cb) + { + memset(&cbinfo, 0, sizeof(cbinfo)); + cbinfo.cbdata = &s; + cbinfo.reason = Pt_CB_MOZ_STATUS; + cb = moz->status_cb; + + moz->embed_private->embed->GetLinkMessage(&retval); + s.message = retval; + PtInvokeCallbackList(cb, widget, &cbinfo); + } +} + +static void +mozilla_embed_handle_progress(PtWidget_t *widget, int32 curprogress, int32 maxprogress) +{ + PtMozillaWidget_t *moz = (PtMozillaWidget_t *)widget; + PtCallbackList_t *cb; + PtCallbackInfo_t cbinfo; + PtMozillaProgressCb_t p; + + if (moz->progress_cb) + { + memset(&cbinfo, 0, sizeof(cbinfo)); + cbinfo.cbdata = &p; + cbinfo.reason = Pt_CB_MOZ_PROGRESS; + cb = moz->progress_cb; + p.max = maxprogress; + p.cur = curprogress; + PtInvokeCallbackList(cb, widget, &cbinfo); + } +} + +static void +mozilla_embed_handle_net(PtWidget_t *widget,int32 flags, _uint32 status) +{ + PtMozillaWidget_t *moz = (PtMozillaWidget_t *)widget; + PtCallbackList_t *cb = NULL; + PtCallbackInfo_t cbinfo; + + memset(&cbinfo, 0, sizeof(cbinfo)); + // if we've got the start flag, emit the signal + if ((flags & MOZ_EMBED_FLAG_IS_NETWORK) && (flags & MOZ_EMBED_FLAG_START)) + { + if (moz->start_cb) + { + cbinfo.reason = Pt_CB_MOZ_START; + cb = moz->start_cb; + } + fprintf(stderr, "start\n"); + } + // and for stop, too + if ((flags & MOZ_EMBED_FLAG_IS_NETWORK) && (flags & MOZ_EMBED_FLAG_STOP)) + { + if (moz->complete_cb) + { + cbinfo.reason = Pt_CB_MOZ_COMPLETE; + cb = moz->complete_cb; + } + fprintf(stderr, "stop\n"); + } + fprintf(stderr, "other %d\n", flags); + if (cb) + PtInvokeCallbackList(cb, widget, &cbinfo); +} + +static void mozilla_defaults( PtWidget_t *widget ) +{ + PtMozillaWidget_t *moz = (PtMozillaWidget_t *)widget; + PtBasicWidget_t *basic = (PtBasicWidget_t *)widget; + nsCOMPtr browserChrome; + nsresult rv; + char *component_path = NULL; + + rv = NS_InitEmbedding(component_path); + if (NS_FAILED(rv)) + return; + // set up the thread event queue + nsIEventQueueService* eventQService; + rv = nsServiceManager::GetService(kEventQueueServiceCID, NS_GET_IID(nsIEventQueueService), (nsISupports **)&eventQService); + if (NS_OK == rv) + { + // get our hands on the thread event queue + nsIEventQueue *eventQueue; + rv = eventQService->GetThreadEventQueue(NS_CURRENT_THREAD, &eventQueue); + if (NS_FAILED(rv)) + return; + + PtAppAddFd(NULL, eventQueue->GetEventQueueSelectFD(), Pt_FD_READ|Pt_FD_NOPOLL, mozilla_handle_event_queue, eventQueue); + NS_RELEASE(eventQService); + NS_RELEASE(eventQueue); + } + + basic->flags = Pt_ALL_OUTLINES | Pt_ALL_BEVELS | Pt_FLAT_FILL; + widget->resize_flags &= ~Pt_RESIZE_XY_BITS; // fixed size. + widget->anchor_flags = Pt_TOP_ANCHORED_TOP | Pt_LEFT_ANCHORED_LEFT | \ + Pt_BOTTOM_ANCHORED_TOP | Pt_RIGHT_ANCHORED_LEFT | Pt_ANCHORS_INVALID; + + strcpy(moz->url, "www.mozilla.org"); + moz->embed_private = new MozEmbedPrivate(); + // create an nsIWebBrowser object + moz->embed_private->webBrowser = do_CreateInstance(NS_WEBBROWSER_PROGID); + // create our glue widget + moz->chrome = new MozEmbedChrome(); + moz->embed_private->embed = do_QueryInterface((nsISupports *)(nsIPhEmbed *) moz->chrome); + + // get our hands on the browser chrome + browserChrome = do_QueryInterface(moz->embed_private->embed); + // set the toplevel window + moz->embed_private->webBrowser->SetTopLevelWindow(browserChrome); + // set the widget as the owner of the object + moz->embed_private->embed->Init(widget); + + // so the embedding widget can find it's owning nsIWebBrowser object + browserChrome->SetWebBrowser(moz->embed_private->webBrowser); + + // track the window changes + moz->embed_private->embed->SetLinkChangeCallback((void (*)(void *))mozilla_embed_handle_link_change, widget); + moz->embed_private->embed->SetTitleChangeCallback((void (*)(void *))mozilla_embed_handle_title_change, widget); + moz->embed_private->embed->SetProgressCallback((void (*)(void *, int, int))mozilla_embed_handle_progress, widget); + moz->embed_private->embed->SetNetCallback((void (*)(void *, int, uint))mozilla_embed_handle_net, widget); + moz->embed_private->embed->SetLocationChangeCallback((void (*)(void *))mozilla_embed_handle_location_change, widget); + + // get our hands on a copy of the nsIWebNavigation interface for later + moz->embed_private->navigation = do_QueryInterface(moz->embed_private->webBrowser); + + browserChrome->SetChromeMask(1); +} + +void +mozilla_embed_load_url(PtWidget_t *widget, const char *url) +{ + PtMozillaWidget_t *moz = (PtMozillaWidget_t *)widget; + nsString URLString; + + URLString.AssignWithConversion(url); + moz->embed_private->navigation->LoadURI(URLString.GetUnicode()); +} + +// realized function +static void mozilla_realized( PtWidget_t *widget ) +{ + PtMozillaWidget_t *moz = (PtMozillaWidget_t *)widget; + nsCOMPtr uriListener; + nsCOMPtr webBrowserBaseWindow; + PRBool visibility; + + PtSuperClassRealized(PtContainer, widget); + + // init our window + webBrowserBaseWindow = do_QueryInterface(moz->embed_private->webBrowser); + if (!webBrowserBaseWindow) + printf("no webBrowserBaseWindow\n"); + webBrowserBaseWindow->InitWindow(widget, NULL, 0, 0, widget->area.size.w, widget->area.size.h); + webBrowserBaseWindow->Create(); + webBrowserBaseWindow->GetVisibility(&visibility); + // set our webBrowser object as the content listener object + uriListener = do_QueryInterface(moz->embed_private->embed); + if (!uriListener) + printf("no uriListener\n"); + moz->embed_private->webBrowser->SetParentURIContentListener(uriListener); + + // show it + webBrowserBaseWindow->SetVisibility(PR_TRUE); + + // If an initial url was stored, load it + if (moz->url[0]) + mozilla_embed_load_url(widget, moz->url); +} + +// unrealized function +static void mozilla_unrealized( PtWidget_t *widget ) +{ + PtMozillaWidget_t *moz = (PtMozillaWidget_t *)widget; +} + +static void mozilla_modify( PtWidget_t *widget, PtArg_t const *argt ) +{ + PtMozillaWidget_t *moz = (PtMozillaWidget_t *)widget; + + switch( argt->type ) + { + case Pt_ARG_MOZ_GET_URL: + { + nsString URLString; + char *url = (char *)argt->value; + URLString.AssignWithConversion(url); + moz->embed_private->navigation->LoadURI(URLString.GetUnicode()); + break; + } + case Pt_ARG_MOZ_NAVIGATE_PAGE: + if (argt->len == WWW_DIRECTION_FWD) + moz->embed_private->navigation->GoForward(); + else + moz->embed_private->navigation->GoBack(); + break; + case Pt_ARG_MOZ_STOP: + moz->embed_private->navigation->Stop(); + break; + case Pt_ARG_MOZ_RELOAD: + moz->embed_private->navigation->Reload(0); + break; + default: + return; + } + + return; +} + +// PtMozilla class creation function +PtWidgetClass_t *PtCreateMozillaClass( void ) +{ + static const PtResourceRec_t resources[] = + { + { Pt_ARG_MOZ_GET_URL, mozilla_modify, Pt_QUERY_PREVENT }, + { Pt_ARG_MOZ_NAVIGATE_PAGE, mozilla_modify, Pt_QUERY_PREVENT }, + { Pt_ARG_MOZ_RELOAD, mozilla_modify, Pt_QUERY_PREVENT }, + { Pt_ARG_MOZ_STOP, mozilla_modify, Pt_QUERY_PREVENT }, + { Pt_CB_MOZ_STATUS, NULL, NULL, Pt_ARG_IS_CALLBACK_LIST(PtMozillaWidget_t, status_cb) }, + { Pt_CB_MOZ_PROGRESS, NULL, NULL, Pt_ARG_IS_CALLBACK_LIST(PtMozillaWidget_t, progress_cb) }, + { Pt_CB_MOZ_TITLE, NULL, NULL, Pt_ARG_IS_CALLBACK_LIST(PtMozillaWidget_t, title_cb) }, + { Pt_CB_MOZ_START, NULL, NULL, Pt_ARG_IS_CALLBACK_LIST(PtMozillaWidget_t, start_cb) }, + { Pt_CB_MOZ_COMPLETE, NULL, NULL, Pt_ARG_IS_CALLBACK_LIST(PtMozillaWidget_t, complete_cb) }, + { Pt_CB_MOZ_URL, NULL, NULL, Pt_ARG_IS_CALLBACK_LIST(PtMozillaWidget_t, url_cb) }, + }; + + static const PtArg_t args[] = + { + { Pt_SET_VERSION, 200}, + { Pt_SET_STATE_LEN, sizeof( PtMozillaWidget_t ) }, + //{ Pt_SET_CONNECT_F, (long)mozilla_init }, + { Pt_SET_DFLTS_F, (long)mozilla_defaults }, + { Pt_SET_REALIZED_F, (long)mozilla_realized }, + { Pt_SET_UNREALIZE_F, (long)mozilla_unrealized }, + { Pt_SET_FLAGS, Pt_RECTANGULAR, Pt_RECTANGULAR }, + { Pt_SET_RESOURCES, (long) resources }, + { Pt_SET_NUM_RESOURCES, sizeof( resources )/sizeof( resources[0] ) }, + { Pt_SET_DESCRIPTION, (long) "PtMozilla" }, + }; + + return( PtMozilla->wclass = PtCreateWidgetClass( + PtContainer, 0, sizeof( args )/sizeof( args[0] ), args ) ); +} diff --git a/embedding/browser/photon/src/PtMozilla.h b/embedding/browser/photon/src/PtMozilla.h new file mode 100644 index 000000000000..f8453f16054d --- /dev/null +++ b/embedding/browser/photon/src/PtMozilla.h @@ -0,0 +1,122 @@ +/* + * PtWebClient.h + * Header file for the PtWebClient widget class + * + * Copyright by QNX Software Systems Limited 1996. All rights reserved. + */ + +#ifndef __PT_MOZILLA_H_INCLUDED +#define __PT_MOZILLA_H_INCLUDED + +#include +#include +#include +#include "nsString.h" +#include "nsIWebBrowser.h" +#include "nsCWebBrowser.h" +#include "nsIWebBrowserChrome.h" +#include "MozEmbedChrome.h" +#include "nsIComponentManager.h" +#include "nsIWebNavigation.h" +#include "nsIEventQueueService.h" +#include "nsIServiceManager.h" +#include "nsISupportsArray.h" +#include "nsVoidArray.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * PtMozilla public + */ + +extern PtWidgetClassRef_t *PtMozilla; + +enum { MOZ_EMBED_FLAG_START = 1, + MOZ_EMBED_FLAG_REDIRECTING = 2, + MOZ_EMBED_FLAG_TRANSFERRING = 4, + MOZ_EMBED_FLAG_NEGOTIATING = 8, + MOZ_EMBED_FLAG_STOP = 16, + + MOZ_EMBED_FLAG_IS_REQUEST = 65536, + MOZ_EMBED_FLAG_IS_DOCUMENT = 131072, + MOZ_EMBED_FLAG_IS_NETWORK = 262144, + MOZ_EMBED_FLAG_IS_WINDOW = 524288 }; + +/* Resources */ + +#define Pt_ARG_MOZ_GET_URL Pt_RESOURCE( Pt_USER(10), 0 ) +#define Pt_ARG_MOZ_NAVIGATE_PAGE Pt_RESOURCE( Pt_USER(10), 1 ) +#define Pt_ARG_MOZ_RELOAD Pt_RESOURCE( Pt_USER(10), 2 ) +#define Pt_ARG_MOZ_STOP Pt_RESOURCE( Pt_USER(10), 3 ) +#define Pt_CB_MOZ_STATUS Pt_RESOURCE( Pt_USER(10), 4 ) +#define Pt_CB_MOZ_TITLE Pt_RESOURCE( Pt_USER(10), 5 ) +#define Pt_CB_MOZ_PROGRESS Pt_RESOURCE( Pt_USER(10), 6 ) +#define Pt_CB_MOZ_START Pt_RESOURCE( Pt_USER(10), 7 ) +#define Pt_CB_MOZ_COMPLETE Pt_RESOURCE( Pt_USER(10), 8 ) +#define Pt_CB_MOZ_URL Pt_RESOURCE( Pt_USER(10), 9 ) + +#define MAX_URL_LENGTH 1024 + +#define WWW_DIRECTION_FWD 1 +#define WWW_DIRECTION_BACK 2 + +typedef struct mozilla_progress_t +{ + int32 cur; + int32 max; +} PtMozillaProgressCb_t; + +typedef struct mozilla_title_t +{ + char *title; +} PtMozillaTitleCb_t; + +typedef struct mozilla_url_t +{ + char *url; +} PtMozillaUrlCb_t; + +typedef struct mozilla_status_t +{ + char *message; +} PtMozillaStatusCb_t; + +class MozEmbedPrivate +{ +public: + nsCOMPtr webBrowser; + nsCOMPtr navigation; + nsCOMPtr embed; + nsCString mInitialURL; +}; + +typedef struct Pt_mozilla_client_widget +{ + PtContainerWidget_t container; + char url[MAX_URL_LENGTH]; + MozEmbedPrivate *embed_private; + MozEmbedChrome *chrome; + PtCallbackList_t *title_cb; + PtCallbackList_t *status_cb; + PtCallbackList_t *progress_cb; + PtCallbackList_t *start_cb; + PtCallbackList_t *complete_cb; + PtCallbackList_t *url_cb; +} PtMozillaWidget_t; + +/* Widget union */ +typedef union Pt_mozilla_union +{ + PtWidget_t core; + PtBasicWidget_t basic; + PtContainerWidget_t cntnr; + PtMozillaWidget_t moz; +} PtMozillaUnion_t; + +#ifdef __cplusplus +}; +#endif + +#endif diff --git a/embedding/browser/photon/src/nsIPhEmbed.h b/embedding/browser/photon/src/nsIPhEmbed.h new file mode 100644 index 000000000000..d3c6f02c4987 --- /dev/null +++ b/embedding/browser/photon/src/nsIPhEmbed.h @@ -0,0 +1,72 @@ +/* + * 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 mozilla.org code. + * + * The Initial Developer of the Original Code is Christopher Blizzard. + * Portions created by Christopher Blizzard are Copyright (C) + * Christopher Blizzard. All Rights Reserved. + * + * Contributor(s): + * Christopher Blizzard + */ + +#ifndef __nsIPhEmbed_h__ +#define __nsIPhEmbed_h__ + +#include +#include "nsIWebBrowser.h" + +#define NS_IGTKEMBED_IID_STR "ebe19ea4-1dd1-11b2-bc20-8e8105516b2f" + +#define NS_IGTKEMBED_IID \ + {0xebe19ea4, 0x1dd1, 0x11b2, \ + { 0xbc, 0x20, 0x8e, 0x81, 0x05, 0x51, 0x6b, 0x2f }} + +typedef nsresult (MozEmbedChromeCB) (PRUint32 chromeMask, nsIWebBrowser **_retval, void *aData); +typedef void (MozEmbedDestroyCB) (void *aData); +typedef void (MozEmbedVisibilityCB) (PRBool aVisibility, void *aData); +typedef void (MozEmbedLinkCB) (void *aData); +typedef void (MozEmbedJSStatusCB) (void *aData); +typedef void (MozEmbedLocationCB) (void *aData); +typedef void (MozEmbedTitleCB) (void *aData); +typedef void (MozEmbedProgressCB) (void *aData, PRInt32 aProgressTotal, + PRInt32 aProgressCurrent); +typedef void (MozEmbedNetCB) (void *aData, PRInt32 aFlags, nsresult aStatus); +typedef PRBool (MozEmbedStartOpenCB) (const char *aURI, void *aData); + +class nsIPhEmbed : public nsISupports +{ +public: + + NS_DEFINE_STATIC_IID_ACCESSOR(NS_IGTKEMBED_IID) + + NS_IMETHOD Init (PtWidget_t *aOwningWidget) = 0; + NS_IMETHOD SetNewBrowserCallback (MozEmbedChromeCB *aCallback, void *aData) = 0; + NS_IMETHOD SetDestroyCallback (MozEmbedDestroyCB *aCallback, void *aData) = 0; + NS_IMETHOD SetVisibilityCallback (MozEmbedVisibilityCB *aCallback, void *aData) = 0; + NS_IMETHOD SetLinkChangeCallback (MozEmbedLinkCB *aCallback, void *aData) = 0; + NS_IMETHOD SetJSStatusChangeCallback (MozEmbedJSStatusCB *aCallback, void *aData) = 0; + NS_IMETHOD SetLocationChangeCallback (MozEmbedLocationCB *aCallback, void *aData) = 0; + NS_IMETHOD SetTitleChangeCallback (MozEmbedTitleCB *aCallback, void *aData) = 0; + NS_IMETHOD SetProgressCallback (MozEmbedProgressCB *aCallback, void *aData) = 0; + NS_IMETHOD SetNetCallback (MozEmbedNetCB *aCallback, void *aData) = 0; + NS_IMETHOD SetStartOpenCallback (MozEmbedStartOpenCB *aCallback, void *aData) = 0; + NS_IMETHOD GetLinkMessage (char **retval) = 0; + NS_IMETHOD GetJSStatus (char **retval) = 0; + NS_IMETHOD GetLocation (char **retval) = 0; + NS_IMETHOD GetTitleChar (char **retval) = 0; + NS_IMETHOD OpenStream (const char *aBaseURI, const char *aContentType) = 0; + NS_IMETHOD AppendToStream (const char *aData, int32 aLen) = 0; + NS_IMETHOD CloseStream (void) = 0; +}; + +#endif /* __nsIPhEmbed_h__ */ diff --git a/embedding/browser/photon/tests/Makefile.in b/embedding/browser/photon/tests/Makefile.in new file mode 100644 index 000000000000..c6f847bd0b43 --- /dev/null +++ b/embedding/browser/photon/tests/Makefile.in @@ -0,0 +1,42 @@ +# +# 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 the Mozilla browser. +# +# The Initial Developer of the Original Code is Christopher +# Blizzard. Portions created by Christopher Blizzard are +# Copyright (C) 1999, Mozilla. All Rights Reserved. +# +# Contributor(s): +# Christopher Blizzard + +DEPTH = ../../../.. +topsrcdir = @top_srcdir@ +srcdir = @srcdir@ +VPATH = @srcdir@ + +include $(DEPTH)/config/autoconf.mk + +CPPSRCS = \ + TestPhEmbed.cpp + +SIMPLE_PROGRAMS = $(CPPSRCS:.cpp=) + +LIBS = \ + $(MOZ_COMPONENT_LIBS) \ + -lphembedmoz \ + $(TK_LIBS) \ + $(NULL) + +include $(topsrcdir)/config/rules.mk + +CXXFLAGS += $(MOZ_GTK_CFLAGS) + diff --git a/embedding/browser/photon/tests/TestPhEmbed.cpp b/embedding/browser/photon/tests/TestPhEmbed.cpp new file mode 100644 index 000000000000..0b6f3c285e2a --- /dev/null +++ b/embedding/browser/photon/tests/TestPhEmbed.cpp @@ -0,0 +1,150 @@ +/* + * 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 mozilla.org code. + * + * The Initial Developer of the Original Code is Christopher Blizzard. + * Portions created by Christopher Blizzard are Copyright (C) + * Christopher Blizzard. All Rights Reserved. + * + * Contributor(s): + * Christopher Blizzard + */ + +#include +#include +#include +#include "nsIWebBrowser.h" +#include "nsCWebBrowser.h" +#include "nsIWebBrowserChrome.h" +#include "MozEmbedChrome.h" +#include "nsIComponentManager.h" +#include "nsIWebNavigation.h" +#include "nsString.h" +#include "nsIEventQueueService.h" +#include "nsIServiceManager.h" +#include "nsISupportsArray.h" +#include "nsVoidArray.h" +#include "prlog.h" + +#include +#include "PtMozilla.h" +#include + +PtWidget_t *window, *back, *forward, *stop, *web, *reload; + +int reload_cb(PtWidget_t *widget, void *data, PtCallbackInfo_t *cbinfo) +{ + PtArg_t args[1]; + PtSetArg(&args[0], Pt_ARG_MOZ_RELOAD, 0, 0); + PtSetResources(web, 1, args); + return (Pt_CONTINUE); +} + +int stop_cb(PtWidget_t *widget, void *data, PtCallbackInfo_t *cbinfo) +{ + PtArg_t args[1]; + PtSetArg(&args[0], Pt_ARG_MOZ_STOP, 0, 0); + PtSetResources(web, 1, args); + return (Pt_CONTINUE); +} + +int back_cb(PtWidget_t *widget, void *data, PtCallbackInfo_t *cbinfo) +{ + PtArg_t args[1]; + PtSetArg(&args[0], Pt_ARG_MOZ_NAVIGATE_PAGE, WWW_DIRECTION_BACK, 0); + PtSetResources(web, 1, args); + return (Pt_CONTINUE); +} + +int forward_cb(PtWidget_t *widget, void *data, PtCallbackInfo_t *cbinfo) +{ + PtArg_t args[1]; + PtSetArg(&args[0], Pt_ARG_MOZ_NAVIGATE_PAGE, WWW_DIRECTION_FWD, 0); + PtSetResources(web, 1, args); + return (Pt_CONTINUE); +} + +int load_url_cb(PtWidget_t *widget, void *data, PtCallbackInfo_t *cbinfo) +{ + PtTextCallback_t *tcb = (PtTextCallback_t *)cbinfo->cbdata; + PtArg_t args[1]; + + PtSetArg(&args[0], Pt_ARG_MOZ_GET_URL, tcb->text, 0); + PtSetResources(web, 1, args); + return (Pt_CONTINUE); +} + +PRLogModuleInfo *PhWidLog; + +int +main(int argc, char **argv) +{ + int n = 0; + PtArg_t args[10]; + PhDim_t win_dim = {700, 700}; + PhArea_t area = {{0, 0}, {70, 25}}; + + if (!PhWidLog) + { + PhWidLog = PR_NewLogModule("PhWidLog"); + } + + PtSetArg(&args[n++], Pt_ARG_TITLE, "PtMozilla Test\n", 0); + PtSetArg(&args[n++], Pt_ARG_DIM, &win_dim, 0); + window = PtAppInit(NULL, NULL, NULL, n, args); + + n = 0; + PtSetArg(&args[n++], Pt_ARG_AREA, &area, 0); + PtSetArg(&args[n++], Pt_ARG_TEXT_STRING, "Back", 0); + back = PtCreateWidget(PtButton, window, n, args); + PtAddCallback(back, Pt_CB_ACTIVATE, back_cb, NULL); + + n = 0; + area.pos.x += 71; + PtSetArg(&args[n++], Pt_ARG_AREA, &area, 0); + PtSetArg(&args[n++], Pt_ARG_TEXT_STRING, "Forward", 0); + forward = PtCreateWidget(PtButton, window, n, args); + PtAddCallback(forward, Pt_CB_ACTIVATE, forward_cb, NULL); + + n = 0; + area.pos.x += 71; + PtSetArg(&args[n++], Pt_ARG_AREA, &area, 0); + PtSetArg(&args[n++], Pt_ARG_TEXT_STRING, "Reload", 0); + reload = PtCreateWidget(PtButton, window, n, args); + PtAddCallback(reload, Pt_CB_ACTIVATE, reload_cb, NULL); + + n = 0; + area.pos.x += 71; + PtSetArg(&args[n++], Pt_ARG_AREA, &area, 0); + PtSetArg(&args[n++], Pt_ARG_TEXT_STRING, "Stop", 0); + stop = PtCreateWidget(PtButton, window, n, args); + PtAddCallback(stop, Pt_CB_ACTIVATE, stop_cb, NULL); + + n = 0; + area.pos.x += 71; + area.size.w = win_dim.w - area.pos.x - 2; + PtSetArg(&args[n++], Pt_ARG_AREA, &area, 0); + stop = PtCreateWidget(PtText, window, n, args); + PtAddCallback(stop, Pt_CB_ACTIVATE, load_url_cb, NULL); + + n = 0; + area.pos.y += area.size.h + 2; + area.pos.x = 0; + area.size.w = win_dim.w; + area.size.h = win_dim.h - area.pos.y; + PtSetArg(&args[n++], Pt_ARG_AREA, &area, 0); + web = PtCreateWidget(PtMozilla, window, n, args); + + PtRealizeWidget(window); + + PtMainLoop(); +}