Attachment #375458 for bug #76053

Attachment #375458: Patch v4.0 for bug #76053

View | Details | Raw Unified | Return to bug 76053
Collapse All | Expand All





#include "nsIURIFixup.h"
#include "nsCDefaultURIFixup.h"
#include "nsEventDispatcher.h"
#include "nsIObserverService.h"
#include "nsIXULAppInfo.h"
#include "nsNetUtil.h"
#ifdef MOZ_XUL
#include "nsXULPopupManager.h"
#include "nsIDOMXULControlElement.h"
#include "nsIFrame.h"
#include "nsPresShellIterator.h"
#endif

#include "plbase64.h"

#ifdef NS_PRINTING
#include "nsIPrintSettings.h"
#include "nsIPrintSettingsService.h"
#include "nsIWebBrowserPrint.h"


  if (treeOwnerAsWin) {
    treeOwnerAsWin->GetMainWidget(&widget);
  }

  return widget;
}

nsIWidget*
nsGlobalWindow::GetNearetWidget()
{
  nsIDocShell* docShell = GetDocShell();
  NS_ENSURE_TRUE(docShell, nsnull);
  nsCOMPtr<nsIPresShell> winShell;
  docShell->GetPresShell(getter_AddRefs(winShell));
  NS_ENSURE_TRUE(winShell, nsnull);
  nsIFrame* rootFrame = winShell->GetRootFrame();
  NS_ENSURE_TRUE(rootFrame, nsnull);
  return rootFrame->GetView()->GetNearestWidget(nsnull);
}

NS_IMETHODIMP
nsGlobalWindow::SetFullScreen(PRBool aFullScreen)
{
  FORWARD_TO_OUTER(SetFullScreen, (aFullScreen), NS_ERROR_NOT_INITIALIZED);

  NS_ENSURE_TRUE(mDocShell, NS_ERROR_FAILURE);

  PRBool rootWinFullScreen;

{
  FORWARD_TO_OUTER_CHROME(SetBrowserDOMWindow, (aBrowserWindow),
                          NS_ERROR_NOT_INITIALIZED);

  mBrowserDOMWindow = aBrowserWindow;
  return NS_OK;
}

NS_IMETHODIMP
nsGlobalChromeWindow::NotifyDefaultButtonLoaded(nsIDOMElement* aDefaultButton)
{
#ifdef MOZ_XUL
  NS_ENSURE_ARG(aDefaultButton);

  // Don't snap to a disabled button.
  nsCOMPtr<nsIDOMXULControlElement> xulControl =
                                      do_QueryInterface(aDefaultButton);
  NS_ENSURE_TRUE(xulControl, NS_ERROR_FAILURE);
  PRBool disabled;
  nsresult rv = xulControl->GetDisabled(&disabled);
  NS_ENSURE_SUCCESS(rv, rv);
  if (disabled)
    return NS_OK;

  // Get the button rect in screen coordinates.
  nsCOMPtr<nsIContent> content(do_QueryInterface(aDefaultButton));
  NS_ENSURE_TRUE(content, NS_ERROR_FAILURE);
  nsIDocument *doc = content->GetDocument();
  NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
  nsIPresShell *shell = doc->GetPrimaryShell();
  NS_ENSURE_TRUE(shell, NS_ERROR_FAILURE);
  nsIFrame *frame = shell->GetPrimaryFrameFor(content);
  NS_ENSURE_TRUE(frame, NS_ERROR_FAILURE);
  nsIntRect buttonRect = frame->GetScreenRect();

  // Get the widget rect in screen coordinates.
  nsIWidget *widget = GetNearetWidget();
  NS_ENSURE_TRUE(widget, NS_ERROR_FAILURE);
  nsIntRect widgetRect;
  rv = widget->GetScreenBounds(widgetRect);
  NS_ENSURE_SUCCESS(rv, rv);

  // Convert the buttonRect coordinates from screen to the widget.
  buttonRect -= widgetRect.TopLeft();
  rv = widget->OnDefaultButtonLoaded(buttonRect);
  if (rv == NS_ERROR_NOT_IMPLEMENTED)
    return NS_OK;
  NS_ENSURE_SUCCESS(rv, rv);
  return NS_OK;
#else
  return NS_ERROR_NOT_IMPLEMENTED;
#endif
}

// nsGlobalModalWindow implementation

// QueryInterface implementation for nsGlobalModalWindow
NS_IMPL_CYCLE_COLLECTION_CLASS(nsGlobalModalWindow)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(nsGlobalModalWindow,
                                                  nsGlobalWindow)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mArguments)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END





  PRBool DispatchCustomEvent(const char *aEventName);

  // If aLookForCallerOnJSStack is true, this method will look at the JS stack
  // to determine who the caller is.  If it's false, it'll use |this| as the
  // caller.
  PRBool WindowExists(const nsAString& aName, PRBool aLookForCallerOnJSStack);

  already_AddRefed<nsIWidget> GetMainWidget();
  nsIWidget* GetNearetWidget();

  void Freeze()
  {
    NS_ASSERTION(!IsFrozen(), "Double-freezing?");
    mIsFrozen = PR_TRUE;
  }

  void Thaw()





 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#include "domstubs.idl"

interface nsIBrowserDOMWindow;
interface nsIDOMElement;

[scriptable, uuid(09b86cbd-9784-4fe4-9be6-70b9bbca3a9c)]
interface nsIDOMChromeWindow : nsISupports
{
  const unsigned short STATE_MAXIMIZED = 1;
  const unsigned short STATE_MINIMIZED = 2;
  const unsigned short STATE_NORMAL = 3;

  readonly attribute unsigned short              windowState;



  void                      getAttentionWithCycleCount(in long aCycleCount);

  void                      setCursor(in DOMString cursor);

  void                      maximize();
  void                      minimize();
  void                      restore();

  /**
   * Notify a default button is loaded on a dialog or a wizard.
   * defaultButton is the default button.
   */
  void notifyDefaultButtonLoaded(in nsIDOMElement defaultButton);
};





		test_preferences.xul \
		window_preferences.xul \
		window_preferences2.xul \
		window_preferences3.xul \
		test_autocomplete2.xul \
		test_autocomplete3.xul \
		test_keys.xul \
		window_keys.xul \
		test_cursorsnap.xul \
		window_cursorsnap_dialog.xul \
		window_cursorsnap_wizard.xul \
		$(NULL)

# test_panel_focus.xul won't work if the Full Keyboard Access preference is set to
# textboxes and lists only, so skip this test on Mac
ifeq (,$(filter mac cocoa,$(MOZ_WIDGET_TOOLKIT)))
_TEST_FILES += test_panel_focus.xul \
               window_panel_focus.xul
else

-      Line
+  Link Here
-      Line 0
+  Link Here
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin" type="text/css"?>
+<?xml-stylesheet href="chrome://mochikit/content/tests/SimpleTest/test.css"
+                 type="text/css"?>
+<window title="Cursor snapping test"
+  xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+  <script type="application/javascript"
+          src="chrome://mochikit/content/MochiKit/packed.js"/>
+  <script type="application/javascript"
+          src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js" />
+  <script type="application/javascript"
+          src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js" />
+<body  xmlns="http://www.w3.org/1999/xhtml">
+<div id="content" style="display: none">
+</div>
+<pre id="test">
+</pre>
+</body>
+<script class="testbody" type="application/javascript">
+<![CDATA[
+SimpleTest.waitForExplicitFinish();
+var gTestingIndex = 0;
+var gDisable = false;
+var gHidden = false;
+function runNextTest() {
+  switch (gTestingIndex) {
+    case 0:
+      gDisable = false;
+      gHidden = false;
+      window.open("window_cursorsnap_dialog.xul", "_blank",
+                  "chrome,width=100,height=100");
+      break;
+    case 1:
+      gDisable = true;
+      gHidden = false;
+      window.open("window_cursorsnap_dialog.xul", "_blank",
+                  "chrome,width=100,height=100");
+      break;
+    case 2:
+      gDisable = false;
+      gHidden = true;
+      window.open("window_cursorsnap_dialog.xul", "_blank",
+                  "chrome,width=100,height=100");
+      break;
+    case 3:
+      gDisable = false;
+      gHidden = false;
+      window.open("window_cursorsnap_wizard.xul", "_blank",
+                  "chrome,width=100,height=100");
+      break;
+    case 4:
+      gDisable = true;
+      gHidden = false;
+      window.open("window_cursorsnap_wizard.xul", "_blank",
+                  "chrome,width=100,height=100");
+      break;
+    case 5:
+      gDisable = false;
+      gHidden = true;
+      window.open("window_cursorsnap_wizard.xul", "_blank",
+                  "chrome,width=100,height=100");
+      break;
+    default:
+      disableNonTestMouseEvents(false);
+      SetPrefs(false);
+      SimpleTest.finish();
+      return;
+  }
+  gTestingIndex++;
+}
+function SetPrefs(aSet)
+{
+  netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
+  var prefSvc = Components.classes["@mozilla.org/preferences-service;1"].
+                           getService(Components.interfaces.nsIPrefBranch2);
+  const kPrefName = "ui.snap_cursor_testing";
+  if (aSet) {
+    prefSvc.setBoolPref(kPrefName, true);
+  } else {
+    prefSvc.clearUserPref(kPrefName);
+  }
+}
+if (navigator.platform.indexOf("Win") != 0) {
+  // We don't support this feature on the platform.
+  SimpleTest.finish();
+} else {
+  disableNonTestMouseEvents(true);
+  SetPrefs(true);
+  runNextTest();
+}
+]]>
+</script>
+</window>

-      Line
+  Link Here
-      Line 0
+  Link Here
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin" type="text/css"?>
+<wizard title="Cursor snapping test" id="wizard"
+  width="600" height="600"
+  onload="onload();"
+  onunload="onunload();"
+  buttons="accept,cancel"
+  xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+  <wizardpage>
+    <label value="first page"/>
+  </wizardpage>
+  <wizardpage>
+    <label value="second page"/>
+  </wizardpage>
+<script class="testbody" type="application/javascript">
+<![CDATA[
+function ok(aCondition, aMessage)
+{
+  window.opener.wrappedJSObject.SimpleTest.ok(aCondition, aMessage);
+}
+function is(aLeft, aRight, aMessage)
+{
+  window.opener.wrappedJSObject.SimpleTest.is(aLeft, aRight, aMessage);
+}
+function isnot(aLeft, aRight, aMessage)
+{
+  window.opener.wrappedJSObject.SimpleTest.isnot(aLeft, aRight, aMessage);
+}
+var gTimer;
+function finishByTimeout()
+{
+  var button = document.getElementById("wizard").getButton("next");
+  if (button.disabled)
+    ok(true, "cursor is NOT snapped to the disabled button (wizard)");
+  else if (button.hidden)
+    ok(true, "cursor is NOT snapped to the hidden button (wizard)");
+  else
+    ok(false, "cursor is NOT snapped to the default button (wizard)");
+  finish();
+}
+function finish()
+{
+  window.close();
+}
+function onMouseMove()
+{
+  var button = document.getElementById("wizard").getButton("next");
+  if (button.disabled)
+    ok(false, "cursor IS snapped to the disabled button (wizard)");
+  else if (button.hidden)
+    ok(false, "cursor IS snapped to the hidden button (wizard)");
+  else
+    ok(true, "cursor IS snapped to the default button (wizard)");
+  clearTimeout(gTimer);
+  finish();
+}
+function onload()
+{
+  var button = document.getElementById("wizard").getButton("next");
+  button.addEventListener("mousemove", onMouseMove, false);
+  if (window.opener.wrappedJSObject.gDisable) {
+    button.disabled = true;
+  }
+  if (window.opener.wrappedJSObject.gHidden) {
+    button.hidden = true;
+  }
+  // XXX this could cause a random failure...
+  gTimer = setTimeout(finishByTimeout, 1000);
+}
+function onunload()
+{
+  window.opener.wrappedJSObject.runNextTest();
+}
+]]>
+</script>
+</wizard>





      ]]>
      </constructor>

      <method name="postLoadInit">
        <parameter name="aEvent"/>
        <body>
        <![CDATA[
          function focusInit() {
            const dialog = document.documentElement;
            const defaultButton = dialog.getButton(dialog.defaultButton);
            // give focus to the first focusable element in the dialog
            if (!document.commandDispatcher.focusedElement) {
              document.commandDispatcher.advanceFocusIntoSubtree(dialog);
              var focusedElt = document.commandDispatcher.focusedElement;
              if (focusedElt) {
                if (focusedElt.localName == 'tab') {
                  // Move focus into the tab
                  document.commandDispatcher.advanceFocusIntoSubtree(focusedElt);
                  if (document.commandDispatcher.focusedElement.hasAttribute("dlgtype")) {
                    // We don't want to focus on anonymous OK, Cancel, etc. buttons,
                    // so return focus to the tab itself
                    focusedElt.focus();
                  }
                }
#ifndef XP_MACOSX
                else {
                  const dialog = document.documentElement;
                  const defaultButton = dialog.getButton(dialog.defaultButton);
                  if (focusedElt.hasAttribute("dlgtype") && focusedElt != defaultButton)
                    defaultButton.focus();
                }
#endif
              }
            }

            try {
              if (defaultButton)
                window.notifyDefaultButtonLoaded(defaultButton);
            } catch (e) { }
          }

          // Give focus after onload completes, see bug 103197.
          setTimeout(focusInit, 0);
        ]]>
        </body>
      </method>                






        <body>
        <![CDATA[
          document.documentElement._hasLoaded = true;
          var focusInit = 
            function() {
              // give focus to the first focusable element in the dialog
              if (!document.commandDispatcher.focusedElement)
                document.commandDispatcher.advanceFocusIntoSubtree(document.documentElement);

              try {
                var button =
                      document.documentElement._wizardButtons.defaultButton;
                if (button)
                  window.notifyDefaultButtonLoaded(button);
              } catch (e) { }
            };

          // Give focus after onload completes, see bug 103197.
          setTimeout(focusInit, 0);
        ]]>
        </body>
      </method>                


        <body><![CDATA[
          if (this.getAttribute("lastpage") == "true") {
            this._wizardButtonDeck.setAttribute("selectedIndex", 0);
          } else {
            this._wizardButtonDeck.setAttribute("selectedIndex", 1);
          }
        ]]></body>
      </method>

      <property name="defaultButton">
        <getter><![CDATA[
          const kXULNS =
            "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
          var buttons = this._wizardButtonDeck.selectedPanel
                            .getElementsByTagNameNS(kXULNS, "button");
          for (var i = 0; i < buttons.length; i++) {
            if (buttons[i].getAttribute("default") == "true" &&
                !buttons[i].hidden && !buttons[i].disabled)
              return buttons[i];
          }
          return null;
        ]]></getter>
      </property>
    </implementation>
  </binding>
#endif

</bindings>





#define NS_NATIVE_PLUGIN_PORT_CG    101
#endif
#ifdef XP_WIN
#define NS_NATIVE_TSF_THREAD_MGR       100
#define NS_NATIVE_TSF_CATEGORY_MGR     101
#define NS_NATIVE_TSF_DISPLAY_ATTR_MGR 102
#endif

// {a395289d-b344-42c3-ae7e-34d64282b6e0}
#define NS_IWIDGET_IID \
{ 0xa395289d, 0xb344, 0x42c3, \
  { 0xae, 0x7e, 0x34, 0xd6, 0x42, 0x82, 0xb6, 0xe0 } }

/*
 * Window shadow styles
 * Also used for the -moz-window-shadow CSS property
 */

#define NS_STYLE_WINDOW_SHADOW_NONE             0
#define NS_STYLE_WINDOW_SHADOW_DEFAULT          1

                               PRUint32 aOldEnd,
                               PRUint32 aNewEnd) = 0;

    /*
     * Selection has changed in the focused node
     */
    NS_IMETHOD OnIMESelectionChange(void) = 0;

    /*
     * When a default button loaded on dialog or something, this method is
     * called.  aButtonRect coordinates are relative to this widget.
     */ 
    NS_IMETHOD OnDefaultButtonLoaded(const nsIntRect &aButtonRect) = 0;

protected:
    // keep the list of children.  We also keep track of our siblings.
    // The ownership model is as follows: parent holds a strong ref to
    // the first element of the list, and each element holds a strong
    // ref to the next element in the list.  The prevsibling and
    // lastchild pointers are weak, which is fine as long as they are
    // maintained properly.
    nsCOMPtr<nsIWidget> mFirstChild;

-      Line
+  Link Here
-       Lines 8539-8554
      nsWindow :: DealWithPopups ( HWND inWnd,
+  Link Here
+        }
+      }
     } // if event that might trigger a popup to rollup
   } // if rollup listeners registered
   return FALSE;
 } // DealWithPopups
+NS_IMETHODIMP
+nsWindow::OnDefaultButtonLoaded(const nsIntRect &aButtonRect)
+{
+  if (aButtonRect.IsEmpty())
+    return NS_OK;
+  // Check whether we are testing the feature of "to snap mouse cursor to center
+  // of the default window".  That is not easy to test in normal conditions.
+  // The tests disables all mouse event handling and they need the synthesized
+  // mouse event on the default button.  And also they hope that the snapping
+  // should be happend always.
+  PRBool isCursorSnapTesting = PR_FALSE;
+  nsCOMPtr<nsIPrefService> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);
+  if (prefs) {
+    nsCOMPtr<nsIPrefBranch> prefBranch;
+    prefs->GetBranch(nsnull, getter_AddRefs(prefBranch));
+    if (prefBranch) {
+      prefBranch->GetBoolPref("ui.snap_cursor_testing", &isCursorSnapTesting);
+    }
+  }
+  // We don't need to check whether we should snap the mouse cursor.
+  if (!isCursorSnapTesting) {
+    // Don't snap when we are not active.
+    if (::GetActiveWindow() != ::GetForegroundWindow())
+      return NS_OK;
+    BOOL snapDefaultButton;
+    if (!::SystemParametersInfo(SPI_GETSNAPTODEFBUTTON, 0,
+                                &snapDefaultButton, 0) || !snapDefaultButton)
+      return NS_OK;
+  }
+  nsIntRect widgetRect;
+  nsresult rv = GetScreenBounds(widgetRect);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsIntRect buttonRect(aButtonRect + widgetRect.TopLeft());
+  nsIntPoint centerOfButton(buttonRect.x + buttonRect.width / 2,
+                            buttonRect.y + buttonRect.height / 2);
+  // The button can be outside of the widget.
+  // E.g., it could be hidden by scrolling.
+  if (!widgetRect.Intersects(buttonRect) ||
+      !widgetRect.Contains(centerOfButton)) {
+    return NS_OK;
+  }
+  rv = ::SetCursorPos(centerOfButton.x, centerOfButton.y) ? NS_OK :
+                                                            NS_ERROR_FAILURE;
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!isCursorSnapTesting)
+    return NS_OK;
+  // Generate a fake event for automated testing of this feature.
+  nsMouseEvent event(PR_TRUE, NS_MOUSE_MOVE, this, nsMouseEvent::eReal,
+                     nsMouseEvent::eNormal);
+  event.flags |= NS_EVENT_FLAG_SYNTETIC_TEST_EVENT;
+  event.time = PR_IntervalNow();
+  event.refPoint = centerOfButton - widgetRect.TopLeft();
+  nsEventStatus status;
+  return DispatchEvent(&event, status);
+}
 #ifdef ACCESSIBILITY
 already_AddRefed<nsIAccessible> nsWindow::GetRootAccessible()
+{
   nsWindow::gIsAccessibilityOn = TRUE;
   if (mIsDestroying || mOnDestroyCalled || mWindowType == eWindowType_invisible) {





  NS_IMETHOD CancelIMEComposition();
  NS_IMETHOD GetToggledKeyState(PRUint32 aKeyCode, PRBool* aLEDState);

#ifdef NS_ENABLE_TSF
  NS_IMETHOD OnIMEFocusChange(PRBool aFocus);
  NS_IMETHOD OnIMETextChange(PRUint32 aStart, PRUint32 aOldEnd, PRUint32 aNewEnd);
  NS_IMETHOD OnIMESelectionChange(void);
#endif //NS_ENABLE_TSF

  NS_IMETHOD OnDefaultButtonLoaded(const nsIntRect &aButtonRect);

  PRBool IMEMouseHandling(PRInt32 aAction, LPARAM lParam);
  PRBool IMECompositionHitTest(POINT * ptPos);
  PRBool HandleMouseActionOfIME(PRInt32 aAction, POINT* ptPos);

  // nsSwitchToUIThread interface
  virtual BOOL            CallMethod(MethodInfo *info);






  NS_IMETHOD              GetIMEOpenState(PRBool* aState) { return NS_ERROR_NOT_IMPLEMENTED; }
  NS_IMETHOD              SetIMEEnabled(PRUint32 aState) { return NS_ERROR_NOT_IMPLEMENTED; }
  NS_IMETHOD              GetIMEEnabled(PRUint32* aState) { return NS_ERROR_NOT_IMPLEMENTED; }
  NS_IMETHOD              CancelIMEComposition() { return NS_OK; }
  NS_IMETHOD              GetToggledKeyState(PRUint32 aKeyCode, PRBool* aLEDState) { return NS_ERROR_NOT_IMPLEMENTED; }
  NS_IMETHOD              OnIMEFocusChange(PRBool aFocus) { return NS_ERROR_NOT_IMPLEMENTED; }
  NS_IMETHOD              OnIMETextChange(PRUint32 aStart, PRUint32 aOldEnd, PRUint32 aNewEnd) { return NS_ERROR_NOT_IMPLEMENTED; }
  NS_IMETHOD              OnIMESelectionChange(void) { return NS_ERROR_NOT_IMPLEMENTED; }
  NS_IMETHOD              OnDefaultButtonLoaded(const nsIntRect &aButtonRect) { return NS_ERROR_NOT_IMPLEMENTED; }

protected:

  virtual void            ResolveIconName(const nsAString &aIconName,
                                          const nsAString &aIconSuffix,
                                          nsILocalFile **aResult);
  virtual void            OnDestroy();
  virtual void            BaseCreate(nsIWidget *aParent,

Return to bug 76053