widget/src/xpwidgets/nsBaseWidget.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Dean Tessman <dean_tessman@hotmail.com>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either the GNU General Public License Version 2 or later (the "GPL"), or
  27  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 #include "nsBaseWidget.h"
  40 #include "nsIDeviceContext.h"
  41 #include "nsCOMPtr.h"
  42 #include "nsGfxCIID.h"
  43 #include "nsWidgetsCID.h"
  44 #include "nsServiceManagerUtils.h"
  45 #include "nsIScreenManager.h"
  46 #include "nsAppDirectoryServiceDefs.h"
  47 #include "nsISimpleEnumerator.h"
  48 #include "nsIContent.h"
  49 #include "nsIServiceManager.h"
  50 #include "nsIPrefService.h"
  51 #include "nsIPrefBranch2.h"
  52 #include "BasicLayers.h"
  53 #include "LayerManagerOGL.h"
  54 #include "nsIXULRuntime.h"
  55 #include "nsIGfxInfo.h"
  56 #include "npapi.h"
  57
  58 #ifdef DEBUG
  59 #include "nsIObserver.h"
  60
  61 static void debug_RegisterPrefCallbacks();
  62
  63 static PRBool debug_InSecureKeyboardInputMode = PR_FALSE;
  64 #endif
  65
  66 #ifdef NOISY_WIDGET_LEAKS
  67 static PRInt32 gNumWidgets;
  68 #endif
  69
  70 using namespace mozilla::layers;
  71
  72 nsIContent* nsBaseWidget::mLastRollup = nsnull;
  73
  74 // nsBaseWidget
  75 NS_IMPL_ISUPPORTS1(nsBaseWidget, nsIWidget)
  76
  77
  78 nsAutoRollup::nsAutoRollup()
  79 {
  80   // remember if mLastRollup was null, and only clear it upon destruction
  81   // if so. This prevents recursive usage of nsAutoRollup from clearing
  82   // mLastRollup when it shouldn't.
  83   wasClear = !nsBaseWidget::mLastRollup;
  84 }
  85
  86 nsAutoRollup::~nsAutoRollup()
  87 {
  88   if (nsBaseWidget::mLastRollup && wasClear) {
  89     NS_RELEASE(nsBaseWidget::mLastRollup);
  90   }
  91 }
  92
  93 //-------------------------------------------------------------------------
  94 //
  95 // nsBaseWidget constructor
  96 //
  97 //-------------------------------------------------------------------------
  98
  99 nsBaseWidget::nsBaseWidget()
 100 : mClientData(nsnull)
 101 , mViewWrapperPtr(nsnull)
 102 , mEventCallback(nsnull)
 103 , mViewCallback(nsnull)
 104 , mContext(nsnull)
 105 , mToolkit(nsnull)
 106 , mCursor(eCursor_standard)
 107 , mWindowType(eWindowType_child)
 108 , mBorderStyle(eBorderStyle_none)
 109 , mOnDestroyCalled(PR_FALSE)
 110 , mUseAcceleratedRendering(PR_FALSE)
 111 , mTemporarilyUseBasicLayerManager(PR_FALSE)
 112 , mBounds(0,0,0,0)
 113 , mOriginalBounds(nsnull)
 114 , mClipRectCount(0)
 115 , mZIndex(0)
 116 , mSizeMode(nsSizeMode_Normal)
 117 , mPopupLevel(ePopupLevelTop)
 118 {
 119 #ifdef NOISY_WIDGET_LEAKS
 120   gNumWidgets++;
 121   printf("WIDGETS+ = %d\n", gNumWidgets);
 122 #endif
 123
 124 #ifdef DEBUG
 125     debug_RegisterPrefCallbacks();
 126 #endif
 127 }
 128
 129
 130 //-------------------------------------------------------------------------
 131 //
 132 // nsBaseWidget destructor
 133 //
 134 //-------------------------------------------------------------------------
 135 nsBaseWidget::~nsBaseWidget()
 136 {
 137   if (mLayerManager &&
 138       mLayerManager->GetBackendType() == LayerManager::LAYERS_BASIC) {
 139     static_cast<BasicLayerManager*>(mLayerManager.get())->ClearRetainerWidget();
 140   }
 141
 142   if (mLayerManager) {
 143     mLayerManager->Destroy();
 144   }
 145
 146 #ifdef NOISY_WIDGET_LEAKS
 147   gNumWidgets--;
 148   printf("WIDGETS- = %d\n", gNumWidgets);
 149 #endif
 150
 151   NS_IF_RELEASE(mToolkit);
 152   NS_IF_RELEASE(mContext);
 153   if (mOriginalBounds)
 154     delete mOriginalBounds;
 155 }
 156
 157
 158 //-------------------------------------------------------------------------
 159 //
 160 // Basic create.
 161 //
 162 //-------------------------------------------------------------------------
 163 void nsBaseWidget::BaseCreate(nsIWidget *aParent,
 164                               const nsIntRect &aRect,
 165                               EVENT_CALLBACK aHandleEventFunction,
 166                               nsIDeviceContext *aContext,
 167                               nsIAppShell *aAppShell,
 168                               nsIToolkit *aToolkit,
 169                               nsWidgetInitData *aInitData)
 170 {
 171   if (nsnull == mToolkit) {
 172     if (nsnull != aToolkit) {
 173       mToolkit = (nsIToolkit*)aToolkit;
 174       NS_ADDREF(mToolkit);
 175     }
 176     else {
 177       if (nsnull != aParent) {
 178         mToolkit = aParent->GetToolkit();
 179         NS_IF_ADDREF(mToolkit);
 180       }
 181       // it's some top level window with no toolkit passed in.
 182       // Create a default toolkit with the current thread
 183 #if !defined(USE_TLS_FOR_TOOLKIT)
 184       else {
 185         static NS_DEFINE_CID(kToolkitCID, NS_TOOLKIT_CID);
 186
 187         nsresult res;
 188         res = CallCreateInstance(kToolkitCID, &mToolkit);
 189         NS_ASSERTION(NS_SUCCEEDED(res), "Can not create a toolkit in nsBaseWidget::Create");
 190         if (mToolkit)
 191           mToolkit->Init(PR_GetCurrentThread());
 192       }
 193 #else /* USE_TLS_FOR_TOOLKIT */
 194       else {
 195         nsresult rv;
 196
 197         rv = NS_GetCurrentToolkit(&mToolkit);
 198       }
 199 #endif /* USE_TLS_FOR_TOOLKIT */
 200     }
 201
 202   }
 203
 204   // save the event callback function
 205   mEventCallback = aHandleEventFunction;
 206
 207   // keep a reference to the device context
 208   if (aContext) {
 209     mContext = aContext;
 210     NS_ADDREF(mContext);
 211   }
 212   else {
 213     nsresult  res;
 214
 215     static NS_DEFINE_CID(kDeviceContextCID, NS_DEVICE_CONTEXT_CID);
 216
 217     res = CallCreateInstance(kDeviceContextCID, &mContext);
 218
 219     if (NS_SUCCEEDED(res))
 220       mContext->Init(nsnull);
 221   }
 222
 223   if (nsnull != aInitData) {
 224     mWindowType = aInitData->mWindowType;
 225     mBorderStyle = aInitData->mBorderStyle;
 226     mPopupLevel = aInitData->mPopupLevel;
 227   }
 228
 229   if (aParent) {
 230     aParent->AddChild(this);
 231   }
 232 }
 233
 234 NS_IMETHODIMP nsBaseWidget::CaptureMouse(PRBool aCapture)
 235 {
 236   return NS_OK;
 237 }
 238
 239 //-------------------------------------------------------------------------
 240 //
 241 // Accessor functions to get/set the client data
 242 //
 243 //-------------------------------------------------------------------------
 244
 245 NS_IMETHODIMP nsBaseWidget::GetClientData(void*& aClientData)
 246 {
 247   aClientData = mClientData;
 248   return NS_OK;
 249 }
 250
 251 NS_IMETHODIMP nsBaseWidget::SetClientData(void* aClientData)
 252 {
 253   mClientData = aClientData;
 254   return NS_OK;
 255 }
 256
 257 already_AddRefed<nsIWidget>
 258 nsBaseWidget::CreateChild(const nsIntRect  &aRect,
 259                           EVENT_CALLBACK   aHandleEventFunction,
 260                           nsIDeviceContext *aContext,
 261                           nsIAppShell      *aAppShell,
 262                           nsIToolkit       *aToolkit,
 263                           nsWidgetInitData *aInitData,
 264                           PRBool           aForceUseIWidgetParent)
 265 {
 266   nsIWidget* parent = this;
 267   nsNativeWidget nativeParent = nsnull;
 268
 269   if (!aForceUseIWidgetParent) {
 270     // Use only either parent or nativeParent, not both, to match
 271     // existing code.  Eventually Create() should be divested of its
 272     // nativeWidget parameter.
 273     nativeParent = parent ? parent->GetNativeData(NS_NATIVE_WIDGET) : nsnull;
 274     parent = nativeParent ? nsnull : parent;
 275     NS_ABORT_IF_FALSE(!parent || !nativeParent, "messed up logic");
 276   }
 277
 278   nsCOMPtr<nsIWidget> widget;
 279   if (aInitData && aInitData->mWindowType == eWindowType_popup) {
 280     widget = AllocateChildPopupWidget();
 281   } else {
 282     static NS_DEFINE_IID(kCChildCID, NS_CHILD_CID);
 283     widget = do_CreateInstance(kCChildCID);
 284   }
 285
 286   if (widget &&
 287       NS_SUCCEEDED(widget->Create(parent, nativeParent, aRect,
 288                                   aHandleEventFunction,
 289                                   aContext, aAppShell, aToolkit,
 290                                   aInitData))) {
 291     return widget.forget();
 292   }
 293
 294   return nsnull;
 295 }
 296
 297 // Attach a view to our widget which we'll send events to.
 298 NS_IMETHODIMP
 299 nsBaseWidget::AttachViewToTopLevel(EVENT_CALLBACK aViewEventFunction,
 300                                    nsIDeviceContext *aContext)
 301 {
 302   NS_ASSERTION((mWindowType == eWindowType_toplevel ||
 303                 mWindowType == eWindowType_dialog ||
 304                 mWindowType == eWindowType_invisible ||
 305                 mWindowType == eWindowType_child),
 306                "Can't attach to window of that type");
 307
 308   mViewCallback = aViewEventFunction;
 309
 310   if (aContext) {
 311     if (mContext) {
 312       NS_IF_RELEASE(mContext);
 313     }
 314     mContext = aContext;
 315     NS_ADDREF(mContext);
 316   }
 317
 318   return NS_OK;
 319 }
 320
 321 ViewWrapper* nsBaseWidget::GetAttachedViewPtr()
 322  {
 323    return mViewWrapperPtr;
 324  }
 325
 326 NS_IMETHODIMP nsBaseWidget::SetAttachedViewPtr(ViewWrapper* aViewWrapper)
 327  {
 328    mViewWrapperPtr = aViewWrapper;
 329    return NS_OK;
 330  }
 331
 332 NS_METHOD nsBaseWidget::ResizeClient(PRInt32 aX,
 333                                      PRInt32 aY,
 334                                      PRInt32 aWidth,
 335                                      PRInt32 aHeight,
 336                                      PRBool aRepaint)
 337 {
 338   return Resize(aX, aY, aWidth, aHeight, aRepaint);
 339 }
 340
 341 //-------------------------------------------------------------------------
 342 //
 343 // Close this nsBaseWidget
 344 //
 345 //-------------------------------------------------------------------------
 346 NS_METHOD nsBaseWidget::Destroy()
 347 {
 348   // Just in case our parent is the only ref to us
 349   nsCOMPtr<nsIWidget> kungFuDeathGrip(this);
 350   // disconnect from the parent
 351   nsIWidget *parent = GetParent();
 352   if (parent) {
 353     parent->RemoveChild(this);
 354   }
 355
 356   return NS_OK;
 357 }
 358
 359
 360 //-------------------------------------------------------------------------
 361 //
 362 // Set this nsBaseWidget's parent
 363 //
 364 //-------------------------------------------------------------------------
 365 NS_IMETHODIMP nsBaseWidget::SetParent(nsIWidget* aNewParent)
 366 {
 367   return NS_ERROR_NOT_IMPLEMENTED;
 368 }
 369
 370
 371 //-------------------------------------------------------------------------
 372 //
 373 // Get this nsBaseWidget parent
 374 //
 375 //-------------------------------------------------------------------------
 376 nsIWidget* nsBaseWidget::GetParent(void)
 377 {
 378   return nsnull;
 379 }
 380
 381 //-------------------------------------------------------------------------
 382 //
 383 // Get this nsBaseWidget top level widget
 384 //
 385 //-------------------------------------------------------------------------
 386 nsIWidget* nsBaseWidget::GetTopLevelWidget()
 387 {
 388   nsIWidget *topLevelWidget = nsnull, *widget = this;
 389   while (widget) {
 390     topLevelWidget = widget;
 391     widget = widget->GetParent();
 392   }
 393   return topLevelWidget;
 394 }
 395
 396 //-------------------------------------------------------------------------
 397 //
 398 // Get this nsBaseWidget's top (non-sheet) parent (if it's a sheet)
 399 //
 400 //-------------------------------------------------------------------------
 401 nsIWidget* nsBaseWidget::GetSheetWindowParent(void)
 402 {
 403   return nsnull;
 404 }
 405
 406 float nsBaseWidget::GetDPI()
 407 {
 408   return 96.0f;
 409 }
 410
 411 double nsBaseWidget::GetDefaultScale()
 412 {
 413   return 1.0;
 414 }
 415
 416 //-------------------------------------------------------------------------
 417 //
 418 // Add a child to the list of children
 419 //
 420 //-------------------------------------------------------------------------
 421 void nsBaseWidget::AddChild(nsIWidget* aChild)
 422 {
 423   NS_PRECONDITION(!aChild->GetNextSibling() && !aChild->GetPrevSibling(),
 424                   "aChild not properly removed from its old child list");
 425
 426   if (!mFirstChild) {
 427     mFirstChild = mLastChild = aChild;
 428   } else {
 429     // append to the list
 430     NS_ASSERTION(mLastChild, "Bogus state");
 431     NS_ASSERTION(!mLastChild->GetNextSibling(), "Bogus state");
 432     mLastChild->SetNextSibling(aChild);
 433     aChild->SetPrevSibling(mLastChild);
 434     mLastChild = aChild;
 435   }
 436 }
 437
 438
 439 //-------------------------------------------------------------------------
 440 //
 441 // Remove a child from the list of children
 442 //
 443 //-------------------------------------------------------------------------
 444 void nsBaseWidget::RemoveChild(nsIWidget* aChild)
 445 {
 446   NS_ASSERTION(aChild->GetParent() == this, "Not one of our kids!");
 447
 448   if (mLastChild == aChild) {
 449     mLastChild = mLastChild->GetPrevSibling();
 450   }
 451   if (mFirstChild == aChild) {
 452     mFirstChild = mFirstChild->GetNextSibling();
 453   }
 454
 455   // Now remove from the list.  Make sure that we pass ownership of the tail
 456   // of the list correctly before we have aChild let go of it.
 457   nsIWidget* prev = aChild->GetPrevSibling();
 458   nsIWidget* next = aChild->GetNextSibling();
 459   if (prev) {
 460     prev->SetNextSibling(next);
 461   }
 462   if (next) {
 463     next->SetPrevSibling(prev);
 464   }
 465
 466   aChild->SetNextSibling(nsnull);
 467   aChild->SetPrevSibling(nsnull);
 468 }
 469
 470
 471 //-------------------------------------------------------------------------
 472 //
 473 // Sets widget's position within its parent's child list.
 474 //
 475 //-------------------------------------------------------------------------
 476 NS_IMETHODIMP nsBaseWidget::SetZIndex(PRInt32 aZIndex)
 477 {
 478   // Hold a ref to ourselves just in case, since we're going to remove
 479   // from our parent.
 480   nsCOMPtr<nsIWidget> kungFuDeathGrip(this);
 481
 482   mZIndex = aZIndex;
 483
 484   // reorder this child in its parent's list.
 485   nsBaseWidget* parent = static_cast<nsBaseWidget*>(GetParent());
 486   if (parent) {
 487     parent->RemoveChild(this);
 488     // Scope sib outside the for loop so we can check it afterward
 489     nsIWidget* sib = parent->GetFirstChild();
 490     for ( ; sib; sib = sib->GetNextSibling()) {
 491       PRInt32 childZIndex;
 492       if (NS_SUCCEEDED(sib->GetZIndex(&childZIndex))) {
 493         if (aZIndex < childZIndex) {
 494           // Insert ourselves before sib
 495           nsIWidget* prev = sib->GetPrevSibling();
 496           mNextSibling = sib;
 497           mPrevSibling = prev;
 498           sib->SetPrevSibling(this);
 499           if (prev) {
 500             prev->SetNextSibling(this);
 501           } else {
 502             NS_ASSERTION(sib == parent->mFirstChild, "Broken child list");
 503             // We've taken ownership of sib, so it's safe to have parent let
 504             // go of it
 505             parent->mFirstChild = this;
 506           }
 507           PlaceBehind(eZPlacementBelow, sib, PR_FALSE);
 508           break;
 509         }
 510       }
 511     }
 512     // were we added to the list?
 513     if (!sib) {
 514       parent->AddChild(this);
 515     }
 516   }
 517   return NS_OK;
 518 }
 519
 520 //-------------------------------------------------------------------------
 521 //
 522 // Gets widget's position within its parent's child list.
 523 //
 524 //-------------------------------------------------------------------------
 525 NS_IMETHODIMP nsBaseWidget::GetZIndex(PRInt32* aZIndex)
 526 {
 527   *aZIndex = mZIndex;
 528   return NS_OK;
 529 }
 530
 531 //-------------------------------------------------------------------------
 532 //
 533 // Places widget behind the given widget (platforms must override)
 534 //
 535 //-------------------------------------------------------------------------
 536 NS_IMETHODIMP nsBaseWidget::PlaceBehind(nsTopLevelWidgetZPlacement aPlacement,
 537                                         nsIWidget *aWidget, PRBool aActivate)
 538 {
 539   return NS_OK;
 540 }
 541
 542 //-------------------------------------------------------------------------
 543 //
 544 // Maximize, minimize or restore the window. The BaseWidget implementation
 545 // merely stores the state.
 546 //
 547 //-------------------------------------------------------------------------
 548 NS_IMETHODIMP nsBaseWidget::SetSizeMode(PRInt32 aMode)
 549 {
 550   if (aMode == nsSizeMode_Normal ||
 551       aMode == nsSizeMode_Minimized ||
 552       aMode == nsSizeMode_Maximized ||
 553       aMode == nsSizeMode_Fullscreen) {
 554
 555     mSizeMode = (nsSizeMode) aMode;
 556     return NS_OK;
 557   }
 558   return NS_ERROR_ILLEGAL_VALUE;
 559 }
 560
 561 //-------------------------------------------------------------------------
 562 //
 563 // Get the size mode (minimized, maximized, that sort of thing...)
 564 //
 565 //-------------------------------------------------------------------------
 566 NS_IMETHODIMP nsBaseWidget::GetSizeMode(PRInt32* aMode)
 567 {
 568   *aMode = mSizeMode;
 569   return NS_OK;
 570 }
 571
 572 //-------------------------------------------------------------------------
 573 //
 574 // Get the foreground color
 575 //
 576 //-------------------------------------------------------------------------
 577 nscolor nsBaseWidget::GetForegroundColor(void)
 578 {
 579   return mForeground;
 580 }
 581
 582
 583 //-------------------------------------------------------------------------
 584 //
 585 // Set the foreground color
 586 //
 587 //-------------------------------------------------------------------------
 588 NS_METHOD nsBaseWidget::SetForegroundColor(const nscolor &aColor)
 589 {
 590   mForeground = aColor;
 591   return NS_OK;
 592 }
 593
 594
 595 //-------------------------------------------------------------------------
 596 //
 597 // Get the background color
 598 //
 599 //-------------------------------------------------------------------------
 600 nscolor nsBaseWidget::GetBackgroundColor(void)
 601 {
 602   return mBackground;
 603 }
 604
 605 //-------------------------------------------------------------------------
 606 //
 607 // Set the background color
 608 //
 609 //-------------------------------------------------------------------------
 610 NS_METHOD nsBaseWidget::SetBackgroundColor(const nscolor &aColor)
 611 {
 612   mBackground = aColor;
 613   return NS_OK;
 614 }
 615
 616 //-------------------------------------------------------------------------
 617 //
 618 // Get this component cursor
 619 //
 620 //-------------------------------------------------------------------------
 621 nsCursor nsBaseWidget::GetCursor()
 622 {
 623   return mCursor;
 624 }
 625
 626 NS_METHOD nsBaseWidget::SetCursor(nsCursor aCursor)
 627 {
 628   mCursor = aCursor;
 629   return NS_OK;
 630 }
 631
 632 NS_IMETHODIMP nsBaseWidget::SetCursor(imgIContainer* aCursor,
 633                                       PRUint32 aHotspotX, PRUint32 aHotspotY)
 634 {
 635   return NS_ERROR_NOT_IMPLEMENTED;
 636 }
 637
 638 //-------------------------------------------------------------------------
 639 //
 640 // Get the window type for this widget
 641 //
 642 //-------------------------------------------------------------------------
 643 NS_IMETHODIMP nsBaseWidget::GetWindowType(nsWindowType& aWindowType)
 644 {
 645   aWindowType = mWindowType;
 646   return NS_OK;
 647 }
 648
 649 //-------------------------------------------------------------------------
 650 //
 651 // Window transparency methods
 652 //
 653 //-------------------------------------------------------------------------
 654
 655 void nsBaseWidget::SetTransparencyMode(nsTransparencyMode aMode) {
 656 }
 657
 658 nsTransparencyMode nsBaseWidget::GetTransparencyMode() {
 659   return eTransparencyOpaque;
 660 }
 661
 662 PRBool
 663 nsBaseWidget::StoreWindowClipRegion(const nsTArray<nsIntRect>& aRects)
 664 {
 665   if (mClipRects && mClipRectCount == aRects.Length() &&
 666       memcmp(mClipRects, aRects.Elements(), sizeof(nsIntRect)*mClipRectCount) == 0)
 667     return PR_FALSE;
 668
 669   mClipRectCount = aRects.Length();
 670   mClipRects = new nsIntRect[mClipRectCount];
 671   if (mClipRects) {
 672     memcpy(mClipRects, aRects.Elements(), sizeof(nsIntRect)*mClipRectCount);
 673   }
 674   return PR_TRUE;
 675 }
 676
 677 void
 678 nsBaseWidget::GetWindowClipRegion(nsTArray<nsIntRect>* aRects)
 679 {
 680   if (mClipRects) {
 681     aRects->AppendElements(mClipRects.get(), mClipRectCount);
 682   } else {
 683     aRects->AppendElement(nsIntRect(0, 0, mBounds.width, mBounds.height));
 684   }
 685 }
 686
 687 //-------------------------------------------------------------------------
 688 //
 689 // Set window shadow style
 690 //
 691 //-------------------------------------------------------------------------
 692
 693 NS_IMETHODIMP nsBaseWidget::SetWindowShadowStyle(PRInt32 aMode)
 694 {
 695   return NS_ERROR_NOT_IMPLEMENTED;
 696 }
 697
 698 //-------------------------------------------------------------------------
 699 //
 700 // Hide window borders/decorations for this widget
 701 //
 702 //-------------------------------------------------------------------------
 703 NS_IMETHODIMP nsBaseWidget::HideWindowChrome(PRBool aShouldHide)
 704 {
 705   return NS_ERROR_NOT_IMPLEMENTED;
 706 }
 707
 708 //-------------------------------------------------------------------------
 709 //
 710 // Put the window into full-screen mode
 711 //
 712 //-------------------------------------------------------------------------
 713 NS_IMETHODIMP nsBaseWidget::MakeFullScreen(PRBool aFullScreen)
 714 {
 715   HideWindowChrome(aFullScreen);
 716
 717   if (aFullScreen) {
 718     if (!mOriginalBounds)
 719       mOriginalBounds = new nsIntRect();
 720     GetScreenBounds(*mOriginalBounds);
 721
 722     // Move to top-left corner of screen and size to the screen dimensions
 723     nsCOMPtr<nsIScreenManager> screenManager;
 724     screenManager = do_GetService("@mozilla.org/gfx/screenmanager;1");
 725     NS_ASSERTION(screenManager, "Unable to grab screenManager.");
 726     if (screenManager) {
 727       nsCOMPtr<nsIScreen> screen;
 728       screenManager->ScreenForRect(mOriginalBounds->x, mOriginalBounds->y,
 729                                    mOriginalBounds->width, mOriginalBounds->height,
 730                                    getter_AddRefs(screen));
 731       if (screen) {
 732         PRInt32 left, top, width, height;
 733         if (NS_SUCCEEDED(screen->GetRect(&left, &top, &width, &height))) {
 734           Resize(left, top, width, height, PR_TRUE);
 735         }
 736       }
 737     }
 738
 739   } else if (mOriginalBounds) {
 740     Resize(mOriginalBounds->x, mOriginalBounds->y, mOriginalBounds->width,
 741            mOriginalBounds->height, PR_TRUE);
 742   }
 743
 744   return NS_OK;
 745 }
 746
 747 nsBaseWidget::AutoLayerManagerSetup::AutoLayerManagerSetup(
 748     nsBaseWidget* aWidget, gfxContext* aTarget,
 749     BasicLayerManager::BufferMode aDoubleBuffering)
 750   : mWidget(aWidget)
 751 {
 752   BasicLayerManager* manager =
 753     static_cast<BasicLayerManager*>(mWidget->GetLayerManager(nsnull));
 754   if (manager) {
 755     NS_ASSERTION(manager->GetBackendType() == LayerManager::LAYERS_BASIC,
 756       "AutoLayerManagerSetup instantiated for non-basic layer backend!");
 757     manager->SetDefaultTarget(aTarget, aDoubleBuffering);
 758   }
 759 }
 760
 761 nsBaseWidget::AutoLayerManagerSetup::~AutoLayerManagerSetup()
 762 {
 763   BasicLayerManager* manager =
 764     static_cast<BasicLayerManager*>(mWidget->GetLayerManager(nsnull));
 765   if (manager) {
 766     NS_ASSERTION(manager->GetBackendType() == LayerManager::LAYERS_BASIC,
 767       "AutoLayerManagerSetup instantiated for non-basic layer backend!");
 768     manager->SetDefaultTarget(nsnull, BasicLayerManager::BUFFER_NONE);
 769   }
 770 }
 771
 772 nsBaseWidget::AutoUseBasicLayerManager::AutoUseBasicLayerManager(nsBaseWidget* aWidget)
 773   : mWidget(aWidget)
 774 {
 775   mWidget->mTemporarilyUseBasicLayerManager = PR_TRUE;
 776 }
 777
 778 nsBaseWidget::AutoUseBasicLayerManager::~AutoUseBasicLayerManager()
 779 {
 780   mWidget->mTemporarilyUseBasicLayerManager = PR_FALSE;
 781 }
 782
 783 PRBool
 784 nsBaseWidget::GetShouldAccelerate()
 785 {
 786   nsCOMPtr<nsIPrefBranch2> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);
 787
 788   PRBool disableAcceleration = PR_FALSE;
 789   PRBool forceAcceleration = PR_FALSE;
 790 #if defined(XP_WIN) || defined(ANDROID) || (MOZ_PLATFORM_MAEMO > 5)
 791   PRBool accelerateByDefault = PR_TRUE;
 792 #elif defined(XP_MACOSX)
 793 /* quickdraw plugins don't work with OpenGL so we need to avoid OpenGL when we want to support
 794  * them. e.g. 10.5 */
 795 # if defined(NP_NO_QUICKDRAW)
 796   PRBool accelerateByDefault = PR_TRUE;
 797
 798   // 10.6.2 and lower have a bug involving textures and pixel buffer objects
 799   // that caused bug 629016, so we don't allow OpenGL-accelerated layers on
 800   // those versions of the OS.
 801   // This will still let full-screen video be accelerated on OpenGL, because
 802   // that XUL widget opts in to acceleration, but that's probably OK.
 803   SInt32 major, minor, bugfix;
 804   OSErr err1 = ::Gestalt(gestaltSystemVersionMajor, &major);
 805   OSErr err2 = ::Gestalt(gestaltSystemVersionMinor, &minor);
 806   OSErr err3 = ::Gestalt(gestaltSystemVersionBugFix, &bugfix);
 807   if (err1 == noErr && err2 == noErr && err3 == noErr) {
 808     if (major == 10 && minor == 6) {
 809       if (bugfix <= 2) {
 810         accelerateByDefault = PR_FALSE;
 811       }
 812     }
 813   }
 814
 815 # else
 816   PRBool accelerateByDefault = PR_FALSE;
 817 # endif
 818
 819 #else
 820   PRBool accelerateByDefault = PR_FALSE;
 821 #endif
 822
 823   if (prefs) {
 824     // we should use AddBoolPrefVarCache
 825     prefs->GetBoolPref("layers.acceleration.disabled",
 826                        &disableAcceleration);
 827
 828     prefs->GetBoolPref("layers.acceleration.force-enabled",
 829                        &forceAcceleration);
 830
 831   }
 832
 833   const char *acceleratedEnv = PR_GetEnv("MOZ_ACCELERATED");
 834   accelerateByDefault = accelerateByDefault ||
 835                         (acceleratedEnv && (*acceleratedEnv != '0'));
 836
 837   nsCOMPtr<nsIXULRuntime> xr = do_GetService("@mozilla.org/xre/runtime;1");
 838   PRBool safeMode = PR_FALSE;
 839   if (xr)
 840     xr->GetInSafeMode(&safeMode);
 841
 842   if (disableAcceleration || safeMode)
 843     return PR_FALSE;
 844
 845   if (forceAcceleration)
 846     return PR_TRUE;
 847
 848   nsCOMPtr<nsIGfxInfo> gfxInfo = do_GetService("@mozilla.org/gfx/info;1");
 849   if (gfxInfo) {
 850     PRInt32 status;
 851     if (NS_SUCCEEDED(gfxInfo->GetFeatureStatus(nsIGfxInfo::FEATURE_OPENGL_LAYERS, &status))) {
 852       if (status != nsIGfxInfo::FEATURE_NO_INFO) {
 853         NS_WARNING("OpenGL-accelerated layers are not supported on this system.");
 854         return PR_FALSE;
 855       }
 856     }
 857   }
 858
 859   if (accelerateByDefault)
 860     return PR_TRUE;
 861
 862   /* use the window acceleration flag */
 863   return mUseAcceleratedRendering;
 864 }
 865
 866 LayerManager* nsBaseWidget::GetLayerManager(bool* aAllowRetaining)
 867 {
 868   return GetLayerManager(LAYER_MANAGER_CURRENT, aAllowRetaining);
 869 }
 870
 871 LayerManager* nsBaseWidget::GetLayerManager(LayerManagerPersistence,
 872                                             bool* aAllowRetaining)
 873 {
 874   if (!mLayerManager) {
 875
 876     mUseAcceleratedRendering = GetShouldAccelerate();
 877
 878     if (mUseAcceleratedRendering) {
 879       nsRefPtr<LayerManagerOGL> layerManager =
 880         new mozilla::layers::LayerManagerOGL(this);
 881       /**
 882        * XXX - On several OSes initialization is expected to fail for now.
 883        * If we'd get a none-basic layer manager they'd crash. This is ok though
 884        * since on those platforms it will fail. Anyone implementing new
 885        * platforms on LayerManagerOGL should ensure their widget is able to
 886        * deal with it though!
 887        */
 888       if (layerManager->Initialize()) {
 889         mLayerManager = layerManager;
 890       }
 891     }
 892     if (!mLayerManager) {
 893       mBasicLayerManager = mLayerManager = CreateBasicLayerManager();
 894     }
 895   }
 896   if (mTemporarilyUseBasicLayerManager && !mBasicLayerManager) {
 897     mBasicLayerManager = CreateBasicLayerManager();
 898   }
 899   LayerManager* usedLayerManager = mTemporarilyUseBasicLayerManager ?
 900                                      mBasicLayerManager : mLayerManager;
 901   if (aAllowRetaining) {
 902     *aAllowRetaining = (usedLayerManager == mLayerManager);
 903   }
 904   return usedLayerManager;
 905 }
 906
 907 BasicLayerManager* nsBaseWidget::CreateBasicLayerManager()
 908 {
 909 #if !defined(MOZ_IPC)
 910       return new BasicLayerManager(this);
 911 #else
 912       return new BasicShadowLayerManager(this);
 913 #endif
 914 }
 915
 916 //-------------------------------------------------------------------------
 917 //
 918 // Return the toolkit this widget was created on
 919 //
 920 //-------------------------------------------------------------------------
 921 nsIToolkit* nsBaseWidget::GetToolkit()
 922 {
 923   return mToolkit;
 924 }
 925
 926
 927 //-------------------------------------------------------------------------
 928 //
 929 // Return the used device context
 930 //
 931 //-------------------------------------------------------------------------
 932 nsIDeviceContext* nsBaseWidget::GetDeviceContext()
 933 {
 934   return mContext;
 935 }
 936
 937 //-------------------------------------------------------------------------
 938 //
 939 // Get the thebes surface
 940 //
 941 //-------------------------------------------------------------------------
 942 gfxASurface *nsBaseWidget::GetThebesSurface()
 943 {
 944   // in theory we should get our parent's surface,
 945   // clone it, and set a device offset before returning
 946   return nsnull;
 947 }
 948
 949
 950 //-------------------------------------------------------------------------
 951 //
 952 // Destroy the window
 953 //
 954 //-------------------------------------------------------------------------
 955 void nsBaseWidget::OnDestroy()
 956 {
 957   // release references to device context, toolkit, and app shell
 958   NS_IF_RELEASE(mContext);
 959   NS_IF_RELEASE(mToolkit);
 960 }
 961
 962 NS_METHOD nsBaseWidget::SetWindowClass(const nsAString& xulWinType)
 963 {
 964   return NS_ERROR_NOT_IMPLEMENTED;
 965 }
 966
 967 //-------------------------------------------------------------------------
 968 //
 969 // Bounds
 970 //
 971 //-------------------------------------------------------------------------
 972
 973 /**
 974 * If the implementation of nsWindow supports borders this method MUST be overridden
 975 *
 976 **/
 977 NS_METHOD nsBaseWidget::GetClientBounds(nsIntRect &aRect)
 978 {
 979   return GetBounds(aRect);
 980 }
 981
 982 /**
 983 * If the implementation of nsWindow supports borders this method MUST be overridden
 984 *
 985 **/
 986 NS_METHOD nsBaseWidget::GetBounds(nsIntRect &aRect)
 987 {
 988   aRect = mBounds;
 989   return NS_OK;
 990 }
 991
 992 /**
 993 * If the implementation of nsWindow uses a local coordinate system within the window,
 994 * this method must be overridden
 995 *
 996 **/
 997 NS_METHOD nsBaseWidget::GetScreenBounds(nsIntRect &aRect)
 998 {
 999   return GetBounds(aRect);
1000 }
1001
1002 nsIntPoint nsBaseWidget::GetClientOffset()
1003 {
1004   return nsIntPoint(0, 0);
1005 }
1006
1007 NS_METHOD nsBaseWidget::SetBounds(const nsIntRect &aRect)
1008 {
1009   mBounds = aRect;
1010
1011   return NS_OK;
1012 }
1013
1014 NS_IMETHODIMP
1015 nsBaseWidget::GetNonClientMargins(nsIntMargin &margins)
1016 {
1017   return NS_ERROR_NOT_IMPLEMENTED;
1018 }
1019
1020 NS_IMETHODIMP
1021 nsBaseWidget::SetNonClientMargins(nsIntMargin &margins)
1022 {
1023   return NS_ERROR_NOT_IMPLEMENTED;
1024 }
1025
1026 NS_METHOD nsBaseWidget::EnableDragDrop(PRBool aEnable)
1027 {
1028   return NS_OK;
1029 }
1030
1031 NS_METHOD nsBaseWidget::SetModal(PRBool aModal)
1032 {
1033   return NS_ERROR_FAILURE;
1034 }
1035
1036 NS_IMETHODIMP
1037 nsBaseWidget::GetAttention(PRInt32 aCycleCount) {
1038     return NS_OK;
1039 }
1040
1041 PRBool
1042 nsBaseWidget::HasPendingInputEvent()
1043 {
1044   return PR_FALSE;
1045 }
1046
1047 NS_IMETHODIMP
1048 nsBaseWidget::SetIcon(const nsAString&)
1049 {
1050   return NS_OK;
1051 }
1052
1053 NS_IMETHODIMP
1054 nsBaseWidget::BeginSecureKeyboardInput()
1055 {
1056 #ifdef DEBUG
1057   NS_ASSERTION(!debug_InSecureKeyboardInputMode, "Attempting to nest call to BeginSecureKeyboardInput!");
1058   debug_InSecureKeyboardInputMode = PR_TRUE;
1059 #endif
1060   return NS_OK;
1061 }
1062
1063 NS_IMETHODIMP
1064 nsBaseWidget::EndSecureKeyboardInput()
1065 {
1066 #ifdef DEBUG
1067   NS_ASSERTION(debug_InSecureKeyboardInputMode, "Calling EndSecureKeyboardInput when it hasn't been enabled!");
1068   debug_InSecureKeyboardInputMode = PR_FALSE;
1069 #endif
1070   return NS_OK;
1071 }
1072
1073 NS_IMETHODIMP
1074 nsBaseWidget::SetWindowTitlebarColor(nscolor aColor, PRBool aActive)
1075 {
1076   return NS_ERROR_NOT_IMPLEMENTED;
1077 }
1078
1079 PRBool
1080 nsBaseWidget::ShowsResizeIndicator(nsIntRect* aResizerRect)
1081 {
1082   return PR_FALSE;
1083 }
1084
1085 NS_IMETHODIMP
1086 nsBaseWidget::SetAcceleratedRendering(PRBool aEnabled)
1087 {
1088   if (mUseAcceleratedRendering == aEnabled) {
1089     return NS_OK;
1090   }
1091   mUseAcceleratedRendering = aEnabled;
1092   if (mLayerManager) {
1093     mLayerManager->Destroy();
1094   }
1095   mLayerManager = NULL;
1096   return NS_OK;
1097 }
1098
1099 PRBool
1100 nsBaseWidget::GetAcceleratedRendering()
1101 {
1102   return mUseAcceleratedRendering;
1103 }
1104
1105 NS_METHOD nsBaseWidget::RegisterTouchWindow()
1106 {
1107   return NS_ERROR_NOT_IMPLEMENTED;
1108 }
1109
1110 NS_METHOD nsBaseWidget::UnregisterTouchWindow()
1111 {
1112   return NS_ERROR_NOT_IMPLEMENTED;
1113 }
1114
1115 NS_IMETHODIMP
1116 nsBaseWidget::OverrideSystemMouseScrollSpeed(PRInt32 aOriginalDelta,
1117                                              PRBool aIsHorizontal,
1118                                              PRInt32 &aOverriddenDelta)
1119 {
1120   aOverriddenDelta = aOriginalDelta;
1121
1122   nsCOMPtr<nsIPrefService> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);
1123   NS_ENSURE_TRUE(prefs, NS_ERROR_FAILURE);
1124   nsCOMPtr<nsIPrefBranch> prefBranch;
1125   nsresult rv = prefs->GetBranch(nsnull, getter_AddRefs(prefBranch));
1126   NS_ENSURE_SUCCESS(rv, rv);
1127   NS_ENSURE_TRUE(prefBranch, NS_ERROR_FAILURE);
1128
1129   PRBool isOverrideEnabled;
1130   const char* kPrefNameOverrideEnabled =
1131     "mousewheel.system_scroll_override_on_root_content.enabled";
1132   rv = prefBranch->GetBoolPref(kPrefNameOverrideEnabled, &isOverrideEnabled);
1133   if (NS_FAILED(rv) || !isOverrideEnabled) {
1134     return NS_OK;
1135   }
1136
1137   PRInt32 iFactor;
1138   nsCAutoString factorPrefName(
1139     "mousewheel.system_scroll_override_on_root_content.");
1140   if (aIsHorizontal) {
1141     factorPrefName.AppendLiteral("horizontal.");
1142   } else {
1143     factorPrefName.AppendLiteral("vertical.");
1144   }
1145   factorPrefName.AppendLiteral("factor");
1146   rv = prefBranch->GetIntPref(factorPrefName.get(), &iFactor);
1147   // The pref value must be larger than 100, otherwise, we don't override the
1148   // delta value.
1149   if (NS_FAILED(rv) || iFactor <= 100) {
1150     return NS_OK;
1151   }
1152   double factor = (double)iFactor / 100;
1153   aOverriddenDelta = PRInt32(NS_round((double)aOriginalDelta * factor));
1154
1155   return NS_OK;
1156 }
1157
1158
1159 /**
1160  * Modifies aFile to point at an icon file with the given name and suffix.  The
1161  * suffix may correspond to a file extension with leading '.' if appropriate.
1162  * Returns true if the icon file exists and can be read.
1163  */
1164 static PRBool
1165 ResolveIconNameHelper(nsILocalFile *aFile,
1166                       const nsAString &aIconName,
1167                       const nsAString &aIconSuffix)
1168 {
1169   aFile->Append(NS_LITERAL_STRING("icons"));
1170   aFile->Append(NS_LITERAL_STRING("default"));
1171   aFile->Append(aIconName + aIconSuffix);
1172
1173   PRBool readable;
1174   return NS_SUCCEEDED(aFile->IsReadable(&readable)) && readable;
1175 }
1176
1177 /**
1178  * Resolve the given icon name into a local file object.  This method is
1179  * intended to be called by subclasses of nsBaseWidget.  aIconSuffix is a
1180  * platform specific icon file suffix (e.g., ".ico" under Win32).
1181  *
1182  * If no file is found matching the given parameters, then null is returned.
1183  */
1184 void
1185 nsBaseWidget::ResolveIconName(const nsAString &aIconName,
1186                               const nsAString &aIconSuffix,
1187                               nsILocalFile **aResult)
1188 {
1189   *aResult = nsnull;
1190
1191   nsCOMPtr<nsIProperties> dirSvc = do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID);
1192   if (!dirSvc)
1193     return;
1194
1195   // first check auxilary chrome directories
1196
1197   nsCOMPtr<nsISimpleEnumerator> dirs;
1198   dirSvc->Get(NS_APP_CHROME_DIR_LIST, NS_GET_IID(nsISimpleEnumerator),
1199               getter_AddRefs(dirs));
1200   if (dirs) {
1201     PRBool hasMore;
1202     while (NS_SUCCEEDED(dirs->HasMoreElements(&hasMore)) && hasMore) {
1203       nsCOMPtr<nsISupports> element;
1204       dirs->GetNext(getter_AddRefs(element));
1205       if (!element)
1206         continue;
1207       nsCOMPtr<nsILocalFile> file = do_QueryInterface(element);
1208       if (!file)
1209         continue;
1210       if (ResolveIconNameHelper(file, aIconName, aIconSuffix)) {
1211         NS_ADDREF(*aResult = file);
1212         return;
1213       }
1214     }
1215   }
1216
1217   // then check the main app chrome directory
1218
1219   nsCOMPtr<nsILocalFile> file;
1220   dirSvc->Get(NS_APP_CHROME_DIR, NS_GET_IID(nsILocalFile),
1221               getter_AddRefs(file));
1222   if (file && ResolveIconNameHelper(file, aIconName, aIconSuffix))
1223     NS_ADDREF(*aResult = file);
1224 }
1225
1226 NS_IMETHODIMP
1227 nsBaseWidget::BeginResizeDrag(nsGUIEvent* aEvent, PRInt32 aHorizontal, PRInt32 aVertical)
1228 {
1229   return NS_ERROR_NOT_IMPLEMENTED;
1230 }
1231
1232 NS_IMETHODIMP
1233 nsBaseWidget::BeginMoveDrag(nsMouseEvent* aEvent)
1234 {
1235   return NS_ERROR_NOT_IMPLEMENTED;
1236 }
1237
1238 // For backwards compatibility only
1239 NS_IMETHODIMP
1240 nsBaseWidget::SetIMEEnabled(PRUint32 aState)
1241 {
1242   IMEContext context;
1243   context.mStatus = aState;
1244   return SetInputMode(context);
1245 }
1246
1247 NS_IMETHODIMP
1248 nsBaseWidget::GetIMEEnabled(PRUint32* aState)
1249 {
1250   IMEContext context;
1251   nsresult rv = GetInputMode(context);
1252   NS_ENSURE_SUCCESS(rv, rv);
1253
1254   *aState = context.mStatus;
1255   return NS_OK;
1256 }
1257
1258 #ifdef DEBUG
1259 //////////////////////////////////////////////////////////////
1260 //
1261 // Convert a GUI event message code to a string.
1262 // Makes it a lot easier to debug events.
1263 //
1264 // See gtk/nsWidget.cpp and windows/nsWindow.cpp
1265 // for a DebugPrintEvent() function that uses
1266 // this.
1267 //
1268 //////////////////////////////////////////////////////////////
1269 /* static */ nsAutoString
1270 nsBaseWidget::debug_GuiEventToString(nsGUIEvent * aGuiEvent)
1271 {
1272   NS_ASSERTION(nsnull != aGuiEvent,"cmon, null gui event.");
1273
1274   nsAutoString eventName(NS_LITERAL_STRING("UNKNOWN"));
1275
1276 #define _ASSIGN_eventName(_value,_name)\
1277 case _value: eventName.AssignWithConversion(_name) ; break
1278
1279   switch(aGuiEvent->message)
1280   {
1281     _ASSIGN_eventName(NS_BLUR_CONTENT,"NS_BLUR_CONTENT");
1282     _ASSIGN_eventName(NS_CREATE,"NS_CREATE");
1283     _ASSIGN_eventName(NS_DESTROY,"NS_DESTROY");
1284     _ASSIGN_eventName(NS_DRAGDROP_GESTURE,"NS_DND_GESTURE");
1285     _ASSIGN_eventName(NS_DRAGDROP_DROP,"NS_DND_DROP");
1286     _ASSIGN_eventName(NS_DRAGDROP_ENTER,"NS_DND_ENTER");
1287     _ASSIGN_eventName(NS_DRAGDROP_EXIT,"NS_DND_EXIT");
1288     _ASSIGN_eventName(NS_DRAGDROP_OVER,"NS_DND_OVER");
1289     _ASSIGN_eventName(NS_FOCUS_CONTENT,"NS_FOCUS_CONTENT");
1290     _ASSIGN_eventName(NS_FORM_SELECTED,"NS_FORM_SELECTED");
1291     _ASSIGN_eventName(NS_FORM_CHANGE,"NS_FORM_CHANGE");
1292     _ASSIGN_eventName(NS_FORM_INPUT,"NS_FORM_INPUT");
1293     _ASSIGN_eventName(NS_FORM_RESET,"NS_FORM_RESET");
1294     _ASSIGN_eventName(NS_FORM_SUBMIT,"NS_FORM_SUBMIT");
1295     _ASSIGN_eventName(NS_IMAGE_ABORT,"NS_IMAGE_ABORT");
1296     _ASSIGN_eventName(NS_LOAD_ERROR,"NS_LOAD_ERROR");
1297     _ASSIGN_eventName(NS_KEY_DOWN,"NS_KEY_DOWN");
1298     _ASSIGN_eventName(NS_KEY_PRESS,"NS_KEY_PRESS");
1299     _ASSIGN_eventName(NS_KEY_UP,"NS_KEY_UP");
1300     _ASSIGN_eventName(NS_MOUSE_ENTER,"NS_MOUSE_ENTER");
1301     _ASSIGN_eventName(NS_MOUSE_EXIT,"NS_MOUSE_EXIT");
1302     _ASSIGN_eventName(NS_MOUSE_BUTTON_DOWN,"NS_MOUSE_BUTTON_DOWN");
1303     _ASSIGN_eventName(NS_MOUSE_BUTTON_UP,"NS_MOUSE_BUTTON_UP");
1304     _ASSIGN_eventName(NS_MOUSE_CLICK,"NS_MOUSE_CLICK");
1305     _ASSIGN_eventName(NS_MOUSE_DOUBLECLICK,"NS_MOUSE_DBLCLICK");
1306     _ASSIGN_eventName(NS_MOUSE_MOVE,"NS_MOUSE_MOVE");
1307     _ASSIGN_eventName(NS_MOVE,"NS_MOVE");
1308     _ASSIGN_eventName(NS_LOAD,"NS_LOAD");
1309     _ASSIGN_eventName(NS_POPSTATE,"NS_POPSTATE");
1310     _ASSIGN_eventName(NS_BEFORE_SCRIPT_EXECUTE,"NS_BEFORE_SCRIPT_EXECUTE");
1311     _ASSIGN_eventName(NS_AFTER_SCRIPT_EXECUTE,"NS_AFTER_SCRIPT_EXECUTE");
1312     _ASSIGN_eventName(NS_PAGE_UNLOAD,"NS_PAGE_UNLOAD");
1313     _ASSIGN_eventName(NS_HASHCHANGE,"NS_HASHCHANGE");
1314     _ASSIGN_eventName(NS_READYSTATECHANGE,"NS_READYSTATECHANGE");
1315     _ASSIGN_eventName(NS_PAINT,"NS_PAINT");
1316     _ASSIGN_eventName(NS_XUL_BROADCAST, "NS_XUL_BROADCAST");
1317     _ASSIGN_eventName(NS_XUL_COMMAND_UPDATE, "NS_XUL_COMMAND_UPDATE");
1318     _ASSIGN_eventName(NS_SCROLLBAR_LINE_NEXT,"NS_SB_LINE_NEXT");
1319     _ASSIGN_eventName(NS_SCROLLBAR_LINE_PREV,"NS_SB_LINE_PREV");
1320     _ASSIGN_eventName(NS_SCROLLBAR_PAGE_NEXT,"NS_SB_PAGE_NEXT");
1321     _ASSIGN_eventName(NS_SCROLLBAR_PAGE_PREV,"NS_SB_PAGE_PREV");
1322     _ASSIGN_eventName(NS_SCROLLBAR_POS,"NS_SB_POS");
1323     _ASSIGN_eventName(NS_SIZE,"NS_SIZE");
1324
1325 #undef _ASSIGN_eventName
1326
1327   default:
1328     {
1329       char buf[32];
1330
1331       sprintf(buf,"UNKNOWN: %d",aGuiEvent->message);
1332
1333       eventName.AssignWithConversion(buf);
1334     }
1335     break;
1336   }
1337
1338   return nsAutoString(eventName);
1339 }
1340 //////////////////////////////////////////////////////////////
1341 //
1342 // Code to deal with paint and event debug prefs.
1343 //
1344 //////////////////////////////////////////////////////////////
1345 struct PrefPair
1346 {
1347   const char * name;
1348   PRBool value;
1349 };
1350
1351 static PrefPair debug_PrefValues[] =
1352 {
1353   { "nglayout.debug.crossing_event_dumping", PR_FALSE },
1354   { "nglayout.debug.event_dumping", PR_FALSE },
1355   { "nglayout.debug.invalidate_dumping", PR_FALSE },
1356   { "nglayout.debug.motion_event_dumping", PR_FALSE },
1357   { "nglayout.debug.paint_dumping", PR_FALSE },
1358   { "nglayout.debug.paint_flashing", PR_FALSE }
1359 };
1360
1361 static PRUint32 debug_NumPrefValues =
1362   (sizeof(debug_PrefValues) / sizeof(debug_PrefValues[0]));
1363
1364
1365 //////////////////////////////////////////////////////////////
1366 static PRBool debug_GetBoolPref(nsIPrefBranch * aPrefs,const char * aPrefName)
1367 {
1368   NS_ASSERTION(nsnull != aPrefName,"cmon, pref name is null.");
1369   NS_ASSERTION(nsnull != aPrefs,"cmon, prefs are null.");
1370
1371   PRBool value = PR_FALSE;
1372
1373   if (aPrefs)
1374   {
1375     aPrefs->GetBoolPref(aPrefName,&value);
1376   }
1377
1378   return value;
1379 }
1380 //////////////////////////////////////////////////////////////
1381 PRBool
1382 nsBaseWidget::debug_GetCachedBoolPref(const char * aPrefName)
1383 {
1384   NS_ASSERTION(nsnull != aPrefName,"cmon, pref name is null.");
1385
1386   for (PRUint32 i = 0; i < debug_NumPrefValues; i++)
1387   {
1388     if (strcmp(debug_PrefValues[i].name, aPrefName) == 0)
1389     {
1390       return debug_PrefValues[i].value;
1391     }
1392   }
1393
1394   return PR_FALSE;
1395 }
1396 //////////////////////////////////////////////////////////////
1397 static void debug_SetCachedBoolPref(const char * aPrefName,PRBool aValue)
1398 {
1399   NS_ASSERTION(nsnull != aPrefName,"cmon, pref name is null.");
1400
1401   for (PRUint32 i = 0; i < debug_NumPrefValues; i++)
1402   {
1403     if (strcmp(debug_PrefValues[i].name, aPrefName) == 0)
1404     {
1405       debug_PrefValues[i].value = aValue;
1406
1407       return;
1408     }
1409   }
1410
1411   NS_ASSERTION(PR_FALSE, "cmon, this code is not reached dude.");
1412 }
1413
1414 //////////////////////////////////////////////////////////////
1415 class Debug_PrefObserver : public nsIObserver {
1416   public:
1417     NS_DECL_ISUPPORTS
1418     NS_DECL_NSIOBSERVER
1419 };
1420
1421 NS_IMPL_ISUPPORTS1(Debug_PrefObserver, nsIObserver)
1422
1423 NS_IMETHODIMP
1424 Debug_PrefObserver::Observe(nsISupports* subject, const char* topic,
1425                             const PRUnichar* data)
1426 {
1427   nsCOMPtr<nsIPrefBranch> branch(do_QueryInterface(subject));
1428   NS_ASSERTION(branch, "must implement nsIPrefBranch");
1429
1430   NS_ConvertUTF16toUTF8 prefName(data);
1431
1432   PRBool value = PR_FALSE;
1433   branch->GetBoolPref(prefName.get(), &value);
1434   debug_SetCachedBoolPref(prefName.get(), value);
1435   return NS_OK;
1436 }
1437
1438 //////////////////////////////////////////////////////////////
1439 /* static */ void
1440 debug_RegisterPrefCallbacks()
1441 {
1442   static PRBool once = PR_TRUE;
1443
1444   if (once)
1445   {
1446     once = PR_FALSE;
1447
1448     nsCOMPtr<nsIPrefBranch2> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
1449
1450     NS_ASSERTION(prefs, "Prefs services is null.");
1451
1452     if (prefs)
1453     {
1454       nsCOMPtr<nsIObserver> obs(new Debug_PrefObserver());
1455       for (PRUint32 i = 0; i < debug_NumPrefValues; i++)
1456       {
1457         // Initialize the pref values
1458         debug_PrefValues[i].value =
1459           debug_GetBoolPref(prefs,debug_PrefValues[i].name);
1460
1461         if (obs) {
1462           // Register callbacks for when these change
1463           prefs->AddObserver(debug_PrefValues[i].name, obs, PR_FALSE);
1464         }
1465       }
1466     }
1467   }
1468 }
1469 //////////////////////////////////////////////////////////////
1470 static PRInt32
1471 _GetPrintCount()
1472 {
1473   static PRInt32 sCount = 0;
1474
1475   return ++sCount;
1476 }
1477 //////////////////////////////////////////////////////////////
1478 /* static */ PRBool
1479 nsBaseWidget::debug_WantPaintFlashing()
1480 {
1481   return debug_GetCachedBoolPref("nglayout.debug.paint_flashing");
1482 }
1483 //////////////////////////////////////////////////////////////
1484 /* static */ void
1485 nsBaseWidget::debug_DumpEvent(FILE *                aFileOut,
1486                               nsIWidget *           aWidget,
1487                               nsGUIEvent *          aGuiEvent,
1488                               const nsCAutoString & aWidgetName,
1489                               PRInt32               aWindowID)
1490 {
1491   // NS_PAINT is handled by debug_DumpPaintEvent()
1492   if (aGuiEvent->message == NS_PAINT)
1493     return;
1494
1495   if (aGuiEvent->message == NS_MOUSE_MOVE)
1496   {
1497     if (!debug_GetCachedBoolPref("nglayout.debug.motion_event_dumping"))
1498       return;
1499   }
1500
1501   if (aGuiEvent->message == NS_MOUSE_ENTER ||
1502       aGuiEvent->message == NS_MOUSE_EXIT)
1503   {
1504     if (!debug_GetCachedBoolPref("nglayout.debug.crossing_event_dumping"))
1505       return;
1506   }
1507
1508   if (!debug_GetCachedBoolPref("nglayout.debug.event_dumping"))
1509     return;
1510
1511   nsCAutoString tempString; tempString.AssignWithConversion(debug_GuiEventToString(aGuiEvent).get());
1512
1513   fprintf(aFileOut,
1514           "%4d %-26s widget=%-8p name=%-12s id=%-8p refpt=%d,%d\n",
1515           _GetPrintCount(),
1516           tempString.get(),
1517           (void *) aWidget,
1518           aWidgetName.get(),
1519           (void *) (aWindowID ? aWindowID : 0x0),
1520           aGuiEvent->refPoint.x,
1521           aGuiEvent->refPoint.y);
1522 }
1523 //////////////////////////////////////////////////////////////
1524 /* static */ void
1525 nsBaseWidget::debug_DumpPaintEvent(FILE *                aFileOut,
1526                                    nsIWidget *           aWidget,
1527                                    nsPaintEvent *        aPaintEvent,
1528                                    const nsCAutoString & aWidgetName,
1529                                    PRInt32               aWindowID)
1530 {
1531   NS_ASSERTION(nsnull != aFileOut,"cmon, null output FILE");
1532   NS_ASSERTION(nsnull != aWidget,"cmon, the widget is null");
1533   NS_ASSERTION(nsnull != aPaintEvent,"cmon, the paint event is null");
1534
1535   if (!debug_GetCachedBoolPref("nglayout.debug.paint_dumping"))
1536     return;
1537
1538   nsIntRect rect = aPaintEvent->region.GetBounds();
1539   fprintf(aFileOut,
1540           "%4d PAINT      widget=%p name=%-12s id=%-8p bounds-rect=%3d,%-3d %3d,%-3d",
1541           _GetPrintCount(),
1542           (void *) aWidget,
1543           aWidgetName.get(),
1544           (void *) aWindowID,
1545           rect.x, rect.y, rect.width, rect.height
1546     );
1547
1548   fprintf(aFileOut,"\n");
1549 }
1550 //////////////////////////////////////////////////////////////
1551 /* static */ void
1552 nsBaseWidget::debug_DumpInvalidate(FILE *                aFileOut,
1553                                    nsIWidget *           aWidget,
1554                                    const nsIntRect *     aRect,
1555                                    PRBool                aIsSynchronous,
1556                                    const nsCAutoString & aWidgetName,
1557                                    PRInt32               aWindowID)
1558 {
1559   if (!debug_GetCachedBoolPref("nglayout.debug.invalidate_dumping"))
1560     return;
1561
1562   NS_ASSERTION(nsnull != aFileOut,"cmon, null output FILE");
1563   NS_ASSERTION(nsnull != aWidget,"cmon, the widget is null");
1564
1565   fprintf(aFileOut,
1566           "%4d Invalidate widget=%p name=%-12s id=%-8p",
1567           _GetPrintCount(),
1568           (void *) aWidget,
1569           aWidgetName.get(),
1570           (void *) aWindowID);
1571
1572   if (aRect)
1573   {
1574     fprintf(aFileOut,
1575             " rect=%3d,%-3d %3d,%-3d",
1576             aRect->x,
1577             aRect->y,
1578             aRect->width,
1579             aRect->height);
1580   }
1581   else
1582   {
1583     fprintf(aFileOut,
1584             " rect=%-15s",
1585             "none");
1586   }
1587
1588   fprintf(aFileOut,
1589           " sync=%s",
1590           (const char *) (aIsSynchronous ? "yes" : "no "));
1591
1592   fprintf(aFileOut,"\n");
1593 }
1594 //////////////////////////////////////////////////////////////
1595
1596 #endif // DEBUG
1597