From 7e663e4f9ee7406de01cf2bcc53cc8a23ade6d02 Mon Sep 17 00:00:00 2001 From: "timeless%mozdev.org" Date: Mon, 4 Dec 2006 04:06:14 +0000 Subject: [PATCH] Landing MICROB_20061031_BRANCH This is an experiment, and I'm sorry that the code isn't perfect. Patches Wanted, Work will be on the MICROB_20061204_BRANCH git-svn-id: svn://10.0.0.236/trunk@216392 18797224-902f-48f8-a5cc-f745e15eee43 --- .../browser/gtk/src/EmbedCertificates.cpp | 366 +++ .../browser/gtk/src/EmbedCertificates.h | 96 + .../browser/gtk/src/EmbedContentListener.cpp | 61 +- .../browser/gtk/src/EmbedContentListener.h | 2 + .../browser/gtk/src/EmbedContextMenuInfo.cpp | 578 +++++ .../browser/gtk/src/EmbedContextMenuInfo.h | 99 + .../browser/gtk/src/EmbedDownloadMgr.cpp | 298 +++ .../browser/gtk/src/EmbedDownloadMgr.h | 96 + .../browser/gtk/src/EmbedEventListener.cpp | 625 ++++- .../browser/gtk/src/EmbedEventListener.h | 69 +- .../browser/gtk/src/EmbedFilePicker.cpp | 215 ++ .../browser/gtk/src/EmbedFilePicker.h | 64 + .../browser/gtk/src/EmbedGlobalHistory.cpp | 920 +++++++ .../browser/gtk/src/EmbedGlobalHistory.h | 124 + .../browser/gtk/src/EmbedGtkTools.cpp | 105 + .../embedding/browser/gtk/src/EmbedGtkTools.h | 69 + .../browser/gtk/src/EmbedPasswordMgr.cpp | 2134 +++++++++++++++++ .../browser/gtk/src/EmbedPasswordMgr.h | 193 ++ .../browser/gtk/src/EmbedPrivate.cpp | 958 +++++++- .../embedding/browser/gtk/src/EmbedPrivate.h | 74 + .../browser/gtk/src/EmbedProgress.cpp | 241 +- .../embedding/browser/gtk/src/EmbedProgress.h | 4 +- .../browser/gtk/src/EmbedPrompter.cpp | 503 ++-- .../embedding/browser/gtk/src/EmbedPrompter.h | 11 +- .../embedding/browser/gtk/src/EmbedWindow.cpp | 79 +- .../embedding/browser/gtk/src/EmbedWindow.h | 19 +- .../browser/gtk/src/EmbedWindowCreator.cpp | 31 +- .../browser/gtk/src/EmbedWindowCreator.h | 6 +- .../browser/gtk/src/GtkPromptService.cpp | 742 ++++-- .../browser/gtk/src/GtkPromptService.h | 23 +- mozilla/embedding/browser/gtk/src/Makefile.in | 116 +- .../embedding/browser/gtk/src/gtkmozembed.h | 182 +- .../browser/gtk/src/gtkmozembed2.cpp | 989 ++++++-- .../browser/gtk/src/gtkmozembed_common.cpp | 665 +++++ .../browser/gtk/src/gtkmozembed_common.h | 206 ++ .../browser/gtk/src/gtkmozembed_download.cpp | 260 ++ .../browser/gtk/src/gtkmozembed_download.h | 116 + .../browser/gtk/src/gtkmozembed_glue.cpp | 26 +- .../browser/gtk/src/gtkmozembed_internal.h | 6 +- .../browser/gtk/src/gtkmozembedmarshal.c | 1115 ++++++++- .../browser/gtk/src/gtkmozembedmarshal.h | 238 +- .../browser/gtk/src/gtkmozembedmarshal.list | 31 + .../browser/gtk/src/gtkmozembedprivate.h | 59 +- .../embedding/browser/gtk/src/nsIPassword.idl | 79 + .../browser/gtk/src/nsIPasswordInternal.idl | 57 + mozilla/embedding/browser/gtk/src/types.txt | 5 - 46 files changed, 11867 insertions(+), 1088 deletions(-) create mode 100644 mozilla/embedding/browser/gtk/src/EmbedCertificates.cpp create mode 100644 mozilla/embedding/browser/gtk/src/EmbedCertificates.h create mode 100644 mozilla/embedding/browser/gtk/src/EmbedContextMenuInfo.cpp create mode 100644 mozilla/embedding/browser/gtk/src/EmbedContextMenuInfo.h create mode 100644 mozilla/embedding/browser/gtk/src/EmbedDownloadMgr.cpp create mode 100644 mozilla/embedding/browser/gtk/src/EmbedDownloadMgr.h create mode 100644 mozilla/embedding/browser/gtk/src/EmbedFilePicker.cpp create mode 100644 mozilla/embedding/browser/gtk/src/EmbedFilePicker.h create mode 100644 mozilla/embedding/browser/gtk/src/EmbedGlobalHistory.cpp create mode 100644 mozilla/embedding/browser/gtk/src/EmbedGlobalHistory.h create mode 100644 mozilla/embedding/browser/gtk/src/EmbedGtkTools.cpp create mode 100644 mozilla/embedding/browser/gtk/src/EmbedGtkTools.h create mode 100644 mozilla/embedding/browser/gtk/src/EmbedPasswordMgr.cpp create mode 100644 mozilla/embedding/browser/gtk/src/EmbedPasswordMgr.h create mode 100644 mozilla/embedding/browser/gtk/src/gtkmozembed_common.cpp create mode 100644 mozilla/embedding/browser/gtk/src/gtkmozembed_common.h create mode 100644 mozilla/embedding/browser/gtk/src/gtkmozembed_download.cpp create mode 100644 mozilla/embedding/browser/gtk/src/gtkmozembed_download.h create mode 100644 mozilla/embedding/browser/gtk/src/gtkmozembedmarshal.list create mode 100644 mozilla/embedding/browser/gtk/src/nsIPassword.idl create mode 100644 mozilla/embedding/browser/gtk/src/nsIPasswordInternal.idl delete mode 100644 mozilla/embedding/browser/gtk/src/types.txt diff --git a/mozilla/embedding/browser/gtk/src/EmbedCertificates.cpp b/mozilla/embedding/browser/gtk/src/EmbedCertificates.cpp new file mode 100644 index 00000000000..3ac391848b9 --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/EmbedCertificates.cpp @@ -0,0 +1,366 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 tw=80 et cindent: */ +/* ***** 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 mozilla.org code. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 2001 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Terry Hayes + * Javier Delgadillo + * Oleg Romashin + * + * 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 ***** */ +/** + * Derived from nsNSSDialogs http://landfill.mozilla.org/mxr-test/seamonkey/source/security/manager/pki/src/nsNSSDialogs.cpp + */ +#include +#include "nsIURI.h" +#include "EmbedPrivate.h" +#include "nsServiceManagerUtils.h" +#include "nsIWebNavigationInfo.h" +#include "nsDocShellCID.h" +#include "nsCOMPtr.h" +#ifdef MOZILLA_INTERNAL_API +#include "nsString.h" +#include +#include "nsReadableUtils.h" +#else +#include "nsStringAPI.h" +#endif +#include "nsIPrompt.h" +#include "nsIDOMWindowInternal.h" +#include "nsIComponentManager.h" +#include "nsIServiceManager.h" +#include "nsIStringBundle.h" +#include "nsIInterfaceRequestor.h" +#include "nsIInterfaceRequestorUtils.h" +#include "nsIX509Cert.h" +#include "nsIX509CertDB.h" +#include "nsILocaleService.h" +#include "nsIDateTimeFormat.h" +#include "nsDateTimeFormatCID.h" +#include "EmbedCertificates.h" +#include "nsIKeygenThread.h" +#include "nsIX509CertValidity.h" +#include "nsICRLInfo.h" +#include "gtkmozembed.h" + +#define PIPSTRING_BUNDLE_URL "chrome://pippki/locale/pippki.properties" + +static NS_DEFINE_CID(kCStringBundleServiceCID, NS_STRINGBUNDLESERVICE_CID); + +EmbedCertificates::EmbedCertificates(void) +{ +} + +EmbedCertificates::~EmbedCertificates() +{ +} + +#ifdef BAD_CERT_LISTENER2 +NS_IMPL_THREADSAFE_ISUPPORTS9( +#else +NS_IMPL_THREADSAFE_ISUPPORTS8( +#endif + EmbedCertificates, + nsITokenPasswordDialogs, + nsIBadCertListener, +#ifdef BAD_CERT_LISTENER2 + nsIBadCertListener2, +#endif + nsICertificateDialogs, + nsIClientAuthDialogs, + nsICertPickDialogs, + nsITokenDialogs, + nsIDOMCryptoDialogs, + nsIGeneratingKeypairInfoDialogs) + +nsresult +EmbedCertificates::Init(void) +{ + nsresult rv; + nsCOMPtr service = do_GetService(kCStringBundleServiceCID, &rv); + if (NS_FAILED(rv)) return NS_OK; + rv = service->CreateBundle(PIPSTRING_BUNDLE_URL, + getter_AddRefs(mPIPStringBundle)); + return NS_OK; +} + +nsresult +EmbedCertificates::SetPassword(nsIInterfaceRequestor *ctx, + const PRUnichar *tokenName, PRBool* _canceled) +{ + *_canceled = PR_FALSE; + return NS_OK; +} + +nsresult +EmbedCertificates::GetPassword(nsIInterfaceRequestor *ctx, + const PRUnichar *tokenName, + PRUnichar **_password, + PRBool* _canceled) +{ + *_canceled = PR_FALSE; + return NS_OK; +} + +NS_IMETHODIMP +EmbedCertificates::ConfirmUnknownIssuer(nsIInterfaceRequestor *socketInfo, + nsIX509Cert *cert, PRInt16 *outAddType, + PRBool *_retval) +{ + *outAddType = ADD_TRUSTED_FOR_SESSION; + *_retval = PR_TRUE; + return NS_OK; +} + +NS_IMETHODIMP +EmbedCertificates::ConfirmMismatchDomain(nsIInterfaceRequestor *socketInfo, + const nsACString &targetURL, + nsIX509Cert *cert, PRBool *_retval) +{ + *_retval = PR_TRUE; + return NS_OK; +} + +NS_IMETHODIMP +EmbedCertificates::ConfirmCertExpired(nsIInterfaceRequestor *socketInfo, + nsIX509Cert *cert, PRBool *_retval) +{ + *_retval = PR_TRUE; + return NS_OK; +} + +NS_IMETHODIMP +EmbedCertificates::NotifyCrlNextupdate(nsIInterfaceRequestor *socketInfo, + const nsACString &targetURL, nsIX509Cert *cert) +{ + return NS_OK; +} + +NS_IMETHODIMP +EmbedCertificates::CrlImportStatusDialog(nsIInterfaceRequestor *ctx, nsICRLInfo *crl) +{ + return NS_OK; +} + +NS_IMETHODIMP +EmbedCertificates::ConfirmDownloadCACert(nsIInterfaceRequestor *ctx, + nsIX509Cert *cert, + PRUint32 *_trust, + PRBool *_retval) +{ + *_retval = PR_TRUE; + *_trust |= nsIX509CertDB::TRUSTED_SSL; + *_trust |= nsIX509CertDB::TRUSTED_EMAIL; + *_trust |= nsIX509CertDB::TRUSTED_OBJSIGN; + return NS_OK; +} + +NS_IMETHODIMP +EmbedCertificates::NotifyCACertExists(nsIInterfaceRequestor *ctx) +{ + return NS_OK; +} + +NS_IMETHODIMP +EmbedCertificates::ChooseCertificate( + nsIInterfaceRequestor *ctx, + const PRUnichar *cn, + const PRUnichar *organization, + const PRUnichar *issuer, + const PRUnichar **certNickList, + const PRUnichar **certDetailsList, + PRUint32 count, + PRInt32 *selectedIndex, + PRBool *canceled) +{ + *canceled = PR_FALSE; + return NS_OK; +} + +NS_IMETHODIMP +EmbedCertificates::PickCertificate( + nsIInterfaceRequestor *ctx, + const PRUnichar **certNickList, + const PRUnichar **certDetailsList, + PRUint32 count, + PRInt32 *selectedIndex, + PRBool *canceled) +{ + *canceled = PR_FALSE; + return NS_OK; +} + +NS_IMETHODIMP +EmbedCertificates::SetPKCS12FilePassword( + nsIInterfaceRequestor *ctx, + nsAString &_password, + PRBool *_retval) +{ + /* The person who wrote this method implementation did + * not read the contract. + */ + *_retval = PR_FALSE; + return NS_OK; +} + +NS_IMETHODIMP +EmbedCertificates::GetPKCS12FilePassword( + nsIInterfaceRequestor *ctx, + nsAString &_password, + PRBool *_retval) +{ + /* The person who wrote this method implementation did + * not read the contract. + */ + *_retval = PR_FALSE; + return NS_OK; +} + +/* void viewCert (in nsIX509Cert cert); */ +NS_IMETHODIMP +EmbedCertificates::ViewCert( + nsIInterfaceRequestor *ctx, + nsIX509Cert *cert) +{ + return NS_OK; +} + +NS_IMETHODIMP +EmbedCertificates::DisplayGeneratingKeypairInfo(nsIInterfaceRequestor *aCtx, nsIKeygenThread *runnable) +{ + return NS_OK; +} + +NS_IMETHODIMP +EmbedCertificates::ChooseToken( + nsIInterfaceRequestor *aCtx, + const PRUnichar **aTokenList, + PRUint32 aCount, + PRUnichar **aTokenChosen, + PRBool *aCanceled) +{ + *aCanceled = PR_FALSE; + return NS_OK; +} + +/* boolean ConfirmKeyEscrow (in nsIX509Cert escrowAuthority); */ +NS_IMETHODIMP +EmbedCertificates::ConfirmKeyEscrow(nsIX509Cert *escrowAuthority, PRBool *_retval) +{ + *_retval = PR_TRUE; + return NS_OK; +} + +#ifdef BAD_CERT_LISTENER2 +NS_IMETHODIMP +EmbedCertificates::ConfirmBadCertificate( + nsIInterfaceRequestor *ctx, + nsIX509Cert *cert, + PRBool aSecSuccess, + PRUint32 aError, + PRBool *_retval) +{ + nsresult rv; + gpointer pCert = NULL; + guint messint = 0; + nsCOMPtr parent (do_GetInterface (ctx)); + + GtkMozEmbedCommon * common = nsnull; + GtkMozEmbed *parentWidget = GTK_MOZ_EMBED(GetGtkWidgetForDOMWindow(parent)); + + if (!parentWidget) { + EmbedCommon * embedcommon = EmbedCommon::GetInstance(); + if (embedcommon) + common = embedcommon->mCommon; + } + + if (!(aError & nsIX509Cert::VERIFIED_OK)) { + pCert = (gpointer)cert; + messint = GTK_MOZ_EMBED_CERT_VERIFIED_OK; + if (aError & nsIX509Cert::NOT_VERIFIED_UNKNOWN) { + messint |= GTK_MOZ_EMBED_CERT_NOT_VERIFIED_UNKNOWN; + } + if (aError & nsIX509Cert::CERT_EXPIRED || aError & nsIX509Cert::CERT_REVOKED) { + nsCOMPtr validity; + rv = cert->GetValidity(getter_AddRefs(validity)); + if (NS_SUCCEEDED(rv)) { + PRTime notBefore, notAfter, timeToUse; + PRTime now = PR_Now(); + rv = validity->GetNotBefore(¬Before); + if (NS_FAILED(rv)) + return rv; + rv = validity->GetNotAfter(¬After); + if (NS_FAILED(rv)) + return rv; + if (LL_CMP(now, >, notAfter)) { + messint |= GTK_MOZ_EMBED_CERT_EXPIRED; + timeToUse = notAfter; + } else { + messint |= GTK_MOZ_EMBED_CERT_REVOKED; + timeToUse = notBefore; + } + } + } + if (aError & nsIX509Cert::CERT_NOT_TRUSTED) { + messint |= GTK_MOZ_EMBED_CERT_UNTRUSTED; + } + if (aError & nsIX509Cert::ISSUER_UNKNOWN) { + messint |= GTK_MOZ_EMBED_CERT_ISSUER_UNKNOWN; + } + if (aError & nsIX509Cert::ISSUER_NOT_TRUSTED) { + messint |= GTK_MOZ_EMBED_CERT_ISSUER_UNTRUSTED; + } + if (aError & nsIX509Cert::INVALID_CA) { + messint |= GTK_MOZ_EMBED_CERT_INVALID_CA; + } + if (aError & nsIX509Cert::USAGE_NOT_ALLOWED) { + } + PRBool retVal = PR_FALSE; + if (common) { + g_signal_emit_by_name(common, "certificate-error", pCert, messint, &retVal); + } + if (retVal == PR_TRUE) { + *_retval = PR_FALSE; + rv = NS_ERROR_FAILURE; + } else { + rv = NS_OK; + *_retval = PR_TRUE; + } + pCert = NULL; + } else { + rv = NS_OK; + *_retval = PR_TRUE; + } + return rv; +} +#endif diff --git a/mozilla/embedding/browser/gtk/src/EmbedCertificates.h b/mozilla/embedding/browser/gtk/src/EmbedCertificates.h new file mode 100644 index 00000000000..0f93027d359 --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/EmbedCertificates.h @@ -0,0 +1,96 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* ***** 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 mozilla.org code. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 2001 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Terry Hayes + * Javier Delgadillo + * Oleg Romashin + * + * 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 ***** */ +/** + * Derived from nsNSSDialogs http://landfill.mozilla.org/mxr-test/seamonkey/source/security/manager/pki/src/nsNSSDialogs.h + */ +#ifndef __EmbedCertificates_h +#define __EmbedCertificates_h +#include "nsITokenPasswordDialogs.h" +#include "nsIBadCertListener.h" +#ifdef BAD_CERT_LISTENER2 +#include "nsIBadCertListener2.h" +#endif +#include "nsICertificateDialogs.h" +#include "nsIClientAuthDialogs.h" +#include "nsICertPickDialogs.h" +#include "nsITokenDialogs.h" +#include "nsIDOMCryptoDialogs.h" +#include "nsIGenKeypairInfoDlg.h" +#include "nsCOMPtr.h" +#include "nsIStringBundle.h" +#define EMBED_CERTIFICATES_CID \ + { 0x518e071f, 0x1dd2, 0x11b2, \ + { 0x93, 0x7e, 0xc4, 0x5f, 0x14, 0xde, 0xf7, 0x78 }} +#define EMBED_CERTIFICATES_DESCRIPTION "Certificates Listener Impl" +class EmbedPrivate; +class EmbedCertificates +: public nsITokenPasswordDialogs, + public nsIBadCertListener, +#ifdef BAD_CERT_LISTENER2 + public nsIBadCertListener2, +#endif + public nsICertificateDialogs, + public nsIClientAuthDialogs, + public nsICertPickDialogs, + public nsITokenDialogs, + public nsIDOMCryptoDialogs, + public nsIGeneratingKeypairInfoDialogs +{ + public: + NS_DECL_ISUPPORTS + NS_DECL_NSITOKENPASSWORDDIALOGS + NS_DECL_NSIBADCERTLISTENER +#ifdef BAD_CERT_LISTENER2 + NS_DECL_NSIBADCERTLISTENER2 +#endif + NS_DECL_NSICERTIFICATEDIALOGS + NS_DECL_NSICLIENTAUTHDIALOGS + NS_DECL_NSICERTPICKDIALOGS + NS_DECL_NSITOKENDIALOGS + NS_DECL_NSIDOMCRYPTODIALOGS + NS_DECL_NSIGENERATINGKEYPAIRINFODIALOGS + EmbedCertificates(); + virtual ~EmbedCertificates(); + nsresult Init(void); + protected: + nsCOMPtr mPIPStringBundle; +}; +#endif /* __EmbedCertificates_h */ diff --git a/mozilla/embedding/browser/gtk/src/EmbedContentListener.cpp b/mozilla/embedding/browser/gtk/src/EmbedContentListener.cpp index 5b1967abd02..f5195c278b7 100644 --- a/mozilla/embedding/browser/gtk/src/EmbedContentListener.cpp +++ b/mozilla/embedding/browser/gtk/src/EmbedContentListener.cpp @@ -1,3 +1,5 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 tw=80 et cindent: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * @@ -36,7 +38,6 @@ * ***** END LICENSE BLOCK ***** */ #include -#include #include "nsIURI.h" @@ -69,10 +70,15 @@ EmbedContentListener::Init(EmbedPrivate *aOwner) NS_IMETHODIMP EmbedContentListener::OnStartURIOpen(nsIURI *aURI, - PRBool *aAbortOpen) + PRBool *aAbortOpen) { nsresult rv; + if (mOwner->mOpenBlock) { + *aAbortOpen = mOwner->mOpenBlock; + mOwner->mOpenBlock = PR_FALSE; + return NS_OK; + } nsCAutoString specString; rv = aURI->GetSpec(specString); @@ -80,9 +86,26 @@ EmbedContentListener::OnStartURIOpen(nsIURI *aURI, return rv; gint return_val = FALSE; + + /* checks if URI scheme is mailto */ + aURI->SchemeIs("mailto", &return_val); + if (return_val) { + /* stops URI opening to emit "mailto" signal */ + *aAbortOpen = TRUE; + + gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), + moz_embed_signals[MAILTO], + specString.get()); + + return NS_OK; + } + + // otherwise ... + return_val = FALSE; + gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[OPEN_URI], - specString.get(), &return_val); + moz_embed_signals[OPEN_URI], + specString.get(), &return_val); *aAbortOpen = return_val; @@ -91,41 +114,41 @@ EmbedContentListener::OnStartURIOpen(nsIURI *aURI, NS_IMETHODIMP EmbedContentListener::DoContent(const char *aContentType, - PRBool aIsContentPreferred, - nsIRequest *aRequest, - nsIStreamListener **aContentHandler, - PRBool *aAbortProcess) + PRBool aIsContentPreferred, + nsIRequest *aRequest, + nsIStreamListener **aContentHandler, + PRBool *aAbortProcess) { return NS_ERROR_NOT_IMPLEMENTED; } NS_IMETHODIMP EmbedContentListener::IsPreferred(const char *aContentType, - char **aDesiredContentType, - PRBool *aCanHandleContent) + char **aDesiredContentType, + PRBool *aCanHandleContent) { return CanHandleContent(aContentType, PR_TRUE, aDesiredContentType, - aCanHandleContent); + aCanHandleContent); } NS_IMETHODIMP EmbedContentListener::CanHandleContent(const char *aContentType, - PRBool aIsContentPreferred, - char **aDesiredContentType, - PRBool *_retval) + PRBool aIsContentPreferred, + char **aDesiredContentType, + PRBool *_retval) { *_retval = PR_FALSE; *aDesiredContentType = nsnull; - + if (aContentType) { nsCOMPtr webNavInfo( - do_GetService(NS_WEBNAVIGATION_INFO_CONTRACTID)); + do_GetService(NS_WEBNAVIGATION_INFO_CONTRACTID)); if (webNavInfo) { PRUint32 canHandle; nsresult rv = - webNavInfo->IsTypeSupported(nsDependentCString(aContentType), - mOwner ? mOwner->mNavigation.get() : nsnull, - &canHandle); + webNavInfo->IsTypeSupported(nsDependentCString(aContentType), + mOwner ? mOwner->mNavigation.get() : nsnull, + &canHandle); NS_ENSURE_SUCCESS(rv, rv); *_retval = (canHandle != nsIWebNavigationInfo::UNSUPPORTED); } diff --git a/mozilla/embedding/browser/gtk/src/EmbedContentListener.h b/mozilla/embedding/browser/gtk/src/EmbedContentListener.h index d7b42d03c9d..5ddb217780a 100644 --- a/mozilla/embedding/browser/gtk/src/EmbedContentListener.h +++ b/mozilla/embedding/browser/gtk/src/EmbedContentListener.h @@ -1,3 +1,5 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * diff --git a/mozilla/embedding/browser/gtk/src/EmbedContextMenuInfo.cpp b/mozilla/embedding/browser/gtk/src/EmbedContextMenuInfo.cpp new file mode 100644 index 00000000000..6aa9c654726 --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/EmbedContextMenuInfo.cpp @@ -0,0 +1,578 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 tw=80 et cindent: */ +/* + * ***** 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 mozilla.org code. + * + * The Initial Developer of the Original Code is + * Oleg Romashin. Portions created by Oleg Romashin are Copyright (C) Oleg Romashin. All Rights Reserved. + * Portions created by the Initial Developer are Copyright (C) 2006 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Oleg Romashin + * + * 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 ***** */ +#include "EmbedContextMenuInfo.h" +#include "nsIImageLoadingContent.h" +#include "imgILoader.h" +#include "nsIDOMDocument.h" +#include "nsIDOMHTMLDocument.h" +#include "nsIDOMHTMLElement.h" +#include "nsIDOMHTMLHtmlElement.h" +#include "nsIDOMHTMLAnchorElement.h" +#include "nsIDOMHTMLImageElement.h" +#include "nsIDOMHTMLAreaElement.h" +#include "nsIDOMHTMLLinkElement.h" +#include "nsIDOMDocumentView.h" +#include "nsIDOMAbstractView.h" +#include "nsIDOMViewCSS.h" +#include "nsIDOMCSSStyleDeclaration.h" +#include "nsIDOMCSSValue.h" +#include "nsIDOMCSSPrimitiveValue.h" +#include "nsNetUtil.h" +#include "nsUnicharUtils.h" +#include "nsIDOMMouseEvent.h" +#include "nsIDOMNSEvent.h" +#include "nsIDOMWindow.h" +#include "nsIDOMWindowCollection.h" +#include "nsIWebBrowser.h" +#include "nsIDOM3Document.h" +#include "nsIContent.h" +#include "nsIFormControl.h" +#include "nsIDOMNSHTMLInputElement.h" +#include "nsIDOMNSHTMLTextAreaElement.h" +#include "nsIDOMHTMLInputElement.h" +#include "nsIDOMHTMLTextAreaElement.h" +#include "nsIDOMNSHTMLDocument.h" +#include "nsIDOMNodeList.h" +#include "nsISelection.h" +#include "nsIDocument.h" +#include "EmbedPrivate.h" +#include +#include +#include +#include + +//***************************************************************************** +// class EmbedContextMenuInfo +//***************************************************************************** +EmbedContextMenuInfo::EmbedContextMenuInfo(EmbedPrivate *aOwner) : mCtxFrameNum(-1), mEmbedCtxType(0) +{ + mOwner = aOwner; + mEventNode = nsnull; + mCtxDocument = nsnull; + mNSHHTMLElement = nsnull; + mNSHHTMLElementSc = nsnull; + mFormRect = nsRect(0,0,0,0); +} + +EmbedContextMenuInfo::~EmbedContextMenuInfo(void) +{ +} + +NS_IMPL_ADDREF(EmbedContextMenuInfo) +NS_IMPL_RELEASE(EmbedContextMenuInfo) +NS_INTERFACE_MAP_BEGIN(EmbedContextMenuInfo) +NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +nsresult +EmbedContextMenuInfo::SetFrameIndex() +{ + nsCOMPtr frames; + mCtxDomWindow->GetFrames (getter_AddRefs (frames)); + nsCOMPtr currentWindow; + PRUint32 frameCount = 0; + frames->GetLength (&frameCount); + for (unsigned int i= 0; i < frameCount; i++) { + frames->Item(i, getter_AddRefs (currentWindow)); + nsCOMPtr currentDoc; + currentWindow->GetDocument (getter_AddRefs(currentDoc)); + if (currentDoc == mCtxDocument) { + mCtxFrameNum = i; + mCtxDomWindow = currentWindow; + return NS_OK; + } + } + return NS_ERROR_FAILURE; +} + +nsresult +EmbedContextMenuInfo::GetFormControlType(nsIDOMEvent* aEvent) +{ + if (!aEvent) + return NS_OK; + nsCOMPtr nsevent(do_QueryInterface(aEvent)); + nsCOMPtr target; + nsevent->GetOriginalTarget(getter_AddRefs(target)); + // mOrigTarget = target; + if (SetFormControlType(target)) { + nsCOMPtr eventNode = do_QueryInterface(target); + if (!eventNode) + return NS_OK; + eventNode->GetNodeName(mSEventNode); + //Frame Stuff + nsCOMPtr domDoc; + nsresult rv = eventNode->GetOwnerDocument(getter_AddRefs(domDoc)); + if (!NS_SUCCEEDED (rv) || !domDoc) { + return NS_OK; + } + mEventNode = eventNode; + mCtxDocument = domDoc; + nsCOMPtr doc = do_QueryInterface(mCtxDocument); + if (!doc) + return NS_OK; + nsIPresShell *presShell = doc->GetShellAt(0); + if (!presShell) + return NS_OK; + nsCOMPtr tgContent = do_QueryInterface(mEventTarget); +#ifdef MOZILLA_1_8_BRANCH + nsIFrame* frame = nsnull; + presShell->GetPrimaryFrameFor(tgContent, &frame); +#else + nsIFrame* frame = presShell->GetPrimaryFrameFor(tgContent); +#endif + if (frame) + mFormRect = frame->GetScreenRectExternal(); + return NS_OK; + } + return NS_ERROR_FAILURE; +} + +nsresult +EmbedContextMenuInfo::SetFormControlType(nsIDOMEventTarget *originalTarget) +{ + nsresult rv = NS_ERROR_FAILURE; + nsCOMPtr targetContent = do_QueryInterface(originalTarget); + mCtxFormType = 0; +#ifdef MOZILLA_1_8_BRANCH + if (targetContent && targetContent->IsContentOfType(nsIContent::eHTML_FORM_CONTROL)) { +#else + if (targetContent && targetContent->IsNodeOfType(nsIContent::eHTML_FORM_CONTROL)) { +#endif + nsCOMPtr formControl (do_QueryInterface(targetContent)); + if (formControl) { + mCtxFormType = formControl->GetType(); + rv = NS_OK; + //#ifdef MOZ_LOGGING + switch (mCtxFormType) { + case NS_FORM_BUTTON_BUTTON: + break; + case NS_FORM_BUTTON_RESET: + break; + case NS_FORM_BUTTON_SUBMIT: + break; + case NS_FORM_FIELDSET: + break; + case NS_FORM_INPUT_BUTTON: + break; + case NS_FORM_INPUT_CHECKBOX: + break; + case NS_FORM_INPUT_FILE: + mEmbedCtxType |= GTK_MOZ_EMBED_CTX_INPUT; + break; + case NS_FORM_INPUT_HIDDEN: + break; + case NS_FORM_INPUT_RESET: + break; + case NS_FORM_INPUT_IMAGE: + break; + case NS_FORM_INPUT_PASSWORD: + mEmbedCtxType |= GTK_MOZ_EMBED_CTX_INPUT; + mEmbedCtxType |= GTK_MOZ_EMBED_CTX_IPASSWORD; + break; + case NS_FORM_INPUT_RADIO: + break; + case NS_FORM_INPUT_SUBMIT: + break; + case NS_FORM_INPUT_TEXT: + mEmbedCtxType |= GTK_MOZ_EMBED_CTX_INPUT; + break; + case NS_FORM_LABEL: + break; + case NS_FORM_OPTION: + break; + case NS_FORM_OPTGROUP: + break; + case NS_FORM_LEGEND: + break; + case NS_FORM_SELECT: + break; + case NS_FORM_TEXTAREA: + mEmbedCtxType |= GTK_MOZ_EMBED_CTX_INPUT; + break; + case NS_FORM_OBJECT: + break; + default: + break; + } + if (mEmbedCtxType & GTK_MOZ_EMBED_CTX_INPUT) { + PRBool rdonly = PR_FALSE; + if (mCtxFormType == NS_FORM_TEXTAREA) { + nsCOMPtr input; + input = do_QueryInterface(mEventNode, &rv); + if (!NS_FAILED(rv) && input) + rv = input->GetReadOnly(&rdonly); + if (!NS_FAILED(rv) && rdonly) { + mEmbedCtxType |= GTK_MOZ_EMBED_CTX_ROINPUT; + } + } else { + nsCOMPtr input; + input = do_QueryInterface(mEventNode, &rv); + if (!NS_FAILED(rv) && input) + rv = input->GetReadOnly(&rdonly); + if (!NS_FAILED(rv) && rdonly) { + mEmbedCtxType |= GTK_MOZ_EMBED_CTX_ROINPUT; + } + } + } + //#endif + } + } + return rv; +} + +const char* +EmbedContextMenuInfo::GetSelectedText() +{ + nsString cString; + nsresult rv = NS_ERROR_FAILURE; + if (mCtxFormType != 0 && mEventNode) { + PRInt32 TextLength = 0, selStart = 0, selEnd = 0; + if (mCtxFormType == NS_FORM_INPUT_TEXT || mCtxFormType == NS_FORM_INPUT_FILE) { + nsCOMPtr nsinput = do_QueryInterface(mEventNode, &rv); + if (NS_SUCCEEDED(rv) && nsinput) + nsinput->GetTextLength(&TextLength); + if (TextLength > 0) { + nsinput->GetSelectionEnd(&selEnd); + nsinput->GetSelectionStart(&selStart); + if (selStart < selEnd || mCtxFormType == NS_FORM_INPUT_FILE) { + nsCOMPtr input = do_QueryInterface (mEventNode, &rv); + rv = input->GetValue(cString); + } + } + } else if (mCtxFormType == NS_FORM_TEXTAREA) { + nsCOMPtr nsinput = do_QueryInterface(mEventNode, &rv); + if (NS_SUCCEEDED(rv) && nsinput) + nsinput->GetTextLength(&TextLength); + if (TextLength > 0) { + nsinput->GetSelectionStart(&selStart); + nsinput->GetSelectionEnd(&selEnd); + if (selStart < selEnd) { + nsCOMPtr input = do_QueryInterface (mEventNode, &rv); + rv = input->GetValue(cString); + } + } + } + if (NS_SUCCEEDED(rv) && cString.Length()) { + if (selStart < selEnd) { + cString.Cut(0, selStart); + cString.Cut(selEnd-selStart, TextLength); + } + rv = NS_OK; + } + } else if (mCtxDocument) { + nsCOMPtr htmlDoc = do_QueryInterface(mCtxDocument); + htmlDoc->GetSelection(cString); + if ( cString.Length() > 0) { + rv = NS_OK; + } + } + if (rv == NS_OK) { + return NS_ConvertUTF16toUTF8(cString).get(); + } + return nsnull; +} + +nsresult +EmbedContextMenuInfo::CheckDomImageElement(nsIDOMNode *node, nsString& aHref, + PRInt32 *aWidth, PRInt32 *aHeight) +{ + nsresult rv = NS_ERROR_FAILURE; + nsCOMPtr image = + do_QueryInterface(node, &rv); + if (image) { + rv = image->GetSrc (aHref); + if (NS_FAILED(rv)) { + return rv; + } + rv = image->GetWidth (aWidth); + rv = image->GetHeight (aHeight); + rv = NS_OK; + } + return rv; +} + +nsresult +EmbedContextMenuInfo::CheckDomHtmlNode(nsIDOMNode *node) +{ + nsresult rv = NS_ERROR_FAILURE; + nsString uTag; + PRUint16 dnode_type; + rv = node->GetNodeType(&dnode_type); + if (NS_FAILED(rv)) { + return rv; + } + nsCOMPtr element = do_QueryInterface(node); + if (!((nsIDOMNode::ELEMENT_NODE == dnode_type) && element)) { + return rv; + } + nsCOMPtr nodeElement = do_QueryInterface(node, &rv); + if (NS_SUCCEEDED(rv) && nodeElement) { + mNSHHTMLElement = nodeElement; + } else { + mNSHHTMLElement = nsnull; + } + rv = element->GetLocalName(uTag); + if (NS_FAILED(rv)) { + return rv; + } + if (uTag.LowerCaseEqualsLiteral("object")) { + } + else if (uTag.LowerCaseEqualsLiteral("html")) { + } + else if (uTag.LowerCaseEqualsLiteral("a")) { + nsCOMPtr anchor = do_QueryInterface(node); + anchor->GetHref (mCtxHref); + mEmbedCtxType |= GTK_MOZ_EMBED_CTX_LINK; + if (anchor && !mCtxHref.IsEmpty()) { + if (mCtxHref.LowerCaseEqualsLiteral("text/smartbookmark")) { + nsCOMPtr childNode; + node->GetFirstChild (getter_AddRefs(childNode)); + if (childNode) { + PRInt32 width, height; + rv = CheckDomImageElement(node, mCtxImgHref, &width, &height); + if (NS_SUCCEEDED(rv)) + mEmbedCtxType |= GTK_MOZ_EMBED_CTX_IMAGE; + } + } else if (StringBeginsWith(mCtxHref, NS_LITERAL_STRING("mailto:"))) { + mEmbedCtxType |= GTK_MOZ_EMBED_CTX_EMAIL; + } + } + } + else if (uTag.LowerCaseEqualsLiteral("area")) { + nsCOMPtr area = do_QueryInterface(node, &rv); + if (NS_SUCCEEDED(rv) && area) { + PRBool aNoHref = PR_FALSE; + rv = area->GetNoHref (&aNoHref); + if (aNoHref == PR_FALSE) + rv = area->GetHref (mCtxHref); + else + rv = area->GetTarget (mCtxHref); + mEmbedCtxType |= GTK_MOZ_EMBED_CTX_LINK; + rv = NS_OK; + } + } + else if (uTag.LowerCaseEqualsLiteral("img")) { + PRInt32 width, height; + rv = CheckDomImageElement(node, mCtxImgHref, &width, &height); + if (NS_SUCCEEDED(rv)) + mEmbedCtxType |= GTK_MOZ_EMBED_CTX_IMAGE; + } else { + rv = NS_ERROR_FAILURE; + } + return rv; +} + +nsresult +EmbedContextMenuInfo::UpdateContextData(void *aEvent) +{ + NS_ENSURE_ARG_POINTER(aEvent); + return UpdateContextData((nsIDOMEvent *)aEvent); +} + +nsresult +EmbedContextMenuInfo::GetElementForScroll(nsIDOMEvent *aEvent) +{ + if (!aEvent) return NS_ERROR_UNEXPECTED; + nsCOMPtr nsevent (do_QueryInterface(aEvent)); + nsCOMPtr target; + nsevent->GetOriginalTarget(getter_AddRefs(target)); + if (!target) return NS_ERROR_UNEXPECTED; + nsCOMPtr targetDOMNode (do_QueryInterface (target)); + if (!targetDOMNode) return NS_ERROR_UNEXPECTED; + nsCOMPtr targetDOMDocument; + targetDOMNode->GetOwnerDocument (getter_AddRefs (targetDOMDocument)); + if (!targetDOMDocument) return NS_ERROR_UNEXPECTED; + return GetElementForScroll(targetDOMDocument); +} + +nsresult +EmbedContextMenuInfo::GetElementForScroll(nsIDOMDocument *targetDOMDocument) +{ + nsCOMPtr targetDOMElement; + targetDOMDocument->GetDocumentElement (getter_AddRefs (targetDOMElement)); + if (!targetDOMElement) return NS_ERROR_UNEXPECTED; + nsString bodyName (NS_LITERAL_STRING ("body")); + nsCOMPtr bodyList; + targetDOMElement->GetElementsByTagName(bodyName, getter_AddRefs (bodyList)); + PRUint32 i = 0; + bodyList->GetLength (&i); + if (i) { + nsCOMPtr domBodyNode; + bodyList->Item(0, getter_AddRefs(domBodyNode)); + if (!domBodyNode) return NS_ERROR_UNEXPECTED; + mNSHHTMLElementSc = do_QueryInterface(domBodyNode); + if (!mNSHHTMLElementSc) return NS_ERROR_UNEXPECTED; + } + return NS_OK; +} + +nsresult +EmbedContextMenuInfo::UpdateContextData(nsIDOMEvent *aDOMEvent) +{ + if (mCtxEvent == aDOMEvent) + return NS_OK; + mCtxEvent = aDOMEvent; + NS_ENSURE_ARG_POINTER(mCtxEvent); + nsresult res = nsnull; + nsresult rv = nsnull; + nsCOMPtr originalTarget = nsnull; + nsCOMPtr originalNode = nsnull; + nsCOMPtr aEvent = do_QueryInterface(mCtxEvent); + if (!aEvent) { + return NS_OK; + } + nsCOMPtr mouseEvent (do_QueryInterface( mCtxEvent )); + if(mouseEvent) { + ((nsIDOMMouseEvent*)mouseEvent)->GetClientX(&mX); + ((nsIDOMMouseEvent*)mouseEvent)->GetClientY(&mY); + } + res = aEvent->GetOriginalTarget(getter_AddRefs(originalTarget)); + originalNode = do_QueryInterface(originalTarget); + if (NS_FAILED(res) || !originalNode) { + return NS_ERROR_NULL_POINTER; + } + // nsresult SelText = mOwner->ClipBoardAction(GTK_MOZ_EMBED_CAN_COPY); + if (originalNode == mOrigNode) { + return NS_OK; + } + mEmbedCtxType = GTK_MOZ_EMBED_CTX_NONE; + mOrigNode = originalNode; + originalNode->GetNodeName(mSOrigNode); + if (mSOrigNode.EqualsLiteral ("#document")) + return NS_OK; + if (mSOrigNode.EqualsLiteral ("xul:thumb") + || mSOrigNode.EqualsLiteral ("xul:slider") + || mSOrigNode.EqualsLiteral ("xul:scrollbarbutton") + || mSOrigNode.EqualsLiteral ("xul:vbox") + || mSOrigNode.EqualsLiteral ("xul:spacer")) { + mEmbedCtxType |= GTK_MOZ_EMBED_CTX_XUL; + return NS_OK; + } + res = mCtxEvent->GetTarget(getter_AddRefs(mEventTarget)); + if (NS_FAILED(res) || !mEventTarget) { + return NS_OK; + } + nsCOMPtr eventNode = do_QueryInterface(mEventTarget); + if (eventNode == mEventNode) { +// return NS_OK; + } + mEventNode = eventNode; + eventNode->GetNodeName(mSEventNode); + //Frame Stuff + nsCOMPtr domDoc; + rv = mEventNode->GetOwnerDocument(getter_AddRefs(domDoc)); + if (!NS_SUCCEEDED (rv) || !domDoc) { + // return NS_OK; + } + if (NS_SUCCEEDED (rv) && domDoc && mCtxDocument != domDoc) { + mCtxDocument = domDoc; + mNSHHTMLElementSc = nsnull; +// rv = GetElementForScroll(mCtxDocument); +// if (NS_ERROR_UNEXPECTED == rv) { +// } + nsCOMPtr docuri = do_QueryInterface(mCtxDocument); + docuri->GetDocumentURI (mCtxURI); + NS_ENSURE_ARG_POINTER(mOwner); + nsCOMPtr webBrowser; + mOwner->mWindow->GetWebBrowser(getter_AddRefs(webBrowser)); + webBrowser->GetContentDOMWindow(getter_AddRefs(mCtxDomWindow)); + nsCOMPtr mainDocument; + mCtxDomWindow->GetDocument (getter_AddRefs(mainDocument)); + if (!mainDocument) { + return NS_OK; + } + mCtxFrameNum = -1; + if (mainDocument != domDoc) { + mEmbedCtxType |= GTK_MOZ_EMBED_CTX_IFRAME; + SetFrameIndex(); + } + } + nsCOMPtr targetDOMElement; + mCtxDocument->GetDocumentElement (getter_AddRefs (targetDOMElement)); + if (!targetDOMElement) return NS_ERROR_UNEXPECTED; + nsCOMPtr htmlDoc = do_QueryInterface(mCtxDocument); + if (htmlDoc) { + nsString DMode; + htmlDoc->GetDesignMode(DMode); + if (DMode.EqualsLiteral ("on")) { + mEmbedCtxType |= GTK_MOZ_EMBED_CTX_INPUT; + mEmbedCtxType |= GTK_MOZ_EMBED_CTX_RICHEDIT; + } + } + nsCOMPtr doc = do_QueryInterface(mCtxDocument); + if (!doc) + return NS_OK; + nsIPresShell *presShell = doc->GetShellAt(0); + if (!presShell) + return NS_OK; + nsCOMPtr tgContent = do_QueryInterface(mEventTarget); + nsIFrame* frame = nsnull; + if (mEmbedCtxType & GTK_MOZ_EMBED_CTX_RICHEDIT) + frame = presShell->GetRootFrame(); + else { +#ifdef MOZILLA_1_8_BRANCH + nsIFrame* frame = nsnull; + presShell->GetPrimaryFrameFor(tgContent, &frame); +#else + frame = presShell->GetPrimaryFrameFor(tgContent); +#endif + } + if (frame) { + mFormRect = frame->GetScreenRectExternal(); + printf("Prim frame FormRect1: y:%i, x:%i, h:%i, w:%i\n", mFormRect.y, mFormRect.x, mFormRect.height, mFormRect.width); + } + if (NS_SUCCEEDED(SetFormControlType(mEventTarget))) { + return NS_OK; + } + CheckDomHtmlNode(mEventNode); + nsCOMPtr node = mEventNode; + nsCOMPtr parentNode; + node->GetParentNode (getter_AddRefs(parentNode)); + node = parentNode; + while (node) { + if (NS_FAILED(CheckDomHtmlNode(node))) { + break; + } + node->GetParentNode (getter_AddRefs(parentNode)); + node = parentNode; + } + mEmbedCtxType |= GTK_MOZ_EMBED_CTX_DOCUMENT; + return NS_OK; +} diff --git a/mozilla/embedding/browser/gtk/src/EmbedContextMenuInfo.h b/mozilla/embedding/browser/gtk/src/EmbedContextMenuInfo.h new file mode 100644 index 00000000000..0f7e038936e --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/EmbedContextMenuInfo.h @@ -0,0 +1,99 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 tw=80 et cindent: */ +/* + * ***** 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 the Mozilla browser. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is + * Oleg Romashin. Portions created by Oleg Romashin are Copyright (C) Oleg Romashin. All Rights Reserved. + * Portions created by the Initial Developer are Copyright (C) 2006 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Oleg Romashin + * + * 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 ***** */ +#ifndef EmbedContextMenuInfo_h__ +#define EmbedContextMenuInfo_h__ +#include "nsCOMPtr.h" +#include "nsIDOMNode.h" +#include "nsIDOMEvent.h" +#include "imgIContainer.h" +#include "imgIRequest.h" +#include "nsIDOMEventTarget.h" +#include "nsIFrame.h" +// for strings +#ifdef MOZILLA_INTERNAL_API +#include +#include +#endif +#include "EmbedWindow.h" +#include "nsIDOMNSHTMLElement.h" +//***************************************************************************** +// class EmbedContextMenuInfo +// +//***************************************************************************** +class EmbedContextMenuInfo : public nsISupports +{ +public: + EmbedContextMenuInfo(EmbedPrivate *aOwner); + virtual ~EmbedContextMenuInfo(void); + NS_DECL_ISUPPORTS + nsresult GetFormControlType(nsIDOMEvent *aDOMEvent); + nsresult UpdateContextData(nsIDOMEvent *aDOMEvent); + nsresult UpdateContextData(void *aEvent); + const char* GetSelectedText(); + nsresult GetElementForScroll(nsIDOMDocument *targetDOMDocument); + nsresult GetElementForScroll(nsIDOMEvent *aEvent); + nsresult CheckDomImageElement(nsIDOMNode *node, nsString& aHref, + PRInt32 *aWidth, PRInt32 *aHeight); + + PRInt32 mX, mY, mObjWidth, mObjHeight, mCtxFrameNum; + nsString mCtxURI, mCtxHref, mCtxImgHref; + PRUint32 mEmbedCtxType; + PRInt32 mCtxFormType; + nsCOMPtr mEventNode; + nsCOMPtr mEventTarget; + nsCOMPtrmCtxDocument; + nsIntRect mFormRect; + nsCOMPtr mCtxDomWindow; + nsCOMPtr mCtxEvent; + nsCOMPtr mNSHHTMLElement; + nsCOMPtr mNSHHTMLElementSc; +private: + nsresult SetFrameIndex(); + nsresult SetFormControlType(nsIDOMEventTarget *originalTarget); + nsresult CheckDomHtmlNode(nsIDOMNode *node); + + EmbedPrivate *mOwner; + nsCOMPtr mOrigNode; + nsString mSOrigNode; + nsString mSEventNode; +}; // class EmbedContextMenuInfo +#endif // EmbedContextMenuInfo_h__ diff --git a/mozilla/embedding/browser/gtk/src/EmbedDownloadMgr.cpp b/mozilla/embedding/browser/gtk/src/EmbedDownloadMgr.cpp new file mode 100644 index 00000000000..26df62ce5af --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/EmbedDownloadMgr.cpp @@ -0,0 +1,298 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 tw=80 et cindent: */ +/* ***** 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 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. + * Portions created by the Initial Developer are Copyright (C) 2001 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Christopher Blizzard + * + * 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 ***** */ +/** + * Derived from GContentHandler http://landfill.mozilla.org/mxr-test/gnome/source/galeon/mozilla/ContentHandler.cpp + */ +#include "EmbedDownloadMgr.h" +#include "EmbedGtkTools.h" +#ifdef MOZILLA_INTERNAL_API +#include +#else +#include "nsComponentManagerUtils.h" +#endif +#include +#include +#include +#include "nsIURI.h" +#include "nsCRT.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +class EmbedDownloadMgr; +class ProgressListener : public nsIWebProgressListener2 +{ +public: + ProgressListener(EmbedDownload *aDownload, nsCAutoString aFilename, nsISupports *aContext) : mFilename (aFilename) + { + mDownload = aDownload; + mContext = aContext; + }; + ~ProgressListener() + { + }; + NS_DECL_ISUPPORTS + NS_DECL_NSIWEBPROGRESSLISTENER + NS_DECL_NSIWEBPROGRESSLISTENER2 + EmbedDownload *mDownload; + nsISupports *mContext; /** < The context object */ + nsCOMPtr mDestFile; + nsCAutoString mFilename; + nsCAutoString mLocalSaveFileName; +}; + +NS_IMPL_ISUPPORTS2(ProgressListener, nsIWebProgressListener2, nsIWebProgressListener) +NS_IMPL_ISUPPORTS1(EmbedDownloadMgr, nsIHelperAppLauncherDialog) + +EmbedDownloadMgr::EmbedDownloadMgr(void) +{ +} + +EmbedDownloadMgr::~EmbedDownloadMgr(void) +{ +} + +nsresult +EmbedDownloadMgr::Init() +{ + return NS_OK; +} + +NS_IMETHODIMP +EmbedDownloadMgr::Show(nsIHelperAppLauncher *aLauncher, nsISupports *aContext, PRUint32 aForced) +{ + nsresult rv; + mContext = aContext; + mLauncher = aLauncher; + rv = GetDownloadInfo(); + return NS_OK; +} + +NS_METHOD EmbedDownloadMgr::GetDownloadInfo (void) +{ + nsresult rv; + // create a Download object + GtkObject* instance = gtk_moz_embed_download_new (); + EmbedDownload *download = (EmbedDownload *) GTK_MOZ_EMBED_DOWNLOAD(instance)->data; + // get file mimetype + rv = mLauncher->GetMIMEInfo (getter_AddRefs(mMIMEInfo)); + if (NS_FAILED(rv)) return NS_ERROR_FAILURE; + nsCAutoString aMimeType; + rv = mMIMEInfo->GetMIMEType (aMimeType); + if (NS_FAILED(rv)) return NS_ERROR_FAILURE; + // get file name + nsCAutoString aTempFileName; + nsAutoString aSuggestedFileName; + rv = mLauncher->GetSuggestedFileName (aSuggestedFileName); + if (NS_FAILED(rv)) return NS_ERROR_FAILURE; + aTempFileName = NS_ConvertUTF16toUTF8 (aSuggestedFileName); + // get source url (concatened to file name) + rv = mLauncher->GetSource (getter_AddRefs(mUri)); + if (NS_FAILED(rv)) return NS_ERROR_FAILURE; + rv = mUri->Resolve(NS_LITERAL_CSTRING("."), mSpec); + if (NS_FAILED(rv)) return NS_ERROR_FAILURE; + rv = mLauncher->GetTargetFile(getter_AddRefs(mDestFileTemp)); + if (NS_FAILED(rv)) return NS_ERROR_FAILURE; + download->file_target = mDestFileTemp; + // creating a progress listener to follow the download and connecting it to the launcher which controls the download. + nsCOMPtr listener = new ProgressListener(download, aTempFileName, mContext); + rv = mLauncher->SetWebProgressListener(listener); + if (NS_FAILED(rv)) return NS_ERROR_FAILURE; + // setting download vars to keep control of each download. + download->parent = instance; + download->started = 0; + download->downloaded_size = -1; + download->launcher = mLauncher; + download->file_name = g_strdup ((gchar *) aTempFileName.get()); + download->server = g_strconcat(mSpec.get(), (gchar *) download->file_name, NULL); + download->file_type = g_strdup (aMimeType.get()); + return NS_OK; +} + +// it should be used... but it's not possible to do it according ui flow +NS_IMETHODIMP EmbedDownloadMgr::PromptForSaveToFile (nsIHelperAppLauncher *aLauncher, + nsISupports *aWindowContext, + const PRUnichar *aDefaultFile, + const PRUnichar *aSuggestedFileExtension, + nsILocalFile **_retval) +{ + return NS_OK; +} + +// nsIWebProgressListener Functions +// all these methods must be here due to nsIWebProgressListenr/2 inheritance +NS_IMETHODIMP ProgressListener::OnStatusChange (nsIWebProgress *aWebProgress, + nsIRequest *aRequest, nsresult aStatus, + const PRUnichar *aMessage) +{ + if (NS_SUCCEEDED (aStatus)) + return NS_OK; + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP ProgressListener::OnStateChange (nsIWebProgress *aWebProgress, + nsIRequest *aRequest, PRUint32 aStateFlags, + nsresult aStatus) +{ + if (NS_SUCCEEDED (aStatus)) + return NS_OK; + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP ProgressListener::OnProgressChange (nsIWebProgress *aWebProgress, + nsIRequest *aRequest, PRInt32 aCurSelfProgress, + PRInt32 aMaxSelfProgress, PRInt32 aCurTotalProgress, + PRInt32 aMaxTotalProgress) +{ + return OnProgressChange64 (aWebProgress, aRequest, aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress, aMaxTotalProgress); +} + +NS_IMETHODIMP ProgressListener::OnLocationChange (nsIWebProgress *aWebProgress, + nsIRequest *aRequest, nsIURI *location) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP ProgressListener::OnSecurityChange (nsIWebProgress *aWebProgress, + nsIRequest *aRequest, PRUint32 state) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +// nsIWebProgressListener 2 +NS_IMETHODIMP ProgressListener::OnProgressChange64 (nsIWebProgress *aWebProgress, + nsIRequest *aRequest, PRInt64 aCurSelfProgress, + PRInt64 aMaxSelfProgress, PRInt64 aCurTotalProgress, + PRInt64 aMaxTotalProgress) +{ + nsresult rv; + + if (!mDownload) return NS_OK; + if (mDownload->started == 0) { + mDownload->request = aRequest; + mDownload->started = 1; + // it might not work when there is more than one browser window opened + mDownload->file_size = aMaxSelfProgress; + nsCOMPtr parentDOMWindow = do_GetInterface (mContext); + mDownload->gtkMozEmbedParentWidget = GetGtkWidgetForDOMWindow(parentDOMWindow); + if (mDownload->gtkMozEmbedParentWidget) { + gtk_signal_emit(GTK_OBJECT(mDownload->gtkMozEmbedParentWidget), + moz_embed_signals[DOWNLOAD_REQUEST], + mDownload->server, + mDownload->file_name, + mDownload->file_type, + (gulong) mDownload->file_size, + 1); + } + } + if (mDownload->started == 1) { + // emit signal to get download progress and displays on download list dialog + gtk_signal_emit(GTK_OBJECT(mDownload->parent), + moz_embed_download_signals[DOWNLOAD_STARTED_SIGNAL], &mDownload->file_name_with_path); + // in this case, user has canceled download from UI. + if (!mDownload->file_name_with_path) { + gtk_moz_embed_download_do_command (GTK_MOZ_EMBED_DOWNLOAD (mDownload->parent), GTK_MOZ_EMBED_DOWNLOAD_CANCEL); + return NS_OK; + } + // FIXME: Clean up this code bellow, please :) + gchar *localUrl = nsnull, *localFileName = nsnull; + // second step - the target file will be created + if (g_str_has_prefix (mDownload->file_name_with_path, FILE_SCHEME)) { + // if user has chosen to save file (contains file:// prefix) + gchar *localUrlWithFileName = (g_strsplit (mDownload->file_name_with_path, FILE_SCHEME, -1))[1]; + gint i; + gchar **localUrlSplitted = (char **) (g_strsplit(localUrlWithFileName, SLASH, -1)); + for(i = 0; localUrlSplitted[i]; i++); + localFileName = localUrlSplitted[i-1]; + localUrl = (gchar *) (g_strsplit(localUrlWithFileName, localFileName, -1))[0]; + } else { + // if user has chosen to open with application (in /var/tmp) + localUrl = (char *) (g_strsplit (mDownload->file_name_with_path, mFilename.get(), -1))[0]; + localFileName = g_strdup ((gchar *) mFilename.get()); + } + nsCAutoString localSavePath; + if (localUrl) { + localSavePath.Assign(localUrl); + g_free (localUrl); + localUrl = nsnull; + } + if (localFileName) { + mLocalSaveFileName.Assign(localFileName); + g_free (localFileName); + localFileName = nsnull; + } + // create the file where the download will be moved to + mDestFile = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID); + mDestFile->InitWithNativePath(localSavePath); + mDestFile->Create(nsIFile::NORMAL_FILE_TYPE, 0777); + mDownload->started = 2; + } + // when download finishes (bytes downloaded = total file size), emit completed signal + // FIXME: if you don't have aMaxSelfProgress available, the signal won't be emitted + if (aCurSelfProgress == aMaxSelfProgress) { + // signal to confirm that download has finished + gtk_signal_emit(GTK_OBJECT(mDownload->parent), + moz_embed_download_signals[DOWNLOAD_COMPLETED_SIGNAL]); + } else { + // emit signal to get download progress and displays on download list dialog + gtk_signal_emit(GTK_OBJECT(mDownload->parent), + moz_embed_download_signals[DOWNLOAD_PROGRESS_SIGNAL], + (gulong) aCurSelfProgress, (gulong) aMaxSelfProgress, 1); + } + // storing current downloaded size. + mDownload->downloaded_size = (gulong) aCurSelfProgress; + // moving the target file to the right place. + rv = mDownload->file_target->MoveToNative (mDestFile, mLocalSaveFileName); + return NS_OK; +} diff --git a/mozilla/embedding/browser/gtk/src/EmbedDownloadMgr.h b/mozilla/embedding/browser/gtk/src/EmbedDownloadMgr.h new file mode 100644 index 00000000000..31e1f582ed2 --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/EmbedDownloadMgr.h @@ -0,0 +1,96 @@ +/* ***** 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 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. + * Portions created by the Initial Developer are Copyright (C) 2001 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Christopher Blizzard + * + * 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 ***** */ +/** + * Derived from GContentHandler http://landfill.mozilla.org/mxr-test/gnome/source/galeon/mozilla/ContentHandler.h + */ +#ifndef __EmbedDownloadMgr_h +#define __EmbedDownloadMgr_h +#include "EmbedPrivate.h" +#include +#include +#include +#include +#include +#include +#include "nsWeakReference.h" +#define EMBED_DOWNLOADMGR_DESCRIPTION "MicroB Download Manager" +#define EMBED_DOWNLOADMGR_CID {0x53df12a2, 0x1f4a, 0x4382, {0x99, 0x4e, 0xed, 0x62, 0xcf, 0x0d, 0x6b, 0x3a}} +#define FILE_SCHEME "file://" +#define SLASH "/" +class nsIURI; +class nsIFile; +class nsIFactory; +typedef struct _EmbedDownload EmbedDownload; +struct _EmbedDownload +{ + GtkObject * parent; + GtkWidget* gtkMozEmbedParentWidget;/** Associated gtkmozembed widget */ + char* file_name; /** < The file's name */ + const char *file_name_with_path; /** < The file's name */ + const char* server; /** < The server's name */ + PRInt64 file_size; /** < The file's size */ + const char* file_type; /** < The file's type */ + const char* handler_app; /** < The application's name */ + PRInt64 downloaded_size; /** < The download's size */ + gboolean isPaused; /** < If download is paused or not */ + gboolean open_with; /** < If the file can be opened by other application */ + gboolean started; /** < If the download has started or not */ + nsIHelperAppLauncher* launcher; /** < The mozilla's download dialog */ + nsIRequest* request; /** < The download request */ + nsIFile* file_dest; /** < The final file's name */ + nsIFile* file_target; /** < The target file's name */ +}; +class EmbedDownloadMgr : public nsIHelperAppLauncherDialog +{ + public: + EmbedDownloadMgr(); + virtual ~EmbedDownloadMgr(); + nsresult Init(void); + NS_DECL_ISUPPORTS + NS_DECL_NSIHELPERAPPLAUNCHERDIALOG + private: + /** Gets all informations about a file which is being downloaded. + */ + NS_METHOD GetDownloadInfo (void); + nsCOMPtr mLauncher; /** < Download dialog */ + nsCOMPtr mContext; /** < The context object */ + nsCOMPtr mUri; /** < The source URL */ + nsCOMPtr mDestFileTemp; /** < The temporary file (destiny) */ + nsCOMPtr mMIMEInfo; /** < MIME information */ + nsCAutoString mSpec; /** < The URL without file name */ +}; +#endif /* __EmbedDownloadMgr_h */ diff --git a/mozilla/embedding/browser/gtk/src/EmbedEventListener.cpp b/mozilla/embedding/browser/gtk/src/EmbedEventListener.cpp index 10d672c67f8..8e7d1810aaa 100644 --- a/mozilla/embedding/browser/gtk/src/EmbedEventListener.cpp +++ b/mozilla/embedding/browser/gtk/src/EmbedEventListener.cpp @@ -1,3 +1,5 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 tw=80 et cindent: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * @@ -20,6 +22,8 @@ * * Contributor(s): * Christopher Blizzard + * Oleg Romashin + * Tomaz Noleto * * 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 @@ -38,11 +42,20 @@ #include #include +#include #include "nsIDOMKeyEvent.h" #include "nsIDOMUIEvent.h" +#include "nsIDOMDocument.h" +#include "nsIDocument.h" #include "EmbedEventListener.h" #include "EmbedPrivate.h" +#include "gtkmozembed_internal.h" + +static PRInt32 sLongPressTimer = 0, mLongMPressDelay = 1000; +static PRInt32 sX = 0, sY = 0; +static PRBool sMPressed = PR_FALSE, sIsScrolling = PR_FALSE; +static char* gFavLocation = NULL; EmbedEventListener::EmbedEventListener(void) { @@ -61,18 +74,136 @@ NS_INTERFACE_MAP_BEGIN(EmbedEventListener) NS_INTERFACE_MAP_ENTRY(nsIDOMKeyListener) NS_INTERFACE_MAP_ENTRY(nsIDOMMouseListener) NS_INTERFACE_MAP_ENTRY(nsIDOMUIListener) + NS_INTERFACE_MAP_ENTRY(nsIDOMMouseMotionListener) + NS_INTERFACE_MAP_ENTRY(nsIDOMFocusListener) + NS_INTERFACE_MAP_ENTRY(nsIWebProgressListener) NS_INTERFACE_MAP_END nsresult EmbedEventListener::Init(EmbedPrivate *aOwner) { mOwner = aOwner; + mCtxInfo = new EmbedContextMenuInfo(aOwner); + return NS_OK; +} + +NS_IMETHODIMP +EmbedEventListener::HandleLink (nsIDOMNode* node) +{ + nsresult result; + + nsCOMPtr linkElement; + linkElement = do_QueryInterface (node); + if (!linkElement) return NS_ERROR_FAILURE; + + nsString name; + result = GetLinkAttribute(linkElement, "rel", &name); + if (NS_FAILED(result)) return NS_ERROR_FAILURE; + + nsString link; + result = GetLinkAttribute(linkElement, "href", &link); + if (NS_FAILED (result) || !link.Length()) return NS_ERROR_FAILURE; + + nsCOMPtr domDoc; + result = node->GetOwnerDocument(getter_AddRefs(domDoc)); + if (NS_FAILED(result) || !domDoc) return NS_ERROR_FAILURE; + + nsCOMPtr domnode = do_QueryInterface(domDoc); + if(!domnode) return NS_ERROR_FAILURE; + + nsString spec; + domnode->GetBaseURI(spec); + + nsCString cSpec; + NS_UTF16ToCString(spec, NS_CSTRING_ENCODING_UTF8, cSpec); + + nsCOMPtr baseURI; + result = NewURI(getter_AddRefs(baseURI), cSpec.get()); + if (NS_FAILED(result) || !baseURI) return NS_ERROR_FAILURE; + + nsCString linkstring; + NS_UTF16ToCString(link, NS_CSTRING_ENCODING_UTF8, linkstring); + nsCString url; + result = baseURI->Resolve (linkstring, url); + if (NS_FAILED (result)) return NS_ERROR_FAILURE; + + nsString type; + result = GetLinkAttribute(linkElement, "type", &type); + if (NS_FAILED(result)) return NS_ERROR_FAILURE; + + nsCString cType; + NS_UTF16ToCString(type, NS_CSTRING_ENCODING_UTF8, cType); + + nsString title; + result = GetLinkAttribute(linkElement, "title", &title); + if (NS_FAILED(result)) return NS_ERROR_FAILURE; + + nsCString cTitle; + NS_UTF16ToCString(title, NS_CSTRING_ENCODING_UTF8, cTitle); + + nsCString cName; + NS_UTF16ToCString(name, NS_CSTRING_ENCODING_UTF8, cName); + + if (!g_ascii_strcasecmp(cName.get(),"SHORTCUT ICON") || + !g_ascii_strcasecmp(cName.get(),"ICON")) { + + mOwner->mNeedFav = PR_FALSE; + this->GetFaviconFromURI(url.get()); + } + else { + + const gchar *navi_title = cTitle.get(); + if (*navi_title == '\0') + navi_title = NULL; + + const gchar *navi_type = cType.get(); + if (*navi_type == '\0') + navi_type = NULL; + + if (!g_ascii_strcasecmp(cName.get(), "ALTERNATE") && + !g_ascii_strcasecmp(cType.get(), "application/rss+xml")) { + } + else { + } + } return NS_OK; } NS_IMETHODIMP EmbedEventListener::HandleEvent(nsIDOMEvent* aDOMEvent) { + nsString eventType; + aDOMEvent->GetType(eventType); + if (eventType.EqualsLiteral ("focus")) + if (mCtxInfo->GetFormControlType(aDOMEvent)) { + if (mCtxInfo->mEmbedCtxType & GTK_MOZ_EMBED_CTX_INPUT) { + gint return_val = FALSE; + gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), + moz_embed_signals[DOM_FOCUS], + (void *)aDOMEvent, &return_val); + if (return_val) { + aDOMEvent->StopPropagation(); + aDOMEvent->PreventDefault(); + } + } + } + + if (eventType.EqualsLiteral ("DOMLinkAdded") && mOwner->mNeedFav) { + + nsresult result; + nsCOMPtr eventTarget; + + aDOMEvent->GetTarget(getter_AddRefs(eventTarget)); + nsCOMPtr node = do_QueryInterface(eventTarget, &result); + if (NS_FAILED(result) || !node) + return NS_ERROR_FAILURE; + HandleLink (node); + } + else if (mOwner->mNeedFav) { + mOwner->mNeedFav = PR_FALSE; + nsCString favicon_url = mOwner->mPrePath + nsCString("/favicon.ico"); + this->GetFaviconFromURI(favicon_url.get()); + } return NS_OK; } @@ -87,8 +218,8 @@ EmbedEventListener::KeyDown(nsIDOMEvent* aDOMEvent) // consumed... gint return_val = FALSE; gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[DOM_KEY_DOWN], - (void *)keyEvent, &return_val); + moz_embed_signals[DOM_KEY_DOWN], + (void *)keyEvent, &return_val); if (return_val) { aDOMEvent->StopPropagation(); aDOMEvent->PreventDefault(); @@ -107,11 +238,13 @@ EmbedEventListener::KeyUp(nsIDOMEvent* aDOMEvent) // consumed... gint return_val = FALSE; gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[DOM_KEY_UP], - (void *)keyEvent, &return_val); + moz_embed_signals[DOM_KEY_UP], + (void *)keyEvent, &return_val); if (return_val) { aDOMEvent->StopPropagation(); aDOMEvent->PreventDefault(); + } else { + //mCtxInfo->UpdateContextData(aDOMEvent); } return NS_OK; } @@ -126,8 +259,8 @@ EmbedEventListener::KeyPress(nsIDOMEvent* aDOMEvent) // Return TRUE from your signal handler to mark the event as consumed. gint return_val = FALSE; gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[DOM_KEY_PRESS], - (void *)keyEvent, &return_val); + moz_embed_signals[DOM_KEY_PRESS], + (void *)keyEvent, &return_val); if (return_val) { aDOMEvent->StopPropagation(); aDOMEvent->PreventDefault(); @@ -135,6 +268,23 @@ EmbedEventListener::KeyPress(nsIDOMEvent* aDOMEvent) return NS_OK; } +static gboolean +sLongMPress(void *aOwningWidget) +{ + // Return TRUE from your signal handler to mark the event as consumed. + if (!sMPressed || sIsScrolling) + return FALSE; + sMPressed = PR_FALSE; + gint return_val = FALSE; + gtk_signal_emit(GTK_OBJECT(aOwningWidget), + moz_embed_signals[DOM_MOUSE_LONG_PRESS], + (void *)0, &return_val); + if (return_val) { + sMPressed = PR_FALSE; + } + return FALSE; +} + NS_IMETHODIMP EmbedEventListener::MouseDown(nsIDOMEvent* aDOMEvent) { @@ -142,14 +292,29 @@ EmbedEventListener::MouseDown(nsIDOMEvent* aDOMEvent) mouseEvent = do_QueryInterface(aDOMEvent); if (!mouseEvent) return NS_OK; + + // handling event internally, first. + HandleSelection(mouseEvent); + // Return TRUE from your signal handler to mark the event as consumed. + sMPressed = PR_TRUE; gint return_val = FALSE; gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[DOM_MOUSE_DOWN], - (void *)mouseEvent, &return_val); + moz_embed_signals[DOM_MOUSE_DOWN], + (void *)mouseEvent, &return_val); if (return_val) { + sMPressed = PR_FALSE; +#if 1 + if (sLongPressTimer) + g_source_remove (sLongPressTimer); +#else aDOMEvent->StopPropagation(); aDOMEvent->PreventDefault(); +#endif + } else { + sLongPressTimer = g_timeout_add(mLongMPressDelay, sLongMPress, mOwner->mOwningWidget); + ((nsIDOMMouseEvent*)mouseEvent)->GetScreenX(&sX); + ((nsIDOMMouseEvent*)mouseEvent)->GetScreenY(&sY); } return NS_OK; } @@ -161,11 +326,20 @@ EmbedEventListener::MouseUp(nsIDOMEvent* aDOMEvent) mouseEvent = do_QueryInterface(aDOMEvent); if (!mouseEvent) return NS_OK; + + // handling event internally, first. + HandleSelection(mouseEvent); + // Return TRUE from your signal handler to mark the event as consumed. + if (sLongPressTimer) + g_source_remove (sLongPressTimer); + sMPressed = PR_FALSE; + mOwner->mOpenBlock = sIsScrolling; + sIsScrolling = sMPressed; gint return_val = FALSE; gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[DOM_MOUSE_UP], - (void *)mouseEvent, &return_val); + moz_embed_signals[DOM_MOUSE_UP], + (void *)mouseEvent, &return_val); if (return_val) { aDOMEvent->StopPropagation(); aDOMEvent->PreventDefault(); @@ -181,10 +355,11 @@ EmbedEventListener::MouseClick(nsIDOMEvent* aDOMEvent) if (!mouseEvent) return NS_OK; // Return TRUE from your signal handler to mark the event as consumed. + sMPressed = PR_FALSE; gint return_val = FALSE; gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[DOM_MOUSE_CLICK], - (void *)mouseEvent, &return_val); + moz_embed_signals[DOM_MOUSE_CLICK], + (void *)mouseEvent, &return_val); if (return_val) { aDOMEvent->StopPropagation(); aDOMEvent->PreventDefault(); @@ -200,14 +375,17 @@ EmbedEventListener::MouseDblClick(nsIDOMEvent* aDOMEvent) if (!mouseEvent) return NS_OK; // Return TRUE from your signal handler to mark the event as consumed. + if (sLongPressTimer) + g_source_remove (sLongPressTimer); + sMPressed = PR_FALSE; gint return_val = FALSE; gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[DOM_MOUSE_DBL_CLICK], - (void *)mouseEvent, &return_val); + moz_embed_signals[DOM_MOUSE_DBL_CLICK], + (void *)mouseEvent, &return_val); if (return_val) { aDOMEvent->StopPropagation(); aDOMEvent->PreventDefault(); - } + } return NS_OK; } @@ -221,11 +399,13 @@ EmbedEventListener::MouseOver(nsIDOMEvent* aDOMEvent) // Return TRUE from your signal handler to mark the event as consumed. gint return_val = FALSE; gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[DOM_MOUSE_OVER], - (void *)mouseEvent, &return_val); + moz_embed_signals[DOM_MOUSE_OVER], + (void *)mouseEvent, &return_val); if (return_val) { aDOMEvent->StopPropagation(); aDOMEvent->PreventDefault(); + } else { + //mCtxInfo->UpdateContextData(aDOMEvent); } return NS_OK; } @@ -240,8 +420,8 @@ EmbedEventListener::MouseOut(nsIDOMEvent* aDOMEvent) // Return TRUE from your signal handler to mark the event as consumed. gint return_val = FALSE; gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[DOM_MOUSE_OUT], - (void *)mouseEvent, &return_val); + moz_embed_signals[DOM_MOUSE_OUT], + (void *)mouseEvent, &return_val); if (return_val) { aDOMEvent->StopPropagation(); aDOMEvent->PreventDefault(); @@ -302,3 +482,410 @@ EmbedEventListener::FocusOut(nsIDOMEvent* aDOMEvent) } return NS_OK; } + +NS_IMETHODIMP +EmbedEventListener::MouseMove(nsIDOMEvent* aDOMEvent) +{ + if (mCurSelCon) + mCurSelCon->SetDisplaySelection (nsISelectionController::SELECTION_ON); + + if (sMPressed && + gtk_signal_handler_pending(GTK_OBJECT(mOwner->mOwningWidget), + moz_embed_signals[DOM_MOUSE_SCROLL], TRUE)) { + // Return TRUE from your signal handler to mark the event as consumed. + nsCOMPtr mouseEvent = do_QueryInterface(aDOMEvent); + if (!mouseEvent) + return NS_OK; + PRInt32 newX, newY, subX, subY; + ((nsIDOMMouseEvent*)mouseEvent)->GetScreenX(&newX); + ((nsIDOMMouseEvent*)mouseEvent)->GetScreenY(&newY); + subX = newX - sX; + subY = newY - sY; + nsresult rv = NS_OK; + if (ABS(subX) > 10 || ABS(subY) > 10 || (sIsScrolling && sMPressed)) { + if (!sIsScrolling) { + gint return_val = FALSE; + gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), + moz_embed_signals[DOM_MOUSE_SCROLL], + (void *)mouseEvent, &return_val); + if (!return_val) { + sIsScrolling = PR_TRUE; + if (mCtxInfo) + rv = mCtxInfo->GetElementForScroll(aDOMEvent); + } else { + sMPressed = PR_FALSE; + sIsScrolling = PR_FALSE; + } + } + if (sIsScrolling) + { + if (sLongPressTimer) + g_source_remove (sLongPressTimer); + if (mCtxInfo->mNSHHTMLElementSc) { + PRInt32 x, y; + mCtxInfo->mNSHHTMLElementSc->GetScrollTop(&y); + mCtxInfo->mNSHHTMLElementSc->GetScrollLeft(&x); +#ifdef MOZ_SCROLL_TOP_LEFT_HACK + rv = mCtxInfo->mNSHHTMLElementSc->ScrollTopLeft (y - subY, x - subX); +#endif + } else { + rv = NS_ERROR_UNEXPECTED; + } + if (rv == NS_ERROR_UNEXPECTED) { + nsCOMPtr DOMWindow; + nsIWebBrowser *webBrowser = nsnull; + gtk_moz_embed_get_nsIWebBrowser(mOwner->mOwningWidget, &webBrowser); + webBrowser->GetContentDOMWindow(getter_AddRefs(DOMWindow)); + DOMWindow->ScrollBy(-subX, -subY); + } + } + sX = newX; + sY = newY; + sIsScrolling = sMPressed; + } + } + return NS_OK; +} + +NS_IMETHODIMP +EmbedEventListener::DragMove(nsIDOMEvent* aMouseEvent) +{ + return NS_OK; +} + +NS_IMETHODIMP +EmbedEventListener::Focus(nsIDOMEvent* aEvent) +{ + return NS_OK; +} + +NS_IMETHODIMP +EmbedEventListener::Blur(nsIDOMEvent* aEvent) +{ + mFocusInternalFrame = PR_FALSE; + return NS_OK; + } + +NS_IMETHODIMP +EmbedEventListener::HandleSelection(nsIDOMMouseEvent* aDOMMouseEvent) +{ + nsresult rv; + + /* This function gets called everytime that a mousedown or a mouseup + * event occurs. + */ + nsCOMPtr nsevent(do_QueryInterface(aDOMMouseEvent)); + + nsCOMPtr target; + rv = nsevent->GetOriginalTarget(getter_AddRefs(target)); + if (NS_FAILED(rv)) + return rv; + + nsCOMPtr eventNode = do_QueryInterface(target); + nsCOMPtr domDoc; + rv = eventNode->GetOwnerDocument(getter_AddRefs(domDoc)); + if (NS_FAILED(rv)) + return rv; + + nsCOMPtr doc = do_QueryInterface(domDoc); + nsIPresShell *presShell = doc->GetShellAt(0); + + /* Gets nsISelectionController interface for the current context */ + mCurSelCon = do_QueryInterface(presShell); + if (!mCurSelCon) + return NS_ERROR_FAILURE; + + /* Gets event type */ + nsString eventType; + rv = aDOMMouseEvent->GetType(eventType); + if (NS_FAILED(rv)) + return rv; + + /* Updates context to check which context is being clicked on */ + mCtxInfo->UpdateContextData(aDOMMouseEvent); + + /* If a mousedown after 1 click is done (and if clicked context is not a XUL + * one (e.g. scrollbar), the selection is disabled for that context. + */ + if (!(mCtxInfo->mEmbedCtxType & GTK_MOZ_EMBED_CTX_XUL)) { + + if (eventType.EqualsLiteral("mousedown")) { + + /* Gets number of clicks done for event */ + rv = aDOMMouseEvent->GetDetail(&mClickCount); + if (NS_FAILED(rv)) + return rv; + + if (mClickCount == 1) + rv = mCurSelCon->SetDisplaySelection(nsISelectionController::SELECTION_OFF); + + } // mousedown + + /* If a mouseup occurs, the selection for context is enabled again (despite of + * number of clicks). If this event occurs after 1 click, the selection of + * both last and current context is cleaned up. + */ + if (eventType.EqualsLiteral("mouseup")) { + + /* Selection controller of current event context */ + if (mCurSelCon) { + rv = mCurSelCon->SetDisplaySelection(nsISelectionController::SELECTION_ON); + if (mClickCount == 1) { + nsCOMPtr domSel; + mCurSelCon->GetSelection(nsISelectionController::SELECTION_NORMAL, + getter_AddRefs(domSel)); + rv = domSel->RemoveAllRanges(); + } + } + /* Selection controller of previous event context */ + if (mLastSelCon) { + rv = mLastSelCon->SetDisplaySelection(nsISelectionController::SELECTION_ON); + if (mClickCount == 1) { + nsCOMPtr domSel; + mLastSelCon->GetSelection(nsISelectionController::SELECTION_NORMAL, + getter_AddRefs(domSel)); + rv = domSel->RemoveAllRanges(); + } + } + + /* If 1 click was done (despite the event type), sets the last context's + * selection controller with current one + */ + if (mClickCount == 1) + mLastSelCon = mCurSelCon; + } // mouseup + } + + return rv; +} + +nsresult +EmbedEventListener::GetLinkAttribute (nsCOMPtr& linkElement, + const char *name, + nsString *value) +{ + nsString n_name; + nsCString c_name(name); + NS_CStringToUTF16(c_name, NS_CSTRING_ENCODING_UTF8, n_name); + + return linkElement->GetAttribute(n_name, *value); +} + +nsresult +EmbedEventListener::NewURI (nsIURI **result, + const char *spec) +{ + nsresult rv; + nsCString cSpec(spec); + nsCOMPtr ioService; + rv = GetIOService (getter_AddRefs (ioService)); + if (NS_FAILED(rv)) + return rv; + + rv = ioService->NewURI (cSpec, nsnull, nsnull, result); + return rv; +} + +nsresult +EmbedEventListener::GetIOService(nsIIOService **ioService) +{ + nsresult rv; + + nsCOMPtr mgr; + NS_GetServiceManager (getter_AddRefs (mgr)); + if (!mgr) return NS_ERROR_FAILURE; + + rv = mgr->GetServiceByContractID ("@mozilla.org/network/io-service;1", + NS_GET_IID (nsIIOService), + (void **)ioService); + return rv; +} + + +void +EmbedEventListener::GeneratePixBuf() +{ + GdkPixbuf *pixbuf = NULL; + pixbuf = gdk_pixbuf_new_from_file(::gFavLocation, NULL); + if(!pixbuf) { + gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), + moz_embed_signals[ICON_CHANGED], + NULL ); + + // remove the wrong favicon + // FIXME: need better impl... + nsCOMPtr faviconFile = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID); + + if (!faviconFile) { + NS_Free(::gFavLocation); + return; + } + + nsCString faviconLocation(::gFavLocation); + faviconFile->InitWithNativePath(faviconLocation); + faviconFile->Remove(FALSE); + NS_Free(::gFavLocation); + return; + } + + // now send the signal to eal then eal send another signal to UI + gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), + moz_embed_signals[ICON_CHANGED], + pixbuf ); + //mOwner->mNeedFav = PR_FALSE; + NS_Free(::gFavLocation); +} + +void +EmbedEventListener::GetFaviconFromURI(const char* aURI) +{ + gchar *file_name = NS_strdup(aURI); + gchar *favicon_uri = NS_strdup(aURI); + + gint i = 0; + gint rv = 0; + + nsCOMPtr persist = do_CreateInstance(NS_WEBBROWSERPERSIST_CONTRACTID); + if (!persist) { + NS_Free(file_name); + NS_Free(favicon_uri); + return; + } + persist->SetProgressListener(this); + + while (file_name[i] != '\0') { + if (file_name[i] == '/' || file_name[i] == ':') + file_name[i] = '_'; + i++; + } + + nsCString fileName(file_name); + + nsCOMPtr favicon_dir = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID); + + if (!favicon_dir) { + NS_Free(favicon_uri); + NS_Free(file_name); + return; + } + + nsCString faviconDir("~/.mozilla/favicon"); + favicon_dir->InitWithNativePath(faviconDir); + + PRBool isExist; + rv = favicon_dir->Exists(&isExist); + if (NS_SUCCEEDED(rv) && !isExist) { + rv = favicon_dir->Create(nsIFile::DIRECTORY_TYPE,0775); + if (NS_FAILED(rv)) { + NS_Free(file_name); + NS_Free(favicon_uri); + return; + } + } + + nsCAutoString favicon_path("~/.mozilla/favicon"); + nsCOMPtr target_file = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID); + if (!target_file) { + NS_Free(file_name); + NS_Free(favicon_uri); + return; + } + target_file->InitWithNativePath(favicon_path); + target_file->Append(NS_ConvertUTF8toUTF16(fileName)); + + nsString path; + target_file->GetPath(path); + ::gFavLocation = NS_strdup(NS_ConvertUTF16toUTF8(path).get()); + nsCOMPtr ios (do_GetService(NS_IOSERVICE_CONTRACTID)); + if (!ios) { + NS_Free(file_name); + NS_Free(favicon_uri); + NS_Free(::gFavLocation); + return; + } + + nsCOMPtr uri; + + rv = ios->NewURI(nsDependentCString(favicon_uri), "", nsnull, getter_AddRefs(uri)); + if (!uri) { + NS_Free(file_name); + NS_Free(favicon_uri); + NS_Free(::gFavLocation); + return; + } + NS_Free(file_name); + NS_Free(favicon_uri); + + // save the favicon if the icon does not exist + rv = target_file->Exists(&isExist); + if (NS_SUCCEEDED(rv) && !isExist) { + rv = persist->SaveURI(uri, nsnull, nsnull, nsnull, "", target_file); + if (NS_FAILED(rv)) { + return; + } + } + else { + GeneratePixBuf(); + } + +} + +NS_IMETHODIMP +EmbedEventListener::OnStateChange(nsIWebProgress *aWebProgress, + nsIRequest *aRequest, + PRUint32 aStateFlags, + nsresult aStatus) +{ + /* if (!(aStateFlags & (STATE_STOP | STATE_IS_NETWORK | STATE_IS_DOCUMENT))){*/ + if(aStateFlags & STATE_STOP) + { + /* FINISH DOWNLOADING */ + if (NS_SUCCEEDED(aStatus)) { + GeneratePixBuf(); + return NS_OK; + } + } + else { + } + + return NS_OK; + +} + +NS_IMETHODIMP +EmbedEventListener::OnProgressChange(nsIWebProgress *aWebProgress, + nsIRequest *aRequest, + PRInt32 aCurSelfProgress, + PRInt32 aMaxSelfProgress, + PRInt32 aCurTotalProgress, + PRInt32 aMaxTotalProgress) +{ + return NS_OK; +} + +NS_IMETHODIMP +EmbedEventListener::OnLocationChange(nsIWebProgress *aWebProgress, + nsIRequest *aRequest, + nsIURI *aLocation) +{ + return NS_OK; +} + + +NS_IMETHODIMP +EmbedEventListener::OnStatusChange(nsIWebProgress *aWebProgress, + nsIRequest *aRequest, + nsresult aStatus, + const PRUnichar *aMessage) +{ + return NS_OK; +} + + +NS_IMETHODIMP +EmbedEventListener::OnSecurityChange(nsIWebProgress *aWebProgress, + nsIRequest *aRequest, + PRUint32 aState) +{ + return NS_OK; +} diff --git a/mozilla/embedding/browser/gtk/src/EmbedEventListener.h b/mozilla/embedding/browser/gtk/src/EmbedEventListener.h index ab17dc4e5e3..17773ef7751 100644 --- a/mozilla/embedding/browser/gtk/src/EmbedEventListener.h +++ b/mozilla/embedding/browser/gtk/src/EmbedEventListener.h @@ -1,3 +1,5 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * @@ -20,6 +22,7 @@ * * Contributor(s): * Christopher Blizzard + * Oleg Romashin * * 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 @@ -42,11 +45,42 @@ #include #include +#include +#include +#include +#include "EmbedContextMenuInfo.h" + +#include "nsIDOMNode.h" +#include "nsIDOMDocument.h" +#include "nsIDOMElement.h" +#include "nsIURI.h" +#include "nsIDOMEventTarget.h" +#include "nsIDOMEvent.h" +#include "nsIDOM3Node.h" + +#include "nsIURI.h" +#include "nsIIOService.h" +#include "nsNetCID.h" +#include "nsCOMPtr.h" +#include "nsIFileURL.h" +#include "nsILocalFile.h" +#include "nsIFile.h" +#include "nsIWebBrowserPersist.h" +#include "nsCWebBrowserPersist.h" +#include "nsIWebProgressListener.h" +#include "nsISelectionController.h" +#include "nsIDOMMouseEvent.h" +#include "nsXPCOMStrings.h" +#include "nsCRTGlue.h" + class EmbedPrivate; class EmbedEventListener : public nsIDOMKeyListener, public nsIDOMMouseListener, - public nsIDOMUIListener + public nsIDOMUIListener, + public nsIDOMMouseMotionListener, + public nsIWebProgressListener, + public nsIDOMFocusListener { public: @@ -57,10 +91,11 @@ class EmbedEventListener : public nsIDOMKeyListener, NS_DECL_ISUPPORTS +// NS_DECL_NSIDOMEVENTLISTENER // nsIDOMEventListener - + NS_DECL_NSIWEBPROGRESSLISTENER NS_IMETHOD HandleEvent(nsIDOMEvent* aEvent); - + NS_IMETHOD HandleLink (nsIDOMNode* node); // nsIDOMKeyListener NS_IMETHOD KeyDown(nsIDOMEvent* aDOMEvent); @@ -82,9 +117,37 @@ class EmbedEventListener : public nsIDOMKeyListener, NS_IMETHOD FocusIn(nsIDOMEvent* aDOMEvent); NS_IMETHOD FocusOut(nsIDOMEvent* aDOMEvent); + // nsIDOMMouseMotionListener + NS_IMETHOD MouseMove(nsIDOMEvent* aDOMEvent); + NS_IMETHOD DragMove(nsIDOMEvent* aMouseEvent); + EmbedContextMenuInfo* GetContextInfo() { return mCtxInfo; }; + + // nsIDOMFocusListener + NS_IMETHOD Focus(nsIDOMEvent* aEvent); + NS_IMETHOD Blur(nsIDOMEvent* aEvent); + NS_IMETHOD HandleSelection(nsIDOMMouseEvent* aDOMMouseEvent); + + // FIXME: dont not use nsCOMPtr<...> as param !! and how to ? + nsresult GetLinkAttribute (nsCOMPtr & linkElement, + const char *name, + nsString *value); + nsresult NewURI (nsIURI **result, + const char *spec); + nsresult GetIOService (nsIIOService **ioService); + + void GeneratePixBuf (); + + void GetFaviconFromURI (const char* aURI); private: EmbedPrivate *mOwner; + EmbedContextMenuInfo *mCtxInfo; + + // Selection and some clipboard stuff + nsCOMPtr mCurSelCon; + nsCOMPtr mLastSelCon; + PRBool mFocusInternalFrame; + PRInt32 mClickCount; }; #endif /* __EmbedEventListener_h */ diff --git a/mozilla/embedding/browser/gtk/src/EmbedFilePicker.cpp b/mozilla/embedding/browser/gtk/src/EmbedFilePicker.cpp new file mode 100644 index 00000000000..81c231e37c3 --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/EmbedFilePicker.cpp @@ -0,0 +1,215 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 tw=80 et cindent: */ +/* + * ***** 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 mozilla.org code. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the 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 ***** */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif +// local includes +#include "EmbedFilePicker.h" +#include "EmbedGtkTools.h" +#include "gtkmozembed.h" +#include +#include +#include +#include +#include +#include +#include +#include +#ifndef MOZILLA_INTERNAL_API +#include "nsComponentManagerUtils.h" +#include "nsServiceManagerUtils.h" +#endif +#ifdef MOZ_LOGGING +#include +#endif + +NS_IMPL_ISUPPORTS1(EmbedFilePicker, nsIFilePicker) +EmbedFilePicker::EmbedFilePicker() +: mParent (nsnull), + mMode(nsIFilePicker::modeOpen), + mFilename (nsnull) +{ +} + +EmbedFilePicker::~EmbedFilePicker() +{ + if (mFilename) + g_free (mFilename); +} + +/* void init (in nsIDOMWindowInternal parent, in wstring title, in short mode); */ +NS_IMETHODIMP EmbedFilePicker::Init(nsIDOMWindow *parent, const nsAString &title, PRInt16 mode) +{ + mParent = parent; + mMode = mode; + return NS_OK; +} + +/* void appendFilters (in long filterMask); */ +NS_IMETHODIMP EmbedFilePicker::AppendFilters(PRInt32 filterMask) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +/* void appendFilter (in wstring title, in wstring filter); */ +NS_IMETHODIMP EmbedFilePicker::AppendFilter(const nsAString &title, const nsAString &filter) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +/* attribute wstring defaultString; */ +NS_IMETHODIMP EmbedFilePicker::GetDefaultString(nsAString &aDefaultString) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP EmbedFilePicker::SetDefaultString(const nsAString &aDefaultString) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +/* attribute wstring defaultExtension; */ +NS_IMETHODIMP EmbedFilePicker::GetDefaultExtension(nsAString &aDefaultExtension) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP EmbedFilePicker::SetDefaultExtension(const nsAString &aDefaultExtension) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +/* attribute long filterIndex; */ +NS_IMETHODIMP EmbedFilePicker::GetFilterIndex(PRInt32 *aFilterIndex) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP EmbedFilePicker::SetFilterIndex(PRInt32 aFilterIndex) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +/* attribute nsILocalFile displayDirectory; */ +NS_IMETHODIMP EmbedFilePicker::GetDisplayDirectory(nsILocalFile **aDisplayDirectory) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP EmbedFilePicker::SetDisplayDirectory(nsILocalFile *aDisplayDirectory) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +/* readonly attribute nsILocalFile file; */ +NS_IMETHODIMP EmbedFilePicker::GetFile(nsILocalFile **aFile) +{ + if (!mFilename) return NS_OK; + /* NOTE: we have to take out any prefix (file:// or obex://) + * from file name to make it work in mozilla. + */ + gchar *strippedFileName = nsnull; + if (!strncmp (mFilename, GTK_MOZ_EMBED_COMMON_FILE_SCHEME, 7)) + strippedFileName = (g_strsplit(mFilename, GTK_MOZ_EMBED_COMMON_FILE_SCHEME, -1))[1]; + else if (!strncmp (mFilename, GTK_MOZ_EMBED_BLUETOOTH_FILE_SCHEME, 7)) + strippedFileName = (g_strsplit(mFilename, GTK_MOZ_EMBED_BLUETOOTH_FILE_SCHEME, -1))[1]; + else { + if (!mParent) return NS_OK; + GtkWidget* parentWidget = GetGtkWidgetForDOMWindow (mParent); + if (!parentWidget) return NS_OK; + g_signal_emit_by_name(GTK_OBJECT (parentWidget), "alert", "File protocol not supported." ,NULL); + // FIXME: clean/free parentWidget + return NS_OK; + } + if (strippedFileName) + { + nsCAutoString localSavePath (strippedFileName); + nsCOMPtr file = do_CreateInstance (NS_LOCAL_FILE_CONTRACTID); + if (!file) return NS_OK; + file->InitWithNativePath (localSavePath); + NS_ADDREF (*aFile = file); + g_free (strippedFileName); + strippedFileName = nsnull; + } + return NS_OK; +} + +/* readonly attribute nsIFileURL fileURL; */ +NS_IMETHODIMP EmbedFilePicker::GetFileURL(nsIFileURL **aFileURL) +{ + nsCOMPtr file; + GetFile (getter_AddRefs(file)); + if (!file) return NS_OK; + NS_ENSURE_TRUE (file, NS_ERROR_FAILURE); + nsCOMPtr fileURL = do_CreateInstance (NS_STANDARDURL_CONTRACTID); + if (!fileURL) return NS_OK; + fileURL->SetFile(file); + NS_ADDREF(*aFileURL = fileURL); + return NS_OK; +} + +/* readonly attribute nsISimpleEnumerator files; */ +NS_IMETHODIMP EmbedFilePicker::GetFiles(nsISimpleEnumerator * *aFiles) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +/* short show (); */ +NS_IMETHODIMP EmbedFilePicker::Show(PRInt16 *_retval) +{ + if (!mParent) + return NS_OK; + GtkWidget* parentWidget = GetGtkWidgetForDOMWindow (mParent); + if (!parentWidget) + return NS_OK; + if (mFilename) { + g_free (mFilename); + mFilename = nsnull; + } + int response; + g_signal_emit_by_name ( + GTK_OBJECT (parentWidget), + "upload_dialog", + "/home/user", // XXX please use genenv("HOME") instead of this. + "", + &mFilename, + &response, + NULL); + if (response == 1 && mFilename != NULL) + *_retval = nsIFilePicker::returnOK; + else + *_retval = nsIFilePicker::returnCancel; + return NS_OK; +} diff --git a/mozilla/embedding/browser/gtk/src/EmbedFilePicker.h b/mozilla/embedding/browser/gtk/src/EmbedFilePicker.h new file mode 100644 index 00000000000..9e7aaa330f9 --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/EmbedFilePicker.h @@ -0,0 +1,64 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 tw=80 et cindent: */ +/* + * ***** 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 mozilla.org code. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the 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 ***** */ + +#ifndef __EmbedFilePicker_h +#define __EmbedFilePicker_h + +#include +#include + +#define EMBED_FILEPICKER_CID \ +{ /* f097d33b-1c97-48a6-af4c-07022857eb7c */ \ + 0xf097d33b, \ + 0x1c97, \ + 0x48a6, \ + {0xaf, 0x4c, 0x07, 0x02, 0x28, 0x57, 0xeb, 0x7c} \ +} + +#define EMBED_FILEPICKER_CONTRACTID "@mozilla.org/filepicker;1" +#define EMBED_FILEPICKER_CLASSNAME "File Picker Implementation" + +class EmbedFilePicker : public nsIFilePicker +{ +public: + NS_DECL_ISUPPORTS + NS_DECL_NSIFILEPICKER + EmbedFilePicker (); + virtual ~EmbedFilePicker(); +private: + nsIDOMWindow *mParent; + PRInt16 mMode; + char *mFilename; +}; +#endif diff --git a/mozilla/embedding/browser/gtk/src/EmbedGlobalHistory.cpp b/mozilla/embedding/browser/gtk/src/EmbedGlobalHistory.cpp new file mode 100644 index 00000000000..f454c2b149b --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/EmbedGlobalHistory.cpp @@ -0,0 +1,920 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 tw=80 et cindent: */ +/* ***** 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 mozilla.org code. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Conrad Carlen + * (from original mozilla/embedding/lite/nsEmbedGlobalHistory.cpp) + * + * 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 ***** */ +/* XXX This file is probably out of sync with its original. + * This is a bad thing + */ +#include "EmbedGlobalHistory.h" +#include "nsIObserverService.h" +#include +#include +#include +#include +#include "gtkmozembed_common.h" +#ifndef MOZILLA_INTERNAL_API +#include "nsCRT.h" +#endif +// Constants +#define defaultSeparator 1 +// Number of changes in history before automatic flush +static const PRInt32 kNewEntriesBetweenFlush = 10; +// Default expiration interval: used if can't get preference service value +static const PRUint32 kDefaultExpirationIntervalDays = 7; +// Mozilla and EAL standard are different each other +static const PRInt64 kMSecsPerDay = LL_INIT(0, 60 * 60 * 24 * 1000); +static const PRInt64 kOneThousand = LL_INIT(0, 1000); +// The history list and the entries counter +static GList *mURLList; /** < The history list */ +static PRInt64 mExpirationInterval; /** < Expiration interval time */ +static EmbedGlobalHistory *sEmbedGlobalHistory = nsnull; + +//***************************************************************************** +// HistoryEntryOld: an entry object and its methods +//***************************************************************************** +typedef struct _HistoryEntry { + PRInt64 mLastVisitTime; // Millisecs + PRPackedBool mWritten; // TRUE if ever persisted + nsAutoString mTitle; // The entry title + char *url; // The url itself +} HistoryEntry; + +static void close_file_handle(void *file_handle) +{ + g_return_if_fail(file_handle); + gnome_vfs_close((GnomeVFSHandle*) file_handle); +} + +static bool file_handle_uri_exists(const void *uri) +{ + g_return_val_if_fail(uri, false); + return gnome_vfs_uri_exists((GnomeVFSURI*)uri); +} + +static void* file_handle_uri_new(const char *uri) +{ + g_return_val_if_fail(uri, nsnull); + return gnome_vfs_uri_new(uri); +} + +static bool file_handle_create_uri(void *file_handle, const void *uri) +{ + g_return_val_if_fail(file_handle, false); + return gnome_vfs_create_uri( + (GnomeVFSHandle**)file_handle, + (GnomeVFSURI*)uri, + GNOME_VFS_OPEN_WRITE, + 1, + 0600 + ) == GNOME_VFS_OK; +} + +static bool file_handle_open_uri(void *file_handle, const void *uri) +{ + g_return_val_if_fail(file_handle, false); + return gnome_vfs_open_uri( + (GnomeVFSHandle**)file_handle, + (GnomeVFSURI*)uri, + (GnomeVFSOpenMode)(GNOME_VFS_OPEN_WRITE + | GNOME_VFS_OPEN_RANDOM + | GNOME_VFS_OPEN_READ)); +} + +static bool file_handle_seek(void *file_handle, gboolean end) +{ + g_return_val_if_fail(file_handle, false); + + return gnome_vfs_seek((GnomeVFSHandle*)file_handle, + end ? GNOME_VFS_SEEK_END : GNOME_VFS_SEEK_START, 0); +} + +static bool file_handle_truncate(void *file_handle) +{ + g_return_val_if_fail(file_handle, false); + return gnome_vfs_truncate_handle ((GnomeVFSHandle*)file_handle, 0); +} + +static int file_handle_file_info_block_size(void *file_handle) +{ + g_return_val_if_fail(file_handle, 0); + GnomeVFSFileInfo info; + gnome_vfs_get_file_info_from_handle ((GnomeVFSHandle *)file_handle, + &info, + GNOME_VFS_FILE_INFO_DEFAULT); + return info.io_block_size; +} + +static int64 file_handle_read(void *file_handle, gpointer buffer, guint64 bytes) +{ + g_return_val_if_fail(file_handle, false); + GnomeVFSResult vfs_result = GNOME_VFS_OK; + GnomeVFSFileSize read_bytes; + vfs_result = gnome_vfs_read((GnomeVFSHandle *)file_handle, + (gpointer) buffer, (GnomeVFSFileSize)bytes-1, &read_bytes); + if (vfs_result!=GNOME_VFS_OK) + return -1; + + return (int64)read_bytes; +} + +static guint64 file_handle_write(void *file_handle, gpointer line) +{ + g_return_val_if_fail(file_handle, 0); + GnomeVFSFileSize written; + gnome_vfs_write ((GnomeVFSHandle *)file_handle, + (gpointer)line, + strlen((const char*)line), + &written); + return written; +} + +// Static Routine Prototypes +//GnomeVFSHandle +static nsresult writeEntry(void *file_handle, HistoryEntry *entry); +// when an entry is visited +nsresult OnVisited(HistoryEntry *entry) +{ + NS_ENSURE_ARG(entry); + entry->mLastVisitTime = PR_Now(); + LL_DIV(entry->mLastVisitTime, entry->mLastVisitTime, kOneThousand); + return NS_OK; +} + +// Return the last time an entry was visited +PRInt64 GetLastVisitTime(HistoryEntry *entry) +{ + NS_ENSURE_ARG(entry); + return entry->mLastVisitTime; +} + +// Change the last time an entry was visited +nsresult SetLastVisitTime(HistoryEntry *entry, const PRInt64& aTime) +{ + NS_ENSURE_ARG(entry); + NS_ENSURE_ARG_POINTER(aTime); + entry->mLastVisitTime = aTime; + return NS_OK; +} + +// Return TRUE if an entry has been written +PRBool GetIsWritten(HistoryEntry *entry) +{ + NS_ENSURE_ARG(entry); + return entry->mWritten; +} + +// Set TRUE when an entry is visited +nsresult SetIsWritten(HistoryEntry *entry) +{ + NS_ENSURE_ARG(entry); + entry->mWritten = PR_TRUE; + return NS_OK; +} + +// Change the entry title +#define SET_TITLE(entry, aTitle) entry->mTitle.Assign (aTitle); + +// Change the entry title +nsresult SetURL(HistoryEntry *entry, const char *url) +{ + NS_ENSURE_ARG(entry); + NS_ENSURE_ARG(url); + if (entry->url) + g_free(entry->url); + entry->url = g_strdup(url); + return NS_OK; +} + +// Return the entry title +#define GET_TITLE(entry) (entry->mTitle) + +// Return the entry url +char* GetURL(HistoryEntry *entry) +{ + return entry->url; +} + +// Traverse the history list trying to find a frame +int history_entry_find_exist (gconstpointer a, gconstpointer b) +{ + return g_ascii_strcasecmp(GetURL((HistoryEntry *) a), (char *) b); +} + +// Traverse the history list looking for the correct place to add a new item +int find_insertion_place (gconstpointer a, gconstpointer b) +{ + PRInt64 lastVisitTime = GetLastVisitTime((HistoryEntry *) a); + PRInt64 tempTime = GetLastVisitTime((HistoryEntry *) b); + return LL_CMP(lastVisitTime, <, tempTime); +} + +// Check whether an entry has expired +PRBool entryHasExpired(HistoryEntry *entry) +{ + // convert "now" from microsecs to millisecs + PRInt64 nowInMilliSecs = PR_Now(); + LL_DIV(nowInMilliSecs, nowInMilliSecs, kOneThousand); + // determine when the entry would have expired + PRInt64 expirationIntervalAgo; + LL_SUB(expirationIntervalAgo, nowInMilliSecs, mExpirationInterval); + PRInt64 lastVisitTime = GetLastVisitTime(entry); + return (LL_CMP(lastVisitTime, <, expirationIntervalAgo)); +} + +// Traverse the history list to get all the entries data and set the EAL history list +void history_entry_foreach_to_remove (gpointer data, gpointer user_data) +{ + HistoryEntry *entry = (HistoryEntry *) data; + if (entry) { + entry->url = NULL; + entry->mLastVisitTime = 0; + g_free(entry); + } +} + +//***************************************************************************** +// EmbedGlobalHistory - Creation/Destruction +//***************************************************************************** +NS_IMPL_ISUPPORTS3(EmbedGlobalHistory, nsIGlobalHistory2, nsIBrowserHistory, nsIObserver) +/* static */ +EmbedGlobalHistory* +EmbedGlobalHistory::GetInstance() +{ + if (!sEmbedGlobalHistory) + { + sEmbedGlobalHistory = new EmbedGlobalHistory(); + if (!sEmbedGlobalHistory) + return nsnull; + sEmbedGlobalHistory->handle = NULL; + NS_ADDREF(sEmbedGlobalHistory); // addref the global + if (NS_FAILED(sEmbedGlobalHistory->Init())) + { + NS_RELEASE(sEmbedGlobalHistory); + return nsnull; + } + } + NS_ADDREF(sEmbedGlobalHistory); // addref the return result + return sEmbedGlobalHistory; +} + +/* static */ +void +EmbedGlobalHistory::DeleteInstance() +{ + if (sEmbedGlobalHistory) + { + delete sEmbedGlobalHistory; + sEmbedGlobalHistory = nsnull; + } +} + +// The global history component constructor +EmbedGlobalHistory::EmbedGlobalHistory() +{ + if (!mURLList) { + mDataIsLoaded = PR_FALSE; + mEntriesAddedSinceFlush = 0; + LL_I2L(mExpirationInterval, kDefaultExpirationIntervalDays); + LL_MUL(mExpirationInterval, mExpirationInterval, kMSecsPerDay); + } +} + +// The global history component destructor +EmbedGlobalHistory::~EmbedGlobalHistory() +{ + LoadData(); + FlushData(); + if (mURLList) { + g_list_foreach(mURLList, (GFunc) history_entry_foreach_to_remove, NULL); + g_list_free(mURLList); + } + if (handle) { + close_file_handle(handle); + handle = NULL; + } + if (mHistoryFile) { + g_free(mHistoryFile); + mHistoryFile = nsnull; + } +} + +// Initialize the global history component +NS_IMETHODIMP EmbedGlobalHistory::Init() +{ + if (mURLList) return NS_OK; + // Get Pref and convert to millisecs + PRInt32 expireDays; + int success = gtk_moz_embed_common_get_pref(G_TYPE_INT, EMBED_HISTORY_PREF_EXPIRE_DAYS, &expireDays); + if (success) { + LL_I2L(mExpirationInterval, expireDays); + LL_MUL(mExpirationInterval, mExpirationInterval, kMSecsPerDay); + } + // register to observe profile changes + nsCOMPtr observerService = + do_GetService(NS_OBSERVERSERVICE_CONTRACTID); + NS_ASSERTION(observerService, "failed to get observer service"); + if (observerService) + observerService->AddObserver(this, "quit-application", PR_FALSE); + nsresult rv = InitFile(); + if (NS_FAILED(rv)) + return NS_ERROR_FAILURE; + rv = LoadData(); + NS_ENSURE_SUCCESS(rv, rv); + return rv; +} + +#define BROKEN_RV_HANDLING_CODE(rv) PR_BEGIN_MACRO \ + if (NS_FAILED(rv)) { \ + /* OOPS the coder (not timeless) didn't handle this case well at all. \ + * unfortunately the coder will remain anonymous. \ + * XXX please fix me. \ + */ \ + } \ + PR_END_MACRO + +#define BROKEN_STRING_GETTER(out) PR_BEGIN_MACRO \ + /* OOPS the coder (not timeless) decided not to do anything in this \ + * method, but to return NS_OK anyway. That's not very polite. \ + */ \ + out.Truncate(); \ + PR_END_MACRO + +#define BROKEN_STRING_BUILDER(var) PR_BEGIN_MACRO \ + /* This is just wrong */ \ + PR_END_MACRO + +//***************************************************************************** +// EmbedGlobalHistory::nsIGlobalHistory +//***************************************************************************** +// Add a new URI to the history +NS_IMETHODIMP EmbedGlobalHistory::AddURI(nsIURI *aURI, PRBool aRedirect, PRBool aToplevel, nsIURI *aReferrer) +{ + NS_ENSURE_ARG(aURI); + nsCAutoString URISpec; + aURI->GetSpec(URISpec); + const char *aURL = URISpec.get(); + if (!aToplevel) + return NS_OK; + PRBool isHTTP, isHTTPS; + nsresult rv = NS_OK; + rv |= aURI->SchemeIs("http", &isHTTP); + rv |= aURI->SchemeIs("https", &isHTTPS); + NS_ENSURE_SUCCESS (rv, NS_ERROR_FAILURE); + // Only get valid uri schemes + if (!isHTTP && !isHTTPS) + { + /* the following blacklist is silly. + * if there's some need to whitelist http(s) + ftp, + * that's what we should do. + */ + PRBool isAbout, isImap, isNews, isMailbox, isViewSource, isChrome, isData, isJavascript; + rv = aURI->SchemeIs("about", &isAbout); + rv |= aURI->SchemeIs("imap", &isImap); + rv |= aURI->SchemeIs("news", &isNews); + rv |= aURI->SchemeIs("mailbox", &isMailbox); + rv |= aURI->SchemeIs("view-source", &isViewSource); + rv |= aURI->SchemeIs("chrome", &isChrome); + rv |= aURI->SchemeIs("data", &isData); + rv |= aURI->SchemeIs("javascript", &isJavascript); + NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE); + if (isAbout || + isImap || + isNews || + isMailbox || + isViewSource || + isChrome || + isData || + isJavascript) { + return NS_OK; + } + } +#ifdef DEBUG + g_print("[HISTORY] Visited URL: %s\n", aURL); +#endif + rv = LoadData(); + NS_ENSURE_SUCCESS(rv, rv); + GList *node = g_list_find_custom(mURLList, aURL, (GCompareFunc) history_entry_find_exist); + HistoryEntry *entry = NULL; + if (node && node->data) + entry = (HistoryEntry *)(node->data); + nsCAutoString hostname; + aURI->GetHost(hostname); + + // It is not in the history + if (!entry) { + entry = g_new0(HistoryEntry, 1); + rv |= OnVisited(entry); + SET_TITLE(entry, hostname); + rv |= SetURL(entry, aURL); + BROKEN_RV_HANDLING_CODE(rv); + unsigned int listSize = g_list_length(mURLList); + if (listSize+1 > kDefaultMaxSize) { + GList *last = g_list_last (mURLList); + mURLList = g_list_remove (mURLList, last->data); + mEntriesAddedSinceFlush++; + } + mURLList = g_list_insert_sorted(mURLList, entry, + (GCompareFunc) find_insertion_place); + // Flush after kNewEntriesBetweenFlush changes + BROKEN_RV_HANDLING_CODE(rv); + if (++mEntriesAddedSinceFlush >= kNewEntriesBetweenFlush) + rv |= FlushData(kFlushModeAppend); + // emit signal to let EAL knows a new item was added + //FIXME REIMP g_signal_emit_by_name (g_mozilla_get_current_web(), + //"global-history-item-added", aURL); + } else { + // update the last visited time + rv |= OnVisited(entry); + SET_TITLE(entry, hostname); + // Move the element to the start of the list + BROKEN_RV_HANDLING_CODE(rv); + mURLList = g_list_remove (mURLList, entry); + mURLList = g_list_insert_sorted(mURLList, entry, (GCompareFunc) find_insertion_place); + // Flush after kNewEntriesBetweenFlush changes + BROKEN_RV_HANDLING_CODE(rv); + if (++mEntriesAddedSinceFlush >= kNewEntriesBetweenFlush) + rv |= FlushData(kFlushModeFullWrite); + } + return rv; +} + +// Return TRUE if the url is already in history +NS_IMETHODIMP EmbedGlobalHistory::IsVisited(nsIURI *aURI, PRBool *_retval) +{ + NS_ENSURE_ARG(aURI); + NS_ENSURE_ARG_POINTER(_retval); + nsCAutoString URISpec; + aURI->GetSpec(URISpec); + const char *aURL = URISpec.get(); + nsresult rv = LoadData(); + NS_ENSURE_SUCCESS(rv, rv); + GList *node = g_list_find_custom(mURLList, aURL, + (GCompareFunc) history_entry_find_exist); + *_retval = (node && node->data); + return rv; +} + +// It is called when Mozilla get real name of a URL +NS_IMETHODIMP EmbedGlobalHistory::SetPageTitle(nsIURI *aURI, + const nsAString & aTitle) +{ + NS_ENSURE_ARG(aURI); + nsresult rv; + // skip about: URIs to avoid reading in the db (about:blank, especially) + PRBool isAbout; + rv = aURI->SchemeIs("about", &isAbout); + NS_ENSURE_SUCCESS(rv, rv); + if (isAbout) + return NS_OK; + nsCAutoString URISpec; + aURI->GetSpec(URISpec); + const char *aURL = URISpec.get(); + rv |= LoadData(); + BROKEN_RV_HANDLING_CODE(rv); + NS_ENSURE_SUCCESS(rv, rv); + + GList *node = g_list_find_custom(mURLList, aURL, + (GCompareFunc) history_entry_find_exist); + HistoryEntry *entry = NULL; + if (node) + entry = (HistoryEntry *)(node->data); + if (entry) { + nsCString title; + CopyUTF16toUTF8(aTitle, title); + SET_TITLE(entry, title); + BROKEN_RV_HANDLING_CODE(rv); + if (++mEntriesAddedSinceFlush >= kNewEntriesBetweenFlush) + rv |= FlushData(kFlushModeAppend); + BROKEN_RV_HANDLING_CODE(rv); + } + return rv; +} + +//***************************************************************************** +// EmbedGlobalHistory::nsIBrowserHistory +//***************************************************************************** +// Add a page with url, title and last visit time +NS_IMETHODIMP EmbedGlobalHistory::AddPageWithDetails(nsIURI *aURI, + const PRUnichar *aTitle, + PRInt64 aLastVisited) +{ + return NS_OK; +} + +// Get the last page visited +NS_IMETHODIMP EmbedGlobalHistory::GetLastPageVisited(nsACString & aLastPageVisited) +{ + BROKEN_STRING_GETTER(aLastPageVisited); + return NS_OK; +} + +// Get the number of items in the history +NS_IMETHODIMP EmbedGlobalHistory::GetCount(PRUint32 *aCount) +{ + return NS_OK; +} + +// Remove a page from history +NS_IMETHODIMP EmbedGlobalHistory::RemovePage(nsIURI *aURI) +{ + nsCAutoString URISpec; + nsresult rv = aURI->GetSpec(URISpec); + if (NS_FAILED(rv)) { + return rv; + } + rv = LoadData(); + NS_ENSURE_SUCCESS(rv, rv); + const char *aURL = URISpec.get(); + GList *node = g_list_find_custom(mURLList, aURL, + (GCompareFunc) history_entry_find_exist); + if (node && node->data) { + mURLList = g_list_remove(mURLList, node->data); +#ifdef DEBUG + g_print("[HISTORY] Removed URL: %s\n", aURL); +#endif + if (++mEntriesAddedSinceFlush >= kNewEntriesBetweenFlush) + rv |= FlushData(kFlushModeFullWrite); + } + return rv; +} + +// Remove all the pages from a host +NS_IMETHODIMP EmbedGlobalHistory::RemovePagesFromHost(const nsACString & aHost, + PRBool aEntireDomain) +{ + return NS_OK; +} + +// Remove all pages from history +NS_IMETHODIMP EmbedGlobalHistory::RemoveAllPages() +{ + nsresult rv; + if (mURLList) { + g_list_foreach (mURLList, (GFunc) history_entry_foreach_to_remove, NULL); + g_list_free(mURLList); + mURLList = NULL; + } + mDataIsLoaded = PR_FALSE; + rv = FlushData(kFlushModeFullWrite); + mEntriesAddedSinceFlush = 0; + return rv; +} + +// Hide a page +NS_IMETHODIMP EmbedGlobalHistory::HidePage(nsIURI *aURI) +{ + return NS_OK; +} + +// +NS_IMETHODIMP EmbedGlobalHistory::MarkPageAsTyped(nsIURI *aURI) +{ + return NS_OK; +} + +//***************************************************************************** +// EmbedGlobalHistory::nsIObserver +//***************************************************************************** +NS_IMETHODIMP EmbedGlobalHistory::Observe(nsISupports *aSubject, + const char *aTopic, + const PRUnichar *aData) +{ + nsresult rv = NS_OK; + // used when the browser is closed and the EmbedGlobalHistory destructor is not called + if (strcmp(aTopic, "quit-application") == 0) { + rv = LoadData(); + // we have to sort the list before flush it + rv |= FlushData(); + if (mURLList) { + g_list_foreach(mURLList, (GFunc) history_entry_foreach_to_remove, NULL); + g_list_free(mURLList); + } + if (handle) + close_file_handle(handle); + } + return rv; +} + +//***************************************************************************** +// EmbedGlobalHistory +//***************************************************************************** +// Open/Create the history.dat file if it does not exist +nsresult EmbedGlobalHistory::InitFile() +{ + // Get the history file in our profile dir. + // Notice we are not just getting NS_APP_HISTORY_50_FILE + // because it is used by the "real" global history component. + if (EmbedPrivate::sProfileDir) { + nsString path; + EmbedPrivate::sProfileDir->GetPath(path); + mHistoryFile = g_strdup_printf("%s/history.dat", NS_ConvertUTF16toUTF8(path).get()); + BROKEN_STRING_BUILDER(mHistoryFile); + } else { + mHistoryFile = g_strdup_printf("%s/history.dat", g_get_tmp_dir()); + } + void *uri = file_handle_uri_new(mHistoryFile); + gboolean rs = FALSE; + if (!file_handle_uri_exists(uri)) { + if (file_handle_create_uri(&handle, uri)) { + g_print("Could not create a history file\n"); + return NS_ERROR_FAILURE; + } + close_file_handle(handle); + } + rs = file_handle_open_uri(&handle, uri); + if (rs) { + //g_print("Could not open history URI. Result: %s\n", gnome_vfs_result_to_string(rs)); + return NS_ERROR_FAILURE; + } + return NS_OK; +} + +// Get the data from history.dat file +nsresult EmbedGlobalHistory::LoadData() +{ + nsresult rv = NS_OK; + if (!mDataIsLoaded) { + mDataIsLoaded = PR_TRUE; + void *uri = file_handle_uri_new(mHistoryFile); + if (!file_handle_uri_exists(uri)) { + rv = InitFile(); + if (NS_FAILED(rv)) + return NS_ERROR_FAILURE; + } + file_handle_seek(handle, FALSE); + rv |= ReadEntries(handle); + } + return rv; +} + +// Call a function to write each entry in the history hash table +nsresult EmbedGlobalHistory::WriteEntryIfWritten(GList *list, void *file_handle) +{ + if (!file_handle) + return NS_ERROR_FAILURE; + + unsigned int counter = g_list_length(list); + while (counter > 0) { + HistoryEntry *entry = NS_STATIC_CAST(HistoryEntry*, g_list_nth_data(list, counter-1)); + counter--; + if (!entry || entryHasExpired(entry)) { + continue; + } + writeEntry(file_handle, entry); + } + return NS_OK; +} + +// Call a function to write each unwritten entry in the history hash table +nsresult EmbedGlobalHistory::WriteEntryIfUnwritten(GList *list, void *file_handle) +{ + if (!file_handle) + return NS_ERROR_FAILURE; + unsigned int counter = g_list_length(list); + while (counter > 0) { + HistoryEntry *entry = NS_STATIC_CAST(HistoryEntry*, g_list_nth_data(list, counter-1)); + if (!entry || entryHasExpired(entry)) { + counter--; + continue; + } + if (!GetIsWritten(entry)) + writeEntry(file_handle, entry); + counter--; + } + return NS_OK; +} + +// Write the history in history.dat file +nsresult EmbedGlobalHistory::FlushData(PRIntn mode) +{ + nsresult rv = NS_OK; + if (mEntriesAddedSinceFlush == 0) + return NS_OK; + if (!mHistoryFile) + { + rv |= InitFile(); + rv |= FlushData(kFlushModeFullWrite); + BROKEN_RV_HANDLING_CODE(rv); + return rv; + } + void *uri = file_handle_uri_new(mHistoryFile); + if (!file_handle_uri_exists(uri)) { + rv = InitFile(); + if (NS_FAILED(rv)) + return NS_ERROR_FAILURE; + } + else { + rv |= InitFile(); + rv |= FlushData(kFlushModeFullWrite); + + return rv; + } + mEntriesAddedSinceFlush = 0; + return NS_OK; +} + +// Split an entry in last visit time, title and url. +// Add a stored entry in the history.dat file in the history hash table +nsresult EmbedGlobalHistory::GetEntry(char *entry) +{ + char separator = (char) defaultSeparator; + int pos = 0; + nsInt64 outValue = 0; + while (PR_TRUE) { + PRInt32 digit; + if (entry[pos] == separator) { + pos++; + break; + } + if (entry[pos] == '\0' || !isdigit(entry[pos])) + return NS_ERROR_FAILURE; + digit = entry[pos] - '0'; + outValue *= nsInt64(10); + outValue += nsInt64(digit); + pos++; + } + char url[1024], title[1024]; + int urlLength= 0, titleLength= 0, numStrings=1; + // get the url and title + // FIXME + while(PR_TRUE) { + if (entry[pos] == separator) { + numStrings++; + pos++; + continue; + } + if (numStrings > 2) + break; + if (numStrings==1) { + url[urlLength++] = entry[pos]; + } else { + title[titleLength++] = entry[pos]; + } + pos++; + } + url[urlLength]='\0'; + title[titleLength]='\0'; + HistoryEntry *newEntry = g_new0(HistoryEntry, 1); + if (!newEntry) + return NS_ERROR_OUT_OF_MEMORY; + + nsresult rv = NS_OK; + SET_TITLE(newEntry, title); + rv |= SetLastVisitTime(newEntry, outValue); + rv |= SetIsWritten(newEntry); + rv |= SetURL(newEntry, url); + BROKEN_RV_HANDLING_CODE(rv); + // Check wheter the entry has expired + if (!entryHasExpired(newEntry)) { + mURLList = g_list_prepend(mURLList, newEntry); + } + return rv; +} + +// Get the history entries from history.dat file +nsresult EmbedGlobalHistory::ReadEntries(void *file_handle) +{ + if (!file_handle) + return NS_ERROR_FAILURE; + + nsresult rv = NS_OK; + guint64 bytes; + int64 read_bytes; + char separator = (char) defaultSeparator; + int pos = 0; + int numStrings = 0; + bytes = file_handle_file_info_block_size (file_handle); + /* Optimal buffer size for reading/writing the file. */ + char line[bytes]; + char buffer[bytes]; + do { + read_bytes = file_handle_read(file_handle, (gpointer) buffer, bytes-1); + if (read_bytes < 0) + break; + buffer[read_bytes] = '\0'; + unsigned int buf_pos = 0; + while (buf_pos< read_bytes) { + if (buffer[buf_pos]== separator) + numStrings++; + if (buffer[buf_pos]!= '\n') + line[pos] = buffer[buf_pos]; + else + buf_pos++; + if (numStrings==3) { + line[pos+1] = '\0'; + rv = GetEntry(line); + if (NS_FAILED(rv)) + return NS_ERROR_FAILURE; + pos = -1; + numStrings = 0; + } + pos++; + buf_pos++; + } + } while (read_bytes != -1); + return rv; +} + +//***************************************************************************** +// Static Functions +//***************************************************************************** +// Get last visit time from a string +static nsresult writePRInt64(char time[14], const PRInt64& inValue) +{ + nsInt64 value(inValue); + if (value == nsInt64(0)) { + strcpy(time, "0"); + return NS_OK; + } + nsCAutoString tempString; + while (value != nsInt64(0)) { + PRInt32 ones = PRInt32(value % nsInt64(10)); + value /= nsInt64(10); + tempString.Insert(char('0' + ones), 0); + } + strcpy(time,(char *) tempString.get()); + return NS_OK; +} + +// Write an entry in the history.dat file +nsresult writeEntry(void *file_handle, HistoryEntry *entry) +{ + nsresult rv = NS_OK; + char sep = (char) defaultSeparator; + char time[14]; + writePRInt64(time, GetLastVisitTime(entry)); + char *line = g_strdup_printf("%s%c%s%c%s%c\n", time, sep, GetURL(entry), sep, GET_TITLE(entry).get(), sep); + BROKEN_STRING_BUILDER(line); + guint64 size = file_handle_write (file_handle, (gpointer)line); + if (size != strlen(line)) + rv = NS_ERROR_FAILURE; + rv |= SetIsWritten(entry); + g_free(line); + return rv; +} + +nsresult EmbedGlobalHistory::GetContentList(GtkMozHistoryItem **GtkHI, int *count) +{ + if (!mURLList) return NS_ERROR_FAILURE; + + unsigned int num_items = 0; + *GtkHI = g_new0(GtkMozHistoryItem, g_list_length(mURLList)); + GtkMozHistoryItem * item = (GtkMozHistoryItem *)*GtkHI; + while (num_items < g_list_length(mURLList)) { + HistoryEntry *entry = NS_STATIC_CAST(HistoryEntry*, + g_list_nth_data(mURLList, num_items)); + // verify if the entry has expired and discard it + if (entryHasExpired(entry)) { + break; + } + glong accessed; + PRInt64 temp, outValue; + LL_MUL(outValue, GetLastVisitTime(entry), kOneThousand); + LL_DIV(temp, outValue, PR_USEC_PER_SEC); + LL_L2I(accessed, temp); + // Set the EAL history list + item[num_items].title = g_strdup(GET_TITLE(entry).get()); + BROKEN_STRING_BUILDER(item[num_items].title); + item[num_items].url = GetURL(entry); + item[num_items].accessed = accessed; + num_items++; + } + *count = num_items; + return NS_OK; +} + diff --git a/mozilla/embedding/browser/gtk/src/EmbedGlobalHistory.h b/mozilla/embedding/browser/gtk/src/EmbedGlobalHistory.h new file mode 100644 index 00000000000..5889d9f6880 --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/EmbedGlobalHistory.h @@ -0,0 +1,124 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* ***** 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 mozilla.org code. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Conrad Carlen + * Changes: andre.pedralho@indt.org.br (from original: mozilla/embedding/lite/nsEmbedGlobalHistory.h) + * + * 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 ***** */ +#ifndef __EMBEDGLOBALHISTORY_h +#define __EMBEDGLOBALHISTORY_h +#include +#include +#include +#include "EmbedPrivate.h" +#include +#include +#include +#include +//#include "gtkmozembed_common.h" +/* {2f977d51-5485-11d4-87e2-0010a4e75ef2} */ +#define NS_EMBEDGLOBALHISTORY_CID \ + { 0x2f977d51, 0x5485, 0x11d4, \ + { 0x87, 0xe2, 0x00, 0x10, 0xa4, 0xe7, 0x5e, 0xf2 } } +#define EMBED_HISTORY_PREF_EXPIRE_DAYS "browser.history_expire_days" +/** The Mozilla History Class + * This class is responsible for handling the history stuff. + */ +class EmbedGlobalHistory: public nsIBrowserHistory, + public nsIObserver +{ + public: + EmbedGlobalHistory(); + virtual ~EmbedGlobalHistory(); + static EmbedGlobalHistory* GetInstance(); + static void DeleteInstance(); + NS_IMETHOD Init(); + nsresult GetContentList(GtkMozHistoryItem**, int *count); + NS_DECL_ISUPPORTS + NS_DECL_NSIGLOBALHISTORY2 + NS_DECL_NSIBROWSERHISTORY + NS_DECL_NSIOBSERVER + protected: + enum { + kFlushModeAppend, /** < Add a new entry in the history file */ + kFlushModeFullWrite /** < Rewrite all history file */ + }; +/** Initiates the history file + * @return NS_OK on the success. + */ + nsresult InitFile(); +/** Loads the history file + * @return NS_OK on the success. + */ + nsresult LoadData(); +/** Writes entries in the history file + * @param list The internal history list. + * @param handle A Gnome VFS handle. + * @return NS_OK on the success. +*/ + nsresult WriteEntryIfWritten(GList *list, void *file_handle); +/** Writes entries in the history file + * @param list The internal history list. + * @param handle A Gnome VFS handle. + * @return NS_OK on the success. +*/ + nsresult WriteEntryIfUnwritten(GList *list, void *file_handle); +/** Writes entries in the history file + * @param mode How to write in the history file + * @return NS_OK on the success. + */ + nsresult FlushData(PRIntn mode = kFlushModeFullWrite); + /** Remove entries from the URL table + * @return NS_OK on the success. + */ + nsresult ResetData(); +/** Reads the history entries using GnomeVFS + * @param vfs_handle A Gnome VFS handle. + * @return NS_OK on the success. + */ + nsresult ReadEntries(void *file_handle); +/** Gets a history entry + * @param name The history entry name. + * @return NS_OK if the history entry name was gotten. + */ + nsresult GetEntry(gchar *); + protected: + void *handle; /** < The GnomeVFS handler */ + PRBool mDataIsLoaded; /** < If the data is loaded */ + PRInt32 mEntriesAddedSinceFlush; /** < Number of entries added since flush */ + gchar* mHistoryFile; /** < The history file path */ +}; +// Default maximum history entries +static const PRUint32 kDefaultMaxSize = 1000; +#endif diff --git a/mozilla/embedding/browser/gtk/src/EmbedGtkTools.cpp b/mozilla/embedding/browser/gtk/src/EmbedGtkTools.cpp new file mode 100644 index 00000000000..a65ffd2970d --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/EmbedGtkTools.cpp @@ -0,0 +1,105 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=4 sts=2 tw=80 et cindent: */ +/* ***** 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 mozilla.org code. + * + * The Initial Developer of the Original Code is + * Oleg Romashin. Portions created by Oleg Romashin are Copyright (C) Oleg Romashin. All Rights Reserved. + * Portions created by the Initial Developer are Copyright (C) 2006 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Oleg Romashin + * + * 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 ***** */ + +#include "EmbedGtkTools.h" +#ifndef MOZILLA_INTERNAL_API +#include "nsServiceManagerUtils.h" +#endif +#include "EmbedPrivate.h" + +GtkWidget * GetGtkWidgetForDOMWindow(nsIDOMWindow* aDOMWindow) +{ + nsCOMPtr wwatch = do_GetService("@mozilla.org/embedcomp/window-watcher;1"); + if (!aDOMWindow) + return NULL; + nsCOMPtr chrome; + wwatch->GetChromeForWindow(aDOMWindow, getter_AddRefs(chrome)); + if (!chrome) { + return GTK_WIDGET(EmbedCommon::GetAnyLiveWidget()); + } + + nsCOMPtr siteWindow = nsnull; + siteWindow = do_QueryInterface(chrome); + + if (!siteWindow) { + return GTK_WIDGET(EmbedCommon::GetAnyLiveWidget()); + } + + GtkWidget* parentWidget; + siteWindow->GetSiteWindow((void**)&parentWidget); + if (GTK_IS_WIDGET(parentWidget)) + return parentWidget; + return NULL; +} + +GtkWindow * GetGtkWindowForDOMWindow(nsIDOMWindow* aDOMWindow) +{ + GtkWidget* parentWidget = GetGtkWidgetForDOMWindow(aDOMWindow); + if (!parentWidget) + return NULL; + GtkWidget* gtkWin = gtk_widget_get_toplevel(parentWidget); + if (GTK_WIDGET_TOPLEVEL(gtkWin)) + return GTK_WINDOW(gtkWin); + return NULL; +} + +nsresult GetContentViewer (nsIWebBrowser *webBrowser, nsIContentViewer **aViewer) +{ + g_return_val_if_fail(webBrowser, NS_ERROR_FAILURE); + nsCOMPtr docShell(do_GetInterface((nsISupports*)webBrowser)); + NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE); + return docShell->GetContentViewer(aViewer); +} + +PRUnichar *LocaleToUnicode (const char *locStr) +{ + if (!locStr) + return (NULL); + + nsAutoString autoStr; +#ifdef MOZILLA_INTERNAL_API //FIXME? + + autoStr.AssignWithConversion (locStr); +#else + autoStr.AssignLiteral (locStr); +#endif + PRUnichar *uniStr = ToNewUnicode(autoStr); + + return (uniStr); +} diff --git a/mozilla/embedding/browser/gtk/src/EmbedGtkTools.h b/mozilla/embedding/browser/gtk/src/EmbedGtkTools.h new file mode 100644 index 00000000000..ec19c0d669b --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/EmbedGtkTools.h @@ -0,0 +1,69 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* ***** 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 mozilla.org code. + * + * The Initial Developer of the Original Code is + * Oleg Romashin. Portions created by Oleg Romashin are Copyright (C) Oleg Romashin. All Rights Reserved. + * Portions created by the Initial Developer are Copyright (C) 2006 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Oleg Romashin + * + * 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 ***** */ +#include +#ifdef MOZILLA_INTERNAL_API +#include "nsString.h" +#else +#include "nsStringAPI.h" +#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifndef __EmbedTools_h +#define __EmbedTools_h + +GtkWidget* +GetGtkWidgetForDOMWindow(nsIDOMWindow* aDOMWindow); + +GtkWindow* +GetGtkWindowForDOMWindow(nsIDOMWindow* aDOMWindow); + +nsresult +GetContentViewer (nsIWebBrowser *webBrowser, nsIContentViewer **aViewer); + +PRUnichar* +LocaleToUnicode (const char *locStr); + +#endif /* __EmbedTools_h */ diff --git a/mozilla/embedding/browser/gtk/src/EmbedPasswordMgr.cpp b/mozilla/embedding/browser/gtk/src/EmbedPasswordMgr.cpp new file mode 100644 index 00000000000..9f543fa009a --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/EmbedPasswordMgr.cpp @@ -0,0 +1,2134 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=4 sw=4 sts=4 tw=80 et cindent: */ +/* ***** 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 Mozilla Password Manager. + * + * The Initial Developer of the Original Code is + * Brian Ryner. + * Portions created by the Initial Developer are Copyright (C) 2003 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Brian Ryner + * Modified by: + * romaxa@gmail.com (from original: mozilla/toolkit/components/passwordmgr/base/nsPasswordManager.cpp) + * Antonio Gomes + * + * 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 ***** */ +#include "EmbedPasswordMgr.h" +#include "nsIFile.h" +#include "nsNetUtil.h" +#include "nsILineInputStream.h" +#include "plbase64.h" +#include "nsISecretDecoderRing.h" +#include "nsIPrompt.h" +#include "nsIPrefService.h" +#include "nsIPrefBranch.h" +#include "nsIPrefBranch2.h" +#include "prmem.h" +#include "nsIStringBundle.h" +#ifdef MOZILLA_1_8_BRANCH +#include "nsIArray.h" +#include "nsObserverService.h" +#else +#include "nsIMutableArray.h" +#endif +#include "nsICategoryManager.h" +#include "nsIObserverService.h" +#include "nsIWebProgress.h" +#include "nsIDOMDocument.h" +#include "nsIDOMWindow.h" +#include "nsIDOMHTMLDocument.h" +#include "nsIDocument.h" +#include "nsIDOMHTMLCollection.h" +#include "nsIDOMHTMLInputElement.h" +#include "nsIContent.h" +#include "nsIFormControl.h" +#include "nsIDOMWindowInternal.h" +#include "nsCURILoader.h" +#include "nsAppDirectoryServiceDefs.h" +#include "nsIDOMEventTarget.h" +#include "nsIDOMHTMLFormElement.h" +#include "nsIPK11TokenDB.h" +#include "nsIPK11Token.h" +#include "nsUnicharUtils.h" +#include "nsCOMArray.h" +#include "nsIServiceManager.h" +#include "nsIIDNService.h" +#include "EmbedPrivate.h" +#include "gtkmozembedprivate.h" +#ifdef MOZILLA_INTERNAL_API +#include "nsString.h" +#include +#include "nsIForm.h" +#else +#include "nsDirectoryServiceUtils.h" +//FIXME +typedef char* nsXPIDLCString; +typedef PRUnichar* nsXPIDLString; +#define getter_Copies(str) &str +#include "nsComponentManagerUtils.h" +#include "nsIForm.h" +#include "nsStringAPI.h" +#endif +#include "nsIPassword.h" +#include "nsIPasswordInternal.h" +#include + + +static const char kPMPropertiesURL[] = "chrome://passwordmgr/locale/passwordmgr.properties"; +static PRBool sRememberPasswords = PR_FALSE; +static PRBool sForceAutocompletion = PR_FALSE; +static PRBool sPrefsInitialized = PR_FALSE; +static nsIStringBundle* sPMBundle; +static nsISecretDecoderRing* sDecoderRing; +static EmbedPasswordMgr* sPasswordManager; +class EmbedPasswordMgr::SignonDataEntry +{ +public: + nsString userField; + nsString userValue; + nsString passField; + nsString passValue; + SignonDataEntry* next; + SignonDataEntry() : next(nsnull) + { } + ~SignonDataEntry() + { + delete next; + } +}; + +class EmbedPasswordMgr::SignonHashEntry +{ + // Wraps a pointer to the linked list of SignonDataEntry objects. + // This allows us to adjust the head of the linked list without a + // hashtable operation. +public: + SignonDataEntry* head; + SignonHashEntry(SignonDataEntry* aEntry) : head(aEntry) + { } + ~SignonHashEntry() + { + delete head; + } +}; + +class EmbedPasswordMgr::PasswordEntry : public nsIPasswordInternal +{ +public: + PasswordEntry(const nsACString& aKey, SignonDataEntry* aData); + virtual ~PasswordEntry() + { } + NS_DECL_ISUPPORTS + NS_DECL_NSIPASSWORD + NS_DECL_NSIPASSWORDINTERNAL +protected: + nsCString mHost; + nsString mUser; + nsString mUserField; + nsString mPassword; + nsString mPasswordField; + PRBool mDecrypted[2]; +}; + +NS_IMPL_ISUPPORTS2(EmbedPasswordMgr::PasswordEntry, nsIPassword, + nsIPasswordInternal) +EmbedPasswordMgr::PasswordEntry::PasswordEntry(const nsACString& aKey, + SignonDataEntry* aData) + : mHost(aKey) +{ + mDecrypted[0] = mDecrypted[1] = PR_FALSE; + if (aData) + { + mUser.Assign(aData->userValue); + mUserField.Assign(aData->userField); + mPassword.Assign(aData->passValue); + mPasswordField.Assign(aData->passField); + } +} + +NS_IMETHODIMP +EmbedPasswordMgr::PasswordEntry::GetHost(nsACString& aHost) +{ + aHost.Assign(mHost); + return NS_OK; +} + +NS_IMETHODIMP +EmbedPasswordMgr::PasswordEntry::GetUser(nsAString& aUser) +{ + if (!mUser.IsEmpty() && !mDecrypted[0]) + { + if (NS_SUCCEEDED(DecryptData(mUser, mUser))) + mDecrypted[0] = PR_TRUE; + else + return NS_ERROR_FAILURE; + } + aUser.Assign(mUser); + return NS_OK; +} + +NS_IMETHODIMP +EmbedPasswordMgr::PasswordEntry::GetPassword(nsAString& aPassword) +{ + if (!mPassword.IsEmpty() && !mDecrypted[1]) + { + if (NS_SUCCEEDED(DecryptData(mPassword, mPassword))) + mDecrypted[1] = PR_TRUE; + else + return NS_ERROR_FAILURE; + } + aPassword.Assign(mPassword); + return NS_OK; +} + +NS_IMETHODIMP +EmbedPasswordMgr::PasswordEntry::GetUserFieldName(nsAString& aField) +{ + aField.Assign(mUserField); + return NS_OK; +} + +NS_IMETHODIMP +EmbedPasswordMgr::PasswordEntry::GetPasswordFieldName(nsAString& aField) +{ + aField.Assign(mPasswordField); + return NS_OK; +} + +NS_IMPL_ADDREF(EmbedPasswordMgr) +NS_IMPL_RELEASE(EmbedPasswordMgr) +NS_INTERFACE_MAP_BEGIN(EmbedPasswordMgr) +NS_INTERFACE_MAP_ENTRY(nsIPasswordManager) +NS_INTERFACE_MAP_ENTRY(nsIPasswordManagerInternal) +NS_INTERFACE_MAP_ENTRY(nsIObserver) +NS_INTERFACE_MAP_ENTRY(nsIFormSubmitObserver) +NS_INTERFACE_MAP_ENTRY(nsIWebProgressListener) +NS_INTERFACE_MAP_ENTRY(nsIDOMFocusListener) +NS_INTERFACE_MAP_ENTRY(nsIDOMLoadListener) +NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsIDOMEventListener, nsIDOMFocusListener) +NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference) +NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIPasswordManager) +NS_INTERFACE_MAP_END + +EmbedPasswordMgr::EmbedPasswordMgr() + : mAutoCompletingField(nsnull), mCommonObject(nsnull) +{ +} + +EmbedPasswordMgr::~EmbedPasswordMgr() +{ +} + +/* static */ +EmbedPasswordMgr* +EmbedPasswordMgr::GetInstance() +{ + if (!sPasswordManager) + { + sPasswordManager = new EmbedPasswordMgr(); + if (!sPasswordManager) + return nsnull; + NS_ADDREF(sPasswordManager); // addref the global + if (NS_FAILED(sPasswordManager->Init())) + { + NS_RELEASE(sPasswordManager); + return nsnull; + } + } + NS_ADDREF(sPasswordManager); // addref the return result + return sPasswordManager; +} + +nsresult +EmbedPasswordMgr::Init() +{ + mSignonTable.Init(); + mRejectTable.Init(); + mAutoCompleteInputs.Init(); + sPrefsInitialized = PR_TRUE; + nsCOMPtr prefService = do_GetService(NS_PREFSERVICE_CONTRACTID); + NS_ASSERTION(prefService, "No pref service"); + prefService->GetBranch("signon.", getter_AddRefs(mPrefBranch)); + NS_ASSERTION(mPrefBranch, "No pref branch"); + mPrefBranch->GetBoolPref("rememberSignons", &sRememberPasswords); + mPrefBranch->GetBoolPref("forceAutocompletion", &sForceAutocompletion); + nsCOMPtr branchInternal = do_QueryInterface(mPrefBranch); + // Have the pref service hold a weak reference; the service manager + // will be holding a strong reference. + branchInternal->AddObserver("rememberSignons", this, PR_TRUE); + branchInternal->AddObserver("forceAutocompletion", this, PR_TRUE); + // Be a form submit and web progress observer so that we can save and + // prefill passwords. + nsCOMPtr obsService = do_GetService(NS_OBSERVERSERVICE_CONTRACTID); + NS_ASSERTION(obsService, "No observer service"); + obsService->AddObserver(this, NS_FORMSUBMIT_SUBJECT, PR_TRUE); + nsCOMPtr progress = do_GetService(NS_DOCUMENTLOADER_SERVICE_CONTRACTID); + NS_ASSERTION(progress, "No web progress service"); + progress->AddProgressListener(this, nsIWebProgress::NOTIFY_STATE_DOCUMENT); + // Now read in the signon file + nsXPIDLCString signonFile; + mPrefBranch->GetCharPref("SignonFileName", getter_Copies(signonFile)); +#ifdef MOZILLA_INTERNAL_API + NS_ASSERTION(!signonFile.IsEmpty(), "Fallback for signon filename not present"); +#endif + NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(mSignonFile)); + NS_ENSURE_TRUE(mSignonFile, NS_ERROR_FAILURE); +#ifdef MOZILLA_INTERNAL_API + mSignonFile->AppendNative(signonFile); +#else + nsCString cSignonFile(signonFile); + mSignonFile->AppendNative(cSignonFile); +#endif + nsCAutoString path; + mSignonFile->GetNativePath(path); + ReadPasswords(mSignonFile); + return NS_OK; +} + +/* static */ PRBool +EmbedPasswordMgr::SingleSignonEnabled() +{ + if (!sPrefsInitialized) + { + // Create the PasswordManager service to initialize the prefs and callback + nsCOMPtr manager = do_GetService(NS_PASSWORDMANAGER_CONTRACTID); + } + return sRememberPasswords; +} + +/* static */ NS_METHOD +EmbedPasswordMgr::Register( + nsIComponentManager* aCompMgr, + nsIFile* aPath, + const char* aRegistryLocation, + const char* aComponentType, + const nsModuleComponentInfo* aInfo) +{ + // By registering in NS_PASSWORDMANAGER_CATEGORY, an instance of the password + // manager will be created when a password input is added to a form. We + // can then register that singleton instance as a form submission observer. + nsresult rv; + nsCOMPtr catman = do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv, rv); + nsXPIDLCString prevEntry; + catman->AddCategoryEntry(NS_PASSWORDMANAGER_CATEGORY, + "MicroB Password Manager", + NS_PASSWORDMANAGER_CONTRACTID, + PR_TRUE, + PR_TRUE, + getter_Copies(prevEntry)); + return NS_OK; +} + +/* static */ NS_METHOD +EmbedPasswordMgr::Unregister( + nsIComponentManager* aCompMgr, + nsIFile* aPath, + const char* aRegistryLocation, + const nsModuleComponentInfo* aInfo) +{ + nsresult rv; + nsCOMPtr catman = do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv, rv); + catman->DeleteCategoryEntry( + NS_PASSWORDMANAGER_CATEGORY, + NS_PASSWORDMANAGER_CONTRACTID, + PR_TRUE); + return NS_OK; +} + +/* static */ void +EmbedPasswordMgr::Shutdown() +{ + NS_IF_RELEASE(sDecoderRing); + NS_IF_RELEASE(sPMBundle); + NS_IF_RELEASE(sPasswordManager); +} + +// nsIPasswordManager implementation +NS_IMETHODIMP +EmbedPasswordMgr::AddUser( + const nsACString& aHost, + const nsAString& aUser, + const nsAString& aPassword) +{ + // Silently ignore an empty username/password entry. + // There's no point in taking up space in the signon file with this. + if (aUser.IsEmpty() && aPassword.IsEmpty()) + return NS_OK; + // Check for an existing entry for this host + user + if (!aHost.IsEmpty()) + { + SignonHashEntry *hashEnt; + if (mSignonTable.Get(aHost, &hashEnt)) + { + nsString empty; + SignonDataEntry *entry = nsnull; + FindPasswordEntryInternal(hashEnt->head, aUser, empty, empty, &entry); + if (entry) + { + // Just change the password + return EncryptDataUCS2(aPassword, entry->passValue); + } + } + } + SignonDataEntry* entry = new SignonDataEntry(); + if (NS_FAILED(EncryptDataUCS2(aUser, entry->userValue)) || + NS_FAILED(EncryptDataUCS2(aPassword, entry->passValue))) + { + delete entry; + return NS_ERROR_FAILURE; + } + AddSignonData(aHost, entry); + WritePasswords(mSignonFile); + return NS_OK; +} + +NS_IMETHODIMP +EmbedPasswordMgr::InsertLogin(const char* username, const char* password) +{ + if (username) + mGlobalUserField->SetValue (NS_ConvertUTF8toUTF16(username)); + else + return NS_ERROR_FAILURE; + + if (password) + mGlobalPassField->SetValue (NS_ConvertUTF8toUTF16(password)); + else + FillPassword(); + + return NS_OK; +} + +NS_IMETHODIMP +EmbedPasswordMgr::GetNumberOfSavedPassword (PRInt32 *aNum) +{ + // default return value in case of errors. + *aNum = 0; + + nsCOMPtr passwordManager = do_GetService(NS_PASSWORDMANAGER_CONTRACTID); + if (!passwordManager) + return NS_ERROR_NULL_POINTER; + + nsCOMPtr idnService (do_GetService ("@mozilla.org/network/idn-service;1")); + if (!idnService) + return NS_ERROR_NULL_POINTER; + + if (mLastHostQuery.Equals ("")) + return NS_ERROR_FAILURE; + + nsresult result = NS_ERROR_FAILURE; + nsCOMPtr passwordEnumerator; + result = passwordManager->GetEnumerator(getter_AddRefs(passwordEnumerator)); + if (NS_FAILED (result)) + return NS_ERROR_FAILURE; + + PRUint32 aCount = 0; + PRBool enumResult; + for (passwordEnumerator->HasMoreElements(&enumResult); + enumResult == PR_TRUE; + passwordEnumerator->HasMoreElements(&enumResult)) + { + nsCOMPtr nsPassword; + result = passwordEnumerator->GetNext (getter_AddRefs(nsPassword)); + if (NS_FAILED(result)) + break; + + nsCString host; + nsString unicodeName; + + nsPassword->GetHost (host); + nsPassword->GetUser (unicodeName); + + if (StringBeginsWith (host, mLastHostQuery)){ +#ifdef NS_DEBUG + printf ("HOST = '%s' LAST REALM '%s'\n", host.get(), mLastHostQuery.get ()); +#endif + aCount++; + } + } + + *aNum = aCount; + return NS_OK; +} + +NS_IMETHODIMP +EmbedPasswordMgr::RemovePasswordsByIndex(PRUint32 aIndex) +{ + nsCOMPtr passwordManager = do_GetService(NS_PASSWORDMANAGER_CONTRACTID); + if (!passwordManager) + return NS_ERROR_NULL_POINTER; + nsCOMPtr idnService (do_GetService ("@mozilla.org/network/idn-service;1")); + if (!idnService) + return NS_ERROR_NULL_POINTER; + nsresult result = NS_ERROR_FAILURE; + nsCOMPtr passwordEnumerator; + result = passwordManager->GetEnumerator(getter_AddRefs(passwordEnumerator)); + if (NS_FAILED(result)) + return result; + PRBool enumResult; + PRUint32 i = 0; + nsCOMPtr nsPassword; + for (passwordEnumerator->HasMoreElements(&enumResult); + enumResult == PR_TRUE && i <= aIndex; + passwordEnumerator->HasMoreElements(&enumResult)) + { + result = passwordEnumerator->GetNext (getter_AddRefs(nsPassword)); + if (NS_FAILED(result) || !nsPassword) + return result; + + nsCString host; + nsPassword->GetHost (host); + + if (StringBeginsWith (host, mLastHostQuery)) + i++; + } + // if we found the right object to delete + if (nsPassword) { + + nsCString host, idn_host; + nsString unicodeName; + + nsPassword->GetHost (host); + nsPassword->GetUser (unicodeName); + result = idnService->ConvertUTF8toACE (host, idn_host); + + result = passwordManager->RemoveUser(idn_host, unicodeName); + } + return NS_OK; +} + +NS_IMETHODIMP +EmbedPasswordMgr::RemovePasswords(const char *aHostName, const char *aUserName) +{ + nsCOMPtr passwordManager = do_GetService(NS_PASSWORDMANAGER_CONTRACTID); + if (!passwordManager) + return NS_ERROR_NULL_POINTER; + nsCOMPtr idnService (do_GetService ("@mozilla.org/network/idn-service;1")); + if (!idnService) + return NS_ERROR_NULL_POINTER; + nsresult result = NS_ERROR_FAILURE; + nsCOMPtr passwordEnumerator; + result = passwordManager->GetEnumerator(getter_AddRefs(passwordEnumerator)); + if (NS_FAILED(result)) + return result; + PRBool enumResult; + for (passwordEnumerator->HasMoreElements(&enumResult); + enumResult == PR_TRUE ; passwordEnumerator->HasMoreElements(&enumResult)) + { + nsCOMPtr nsPassword; + result = passwordEnumerator->GetNext (getter_AddRefs(nsPassword)); + if (NS_FAILED(result)) return FALSE; + nsCString host, idn_host; + + nsPassword->GetHost (host); + nsString unicodeName; + nsPassword->GetUser (unicodeName); + result = idnService->ConvertUTF8toACE (host, idn_host); + result = passwordManager->RemoveUser(idn_host, unicodeName); + } + return NS_OK; +} + +NS_IMETHODIMP +EmbedPasswordMgr::RemoveUser(const nsACString& aHost, const nsAString& aUser) +{ + SignonDataEntry* entry, *prevEntry = nsnull; + SignonHashEntry* hashEnt; + if (!mSignonTable.Get(aHost, &hashEnt)) + return NS_ERROR_FAILURE; + for (entry = hashEnt->head; entry; prevEntry = entry, entry = entry->next) + { + nsAutoString ptUser; + if (!entry->userValue.IsEmpty() && + NS_FAILED(DecryptData(entry->userValue, ptUser))) + break; + if (ptUser.Equals(aUser)) + { + if (prevEntry) + prevEntry->next = entry->next; + else + hashEnt->head = entry->next; + entry->next = nsnull; + delete entry; + if (!hashEnt->head) + mSignonTable.Remove(aHost); // deletes hashEnt + WritePasswords(mSignonFile); + return NS_OK; + } + } + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP +EmbedPasswordMgr::AddReject(const nsACString& aHost) +{ + mRejectTable.Put(aHost, 1); + WritePasswords(mSignonFile); + return NS_OK; +} + +NS_IMETHODIMP +EmbedPasswordMgr::RemoveReject(const nsACString& aHost) +{ + mRejectTable.Remove(aHost); + WritePasswords(mSignonFile); + return NS_OK; +} + +/* static */ PLDHashOperator PR_CALLBACK +EmbedPasswordMgr::BuildArrayEnumerator( + const nsACString& aKey, + SignonHashEntry* aEntry, + void* aUserData) +{ + nsIMutableArray* array = NS_STATIC_CAST(nsIMutableArray*, aUserData); + for (SignonDataEntry* e = aEntry->head; e; e = e->next) + array->AppendElement(new PasswordEntry(aKey, e), PR_FALSE); + return PL_DHASH_NEXT; +} + +NS_IMETHODIMP +EmbedPasswordMgr::GetEnumerator(nsISimpleEnumerator** aEnumerator) +{ + // Build an array out of the hashtable + nsCOMPtr signonArray = + do_CreateInstance(NS_ARRAY_CONTRACTID); + NS_ENSURE_STATE(signonArray); + mSignonTable.EnumerateRead(BuildArrayEnumerator, signonArray); + return signonArray->Enumerate(aEnumerator); +} + +/* static */ PLDHashOperator PR_CALLBACK +EmbedPasswordMgr::BuildRejectArrayEnumerator( + const nsACString& aKey, + PRInt32 aEntry, + void* aUserData) +{ + nsIMutableArray* array = NS_STATIC_CAST(nsIMutableArray*, aUserData); + nsCOMPtr passwordEntry = new PasswordEntry(aKey, nsnull); +// if (!passwordEntry) { +// // XXX handle oom +// } + array->AppendElement(passwordEntry, PR_FALSE); + return PL_DHASH_NEXT; +} + +NS_IMETHODIMP +EmbedPasswordMgr::GetRejectEnumerator(nsISimpleEnumerator** aEnumerator) +{ + // Build an array out of the hashtable + nsCOMPtr rejectArray = + do_CreateInstance(NS_ARRAY_CONTRACTID); + NS_ENSURE_STATE(rejectArray); + mRejectTable.EnumerateRead(BuildRejectArrayEnumerator, rejectArray); + return rejectArray->Enumerate(aEnumerator); +} + +// nsIPasswordManagerInternal implementation +struct findEntryContext +{ + EmbedPasswordMgr* manager; + const nsACString& hostURI; + const nsAString& username; + const nsAString& password; + nsACString& hostURIFound; + nsAString& usernameFound; + nsAString& passwordFound; + PRBool matched; + + findEntryContext(EmbedPasswordMgr* aManager, + const nsACString& aHostURI, + const nsAString& aUsername, + const nsAString& aPassword, + nsACString& aHostURIFound, + nsAString& aUsernameFound, + nsAString& aPasswordFound) + : manager(aManager), hostURI(aHostURI), username(aUsername), + password(aPassword), hostURIFound(aHostURIFound), + usernameFound(aUsernameFound), passwordFound(aPasswordFound), + matched(PR_FALSE) + { + } +}; + +/* static */ +PLDHashOperator PR_CALLBACK +EmbedPasswordMgr::FindEntryEnumerator( + const nsACString& aKey, + SignonHashEntry* aEntry, + void* aUserData) +{ + findEntryContext* context = NS_STATIC_CAST(findEntryContext*, aUserData); + EmbedPasswordMgr* manager = context->manager; + nsresult rv; + SignonDataEntry* entry = nsnull; + rv = manager->FindPasswordEntryInternal( + aEntry->head, + context->username, + context->password, + EmptyString(), + &entry); + if (NS_SUCCEEDED(rv) && entry) + { + if (NS_SUCCEEDED(DecryptData(entry->userValue, context->usernameFound)) && + NS_SUCCEEDED(DecryptData(entry->passValue, context->passwordFound))) + { + context->matched = PR_TRUE; + context->hostURIFound.Assign(context->hostURI); + } + /* XXX The logic here doesn't make sense, but the author + * returned STOP instead of NEXT, so ... + */ + return PL_DHASH_STOP; + } + return PL_DHASH_NEXT; +} + + +NS_IMETHODIMP +EmbedPasswordMgr::FindPasswordEntry( + const nsACString& aHostURI, + const nsAString& aUsername, + const nsAString& aPassword, + nsACString& aHostURIFound, + nsAString& aUsernameFound, + nsAString& aPasswordFound) +{ + if (!aHostURI.IsEmpty()) + { + SignonHashEntry* hashEnt; + if (mSignonTable.Get(aHostURI, &hashEnt)) + { + SignonDataEntry* entry; + nsresult rv = + FindPasswordEntryInternal( + hashEnt->head, + aUsername, + aPassword, + EmptyString(), + &entry); + if (NS_SUCCEEDED(rv) && entry) + { + if (NS_SUCCEEDED(DecryptData(entry->userValue, aUsernameFound)) && + NS_SUCCEEDED(DecryptData(entry->passValue, aPasswordFound))) + { + aHostURIFound.Assign(aHostURI); + } else { + return NS_ERROR_FAILURE; + } + } + return rv; + } + return NS_ERROR_FAILURE; + } + // No host given, so enumerate all entries in the hashtable + findEntryContext context(this, aHostURI, aUsername, aPassword, + aHostURIFound, aUsernameFound, aPasswordFound); + mSignonTable.EnumerateRead(FindEntryEnumerator, &context); + return NS_OK; +} + +NS_IMETHODIMP +EmbedPasswordMgr::AddUserFull( + const nsACString& aKey, + const nsAString& aUser, + const nsAString& aPassword, + const nsAString& aUserFieldName, + const nsAString& aPassFieldName) +{ + // Silently ignore an empty username/password entry. + // There's no point in taking up space in the signon file with this. + if (aUser.IsEmpty() && aPassword.IsEmpty()) + return NS_OK; + // Check for an existing entry for this host + user + if (!aKey.IsEmpty()) + { + SignonHashEntry *hashEnt; + if (mSignonTable.Get(aKey, &hashEnt)) + { + nsString empty; + SignonDataEntry *entry = nsnull; + FindPasswordEntryInternal(hashEnt->head, aUser, empty, empty, &entry); + if (entry) + { + // Just change the password + EncryptDataUCS2(aPassword, entry->passValue); + // ... and update the field names...s + entry->userField.Assign(aUserFieldName); + entry->passField.Assign(aPassFieldName); + return NS_OK; + } + } + } + SignonDataEntry* entry = new SignonDataEntry(); +// if (!entry) { +// // XXX handle oom +// } + entry->userField.Assign(aUserFieldName); + entry->passField.Assign(aPassFieldName); + EncryptDataUCS2(aUser, entry->userValue); + EncryptDataUCS2(aPassword, entry->passValue); + AddSignonData(aKey, entry); + WritePasswords(mSignonFile); + return NS_OK; +} + +NS_IMETHODIMP +EmbedPasswordMgr::ReadPasswords(nsIFile* aPasswordFile) +{ + nsCOMPtr fileStream; + NS_NewLocalFileInputStream(getter_AddRefs(fileStream), aPasswordFile); + if (!fileStream) + return NS_ERROR_OUT_OF_MEMORY; + nsCOMPtr lineStream = do_QueryInterface(fileStream); + NS_ASSERTION(lineStream, "File stream is not an nsILineInputStream"); + // Read the header + nsCAutoString utf8Buffer; + PRBool moreData = PR_FALSE; + nsresult rv = lineStream->ReadLine(utf8Buffer, &moreData); + if (NS_FAILED(rv)) + return NS_OK; + if (!utf8Buffer.Equals("#2c")) + { + NS_ERROR("Unexpected version header in signon file"); + return NS_OK; + } + enum { + STATE_REJECT, + STATE_REALM, + STATE_USERFIELD, + STATE_USERVALUE, + STATE_PASSFIELD, + STATE_PASSVALUE + } state = STATE_REJECT; + nsCAutoString realm; + SignonDataEntry* entry = nsnull; + PRBool writeOnFinish = PR_FALSE; + do + { + rv = lineStream->ReadLine(utf8Buffer, &moreData); + if (NS_FAILED(rv)) + return NS_OK; + switch (state) + { + case STATE_REJECT: + if (utf8Buffer.Equals(NS_LITERAL_CSTRING("."))) + state = STATE_REALM; + else + mRejectTable.Put(utf8Buffer, 1); + break; + case STATE_REALM: + realm.Assign(utf8Buffer); + state = STATE_USERFIELD; + break; + case STATE_USERFIELD: + // Commit any completed entry + if (entry) + { + // Weed out empty username+password entries from corrupted signon files + if (entry->userValue.IsEmpty() && entry->passValue.IsEmpty()) + { + NS_WARNING("Discarding empty password entry"); + writeOnFinish = PR_TRUE; // so we won't get this on the next startup + delete entry; + } + else + { + AddSignonData(realm, entry); + } + } + // If the line is a ., we've reached the end of this realm's entries. + if (utf8Buffer.Equals(NS_LITERAL_CSTRING("."))) + { + entry = nsnull; + state = STATE_REALM; + } + else + { + entry = new SignonDataEntry(); + if (!entry) { + /* XXX handle oom */ + } + CopyUTF8toUTF16(utf8Buffer, entry->userField); + state = STATE_USERVALUE; + } + break; + case STATE_USERVALUE: + NS_ASSERTION(entry, "bad state"); + CopyUTF8toUTF16(utf8Buffer, entry->userValue); + state = STATE_PASSFIELD; + break; + case STATE_PASSFIELD: + NS_ASSERTION(entry, "bad state"); + // Strip off the leading "*" character + CopyUTF8toUTF16(Substring(utf8Buffer, 1, utf8Buffer.Length() - 1), + entry->passField); + state = STATE_PASSVALUE; + break; + case STATE_PASSVALUE: + NS_ASSERTION(entry, "bad state"); + CopyUTF8toUTF16(utf8Buffer, entry->passValue); + state = STATE_USERFIELD; + break; + } + } + while (moreData); + // Don't leak if the file ended unexpectedly + delete entry; + if (writeOnFinish) + { + fileStream->Close(); + WritePasswords(mSignonFile); + } + return NS_OK; +} + +// nsIObserver implementation +NS_IMETHODIMP +EmbedPasswordMgr::Observe( + nsISupports* aSubject, + const char* aTopic, + const PRUnichar* aData) +{ + if (!strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID)) + { + nsCOMPtr branch = do_QueryInterface(aSubject); + NS_ASSERTION(branch == mPrefBranch, "unexpected pref change notification"); + branch->GetBoolPref("rememberSignons", &sRememberPasswords); + } + return NS_OK; +} + +// nsIWebProgressListener implementation +NS_IMETHODIMP +EmbedPasswordMgr::OnStateChange( + nsIWebProgress* aWebProgress, + nsIRequest* aRequest, + PRUint32 aStateFlags, + nsresult aStatus) +{ + // We're only interested in successful document loads. + if (NS_FAILED(aStatus) || + !(aStateFlags & nsIWebProgressListener::STATE_IS_DOCUMENT) || + !(aStateFlags & nsIWebProgressListener::STATE_STOP)) + return NS_OK; + // Don't do anything if the global signon pref is disabled + if (!SingleSignonEnabled()) + return NS_OK; + nsCOMPtr domWin; + nsresult rv = aWebProgress->GetDOMWindow(getter_AddRefs(domWin)); + NS_ENSURE_SUCCESS(rv, rv); + if (!mCommonObject) + mCommonObject = EmbedCommon::GetInstance(); + nsCOMPtr domDoc; + domWin->GetDocument(getter_AddRefs(domDoc)); + NS_ASSERTION(domDoc, "DOM window should always have a document!"); + // For now, only prefill forms in HTML documents. + nsCOMPtr htmlDoc = do_QueryInterface(domDoc); + if (!htmlDoc) + return NS_OK; + nsCOMPtr forms; + htmlDoc->GetForms(getter_AddRefs(forms)); + nsCOMPtr doc = do_QueryInterface(domDoc); + nsCAutoString realm; + if (!GetPasswordRealm(doc->GetDocumentURI(), realm)) + return NS_OK; + + mLastHostQuery.Assign (realm); + + SignonHashEntry* hashEnt; + if (!mSignonTable.Get(realm, &hashEnt)) + return NS_OK; + PRUint32 formCount; + forms->GetLength(&formCount); + // We can auto-prefill the username and password if there is only + // one stored login that matches the username and password field names + // on the form in question. Note that we only need to worry about a + // single login per form. + for (PRUint32 i = 0; i < formCount; ++i) + { + nsCOMPtr formNode; + forms->Item(i, getter_AddRefs(formNode)); + nsCOMPtr form = do_QueryInterface(formNode); + SignonDataEntry* firstMatch = nsnull; + PRBool attachedToInput = PR_FALSE; + PRBool prefilledUser = PR_FALSE; + nsCOMPtr userField, passField; + nsCOMPtr temp; + nsAutoString fieldType; + for (SignonDataEntry* e = hashEnt->head; e; e = e->next) + { + nsCOMPtr foundNode; + if (!(e->userField).IsEmpty()) + { + form->ResolveName(e->userField, getter_AddRefs(foundNode)); + temp = do_QueryInterface(foundNode); + } + nsAutoString oldUserValue; + if (temp) + { + temp->GetType(fieldType); + if (!fieldType.Equals(NS_LITERAL_STRING("text"))) + continue; + temp->GetValue(oldUserValue); + userField = temp; + } + if (!(e->passField).IsEmpty()) + { + form->ResolveName(e->passField, getter_AddRefs(foundNode)); + temp = do_QueryInterface(foundNode); + } + else if (userField) + { + // No password field name was supplied, try to locate one in the form, + // but only if we have a username field. + nsCOMPtr fc(do_QueryInterface(foundNode)); + PRInt32 index = -1; + form->IndexOfControl(fc, &index); + if (index >= 0) + { + PRUint32 count; + form->GetElementCount(&count); + PRUint32 i; + temp = nsnull; + // Search forwards + nsCOMPtr passField; + for (i = index + 1; i < count; ++i) + { + form->GetElementAt(i, getter_AddRefs(passField)); + if (passField && passField->GetType() == NS_FORM_INPUT_PASSWORD) + { + foundNode = passField; + temp = do_QueryInterface(foundNode); + } + } + if (!temp && index != 0) + { + // Search backwards + i = index; + do + { + form->GetElementAt(i, getter_AddRefs(passField)); + if (passField && passField->GetType() == NS_FORM_INPUT_PASSWORD) + { + foundNode = passField; + temp = do_QueryInterface(foundNode); + } + } + while (i-- != 0); + } + } + } + nsAutoString oldPassValue; + if (temp) + { + temp->GetType(fieldType); + if (!fieldType.Equals(NS_LITERAL_STRING("password"))) + continue; + temp->GetValue(oldPassValue); + passField = temp; + } + else + { + continue; + } + if (!oldUserValue.IsEmpty()) + { + // The page has prefilled a username. + // If it matches any of our saved usernames, prefill the password + // for that username. If there are multiple saved usernames, + // we will also attach the autocomplete listener. + prefilledUser = PR_TRUE; + nsAutoString userValue; + if (NS_FAILED(DecryptData(e->userValue, userValue))) + goto done; + if (userValue.Equals(oldUserValue)) + { + nsAutoString passValue; + if (NS_FAILED(DecryptData(e->passValue, passValue))) + goto done; + passField->SetValue(passValue); + } + } + if (firstMatch && userField && !attachedToInput) + { + // We've found more than one possible signon for this form. + // Listen for blur and autocomplete events on the username field so + // that we can attempt to prefill the password after the user has + // entered the username. + if (mCommonObject) + mCommonObject->mFormAttachCount = true; + AttachToInput(userField); + attachedToInput = PR_TRUE; + } + else + { + firstMatch = e; + } + } + // If we found more than one match, attachedToInput will be true, + // but if we found just one, we need to attach the autocomplete listener, + // and fill in the username and password only if the HTML didn't prefill + // the username. + if (firstMatch && !attachedToInput) + { + if (userField) { + AttachToInput(userField); + } + if (!prefilledUser) + { + nsAutoString buffer; + if (userField) + { + if (NS_FAILED(DecryptData(firstMatch->userValue, buffer))) + goto done; + userField->SetValue(buffer); + } + if (NS_FAILED(DecryptData(firstMatch->passValue, buffer))) + goto done; + passField->SetValue(buffer); + } + } + mGlobalUserField = userField; + mGlobalPassField = passField; + } +done: + nsCOMPtr targ = do_QueryInterface(domDoc); + targ->AddEventListener( + NS_LITERAL_STRING("unload"), + NS_STATIC_CAST(nsIDOMLoadListener*, this), + PR_FALSE); + return NS_OK; +} + +NS_IMETHODIMP +EmbedPasswordMgr::OnProgressChange( + nsIWebProgress* aWebProgress, + nsIRequest* aRequest, + PRInt32 aCurSelfProgress, + PRInt32 aMaxSelfProgress, + PRInt32 aCurTotalProgress, + PRInt32 aMaxTotalProgress) +{ + return NS_OK; +} + +NS_IMETHODIMP +EmbedPasswordMgr::OnLocationChange( + nsIWebProgress* aWebProgress, + nsIRequest* aRequest, + nsIURI* aLocation) +{ + return NS_OK; +} + +NS_IMETHODIMP +EmbedPasswordMgr::OnStatusChange( + nsIWebProgress* aWebProgress, + nsIRequest* aRequest, + nsresult aStatus, + const PRUnichar* aMessage) +{ + return NS_OK; +} + +NS_IMETHODIMP +EmbedPasswordMgr::OnSecurityChange( + nsIWebProgress* aWebProgress, + nsIRequest* aRequest, + PRUint32 aState) +{ + return NS_OK; +} + +// nsIFormSubmitObserver implementation +NS_IMETHODIMP +EmbedPasswordMgr::Notify( + nsIContent* aFormNode, + nsIDOMWindowInternal* aWindow, + nsIURI* aActionURL, + PRBool* aCancelSubmit) +{ + // This function must never return a failure code or the form submit + // will be cancelled. + NS_ENSURE_TRUE(aWindow, NS_OK); + // Don't do anything if the global signon pref is disabled + if (!SingleSignonEnabled()) + return NS_OK; + // Check the reject list + nsCAutoString realm; + // XXX bug 281125: GetDocument() could sometimes be null here, hinting + // XXX at a problem with document teardown while a modal dialog is posted. + if (!GetPasswordRealm(aFormNode->GetOwnerDoc()->GetDocumentURI(), realm)) + return NS_OK; + PRInt32 rejectValue; + if (mRejectTable.Get(realm, &rejectValue)) + { + // The user has opted to never save passwords for this site. + return NS_OK; + } + nsCOMPtr formElement = do_QueryInterface(aFormNode); + PRUint32 numControls; + formElement->GetElementCount(&numControls); + // Count the number of password fields in the form. + nsCOMPtr userField; + nsCOMArray passFields; + PRUint32 i, firstPasswordIndex = numControls; + for (i = 0; i < numControls; ++i) + { + nsCOMPtr control; + formElement->GetElementAt(i, getter_AddRefs(control)); + PRInt32 ctype = control->GetType(); + if (ctype == NS_FORM_INPUT_PASSWORD) + { + nsCOMPtr elem = do_QueryInterface(control); + passFields.AppendObject(elem); + if (firstPasswordIndex == numControls) + firstPasswordIndex = i; + } + } + nsCOMPtr prompt; + aWindow->GetPrompter(getter_AddRefs(prompt)); + switch (passFields.Count()) + { + case 1: // normal login + { + // Search backwards from the password field to find a username field. + for (PRInt32 j = (PRInt32) firstPasswordIndex - 1; j >= 0; --j) + { + nsCOMPtr control; + formElement->GetElementAt(j, getter_AddRefs(control)); + if (control->GetType() == NS_FORM_INPUT_TEXT) + { + userField = do_QueryInterface(control); + break; + } + } + // If the username field or the form has autocomplete=off, + // we don't store the login + if (!sForceAutocompletion) { + nsAutoString autocomplete; + if (userField) + { + nsCOMPtr userFieldElement = do_QueryInterface(userField); + userFieldElement->GetAttribute(NS_LITERAL_STRING("autocomplete"), + autocomplete); +#ifdef MOZILLA_INTERNAL_API + if (autocomplete.EqualsIgnoreCase("off")) +#else + if (autocomplete.LowerCaseEqualsLiteral("off")) +#endif + return NS_OK; + } + nsCOMPtr formDOMEl = do_QueryInterface(aFormNode); + formDOMEl->GetAttribute(NS_LITERAL_STRING("autocomplete"), autocomplete); +#ifdef MOZILLA_INTERNAL_API + if (autocomplete.EqualsIgnoreCase("off")) +#else + if (autocomplete.LowerCaseEqualsLiteral("off")) +#endif + return NS_OK; + nsCOMPtr passFieldElement = do_QueryInterface(passFields.ObjectAt(0)); + passFieldElement->GetAttribute(NS_LITERAL_STRING("autocomplete"), autocomplete); +#ifdef MOZILLA_INTERNAL_API + if (autocomplete.EqualsIgnoreCase("off")) +#else + if (autocomplete.LowerCaseEqualsLiteral("off")) +#endif + return NS_OK; + } + // Check whether this signon is already stored. + // Note that we don't prompt the user if only the password doesn't match; + // we instead just silently change the stored password. + nsAutoString userValue, passValue, userFieldName, passFieldName; + if (userField) + { + userField->GetValue(userValue); + userField->GetName(userFieldName); + } + passFields.ObjectAt(0)->GetValue(passValue); + passFields.ObjectAt(0)->GetName(passFieldName); + // If the password is empty, there is no reason to store this login. + if (passValue.IsEmpty()) + return NS_OK; + SignonHashEntry* hashEnt; + if (mSignonTable.Get(realm, &hashEnt)) + { + SignonDataEntry* entry; + nsAutoString buffer; + for (entry = hashEnt->head; entry; entry = entry->next) + { + if (entry->userField.Equals(userFieldName) && + entry->passField.Equals(passFieldName)) + { + if (NS_FAILED(DecryptData(entry->userValue, buffer))) + return NS_OK; + if (buffer.Equals(userValue)) + { + if (NS_FAILED(DecryptData(entry->passValue, buffer))) + return NS_OK; + if (!buffer.Equals(passValue)) + { + if (NS_FAILED(EncryptDataUCS2(passValue, entry->passValue))) + return NS_OK; + WritePasswords(mSignonFile); + } + return NS_OK; + } + } + } + } + nsresult rv; + nsCOMPtr bundleService = + do_GetService(NS_STRINGBUNDLE_CONTRACTID, &rv); + nsCOMPtr brandBundle; + rv = bundleService->CreateBundle("chrome://branding/locale/brand.properties", + getter_AddRefs(brandBundle)); + NS_ENSURE_SUCCESS(rv, rv); + nsXPIDLString brandShortName; + rv = brandBundle->GetStringFromName(NS_LITERAL_STRING("brandShortName").get(), + getter_Copies(brandShortName)); + NS_ENSURE_SUCCESS(rv, rv); + const PRUnichar* formatArgs[1] = + { +#ifdef MOZILLA_INTERNAL_API + brandShortName.get() +#else + brandShortName +#endif + }; + nsAutoString dialogText; + GetLocalizedString(NS_LITERAL_STRING("savePasswordText"), + dialogText, + PR_TRUE, + formatArgs, + 1); + nsAutoString dialogTitle, neverButtonText, rememberButtonText, + notNowButtonText; + GetLocalizedString(NS_LITERAL_STRING("savePasswordTitle"), dialogTitle); + GetLocalizedString(NS_LITERAL_STRING("neverForSiteButtonText"), + neverButtonText); + GetLocalizedString(NS_LITERAL_STRING("rememberButtonText"), + rememberButtonText); + GetLocalizedString(NS_LITERAL_STRING("notNowButtonText"), + notNowButtonText); + PRInt32 selection; + nsCOMPtr domWindow (do_QueryInterface (aWindow)); + GtkWidget *parentWidget = GetGtkWidgetForDOMWindow(domWindow); + if (parentWidget) + gtk_signal_emit (GTK_OBJECT (GTK_MOZ_EMBED(parentWidget)->common), + moz_embed_common_signals[COMMON_REMEMBER_LOGIN], &selection); + // FIXME These values (0,1,2,3,4) need constant variable. + if (selection == GTK_MOZ_EMBED_LOGIN_REMEMBER_FOR_THIS_SITE ) + { + SignonDataEntry* entry = new SignonDataEntry(); + entry->userField.Assign(userFieldName); + entry->passField.Assign(passFieldName); + if (NS_FAILED(EncryptDataUCS2(userValue, entry->userValue)) || + NS_FAILED(EncryptDataUCS2(passValue, entry->passValue))) + { + delete entry; + return NS_OK; + } + AddSignonData(realm, entry); + WritePasswords(mSignonFile); + } + else if (selection == GTK_MOZ_EMBED_LOGIN_REMEMBER_FOR_THIS_SERVER ) + { + SignonDataEntry* entry = new SignonDataEntry(); + + entry->userField.Assign(userFieldName); + entry->passField.Assign(passFieldName); + if (NS_FAILED(EncryptDataUCS2(userValue, entry->userValue)) || + NS_FAILED(EncryptDataUCS2(passValue, entry->passValue))) + { + delete entry; + return NS_OK; + } + AddSignonData(realm, entry); + WritePasswords(mSignonFile); + } + else if (selection == GTK_MOZ_EMBED_LOGIN_NOT_NOW) + { + // cancel button was pressed. + } else if (selection == GTK_MOZ_EMBED_LOGIN_NEVER_FOR_SITE || selection == GTK_MOZ_EMBED_LOGIN_NEVER_FOR_SERVER) { + AddReject(realm); + } + } + break; + case 2: + case 3: + { + // If the following conditions are true, we guess that this is a + // password change page: + // - there are 2 or 3 password fields on the page + // - the fields do not all have the same value + // - there is already a stored login for this realm + // + // In this situation, prompt the user to confirm that this is a password + // change. + SignonDataEntry* changeEntry = nsnull; + nsAutoString value0, valueN; + passFields.ObjectAt(0)->GetValue(value0); + for (PRInt32 k = 1; k < passFields.Count(); ++k) + { + passFields.ObjectAt(k)->GetValue(valueN); + if (!value0.Equals(valueN)) + { + SignonHashEntry* hashEnt; + if (mSignonTable.Get(realm, &hashEnt)) + { + SignonDataEntry* entry = hashEnt->head; + if (entry->next) + { + // Multiple stored logons, prompt for which username is + // being changed. + PRUint32 entryCount = 2; + SignonDataEntry* temp = entry->next; + while (temp->next) + { + ++entryCount; + temp = temp->next; + } + nsAutoString* ptUsernames = new nsAutoString[entryCount]; + const PRUnichar** formatArgs = new const PRUnichar*[entryCount]; + temp = entry; + for (PRUint32 arg = 0; arg < entryCount; ++arg) + { + if (NS_FAILED(DecryptData(temp->userValue, ptUsernames[arg]))) + { + delete [] formatArgs; + delete [] ptUsernames; + return NS_OK; + } + formatArgs[arg] = ptUsernames[arg].get(); + temp = temp->next; + } + nsAutoString dialogTitle, dialogText; + GetLocalizedString(NS_LITERAL_STRING("passwordChangeTitle"), + dialogTitle); + GetLocalizedString(NS_LITERAL_STRING("userSelectText"), + dialogText); + PRInt32 selection; + PRBool confirm; + prompt->Select(dialogTitle.get(), + dialogText.get(), + entryCount, + formatArgs, + &selection, + &confirm); + delete[] formatArgs; + delete[] ptUsernames; + if (confirm && selection >= 0) + { + changeEntry = entry; + for (PRInt32 m = 0; m < selection; ++m) + changeEntry = changeEntry->next; + } + } + else + { + nsAutoString dialogTitle, dialogText, ptUser; + if (NS_FAILED(DecryptData(entry->userValue, ptUser))) + return NS_OK; + + const PRUnichar* formatArgs[1] = + { + ptUser.get() + }; + GetLocalizedString(NS_LITERAL_STRING("passwordChangeTitle"), + dialogTitle); + GetLocalizedString(NS_LITERAL_STRING("passwordChangeText"), + dialogText, + PR_TRUE, + formatArgs, + 1); + PRInt32 selection; + prompt->ConfirmEx(dialogTitle.get(), + dialogText.get(), + (nsIPrompt::BUTTON_TITLE_YES * nsIPrompt::BUTTON_POS_0) + + (nsIPrompt::BUTTON_TITLE_NO * nsIPrompt::BUTTON_POS_1), + nsnull, nsnull, nsnull, nsnull, nsnull, + &selection); + if (selection == 0) + changeEntry = entry; + } + } + break; + } + } + if (changeEntry) + { + nsAutoString newValue; + passFields.ObjectAt(1)->GetValue(newValue); + if (NS_FAILED(EncryptDataUCS2(newValue, changeEntry->passValue))) + return NS_OK; + WritePasswords(mSignonFile); + } + } + break; + default: // no passwords or something odd; be safe and just don't store anything + break; + } + return NS_OK; +} + +// nsIDOMFocusListener implementation +NS_IMETHODIMP +EmbedPasswordMgr::Focus(nsIDOMEvent* aEvent) +{ + return NS_OK; +} + +NS_IMETHODIMP +EmbedPasswordMgr::Blur(nsIDOMEvent* aEvent) +{ + return FillPassword(aEvent); +} + +NS_IMETHODIMP +EmbedPasswordMgr::HandleEvent(nsIDOMEvent* aEvent) +{ + return FillPassword(aEvent); +} + +// nsIDOMLoadListener implementation +NS_IMETHODIMP +EmbedPasswordMgr::Load(nsIDOMEvent* aEvent) +{ + return NS_OK; +} + +NS_IMETHODIMP +EmbedPasswordMgr::BeforeUnload(nsIDOMEvent* aEvent) +{ + return NS_OK; +} + +/* static */ PLDHashOperator PR_CALLBACK +EmbedPasswordMgr::RemoveForDOMDocumentEnumerator( + nsISupports* aKey, + PRInt32& aEntry, + void* aUserData) +{ + nsIDOMDocument* domDoc = NS_STATIC_CAST(nsIDOMDocument*, aUserData); + nsCOMPtr element = do_QueryInterface(aKey); + nsCOMPtr elementDoc; + element->GetOwnerDocument(getter_AddRefs(elementDoc)); + if (elementDoc == domDoc) + return PL_DHASH_REMOVE; + return PL_DHASH_NEXT; +} + +NS_IMETHODIMP +EmbedPasswordMgr::Unload(nsIDOMEvent* aEvent) +{ + nsCOMPtr target; + aEvent->GetTarget(getter_AddRefs(target)); + nsCOMPtr domDoc = do_QueryInterface(target); + if (domDoc) + mAutoCompleteInputs.Enumerate(RemoveForDOMDocumentEnumerator, domDoc); + return NS_OK; +} + +NS_IMETHODIMP +EmbedPasswordMgr::Abort(nsIDOMEvent* aEvent) +{ + return NS_OK; +} + +NS_IMETHODIMP +EmbedPasswordMgr::Error(nsIDOMEvent* aEvent) +{ + return NS_OK; +} + +/* static */ PLDHashOperator PR_CALLBACK +EmbedPasswordMgr::WriteRejectEntryEnumerator( + const nsACString& aKey, + PRInt32 aEntry, + void* aUserData) +{ + nsIOutputStream* stream = NS_STATIC_CAST(nsIOutputStream*, aUserData); + PRUint32 bytesWritten; + nsCAutoString buffer(aKey); + buffer.Append(NS_LINEBREAK); + stream->Write(buffer.get(), buffer.Length(), &bytesWritten); + return PL_DHASH_NEXT; +} + +/* static */ PLDHashOperator PR_CALLBACK +EmbedPasswordMgr::WriteSignonEntryEnumerator( + const nsACString& aKey, + SignonHashEntry* aEntry, + void* aUserData) +{ + nsIOutputStream* stream = NS_STATIC_CAST(nsIOutputStream*, aUserData); + PRUint32 bytesWritten; + nsCAutoString buffer(aKey); + buffer.Append(NS_LINEBREAK); + stream->Write(buffer.get(), buffer.Length(), &bytesWritten); + for (SignonDataEntry* e = aEntry->head; e; e = e->next) + { + NS_ConvertUTF16toUTF8 userField(e->userField); + userField.Append(NS_LINEBREAK); + stream->Write(userField.get(), userField.Length(), &bytesWritten); + buffer.Assign(NS_ConvertUTF16toUTF8(e->userValue)); + buffer.Append(NS_LINEBREAK); + stream->Write(buffer.get(), buffer.Length(), &bytesWritten); + buffer.Assign("*"); + buffer.Append(NS_ConvertUTF16toUTF8(e->passField)); + buffer.Append(NS_LINEBREAK); + stream->Write(buffer.get(), buffer.Length(), &bytesWritten); + buffer.Assign(NS_ConvertUTF16toUTF8(e->passValue)); + buffer.Append(NS_LINEBREAK); + stream->Write(buffer.get(), buffer.Length(), &bytesWritten); + } + buffer.Assign("." NS_LINEBREAK); + stream->Write(buffer.get(), buffer.Length(), &bytesWritten); + return PL_DHASH_NEXT; +} + +void +EmbedPasswordMgr::WritePasswords(nsIFile* aPasswordFile) +{ + nsCOMPtr fileStream; + NS_NewLocalFileOutputStream( + getter_AddRefs(fileStream), + aPasswordFile, + -1, + 0600, + 0); + if (!fileStream) + return; + PRUint32 bytesWritten; + // File header + nsCAutoString buffer("#2c" NS_LINEBREAK); + fileStream->Write(buffer.get(), buffer.Length(), &bytesWritten); + // Write out the reject list. + mRejectTable.EnumerateRead(WriteRejectEntryEnumerator, fileStream); + buffer.Assign("." NS_LINEBREAK); + fileStream->Write(buffer.get(), buffer.Length(), &bytesWritten); + // Write out the signon data. + mSignonTable.EnumerateRead(WriteSignonEntryEnumerator, fileStream); +} + +void +EmbedPasswordMgr::AddSignonData( + const nsACString& aRealm, + SignonDataEntry* aEntry) +{ + // See if there is already an entry for this URL + SignonHashEntry* hashEnt; + if (mSignonTable.Get(aRealm, &hashEnt)) + { + // Add this one at the front of the linked list + aEntry->next = hashEnt->head; + hashEnt->head = aEntry; + } + else + { + /* XXX this is bad, you shouldn't stick nulls -OOM- into hashtables */ + mSignonTable.Put(aRealm, new SignonHashEntry(aEntry)); + } +} + +/* static */ nsresult +EmbedPasswordMgr::DecryptData( + const nsAString& aData, + nsAString& aPlaintext) +{ + NS_ConvertUTF16toUTF8 flatData(aData); + char* buffer = nsnull; + if (flatData.CharAt(0) == '~') + { + // This is a base64-encoded string. Strip off the ~ prefix. + PRUint32 srcLength = flatData.Length() - 1; + if (!(buffer = PL_Base64Decode(&(flatData.get())[1], srcLength, NULL))) + return NS_ERROR_FAILURE; + } + else + { + // This is encrypted using nsISecretDecoderRing. + EnsureDecoderRing(); + if (!sDecoderRing) + { + NS_WARNING("Unable to get decoder ring service"); + return NS_ERROR_FAILURE; + } + if (NS_FAILED(sDecoderRing->DecryptString(flatData.get(), &buffer))) + return NS_ERROR_FAILURE; + } + aPlaintext.Assign(NS_ConvertUTF8toUTF16(buffer)); + /* sdr::descryptstring is a proper xpcom creature, it uses nsmemory */ + NS_Free(buffer); + return NS_OK; +} + +// Note that nsISecretDecoderRing encryption uses a pseudo-random salt value, +// so it's not possible to test equality of two strings by comparing their +// ciphertexts. We need to decrypt both strings and compare the plaintext. +/* static */ nsresult +EmbedPasswordMgr::EncryptData(const nsAString& aPlaintext, + nsACString& aEncrypted) +{ + EnsureDecoderRing(); + NS_ENSURE_TRUE(sDecoderRing, NS_ERROR_FAILURE); + char* buffer; + if (NS_FAILED(sDecoderRing->EncryptString(NS_ConvertUTF16toUTF8(aPlaintext).get(), &buffer))) + return NS_ERROR_FAILURE; + aEncrypted.Assign(buffer); + /* XXX [not our fault] we intentionally leak here because SDR is so buggy that we could + * only corrupt the heap if we tried to do something about it. Bug 359209 + */ + NS_Free(buffer); + return NS_OK; +} + +/* static */ nsresult +EmbedPasswordMgr::EncryptDataUCS2(const nsAString& aPlaintext, + nsAString& aEncrypted) +{ + nsCAutoString buffer; + nsresult rv = EncryptData(aPlaintext, buffer); + NS_ENSURE_SUCCESS(rv, rv); + aEncrypted.Assign(NS_ConvertUTF8toUTF16(buffer)); + return NS_OK; +} + +/* static */ void +EmbedPasswordMgr::EnsureDecoderRing() +{ + if (!sDecoderRing) + { + CallGetService("@mozilla.org/security/sdr;1", &sDecoderRing); + // Ensure that the master password (internal key) has been initialized. + // If not, set a default empty master password. + nsCOMPtr tokenDB = do_GetService(NS_PK11TOKENDB_CONTRACTID); + if (!tokenDB) + return; + nsCOMPtr token; + tokenDB->GetInternalKeyToken(getter_AddRefs(token)); + PRBool needUserInit = PR_FALSE; + token->GetNeedsUserInit(&needUserInit); + if (needUserInit) + token->InitPassword(EmptyString().get()); + } +} + +nsresult +EmbedPasswordMgr::FindPasswordEntryInternal( + const SignonDataEntry* aEntry, + const nsAString& aUser, + const nsAString& aPassword, + const nsAString& aUserField, + SignonDataEntry** aResult) +{ + // host has already been checked, so just look for user/password match. + const SignonDataEntry* entry = aEntry; + nsAutoString buffer; + for (; entry; entry = entry->next) + { + PRBool matched; + if (aUser.IsEmpty()) + { + matched = PR_TRUE; + } + else + { + if (NS_FAILED(DecryptData(entry->userValue, buffer))) + { + *aResult = nsnull; + return NS_ERROR_FAILURE; + } + matched = aUser.Equals(buffer); + } + if (!matched) + continue; + if (aPassword.IsEmpty()) + { + matched = PR_TRUE; + } + else + { + if (NS_FAILED(DecryptData(entry->passValue, buffer))) + { + *aResult = nsnull; + return NS_ERROR_FAILURE; + } + matched = aPassword.Equals(buffer); + } + if (!matched) + continue; + if (aUserField.IsEmpty()) + matched = PR_TRUE; + else + matched = entry->userField.Equals(aUserField); + if (matched) + break; + } + if (entry) + { + *aResult = NS_CONST_CAST(SignonDataEntry*, entry); + return NS_OK; + } + *aResult = nsnull; + return NS_ERROR_FAILURE; +} + +nsresult +EmbedPasswordMgr::FillPassword(nsIDOMEvent* aEvent) +{ + // Try to prefill the password for the just-changed username. + nsCOMPtr userField; + if (aEvent) { + nsCOMPtr target; + aEvent->GetTarget(getter_AddRefs(target)); + userField = do_QueryInterface(target); + } else { + userField = mGlobalUserField; + } + if (!userField || userField == mAutoCompletingField) + return NS_OK; + nsCOMPtr fieldContent = do_QueryInterface(userField); + // The document may be null during teardown, for example as Windows + // sends a blur event as a native widget is destroyed. + nsIDocument *doc = fieldContent->GetDocument(); + if (!doc) + return NS_OK; + nsCAutoString realm; + if (!GetPasswordRealm(doc->GetDocumentURI(), realm)) + return NS_OK; + nsAutoString userValue; + userField->GetValue(userValue); + if (userValue.IsEmpty()) + return NS_OK; + nsAutoString fieldName; + userField->GetName(fieldName); + SignonHashEntry* hashEnt; + if (!mSignonTable.Get(realm, &hashEnt)) + return NS_OK; + SignonDataEntry* foundEntry; + FindPasswordEntryInternal(hashEnt->head, userValue, EmptyString(), + fieldName, &foundEntry); + if (!foundEntry) + return NS_OK; + nsCOMPtr formEl; + userField->GetForm(getter_AddRefs(formEl)); + if (!formEl) + return NS_OK; + nsCOMPtr form = do_QueryInterface(formEl); + nsCOMPtr foundNode; + form->ResolveName(foundEntry->passField, getter_AddRefs(foundNode)); + nsCOMPtr passField = do_QueryInterface(foundNode); + if (!passField) + return NS_OK; + nsAutoString passValue; + if (NS_SUCCEEDED(DecryptData(foundEntry->passValue, passValue))) + passField->SetValue(passValue); + return NS_OK; +} + +void +EmbedPasswordMgr::AttachToInput(nsIDOMHTMLInputElement* aElement) +{ + nsCOMPtr targ = do_QueryInterface(aElement); + nsIDOMEventListener* listener = NS_STATIC_CAST(nsIDOMFocusListener*, this); + targ->AddEventListener(NS_LITERAL_STRING("blur"), listener, PR_FALSE); + targ->AddEventListener(NS_LITERAL_STRING("DOMAutoComplete"), listener, PR_FALSE); + mAutoCompleteInputs.Put(aElement, 1); +} + +PRBool +EmbedPasswordMgr::GetPasswordRealm(nsIURI* aURI, nsACString& aRealm) +{ + // Note: this _is_ different from getting the uri's prePath! + // We don't want to include a username or password that's part of the + // URL in the host key... it will cause lookups to work incorrectly, and will + // also cause usernames and passwords to be stored in cleartext. + nsCAutoString buffer; + aURI->GetScheme(buffer); + aRealm.Append(buffer); + aRealm.Append(NS_LITERAL_CSTRING("://")); + aURI->GetHostPort(buffer); + if (buffer.IsEmpty()) + { + // The scheme does not support hostnames, so don't attempt to save/restore + // any signon data. (see bug 159484) + return PR_FALSE; + } + aRealm.Append(buffer); + return PR_TRUE; +} + +/* static */ void +EmbedPasswordMgr::GetLocalizedString(const nsAString& key, + nsAString& aResult, + PRBool aIsFormatted, + const PRUnichar** aFormatArgs, + PRUint32 aFormatArgsLength) +{ + if (!sPMBundle) + { + nsCOMPtr bundleService = do_GetService(NS_STRINGBUNDLE_CONTRACTID); + bundleService->CreateBundle(kPMPropertiesURL, + &sPMBundle); + if (!sPMBundle) + { + NS_ERROR("string bundle not present"); + return; + } + } + nsXPIDLString str; + if (aIsFormatted) + sPMBundle->FormatStringFromName(PromiseFlatString(key).get(), + aFormatArgs, aFormatArgsLength, + getter_Copies(str)); + else + sPMBundle->GetStringFromName(PromiseFlatString(key).get(), + getter_Copies(str)); + aResult.Assign(str); +} + +NS_IMPL_ISUPPORTS2(EmbedSignonPrompt, + nsIAuthPromptWrapper, + nsIAuthPrompt) + +// nsIAuthPrompt +NS_IMETHODIMP +EmbedSignonPrompt::Prompt( + const PRUnichar* aDialogTitle, + const PRUnichar* aText, + const PRUnichar* aPasswordRealm, + PRUint32 aSavePassword, + const PRUnichar* aDefaultText, + PRUnichar** aResult, + PRBool* aConfirm) +{ + nsAutoString checkMsg; + nsString emptyString; + PRBool checkValue = PR_FALSE; + PRBool *checkPtr = nsnull; + PRUnichar* value = nsnull; + nsCOMPtr mgrInternal; + if (EmbedPasswordMgr::SingleSignonEnabled() && aPasswordRealm) + { + if (aSavePassword == SAVE_PASSWORD_PERMANENTLY) + { + EmbedPasswordMgr::GetLocalizedString(NS_LITERAL_STRING("rememberValue"), + checkMsg); + checkPtr = &checkValue; + } + mgrInternal = do_GetService(NS_PASSWORDMANAGER_CONTRACTID); + nsCAutoString outHost; + nsAutoString outUser, outPassword; + mgrInternal->FindPasswordEntry(NS_ConvertUTF16toUTF8(aPasswordRealm), + emptyString, + emptyString, + outHost, + outUser, + outPassword); + if (!outUser.IsEmpty()) + { + value = ToNewUnicode(outUser); + checkValue = PR_TRUE; + } + } + if (!value && aDefaultText) + value = ToNewUnicode(nsDependentString(aDefaultText)); + mPrompt->Prompt(aDialogTitle, + aText, + &value, + checkMsg.get(), + checkPtr, + aConfirm); + if (*aConfirm) + { + if (checkValue && value && value[0] != '\0') + { + // The user requested that we save the value + // TODO: support SAVE_PASSWORD_FOR_SESSION + nsCOMPtr manager = do_QueryInterface(mgrInternal); + manager->AddUser(NS_ConvertUTF16toUTF8(aPasswordRealm), + nsDependentString(value), + emptyString); + } + *aResult = value; + } + else + { + if (value) + nsMemory::Free(value); + *aResult = nsnull; + } + return NS_OK; +} + +NS_IMETHODIMP +EmbedSignonPrompt::PromptUsernameAndPassword( + const PRUnichar* aDialogTitle, + const PRUnichar* aText, + const PRUnichar* aPasswordRealm, + PRUint32 aSavePassword, + PRUnichar** aUser, + PRUnichar** aPassword, + PRBool* aConfirm) +{ + nsAutoString checkMsg; + nsString emptyString; + PRBool checkValue = PR_FALSE; + PRBool *checkPtr = nsnull; + PRUnichar *user = nsnull, *password = nsnull; + nsCOMPtr mgrInternal; + if (EmbedPasswordMgr::SingleSignonEnabled() && aPasswordRealm) + { + if (aSavePassword == SAVE_PASSWORD_PERMANENTLY) + { + EmbedPasswordMgr::GetLocalizedString(NS_LITERAL_STRING("rememberPassword"), + checkMsg); + checkPtr = &checkValue; + } + mgrInternal = do_GetService(NS_PASSWORDMANAGER_CONTRACTID); + nsCAutoString outHost; + nsAutoString outUser, outPassword; + mgrInternal->FindPasswordEntry(NS_ConvertUTF16toUTF8(aPasswordRealm), + emptyString, + emptyString, + outHost, + outUser, + outPassword); + user = ToNewUnicode(outUser); + password = ToNewUnicode(outPassword); + if (!outUser.IsEmpty() || !outPassword.IsEmpty()) + checkValue = PR_TRUE; + } + mPrompt->PromptUsernameAndPassword(aPasswordRealm, + aText, + &user, + &password, + checkMsg.get(), + checkPtr, + aConfirm); + if (*aConfirm) + { + if (checkValue && user && password && (user[0] != '\0' || password[0] != '\0')) + { + // The user requested that we save the values + // TODO: support SAVE_PASSWORD_FOR_SESSION + nsCOMPtr manager = do_QueryInterface(mgrInternal); + manager->AddUser(NS_ConvertUTF16toUTF8(aPasswordRealm), + nsDependentString(user), + nsDependentString(password)); + } + *aUser = user; + *aPassword = password; + } + else + { + if (user) + nsMemory::Free(user); + if (password) + nsMemory::Free(password); + *aUser = *aPassword = nsnull; + } + return NS_OK; +} + +NS_IMETHODIMP +EmbedSignonPrompt::PromptPassword( + const PRUnichar* aDialogTitle, + const PRUnichar* aText, + const PRUnichar* aPasswordRealm, + PRUint32 aSavePassword, + PRUnichar** aPassword, + PRBool* aConfirm) +{ + nsAutoString checkMsg; + nsString emptyString; + PRBool checkValue = PR_FALSE; + PRBool *checkPtr = nsnull; + PRUnichar* password = nsnull; + nsCOMPtr mgrInternal; + if (EmbedPasswordMgr::SingleSignonEnabled() && aPasswordRealm) + { + if (aSavePassword == SAVE_PASSWORD_PERMANENTLY) + { + EmbedPasswordMgr::GetLocalizedString(NS_LITERAL_STRING("rememberPassword"), + checkMsg); + checkPtr = &checkValue; + } + mgrInternal = do_GetService(NS_PASSWORDMANAGER_CONTRACTID); + nsCAutoString outHost; + nsAutoString outUser, outPassword; + mgrInternal->FindPasswordEntry(NS_ConvertUTF16toUTF8(aPasswordRealm), + emptyString, + emptyString, + outHost, + outUser, + outPassword); + password = ToNewUnicode(outPassword); + if (!outPassword.IsEmpty()) + checkValue = PR_TRUE; + } + mPrompt->PromptPassword(aDialogTitle, + aText, + &password, + checkMsg.get(), + checkPtr, + aConfirm); + if (*aConfirm) + { + if (checkValue && password && password[0] != '\0') + { + // The user requested that we save the password + // TODO: support SAVE_PASSWORD_FOR_SESSION + nsCOMPtr manager = do_QueryInterface(mgrInternal); + manager->AddUser(NS_ConvertUTF16toUTF8(aPasswordRealm), + emptyString, + nsDependentString(password)); + } + *aPassword = password; + } + else + { + if (password) + nsMemory::Free(password); + *aPassword = nsnull; + } + return NS_OK; +} + +// nsIAuthPromptWrapper +NS_IMETHODIMP +EmbedSignonPrompt::SetPromptDialogs(nsIPrompt* aDialogs) +{ + mPrompt = aDialogs; + return NS_OK; +} diff --git a/mozilla/embedding/browser/gtk/src/EmbedPasswordMgr.h b/mozilla/embedding/browser/gtk/src/EmbedPasswordMgr.h new file mode 100644 index 00000000000..549bccc15ad --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/EmbedPasswordMgr.h @@ -0,0 +1,193 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* ***** 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 Mozilla Password Manager. + * + * The Initial Developer of the Original Code is + * Brian Ryner. + * Portions created by the Initial Developer are Copyright (C) 2003 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Brian Ryner + * Changes: romaxa@gmail.com (from original: mozilla/toolkit/components/passwordmgr/base/nsPasswordManager.h) + * + * 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 ***** */ + +#include "nsCPasswordManager.h" +#include "nsClassHashtable.h" +#include "nsDataHashtable.h" +#include "nsCOMPtr.h" +#include "nsIObserver.h" +#include "nsWeakReference.h" +#include "nsIFormSubmitObserver.h" +#include "nsIWebProgressListener.h" +#include "nsIDOMFocusListener.h" +#include "nsIDOMLoadListener.h" +#include "nsIStringBundle.h" +#include "nsIPrefBranch.h" +#include "nsIAuthPromptWrapper.h" +#include "nsCOMPtr.h" +#include "nsIPrompt.h" +#include "EmbedPrivate.h" +#define EMBED_PASSWORDMANAGER_DESCRIPTION "MicroB PSM Dialog Impl" +/* 360565c4-2ef3-4f6a-bab9-94cca891b2a7 */ +#define EMBED_PASSWORDMANAGER_CID \ +{0x360565c4, 0x2ef3, 0x4f6a, {0xba, 0xb9, 0x94, 0xcc, 0xa8, 0x91, 0xb2, 0xa7}} +class nsIFile; +class nsIStringBundle; +class nsIComponentManager; +class nsIContent; +class nsIDOMWindowInternal; +class nsIURI; +class nsIDOMHTMLInputElement; +struct nsModuleComponentInfo; +class EmbedPasswordMgr : public nsIPasswordManager, + public nsIPasswordManagerInternal, + public nsIObserver, + public nsIFormSubmitObserver, + public nsIWebProgressListener, + public nsIDOMFocusListener, + public nsIDOMLoadListener, + public nsSupportsWeakReference +{ +public: + class SignonDataEntry; + class SignonHashEntry; + class PasswordEntry; + EmbedPasswordMgr(); + virtual ~EmbedPasswordMgr(); + static EmbedPasswordMgr* GetInstance(); + static EmbedPasswordMgr* GetInstance(EmbedPrivate *aOwner); + nsresult Init(); + static PRBool SingleSignonEnabled(); + static NS_METHOD Register(nsIComponentManager* aCompMgr, + nsIFile* aPath, + const char* aRegistryLocation, + const char* aComponentType, + const nsModuleComponentInfo* aInfo); + static NS_METHOD Unregister(nsIComponentManager* aCompMgr, + nsIFile* aPath, + const char* aRegistryLocation, + const nsModuleComponentInfo* aInfo); + static void Shutdown(); + static void GetLocalizedString(const nsAString& key, + nsAString& aResult, + PRBool aFormatted = PR_FALSE, + const PRUnichar** aFormatArgs = nsnull, + PRUint32 aFormatArgsLength = 0); + static nsresult DecryptData(const nsAString& aData, nsAString& aPlaintext); + static nsresult EncryptData(const nsAString& aPlaintext, + nsACString& aEncrypted); + static nsresult EncryptDataUCS2(const nsAString& aPlaintext, + nsAString& aEncrypted); + nsresult InsertLogin(const char* username, const char* password = nsnull); + nsresult RemovePasswords(const char *aHostName, const char *aUserName); + nsresult RemovePasswordsByIndex(PRUint32 aIndex); + nsresult GetNumberOfSavedPassword(PRInt32 *aNum); + NS_DECL_ISUPPORTS + NS_DECL_NSIPASSWORDMANAGER + NS_DECL_NSIPASSWORDMANAGERINTERNAL + NS_DECL_NSIOBSERVER + NS_DECL_NSIWEBPROGRESSLISTENER + // nsIFormSubmitObserver + NS_IMETHOD Notify(nsIContent* aFormNode, + nsIDOMWindowInternal* aWindow, + nsIURI* aActionURL, + PRBool* aCancelSubmit); + // nsIDOMFocusListener + NS_IMETHOD Focus(nsIDOMEvent* aEvent); + NS_IMETHOD Blur(nsIDOMEvent* aEvent); + // nsIDOMEventListener + NS_IMETHOD HandleEvent(nsIDOMEvent* aEvent); + // nsIDOMLoadListener + NS_IMETHOD Load(nsIDOMEvent* aEvent); + NS_IMETHOD Unload(nsIDOMEvent* aEvent); + NS_IMETHOD BeforeUnload(nsIDOMEvent* aEvent); + NS_IMETHOD Abort(nsIDOMEvent* aEvent); + NS_IMETHOD Error(nsIDOMEvent* aEvent); +protected: + void WritePasswords(nsIFile* aPasswordFile); + void AddSignonData(const nsACString& aRealm, SignonDataEntry* aEntry); + nsresult FindPasswordEntryInternal(const SignonDataEntry* aEntry, + const nsAString& aUser, + const nsAString& aPassword, + const nsAString& aUserField, + SignonDataEntry** aResult); + nsresult FillPassword(nsIDOMEvent* aEvent = nsnull); + void AttachToInput(nsIDOMHTMLInputElement* aElement); + PRBool GetPasswordRealm(nsIURI* aURI, nsACString& aRealm); + static PLDHashOperator PR_CALLBACK FindEntryEnumerator(const nsACString& aKey, + SignonHashEntry* aEntry, + void* aUserData); + static PLDHashOperator PR_CALLBACK WriteRejectEntryEnumerator(const nsACString& aKey, + PRInt32 aEntry, + void* aUserData); + static PLDHashOperator PR_CALLBACK WriteSignonEntryEnumerator(const nsACString& aKey, + SignonHashEntry* aEntry, + void* aUserData); + static PLDHashOperator PR_CALLBACK BuildArrayEnumerator(const nsACString& aKey, + SignonHashEntry* aEntry, + void* aUserData); + static PLDHashOperator PR_CALLBACK BuildRejectArrayEnumerator(const nsACString& aKey, + PRInt32 aEntry, + void* aUserData); + static PLDHashOperator PR_CALLBACK RemoveForDOMDocumentEnumerator(nsISupports* aKey, + PRInt32& aEntry, + void* aUserData); + static void EnsureDecoderRing(); + nsClassHashtable mSignonTable; + nsDataHashtable mRejectTable; + nsDataHashtable mAutoCompleteInputs; + nsCOMPtr mSignonFile; + nsCOMPtr mPrefBranch; + nsIDOMHTMLInputElement* mAutoCompletingField; + nsIDOMHTMLInputElement* mGlobalUserField; + nsIDOMHTMLInputElement* mGlobalPassField; + SignonHashEntry * mLastSignonHashEntry; + int lastIndex; + nsCAutoString mLastHostQuery; + EmbedCommon* mCommonObject; +// nsAString mLastHostQuery; +}; +/* 1baf3398-f759-4a72-a21f-0abdc9cc9960 */ +#define NS_SINGLE_SIGNON_PROMPT_CID \ +{0x1baf3398, 0xf759, 0x4a72, {0xa2, 0x1f, 0x0a, 0xbd, 0xc9, 0xcc, 0x99, 0x60}} +// Our wrapper for username/password prompts - this allows us to prefill +// the password dialog and add a "remember this password" checkbox. +class EmbedSignonPrompt : public nsIAuthPromptWrapper +{ +public: + NS_DECL_ISUPPORTS + NS_DECL_NSIAUTHPROMPT + NS_DECL_NSIAUTHPROMPTWRAPPER + EmbedSignonPrompt() { } + virtual ~EmbedSignonPrompt() { } +protected: + void GetLocalizedString(const nsAString& aKey, nsAString& aResult); + nsCOMPtr mPrompt; +}; + diff --git a/mozilla/embedding/browser/gtk/src/EmbedPrivate.cpp b/mozilla/embedding/browser/gtk/src/EmbedPrivate.cpp index 0495da64dfc..5568f662626 100644 --- a/mozilla/embedding/browser/gtk/src/EmbedPrivate.cpp +++ b/mozilla/embedding/browser/gtk/src/EmbedPrivate.cpp @@ -1,3 +1,5 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 tw=80 et cindent: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * @@ -70,6 +72,18 @@ // for the focus hacking we need to do #include +#include +// for the clipboard actions we need to do +#include "nsIClipboardCommands.h" + +#ifdef MOZILLA_1_8_BRANCH +// for profiles +#include +#include +// for NS_APPSHELL_CID +#include +#endif + // app component registration #include #include @@ -83,6 +97,7 @@ #include "EmbedWindowCreator.h" #ifdef MOZ_WIDGET_GTK2 #include "GtkPromptService.h" +#include "nsICookiePromptService.h" #else #include "nsNativeCharsetUtils.h" #endif @@ -92,19 +107,104 @@ #include "nsIAccessible.h" #include "nsIDOMDocument.h" #endif +#include "nsIDocument.h" +#include "nsIDOMNSHTMLElement.h" +#include "nsIDOMNSHTMLInputElement.h" +#include "nsIDOMHTMLInputElement.h" +#include "nsIDOMNSHTMLTextAreaElement.h" +#include "nsIDOMHTMLTextAreaElement.h" +#include "nsIDOMNSEditableElement.h" +#include "nsIDOMNSDocument.h" +#include "nsIEditingSession.h" +#include "nsIEditor.h" +#include "nsIHTMLEditor.h" +#include "nsEditorCID.h" +#include "EmbedCertificates.h" +#include "EmbedDownloadMgr.h" +#ifdef MOZ_GTKPASSWORD_INTERFACE +#include "EmbedPasswordMgr.h" +#endif +#include "EmbedGlobalHistory.h" +#include "EmbedFilePicker.h" +static EmbedCommon* sEmbedCommon = nsnull; + +/* static */ +EmbedCommon* +EmbedCommon::GetInstance() +{ + if (!sEmbedCommon) + { + sEmbedCommon = new EmbedCommon(); + if (!sEmbedCommon) + return nsnull; + if (NS_FAILED(sEmbedCommon->Init())) + { + return nsnull; + } + } + return sEmbedCommon; +} + +/* static */ +void +EmbedCommon::DeleteInstance() +{ + if (sEmbedCommon) + { + delete sEmbedCommon; + sEmbedCommon = nsnull; + EmbedGlobalHistory::DeleteInstance(); + } +} + +nsresult +EmbedCommon::Init (void) +{ + mFormAttachCount = false; + mCommon = NULL; + return NS_OK; +}; PRUint32 EmbedPrivate::sWidgetCount = 0; - char *EmbedPrivate::sPath = nsnull; char *EmbedPrivate::sCompPath = nsnull; nsVoidArray *EmbedPrivate::sWindowList = nsnull; nsILocalFile *EmbedPrivate::sProfileDir = nsnull; nsISupports *EmbedPrivate::sProfileLock = nsnull; +#ifdef MOZILLA_1_8_BRANCH +char *EmbedPrivate::sProfileDirS = nsnull; +char *EmbedPrivate::sProfileName = nsnull; +nsIPref *EmbedPrivate::sPrefs = nsnull; +nsIAppShell *EmbedPrivate::sAppShell = nsnull; +nsProfileDirServiceProvider *EmbedPrivate::sProfileDirServiceProvider = nsnull; +static NS_DEFINE_CID(kAppShellCID, NS_APPSHELL_CID); +#endif GtkWidget *EmbedPrivate::sOffscreenWindow = 0; GtkWidget *EmbedPrivate::sOffscreenFixed = 0; nsIDirectoryServiceProvider *EmbedPrivate::sAppFileLocProvider = nsnull; +GtkMozEmbed* +EmbedCommon::GetAnyLiveWidget() +{ + if (!EmbedPrivate::sWidgetCount || !EmbedPrivate::sWindowList) + return nsnull; + + // Get the number of browser windows. + PRInt32 count = EmbedPrivate::sWindowList->Count(); + // This function doesn't get called very often at all ( only when + // creating a new window ) so it's OK to walk the list of open + // windows. + //FIXME need to choose right window + GtkMozEmbed *ret = nsnull; + for (int i = 0; i < count; i++) { + EmbedPrivate *tmpPrivate = NS_STATIC_CAST(EmbedPrivate *, + EmbedPrivate::sWindowList->ElementAt(i)); + ret = tmpPrivate->mOwningWidget; + } + return ret; +} + class GTKEmbedDirectoryProvider : public nsIDirectoryServiceProvider2 { public: @@ -163,22 +263,121 @@ GTKEmbedDirectoryProvider::GetFiles(const char *aKey, return dp2->GetFiles(aKey, aResult); } -#define NS_PROMPTSERVICE_CID \ - {0x95611356, 0xf583, 0x46f5, {0x81, 0xff, 0x4b, 0x3e, 0x01, 0x62, 0xc6, 0x19}} - #ifdef MOZ_WIDGET_GTK2 NS_GENERIC_FACTORY_CONSTRUCTOR(GtkPromptService) +NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(EmbedCertificates, Init) +NS_GENERIC_FACTORY_CONSTRUCTOR(EmbedDownloadMgr) +#ifdef MOZ_GTKPASSWORD_INTERFACE +NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(EmbedPasswordMgr, EmbedPasswordMgr::GetInstance) +NS_GENERIC_FACTORY_CONSTRUCTOR(EmbedSignonPrompt) #endif - -#ifdef MOZ_WIDGET_GTK2 +NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(EmbedGlobalHistory, EmbedGlobalHistory::GetInstance) +NS_GENERIC_FACTORY_CONSTRUCTOR(EmbedFilePicker) static const nsModuleComponentInfo defaultAppComps[] = { +#ifdef MOZ_GTKPASSWORD_INTERFACE + { + EMBED_PASSWORDMANAGER_DESCRIPTION, + EMBED_PASSWORDMANAGER_CID, + NS_PASSWORDMANAGER_CONTRACTID, + EmbedPasswordMgrConstructor, + EmbedPasswordMgr::Register, + EmbedPasswordMgr::Unregister + }, + { + EMBED_PASSWORDMANAGER_DESCRIPTION, + NS_SINGLE_SIGNON_PROMPT_CID, + "@mozilla.org/wallet/single-sign-on-prompt;1", + EmbedSignonPromptConstructor + }, +#endif + { "Prompt Service", + NS_PROMPTSERVICE_CID, + NS_COOKIEPROMPTSERVICE_CONTRACTID, + GtkPromptServiceConstructor + }, { "Prompt Service", NS_PROMPTSERVICE_CID, "@mozilla.org/embedcomp/prompt-service;1", GtkPromptServiceConstructor - } + }, + { + EMBED_CERTIFICATES_DESCRIPTION, + EMBED_CERTIFICATES_CID, + NS_TOKENPASSWORDSDIALOG_CONTRACTID, + EmbedCertificatesConstructor + }, + { + EMBED_CERTIFICATES_DESCRIPTION, + EMBED_CERTIFICATES_CID, + NS_BADCERTLISTENER_CONTRACTID, + EmbedCertificatesConstructor + }, +#ifdef BAD_CERT_LISTENER2 + { + EMBED_CERTIFICATES_DESCRIPTION, + EMBED_CERTIFICATES_CID, + NS_BADCERTLISTENER2_CONTRACTID, + EmbedCertificatesConstructor + }, +#endif + { + EMBED_CERTIFICATES_DESCRIPTION, + EMBED_CERTIFICATES_CID, + NS_CERTIFICATEDIALOGS_CONTRACTID, + EmbedCertificatesConstructor + }, + { + EMBED_CERTIFICATES_DESCRIPTION, + EMBED_CERTIFICATES_CID, + NS_CLIENTAUTHDIALOGS_CONTRACTID, + EmbedCertificatesConstructor + }, + { + EMBED_CERTIFICATES_DESCRIPTION, + EMBED_CERTIFICATES_CID, + NS_CERTPICKDIALOGS_CONTRACTID, + EmbedCertificatesConstructor + }, + { + EMBED_CERTIFICATES_DESCRIPTION, + EMBED_CERTIFICATES_CID, + NS_TOKENDIALOGS_CONTRACTID, + EmbedCertificatesConstructor + }, + { + EMBED_CERTIFICATES_DESCRIPTION, + EMBED_CERTIFICATES_CID, + NS_DOMCRYPTODIALOGS_CONTRACTID, + EmbedCertificatesConstructor + }, + { + EMBED_CERTIFICATES_DESCRIPTION, + EMBED_CERTIFICATES_CID, + NS_GENERATINGKEYPAIRINFODIALOGS_CONTRACTID, + EmbedCertificatesConstructor + }, +// content handler component info + { + EMBED_DOWNLOADMGR_DESCRIPTION, + EMBED_DOWNLOADMGR_CID, + NS_IHELPERAPPLAUNCHERDLG_CONTRACTID, + EmbedDownloadMgrConstructor + }, + // global history + { + "Global History", + NS_EMBEDGLOBALHISTORY_CID, + NS_GLOBALHISTORY2_CONTRACTID, + EmbedGlobalHistoryConstructor + }, + { + EMBED_FILEPICKER_CLASSNAME, + EMBED_FILEPICKER_CID, + EMBED_FILEPICKER_CONTRACTID, + EmbedFilePickerConstructor + }, }; const nsModuleComponentInfo *EmbedPrivate::sAppComps = defaultAppComps; @@ -201,10 +400,14 @@ EmbedPrivate::EmbedPrivate(void) mChromeMask = nsIWebBrowserChrome::CHROME_ALL; mIsChrome = PR_FALSE; mChromeLoaded = PR_FALSE; + mLoadFinished = PR_TRUE; mListenersAttached = PR_FALSE; mMozWindowWidget = 0; mIsDestroyed = PR_FALSE; - + mDoResizeEmbed = PR_TRUE; + mOpenBlock = PR_FALSE; + mNeedFav = PR_FALSE; + PushStartup(); if (!sWindowList) { sWindowList = new nsVoidArray(); @@ -240,22 +443,21 @@ EmbedPrivate::Init(GtkMozEmbed *aOwningWidget) // will be destroyed when we go out of scope. mProgress = new EmbedProgress(); mProgressGuard = NS_STATIC_CAST(nsIWebProgressListener *, - mProgress); + mProgress); mProgress->Init(this); // Create our content listener object, initialize it and attach it. // It is assumed that this will be destroyed when we go out of // scope. mContentListener = new EmbedContentListener(); - mContentListenerGuard = NS_STATIC_CAST(nsISupports*, NS_STATIC_CAST(nsIURIContentListener*, mContentListener)); + mContentListenerGuard = NS_ISUPPORTS_CAST(nsIURIContentListener*, mContentListener); mContentListener->Init(this); // Create our key listener object and initialize it. It is assumed // that this will be destroyed before we go out of scope. mEventListener = new EmbedEventListener(); mEventListenerGuard = - NS_STATIC_CAST(nsISupports *, NS_STATIC_CAST(nsIDOMKeyListener *, - mEventListener)); + NS_ISUPPORTS_CAST(nsIDOMKeyListener *, mEventListener); mEventListener->Init(this); // has the window creator service been set up? @@ -267,7 +469,7 @@ EmbedPrivate::Init(GtkMozEmbed *aOwningWidget) initialized = PR_TRUE; // create our local object - EmbedWindowCreator *creator = new EmbedWindowCreator(); + EmbedWindowCreator *creator = new EmbedWindowCreator(&mOpenBlock); nsCOMPtr windowCreator; windowCreator = NS_STATIC_CAST(nsIWindowCreator *, creator); @@ -307,7 +509,8 @@ EmbedPrivate::Realize(PRBool *aAlreadyRealized) // to use it. We need to do this before we create the web browser // window. mSessionHistory = do_CreateInstance(NS_SHISTORY_CONTRACTID); - mNavigation->SetSessionHistory(mSessionHistory); + if (mSessionHistory) + mNavigation->SetSessionHistory(mSessionHistory); // create the window mWindow->CreateWindow(); @@ -317,8 +520,9 @@ EmbedPrivate::Realize(PRBool *aAlreadyRealized) supportsWeak = do_QueryInterface(mProgressGuard); nsCOMPtr weakRef; supportsWeak->GetWeakReference(getter_AddRefs(weakRef)); - webBrowser->AddWebBrowserListener(weakRef, - NS_GET_IID(nsIWebProgressListener)); + webBrowser->AddWebBrowserListener( + weakRef, + NS_GET_IID(nsIWebProgressListener)); // set ourselves as the parent uri content listener nsCOMPtr uriListener; @@ -331,7 +535,7 @@ EmbedPrivate::Realize(PRBool *aAlreadyRealized) // get the native drawing area GdkWindow *tmp_window = NS_STATIC_CAST(GdkWindow *, - mozWidget->GetNativeData(NS_NATIVE_WINDOW)); + mozWidget->GetNativeData(NS_NATIVE_WINDOW)); // and, thanks to superwin we actually need the parent of that. tmp_window = gdk_window_get_parent(tmp_window); // save the widget ID - it should be the mozarea of the window. @@ -376,12 +580,39 @@ EmbedPrivate::Hide(void) baseWindow->SetVisibility(PR_FALSE); } +#include "nsIDOMScreen.h" void EmbedPrivate::Resize(PRUint32 aWidth, PRUint32 aHeight) { - mWindow->SetDimensions(nsIEmbeddingSiteWindow::DIM_FLAGS_POSITION | - nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_INNER, - 0, 0, aWidth, aHeight); + if (mDoResizeEmbed) { + mWindow->SetDimensions(nsIEmbeddingSiteWindow::DIM_FLAGS_POSITION | + nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_INNER, + 0, 0, aWidth, aHeight); + } else { + PRInt32 X, Y, W, H; + mWindow->GetDimensions( nsIEmbeddingSiteWindow::DIM_FLAGS_POSITION, &X, &Y, &W, &H); + if (Y < 0) { + mWindow->SetDimensions( nsIEmbeddingSiteWindow::DIM_FLAGS_POSITION, 0, 0, nsnull, nsnull); + return; + } + EmbedContextMenuInfo * ctx_menu = mEventListener->GetContextInfo(); + gint x, y, width, height, depth; + gdk_window_get_geometry(gtk_widget_get_parent_window(GTK_WIDGET(mOwningWidget)), + &x, + &y, + &width, + &height, + &depth); + if (ctx_menu) { + if (height < ctx_menu->mFormRect.y + ctx_menu->mFormRect.height) { + PRInt32 sub = ctx_menu->mFormRect.y - height + ctx_menu->mFormRect.height; + PRInt32 diff = ctx_menu->mFormRect.y - sub; + printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!height: %i, Form.y: %i, Form.Height: %i, sub: %i, diff: %i\n", height, ctx_menu->mFormRect.y, ctx_menu->mFormRect.height, sub, diff); + if (sub > 0 && diff >= 0) + mWindow->SetDimensions( nsIEmbeddingSiteWindow::DIM_FLAGS_POSITION, 0, -sub, nsnull, nsnull); + } + } + } } void @@ -402,8 +633,9 @@ EmbedPrivate::Destroy(void) supportsWeak = do_QueryInterface(mProgressGuard); nsCOMPtr weakRef; supportsWeak->GetWeakReference(getter_AddRefs(weakRef)); - webBrowser->RemoveWebBrowserListener(weakRef, - NS_GET_IID(nsIWebProgressListener)); + webBrowser->RemoveWebBrowserListener( + weakRef, + NS_GET_IID(nsIWebProgressListener)); weakRef = nsnull; supportsWeak = nsnull; @@ -434,6 +666,7 @@ EmbedPrivate::Destroy(void) mOwningWidget = nsnull; mMozWindowWidget = 0; + mNeedFav = PR_FALSE; } void @@ -446,7 +679,11 @@ EmbedPrivate::SetURI(const char *aURI) #endif #ifdef MOZ_WIDGET_GTK2 +#ifdef MOZILLA_INTERNAL_API CopyUTF8toUTF16(aURI, mURI); +#else + mURI.AssignLiteral(aURI); +#endif #endif } @@ -512,9 +749,16 @@ EmbedPrivate::ApplyChromeMask() void EmbedPrivate::SetChromeMask(PRUint32 aChromeMask) { - mChromeMask = aChromeMask; + if (aChromeMask & GTK_MOZ_EMBED_FLAG_WINDOWRESIZEON) { + mDoResizeEmbed = PR_TRUE; + mChromeMask = aChromeMask; + } else { + mDoResizeEmbed = PR_FALSE; + return; + } + mChromeMask = aChromeMask; - ApplyChromeMask(); + ApplyChromeMask(); } @@ -528,15 +772,27 @@ EmbedPrivate::PushStartup(void) // if this is the first widget, fire up xpcom if (sWidgetCount == 1) { nsresult rv; - nsCOMPtr binDir; - if (sCompPath) { - rv = NS_NewNativeLocalFile(nsDependentCString(sCompPath), 1, getter_AddRefs(binDir)); + nsCOMPtr compDir; + if (EmbedPrivate::sCompPath) { + rv = NS_NewNativeLocalFile(nsDependentCString(EmbedPrivate::sCompPath), 1, getter_AddRefs(binDir)); + rv = NS_NewNativeLocalFile(nsDependentCString(EmbedPrivate::sCompPath), 1, getter_AddRefs(compDir)); if (NS_FAILED(rv)) - return; - } + return; + PRBool exists; + rv = compDir->AppendNative(nsDependentCString("components")); + compDir->Exists(&exists); + if (!exists) + rv = compDir->Create(nsIFile::DIRECTORY_TYPE, 0700); + if (NS_FAILED(rv)) + return; + } else + NS_ASSERTION(EmbedPrivate::sCompPath, "Warning: Failed to init Component Path.\n"); + +#ifndef MOZILLA_1_8_BRANCH const char *grePath = sPath; + NS_ASSERTION(grePath, "Warning: Failed to init grePath.\n"); if (!grePath) grePath = getenv("MOZILLA_FIVE_HOME"); @@ -557,8 +813,35 @@ EmbedPrivate::PushStartup(void) if (NS_FAILED(rv)) return; - if (sProfileDir) + if (EmbedPrivate::sProfileDir) { XRE_NotifyProfile(); + } +#else + + rv = NS_InitEmbedding(binDir, sAppFileLocProvider); + if (NS_FAILED(rv)) + return; + + // we no longer need a reference to the DirectoryServiceProvider + if (sAppFileLocProvider) { + NS_RELEASE(sAppFileLocProvider); + sAppFileLocProvider = nsnull; + } + + rv = StartupProfile(); + NS_WARN_IF_FALSE(NS_SUCCEEDED(rv), "Warning: Failed to start up profiles.\n"); + + nsCOMPtr appShell; + appShell = do_CreateInstance(kAppShellCID); + if (!appShell) { + NS_WARNING("Failed to create appshell in EmbedPrivate::PushStartup!\n"); + return; + } + sAppShell = appShell.get(); + NS_ADDREF(sAppShell); + sAppShell->Create(0, nsnull); + sAppShell->Spinup(); +#endif rv = RegisterAppComponents(); NS_ASSERTION(NS_SUCCEEDED(rv), "Warning: Failed to register app components.\n"); @@ -571,18 +854,33 @@ EmbedPrivate::PopStartup(void) { sWidgetCount--; if (sWidgetCount == 0) { - // destroy the offscreen window DestroyOffscreenWindow(); + +#ifdef MOZILLA_1_8_BRANCH + // shut down the profiles + ShutdownProfile(); + + if (sAppShell) { + // Shutdown the appshell service. + sAppShell->Spindown(); + NS_RELEASE(sAppShell); + sAppShell = 0; + } + + // shut down XPCOM/Embedding + NS_TermEmbedding(); +#endif // we no longer need a reference to the DirectoryServiceProvider - if (sAppFileLocProvider) { - NS_RELEASE(sAppFileLocProvider); - sAppFileLocProvider = nsnull; + if (EmbedPrivate::sAppFileLocProvider) { + NS_RELEASE(EmbedPrivate::sAppFileLocProvider); + EmbedPrivate::sAppFileLocProvider = nsnull; } // shut down XPCOM/Embedding XRE_TermEmbedding(); + EmbedGlobalHistory::DeleteInstance(); } } @@ -601,12 +899,12 @@ void EmbedPrivate::SetPath(const char *aPath) void EmbedPrivate::SetCompPath(const char *aPath) { - if (sCompPath) - free(sCompPath); + if (EmbedPrivate::sCompPath) + free(EmbedPrivate::sCompPath); if (aPath) - sCompPath = strdup(aPath); + EmbedPrivate::sCompPath = strdup(aPath); else - sCompPath = nsnull; + EmbedPrivate::sCompPath = nsnull; } /* static */ @@ -622,48 +920,71 @@ EmbedPrivate::SetAppComponents(const nsModuleComponentInfo* aComps, void EmbedPrivate::SetProfilePath(const char *aDir, const char *aName) { - if (sProfileDir) { + if (EmbedPrivate::sProfileDir) { if (sWidgetCount) { NS_ERROR("Cannot change profile directory during run."); return; } - NS_RELEASE(sProfileDir); - NS_RELEASE(sProfileLock); + NS_RELEASE(EmbedPrivate::sProfileDir); + NS_RELEASE(EmbedPrivate::sProfileLock); } nsresult rv = - NS_NewNativeLocalFile(nsDependentCString(aDir), PR_TRUE, &sProfileDir); + NS_NewNativeLocalFile(nsDependentCString(aDir), PR_TRUE, &EmbedPrivate::sProfileDir); if (NS_SUCCEEDED(rv) && aName) - rv = sProfileDir->AppendNative(nsDependentCString(aName)); - - if (NS_SUCCEEDED(rv)) - rv = XRE_LockProfileDirectory(sProfileDir, &sProfileLock); - + rv = EmbedPrivate::sProfileDir->AppendNative(nsDependentCString(aName)); + if (NS_SUCCEEDED(rv)) { + PRBool exists; + rv = EmbedPrivate::sProfileDir->Exists(&exists); + if (!exists) { + rv = EmbedPrivate::sProfileDir->Create(nsIFile::DIRECTORY_TYPE, 0700); + } +#ifndef MOZILLA_1_8_BRANCH + rv = XRE_LockProfileDirectory(EmbedPrivate::sProfileDir, &EmbedPrivate::sProfileLock); +#endif + } +#ifndef MOZILLA_1_8_BRANCH if (NS_SUCCEEDED(rv)) { if (sWidgetCount) XRE_NotifyProfile(); return; - } - + } NS_WARNING("Failed to lock profile."); // Failed - NS_IF_RELEASE(sProfileDir); - NS_IF_RELEASE(sProfileLock); + NS_IF_RELEASE(EmbedPrivate::sProfileDir); + NS_IF_RELEASE(EmbedPrivate::sProfileLock); +#else + if (sProfileDir) { + nsMemory::Free(sProfileDirS); + sProfileDir = nsnull; + } + + if (sProfileName) { + nsMemory::Free(sProfileName); + sProfileName = nsnull; + } + + if (aDir) + sProfileDirS = (char *)nsMemory::Clone(aDir, strlen(aDir) + 1); + + if (aName) + sProfileName = (char *)nsMemory::Clone(aName, strlen(aName) + 1); +#endif } void EmbedPrivate::SetDirectoryServiceProvider(nsIDirectoryServiceProvider * appFileLocProvider) { - if (sAppFileLocProvider) - NS_RELEASE(sAppFileLocProvider); + if (EmbedPrivate::sAppFileLocProvider) + NS_RELEASE(EmbedPrivate::sAppFileLocProvider); if (appFileLocProvider) { - sAppFileLocProvider = appFileLocProvider; - NS_ADDREF(sAppFileLocProvider); + EmbedPrivate::sAppFileLocProvider = appFileLocProvider; + NS_ADDREF(EmbedPrivate::sAppFileLocProvider); } } @@ -727,10 +1048,12 @@ EmbedPrivate::FindPrivateForBrowser(nsIWebBrowserChrome *aBrowser) // windows. for (int i = 0; i < count; i++) { EmbedPrivate *tmpPrivate = NS_STATIC_CAST(EmbedPrivate *, - sWindowList->ElementAt(i)); + sWindowList->ElementAt(i)); // get the browser object for that window - nsIWebBrowserChrome *chrome = NS_STATIC_CAST(nsIWebBrowserChrome *, - tmpPrivate->mWindow); + nsIWebBrowserChrome *chrome = + NS_STATIC_CAST( + nsIWebBrowserChrome *, + tmpPrivate->mWindow); if (chrome == aBrowser) return tmpPrivate; } @@ -865,11 +1188,11 @@ EmbedPrivate::ChildFocusOut(void) nsCOMPtr webBrowser; rv = mWindow->GetWebBrowser(getter_AddRefs(webBrowser)); if (NS_FAILED(rv)) - return; + return; nsCOMPtr webBrowserFocus(do_QueryInterface(webBrowser)); if (!webBrowserFocus) - return; + return; webBrowserFocus->Deactivate(); #endif /* MOZ_WIDGET_GTK2 */ @@ -918,31 +1241,47 @@ EmbedPrivate::AttachListeners(void) nsIDOMEventListener *eventListener = NS_STATIC_CAST(nsIDOMEventListener *, - NS_STATIC_CAST(nsIDOMKeyListener *, mEventListener)); + NS_STATIC_CAST(nsIDOMKeyListener *, mEventListener)); // add the key listener nsresult rv; - rv = mEventReceiver->AddEventListenerByIID(eventListener, - NS_GET_IID(nsIDOMKeyListener)); + rv = mEventReceiver->AddEventListenerByIID( + eventListener, + NS_GET_IID(nsIDOMKeyListener)); if (NS_FAILED(rv)) { NS_WARNING("Failed to add key listener\n"); return; } - rv = mEventReceiver->AddEventListenerByIID(eventListener, - NS_GET_IID(nsIDOMMouseListener)); + rv = mEventReceiver->AddEventListenerByIID( + eventListener, + NS_GET_IID(nsIDOMMouseListener)); if (NS_FAILED(rv)) { NS_WARNING("Failed to add mouse listener\n"); return; } - rv = mEventReceiver->AddEventListenerByIID(eventListener, - NS_GET_IID(nsIDOMUIListener)); + rv = mEventReceiver->AddEventListenerByIID( + eventListener, + NS_GET_IID(nsIDOMUIListener)); if (NS_FAILED(rv)) { NS_WARNING("Failed to add UI listener\n"); return; } + rv = mEventReceiver->AddEventListenerByIID( + eventListener, + NS_GET_IID(nsIDOMMouseMotionListener)); + if (NS_FAILED(rv)) { + NS_WARNING("Failed to add Mouse Motion listener\n"); + return; + } + rv = mEventReceiver->AddEventListener(NS_LITERAL_STRING("focus"), eventListener, PR_TRUE); + rv = mEventReceiver->AddEventListener(NS_LITERAL_STRING("blur"), eventListener, PR_TRUE); + if (NS_FAILED(rv)) { + NS_WARNING("Failed to add Mouse Motion listener\n"); + return; + } // ok, all set. mListenersAttached = PR_TRUE; } @@ -955,52 +1294,89 @@ EmbedPrivate::DetachListeners(void) nsIDOMEventListener *eventListener = NS_STATIC_CAST(nsIDOMEventListener *, - NS_STATIC_CAST(nsIDOMKeyListener *, mEventListener)); + NS_STATIC_CAST(nsIDOMKeyListener *, mEventListener)); nsresult rv; - rv = mEventReceiver->RemoveEventListenerByIID(eventListener, - NS_GET_IID(nsIDOMKeyListener)); + rv = mEventReceiver->RemoveEventListenerByIID( + eventListener, + NS_GET_IID(nsIDOMKeyListener)); if (NS_FAILED(rv)) { NS_WARNING("Failed to remove key listener\n"); return; } rv = - mEventReceiver->RemoveEventListenerByIID(eventListener, - NS_GET_IID(nsIDOMMouseListener)); + mEventReceiver->RemoveEventListenerByIID( + eventListener, + NS_GET_IID(nsIDOMMouseListener)); if (NS_FAILED(rv)) { NS_WARNING("Failed to remove mouse listener\n"); return; } - rv = mEventReceiver->RemoveEventListenerByIID(eventListener, - NS_GET_IID(nsIDOMUIListener)); + rv = mEventReceiver->RemoveEventListenerByIID( + eventListener, + NS_GET_IID(nsIDOMUIListener)); if (NS_FAILED(rv)) { NS_WARNING("Failed to remove UI listener\n"); return; } + rv = mEventReceiver->RemoveEventListenerByIID( + eventListener, + NS_GET_IID(nsIDOMMouseMotionListener)); + if (NS_FAILED(rv)) { + NS_WARNING("Failed to remove Mouse Motion listener\n"); + return; + } + rv = mEventReceiver->RemoveEventListener(NS_LITERAL_STRING("focus"), eventListener, PR_TRUE); + rv = mEventReceiver->RemoveEventListener(NS_LITERAL_STRING("blur"), eventListener, PR_TRUE); mListenersAttached = PR_FALSE; } +nsresult +EmbedPrivate::GetFocusController(nsIFocusController * *controller) +{ + nsresult rv; + if (!controller) { + return NS_ERROR_FAILURE; + } + nsCOMPtr piWin; + rv = GetPIDOMWindow(getter_AddRefs(piWin)); + if (!piWin || NS_FAILED(rv)) { + return NS_ERROR_FAILURE; + } + nsIFocusController *focusController = piWin->GetRootFocusController(); + if (!focusController) + return NS_ERROR_FAILURE; + + *controller = focusController; + return NS_OK; +} + nsresult EmbedPrivate::GetPIDOMWindow(nsPIDOMWindow **aPIWin) { *aPIWin = nsnull; + nsresult rv; // get the web browser nsCOMPtr webBrowser; - mWindow->GetWebBrowser(getter_AddRefs(webBrowser)); + rv = mWindow->GetWebBrowser(getter_AddRefs(webBrowser)); + if (NS_FAILED(rv) || !webBrowser) + return NS_ERROR_FAILURE; // get the content DOM window for that web browser nsCOMPtr domWindow; - webBrowser->GetContentDOMWindow(getter_AddRefs(domWindow)); - if (!domWindow) + rv = webBrowser->GetContentDOMWindow(getter_AddRefs(domWindow)); + if (NS_FAILED(rv) || !domWindow) return NS_ERROR_FAILURE; // get the private DOM window - nsCOMPtr domWindowPrivate = do_QueryInterface(domWindow); + nsCOMPtr domWindowPrivate = do_QueryInterface(domWindow, &rv); // and the root window for that DOM window + if (NS_FAILED(rv) || !domWindowPrivate) + return NS_ERROR_FAILURE; *aPIWin = domWindowPrivate->GetPrivateRoot(); if (*aPIWin) { @@ -1042,6 +1418,62 @@ EmbedPrivate::GetAtkObjectForCurrentDocument() } #endif /* MOZ_ACCESSIBILITY_ATK */ +#ifdef MOZILLA_1_8_BRANCH +/* static */ +nsresult +EmbedPrivate::StartupProfile(void) +{ + // initialize profiles + if (sProfileDirS && sProfileName) { + nsresult rv; + nsCOMPtr profileDir; + NS_NewNativeLocalFile(nsDependentCString(sProfileDirS), PR_TRUE, + getter_AddRefs(profileDir)); + if (!profileDir) + return NS_ERROR_FAILURE; + rv = profileDir->AppendNative(nsDependentCString(sProfileName)); + if (NS_FAILED(rv)) + return NS_ERROR_FAILURE; + + nsCOMPtr locProvider; + NS_NewProfileDirServiceProvider(PR_TRUE, getter_AddRefs(locProvider)); + if (!locProvider) + return NS_ERROR_FAILURE; + rv = locProvider->Register(); + if (NS_FAILED(rv)) + return rv; + rv = locProvider->SetProfileDir(profileDir); + if (NS_FAILED(rv)) + return rv; + // Keep a ref so we can shut it down. + NS_ADDREF(sProfileDirServiceProvider = locProvider); + // get prefs + nsCOMPtr pref; + pref = do_GetService(NS_PREF_CONTRACTID); + if (!pref) + return NS_ERROR_FAILURE; + sPrefs = pref.get(); + NS_ADDREF(sPrefs); + } + return NS_OK; +} + +/* static */ +void +EmbedPrivate::ShutdownProfile(void) +{ + if (sProfileDirServiceProvider) { + sProfileDirServiceProvider->Shutdown(); + NS_RELEASE(sProfileDirServiceProvider); + sProfileDirServiceProvider = 0; + } + if (sPrefs) { + NS_RELEASE(sPrefs); + sPrefs = 0; + } +} +#endif + /* static */ nsresult EmbedPrivate::RegisterAppComponents(void) @@ -1100,3 +1532,373 @@ EmbedPrivate::DestroyOffscreenWindow(void) gtk_widget_destroy(sOffscreenWindow); sOffscreenWindow = 0; } + +/* static */ +PRBool +EmbedPrivate::ClipBoardAction(GtkMozEmbedClipboard type) +{ + nsresult rv = NS_OK; + PRBool canDo = PR_TRUE; + nsCOMPtr webBrowser; + rv = mWindow->GetWebBrowser(getter_AddRefs(webBrowser)); + if (NS_FAILED(rv)) + return PR_FALSE; + nsCOMPtr clipboard (do_GetInterface(webBrowser)); + if (!clipboard) + return PR_FALSE; + switch (type) { + case GTK_MOZ_EMBED_SELECT_ALL: + { + rv = clipboard->SelectAll(); + break; + } + case GTK_MOZ_EMBED_CAN_SELECT: + { + //FIXME + break; + } + case GTK_MOZ_EMBED_CUT: + { + rv = clipboard->CutSelection(); + break; + } + case GTK_MOZ_EMBED_COPY: + { + rv = clipboard->CopySelection(); + break; + } + case GTK_MOZ_EMBED_PASTE: + { + rv = clipboard->Paste(); + break; + } + case GTK_MOZ_EMBED_CAN_CUT: + { + rv = clipboard->CanCutSelection (&canDo); + break; + } + case GTK_MOZ_EMBED_CAN_PASTE: + { + rv = clipboard->CanPaste (&canDo); + break; + } + case GTK_MOZ_EMBED_CAN_COPY: + { + rv = clipboard->CanCopySelection (&canDo); + break; + } + default: + break; + } + if (NS_FAILED(rv)) + return PR_FALSE; + return canDo; +} + +char* +EmbedPrivate::GetEncoding () +{ + char *encoding; + nsCOMPtr webBrowser; + mWindow->GetWebBrowser(getter_AddRefs(webBrowser)); + nsCOMPtr docCharset = do_GetInterface (webBrowser); + docCharset->GetCharset (&encoding); + return encoding; +} + +nsresult +EmbedPrivate::SetEncoding (const char *encoding) +{ + nsCOMPtr webBrowser; + mWindow->GetWebBrowser(getter_AddRefs(webBrowser)); + nsCOMPtr contentViewer; + GetContentViewer (webBrowser, getter_AddRefs(contentViewer)); + NS_ENSURE_TRUE (contentViewer, NS_ERROR_FAILURE); + nsCOMPtr mDocViewer = do_QueryInterface(contentViewer); + NS_ENSURE_TRUE (mDocViewer, NS_ERROR_FAILURE); + nsAutoString mCharset; +#ifdef MOZILLA_INTERNAL_API + mCharset.AssignWithConversion (encoding); +#else + mCharset.AssignLiteral (encoding); +#endif + return mDocViewer->SetForceCharacterSet(NS_LossyConvertUTF16toASCII(ToNewUnicode(mCharset))); +} + +PRBool +EmbedPrivate::FindText(const char *exp, PRBool reverse, + PRBool whole_word, PRBool case_sensitive, + PRBool restart) +{ + PRUnichar *text; + nsresult rv; + nsCOMPtr webBrowser; + mWindow->GetWebBrowser(getter_AddRefs(webBrowser)); + nsCOMPtr finder(do_GetInterface (webBrowser)); + g_return_val_if_fail( finder != NULL, FALSE); + text = LocaleToUnicode (exp); + finder->SetSearchString (text); + finder->SetFindBackwards (reverse); + finder->SetWrapFind(TRUE); //DoWrapFind + finder->SetEntireWord (whole_word); + finder->SetSearchFrames(TRUE); //SearchInFrames + finder->SetMatchCase (case_sensitive); + rv = finder->FindNext (&restart); + NS_Free(text); + return ( !rv ); +} + +nsresult +EmbedPrivate::ScrollToSelectedNode(nsIDOMNode *aDOMNode) +{ + nsresult rv; + if (aDOMNode) { + nsCOMPtr nodeElement = do_QueryInterface(aDOMNode, &rv); + if (NS_SUCCEEDED(rv) && nodeElement) { + nodeElement->ScrollIntoView(PR_FALSE); + } + } + return rv; +} + +nsresult +EmbedPrivate::InsertTextToNode(nsIDOMNode *aDOMNode, const char *string) +{ + nsIDOMNode *targetNode = nsnull; + nsresult rv; + + EmbedContextMenuInfo * ctx_menu = mEventListener->GetContextInfo(); + if (ctx_menu && ctx_menu->mEventNode && (ctx_menu->mEmbedCtxType & GTK_MOZ_EMBED_CTX_INPUT)) { + targetNode = ctx_menu->mEventNode; + } + + if (!targetNode) + return NS_ERROR_FAILURE; + + nsString nodeName; + targetNode->GetNodeName(nodeName); + PRInt32 selectionStart = 0, selectionEnd = 0, textLength = 0; + nsString buffer; + + if (ctx_menu->mCtxFormType == NS_FORM_TEXTAREA) { + nsCOMPtr input; + input = do_QueryInterface(targetNode, &rv); + NS_ENSURE_SUCCESS(rv, rv); + PRBool rdonly = PR_FALSE; + input->GetReadOnly(&rdonly); + if (rdonly) + return NS_ERROR_FAILURE; + + nsCOMPtr nsinput; + nsinput = do_QueryInterface(targetNode, &rv); + NS_ENSURE_SUCCESS(rv, rv); + nsinput->GetTextLength(&textLength); + if (textLength > 0) { + NS_ENSURE_SUCCESS(rv, rv); + rv = input->GetValue(buffer); + nsinput->GetSelectionStart (&selectionStart); + nsinput->GetSelectionEnd (&selectionEnd); + + if (selectionStart != selectionEnd) + buffer.Cut(selectionStart, selectionEnd - selectionStart); +#ifdef MOZILLA_INTERNAL_API + buffer.Insert(UTF8ToNewUnicode(nsDependentCString(string)), selectionStart); +#else + nsString nsstr; + nsstr.AssignLiteral(string); + buffer.Insert(nsstr, selectionStart); +#endif + } else { +#ifdef MOZILLA_INTERNAL_API + CopyUTF8toUTF16(string, buffer); +#else + buffer.AssignLiteral(string); +#endif + } + + input->SetValue(buffer); + int len = strlen(string); + nsinput->SetSelectionRange(selectionStart + len, selectionStart + len); + } + else if (ctx_menu->mCtxFormType) { + nsCOMPtr input; + input = do_QueryInterface(targetNode, &rv); + NS_ENSURE_SUCCESS(rv, rv); + PRBool rdonly = PR_FALSE; + input->GetReadOnly(&rdonly); + if (rdonly) + return NS_ERROR_FAILURE; + + nsCOMPtr nsinput; + nsinput = do_QueryInterface(targetNode, &rv); + NS_ENSURE_SUCCESS(rv, rv); + nsinput->GetTextLength(&textLength); + + if (textLength > 0) { + NS_ENSURE_SUCCESS(rv, rv); + rv = input->GetValue(buffer); + nsinput->GetSelectionStart (&selectionStart); + nsinput->GetSelectionEnd (&selectionEnd); + + if (selectionStart != selectionEnd) { + buffer.Cut(selectionStart, selectionEnd - selectionStart); + } +#ifdef MOZILLA_INTERNAL_API + buffer.Insert(UTF8ToNewUnicode(nsDependentCString(string)), selectionStart); +#else + nsString nsstr; + buffer.Insert(nsstr, selectionStart); +#endif + } else { +#ifdef MOZILLA_INTERNAL_API + CopyUTF8toUTF16(string, buffer); +#else + buffer.AssignLiteral(string); +#endif + } + + input->SetValue(buffer); + int len = strlen(string); + nsinput->SetSelectionRange(selectionStart + len, selectionStart + len); + } + else { + nsIWebBrowser *retval = nsnull; + mWindow->GetWebBrowser(&retval); + nsCOMPtr editingSession = do_GetInterface(retval); + if (!editingSession) + return NS_ERROR_FAILURE; + + nsCOMPtr theEditor; + nsCOMPtr piWin; + nsCOMPtr doc = do_QueryInterface(ctx_menu->mCtxDocument); + if (!doc) + return NS_OK; + piWin = doc->GetWindow(); + editingSession->GetEditorForWindow(piWin, getter_AddRefs(theEditor)); + if (!theEditor) { + return NS_ERROR_FAILURE; + } + + nsCOMPtr htmlEditor; + htmlEditor = do_QueryInterface(theEditor, &rv); + if (!htmlEditor) + return NS_ERROR_FAILURE; + +#ifdef MOZILLA_INTERNAL_API + CopyUTF8toUTF16(string, buffer); +#else + buffer.AssignLiteral(string); +#endif + htmlEditor->InsertHTML(buffer); + } + return NS_OK; +} + +#define GTK_MOZ_EMBED_DIFFERENT_ZOOM_LEVEL 0 +#define GTK_MOZ_EMBED_EQUAL_ZOOM_LEVEL 1 + +nsresult +EmbedPrivate::GetZoom (gint *zoomLevel, gint *compareFramesZoomLevel) { + // setting default zoom value. + *zoomLevel = 100; + nsCOMPtr webBrowser; + nsresult rv = mWindow->GetWebBrowser(getter_AddRefs(webBrowser)); + if (NS_FAILED(rv)) return NS_ERROR_FAILURE; + // get main dom window + nsCOMPtr DOMWindow; + rv = webBrowser->GetContentDOMWindow(getter_AddRefs(DOMWindow)); + if (NS_FAILED(rv)) return NS_ERROR_FAILURE; + // get window/document zoom + float zoomLevelFloat; + rv = DOMWindow->GetTextZoom(&zoomLevelFloat); + if (NS_FAILED(rv)) return NS_ERROR_FAILURE; + *zoomLevel = (int)round (zoomLevelFloat * 100.); + if (compareFramesZoomLevel) { + *compareFramesZoomLevel = GTK_MOZ_EMBED_EQUAL_ZOOM_LEVEL; + // get frames. + nsCOMPtr frameCollection; + rv = DOMWindow->GetFrames (getter_AddRefs (frameCollection)); + if (NS_FAILED(rv)) return NS_ERROR_FAILURE; + // comparing frames' zoom level + PRUint32 numberOfFrames; + frameCollection->GetLength (&numberOfFrames); + if (numberOfFrames) { + //gint mainFrameCurrentIntZoomLevel = ((float) zoomLevelFloat) * 100.; + //gint mainFrameCurrentIntZoomLevel = zoomLevel; + nsCOMPtr currentFrameDOMWindow; + gint currentFrameIntZoomLevel; + gfloat currentFrameFloatZoomLevel; + for (guint i= 0; i < numberOfFrames; i++) { + frameCollection->Item(i, getter_AddRefs (currentFrameDOMWindow)); + if (!currentFrameDOMWindow) continue; + currentFrameDOMWindow->GetTextZoom(¤tFrameFloatZoomLevel); + currentFrameIntZoomLevel = (gint)round(currentFrameFloatZoomLevel * 100.); + if (currentFrameIntZoomLevel != *zoomLevel) { + *compareFramesZoomLevel = GTK_MOZ_EMBED_DIFFERENT_ZOOM_LEVEL; + break ; + } + } // for + } // if frames + } // if compareFramesZoomLevel + return NS_OK; +} + +nsresult +EmbedPrivate::SetZoom (gint zoomLevel) +{ + nsresult rv; + nsCOMPtr webBrowser; + rv = mWindow->GetWebBrowser(getter_AddRefs(webBrowser)); + if (NS_FAILED(rv)) return NS_ERROR_FAILURE; + // get main dom window + nsCOMPtr DOMWindow; + rv = webBrowser->GetContentDOMWindow(getter_AddRefs(DOMWindow)); + if (NS_FAILED(rv)) return NS_ERROR_FAILURE; + gfloat zoomLevelFloat; //, relativeScale; + zoomLevelFloat = (float) zoomLevel / 100.; + // performing text zooming first to get the user a faster visual response. + rv = DOMWindow->SetTextZoom(zoomLevelFloat); + return rv; +} + +nsresult +EmbedPrivate::HasFrames (PRUint32 *numberOfFrames) +{ + // setting default value. + *numberOfFrames = 0; + nsCOMPtr webBrowser; + nsresult rv = mWindow->GetWebBrowser(getter_AddRefs(webBrowser)); + if (NS_FAILED(rv)) return NS_ERROR_FAILURE; + // get main dom window + nsCOMPtr DOMWindow; + rv = webBrowser->GetContentDOMWindow(getter_AddRefs(DOMWindow)); + if (NS_FAILED(rv)) return NS_ERROR_FAILURE; + // get frames. + nsCOMPtr frameCollection; + rv = DOMWindow->GetFrames (getter_AddRefs (frameCollection)); + if (NS_FAILED(rv)) return NS_ERROR_FAILURE; + // comparing frames' zoom level + rv = frameCollection->GetLength (numberOfFrames); + return rv; +} + +nsresult +EmbedPrivate::GetMIMEInfo (nsString& info) +{ + nsresult rv; + nsCOMPtr webBrowser; + rv = mWindow->GetWebBrowser(getter_AddRefs(webBrowser)); + + nsCOMPtr DOMWindow; + rv = webBrowser->GetContentDOMWindow(getter_AddRefs(DOMWindow)); + + nsCOMPtr doc; + rv = DOMWindow->GetDocument (getter_AddRefs(doc)); + + nsCOMPtr nsDoc = do_QueryInterface(doc); + + if (nsDoc) + rv = nsDoc->GetContentType(info); + return rv; +} + diff --git a/mozilla/embedding/browser/gtk/src/EmbedPrivate.h b/mozilla/embedding/browser/gtk/src/EmbedPrivate.h index 23f80379945..c0d365d7f5a 100644 --- a/mozilla/embedding/browser/gtk/src/EmbedPrivate.h +++ b/mozilla/embedding/browser/gtk/src/EmbedPrivate.h @@ -1,3 +1,5 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * @@ -39,7 +41,11 @@ #define __EmbedPrivate_h #include +#ifdef MOZILLA_INTERNAL_API #include +#else +#include +#endif #include #include // for our one function that gets the EmbedPrivate via the chrome @@ -48,12 +54,27 @@ #include #include #include + +#ifdef MOZILLA_1_8_BRANCH +// for profiles +#include +#endif + // app component registration #include #include +#include +#include +#include +#include +// for the focus hacking we need to do +#include +// for frames +#include #include "gtkmozembedprivate.h" +#include "EmbedGtkTools.h" class EmbedProgress; class EmbedWindow; class EmbedContentListener; @@ -61,7 +82,22 @@ class EmbedEventListener; class nsPIDOMWindow; class nsIDirectoryServiceProvider; +#ifdef MOZILLA_1_8_BRANCH +class nsProfileDirServiceProvider; +#endif +class EmbedCommon { + public: + EmbedCommon() { + }; + ~EmbedCommon() { }; + static EmbedCommon* GetInstance(); + static void DeleteInstance(); + nsresult Init (void); + bool mFormAttachCount; + GtkMozEmbedCommon* mCommon; + static GtkMozEmbed* GetAnyLiveWidget(); +}; class EmbedPrivate { public: @@ -87,6 +123,12 @@ class EmbedPrivate { static void PopStartup (void); static void SetPath (const char *aPath); static void SetCompPath (const char *aPath); + +#ifdef MOZILLA_1_8_BRANCH + static nsresult StartupProfile (void); + static void ShutdownProfile(void); +#endif + static void SetAppComponents (const nsModuleComponentInfo* aComps, int aNumComponents); static void SetProfilePath (const char *aDir, const char *aName); @@ -122,6 +164,19 @@ class EmbedPrivate { // events void ChildFocusIn (void); void ChildFocusOut(void); + PRBool ClipBoardAction(GtkMozEmbedClipboard type); + char* GetEncoding (); + nsresult SetEncoding (const char *encoding); + PRBool FindText(const char *exp, PRBool reverse, + PRBool whole_word, PRBool case_sensitive, + PRBool restart); + nsresult ScrollToSelectedNode(nsIDOMNode *aDOMNode); + nsresult InsertTextToNode(nsIDOMNode *aDOMNode, const char *string); + nsresult GetFocusController(nsIFocusController **controller); + nsresult GetZoom (gint *zoomLevel, gint *compareFramesZoomLevel); + nsresult SetZoom (gint zoomLevel); + nsresult HasFrames (PRUint32 *numberOfFrames); + nsresult GetMIMEInfo (nsString& info); #ifdef MOZ_ACCESSIBILITY_ATK void *GetAtkObjectForCurrentDocument(); @@ -147,6 +202,7 @@ class EmbedPrivate { // the currently loaded uri nsString mURI; + nsCString mPrePath; // the number of widgets that have been created static PRUint32 sWidgetCount; @@ -165,6 +221,15 @@ class EmbedPrivate { static nsILocalFile *sProfileDir; static nsISupports *sProfileLock; +#ifdef MOZILLA_1_8_BRANCH + // what is our profile path? + static char *sProfileDirS; + static char *sProfileName; + // for profiles + static nsProfileDirServiceProvider *sProfileDirServiceProvider; + static nsIPref *sPrefs; +#endif + static nsIDirectoryServiceProvider * sAppFileLocProvider; // chrome mask @@ -173,15 +238,24 @@ class EmbedPrivate { PRBool mIsChrome; // has the chrome finished loading? PRBool mChromeLoaded; + + // has the network finished loading? + PRBool mLoadFinished; + // saved window ID for reparenting later GtkWidget *mMozWindowWidget; // has someone called Destroy() on us? PRBool mIsDestroyed; + //Open Blocker for Create Window class //Fixme... + //I just tried to block it on earlier moment + PRBool mOpenBlock; + PRBool mNeedFav; private: // is the chrome listener attached yet? PRBool mListenersAttached; + PRBool mDoResizeEmbed; void GetListener (void); void AttachListeners(void); diff --git a/mozilla/embedding/browser/gtk/src/EmbedProgress.cpp b/mozilla/embedding/browser/gtk/src/EmbedProgress.cpp index 0a4c04979ef..1256715cad2 100644 --- a/mozilla/embedding/browser/gtk/src/EmbedProgress.cpp +++ b/mozilla/embedding/browser/gtk/src/EmbedProgress.cpp @@ -1,3 +1,5 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 tw=80 et cindent: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * @@ -20,6 +22,8 @@ * * Contributor(s): * Christopher Blizzard + * Antonio Gomes + * Oleg Romashin * * 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 @@ -37,14 +41,31 @@ #include "EmbedProgress.h" +#ifdef MOZILLA_INTERNAL_API #include +#endif #include +#include #include #include #include "nsIURI.h" #include "nsCRT.h" +static PRInt32 sStopSignalTimer = 0; +static gboolean +progress_emit_stop(void * data) +{ + g_return_val_if_fail(data, FALSE); + EmbedPrivate *owner = (EmbedPrivate*)data; + if (!owner->mLoadFinished) { + owner->mLoadFinished = PR_TRUE; + gtk_signal_emit(GTK_OBJECT(owner->mOwningWidget), + moz_embed_signals[NET_STOP]); + } + return FALSE; +} + EmbedProgress::EmbedProgress(void) { mOwner = nsnull; @@ -55,100 +76,173 @@ EmbedProgress::~EmbedProgress() } NS_IMPL_ISUPPORTS2(EmbedProgress, - nsIWebProgressListener, - nsISupportsWeakReference) + nsIWebProgressListener, + nsISupportsWeakReference) nsresult EmbedProgress::Init(EmbedPrivate *aOwner) { mOwner = aOwner; + mStopLevel = 0; return NS_OK; } NS_IMETHODIMP EmbedProgress::OnStateChange(nsIWebProgress *aWebProgress, - nsIRequest *aRequest, - PRUint32 aStateFlags, - nsresult aStatus) + nsIRequest *aRequest, + PRUint32 aStateFlags, + nsresult aStatus) { // give the widget a chance to attach any listeners mOwner->ContentStateChange(); + EmbedCommon * common = EmbedCommon::GetInstance(); + + if (sStopSignalTimer && + ( + (aStateFlags & GTK_MOZ_EMBED_FLAG_TRANSFERRING) + || (aStateFlags & GTK_MOZ_EMBED_FLAG_REDIRECTING) + || (aStateFlags & GTK_MOZ_EMBED_FLAG_NEGOTIATING) + ) + ) { + g_source_remove(sStopSignalTimer); + mStopLevel = 0; + gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), + moz_embed_signals[NET_START]); + mOwner->mLoadFinished = PR_FALSE; + } + // if we've got the start flag, emit the signal if ((aStateFlags & GTK_MOZ_EMBED_FLAG_IS_NETWORK) && (aStateFlags & GTK_MOZ_EMBED_FLAG_START)) { - gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[NET_START]); + // FIXME: workaround for broken progress values. + mOwner->mOwningWidget->current_number_of_requests = 0; + mOwner->mOwningWidget->total_number_of_requests = 0; + + if (mOwner->mLoadFinished) { + mOwner->mLoadFinished = PR_FALSE; + mStopLevel = 0; + gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), + moz_embed_signals[NET_START]); + } + if (common) + common->mFormAttachCount = false; } - // get the uri for this request + nsString tmpString; +#ifdef MOZILLA_INTERNAL_API nsXPIDLCString uriString; RequestToURIString(aRequest, getter_Copies(uriString)); - nsString tmpString; CopyUTF8toUTF16(uriString, tmpString); +#else + char *uriString = NULL; + RequestToURIString(aRequest, &uriString); + tmpString.AssignLiteral(uriString); +#endif + // FIXME: workaround for broken progress values. + if (mOwner->mOwningWidget) { + if (aStateFlags & GTK_MOZ_EMBED_FLAG_IS_REQUEST) { + if (aStateFlags & GTK_MOZ_EMBED_FLAG_START) + mOwner->mOwningWidget->total_number_of_requests ++; + else if (aStateFlags & GTK_MOZ_EMBED_FLAG_STOP) + mOwner->mOwningWidget->current_number_of_requests++; + } + gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), + moz_embed_signals[PROGRESS_ALL], + (const gchar *) uriString, + mOwner->mOwningWidget->current_number_of_requests, + mOwner->mOwningWidget->total_number_of_requests); + } // is it the same as the current URI? - if (mOwner->mURI.Equals(tmpString)) - { + if (mOwner->mURI.Equals(tmpString)) { // for people who know what they are doing gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[NET_STATE], - aStateFlags, aStatus); - } - gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[NET_STATE_ALL], - (const char *)uriString, - (gint)aStateFlags, (gint)aStatus); - // and for stop, too - if ((aStateFlags & GTK_MOZ_EMBED_FLAG_IS_NETWORK) && - (aStateFlags & GTK_MOZ_EMBED_FLAG_STOP)) - { - gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[NET_STOP]); - // let our owner know that the load finished - mOwner->ContentFinishedLoading(); + moz_embed_signals[NET_STATE], + aStateFlags, aStatus); } + gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), + moz_embed_signals[NET_STATE_ALL], + (const gchar *)uriString, + (gint)aStateFlags, (gint)aStatus); + + // and for stop, too + if (aStateFlags & GTK_MOZ_EMBED_FLAG_STOP) { + if (aStateFlags & GTK_MOZ_EMBED_FLAG_IS_REQUEST) + mStopLevel = 1; + if (aStateFlags & GTK_MOZ_EMBED_FLAG_IS_DOCUMENT) + mStopLevel = mStopLevel == 1 ? 2 : 0; + if (aStateFlags & GTK_MOZ_EMBED_FLAG_IS_WINDOW) { + mStopLevel = mStopLevel == 2 ? 3 : 0; + } + } + + if (aStateFlags & GTK_MOZ_EMBED_FLAG_STOP) { + if (aStateFlags & GTK_MOZ_EMBED_FLAG_IS_NETWORK) { + if (sStopSignalTimer) + g_source_remove(sStopSignalTimer); + progress_emit_stop(mOwner); + // let our owner know that the load finished + mOwner->ContentFinishedLoading(); + + if (common && common->mFormAttachCount) { + gtk_moz_embed_common_login(GTK_WIDGET(mOwner->mOwningWidget)); + common->mFormAttachCount = false; + } + } else if (mStopLevel == 3) { + if (sStopSignalTimer) + g_source_remove(sStopSignalTimer); + mStopLevel = 0; + sStopSignalTimer = g_timeout_add(1000, progress_emit_stop, mOwner); + } + } return NS_OK; } NS_IMETHODIMP EmbedProgress::OnProgressChange(nsIWebProgress *aWebProgress, - nsIRequest *aRequest, - PRInt32 aCurSelfProgress, - PRInt32 aMaxSelfProgress, - PRInt32 aCurTotalProgress, - PRInt32 aMaxTotalProgress) + nsIRequest *aRequest, + PRInt32 aCurSelfProgress, + PRInt32 aMaxSelfProgress, + PRInt32 aCurTotalProgress, + PRInt32 aMaxTotalProgress) { - + nsString tmpString; +#ifdef MOZILLA_INTERNAL_API nsXPIDLCString uriString; RequestToURIString(aRequest, getter_Copies(uriString)); - - nsString tmpString; CopyUTF8toUTF16(uriString, tmpString); +#else + gchar *uriString = NULL; + RequestToURIString(aRequest, &uriString); + tmpString.AssignLiteral(uriString); +#endif // is it the same as the current uri? if (mOwner->mURI.Equals(tmpString)) { gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[PROGRESS], - aCurTotalProgress, aMaxTotalProgress); + moz_embed_signals[PROGRESS], + aCurTotalProgress, aMaxTotalProgress); } - - gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[PROGRESS_ALL], - (const char *)uriString, - aCurTotalProgress, aMaxTotalProgress); + // FIXME: workaround for broken progress values. This signal is being fired off above. + /*gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), + moz_embed_signals[PROGRESS_ALL], + (const char *)uriString, + aCurTotalProgress, aMaxTotalProgress);*/ return NS_OK; } NS_IMETHODIMP EmbedProgress::OnLocationChange(nsIWebProgress *aWebProgress, - nsIRequest *aRequest, - nsIURI *aLocation) + nsIRequest *aRequest, + nsIURI *aLocation) { nsCAutoString newURI; + nsCAutoString prePath; NS_ENSURE_ARG_POINTER(aLocation); aLocation->GetSpec(newURI); + aLocation->GetPrePath(prePath); // Make sure that this is the primary frame change and not // just a subframe. @@ -167,64 +261,87 @@ EmbedProgress::OnLocationChange(nsIWebProgress *aWebProgress, isSubFrameLoad = PR_TRUE; } + nsresult rv; + nsCOMPtr httpChannel(do_QueryInterface(aRequest, &rv)); + if (NS_FAILED(rv) || !httpChannel) + return NS_ERROR_FAILURE; + + PRUint32 responseCode = 0; + + rv = httpChannel->GetResponseStatus(&responseCode); + if (NS_FAILED(rv)) + return NS_ERROR_FAILURE; + + // it has to handle more http errors code ??? 401 ? + if (responseCode >= 500 && responseCode <= 505) { + gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), + moz_embed_signals[UNKNOWN_PROTOCOL], + newURI.get()); + mOwner->mNeedFav = PR_FALSE; + return NS_OK; + } + if (!isSubFrameLoad) { mOwner->SetURI(newURI.get()); + mOwner->mPrePath.Assign(prePath.get()); gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[LOCATION]); + moz_embed_signals[LOCATION]); } + mOwner->mNeedFav = PR_TRUE; return NS_OK; } NS_IMETHODIMP EmbedProgress::OnStatusChange(nsIWebProgress *aWebProgress, - nsIRequest *aRequest, - nsresult aStatus, - const PRUnichar *aMessage) + nsIRequest *aRequest, + nsresult aStatus, + const PRUnichar *aMessage) { // need to make a copy so we can safely cast to a void * - PRUnichar *tmpString = nsCRT::strdup(aMessage); + PRUnichar *tmpString = NS_strdup(aMessage); gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[STATUS_CHANGE], - NS_STATIC_CAST(void *, aRequest), - NS_STATIC_CAST(int, aStatus), - NS_STATIC_CAST(void *, tmpString)); + moz_embed_signals[STATUS_CHANGE], + NS_STATIC_CAST(void *, aRequest), + NS_STATIC_CAST(gint, aStatus), + NS_STATIC_CAST(void *, tmpString)); - nsMemory::Free(tmpString); + NS_Free(tmpString); return NS_OK; } NS_IMETHODIMP EmbedProgress::OnSecurityChange(nsIWebProgress *aWebProgress, - nsIRequest *aRequest, - PRUint32 aState) + nsIRequest *aRequest, + PRUint32 aState) { gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[SECURITY_CHANGE], - NS_STATIC_CAST(void *, aRequest), - aState); + moz_embed_signals[SECURITY_CHANGE], + NS_STATIC_CAST(void *, aRequest), + aState); return NS_OK; } /* static */ void -EmbedProgress::RequestToURIString(nsIRequest *aRequest, char **aString) +EmbedProgress::RequestToURIString(nsIRequest *aRequest, gchar **aString) { // is it a channel nsCOMPtr channel; channel = do_QueryInterface(aRequest); if (!channel) return; - + nsCOMPtr uri; channel->GetURI(getter_AddRefs(uri)); if (!uri) return; - + nsCAutoString uriString; uri->GetSpec(uriString); - *aString = strdup(uriString.get()); + *aString = g_strdup(uriString.get()); } + diff --git a/mozilla/embedding/browser/gtk/src/EmbedProgress.h b/mozilla/embedding/browser/gtk/src/EmbedProgress.h index 75363d0dfc7..d71c7868c9e 100644 --- a/mozilla/embedding/browser/gtk/src/EmbedProgress.h +++ b/mozilla/embedding/browser/gtk/src/EmbedProgress.h @@ -1,3 +1,5 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * @@ -60,7 +62,7 @@ class EmbedProgress : public nsIWebProgressListener, static void RequestToURIString (nsIRequest *aRequest, char **aString); EmbedPrivate *mOwner; - + PRBool mStopLevel; }; #endif /* __EmbedProgress_h */ diff --git a/mozilla/embedding/browser/gtk/src/EmbedPrompter.cpp b/mozilla/embedding/browser/gtk/src/EmbedPrompter.cpp index 9a9b67adada..45276882a64 100644 --- a/mozilla/embedding/browser/gtk/src/EmbedPrompter.cpp +++ b/mozilla/embedding/browser/gtk/src/EmbedPrompter.cpp @@ -1,5 +1,5 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* vim:expandtab:shiftwidth=4:tabstop=4: */ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=4 sts=2 et cindent: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * @@ -41,369 +41,386 @@ #include "nsReadableUtils.h" enum { - INCLUDE_USERNAME = 1 << 0, - INCLUDE_PASSWORD = 1 << 1, - INCLUDE_CHECKBOX = 1 << 2, - INCLUDE_CANCEL = 1 << 3 + INCLUDE_USERNAME = 1 << 0, + INCLUDE_PASSWORD = 1 << 1, + INCLUDE_CHECKBOX = 1 << 2, + INCLUDE_CANCEL = 1 << 3 }; struct DialogDescription { - int flags; - gchar* icon; + int flags; + gchar* icon; }; // This table contains the optional widgets and icons associated with // each type of dialog. static const DialogDescription DialogTable[] = { - { 0, GTK_STOCK_DIALOG_WARNING }, // ALERT - { INCLUDE_CHECKBOX, GTK_STOCK_DIALOG_WARNING }, // ALERT_CHECK - { INCLUDE_CANCEL, GTK_STOCK_DIALOG_QUESTION }, // CONFIRM - { INCLUDE_CHECKBOX | - INCLUDE_CANCEL, GTK_STOCK_DIALOG_QUESTION }, // CONFIRM_CHECK - { INCLUDE_CANCEL | - INCLUDE_CHECKBOX, GTK_STOCK_DIALOG_QUESTION }, // PROMPT - { INCLUDE_CANCEL | - INCLUDE_USERNAME | - INCLUDE_PASSWORD | - INCLUDE_CHECKBOX, GTK_STOCK_DIALOG_QUESTION }, // PROMPT_USER_PASS - { INCLUDE_CANCEL | - INCLUDE_PASSWORD | - INCLUDE_CHECKBOX, GTK_STOCK_DIALOG_QUESTION }, // PROMPT_PASS - { INCLUDE_CANCEL, GTK_STOCK_DIALOG_QUESTION }, // SELECT - { INCLUDE_CANCEL | - INCLUDE_CHECKBOX, GTK_STOCK_DIALOG_QUESTION } // UNIVERSAL + { 0, GTK_STOCK_DIALOG_WARNING }, // ALERT + { INCLUDE_CHECKBOX, GTK_STOCK_DIALOG_WARNING }, // ALERT_CHECK + { INCLUDE_CANCEL, GTK_STOCK_DIALOG_QUESTION }, // CONFIRM + { INCLUDE_CHECKBOX | + INCLUDE_CANCEL, GTK_STOCK_DIALOG_QUESTION }, // CONFIRM_CHECK + { INCLUDE_CANCEL | + INCLUDE_CHECKBOX, GTK_STOCK_DIALOG_QUESTION }, // PROMPT + { INCLUDE_CANCEL | + INCLUDE_USERNAME | + INCLUDE_PASSWORD | + INCLUDE_CHECKBOX, GTK_STOCK_DIALOG_QUESTION }, // PROMPT_USER_PASS + { INCLUDE_CANCEL | + INCLUDE_PASSWORD | + INCLUDE_CHECKBOX, GTK_STOCK_DIALOG_QUESTION }, // PROMPT_PASS + { INCLUDE_CANCEL, GTK_STOCK_DIALOG_QUESTION }, // SELECT + { INCLUDE_CANCEL | + INCLUDE_CHECKBOX, GTK_STOCK_DIALOG_QUESTION } // UNIVERSAL }; EmbedPrompter::EmbedPrompter(void) - : mCheckValue(PR_FALSE), - mItemList(nsnull), - mItemCount(0), - mButtonPressed(0), - mConfirmResult(PR_FALSE), - mSelectedItem(0), - mWindow(NULL), - mUserField(NULL), - mPassField(NULL), - mTextField(NULL), - mOptionMenu(NULL), - mCheckBox(NULL) + : mCheckValue(PR_FALSE), + mItemList(nsnull), + mItemCount(0), + mButtonPressed(0), + mConfirmResult(PR_FALSE), + mSelectedItem(0), + mWindow(NULL), + mUserField(NULL), + mPassField(NULL), + mTextField(NULL), + mOptionMenu(NULL), + mCheckBox(NULL) { } EmbedPrompter::~EmbedPrompter(void) { - if (mItemList) - delete[] mItemList; + if (mItemList) + delete[] mItemList; } nsresult EmbedPrompter::Create(PromptType aType, GtkWindow* aParentWindow) + { - mWindow = gtk_dialog_new_with_buttons(mTitle.get(), aParentWindow, - (GtkDialogFlags)0, - NULL); + mWindow = gtk_dialog_new_with_buttons( + mTitle.get(), + aParentWindow, + (GtkDialogFlags)0, + NULL); + // only add the dialog to the window group if the parent already has a window group, + // so as not to break app's expectations about modal dialogs. + if (aParentWindow && aParentWindow->group) { + gtk_window_group_add_window (aParentWindow->group, GTK_WINDOW (mWindow)); + } - // only add the dialog to the window group if the parent already has a window group, - // so as not to break app's expectations about modal dialogs. - if (aParentWindow && aParentWindow->group) { - gtk_window_group_add_window (aParentWindow->group, GTK_WINDOW (mWindow)); + // gtk will resize this for us as necessary + gtk_window_set_default_size(GTK_WINDOW(mWindow), 100, 50); + + // this HBox will contain the icon, and a vbox which contains the + // dialog text and other widgets. + GtkWidget* dialogHBox = gtk_hbox_new(FALSE, 12); + + + // Set up dialog properties according to the GNOME HIG + // (http://developer.gnome.org/projects/gup/hig/1.0/windows.html#alert-windows) + + gtk_container_set_border_width(GTK_CONTAINER(mWindow), 6); + gtk_dialog_set_has_separator(GTK_DIALOG(mWindow), FALSE); + gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(mWindow)->vbox), 12); + gtk_container_set_border_width(GTK_CONTAINER(dialogHBox), 6); + + + // This is the VBox which will contain the label and other controls. + GtkWidget* contentsVBox = gtk_vbox_new(FALSE, 12); + + // get the stock icon for this dialog and put it in the box + const gchar* iconDesc = DialogTable[aType].icon; + GtkWidget* icon = gtk_image_new_from_stock(iconDesc, GTK_ICON_SIZE_DIALOG); + gtk_misc_set_alignment(GTK_MISC(icon), 0.5, 0.0); + gtk_box_pack_start(GTK_BOX(dialogHBox), icon, FALSE, FALSE, 0); + + // now pack the label into the vbox + GtkWidget* label = gtk_label_new(mMessageText.get()); + gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); + gtk_label_set_selectable(GTK_LABEL(label), TRUE); + gtk_box_pack_start(GTK_BOX(contentsVBox), label, FALSE, FALSE, 0); + + int widgetFlags = DialogTable[aType].flags; + + if (widgetFlags & (INCLUDE_USERNAME | INCLUDE_PASSWORD)) { + + // If we're creating a username and/or password field, make an hbox + // which will contain two vboxes, one for the labels and one for the + // text fields. This will let us line up the textfields. + + GtkWidget* userPassHBox = gtk_hbox_new(FALSE, 12); + GtkWidget* userPassLabels = gtk_vbox_new(TRUE, 6); + GtkWidget* userPassFields = gtk_vbox_new(TRUE, 6); + + if (widgetFlags & INCLUDE_USERNAME) { + GtkWidget* userLabel = gtk_label_new("User Name:"); + gtk_box_pack_start(GTK_BOX(userPassLabels), userLabel, FALSE, + FALSE, 0); + + mUserField = gtk_entry_new(); + + if (!mUser.IsEmpty()) + gtk_entry_set_text(GTK_ENTRY(mUserField), mUser.get()); + + gtk_entry_set_activates_default(GTK_ENTRY(mUserField), TRUE); + + gtk_box_pack_start( + GTK_BOX(userPassFields), + mUserField, + FALSE, + FALSE, + 0); + } + if (widgetFlags & INCLUDE_PASSWORD) { + GtkWidget* passLabel = gtk_label_new("Password:"); + gtk_box_pack_start( + GTK_BOX(userPassLabels), + passLabel, + FALSE, + FALSE, + 0); + mPassField = gtk_entry_new(); + if (!mPass.IsEmpty()) + gtk_entry_set_text(GTK_ENTRY(mPassField), mPass.get()); + gtk_entry_set_visibility(GTK_ENTRY(mPassField), FALSE); + gtk_entry_set_activates_default(GTK_ENTRY(mPassField), TRUE); + gtk_box_pack_start( + GTK_BOX(userPassFields), + mPassField, + FALSE, + FALSE, + 0); + } + gtk_box_pack_start( + GTK_BOX(userPassHBox), + userPassLabels, + FALSE, + FALSE, + 0); + gtk_box_pack_start( + GTK_BOX(userPassHBox), + userPassFields, + FALSE, + FALSE, + 0); + gtk_box_pack_start( + GTK_BOX(contentsVBox), + userPassHBox, + FALSE, + FALSE, + 0); + } + if (aType == TYPE_PROMPT) { + mTextField = gtk_entry_new(); + if (!mTextValue.IsEmpty()) + gtk_entry_set_text(GTK_ENTRY(mTextField), mTextValue.get()); + gtk_entry_set_activates_default(GTK_ENTRY(mTextField), TRUE); + gtk_box_pack_start(GTK_BOX(contentsVBox), mTextField, FALSE, FALSE, 0); + } + // Add a checkbox + if ((widgetFlags & INCLUDE_CHECKBOX) && !mCheckMessage.IsEmpty()) { + mCheckBox = gtk_check_button_new_with_label(mCheckMessage.get()); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mCheckBox), + mCheckValue); + gtk_label_set_line_wrap( + GTK_LABEL(gtk_bin_get_child(GTK_BIN(mCheckBox))), + TRUE); + gtk_box_pack_start(GTK_BOX(contentsVBox), mCheckBox, FALSE, FALSE, 0); + } + // Add a dropdown menu + if (aType == TYPE_SELECT) { + // Build up a GtkMenu containing the items + GtkWidget* menu = gtk_menu_new(); + for (PRUint32 i = 0; i < mItemCount; ++i) { + GtkWidget* item = gtk_menu_item_new_with_label(mItemList[i].get()); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); } - // gtk will resize this for us as necessary - gtk_window_set_default_size(GTK_WINDOW(mWindow), 100, 50); + // Now create an OptionMenu and set this as the menu + mOptionMenu = gtk_option_menu_new(); - // this HBox will contain the icon, and a vbox which contains the - // dialog text and other widgets. - GtkWidget* dialogHBox = gtk_hbox_new(FALSE, 12); + gtk_option_menu_set_menu(GTK_OPTION_MENU(mOptionMenu), menu); + gtk_box_pack_start(GTK_BOX(contentsVBox), mOptionMenu, FALSE, FALSE, 0); + } - - // Set up dialog properties according to the GNOME HIG - // (http://developer.gnome.org/projects/gup/hig/1.0/windows.html#alert-windows) - - gtk_container_set_border_width(GTK_CONTAINER(mWindow), 6); - gtk_dialog_set_has_separator(GTK_DIALOG(mWindow), FALSE); - gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(mWindow)->vbox), 12); - gtk_container_set_border_width(GTK_CONTAINER(dialogHBox), 6); - - - // This is the VBox which will contain the label and other controls. - GtkWidget* contentsVBox = gtk_vbox_new(FALSE, 12); - - // get the stock icon for this dialog and put it in the box - const gchar* iconDesc = DialogTable[aType].icon; - GtkWidget* icon = gtk_image_new_from_stock(iconDesc, GTK_ICON_SIZE_DIALOG); - gtk_misc_set_alignment(GTK_MISC(icon), 0.5, 0.0); - gtk_box_pack_start(GTK_BOX(dialogHBox), icon, FALSE, FALSE, 0); - - // now pack the label into the vbox - GtkWidget* label = gtk_label_new(mMessageText.get()); - gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); - gtk_label_set_selectable(GTK_LABEL(label), TRUE); - gtk_box_pack_start(GTK_BOX(contentsVBox), label, FALSE, FALSE, 0); - - int widgetFlags = DialogTable[aType].flags; - - if (widgetFlags & (INCLUDE_USERNAME | INCLUDE_PASSWORD)) { - - // If we're creating a username and/or password field, make an hbox - // which will contain two vboxes, one for the labels and one for the - // text fields. This will let us line up the textfields. - - GtkWidget* userPassHBox = gtk_hbox_new(FALSE, 12); - GtkWidget* userPassLabels = gtk_vbox_new(TRUE, 6); - GtkWidget* userPassFields = gtk_vbox_new(TRUE, 6); - - if (widgetFlags & INCLUDE_USERNAME) { - GtkWidget* userLabel = gtk_label_new("User Name:"); - gtk_box_pack_start(GTK_BOX(userPassLabels), userLabel, FALSE, - FALSE, 0); - - mUserField = gtk_entry_new(); - - if (!mUser.IsEmpty()) - gtk_entry_set_text(GTK_ENTRY(mUserField), mUser.get()); - - gtk_entry_set_activates_default(GTK_ENTRY(mUserField), TRUE); - - gtk_box_pack_start(GTK_BOX(userPassFields), mUserField, FALSE, - FALSE, 0); - } - if (widgetFlags & INCLUDE_PASSWORD) { - GtkWidget* passLabel = gtk_label_new("Password:"); - gtk_box_pack_start(GTK_BOX(userPassLabels), passLabel, FALSE, - FALSE, 0); - - mPassField = gtk_entry_new(); - - if (!mPass.IsEmpty()) - gtk_entry_set_text(GTK_ENTRY(mPassField), mPass.get()); - - gtk_entry_set_visibility(GTK_ENTRY(mPassField), FALSE); - gtk_entry_set_activates_default(GTK_ENTRY(mPassField), TRUE); - - gtk_box_pack_start(GTK_BOX(userPassFields), mPassField, FALSE, - FALSE, 0); - } - - gtk_box_pack_start(GTK_BOX(userPassHBox), userPassLabels, FALSE, - FALSE, 0); - gtk_box_pack_start(GTK_BOX(userPassHBox), userPassFields, FALSE, - FALSE, 0); - gtk_box_pack_start(GTK_BOX(contentsVBox), userPassHBox, FALSE, FALSE, 0); + if (aType == TYPE_UNIVERSAL) { + // Create buttons based on the flags passed in. + for (int i = EMBED_MAX_BUTTONS; i >= 0; --i) { + if (!mButtonLabels[i].IsEmpty()) + gtk_dialog_add_button(GTK_DIALOG(mWindow), + mButtonLabels[i].get(), i); } + gtk_dialog_set_default_response(GTK_DIALOG(mWindow), 0); + } else { + // Create standard ok and cancel buttons + if (widgetFlags & INCLUDE_CANCEL) + gtk_dialog_add_button(GTK_DIALOG(mWindow), GTK_STOCK_CANCEL, + GTK_RESPONSE_CANCEL); - if (aType == TYPE_PROMPT) { - mTextField = gtk_entry_new(); - - if (!mTextValue.IsEmpty()) - gtk_entry_set_text(GTK_ENTRY(mTextField), mTextValue.get()); - - gtk_entry_set_activates_default(GTK_ENTRY(mTextField), TRUE); - - gtk_box_pack_start(GTK_BOX(contentsVBox), mTextField, FALSE, FALSE, 0); - } - - // Add a checkbox - if ((widgetFlags & INCLUDE_CHECKBOX) && !mCheckMessage.IsEmpty()) { - mCheckBox = gtk_check_button_new_with_label(mCheckMessage.get()); - - gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mCheckBox), - mCheckValue); - gtk_label_set_line_wrap(GTK_LABEL(gtk_bin_get_child(GTK_BIN(mCheckBox))), - TRUE); - - gtk_box_pack_start(GTK_BOX(contentsVBox), mCheckBox, FALSE, FALSE, 0); - } - - // Add a dropdown menu - if (aType == TYPE_SELECT) { - // Build up a GtkMenu containing the items - GtkWidget* menu = gtk_menu_new(); - for (PRUint32 i = 0; i < mItemCount; ++i) { - GtkWidget* item = gtk_menu_item_new_with_label(mItemList[i].get()); - gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); - } - - // Now create an OptionMenu and set this as the menu - mOptionMenu = gtk_option_menu_new(); - - gtk_option_menu_set_menu(GTK_OPTION_MENU(mOptionMenu), menu); - gtk_box_pack_start(GTK_BOX(contentsVBox), mOptionMenu, FALSE, FALSE, 0); - } - - if (aType == TYPE_UNIVERSAL) { - // Create buttons based on the flags passed in. - for (int i = EMBED_MAX_BUTTONS; i >= 0; --i) { - if (!mButtonLabels[i].IsEmpty()) - gtk_dialog_add_button(GTK_DIALOG(mWindow), - mButtonLabels[i].get(), i); - } - gtk_dialog_set_default_response(GTK_DIALOG(mWindow), 0); - } else { - // Create standard ok and cancel buttons - if (widgetFlags & INCLUDE_CANCEL) - gtk_dialog_add_button(GTK_DIALOG(mWindow), GTK_STOCK_CANCEL, - GTK_RESPONSE_CANCEL); - - GtkWidget* okButton = gtk_dialog_add_button(GTK_DIALOG(mWindow), - GTK_STOCK_OK, - GTK_RESPONSE_ACCEPT); - gtk_widget_grab_default(okButton); - } - - // Pack the contentsVBox into the dialogHBox and the dialog. - gtk_box_pack_start(GTK_BOX(dialogHBox), contentsVBox, FALSE, FALSE, 0); - gtk_box_pack_start(GTK_BOX(GTK_DIALOG(mWindow)->vbox), dialogHBox, FALSE, - FALSE, 0); - - return NS_OK; + GtkWidget* okButton = gtk_dialog_add_button(GTK_DIALOG(mWindow), + GTK_STOCK_OK, + GTK_RESPONSE_ACCEPT); + gtk_widget_grab_default(okButton); + } + // Pack the contentsVBox into the dialogHBox and the dialog. + gtk_box_pack_start(GTK_BOX(dialogHBox), contentsVBox, FALSE, FALSE, 0); + gtk_box_pack_start( + GTK_BOX(GTK_DIALOG(mWindow)->vbox), + dialogHBox, + FALSE, + FALSE, + 0); + return NS_OK; } void EmbedPrompter::SetTitle(const PRUnichar *aTitle) { - CopyUTF16toUTF8(aTitle, mTitle); + CopyUTF16toUTF8(aTitle, mTitle); } void EmbedPrompter::SetTextValue(const PRUnichar *aTextValue) { - CopyUTF16toUTF8(aTextValue, mTextValue); + CopyUTF16toUTF8(aTextValue, mTextValue); } void EmbedPrompter::SetCheckMessage(const PRUnichar *aMessage) { - CopyUTF16toUTF8(aMessage, mCheckMessage); + CopyUTF16toUTF8(aMessage, mCheckMessage); } void EmbedPrompter::SetMessageText(const PRUnichar *aMessageText) { - CopyUTF16toUTF8(aMessageText, mMessageText); + CopyUTF16toUTF8(aMessageText, mMessageText); } void EmbedPrompter::SetUser(const PRUnichar *aUser) { - CopyUTF16toUTF8(aUser, mUser); + CopyUTF16toUTF8(aUser, mUser); } void EmbedPrompter::SetPassword(const PRUnichar *aPass) { - CopyUTF16toUTF8(aPass, mPass); + CopyUTF16toUTF8(aPass, mPass); } void EmbedPrompter::SetCheckValue(const PRBool aValue) { - mCheckValue = aValue; + mCheckValue = aValue; } void EmbedPrompter::SetItems(const PRUnichar** aItemArray, PRUint32 aCount) { - if (mItemList) - delete[] mItemList; + if (mItemList) + delete[] mItemList; - mItemCount = aCount; - mItemList = new nsCString[aCount]; - for (PRUint32 i = 0; i < aCount; ++i) - CopyUTF16toUTF8(aItemArray[i], mItemList[i]); + mItemCount = aCount; + mItemList = new nsCString[aCount]; + for (PRUint32 i = 0; i < aCount; ++i) + CopyUTF16toUTF8(aItemArray[i], mItemList[i]); } void EmbedPrompter::SetButtons(const PRUnichar* aButton0Label, - const PRUnichar* aButton1Label, - const PRUnichar* aButton2Label) + const PRUnichar* aButton1Label, + const PRUnichar* aButton2Label) { - CopyUTF16toUTF8(aButton0Label, mButtonLabels[0]); - CopyUTF16toUTF8(aButton1Label, mButtonLabels[1]); - CopyUTF16toUTF8(aButton2Label, mButtonLabels[2]); + CopyUTF16toUTF8(aButton0Label, mButtonLabels[0]); + CopyUTF16toUTF8(aButton1Label, mButtonLabels[1]); + CopyUTF16toUTF8(aButton2Label, mButtonLabels[2]); } void EmbedPrompter::GetCheckValue(PRBool *aValue) { - *aValue = mCheckValue; + *aValue = mCheckValue; } void EmbedPrompter::GetConfirmValue(PRBool *aConfirmValue) { - *aConfirmValue = mConfirmResult; + *aConfirmValue = mConfirmResult; } - + void EmbedPrompter::GetTextValue(PRUnichar **aTextValue) { - *aTextValue = UTF8ToNewUnicode(mTextValue); + *aTextValue = UTF8ToNewUnicode(mTextValue); } void EmbedPrompter::GetUser(PRUnichar **aUser) { - *aUser = UTF8ToNewUnicode(mUser); + *aUser = UTF8ToNewUnicode(mUser); } void EmbedPrompter::GetPassword(PRUnichar **aPass) { - *aPass = UTF8ToNewUnicode(mPass); + *aPass = UTF8ToNewUnicode(mPass); } void EmbedPrompter::GetSelectedItem(PRInt32 *aIndex) { - *aIndex = mSelectedItem; + *aIndex = mSelectedItem; } void EmbedPrompter::GetButtonPressed(PRInt32 *aButton) { - *aButton = mButtonPressed; + *aButton = mButtonPressed; } void EmbedPrompter::Run(void) { - gtk_widget_show_all(mWindow); - gint response = gtk_dialog_run(GTK_DIALOG(mWindow)); - switch (response) { - case GTK_RESPONSE_NONE: - case GTK_RESPONSE_CANCEL: - case GTK_RESPONSE_DELETE_EVENT: - mConfirmResult = PR_FALSE; - break; - case GTK_RESPONSE_ACCEPT: - mConfirmResult = PR_TRUE; - SaveDialogValues(); - break; - default: - mButtonPressed = response; - SaveDialogValues(); - } + gtk_widget_show_all(mWindow); + gint response = gtk_dialog_run(GTK_DIALOG(mWindow)); + switch (response) { + case GTK_RESPONSE_NONE: + case GTK_RESPONSE_CANCEL: + case GTK_RESPONSE_DELETE_EVENT: + mConfirmResult = PR_FALSE; + break; + case GTK_RESPONSE_ACCEPT: + mConfirmResult = PR_TRUE; + SaveDialogValues(); + break; + default: + mButtonPressed = response; + SaveDialogValues(); + } - gtk_widget_destroy(mWindow); + gtk_widget_destroy(mWindow); } void EmbedPrompter::SaveDialogValues() { - if (mUserField) - mUser.Assign(gtk_entry_get_text(GTK_ENTRY(mUserField))); + if (mUserField) + mUser.Assign(gtk_entry_get_text(GTK_ENTRY(mUserField))); - if (mPassField) - mPass.Assign(gtk_entry_get_text(GTK_ENTRY(mPassField))); + if (mPassField) + mPass.Assign(gtk_entry_get_text(GTK_ENTRY(mPassField))); - if (mCheckBox) - mCheckValue = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mCheckBox)); + if (mCheckBox) + mCheckValue = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mCheckBox)); - if (mTextField) - mTextValue.Assign(gtk_entry_get_text(GTK_ENTRY(mTextField))); + if (mTextField) + mTextValue.Assign(gtk_entry_get_text(GTK_ENTRY(mTextField))); - if (mOptionMenu) - mSelectedItem = gtk_option_menu_get_history(GTK_OPTION_MENU(mOptionMenu)); + if (mOptionMenu) + mSelectedItem = gtk_option_menu_get_history(GTK_OPTION_MENU(mOptionMenu)); } diff --git a/mozilla/embedding/browser/gtk/src/EmbedPrompter.h b/mozilla/embedding/browser/gtk/src/EmbedPrompter.h index 935f671085d..71dced1097b 100644 --- a/mozilla/embedding/browser/gtk/src/EmbedPrompter.h +++ b/mozilla/embedding/browser/gtk/src/EmbedPrompter.h @@ -1,5 +1,5 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* vim:expandtab:shiftwidth=4:tabstop=4: */ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * @@ -38,9 +38,14 @@ * * ***** END LICENSE BLOCK ***** */ -#include +#ifdef MOZILLA_INTERNAL_API +#include "nsString.h" +#else +#include "nsStringAPI.h" +#endif #include +#include #define EMBED_MAX_BUTTONS 3 class EmbedPrompter { diff --git a/mozilla/embedding/browser/gtk/src/EmbedWindow.cpp b/mozilla/embedding/browser/gtk/src/EmbedWindow.cpp index 584d9d96d42..cb0cd08cffe 100644 --- a/mozilla/embedding/browser/gtk/src/EmbedWindow.cpp +++ b/mozilla/embedding/browser/gtk/src/EmbedWindow.cpp @@ -1,6 +1,6 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ /* - * vim:ts=2:et:sw=2 - * * ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * @@ -42,8 +42,11 @@ #include #include #include "nsIWidget.h" +#ifdef MOZILLA_INTERNAL_API #include "nsReadableUtils.h" - +#else +#include "nsComponentManagerUtils.h" +#endif #include "EmbedWindow.h" #include "EmbedPrivate.h" #include "EmbedPrompter.h" @@ -91,10 +94,10 @@ EmbedWindow::CreateWindow(void) // create the window. mBaseWindow = do_QueryInterface(mWebBrowser); rv = mBaseWindow->InitWindow(GTK_WIDGET(mOwner->mOwningWidget), - nsnull, - 0, 0, - ownerAsWidget->allocation.width, - ownerAsWidget->allocation.height); + nsnull, + 0, 0, + ownerAsWidget->allocation.width, + ownerAsWidget->allocation.height); if (NS_FAILED(rv)) return rv; @@ -125,7 +128,7 @@ NS_INTERFACE_MAP_BEGIN(EmbedWindow) NS_INTERFACE_MAP_ENTRY(nsIWebBrowserChrome) NS_INTERFACE_MAP_ENTRY(nsIWebBrowserChromeFocus) NS_INTERFACE_MAP_ENTRY(nsIEmbeddingSiteWindow) - NS_INTERFACE_MAP_ENTRY(nsITooltipListener) +// NS_INTERFACE_MAP_ENTRY(nsITooltipListener) NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor) NS_INTERFACE_MAP_END @@ -135,21 +138,21 @@ NS_IMETHODIMP EmbedWindow::SetStatus(PRUint32 aStatusType, const PRUnichar *aStatus) { switch (aStatusType) { - case STATUS_SCRIPT: + case STATUS_SCRIPT: { mJSStatus = aStatus; gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[JS_STATUS]); + moz_embed_signals[JS_STATUS]); } break; - case STATUS_SCRIPT_DEFAULT: + case STATUS_SCRIPT_DEFAULT: // Gee, that's nice. break; - case STATUS_LINK: + case STATUS_LINK: { mLinkMessage = aStatus; gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[LINK_MESSAGE]); + moz_embed_signals[LINK_MESSAGE]); } break; } @@ -192,7 +195,7 @@ EmbedWindow::DestroyBrowserWindow(void) mOwner->mIsDestroyed = PR_TRUE; gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[DESTROY_BROWSER]); + moz_embed_signals[DESTROY_BROWSER]); return NS_OK; } @@ -200,7 +203,7 @@ NS_IMETHODIMP EmbedWindow::SizeBrowserTo(PRInt32 aCX, PRInt32 aCY) { gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[SIZE_TO], aCX, aCY); + moz_embed_signals[SIZE_TO], aCX, aCY); return NS_OK; } @@ -255,7 +258,7 @@ EmbedWindow::FocusNextElement() return NS_OK; g_signal_emit_by_name(G_OBJECT(toplevel), "move_focus", - GTK_DIR_TAB_FORWARD); + GTK_DIR_TAB_FORWARD); #endif return NS_OK; @@ -279,7 +282,7 @@ EmbedWindow::FocusPrevElement() return NS_OK; g_signal_emit_by_name(G_OBJECT(toplevel), "move_focus", - GTK_DIR_TAB_BACKWARD); + GTK_DIR_TAB_BACKWARD); #endif return NS_OK; @@ -289,18 +292,18 @@ EmbedWindow::FocusPrevElement() NS_IMETHODIMP EmbedWindow::SetDimensions(PRUint32 aFlags, PRInt32 aX, PRInt32 aY, - PRInt32 aCX, PRInt32 aCY) + PRInt32 aCX, PRInt32 aCY) { if (aFlags & nsIEmbeddingSiteWindow::DIM_FLAGS_POSITION && (aFlags & (nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_INNER | - nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_OUTER))) { + nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_OUTER))) { return mBaseWindow->SetPositionAndSize(aX, aY, aCX, aCY, PR_TRUE); } else if (aFlags & nsIEmbeddingSiteWindow::DIM_FLAGS_POSITION) { return mBaseWindow->SetPosition(aX, aY); } else if (aFlags & (nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_INNER | - nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_OUTER)) { + nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_OUTER)) { return mBaseWindow->SetSize(aCX, aCY, PR_TRUE); } return NS_ERROR_INVALID_ARG; @@ -308,18 +311,18 @@ EmbedWindow::SetDimensions(PRUint32 aFlags, PRInt32 aX, PRInt32 aY, NS_IMETHODIMP EmbedWindow::GetDimensions(PRUint32 aFlags, PRInt32 *aX, - PRInt32 *aY, PRInt32 *aCX, PRInt32 *aCY) + PRInt32 *aY, PRInt32 *aCX, PRInt32 *aCY) { if (aFlags & nsIEmbeddingSiteWindow::DIM_FLAGS_POSITION && (aFlags & (nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_INNER | - nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_OUTER))) { + nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_OUTER))) { return mBaseWindow->GetPositionAndSize(aX, aY, aCX, aCY); } else if (aFlags & nsIEmbeddingSiteWindow::DIM_FLAGS_POSITION) { return mBaseWindow->GetPosition(aX, aY); } else if (aFlags & (nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_INNER | - nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_OUTER)) { + nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_OUTER)) { return mBaseWindow->GetSize(aCX, aCY); } return NS_ERROR_INVALID_ARG; @@ -344,7 +347,7 @@ EmbedWindow::SetTitle(const PRUnichar *aTitle) { mTitle = aTitle; gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[TITLE]); + moz_embed_signals[TITLE]); return NS_OK; } @@ -359,14 +362,10 @@ EmbedWindow::GetSiteWindow(void **aSiteWindow) NS_IMETHODIMP EmbedWindow::GetVisibility(PRBool *aVisibility) { - // XXX See bug 312998 - // Work around the problem that sometimes the window - // is already visible even though mVisibility isn't true - // yet. *aVisibility = mVisibility || - (!mOwner->mIsChrome && - mOwner->mOwningWidget && - GTK_WIDGET_MAPPED(mOwner->mOwningWidget)); + !mOwner->mIsChrome && + mOwner->mOwningWidget && + GTK_WIDGET_MAPPED(mOwner->mOwningWidget); return NS_OK; } @@ -383,13 +382,14 @@ EmbedWindow::SetVisibility(PRBool aVisibility) return NS_OK; gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget), - moz_embed_signals[VISIBILITY], - aVisibility); + moz_embed_signals[VISIBILITY], + aVisibility); return NS_OK; } // nsITooltipListener +#if 0 static gint tooltips_paint_window(GtkWidget *window) { @@ -402,10 +402,10 @@ tooltips_paint_window(GtkWidget *window) return FALSE; } - + NS_IMETHODIMP EmbedWindow::OnShowTooltip(PRInt32 aXCoords, PRInt32 aYCoords, - const PRUnichar *aTipText) + const PRUnichar *aTipText) { nsAutoString tipText ( aTipText ); @@ -425,7 +425,7 @@ EmbedWindow::OnShowTooltip(PRInt32 aXCoords, PRInt32 aYCoords, mBaseWindow->GetMainWidget(getter_AddRefs(mainWidget)); GdkWindow *window; window = NS_STATIC_CAST(GdkWindow *, - mainWidget->GetNativeData(NS_NATIVE_WINDOW)); + mainWidget->GetNativeData(NS_NATIVE_WINDOW)); gint root_x, root_y; gdk_window_get_origin(window, &root_x, &root_y); @@ -448,7 +448,7 @@ EmbedWindow::OnShowTooltip(PRInt32 aXCoords, PRInt32 aYCoords, return NS_ERROR_FAILURE; } gtk_window_set_transient_for(GTK_WINDOW(sTipWindow), - GTK_WINDOW(toplevel_window)); + GTK_WINDOW(toplevel_window)); // realize the widget gtk_widget_realize(sTipWindow); @@ -464,13 +464,13 @@ EmbedWindow::OnShowTooltip(PRInt32 aXCoords, PRInt32 aYCoords, gtk_container_set_border_width(GTK_CONTAINER(sTipWindow), 4); // set the coords for the widget gtk_widget_set_uposition(sTipWindow, aXCoords + root_x, - aYCoords + root_y); + aYCoords + root_y); // and show it. gtk_widget_show_all(sTipWindow); #ifdef MOZ_WIDGET_GTK - gtk_widget_popup(sTipWindow, aXCoords + root_x, aYCoords + root_y); + gtk_widget_popup(sTipWindow, aXCoords + root_x, aYCoords + root_y); */ #endif /* MOZ_WIDGET_GTK */ nsMemory::Free( (void*)tipString ); @@ -486,6 +486,7 @@ EmbedWindow::OnHideTooltip(void) sTipWindow = NULL; return NS_OK; } +#endif // nsIInterfaceRequestor diff --git a/mozilla/embedding/browser/gtk/src/EmbedWindow.h b/mozilla/embedding/browser/gtk/src/EmbedWindow.h index c8e4346aaa3..f00288cf479 100644 --- a/mozilla/embedding/browser/gtk/src/EmbedWindow.h +++ b/mozilla/embedding/browser/gtk/src/EmbedWindow.h @@ -1,3 +1,5 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * @@ -38,27 +40,30 @@ #ifndef __EmbedWindow_h #define __EmbedWindow_h -#include +#ifdef MOZILLA_INTERNAL_API +#include "nsString.h" +#else +#include "nsStringAPI.h" +#endif #include #include #include -#include +//#include #include #include #include #include #include -#include "nsString.h" #include class EmbedPrivate; class EmbedWindow : public nsIWebBrowserChrome, - public nsIWebBrowserChromeFocus, + public nsIWebBrowserChromeFocus, public nsIEmbeddingSiteWindow, - public nsITooltipListener, - public nsIInterfaceRequestor +// public nsITooltipListener, + public nsIInterfaceRequestor { public: @@ -78,7 +83,7 @@ class EmbedWindow : public nsIWebBrowserChrome, NS_DECL_NSIEMBEDDINGSITEWINDOW - NS_DECL_NSITOOLTIPLISTENER +// NS_DECL_NSITOOLTIPLISTENER NS_DECL_NSIINTERFACEREQUESTOR diff --git a/mozilla/embedding/browser/gtk/src/EmbedWindowCreator.cpp b/mozilla/embedding/browser/gtk/src/EmbedWindowCreator.cpp index c75f895a9d8..7365d9cb1c3 100644 --- a/mozilla/embedding/browser/gtk/src/EmbedWindowCreator.cpp +++ b/mozilla/embedding/browser/gtk/src/EmbedWindowCreator.cpp @@ -1,3 +1,5 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * @@ -14,7 +16,8 @@ * 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. + * Christopher Blizzard. + * Portions created by Christopher Blizzard are Copyright (C) Christopher Blizzard. All Rights Reserved. * Portions created by the Initial Developer are Copyright (C) 2001 * the Initial Developer. All Rights Reserved. * @@ -42,8 +45,9 @@ // in order to create orphaned windows #include "gtkmozembedprivate.h" -EmbedWindowCreator::EmbedWindowCreator(void) +EmbedWindowCreator::EmbedWindowCreator(PRBool *aOpenBlockPtr) { + mOpenBlock = aOpenBlockPtr; } EmbedWindowCreator::~EmbedWindowCreator() @@ -54,19 +58,24 @@ NS_IMPL_ISUPPORTS1(EmbedWindowCreator, nsIWindowCreator) NS_IMETHODIMP EmbedWindowCreator::CreateChromeWindow(nsIWebBrowserChrome *aParent, - PRUint32 aChromeFlags, - nsIWebBrowserChrome **_retval) + PRUint32 aChromeFlags, + nsIWebBrowserChrome **_retval) { NS_ENSURE_ARG_POINTER(_retval); + if (mOpenBlock) { + if (*mOpenBlock == PR_TRUE) { + *mOpenBlock = PR_FALSE; + return NS_ERROR_FAILURE; + } + } GtkMozEmbed *newEmbed = nsnull; // No parent? Ask via the singleton object instead. if (!aParent) { gtk_moz_embed_single_create_window(&newEmbed, - (guint)aChromeFlags); - } - else { + (guint)aChromeFlags); + } else { // Find the EmbedPrivate object for this web browser chrome object. EmbedPrivate *embedPrivate = EmbedPrivate::FindPrivateForBrowser(aParent); @@ -74,8 +83,8 @@ EmbedWindowCreator::CreateChromeWindow(nsIWebBrowserChrome *aParent, return NS_ERROR_FAILURE; gtk_signal_emit(GTK_OBJECT(embedPrivate->mOwningWidget), - moz_embed_signals[NEW_WINDOW], - &newEmbed, (guint)aChromeFlags); + moz_embed_signals[NEW_WINDOW], + &newEmbed, (guint)aChromeFlags); } @@ -90,14 +99,14 @@ EmbedWindowCreator::CreateChromeWindow(nsIWebBrowserChrome *aParent, gtk_widget_realize(GTK_WIDGET(newEmbed)); EmbedPrivate *newEmbedPrivate = NS_STATIC_CAST(EmbedPrivate *, - newEmbed->data); + newEmbed->data); // set the chrome flag on the new window if it's a chrome open if (aChromeFlags & nsIWebBrowserChrome::CHROME_OPENAS_CHROME) newEmbedPrivate->mIsChrome = PR_TRUE; *_retval = NS_STATIC_CAST(nsIWebBrowserChrome *, - (newEmbedPrivate->mWindow)); + (newEmbedPrivate->mWindow)); if (*_retval) { NS_ADDREF(*_retval); diff --git a/mozilla/embedding/browser/gtk/src/EmbedWindowCreator.h b/mozilla/embedding/browser/gtk/src/EmbedWindowCreator.h index 6a2adbc9cbe..b49bfc0218f 100644 --- a/mozilla/embedding/browser/gtk/src/EmbedWindowCreator.h +++ b/mozilla/embedding/browser/gtk/src/EmbedWindowCreator.h @@ -1,3 +1,5 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * @@ -43,12 +45,14 @@ class EmbedWindowCreator : public nsIWindowCreator { public: - EmbedWindowCreator(); + EmbedWindowCreator(PRBool *aOpenBlockPtr); virtual ~EmbedWindowCreator(); NS_DECL_ISUPPORTS NS_DECL_NSIWINDOWCREATOR + private: + PRBool *mOpenBlock; }; #endif /* __EmbedWindowCreator_h */ diff --git a/mozilla/embedding/browser/gtk/src/GtkPromptService.cpp b/mozilla/embedding/browser/gtk/src/GtkPromptService.cpp index ad614061faf..2b12cdf6fe8 100644 --- a/mozilla/embedding/browser/gtk/src/GtkPromptService.cpp +++ b/mozilla/embedding/browser/gtk/src/GtkPromptService.cpp @@ -1,5 +1,5 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* vim:expandtab:shiftwidth=4:tabstop=4: */ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=4 sts=2 et cindent: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * @@ -22,6 +22,7 @@ * * Contributor(s): * Brian Ryner + * Oleg Romashin * * 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 @@ -38,8 +39,16 @@ * ***** END LICENSE BLOCK ***** */ #include "GtkPromptService.h" +#include "EmbedGtkTools.h" +#include "gtkmozembedprivate.h" +#ifndef MOZ_NO_GECKO_UI_FALLBACK_1_8_COMPAT #include "EmbedPrompter.h" -#include +#endif +#ifdef MOZILLA_INTERNAL_API +#include "nsString.h" +#else +#include "nsStringAPI.h" +#endif #include #include #include @@ -54,295 +63,534 @@ GtkPromptService::~GtkPromptService() { } -NS_IMPL_ISUPPORTS1(GtkPromptService, nsIPromptService) +NS_IMPL_ISUPPORTS2(GtkPromptService, nsIPromptService, nsICookiePromptService) NS_IMETHODIMP -GtkPromptService::Alert(nsIDOMWindow* aParent, const PRUnichar* aDialogTitle, - const PRUnichar* aDialogText) +GtkPromptService::Alert( + nsIDOMWindow* aParent, + const PRUnichar* aDialogTitle, + const PRUnichar* aDialogText) { - EmbedPrompter prompter; - prompter.SetTitle(aDialogTitle ? aDialogTitle : NS_LITERAL_STRING("Alert").get()); - prompter.SetMessageText(aDialogText); - prompter.Create(EmbedPrompter::TYPE_ALERT, - GetGtkWindowForDOMWindow(aParent)); - prompter.Run(); + GtkWidget* parentWidget = GetGtkWidgetForDOMWindow(aParent); + if (parentWidget && gtk_signal_handler_pending(parentWidget, moz_embed_signals[ALERT], TRUE)) { + nsCString dialogTitle, dialogText; + CopyUTF16toUTF8(aDialogTitle, dialogTitle); + CopyUTF16toUTF8(aDialogText, dialogText); + gtk_signal_emit(GTK_OBJECT(parentWidget), + moz_embed_signals[ALERT], + (const gchar *) dialogTitle.get(), (const gchar *) dialogText.get()); return NS_OK; + } +#ifndef MOZ_NO_GECKO_UI_FALLBACK_1_8_COMPAT + EmbedPrompter prompter; + prompter.SetTitle(aDialogTitle ? aDialogTitle : NS_LITERAL_STRING("Alert").get()); + prompter.SetMessageText(aDialogText); + prompter.Create(EmbedPrompter::TYPE_ALERT, + GetGtkWindowForDOMWindow(aParent)); + prompter.Run(); +#endif + return NS_OK; } NS_IMETHODIMP -GtkPromptService::AlertCheck(nsIDOMWindow* aParent, - const PRUnichar* aDialogTitle, - const PRUnichar* aDialogText, - const PRUnichar* aCheckMsg, PRBool* aCheckValue) +GtkPromptService::AlertCheck( + nsIDOMWindow* aParent, + const PRUnichar* aDialogTitle, + const PRUnichar* aDialogText, + const PRUnichar* aCheckMsg, + PRBool* aCheckValue) { - NS_ENSURE_ARG_POINTER(aCheckValue); + NS_ENSURE_ARG_POINTER(aCheckValue); - EmbedPrompter prompter; - prompter.SetTitle(aDialogTitle ? aDialogTitle : NS_LITERAL_STRING("Alert").get()); - prompter.SetMessageText(aDialogText); + GtkWidget* parentWidget = GetGtkWidgetForDOMWindow(aParent); + if (parentWidget && gtk_signal_handler_pending(parentWidget, moz_embed_signals[ALERT_CHECK], TRUE)) { + nsCString dialogTitle, dialogText, checkMsg; + CopyUTF16toUTF8(aDialogTitle, dialogTitle); + CopyUTF16toUTF8(aDialogText, dialogText); + CopyUTF16toUTF8(aCheckMsg, checkMsg); + gtk_signal_emit(GTK_OBJECT(parentWidget), + moz_embed_signals[ALERT_CHECK], + dialogTitle.get(), dialogTitle.get(), checkMsg.get(), aCheckValue); + return NS_OK; + } +#ifndef MOZ_NO_GECKO_UI_FALLBACK_1_8_COMPAT + EmbedPrompter prompter; + prompter.SetTitle(aDialogTitle ? aDialogTitle : NS_LITERAL_STRING("Alert").get()); + prompter.SetMessageText(aDialogText); + prompter.SetCheckMessage(aCheckMsg); + prompter.SetCheckValue(*aCheckValue); + prompter.Create(EmbedPrompter::TYPE_ALERT_CHECK, + GetGtkWindowForDOMWindow(aParent)); + prompter.Run(); + prompter.GetCheckValue(aCheckValue); +#endif + return NS_OK; +} + +NS_IMETHODIMP +GtkPromptService::Confirm( + nsIDOMWindow* aParent, + const PRUnichar* aDialogTitle, + const PRUnichar* aDialogText, PRBool* aConfirm) +{ + GtkWidget* parentWidget = GetGtkWidgetForDOMWindow(aParent); + if (parentWidget && gtk_signal_handler_pending(parentWidget, moz_embed_signals[CONFIRM], TRUE)) { + nsCString dialogTitle, dialogText; + CopyUTF16toUTF8(aDialogTitle, dialogTitle); + CopyUTF16toUTF8(aDialogText, dialogText); + gtk_signal_emit(GTK_OBJECT(parentWidget), + moz_embed_signals[CONFIRM], + dialogTitle.get(), dialogText.get(), aConfirm); + return NS_OK; + } +#ifndef MOZ_NO_GECKO_UI_FALLBACK_1_8_COMPAT + EmbedPrompter prompter; + prompter.SetTitle(aDialogTitle ? aDialogTitle : NS_LITERAL_STRING("Confirm").get()); + prompter.SetMessageText(aDialogText); + prompter.Create(EmbedPrompter::TYPE_CONFIRM, + GetGtkWindowForDOMWindow(aParent)); + prompter.Run(); + prompter.GetConfirmValue(aConfirm); +#endif + return NS_OK; +} + +NS_IMETHODIMP +GtkPromptService::ConfirmCheck( + nsIDOMWindow* aParent, + const PRUnichar* aDialogTitle, + const PRUnichar* aDialogText, + const PRUnichar* aCheckMsg, + PRBool* aCheckValue, + PRBool* aConfirm) +{ + NS_ENSURE_ARG_POINTER(aCheckValue); + + GtkWidget* parentWidget = GetGtkWidgetForDOMWindow(aParent); + if (parentWidget && gtk_signal_handler_pending(parentWidget, moz_embed_signals[CONFIRM_CHECK], TRUE)) { + nsCString dialogTitle, dialogText, checkMsg; + CopyUTF16toUTF8(aDialogTitle, dialogTitle); + CopyUTF16toUTF8(aDialogText, dialogText); + CopyUTF16toUTF8(aCheckMsg, checkMsg); + gtk_signal_emit(GTK_OBJECT(parentWidget), + moz_embed_signals[CONFIRM_CHECK], + dialogTitle.get(), + dialogTitle.get(), + checkMsg.get(), + aCheckValue, + aConfirm); + return NS_OK; + } +#ifndef MOZ_NO_GECKO_UI_FALLBACK_1_8_COMPAT + EmbedPrompter prompter; + prompter.SetTitle(aDialogTitle ? aDialogTitle : NS_LITERAL_STRING("Confirm").get()); + prompter.SetMessageText(aDialogText); + prompter.SetCheckMessage(aCheckMsg); + prompter.SetCheckValue(*aCheckValue); + prompter.Create(EmbedPrompter::TYPE_CONFIRM_CHECK, + GetGtkWindowForDOMWindow(aParent)); + prompter.Run(); + prompter.GetCheckValue(aCheckValue); + prompter.GetConfirmValue(aConfirm); +#endif + return NS_OK; +} + +NS_IMETHODIMP +GtkPromptService::ConfirmEx( + nsIDOMWindow* aParent, + const PRUnichar* aDialogTitle, + const PRUnichar* aDialogText, + PRUint32 aButtonFlags, + const PRUnichar* aButton0Title, + const PRUnichar* aButton1Title, + const PRUnichar* aButton2Title, + const PRUnichar* aCheckMsg, + PRBool* aCheckValue, + PRInt32* aRetVal) +{ + GtkWidget* parentWidget = GetGtkWidgetForDOMWindow(aParent); + if (parentWidget && gtk_signal_handler_pending(parentWidget, moz_embed_signals[CONFIRM_EX], TRUE)) { + nsCString dialogTitle, dialogText, checkMsg; + nsCString button0,button1,button2; + CopyUTF16toUTF8(aDialogTitle, dialogTitle); + CopyUTF16toUTF8(aDialogText, dialogText); + CopyUTF16toUTF8(aCheckMsg, checkMsg); + CopyUTF16toUTF8(aButton0Title, button0); + CopyUTF16toUTF8(aButton1Title, button1); + CopyUTF16toUTF8(aButton2Title, button2); + gtk_signal_emit(GTK_OBJECT(parentWidget), + moz_embed_signals[CONFIRM_EX], + dialogTitle.get(), + dialogTitle.get(), + aButtonFlags, + button0.get(), + button1.get(), + button2.get(), + checkMsg.get(), + aCheckValue, + aRetVal); + return NS_OK; + } +#ifndef MOZ_NO_GECKO_UI_FALLBACK_1_8_COMPAT + EmbedPrompter prompter; + prompter.SetTitle(aDialogTitle ? aDialogTitle : NS_LITERAL_STRING("Confirm").get()); + prompter.SetMessageText(aDialogText); + + nsAutoString button0Label, button1Label, button2Label; + GetButtonLabel(aButtonFlags, BUTTON_POS_0, aButton0Title, button0Label); + GetButtonLabel(aButtonFlags, BUTTON_POS_1, aButton1Title, button1Label); + GetButtonLabel(aButtonFlags, BUTTON_POS_2, aButton2Title, button2Label); + prompter.SetButtons(button0Label.get(), + button1Label.get(), + button2Label.get()); + + if (aCheckMsg) prompter.SetCheckMessage(aCheckMsg); + if (aCheckValue) prompter.SetCheckValue(*aCheckValue); - prompter.Create(EmbedPrompter::TYPE_ALERT_CHECK, - GetGtkWindowForDOMWindow(aParent)); - prompter.Run(); + + prompter.Create(EmbedPrompter::TYPE_UNIVERSAL, + GetGtkWindowForDOMWindow(aParent)); + prompter.Run(); + + if (aCheckValue) prompter.GetCheckValue(aCheckValue); - return NS_OK; + + prompter.GetButtonPressed(aRetVal); +#endif + + return NS_OK; } NS_IMETHODIMP -GtkPromptService::Confirm(nsIDOMWindow* aParent, - const PRUnichar* aDialogTitle, - const PRUnichar* aDialogText, PRBool* aConfirm) +GtkPromptService::Prompt( + nsIDOMWindow* aParent, + const PRUnichar* aDialogTitle, + const PRUnichar* aDialogText, + PRUnichar** aValue, + const PRUnichar* aCheckMsg, + PRBool* aCheckValue, + PRBool* aConfirm) { - EmbedPrompter prompter; - prompter.SetTitle(aDialogTitle ? aDialogTitle : NS_LITERAL_STRING("Confirm").get()); - prompter.SetMessageText(aDialogText); - prompter.Create(EmbedPrompter::TYPE_CONFIRM, - GetGtkWindowForDOMWindow(aParent)); - prompter.Run(); - prompter.GetConfirmValue(aConfirm); + GtkWidget* parentWidget = GetGtkWidgetForDOMWindow(aParent); + if (parentWidget && gtk_signal_handler_pending(parentWidget, moz_embed_signals[PROMPT], TRUE)) { + nsCString dialogTitle, dialogText, checkMsg, retValue; + CopyUTF16toUTF8(aDialogTitle, dialogTitle); + CopyUTF16toUTF8(aDialogText, dialogText); + CopyUTF16toUTF8(aCheckMsg, checkMsg); + CopyUTF16toUTF8(*aValue, retValue); + gchar * aGValue = g_strdup(retValue.get()); + gtk_signal_emit(GTK_OBJECT(parentWidget), + moz_embed_signals[PROMPT], + dialogTitle.get(), + dialogText.get(), + &aGValue, + checkMsg.get(), + aCheckValue, + aConfirm, + NULL); + if (*aConfirm) { + if (*aValue) + NS_Free(*aValue); + retValue.Assign(aGValue); + *aValue = UTF8ToNewUnicode(retValue); + } + g_free(aGValue); return NS_OK; -} - -NS_IMETHODIMP -GtkPromptService::ConfirmCheck(nsIDOMWindow* aParent, - const PRUnichar* aDialogTitle, - const PRUnichar* aDialogText, - const PRUnichar* aCheckMsg, - PRBool* aCheckValue, PRBool* aConfirm) -{ - NS_ENSURE_ARG_POINTER(aCheckValue); - - EmbedPrompter prompter; - prompter.SetTitle(aDialogTitle ? aDialogTitle : NS_LITERAL_STRING("Confirm").get()); - prompter.SetMessageText(aDialogText); + } +#ifndef MOZ_NO_GECKO_UI_FALLBACK_1_8_COMPAT + EmbedPrompter prompter; + prompter.SetTitle(aDialogTitle ? aDialogTitle : NS_LITERAL_STRING("Prompt").get()); + prompter.SetMessageText(aDialogText); + prompter.SetTextValue(*aValue); + if (aCheckMsg) prompter.SetCheckMessage(aCheckMsg); + if (aCheckValue) prompter.SetCheckValue(*aCheckValue); - prompter.Create(EmbedPrompter::TYPE_CONFIRM_CHECK, - GetGtkWindowForDOMWindow(aParent)); - prompter.Run(); + + prompter.Create(EmbedPrompter::TYPE_PROMPT, + GetGtkWindowForDOMWindow(aParent)); + prompter.Run(); + if (aCheckValue) prompter.GetCheckValue(aCheckValue); - prompter.GetConfirmValue(aConfirm); - return NS_OK; + prompter.GetConfirmValue(aConfirm); + if (*aConfirm) { + if (*aValue) + NS_Free(*aValue); + prompter.GetTextValue(aValue); + } +#endif + return NS_OK; } NS_IMETHODIMP -GtkPromptService::ConfirmEx(nsIDOMWindow* aParent, - const PRUnichar* aDialogTitle, - const PRUnichar* aDialogText, - PRUint32 aButtonFlags, - const PRUnichar* aButton0Title, - const PRUnichar* aButton1Title, - const PRUnichar* aButton2Title, - const PRUnichar* aCheckMsg, PRBool* aCheckValue, - PRInt32* aRetVal) +GtkPromptService::PromptUsernameAndPassword( + nsIDOMWindow* aParent, + const PRUnichar* aDialogTitle, + const PRUnichar* aDialogText, + PRUnichar** aUsername, + PRUnichar** aPassword, + const PRUnichar* aCheckMsg, + PRBool* aCheckValue, + PRBool* aConfirm) { - EmbedPrompter prompter; - prompter.SetTitle(aDialogTitle ? aDialogTitle : NS_LITERAL_STRING("Confirm").get()); - prompter.SetMessageText(aDialogText); - - nsAutoString button0Label, button1Label, button2Label; - GetButtonLabel(aButtonFlags, BUTTON_POS_0, aButton0Title, button0Label); - GetButtonLabel(aButtonFlags, BUTTON_POS_1, aButton1Title, button1Label); - GetButtonLabel(aButtonFlags, BUTTON_POS_2, aButton2Title, button2Label); - prompter.SetButtons(button0Label.get(), button1Label.get(), - button2Label.get()); - - if (aCheckMsg) - prompter.SetCheckMessage(aCheckMsg); - if (aCheckValue) - prompter.SetCheckValue(*aCheckValue); - - prompter.Create(EmbedPrompter::TYPE_UNIVERSAL, - GetGtkWindowForDOMWindow(aParent)); - prompter.Run(); - - if (aCheckValue) - prompter.GetCheckValue(aCheckValue); - - prompter.GetButtonPressed(aRetVal); - - return NS_OK; -} - -NS_IMETHODIMP -GtkPromptService::Prompt(nsIDOMWindow* aParent, const PRUnichar* aDialogTitle, - const PRUnichar* aDialogText, PRUnichar** aValue, - const PRUnichar* aCheckMsg, PRBool* aCheckValue, - PRBool* aConfirm) -{ - EmbedPrompter prompter; - prompter.SetTitle(aDialogTitle ? aDialogTitle : NS_LITERAL_STRING("Prompt").get()); - prompter.SetMessageText(aDialogText); - prompter.SetTextValue(*aValue); - if (aCheckMsg) - prompter.SetCheckMessage(aCheckMsg); - if (aCheckValue) - prompter.SetCheckValue(*aCheckValue); - - prompter.Create(EmbedPrompter::TYPE_PROMPT, - GetGtkWindowForDOMWindow(aParent)); - prompter.Run(); - if (aCheckValue) - prompter.GetCheckValue(aCheckValue); - prompter.GetConfirmValue(aConfirm); + GtkWidget* parentWidget = GetGtkWidgetForDOMWindow(aParent); + if (parentWidget && gtk_signal_handler_pending(parentWidget, moz_embed_signals[PROMPT_AUTH], TRUE)) { + nsCString dialogTitle, dialogText, checkMsg, retUsername, retPassword; + CopyUTF16toUTF8(aDialogTitle, dialogTitle); + CopyUTF16toUTF8(aDialogText, dialogText); + CopyUTF16toUTF8(aCheckMsg, checkMsg); + CopyUTF16toUTF8(*aUsername, retUsername); + CopyUTF16toUTF8(*aPassword, retPassword); + gchar * aGUsername = g_strdup(retUsername.get()); + gchar * aGPassword = g_strdup(retPassword.get()); + // FIXME: it is not working. CheckValue has no effect. + if (!aCheckValue) + aCheckValue = (PRBool *) malloc (sizeof (PRBool)); + gtk_signal_emit(GTK_OBJECT(parentWidget), + moz_embed_signals[PROMPT_AUTH], + dialogTitle.get(), dialogText.get(), &aGUsername, + &aGPassword, checkMsg.get(), aCheckValue, aConfirm); if (*aConfirm) { - if (*aValue) - nsMemory::Free(*aValue); - prompter.GetTextValue(aValue); + if (*aUsername) + NS_Free(*aUsername); + retUsername.Assign(aGUsername); + *aUsername = UTF8ToNewUnicode(retUsername); + if (*aPassword) + NS_Free(*aPassword); + retPassword.Assign(aGPassword); + *aPassword = UTF8ToNewUnicode(retPassword); } + g_free(aGUsername); + g_free(aGPassword); return NS_OK; + } +#ifndef MOZ_NO_GECKO_UI_FALLBACK_1_8_COMPAT + EmbedPrompter prompter; + prompter.SetTitle(aDialogTitle ? aDialogTitle : NS_LITERAL_STRING("Prompt").get()); + prompter.SetMessageText(aDialogText); + prompter.SetUser(*aUsername); + prompter.SetPassword(*aPassword); + if (aCheckMsg) + prompter.SetCheckMessage(aCheckMsg); + if (aCheckValue) + prompter.SetCheckValue(*aCheckValue); + + prompter.Create(EmbedPrompter::TYPE_PROMPT_USER_PASS, + GetGtkWindowForDOMWindow(aParent)); + prompter.Run(); + if (aCheckValue) + prompter.GetCheckValue(aCheckValue); + prompter.GetConfirmValue(aConfirm); + if (*aConfirm) { + if (*aUsername) + NS_Free(*aUsername); + prompter.GetUser(aUsername); + + if (*aPassword) + NS_Free(*aPassword); + prompter.GetPassword(aPassword); + } +#endif + return NS_OK; } NS_IMETHODIMP -GtkPromptService::PromptUsernameAndPassword(nsIDOMWindow* aParent, - const PRUnichar* aDialogTitle, - const PRUnichar* aDialogText, - PRUnichar** aUsername, - PRUnichar** aPassword, - const PRUnichar* aCheckMsg, - PRBool* aCheckValue, - PRBool* aConfirm) +GtkPromptService::PromptPassword( + nsIDOMWindow* aParent, + const PRUnichar* aDialogTitle, + const PRUnichar* aDialogText, + PRUnichar** aPassword, + const PRUnichar* aCheckMsg, + PRBool* aCheckValue, PRBool* aConfirm) { - EmbedPrompter prompter; - prompter.SetTitle(aDialogTitle ? aDialogTitle : NS_LITERAL_STRING("Prompt").get()); - prompter.SetMessageText(aDialogText); - prompter.SetUser(*aUsername); - prompter.SetPassword(*aPassword); - if (aCheckMsg) - prompter.SetCheckMessage(aCheckMsg); - if (aCheckValue) - prompter.SetCheckValue(*aCheckValue); - - prompter.Create(EmbedPrompter::TYPE_PROMPT_USER_PASS, - GetGtkWindowForDOMWindow(aParent)); - prompter.Run(); - if (aCheckValue) - prompter.GetCheckValue(aCheckValue); - prompter.GetConfirmValue(aConfirm); + GtkWidget* parentWidget = GetGtkWidgetForDOMWindow(aParent); + if (parentWidget && gtk_signal_handler_pending(parentWidget, moz_embed_signals[PROMPT_AUTH], TRUE)) { + nsCString dialogTitle, dialogText, checkMsg, retPassword; + CopyUTF16toUTF8(aDialogTitle, dialogTitle); + CopyUTF16toUTF8(aDialogText, dialogText); + CopyUTF16toUTF8(aCheckMsg, checkMsg); + CopyUTF16toUTF8(*aPassword, retPassword); + gchar * aGPassword = g_strdup(retPassword.get()); + gtk_signal_emit( + GTK_OBJECT(parentWidget), + moz_embed_signals[PROMPT_AUTH], + dialogTitle.get(), + dialogText.get(), + NULL, + &aGPassword, + checkMsg.get(), + aCheckValue, + aConfirm); if (*aConfirm) { - if (*aUsername) - nsMemory::Free(*aUsername); - prompter.GetUser(aUsername); - - if (*aPassword) - nsMemory::Free(*aPassword); - prompter.GetPassword(aPassword); + if (*aPassword) + NS_Free(*aPassword); + retPassword.Assign(aGPassword); + *aPassword = UTF8ToNewUnicode(retPassword); } + g_free(aGPassword); return NS_OK; + } +#ifndef MOZ_NO_GECKO_UI_FALLBACK_1_8_COMPAT + EmbedPrompter prompter; + prompter.SetTitle(aDialogTitle ? aDialogTitle : NS_LITERAL_STRING("Prompt").get()); + prompter.SetMessageText(aDialogText); + prompter.SetPassword(*aPassword); + if (aCheckMsg) + prompter.SetCheckMessage(aCheckMsg); + if (aCheckValue) + prompter.SetCheckValue(*aCheckValue); + + prompter.Create(EmbedPrompter::TYPE_PROMPT_PASS, + GetGtkWindowForDOMWindow(aParent)); + prompter.Run(); + if (aCheckValue) + prompter.GetCheckValue(aCheckValue); + prompter.GetConfirmValue(aConfirm); + if (*aConfirm) { + if (*aPassword) + NS_Free(*aPassword); + prompter.GetPassword(aPassword); + } +#endif + return NS_OK; } NS_IMETHODIMP -GtkPromptService::PromptPassword(nsIDOMWindow* aParent, - const PRUnichar* aDialogTitle, - const PRUnichar* aDialogText, - PRUnichar** aPassword, - const PRUnichar* aCheckMsg, - PRBool* aCheckValue, PRBool* aConfirm) +GtkPromptService::Select( + nsIDOMWindow* aParent, + const PRUnichar* aDialogTitle, + const PRUnichar* aDialogText, + PRUint32 aCount, + const PRUnichar** aSelectList, + PRInt32* outSelection, + PRBool* aConfirm) { - EmbedPrompter prompter; - prompter.SetTitle(aDialogTitle ? aDialogTitle : NS_LITERAL_STRING("Prompt").get()); - prompter.SetMessageText(aDialogText); - prompter.SetPassword(*aPassword); - if (aCheckMsg) - prompter.SetCheckMessage(aCheckMsg); - if (aCheckValue) - prompter.SetCheckValue(*aCheckValue); - - prompter.Create(EmbedPrompter::TYPE_PROMPT_PASS, - GetGtkWindowForDOMWindow(aParent)); - prompter.Run(); - if (aCheckValue) - prompter.GetCheckValue(aCheckValue); - prompter.GetConfirmValue(aConfirm); - if (*aConfirm) { - if (*aPassword) - nsMemory::Free(*aPassword); - prompter.GetPassword(aPassword); + GtkWidget* parentWidget = GetGtkWidgetForDOMWindow(aParent); + if (parentWidget && gtk_signal_handler_pending(parentWidget, moz_embed_signals[SELECT], TRUE)) { + nsCString dialogTitle, dialogText; + CopyUTF16toUTF8(aDialogTitle, dialogTitle); + CopyUTF16toUTF8(aDialogText, dialogText); + GList * list = NULL; + nsCString *itemList = new nsCString[aCount]; + NS_ENSURE_TRUE(itemList, NS_ERROR_OUT_OF_MEMORY); + for (PRUint32 i = 0; i < aCount; ++i) { + CopyUTF16toUTF8(aSelectList[i], itemList[i]); + list = g_list_append(list, (gpointer)itemList[i].get()); } + gtk_signal_emit( + GTK_OBJECT(parentWidget), + moz_embed_signals[SELECT], + dialogTitle.get(), + dialogText.get(), + (const GList**)&list, + outSelection, + aConfirm); + delete[] itemList; + g_list_free(list); return NS_OK; + } +#ifndef MOZ_NO_GECKO_UI_FALLBACK_1_8_COMPAT + EmbedPrompter prompter; + prompter.SetTitle(aDialogTitle ? aDialogTitle : NS_LITERAL_STRING("Select").get()); + prompter.SetMessageText(aDialogText); + prompter.SetItems(aSelectList, aCount); + prompter.Create(EmbedPrompter::TYPE_SELECT, + GetGtkWindowForDOMWindow(aParent)); + prompter.Run(); + prompter.GetSelectedItem(outSelection); + prompter.GetConfirmValue(aConfirm); +#endif + return NS_OK; } - +/* nsCookiePromptService */ NS_IMETHODIMP -GtkPromptService::Select(nsIDOMWindow* aParent, const PRUnichar* aDialogTitle, - const PRUnichar* aDialogText, PRUint32 aCount, - const PRUnichar** aSelectList, PRInt32* outSelection, - PRBool* aConfirm) +GtkPromptService::CookieDialog( + nsIDOMWindow *aParent, + nsICookie *aCookie, + const nsACString &aHostname, + PRInt32 aCookiesFromHost, + PRBool aChangingCookie, + PRBool *aRememberDecision, + PRInt32 *aAccept) { - EmbedPrompter prompter; - prompter.SetTitle(aDialogTitle ? aDialogTitle : NS_LITERAL_STRING("Select").get()); - prompter.SetMessageText(aDialogText); - prompter.SetItems(aSelectList, aCount); - prompter.Create(EmbedPrompter::TYPE_SELECT, - GetGtkWindowForDOMWindow(aParent)); - prompter.Run(); - prompter.GetSelectedItem(outSelection); - prompter.GetConfirmValue(aConfirm); - return NS_OK; -} - -GtkWindow* -GtkPromptService::GetGtkWindowForDOMWindow(nsIDOMWindow* aDOMWindow) -{ - nsCOMPtr wwatch = do_GetService("@mozilla.org/embedcomp/window-watcher;1"); - - if (!aDOMWindow) - return NULL; - - nsCOMPtr chrome; - wwatch->GetChromeForWindow(aDOMWindow, getter_AddRefs(chrome)); - nsCOMPtr siteWindow = do_QueryInterface(chrome); - - if (!siteWindow) - return NULL; - - GtkWidget* parentWidget; - siteWindow->GetSiteWindow((void**)&parentWidget); - - if (!parentWidget) - return NULL; - - GtkWidget* gtkWin = gtk_widget_get_toplevel(parentWidget); - if (GTK_WIDGET_TOPLEVEL(gtkWin)) - return GTK_WINDOW(gtkWin); - - return NULL; + /* FIXME - missing gint actions and gboolean illegal_path */ + gint actions = 1; + nsCString hostName (aHostname); + nsCString aName; + aCookie->GetName(aName); + nsCString aValue; + aCookie->GetValue(aValue); + nsCString aDomain; + aCookie->GetHost(aDomain); + nsCString aPath; + aCookie->GetPath(aPath); + /* We have to investigate a value to use here */ + gboolean illegal_path = FALSE; + PRUint64 aExpires; + aCookie->GetExpires(&aExpires); + nsCOMPtr domWindow (do_QueryInterface (aParent)); + GtkMozEmbed *parentWidget = GTK_MOZ_EMBED(GetGtkWidgetForDOMWindow(domWindow)); + GtkMozEmbedCookie *cookie_struct = g_new0(GtkMozEmbedCookie, 1); + if (parentWidget && cookie_struct) { + g_signal_emit_by_name( + GTK_OBJECT(parentWidget->common), + "ask-cookie", + cookie_struct, + actions, + (const gchar *) hostName.get (), + (const gchar *) aName.get(), + (const gchar *) aValue.get(), + (const gchar *) aDomain.get(), + (const gchar *) aPath.get(), + illegal_path, + aExpires, + NULL); + } + *aRememberDecision = cookie_struct->remember_decision; + *aAccept = cookie_struct->accept; + return NS_OK; } +#ifndef MOZ_NO_GECKO_UI_FALLBACK_1_8_COMPAT void -GtkPromptService::GetButtonLabel(PRUint32 aFlags, PRUint32 aPos, - const PRUnichar* aStringValue, - nsAString& aLabel) +GtkPromptService::GetButtonLabel( + PRUint32 aFlags, + PRUint32 aPos, + const PRUnichar* aStringValue, + nsAString& aLabel) { - PRUint32 posFlag = (aFlags & (255 * aPos)) / aPos; - switch (posFlag) { - case 0: - break; - case BUTTON_TITLE_OK: - aLabel.AssignLiteral(GTK_STOCK_OK); - break; - case BUTTON_TITLE_CANCEL: - aLabel.AssignLiteral(GTK_STOCK_CANCEL); - break; - case BUTTON_TITLE_YES: - aLabel.AssignLiteral(GTK_STOCK_YES); - break; - case BUTTON_TITLE_NO: - aLabel.AssignLiteral(GTK_STOCK_NO); - break; - case BUTTON_TITLE_SAVE: - aLabel.AssignLiteral(GTK_STOCK_SAVE); - break; - case BUTTON_TITLE_DONT_SAVE: - aLabel.AssignLiteral("Don't Save"); - break; - case BUTTON_TITLE_REVERT: - aLabel.AssignLiteral("Revert"); - break; - case BUTTON_TITLE_IS_STRING: - aLabel = aStringValue; - break; - default: - NS_WARNING("Unexpected button flags"); - } + PRUint32 posFlag = (aFlags & (255 * aPos)) / aPos; + switch (posFlag) { + case 0: + break; + case BUTTON_TITLE_OK: + aLabel.AssignLiteral(GTK_STOCK_OK); + break; + case BUTTON_TITLE_CANCEL: + aLabel.AssignLiteral(GTK_STOCK_CANCEL); + break; + case BUTTON_TITLE_YES: + aLabel.AssignLiteral(GTK_STOCK_YES); + break; + case BUTTON_TITLE_NO: + aLabel.AssignLiteral(GTK_STOCK_NO); + break; + case BUTTON_TITLE_SAVE: + aLabel.AssignLiteral(GTK_STOCK_SAVE); + break; + case BUTTON_TITLE_DONT_SAVE: + aLabel.AssignLiteral("Don't Save"); + break; + case BUTTON_TITLE_REVERT: + aLabel.AssignLiteral("Revert"); + break; + case BUTTON_TITLE_IS_STRING: + aLabel = aStringValue; + break; + default: + NS_WARNING("Unexpected button flags"); + } } +#endif diff --git a/mozilla/embedding/browser/gtk/src/GtkPromptService.h b/mozilla/embedding/browser/gtk/src/GtkPromptService.h index 76ac4c25ace..df80e36313d 100644 --- a/mozilla/embedding/browser/gtk/src/GtkPromptService.h +++ b/mozilla/embedding/browser/gtk/src/GtkPromptService.h @@ -1,5 +1,5 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* vim:expandtab:shiftwidth=4:tabstop=4: */ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * @@ -22,6 +22,7 @@ * * Contributor(s): * Brian Ryner + * Oleg Romashin * * 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 @@ -38,12 +39,22 @@ * ***** END LICENSE BLOCK ***** */ #include -#include +#include +#include +#include #include +#ifdef MOZILLA_INTERNAL_API +#include "nsString.h" +#else +#include "nsStringAPI.h" +#endif +#define NS_PROMPTSERVICE_CID \ + {0x95611356, 0xf583, 0x46f5, {0x81, 0xff, 0x4b, 0x3e, 0x01, 0x62, 0xc6, 0x19}} class nsIDOMWindow; -class GtkPromptService : public nsIPromptService +class GtkPromptService : public nsIPromptService, + public nsICookiePromptService { public: GtkPromptService(); @@ -51,9 +62,11 @@ public: NS_DECL_ISUPPORTS NS_DECL_NSIPROMPTSERVICE + NS_DECL_NSICOOKIEPROMPTSERVICE +#ifndef MOZ_NO_GECKO_UI_FALLBACK_1_8_COMPAT private: - GtkWindow* GetGtkWindowForDOMWindow(nsIDOMWindow* aDOMWindow); void GetButtonLabel(PRUint32 aFlags, PRUint32 aPos, const PRUnichar* aStringValue, nsAString &aLabel); +#endif }; diff --git a/mozilla/embedding/browser/gtk/src/Makefile.in b/mozilla/embedding/browser/gtk/src/Makefile.in index b169151b3c6..002b64d8ff8 100644 --- a/mozilla/embedding/browser/gtk/src/Makefile.in +++ b/mozilla/embedding/browser/gtk/src/Makefile.in @@ -47,23 +47,73 @@ MODULE = gtkembedmoz LIBRARY_NAME = gtkembedmoz LIBXUL_LIBRARY = 1 FORCE_STATIC_LIB = 1 + +#Define for building GtkmozEmbed with MOZILLA_1_8_BRANCH +#MOZILLA_1_8_BRANCH = 1 + +ifdef MOZILLA_1_8_BRANCH +MOZ_GTKEMBED_DYN = 1 +DEFINES += -DMOZILLA_1_8_BRANCH +endif + +ifdef MOZ_MICROBEMBED_DYN +MOZ_GTKEMBED_DYN = 1 +endif + +ifdef MOZ_GTKEMBED_DYN +FORCE_SHARED_LIB = 1 +MOZILLA_INTERNAL_API = 1 +DEFINES += -DMOZILLA_INTERNAL_API +endif + DEFINES += -DIMPL_XREAPI +# New Stuff in GtkMozEmbed +ifdef MOZ_MICROBEMBED +DEFINES += -DBAD_CERT_LISTENER2 +#Probably scrolling can be fixed without this hack +DEFINES += -DMOZ_SCROLL_TOP_LEFT_HACK + +MOZ_NO_GECKO_UI_FALLBACK_1_8_COMPAT = 1 +DEFINES += -DMOZ_NO_GECKO_UI_FALLBACK_1_8_COMPAT + +MOZ_GTKPASSWORD_INTERFACE = 1 +DEFINES += -DMOZ_GTKPASSWORD_INTERFACE +endif + REQUIRES = xpcom \ string \ + content \ docshell \ necko \ widget \ dom \ gfx \ + intl \ + imglib2 \ layout \ + locale \ + unicharutil \ uriloader \ webbrwsr \ shistory \ + composer \ + editor \ embed_base \ windowwatcher \ + webshell \ + pipnss \ + history \ profdirserviceprovider \ + pref \ + nspr \ xulapp \ + exthandler \ + mimetype \ + chardet \ + find \ + webbrowserpersist \ + cookie \ $(NULL) ifdef ACCESSIBILITY @@ -72,29 +122,75 @@ endif CPPSRCS = \ gtkmozembed2.cpp \ + gtkmozembed_common.cpp \ + gtkmozembed_download.cpp \ EmbedPrivate.cpp \ EmbedWindow.cpp \ EmbedProgress.cpp \ EmbedContentListener.cpp \ EmbedEventListener.cpp \ + EmbedContextMenuInfo.cpp \ EmbedWindowCreator.cpp \ + EmbedCertificates.cpp \ + EmbedDownloadMgr.cpp \ + EmbedGlobalHistory.cpp \ + EmbedFilePicker.cpp \ $(NULL) +ifdef MOZ_GTKPASSWORD_INTERFACE +CPPSRCS += \ + EmbedPasswordMgr.cpp \ + $(NULL) + +XPIDLSRCS += \ + nsIPassword.idl \ + nsIPasswordInternal.idl \ + $(NULL) +endif + ifdef MOZ_ENABLE_GTK2 CSRCS = \ gtkmozembedmarshal.c + +CPPSRCS += \ + EmbedGtkTools.cpp \ + GtkPromptService.cpp \ + $(NULL) + +ifndef MOZ_NO_GECKO_UI_FALLBACK_1_8_COMPAT CPPSRCS += \ EmbedPrompter.cpp \ - GtkPromptService.cpp + $(NULL) +endif endif include $(topsrcdir)/config/config.mk +ifdef MOZILLA_1_8_BRANCH +SHARED_LIBRARY_LIBS += \ + $(DIST)/lib/libembed_base_s.$(LIB_SUFFIX) \ + $(DIST)/lib/libprofdirserviceprovider_s.$(LIB_SUFFIX) \ + $(NULL) +endif + EXPORTS = \ gtkmozembed.h \ + gtkmozembed_common.h \ + gtkmozembed_download.h \ gtkmozembed_glue.cpp \ gtkmozembed_internal.h +ifdef MOZ_GTKEMBED_DYN +ifdef MOZ_ENABLE_GTK +EXTRA_DSO_LDOPTS += -L$(DIST)/lib -lgtksuperwin +endif + +ifneq (,$(filter gtk gtk2 qt xlib,$(MOZ_WIDGET_TOOLKIT))) +EXTRA_DSO_LDOPTS += $(XLDFLAGS) $(XLIBS) $(MOZ_GTK_LDFLAGS) $(MOZ_XFT_LIBS) $(MOZ_GTK2_LIBS) $(XT_LIBS) $(MOZ_COMPONENT_LIBS) $(MOZ_GNOMEVFS_LIBS) $(DIST)/lib/libxpcom_core.a +endif + +endif + include $(topsrcdir)/config/rules.mk ifeq ($(OS_ARCH), SunOS) @@ -108,8 +204,22 @@ DEFINES += -D_TIME_H=1 endif endif -CXXFLAGS += $(MOZ_GTK_CFLAGS) $(MOZ_GTK2_CFLAGS) -CFLAGS += $(MOZ_GTK_CFLAGS) $(MOZ_GTK2_CFLAGS) +CXXFLAGS += $(MOZ_GTK_CFLAGS) $(MOZ_GTK2_CFLAGS) $(MOZ_GNOMEVFS_CFLAGS) +CFLAGS += $(MOZ_GTK_CFLAGS) $(MOZ_GTK2_CFLAGS) $(MOZ_GNOMEVFS_CFLAGS) DEFINES += -D_IMPL_GTKMOZEMBED +MARSHAL_FILE = gtkmozembedmarshal +MARSHAL_PREFIX = gtkmozembed + +$(MARSHAL_FILE).h: $(MARSHAL_FILE).list + ( glib-genmarshal --prefix=$(MARSHAL_PREFIX) $(srcdir)/$(MARSHAL_FILE).list --skip-source --header > $(srcdir)/$(MARSHAL_FILE).htmp \ + && mv $(srcdir)/$(MARSHAL_FILE).htmp $(srcdir)/$(MARSHAL_FILE).h && cp -f $(srcdir)/$(MARSHAL_FILE).h $(MARSHAL_FILE).h ) \ + || ( rm -f $(srcdir)/$(MARSHAL_FILE).htmp && exit 1 ) + +$(MARSHAL_FILE).c: $(MARSHAL_FILE).list $(MARSHAL_FILE).h + ( glib-genmarshal --prefix=$(MARSHAL_PREFIX) $(srcdir)/$(MARSHAL_FILE).list --skip-source --body > $(srcdir)/$(MARSHAL_FILE).ctmp \ + && mv $(srcdir)/$(MARSHAL_FILE).ctmp $(srcdir)/$(MARSHAL_FILE).c && cp -f $(srcdir)/$(MARSHAL_FILE).c $(MARSHAL_FILE).c ) \ + || ( rm -f $(srcdir)/$(MARSHAL_FILE).ctmp && exit 1 ) + + diff --git a/mozilla/embedding/browser/gtk/src/gtkmozembed.h b/mozilla/embedding/browser/gtk/src/gtkmozembed.h index 638ca700672..01e2ac31a06 100644 --- a/mozilla/embedding/browser/gtk/src/gtkmozembed.h +++ b/mozilla/embedding/browser/gtk/src/gtkmozembed.h @@ -1,3 +1,5 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 tw=80 et cindent: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * @@ -21,6 +23,8 @@ * Contributor(s): * Christopher Blizzard * Ramiro Estrugo + * Oleg Romashin + * Antonio Gomes * * 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 @@ -45,6 +49,7 @@ extern "C" { #include #include +#include #ifdef MOZILLA_CLIENT #include "nscore.h" @@ -81,19 +86,35 @@ extern "C" { #endif // XPCOM_GLUE +#include "gtkmozembed_common.h" #define GTK_TYPE_MOZ_EMBED (gtk_moz_embed_get_type()) #define GTK_MOZ_EMBED(obj) GTK_CHECK_CAST((obj), GTK_TYPE_MOZ_EMBED, GtkMozEmbed) #define GTK_MOZ_EMBED_CLASS(klass) GTK_CHECK_CLASS_CAST((klass), GTK_TYPE_MOZ_EMBED, GtkMozEmbedClass) #define GTK_IS_MOZ_EMBED(obj) GTK_CHECK_TYPE((obj), GTK_TYPE_MOZ_EMBED) #define GTK_IS_MOZ_EMBED_CLASS(klass) GTK_CHECK_CLASS_TYPE((klass), GTK_TYPE_MOZ_EMBED) +typedef enum +{ + ZOOM_SIMPLE, + ZOOM_AROUND_POINT, + ZOOM_STEPS, + ZOOM_FRAME +} GtkMozEmbedZoomType; + typedef struct _GtkMozEmbed GtkMozEmbed; typedef struct _GtkMozEmbedClass GtkMozEmbedClass; struct _GtkMozEmbed { - GtkBin bin; - void *data; + GtkBin bin; + void *data; + GtkMozEmbedCommon *common; + // FIXME: This is a temporary solution for wrong progress values + // being passed up. Oleg has mentioned something about a bug in JS. + gint current_number_of_requests; + gint total_number_of_requests; + gint number_of_frames_loaded; + }; struct _GtkMozEmbedClass @@ -106,10 +127,10 @@ struct _GtkMozEmbedClass void (* title) (GtkMozEmbed *embed); void (* progress) (GtkMozEmbed *embed, gint curprogress, gint maxprogress); - void (* progress_all) (GtkMozEmbed *embed, const char *aURI, + void (* progress_all) (GtkMozEmbed *embed, const gchar *aURI, gint curprogress, gint maxprogress); void (* net_state) (GtkMozEmbed *embed, gint state, guint status); - void (* net_state_all) (GtkMozEmbed *embed, const char *aURI, + void (* net_state_all) (GtkMozEmbed *embed, const gchar *aURI, gint state, guint status); void (* net_start) (GtkMozEmbed *embed); void (* net_stop) (GtkMozEmbed *embed); @@ -128,6 +149,11 @@ struct _GtkMozEmbedClass gint (* dom_mouse_dbl_click) (GtkMozEmbed *embed, gpointer dom_event); gint (* dom_mouse_over) (GtkMozEmbed *embed, gpointer dom_event); gint (* dom_mouse_out) (GtkMozEmbed *embed, gpointer dom_event); +// gint (* dom_mouse_move) (GtkMozEmbed *embed, gpointer dom_event); + gint (* dom_mouse_scroll) (GtkMozEmbed *embed, gpointer dom_event); + gint (* dom_mouse_long_press)(GtkMozEmbed *embed, gpointer dom_event); + gint (* dom_focus) (GtkMozEmbed *embed, gpointer dom_event); + gint (* dom_blur) (GtkMozEmbed *embed, gpointer dom_event); void (* security_change) (GtkMozEmbed *embed, gpointer request, guint state); void (* status_change) (GtkMozEmbed *embed, gpointer request, @@ -135,49 +161,121 @@ struct _GtkMozEmbedClass gint (* dom_activate) (GtkMozEmbed *embed, gpointer dom_event); gint (* dom_focus_in) (GtkMozEmbed *embed, gpointer dom_event); gint (* dom_focus_out) (GtkMozEmbed *embed, gpointer dom_event); + void (* alert) (GtkMozEmbed *embed, const char *title, const char *text); + void (* alert_check) (GtkMozEmbed *embed, const char *title, const char *text, + const char *check_msg, gboolean *check_val); + gboolean (* confirm) (GtkMozEmbed *embed, const char *title, const char *text); + gboolean (* confirm_check) (GtkMozEmbed *embed, const char *title, const char *text, + const char *check_msg, gboolean *check_val); + gint (* confirm_ex) (GtkMozEmbed *embed, const char *title, const char *text, guint bt_flags, + const char *button1, const char *button2, const char *button3, + const char *check_msg, gboolean *check_val); + gboolean (* prompt) (GtkMozEmbed *embed, const char *title, const char *text, + char **value, const char *check_msg, gboolean *check_val); + gboolean (* prompt_auth) (GtkMozEmbed *embed, const char *title, const char *text, + char **user, char **pass, const char *check_msg, gboolean *check_val); + gboolean (* select) (GtkMozEmbed *embed, const char *title, const char *text, + GList *list, gint *selected_item); + void (* download_request)(GtkMozEmbed *, const char *, const char *, const char *, long, int, gpointer); + gboolean (* upload_dialog) (GtkMozEmbed *, const char *, const char *, char **); + void (* icon_changed) (GtkMozEmbed *, gpointer*); + void (* mailto) (GtkMozEmbed *, gchar *); + void (* unknown_protocol)(GtkMozEmbed *, gchar *); }; -GTKMOZEMBED_API(GtkType, gtk_moz_embed_get_type, (void)) -GTKMOZEMBED_API(GtkWidget*, gtk_moz_embed_new, (void)) -GTKMOZEMBED_API(void, gtk_moz_embed_push_startup, (void)) -GTKMOZEMBED_API(void, gtk_moz_embed_pop_startup, (void)) +GTKMOZEMBED_API(GtkType, gtk_moz_embed_get_type, (void)) +GTKMOZEMBED_API(GtkWidget*, gtk_moz_embed_new, (void)) +GTKMOZEMBED_API(void, gtk_moz_embed_push_startup, (void)) +GTKMOZEMBED_API(void, gtk_moz_embed_pop_startup, (void)) /* Tell gtkmozembed where the gtkmozembed libs live. If this is not specified, The MOZILLA_FIVE_HOME environment variable is checked. */ -GTKMOZEMBED_API(void, gtk_moz_embed_set_path, (const char *aPath)) +GTKMOZEMBED_API(void, gtk_moz_embed_set_path, (const char *aPath)) -GTKMOZEMBED_API(void, gtk_moz_embed_set_comp_path, (const char *aPath)) -GTKMOZEMBED_API(void, gtk_moz_embed_set_profile_path, (const char *aDir, - const char *aName)) -GTKMOZEMBED_API(void, gtk_moz_embed_load_url, (GtkMozEmbed *embed, - const char *url)) -GTKMOZEMBED_API(void, gtk_moz_embed_stop_load, (GtkMozEmbed *embed)) -GTKMOZEMBED_API(gboolean, gtk_moz_embed_can_go_back, (GtkMozEmbed *embed)) -GTKMOZEMBED_API(gboolean, gtk_moz_embed_can_go_forward, (GtkMozEmbed *embed)) -GTKMOZEMBED_API(void, gtk_moz_embed_go_back, (GtkMozEmbed *embed)) -GTKMOZEMBED_API(void, gtk_moz_embed_go_forward, (GtkMozEmbed *embed)) -GTKMOZEMBED_API(void, gtk_moz_embed_render_data, (GtkMozEmbed *embed, - const char *data, - guint32 len, - const char *base_uri, - const char *mime_type)) -GTKMOZEMBED_API(void, gtk_moz_embed_open_stream, (GtkMozEmbed *embed, - const char *base_uri, - const char *mime_type)) -GTKMOZEMBED_API(void, gtk_moz_embed_append_data, (GtkMozEmbed *embed, - const char *data, - guint32 len)) -GTKMOZEMBED_API(void, gtk_moz_embed_close_stream, (GtkMozEmbed *embed)) -GTKMOZEMBED_API(char*, gtk_moz_embed_get_link_message, (GtkMozEmbed *embed)) -GTKMOZEMBED_API(char*, gtk_moz_embed_get_js_status, (GtkMozEmbed *embed)) -GTKMOZEMBED_API(char*, gtk_moz_embed_get_title, (GtkMozEmbed *embed)) -GTKMOZEMBED_API(char*, gtk_moz_embed_get_location, (GtkMozEmbed *embed)) -GTKMOZEMBED_API(void, gtk_moz_embed_reload, (GtkMozEmbed *embed, - gint32 flags)) -GTKMOZEMBED_API(void, gtk_moz_embed_set_chrome_mask, (GtkMozEmbed *embed, - guint32 flags)) -GTKMOZEMBED_API(guint32, gtk_moz_embed_get_chrome_mask, (GtkMozEmbed *embed)) +GTKMOZEMBED_API(void, gtk_moz_embed_set_comp_path, (const char *aPath)) +GTKMOZEMBED_API(void, gtk_moz_embed_set_profile_path, (const char *aDir, + const char *aName)) +GTKMOZEMBED_API(void, gtk_moz_embed_load_url, (GtkMozEmbed *embed, + const char *url)) +GTKMOZEMBED_API(void, gtk_moz_embed_stop_load, (GtkMozEmbed *embed)) +GTKMOZEMBED_API(gboolean, gtk_moz_embed_can_go_back, (GtkMozEmbed *embed)) +GTKMOZEMBED_API(gboolean, gtk_moz_embed_can_go_forward, (GtkMozEmbed *embed)) +GTKMOZEMBED_API(void, gtk_moz_embed_go_back, (GtkMozEmbed *embed)) +GTKMOZEMBED_API(void, gtk_moz_embed_go_forward, (GtkMozEmbed *embed)) +GTKMOZEMBED_API(void, gtk_moz_embed_render_data, (GtkMozEmbed *embed, const char *data, guint32 len, + const char *base_uri, const char *mime_type)) +GTKMOZEMBED_API(void, gtk_moz_embed_open_stream, (GtkMozEmbed *embed, + const char *base_uri, const char *mime_type)) +GTKMOZEMBED_API(void, gtk_moz_embed_append_data, (GtkMozEmbed *embed, + const char *data, guint32 len)) +GTKMOZEMBED_API(void, gtk_moz_embed_close_stream, (GtkMozEmbed *embed)) +GTKMOZEMBED_API(gchar*, gtk_moz_embed_get_link_message, (GtkMozEmbed *embed)) +GTKMOZEMBED_API(gchar*, gtk_moz_embed_get_js_status, (GtkMozEmbed *embed)) +GTKMOZEMBED_API(gchar*, gtk_moz_embed_get_title, (GtkMozEmbed *embed)) +GTKMOZEMBED_API(gchar*, gtk_moz_embed_get_location, (GtkMozEmbed *embed)) +GTKMOZEMBED_API(void, gtk_moz_embed_reload, (GtkMozEmbed *embed, gint32 flags)) +GTKMOZEMBED_API(void, gtk_moz_embed_set_chrome_mask, (GtkMozEmbed *embed, guint32 flags)) +GTKMOZEMBED_API(guint32, gtk_moz_embed_get_chrome_mask, (GtkMozEmbed *embed)) +GTKMOZEMBED_API(gint, gtk_moz_embed_get_zoom_level, (GtkMozEmbed *embed, GtkMozEmbedZoomType, gint*)) +GTKMOZEMBED_API(gboolean, gtk_moz_embed_set_zoom_level, (GtkMozEmbed *embed, GtkMozEmbedZoomType, gint, gint, gint, guint*, gint)) +GTKMOZEMBED_API(gboolean, gtk_moz_embed_load_image, (GtkMozEmbed *embed, const gchar*)) +GTKMOZEMBED_API(gboolean, gtk_moz_embed_find_text, (GtkMozEmbed *embed, const gchar*, gboolean, gboolean, gboolean, gboolean, gint)) +GTKMOZEMBED_API(gboolean, gtk_moz_embed_clipboard, (GtkMozEmbed *embed, guint, gint)) +GTKMOZEMBED_API(void, gtk_moz_embed_notify_plugins, (GtkMozEmbed *embed, guint)) +GTKMOZEMBED_API(void, gtk_moz_embed_check_logins, (GtkMozEmbed *embed)) +GTKMOZEMBED_API(char*, gtk_moz_embed_get_encoding, (GtkMozEmbed *embed, gint)) +GTKMOZEMBED_API(void, gtk_moz_embed_set_encoding, (GtkMozEmbed *embed, const gchar *, gint)) +GTKMOZEMBED_API(guint, gtk_moz_embed_get_context_info, (GtkMozEmbed *embed, gpointer event, gpointer *node, + gint *x, gint *y, gint *docindex, + const gchar **url, const gchar **objurl, const gchar **docurl)) +GTKMOZEMBED_API(const gchar*, gtk_moz_embed_get_selection, (GtkMozEmbed *embed)) +GTKMOZEMBED_API(gboolean, gtk_moz_embed_get_doc_info, (GtkMozEmbed *embed, gint docindex, const gchar**title, + const gchar**location, const gchar **file_type, guint *file_size)) +GTKMOZEMBED_API(gboolean, gtk_moz_embed_insert_text, (GtkMozEmbed *embed, const gchar*, gpointer node)) +GTKMOZEMBED_API(gboolean, gtk_moz_embed_save_target, (GtkMozEmbed *embed, gchar*, gchar*, gint)) +GTKMOZEMBED_API(void, gtk_moz_embed_get_image_dimensions,(GtkMozEmbed *embed, gint*, gint*, gpointer)) +GTKMOZEMBED_API(char*, gtk_moz_embed_get_mime_type, (GtkMozEmbed *embed)) +/* Defines used by download and upload components */ +#define GTK_MOZ_EMBED_COMMON_FILE_SCHEME "file://" +#define GTK_MOZ_EMBED_BLUETOOTH_FILE_SCHEME "obex://" +typedef enum +{ + GTK_MOZ_EMBED_SELECT_ALL, + GTK_MOZ_EMBED_CAN_SELECT, + GTK_MOZ_EMBED_CUT, + GTK_MOZ_EMBED_COPY, + GTK_MOZ_EMBED_PASTE, + GTK_MOZ_EMBED_CAN_CUT, + GTK_MOZ_EMBED_CAN_PASTE, + GTK_MOZ_EMBED_CAN_COPY +} GtkMozEmbedClipboard; +typedef enum +{ + GTK_MOZ_EMBED_CTX_NONE = 0, + GTK_MOZ_EMBED_CTX_XUL = 1 << 1, + GTK_MOZ_EMBED_CTX_SIDEBAR = 1 << 2, + GTK_MOZ_EMBED_CTX_DOCUMENT = 1 << 3, + GTK_MOZ_EMBED_CTX_LINK = 1 << 4, + GTK_MOZ_EMBED_CTX_IMAGE = 1 << 5, + GTK_MOZ_EMBED_CTX_IFRAME = 1 << 6, + GTK_MOZ_EMBED_CTX_INPUT = 1 << 7, + GTK_MOZ_EMBED_CTX_IPASSWORD = 1 << 8, + GTK_MOZ_EMBED_CTX_EMAIL = 1 << 9, + GTK_MOZ_EMBED_CTX_RICHEDIT = 1 << 10, + GTK_MOZ_EMBED_CTX_ROINPUT = 1 << 11 +} GtkMozEmbedContext; +typedef enum +{ + GTK_MOZ_EMBED_DIALOG_BUTTON_OK, + GTK_MOZ_EMBED_DIALOG_BUTTON_CANCEL, + GTK_MOZ_EMBED_DIALOG_BUTTON_YES, + GTK_MOZ_EMBED_DIALOG_BUTTON_NO, + GTK_MOZ_EMBED_DIALOG_BUTTON_SAVE, + GTK_MOZ_EMBED_DIALOG_BUTTON_DONT_SAVE, + GTK_MOZ_EMBED_DIALOG_BUTTON_REVERT, + GTK_MOZ_EMBED_DIALOG_BUTTON_STRING +} GtkMozEmbedDialogButtons; /* These are straight out of nsIWebProgressListener.h */ typedef enum @@ -207,7 +305,9 @@ typedef enum /* NS_ERROR_NET_TIMEOUT */ GTK_MOZ_EMBED_STATUS_FAILED_TIMEOUT = 2152398862U, /* NS_BINDING_ABORTED */ - GTK_MOZ_EMBED_STATUS_FAILED_USERCANCELED = 2152398850U + GTK_MOZ_EMBED_STATUS_FAILED_USERCANCELED = 2152398850U, + /* NS_ERROR_PROXY_CONNECTION_REFUSED */ + GTK_MOZ_EMBED_STATUS_PROXY_FAILED = 2152398920U } GtkMozEmbedStatusFlags; /* These used to be straight out of nsIWebNavigation.h until the API diff --git a/mozilla/embedding/browser/gtk/src/gtkmozembed2.cpp b/mozilla/embedding/browser/gtk/src/gtkmozembed2.cpp index d8bc0e0955d..10579f827ae 100644 --- a/mozilla/embedding/browser/gtk/src/gtkmozembed2.cpp +++ b/mozilla/embedding/browser/gtk/src/gtkmozembed2.cpp @@ -1,3 +1,5 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 tw=80 et cindent: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * @@ -14,13 +16,16 @@ * 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. + * Christopher Blizzard. + * Portions created by Christopher Blizzard are Copyright (C) Christopher Blizzard. All Rights Reserved. * Portions created by the Initial Developer are Copyright (C) 2001 * the Initial Developer. All Rights Reserved. * * Contributor(s): * Christopher Blizzard * Ramiro Estrugo + * Oleg Romashin + * Antonio Gomes * * 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 @@ -44,14 +49,30 @@ #include "EmbedPrivate.h" #include "EmbedWindow.h" +#include "EmbedContextMenuInfo.h" +#include "EmbedEventListener.h" +#include "EmbedDownloadMgr.h" +#include "nsIWebBrowserPersist.h" +#include "nsCWebBrowserPersist.h" +#include "nsIDOMDocument.h" +#include "nsNetCID.h" +#include "nsIIOService.h" +#include "nsIFileURL.h" +#include "nsIURI.h" +#include "nsILocalFile.h" +#include "nsIFile.h" // so we can do our get_nsIWebBrowser later... #include // for strings +#ifdef MOZILLA_INTERNAL_API #include #include +#else +#include +#endif #ifdef MOZ_WIDGET_GTK2 #include "gtkmozembedmarshal.h" @@ -77,7 +98,21 @@ gtk_marshal_NONE__POINTER_INT_POINTER #define gtkmozembed_BOOL__STRING \ gtk_marshal_BOOL__POINTER +#define gtkmozembed_VOID__STRING_STRING \ + gtk_marshal_NONE__STRING_STRING +#define gtkmozembed_VOID__STRING_STRING_STRING_POINTER \ + gtk_marshal_NONE__STRING_STRING_STRING_POINTER +#define gtkmozembed_BOOL__STRING_STRING \ + gtk_marshal_BOOL__STRING_STRING +#define gtkmozembed_BOOL__STRING_STRING_STRING_POINTER \ + gtk_marshal_BOOL__STRING_STRING_STRING_POINTER +#define gtkmozembed_INT__STRING_STRING_UINT_STRING_STRING_STRING_STRING_POINTER \ + gtk_marshal_INT__STRING_STRING_UINT_STRING_STRING_STRING_STRING_POINTER +#define gtkmozembed_BOOL__STRING_STRING_POINTER_STRING_POINTER \ + gtk_marshal_BOOL__STRING_STRING_POINTER_STRING_POINTER +#define gtkmozembed_BOOL__STRING_STRING_POINTER_INT \ + gtk_marshal_BOOL__STRING_STRING_POINTER_INT #define G_SIGNAL_TYPE_STATIC_SCOPE 0 #define NEW_TOOLKIT_STRING(x) g_strdup(NS_LossyConvertUTF16toASCII(x).get()) @@ -123,13 +158,13 @@ static AtkObject* gtk_moz_embed_get_accessible (GtkWidget *widget); static gint handle_child_focus_in(GtkWidget *aWidget, - GdkEventFocus *aGdkFocusEvent, - GtkMozEmbed *aEmbed); + GdkEventFocus *aGdkFocusEvent, + GtkMozEmbed *aEmbed); static gint handle_child_focus_out(GtkWidget *aWidget, - GdkEventFocus *aGdkFocusEvent, - GtkMozEmbed *aEmbed); + GdkEventFocus *aGdkFocusEvent, + GtkMozEmbed *aEmbed); #ifdef MOZ_WIDGET_GTK // signal handlers for tracking the focus in and and focus out events @@ -137,10 +172,12 @@ handle_child_focus_out(GtkWidget *aWidget, static void handle_toplevel_focus_in (GtkMozArea *aArea, - GtkMozEmbed *aEmbed); + GtkMozEmbed *aEmbed); + static void handle_toplevel_focus_out(GtkMozArea *aArea, - GtkMozEmbed *aEmbed); + GtkMozEmbed *aEmbed); + #endif /* MOZ_WIDGET_GTK */ // globals for this type of widget @@ -180,7 +217,7 @@ gtk_moz_embed_class_init(GtkMozEmbedClass *klass) GtkContainerClass *container_class; GtkWidgetClass *widget_class; GtkObjectClass *object_class; - + container_class = GTK_CONTAINER_CLASS(klass); widget_class = GTK_WIDGET_CLASS(klass); object_class = GTK_OBJECT_CLASS(klass); @@ -203,192 +240,227 @@ gtk_moz_embed_class_init(GtkMozEmbedClass *klass) moz_embed_signals[LINK_MESSAGE] = gtk_signal_new ("link_message", - GTK_RUN_FIRST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, link_message), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, link_message), + gtk_marshal_NONE__NONE, + GTK_TYPE_NONE, 0); moz_embed_signals[JS_STATUS] = gtk_signal_new ("js_status", - GTK_RUN_FIRST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, js_status), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, js_status), + gtk_marshal_NONE__NONE, + GTK_TYPE_NONE, 0); moz_embed_signals[LOCATION] = gtk_signal_new ("location", - GTK_RUN_FIRST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, location), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, location), + gtk_marshal_NONE__NONE, + GTK_TYPE_NONE, 0); moz_embed_signals[TITLE] = gtk_signal_new("title", - GTK_RUN_FIRST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, title), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, title), + gtk_marshal_NONE__NONE, + GTK_TYPE_NONE, 0); moz_embed_signals[PROGRESS] = gtk_signal_new("progress", - GTK_RUN_FIRST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, progress), - gtk_marshal_NONE__INT_INT, - GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT); + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, progress), + gtk_marshal_NONE__INT_INT, + GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT); moz_embed_signals[PROGRESS_ALL] = gtk_signal_new("progress_all", - GTK_RUN_FIRST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, progress_all), - gtkmozembed_VOID__STRING_INT_INT, - GTK_TYPE_NONE, 3, - GTK_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE, - GTK_TYPE_INT, GTK_TYPE_INT); + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, progress_all), + gtkmozembed_VOID__STRING_INT_INT, + GTK_TYPE_NONE, 3, + GTK_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE, + GTK_TYPE_INT, GTK_TYPE_INT); moz_embed_signals[NET_STATE] = gtk_signal_new("net_state", - GTK_RUN_FIRST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, net_state), - gtkmozembed_VOID__INT_UINT, - GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_UINT); + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, net_state), + gtkmozembed_VOID__INT_UINT, + GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_UINT); moz_embed_signals[NET_STATE_ALL] = gtk_signal_new("net_state_all", - GTK_RUN_FIRST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, net_state_all), - gtkmozembed_VOID__STRING_INT_UINT, - GTK_TYPE_NONE, 3, - GTK_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE, - GTK_TYPE_INT, GTK_TYPE_UINT); + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, net_state_all), + gtkmozembed_VOID__STRING_INT_UINT, + GTK_TYPE_NONE, 3, + GTK_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE, + GTK_TYPE_INT, GTK_TYPE_UINT); moz_embed_signals[NET_START] = gtk_signal_new("net_start", - GTK_RUN_FIRST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, net_start), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, net_start), + gtk_marshal_NONE__NONE, + GTK_TYPE_NONE, 0); moz_embed_signals[NET_STOP] = gtk_signal_new("net_stop", - GTK_RUN_FIRST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, net_stop), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, net_stop), + gtk_marshal_NONE__NONE, + GTK_TYPE_NONE, 0); moz_embed_signals[NEW_WINDOW] = gtk_signal_new("new_window", - GTK_RUN_FIRST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, new_window), - gtk_marshal_NONE__POINTER_UINT, - GTK_TYPE_NONE, 2, GTK_TYPE_POINTER, GTK_TYPE_UINT); + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, new_window), + gtk_marshal_NONE__POINTER_UINT, + GTK_TYPE_NONE, 2, GTK_TYPE_POINTER, GTK_TYPE_UINT); moz_embed_signals[VISIBILITY] = gtk_signal_new("visibility", - GTK_RUN_FIRST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, visibility), - gtk_marshal_NONE__BOOL, - GTK_TYPE_NONE, 1, GTK_TYPE_BOOL); + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, visibility), + gtk_marshal_NONE__BOOL, + GTK_TYPE_NONE, 1, GTK_TYPE_BOOL); moz_embed_signals[DESTROY_BROWSER] = gtk_signal_new("destroy_browser", - GTK_RUN_FIRST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, destroy_brsr), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, destroy_brsr), + gtk_marshal_NONE__NONE, + GTK_TYPE_NONE, 0); moz_embed_signals[OPEN_URI] = gtk_signal_new("open_uri", - GTK_RUN_LAST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, open_uri), - gtkmozembed_BOOL__STRING, - GTK_TYPE_BOOL, 1, GTK_TYPE_STRING | - G_SIGNAL_TYPE_STATIC_SCOPE); + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, open_uri), + gtkmozembed_BOOL__STRING, + GTK_TYPE_BOOL, 1, GTK_TYPE_STRING | + G_SIGNAL_TYPE_STATIC_SCOPE); moz_embed_signals[SIZE_TO] = gtk_signal_new("size_to", - GTK_RUN_LAST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, size_to), - gtk_marshal_NONE__INT_INT, - GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT); + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, size_to), + gtk_marshal_NONE__INT_INT, + GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT); moz_embed_signals[DOM_KEY_DOWN] = gtk_signal_new("dom_key_down", - GTK_RUN_LAST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_key_down), - gtk_marshal_BOOL__POINTER, - GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_key_down), + gtk_marshal_BOOL__POINTER, + GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); moz_embed_signals[DOM_KEY_PRESS] = gtk_signal_new("dom_key_press", - GTK_RUN_LAST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_key_press), - gtk_marshal_BOOL__POINTER, - GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_key_press), + gtk_marshal_BOOL__POINTER, + GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); moz_embed_signals[DOM_KEY_UP] = gtk_signal_new("dom_key_up", - GTK_RUN_LAST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_key_up), - gtk_marshal_BOOL__POINTER, - GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_key_up), + gtk_marshal_BOOL__POINTER, + GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); moz_embed_signals[DOM_MOUSE_DOWN] = gtk_signal_new("dom_mouse_down", - GTK_RUN_LAST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_mouse_down), - gtk_marshal_BOOL__POINTER, - GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_mouse_down), + gtk_marshal_BOOL__POINTER, + GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); moz_embed_signals[DOM_MOUSE_UP] = gtk_signal_new("dom_mouse_up", - GTK_RUN_LAST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_mouse_up), - gtk_marshal_BOOL__POINTER, - GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_mouse_up), + gtk_marshal_BOOL__POINTER, + GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); moz_embed_signals[DOM_MOUSE_CLICK] = gtk_signal_new("dom_mouse_click", - GTK_RUN_LAST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_mouse_click), - gtk_marshal_BOOL__POINTER, - GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_mouse_click), + gtk_marshal_BOOL__POINTER, + GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); moz_embed_signals[DOM_MOUSE_DBL_CLICK] = gtk_signal_new("dom_mouse_dbl_click", - GTK_RUN_LAST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_mouse_dbl_click), - gtk_marshal_BOOL__POINTER, - GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_mouse_dbl_click), + gtk_marshal_BOOL__POINTER, + GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); moz_embed_signals[DOM_MOUSE_OVER] = gtk_signal_new("dom_mouse_over", - GTK_RUN_LAST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_mouse_over), - gtk_marshal_BOOL__POINTER, - GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_mouse_over), + gtk_marshal_BOOL__POINTER, + GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); moz_embed_signals[DOM_MOUSE_OUT] = gtk_signal_new("dom_mouse_out", - GTK_RUN_LAST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_mouse_out), - gtk_marshal_BOOL__POINTER, - GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_mouse_out), + gtk_marshal_BOOL__POINTER, + GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); +/* moz_embed_signals[DOM_MOUSE_MOVE] = + gtk_signal_new("dom_mouse_move", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_mouse_move), + gtk_marshal_BOOL__POINTER, + GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER);*/ + moz_embed_signals[DOM_MOUSE_SCROLL] = + gtk_signal_new("dom_mouse_scroll", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_mouse_scroll), + gtk_marshal_BOOL__POINTER, + GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); + moz_embed_signals[DOM_MOUSE_LONG_PRESS] = + gtk_signal_new("dom_mouse_long_press", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_mouse_long_press), + gtk_marshal_BOOL__POINTER, + GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); + moz_embed_signals[DOM_FOCUS] = + gtk_signal_new("dom_focus", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_focus), + gtk_marshal_BOOL__POINTER, + GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); + moz_embed_signals[DOM_BLUR] = + gtk_signal_new("dom_blur", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_blur), + gtk_marshal_BOOL__POINTER, + GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); moz_embed_signals[SECURITY_CHANGE] = gtk_signal_new("security_change", - GTK_RUN_LAST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, security_change), - gtk_marshal_NONE__POINTER_UINT, - GTK_TYPE_NONE, 2, GTK_TYPE_POINTER, GTK_TYPE_UINT); + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, security_change), + gtk_marshal_NONE__POINTER_UINT, + GTK_TYPE_NONE, 2, GTK_TYPE_POINTER, GTK_TYPE_UINT); moz_embed_signals[STATUS_CHANGE] = gtk_signal_new("status_change", - GTK_RUN_LAST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedClass, status_change), - gtkmozembed_VOID__POINTER_INT_POINTER, - GTK_TYPE_NONE, 3, - GTK_TYPE_POINTER, GTK_TYPE_INT, GTK_TYPE_POINTER); + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, status_change), + gtkmozembed_VOID__POINTER_INT_POINTER, + GTK_TYPE_NONE, 3, + GTK_TYPE_POINTER, GTK_TYPE_INT, GTK_TYPE_POINTER); moz_embed_signals[DOM_ACTIVATE] = gtk_signal_new("dom_activate", GTK_RUN_LAST, @@ -410,9 +482,155 @@ gtk_moz_embed_class_init(GtkMozEmbedClass *klass) GTK_SIGNAL_OFFSET(GtkMozEmbedClass, dom_focus_out), gtk_marshal_BOOL__POINTER, GTK_TYPE_BOOL, 1, GTK_TYPE_POINTER); + moz_embed_signals[ALERT] = + gtk_signal_new("alert", + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, alert), + gtkmozembed_VOID__STRING_STRING, + GTK_TYPE_NONE, 2, + GTK_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE, + GTK_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE); + moz_embed_signals[ALERT_CHECK] = + gtk_signal_new("alert_check", + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, alert_check), + gtkmozembed_VOID__STRING_STRING_STRING_POINTER, + GTK_TYPE_NONE, 4, + GTK_TYPE_STRING, + GTK_TYPE_STRING, + GTK_TYPE_STRING, + GTK_TYPE_POINTER); + moz_embed_signals[CONFIRM] = + gtk_signal_new("confirm", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, confirm), + gtkmozembed_BOOL__STRING_STRING, + GTK_TYPE_BOOL, 2, + GTK_TYPE_STRING, + GTK_TYPE_STRING); + moz_embed_signals[CONFIRM_CHECK] = + gtk_signal_new("confirm_check", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, confirm_check), + gtkmozembed_BOOL__STRING_STRING_STRING_POINTER, + GTK_TYPE_BOOL, 4, + GTK_TYPE_STRING, + GTK_TYPE_STRING, + GTK_TYPE_STRING, + GTK_TYPE_POINTER); + moz_embed_signals[CONFIRM_EX] = + gtk_signal_new("confirm_ex", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, confirm_ex), + gtkmozembed_INT__STRING_STRING_UINT_STRING_STRING_STRING_STRING_POINTER, + GTK_TYPE_INT, 8, + GTK_TYPE_STRING, + GTK_TYPE_STRING, + GTK_TYPE_UINT, + GTK_TYPE_STRING, + GTK_TYPE_STRING, + GTK_TYPE_STRING, + GTK_TYPE_STRING, + GTK_TYPE_POINTER); + moz_embed_signals[PROMPT] = + gtk_signal_new("prompt", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, prompt), + gtkmozembed_BOOL__STRING_STRING_POINTER_STRING_POINTER, + GTK_TYPE_BOOL, 5, + GTK_TYPE_STRING, + GTK_TYPE_STRING, + GTK_TYPE_POINTER, + GTK_TYPE_STRING, + GTK_TYPE_POINTER); + moz_embed_signals[PROMPT_AUTH] = + gtk_signal_new("prompt_auth", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, prompt_auth), + gtkmozembed_BOOL__STRING_STRING_POINTER_POINTER_STRING_POINTER, + GTK_TYPE_BOOL, 6, + GTK_TYPE_STRING, + GTK_TYPE_STRING, + GTK_TYPE_POINTER, + GTK_TYPE_POINTER, + GTK_TYPE_STRING, + GTK_TYPE_POINTER); + moz_embed_signals[SELECT] = + gtk_signal_new("select", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, select), + gtkmozembed_BOOL__STRING_STRING_POINTER_INT, + GTK_TYPE_BOOL, 4, + GTK_TYPE_STRING, + GTK_TYPE_STRING, + GTK_TYPE_POINTER, + GTK_TYPE_INT); + moz_embed_signals[DOWNLOAD_REQUEST] = + gtk_signal_new("download_request", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, download_request), + gtkmozembed_VOID__STRING_STRING_STRING_ULONG_INT, + GTK_TYPE_NONE, + 5, + GTK_TYPE_STRING, + GTK_TYPE_STRING, + GTK_TYPE_STRING, + GTK_TYPE_INT, + GTK_TYPE_INT + ); + moz_embed_signals[UPLOAD_DIALOG] = + gtk_signal_new("upload_dialog", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, upload_dialog), + gtkmozembed_BOOL__STRING_STRING_POINTER, + GTK_TYPE_BOOL, + 3, + GTK_TYPE_STRING, + GTK_TYPE_STRING, + GTK_TYPE_POINTER); + moz_embed_signals[ICON_CHANGED] = + gtk_signal_new("icon_changed", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, icon_changed), + gtkmozembed_VOID__POINTER, + GTK_TYPE_NONE, + 1, + GTK_TYPE_POINTER); + moz_embed_signals[MAILTO] = + gtk_signal_new("mailto", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, mailto), + gtk_marshal_VOID__STRING, + GTK_TYPE_NONE, + 1, + GTK_TYPE_STRING); + + moz_embed_signals[UNKNOWN_PROTOCOL] = + gtk_signal_new("unknown_protocol", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedClass, unknown_protocol), + gtk_marshal_VOID__STRING, + GTK_TYPE_NONE, + 1, + GTK_TYPE_STRING); + + #ifdef MOZ_WIDGET_GTK gtk_object_class_add_signals(object_class, moz_embed_signals, - EMBED_LAST_SIGNAL); + EMBED_LAST_SIGNAL); #endif /* MOZ_WIDGET_GTK */ } @@ -422,6 +640,7 @@ gtk_moz_embed_init(GtkMozEmbed *embed) { EmbedPrivate *priv = new EmbedPrivate(); embed->data = priv; + embed->common = NULL; gtk_widget_set_name(GTK_WIDGET(embed), "gtkmozembed"); #ifdef MOZ_WIDGET_GTK2 @@ -442,7 +661,7 @@ gtk_moz_embed_destroy(GtkObject *object) { GtkMozEmbed *embed; EmbedPrivate *embedPrivate; - + g_return_if_fail(object != NULL); g_return_if_fail(GTK_IS_MOZ_EMBED(object)); @@ -492,7 +711,7 @@ gtk_moz_embed_realize(GtkWidget *widget) attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP; widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), - &attributes, attributes_mask); + &attributes, attributes_mask); gdk_window_set_user_data (widget->window, embed); widget->style = gtk_style_attach (widget->style, widget->window); @@ -502,7 +721,7 @@ gtk_moz_embed_realize(GtkWidget *widget) nsresult rv; rv = embedPrivate->Init(embed); g_return_if_fail(NS_SUCCEEDED(rv)); - + PRBool alreadyRealized = PR_FALSE; rv = embedPrivate->Realize(&alreadyRealized); g_return_if_fail(NS_SUCCEEDED(rv)); @@ -517,30 +736,30 @@ gtk_moz_embed_realize(GtkWidget *widget) // connect to the focus out event for the child GtkWidget *child_widget = GTK_BIN(widget)->child; gtk_signal_connect_while_alive(GTK_OBJECT(child_widget), - "focus_out_event", - GTK_SIGNAL_FUNC(handle_child_focus_out), - embed, - GTK_OBJECT(child_widget)); + "focus_out_event", + GTK_SIGNAL_FUNC(handle_child_focus_out), + embed, + GTK_OBJECT(child_widget)); gtk_signal_connect_while_alive(GTK_OBJECT(child_widget), - "focus_in_event", - GTK_SIGNAL_FUNC(handle_child_focus_in), - embed, - GTK_OBJECT(child_widget)); + "focus_in_event", + GTK_SIGNAL_FUNC(handle_child_focus_in), + embed, + GTK_OBJECT(child_widget)); #ifdef MOZ_WIDGET_GTK // connect to the toplevel focus out events for the child GtkMozArea *mozarea = GTK_MOZAREA(child_widget); gtk_signal_connect_while_alive(GTK_OBJECT(mozarea), - "toplevel_focus_in", - GTK_SIGNAL_FUNC(handle_toplevel_focus_in), - embed, - GTK_OBJECT(mozarea)); + "toplevel_focus_in", + GTK_SIGNAL_FUNC(handle_toplevel_focus_in), + embed, + GTK_OBJECT(mozarea)); gtk_signal_connect_while_alive(GTK_OBJECT(mozarea), - "toplevel_focus_out", - GTK_SIGNAL_FUNC(handle_toplevel_focus_out), - embed, - GTK_OBJECT(mozarea)); + "toplevel_focus_out", + GTK_SIGNAL_FUNC(handle_toplevel_focus_out), + embed, + GTK_OBJECT(mozarea)); #endif /* MOZ_WIDGET_GTK */ } @@ -549,7 +768,7 @@ gtk_moz_embed_unrealize(GtkWidget *widget) { GtkMozEmbed *embed; EmbedPrivate *embedPrivate; - + g_return_if_fail(widget != NULL); g_return_if_fail(GTK_IS_MOZ_EMBED(widget)); @@ -581,8 +800,8 @@ gtk_moz_embed_size_allocate(GtkWidget *widget, GtkAllocation *allocation) if (GTK_WIDGET_REALIZED(widget)) { gdk_window_move_resize(widget->window, - allocation->x, allocation->y, - allocation->width, allocation->height); + allocation->x, allocation->y, + allocation->width, allocation->height); embedPrivate->Resize(allocation->width, allocation->height); } } @@ -642,8 +861,8 @@ gtk_moz_embed_get_accessible (GtkWidget *widget) static gint handle_child_focus_in(GtkWidget *aWidget, - GdkEventFocus *aGdkFocusEvent, - GtkMozEmbed *aEmbed) + GdkEventFocus *aGdkFocusEvent, + GtkMozEmbed *aEmbed) { EmbedPrivate *embedPrivate; @@ -651,13 +870,13 @@ handle_child_focus_in(GtkWidget *aWidget, embedPrivate->ChildFocusIn(); - return FALSE; + return PR_FALSE; } static gint handle_child_focus_out(GtkWidget *aWidget, - GdkEventFocus *aGdkFocusEvent, - GtkMozEmbed *aEmbed) + GdkEventFocus *aGdkFocusEvent, + GtkMozEmbed *aEmbed) { EmbedPrivate *embedPrivate; @@ -665,13 +884,13 @@ handle_child_focus_out(GtkWidget *aWidget, embedPrivate->ChildFocusOut(); - return FALSE; + return PR_FALSE; } #ifdef MOZ_WIDGET_GTK void handle_toplevel_focus_in (GtkMozArea *aArea, - GtkMozEmbed *aEmbed) + GtkMozEmbed *aEmbed) { EmbedPrivate *embedPrivate; embedPrivate = (EmbedPrivate *)aEmbed->data; @@ -681,7 +900,7 @@ handle_toplevel_focus_in (GtkMozArea *aArea, void handle_toplevel_focus_out(GtkMozArea *aArea, - GtkMozEmbed *aEmbed) + GtkMozEmbed *aEmbed) { EmbedPrivate *embedPrivate; embedPrivate = (EmbedPrivate *)aEmbed->data; @@ -705,37 +924,38 @@ gtk_moz_embed_pop_startup(void) } void -gtk_moz_embed_set_path(const char *aPath) +gtk_moz_embed_set_path(const gchar *aPath) { EmbedPrivate::SetPath(aPath); } void -gtk_moz_embed_set_comp_path(const char *aPath) +gtk_moz_embed_set_comp_path(const gchar *aPath) { EmbedPrivate::SetCompPath(aPath); } void gtk_moz_embed_set_app_components(const nsModuleComponentInfo* aComps, - int aNumComponents) + gint aNumComponents) { EmbedPrivate::SetAppComponents(aComps, aNumComponents); } void -gtk_moz_embed_set_profile_path(const char *aDir, const char *aName) +gtk_moz_embed_set_profile_path(const gchar *aDir, const gchar *aName) { EmbedPrivate::SetProfilePath(aDir, aName); } void -gtk_moz_embed_set_directory_service_provider(nsIDirectoryServiceProvider *appFileLocProvider) { +gtk_moz_embed_set_directory_service_provider(nsIDirectoryServiceProvider *appFileLocProvider) +{ EmbedPrivate::SetDirectoryServiceProvider(appFileLocProvider); } void -gtk_moz_embed_load_url(GtkMozEmbed *embed, const char *url) +gtk_moz_embed_load_url(GtkMozEmbed *embed, const gchar *url) { EmbedPrivate *embedPrivate; @@ -779,7 +999,7 @@ gtk_moz_embed_can_go_back(GtkMozEmbed *embed) if (embedPrivate->mNavigation) embedPrivate->mNavigation->GetCanGoBack(&retval); - return retval; + return retval ? TRUE : FALSE; } gboolean @@ -795,7 +1015,7 @@ gtk_moz_embed_can_go_forward(GtkMozEmbed *embed) if (embedPrivate->mNavigation) embedPrivate->mNavigation->GetCanGoForward(&retval); - return retval; + return retval ? TRUE : FALSE; } void @@ -827,9 +1047,9 @@ gtk_moz_embed_go_forward(GtkMozEmbed *embed) } void -gtk_moz_embed_render_data(GtkMozEmbed *embed, const char *data, - guint32 len, const char *base_uri, - const char *mime_type) +gtk_moz_embed_render_data(GtkMozEmbed *embed, const gchar *data, + guint32 len, const gchar *base_uri, + const gchar *mime_type) { EmbedPrivate *embedPrivate; @@ -844,8 +1064,8 @@ gtk_moz_embed_render_data(GtkMozEmbed *embed, const char *data, } void -gtk_moz_embed_open_stream(GtkMozEmbed *embed, const char *base_uri, - const char *mime_type) +gtk_moz_embed_open_stream(GtkMozEmbed *embed, const gchar *base_uri, + const gchar *mime_type) { EmbedPrivate *embedPrivate; @@ -858,8 +1078,9 @@ gtk_moz_embed_open_stream(GtkMozEmbed *embed, const char *base_uri, embedPrivate->OpenStream(base_uri, mime_type); } -void gtk_moz_embed_append_data(GtkMozEmbed *embed, const char *data, - guint32 len) +void gtk_moz_embed_append_data(GtkMozEmbed *embed, + const gchar *data, + guint32 len) { EmbedPrivate *embedPrivate; @@ -884,14 +1105,14 @@ gtk_moz_embed_close_stream(GtkMozEmbed *embed) embedPrivate->CloseStream(); } -char * +gchar * gtk_moz_embed_get_link_message(GtkMozEmbed *embed) { - char *retval = nsnull; + gchar *retval = nsnull; EmbedPrivate *embedPrivate; - g_return_val_if_fail ((embed != NULL), (char *)NULL); - g_return_val_if_fail (GTK_IS_MOZ_EMBED(embed), (char *)NULL); + g_return_val_if_fail ((embed != NULL), (gchar *)NULL); + g_return_val_if_fail (GTK_IS_MOZ_EMBED(embed), (gchar *)NULL); embedPrivate = (EmbedPrivate *)embed->data; @@ -901,14 +1122,14 @@ gtk_moz_embed_get_link_message(GtkMozEmbed *embed) return retval; } -char * +gchar * gtk_moz_embed_get_js_status(GtkMozEmbed *embed) { - char *retval = nsnull; + gchar *retval = nsnull; EmbedPrivate *embedPrivate; - g_return_val_if_fail ((embed != NULL), (char *)NULL); - g_return_val_if_fail (GTK_IS_MOZ_EMBED(embed), (char *)NULL); + g_return_val_if_fail ((embed != NULL), (gchar *)NULL); + g_return_val_if_fail (GTK_IS_MOZ_EMBED(embed), (gchar *)NULL); embedPrivate = (EmbedPrivate *)embed->data; @@ -918,14 +1139,14 @@ gtk_moz_embed_get_js_status(GtkMozEmbed *embed) return retval; } -char * +gchar * gtk_moz_embed_get_title(GtkMozEmbed *embed) { - char *retval = nsnull; + gchar *retval = nsnull; EmbedPrivate *embedPrivate; - g_return_val_if_fail ((embed != NULL), (char *)NULL); - g_return_val_if_fail (GTK_IS_MOZ_EMBED(embed), (char *)NULL); + g_return_val_if_fail ((embed != NULL), (gchar *)NULL); + g_return_val_if_fail (GTK_IS_MOZ_EMBED(embed), (gchar *)NULL); embedPrivate = (EmbedPrivate *)embed->data; @@ -935,14 +1156,14 @@ gtk_moz_embed_get_title(GtkMozEmbed *embed) return retval; } -char * +gchar * gtk_moz_embed_get_location(GtkMozEmbed *embed) { - char *retval = nsnull; + gchar *retval = nsnull; EmbedPrivate *embedPrivate; - g_return_val_if_fail ((embed != NULL), (char *)NULL); - g_return_val_if_fail (GTK_IS_MOZ_EMBED(embed), (char *)NULL); + g_return_val_if_fail ((embed != NULL), (gchar *)NULL); + g_return_val_if_fail (GTK_IS_MOZ_EMBED(embed), (gchar *)NULL); embedPrivate = (EmbedPrivate *)embed->data; @@ -977,7 +1198,7 @@ gtk_moz_embed_reload(GtkMozEmbed *embed, gint32 flags) break; case GTK_MOZ_EMBED_FLAG_RELOADBYPASSPROXYANDCACHE: reloadFlags = (nsIWebNavigation::LOAD_FLAGS_BYPASS_PROXY | - nsIWebNavigation::LOAD_FLAGS_BYPASS_CACHE); + nsIWebNavigation::LOAD_FLAGS_BYPASS_CACHE); break; case GTK_MOZ_EMBED_FLAG_RELOADCHARSETCHANGE: reloadFlags = nsIWebNavigation::LOAD_FLAGS_CHARSET_CHANGE; @@ -1119,7 +1340,7 @@ gtk_moz_embed_single_get_type(void) 0 }; moz_embed_single_type = gtk_type_unique(GTK_TYPE_OBJECT, - &moz_embed_single_info); + &moz_embed_single_info); } return moz_embed_single_type; @@ -1136,16 +1357,18 @@ gtk_moz_embed_single_class_init(GtkMozEmbedSingleClass *klass) moz_embed_single_signals[NEW_WINDOW_ORPHAN] = gtk_signal_new("new_window_orphan", - GTK_RUN_FIRST, - GET_OBJECT_CLASS_TYPE(klass), - GTK_SIGNAL_OFFSET(GtkMozEmbedSingleClass, - new_window_orphan), - gtk_marshal_NONE__POINTER_UINT, - GTK_TYPE_NONE, 2, GTK_TYPE_POINTER, GTK_TYPE_UINT); - + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedSingleClass, + new_window_orphan), + gtk_marshal_NONE__POINTER_UINT, + GTK_TYPE_NONE, + 2, + GTK_TYPE_POINTER, GTK_TYPE_UINT); + #ifdef MOZ_WIDGET_GTK gtk_object_class_add_signals(object_class, moz_embed_single_signals, - SINGLE_LAST_SIGNAL); + SINGLE_LAST_SIGNAL); #endif /* MOZ_WIDGET_GTK */ } @@ -1178,7 +1401,7 @@ gtk_moz_embed_single_get(void) // our callback from the window creator service void gtk_moz_embed_single_create_window(GtkMozEmbed **aNewEmbed, - guint aChromeFlags) + guint aChromeFlags) { GtkMozEmbedSingle *single = gtk_moz_embed_single_get(); @@ -1188,7 +1411,333 @@ gtk_moz_embed_single_create_window(GtkMozEmbed **aNewEmbed, return; gtk_signal_emit(GTK_OBJECT(single), - moz_embed_single_signals[NEW_WINDOW_ORPHAN], - aNewEmbed, aChromeFlags); - + moz_embed_single_signals[NEW_WINDOW_ORPHAN], + aNewEmbed, aChromeFlags); } + +gboolean +gtk_moz_embed_set_zoom_level (GtkMozEmbed *embed, GtkMozEmbedZoomType zoom_type, gint zoom_level, + gint x, gint y, guint *legal_levels, gint layout_part) +{ + g_return_val_if_fail (embed != NULL, FALSE); + g_return_val_if_fail (GTK_IS_MOZ_EMBED (embed), FALSE); + g_return_val_if_fail (GTK_WIDGET_REALIZED (GTK_WIDGET(embed)), FALSE); + EmbedPrivate *embedPrivate; + embedPrivate = (EmbedPrivate *) embed->data; + switch (zoom_type) { + + case ZOOM_SIMPLE: + { + embedPrivate->SetZoom (zoom_level); + break; + } + case ZOOM_AROUND_POINT: + { + break; + } + case ZOOM_STEPS: + { + break; + } + case ZOOM_FRAME: + { + break; + } + default: + break; + } + + return TRUE; +} + +gint +gtk_moz_embed_get_zoom_level (GtkMozEmbed *embed, + GtkMozEmbedZoomType zoom_type, + gint *compare_frames) +{ + g_return_val_if_fail (embed != NULL, -1); + g_return_val_if_fail (GTK_IS_MOZ_EMBED (embed), -1); + g_return_val_if_fail (GTK_WIDGET_REALIZED (GTK_WIDGET(embed)), -1); + EmbedPrivate *embedPrivate; + embedPrivate = (EmbedPrivate *) embed->data; + gint zoom_level = 0; + switch (zoom_type) { + + case ZOOM_SIMPLE: + { + embedPrivate->GetZoom (&zoom_level, compare_frames); + break; + } + case ZOOM_AROUND_POINT: + { + break; + } + case ZOOM_STEPS: + { + break; + } + case ZOOM_FRAME: + { + break; + } + default: + break; + } + + return zoom_level; +} + +gboolean +gtk_moz_embed_load_image (GtkMozEmbed *embed, const gchar *url) +{ + g_return_val_if_fail (embed != NULL, FALSE); + g_return_val_if_fail (embed, FALSE); + + gtk_moz_embed_load_url (embed, url); + + return TRUE; +} + +gboolean +gtk_moz_embed_find_text (GtkMozEmbed *embed, const gchar *string, + gboolean reverse, gboolean whole_word, + gboolean case_sensitive, gboolean restart, gint target) +{ + EmbedPrivate *embedPrivate; + g_return_val_if_fail (embed != NULL, FALSE); + g_return_val_if_fail (GTK_IS_MOZ_EMBED(embed), FALSE); + g_return_val_if_fail (GTK_WIDGET_REALIZED(GTK_WIDGET(embed)), FALSE); + embedPrivate = (EmbedPrivate *)embed->data; + if (embedPrivate->mWindow) + return embedPrivate->FindText (string, reverse, whole_word, case_sensitive, restart); + return FALSE; +} + +gboolean +gtk_moz_embed_clipboard (GtkMozEmbed *embed, guint action, gint target) +{ + EmbedPrivate *embedPrivate; + g_return_val_if_fail (embed != NULL, FALSE); + g_return_val_if_fail (GTK_IS_MOZ_EMBED(embed), FALSE); + g_return_val_if_fail (GTK_WIDGET_REALIZED(GTK_WIDGET(embed)), FALSE); + embedPrivate = (EmbedPrivate *)embed->data; + return embedPrivate->ClipBoardAction((GtkMozEmbedClipboard)action) ? TRUE : FALSE; +} + +void +gtk_moz_embed_notify_plugins (GtkMozEmbed *embed, guint) +{ + return; +} + +gchar * +gtk_moz_embed_get_encoding(GtkMozEmbed *embed, gint frame_number) +{ + gchar *retval = nsnull; + EmbedPrivate *embedPrivate; + g_return_val_if_fail ((embed != NULL), (gchar *)NULL); + g_return_val_if_fail (GTK_IS_MOZ_EMBED(embed), (gchar *)NULL); + embedPrivate = (EmbedPrivate *)embed->data; + if (embedPrivate->mWindow) + retval = embedPrivate->GetEncoding(); + return retval; +} + +void +gtk_moz_embed_set_encoding(GtkMozEmbed *embed, const gchar *encoding_text, gint frame_number) +{ + EmbedPrivate *embedPrivate; + g_return_if_fail(embed != NULL); + g_return_if_fail(GTK_IS_MOZ_EMBED(embed)); + embedPrivate = (EmbedPrivate *)embed->data; + if (embedPrivate->mWindow) + embedPrivate->SetEncoding (encoding_text); + return; +} + +guint +gtk_moz_embed_get_context_info(GtkMozEmbed *embed, gpointer event, gpointer *node, + gint *x, gint *y, gint *docindex, + const gchar **url, const gchar **objurl, const gchar **docurl) +{ + EmbedPrivate *embedPrivate; + g_return_val_if_fail(embed != NULL, GTK_MOZ_EMBED_CTX_NONE); + g_return_val_if_fail(GTK_IS_MOZ_EMBED(embed), GTK_MOZ_EMBED_CTX_NONE); + embedPrivate = (EmbedPrivate *)embed->data; + if (embedPrivate->mEventListener) { +#ifdef MOZILLA_INTERNAL_API //FIXME replace to using nsStringAPI + EmbedContextMenuInfo * ctx_menu = embedPrivate->mEventListener->GetContextInfo(); + if (!ctx_menu) + return (unsigned gint) 0; + ctx_menu->UpdateContextData(event); + *x = ctx_menu->mX; + *y = ctx_menu->mY; + *docindex = ctx_menu->mCtxFrameNum; + if (ctx_menu->mEmbedCtxType & GTK_MOZ_EMBED_CTX_LINK && !*url) { + *url = ToNewCString(ctx_menu->mCtxHref); + } + if (ctx_menu->mEmbedCtxType & GTK_MOZ_EMBED_CTX_IMAGE) { + *objurl = ToNewCString(ctx_menu->mCtxImgHref); + } + *docurl = ToNewCString(ctx_menu->mCtxURI); + *node = ctx_menu->mEventNode; + return ctx_menu->mEmbedCtxType; +#endif + } + return (unsigned gint) 0; +} + +const gchar* +gtk_moz_embed_get_selection(GtkMozEmbed *embed) +{ + EmbedPrivate *embedPrivate; + g_return_val_if_fail(embed != NULL, NULL); + g_return_val_if_fail(GTK_IS_MOZ_EMBED(embed), NULL); + embedPrivate = (EmbedPrivate *)embed->data; + if (embedPrivate->mEventListener) { + EmbedContextMenuInfo * ctx_menu = embedPrivate->mEventListener->GetContextInfo(); + if (!ctx_menu) + return NULL; + return ctx_menu->GetSelectedText(); + } + return NULL; +} + +gboolean +gtk_moz_embed_get_doc_info(GtkMozEmbed *embed, gint docindex, + const gchar**title, const gchar**location, + const gchar **file_type, guint *file_size) +{ + return FALSE; +} + +gboolean +gtk_moz_embed_insert_text(GtkMozEmbed *embed, const gchar *string, gpointer node) +{ + EmbedPrivate *embedPrivate; + g_return_val_if_fail(embed != NULL, FALSE); + g_return_val_if_fail(GTK_IS_MOZ_EMBED(embed), FALSE); + embedPrivate = (EmbedPrivate *)embed->data; + if ( !embedPrivate || !embedPrivate->mEventListener) + return FALSE; + if (!string && node) { + embedPrivate->ScrollToSelectedNode((nsIDOMNode*)node); + return TRUE; + } + if (string) { + embedPrivate->InsertTextToNode((nsIDOMNode*)node, string); + return TRUE; + } + return FALSE; +} + +gboolean +gtk_moz_embed_save_target (GtkMozEmbed *aEmbed, gchar* aUrl, + gchar* aDestination, gint aSetting) +{ + //FIXME + nsresult rv; + + g_return_val_if_fail (aEmbed != NULL, FALSE); + nsIWebBrowser *webBrowser = nsnull; + gtk_moz_embed_get_nsIWebBrowser (GTK_MOZ_EMBED (aEmbed), &webBrowser); + g_return_val_if_fail (webBrowser != NULL, FALSE); + + nsCOMPtr DOMWindow; + webBrowser->GetContentDOMWindow(getter_AddRefs(DOMWindow)); + g_return_val_if_fail (DOMWindow != NULL, FALSE); + + nsCOMPtr doc; + DOMWindow->GetDocument (getter_AddRefs(doc)); + g_return_val_if_fail (doc != NULL, FALSE); + + nsCOMPtr persist = + do_CreateInstance(NS_WEBBROWSERPERSIST_CONTRACTID); + if (!persist) + return FALSE; + + nsCOMPtr ios (do_GetService(NS_IOSERVICE_CONTRACTID)); + if (!ios) + return FALSE; + + nsCOMPtr uri; + rv = ios->NewURI(nsDependentCString(aDestination), "", nsnull, getter_AddRefs(uri)); + if (!uri) + return FALSE; + + nsCOMPtr fileURL(do_QueryInterface(uri)); + if (!fileURL) + return FALSE; + + nsCOMPtr file; + rv = fileURL->GetFile(getter_AddRefs(file)); + if (!file) + return FALSE; + + if (aSetting == 0) + { + rv = ios->NewURI(nsDependentCString(aUrl), "", nsnull, getter_AddRefs(uri)); + if (!uri) + return FALSE; + rv = persist->SaveURI(uri, nsnull, nsnull, nsnull, "", file); + if (NS_SUCCEEDED(rv)) + return TRUE; + + } else if (aSetting == 1) + { + nsCOMPtr contentFolder; + nsCString contentFolderPath; + file->GetNativePath(contentFolderPath); + contentFolderPath.Append("_content"); + rv = NS_NewNativeLocalFile(contentFolderPath, PR_TRUE, getter_AddRefs(contentFolder)); + if (NS_FAILED(rv)) + return FALSE; + rv = persist->SaveDocument(doc, file, contentFolder, nsnull, 0, 0); + if (NS_SUCCEEDED(rv)) + return TRUE; + } else if (aSetting == 2) + { + // FIXME: How should I handle this option G_WEBENGINE_SAVE_FRAMES ? + return FALSE; + } + return FALSE; +} + +void +gtk_moz_embed_get_image_dimensions (GtkMozEmbed *embed, gint *width, gint *height, gpointer node) +{ + g_return_if_fail(embed != NULL); + g_return_if_fail(GTK_IS_MOZ_EMBED(embed)); + g_return_if_fail(width); + g_return_if_fail(height); + + EmbedPrivate *embedPrivate; + embedPrivate = (EmbedPrivate *)embed->data; + + if ( !embedPrivate || !embedPrivate->mEventListener) + return; + + EmbedContextMenuInfo * ctx_menu = embedPrivate->mEventListener->GetContextInfo(); + if (!ctx_menu) + return; + + nsString imgSrc; + ctx_menu->CheckDomImageElement((nsIDOMNode*)node, imgSrc, width, height); +} + +gchar * +gtk_moz_embed_get_mime_type (GtkMozEmbed *embed) +{ + g_return_val_if_fail ((embed != NULL), (gchar *)NULL); + g_return_val_if_fail (GTK_IS_MOZ_EMBED(embed), (gchar *)NULL); + gchar *retval = NULL; + EmbedPrivate *embedPrivate = nsnull; + embedPrivate = (EmbedPrivate *)embed->data; + if (embedPrivate && embedPrivate->mWindow) { + nsString mime; + if (NS_SUCCEEDED(embedPrivate->GetMIMEInfo(mime))) + retval = g_strdup((char*)NS_LossyConvertUTF16toASCII(mime).get()); + } + return retval; +} + diff --git a/mozilla/embedding/browser/gtk/src/gtkmozembed_common.cpp b/mozilla/embedding/browser/gtk/src/gtkmozembed_common.cpp new file mode 100644 index 00000000000..b686e041d56 --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/gtkmozembed_common.cpp @@ -0,0 +1,665 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 tw=80 et cindent: */ +/* ***** 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 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. + * Portions created by the Initial Developer are Copyright (C) 2001 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Christopher Blizzard + * Ramiro Estrugo + * + * 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 ***** */ + +#include +#include "gtkmozembed.h" +#include "gtkmozembed_common.h" +#include "gtkmozembedprivate.h" +#include "gtkmozembed_internal.h" +#include "EmbedPrivate.h" +#include "EmbedWindow.h" + +#ifdef MOZ_GTKPASSWORD_INTERFACE +#include "EmbedPasswordMgr.h" +#include "nsIPassword.h" +#endif + +#include "EmbedGlobalHistory.h" +//#include "EmbedDownloadMgr.h" +// so we can do our get_nsIWebBrowser later... +#include +#include +#include +#include "nsIPref.h" +#include +#include +#include +#include +#include +// for strings +#ifdef MOZILLA_INTERNAL_API +#include +#include +#else +#include +#include "nsComponentManagerUtils.h" +#include "nsServiceManagerUtils.h" +#endif +// for plugins +#include +#include +#include +#include +#include +#include + +//for security +#include + +#ifdef MOZ_WIDGET_GTK2 +#include "gtkmozembedmarshal.h" +#define NEW_TOOLKIT_STRING(x) g_strdup(NS_ConvertUTF16toUTF8(x).get()) +#define GET_TOOLKIT_STRING(x) NS_ConvertUTF16toUTF8(x).get() +#define GET_OBJECT_CLASS_TYPE(x) G_OBJECT_CLASS_TYPE(x) +#endif /* MOZ_WIDGET_GTK2 */ + +#ifdef MOZ_WIDGET_GTK +// so we can get callbacks from the mozarea +#include +// so we get the right marshaler for gtk 1.2 +#define gtkmozembed_VOID__INT_UINT \ + gtk_marshal_NONE__INT_INT +#define gtkmozembed_VOID__STRING_INT_INT \ + gtk_marshal_NONE__POINTER_INT_INT +#define gtkmozembed_VOID__STRING_INT_UINT \ + gtk_marshal_NONE__POINTER_INT_INT +#define gtkmozembed_VOID__POINTER_INT_POINTER \ + gtk_marshal_NONE__POINTER_INT_POINTER +#define gtkmozembed_BOOL__STRING \ + gtk_marshal_BOOL__POINTER +#define gtkmozembed_VOID__INT_INT_BOOLEAN \ + gtk_marshal_NONE__INT_INT_BOOLEAN + +#define G_SIGNAL_TYPE_STATIC_SCOPE 0 +#define NEW_TOOLKIT_STRING(x) g_strdup(NS_LossyConvertUTF16toASCII(x).get()) +#define GET_TOOLKIT_STRING(x) NS_LossyConvertUTF16toASCII(x).get() +#define GET_OBJECT_CLASS_TYPE(x) (GTK_OBJECT_CLASS(x)->type) +#endif /* MOZ_WIDGET_GTK */ + +// CID used to get the plugin manager +static NS_DEFINE_CID(kPluginManagerCID, NS_PLUGINMANAGER_CID); + +// class and instance initialization + +static void +gtk_moz_embed_common_class_init(GtkMozEmbedCommonClass *klass); + +static void +gtk_moz_embed_common_init(GtkMozEmbedCommon *embed); + +static GtkObjectClass *common_parent_class = NULL; + +// GtkObject methods + +static void +gtk_moz_embed_common_destroy(GtkObject *object); + +guint moz_embed_common_signals[COMMON_LAST_SIGNAL] = { 0 }; + +// GtkObject + class-related functions +GtkType +gtk_moz_embed_common_get_type(void) +{ + static GtkType moz_embed_common_type = 0; + if (!moz_embed_common_type) + { + static const GtkTypeInfo moz_embed_common_info = + { + "GtkMozEmbedCommon", + sizeof(GtkMozEmbedCommon), + sizeof(GtkMozEmbedCommonClass), + (GtkClassInitFunc)gtk_moz_embed_common_class_init, + (GtkObjectInitFunc)gtk_moz_embed_common_init, + 0, + 0, + 0 + }; + moz_embed_common_type = gtk_type_unique(GTK_TYPE_BIN, &moz_embed_common_info); + } + return moz_embed_common_type; +} + +static void +gtk_moz_embed_common_class_init(GtkMozEmbedCommonClass *klass) +{ + GtkObjectClass *object_class; + object_class = GTK_OBJECT_CLASS(klass); + common_parent_class = (GtkObjectClass *)gtk_type_class(gtk_object_get_type()); + object_class->destroy = gtk_moz_embed_common_destroy; + moz_embed_common_signals[COMMON_CERT_ERROR] = + gtk_signal_new("certificate-error", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedCommonClass, + certificate_error), + gtkmozembed_BOOL__POINTER_UINT, + G_TYPE_BOOLEAN, + 2, + GTK_TYPE_POINTER, + GTK_TYPE_UINT); + moz_embed_common_signals[COMMON_SELECT_LOGIN] = + gtk_signal_new("select-login", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedCommonClass, + select_login), + gtk_marshal_INT__POINTER, + G_TYPE_INT, + 1, + G_TYPE_POINTER); + moz_embed_common_signals[COMMON_REMEMBER_LOGIN] = + gtk_signal_new("remember-login", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedCommonClass, + remember_login), + gtkmozembed_INT__VOID, + G_TYPE_INT, 0); + // set up our signals + moz_embed_common_signals[COMMON_ASK_COOKIE] = + gtk_signal_new("ask-cookie", + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedCommonClass, ask_cookie), + gtkmozembed_VOID__POINTER_INT_STRING_STRING_STRING_STRING_STRING_BOOLEAN_INT, + G_TYPE_NONE, 9, + GTK_TYPE_POINTER, + GTK_TYPE_INT, + GTK_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE, + GTK_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE, + GTK_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE, + GTK_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE, + GTK_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE, + GTK_TYPE_BOOL, + GTK_TYPE_INT); +/* + moz_embed_common_signals[COMMON_CERT_DIALOG] = + gtk_signal_new("certificate-dialog", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedCommonClass, + certificate_dialog), + gtk_marshal_BOOL__POINTER, + G_TYPE_BOOLEAN, 1, GTK_TYPE_POINTER); + moz_embed_common_signals[COMMON_CERT_PASSWD_DIALOG] = + gtk_signal_new("certificate-password-dialog", + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedCommonClass, + certificate_password_dialog), + gtkmozembed_VOID__STRING_STRING_POINTER, + G_TYPE_NONE, + 3, + GTK_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE, + GTK_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE, + GTK_TYPE_POINTER); + moz_embed_common_signals[COMMON_CERT_DETAILS_DIALOG] = + gtk_signal_new("certificate-details", + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedCommonClass, + certificate_details), + gtk_marshal_VOID__POINTER, + G_TYPE_NONE, + 1, + GTK_TYPE_POINTER); + moz_embed_common_signals[COMMON_HISTORY_ADDED] = + gtk_signal_new("global-history-item-added", + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedCommonClass, + history_added), + gtk_marshal_VOID__STRING, + G_TYPE_NONE, + 1, + GTK_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE); + moz_embed_common_signals[COMMON_ON_SUBMIT_SIGNAL] = + gtk_signal_new("on-submit", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedCommonClass, + on_submit), + gtkmozembed_INT__VOID, + G_TYPE_INT, 0); + moz_embed_common_signals[COMMON_MODAL_DIALOG] = + gtk_signal_new("modal_dialog", + GTK_RUN_LAST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedCommonClass, + modal_dialog), + gtkmozembed_INT__STRING_STRING_INT_INT_INT_INT, + G_TYPE_INT, + 6, + G_TYPE_STRING, G_TYPE_STRING, + G_TYPE_INT, G_TYPE_INT, + G_TYPE_INT, G_TYPE_INT); + */ +#ifdef MOZ_WIDGET_GTK + gtk_object_class_add_signals(object_class, moz_embed_common_signals, + COMMON_LAST_SIGNAL); +#endif /* MOZ_WIDGET_GTK */ +} + +static void +gtk_moz_embed_common_init(GtkMozEmbedCommon *common) +{ + // this is a placeholder for later in case we need to stash data at + // a later data and maintain backwards compatibility. + common->data = nsnull; + EmbedCommon *priv = EmbedCommon::GetInstance(); + priv->mCommon = common; + common->data = priv; + EmbedGlobalHistory::GetInstance(); +} + +static void +gtk_moz_embed_common_destroy(GtkObject *object) +{ + g_return_if_fail(object != NULL); + g_return_if_fail(GTK_IS_MOZ_EMBED_COMMON(object)); + GtkMozEmbedCommon *embed = nsnull; + EmbedCommon *commonPrivate = nsnull; + embed = GTK_MOZ_EMBED_COMMON(object); + commonPrivate = (EmbedCommon *)embed->data; + if (commonPrivate) { + delete commonPrivate; + embed->data = NULL; + } +} + +GtkWidget * +gtk_moz_embed_common_new(void) +{ + GtkWidget *widget = (GtkWidget*) gtk_type_new(gtk_moz_embed_common_get_type()); + gtk_widget_set_name (widget, "gtkmozembedcommon"); + return (GtkWidget *) widget; +} + +gboolean +gtk_moz_embed_common_set_pref(GtkType type, gchar *name, gpointer value) +{ + g_return_val_if_fail (name != NULL, FALSE); + + nsCOMPtr pref = do_GetService(NS_PREF_CONTRACTID); + + if (pref) { + nsresult rv = NS_ERROR_FAILURE; + switch (type) { + case GTK_TYPE_BOOL: + { + /* I doubt this cast pair is correct */ + rv = pref->SetBoolPref (name, (int)(int*)value != 0 ? PR_TRUE : PR_FALSE); + break; + } + case GTK_TYPE_INT: + { + /* I doubt this cast pair is correct */ + rv = pref->SetIntPref (name, (int)(int*)value); + break; + } + case GTK_TYPE_STRING: + { + g_return_val_if_fail (value, FALSE); + rv = pref->SetCharPref (name, (gchar*)value); + break; + } + default: + break; + } + return ( NS_SUCCEEDED (rv) ? TRUE : FALSE ); + } + return (FALSE); +} + +gboolean +gtk_moz_embed_common_get_pref(GtkType type, gchar *name, gpointer value) +{ + g_return_val_if_fail (name != NULL, FALSE); + + nsCOMPtr pref = do_GetService(NS_PREF_CONTRACTID); + + nsresult rv = NS_ERROR_FAILURE; + if (pref){ + switch (type) { + case GTK_TYPE_BOOL: + { + rv = pref->GetBoolPref (name, (gboolean*)value); + break; + } + case GTK_TYPE_INT: + { + rv = pref->GetIntPref (name, (gint*)value); + break; + } + case GTK_TYPE_STRING: + { + rv = pref->GetCharPref (name, (gchar**)value); + break; + } + default: + break; + } + return ( NS_SUCCEEDED (rv) ? TRUE : FALSE ); + } + return (FALSE); +} + +gboolean +gtk_moz_embed_common_save_prefs() +{ + nsCOMPtr prefService = do_GetService(NS_PREF_CONTRACTID); + g_return_val_if_fail (prefService != nsnull, FALSE); + if (prefService == nsnull) + return FALSE; + nsresult rv = prefService->SavePrefFile (nsnull); + return NS_SUCCEEDED (rv) ? TRUE : FALSE; +} + +#ifdef MOZ_GTKPASSWORD_INTERFACE +static GList * +gtk_moz_embed_common_get_logins(const char* uri, nsIPasswordManager *passwordManager) +{ + GList *logins = NULL; + nsCOMPtr passwordEnumerator; + nsresult result = passwordManager->GetEnumerator(getter_AddRefs(passwordEnumerator)); + PRBool enumResult; + for (passwordEnumerator->HasMoreElements(&enumResult) ; + enumResult == PR_TRUE ; + passwordEnumerator->HasMoreElements(&enumResult)) + { + nsCOMPtr nsPassword; + result = passwordEnumerator->GetNext + (getter_AddRefs(nsPassword)); + if (NS_FAILED(result)) { + /* this almost certainly leaks logins */ + return NULL; + } + nsCString transfer; + nsPassword->GetHost (transfer); + if (uri && !g_str_has_prefix(uri, transfer.get())) + continue; + nsString unicodeName; + nsPassword->GetUser (unicodeName); + logins = g_list_append(logins, ToNewUTF8String(unicodeName)); + } + return logins; +} +#endif + +gboolean +gtk_moz_embed_common_login(GtkWidget *embed) +{ + gint retval = -1; +#ifdef MOZ_GTKPASSWORD_INTERFACE + EmbedPasswordMgr *passwordManager = EmbedPasswordMgr::GetInstance(); + GList * list = gtk_moz_embed_common_get_logins(gtk_moz_embed_get_location(GTK_MOZ_EMBED(embed)), passwordManager); + gtk_signal_emit( + GTK_OBJECT(GTK_MOZ_EMBED(embed)->common), + moz_embed_common_signals[COMMON_SELECT_LOGIN], + list, + &retval); + if (retval != -1) { + passwordManager->InsertLogin((const gchar*)g_list_nth_data(list, retval)); + } + g_list_free(list); +#endif + return retval != -1; +} + +gboolean +gtk_moz_embed_common_remove_passwords(const gchar *host, const gchar *user) +{ +#ifdef MOZ_GTKPASSWORD_INTERFACE + EmbedPasswordMgr *passwordManager = EmbedPasswordMgr::GetInstance(); + passwordManager->RemovePasswords(host, user); +#endif + return TRUE; +} + +gboolean +gtk_moz_embed_common_remove_passwords_by_index (gint index) +{ +#ifdef MOZ_GTKPASSWORD_INTERFACE + EmbedPasswordMgr *passwordManager = EmbedPasswordMgr::GetInstance(); + passwordManager->RemovePasswordsByIndex(index); +#endif + return TRUE; +} + +gint +gtk_moz_embed_common_get_number_of_saved_passwords () +{ + gint saved_passwd_num = 0; +#ifdef MOZ_GTKPASSWORD_INTERFACE + EmbedPasswordMgr *passwordManager = EmbedPasswordMgr::GetInstance(); + passwordManager->GetNumberOfSavedPassword ( &saved_passwd_num); +#endif + return saved_passwd_num; +} + +gint +gtk_moz_embed_common_get_history_list (GtkMozHistoryItem **GtkHI) +{ + gint count = 0; + EmbedGlobalHistory *history = EmbedGlobalHistory::GetInstance(); + history->GetContentList(GtkHI, &count); + return count; +} + +gint +gtk_moz_embed_common_clean_all_history () { + nsresult rv; + // The global history service + nsCOMPtr globalHistory(do_GetService("@mozilla.org/browser/global-history;2")); + if (!globalHistory) return NS_ERROR_NULL_POINTER; + // The browser history interface + nsCOMPtr myHistory = do_QueryInterface(globalHistory, &rv); + if (!myHistory) return NS_ERROR_NULL_POINTER ; + myHistory->RemoveAllPages(); + return 1; +} + +GSList* +gtk_moz_embed_common_get_cookie_list(void) +{ + GSList *cookies = NULL; + nsresult result; + nsCOMPtr cookieManager = + do_GetService(NS_COOKIEMANAGER_CONTRACTID); + nsCOMPtr cookieEnumerator; + result = cookieManager->GetEnumerator(getter_AddRefs(cookieEnumerator)); + g_return_val_if_fail(NS_SUCCEEDED(result), NULL); + PRBool enumResult; + for (cookieEnumerator->HasMoreElements(&enumResult); + enumResult == PR_TRUE; + cookieEnumerator->HasMoreElements(&enumResult)) + { + GtkMozCookieList *c; + nsCOMPtr nsCookie; + result = cookieEnumerator->GetNext(getter_AddRefs(nsCookie)); + g_return_val_if_fail(NS_SUCCEEDED(result), NULL); + c = g_new0(GtkMozCookieList, 1); + nsCAutoString transfer; + nsCookie->GetHost(transfer); + c->domain = g_strdup(transfer.get()); + nsCookie->GetName(transfer); + c->name = g_strdup(transfer.get()); + nsCookie->GetValue(transfer); + c->value = g_strdup(transfer.get()); + nsCookie->GetPath(transfer); + /* this almost certainly leaks g_strconcat */ + if (strchr(c->domain,'.')) + c->path = g_strdup(g_strconcat("http://*",c->domain,"/",NULL)); + else + c->path = g_strdup(g_strconcat("http://",c->domain,"/",NULL)); + cookies = g_slist_prepend(cookies, c); + } + cookies = g_slist_reverse(cookies); + return cookies; +} + +gint +gtk_moz_embed_common_delete_all_cookies (GSList *deletedCookies) +{ + if (!deletedCookies) + return 1; + + nsCOMPtr cookieManager = + do_GetService(NS_COOKIEMANAGER_CONTRACTID); + + if (!cookieManager) + return 1; + cookieManager->RemoveAll(); + + nsCOMPtr permissionManager = + do_GetService(NS_PERMISSIONMANAGER_CONTRACTID); + + if (!permissionManager) + return 1; + + permissionManager->RemoveAll (); + + g_slist_free (deletedCookies); + return 0;//False in GWebStatus means OK, as opposed to gboolean in C +} + +unsigned char * +gtk_moz_embed_common_nsx509_to_raw(void *nsIX509Ptr, guint *len) +{ + if (!nsIX509Ptr) + return NULL; + unsigned char *data; + ((nsIX509Cert*)nsIX509Ptr)->GetRawDER(len, (PRUint8 **)&data); + if (!data) + return NULL; + return data; +} + +void +gtk_moz_embed_common_get_plugins_list (GtkMozPlugin **pluginArray, gint *num_plugins) +{ + nsresult rv; + nsCOMPtr pluginMan = + do_GetService(kPluginManagerCID, &rv); + if (NS_FAILED(rv)) { + g_print("Could not get the plugin manager\n"); + return; + } + pluginMan->ReloadPlugins(PR_TRUE); + nsCOMPtr pluginHost = + do_GetService(kPluginManagerCID, &rv); + if (NS_FAILED(rv)) { + return; + } + PRUint32 aLength; + nsIDOMPlugin **aItem; + pluginHost->GetPluginCount(&aLength); + *num_plugins = aLength; + gint size = aLength; + aItem = new nsIDOMPlugin*[aLength]; + pluginHost->GetPlugins(aLength, aItem); + *pluginArray = (GtkMozPlugin*) g_try_malloc(size*sizeof(GtkMozPlugin)); + for (int aIndex = 0; aIndex < (gint) aLength; aIndex++) + { + nsAutoString aName; + aItem[aIndex]->GetName(aName); + NS_ConvertUTF16toUTF8 utf8ValueTitle(aName); + (*pluginArray)[aIndex].title = g_strdup((gchar *)utf8ValueTitle.get()); + nsAutoString aFilename; + aItem[aIndex]->GetFilename(aFilename); + NS_ConvertUTF16toUTF8 utf8ValueFilename(aFilename); + (*pluginArray)[aIndex].path =g_strdup((gchar *)utf8ValueFilename.get()); + nsCOMPtr mimeType; + aItem[aIndex]->Item(aIndex, getter_AddRefs(mimeType)); + nsAutoString aDescription; + mimeType->GetDescription(aDescription); + NS_ConvertUTF16toUTF8 utf8ValueDescription(aDescription); + (*pluginArray)[aIndex].type = g_strdup((gchar *)utf8ValueDescription.get()); + } + return; +} + +void +gtk_moz_embed_common_reload_plugins () +{ + nsresult rv; + nsCOMPtr pluginMan = + do_GetService(kPluginManagerCID, &rv); + pluginMan->ReloadPlugins(PR_TRUE); +} + +guint +gtk_moz_embed_common_get_security_mode (guint sec_state) +{ + GtkMozEmbedSecurityMode sec_mode; + + switch (sec_state) { + case nsIWebProgressListener::STATE_IS_INSECURE: + sec_mode = GTK_MOZ_EMBED_NO_SECURITY; + //g_print("GTK_MOZ_EMBED_NO_SECURITY\n"); + break; + case nsIWebProgressListener::STATE_IS_BROKEN: + sec_mode = GTK_MOZ_EMBED_NO_SECURITY; + //g_print("GTK_MOZ_EMBED_NO_SECURITY\n"); + break; + case nsIWebProgressListener::STATE_IS_SECURE| + nsIWebProgressListener::STATE_SECURE_HIGH: + sec_mode = GTK_MOZ_EMBED_HIGH_SECURITY; + //g_print("GTK_MOZ_EMBED_HIGH_SECURITY"); + break; + case nsIWebProgressListener::STATE_IS_SECURE| + nsIWebProgressListener::STATE_SECURE_MED: + sec_mode = GTK_MOZ_EMBED_MEDIUM_SECURITY; + //g_print("GTK_MOZ_EMBED_MEDIUM_SECURITY\n"); + break; + case nsIWebProgressListener::STATE_IS_SECURE| + nsIWebProgressListener::STATE_SECURE_LOW: + sec_mode = GTK_MOZ_EMBED_LOW_SECURITY; + //g_print("GTK_MOZ_EMBED_LOW_SECURITY\n"); + break; + default: + sec_mode = GTK_MOZ_EMBED_UNKNOWN_SECURITY; + //g_print("GTK_MOZ_EMBED_UNKNOWN_SECURITY\n"); + break; + } + return sec_mode; +} + diff --git a/mozilla/embedding/browser/gtk/src/gtkmozembed_common.h b/mozilla/embedding/browser/gtk/src/gtkmozembed_common.h new file mode 100644 index 00000000000..d6038c05f75 --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/gtkmozembed_common.h @@ -0,0 +1,206 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* ***** 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 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. + * Portions created by the Initial Developer are Copyright (C) 2001 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Christopher Blizzard + * Ramiro Estrugo + * + * 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 ***** */ +#ifndef gtkmozembed_common_h +#define gtkmozembed_common_h +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ +#include +#include +#ifdef MOZILLA_CLIENT +#include "nscore.h" +#else // MOZILLA_CLIENT +#ifndef nscore_h__ +/* Because this header may be included from files which not part of the mozilla + build system, define macros from nscore.h */ +#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) +#define NS_HIDDEN __attribute__((visibility("hidden"))) +#else +#define NS_HIDDEN +#endif +#define NS_FROZENCALL +#define NS_EXPORT_(type) type +#define NS_IMPORT_(type) type +#endif // nscore_h__ +#endif // MOZILLA_CLIENT +#ifdef XPCOM_GLUE +#define GTKMOZEMBED_API(type, name, params) \ + typedef type (NS_FROZENCALL * name##Type) params; \ + extern name##Type name NS_HIDDEN; +#else // XPCOM_GLUE +#ifdef _IMPL_GTKMOZEMBED +#define GTKMOZEMBED_API(type, name, params) NS_EXPORT_(type) name params; +#else +#define GTKMOZEMBED_API(type,name, params) NS_IMPORT_(type) name params; +#endif +#endif // XPCOM_GLUE +#define GTK_TYPE_MOZ_EMBED_COMMON (gtk_moz_embed_common_get_type()) +#define GTK_MOZ_EMBED_COMMON(obj) GTK_CHECK_CAST((obj), GTK_TYPE_MOZ_EMBED_COMMON, GtkMozEmbedCommon) +#define GTK_MOZ_EMBED_COMMON_CLASS(klass) GTK_CHECK_CLASS_CAST((klass), GTK_TYPE_MOZ_EMBED_COMMON, GtkMozEmbedCommonClass) +#define GTK_IS_MOZ_EMBED_COMMON(obj) GTK_CHECK_TYPE((obj), GTK_TYPE_MOZ_EMBED_COMMON) +#define GTK_IS_MOZ_EMBED_COMMON_CLASS(klass) GTK_CHECK_CLASS_TYPE((klass), GTK_TYPE_MOZ_EMBED_COMMON) +typedef struct _GtkMozEmbedCommon GtkMozEmbedCommon; +typedef struct _GtkMozEmbedCommonClass GtkMozEmbedCommonClass; +struct _GtkMozEmbedCommon +{ + GtkBin object; + void *data; +}; +struct _GtkMozEmbedCommonClass +{ + GtkBinClass parent_class; + gboolean (* certificate_error) (GObject *, GObject*, guint); + gint (* select_login) (GObject *, GList*); + gint (* remember_login) (GObject *); + void (* ask_cookie) (GObject * , gint , const gchar * , const gchar * , const gchar * , + const gchar *, const gchar * , gboolean , gint , GObject *); +// void (* ask_cookie) (GObject * , gpointer , gint , const gchar * , const gchar * , const gchar * , +// const gchar *, const gchar * , gboolean , gint , GObject *); +// gint (* modal_dialog) (GObject *, const gchar *, const gchar *, gint, gint, gint, gint); +// gboolean (* certificate_dialog) (GObject * , GObject *); +// void (*certificate_password_dialog) (GObject *, const gchar *, const gchar *, gchar **); +// void (*certificate_details) (GObject *, gpointer ); +// gint (*on_submit) (GObject *); +// gint (*select_match) (GObject *, gpointer); +// void (*history_added) (GObject *, const gchar *, GObject*); +}; +typedef enum +{ + GTK_MOZ_EMBED_CERT_VERIFIED_OK = 0x0000, + GTK_MOZ_EMBED_CERT_UNTRUSTED = 0x0001, + GTK_MOZ_EMBED_CERT_NOT_VERIFIED_UNKNOWN = 0x0002, + GTK_MOZ_EMBED_CERT_EXPIRED = 0x0004, + GTK_MOZ_EMBED_CERT_REVOKED = 0x0008, + GTK_MOZ_EMBED_UNKNOWN_CERT = 0x0010, + GTK_MOZ_EMBED_CERT_ISSUER_UNTRUSTED = 0x0020, + GTK_MOZ_EMBED_CERT_ISSUER_UNKNOWN = 0x0040, + GTK_MOZ_EMBED_CERT_INVALID_CA = 0x0080 +} GtkMozEmbedCertificateType; +typedef enum +{ + GTK_MOZ_EMBED_LOGIN_REMEMBER_FOR_THIS_SITE, + GTK_MOZ_EMBED_LOGIN_REMEMBER_FOR_THIS_SERVER, + GTK_MOZ_EMBED_LOGIN_NOT_NOW, + GTK_MOZ_EMBED_LOGIN_NEVER_FOR_SITE, + GTK_MOZ_EMBED_LOGIN_NEVER_FOR_SERVER +} GtkMozEmbedLoginType; +/* GTK_MOZ_EMBED_CERT_USAGE_NOT_ALLOWED, + GTK_MOZ_EMBED_CA_CERT, + GTK_MOZ_EMBED_USER_CERT, + GTK_MOZ_EMBED_EMAIL_CERT, + GTK_MOZ_EMBED_SERVER_CERT +*/ + +/** GtkMozEmbedSecurityMode. + * Enumerates security modes. + */ +typedef enum +{ + GTK_MOZ_EMBED_NO_SECURITY = 0, + GTK_MOZ_EMBED_LOW_SECURITY, + GTK_MOZ_EMBED_MEDIUM_SECURITY, + GTK_MOZ_EMBED_HIGH_SECURITY, + GTK_MOZ_EMBED_UNKNOWN_SECURITY +} GtkMozEmbedSecurityMode; + +/** @struct GtkWebHistoryItem. + * Defines a web history item. + */ +typedef struct _GtkMozHistoryItem GtkMozHistoryItem; +struct _GtkMozHistoryItem +{ + gchar *title; /** < URL title */ + gchar *url; /** < URL */ + long accessed; /** < The last time that the URL was accessed */ +}; +typedef struct _GtkMozCookieList GtkMozCookieList; +struct _GtkMozCookieList +{ + gchar *domain; /** < The domain's name */ + gchar *name; /** < The cookie's name */ + gchar *value; /** < The cookie's value */ + gchar *path; /** < The cookie's path */ +}; +typedef struct _GtkMozEmbedCookie GtkMozEmbedCookie; +struct _GtkMozEmbedCookie +{ + gboolean remember_decision; + gboolean accept; +}; +/** @struct GtkMozPlugin. + * Defines a Mozilla Plugin. + */ +typedef struct _GtkMozPlugin GtkMozPlugin; +struct _GtkMozPlugin +{ + const gchar *title; /** < Plugin title */ + const gchar *path; /** < Plugin path */ + const gchar *type; /** < Plugin type */ + gboolean isDisabled; /** < is plugin enabled */ +}; +GTKMOZEMBED_API(GtkType, gtk_moz_embed_common_get_type, (void)) +GTKMOZEMBED_API(GtkWidget*, gtk_moz_embed_common_new, (void)) +GTKMOZEMBED_API(gboolean, gtk_moz_embed_common_set_pref, (GtkType type, gchar*, gpointer)) +GTKMOZEMBED_API(gboolean, gtk_moz_embed_common_get_pref, (GtkType type, gchar*, gpointer)) +GTKMOZEMBED_API(gboolean, gtk_moz_embed_common_save_prefs, (void)) +GTKMOZEMBED_API(gboolean, gtk_moz_embed_common_login, (GtkWidget *embed)) +GTKMOZEMBED_API(gboolean, gtk_moz_embed_common_remove_passwords, (const gchar *host, const gchar *user)) +GTKMOZEMBED_API(gboolean, gtk_moz_embed_common_remove_passwords_by_index, (gint index)) +GTKMOZEMBED_API(gint, gtk_moz_embed_common_get_number_of_saved_passwords, (void)) +GTKMOZEMBED_API(gint, gtk_moz_embed_common_get_history_list, (GtkMozHistoryItem **GtkHI)) +GTKMOZEMBED_API(gint, gtk_moz_embed_common_clean_all_history, (void)) +GTKMOZEMBED_API(GSList*, gtk_moz_embed_common_get_cookie_list, (void)) +GTKMOZEMBED_API(gint, gtk_moz_embed_common_delete_all_cookies,(GSList *deletedCookies)) +GTKMOZEMBED_API(unsigned char*, gtk_moz_embed_common_nsx509_to_raw, (void *nsIX509Ptr, guint *len)) +GTKMOZEMBED_API(void, gtk_moz_embed_common_get_plugins_list, (GtkMozPlugin **pluginArray, gint*)) +GTKMOZEMBED_API(void, gtk_moz_embed_common_reload_plugins, (void)) +GTKMOZEMBED_API(guint, gtk_moz_embed_common_get_security_mode, (guint sec_state)) + +/*typedef struct _GtkMozEmbedCertContext GtkMozEmbedCertContext; +struct _GtkMozEmbedCertContext +{ + GObject * cert; + guint message; + GtkWidget *parent; +};*/ +#ifdef __cplusplus +} +#endif /* __cplusplus */ +#endif /* gtkmozembed_common_h */ diff --git a/mozilla/embedding/browser/gtk/src/gtkmozembed_download.cpp b/mozilla/embedding/browser/gtk/src/gtkmozembed_download.cpp new file mode 100644 index 00000000000..898a41fba66 --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/gtkmozembed_download.cpp @@ -0,0 +1,260 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=4 sts=2 tw=80 et cindent: */ +/* ***** 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 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. + * Portions created by the Initial Developer are Copyright (C) 2001 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Christopher Blizzard + * Ramiro Estrugo + * + * 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 ***** */ +#include +#include "gtkmozembed.h" +#include "gtkmozembed_download.h" +#include "gtkmozembedprivate.h" +#include "gtkmozembed_internal.h" +#include "EmbedPrivate.h" +#include "EmbedWindow.h" +#include "EmbedDownloadMgr.h" +// so we can do our get_nsIWebBrowser later... +#include +// for strings +#ifdef MOZILLA_INTERNAL_API +#include +#include +#else +#include +#endif +#ifdef MOZ_WIDGET_GTK2 +#include "gtkmozembedmarshal.h" +#define NEW_TOOLKIT_STRING(x) g_strdup(NS_ConvertUTF16toUTF8(x).get()) +#define GET_TOOLKIT_STRING(x) NS_ConvertUTF16toUTF8(x).get() +#define GET_OBJECT_CLASS_TYPE(x) G_OBJECT_CLASS_TYPE(x) +#endif /* MOZ_WIDGET_GTK2 */ +#ifdef MOZ_WIDGET_GTK +// so we can get callbacks from the mozarea +#include +// so we get the right marshaler for gtk 1.2 +#define gtkmozembed_VOID__INT_UINT \ + gtk_marshal_NONE__INT_INT +#define gtkmozembed_VOID__STRING_INT_INT \ + gtk_marshal_NONE__POINTER_INT_INT +#define gtkmozembed_VOID__STRING_INT_UINT \ + gtk_marshal_NONE__POINTER_INT_INT +#define gtkmozembed_VOID__POINTER_INT_POINTER \ + gtk_marshal_NONE__POINTER_INT_POINTER +#define gtkmozembed_BOOL__STRING \ + gtk_marshal_BOOL__POINTER +#define gtkmozembed_VOID__INT_INT_BOOLEAN \ + gtk_marshal_NONE__INT_INT_BOOLEAN +#define G_SIGNAL_TYPE_STATIC_SCOPE 0 +#define NEW_TOOLKIT_STRING(x) g_strdup(NS_LossyConvertUTF16toASCII(x).get()) +#define GET_TOOLKIT_STRING(x) NS_LossyConvertUTF16toASCII(x).get() +#define GET_OBJECT_CLASS_TYPE(x) (GTK_OBJECT_CLASS(x)->type) +#endif /* MOZ_WIDGET_GTK */ +static void gtk_moz_embed_download_set_lastest_object (GtkObject *o); +static GtkObject *latest_download_object = nsnull; +// class and instance initialization +guint moz_embed_download_signals[DOWNLOAD_LAST_SIGNAL] = { 0 }; +static void +gtk_moz_embed_download_class_init(GtkMozEmbedDownloadClass *klass); +static void +gtk_moz_embed_download_init(GtkMozEmbedDownload *embed); +static void +gtk_moz_embed_download_destroy(GtkObject *object); +GtkObject * +gtk_moz_embed_download_new(void); +// GtkObject + class-related functions +GtkType +gtk_moz_embed_download_get_type(void) +{ + static GtkType moz_embed_download_type = 0; + if (!moz_embed_download_type) + { + static const GtkTypeInfo moz_embed_download_info = + { + "GtkMozEmbedDownload", + sizeof(GtkMozEmbedDownload), + sizeof(GtkMozEmbedDownloadClass), + (GtkClassInitFunc)gtk_moz_embed_download_class_init, + (GtkObjectInitFunc)gtk_moz_embed_download_init, + 0, + 0, + 0 + }; + moz_embed_download_type = gtk_type_unique(GTK_TYPE_OBJECT, &moz_embed_download_info); + } + return moz_embed_download_type; +} +static void +gtk_moz_embed_download_class_init(GtkMozEmbedDownloadClass *klass) +{ + GtkObjectClass *object_class; + object_class = GTK_OBJECT_CLASS(klass); + object_class->destroy = gtk_moz_embed_download_destroy; + // set up our signals + moz_embed_download_signals[DOWNLOAD_STARTED_SIGNAL] = + gtk_signal_new("started", + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedDownloadClass, + started), + gtk_marshal_NONE__POINTER, + GTK_TYPE_NONE, 1, + G_TYPE_POINTER); + moz_embed_download_signals[DOWNLOAD_COMPLETED_SIGNAL] = + gtk_signal_new("completed", + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedDownloadClass, + completed), + gtk_marshal_NONE__NONE, + GTK_TYPE_NONE, 0); + moz_embed_download_signals[DOWNLOAD_FAILED_SIGNAL] = + gtk_signal_new("error", + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedDownloadClass, + error), + gtk_marshal_NONE__NONE, + GTK_TYPE_NONE, 0); + moz_embed_download_signals[DOWNLOAD_DESTROYED_SIGNAL] = + gtk_signal_new("aborted", + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedDownloadClass, + aborted), + gtk_marshal_NONE__NONE, + GTK_TYPE_NONE, 0); + moz_embed_download_signals[DOWNLOAD_PROGRESS_SIGNAL] = + gtk_signal_new("progress", + GTK_RUN_FIRST, + GET_OBJECT_CLASS_TYPE(klass), + GTK_SIGNAL_OFFSET(GtkMozEmbedDownloadClass, + progress), + gtkmozembed_VOID__ULONG_ULONG_ULONG, + GTK_TYPE_NONE, + 3, + G_TYPE_ULONG, + G_TYPE_ULONG, + G_TYPE_ULONG); +#ifdef MOZ_WIDGET_GTK + gtk_object_class_add_signals(object_class, moz_embed_download_signals, + DOWNLOAD_LAST_SIGNAL); +#endif /* MOZ_WIDGET_GTK */ +} +static void +gtk_moz_embed_download_init(GtkMozEmbedDownload *download) +{ + // this is a placeholder for later in case we need to stash data at + // a later data and maintain backwards compatibility. + download->data = nsnull; + EmbedDownload *priv = new EmbedDownload(); + download->data = priv; +} +static void +gtk_moz_embed_download_destroy(GtkObject *object) +{ + GtkMozEmbedDownload *embed; + EmbedDownload *downloadPrivate; + g_return_if_fail(object != NULL); + g_return_if_fail(GTK_IS_MOZ_EMBED_DOWNLOAD(object)); + embed = GTK_MOZ_EMBED_DOWNLOAD(object); + downloadPrivate = (EmbedDownload *)embed->data; + if (downloadPrivate) { + delete downloadPrivate; + embed->data = NULL; + } +} +GtkObject * +gtk_moz_embed_download_new(void) +{ + GtkObject *instance = (GtkObject *) gtk_type_new (gtk_moz_embed_download_get_type()); + gtk_moz_embed_download_set_lastest_object (instance); + return instance; +} +GtkObject * +gtk_moz_embed_download_get_lastest_object (void) +{ + return latest_download_object; +} +static void +gtk_moz_embed_download_set_lastest_object (GtkObject *obj) +{ + latest_download_object = obj; + return ; +} +void gtk_moz_embed_download_do_command (GtkMozEmbedDownload *item, guint command) +{ + EmbedDownload *download_priv = (EmbedDownload *) item->data; + if (!download_priv) return ; + if (command == GTK_MOZ_EMBED_DOWNLOAD_CANCEL) { + // workaround to avoid crashs if download is 0%. + if (download_priv->downloaded_size != -1) + download_priv->launcher->Cancel (GTK_MOZ_EMBED_STATUS_FAILED_USERCANCELED); + download_priv->launcher->SetWebProgressListener (nsnull); + } else if (command == GTK_MOZ_EMBED_DOWNLOAD_RESUME) { + download_priv->request->Resume (); + download_priv->isPaused = FALSE; + } else if (command == GTK_MOZ_EMBED_DOWNLOAD_PAUSE) { + download_priv->request->Suspend (); + download_priv->isPaused = TRUE; + } else if (command == GTK_MOZ_EMBED_DOWNLOAD_RELOAD) { + if (download_priv->gtkMozEmbedParentWidget) {} + } + // FIXME: missing GTK_MOZ_EMBED_DOWNLOAD_STORE and GTK_MOZ_EMBED_DOWNLOAD_RESTORE implementation. +} +gchar * gtk_moz_embed_download_get_file_name (GtkMozEmbedDownload *item) +{ + EmbedDownload *download_priv = (EmbedDownload *) item->data; + if (!download_priv) return nsnull; + return (gchar *) download_priv->file_name; +} +gchar * gtk_moz_embed_download_get_url (GtkMozEmbedDownload *item) +{ + EmbedDownload *download_priv = (EmbedDownload *) item->data; + if (!download_priv) return nsnull; + // FIXME : 'server' is storing the wrong value. See EmbedDownloadMgr.cpp l. 189. + return (gchar *) download_priv->server; +} +glong gtk_moz_embed_download_get_progress (GtkMozEmbedDownload *item) +{ + EmbedDownload *download_priv = (EmbedDownload *) item->data; + if (!download_priv) return -1; + return (glong) download_priv->downloaded_size; +} +glong gtk_moz_embed_download_get_file_size (GtkMozEmbedDownload *item) +{ + EmbedDownload *download_priv = (EmbedDownload *) item->data; + if (!download_priv) return -1; + return (glong) download_priv->file_size; +} diff --git a/mozilla/embedding/browser/gtk/src/gtkmozembed_download.h b/mozilla/embedding/browser/gtk/src/gtkmozembed_download.h new file mode 100644 index 00000000000..a03f079eed3 --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/gtkmozembed_download.h @@ -0,0 +1,116 @@ +/* ***** 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 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. + * Portions created by the Initial Developer are Copyright (C) 2001 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Christopher Blizzard + * Ramiro Estrugo + * + * 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 ***** */ +#ifndef gtkmozembed_download_h +#define gtkmozembed_download_h +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ +#include +#include +#ifdef MOZILLA_CLIENT +#include "nscore.h" +#else // MOZILLA_CLIENT +#ifndef nscore_h__ +/* Because this header may be included from files which not part of the mozilla + build system, define macros from nscore.h */ +#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) +#define NS_HIDDEN __attribute__((visibility("hidden"))) +#else +#define NS_HIDDEN +#endif +#define NS_FROZENCALL +#define NS_EXPORT_(type) type +#define NS_IMPORT_(type) type +#endif // nscore_h__ +#endif // MOZILLA_CLIENT +#ifdef XPCOM_GLUE +#define GTKMOZEMBED_API(type, name, params) \ + typedef type (NS_FROZENCALL * name##Type) params; \ + extern name##Type name NS_HIDDEN; +#else // XPCOM_GLUE +#ifdef _IMPL_GTKMOZEMBED +#define GTKMOZEMBED_API(type, name, params) NS_EXPORT_(type) name params; +#else +#define GTKMOZEMBED_API(type,name, params) NS_IMPORT_(type) name params; +#endif +#endif // XPCOM_GLUE +#define GTK_TYPE_MOZ_EMBED_DOWNLOAD (gtk_moz_embed_download_get_type()) +#define GTK_MOZ_EMBED_DOWNLOAD(obj) GTK_CHECK_CAST((obj), GTK_TYPE_MOZ_EMBED_DOWNLOAD, GtkMozEmbedDownload) +#define GTK_MOZ_EMBED_DOWNLOAD_CLASS(klass) GTK_CHECK_CLASS_CAST((klass), GTK_TYPE_MOZ_EMBED_DOWNLOAD, GtkMozEmbedDownloadClass) +#define GTK_IS_MOZ_EMBED_DOWNLOAD(obj) GTK_CHECK_TYPE((obj), GTK_TYPE_MOZ_EMBED_DOWNLOAD) +#define GTK_IS_MOZ_EMBED_DOWNLOAD_CLASS(klass) GTK_CHECK_CLASS_TYPE((klass), GTK_TYPE_MOZ_EMBED_DOWNLOAD) +typedef struct _GtkMozEmbedDownload GtkMozEmbedDownload; +typedef struct _GtkMozEmbedDownloadClass GtkMozEmbedDownloadClass; +struct _GtkMozEmbedDownload +{ + GtkObject object; + void *data; +}; +struct _GtkMozEmbedDownloadClass +{ + GtkObjectClass parent_class; + void (*started) (GtkMozEmbedDownload* item, gchar **file_name_with_path); + void (*completed) (GtkMozEmbedDownload* item); + void (*error) (GtkMozEmbedDownload* item); + void (*aborted) (GtkMozEmbedDownload* item); + void (*progress) (GtkMozEmbedDownload* item, gulong downloaded_bytes, gulong total_bytes, gdouble kbps); +}; +typedef enum +{ + GTK_MOZ_EMBED_DOWNLOAD_RESUME, + GTK_MOZ_EMBED_DOWNLOAD_CANCEL, + GTK_MOZ_EMBED_DOWNLOAD_PAUSE, + GTK_MOZ_EMBED_DOWNLOAD_RELOAD, + GTK_MOZ_EMBED_DOWNLOAD_STORE, + GTK_MOZ_EMBED_DOWNLOAD_RESTORE +} GtkMozEmbedDownloadActions; +GTKMOZEMBED_API(GtkType, gtk_moz_embed_download_get_type, (void)) +GTKMOZEMBED_API(GtkObject *, gtk_moz_embed_download_new, (void)) +GTKMOZEMBED_API(GtkObject *, gtk_moz_embed_download_get_lastest_object, (void)) +GTKMOZEMBED_API(void, gtk_moz_embed_download_do_command , (GtkMozEmbedDownload *item, guint command)) +GTKMOZEMBED_API(void, gtk_moz_embed_download_do_command , (GtkMozEmbedDownload *item, guint command)) +GTKMOZEMBED_API(void, gtk_moz_embed_download_do_command , (GtkMozEmbedDownload *item, guint command)) +GTKMOZEMBED_API(void, gtk_moz_embed_download_do_command , (GtkMozEmbedDownload *item, guint command)) +GTKMOZEMBED_API(gchar *, gtk_moz_embed_download_get_file_name , (GtkMozEmbedDownload *item)) +GTKMOZEMBED_API(gchar *, gtk_moz_embed_download_get_url , (GtkMozEmbedDownload *item)) +GTKMOZEMBED_API(glong , gtk_moz_embed_download_get_progress , (GtkMozEmbedDownload *item)) +GTKMOZEMBED_API(glong , gtk_moz_embed_download_get_file_size , (GtkMozEmbedDownload *item)) +#ifdef __cplusplus +} +#endif /* __cplusplus */ +#endif /* gtkmozembed_download_h */ diff --git a/mozilla/embedding/browser/gtk/src/gtkmozembed_glue.cpp b/mozilla/embedding/browser/gtk/src/gtkmozembed_glue.cpp index f78defaad83..9eeb2d36ea0 100644 --- a/mozilla/embedding/browser/gtk/src/gtkmozembed_glue.cpp +++ b/mozilla/embedding/browser/gtk/src/gtkmozembed_glue.cpp @@ -1,3 +1,5 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * @@ -40,6 +42,8 @@ // XPCOMGlueStartup to glue the gtkmozembed functions. #include "gtkmozembed.h" +#include "gtkmozembed_common.h" +#include "gtkmozembed_download.h" #include "nsXPCOMGlue.h" #ifndef XPCOM_GLUE @@ -72,7 +76,27 @@ GTKF(gtk_moz_embed_set_chrome_mask) \ GTKF(gtk_moz_embed_get_chrome_mask) \ GTKF(gtk_moz_embed_single_get_type) \ - GTKF(gtk_moz_embed_single_get) + GTKF(gtk_moz_embed_single_get) \ + GTKF(gtk_moz_embed_get_zoom_level) \ + GTKF(gtk_moz_embed_set_zoom_level) \ + GTKF(gtk_moz_embed_load_image) \ + GTKF(gtk_moz_embed_find_text) \ + GTKF(gtk_moz_embed_clipboard) \ + GTKF(gtk_moz_embed_notify_plugins) \ + GTKF(gtk_moz_embed_download_get_type) \ + GTKF(gtk_moz_embed_download_new) \ + GTKF(gtk_moz_embed_common_get_type) \ + GTKF(gtk_moz_embed_common_new) \ + GTKF(gtk_moz_embed_common_set_pref) \ + GTKF(gtk_moz_embed_common_get_pref) \ + GTKF(gtk_moz_embed_common_save_prefs) \ + GTKF(gtk_moz_embed_common_remove_passwords) \ + GTKF(gtk_moz_embed_common_get_history_list) \ + GTKF(gtk_moz_embed_get_context_info) \ + GTKF(gtk_moz_embed_get_selection) \ + GTKF(gtk_moz_embed_get_doc_info) \ + GTKF(gtk_moz_embed_insert_text) \ + GTKF(gtk_moz_embed_common_nsx509_to_raw) #define GTKF(fname) fname##Type fname; diff --git a/mozilla/embedding/browser/gtk/src/gtkmozembed_internal.h b/mozilla/embedding/browser/gtk/src/gtkmozembed_internal.h index dbed4a2a4c4..3603cc43165 100644 --- a/mozilla/embedding/browser/gtk/src/gtkmozembed_internal.h +++ b/mozilla/embedding/browser/gtk/src/gtkmozembed_internal.h @@ -1,3 +1,5 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * @@ -40,6 +42,7 @@ #include #include +#include struct nsModuleComponentInfo; @@ -50,6 +53,7 @@ extern "C" { GTKMOZEMBED_API(void, gtk_moz_embed_get_nsIWebBrowser, (GtkMozEmbed *embed, nsIWebBrowser **retval)) + GTKMOZEMBED_API(PRUnichar*, gtk_moz_embed_get_title_unichar, (GtkMozEmbed *embed)) @@ -69,6 +73,4 @@ GTKMOZEMBED_API(void, #ifdef __cplusplus } #endif /* __cplusplus */ - #endif /* gtkmozembed_internal_h */ - diff --git a/mozilla/embedding/browser/gtk/src/gtkmozembedmarshal.c b/mozilla/embedding/browser/gtk/src/gtkmozembedmarshal.c index 87735725e1d..9a8aaca1251 100644 --- a/mozilla/embedding/browser/gtk/src/gtkmozembedmarshal.c +++ b/mozilla/embedding/browser/gtk/src/gtkmozembedmarshal.c @@ -47,7 +47,7 @@ #endif /* !G_ENABLE_DEBUG */ -/* BOOL:STRING (types.txt:1) */ +/* BOOL:STRING */ void gtkmozembed_BOOLEAN__STRING (GClosure *closure, GValue *return_value, @@ -86,21 +86,522 @@ gtkmozembed_BOOLEAN__STRING (GClosure *closure, g_value_set_boolean (return_value, v_return); } -/* VOID:STRING,INT,INT (types.txt:2) */ +/* BOOL:STRING,STRING */ void -gtkmozembed_VOID__STRING_INT_INT (GClosure *closure, - GValue *return_value, - guint n_param_values, - const GValue *param_values, - gpointer invocation_hint, - gpointer marshal_data) +gtkmozembed_BOOLEAN__STRING_STRING (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) { - typedef void (*GMarshalFunc_VOID__STRING_INT_INT) (gpointer data1, - gpointer arg_1, - gint arg_2, - gint arg_3, - gpointer data2); - register GMarshalFunc_VOID__STRING_INT_INT callback; + typedef gboolean (*GMarshalFunc_BOOLEAN__STRING_STRING) (gpointer data1, + gpointer arg_1, + gpointer arg_2, + gpointer data2); + register GMarshalFunc_BOOLEAN__STRING_STRING callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + gboolean v_return; + + g_return_if_fail (return_value != NULL); + g_return_if_fail (n_param_values == 3); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_BOOLEAN__STRING_STRING) (marshal_data ? marshal_data : cc->callback); + + v_return = callback (data1, + g_marshal_value_peek_string (param_values + 1), + g_marshal_value_peek_string (param_values + 2), + data2); + + g_value_set_boolean (return_value, v_return); +} + +/* BOOL:STRING,STRING,POINTER */ +void +gtkmozembed_BOOLEAN__STRING_STRING_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef gboolean (*GMarshalFunc_BOOLEAN__STRING_STRING_POINTER) (gpointer data1, + gpointer arg_1, + gpointer arg_2, + gpointer arg_3, + gpointer data2); + register GMarshalFunc_BOOLEAN__STRING_STRING_POINTER callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + gboolean v_return; + + g_return_if_fail (return_value != NULL); + g_return_if_fail (n_param_values == 4); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_BOOLEAN__STRING_STRING_POINTER) (marshal_data ? marshal_data : cc->callback); + + v_return = callback (data1, + g_marshal_value_peek_string (param_values + 1), + g_marshal_value_peek_string (param_values + 2), + g_marshal_value_peek_pointer (param_values + 3), + data2); + + g_value_set_boolean (return_value, v_return); +} + +/* BOOL:STRING,STRING,POINTER,INT */ +void +gtkmozembed_BOOLEAN__STRING_STRING_POINTER_INT (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef gboolean (*GMarshalFunc_BOOLEAN__STRING_STRING_POINTER_INT) (gpointer data1, + gpointer arg_1, + gpointer arg_2, + gpointer arg_3, + gint arg_4, + gpointer data2); + register GMarshalFunc_BOOLEAN__STRING_STRING_POINTER_INT callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + gboolean v_return; + + g_return_if_fail (return_value != NULL); + g_return_if_fail (n_param_values == 5); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_BOOLEAN__STRING_STRING_POINTER_INT) (marshal_data ? marshal_data : cc->callback); + + v_return = callback (data1, + g_marshal_value_peek_string (param_values + 1), + g_marshal_value_peek_string (param_values + 2), + g_marshal_value_peek_pointer (param_values + 3), + g_marshal_value_peek_int (param_values + 4), + data2); + + g_value_set_boolean (return_value, v_return); +} + +/* BOOL:STRING,STRING,POINTER,POINTER,STRING,POINTER */ +void +gtkmozembed_BOOLEAN__STRING_STRING_POINTER_POINTER_STRING_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef gboolean (*GMarshalFunc_BOOLEAN__STRING_STRING_POINTER_POINTER_STRING_POINTER) (gpointer data1, + gpointer arg_1, + gpointer arg_2, + gpointer arg_3, + gpointer arg_4, + gpointer arg_5, + gpointer arg_6, + gpointer data2); + register GMarshalFunc_BOOLEAN__STRING_STRING_POINTER_POINTER_STRING_POINTER callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + gboolean v_return; + + g_return_if_fail (return_value != NULL); + g_return_if_fail (n_param_values == 7); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_BOOLEAN__STRING_STRING_POINTER_POINTER_STRING_POINTER) (marshal_data ? marshal_data : cc->callback); + + v_return = callback (data1, + g_marshal_value_peek_string (param_values + 1), + g_marshal_value_peek_string (param_values + 2), + g_marshal_value_peek_pointer (param_values + 3), + g_marshal_value_peek_pointer (param_values + 4), + g_marshal_value_peek_string (param_values + 5), + g_marshal_value_peek_pointer (param_values + 6), + data2); + + g_value_set_boolean (return_value, v_return); +} + +/* BOOL:STRING,STRING,POINTER,STRING,POINTER */ +void +gtkmozembed_BOOLEAN__STRING_STRING_POINTER_STRING_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef gboolean (*GMarshalFunc_BOOLEAN__STRING_STRING_POINTER_STRING_POINTER) (gpointer data1, + gpointer arg_1, + gpointer arg_2, + gpointer arg_3, + gpointer arg_4, + gpointer arg_5, + gpointer data2); + register GMarshalFunc_BOOLEAN__STRING_STRING_POINTER_STRING_POINTER callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + gboolean v_return; + + g_return_if_fail (return_value != NULL); + g_return_if_fail (n_param_values == 6); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_BOOLEAN__STRING_STRING_POINTER_STRING_POINTER) (marshal_data ? marshal_data : cc->callback); + + v_return = callback (data1, + g_marshal_value_peek_string (param_values + 1), + g_marshal_value_peek_string (param_values + 2), + g_marshal_value_peek_pointer (param_values + 3), + g_marshal_value_peek_string (param_values + 4), + g_marshal_value_peek_pointer (param_values + 5), + data2); + + g_value_set_boolean (return_value, v_return); +} + +/* BOOL:STRING,STRING,STRING,POINTER */ +void +gtkmozembed_BOOLEAN__STRING_STRING_STRING_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef gboolean (*GMarshalFunc_BOOLEAN__STRING_STRING_STRING_POINTER) (gpointer data1, + gpointer arg_1, + gpointer arg_2, + gpointer arg_3, + gpointer arg_4, + gpointer data2); + register GMarshalFunc_BOOLEAN__STRING_STRING_STRING_POINTER callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + gboolean v_return; + + g_return_if_fail (return_value != NULL); + g_return_if_fail (n_param_values == 5); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_BOOLEAN__STRING_STRING_STRING_POINTER) (marshal_data ? marshal_data : cc->callback); + + v_return = callback (data1, + g_marshal_value_peek_string (param_values + 1), + g_marshal_value_peek_string (param_values + 2), + g_marshal_value_peek_string (param_values + 3), + g_marshal_value_peek_pointer (param_values + 4), + data2); + + g_value_set_boolean (return_value, v_return); +} + +/* INT:STRING,INT,INT,INT,INT,INT */ +void +gtkmozembed_INT__STRING_INT_INT_INT_INT_INT (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef gint (*GMarshalFunc_INT__STRING_INT_INT_INT_INT_INT) (gpointer data1, + gpointer arg_1, + gint arg_2, + gint arg_3, + gint arg_4, + gint arg_5, + gint arg_6, + gpointer data2); + register GMarshalFunc_INT__STRING_INT_INT_INT_INT_INT callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + gint v_return; + + g_return_if_fail (return_value != NULL); + g_return_if_fail (n_param_values == 7); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_INT__STRING_INT_INT_INT_INT_INT) (marshal_data ? marshal_data : cc->callback); + + v_return = callback (data1, + g_marshal_value_peek_string (param_values + 1), + g_marshal_value_peek_int (param_values + 2), + g_marshal_value_peek_int (param_values + 3), + g_marshal_value_peek_int (param_values + 4), + g_marshal_value_peek_int (param_values + 5), + g_marshal_value_peek_int (param_values + 6), + data2); + + g_value_set_int (return_value, v_return); +} + +/* INT:STRING,STRING,INT,INT,INT,INT */ +void +gtkmozembed_INT__STRING_STRING_INT_INT_INT_INT (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef gint (*GMarshalFunc_INT__STRING_STRING_INT_INT_INT_INT) (gpointer data1, + gpointer arg_1, + gpointer arg_2, + gint arg_3, + gint arg_4, + gint arg_5, + gint arg_6, + gpointer data2); + register GMarshalFunc_INT__STRING_STRING_INT_INT_INT_INT callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + gint v_return; + + g_return_if_fail (return_value != NULL); + g_return_if_fail (n_param_values == 7); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_INT__STRING_STRING_INT_INT_INT_INT) (marshal_data ? marshal_data : cc->callback); + + v_return = callback (data1, + g_marshal_value_peek_string (param_values + 1), + g_marshal_value_peek_string (param_values + 2), + g_marshal_value_peek_int (param_values + 3), + g_marshal_value_peek_int (param_values + 4), + g_marshal_value_peek_int (param_values + 5), + g_marshal_value_peek_int (param_values + 6), + data2); + + g_value_set_int (return_value, v_return); +} + +/* INT:STRING,STRING,UINT,STRING,STRING,STRING,STRING,POINTER */ +void +gtkmozembed_INT__STRING_STRING_UINT_STRING_STRING_STRING_STRING_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef gint (*GMarshalFunc_INT__STRING_STRING_UINT_STRING_STRING_STRING_STRING_POINTER) (gpointer data1, + gpointer arg_1, + gpointer arg_2, + guint arg_3, + gpointer arg_4, + gpointer arg_5, + gpointer arg_6, + gpointer arg_7, + gpointer arg_8, + gpointer data2); + register GMarshalFunc_INT__STRING_STRING_UINT_STRING_STRING_STRING_STRING_POINTER callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + gint v_return; + + g_return_if_fail (return_value != NULL); + g_return_if_fail (n_param_values == 9); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_INT__STRING_STRING_UINT_STRING_STRING_STRING_STRING_POINTER) (marshal_data ? marshal_data : cc->callback); + + v_return = callback (data1, + g_marshal_value_peek_string (param_values + 1), + g_marshal_value_peek_string (param_values + 2), + g_marshal_value_peek_uint (param_values + 3), + g_marshal_value_peek_string (param_values + 4), + g_marshal_value_peek_string (param_values + 5), + g_marshal_value_peek_string (param_values + 6), + g_marshal_value_peek_string (param_values + 7), + g_marshal_value_peek_pointer (param_values + 8), + data2); + + g_value_set_int (return_value, v_return); +} + +/* INT:VOID */ +void +gtkmozembed_INT__VOID (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef gint (*GMarshalFunc_INT__VOID) (gpointer data1, + gpointer data2); + register GMarshalFunc_INT__VOID callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + gint v_return; + + g_return_if_fail (return_value != NULL); + g_return_if_fail (n_param_values == 1); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_INT__VOID) (marshal_data ? marshal_data : cc->callback); + + v_return = callback (data1, + data2); + + g_value_set_int (return_value, v_return); +} + +/* STRING:STRING,STRING */ +void +gtkmozembed_STRING__STRING_STRING (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef gchar* (*GMarshalFunc_STRING__STRING_STRING) (gpointer data1, + gpointer arg_1, + gpointer arg_2, + gpointer data2); + register GMarshalFunc_STRING__STRING_STRING callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + gchar* v_return; + + g_return_if_fail (return_value != NULL); + g_return_if_fail (n_param_values == 3); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_STRING__STRING_STRING) (marshal_data ? marshal_data : cc->callback); + + v_return = callback (data1, + g_marshal_value_peek_string (param_values + 1), + g_marshal_value_peek_string (param_values + 2), + data2); + + g_value_take_string (return_value, v_return); +} + +/* VOID:BOOL */ + +/* VOID:INT,INT,BOOL */ +void +gtkmozembed_VOID__INT_INT_BOOLEAN (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef void (*GMarshalFunc_VOID__INT_INT_BOOLEAN) (gpointer data1, + gint arg_1, + gint arg_2, + gboolean arg_3, + gpointer data2); + register GMarshalFunc_VOID__INT_INT_BOOLEAN callback; register GCClosure *cc = (GCClosure*) closure; register gpointer data1, data2; @@ -116,16 +617,92 @@ gtkmozembed_VOID__STRING_INT_INT (GClosure *closure, data1 = g_value_peek_pointer (param_values + 0); data2 = closure->data; } - callback = (GMarshalFunc_VOID__STRING_INT_INT) (marshal_data ? marshal_data : cc->callback); + callback = (GMarshalFunc_VOID__INT_INT_BOOLEAN) (marshal_data ? marshal_data : cc->callback); callback (data1, - g_marshal_value_peek_string (param_values + 1), + g_marshal_value_peek_int (param_values + 1), g_marshal_value_peek_int (param_values + 2), - g_marshal_value_peek_int (param_values + 3), + g_marshal_value_peek_boolean (param_values + 3), data2); } -/* VOID:INT,UINT (types.txt:3) */ +/* VOID:INT,STRING */ +void +gtkmozembed_VOID__INT_STRING (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef void (*GMarshalFunc_VOID__INT_STRING) (gpointer data1, + gint arg_1, + gpointer arg_2, + gpointer data2); + register GMarshalFunc_VOID__INT_STRING callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + + g_return_if_fail (n_param_values == 3); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__INT_STRING) (marshal_data ? marshal_data : cc->callback); + + callback (data1, + g_marshal_value_peek_int (param_values + 1), + g_marshal_value_peek_string (param_values + 2), + data2); +} + +/* VOID:INT,STRING,STRING */ +void +gtkmozembed_VOID__INT_STRING_STRING (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef void (*GMarshalFunc_VOID__INT_STRING_STRING) (gpointer data1, + gint arg_1, + gpointer arg_2, + gpointer arg_3, + gpointer data2); + register GMarshalFunc_VOID__INT_STRING_STRING callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + + g_return_if_fail (n_param_values == 4); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__INT_STRING_STRING) (marshal_data ? marshal_data : cc->callback); + + callback (data1, + g_marshal_value_peek_int (param_values + 1), + g_marshal_value_peek_string (param_values + 2), + g_marshal_value_peek_string (param_values + 3), + data2); +} + +/* VOID:INT,UINT */ void gtkmozembed_VOID__INT_UINT (GClosure *closure, GValue *return_value, @@ -162,46 +739,7 @@ gtkmozembed_VOID__INT_UINT (GClosure *closure, data2); } -/* VOID:STRING,INT,UINT (types.txt:4) */ -void -gtkmozembed_VOID__STRING_INT_UINT (GClosure *closure, - GValue *return_value, - guint n_param_values, - const GValue *param_values, - gpointer invocation_hint, - gpointer marshal_data) -{ - typedef void (*GMarshalFunc_VOID__STRING_INT_UINT) (gpointer data1, - gpointer arg_1, - gint arg_2, - guint arg_3, - gpointer data2); - register GMarshalFunc_VOID__STRING_INT_UINT callback; - register GCClosure *cc = (GCClosure*) closure; - register gpointer data1, data2; - - g_return_if_fail (n_param_values == 4); - - if (G_CCLOSURE_SWAP_DATA (closure)) - { - data1 = closure->data; - data2 = g_value_peek_pointer (param_values + 0); - } - else - { - data1 = g_value_peek_pointer (param_values + 0); - data2 = closure->data; - } - callback = (GMarshalFunc_VOID__STRING_INT_UINT) (marshal_data ? marshal_data : cc->callback); - - callback (data1, - g_marshal_value_peek_string (param_values + 1), - g_marshal_value_peek_int (param_values + 2), - g_marshal_value_peek_uint (param_values + 3), - data2); -} - -/* VOID:POINTER,INT,POINTER (types.txt:5) */ +/* VOID:POINTER,INT,POINTER */ void gtkmozembed_VOID__POINTER_INT_POINTER (GClosure *closure, GValue *return_value, @@ -240,3 +778,464 @@ gtkmozembed_VOID__POINTER_INT_POINTER (GClosure *closure, data2); } +/* VOID:POINTER,INT,STRING,STRING,STRING,STRING,STRING,BOOLEAN,INT */ +void +gtkmozembed_VOID__POINTER_INT_STRING_STRING_STRING_STRING_STRING_BOOLEAN_INT (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef void (*GMarshalFunc_VOID__POINTER_INT_STRING_STRING_STRING_STRING_STRING_BOOLEAN_INT) (gpointer data1, + gpointer arg_1, + gint arg_2, + gpointer arg_3, + gpointer arg_4, + gpointer arg_5, + gpointer arg_6, + gpointer arg_7, + gboolean arg_8, + gint arg_9, + gpointer data2); + register GMarshalFunc_VOID__POINTER_INT_STRING_STRING_STRING_STRING_STRING_BOOLEAN_INT callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + + g_return_if_fail (n_param_values == 10); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__POINTER_INT_STRING_STRING_STRING_STRING_STRING_BOOLEAN_INT) (marshal_data ? marshal_data : cc->callback); + + callback (data1, + g_marshal_value_peek_pointer (param_values + 1), + g_marshal_value_peek_int (param_values + 2), + g_marshal_value_peek_string (param_values + 3), + g_marshal_value_peek_string (param_values + 4), + g_marshal_value_peek_string (param_values + 5), + g_marshal_value_peek_string (param_values + 6), + g_marshal_value_peek_string (param_values + 7), + g_marshal_value_peek_boolean (param_values + 8), + g_marshal_value_peek_int (param_values + 9), + data2); +} + +/* VOID:POINTER,STRING,BOOL,BOOL */ +void +gtkmozembed_VOID__POINTER_STRING_BOOLEAN_BOOLEAN (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef void (*GMarshalFunc_VOID__POINTER_STRING_BOOLEAN_BOOLEAN) (gpointer data1, + gpointer arg_1, + gpointer arg_2, + gboolean arg_3, + gboolean arg_4, + gpointer data2); + register GMarshalFunc_VOID__POINTER_STRING_BOOLEAN_BOOLEAN callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + + g_return_if_fail (n_param_values == 5); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__POINTER_STRING_BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback); + + callback (data1, + g_marshal_value_peek_pointer (param_values + 1), + g_marshal_value_peek_string (param_values + 2), + g_marshal_value_peek_boolean (param_values + 3), + g_marshal_value_peek_boolean (param_values + 4), + data2); +} + +/* VOID:STRING,INT,INT */ +void +gtkmozembed_VOID__STRING_INT_INT (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef void (*GMarshalFunc_VOID__STRING_INT_INT) (gpointer data1, + gpointer arg_1, + gint arg_2, + gint arg_3, + gpointer data2); + register GMarshalFunc_VOID__STRING_INT_INT callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + + g_return_if_fail (n_param_values == 4); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__STRING_INT_INT) (marshal_data ? marshal_data : cc->callback); + + callback (data1, + g_marshal_value_peek_string (param_values + 1), + g_marshal_value_peek_int (param_values + 2), + g_marshal_value_peek_int (param_values + 3), + data2); +} + +/* VOID:STRING,INT,UINT */ +void +gtkmozembed_VOID__STRING_INT_UINT (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef void (*GMarshalFunc_VOID__STRING_INT_UINT) (gpointer data1, + gpointer arg_1, + gint arg_2, + guint arg_3, + gpointer data2); + register GMarshalFunc_VOID__STRING_INT_UINT callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + + g_return_if_fail (n_param_values == 4); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__STRING_INT_UINT) (marshal_data ? marshal_data : cc->callback); + + callback (data1, + g_marshal_value_peek_string (param_values + 1), + g_marshal_value_peek_int (param_values + 2), + g_marshal_value_peek_uint (param_values + 3), + data2); +} + +/* VOID:STRING,STRING */ +void +gtkmozembed_VOID__STRING_STRING (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef void (*GMarshalFunc_VOID__STRING_STRING) (gpointer data1, + gpointer arg_1, + gpointer arg_2, + gpointer data2); + register GMarshalFunc_VOID__STRING_STRING callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + + g_return_if_fail (n_param_values == 3); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__STRING_STRING) (marshal_data ? marshal_data : cc->callback); + + callback (data1, + g_marshal_value_peek_string (param_values + 1), + g_marshal_value_peek_string (param_values + 2), + data2); +} + +/* VOID:STRING,STRING,POINTER */ +void +gtkmozembed_VOID__STRING_STRING_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef void (*GMarshalFunc_VOID__STRING_STRING_POINTER) (gpointer data1, + gpointer arg_1, + gpointer arg_2, + gpointer arg_3, + gpointer data2); + register GMarshalFunc_VOID__STRING_STRING_POINTER callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + + g_return_if_fail (n_param_values == 4); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__STRING_STRING_POINTER) (marshal_data ? marshal_data : cc->callback); + + callback (data1, + g_marshal_value_peek_string (param_values + 1), + g_marshal_value_peek_string (param_values + 2), + g_marshal_value_peek_pointer (param_values + 3), + data2); +} + +/* VOID:STRING,STRING,STRING,ULONG,INT */ +void +gtkmozembed_VOID__STRING_STRING_STRING_ULONG_INT (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING_ULONG_INT) (gpointer data1, + gpointer arg_1, + gpointer arg_2, + gpointer arg_3, + gulong arg_4, + gint arg_5, + gpointer data2); + register GMarshalFunc_VOID__STRING_STRING_STRING_ULONG_INT callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + + g_return_if_fail (n_param_values == 6); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__STRING_STRING_STRING_ULONG_INT) (marshal_data ? marshal_data : cc->callback); + + callback (data1, + g_marshal_value_peek_string (param_values + 1), + g_marshal_value_peek_string (param_values + 2), + g_marshal_value_peek_string (param_values + 3), + g_marshal_value_peek_ulong (param_values + 4), + g_marshal_value_peek_int (param_values + 5), + data2); +} + +/* VOID:STRING,STRING,STRING,POINTER */ +void +gtkmozembed_VOID__STRING_STRING_STRING_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING_POINTER) (gpointer data1, + gpointer arg_1, + gpointer arg_2, + gpointer arg_3, + gpointer arg_4, + gpointer data2); + register GMarshalFunc_VOID__STRING_STRING_STRING_POINTER callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + + g_return_if_fail (n_param_values == 5); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__STRING_STRING_STRING_POINTER) (marshal_data ? marshal_data : cc->callback); + + callback (data1, + g_marshal_value_peek_string (param_values + 1), + g_marshal_value_peek_string (param_values + 2), + g_marshal_value_peek_string (param_values + 3), + g_marshal_value_peek_pointer (param_values + 4), + data2); +} + +/* VOID:UINT,INT,INT,STRING,STRING,STRING,STRING */ +void +gtkmozembed_VOID__UINT_INT_INT_STRING_STRING_STRING_STRING (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef void (*GMarshalFunc_VOID__UINT_INT_INT_STRING_STRING_STRING_STRING) (gpointer data1, + guint arg_1, + gint arg_2, + gint arg_3, + gpointer arg_4, + gpointer arg_5, + gpointer arg_6, + gpointer arg_7, + gpointer data2); + register GMarshalFunc_VOID__UINT_INT_INT_STRING_STRING_STRING_STRING callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + + g_return_if_fail (n_param_values == 8); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__UINT_INT_INT_STRING_STRING_STRING_STRING) (marshal_data ? marshal_data : cc->callback); + + callback (data1, + g_marshal_value_peek_uint (param_values + 1), + g_marshal_value_peek_int (param_values + 2), + g_marshal_value_peek_int (param_values + 3), + g_marshal_value_peek_string (param_values + 4), + g_marshal_value_peek_string (param_values + 5), + g_marshal_value_peek_string (param_values + 6), + g_marshal_value_peek_string (param_values + 7), + data2); +} + +/* VOID:ULONG,ULONG,ULONG */ +void +gtkmozembed_VOID__ULONG_ULONG_ULONG (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef void (*GMarshalFunc_VOID__ULONG_ULONG_ULONG) (gpointer data1, + gulong arg_1, + gulong arg_2, + gulong arg_3, + gpointer data2); + register GMarshalFunc_VOID__ULONG_ULONG_ULONG callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + + g_return_if_fail (n_param_values == 4); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__ULONG_ULONG_ULONG) (marshal_data ? marshal_data : cc->callback); + + callback (data1, + g_marshal_value_peek_ulong (param_values + 1), + g_marshal_value_peek_ulong (param_values + 2), + g_marshal_value_peek_ulong (param_values + 3), + data2); +} + +/* BOOL:POINTER,UINT */ +void +gtkmozembed_BOOLEAN__POINTER_UINT (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_UINT) (gpointer data1, + gpointer arg_1, + guint arg_2, + gpointer data2); + register GMarshalFunc_BOOLEAN__POINTER_UINT callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + gboolean v_return; + + g_return_if_fail (return_value != NULL); + g_return_if_fail (n_param_values == 3); + + if (G_CCLOSURE_SWAP_DATA (closure)) + { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } + else + { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = (GMarshalFunc_BOOLEAN__POINTER_UINT) (marshal_data ? marshal_data : cc->callback); + + v_return = callback (data1, + g_marshal_value_peek_pointer (param_values + 1), + g_marshal_value_peek_uint (param_values + 2), + data2); + + g_value_set_boolean (return_value, v_return); +} + +/* VOID:POINTER */ + +/* BOOL:STRING,STRING,POINTER */ + diff --git a/mozilla/embedding/browser/gtk/src/gtkmozembedmarshal.h b/mozilla/embedding/browser/gtk/src/gtkmozembedmarshal.h index d7f294d4f08..82dfa03572f 100644 --- a/mozilla/embedding/browser/gtk/src/gtkmozembedmarshal.h +++ b/mozilla/embedding/browser/gtk/src/gtkmozembedmarshal.h @@ -6,7 +6,7 @@ G_BEGIN_DECLS -/* BOOL:STRING (types.txt:1) */ +/* BOOL:STRING */ extern void gtkmozembed_BOOLEAN__STRING (GClosure *closure, GValue *return_value, guint n_param_values, @@ -15,15 +15,130 @@ extern void gtkmozembed_BOOLEAN__STRING (GClosure *closure, gpointer marshal_data); #define gtkmozembed_BOOL__STRING gtkmozembed_BOOLEAN__STRING -/* VOID:STRING,INT,INT (types.txt:2) */ -extern void gtkmozembed_VOID__STRING_INT_INT (GClosure *closure, - GValue *return_value, - guint n_param_values, - const GValue *param_values, - gpointer invocation_hint, - gpointer marshal_data); +/* BOOL:STRING,STRING */ +extern void gtkmozembed_BOOLEAN__STRING_STRING (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); +#define gtkmozembed_BOOL__STRING_STRING gtkmozembed_BOOLEAN__STRING_STRING -/* VOID:INT,UINT (types.txt:3) */ +/* BOOL:STRING,STRING,POINTER */ +extern void gtkmozembed_BOOLEAN__STRING_STRING_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); +#define gtkmozembed_BOOL__STRING_STRING_POINTER gtkmozembed_BOOLEAN__STRING_STRING_POINTER + +/* BOOL:STRING,STRING,POINTER,INT */ +extern void gtkmozembed_BOOLEAN__STRING_STRING_POINTER_INT (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); +#define gtkmozembed_BOOL__STRING_STRING_POINTER_INT gtkmozembed_BOOLEAN__STRING_STRING_POINTER_INT + +/* BOOL:STRING,STRING,POINTER,POINTER,STRING,POINTER */ +extern void gtkmozembed_BOOLEAN__STRING_STRING_POINTER_POINTER_STRING_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); +#define gtkmozembed_BOOL__STRING_STRING_POINTER_POINTER_STRING_POINTER gtkmozembed_BOOLEAN__STRING_STRING_POINTER_POINTER_STRING_POINTER + +/* BOOL:STRING,STRING,POINTER,STRING,POINTER */ +extern void gtkmozembed_BOOLEAN__STRING_STRING_POINTER_STRING_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); +#define gtkmozembed_BOOL__STRING_STRING_POINTER_STRING_POINTER gtkmozembed_BOOLEAN__STRING_STRING_POINTER_STRING_POINTER + +/* BOOL:STRING,STRING,STRING,POINTER */ +extern void gtkmozembed_BOOLEAN__STRING_STRING_STRING_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); +#define gtkmozembed_BOOL__STRING_STRING_STRING_POINTER gtkmozembed_BOOLEAN__STRING_STRING_STRING_POINTER + +/* INT:STRING,INT,INT,INT,INT,INT */ +extern void gtkmozembed_INT__STRING_INT_INT_INT_INT_INT (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + +/* INT:STRING,STRING,INT,INT,INT,INT */ +extern void gtkmozembed_INT__STRING_STRING_INT_INT_INT_INT (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + +/* INT:STRING,STRING,UINT,STRING,STRING,STRING,STRING,POINTER */ +extern void gtkmozembed_INT__STRING_STRING_UINT_STRING_STRING_STRING_STRING_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + +/* INT:VOID */ +extern void gtkmozembed_INT__VOID (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + +/* STRING:STRING,STRING */ +extern void gtkmozembed_STRING__STRING_STRING (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + +/* VOID:BOOL */ +#define gtkmozembed_VOID__BOOLEAN g_cclosure_marshal_VOID__BOOLEAN +#define gtkmozembed_VOID__BOOL gtkmozembed_VOID__BOOLEAN + +/* VOID:INT,INT,BOOL */ +extern void gtkmozembed_VOID__INT_INT_BOOLEAN (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); +#define gtkmozembed_VOID__INT_INT_BOOL gtkmozembed_VOID__INT_INT_BOOLEAN + +/* VOID:INT,STRING */ +extern void gtkmozembed_VOID__INT_STRING (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + +/* VOID:INT,STRING,STRING */ +extern void gtkmozembed_VOID__INT_STRING_STRING (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + +/* VOID:INT,UINT */ extern void gtkmozembed_VOID__INT_UINT (GClosure *closure, GValue *return_value, guint n_param_values, @@ -31,15 +146,7 @@ extern void gtkmozembed_VOID__INT_UINT (GClosure *closure, gpointer invocation_hint, gpointer marshal_data); -/* VOID:STRING,INT,UINT (types.txt:4) */ -extern void gtkmozembed_VOID__STRING_INT_UINT (GClosure *closure, - GValue *return_value, - guint n_param_values, - const GValue *param_values, - gpointer invocation_hint, - gpointer marshal_data); - -/* VOID:POINTER,INT,POINTER (types.txt:5) */ +/* VOID:POINTER,INT,POINTER */ extern void gtkmozembed_VOID__POINTER_INT_POINTER (GClosure *closure, GValue *return_value, guint n_param_values, @@ -47,6 +154,101 @@ extern void gtkmozembed_VOID__POINTER_INT_POINTER (GClosure *closure, gpointer invocation_hint, gpointer marshal_data); +/* VOID:POINTER,INT,STRING,STRING,STRING,STRING,STRING,BOOLEAN,INT */ +extern void gtkmozembed_VOID__POINTER_INT_STRING_STRING_STRING_STRING_STRING_BOOLEAN_INT (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + +/* VOID:POINTER,STRING,BOOL,BOOL */ +extern void gtkmozembed_VOID__POINTER_STRING_BOOLEAN_BOOLEAN (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); +#define gtkmozembed_VOID__POINTER_STRING_BOOL_BOOL gtkmozembed_VOID__POINTER_STRING_BOOLEAN_BOOLEAN + +/* VOID:STRING,INT,INT */ +extern void gtkmozembed_VOID__STRING_INT_INT (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + +/* VOID:STRING,INT,UINT */ +extern void gtkmozembed_VOID__STRING_INT_UINT (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + +/* VOID:STRING,STRING */ +extern void gtkmozembed_VOID__STRING_STRING (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + +/* VOID:STRING,STRING,POINTER */ +extern void gtkmozembed_VOID__STRING_STRING_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + +/* VOID:STRING,STRING,STRING,ULONG,INT */ +extern void gtkmozembed_VOID__STRING_STRING_STRING_ULONG_INT (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + +/* VOID:STRING,STRING,STRING,POINTER */ +extern void gtkmozembed_VOID__STRING_STRING_STRING_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + +/* VOID:UINT,INT,INT,STRING,STRING,STRING,STRING */ +extern void gtkmozembed_VOID__UINT_INT_INT_STRING_STRING_STRING_STRING (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + +/* VOID:ULONG,ULONG,ULONG */ +extern void gtkmozembed_VOID__ULONG_ULONG_ULONG (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + +/* BOOL:POINTER,UINT */ +extern void gtkmozembed_BOOLEAN__POINTER_UINT (GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); +#define gtkmozembed_BOOL__POINTER_UINT gtkmozembed_BOOLEAN__POINTER_UINT + +/* VOID:POINTER */ +#define gtkmozembed_VOID__POINTER g_cclosure_marshal_VOID__POINTER + +/* BOOL:STRING,STRING,POINTER */ + G_END_DECLS #endif /* __gtkmozembed_MARSHAL_H__ */ diff --git a/mozilla/embedding/browser/gtk/src/gtkmozembedmarshal.list b/mozilla/embedding/browser/gtk/src/gtkmozembedmarshal.list new file mode 100644 index 00000000000..cd73cc8cd9f --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/gtkmozembedmarshal.list @@ -0,0 +1,31 @@ +BOOL:STRING +BOOL:STRING,STRING +BOOL:STRING,STRING,POINTER +BOOL:STRING,STRING,POINTER,INT +BOOL:STRING,STRING,POINTER,POINTER,STRING,POINTER +BOOL:STRING,STRING,POINTER,STRING,POINTER +BOOL:STRING,STRING,STRING,POINTER +INT:STRING,INT,INT,INT,INT,INT +INT:STRING,STRING,INT,INT,INT,INT +INT:STRING,STRING,UINT,STRING,STRING,STRING,STRING,POINTER +INT:VOID +STRING:STRING,STRING +VOID:BOOL +VOID:INT,INT,BOOL +VOID:INT,STRING +VOID:INT,STRING,STRING +VOID:INT,UINT +VOID:POINTER,INT,POINTER +VOID:POINTER,INT,STRING,STRING,STRING,STRING,STRING,BOOLEAN,INT +VOID:POINTER,STRING,BOOL,BOOL +VOID:STRING,INT,INT +VOID:STRING,INT,UINT +VOID:STRING,STRING +VOID:STRING,STRING,POINTER +VOID:STRING,STRING,STRING,ULONG,INT +VOID:STRING,STRING,STRING,POINTER +VOID:UINT,INT,INT,STRING,STRING,STRING,STRING +VOID:ULONG,ULONG,ULONG +BOOL:POINTER,UINT +VOID:POINTER +BOOL:STRING,STRING,POINTER diff --git a/mozilla/embedding/browser/gtk/src/gtkmozembedprivate.h b/mozilla/embedding/browser/gtk/src/gtkmozembedprivate.h index 5d7b652f14c..8ae2b4071ef 100644 --- a/mozilla/embedding/browser/gtk/src/gtkmozembedprivate.h +++ b/mozilla/embedding/browser/gtk/src/gtkmozembedprivate.h @@ -1,3 +1,5 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * @@ -76,16 +78,69 @@ enum { DOM_ACTIVATE, DOM_FOCUS_IN, DOM_FOCUS_OUT, + ALERT, + ALERT_CHECK, + CONFIRM, + CONFIRM_CHECK, + CONFIRM_EX, + PROMPT, + PROMPT_AUTH, + SELECT, + DOWNLOAD_REQUEST, + DOM_MOUSE_SCROLL, + DOM_MOUSE_LONG_PRESS, + DOM_FOCUS, + DOM_BLUR, + UPLOAD_DIALOG, + ICON_CHANGED, + MAILTO, + UNKNOWN_PROTOCOL, EMBED_LAST_SIGNAL }; +// DOM_MOUSE_MOVE, extern guint moz_embed_signals[EMBED_LAST_SIGNAL]; -extern void gtk_moz_embed_single_create_window(GtkMozEmbed **aNewEmbed, - guint aChromeFlags); +#if 0 +enum { + COMMON_CERT_DIALOG, + COMMON_CERT_PASSWD_DIALOG, + COMMON_CERT_DETAILS_DIALOG, + COMMON_HISTORY_ADDED, + COMMON_ON_SUBMIT_SIGNAL, + COMMON_SELECT_MATCH_SIGNAL, + COMMON_MODAL_DIALOG, + COMMON_LAST_SIGNAL +}; +#endif +enum { + COMMON_CERT_ERROR, + COMMON_SELECT_LOGIN, + COMMON_REMEMBER_LOGIN, + COMMON_ASK_COOKIE, + COMMON_LAST_SIGNAL +}; + +extern guint moz_embed_common_signals[COMMON_LAST_SIGNAL]; + +enum +{ + DOWNLOAD_STARTED_SIGNAL, + DOWNLOAD_STOPPED_SIGNAL, + DOWNLOAD_COMPLETED_SIGNAL, + DOWNLOAD_FAILED_SIGNAL, + DOWNLOAD_DESTROYED_SIGNAL, + DOWNLOAD_PROGRESS_SIGNAL, + DOWNLOAD_LAST_SIGNAL +}; + +extern guint moz_embed_download_signals[DOWNLOAD_LAST_SIGNAL]; +extern void gtk_moz_embed_single_create_window(GtkMozEmbed **aNewEmbed, + guint aChromeFlags); #ifdef __cplusplus } #endif /* __cplusplus */ #endif /* gtkmozembedprivate_h */ + diff --git a/mozilla/embedding/browser/gtk/src/nsIPassword.idl b/mozilla/embedding/browser/gtk/src/nsIPassword.idl new file mode 100644 index 00000000000..d7de54a3968 --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/nsIPassword.idl @@ -0,0 +1,79 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** 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 mozilla.org code. + * + * The Initial Developer of the Original Code is + * Netscape Communications, Inc. + * Portions created by the Initial Developer are Copyright (C) 2001 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the 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 ***** */ + +#include "nsISupports.idl" + +[scriptable, uuid(CF39C2B0-1E4B-11d5-A549-0010A401EB10)] + +/** + * An optional interface for clients wishing to access a + * password object + * + * @status FROZEN + */ + +interface nsIPassword : nsISupports { + + /** + * the name of the host corresponding to the login being saved + * + * The form of the host depends on how the nsIPassword object was created + * + * - if it was created as a result of submitting a form to a site, then the + * host is the url of the site, as obtained from a call to GetSpec + * + * - if it was created as a result of another app (e.g., mailnews) calling a + * prompt routine such at PromptUsernameAndPassword, then the host is whatever + * arbitrary string the app decided to pass in. + * + * Whatever form it is in, it will be used by the password manager to uniquely + * identify the login realm, so that "newsserver:119" is not the same thing as + * "newsserver". + */ + readonly attribute AUTF8String host; + + /** + * the user name portion of the login + */ + readonly attribute AString user; + + /** + * the password portion of the login + */ + readonly attribute AString password; +}; diff --git a/mozilla/embedding/browser/gtk/src/nsIPasswordInternal.idl b/mozilla/embedding/browser/gtk/src/nsIPasswordInternal.idl new file mode 100644 index 00000000000..06dee640092 --- /dev/null +++ b/mozilla/embedding/browser/gtk/src/nsIPasswordInternal.idl @@ -0,0 +1,57 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* ***** 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 mozilla.org code. + * + * The Initial Developer of the Original Code is Google Inc. + * Portions created by the Initial Developer are Copyright (C) 2005 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Darin Fisher + * + * 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 ***** */ + +#include "nsIPassword.idl" + +/** + * This interface is supported by password manager entries to expose the + * fieldnames passed to nsIPasswordManagerInternal's addUserFull method. + */ +[scriptable, uuid(2cc35c67-978f-42a9-a958-16e97ad2f4c8)] +interface nsIPasswordInternal : nsIPassword +{ + /** + * The name of the field that contained the username. + */ + readonly attribute AString userFieldName; + + /** + * The name of the field that contained the password. + */ + readonly attribute AString passwordFieldName; +}; diff --git a/mozilla/embedding/browser/gtk/src/types.txt b/mozilla/embedding/browser/gtk/src/types.txt deleted file mode 100644 index ea3d2de8a46..00000000000 --- a/mozilla/embedding/browser/gtk/src/types.txt +++ /dev/null @@ -1,5 +0,0 @@ -BOOL:STRING -VOID:STRING,INT,INT -VOID:INT,UINT -VOID:STRING,INT,UINT -VOID:POINTER,INT,POINTER