embedding/browser/webBrowser/nsDocShellTreeOwner.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  *
   3  * ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is the Mozilla browser.
  17  *
  18  * The Initial Developer of the Original Code is
  19  * Netscape Communications, Inc.
  20  * Portions created by the Initial Developer are Copyright (C) 1999
  21  * the Initial Developer. All Rights Reserved.
  22  *
  23  * Contributor(s):
  24  *   Travis Bogard <travis@netscape.com>
  25  *   Adam Lock <adamlock@netscape.com>
  26  *   Mike Pinkerton <pinkerton@netscape.com>
  27  *   Dan Rosen <dr@netscape.com>
  28  *
  29  * Alternatively, the contents of this file may be used under the terms of
  30  * either the GNU General Public License Version 2 or later (the "GPL"), or
  31  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  32  * in which case the provisions of the GPL or the LGPL are applicable instead
  33  * of those above. If you wish to allow use of your version of this file only
  34  * under the terms of either the GPL or the LGPL, and not to allow others to
  35  * use your version of this file under the terms of the MPL, indicate your
  36  * decision by deleting the provisions above and replace them with the notice
  37  * and other provisions required by the GPL or the LGPL. If you do not delete
  38  * the provisions above, a recipient may use your version of this file under
  39  * the terms of any one of the MPL, the GPL or the LGPL.
  40  *
  41  * ***** END LICENSE BLOCK ***** */
  42
  43 // Local Includes
  44 #include "nsDocShellTreeOwner.h"
  45 #include "nsWebBrowser.h"
  46
  47 // Helper Classes
  48 #include "nsIGenericFactory.h"
  49 #include "nsStyleCoord.h"
  50 #include "nsSize.h"
  51 #include "nsHTMLReflowState.h"
  52 #include "nsIServiceManager.h"
  53 #include "nsComponentManagerUtils.h"
  54 #include "nsXPIDLString.h"
  55 #include "nsIAtom.h"
  56 #include "nsReadableUtils.h"
  57 #include "nsUnicharUtils.h"
  58 #include "nsISimpleEnumerator.h"
  59
  60 // Interfaces needed to be included
  61 #include "nsPresContext.h"
  62 #include "nsIContextMenuListener.h"
  63 #include "nsIContextMenuListener2.h"
  64 #include "nsITooltipListener.h"
  65 #include "nsIPrivateDOMEvent.h"
  66 #include "nsIDOMNode.h"
  67 #include "nsIDOMNodeList.h"
  68 #include "nsIDOMDocument.h"
  69 #include "nsIDOMDocumentType.h"
  70 #include "nsIDOMElement.h"
  71 #include "nsIDOMEvent.h"
  72 #include "nsIDOMMouseEvent.h"
  73 #include "nsIDOMNSUIEvent.h"
  74 #include "nsIDOMEventTarget.h"
  75 #include "nsIDOMNamedNodeMap.h"
  76 #include "nsIDOMHTMLInputElement.h"
  77 #include "nsIDOMHTMLTextAreaElement.h"
  78 #include "nsIDOMHTMLHtmlElement.h"
  79 #include "nsIDOMHTMLAppletElement.h"
  80 #include "nsIDOMHTMLObjectElement.h"
  81 #include "nsIDOMHTMLEmbedElement.h"
  82 #include "nsIDOMHTMLDocument.h"
  83 #include "nsIImageLoadingContent.h"
  84 #include "nsIWebNavigation.h"
  85 #include "nsIDOMHTMLElement.h"
  86 #include "nsIPresShell.h"
  87 #include "nsPIDOMWindow.h"
  88 #include "nsIDOMWindowCollection.h"
  89 #include "nsIFocusController.h"
  90 #include "nsIWindowWatcher.h"
  91 #include "nsPIWindowWatcher.h"
  92 #include "nsIPrompt.h"
  93 #include "nsRect.h"
  94 #include "nsIWebBrowserChromeFocus.h"
  95 #include "nsIContent.h"
  96 #include "imgIContainer.h"
  97 #include "nsContextMenuInfo.h"
  98 #include "nsPresContext.h"
  99 #include "nsIViewManager.h"
 100 #include "nsIView.h"
 101 #include "nsPIDOMEventTarget.h"
 102
 103 //
 104 // GetEventReceiver
 105 //
 106 // A helper routine that navigates the tricky path from a |nsWebBrowser| to
 107 // a |nsPIDOMEventTarget| via the window root and chrome event handler.
 108 //
 109 static nsresult
 110 GetPIDOMEventTarget( nsWebBrowser* inBrowser, nsPIDOMEventTarget** aTarget)
 111 {
 112   nsCOMPtr<nsIDOMWindow> domWindow;
 113   inBrowser->GetContentDOMWindow(getter_AddRefs(domWindow));
 114   NS_ENSURE_TRUE(domWindow, NS_ERROR_FAILURE);
 115
 116   nsCOMPtr<nsPIDOMWindow> domWindowPrivate = do_QueryInterface(domWindow);
 117   NS_ENSURE_TRUE(domWindowPrivate, NS_ERROR_FAILURE);
 118   nsPIDOMWindow *rootWindow = domWindowPrivate->GetPrivateRoot();
 119   NS_ENSURE_TRUE(rootWindow, NS_ERROR_FAILURE);
 120   nsCOMPtr<nsPIDOMEventTarget> piTarget =
 121     do_QueryInterface(rootWindow->GetChromeEventHandler());
 122   NS_ENSURE_TRUE(piTarget, NS_ERROR_FAILURE);
 123   *aTarget = piTarget;
 124   NS_IF_ADDREF(*aTarget);
 125
 126   return NS_OK;
 127 }
 128
 129
 130 //*****************************************************************************
 131 //***    nsDocShellTreeOwner: Object Management
 132 //*****************************************************************************
 133
 134 nsDocShellTreeOwner::nsDocShellTreeOwner() :
 135    mWebBrowser(nsnull),
 136    mTreeOwner(nsnull),
 137    mPrimaryContentShell(nsnull),
 138    mWebBrowserChrome(nsnull),
 139    mOwnerWin(nsnull),
 140    mOwnerRequestor(nsnull),
 141    mChromeTooltipListener(nsnull),
 142    mChromeContextMenuListener(nsnull)
 143 {
 144 }
 145
 146 nsDocShellTreeOwner::~nsDocShellTreeOwner()
 147 {
 148   RemoveChromeListeners();
 149 }
 150
 151 //*****************************************************************************
 152 // nsDocShellTreeOwner::nsISupports
 153 //*****************************************************************************
 154
 155 NS_IMPL_ADDREF(nsDocShellTreeOwner)
 156 NS_IMPL_RELEASE(nsDocShellTreeOwner)
 157
 158 NS_INTERFACE_MAP_BEGIN(nsDocShellTreeOwner)
 159     NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDocShellTreeOwner)
 160     NS_INTERFACE_MAP_ENTRY(nsIDocShellTreeOwner)
 161     NS_INTERFACE_MAP_ENTRY(nsIBaseWindow)
 162     NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)
 163     NS_INTERFACE_MAP_ENTRY(nsIWebProgressListener)
 164     NS_INTERFACE_MAP_ENTRY(nsICDocShellTreeOwner)
 165     NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
 166 NS_INTERFACE_MAP_END
 167
 168 //*****************************************************************************
 169 // nsDocShellTreeOwner::nsIInterfaceRequestor
 170 //*****************************************************************************
 171
 172 NS_IMETHODIMP
 173 nsDocShellTreeOwner::GetInterface(const nsIID& aIID, void** aSink)
 174 {
 175   NS_ENSURE_ARG_POINTER(aSink);
 176
 177   if(NS_SUCCEEDED(QueryInterface(aIID, aSink)))
 178     return NS_OK;
 179
 180   if (aIID.Equals(NS_GET_IID(nsIWebBrowserChromeFocus))) {
 181     if (mWebBrowserChromeWeak != nsnull)
 182       return mWebBrowserChromeWeak->QueryReferent(aIID, aSink);
 183     return mOwnerWin->QueryInterface(aIID, aSink);
 184   }
 185
 186   if (aIID.Equals(NS_GET_IID(nsIPrompt))) {
 187     nsIPrompt *prompt;
 188     EnsurePrompter();
 189     prompt = mPrompter;
 190     if (prompt) {
 191       NS_ADDREF(prompt);
 192       *aSink = prompt;
 193       return NS_OK;
 194     }
 195     return NS_NOINTERFACE;
 196   }
 197
 198   if (aIID.Equals(NS_GET_IID(nsIAuthPrompt))) {
 199     nsIAuthPrompt *prompt;
 200     EnsureAuthPrompter();
 201     prompt = mAuthPrompter;
 202     if (prompt) {
 203       NS_ADDREF(prompt);
 204       *aSink = prompt;
 205       return NS_OK;
 206     }
 207     return NS_NOINTERFACE;
 208   }
 209
 210   nsCOMPtr<nsIInterfaceRequestor> req = GetOwnerRequestor();
 211   if (req)
 212     return req->GetInterface(aIID, aSink);
 213
 214   return NS_NOINTERFACE;
 215 }
 216
 217 //*****************************************************************************
 218 // nsDocShellTreeOwner::nsIDocShellTreeOwner
 219 //*****************************************************************************
 220
 221 NS_IMETHODIMP
 222 nsDocShellTreeOwner::FindItemWithName(const PRUnichar* aName,
 223                                       nsIDocShellTreeItem* aRequestor,
 224                                       nsIDocShellTreeItem* aOriginalRequestor,
 225                                       nsIDocShellTreeItem** aFoundItem)
 226 {
 227   NS_ENSURE_ARG(aName);
 228   NS_ENSURE_ARG_POINTER(aFoundItem);
 229   *aFoundItem = nsnull; // if we don't find one, we return NS_OK and a null result
 230   nsresult rv;
 231
 232   nsAutoString name(aName);
 233
 234   if (!mWebBrowser)
 235     return NS_OK; // stymied
 236
 237   /* special cases */
 238   if(name.IsEmpty())
 239     return NS_OK;
 240   if(name.LowerCaseEqualsLiteral("_blank"))
 241     return NS_OK;
 242   // _main is an IE target which should be case-insensitive but isn't
 243   // see bug 217886 for details
 244   if(name.LowerCaseEqualsLiteral("_content") || name.EqualsLiteral("_main")) {
 245     *aFoundItem = mWebBrowser->mDocShellAsItem;
 246     NS_IF_ADDREF(*aFoundItem);
 247     return NS_OK;
 248   }
 249
 250   // first, is it us?
 251   {
 252     nsCOMPtr<nsIDOMWindow> domWindow;
 253     mWebBrowser->GetContentDOMWindow(getter_AddRefs(domWindow));
 254     if (domWindow) {
 255       nsAutoString ourName;
 256       domWindow->GetName(ourName);
 257       if (name.Equals(ourName, nsCaseInsensitiveStringComparator())) {
 258         *aFoundItem = mWebBrowser->mDocShellAsItem;
 259         NS_IF_ADDREF(*aFoundItem);
 260         return NS_OK;
 261       }
 262     }
 263   }
 264
 265   // next, check our children
 266   rv = FindChildWithName(aName, PR_TRUE, aRequestor, aOriginalRequestor,
 267                          aFoundItem);
 268   if(NS_FAILED(rv) || *aFoundItem)
 269     return rv;
 270
 271   // next, if we have a parent and it isn't the requestor, ask it
 272   nsCOMPtr<nsIDocShellTreeOwner> reqAsTreeOwner(do_QueryInterface(aRequestor));
 273
 274   if(mTreeOwner) {
 275     if (mTreeOwner != reqAsTreeOwner)
 276       return mTreeOwner->FindItemWithName(aName, mWebBrowser->mDocShellAsItem,
 277                                           aOriginalRequestor, aFoundItem);
 278     return NS_OK;
 279   }
 280
 281   // finally, failing everything else, search all windows
 282   return FindItemWithNameAcrossWindows(aName, aRequestor, aOriginalRequestor,
 283                                        aFoundItem);
 284 }
 285
 286 nsresult
 287 nsDocShellTreeOwner::FindChildWithName(const PRUnichar *aName, PRBool aRecurse,
 288                                        nsIDocShellTreeItem* aRequestor,
 289                                        nsIDocShellTreeItem* aOriginalRequestor,
 290                                        nsIDocShellTreeItem **aFoundItem)
 291 {
 292   if (!mWebBrowser)
 293     return NS_OK;
 294
 295   nsresult rv = NS_OK;
 296
 297   nsCOMPtr<nsIDOMWindow> domWindow;
 298   mWebBrowser->GetContentDOMWindow(getter_AddRefs(domWindow));
 299   if (!domWindow)
 300     return NS_OK;
 301
 302   nsCOMPtr<nsIDOMWindowCollection> frames;
 303   domWindow->GetFrames(getter_AddRefs(frames));
 304   if (!frames)
 305     return NS_OK;
 306
 307   PRUint32 ctr, count;
 308   frames->GetLength(&count);
 309   for (ctr = 0; ctr < count; ctr++) {
 310     nsCOMPtr<nsIDOMWindow> frame;
 311     frames->Item(ctr, getter_AddRefs(frame));
 312     nsCOMPtr<nsPIDOMWindow> w(do_QueryInterface(frame));
 313     if (w) {
 314       nsCOMPtr<nsIDocShellTreeItem> item = do_QueryInterface(w->GetDocShell());
 315       if (item && item != aRequestor) {
 316         rv = item->FindItemWithName(aName, mWebBrowser->mDocShellAsItem,
 317                                     aOriginalRequestor, aFoundItem);
 318         if (NS_FAILED(rv) || *aFoundItem)
 319           break;
 320       }
 321     }
 322   }
 323
 324   return rv;
 325 }
 326
 327 nsresult
 328 nsDocShellTreeOwner::FindItemWithNameAcrossWindows(const PRUnichar* aName,
 329                                                    nsIDocShellTreeItem* aRequestor,
 330                                                    nsIDocShellTreeItem* aOriginalRequestor,
 331                                                    nsIDocShellTreeItem** aFoundItem)
 332 {
 333   // search for the item across the list of top-level windows
 334   nsCOMPtr<nsPIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
 335   if (!wwatch)
 336     return NS_OK;
 337
 338   return wwatch->FindItemWithName(aName, aRequestor, aOriginalRequestor,
 339                                   aFoundItem);
 340 }
 341
 342 void
 343 nsDocShellTreeOwner::EnsurePrompter()
 344 {
 345   if (mPrompter)
 346     return;
 347
 348   nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
 349   if (wwatch && mWebBrowser) {
 350     nsCOMPtr<nsIDOMWindow> domWindow;
 351     mWebBrowser->GetContentDOMWindow(getter_AddRefs(domWindow));
 352     if (domWindow)
 353       wwatch->GetNewPrompter(domWindow, getter_AddRefs(mPrompter));
 354   }
 355 }
 356
 357 void
 358 nsDocShellTreeOwner::EnsureAuthPrompter()
 359 {
 360   if (mAuthPrompter)
 361     return;
 362
 363   nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
 364   if (wwatch && mWebBrowser) {
 365     nsCOMPtr<nsIDOMWindow> domWindow;
 366     mWebBrowser->GetContentDOMWindow(getter_AddRefs(domWindow));
 367     if (domWindow)
 368       wwatch->GetNewAuthPrompter(domWindow, getter_AddRefs(mAuthPrompter));
 369   }
 370 }
 371
 372 void
 373 nsDocShellTreeOwner::AddToWatcher()
 374 {
 375   if (mWebBrowser) {
 376     nsCOMPtr<nsIDOMWindow> domWindow;
 377     mWebBrowser->GetContentDOMWindow(getter_AddRefs(domWindow));
 378     if (domWindow) {
 379       nsCOMPtr<nsPIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
 380       if (wwatch) {
 381         nsCOMPtr<nsIWebBrowserChrome> webBrowserChrome = GetWebBrowserChrome();
 382         if (webBrowserChrome)
 383           wwatch->AddWindow(domWindow, webBrowserChrome);
 384       }
 385     }
 386   }
 387 }
 388
 389 void
 390 nsDocShellTreeOwner::RemoveFromWatcher()
 391 {
 392   if (mWebBrowser) {
 393     nsCOMPtr<nsIDOMWindow> domWindow;
 394     mWebBrowser->GetContentDOMWindow(getter_AddRefs(domWindow));
 395     if (domWindow) {
 396       nsCOMPtr<nsPIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
 397       if (wwatch)
 398         wwatch->RemoveWindow(domWindow);
 399     }
 400   }
 401 }
 402
 403
 404 NS_IMETHODIMP
 405 nsDocShellTreeOwner::ContentShellAdded(nsIDocShellTreeItem* aContentShell,
 406                                        PRBool aPrimary, PRBool aTargetable,
 407                                        const nsAString& aID)
 408 {
 409    if(mTreeOwner)
 410       return mTreeOwner->ContentShellAdded(aContentShell, aPrimary,
 411                                            aTargetable, aID);
 412
 413    if (aPrimary)
 414       mPrimaryContentShell = aContentShell;
 415    return NS_OK;
 416 }
 417
 418 NS_IMETHODIMP
 419 nsDocShellTreeOwner::ContentShellRemoved(nsIDocShellTreeItem* aContentShell)
 420 {
 421   if(mTreeOwner)
 422     return mTreeOwner->ContentShellRemoved(aContentShell);
 423
 424   if(mPrimaryContentShell == aContentShell)
 425     mPrimaryContentShell = nsnull;
 426
 427   return NS_OK;
 428 }
 429
 430 NS_IMETHODIMP
 431 nsDocShellTreeOwner::GetPrimaryContentShell(nsIDocShellTreeItem** aShell)
 432 {
 433    NS_ENSURE_ARG_POINTER(aShell);
 434
 435    if(mTreeOwner)
 436        return mTreeOwner->GetPrimaryContentShell(aShell);
 437
 438    *aShell = (mPrimaryContentShell ? mPrimaryContentShell : mWebBrowser->mDocShellAsItem.get());
 439    NS_IF_ADDREF(*aShell);
 440
 441    return NS_OK;
 442 }
 443
 444 NS_IMETHODIMP
 445 nsDocShellTreeOwner::SizeShellTo(nsIDocShellTreeItem* aShellItem,
 446                                  PRInt32 aCX, PRInt32 aCY)
 447 {
 448    nsCOMPtr<nsIWebBrowserChrome> webBrowserChrome = GetWebBrowserChrome();
 449
 450    NS_ENSURE_STATE(mTreeOwner || webBrowserChrome);
 451
 452    if(mTreeOwner)
 453       return mTreeOwner->SizeShellTo(aShellItem, aCX, aCY);
 454
 455    if(aShellItem == mWebBrowser->mDocShellAsItem)
 456       return webBrowserChrome->SizeBrowserTo(aCX, aCY);
 457
 458    nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(aShellItem));
 459    NS_ENSURE_TRUE(webNav, NS_ERROR_FAILURE);
 460
 461    nsCOMPtr<nsIDOMDocument> domDocument;
 462    webNav->GetDocument(getter_AddRefs(domDocument));
 463    NS_ENSURE_TRUE(domDocument, NS_ERROR_FAILURE);
 464
 465    nsCOMPtr<nsIDOMElement> domElement;
 466    domDocument->GetDocumentElement(getter_AddRefs(domElement));
 467    NS_ENSURE_TRUE(domElement, NS_ERROR_FAILURE);
 468
 469    // Set the preferred Size
 470    //XXX
 471    NS_ERROR("Implement this");
 472    /*
 473    Set the preferred size on the aShellItem.
 474    */
 475
 476    nsCOMPtr<nsPresContext> presContext;
 477    mWebBrowser->mDocShell->GetPresContext(getter_AddRefs(presContext));
 478    NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE);
 479
 480    nsIPresShell *presShell = presContext->GetPresShell();
 481    NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
 482
 483    NS_ENSURE_SUCCESS(presShell->ResizeReflow(NS_UNCONSTRAINEDSIZE,
 484       NS_UNCONSTRAINEDSIZE), NS_ERROR_FAILURE);
 485
 486    nsRect shellArea = presContext->GetVisibleArea();
 487
 488    PRInt32 browserCX = presContext->AppUnitsToDevPixels(shellArea.width);
 489    PRInt32 browserCY = presContext->AppUnitsToDevPixels(shellArea.height);
 490
 491    return webBrowserChrome->SizeBrowserTo(browserCX, browserCY);
 492 }
 493
 494 NS_IMETHODIMP
 495 nsDocShellTreeOwner::SetPersistence(PRBool aPersistPosition,
 496                                     PRBool aPersistSize,
 497                                     PRBool aPersistSizeMode)
 498 {
 499   return NS_ERROR_NOT_IMPLEMENTED;
 500 }
 501
 502 NS_IMETHODIMP
 503 nsDocShellTreeOwner::GetPersistence(PRBool* aPersistPosition,
 504                                     PRBool* aPersistSize,
 505                                     PRBool* aPersistSizeMode)
 506 {
 507   return NS_ERROR_NOT_IMPLEMENTED;
 508 }
 509
 510 //*****************************************************************************
 511 // nsDocShellTreeOwner::nsIBaseWindow
 512 //*****************************************************************************
 513
 514
 515 NS_IMETHODIMP
 516 nsDocShellTreeOwner::InitWindow(nativeWindow aParentNativeWindow,
 517                                 nsIWidget* aParentWidget, PRInt32 aX,
 518                                 PRInt32 aY, PRInt32 aCX, PRInt32 aCY)
 519 {
 520   return NS_ERROR_NULL_POINTER;
 521 }
 522
 523 NS_IMETHODIMP
 524 nsDocShellTreeOwner::Create()
 525 {
 526   return NS_ERROR_NULL_POINTER;
 527 }
 528
 529 NS_IMETHODIMP
 530 nsDocShellTreeOwner::Destroy()
 531 {
 532   nsCOMPtr<nsIWebBrowserChrome> webBrowserChrome = GetWebBrowserChrome();
 533   if (webBrowserChrome)
 534   {
 535     return webBrowserChrome->DestroyBrowserWindow();
 536   }
 537
 538   return NS_ERROR_NULL_POINTER;
 539 }
 540
 541 NS_IMETHODIMP
 542 nsDocShellTreeOwner::SetPosition(PRInt32 aX, PRInt32 aY)
 543 {
 544   nsCOMPtr<nsIEmbeddingSiteWindow> ownerWin = GetOwnerWin();
 545   if (ownerWin)
 546   {
 547     return ownerWin->SetDimensions(nsIEmbeddingSiteWindow::DIM_FLAGS_POSITION,
 548                                    aX, aY, 0, 0);
 549   }
 550   return NS_ERROR_NULL_POINTER;
 551 }
 552
 553 NS_IMETHODIMP
 554 nsDocShellTreeOwner::GetPosition(PRInt32* aX, PRInt32* aY)
 555 {
 556   nsCOMPtr<nsIEmbeddingSiteWindow> ownerWin = GetOwnerWin();
 557   if (ownerWin)
 558   {
 559     return ownerWin->GetDimensions(nsIEmbeddingSiteWindow::DIM_FLAGS_POSITION,
 560                                    aX, aY, nsnull, nsnull);
 561   }
 562   return NS_ERROR_NULL_POINTER;
 563 }
 564
 565 NS_IMETHODIMP
 566 nsDocShellTreeOwner::SetSize(PRInt32 aCX, PRInt32 aCY, PRBool aRepaint)
 567 {
 568   nsCOMPtr<nsIEmbeddingSiteWindow> ownerWin = GetOwnerWin();
 569   if (ownerWin)
 570   {
 571     return ownerWin->SetDimensions(nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_OUTER,
 572                                    0, 0, aCX, aCY);
 573   }
 574   return NS_ERROR_NULL_POINTER;
 575 }
 576
 577 NS_IMETHODIMP
 578 nsDocShellTreeOwner::GetSize(PRInt32* aCX, PRInt32* aCY)
 579 {
 580   nsCOMPtr<nsIEmbeddingSiteWindow> ownerWin = GetOwnerWin();
 581   if (ownerWin)
 582   {
 583     return ownerWin->GetDimensions(nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_OUTER,
 584                                    nsnull, nsnull, aCX, aCY);
 585   }
 586   return NS_ERROR_NULL_POINTER;
 587 }
 588
 589 NS_IMETHODIMP
 590 nsDocShellTreeOwner::SetPositionAndSize(PRInt32 aX, PRInt32 aY, PRInt32 aCX,
 591                                         PRInt32 aCY, PRBool aRepaint)
 592 {
 593   nsCOMPtr<nsIEmbeddingSiteWindow> ownerWin = GetOwnerWin();
 594   if (ownerWin)
 595   {
 596     return ownerWin->SetDimensions(nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_OUTER |
 597                                    nsIEmbeddingSiteWindow::DIM_FLAGS_POSITION,
 598                                    aX, aY, aCX, aCY);
 599   }
 600   return NS_ERROR_NULL_POINTER;
 601 }
 602
 603 NS_IMETHODIMP
 604 nsDocShellTreeOwner::GetPositionAndSize(PRInt32* aX, PRInt32* aY, PRInt32* aCX,
 605                                         PRInt32* aCY)
 606 {
 607   nsCOMPtr<nsIEmbeddingSiteWindow> ownerWin = GetOwnerWin();
 608   if (ownerWin)
 609   {
 610     return ownerWin->GetDimensions(nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_OUTER |
 611                                    nsIEmbeddingSiteWindow::DIM_FLAGS_POSITION,
 612                                    aX, aY, aCX, aCY);
 613   }
 614   return NS_ERROR_NULL_POINTER;
 615 }
 616
 617 NS_IMETHODIMP
 618 nsDocShellTreeOwner::Repaint(PRBool aForce)
 619 {
 620   return NS_ERROR_NULL_POINTER;
 621 }
 622
 623 NS_IMETHODIMP
 624 nsDocShellTreeOwner::GetParentWidget(nsIWidget** aParentWidget)
 625 {
 626   return NS_ERROR_NULL_POINTER;
 627 }
 628
 629 NS_IMETHODIMP
 630 nsDocShellTreeOwner::SetParentWidget(nsIWidget* aParentWidget)
 631 {
 632   return NS_ERROR_NULL_POINTER;
 633 }
 634
 635 NS_IMETHODIMP
 636 nsDocShellTreeOwner::GetParentNativeWindow(nativeWindow* aParentNativeWindow)
 637 {
 638   nsCOMPtr<nsIEmbeddingSiteWindow> ownerWin = GetOwnerWin();
 639   if (ownerWin)
 640   {
 641     return ownerWin->GetSiteWindow(aParentNativeWindow);
 642   }
 643   return NS_ERROR_NULL_POINTER;
 644 }
 645
 646 NS_IMETHODIMP
 647 nsDocShellTreeOwner::SetParentNativeWindow(nativeWindow aParentNativeWindow)
 648 {
 649   return NS_ERROR_NULL_POINTER;
 650 }
 651
 652 NS_IMETHODIMP
 653 nsDocShellTreeOwner::GetVisibility(PRBool* aVisibility)
 654 {
 655   nsCOMPtr<nsIEmbeddingSiteWindow> ownerWin = GetOwnerWin();
 656   if (ownerWin)
 657   {
 658     return ownerWin->GetVisibility(aVisibility);
 659   }
 660   return NS_ERROR_NULL_POINTER;
 661 }
 662
 663 NS_IMETHODIMP
 664 nsDocShellTreeOwner::SetVisibility(PRBool aVisibility)
 665 {
 666   nsCOMPtr<nsIEmbeddingSiteWindow> ownerWin = GetOwnerWin();
 667   if (ownerWin)
 668   {
 669     return ownerWin->SetVisibility(aVisibility);
 670   }
 671   return NS_ERROR_NULL_POINTER;
 672 }
 673
 674 NS_IMETHODIMP
 675 nsDocShellTreeOwner::GetEnabled(PRBool *aEnabled)
 676 {
 677   NS_ENSURE_ARG_POINTER(aEnabled);
 678   *aEnabled = PR_TRUE;
 679   return NS_ERROR_NOT_IMPLEMENTED;
 680 }
 681
 682 NS_IMETHODIMP
 683 nsDocShellTreeOwner::SetEnabled(PRBool aEnabled)
 684 {
 685   return NS_ERROR_NOT_IMPLEMENTED;
 686 }
 687
 688 NS_IMETHODIMP
 689 nsDocShellTreeOwner::GetBlurSuppression(PRBool *aBlurSuppression)
 690 {
 691   NS_ENSURE_ARG_POINTER(aBlurSuppression);
 692   *aBlurSuppression = PR_FALSE;
 693   return NS_ERROR_NOT_IMPLEMENTED;
 694 }
 695
 696 NS_IMETHODIMP
 697 nsDocShellTreeOwner::SetBlurSuppression(PRBool aBlurSuppression)
 698 {
 699   return NS_ERROR_NOT_IMPLEMENTED;
 700 }
 701
 702 NS_IMETHODIMP
 703 nsDocShellTreeOwner::GetMainWidget(nsIWidget** aMainWidget)
 704 {
 705     return NS_ERROR_NULL_POINTER;
 706 }
 707
 708 NS_IMETHODIMP
 709 nsDocShellTreeOwner::SetFocus()
 710 {
 711   nsCOMPtr<nsIEmbeddingSiteWindow> ownerWin = GetOwnerWin();
 712   if (ownerWin)
 713   {
 714     return ownerWin->SetFocus();
 715   }
 716   return NS_ERROR_NULL_POINTER;
 717 }
 718
 719 NS_IMETHODIMP
 720 nsDocShellTreeOwner::GetTitle(PRUnichar** aTitle)
 721 {
 722   nsCOMPtr<nsIEmbeddingSiteWindow> ownerWin = GetOwnerWin();
 723   if (ownerWin)
 724   {
 725     return ownerWin->GetTitle(aTitle);
 726   }
 727   return NS_ERROR_NULL_POINTER;
 728 }
 729
 730 NS_IMETHODIMP
 731 nsDocShellTreeOwner::SetTitle(const PRUnichar* aTitle)
 732 {
 733   nsCOMPtr<nsIEmbeddingSiteWindow> ownerWin = GetOwnerWin();
 734   if (ownerWin)
 735   {
 736     return ownerWin->SetTitle(aTitle);
 737   }
 738   return NS_ERROR_NULL_POINTER;
 739 }
 740
 741
 742 //*****************************************************************************
 743 // nsDocShellTreeOwner::nsIWebProgressListener
 744 //*****************************************************************************
 745
 746
 747 NS_IMETHODIMP
 748 nsDocShellTreeOwner::OnProgressChange(nsIWebProgress* aProgress,
 749                                       nsIRequest* aRequest,
 750                                       PRInt32 aCurSelfProgress,
 751                                       PRInt32 aMaxSelfProgress,
 752                                       PRInt32 aCurTotalProgress,
 753                                       PRInt32 aMaxTotalProgress)
 754 {
 755     // In the absence of DOM document creation event, this method is the
 756     // most convenient place to install the mouse listener on the
 757     // DOM document.
 758     return AddChromeListeners();
 759 }
 760
 761 NS_IMETHODIMP
 762 nsDocShellTreeOwner::OnStateChange(nsIWebProgress* aProgress,
 763                                    nsIRequest* aRequest,
 764                                    PRUint32 aProgressStateFlags,
 765                                    nsresult aStatus)
 766 {
 767     return NS_OK;
 768 }
 769
 770 NS_IMETHODIMP
 771 nsDocShellTreeOwner::OnLocationChange(nsIWebProgress* aWebProgress,
 772                                       nsIRequest* aRequest,
 773                                       nsIURI* aURI)
 774 {
 775     return NS_OK;
 776 }
 777
 778 NS_IMETHODIMP
 779 nsDocShellTreeOwner::OnStatusChange(nsIWebProgress* aWebProgress,
 780                                     nsIRequest* aRequest,
 781                                     nsresult aStatus,
 782                                     const PRUnichar* aMessage)
 783 {
 784     return NS_OK;
 785 }
 786
 787 NS_IMETHODIMP
 788 nsDocShellTreeOwner::OnSecurityChange(nsIWebProgress *aWebProgress,
 789                                       nsIRequest *aRequest,
 790                                       PRUint32 state)
 791 {
 792     return NS_OK;
 793 }
 794
 795
 796 //*****************************************************************************
 797 // nsDocShellTreeOwner: Helpers
 798 //*****************************************************************************
 799
 800 //*****************************************************************************
 801 // nsDocShellTreeOwner: Accessors
 802 //*****************************************************************************
 803
 804 void
 805 nsDocShellTreeOwner::WebBrowser(nsWebBrowser* aWebBrowser)
 806 {
 807   if ( !aWebBrowser )
 808     RemoveChromeListeners();
 809   if (aWebBrowser != mWebBrowser) {
 810     mPrompter = 0;
 811     mAuthPrompter = 0;
 812   }
 813
 814   mWebBrowser = aWebBrowser;
 815 }
 816
 817 nsWebBrowser *
 818 nsDocShellTreeOwner::WebBrowser()
 819 {
 820    return mWebBrowser;
 821 }
 822
 823 NS_IMETHODIMP
 824 nsDocShellTreeOwner::SetTreeOwner(nsIDocShellTreeOwner* aTreeOwner)
 825 {
 826   if(aTreeOwner) {
 827     nsCOMPtr<nsIWebBrowserChrome> webBrowserChrome(do_GetInterface(aTreeOwner));
 828     NS_ENSURE_TRUE(webBrowserChrome, NS_ERROR_INVALID_ARG);
 829     NS_ENSURE_SUCCESS(SetWebBrowserChrome(webBrowserChrome), NS_ERROR_INVALID_ARG);
 830     mTreeOwner = aTreeOwner;
 831   }
 832   else {
 833     mTreeOwner = nsnull;
 834     nsCOMPtr<nsIWebBrowserChrome> webBrowserChrome = GetWebBrowserChrome();
 835     if (!webBrowserChrome)
 836       NS_ENSURE_SUCCESS(SetWebBrowserChrome(nsnull), NS_ERROR_FAILURE);
 837   }
 838
 839   return NS_OK;
 840 }
 841
 842 NS_IMETHODIMP
 843 nsDocShellTreeOwner::SetWebBrowserChrome(nsIWebBrowserChrome* aWebBrowserChrome)
 844 {
 845   if(!aWebBrowserChrome) {
 846     mWebBrowserChrome = nsnull;
 847     mOwnerWin = nsnull;
 848     mOwnerRequestor = nsnull;
 849     mWebBrowserChromeWeak = 0;
 850   } else {
 851     nsCOMPtr<nsISupportsWeakReference> supportsweak =
 852                                            do_QueryInterface(aWebBrowserChrome);
 853     if (supportsweak) {
 854       supportsweak->GetWeakReference(getter_AddRefs(mWebBrowserChromeWeak));
 855     } else {
 856       nsCOMPtr<nsIEmbeddingSiteWindow> ownerWin(do_QueryInterface(aWebBrowserChrome));
 857       nsCOMPtr<nsIInterfaceRequestor> requestor(do_QueryInterface(aWebBrowserChrome));
 858
 859       // it's ok for ownerWin or requestor to be null.
 860       mWebBrowserChrome = aWebBrowserChrome;
 861       mOwnerWin = ownerWin;
 862       mOwnerRequestor = requestor;
 863     }
 864   }
 865   return NS_OK;
 866 }
 867
 868
 869 //
 870 // AddChromeListeners
 871 //
 872 // Hook up things to the chrome like context menus and tooltips, if the chrome
 873 // has implemented the right interfaces.
 874 //
 875 NS_IMETHODIMP
 876 nsDocShellTreeOwner::AddChromeListeners()
 877 {
 878   nsresult rv = NS_OK;
 879
 880   nsCOMPtr<nsIWebBrowserChrome> webBrowserChrome = GetWebBrowserChrome();
 881   if (!webBrowserChrome)
 882     return NS_ERROR_FAILURE;
 883
 884   // install tooltips
 885   if ( !mChromeTooltipListener ) {
 886     nsCOMPtr<nsITooltipListener>
 887                            tooltipListener(do_QueryInterface(webBrowserChrome));
 888     if ( tooltipListener ) {
 889       mChromeTooltipListener = new ChromeTooltipListener(mWebBrowser,
 890                                                          webBrowserChrome);
 891       if ( mChromeTooltipListener ) {
 892         NS_ADDREF(mChromeTooltipListener);
 893         rv = mChromeTooltipListener->AddChromeListeners();
 894       }
 895       else
 896         rv = NS_ERROR_OUT_OF_MEMORY;
 897     }
 898   }
 899
 900   // install context menus
 901   if ( !mChromeContextMenuListener ) {
 902     nsCOMPtr<nsIContextMenuListener2>
 903                           contextListener2(do_QueryInterface(webBrowserChrome));
 904     nsCOMPtr<nsIContextMenuListener>
 905                            contextListener(do_QueryInterface(webBrowserChrome));
 906     if ( contextListener2 || contextListener ) {
 907       mChromeContextMenuListener =
 908                    new ChromeContextMenuListener(mWebBrowser, webBrowserChrome);
 909       if ( mChromeContextMenuListener ) {
 910         NS_ADDREF(mChromeContextMenuListener);
 911         rv = mChromeContextMenuListener->AddChromeListeners();
 912       }
 913       else
 914         rv = NS_ERROR_OUT_OF_MEMORY;
 915     }
 916   }
 917
 918   // install the external dragDrop handler
 919   if ( !mChromeDragHandler ) {
 920     mChromeDragHandler = do_CreateInstance("@mozilla.org:/content/content-area-dragdrop;1", &rv);
 921     NS_ASSERTION(mChromeDragHandler, "Couldn't create the chrome drag handler");
 922     if ( mChromeDragHandler ) {
 923       nsCOMPtr<nsPIDOMEventTarget> piTarget;
 924       GetPIDOMEventTarget(mWebBrowser, getter_AddRefs(piTarget));
 925       nsCOMPtr<nsIDOMEventTarget> target(do_QueryInterface(piTarget));
 926       mChromeDragHandler->HookupTo(target, static_cast<nsIWebNavigation*>(mWebBrowser));
 927     }
 928   }
 929
 930   return rv;
 931
 932 } // AddChromeListeners
 933
 934
 935 NS_IMETHODIMP
 936 nsDocShellTreeOwner::RemoveChromeListeners()
 937 {
 938   if ( mChromeTooltipListener ) {
 939     mChromeTooltipListener->RemoveChromeListeners();
 940     NS_RELEASE(mChromeTooltipListener);
 941   }
 942   if ( mChromeContextMenuListener ) {
 943     mChromeContextMenuListener->RemoveChromeListeners();
 944     NS_RELEASE(mChromeContextMenuListener);
 945   }
 946   if ( mChromeDragHandler )
 947     mChromeDragHandler->Detach();
 948
 949   return NS_OK;
 950 }
 951
 952 already_AddRefed<nsIWebBrowserChrome>
 953 nsDocShellTreeOwner::GetWebBrowserChrome()
 954 {
 955   nsIWebBrowserChrome* chrome = nsnull;
 956   if (mWebBrowserChromeWeak != nsnull) {
 957     mWebBrowserChromeWeak->
 958                         QueryReferent(NS_GET_IID(nsIWebBrowserChrome),
 959                                       reinterpret_cast<void**>(&chrome));
 960   } else if (mWebBrowserChrome) {
 961     chrome = mWebBrowserChrome;
 962     NS_ADDREF(mWebBrowserChrome);
 963   }
 964
 965   return chrome;
 966 }
 967
 968 already_AddRefed<nsIEmbeddingSiteWindow>
 969 nsDocShellTreeOwner::GetOwnerWin()
 970 {
 971   nsIEmbeddingSiteWindow* win = nsnull;
 972   if (mWebBrowserChromeWeak != nsnull) {
 973     mWebBrowserChromeWeak->
 974                         QueryReferent(NS_GET_IID(nsIEmbeddingSiteWindow),
 975                                       reinterpret_cast<void**>(&win));
 976   } else if (mOwnerWin) {
 977     win = mOwnerWin;
 978     NS_ADDREF(mOwnerWin);
 979   }
 980
 981   return win;
 982 }
 983
 984 already_AddRefed<nsIInterfaceRequestor>
 985 nsDocShellTreeOwner::GetOwnerRequestor()
 986 {
 987   nsIInterfaceRequestor* req = nsnull;
 988   if (mWebBrowserChromeWeak != nsnull) {
 989     mWebBrowserChromeWeak->
 990                         QueryReferent(NS_GET_IID(nsIInterfaceRequestor),
 991                                       reinterpret_cast<void**>(&req));
 992   } else if (mOwnerRequestor) {
 993     req = mOwnerRequestor;
 994     NS_ADDREF(mOwnerRequestor);
 995   }
 996
 997   return req;
 998 }
 999
1000
1001 #ifdef XP_MAC
1002 #pragma mark -
1003 #endif
1004
1005
1006 ///////////////////////////////////////////////////////////////////////////////
1007 // DefaultTooltipTextProvider
1008
1009 class DefaultTooltipTextProvider : public nsITooltipTextProvider
1010 {
1011 public:
1012     DefaultTooltipTextProvider();
1013
1014     NS_DECL_ISUPPORTS
1015     NS_DECL_NSITOOLTIPTEXTPROVIDER
1016
1017 protected:
1018     nsCOMPtr<nsIAtom>   mTag_dialog;
1019     nsCOMPtr<nsIAtom>   mTag_dialogheader;
1020     nsCOMPtr<nsIAtom>   mTag_window;
1021 };
1022
1023 NS_IMPL_THREADSAFE_ISUPPORTS1(DefaultTooltipTextProvider, nsITooltipTextProvider)
1024
1025 DefaultTooltipTextProvider::DefaultTooltipTextProvider()
1026 {
1027     // There are certain element types which we don't want to use
1028     // as tool tip text.
1029     mTag_dialog       = do_GetAtom("dialog");
1030     mTag_dialogheader = do_GetAtom("dialogheader");
1031     mTag_window       = do_GetAtom("window");
1032 }
1033
1034 /* void getNodeText (in nsIDOMNode aNode, out wstring aText); */
1035 NS_IMETHODIMP
1036 DefaultTooltipTextProvider::GetNodeText(nsIDOMNode *aNode, PRUnichar **aText,
1037                                         PRBool *_retval)
1038 {
1039   NS_ENSURE_ARG_POINTER(aNode);
1040   NS_ENSURE_ARG_POINTER(aText);
1041
1042   nsString outText;
1043
1044   PRBool found = PR_FALSE;
1045   nsCOMPtr<nsIDOMNode> current ( aNode );
1046   while ( !found && current ) {
1047     nsCOMPtr<nsIDOMElement> currElement ( do_QueryInterface(current) );
1048     if ( currElement ) {
1049       nsCOMPtr<nsIContent> content(do_QueryInterface(currElement));
1050       if (content) {
1051         nsIAtom *tagAtom = content->Tag();
1052         if (tagAtom != mTag_dialog &&
1053             tagAtom != mTag_dialogheader &&
1054             tagAtom != mTag_window) {
1055           // first try the normal title attribute...
1056           currElement->GetAttribute(NS_LITERAL_STRING("title"), outText);
1057           if ( outText.Length() )
1058             found = PR_TRUE;
1059           else {
1060             // ...ok, that didn't work, try it in the XLink namespace
1061             currElement->GetAttributeNS(NS_LITERAL_STRING("http://www.w3.org/1999/xlink"), NS_LITERAL_STRING("title"), outText);
1062             if ( outText.Length() )
1063               found = PR_TRUE;
1064           }
1065         }
1066       }
1067     }
1068
1069     // not found here, walk up to the parent and keep trying
1070     if ( !found ) {
1071       nsCOMPtr<nsIDOMNode> temp ( current );
1072       temp->GetParentNode(getter_AddRefs(current));
1073     }
1074   } // while not found
1075
1076   *_retval = found;
1077   *aText = (found) ? ToNewUnicode(outText) : nsnull;
1078
1079   return NS_OK;
1080 }
1081
1082 ///////////////////////////////////////////////////////////////////////////////
1083
1084 NS_IMPL_ADDREF(ChromeTooltipListener)
1085 NS_IMPL_RELEASE(ChromeTooltipListener)
1086
1087 NS_INTERFACE_MAP_BEGIN(ChromeTooltipListener)
1088     NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMMouseListener)
1089     NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsIDOMEventListener, nsIDOMMouseListener)
1090     NS_INTERFACE_MAP_ENTRY(nsIDOMMouseListener)
1091     NS_INTERFACE_MAP_ENTRY(nsIDOMMouseMotionListener)
1092     NS_INTERFACE_MAP_ENTRY(nsIDOMKeyListener)
1093 NS_INTERFACE_MAP_END
1094
1095
1096 //
1097 // ChromeTooltipListener ctor
1098 //
1099
1100 ChromeTooltipListener::ChromeTooltipListener(nsWebBrowser* inBrowser,
1101                                              nsIWebBrowserChrome* inChrome)
1102   : mWebBrowser(inBrowser), mWebBrowserChrome(inChrome),
1103      mTooltipListenerInstalled(PR_FALSE),
1104      mMouseClientX(0), mMouseClientY(0),
1105      mShowingTooltip(PR_FALSE)
1106 {
1107   mTooltipTextProvider = do_GetService(NS_TOOLTIPTEXTPROVIDER_CONTRACTID);
1108   if (!mTooltipTextProvider) {
1109     nsISupports *pProvider = (nsISupports *) new DefaultTooltipTextProvider;
1110     mTooltipTextProvider = do_QueryInterface(pProvider);
1111   }
1112 } // ctor
1113
1114
1115 //
1116 // ChromeTooltipListener dtor
1117 //
1118 ChromeTooltipListener::~ChromeTooltipListener()
1119 {
1120
1121 } // dtor
1122
1123
1124 //
1125 // AddChromeListeners
1126 //
1127 // Hook up things to the chrome like context menus and tooltips, if the chrome
1128 // has implemented the right interfaces.
1129 //
1130 NS_IMETHODIMP
1131 ChromeTooltipListener::AddChromeListeners()
1132 {
1133   if (!mEventTarget)
1134     GetPIDOMEventTarget(mWebBrowser, getter_AddRefs(mEventTarget));
1135
1136   // Register the appropriate events for tooltips, but only if
1137   // the embedding chrome cares.
1138   nsresult rv = NS_OK;
1139   nsCOMPtr<nsITooltipListener> tooltipListener ( do_QueryInterface(mWebBrowserChrome) );
1140   if ( tooltipListener && !mTooltipListenerInstalled ) {
1141     rv = AddTooltipListener();
1142     if ( NS_FAILED(rv) )
1143       return rv;
1144   }
1145
1146   return rv;
1147
1148 } // AddChromeListeners
1149
1150
1151 //
1152 // AddTooltipListener
1153 //
1154 // Subscribe to the events that will allow us to track tooltips. We need "mouse" for mouseExit,
1155 // "mouse motion" for mouseMove, and "key" for keyDown. As we add the listeners, keep track
1156 // of how many succeed so we can clean up correctly in Release().
1157 //
1158 NS_IMETHODIMP
1159 ChromeTooltipListener::AddTooltipListener()
1160 {
1161   if (mEventTarget) {
1162     nsIDOMMouseListener *pListener = static_cast<nsIDOMMouseListener *>(this);
1163     nsresult rv = mEventTarget->AddEventListenerByIID(pListener, NS_GET_IID(nsIDOMMouseListener));
1164     nsresult rv2 = mEventTarget->AddEventListenerByIID(pListener, NS_GET_IID(nsIDOMMouseMotionListener));
1165     nsresult rv3 = mEventTarget->AddEventListenerByIID(pListener, NS_GET_IID(nsIDOMKeyListener));
1166
1167     // if all 3 succeed, we're a go!
1168     if (NS_SUCCEEDED(rv) && NS_SUCCEEDED(rv2) && NS_SUCCEEDED(rv3))
1169       mTooltipListenerInstalled = PR_TRUE;
1170   }
1171
1172   return NS_OK;
1173 }
1174
1175
1176 //
1177 // RemoveChromeListeners
1178 //
1179 // Unsubscribe from the various things we've hooked up to the window root.
1180 //
1181 NS_IMETHODIMP
1182 ChromeTooltipListener::RemoveChromeListeners ( )
1183 {
1184   HideTooltip();
1185
1186   if ( mTooltipListenerInstalled )
1187     RemoveTooltipListener();
1188
1189   mEventTarget = nsnull;
1190
1191   // it really doesn't matter if these fail...
1192   return NS_OK;
1193
1194 } // RemoveChromeTooltipListeners
1195
1196
1197
1198 //
1199 // RemoveTooltipListener
1200 //
1201 // Unsubscribe from all the various tooltip events that we were listening to
1202 //
1203 NS_IMETHODIMP
1204 ChromeTooltipListener::RemoveTooltipListener()
1205 {
1206   if (mEventTarget) {
1207     nsIDOMMouseListener *pListener = static_cast<nsIDOMMouseListener *>(this);
1208     nsresult rv = mEventTarget->RemoveEventListenerByIID(pListener, NS_GET_IID(nsIDOMMouseListener));
1209     nsresult rv2 = mEventTarget->RemoveEventListenerByIID(pListener, NS_GET_IID(nsIDOMMouseMotionListener));
1210     nsresult rv3 = mEventTarget->RemoveEventListenerByIID(pListener, NS_GET_IID(nsIDOMKeyListener));
1211     if (NS_SUCCEEDED(rv) && NS_SUCCEEDED(rv2) && NS_SUCCEEDED(rv3))
1212       mTooltipListenerInstalled = PR_FALSE;
1213   }
1214
1215   return NS_OK;
1216 }
1217
1218
1219 //
1220 // KeyDown
1221 //
1222 // When the user starts typing, they generaly don't want to see any messy wax
1223 // builup. Hide the tooltip.
1224 //
1225 nsresult
1226 ChromeTooltipListener::KeyDown(nsIDOMEvent* aMouseEvent)
1227 {
1228   return HideTooltip();
1229 } // KeyDown
1230
1231
1232 //
1233 // KeyUp
1234 // KeyPress
1235 //
1236 // We can ignore these as they are already handled by KeyDown
1237 //
1238 nsresult
1239 ChromeTooltipListener::KeyUp(nsIDOMEvent* aMouseEvent)
1240 {
1241   return NS_OK;
1242
1243 } // KeyUp
1244
1245 nsresult
1246 ChromeTooltipListener::KeyPress(nsIDOMEvent* aMouseEvent)
1247 {
1248   return NS_OK;
1249
1250 } // KeyPress
1251
1252
1253 //
1254 // MouseDown
1255 //
1256 // On a click, hide the tooltip
1257 //
1258 nsresult
1259 ChromeTooltipListener::MouseDown(nsIDOMEvent* aMouseEvent)
1260 {
1261   return HideTooltip();
1262
1263 } // MouseDown
1264
1265
1266 nsresult
1267 ChromeTooltipListener::MouseUp(nsIDOMEvent* aMouseEvent)
1268 {
1269     return NS_OK;
1270 }
1271
1272 nsresult
1273 ChromeTooltipListener::MouseClick(nsIDOMEvent* aMouseEvent)
1274 {
1275     return NS_OK;
1276 }
1277
1278 nsresult
1279 ChromeTooltipListener::MouseDblClick(nsIDOMEvent* aMouseEvent)
1280 {
1281     return NS_OK;
1282 }
1283
1284 nsresult
1285 ChromeTooltipListener::MouseOver(nsIDOMEvent* aMouseEvent)
1286 {
1287     return NS_OK;
1288 }
1289
1290
1291 //
1292 // MouseOut
1293 //
1294 // If we're responding to tooltips, hide the tip whenever the mouse leaves
1295 // the area it was in.
1296 nsresult
1297 ChromeTooltipListener::MouseOut(nsIDOMEvent* aMouseEvent)
1298 {
1299   return HideTooltip();
1300 }
1301
1302
1303 //
1304 // MouseMove
1305 //
1306 // If we're a tooltip, fire off a timer to see if a tooltip should be shown. If the
1307 // timer fires, we cache the node in |mPossibleTooltipNode|.
1308 //
1309 nsresult
1310 ChromeTooltipListener::MouseMove(nsIDOMEvent* aMouseEvent)
1311 {
1312   nsCOMPtr<nsIDOMMouseEvent> mouseEvent ( do_QueryInterface(aMouseEvent) );
1313   if (!mouseEvent)
1314     return NS_OK;
1315
1316   // stash the coordinates of the event so that we can still get back to it from within the
1317   // timer callback. On win32, we'll get a MouseMove event even when a popup goes away --
1318   // even when the mouse doesn't change position! To get around this, we make sure the
1319   // mouse has really moved before proceeding.
1320   PRInt32 newMouseX, newMouseY;
1321   mouseEvent->GetClientX(&newMouseX);
1322   mouseEvent->GetClientY(&newMouseY);
1323   if ( mMouseClientX == newMouseX && mMouseClientY == newMouseY )
1324     return NS_OK;
1325   mMouseClientX = newMouseX; mMouseClientY = newMouseY;
1326   mouseEvent->GetScreenX(&mMouseScreenX);
1327   mouseEvent->GetScreenY(&mMouseScreenY);
1328
1329   // We want to close the tip if it is being displayed and the mouse moves. Recall
1330   // that |mShowingTooltip| is set when the popup is showing. Furthermore, as the mouse
1331   // moves, we want to make sure we reset the timer to show it, so that the delay
1332   // is from when the mouse stops moving, not when it enters the element.
1333   if ( mShowingTooltip )
1334     return HideTooltip();
1335   if ( mTooltipTimer )
1336     mTooltipTimer->Cancel();
1337
1338   mTooltipTimer = do_CreateInstance("@mozilla.org/timer;1");
1339   if ( mTooltipTimer ) {
1340     nsCOMPtr<nsIDOMEventTarget> eventTarget;
1341     aMouseEvent->GetTarget(getter_AddRefs(eventTarget));
1342     if ( eventTarget )
1343       mPossibleTooltipNode = do_QueryInterface(eventTarget);
1344     if ( mPossibleTooltipNode ) {
1345       nsresult rv = mTooltipTimer->InitWithFuncCallback(sTooltipCallback, this, kTooltipShowTime,
1346                                                         nsITimer::TYPE_ONE_SHOT);
1347       if (NS_FAILED(rv))
1348         mPossibleTooltipNode = nsnull;
1349     }
1350   }
1351   else
1352     NS_WARNING ( "Could not create a timer for tooltip tracking" );
1353
1354   return NS_OK;
1355
1356 } // MouseMove
1357
1358
1359 //
1360 // ShowTooltip
1361 //
1362 // Tell the registered chrome that they should show the tooltip
1363 //
1364 NS_IMETHODIMP
1365 ChromeTooltipListener::ShowTooltip(PRInt32 inXCoords, PRInt32 inYCoords,
1366                                    const nsAString & inTipText)
1367 {
1368   nsresult rv = NS_OK;
1369
1370   // do the work to call the client
1371   nsCOMPtr<nsITooltipListener> tooltipListener ( do_QueryInterface(mWebBrowserChrome) );
1372   if ( tooltipListener ) {
1373     rv = tooltipListener->OnShowTooltip ( inXCoords, inYCoords, PromiseFlatString(inTipText).get() );
1374     if ( NS_SUCCEEDED(rv) )
1375       mShowingTooltip = PR_TRUE;
1376   }
1377
1378   return rv;
1379
1380 } // ShowTooltip
1381
1382
1383 //
1384 // HideTooltip
1385 //
1386 // Tell the registered chrome that they should rollup the tooltip
1387 // NOTE: This routine is safe to call even if the popup is already closed.
1388 //
1389 NS_IMETHODIMP
1390 ChromeTooltipListener::HideTooltip()
1391 {
1392   nsresult rv = NS_OK;
1393
1394   // shut down the relevant timers
1395   if ( mTooltipTimer ) {
1396     mTooltipTimer->Cancel();
1397     mTooltipTimer = nsnull;
1398     // release tooltip target
1399     mPossibleTooltipNode = nsnull;
1400   }
1401   if ( mAutoHideTimer ) {
1402     mAutoHideTimer->Cancel();
1403     mAutoHideTimer = nsnull;
1404   }
1405
1406   // if we're showing the tip, tell the chrome to hide it
1407   if ( mShowingTooltip ) {
1408     nsCOMPtr<nsITooltipListener> tooltipListener ( do_QueryInterface(mWebBrowserChrome) );
1409     if ( tooltipListener ) {
1410       rv = tooltipListener->OnHideTooltip ( );
1411       if ( NS_SUCCEEDED(rv) )
1412         mShowingTooltip = PR_FALSE;
1413     }
1414   }
1415
1416   return rv;
1417
1418 } // HideTooltip
1419
1420
1421 //
1422 // sTooltipCallback
1423 //
1424 // A timer callback, fired when the mouse has hovered inside of a frame for the
1425 // appropriate amount of time. Getting to this point means that we should show the
1426 // tooltip, but only after we determine there is an appropriate TITLE element.
1427 //
1428 // This relies on certain things being cached into the |aChromeTooltipListener| object passed to
1429 // us by the timer:
1430 //   -- the x/y coordinates of the mouse      (mMouseClientY, mMouseClientX)
1431 //   -- the dom node the user hovered over    (mPossibleTooltipNode)
1432 //
1433 void
1434 ChromeTooltipListener::sTooltipCallback(nsITimer *aTimer,
1435                                         void *aChromeTooltipListener)
1436 {
1437   ChromeTooltipListener* self = static_cast<ChromeTooltipListener*>
1438                                            (aChromeTooltipListener);
1439   if ( self && self->mPossibleTooltipNode ){
1440     // The actual coordinates we want to put the tooltip at are relative to the
1441     // toplevel docshell of our mWebBrowser.  We know what the screen
1442     // coordinates of the mouse event were, which means we just need the screen
1443     // coordinates of the docshell.  Unfortunately, there is no good way to
1444     // find those short of groveling for the presentation in that docshell and
1445     // finding the screen coords of its toplevel widget...
1446     nsCOMPtr<nsIDocShell> docShell =
1447       do_GetInterface(static_cast<nsIWebBrowser*>(self->mWebBrowser));
1448     nsCOMPtr<nsIPresShell> shell;
1449     if (docShell) {
1450       docShell->GetPresShell(getter_AddRefs(shell));
1451     }
1452
1453     nsIWidget* widget = nsnull;
1454     if (shell) {
1455       nsIViewManager* vm = shell->GetViewManager();
1456       if (vm) {
1457         nsIView* view;
1458         vm->GetRootView(view);
1459         if (view) {
1460           nsPoint offset;
1461           widget = view->GetNearestWidget(&offset);
1462         }
1463       }
1464     }
1465
1466     if (!widget) {
1467       // release tooltip target if there is one, NO MATTER WHAT
1468       self->mPossibleTooltipNode = nsnull;
1469       return;
1470     }
1471
1472     // if there is text associated with the node, show the tip and fire
1473     // off a timer to auto-hide it.
1474
1475     nsXPIDLString tooltipText;
1476     if (self->mTooltipTextProvider) {
1477       PRBool textFound = PR_FALSE;
1478
1479       self->mTooltipTextProvider->GetNodeText(
1480           self->mPossibleTooltipNode, getter_Copies(tooltipText), &textFound);
1481
1482       if (textFound) {
1483         nsString tipText(tooltipText);
1484         self->CreateAutoHideTimer();
1485         nsRect widgetDot(0, 0, 1, 1);
1486         nsRect screenDot;
1487         widget->WidgetToScreen(widgetDot, screenDot);
1488         self->ShowTooltip (self->mMouseScreenX - screenDot.x,
1489                            self->mMouseScreenY - screenDot.y,
1490                            tipText);
1491       }
1492     }
1493
1494     // release tooltip target if there is one, NO MATTER WHAT
1495     self->mPossibleTooltipNode = nsnull;
1496   } // if "self" data valid
1497
1498 } // sTooltipCallback
1499
1500
1501 //
1502 // CreateAutoHideTimer
1503 //
1504 // Create a new timer to see if we should auto-hide. It's ok if this fails.
1505 //
1506 void
1507 ChromeTooltipListener::CreateAutoHideTimer()
1508 {
1509   // just to be anal (er, safe)
1510   if ( mAutoHideTimer ) {
1511     mAutoHideTimer->Cancel();
1512     mAutoHideTimer = nsnull;
1513   }
1514
1515   mAutoHideTimer = do_CreateInstance("@mozilla.org/timer;1");
1516   if ( mAutoHideTimer )
1517     mAutoHideTimer->InitWithFuncCallback(sAutoHideCallback, this, kTooltipAutoHideTime,
1518                                          nsITimer::TYPE_ONE_SHOT);
1519
1520 } // CreateAutoHideTimer
1521
1522
1523 //
1524 // sAutoHideCallback
1525 //
1526 // This fires after a tooltip has been open for a certain length of time. Just tell
1527 // the listener to close the popup. We don't have to worry, because HideTooltip() can
1528 // be called multiple times, even if the tip has already been closed.
1529 //
1530 void
1531 ChromeTooltipListener::sAutoHideCallback(nsITimer *aTimer, void* aListener)
1532 {
1533   ChromeTooltipListener* self = static_cast<ChromeTooltipListener*>(aListener);
1534   if ( self )
1535     self->HideTooltip();
1536
1537   // NOTE: |aTimer| and |self->mAutoHideTimer| are invalid after calling ClosePopup();
1538
1539 } // sAutoHideCallback
1540
1541
1542
1543 #ifdef XP_MAC
1544 #pragma mark -
1545 #endif
1546
1547
1548 NS_IMPL_ADDREF(ChromeContextMenuListener)
1549 NS_IMPL_RELEASE(ChromeContextMenuListener)
1550
1551 NS_INTERFACE_MAP_BEGIN(ChromeContextMenuListener)
1552     NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMContextMenuListener)
1553     NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsIDOMEventListener, nsIDOMContextMenuListener)
1554     NS_INTERFACE_MAP_ENTRY(nsIDOMContextMenuListener)
1555 NS_INTERFACE_MAP_END
1556
1557
1558 //
1559 // ChromeTooltipListener ctor
1560 //
1561 ChromeContextMenuListener::ChromeContextMenuListener(nsWebBrowser* inBrowser, nsIWebBrowserChrome* inChrome )
1562   : mContextMenuListenerInstalled(PR_FALSE),
1563     mWebBrowser(inBrowser),
1564     mWebBrowserChrome(inChrome)
1565 {
1566 } // ctor
1567
1568
1569 //
1570 // ChromeTooltipListener dtor
1571 //
1572 ChromeContextMenuListener::~ChromeContextMenuListener()
1573 {
1574 } // dtor
1575
1576
1577 //
1578 // AddContextMenuListener
1579 //
1580 // Subscribe to the events that will allow us to track context menus. Bascially, this
1581 // is just the context-menu DOM event.
1582 //
1583 NS_IMETHODIMP
1584 ChromeContextMenuListener::AddContextMenuListener()
1585 {
1586   if (mEventTarget) {
1587     nsIDOMContextMenuListener *pListener = static_cast<nsIDOMContextMenuListener *>(this);
1588     nsresult rv = mEventTarget->AddEventListenerByIID(pListener, NS_GET_IID(nsIDOMContextMenuListener));
1589     if (NS_SUCCEEDED(rv))
1590       mContextMenuListenerInstalled = PR_TRUE;
1591   }
1592
1593   return NS_OK;
1594 }
1595
1596
1597 //
1598 // RemoveContextMenuListener
1599 //
1600 // Unsubscribe from all the various context menu events that we were listening to.
1601 //
1602 NS_IMETHODIMP
1603 ChromeContextMenuListener::RemoveContextMenuListener()
1604 {
1605   if (mEventTarget) {
1606     nsIDOMContextMenuListener *pListener = static_cast<nsIDOMContextMenuListener *>(this);
1607     nsresult rv = mEventTarget->RemoveEventListenerByIID(pListener, NS_GET_IID(nsIDOMContextMenuListener));
1608     if (NS_SUCCEEDED(rv))
1609       mContextMenuListenerInstalled = PR_FALSE;
1610   }
1611
1612   return NS_OK;
1613 }
1614
1615
1616 //
1617 // AddChromeListeners
1618 //
1619 // Hook up things to the chrome like context menus and tooltips, if the chrome
1620 // has implemented the right interfaces.
1621 //
1622 NS_IMETHODIMP
1623 ChromeContextMenuListener::AddChromeListeners()
1624 {
1625   if (!mEventTarget)
1626     GetPIDOMEventTarget(mWebBrowser, getter_AddRefs(mEventTarget));
1627
1628   // Register the appropriate events for context menus, but only if
1629   // the embedding chrome cares.
1630   nsresult rv = NS_OK;
1631
1632   nsCOMPtr<nsIContextMenuListener2> contextListener2 ( do_QueryInterface(mWebBrowserChrome) );
1633   nsCOMPtr<nsIContextMenuListener> contextListener ( do_QueryInterface(mWebBrowserChrome) );
1634   if ( (contextListener || contextListener2) && !mContextMenuListenerInstalled )
1635     rv = AddContextMenuListener();
1636
1637   return rv;
1638
1639 } // AddChromeListeners
1640
1641
1642 //
1643 // RemoveChromeListeners
1644 //
1645 // Unsubscribe from the various things we've hooked up to the window root.
1646 //
1647 NS_IMETHODIMP
1648 ChromeContextMenuListener::RemoveChromeListeners()
1649 {
1650   if ( mContextMenuListenerInstalled )
1651     RemoveContextMenuListener();
1652
1653   mEventTarget = nsnull;
1654
1655   // it really doesn't matter if these fail...
1656   return NS_OK;
1657
1658 } // RemoveChromeTooltipListeners
1659
1660
1661
1662 //
1663 // ContextMenu
1664 //
1665 // We're on call to show the context menu. Dig around in the DOM to
1666 // find the type of object we're dealing with and notify the front
1667 // end chrome.
1668 //
1669 NS_IMETHODIMP
1670 ChromeContextMenuListener::ContextMenu(nsIDOMEvent* aMouseEvent)
1671 {
1672   nsCOMPtr<nsIDOMNSUIEvent> uievent(do_QueryInterface(aMouseEvent));
1673
1674   if (uievent) {
1675     PRBool isDefaultPrevented = PR_FALSE;
1676     uievent->GetPreventDefault(&isDefaultPrevented);
1677
1678     if (isDefaultPrevented) {
1679       return NS_OK;
1680     }
1681   }
1682
1683   nsCOMPtr<nsIDOMEventTarget> targetNode;
1684   nsresult res = aMouseEvent->GetTarget(getter_AddRefs(targetNode));
1685   if (NS_FAILED(res))
1686     return res;
1687   if (!targetNode)
1688     return NS_ERROR_NULL_POINTER;
1689
1690   nsCOMPtr<nsIDOMNode> targetDOMnode;
1691   nsCOMPtr<nsIDOMNode> node = do_QueryInterface(targetNode);
1692   if (!node)
1693     return NS_OK;
1694
1695   // Stop the context menu event going to other windows (bug 78396)
1696   aMouseEvent->PreventDefault();
1697
1698   // If the listener is a nsIContextMenuListener2, create the info object
1699   nsCOMPtr<nsIContextMenuListener2> menuListener2(do_QueryInterface(mWebBrowserChrome));
1700   nsContextMenuInfo *menuInfoImpl = nsnull;
1701   nsCOMPtr<nsIContextMenuInfo> menuInfo;
1702   if (menuListener2) {
1703     menuInfoImpl = new nsContextMenuInfo;
1704     if (!menuInfoImpl)
1705       return NS_ERROR_OUT_OF_MEMORY;
1706     menuInfo = menuInfoImpl;
1707   }
1708
1709   PRUint32 flags = nsIContextMenuListener::CONTEXT_NONE;
1710   PRUint32 flags2 = nsIContextMenuListener2::CONTEXT_NONE;
1711
1712   // XXX test for selected text
1713
1714   PRUint16 nodeType;
1715   res = node->GetNodeType(&nodeType);
1716   NS_ENSURE_SUCCESS(res, res);
1717
1718   // First, checks for nodes that never have children.
1719   if (nodeType == nsIDOMNode::ELEMENT_NODE) {
1720     nsCOMPtr<nsIImageLoadingContent> content(do_QueryInterface(node));
1721     if (content) {
1722       nsCOMPtr<nsIURI> imgUri;
1723       content->GetCurrentURI(getter_AddRefs(imgUri));
1724       if (imgUri) {
1725         flags |= nsIContextMenuListener::CONTEXT_IMAGE;
1726         flags2 |= nsIContextMenuListener2::CONTEXT_IMAGE;
1727         targetDOMnode = node;
1728       }
1729     }
1730
1731     nsCOMPtr<nsIDOMHTMLInputElement> inputElement(do_QueryInterface(node));
1732     if (inputElement) {
1733       flags |= nsIContextMenuListener::CONTEXT_INPUT;
1734       flags2 |= nsIContextMenuListener2::CONTEXT_INPUT;
1735
1736       if (menuListener2) {
1737         nsAutoString inputElemType;
1738         inputElement->GetType(inputElemType);
1739         if (inputElemType.LowerCaseEqualsLiteral("text") ||
1740             inputElemType.LowerCaseEqualsLiteral("password"))
1741           flags2 |= nsIContextMenuListener2::CONTEXT_TEXT;
1742       }
1743
1744       targetDOMnode = node;
1745     }
1746
1747     nsCOMPtr<nsIDOMHTMLTextAreaElement> textElement(do_QueryInterface(node));
1748     if (textElement) {
1749       flags |= nsIContextMenuListener::CONTEXT_TEXT;
1750       flags2 |= nsIContextMenuListener2::CONTEXT_TEXT;
1751       targetDOMnode = node;
1752     }
1753
1754     // always consume events for plugins and Java who may throw their
1755     // own context menus but not for image objects.  Document objects
1756     // will never be targets or ancestors of targets, so that's OK.
1757     nsCOMPtr<nsIDOMHTMLObjectElement> objectElement;
1758     if (!(flags & nsIContextMenuListener::CONTEXT_IMAGE))
1759       objectElement = do_QueryInterface(node);
1760     nsCOMPtr<nsIDOMHTMLEmbedElement> embedElement(do_QueryInterface(node));
1761     nsCOMPtr<nsIDOMHTMLAppletElement> appletElement(do_QueryInterface(node));
1762
1763     if (objectElement || embedElement || appletElement)
1764       return NS_OK;
1765   }
1766
1767   // Bubble out, looking for items of interest
1768   do {
1769     PRUint16 nodeType;
1770     res = node->GetNodeType(&nodeType);
1771     NS_ENSURE_SUCCESS(res, res);
1772
1773     if (nodeType == nsIDOMNode::ELEMENT_NODE) {
1774
1775       // Test if the element has an associated link
1776       nsCOMPtr<nsIDOMElement> element(do_QueryInterface(node));
1777
1778       PRBool hasAttr = PR_FALSE;
1779       res = element->HasAttribute(NS_LITERAL_STRING("href"), &hasAttr);
1780
1781       if (NS_SUCCEEDED(res) && hasAttr)
1782       {
1783         flags |= nsIContextMenuListener::CONTEXT_LINK;
1784         flags2 |= nsIContextMenuListener2::CONTEXT_LINK;
1785         if (!targetDOMnode)
1786           targetDOMnode = node;
1787         if (menuInfoImpl)
1788           menuInfoImpl->SetAssociatedLink(node);
1789         break; // exit do-while
1790       }
1791     }
1792
1793     // walk-up-the-tree
1794     nsCOMPtr<nsIDOMNode> parentNode;
1795     node->GetParentNode(getter_AddRefs(parentNode));
1796     node = parentNode;
1797   } while (node);
1798
1799   if (!flags && !flags2) {
1800     // We found nothing of interest so far, check if we
1801     // have at least an html document.
1802     nsCOMPtr<nsIDOMDocument> document;
1803     node = do_QueryInterface(targetNode);
1804     node->GetOwnerDocument(getter_AddRefs(document));
1805     nsCOMPtr<nsIDOMHTMLDocument> htmlDocument(do_QueryInterface(document));
1806     if (htmlDocument) {
1807       flags |= nsIContextMenuListener::CONTEXT_DOCUMENT;
1808       flags2 |= nsIContextMenuListener2::CONTEXT_DOCUMENT;
1809       targetDOMnode = node;
1810       if (!(flags & nsIContextMenuListener::CONTEXT_IMAGE)) {
1811         // check if this is a background image that the user was trying to click on
1812         // and if the listener is ready for that (only nsIContextMenuListener2 and up)
1813         if (menuInfoImpl && menuInfoImpl->HasBackgroundImage(targetDOMnode)) {
1814           flags2 |= nsIContextMenuListener2::CONTEXT_BACKGROUND_IMAGE;
1815           // For the embedder to get the correct background image
1816           // targetDOMnode must point to the original node.
1817           targetDOMnode = do_QueryInterface(targetNode);
1818         }
1819       }
1820     }
1821   }
1822
1823   // we need to cache the event target into the focus controller's popupNode
1824   // so we can get at it later from command code, etc.:
1825
1826   // get the dom window
1827   nsCOMPtr<nsIDOMWindow> win;
1828   res = mWebBrowser->GetContentDOMWindow(getter_AddRefs(win));
1829   NS_ENSURE_SUCCESS(res, res);
1830   NS_ENSURE_TRUE(win, NS_ERROR_FAILURE);
1831   // get the private dom window
1832   nsCOMPtr<nsPIDOMWindow> privateWin(do_QueryInterface(win, &res));
1833   NS_ENSURE_SUCCESS(res, res);
1834   NS_ENSURE_TRUE(privateWin, NS_ERROR_FAILURE);
1835   // get the focus controller
1836   nsIFocusController *focusController = privateWin->GetRootFocusController();
1837   NS_ENSURE_TRUE(focusController, NS_ERROR_FAILURE);
1838   // set the focus controller's popup node to the event target
1839   res = focusController->SetPopupNode(targetDOMnode);
1840   NS_ENSURE_SUCCESS(res, res);
1841
1842   // Tell the listener all about the event
1843   if ( menuListener2 ) {
1844     menuInfoImpl->SetMouseEvent(aMouseEvent);
1845     menuInfoImpl->SetDOMNode(targetDOMnode);
1846     menuListener2->OnShowContextMenu(flags2, menuInfo);
1847   }
1848   else {
1849     nsCOMPtr<nsIContextMenuListener> menuListener(do_QueryInterface(mWebBrowserChrome));
1850     if ( menuListener )
1851       menuListener->OnShowContextMenu(flags, aMouseEvent, targetDOMnode);
1852   }
1853
1854   return NS_OK;
1855
1856 } // MouseDown