1998-04-13 20:24:54 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
2006-04-17 23:16:46 +00:00
|
|
|
* vim: set ts=2 sw=2 et tw=78:
|
2004-04-18 14:30:37 +00:00
|
|
|
* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
1998-04-13 20:24:54 +00:00
|
|
|
*
|
2004-04-18 14:30:37 +00:00
|
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
|
|
* the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/MPL/
|
|
|
|
*
|
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
1998-04-13 20:24:54 +00:00
|
|
|
*
|
1999-11-06 03:40:37 +00:00
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
2004-04-18 14:30:37 +00:00
|
|
|
* The Initial Developer of the Original Code is
|
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
1999-11-06 03:40:37 +00:00
|
|
|
*
|
2004-04-18 14:30:37 +00:00
|
|
|
* Contributor(s):
|
2001-04-18 06:06:31 +00:00
|
|
|
* Steve Clark <buster@netscape.com>
|
2007-08-22 11:13:46 +00:00
|
|
|
* Håkan Waara <hwaara@chello.se>
|
2001-04-18 06:06:31 +00:00
|
|
|
* Dan Rosen <dr@netscape.com>
|
2001-08-02 14:34:55 +00:00
|
|
|
* Daniel Glazman <glazman@netscape.com>
|
2005-03-27 11:36:08 +00:00
|
|
|
* Mats Palmgren <mats.palmgren@bredband.net>
|
2000-05-15 03:37:21 +00:00
|
|
|
*
|
2004-04-18 14:30:37 +00:00
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
|
|
* either of the GNU General Public License Version 2 or later (the "GPL"),
|
|
|
|
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK *****
|
2000-05-15 03:37:21 +00:00
|
|
|
*
|
|
|
|
* This Original Code has been modified by IBM Corporation.
|
|
|
|
* Modifications made by IBM described herein are
|
|
|
|
* Copyright (c) International Business Machines
|
|
|
|
* Corporation, 2000
|
|
|
|
*
|
|
|
|
* Modifications to Mozilla code or documentation
|
|
|
|
* identified per MPL Section 3.3
|
|
|
|
*
|
|
|
|
* Date Modified by Description of modification
|
|
|
|
* 05/03/2000 IBM Corp. Observer events for reflow states
|
1999-09-10 18:29:37 +00:00
|
|
|
*/
|
2001-04-18 06:06:31 +00:00
|
|
|
|
2006-03-30 05:56:38 +00:00
|
|
|
/* a presentation of a document, part 2 */
|
|
|
|
|
1999-12-07 04:36:08 +00:00
|
|
|
#define PL_ARENA_CONST_ALIGN_MASK 3
|
2005-04-13 04:35:13 +00:00
|
|
|
|
1998-04-13 20:24:54 +00:00
|
|
|
#include "nsIPresShell.h"
|
2004-07-31 23:15:21 +00:00
|
|
|
#include "nsPresContext.h"
|
1998-04-13 20:24:54 +00:00
|
|
|
#include "nsIContent.h"
|
|
|
|
#include "nsIDocument.h"
|
2003-03-06 23:07:00 +00:00
|
|
|
#include "nsIDOMXULDocument.h"
|
2004-01-29 01:45:34 +00:00
|
|
|
#include "nsStubDocumentObserver.h"
|
2004-01-07 22:30:53 +00:00
|
|
|
#include "nsStyleSet.h"
|
1998-11-26 01:34:53 +00:00
|
|
|
#include "nsICSSStyleSheet.h" // XXX for UA sheet loading hack, can this go away please?
|
2000-10-11 08:33:01 +00:00
|
|
|
#include "nsIDOMCSSStyleSheet.h" // for Pref-related rule management (bugs 22963,20760,31816)
|
|
|
|
#include "nsINameSpaceManager.h" // for Pref-related rule management (bugs 22963,20760,31816)
|
1999-08-05 20:17:44 +00:00
|
|
|
#include "nsIServiceManager.h"
|
1998-05-20 16:24:54 +00:00
|
|
|
#include "nsFrame.h"
|
1998-04-13 20:24:54 +00:00
|
|
|
#include "nsIViewManager.h"
|
|
|
|
#include "nsCRT.h"
|
2006-11-17 01:49:06 +00:00
|
|
|
#include "nsCRTGlue.h"
|
1998-06-03 15:46:54 +00:00
|
|
|
#include "prlog.h"
|
2000-04-01 08:35:40 +00:00
|
|
|
#include "prmem.h"
|
2004-01-18 14:44:43 +00:00
|
|
|
#include "prprf.h"
|
1998-12-12 19:21:05 +00:00
|
|
|
#include "prinrval.h"
|
1998-06-09 04:51:44 +00:00
|
|
|
#include "nsVoidArray.h"
|
2004-09-13 03:22:46 +00:00
|
|
|
#include "nsCOMArray.h"
|
2000-10-09 03:08:41 +00:00
|
|
|
#include "nsHashtable.h"
|
1998-08-28 02:54:06 +00:00
|
|
|
#include "nsIViewObserver.h"
|
1998-09-19 03:24:26 +00:00
|
|
|
#include "nsContainerFrame.h"
|
1998-10-02 01:12:39 +00:00
|
|
|
#include "nsIDeviceContext.h"
|
2004-09-04 19:28:46 +00:00
|
|
|
#include "nsEventStateManager.h"
|
|
|
|
#include "nsDOMEvent.h"
|
2001-07-16 02:40:48 +00:00
|
|
|
#include "nsGUIEvent.h"
|
1998-11-17 02:14:38 +00:00
|
|
|
#include "nsHTMLParts.h"
|
2004-04-29 23:34:19 +00:00
|
|
|
#include "nsContentUtils.h"
|
2000-09-14 11:45:01 +00:00
|
|
|
#include "nsISelection.h"
|
1999-12-02 21:45:21 +00:00
|
|
|
#include "nsISelectionController.h"
|
2007-03-20 12:14:52 +00:00
|
|
|
#include "nsISelectionPrivate.h"
|
1998-12-08 18:26:06 +00:00
|
|
|
#include "nsLayoutCID.h"
|
2007-01-30 00:06:41 +00:00
|
|
|
#include "nsGkAtoms.h"
|
1998-12-14 18:34:14 +00:00
|
|
|
#include "nsIDOMRange.h"
|
|
|
|
#include "nsIDOMDocument.h"
|
|
|
|
#include "nsIDOMNode.h"
|
2003-06-16 11:17:18 +00:00
|
|
|
#include "nsIDOM3Node.h"
|
2000-09-14 11:45:01 +00:00
|
|
|
#include "nsIDOMNodeList.h"
|
1998-12-14 18:34:14 +00:00
|
|
|
#include "nsIDOMElement.h"
|
2007-03-20 12:14:52 +00:00
|
|
|
#include "nsRange.h"
|
2002-11-17 15:37:56 +00:00
|
|
|
#include "nsCSSPseudoElements.h"
|
1999-01-22 18:58:14 +00:00
|
|
|
#include "nsCOMPtr.h"
|
2003-02-22 00:32:13 +00:00
|
|
|
#include "nsAutoPtr.h"
|
2001-09-29 08:28:41 +00:00
|
|
|
#include "nsReadableUtils.h"
|
2001-12-17 07:14:49 +00:00
|
|
|
#include "nsUnicharUtils.h"
|
1999-08-25 10:51:55 +00:00
|
|
|
#include "nsWeakReference.h"
|
2000-01-04 20:24:09 +00:00
|
|
|
#include "nsIPageSequenceFrame.h"
|
1999-02-12 00:02:56 +00:00
|
|
|
#include "nsICaret.h"
|
1999-02-12 05:39:33 +00:00
|
|
|
#include "nsIDOMHTMLDocument.h"
|
2003-03-19 23:45:42 +00:00
|
|
|
#include "nsIXPointer.h"
|
2001-12-20 05:15:52 +00:00
|
|
|
#include "nsIDOMXMLDocument.h"
|
1999-02-12 05:39:33 +00:00
|
|
|
#include "nsIScrollableView.h"
|
1999-03-01 19:21:01 +00:00
|
|
|
#include "nsIParser.h"
|
|
|
|
#include "nsParserCIID.h"
|
2006-04-26 02:01:07 +00:00
|
|
|
#include "nsFrameSelection.h"
|
2000-06-14 02:57:26 +00:00
|
|
|
#include "nsIDOMNSHTMLInputElement.h" //optimization for ::DoXXX commands
|
2000-06-29 22:33:36 +00:00
|
|
|
#include "nsIDOMNSHTMLTextAreaElement.h"
|
1999-04-03 18:58:04 +00:00
|
|
|
#include "nsViewsCID.h"
|
2004-02-23 21:29:06 +00:00
|
|
|
#include "nsFrameManager.h"
|
2002-09-03 23:36:13 +00:00
|
|
|
#include "nsXPCOM.h"
|
1999-08-25 08:35:06 +00:00
|
|
|
#include "nsISupportsPrimitives.h"
|
1999-08-30 22:38:58 +00:00
|
|
|
#include "nsILayoutHistoryState.h"
|
2007-03-07 19:08:36 +00:00
|
|
|
#include "nsILineIterator.h" // for ScrollContentIntoView
|
1999-11-10 03:41:09 +00:00
|
|
|
#include "nsTimer.h"
|
1999-11-09 03:23:26 +00:00
|
|
|
#include "nsWeakPtr.h"
|
1999-12-07 04:36:08 +00:00
|
|
|
#include "plarena.h"
|
2004-05-02 18:07:12 +00:00
|
|
|
#include "pldhash.h"
|
2004-07-18 01:16:27 +00:00
|
|
|
#include "nsIObserverService.h"
|
|
|
|
#include "nsIObserver.h"
|
2000-08-30 00:35:43 +00:00
|
|
|
#include "nsIDocShell.h" // for reflow observation
|
2004-10-14 21:51:00 +00:00
|
|
|
#include "nsIBaseWindow.h"
|
2002-11-25 11:21:22 +00:00
|
|
|
#include "nsLayoutErrors.h"
|
2003-01-05 05:05:17 +00:00
|
|
|
#include "nsLayoutUtils.h"
|
2003-01-17 09:33:52 +00:00
|
|
|
#include "nsCSSRendering.h"
|
1999-11-01 22:12:45 +00:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
#include "nsIFrameDebug.h"
|
|
|
|
#endif
|
2001-10-26 05:12:25 +00:00
|
|
|
// for |#ifdef DEBUG| code
|
|
|
|
#include "nsSpaceManager.h"
|
2001-06-27 04:04:04 +00:00
|
|
|
#include "prenv.h"
|
2005-02-20 09:55:02 +00:00
|
|
|
#include "nsIAttribute.h"
|
2005-08-23 22:26:10 +00:00
|
|
|
#include "nsIGlobalHistory2.h"
|
2006-01-26 02:29:17 +00:00
|
|
|
#include "nsDisplayList.h"
|
2007-03-20 12:14:52 +00:00
|
|
|
#include "nsIRegion.h"
|
2006-01-26 02:29:17 +00:00
|
|
|
#include "nsRegion.h"
|
1999-02-19 23:47:36 +00:00
|
|
|
|
2001-03-13 01:47:22 +00:00
|
|
|
#ifdef MOZ_REFLOW_PERF_DSP
|
|
|
|
#include "nsIRenderingContext.h"
|
|
|
|
#include "nsIFontMetrics.h"
|
|
|
|
#endif
|
|
|
|
|
2000-07-13 23:00:59 +00:00
|
|
|
#include "nsIReflowCallback.h"
|
|
|
|
|
2000-02-13 06:07:38 +00:00
|
|
|
#include "nsPIDOMWindow.h"
|
2000-11-04 08:21:20 +00:00
|
|
|
#include "nsIFocusController.h"
|
2005-05-04 20:22:32 +00:00
|
|
|
#include "nsIPluginInstance.h"
|
|
|
|
#include "nsIObjectFrame.h"
|
2005-12-03 11:27:42 +00:00
|
|
|
#include "nsIObjectLoadingContent.h"
|
2005-11-01 11:37:25 +00:00
|
|
|
#include "nsNetUtil.h"
|
2006-03-07 17:08:51 +00:00
|
|
|
#include "nsEventDispatcher.h"
|
2006-05-10 17:30:15 +00:00
|
|
|
#include "nsThreadUtils.h"
|
2006-06-08 14:32:20 +00:00
|
|
|
#include "nsStyleSheetService.h"
|
2007-03-20 12:14:52 +00:00
|
|
|
#include "gfxImageSurface.h"
|
|
|
|
#include "gfxContext.h"
|
2000-02-13 06:07:38 +00:00
|
|
|
|
1999-03-23 21:32:48 +00:00
|
|
|
// Drag & Drop, Clipboard
|
|
|
|
#include "nsWidgetsCID.h"
|
|
|
|
#include "nsIClipboard.h"
|
2001-05-10 02:35:00 +00:00
|
|
|
#include "nsIClipboardHelper.h"
|
1999-12-18 02:09:29 +00:00
|
|
|
#include "nsIDocShellTreeItem.h"
|
1999-11-09 03:23:26 +00:00
|
|
|
#include "nsIURI.h"
|
1999-12-07 05:28:32 +00:00
|
|
|
#include "nsIScrollableFrame.h"
|
1999-12-23 02:02:33 +00:00
|
|
|
#include "prtime.h"
|
|
|
|
#include "prlong.h"
|
2000-06-14 23:18:54 +00:00
|
|
|
#include "nsIDragService.h"
|
2001-02-15 13:22:26 +00:00
|
|
|
#include "nsCopySupport.h"
|
2001-04-18 06:06:31 +00:00
|
|
|
#include "nsIDOMHTMLAnchorElement.h"
|
2001-09-12 23:31:37 +00:00
|
|
|
#include "nsIDOMHTMLAreaElement.h"
|
|
|
|
#include "nsIDOMHTMLLinkElement.h"
|
2001-04-17 23:25:21 +00:00
|
|
|
#include "nsITimer.h"
|
2003-04-15 08:45:55 +00:00
|
|
|
#ifdef ACCESSIBILITY
|
|
|
|
#include "nsIAccessibilityService.h"
|
|
|
|
#include "nsIAccessible.h"
|
2005-06-10 13:57:27 +00:00
|
|
|
#include "nsIAccessibleEvent.h"
|
2003-04-15 08:45:55 +00:00
|
|
|
#endif
|
2000-06-14 23:18:54 +00:00
|
|
|
|
2001-12-17 22:51:39 +00:00
|
|
|
// For style data reconstruction
|
|
|
|
#include "nsStyleChangeList.h"
|
2004-01-07 22:30:53 +00:00
|
|
|
#include "nsCSSFrameConstructor.h"
|
2003-04-11 00:56:27 +00:00
|
|
|
#ifdef MOZ_XUL
|
2007-07-04 15:49:38 +00:00
|
|
|
#include "nsMenuFrame.h"
|
2002-03-29 02:46:01 +00:00
|
|
|
#include "nsITreeBoxObject.h"
|
2003-04-11 00:56:27 +00:00
|
|
|
#endif
|
2007-04-20 18:20:03 +00:00
|
|
|
#include "nsIMenuParent.h"
|
2001-12-17 22:51:39 +00:00
|
|
|
#include "nsPlaceholderFrame.h"
|
|
|
|
|
2001-05-01 22:54:11 +00:00
|
|
|
// Content viewer interfaces
|
|
|
|
#include "nsIContentViewer.h"
|
2007-05-23 00:11:05 +00:00
|
|
|
#include "imgIEncoder.h"
|
|
|
|
#include "gfxPlatform.h"
|
2001-05-01 22:54:11 +00:00
|
|
|
|
2001-02-19 21:50:04 +00:00
|
|
|
#include "nsContentCID.h"
|
|
|
|
static NS_DEFINE_CID(kCSSStyleSheetCID, NS_CSS_STYLESHEET_CID);
|
2001-03-27 23:59:56 +00:00
|
|
|
static NS_DEFINE_IID(kRangeCID, NS_RANGE_CID);
|
2001-02-19 21:50:04 +00:00
|
|
|
|
2007-05-04 02:19:18 +00:00
|
|
|
PRBool nsIPresShell::gIsAccessibilityActive = PR_FALSE;
|
|
|
|
|
2000-10-11 08:33:01 +00:00
|
|
|
// convert a color value to a string, in the CSS format #RRGGBB
|
|
|
|
// * - initially created for bugs 31816, 20760, 22963
|
|
|
|
static void ColorToString(nscolor aColor, nsAutoString &aString);
|
|
|
|
|
2000-01-04 20:24:09 +00:00
|
|
|
// Class ID's
|
|
|
|
static NS_DEFINE_CID(kFrameSelectionCID, NS_FRAMESELECTION_CID);
|
1999-03-23 21:32:48 +00:00
|
|
|
|
2007-03-20 12:14:52 +00:00
|
|
|
// RangePaintInfo is used to paint ranges to offscreen buffers
|
|
|
|
struct RangePaintInfo {
|
|
|
|
nsCOMPtr<nsIRange> mRange;
|
|
|
|
nsDisplayListBuilder mBuilder;
|
|
|
|
nsDisplayList mList;
|
|
|
|
|
|
|
|
// offset of builder's reference frame to the root frame
|
|
|
|
nsPoint mRootOffset;
|
|
|
|
|
|
|
|
RangePaintInfo(nsIRange* aRange, nsIFrame* aFrame)
|
|
|
|
: mRange(aRange), mBuilder(aFrame, PR_FALSE, PR_FALSE)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
~RangePaintInfo()
|
|
|
|
{
|
|
|
|
mList.DeleteAll();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
1998-04-13 20:24:54 +00:00
|
|
|
#undef NOISY
|
|
|
|
|
2002-05-10 18:22:41 +00:00
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
|
|
|
|
#ifdef NS_DEBUG
|
|
|
|
// Set the environment variable GECKO_VERIFY_REFLOW_FLAGS to one or
|
|
|
|
// more of the following flags (comma separated) for handy debug
|
|
|
|
// output.
|
|
|
|
static PRUint32 gVerifyReflowFlags;
|
|
|
|
|
|
|
|
struct VerifyReflowFlags {
|
2004-01-21 04:15:00 +00:00
|
|
|
const char* name;
|
2002-05-10 18:22:41 +00:00
|
|
|
PRUint32 bit;
|
|
|
|
};
|
|
|
|
|
2004-01-21 04:15:00 +00:00
|
|
|
static const VerifyReflowFlags gFlags[] = {
|
2002-05-10 18:22:41 +00:00
|
|
|
{ "verify", VERIFY_REFLOW_ON },
|
|
|
|
{ "reflow", VERIFY_REFLOW_NOISY },
|
|
|
|
{ "all", VERIFY_REFLOW_ALL },
|
|
|
|
{ "list-commands", VERIFY_REFLOW_DUMP_COMMANDS },
|
|
|
|
{ "noisy-commands", VERIFY_REFLOW_NOISY_RC },
|
|
|
|
{ "really-noisy-commands", VERIFY_REFLOW_REALLY_NOISY_RC },
|
|
|
|
{ "space-manager", VERIFY_REFLOW_INCLUDE_SPACE_MANAGER },
|
|
|
|
{ "resize", VERIFY_REFLOW_DURING_RESIZE_REFLOW },
|
|
|
|
};
|
|
|
|
|
|
|
|
#define NUM_VERIFY_REFLOW_FLAGS (sizeof(gFlags) / sizeof(gFlags[0]))
|
|
|
|
|
|
|
|
static void
|
|
|
|
ShowVerifyReflowFlags()
|
|
|
|
{
|
|
|
|
printf("Here are the available GECKO_VERIFY_REFLOW_FLAGS:\n");
|
2004-01-21 04:15:00 +00:00
|
|
|
const VerifyReflowFlags* flag = gFlags;
|
|
|
|
const VerifyReflowFlags* limit = gFlags + NUM_VERIFY_REFLOW_FLAGS;
|
2002-05-10 18:22:41 +00:00
|
|
|
while (flag < limit) {
|
|
|
|
printf(" %s\n", flag->name);
|
|
|
|
++flag;
|
|
|
|
}
|
|
|
|
printf("Note: GECKO_VERIFY_REFLOW_FLAGS is a comma separated list of flag\n");
|
|
|
|
printf("names (no whitespace)\n");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-03-13 01:47:22 +00:00
|
|
|
//========================================================================
|
|
|
|
//========================================================================
|
2000-04-26 21:01:57 +00:00
|
|
|
//========================================================================
|
|
|
|
#ifdef MOZ_REFLOW_PERF
|
|
|
|
class ReflowCountMgr;
|
|
|
|
|
2003-05-27 03:52:33 +00:00
|
|
|
static const char kGrandTotalsStr[] = "Grand Totals";
|
2000-04-26 21:01:57 +00:00
|
|
|
|
|
|
|
// Counting Class
|
|
|
|
class ReflowCounter {
|
|
|
|
public:
|
2001-02-22 13:58:17 +00:00
|
|
|
ReflowCounter(ReflowCountMgr * aMgr = nsnull);
|
2000-04-26 21:01:57 +00:00
|
|
|
~ReflowCounter();
|
|
|
|
|
|
|
|
void ClearTotals();
|
|
|
|
void DisplayTotals(const char * aStr);
|
2000-04-28 23:32:04 +00:00
|
|
|
void DisplayDiffTotals(const char * aStr);
|
2000-04-26 21:01:57 +00:00
|
|
|
void DisplayHTMLTotals(const char * aStr);
|
|
|
|
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
void Add() { mTotal++; }
|
|
|
|
void Add(PRUint32 aTotal) { mTotal += aTotal; }
|
2000-04-28 23:32:04 +00:00
|
|
|
|
|
|
|
void CalcDiffInTotals();
|
|
|
|
void SetTotalsCache();
|
|
|
|
|
|
|
|
void SetMgr(ReflowCountMgr * aMgr) { mMgr = aMgr; }
|
2000-04-26 21:01:57 +00:00
|
|
|
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
PRUint32 GetTotal() { return mTotal; }
|
2001-02-22 13:58:17 +00:00
|
|
|
|
2000-04-26 21:01:57 +00:00
|
|
|
protected:
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
void DisplayTotals(PRUint32 aTotal, const char * aTitle);
|
|
|
|
void DisplayHTMLTotals(PRUint32 aTotal, const char * aTitle);
|
2000-04-26 21:01:57 +00:00
|
|
|
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
PRUint32 mTotal;
|
|
|
|
PRUint32 mCacheTotal;
|
2000-04-28 23:32:04 +00:00
|
|
|
|
2001-03-13 01:47:22 +00:00
|
|
|
ReflowCountMgr * mMgr; // weak reference (don't delete)
|
2000-04-26 21:01:57 +00:00
|
|
|
};
|
|
|
|
|
2001-02-22 13:58:17 +00:00
|
|
|
// Counting Class
|
|
|
|
class IndiReflowCounter {
|
|
|
|
public:
|
2001-10-25 03:21:53 +00:00
|
|
|
IndiReflowCounter(ReflowCountMgr * aMgr = nsnull)
|
|
|
|
: mFrame(nsnull),
|
|
|
|
mCount(0),
|
|
|
|
mMgr(aMgr),
|
|
|
|
mCounter(aMgr),
|
|
|
|
mHasBeenOutput(PR_FALSE)
|
|
|
|
{}
|
2001-02-22 13:58:17 +00:00
|
|
|
virtual ~IndiReflowCounter() {}
|
|
|
|
|
|
|
|
nsAutoString mName;
|
2001-03-13 01:47:22 +00:00
|
|
|
nsIFrame * mFrame; // weak reference (don't delete)
|
2001-02-22 13:58:17 +00:00
|
|
|
PRInt32 mCount;
|
|
|
|
|
2001-03-13 01:47:22 +00:00
|
|
|
ReflowCountMgr * mMgr; // weak reference (don't delete)
|
2001-02-22 13:58:17 +00:00
|
|
|
|
|
|
|
ReflowCounter mCounter;
|
|
|
|
PRBool mHasBeenOutput;
|
|
|
|
|
|
|
|
};
|
|
|
|
|
2001-03-13 01:47:22 +00:00
|
|
|
//--------------------
|
2000-04-26 21:01:57 +00:00
|
|
|
// Manager Class
|
2001-03-13 01:47:22 +00:00
|
|
|
//--------------------
|
2000-04-26 21:01:57 +00:00
|
|
|
class ReflowCountMgr {
|
|
|
|
public:
|
|
|
|
ReflowCountMgr();
|
2001-03-13 01:47:22 +00:00
|
|
|
virtual ~ReflowCountMgr();
|
2000-04-26 21:01:57 +00:00
|
|
|
|
|
|
|
void ClearTotals();
|
2000-04-28 23:32:04 +00:00
|
|
|
void ClearGrandTotals();
|
2000-04-26 21:01:57 +00:00
|
|
|
void DisplayTotals(const char * aStr);
|
|
|
|
void DisplayHTMLTotals(const char * aStr);
|
2000-04-28 23:32:04 +00:00
|
|
|
void DisplayDiffsInTotals(const char * aStr);
|
2000-04-26 21:01:57 +00:00
|
|
|
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
void Add(const char * aName, nsIFrame * aFrame);
|
2000-04-26 21:01:57 +00:00
|
|
|
ReflowCounter * LookUp(const char * aName);
|
|
|
|
|
2004-07-31 23:15:21 +00:00
|
|
|
void PaintCount(const char * aName, nsIRenderingContext* aRenderingContext, nsPresContext* aPresContext, nsIFrame * aFrame, PRUint32 aColor);
|
2001-03-13 01:47:22 +00:00
|
|
|
|
2000-04-26 21:01:57 +00:00
|
|
|
FILE * GetOutFile() { return mFD; }
|
|
|
|
|
2001-02-22 13:58:17 +00:00
|
|
|
PLHashTable * GetIndiFrameHT() { return mIndiFrameCounts; }
|
|
|
|
|
2004-07-31 23:15:21 +00:00
|
|
|
void SetPresContext(nsPresContext * aPresContext) { mPresContext = aPresContext; } // weak reference
|
2001-03-13 01:47:22 +00:00
|
|
|
void SetPresShell(nsIPresShell* aPresShell) { mPresShell= aPresShell; } // weak reference
|
|
|
|
|
|
|
|
void SetDumpFrameCounts(PRBool aVal) { mDumpFrameCounts = aVal; }
|
|
|
|
void SetDumpFrameByFrameCounts(PRBool aVal) { mDumpFrameByFrameCounts = aVal; }
|
|
|
|
void SetPaintFrameCounts(PRBool aVal) { mPaintFrameByFrameCounts = aVal; }
|
2001-02-22 13:58:17 +00:00
|
|
|
|
2000-04-26 21:01:57 +00:00
|
|
|
protected:
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
void DisplayTotals(PRUint32 aTotal, PRUint32 * aDupArray, char * aTitle);
|
|
|
|
void DisplayHTMLTotals(PRUint32 aTotal, PRUint32 * aDupArray, char * aTitle);
|
2000-04-26 21:01:57 +00:00
|
|
|
|
2001-03-14 23:57:37 +00:00
|
|
|
PR_STATIC_CALLBACK(PRIntn) RemoveItems(PLHashEntry *he, PRIntn i, void *arg);
|
|
|
|
PR_STATIC_CALLBACK(PRIntn) RemoveIndiItems(PLHashEntry *he, PRIntn i, void *arg);
|
2000-04-26 21:01:57 +00:00
|
|
|
void CleanUp();
|
|
|
|
|
|
|
|
// stdout Output Methods
|
2001-03-14 23:57:37 +00:00
|
|
|
PR_STATIC_CALLBACK(PRIntn) DoSingleTotal(PLHashEntry *he, PRIntn i, void *arg);
|
|
|
|
PR_STATIC_CALLBACK(PRIntn) DoSingleIndi(PLHashEntry *he, PRIntn i, void *arg);
|
2001-02-22 13:58:17 +00:00
|
|
|
|
2000-04-26 21:01:57 +00:00
|
|
|
void DoGrandTotals();
|
2001-02-22 13:58:17 +00:00
|
|
|
void DoIndiTotalsTree();
|
2000-04-26 21:01:57 +00:00
|
|
|
|
|
|
|
// HTML Output Methods
|
2001-03-14 23:57:37 +00:00
|
|
|
PR_STATIC_CALLBACK(PRIntn) DoSingleHTMLTotal(PLHashEntry *he, PRIntn i, void *arg);
|
2000-04-26 21:01:57 +00:00
|
|
|
void DoGrandHTMLTotals();
|
|
|
|
|
2000-04-28 23:32:04 +00:00
|
|
|
// Zero Out the Totals
|
2001-03-14 23:57:37 +00:00
|
|
|
PR_STATIC_CALLBACK(PRIntn) DoClearTotals(PLHashEntry *he, PRIntn i, void *arg);
|
2000-04-28 23:32:04 +00:00
|
|
|
|
|
|
|
// Displays the Diff Totals
|
2001-03-14 23:57:37 +00:00
|
|
|
PR_STATIC_CALLBACK(PRIntn) DoDisplayDiffTotals(PLHashEntry *he, PRIntn i, void *arg);
|
2000-04-28 23:32:04 +00:00
|
|
|
|
2000-04-26 21:01:57 +00:00
|
|
|
PLHashTable * mCounts;
|
2001-02-22 13:58:17 +00:00
|
|
|
PLHashTable * mIndiFrameCounts;
|
2000-04-26 21:01:57 +00:00
|
|
|
FILE * mFD;
|
2001-02-22 13:58:17 +00:00
|
|
|
|
2001-03-13 01:47:22 +00:00
|
|
|
PRBool mDumpFrameCounts;
|
|
|
|
PRBool mDumpFrameByFrameCounts;
|
|
|
|
PRBool mPaintFrameByFrameCounts;
|
|
|
|
|
2000-04-28 23:32:04 +00:00
|
|
|
PRBool mCycledOnce;
|
|
|
|
|
2001-02-22 13:58:17 +00:00
|
|
|
// Root Frame for Individual Tracking
|
2004-07-31 23:15:21 +00:00
|
|
|
nsPresContext * mPresContext;
|
2001-02-22 13:58:17 +00:00
|
|
|
nsIPresShell* mPresShell;
|
|
|
|
|
2000-04-26 21:01:57 +00:00
|
|
|
// ReflowCountMgr gReflowCountMgr;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
//========================================================================
|
|
|
|
|
1999-02-12 00:02:56 +00:00
|
|
|
// comment out to hide caret
|
1999-03-02 04:26:49 +00:00
|
|
|
#define SHOW_CARET
|
1999-02-12 00:02:56 +00:00
|
|
|
|
2002-05-10 18:22:41 +00:00
|
|
|
// The upper bound on the amount of time to spend reflowing, in
|
|
|
|
// microseconds. When this bound is exceeded and reflow commands are
|
|
|
|
// still queued up, a reflow event is posted. The idea is for reflow
|
|
|
|
// to not hog the processor beyond the time specifed in
|
|
|
|
// gMaxRCProcessingTime. This data member is initialized from the
|
|
|
|
// layout.reflow.timeslice pref.
|
1999-12-23 02:02:33 +00:00
|
|
|
#define NS_MAX_REFLOW_TIME 1000000
|
1999-12-23 03:47:02 +00:00
|
|
|
static PRInt32 gMaxRCProcessingTime = -1;
|
1999-12-23 02:02:33 +00:00
|
|
|
|
1999-12-07 04:36:08 +00:00
|
|
|
// Largest chunk size we recycle
|
2000-03-31 07:02:06 +00:00
|
|
|
static const size_t gMaxRecycledSize = 400;
|
1999-12-07 04:36:08 +00:00
|
|
|
|
2000-03-31 07:02:06 +00:00
|
|
|
#define MARK_INCREMENT 50
|
2002-08-06 13:51:07 +00:00
|
|
|
#define BLOCK_INCREMENT 4044 /* a bit under 4096, for malloc overhead */
|
2000-03-31 07:02:06 +00:00
|
|
|
|
|
|
|
/**A block of memory that the stack will
|
|
|
|
* chop up and hand out
|
|
|
|
*/
|
|
|
|
struct StackBlock {
|
|
|
|
|
2002-08-06 13:51:07 +00:00
|
|
|
// a block of memory. Note that this must be first so that it will
|
|
|
|
// be aligned.
|
|
|
|
char mBlock[BLOCK_INCREMENT];
|
2000-03-31 07:02:06 +00:00
|
|
|
|
|
|
|
// another block of memory that would only be created
|
|
|
|
// if our stack overflowed. Yes we have the ability
|
|
|
|
// to grow on a stack overflow
|
|
|
|
StackBlock* mNext;
|
2002-08-06 13:51:07 +00:00
|
|
|
|
|
|
|
StackBlock() : mNext(nsnull) { }
|
|
|
|
~StackBlock() { }
|
2000-03-31 07:02:06 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* we hold an array of marks. A push pushes a mark on the stack
|
|
|
|
* a pop pops it off.
|
|
|
|
*/
|
|
|
|
struct StackMark {
|
|
|
|
// the block of memory we are currently handing out chunks of
|
|
|
|
StackBlock* mBlock;
|
|
|
|
|
|
|
|
// our current position in the memory
|
|
|
|
size_t mPos;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/* A stack arena allows a stack based interface to a block of memory.
|
|
|
|
* It should be used when you need to allocate some temporary memory that
|
|
|
|
* you will immediately return.
|
|
|
|
*/
|
|
|
|
class StackArena {
|
|
|
|
public:
|
|
|
|
StackArena();
|
|
|
|
~StackArena();
|
|
|
|
|
2007-01-17 23:53:47 +00:00
|
|
|
nsresult Init() { return mBlocks ? NS_OK : NS_ERROR_OUT_OF_MEMORY; }
|
|
|
|
|
2000-03-31 07:02:06 +00:00
|
|
|
// Memory management functions
|
2007-01-17 23:53:47 +00:00
|
|
|
void* Allocate(size_t aSize);
|
|
|
|
void Push();
|
|
|
|
void Pop();
|
2000-03-31 07:02:06 +00:00
|
|
|
|
|
|
|
private:
|
|
|
|
// our current position in memory
|
|
|
|
size_t mPos;
|
|
|
|
|
|
|
|
// a list of memory block. Usually there is only one
|
|
|
|
// but if we overrun our stack size we can get more memory.
|
|
|
|
StackBlock* mBlocks;
|
|
|
|
|
|
|
|
// the current block of memory we are passing our chucks of
|
|
|
|
StackBlock* mCurBlock;
|
|
|
|
|
|
|
|
// our stack of mark where push has been called
|
|
|
|
StackMark* mMarks;
|
|
|
|
|
2005-11-20 22:05:24 +00:00
|
|
|
// the current top of the mark list
|
2000-03-31 07:02:06 +00:00
|
|
|
PRUint32 mStackTop;
|
|
|
|
|
|
|
|
// the size of the mark array
|
|
|
|
PRUint32 mMarkLength;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
StackArena::StackArena()
|
|
|
|
{
|
2007-01-17 23:53:47 +00:00
|
|
|
mMarkLength = 0;
|
|
|
|
mMarks = nsnull;
|
2000-03-31 07:02:06 +00:00
|
|
|
|
|
|
|
// allocate our stack memory
|
|
|
|
mBlocks = new StackBlock();
|
|
|
|
mCurBlock = mBlocks;
|
|
|
|
|
|
|
|
mStackTop = 0;
|
|
|
|
mPos = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
StackArena::~StackArena()
|
|
|
|
{
|
|
|
|
// free up our data
|
|
|
|
delete[] mMarks;
|
|
|
|
while(mBlocks)
|
|
|
|
{
|
|
|
|
StackBlock* toDelete = mBlocks;
|
|
|
|
mBlocks = mBlocks->mNext;
|
|
|
|
delete toDelete;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-01-17 23:53:47 +00:00
|
|
|
void
|
2000-03-31 07:02:06 +00:00
|
|
|
StackArena::Push()
|
|
|
|
{
|
2007-01-17 23:53:47 +00:00
|
|
|
// Resize the mark array if we overrun it. Failure to allocate the
|
|
|
|
// mark array is not fatal; we just won't free to that mark. This
|
|
|
|
// allows callers not to worry about error checking.
|
|
|
|
if (mStackTop >= mMarkLength)
|
2000-03-31 07:02:06 +00:00
|
|
|
{
|
2007-01-17 23:53:47 +00:00
|
|
|
PRUint32 newLength = mStackTop + MARK_INCREMENT;
|
|
|
|
StackMark* newMarks = new StackMark[newLength];
|
|
|
|
if (newMarks) {
|
|
|
|
if (mMarkLength)
|
|
|
|
memcpy(newMarks, mMarks, sizeof(StackMark)*mMarkLength);
|
|
|
|
// Fill in any marks that we couldn't allocate during a prior call
|
|
|
|
// to Push().
|
|
|
|
for (; mMarkLength < mStackTop; ++mMarkLength) {
|
|
|
|
NS_NOTREACHED("should only hit this on out-of-memory");
|
|
|
|
newMarks[mMarkLength].mBlock = mCurBlock;
|
|
|
|
newMarks[mMarkLength].mPos = mPos;
|
|
|
|
}
|
|
|
|
delete [] mMarks;
|
|
|
|
mMarks = newMarks;
|
|
|
|
mMarkLength = newLength;
|
|
|
|
}
|
2000-03-31 07:02:06 +00:00
|
|
|
}
|
|
|
|
|
2007-01-17 23:53:47 +00:00
|
|
|
// set a mark at the top (if we can)
|
|
|
|
NS_ASSERTION(mStackTop < mMarkLength, "out of memory");
|
|
|
|
if (mStackTop < mMarkLength) {
|
|
|
|
mMarks[mStackTop].mBlock = mCurBlock;
|
|
|
|
mMarks[mStackTop].mPos = mPos;
|
|
|
|
}
|
2000-03-31 07:02:06 +00:00
|
|
|
|
|
|
|
mStackTop++;
|
|
|
|
}
|
|
|
|
|
2007-01-17 23:53:47 +00:00
|
|
|
void*
|
|
|
|
StackArena::Allocate(size_t aSize)
|
2000-03-31 07:02:06 +00:00
|
|
|
{
|
2007-01-17 23:53:47 +00:00
|
|
|
NS_ASSERTION(mStackTop > 0, "Allocate called without Push");
|
2000-03-31 07:02:06 +00:00
|
|
|
|
|
|
|
// make sure we are aligned. Beard said 8 was safer then 4.
|
|
|
|
// Round size to multiple of 8
|
|
|
|
aSize = PR_ROUNDUP(aSize, 8);
|
|
|
|
|
|
|
|
// if the size makes the stack overflow. Grab another block for the stack
|
|
|
|
if (mPos + aSize >= BLOCK_INCREMENT)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aSize <= BLOCK_INCREMENT,"Requested memory is greater that our block size!!");
|
|
|
|
if (mCurBlock->mNext == nsnull)
|
|
|
|
mCurBlock->mNext = new StackBlock();
|
|
|
|
|
|
|
|
mCurBlock = mCurBlock->mNext;
|
|
|
|
mPos = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// return the chunk they need.
|
2007-01-17 23:53:47 +00:00
|
|
|
void *result = mCurBlock->mBlock + mPos;
|
2000-03-31 07:02:06 +00:00
|
|
|
mPos += aSize;
|
|
|
|
|
2007-01-17 23:53:47 +00:00
|
|
|
return result;
|
2000-03-31 07:02:06 +00:00
|
|
|
}
|
|
|
|
|
2007-01-17 23:53:47 +00:00
|
|
|
void
|
2000-03-31 07:02:06 +00:00
|
|
|
StackArena::Pop()
|
|
|
|
{
|
|
|
|
// pop off the mark
|
2007-01-17 23:53:47 +00:00
|
|
|
NS_ASSERTION(mStackTop > 0, "unmatched pop");
|
2000-03-31 07:02:06 +00:00
|
|
|
mStackTop--;
|
2002-08-14 12:49:24 +00:00
|
|
|
|
2007-01-17 23:53:47 +00:00
|
|
|
if (mStackTop >= mMarkLength) {
|
|
|
|
// We couldn't allocate the marks array at the time of the push, so
|
|
|
|
// we don't know where we're freeing to.
|
|
|
|
NS_NOTREACHED("out of memory");
|
|
|
|
if (mStackTop == 0) {
|
|
|
|
// But we do know if we've completely pushed the stack.
|
|
|
|
mCurBlock = mBlocks;
|
|
|
|
mPos = 0;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2002-08-14 12:49:24 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
// Mark the "freed" memory with 0xdd to help with debugging of memory
|
|
|
|
// allocation problems.
|
|
|
|
{
|
|
|
|
StackBlock *block = mMarks[mStackTop].mBlock, *block_end = mCurBlock;
|
|
|
|
size_t pos = mMarks[mStackTop].mPos;
|
|
|
|
for (; block != block_end; block = block->mNext, pos = 0) {
|
|
|
|
memset(block->mBlock + pos, 0xdd, sizeof(block->mBlock) - pos);
|
|
|
|
}
|
|
|
|
memset(block->mBlock + pos, 0xdd, mPos - pos);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2000-03-31 07:02:06 +00:00
|
|
|
mCurBlock = mMarks[mStackTop].mBlock;
|
|
|
|
mPos = mMarks[mStackTop].mPos;
|
|
|
|
}
|
|
|
|
|
2001-12-21 00:16:26 +00:00
|
|
|
// Uncomment this to disable the frame arena.
|
|
|
|
//#define DEBUG_TRACEMALLOC_FRAMEARENA 1
|
2000-03-31 07:02:06 +00:00
|
|
|
|
1999-12-07 04:36:08 +00:00
|
|
|
// Memory is allocated 4-byte aligned. We have recyclers for chunks up to
|
|
|
|
// 200 bytes
|
|
|
|
class FrameArena {
|
|
|
|
public:
|
2000-03-31 04:11:28 +00:00
|
|
|
FrameArena(PRUint32 aArenaSize = 4096);
|
1999-12-07 04:36:08 +00:00
|
|
|
~FrameArena();
|
|
|
|
|
|
|
|
// Memory management functions
|
2004-04-13 00:28:44 +00:00
|
|
|
NS_HIDDEN_(void*) AllocateFrame(size_t aSize);
|
|
|
|
NS_HIDDEN_(void) FreeFrame(size_t aSize, void* aPtr);
|
1999-12-07 04:36:08 +00:00
|
|
|
|
|
|
|
private:
|
2006-08-26 04:22:24 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
// Number of frames in the pool
|
|
|
|
PRUint32 mFrameCount;
|
|
|
|
#endif
|
|
|
|
|
2001-12-21 00:16:26 +00:00
|
|
|
#if !defined(DEBUG_TRACEMALLOC_FRAMEARENA)
|
1999-12-07 04:36:08 +00:00
|
|
|
// Underlying arena pool
|
|
|
|
PLArenaPool mPool;
|
|
|
|
|
|
|
|
// The recycler array is sparse with the indices being multiples of 4,
|
|
|
|
// i.e., 0, 4, 8, 12, 16, 20, ...
|
|
|
|
void* mRecyclers[gMaxRecycledSize >> 2];
|
2001-12-21 00:16:26 +00:00
|
|
|
#endif
|
1999-12-07 04:36:08 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
FrameArena::FrameArena(PRUint32 aArenaSize)
|
2006-08-26 04:22:24 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
: mFrameCount(0)
|
|
|
|
#endif
|
1999-12-07 04:36:08 +00:00
|
|
|
{
|
2001-12-21 00:16:26 +00:00
|
|
|
#if !defined(DEBUG_TRACEMALLOC_FRAMEARENA)
|
1999-12-07 04:36:08 +00:00
|
|
|
// Initialize the arena pool
|
|
|
|
PL_INIT_ARENA_POOL(&mPool, "FrameArena", aArenaSize);
|
|
|
|
|
|
|
|
// Zero out the recyclers array
|
2002-02-05 01:41:13 +00:00
|
|
|
memset(mRecyclers, 0, sizeof(mRecyclers));
|
2001-12-21 00:16:26 +00:00
|
|
|
#endif
|
1999-12-07 04:36:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
FrameArena::~FrameArena()
|
|
|
|
{
|
2007-07-03 22:49:00 +00:00
|
|
|
NS_ASSERTION(mFrameCount == 0,
|
|
|
|
"Some objects allocated with AllocateFrame were not freed");
|
2006-08-26 04:22:24 +00:00
|
|
|
|
2001-12-21 00:16:26 +00:00
|
|
|
#if !defined(DEBUG_TRACEMALLOC_FRAMEARENA)
|
1999-12-07 04:36:08 +00:00
|
|
|
// Free the arena in the pool and finish using it
|
|
|
|
PL_FinishArenaPool(&mPool);
|
2001-12-21 00:16:26 +00:00
|
|
|
#endif
|
2000-03-31 07:02:06 +00:00
|
|
|
}
|
1999-12-07 04:36:08 +00:00
|
|
|
|
2004-04-13 00:28:44 +00:00
|
|
|
void*
|
|
|
|
FrameArena::AllocateFrame(size_t aSize)
|
1999-12-07 04:36:08 +00:00
|
|
|
{
|
2006-08-26 04:22:24 +00:00
|
|
|
void* result = nsnull;
|
|
|
|
|
2001-12-21 00:16:26 +00:00
|
|
|
#if defined(DEBUG_TRACEMALLOC_FRAMEARENA)
|
2006-08-26 04:22:24 +00:00
|
|
|
|
|
|
|
result = PR_Malloc(aSize);
|
|
|
|
|
2001-12-21 00:16:26 +00:00
|
|
|
#else
|
2006-08-26 04:22:24 +00:00
|
|
|
|
2001-06-26 01:19:05 +00:00
|
|
|
// Ensure we have correct alignment for pointers. Important for Tru64
|
|
|
|
aSize = PR_ROUNDUP(aSize, sizeof(void*));
|
1999-12-07 04:36:08 +00:00
|
|
|
|
|
|
|
// Check recyclers first
|
|
|
|
if (aSize < gMaxRecycledSize) {
|
|
|
|
const int index = aSize >> 2;
|
|
|
|
|
|
|
|
result = mRecyclers[index];
|
|
|
|
if (result) {
|
|
|
|
// Need to move to the next object
|
|
|
|
void* next = *((void**)result);
|
|
|
|
mRecyclers[index] = next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!result) {
|
|
|
|
// Allocate a new chunk from the arena
|
|
|
|
PL_ARENA_ALLOCATE(result, &mPool, aSize);
|
|
|
|
}
|
|
|
|
|
2001-12-21 00:16:26 +00:00
|
|
|
#endif
|
2006-08-26 04:22:24 +00:00
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
if (result != nsnull)
|
|
|
|
++mFrameCount;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return result;
|
1999-12-07 04:36:08 +00:00
|
|
|
}
|
|
|
|
|
2004-04-13 00:28:44 +00:00
|
|
|
void
|
1999-12-07 04:36:08 +00:00
|
|
|
FrameArena::FreeFrame(size_t aSize, void* aPtr)
|
|
|
|
{
|
2002-08-06 13:57:16 +00:00
|
|
|
#ifdef DEBUG
|
2006-08-26 04:22:24 +00:00
|
|
|
--mFrameCount;
|
|
|
|
|
2002-08-06 13:57:16 +00:00
|
|
|
// Mark the memory with 0xdd in DEBUG builds so that there will be
|
|
|
|
// problems if someone tries to access memory that they've freed.
|
|
|
|
memset(aPtr, 0xdd, aSize);
|
|
|
|
#endif
|
2001-12-21 00:16:26 +00:00
|
|
|
#if defined(DEBUG_TRACEMALLOC_FRAMEARENA)
|
|
|
|
PR_Free(aPtr);
|
|
|
|
#else
|
2001-06-26 01:19:05 +00:00
|
|
|
// Ensure we have correct alignment for pointers. Important for Tru64
|
|
|
|
aSize = PR_ROUNDUP(aSize, sizeof(void*));
|
1999-12-07 04:36:08 +00:00
|
|
|
|
|
|
|
// See if it's a size that we recycle
|
|
|
|
if (aSize < gMaxRecycledSize) {
|
|
|
|
const int index = aSize >> 2;
|
|
|
|
void* currentTop = mRecyclers[index];
|
|
|
|
mRecyclers[index] = aPtr;
|
|
|
|
*((void**)aPtr) = currentTop;
|
|
|
|
}
|
2003-02-22 19:26:30 +00:00
|
|
|
#ifdef DEBUG_dbaron
|
|
|
|
else {
|
|
|
|
fprintf(stderr,
|
|
|
|
"WARNING: FrameArena::FreeFrame leaking chunk of %d bytes.\n",
|
|
|
|
aSize);
|
|
|
|
}
|
|
|
|
#endif
|
2001-12-21 00:16:26 +00:00
|
|
|
#endif
|
1999-12-07 04:36:08 +00:00
|
|
|
}
|
|
|
|
|
2000-07-13 23:00:59 +00:00
|
|
|
struct nsCallbackEventRequest
|
|
|
|
{
|
|
|
|
nsIReflowCallback* callback;
|
|
|
|
nsCallbackEventRequest* next;
|
|
|
|
};
|
|
|
|
|
2004-05-02 18:07:12 +00:00
|
|
|
// ----------------------------------------------------------------------------
|
2006-03-07 17:08:51 +00:00
|
|
|
class nsPresShellEventCB;
|
2008-03-14 23:08:57 +00:00
|
|
|
class nsAutoCauseReflowNotifier;
|
2004-05-02 18:07:12 +00:00
|
|
|
|
1998-08-28 02:54:06 +00:00
|
|
|
class PresShell : public nsIPresShell, public nsIViewObserver,
|
2004-09-01 05:16:00 +00:00
|
|
|
public nsStubDocumentObserver,
|
2004-07-18 01:16:27 +00:00
|
|
|
public nsISelectionController, public nsIObserver,
|
1999-10-22 00:19:18 +00:00
|
|
|
public nsSupportsWeakReference
|
1998-08-28 02:54:06 +00:00
|
|
|
{
|
1998-04-13 20:24:54 +00:00
|
|
|
public:
|
|
|
|
PresShell();
|
|
|
|
|
1999-02-26 20:02:06 +00:00
|
|
|
NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW
|
1999-02-26 17:08:48 +00:00
|
|
|
|
1998-04-13 20:24:54 +00:00
|
|
|
// nsISupports
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
|
|
|
|
// nsIPresShell
|
1998-06-03 15:46:54 +00:00
|
|
|
NS_IMETHOD Init(nsIDocument* aDocument,
|
2004-07-31 23:15:21 +00:00
|
|
|
nsPresContext* aPresContext,
|
1998-06-03 15:46:54 +00:00
|
|
|
nsIViewManager* aViewManager,
|
2004-01-07 22:30:53 +00:00
|
|
|
nsStyleSet* aStyleSet,
|
2002-06-25 21:16:17 +00:00
|
|
|
nsCompatibility aCompatMode);
|
2001-08-01 03:15:50 +00:00
|
|
|
NS_IMETHOD Destroy();
|
1999-12-04 23:49:50 +00:00
|
|
|
|
2004-04-13 00:28:44 +00:00
|
|
|
virtual NS_HIDDEN_(void*) AllocateFrame(size_t aSize);
|
|
|
|
virtual NS_HIDDEN_(void) FreeFrame(size_t aSize, void* aFreeChunk);
|
2000-03-31 07:02:06 +00:00
|
|
|
|
|
|
|
// Dynamic stack memory allocation
|
2007-01-17 23:53:47 +00:00
|
|
|
virtual NS_HIDDEN_(void) PushStackMemory();
|
|
|
|
virtual NS_HIDDEN_(void) PopStackMemory();
|
|
|
|
virtual NS_HIDDEN_(void*) AllocateStackMemory(size_t aSize);
|
2000-03-31 07:02:06 +00:00
|
|
|
|
2000-12-15 23:48:55 +00:00
|
|
|
NS_IMETHOD SetPreferenceStyleRules(PRBool aForceReflow);
|
2006-04-26 02:01:07 +00:00
|
|
|
|
2002-08-26 20:55:30 +00:00
|
|
|
NS_IMETHOD GetSelection(SelectionType aType, nsISelection** aSelection);
|
2006-04-26 02:01:07 +00:00
|
|
|
virtual nsISelection* GetCurrentSelection(SelectionType aType);
|
2002-08-26 20:55:30 +00:00
|
|
|
|
2000-04-28 06:21:31 +00:00
|
|
|
NS_IMETHOD SetDisplaySelection(PRInt16 aToggle);
|
|
|
|
NS_IMETHOD GetDisplaySelection(PRInt16 *aToggle);
|
2002-06-13 20:35:12 +00:00
|
|
|
NS_IMETHOD ScrollSelectionIntoView(SelectionType aType, SelectionRegion aRegion, PRBool aIsSynchronous);
|
1999-08-30 21:54:40 +00:00
|
|
|
NS_IMETHOD RepaintSelection(SelectionType aType);
|
1999-11-09 03:23:26 +00:00
|
|
|
|
1998-12-29 04:56:31 +00:00
|
|
|
NS_IMETHOD BeginObservingDocument();
|
|
|
|
NS_IMETHOD EndObservingDocument();
|
2002-09-06 05:44:31 +00:00
|
|
|
NS_IMETHOD GetDidInitialReflow(PRBool *aDidInitialReflow);
|
1998-09-10 19:32:14 +00:00
|
|
|
NS_IMETHOD InitialReflow(nscoord aWidth, nscoord aHeight);
|
1998-08-28 02:54:06 +00:00
|
|
|
NS_IMETHOD ResizeReflow(nscoord aWidth, nscoord aHeight);
|
1998-11-06 16:16:01 +00:00
|
|
|
NS_IMETHOD StyleChangeReflow();
|
1999-02-12 17:45:58 +00:00
|
|
|
NS_IMETHOD GetPageSequenceFrame(nsIPageSequenceFrame** aResult) const;
|
2005-08-22 22:24:29 +00:00
|
|
|
virtual NS_HIDDEN_(nsIFrame*) GetPrimaryFrameFor(nsIContent* aContent) const;
|
2008-01-30 04:17:57 +00:00
|
|
|
virtual NS_HIDDEN_(nsIFrame*) GetRealPrimaryFrameFor(nsIContent* aContent) const;
|
2002-08-26 20:55:30 +00:00
|
|
|
|
1999-02-10 23:21:22 +00:00
|
|
|
NS_IMETHOD GetLayoutObjectFor(nsIContent* aContent,
|
|
|
|
nsISupports** aResult) const;
|
1998-12-29 03:38:16 +00:00
|
|
|
NS_IMETHOD GetPlaceholderFrameFor(nsIFrame* aFrame,
|
1999-02-12 17:45:58 +00:00
|
|
|
nsIFrame** aPlaceholderFrame) const;
|
2007-05-06 19:16:51 +00:00
|
|
|
NS_IMETHOD FrameNeedsReflow(nsIFrame *aFrame, IntrinsicDirty aIntrinsicDirty,
|
2007-05-06 22:50:21 +00:00
|
|
|
nsFrameState aBitToAdd);
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
NS_IMETHOD CancelAllPendingReflows();
|
2000-10-17 05:07:39 +00:00
|
|
|
NS_IMETHOD IsSafeToFlush(PRBool& aIsSafeToFlush);
|
2004-05-27 22:08:42 +00:00
|
|
|
NS_IMETHOD FlushPendingNotifications(mozFlushType aType);
|
2000-04-17 07:13:57 +00:00
|
|
|
|
2002-10-22 06:07:52 +00:00
|
|
|
/**
|
|
|
|
* Recreates the frames for a node
|
|
|
|
*/
|
|
|
|
NS_IMETHOD RecreateFramesFor(nsIContent* aContent);
|
|
|
|
|
2000-07-13 23:00:59 +00:00
|
|
|
/**
|
|
|
|
* Post a callback that should be handled after reflow has finished.
|
|
|
|
*/
|
|
|
|
NS_IMETHOD PostReflowCallback(nsIReflowCallback* aCallback);
|
2000-10-07 00:49:08 +00:00
|
|
|
NS_IMETHOD CancelReflowCallback(nsIReflowCallback* aCallback);
|
2000-07-13 23:00:59 +00:00
|
|
|
|
1999-02-12 17:45:58 +00:00
|
|
|
NS_IMETHOD ClearFrameRefs(nsIFrame* aFrame);
|
|
|
|
NS_IMETHOD CreateRenderingContext(nsIFrame *aFrame,
|
|
|
|
nsIRenderingContext** aContext);
|
2003-01-13 23:10:53 +00:00
|
|
|
NS_IMETHOD GoToAnchor(const nsAString& aAnchorName, PRBool aScroll);
|
2008-02-27 10:01:17 +00:00
|
|
|
NS_IMETHOD ScrollToAnchor();
|
1998-08-28 02:54:06 +00:00
|
|
|
|
2007-03-06 09:53:56 +00:00
|
|
|
NS_IMETHOD ScrollContentIntoView(nsIContent* aContent,
|
|
|
|
PRIntn aVPercent,
|
|
|
|
PRIntn aHPercent) const;
|
|
|
|
|
2001-12-01 00:22:00 +00:00
|
|
|
NS_IMETHOD SetIgnoreFrameDestruction(PRBool aIgnore);
|
1999-07-16 23:27:46 +00:00
|
|
|
NS_IMETHOD NotifyDestroyingFrame(nsIFrame* aFrame);
|
1999-08-04 04:02:40 +00:00
|
|
|
|
1999-04-07 03:56:07 +00:00
|
|
|
NS_IMETHOD DoCopy();
|
2005-08-29 15:19:13 +00:00
|
|
|
NS_IMETHOD GetSelectionForCopy(nsISelection** outSelection);
|
|
|
|
|
2002-08-01 21:36:02 +00:00
|
|
|
NS_IMETHOD GetLinkLocation(nsIDOMNode* aNode, nsAString& aLocationString);
|
2003-04-22 18:11:12 +00:00
|
|
|
NS_IMETHOD DoGetContents(const nsACString& aMimeType, PRUint32 aFlags, PRBool aSelectionOnly, nsAString& outValue);
|
1999-08-31 14:35:50 +00:00
|
|
|
|
2000-06-15 00:35:46 +00:00
|
|
|
NS_IMETHOD CaptureHistoryState(nsILayoutHistoryState** aLayoutHistoryState, PRBool aLeavingPage);
|
1999-08-30 22:38:58 +00:00
|
|
|
|
2001-04-25 19:52:49 +00:00
|
|
|
NS_IMETHOD IsPaintingSuppressed(PRBool* aResult);
|
2001-05-01 22:54:11 +00:00
|
|
|
NS_IMETHOD UnsuppressPainting();
|
|
|
|
|
2002-09-21 01:03:38 +00:00
|
|
|
NS_IMETHOD DisableThemeSupport();
|
|
|
|
virtual PRBool IsThemeSupportEnabled();
|
|
|
|
|
2004-01-07 22:30:53 +00:00
|
|
|
virtual nsresult GetAgentStyleSheets(nsCOMArray<nsIStyleSheet>& aSheets);
|
|
|
|
virtual nsresult SetAgentStyleSheets(const nsCOMArray<nsIStyleSheet>& aSheets);
|
|
|
|
|
|
|
|
virtual nsresult AddOverrideStyleSheet(nsIStyleSheet *aSheet);
|
|
|
|
virtual nsresult RemoveOverrideStyleSheet(nsIStyleSheet *aSheet);
|
|
|
|
|
2006-03-07 17:08:51 +00:00
|
|
|
NS_IMETHOD HandleEventWithTarget(nsEvent* aEvent, nsIFrame* aFrame,
|
|
|
|
nsIContent* aContent,
|
|
|
|
nsEventStatus* aStatus);
|
2000-06-24 03:58:13 +00:00
|
|
|
NS_IMETHOD GetEventTargetFrame(nsIFrame** aFrame);
|
2003-02-14 21:43:06 +00:00
|
|
|
NS_IMETHOD GetEventTargetContent(nsEvent* aEvent, nsIContent** aContent);
|
2000-03-23 00:34:54 +00:00
|
|
|
|
2000-02-09 15:48:01 +00:00
|
|
|
NS_IMETHOD IsReflowLocked(PRBool* aIsLocked);
|
2004-01-21 23:05:10 +00:00
|
|
|
|
|
|
|
virtual nsresult ReconstructFrames(void);
|
2005-05-04 20:22:32 +00:00
|
|
|
virtual void Freeze();
|
2005-07-19 17:07:40 +00:00
|
|
|
virtual void Thaw();
|
2007-09-05 08:00:40 +00:00
|
|
|
|
|
|
|
virtual nsIFrame* GetFrameForPoint(nsIFrame* aFrame, nsPoint aPt);
|
|
|
|
|
2007-05-23 00:11:05 +00:00
|
|
|
NS_IMETHOD RenderDocument(const nsRect& aRect, PRBool aUntrusted,
|
|
|
|
PRBool aIgnoreViewportScrolling,
|
|
|
|
nscolor aBackgroundColor,
|
|
|
|
gfxContext* aThebesContext);
|
2004-01-21 23:05:10 +00:00
|
|
|
|
2007-03-20 12:14:52 +00:00
|
|
|
virtual already_AddRefed<gfxASurface> RenderNode(nsIDOMNode* aNode,
|
|
|
|
nsIRegion* aRegion,
|
|
|
|
nsPoint& aPoint,
|
|
|
|
nsRect* aScreenRect);
|
|
|
|
|
|
|
|
virtual already_AddRefed<gfxASurface> RenderSelection(nsISelection* aSelection,
|
|
|
|
nsPoint& aPoint,
|
|
|
|
nsRect* aScreenRect);
|
|
|
|
|
1998-08-28 02:54:06 +00:00
|
|
|
//nsIViewObserver interface
|
|
|
|
|
|
|
|
NS_IMETHOD Paint(nsIView *aView,
|
2006-01-26 02:29:17 +00:00
|
|
|
nsIRenderingContext* aRenderingContext,
|
|
|
|
const nsRegion& aDirtyRegion);
|
|
|
|
NS_IMETHOD ComputeRepaintRegionForCopy(nsIView* aRootView,
|
|
|
|
nsIView* aMovingView,
|
|
|
|
nsPoint aDelta,
|
|
|
|
const nsRect& aCopyRect,
|
|
|
|
nsRegion* aRepaintRegion);
|
1998-08-28 02:54:06 +00:00
|
|
|
NS_IMETHOD HandleEvent(nsIView* aView,
|
|
|
|
nsGUIEvent* aEvent,
|
2006-01-26 02:29:17 +00:00
|
|
|
nsEventStatus* aEventStatus);
|
2000-06-29 02:02:43 +00:00
|
|
|
NS_IMETHOD HandleDOMEventWithTarget(nsIContent* aTargetContent,
|
2006-03-07 17:08:51 +00:00
|
|
|
nsEvent* aEvent,
|
|
|
|
nsEventStatus* aStatus);
|
1998-08-28 02:54:06 +00:00
|
|
|
NS_IMETHOD ResizeReflow(nsIView *aView, nscoord aWidth, nscoord aHeight);
|
2004-10-14 21:51:00 +00:00
|
|
|
NS_IMETHOD_(PRBool) IsVisible();
|
2005-01-20 03:39:09 +00:00
|
|
|
NS_IMETHOD_(void) WillPaint();
|
1998-08-28 02:54:06 +00:00
|
|
|
|
1999-02-13 04:45:44 +00:00
|
|
|
// caret handling
|
1999-08-04 20:46:16 +00:00
|
|
|
NS_IMETHOD GetCaret(nsICaret **aOutCaret);
|
2006-11-07 01:35:36 +00:00
|
|
|
NS_IMETHOD_(void) MaybeInvalidateCaretPosition();
|
2000-05-11 04:25:43 +00:00
|
|
|
NS_IMETHOD SetCaretEnabled(PRBool aInEnable);
|
|
|
|
NS_IMETHOD SetCaretReadOnly(PRBool aReadOnly);
|
1999-08-04 20:46:16 +00:00
|
|
|
NS_IMETHOD GetCaretEnabled(PRBool *aOutEnabled);
|
2003-06-25 01:14:25 +00:00
|
|
|
NS_IMETHOD SetCaretVisibilityDuringSelection(PRBool aVisibility);
|
2008-04-08 18:52:48 +00:00
|
|
|
NS_IMETHOD GetCaretVisible(PRBool *_retval);
|
2007-09-22 21:06:58 +00:00
|
|
|
virtual void SetCaret(nsICaret *aNewCaret);
|
|
|
|
virtual void RestoreCaret();
|
1999-02-13 04:45:44 +00:00
|
|
|
|
2001-12-18 01:29:49 +00:00
|
|
|
NS_IMETHOD SetSelectionFlags(PRInt16 aInEnable);
|
|
|
|
NS_IMETHOD GetSelectionFlags(PRInt16 *aOutEnable);
|
1999-05-17 00:21:18 +00:00
|
|
|
|
1999-12-02 21:45:21 +00:00
|
|
|
// nsISelectionController
|
1999-10-22 00:19:18 +00:00
|
|
|
|
|
|
|
NS_IMETHOD CharacterMove(PRBool aForward, PRBool aExtend);
|
|
|
|
NS_IMETHOD WordMove(PRBool aForward, PRBool aExtend);
|
2006-07-18 07:28:38 +00:00
|
|
|
NS_IMETHOD WordExtendForDelete(PRBool aForward);
|
1999-10-22 00:19:18 +00:00
|
|
|
NS_IMETHOD LineMove(PRBool aForward, PRBool aExtend);
|
|
|
|
NS_IMETHOD IntraLineMove(PRBool aForward, PRBool aExtend);
|
|
|
|
NS_IMETHOD PageMove(PRBool aForward, PRBool aExtend);
|
|
|
|
NS_IMETHOD ScrollPage(PRBool aForward);
|
1999-12-15 03:54:52 +00:00
|
|
|
NS_IMETHOD ScrollLine(PRBool aForward);
|
|
|
|
NS_IMETHOD ScrollHorizontal(PRBool aLeft);
|
1999-12-11 00:02:08 +00:00
|
|
|
NS_IMETHOD CompleteScroll(PRBool aForward);
|
|
|
|
NS_IMETHOD CompleteMove(PRBool aForward, PRBool aExtend);
|
1999-10-22 00:19:18 +00:00
|
|
|
NS_IMETHOD SelectAll();
|
2000-07-26 11:31:12 +00:00
|
|
|
NS_IMETHOD CheckVisibility(nsIDOMNode *node, PRInt16 startOffset, PRInt16 EndOffset, PRBool *_retval);
|
1999-02-13 04:45:44 +00:00
|
|
|
|
1999-07-14 17:30:07 +00:00
|
|
|
// nsIDocumentObserver
|
2004-01-29 01:45:34 +00:00
|
|
|
virtual void BeginUpdate(nsIDocument* aDocument, nsUpdateType aUpdateType);
|
|
|
|
virtual void EndUpdate(nsIDocument* aDocument, nsUpdateType aUpdateType);
|
|
|
|
virtual void BeginLoad(nsIDocument* aDocument);
|
|
|
|
virtual void EndLoad(nsIDocument* aDocument);
|
|
|
|
virtual void ContentStatesChanged(nsIDocument* aDocument,
|
|
|
|
nsIContent* aContent1,
|
|
|
|
nsIContent* aContent2,
|
|
|
|
PRInt32 aStateMask);
|
|
|
|
virtual void StyleSheetAdded(nsIDocument* aDocument,
|
2004-07-28 07:08:41 +00:00
|
|
|
nsIStyleSheet* aStyleSheet,
|
|
|
|
PRBool aDocumentSheet);
|
2004-01-29 01:45:34 +00:00
|
|
|
virtual void StyleSheetRemoved(nsIDocument* aDocument,
|
2004-07-28 07:08:41 +00:00
|
|
|
nsIStyleSheet* aStyleSheet,
|
|
|
|
PRBool aDocumentSheet);
|
2004-01-29 01:45:34 +00:00
|
|
|
virtual void StyleSheetApplicableStateChanged(nsIDocument* aDocument,
|
|
|
|
nsIStyleSheet* aStyleSheet,
|
|
|
|
PRBool aApplicable);
|
|
|
|
virtual void StyleRuleChanged(nsIDocument* aDocument,
|
|
|
|
nsIStyleSheet* aStyleSheet,
|
|
|
|
nsIStyleRule* aOldStyleRule,
|
|
|
|
nsIStyleRule* aNewStyleRule);
|
|
|
|
virtual void StyleRuleAdded(nsIDocument* aDocument,
|
|
|
|
nsIStyleSheet* aStyleSheet,
|
|
|
|
nsIStyleRule* aStyleRule);
|
|
|
|
virtual void StyleRuleRemoved(nsIDocument* aDocument,
|
|
|
|
nsIStyleSheet* aStyleSheet,
|
|
|
|
nsIStyleRule* aStyleRule);
|
1999-12-23 02:02:33 +00:00
|
|
|
|
2007-07-12 20:05:45 +00:00
|
|
|
// nsIMutationObserver
|
|
|
|
NS_DECL_NSIMUTATIONOBSERVER_CHARACTERDATACHANGED
|
|
|
|
NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTECHANGED
|
|
|
|
NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED
|
|
|
|
NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED
|
|
|
|
NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED
|
|
|
|
|
2004-07-18 01:16:27 +00:00
|
|
|
NS_DECL_NSIOBSERVER
|
|
|
|
|
2000-04-21 14:59:47 +00:00
|
|
|
#ifdef MOZ_REFLOW_PERF
|
2000-04-28 23:32:04 +00:00
|
|
|
NS_IMETHOD DumpReflows();
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
NS_IMETHOD CountReflows(const char * aName, nsIFrame * aFrame);
|
2004-07-31 23:15:21 +00:00
|
|
|
NS_IMETHOD PaintCount(const char * aName, nsIRenderingContext* aRenderingContext, nsPresContext* aPresContext, nsIFrame * aFrame, PRUint32 aColor);
|
2001-03-13 01:47:22 +00:00
|
|
|
|
|
|
|
NS_IMETHOD SetPaintFrameCount(PRBool aOn);
|
|
|
|
|
2000-04-21 14:59:47 +00:00
|
|
|
#endif
|
|
|
|
|
2004-01-07 22:30:53 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
virtual void ListStyleContexts(nsIFrame *aRootFrame, FILE *out,
|
|
|
|
PRInt32 aIndent = 0);
|
|
|
|
|
|
|
|
virtual void ListStyleSheets(FILE *out, PRInt32 aIndent = 0);
|
2005-11-06 18:01:17 +00:00
|
|
|
virtual void VerifyStyleTree();
|
2004-01-07 22:30:53 +00:00
|
|
|
#endif
|
|
|
|
|
2001-04-11 03:07:50 +00:00
|
|
|
#ifdef PR_LOGGING
|
|
|
|
static PRLogModuleInfo* gLog;
|
|
|
|
#endif
|
|
|
|
|
1998-04-13 20:24:54 +00:00
|
|
|
protected:
|
1999-02-12 17:45:58 +00:00
|
|
|
virtual ~PresShell();
|
1998-04-13 20:24:54 +00:00
|
|
|
|
2000-07-13 23:00:59 +00:00
|
|
|
void HandlePostedReflowCallbacks();
|
2007-12-01 07:22:44 +00:00
|
|
|
void CancelPostedReflowCallbacks();
|
2000-06-23 05:15:04 +00:00
|
|
|
|
2001-04-25 19:52:49 +00:00
|
|
|
void UnsuppressAndInvalidate();
|
2000-05-15 03:37:21 +00:00
|
|
|
|
2008-03-14 23:08:57 +00:00
|
|
|
|
|
|
|
void WillCauseReflow() {
|
|
|
|
nsContentUtils::AddScriptBlocker();
|
|
|
|
++mChangeNestCount;
|
|
|
|
}
|
2000-04-17 07:13:57 +00:00
|
|
|
nsresult DidCauseReflow();
|
2008-03-14 23:08:57 +00:00
|
|
|
friend class nsAutoCauseReflowNotifier;
|
|
|
|
|
2006-04-28 04:33:41 +00:00
|
|
|
void WillDoReflow();
|
2004-02-04 00:11:59 +00:00
|
|
|
void DidDoReflow();
|
2000-04-17 07:13:57 +00:00
|
|
|
nsresult ProcessReflowCommands(PRBool aInterruptible);
|
2006-05-10 17:30:15 +00:00
|
|
|
void ClearReflowEventStatus();
|
2000-04-17 07:13:57 +00:00
|
|
|
void PostReflowEvent();
|
2007-04-25 15:49:55 +00:00
|
|
|
|
|
|
|
void DoReflow(nsIFrame* aFrame);
|
|
|
|
#ifdef DEBUG
|
|
|
|
void DoVerifyReflow();
|
2007-04-30 06:43:03 +00:00
|
|
|
void VerifyHasDirtyRootAncestor(nsIFrame* aFrame);
|
2007-04-25 15:49:55 +00:00
|
|
|
#endif
|
2004-05-02 18:07:12 +00:00
|
|
|
|
2006-03-07 17:08:51 +00:00
|
|
|
friend class nsPresShellEventCB;
|
1999-11-01 22:12:45 +00:00
|
|
|
|
2006-05-10 17:30:15 +00:00
|
|
|
class ReflowEvent;
|
|
|
|
friend class ReflowEvent;
|
|
|
|
|
|
|
|
class ReflowEvent : public nsRunnable {
|
|
|
|
public:
|
|
|
|
NS_DECL_NSIRUNNABLE
|
|
|
|
ReflowEvent(PresShell *aPresShell) : mPresShell(aPresShell) {
|
|
|
|
NS_ASSERTION(aPresShell, "Null parameters!");
|
|
|
|
}
|
|
|
|
void Revoke() { mPresShell = nsnull; }
|
|
|
|
private:
|
|
|
|
PresShell *mPresShell;
|
|
|
|
};
|
|
|
|
|
2004-08-06 15:55:17 +00:00
|
|
|
// Utility to find which view to scroll.
|
2004-09-21 04:41:08 +00:00
|
|
|
nsIScrollableView* GetViewToScroll(nsLayoutUtils::Direction aDirection);
|
2004-08-06 15:55:17 +00:00
|
|
|
|
2003-03-12 03:22:11 +00:00
|
|
|
PRBool mCaretEnabled;
|
1999-11-01 22:12:45 +00:00
|
|
|
#ifdef NS_DEBUG
|
2004-01-07 22:30:53 +00:00
|
|
|
nsresult CloneStyleSet(nsStyleSet* aSet, nsStyleSet** aResult);
|
1999-09-10 18:49:23 +00:00
|
|
|
PRBool VerifyIncrementalReflow();
|
1998-11-26 18:11:02 +00:00
|
|
|
PRBool mInVerifyReflow;
|
2006-01-26 02:29:17 +00:00
|
|
|
void ShowEventTargetDebug();
|
1998-07-13 19:49:42 +00:00
|
|
|
#endif
|
1998-05-20 16:24:54 +00:00
|
|
|
|
2000-10-11 08:33:01 +00:00
|
|
|
/**
|
|
|
|
* methods that manage rules that are used to implement the associated preferences
|
|
|
|
* - initially created for bugs 31816, 20760, 22963
|
|
|
|
*/
|
|
|
|
nsresult ClearPreferenceStyleRules(void);
|
|
|
|
nsresult CreatePreferenceStyleSheet(void);
|
|
|
|
nsresult SetPrefLinkRules(void);
|
2001-04-09 22:17:11 +00:00
|
|
|
nsresult SetPrefFocusRules(void);
|
2003-06-26 06:10:03 +00:00
|
|
|
nsresult SetPrefNoScriptRule();
|
2005-03-03 18:04:38 +00:00
|
|
|
nsresult SetPrefNoFramesRule(void);
|
|
|
|
|
2007-03-20 12:14:52 +00:00
|
|
|
// methods for painting a range to an offscreen buffer
|
|
|
|
|
|
|
|
// given a display list, clip the items within the list to
|
|
|
|
// the range
|
|
|
|
nsRect ClipListToRange(nsDisplayListBuilder *aBuilder,
|
|
|
|
nsDisplayList* aList,
|
2007-08-17 03:43:00 +00:00
|
|
|
nsIRange* aRange);
|
2007-03-20 12:14:52 +00:00
|
|
|
|
|
|
|
// create a RangePaintInfo for the range aRange containing the
|
|
|
|
// display list needed to paint the range to a surface
|
|
|
|
RangePaintInfo* CreateRangePaintInfo(nsIDOMRange* aRange,
|
|
|
|
nsRect& aSurfaceRect);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Paint the items to a new surface and return it.
|
|
|
|
*
|
|
|
|
* aSelection - selection being painted, if any
|
|
|
|
* aRegion - clip region, if any
|
|
|
|
* aArea - area that the surface occupies, relative to the root frame
|
|
|
|
* aPoint - reference point, typically the mouse position
|
|
|
|
* aScreenRect - [out] set to the area of the screen the painted area should
|
|
|
|
* be displayed at
|
|
|
|
*/
|
|
|
|
already_AddRefed<gfxASurface>
|
|
|
|
PaintRangePaintInfo(nsTArray<nsAutoPtr<RangePaintInfo> >* aItems,
|
|
|
|
nsISelection* aSelection,
|
|
|
|
nsIRegion* aRegion,
|
|
|
|
nsRect aArea,
|
|
|
|
nsPoint& aPoint,
|
|
|
|
nsRect* aScreenRect);
|
|
|
|
|
2006-06-08 14:32:20 +00:00
|
|
|
/**
|
|
|
|
* Methods to handle changes to user and UA sheet lists that we get
|
|
|
|
* notified about.
|
|
|
|
*/
|
|
|
|
void AddUserSheet(nsISupports* aSheet);
|
|
|
|
void AddAgentSheet(nsISupports* aSheet);
|
|
|
|
void RemoveSheet(nsStyleSet::sheetType aType, nsISupports* aSheet);
|
|
|
|
|
2007-04-20 18:20:03 +00:00
|
|
|
// Hide a view if it is a popup
|
|
|
|
void HideViewIfPopup(nsIView* aView);
|
|
|
|
|
2007-04-26 02:33:02 +00:00
|
|
|
// Utility method to restore the root scrollframe state
|
|
|
|
void RestoreRootScrollPosition();
|
|
|
|
|
2007-08-22 02:57:06 +00:00
|
|
|
// Method to handle actually flushing. This allows the caller to control
|
|
|
|
// whether the reflow flush (if any) should be interruptible.
|
|
|
|
nsresult DoFlushPendingNotifications(mozFlushType aType,
|
|
|
|
PRBool aInterruptibleReflow);
|
|
|
|
|
2008-01-18 05:23:44 +00:00
|
|
|
nsCOMPtr<nsICSSStyleSheet> mPrefStyleSheet; // mStyleSet owns it but we
|
|
|
|
// maintain a ref, may be null
|
2004-12-02 01:26:20 +00:00
|
|
|
#ifdef DEBUG
|
2001-12-14 23:13:08 +00:00
|
|
|
PRUint32 mUpdateCount;
|
2004-12-02 01:26:20 +00:00
|
|
|
#endif
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
// reflow roots that need to be reflowed, as both a queue and a hashtable
|
|
|
|
nsVoidArray mDirtyRoots;
|
2001-03-13 06:38:59 +00:00
|
|
|
|
2000-05-16 01:11:29 +00:00
|
|
|
PRPackedBool mDocumentLoading;
|
2000-04-17 07:13:57 +00:00
|
|
|
PRPackedBool mIsReflowing;
|
2001-12-14 23:13:08 +00:00
|
|
|
|
2001-12-01 00:22:00 +00:00
|
|
|
PRPackedBool mIgnoreFrameDestruction;
|
2004-02-25 09:10:06 +00:00
|
|
|
PRPackedBool mHaveShutDown;
|
2001-12-14 23:13:08 +00:00
|
|
|
|
2005-01-20 03:39:09 +00:00
|
|
|
// This is used to protect ourselves from triggering reflow while in the
|
|
|
|
// middle of frame construction and the like... it really shouldn't be
|
|
|
|
// needed, one hopes, but it is for now.
|
|
|
|
PRUint32 mChangeNestCount;
|
|
|
|
|
2001-12-14 23:13:08 +00:00
|
|
|
nsIFrame* mCurrentEventFrame;
|
2004-09-13 03:22:46 +00:00
|
|
|
nsCOMPtr<nsIContent> mCurrentEventContent;
|
1999-09-02 18:14:01 +00:00
|
|
|
nsVoidArray mCurrentEventFrameStack;
|
2004-09-13 03:22:46 +00:00
|
|
|
nsCOMArray<nsIContent> mCurrentEventContentStack;
|
2000-04-24 04:41:27 +00:00
|
|
|
|
2008-02-27 10:01:17 +00:00
|
|
|
nsCOMPtr<nsIContent> mLastAnchorScrolledTo;
|
|
|
|
nscoord mLastAnchorScrollPositionY;
|
1999-02-12 00:02:56 +00:00
|
|
|
nsCOMPtr<nsICaret> mCaret;
|
2007-09-22 21:06:58 +00:00
|
|
|
nsCOMPtr<nsICaret> mOriginalCaret;
|
2001-12-18 21:05:55 +00:00
|
|
|
PRInt16 mSelectionFlags;
|
1999-12-07 04:36:08 +00:00
|
|
|
FrameArena mFrameArena;
|
2007-01-17 23:53:47 +00:00
|
|
|
StackArena mStackArena;
|
2000-06-14 23:18:54 +00:00
|
|
|
nsCOMPtr<nsIDragService> mDragService;
|
2006-05-10 17:30:15 +00:00
|
|
|
|
|
|
|
nsRevocableEventPtr<ReflowEvent> mReflowEvent;
|
2000-06-23 05:15:04 +00:00
|
|
|
|
2000-07-13 23:00:59 +00:00
|
|
|
nsCallbackEventRequest* mFirstCallbackEventRequest;
|
|
|
|
nsCallbackEventRequest* mLastCallbackEventRequest;
|
2000-06-23 05:15:04 +00:00
|
|
|
|
2002-09-21 01:03:38 +00:00
|
|
|
PRPackedBool mIsThemeSupportDisabled; // Whether or not form controls should use nsITheme in this shell.
|
|
|
|
|
2001-12-14 23:13:08 +00:00
|
|
|
PRPackedBool mIsDocumentGone; // We've been disconnected from the document.
|
|
|
|
PRPackedBool mPaintingSuppressed; // For all documents we initially lock down painting.
|
|
|
|
// We will refuse to paint the document until either
|
|
|
|
// (a) our timer fires or (b) all frames are constructed.
|
|
|
|
PRPackedBool mShouldUnsuppressPainting; // Indicates that it is safe to unlock painting once all pending
|
|
|
|
// reflows have been processed.
|
2001-04-25 19:52:49 +00:00
|
|
|
nsCOMPtr<nsITimer> mPaintSuppressionTimer; // This timer controls painting suppression. Until it fires
|
|
|
|
// or all frames are constructed, we won't paint anything but
|
|
|
|
// our <body> background and scrollbars.
|
2002-12-26 21:03:23 +00:00
|
|
|
#define PAINTLOCK_EVENT_DELAY 250 // 250ms. This is actually
|
|
|
|
// pref-controlled, but we use this
|
|
|
|
// value if we fail to get the pref
|
|
|
|
// for any reason.
|
2001-04-25 19:52:49 +00:00
|
|
|
|
|
|
|
static void sPaintSuppressionCallback(nsITimer* aTimer, void* aPresShell); // A callback for the timer.
|
|
|
|
|
2000-04-17 07:13:57 +00:00
|
|
|
MOZ_TIMER_DECLARE(mReflowWatch) // Used for measuring time spent in reflow
|
|
|
|
MOZ_TIMER_DECLARE(mFrameCreationWatch) // Used for measuring time spent in frame creation
|
1999-12-23 02:02:33 +00:00
|
|
|
|
2000-04-21 14:59:47 +00:00
|
|
|
#ifdef MOZ_REFLOW_PERF
|
|
|
|
ReflowCountMgr * mReflowCountMgr;
|
|
|
|
#endif
|
|
|
|
|
2007-04-14 16:51:20 +00:00
|
|
|
nsresult CompleteMoveInner(PRBool aForward, PRBool aExtend, PRBool sScrollIntoView);
|
|
|
|
|
2001-04-18 06:06:31 +00:00
|
|
|
private:
|
|
|
|
|
2003-01-07 02:09:06 +00:00
|
|
|
PRBool InZombieDocument(nsIContent *aContent);
|
2006-10-27 00:01:19 +00:00
|
|
|
nsresult RetargetEventToParent(nsGUIEvent* aEvent,
|
|
|
|
nsEventStatus* aEventStatus);
|
2003-01-07 02:09:06 +00:00
|
|
|
|
1999-09-02 18:14:01 +00:00
|
|
|
//helper funcs for event handling
|
2006-03-07 17:08:51 +00:00
|
|
|
protected:
|
|
|
|
//protected because nsPresShellEventCB needs this.
|
1999-06-15 03:14:28 +00:00
|
|
|
nsIFrame* GetCurrentEventFrame();
|
2006-03-07 17:08:51 +00:00
|
|
|
private:
|
2000-04-24 04:41:27 +00:00
|
|
|
void PushCurrentEventInfo(nsIFrame* aFrame, nsIContent* aContent);
|
|
|
|
void PopCurrentEventInfo();
|
2006-03-07 17:08:51 +00:00
|
|
|
nsresult HandleEventInternal(nsEvent* aEvent, nsIView* aView,
|
|
|
|
nsEventStatus *aStatus);
|
2006-01-26 02:29:17 +00:00
|
|
|
nsresult HandlePositionedEvent(nsIView* aView,
|
|
|
|
nsIFrame* aTargetFrame,
|
|
|
|
nsGUIEvent* aEvent,
|
|
|
|
nsEventStatus* aEventStatus);
|
2001-04-17 23:25:21 +00:00
|
|
|
|
|
|
|
//help funcs for resize events
|
|
|
|
void CreateResizeEventTimer();
|
|
|
|
void KillResizeEventTimer();
|
|
|
|
void FireResizeEvent();
|
|
|
|
static void sResizeEventCallback(nsITimer* aTimer, void* aPresShell) ;
|
|
|
|
nsCOMPtr<nsITimer> mResizeEventTimer;
|
2005-05-04 20:22:32 +00:00
|
|
|
|
|
|
|
typedef void (*nsPluginEnumCallback)(PresShell*, nsIContent*);
|
|
|
|
void EnumeratePlugins(nsIDOMDocument *aDocument,
|
|
|
|
const nsString &aPluginTag,
|
|
|
|
nsPluginEnumCallback aCallback);
|
1998-04-13 20:24:54 +00:00
|
|
|
};
|
|
|
|
|
2008-03-14 23:08:57 +00:00
|
|
|
class nsAutoCauseReflowNotifier
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
nsAutoCauseReflowNotifier(PresShell* aShell)
|
|
|
|
: mShell(aShell)
|
|
|
|
{
|
|
|
|
mShell->WillCauseReflow();
|
|
|
|
}
|
|
|
|
~nsAutoCauseReflowNotifier()
|
|
|
|
{
|
|
|
|
// This check should not be needed. Currently the only place that seem
|
|
|
|
// to need it is the code that deals with bug 337586.
|
|
|
|
if (!mShell->mHaveShutDown) {
|
|
|
|
mShell->DidCauseReflow();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
nsContentUtils::RemoveScriptBlocker();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
PresShell* mShell;
|
|
|
|
};
|
|
|
|
|
2006-03-07 17:08:51 +00:00
|
|
|
class nsPresShellEventCB : public nsDispatchingCallback
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
nsPresShellEventCB(PresShell* aPresShell) : mPresShell(aPresShell) {}
|
|
|
|
|
|
|
|
virtual void HandleEvent(nsEventChainPostVisitor& aVisitor)
|
|
|
|
{
|
|
|
|
if (aVisitor.mPresContext && aVisitor.mEvent->eventStructType != NS_EVENT) {
|
|
|
|
nsIFrame* frame = mPresShell->GetCurrentEventFrame();
|
|
|
|
if (frame) {
|
|
|
|
frame->HandleEvent(aVisitor.mPresContext,
|
|
|
|
(nsGUIEvent*) aVisitor.mEvent,
|
|
|
|
&aVisitor.mEventStatus);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
nsRefPtr<PresShell> mPresShell;
|
|
|
|
};
|
|
|
|
|
2001-04-11 03:07:50 +00:00
|
|
|
#ifdef PR_LOGGING
|
|
|
|
PRLogModuleInfo* PresShell::gLog;
|
|
|
|
#endif
|
|
|
|
|
1999-09-21 07:53:49 +00:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
static void
|
2004-07-31 23:15:21 +00:00
|
|
|
VerifyStyleTree(nsPresContext* aPresContext, nsFrameManager* aFrameManager)
|
1999-09-21 07:53:49 +00:00
|
|
|
{
|
2004-02-23 21:29:06 +00:00
|
|
|
if (nsIFrameDebug::GetVerifyStyleTreeEnable()) {
|
|
|
|
nsIFrame* rootFrame = aFrameManager->GetRootFrame();
|
2003-06-20 01:05:04 +00:00
|
|
|
aFrameManager->DebugVerifyStyleTree(rootFrame);
|
1999-09-21 07:53:49 +00:00
|
|
|
}
|
|
|
|
}
|
2005-11-06 18:01:17 +00:00
|
|
|
#define VERIFY_STYLE_TREE ::VerifyStyleTree(mPresContext, FrameManager())
|
1999-09-21 07:53:49 +00:00
|
|
|
#else
|
|
|
|
#define VERIFY_STYLE_TREE
|
|
|
|
#endif
|
|
|
|
|
1999-09-10 18:49:23 +00:00
|
|
|
static PRBool gVerifyReflowEnabled;
|
|
|
|
|
2001-10-23 01:37:21 +00:00
|
|
|
PRBool
|
1998-07-13 19:49:42 +00:00
|
|
|
nsIPresShell::GetVerifyReflowEnable()
|
|
|
|
{
|
|
|
|
#ifdef NS_DEBUG
|
1999-09-10 18:49:23 +00:00
|
|
|
static PRBool firstTime = PR_TRUE;
|
|
|
|
if (firstTime) {
|
|
|
|
firstTime = PR_FALSE;
|
2001-06-27 04:04:04 +00:00
|
|
|
char* flags = PR_GetEnv("GECKO_VERIFY_REFLOW_FLAGS");
|
|
|
|
if (flags) {
|
|
|
|
PRBool error = PR_FALSE;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
char* comma = PL_strchr(flags, ',');
|
|
|
|
if (comma)
|
|
|
|
*comma = '\0';
|
|
|
|
|
|
|
|
PRBool found = PR_FALSE;
|
2004-01-21 04:15:00 +00:00
|
|
|
const VerifyReflowFlags* flag = gFlags;
|
|
|
|
const VerifyReflowFlags* limit = gFlags + NUM_VERIFY_REFLOW_FLAGS;
|
2001-06-27 04:04:04 +00:00
|
|
|
while (flag < limit) {
|
|
|
|
if (PL_strcasecmp(flag->name, flags) == 0) {
|
|
|
|
gVerifyReflowFlags |= flag->bit;
|
|
|
|
found = PR_TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
++flag;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (! found)
|
|
|
|
error = PR_TRUE;
|
|
|
|
|
|
|
|
if (! comma)
|
|
|
|
break;
|
|
|
|
|
|
|
|
*comma = ',';
|
|
|
|
flags = comma + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (error)
|
|
|
|
ShowVerifyReflowFlags();
|
|
|
|
}
|
|
|
|
|
1999-09-10 18:49:23 +00:00
|
|
|
if (VERIFY_REFLOW_ON & gVerifyReflowFlags) {
|
|
|
|
gVerifyReflowEnabled = PR_TRUE;
|
2007-07-07 23:52:59 +00:00
|
|
|
|
|
|
|
printf("Note: verifyreflow is enabled");
|
|
|
|
if (VERIFY_REFLOW_NOISY & gVerifyReflowFlags) {
|
|
|
|
printf(" (noisy)");
|
|
|
|
}
|
|
|
|
if (VERIFY_REFLOW_ALL & gVerifyReflowFlags) {
|
|
|
|
printf(" (all)");
|
|
|
|
}
|
|
|
|
if (VERIFY_REFLOW_DUMP_COMMANDS & gVerifyReflowFlags) {
|
|
|
|
printf(" (show reflow commands)");
|
|
|
|
}
|
|
|
|
if (VERIFY_REFLOW_NOISY_RC & gVerifyReflowFlags) {
|
|
|
|
printf(" (noisy reflow commands)");
|
|
|
|
if (VERIFY_REFLOW_REALLY_NOISY_RC & gVerifyReflowFlags) {
|
|
|
|
printf(" (REALLY noisy reflow commands)");
|
|
|
|
}
|
1999-10-05 14:51:12 +00:00
|
|
|
}
|
2007-07-07 23:52:59 +00:00
|
|
|
printf("\n");
|
1999-09-15 00:27:05 +00:00
|
|
|
}
|
1998-07-13 19:49:42 +00:00
|
|
|
}
|
|
|
|
#endif
|
1999-09-10 18:49:23 +00:00
|
|
|
return gVerifyReflowEnabled;
|
1998-07-13 19:49:42 +00:00
|
|
|
}
|
|
|
|
|
2001-10-23 01:37:21 +00:00
|
|
|
void
|
1998-07-13 19:49:42 +00:00
|
|
|
nsIPresShell::SetVerifyReflowEnable(PRBool aEnabled)
|
|
|
|
{
|
1999-09-10 18:49:23 +00:00
|
|
|
gVerifyReflowEnabled = aEnabled;
|
1998-07-13 19:49:42 +00:00
|
|
|
}
|
|
|
|
|
2001-10-23 01:37:21 +00:00
|
|
|
PRInt32
|
2000-03-22 23:19:10 +00:00
|
|
|
nsIPresShell::GetVerifyReflowFlags()
|
|
|
|
{
|
2000-03-23 00:10:26 +00:00
|
|
|
#ifdef NS_DEBUG
|
2000-03-22 23:19:10 +00:00
|
|
|
return gVerifyReflowFlags;
|
2000-03-23 00:10:26 +00:00
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
2000-03-22 23:19:10 +00:00
|
|
|
}
|
|
|
|
|
2006-07-12 07:41:11 +00:00
|
|
|
void
|
|
|
|
nsIPresShell::AddWeakFrame(nsWeakFrame* aWeakFrame)
|
|
|
|
{
|
|
|
|
if (aWeakFrame->GetFrame()) {
|
|
|
|
aWeakFrame->GetFrame()->AddStateBits(NS_FRAME_EXTERNAL_REFERENCE);
|
|
|
|
}
|
|
|
|
aWeakFrame->SetPreviousWeakFrame(mWeakFrames);
|
|
|
|
mWeakFrames = aWeakFrame;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsIPresShell::RemoveWeakFrame(nsWeakFrame* aWeakFrame)
|
|
|
|
{
|
|
|
|
if (mWeakFrames == aWeakFrame) {
|
|
|
|
mWeakFrames = aWeakFrame->GetPreviousWeakFrame();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
nsWeakFrame* nextWeak = mWeakFrames;
|
|
|
|
while (nextWeak && nextWeak->GetPreviousWeakFrame() != aWeakFrame) {
|
|
|
|
nextWeak = nextWeak->GetPreviousWeakFrame();
|
|
|
|
}
|
|
|
|
if (nextWeak) {
|
|
|
|
nextWeak->SetPreviousWeakFrame(aWeakFrame->GetPreviousWeakFrame());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-11-22 20:47:33 +00:00
|
|
|
already_AddRefed<nsFrameSelection>
|
|
|
|
nsIPresShell::FrameSelection()
|
|
|
|
{
|
|
|
|
NS_IF_ADDREF(mSelection);
|
|
|
|
return mSelection;
|
|
|
|
}
|
|
|
|
|
1998-04-13 20:24:54 +00:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
2001-10-23 01:37:21 +00:00
|
|
|
nsresult
|
1998-07-13 19:49:42 +00:00
|
|
|
NS_NewPresShell(nsIPresShell** aInstancePtrResult)
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(nsnull != aInstancePtrResult, "null ptr");
|
|
|
|
if (nsnull == aInstancePtrResult) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
PresShell* it = new PresShell();
|
|
|
|
if (nsnull == it) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
2000-01-04 20:24:09 +00:00
|
|
|
return it->QueryInterface(NS_GET_IID(nsIPresShell),
|
|
|
|
(void **) aInstancePtrResult);
|
1998-07-13 19:49:42 +00:00
|
|
|
}
|
|
|
|
|
2004-08-29 03:08:44 +00:00
|
|
|
PresShell::PresShell()
|
2001-12-01 00:22:00 +00:00
|
|
|
{
|
2004-08-29 03:08:44 +00:00
|
|
|
mSelection = nsnull;
|
2000-04-21 14:59:47 +00:00
|
|
|
#ifdef MOZ_REFLOW_PERF
|
|
|
|
mReflowCountMgr = new ReflowCountMgr();
|
2001-02-22 13:58:17 +00:00
|
|
|
mReflowCountMgr->SetPresContext(mPresContext);
|
|
|
|
mReflowCountMgr->SetPresShell(this);
|
2000-04-21 14:59:47 +00:00
|
|
|
#endif
|
2001-04-11 03:07:50 +00:00
|
|
|
#ifdef PR_LOGGING
|
|
|
|
if (! gLog)
|
|
|
|
gLog = PR_NewLogModule("PresShell");
|
|
|
|
#endif
|
2002-09-11 03:03:49 +00:00
|
|
|
mSelectionFlags = nsISelectionDisplay::DISPLAY_TEXT | nsISelectionDisplay::DISPLAY_IMAGES;
|
2002-09-21 01:03:38 +00:00
|
|
|
mIsThemeSupportDisabled = PR_FALSE;
|
2004-03-06 04:46:11 +00:00
|
|
|
|
|
|
|
new (this) nsFrameManager();
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2006-07-02 07:23:10 +00:00
|
|
|
NS_IMPL_ISUPPORTS8(PresShell, nsIPresShell, nsIDocumentObserver,
|
2004-09-01 05:16:00 +00:00
|
|
|
nsIViewObserver, nsISelectionController,
|
2006-07-02 07:23:10 +00:00
|
|
|
nsISelectionDisplay, nsIObserver, nsISupportsWeakReference,
|
|
|
|
nsIMutationObserver)
|
1998-04-13 20:24:54 +00:00
|
|
|
|
|
|
|
PresShell::~PresShell()
|
|
|
|
{
|
2004-02-25 09:10:06 +00:00
|
|
|
if (!mHaveShutDown) {
|
2001-08-01 03:15:50 +00:00
|
|
|
NS_NOTREACHED("Someone did not call nsIPresShell::destroy");
|
|
|
|
Destroy();
|
2001-07-26 20:53:21 +00:00
|
|
|
}
|
|
|
|
|
2002-06-20 20:14:59 +00:00
|
|
|
NS_ASSERTION(mCurrentEventContentStack.Count() == 0,
|
|
|
|
"Huh, event content left on the stack in pres shell dtor!");
|
2007-03-05 01:39:53 +00:00
|
|
|
NS_ASSERTION(mFirstCallbackEventRequest == nsnull &&
|
2004-01-21 04:15:00 +00:00
|
|
|
mLastCallbackEventRequest == nsnull,
|
|
|
|
"post-reflow queues not empty. This means we're leaking");
|
2004-02-25 09:10:06 +00:00
|
|
|
|
|
|
|
delete mStyleSet;
|
2004-01-21 23:05:10 +00:00
|
|
|
delete mFrameConstructor;
|
|
|
|
|
2004-09-13 03:22:46 +00:00
|
|
|
mCurrentEventContent = nsnull;
|
2002-06-20 20:14:59 +00:00
|
|
|
|
2003-06-19 18:16:53 +00:00
|
|
|
NS_IF_RELEASE(mPresContext);
|
|
|
|
NS_IF_RELEASE(mDocument);
|
2008-04-03 02:42:20 +00:00
|
|
|
NS_IF_RELEASE(mSelection);
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Initialize the presentation shell. Create view manager and style
|
|
|
|
* manager.
|
|
|
|
*/
|
2001-08-01 03:15:50 +00:00
|
|
|
NS_IMETHODIMP
|
1998-05-09 03:22:41 +00:00
|
|
|
PresShell::Init(nsIDocument* aDocument,
|
2004-07-31 23:15:21 +00:00
|
|
|
nsPresContext* aPresContext,
|
1998-05-09 03:22:41 +00:00
|
|
|
nsIViewManager* aViewManager,
|
2004-01-07 22:30:53 +00:00
|
|
|
nsStyleSet* aStyleSet,
|
2002-06-25 21:16:17 +00:00
|
|
|
nsCompatibility aCompatMode)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
|
|
|
NS_PRECONDITION(nsnull != aDocument, "null ptr");
|
|
|
|
NS_PRECONDITION(nsnull != aPresContext, "null ptr");
|
|
|
|
NS_PRECONDITION(nsnull != aViewManager, "null ptr");
|
2007-01-17 23:53:47 +00:00
|
|
|
nsresult result;
|
1999-12-04 23:49:50 +00:00
|
|
|
|
1998-04-13 20:24:54 +00:00
|
|
|
if ((nsnull == aDocument) || (nsnull == aPresContext) ||
|
|
|
|
(nsnull == aViewManager)) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
1999-05-04 23:27:42 +00:00
|
|
|
if (mDocument) {
|
2006-03-30 00:27:42 +00:00
|
|
|
NS_WARNING("PresShell double init'ed");
|
1998-04-13 20:24:54 +00:00
|
|
|
return NS_ERROR_ALREADY_INITIALIZED;
|
|
|
|
}
|
2007-01-17 23:53:47 +00:00
|
|
|
result = mStackArena.Init();
|
|
|
|
NS_ENSURE_SUCCESS(result, result);
|
1998-04-13 20:24:54 +00:00
|
|
|
|
2003-06-19 18:16:53 +00:00
|
|
|
mDocument = aDocument;
|
|
|
|
NS_ADDREF(mDocument);
|
1998-04-13 20:24:54 +00:00
|
|
|
mViewManager = aViewManager;
|
|
|
|
|
2004-01-07 22:30:53 +00:00
|
|
|
// Create our frame constructor.
|
2005-02-18 16:11:53 +00:00
|
|
|
mFrameConstructor = new nsCSSFrameConstructor(mDocument, this);
|
2004-01-21 23:05:10 +00:00
|
|
|
NS_ENSURE_TRUE(mFrameConstructor, NS_ERROR_OUT_OF_MEMORY);
|
2004-01-07 22:30:53 +00:00
|
|
|
|
2002-04-11 03:24:18 +00:00
|
|
|
// The document viewer owns both view manager and pres shell.
|
|
|
|
mViewManager->SetViewObserver(this);
|
1998-08-28 02:54:06 +00:00
|
|
|
|
1998-04-13 20:24:54 +00:00
|
|
|
// Bind the context to the presentation shell.
|
2002-05-23 23:09:31 +00:00
|
|
|
mPresContext = aPresContext;
|
2003-06-19 18:16:53 +00:00
|
|
|
NS_ADDREF(mPresContext);
|
1998-04-13 20:24:54 +00:00
|
|
|
aPresContext->SetShell(this);
|
|
|
|
|
2004-01-07 22:30:53 +00:00
|
|
|
// Now we can initialize the style set.
|
2007-01-17 23:53:47 +00:00
|
|
|
result = aStyleSet->Init(aPresContext);
|
2004-01-07 22:30:53 +00:00
|
|
|
NS_ENSURE_SUCCESS(result, result);
|
|
|
|
|
2004-04-13 00:27:29 +00:00
|
|
|
// From this point on, any time we return an error we need to make
|
|
|
|
// sure to null out mStyleSet first, since an error return from this
|
|
|
|
// method will cause the caller to delete the style set, so we don't
|
|
|
|
// want to delete it in our destructor.
|
2001-08-01 03:15:50 +00:00
|
|
|
mStyleSet = aStyleSet;
|
1998-04-13 20:24:54 +00:00
|
|
|
|
2006-12-05 15:46:18 +00:00
|
|
|
// Notify our prescontext that it now has a compatibility mode. Note that
|
|
|
|
// this MUST happen after we set up our style set but before we create any
|
|
|
|
// frames.
|
|
|
|
mPresContext->CompatibilityModeChanged();
|
2002-05-23 23:09:31 +00:00
|
|
|
|
2002-06-25 21:21:48 +00:00
|
|
|
// setup the preference style rules (no forced reflow), and do it
|
|
|
|
// before creating any frames.
|
|
|
|
SetPreferenceStyleRules(PR_FALSE);
|
|
|
|
|
2004-08-29 03:08:44 +00:00
|
|
|
result = CallCreateInstance(kFrameSelectionCID, &mSelection);
|
2004-04-13 00:27:29 +00:00
|
|
|
if (NS_FAILED(result)) {
|
|
|
|
mStyleSet = nsnull;
|
1998-12-14 18:34:14 +00:00
|
|
|
return result;
|
2004-04-13 00:27:29 +00:00
|
|
|
}
|
1999-04-26 04:02:04 +00:00
|
|
|
|
1999-08-04 04:02:40 +00:00
|
|
|
// Create and initialize the frame manager
|
2004-03-06 04:46:11 +00:00
|
|
|
result = FrameManager()->Init(this, mStyleSet);
|
2004-04-13 00:27:29 +00:00
|
|
|
if (NS_FAILED(result)) {
|
|
|
|
NS_WARNING("Frame manager initialization failed");
|
|
|
|
mStyleSet = nsnull;
|
|
|
|
return result;
|
|
|
|
}
|
1999-08-04 04:02:40 +00:00
|
|
|
|
2006-04-26 02:01:07 +00:00
|
|
|
mSelection->Init(this, nsnull);
|
|
|
|
|
1999-02-12 00:02:56 +00:00
|
|
|
// Important: this has to happen after the selection has been set up
|
|
|
|
#ifdef SHOW_CARET
|
|
|
|
// make the caret
|
|
|
|
nsresult err = NS_NewCaret(getter_AddRefs(mCaret));
|
|
|
|
if (NS_SUCCEEDED(err))
|
1999-04-01 23:58:11 +00:00
|
|
|
{
|
1999-07-14 22:18:29 +00:00
|
|
|
mCaret->Init(this);
|
2007-09-22 21:06:58 +00:00
|
|
|
mOriginalCaret = mCaret;
|
1999-04-01 23:58:11 +00:00
|
|
|
}
|
|
|
|
|
2003-03-12 03:22:11 +00:00
|
|
|
//SetCaretEnabled(PR_TRUE); // make it show in browser windows
|
1999-02-12 00:02:56 +00:00
|
|
|
#endif
|
2005-09-06 03:37:15 +00:00
|
|
|
//set up selection to be displayed in document
|
2006-02-07 02:52:40 +00:00
|
|
|
// Don't enable selection for print media
|
|
|
|
nsPresContext::nsPresContextType type = aPresContext->Type();
|
|
|
|
if (type != nsPresContext::eContext_PrintPreview &&
|
|
|
|
type != nsPresContext::eContext_Print)
|
|
|
|
SetDisplaySelection(nsISelectionController::SELECTION_DISABLED);
|
1999-11-30 00:32:43 +00:00
|
|
|
|
1999-12-23 03:47:02 +00:00
|
|
|
if (gMaxRCProcessingTime == -1) {
|
2004-04-29 23:34:19 +00:00
|
|
|
gMaxRCProcessingTime =
|
|
|
|
nsContentUtils::GetIntPref("layout.reflow.timeslice",
|
|
|
|
NS_MAX_REFLOW_TIME);
|
1999-12-23 02:02:33 +00:00
|
|
|
}
|
|
|
|
|
2004-07-18 01:16:27 +00:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIObserverService> os =
|
|
|
|
do_GetService("@mozilla.org/observer-service;1", &result);
|
2005-08-10 20:21:44 +00:00
|
|
|
if (os) {
|
|
|
|
os->AddObserver(this, NS_LINK_VISITED_EVENT_TOPIC, PR_FALSE);
|
2006-06-08 14:32:20 +00:00
|
|
|
os->AddObserver(this, "agent-sheet-added", PR_FALSE);
|
|
|
|
os->AddObserver(this, "user-sheet-added", PR_FALSE);
|
|
|
|
os->AddObserver(this, "agent-sheet-removed", PR_FALSE);
|
|
|
|
os->AddObserver(this, "user-sheet-removed", PR_FALSE);
|
2005-08-10 20:21:44 +00:00
|
|
|
#ifdef MOZ_XUL
|
2004-07-18 01:16:27 +00:00
|
|
|
os->AddObserver(this, "chrome-flush-skin-caches", PR_FALSE);
|
2007-05-04 02:19:18 +00:00
|
|
|
#endif
|
|
|
|
#ifdef ACCESSIBILITY
|
|
|
|
os->AddObserver(this, "a11y-init-or-shutdown", PR_FALSE);
|
2004-07-18 01:16:27 +00:00
|
|
|
#endif
|
2005-08-10 20:21:44 +00:00
|
|
|
}
|
|
|
|
}
|
2000-05-15 03:37:21 +00:00
|
|
|
|
2000-06-14 23:18:54 +00:00
|
|
|
// cache the drag service so we can check it during reflows
|
2000-09-13 23:57:52 +00:00
|
|
|
mDragService = do_GetService("@mozilla.org/widget/dragservice;1");
|
2000-06-14 23:18:54 +00:00
|
|
|
|
2001-03-13 01:47:22 +00:00
|
|
|
#ifdef MOZ_REFLOW_PERF
|
2002-12-11 14:05:41 +00:00
|
|
|
if (mReflowCountMgr) {
|
2004-04-29 23:34:19 +00:00
|
|
|
PRBool paintFrameCounts =
|
|
|
|
nsContentUtils::GetBoolPref("layout.reflow.showframecounts");
|
|
|
|
|
|
|
|
PRBool dumpFrameCounts =
|
|
|
|
nsContentUtils::GetBoolPref("layout.reflow.dumpframecounts");
|
|
|
|
|
|
|
|
PRBool dumpFrameByFrameCounts =
|
|
|
|
nsContentUtils::GetBoolPref("layout.reflow.dumpframebyframecounts");
|
|
|
|
|
|
|
|
mReflowCountMgr->SetDumpFrameCounts(dumpFrameCounts);
|
|
|
|
mReflowCountMgr->SetDumpFrameByFrameCounts(dumpFrameByFrameCounts);
|
|
|
|
mReflowCountMgr->SetPaintFrameCounts(paintFrameCounts);
|
2001-03-13 01:47:22 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-08-01 03:15:50 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::Destroy()
|
|
|
|
{
|
|
|
|
#ifdef MOZ_REFLOW_PERF
|
|
|
|
DumpReflows();
|
|
|
|
if (mReflowCountMgr) {
|
|
|
|
delete mReflowCountMgr;
|
|
|
|
mReflowCountMgr = nsnull;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2004-02-25 09:10:06 +00:00
|
|
|
if (mHaveShutDown)
|
|
|
|
return NS_OK;
|
|
|
|
|
2006-04-11 16:37:58 +00:00
|
|
|
if (mPresContext) {
|
|
|
|
// We need to notify the destroying the nsPresContext to ESM for
|
|
|
|
// suppressing to use from ESM.
|
|
|
|
mPresContext->EventStateManager()->NotifyDestroyPresContext(mPresContext);
|
|
|
|
}
|
|
|
|
|
2004-07-18 01:16:27 +00:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIObserverService> os =
|
|
|
|
do_GetService("@mozilla.org/observer-service;1");
|
2005-08-11 03:59:04 +00:00
|
|
|
if (os) {
|
|
|
|
os->RemoveObserver(this, NS_LINK_VISITED_EVENT_TOPIC);
|
2006-06-08 14:32:20 +00:00
|
|
|
os->RemoveObserver(this, "agent-sheet-added");
|
|
|
|
os->RemoveObserver(this, "user-sheet-added");
|
|
|
|
os->RemoveObserver(this, "agent-sheet-removed");
|
|
|
|
os->RemoveObserver(this, "user-sheet-removed");
|
2005-08-11 03:59:04 +00:00
|
|
|
#ifdef MOZ_XUL
|
2004-07-18 01:16:27 +00:00
|
|
|
os->RemoveObserver(this, "chrome-flush-skin-caches");
|
2007-05-04 18:09:02 +00:00
|
|
|
#endif
|
|
|
|
#ifdef ACCESSIBILITY
|
|
|
|
os->RemoveObserver(this, "a11y-init-or-shutdown");
|
2004-07-18 01:16:27 +00:00
|
|
|
#endif
|
2005-08-11 03:59:04 +00:00
|
|
|
}
|
|
|
|
}
|
2004-07-18 01:16:27 +00:00
|
|
|
|
2001-08-01 03:15:50 +00:00
|
|
|
// If our paint suppression timer is still active, kill it.
|
|
|
|
if (mPaintSuppressionTimer) {
|
|
|
|
mPaintSuppressionTimer->Cancel();
|
|
|
|
mPaintSuppressionTimer = nsnull;
|
|
|
|
}
|
|
|
|
|
2003-02-27 23:09:51 +00:00
|
|
|
if (mCaret) {
|
|
|
|
mCaret->Terminate();
|
|
|
|
mCaret = nsnull;
|
|
|
|
}
|
|
|
|
|
2008-04-03 02:42:20 +00:00
|
|
|
if (mSelection) {
|
|
|
|
mSelection->DisconnectFromPresShell();
|
|
|
|
}
|
|
|
|
|
2001-08-01 03:15:50 +00:00
|
|
|
// release our pref style sheet, if we have one still
|
|
|
|
ClearPreferenceStyleRules();
|
|
|
|
|
|
|
|
mIsDestroying = PR_TRUE;
|
|
|
|
|
2002-06-20 20:14:59 +00:00
|
|
|
// We can't release all the event content in
|
|
|
|
// mCurrentEventContentStack here since there might be code on the
|
|
|
|
// stack that will release the event content too. Double release
|
|
|
|
// bad!
|
|
|
|
|
|
|
|
// The frames will be torn down, so remove them from the current
|
|
|
|
// event frame stack (since they'd be dangling references if we'd
|
|
|
|
// leave them in) and null out the mCurrentEventFrame pointer as
|
|
|
|
// well.
|
|
|
|
|
|
|
|
mCurrentEventFrame = nsnull;
|
2001-08-01 03:15:50 +00:00
|
|
|
|
2002-06-20 20:14:59 +00:00
|
|
|
PRInt32 i, count = mCurrentEventFrameStack.Count();
|
2001-08-01 03:15:50 +00:00
|
|
|
for (i = 0; i < count; i++) {
|
2002-06-20 20:14:59 +00:00
|
|
|
mCurrentEventFrameStack.ReplaceElementAt(nsnull, i);
|
2001-08-01 03:15:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (mViewManager) {
|
2002-04-11 03:24:18 +00:00
|
|
|
// Clear the view manager's weak pointer back to |this| in case it
|
|
|
|
// was leaked.
|
|
|
|
mViewManager->SetViewObserver(nsnull);
|
2001-08-01 03:15:50 +00:00
|
|
|
mViewManager = nsnull;
|
|
|
|
}
|
|
|
|
|
2003-03-06 19:14:17 +00:00
|
|
|
mStyleSet->BeginShutdown(mPresContext);
|
|
|
|
|
2001-08-01 03:15:50 +00:00
|
|
|
// This shell must be removed from the document before the frame
|
|
|
|
// hierarchy is torn down to avoid finding deleted frames through
|
|
|
|
// this presshell while the frames are being torn down
|
|
|
|
if (mDocument) {
|
|
|
|
mDocument->DeleteShell(this);
|
|
|
|
}
|
|
|
|
|
2007-02-13 04:46:57 +00:00
|
|
|
// Revoke any pending reflow event. We need to do this and cancel
|
|
|
|
// pending reflows before we destroy the frame manager, since
|
|
|
|
// apparently frame destruction sometimes spins the event queue when
|
|
|
|
// plug-ins are involved(!).
|
|
|
|
mReflowEvent.Revoke();
|
|
|
|
|
|
|
|
CancelAllPendingReflows();
|
2007-12-01 07:22:44 +00:00
|
|
|
CancelPostedReflowCallbacks();
|
2007-02-13 04:46:57 +00:00
|
|
|
|
2001-08-01 03:15:50 +00:00
|
|
|
// Destroy the frame manager. This will destroy the frame hierarchy
|
2004-04-12 21:53:22 +00:00
|
|
|
mFrameConstructor->WillDestroyFrameTree();
|
2004-03-06 04:46:11 +00:00
|
|
|
FrameManager()->Destroy();
|
2001-08-01 03:15:50 +00:00
|
|
|
|
2006-07-12 07:41:11 +00:00
|
|
|
NS_WARN_IF_FALSE(!mWeakFrames, "Weak frames alive after destroying FrameManager");
|
|
|
|
while (mWeakFrames) {
|
|
|
|
mWeakFrames->Clear(this);
|
|
|
|
}
|
|
|
|
|
2001-08-01 03:15:50 +00:00
|
|
|
// Let the style set do its cleanup.
|
2003-03-06 19:14:17 +00:00
|
|
|
mStyleSet->Shutdown(mPresContext);
|
2004-01-07 22:30:53 +00:00
|
|
|
|
2001-08-01 03:15:50 +00:00
|
|
|
if (mPresContext) {
|
2005-12-06 04:53:03 +00:00
|
|
|
// Clear out the prescontext's property table -- since our frame tree is
|
|
|
|
// now dead, we shouldn't be looking up any more properties in that table.
|
|
|
|
// We want to do this before we call SetShell() on the prescontext, so
|
|
|
|
// property destructors can usefully call GetPresShell() on the
|
|
|
|
// prescontext.
|
|
|
|
mPresContext->PropertyTable()->DeleteAllProperties();
|
|
|
|
|
|
|
|
// We hold a reference to the pres context, and it holds a weak link back
|
|
|
|
// to us. To avoid the pres context having a dangling reference, set its
|
|
|
|
// pres shell to NULL
|
2001-08-01 03:15:50 +00:00
|
|
|
mPresContext->SetShell(nsnull);
|
2004-08-18 22:13:10 +00:00
|
|
|
|
|
|
|
// Clear the link handler (weak reference) as well
|
|
|
|
mPresContext->SetLinkHandler(nsnull);
|
2001-08-01 03:15:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
KillResizeEventTimer();
|
|
|
|
|
2004-02-25 09:10:06 +00:00
|
|
|
mHaveShutDown = PR_TRUE;
|
|
|
|
|
1998-04-13 20:24:54 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-03-31 07:02:06 +00:00
|
|
|
// Dynamic stack memory allocation
|
2007-01-17 23:53:47 +00:00
|
|
|
/* virtual */ void
|
2000-03-31 07:02:06 +00:00
|
|
|
PresShell::PushStackMemory()
|
|
|
|
{
|
2007-01-17 23:53:47 +00:00
|
|
|
mStackArena.Push();
|
2000-03-31 07:02:06 +00:00
|
|
|
}
|
|
|
|
|
2007-01-17 23:53:47 +00:00
|
|
|
/* virtual */ void
|
2000-03-31 07:02:06 +00:00
|
|
|
PresShell::PopStackMemory()
|
|
|
|
{
|
2007-01-17 23:53:47 +00:00
|
|
|
mStackArena.Pop();
|
2000-03-31 07:02:06 +00:00
|
|
|
}
|
|
|
|
|
2007-01-17 23:53:47 +00:00
|
|
|
/* virtual */ void*
|
|
|
|
PresShell::AllocateStackMemory(size_t aSize)
|
2000-03-31 07:02:06 +00:00
|
|
|
{
|
2007-01-17 23:53:47 +00:00
|
|
|
return mStackArena.Allocate(aSize);
|
2000-03-31 07:02:06 +00:00
|
|
|
}
|
|
|
|
|
2004-04-13 00:28:44 +00:00
|
|
|
void
|
1999-12-04 23:49:50 +00:00
|
|
|
PresShell::FreeFrame(size_t aSize, void* aPtr)
|
|
|
|
{
|
1999-12-07 04:36:08 +00:00
|
|
|
mFrameArena.FreeFrame(aSize, aPtr);
|
1999-12-04 23:49:50 +00:00
|
|
|
}
|
|
|
|
|
2004-04-13 00:28:44 +00:00
|
|
|
void*
|
|
|
|
PresShell::AllocateFrame(size_t aSize)
|
1999-12-04 23:49:50 +00:00
|
|
|
{
|
2004-04-13 00:28:44 +00:00
|
|
|
return mFrameArena.AllocateFrame(aSize);
|
1999-12-04 23:49:50 +00:00
|
|
|
}
|
|
|
|
|
2004-08-29 03:08:44 +00:00
|
|
|
void
|
|
|
|
nsIPresShell::SetAuthorStyleDisabled(PRBool aStyleDisabled)
|
2004-08-05 11:38:42 +00:00
|
|
|
{
|
|
|
|
if (aStyleDisabled != mStyleSet->GetAuthorStyleDisabled()) {
|
2004-08-29 03:08:44 +00:00
|
|
|
mStyleSet->SetAuthorStyleDisabled(aStyleDisabled);
|
|
|
|
ReconstructStyleData();
|
2004-08-05 11:38:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-08-29 03:08:44 +00:00
|
|
|
PRBool
|
|
|
|
nsIPresShell::GetAuthorStyleDisabled()
|
2000-10-11 08:33:01 +00:00
|
|
|
{
|
2004-08-29 03:08:44 +00:00
|
|
|
return mStyleSet->GetAuthorStyleDisabled();
|
2000-10-11 08:33:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::SetPreferenceStyleRules(PRBool aForceReflow)
|
|
|
|
{
|
2001-11-01 04:40:59 +00:00
|
|
|
if (!mDocument) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
|
2005-11-28 23:56:44 +00:00
|
|
|
nsPIDOMWindow *window = mDocument->GetWindow();
|
2001-11-01 04:40:59 +00:00
|
|
|
|
2005-11-28 23:56:44 +00:00
|
|
|
// If the document doesn't have a window there's no need to notify
|
|
|
|
// its presshell about changes to preferences since the document is
|
|
|
|
// in a state where it doesn't matter any more (see
|
2001-11-01 04:40:59 +00:00
|
|
|
// DocumentViewerImpl::Close()).
|
|
|
|
|
2005-11-28 23:56:44 +00:00
|
|
|
if (!window) {
|
2001-11-01 04:40:59 +00:00
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
|
2000-10-11 08:33:01 +00:00
|
|
|
NS_PRECONDITION(mPresContext, "presContext cannot be null");
|
|
|
|
if (mPresContext) {
|
|
|
|
nsresult result = NS_OK;
|
|
|
|
|
|
|
|
// first, make sure this is not a chrome shell
|
2004-02-01 10:09:07 +00:00
|
|
|
nsCOMPtr<nsISupports> container = mPresContext->GetContainer();
|
|
|
|
if (container) {
|
2000-10-11 08:33:01 +00:00
|
|
|
nsCOMPtr<nsIDocShellTreeItem> docShell(do_QueryInterface(container, &result));
|
|
|
|
if (NS_SUCCEEDED(result) && docShell){
|
|
|
|
PRInt32 docShellType;
|
|
|
|
result = docShell->GetItemType(&docShellType);
|
|
|
|
if (NS_SUCCEEDED(result)){
|
|
|
|
if (nsIDocShellTreeItem::typeChrome == docShellType){
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
|
2000-11-13 08:27:01 +00:00
|
|
|
#ifdef DEBUG_attinasi
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("Setting Preference Style Rules:\n");
|
|
|
|
#endif
|
2000-10-11 08:33:01 +00:00
|
|
|
// if here, we need to create rules for the prefs
|
|
|
|
// - this includes the background-color, the text-color,
|
|
|
|
// the link color, the visited link color and the link-underlining
|
|
|
|
|
|
|
|
// first clear any exising rules
|
|
|
|
result = ClearPreferenceStyleRules();
|
|
|
|
|
|
|
|
// now the link rules (must come after the color rules, or links will not be correct color!)
|
2001-11-06 10:04:05 +00:00
|
|
|
// XXX - when there is both an override and agent pref stylesheet this won't matter,
|
|
|
|
// as the color rules will be overrides and the links rules will be agent
|
2000-10-11 08:33:01 +00:00
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
result = SetPrefLinkRules();
|
|
|
|
}
|
2001-04-09 22:17:11 +00:00
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
result = SetPrefFocusRules();
|
|
|
|
}
|
2003-06-26 06:10:03 +00:00
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
result = SetPrefNoScriptRule();
|
|
|
|
}
|
2005-03-03 18:04:38 +00:00
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
result = SetPrefNoFramesRule();
|
|
|
|
}
|
2000-10-11 08:33:01 +00:00
|
|
|
}
|
2000-11-13 08:27:01 +00:00
|
|
|
#ifdef DEBUG_attinasi
|
2000-10-28 22:17:53 +00:00
|
|
|
printf( "Preference Style Rules set: error=%ld\n", (long)result);
|
2007-07-25 17:14:13 +00:00
|
|
|
#endif
|
2000-10-11 08:33:01 +00:00
|
|
|
|
2007-07-25 17:14:13 +00:00
|
|
|
// Note that this method never needs to force any calculation; the caller
|
|
|
|
// will recalculate style if needed
|
2000-10-11 08:33:01 +00:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
2001-11-01 04:40:59 +00:00
|
|
|
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
2000-10-11 08:33:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
nsresult PresShell::ClearPreferenceStyleRules(void)
|
|
|
|
{
|
|
|
|
nsresult result = NS_OK;
|
|
|
|
if (mPrefStyleSheet) {
|
|
|
|
NS_ASSERTION(mStyleSet, "null styleset entirely unexpected!");
|
|
|
|
if (mStyleSet) {
|
|
|
|
// remove the sheet from the styleset:
|
|
|
|
// - note that we have to check for success by comparing the count before and after...
|
|
|
|
#ifdef NS_DEBUG
|
2004-01-07 22:30:53 +00:00
|
|
|
PRInt32 numBefore = mStyleSet->SheetCount(nsStyleSet::eUserSheet);
|
2002-01-14 14:47:21 +00:00
|
|
|
NS_ASSERTION(numBefore > 0, "no user stylesheets in styleset, but we have one!");
|
2000-10-11 08:33:01 +00:00
|
|
|
#endif
|
2004-01-07 22:30:53 +00:00
|
|
|
mStyleSet->RemoveStyleSheet(nsStyleSet::eUserSheet, mPrefStyleSheet);
|
2000-10-11 08:33:01 +00:00
|
|
|
|
2000-11-13 08:27:01 +00:00
|
|
|
#ifdef DEBUG_attinasi
|
2002-01-14 14:47:21 +00:00
|
|
|
NS_ASSERTION((numBefore - 1) == mStyleSet->GetNumberOfUserStyleSheets(),
|
2000-10-11 08:33:01 +00:00
|
|
|
"Pref stylesheet was not removed");
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("PrefStyleSheet removed\n");
|
|
|
|
#endif
|
2000-10-11 08:33:01 +00:00
|
|
|
// clear the sheet pointer: it is strictly historical now
|
2008-01-18 05:23:44 +00:00
|
|
|
mPrefStyleSheet = nsnull;
|
2000-10-11 08:33:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult PresShell::CreatePreferenceStyleSheet(void)
|
|
|
|
{
|
2003-07-18 01:26:47 +00:00
|
|
|
NS_ASSERTION(!mPrefStyleSheet, "prefStyleSheet already exists");
|
2008-01-18 05:23:44 +00:00
|
|
|
nsresult result;
|
|
|
|
mPrefStyleSheet = do_CreateInstance(kCSSStyleSheetCID, &result);
|
2000-10-11 08:33:01 +00:00
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
NS_ASSERTION(mPrefStyleSheet, "null but no error");
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
|
|
result = NS_NewURI(getter_AddRefs(uri), "about:PreferenceStyleSheet", nsnull);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
NS_ASSERTION(uri, "null but no error");
|
2008-02-13 21:47:22 +00:00
|
|
|
result = mPrefStyleSheet->SetURIs(uri, uri, uri);
|
2000-10-11 08:33:01 +00:00
|
|
|
if (NS_SUCCEEDED(result)) {
|
2002-12-03 05:48:14 +00:00
|
|
|
mPrefStyleSheet->SetComplete();
|
2008-01-18 05:23:44 +00:00
|
|
|
PRUint32 index;
|
|
|
|
result =
|
|
|
|
mPrefStyleSheet->InsertRuleInternal(NS_LITERAL_STRING("@namespace url(http://www.w3.org/1999/xhtml);"),
|
|
|
|
0, &index);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
mStyleSet->AppendStyleSheet(nsStyleSet::eUserSheet, mPrefStyleSheet);
|
2003-07-18 01:26:47 +00:00
|
|
|
}
|
2000-10-11 08:33:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-11-13 08:27:01 +00:00
|
|
|
#ifdef DEBUG_attinasi
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("CreatePrefStyleSheet completed: error=%ld\n",(long)result);
|
|
|
|
#endif
|
2000-10-11 08:33:01 +00:00
|
|
|
|
2008-01-18 05:23:44 +00:00
|
|
|
if (NS_FAILED(result)) {
|
|
|
|
mPrefStyleSheet = nsnull;
|
|
|
|
}
|
|
|
|
|
2000-10-11 08:33:01 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2003-07-18 01:26:47 +00:00
|
|
|
// XXX We want these after the @namespace rule. Does order matter
|
|
|
|
// for these rules, or can we call nsICSSStyleRule::StyleRuleCount()
|
|
|
|
// and just "append"?
|
|
|
|
static PRUint32 sInsertPrefSheetRulesAt = 1;
|
|
|
|
|
2003-06-26 06:10:03 +00:00
|
|
|
nsresult
|
|
|
|
PresShell::SetPrefNoScriptRule()
|
|
|
|
{
|
2005-01-03 19:37:54 +00:00
|
|
|
nsresult rv = NS_OK;
|
|
|
|
|
2006-07-25 00:29:26 +00:00
|
|
|
// also handle the case where print is done from print preview
|
|
|
|
// see bug #342439 for more details
|
2006-04-22 00:06:30 +00:00
|
|
|
PRBool scriptEnabled = mDocument->IsScriptEnabled() ||
|
2006-07-25 00:29:26 +00:00
|
|
|
((mPresContext->Type() == nsPresContext::eContext_PrintPreview ||
|
2006-07-25 01:34:31 +00:00
|
|
|
mPresContext->Type() == nsPresContext::eContext_Print) &&
|
2006-04-22 00:06:30 +00:00
|
|
|
NS_PTR_TO_INT32(mDocument->GetProperty(
|
2008-04-15 18:02:22 +00:00
|
|
|
nsGkAtoms::scriptEnabledBeforePrintPreview)));
|
2006-04-22 00:06:30 +00:00
|
|
|
|
|
|
|
if (scriptEnabled) {
|
2003-06-26 06:10:03 +00:00
|
|
|
if (!mPrefStyleSheet) {
|
|
|
|
rv = CreatePreferenceStyleSheet();
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
}
|
2008-01-18 05:23:44 +00:00
|
|
|
|
2003-06-26 06:10:03 +00:00
|
|
|
PRUint32 index = 0;
|
2008-01-18 05:23:44 +00:00
|
|
|
mPrefStyleSheet->
|
|
|
|
InsertRuleInternal(NS_LITERAL_STRING("noscript{display:none!important}"),
|
|
|
|
sInsertPrefSheetRulesAt, &index);
|
2003-06-26 06:10:03 +00:00
|
|
|
}
|
2005-01-03 19:37:54 +00:00
|
|
|
|
|
|
|
return rv;
|
2003-06-26 06:10:03 +00:00
|
|
|
}
|
|
|
|
|
2005-03-03 18:04:38 +00:00
|
|
|
nsresult PresShell::SetPrefNoFramesRule(void)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(mPresContext,"null prescontext not allowed");
|
|
|
|
if (!mPresContext) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
|
|
|
|
if (!mPrefStyleSheet) {
|
|
|
|
rv = CreatePreferenceStyleSheet();
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_ASSERTION(mPrefStyleSheet, "prefstylesheet should not be null");
|
|
|
|
|
|
|
|
PRBool allowSubframes = PR_TRUE;
|
|
|
|
nsCOMPtr<nsISupports> container = mPresContext->GetContainer();
|
|
|
|
nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(container));
|
|
|
|
if (docShell) {
|
|
|
|
docShell->GetAllowSubframes(&allowSubframes);
|
|
|
|
}
|
|
|
|
if (!allowSubframes) {
|
|
|
|
PRUint32 index = 0;
|
2008-01-18 05:23:44 +00:00
|
|
|
rv = mPrefStyleSheet->
|
|
|
|
InsertRuleInternal(NS_LITERAL_STRING("noframes{display:block}"),
|
|
|
|
sInsertPrefSheetRulesAt, &index);
|
2005-03-03 18:04:38 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2008-01-18 05:23:44 +00:00
|
|
|
rv = mPrefStyleSheet->
|
|
|
|
InsertRuleInternal(NS_LITERAL_STRING("frame, frameset, iframe {display:none!important}"),
|
|
|
|
sInsertPrefSheetRulesAt, &index);
|
2005-03-03 18:04:38 +00:00
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2000-10-11 08:33:01 +00:00
|
|
|
nsresult PresShell::SetPrefLinkRules(void)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(mPresContext,"null prescontext not allowed");
|
2003-10-15 01:56:12 +00:00
|
|
|
if (!mPresContext) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2000-10-11 08:33:01 +00:00
|
|
|
|
2003-10-15 01:56:12 +00:00
|
|
|
nsresult rv = NS_OK;
|
|
|
|
|
|
|
|
if (!mPrefStyleSheet) {
|
|
|
|
rv = CreatePreferenceStyleSheet();
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_ASSERTION(mPrefStyleSheet, "prefstylesheet should not be null");
|
|
|
|
|
|
|
|
// support default link colors:
|
|
|
|
// this means the link colors need to be overridable,
|
|
|
|
// which they are if we put them in the agent stylesheet,
|
|
|
|
// though if using an override sheet this will cause authors grief still
|
|
|
|
// In the agent stylesheet, they are !important when we are ignoring document colors
|
|
|
|
|
2004-01-31 22:41:40 +00:00
|
|
|
nscolor linkColor(mPresContext->DefaultLinkColor());
|
|
|
|
nscolor activeColor(mPresContext->DefaultActiveLinkColor());
|
|
|
|
nscolor visitedColor(mPresContext->DefaultVisitedLinkColor());
|
2003-10-15 01:56:12 +00:00
|
|
|
|
2007-05-16 21:10:31 +00:00
|
|
|
NS_NAMED_LITERAL_STRING(ruleClose, "}");
|
2003-10-15 01:56:12 +00:00
|
|
|
PRUint32 index = 0;
|
|
|
|
nsAutoString strColor;
|
|
|
|
|
|
|
|
// insert a rule to color links: '*|*:link {color: #RRGGBB [!important];}'
|
|
|
|
ColorToString(linkColor, strColor);
|
2008-01-18 05:23:44 +00:00
|
|
|
rv = mPrefStyleSheet->
|
|
|
|
InsertRuleInternal(NS_LITERAL_STRING("*|*:link{color:") +
|
|
|
|
strColor + ruleClose,
|
|
|
|
sInsertPrefSheetRulesAt, &index);
|
2003-10-15 01:56:12 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
// - visited links: '*|*:visited {color: #RRGGBB [!important];}'
|
|
|
|
ColorToString(visitedColor, strColor);
|
2008-01-18 05:23:44 +00:00
|
|
|
rv = mPrefStyleSheet->
|
|
|
|
InsertRuleInternal(NS_LITERAL_STRING("*|*:visited{color:") +
|
|
|
|
strColor + ruleClose,
|
|
|
|
sInsertPrefSheetRulesAt, &index);
|
2003-10-15 01:56:12 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
// - active links: '*|*:-moz-any-link:active {color: #RRGGBB [!important];}'
|
|
|
|
ColorToString(activeColor, strColor);
|
2008-01-18 05:23:44 +00:00
|
|
|
rv = mPrefStyleSheet->
|
|
|
|
InsertRuleInternal(NS_LITERAL_STRING("*|*:-moz-any-link:active{color:") +
|
|
|
|
strColor + ruleClose,
|
|
|
|
sInsertPrefSheetRulesAt, &index);
|
2003-10-15 01:56:12 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2004-02-20 17:49:01 +00:00
|
|
|
PRBool underlineLinks =
|
|
|
|
mPresContext->GetCachedBoolPref(kPresContext_UnderlineLinks);
|
2003-10-15 01:56:12 +00:00
|
|
|
|
|
|
|
if (underlineLinks) {
|
|
|
|
// create a rule to make underlining happen
|
|
|
|
// '*|*:-moz-any-link {text-decoration:[underline|none];}'
|
|
|
|
// no need for important, we want these to be overridable
|
|
|
|
// NOTE: these must go in the agent stylesheet or they cannot be
|
|
|
|
// overridden by authors
|
2008-01-18 05:23:44 +00:00
|
|
|
rv = mPrefStyleSheet->
|
|
|
|
InsertRuleInternal(NS_LITERAL_STRING("*|*:-moz-any-link{text-decoration:underline}"),
|
|
|
|
sInsertPrefSheetRulesAt, &index);
|
2000-10-11 08:33:01 +00:00
|
|
|
} else {
|
2008-01-18 05:23:44 +00:00
|
|
|
rv = mPrefStyleSheet->
|
|
|
|
InsertRuleInternal(NS_LITERAL_STRING("*|*:-moz-any-link{text-decoration:none}"),
|
|
|
|
sInsertPrefSheetRulesAt, &index);
|
2000-10-11 08:33:01 +00:00
|
|
|
}
|
2003-10-15 01:56:12 +00:00
|
|
|
|
|
|
|
return rv;
|
2000-10-11 08:33:01 +00:00
|
|
|
}
|
|
|
|
|
2001-04-09 22:17:11 +00:00
|
|
|
nsresult PresShell::SetPrefFocusRules(void)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(mPresContext,"null prescontext not allowed");
|
|
|
|
nsresult result = NS_OK;
|
|
|
|
|
|
|
|
if (!mPresContext)
|
|
|
|
result = NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(result) && !mPrefStyleSheet)
|
|
|
|
result = CreatePreferenceStyleSheet();
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
NS_ASSERTION(mPrefStyleSheet, "prefstylesheet should not be null");
|
|
|
|
|
2008-01-18 05:23:44 +00:00
|
|
|
if (mPresContext->GetUseFocusColors()) {
|
|
|
|
nscolor focusBackground(mPresContext->FocusBackgroundColor());
|
|
|
|
nscolor focusText(mPresContext->FocusTextColor());
|
|
|
|
|
|
|
|
// insert a rule to make focus the preferred color
|
|
|
|
PRUint32 index = 0;
|
|
|
|
nsAutoString strRule, strColor;
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////
|
|
|
|
// - focus: '*:focus
|
|
|
|
ColorToString(focusText,strColor);
|
|
|
|
strRule.AppendLiteral("*:focus,*:focus>font {color: ");
|
|
|
|
strRule.Append(strColor);
|
|
|
|
strRule.AppendLiteral(" !important; background-color: ");
|
|
|
|
ColorToString(focusBackground,strColor);
|
|
|
|
strRule.Append(strColor);
|
|
|
|
strRule.AppendLiteral(" !important; } ");
|
|
|
|
// insert the rules
|
|
|
|
result = mPrefStyleSheet->
|
|
|
|
InsertRuleInternal(strRule, sInsertPrefSheetRulesAt, &index);
|
|
|
|
}
|
|
|
|
PRUint8 focusRingWidth = mPresContext->FocusRingWidth();
|
|
|
|
PRBool focusRingOnAnything = mPresContext->GetFocusRingOnAnything();
|
|
|
|
|
|
|
|
if ((NS_SUCCEEDED(result) && focusRingWidth != 1 && focusRingWidth <= 4 ) || focusRingOnAnything) {
|
|
|
|
PRUint32 index = 0;
|
|
|
|
nsAutoString strRule;
|
|
|
|
if (!focusRingOnAnything)
|
|
|
|
strRule.AppendLiteral("*|*:link:focus, *|*:visited"); // If we only want focus rings on the normal things like links
|
|
|
|
strRule.AppendLiteral(":focus {outline: "); // For example 3px dotted WindowText (maximum 4)
|
|
|
|
strRule.AppendInt(focusRingWidth);
|
|
|
|
strRule.AppendLiteral("px dotted WindowText !important; } "); // For example 3px dotted WindowText
|
|
|
|
// insert the rules
|
|
|
|
result = mPrefStyleSheet->
|
|
|
|
InsertRuleInternal(strRule, sInsertPrefSheetRulesAt, &index);
|
|
|
|
NS_ENSURE_SUCCESS(result, result);
|
|
|
|
if (focusRingWidth != 1) {
|
|
|
|
// If the focus ring width is different from the default, fix buttons with rings
|
|
|
|
strRule.AssignLiteral("button::-moz-focus-inner, input[type=\"reset\"]::-moz-focus-inner,");
|
|
|
|
strRule.AppendLiteral("input[type=\"button\"]::-moz-focus-inner, ");
|
|
|
|
strRule.AppendLiteral("input[type=\"submit\"]::-moz-focus-inner { padding: 1px 2px 1px 2px; border: ");
|
2001-04-09 22:17:11 +00:00
|
|
|
strRule.AppendInt(focusRingWidth);
|
2008-01-18 05:23:44 +00:00
|
|
|
strRule.AppendLiteral("px dotted transparent !important; } ");
|
|
|
|
result = mPrefStyleSheet->
|
|
|
|
InsertRuleInternal(strRule, sInsertPrefSheetRulesAt, &index);
|
2001-09-08 21:42:02 +00:00
|
|
|
NS_ENSURE_SUCCESS(result, result);
|
|
|
|
|
2008-01-18 05:23:44 +00:00
|
|
|
strRule.AssignLiteral("button:focus::-moz-focus-inner, input[type=\"reset\"]:focus::-moz-focus-inner,");
|
|
|
|
strRule.AppendLiteral("input[type=\"button\"]:focus::-moz-focus-inner, input[type=\"submit\"]:focus::-moz-focus-inner {");
|
|
|
|
strRule.AppendLiteral("border-color: ButtonText !important; }");
|
|
|
|
result = mPrefStyleSheet->
|
|
|
|
InsertRuleInternal(strRule, sInsertPrefSheetRulesAt, &index);
|
2001-04-09 22:17:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2006-06-08 14:32:20 +00:00
|
|
|
void
|
|
|
|
PresShell::AddUserSheet(nsISupports* aSheet)
|
|
|
|
{
|
|
|
|
// Make sure this does what DocumentViewerImpl::CreateStyleSet does wrt
|
|
|
|
// ordering. We want this new sheet to come after all the existing stylesheet
|
|
|
|
// service sheets, but before other user sheets; see nsIStyleSheetService.idl
|
|
|
|
// for the ordering. Just remove and readd all the nsStyleSheetService
|
|
|
|
// sheets.
|
|
|
|
nsCOMPtr<nsIStyleSheetService> dummy =
|
|
|
|
do_GetService(NS_STYLESHEETSERVICE_CONTRACTID);
|
|
|
|
|
|
|
|
mStyleSet->BeginUpdate();
|
|
|
|
|
|
|
|
nsStyleSheetService *sheetService = nsStyleSheetService::gInstance;
|
|
|
|
nsCOMArray<nsIStyleSheet> & userSheets = *sheetService->UserStyleSheets();
|
|
|
|
PRInt32 i;
|
|
|
|
// Iterate forwards when removing so the searches for RemoveStyleSheet are as
|
|
|
|
// short as possible.
|
|
|
|
for (i = 0; i < userSheets.Count(); ++i) {
|
|
|
|
mStyleSet->RemoveStyleSheet(nsStyleSet::eUserSheet, userSheets[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now iterate backwards, so that the order of userSheets will be the same as
|
|
|
|
// the order of sheets from it in the style set.
|
|
|
|
for (i = userSheets.Count() - 1; i >= 0; --i) {
|
|
|
|
mStyleSet->PrependStyleSheet(nsStyleSet::eUserSheet, userSheets[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
mStyleSet->EndUpdate();
|
|
|
|
|
|
|
|
ReconstructStyleData();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
PresShell::AddAgentSheet(nsISupports* aSheet)
|
|
|
|
{
|
|
|
|
// Make sure this does what DocumentViewerImpl::CreateStyleSet does
|
|
|
|
// wrt ordering.
|
|
|
|
nsCOMPtr<nsIStyleSheet> sheet = do_QueryInterface(aSheet);
|
|
|
|
if (!sheet) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
mStyleSet->AppendStyleSheet(nsStyleSet::eAgentSheet, sheet);
|
|
|
|
ReconstructStyleData();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
PresShell::RemoveSheet(nsStyleSet::sheetType aType, nsISupports* aSheet)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIStyleSheet> sheet = do_QueryInterface(aSheet);
|
|
|
|
if (!sheet) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
mStyleSet->RemoveStyleSheet(aType, sheet);
|
|
|
|
ReconstructStyleData();
|
|
|
|
}
|
2001-04-09 22:17:11 +00:00
|
|
|
|
2000-04-28 06:21:31 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::SetDisplaySelection(PRInt16 aToggle)
|
|
|
|
{
|
2006-04-26 02:01:07 +00:00
|
|
|
mSelection->SetDisplaySelection(aToggle);
|
|
|
|
return NS_OK;
|
2000-04-28 06:21:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::GetDisplaySelection(PRInt16 *aToggle)
|
|
|
|
{
|
2006-04-26 02:01:07 +00:00
|
|
|
*aToggle = mSelection->GetDisplaySelection();
|
|
|
|
return NS_OK;
|
2000-04-28 06:21:31 +00:00
|
|
|
}
|
|
|
|
|
1999-02-12 17:45:58 +00:00
|
|
|
NS_IMETHODIMP
|
2000-09-14 11:45:01 +00:00
|
|
|
PresShell::GetSelection(SelectionType aType, nsISelection **aSelection)
|
1998-12-08 18:26:06 +00:00
|
|
|
{
|
|
|
|
if (!aSelection || !mSelection)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
2006-04-26 02:01:07 +00:00
|
|
|
|
|
|
|
*aSelection = mSelection->GetSelection(aType);
|
|
|
|
|
|
|
|
if (!(*aSelection))
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
|
|
|
|
NS_ADDREF(*aSelection);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsISelection*
|
|
|
|
PresShell::GetCurrentSelection(SelectionType aType)
|
|
|
|
{
|
|
|
|
if (!mSelection)
|
|
|
|
return nsnull;
|
|
|
|
|
|
|
|
return mSelection->GetSelection(aType);
|
1998-12-08 18:26:06 +00:00
|
|
|
}
|
|
|
|
|
1999-08-30 21:54:40 +00:00
|
|
|
NS_IMETHODIMP
|
2002-06-13 20:35:12 +00:00
|
|
|
PresShell::ScrollSelectionIntoView(SelectionType aType, SelectionRegion aRegion, PRBool aIsSynchronous)
|
1999-08-30 21:54:40 +00:00
|
|
|
{
|
|
|
|
if (!mSelection)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
|
2002-06-13 20:35:12 +00:00
|
|
|
return mSelection->ScrollSelectionIntoView(aType, aRegion, aIsSynchronous);
|
1999-08-30 21:54:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::RepaintSelection(SelectionType aType)
|
|
|
|
{
|
|
|
|
if (!mSelection)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
|
2006-04-26 02:01:07 +00:00
|
|
|
return mSelection->RepaintSelection(aType);
|
1999-08-30 21:54:40 +00:00
|
|
|
}
|
|
|
|
|
1998-04-13 20:24:54 +00:00
|
|
|
// Make shell be a document observer
|
1998-12-29 04:56:31 +00:00
|
|
|
NS_IMETHODIMP
|
1998-05-09 03:22:41 +00:00
|
|
|
PresShell::BeginObservingDocument()
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2007-05-14 03:52:48 +00:00
|
|
|
if (mDocument && !mIsDestroying) {
|
2006-08-31 03:17:45 +00:00
|
|
|
mDocument->AddObserver(this);
|
2005-03-25 04:27:21 +00:00
|
|
|
if (mIsDocumentGone) {
|
|
|
|
NS_WARNING("Adding a presshell that was disconnected from the document "
|
|
|
|
"as a document observer? Sounds wrong...");
|
|
|
|
mIsDocumentGone = PR_FALSE;
|
|
|
|
}
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
1998-12-29 04:56:31 +00:00
|
|
|
return NS_OK;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Make shell stop being a document observer
|
1998-12-29 04:56:31 +00:00
|
|
|
NS_IMETHODIMP
|
1998-05-09 03:22:41 +00:00
|
|
|
PresShell::EndObservingDocument()
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2005-02-18 16:11:53 +00:00
|
|
|
// XXXbz do we need to tell the frame constructor that the document
|
|
|
|
// is gone, perhaps? Except for printing it's NOT gone, sometimes.
|
2001-05-01 22:54:11 +00:00
|
|
|
mIsDocumentGone = PR_TRUE;
|
1999-05-04 23:27:42 +00:00
|
|
|
if (mDocument) {
|
2006-08-31 03:17:45 +00:00
|
|
|
mDocument->RemoveObserver(this);
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
1998-12-29 04:56:31 +00:00
|
|
|
return NS_OK;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
1999-08-27 21:50:37 +00:00
|
|
|
#ifdef DEBUG_kipp
|
|
|
|
char* nsPresShell_ReflowStackPointerTop;
|
|
|
|
#endif
|
|
|
|
|
2003-04-03 08:14:51 +00:00
|
|
|
static void CheckForFocus(nsPIDOMWindow* aOurWindow,
|
|
|
|
nsIFocusController* aFocusController,
|
|
|
|
nsIDocument* aDocument)
|
|
|
|
{
|
2005-07-30 20:57:07 +00:00
|
|
|
NS_ASSERTION(aOurWindow->IsOuterWindow(),
|
|
|
|
"Uh, our window has to be an outer window!");
|
|
|
|
|
2003-04-03 08:14:51 +00:00
|
|
|
// Now that we have a root frame, we can set focus on the presshell.
|
|
|
|
// We do this only if our DOM window is currently focused or is an
|
|
|
|
// an ancestor of a previously focused window.
|
2000-02-13 06:07:38 +00:00
|
|
|
|
2003-04-03 08:14:51 +00:00
|
|
|
if (!aFocusController)
|
|
|
|
return;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMWindowInternal> ourWin = do_QueryInterface(aOurWindow);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMWindowInternal> focusedWindow;
|
|
|
|
aFocusController->GetFocusedWindow(getter_AddRefs(focusedWindow));
|
|
|
|
if (!focusedWindow) {
|
|
|
|
// This should never really happen, but if it does, assume
|
|
|
|
// we can focus ourself to keep the window from being keydead.
|
|
|
|
focusedWindow = ourWin;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Walk up the document chain, starting with focusedWindow's document.
|
|
|
|
// We stop walking when we find a document that has a null DOMWindow
|
|
|
|
// (meaning that the DOMWindow has a new document now) or find ourWin
|
2003-05-12 07:11:16 +00:00
|
|
|
// as the document's window. We also stop if we hit aDocument, since
|
|
|
|
// that means there is a child document which loaded before us that's
|
|
|
|
// already been given focus.
|
2003-04-03 08:14:51 +00:00
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMDocument> focusedDOMDoc;
|
|
|
|
focusedWindow->GetDocument(getter_AddRefs(focusedDOMDoc));
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDocument> curDoc = do_QueryInterface(focusedDOMDoc);
|
2003-05-12 07:11:16 +00:00
|
|
|
if (!curDoc) {
|
|
|
|
// This can happen if the previously focused DOM window has been
|
|
|
|
// unhooked from its document during document teardown. We don't
|
2003-06-10 22:17:58 +00:00
|
|
|
// really have any other information to help us determine where
|
2003-05-12 07:11:16 +00:00
|
|
|
// focusedWindow fits into the DOM window hierarchy. For now, we'll
|
|
|
|
// go ahead and allow this window to take focus, so that something
|
|
|
|
// ends up focused.
|
|
|
|
|
|
|
|
curDoc = aDocument;
|
|
|
|
}
|
|
|
|
|
2003-04-03 08:14:51 +00:00
|
|
|
while (curDoc) {
|
2005-08-12 04:11:00 +00:00
|
|
|
nsPIDOMWindow *curWin = curDoc->GetWindow();
|
2005-07-30 20:57:07 +00:00
|
|
|
|
2005-08-12 04:11:00 +00:00
|
|
|
if (!curWin || curWin == ourWin)
|
2003-04-03 08:14:51 +00:00
|
|
|
break;
|
|
|
|
|
2003-10-22 06:09:48 +00:00
|
|
|
curDoc = curDoc->GetParentDocument();
|
|
|
|
if (curDoc == aDocument)
|
2003-05-12 07:11:16 +00:00
|
|
|
return;
|
2000-02-13 06:07:38 +00:00
|
|
|
}
|
2003-04-03 08:14:51 +00:00
|
|
|
|
|
|
|
if (!curDoc) {
|
|
|
|
// We reached the top of the document chain, and did not encounter ourWin
|
|
|
|
// or a windowless document. So, focus should be unaffected by this
|
|
|
|
// document load.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRBool active;
|
|
|
|
aFocusController->GetActive(&active);
|
|
|
|
if (active)
|
|
|
|
ourWin->Focus();
|
|
|
|
|
|
|
|
// We need to ensure that the focus controller is updated, since it may be
|
|
|
|
// suppressed when this function is called.
|
|
|
|
aFocusController->SetFocusedWindow(ourWin);
|
2000-02-13 06:07:38 +00:00
|
|
|
}
|
2000-05-15 03:37:21 +00:00
|
|
|
|
2002-09-06 05:44:31 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::GetDidInitialReflow(PRBool *aDidInitialReflow)
|
|
|
|
{
|
|
|
|
if (!aDidInitialReflow)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
*aDidInitialReflow = mDidInitialReflow;
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1998-08-28 02:54:06 +00:00
|
|
|
NS_IMETHODIMP
|
1998-09-10 19:32:14 +00:00
|
|
|
PresShell::InitialReflow(nscoord aWidth, nscoord aHeight)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2007-05-01 17:15:08 +00:00
|
|
|
if (mIsDestroying) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2006-05-15 17:51:35 +00:00
|
|
|
nsCOMPtr<nsIPresShell> kungFuDeathGrip(this);
|
2001-08-07 18:57:15 +00:00
|
|
|
mDidInitialReflow = PR_TRUE;
|
1998-09-10 19:32:14 +00:00
|
|
|
|
1999-12-23 02:02:33 +00:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
if (VERIFY_REFLOW_NOISY_RC & gVerifyReflowFlags) {
|
|
|
|
if (mDocument) {
|
2004-01-09 23:54:21 +00:00
|
|
|
nsIURI *uri = mDocument->GetDocumentURI();
|
1999-12-23 02:02:33 +00:00
|
|
|
if (uri) {
|
2002-03-06 07:48:55 +00:00
|
|
|
nsCAutoString url;
|
|
|
|
uri->GetSpec(url);
|
|
|
|
printf("*** PresShell::InitialReflow (this=%p, url='%s')\n", (void*)this, url.get());
|
1999-12-23 02:02:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2003-02-27 23:09:51 +00:00
|
|
|
if (mCaret)
|
|
|
|
mCaret->EraseCaret();
|
2004-10-09 01:39:21 +00:00
|
|
|
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
// XXX Do a full invalidate at the beginning so that invalidates along
|
|
|
|
// the way don't have region accumulation issues?
|
|
|
|
|
2007-05-01 17:15:08 +00:00
|
|
|
mPresContext->SetVisibleArea(nsRect(0, 0, aWidth, aHeight));
|
1998-04-13 20:24:54 +00:00
|
|
|
|
2003-10-22 06:09:48 +00:00
|
|
|
nsIContent *root = mDocument ? mDocument->GetRootContent() : nsnull;
|
1999-02-03 19:38:16 +00:00
|
|
|
|
1999-10-18 22:20:37 +00:00
|
|
|
// Get the root frame from the frame manager
|
2004-03-06 04:46:11 +00:00
|
|
|
nsIFrame* rootFrame = FrameManager()->GetRootFrame();
|
1999-10-18 22:20:37 +00:00
|
|
|
|
2001-06-20 03:27:48 +00:00
|
|
|
if (root) {
|
2002-08-24 14:41:28 +00:00
|
|
|
MOZ_TIMER_DEBUGLOG(("Reset and start: Frame Creation: PresShell::InitialReflow(), this=%p\n",
|
|
|
|
(void*)this));
|
1999-11-10 03:41:09 +00:00
|
|
|
MOZ_TIMER_RESET(mFrameCreationWatch);
|
|
|
|
MOZ_TIMER_START(mFrameCreationWatch);
|
1999-10-18 22:20:37 +00:00
|
|
|
|
2008-03-14 23:08:57 +00:00
|
|
|
{
|
|
|
|
nsAutoCauseReflowNotifier reflowNotifier(this);
|
|
|
|
mFrameConstructor->BeginUpdate();
|
|
|
|
|
|
|
|
if (!rootFrame) {
|
|
|
|
// Have style sheet processor construct a frame for the
|
|
|
|
// precursors to the root content object's frame
|
|
|
|
mFrameConstructor->ConstructRootFrame(root, &rootFrame);
|
|
|
|
FrameManager()->SetRootFrame(rootFrame);
|
|
|
|
}
|
1999-02-03 19:38:16 +00:00
|
|
|
|
2008-03-14 23:08:57 +00:00
|
|
|
// Have the style sheet processor construct frame for the root
|
|
|
|
// content object down
|
|
|
|
mFrameConstructor->ContentInserted(nsnull, root, 0, nsnull);
|
|
|
|
VERIFY_STYLE_TREE;
|
|
|
|
MOZ_TIMER_DEBUGLOG(("Stop: Frame Creation: PresShell::InitialReflow(), this=%p\n",
|
|
|
|
(void*)this));
|
|
|
|
MOZ_TIMER_STOP(mFrameCreationWatch);
|
2007-05-14 03:52:48 +00:00
|
|
|
|
2008-03-14 23:08:57 +00:00
|
|
|
// Something in mFrameConstructor->ContentInserted may have caused
|
|
|
|
// Destroy() to get called, bug 337586.
|
|
|
|
NS_ENSURE_STATE(!mHaveShutDown);
|
2008-03-11 02:18:15 +00:00
|
|
|
|
2008-03-14 23:08:57 +00:00
|
|
|
mFrameConstructor->EndUpdate();
|
|
|
|
}
|
2007-10-02 04:37:36 +00:00
|
|
|
|
2008-03-14 23:08:57 +00:00
|
|
|
// DidCauseReflow may have killed us too
|
|
|
|
NS_ENSURE_STATE(!mHaveShutDown);
|
2008-03-11 02:18:15 +00:00
|
|
|
|
2007-05-14 03:52:48 +00:00
|
|
|
// Run the XBL binding constructors for any new frames we've constructed
|
|
|
|
mDocument->BindingManager()->ProcessAttachedQueue();
|
|
|
|
|
|
|
|
// Constructors may have killed us too
|
|
|
|
NS_ENSURE_STATE(!mHaveShutDown);
|
|
|
|
|
|
|
|
// Now flush out pending restyles before we actually reflow, in
|
|
|
|
// case XBL constructors changed styles somewhere.
|
|
|
|
mFrameConstructor->ProcessPendingRestyles();
|
|
|
|
|
|
|
|
// And that might have run _more_ XBL constructors
|
|
|
|
NS_ENSURE_STATE(!mHaveShutDown);
|
|
|
|
|
|
|
|
// Now reget the root frame, since all that script might have affected it
|
|
|
|
// somehow. Currently that can't happen, as long as mHaveShutDown is
|
|
|
|
// false, but let's not rely on that.
|
|
|
|
rootFrame = FrameManager()->GetRootFrame();
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
1999-10-18 22:20:37 +00:00
|
|
|
if (rootFrame) {
|
2007-05-06 19:16:51 +00:00
|
|
|
// Note: Because the frame just got created, it has the NS_FRAME_IS_DIRTY
|
|
|
|
// bit set. Unset it so that FrameNeedsReflow() will work right.
|
|
|
|
NS_ASSERTION(mDirtyRoots.IndexOf(rootFrame) == -1,
|
|
|
|
"Why is the root in mDirtyRoots already?");
|
|
|
|
|
|
|
|
rootFrame->RemoveStateBits(NS_FRAME_IS_DIRTY |
|
|
|
|
NS_FRAME_HAS_DIRTY_CHILDREN);
|
|
|
|
FrameNeedsReflow(rootFrame, eResize, NS_FRAME_IS_DIRTY);
|
|
|
|
|
|
|
|
NS_ASSERTION(mDirtyRoots.IndexOf(rootFrame) != -1,
|
|
|
|
"Should be in mDirtyRoots now");
|
|
|
|
NS_ASSERTION(mReflowEvent.IsPending(), "Why no reflow event pending?");
|
1998-09-10 19:32:14 +00:00
|
|
|
}
|
|
|
|
|
2007-04-26 02:33:02 +00:00
|
|
|
// Restore our root scroll position now if we're getting here after EndLoad
|
2007-05-01 17:15:08 +00:00
|
|
|
// got called, since this is our one chance to do it. Note that we need not
|
|
|
|
// have reflowed for this to work; when the scrollframe is finally reflowed
|
|
|
|
// it'll puick up the position we store in it here.
|
2007-04-26 02:33:02 +00:00
|
|
|
if (!mDocumentLoading) {
|
|
|
|
RestoreRootScrollPosition();
|
|
|
|
}
|
1999-10-15 04:29:30 +00:00
|
|
|
|
2001-05-03 01:41:10 +00:00
|
|
|
// For printing, we just immediately unsuppress.
|
2004-03-03 18:24:20 +00:00
|
|
|
if (!mPresContext->IsPaginated()) {
|
2001-05-03 01:41:10 +00:00
|
|
|
// Kick off a one-shot timer based off our pref value. When this timer
|
|
|
|
// fires, if painting is still locked down, then we will go ahead and
|
|
|
|
// trigger a full invalidate and allow painting to proceed normally.
|
|
|
|
mPaintingSuppressed = PR_TRUE;
|
|
|
|
mPaintSuppressionTimer = do_CreateInstance("@mozilla.org/timer;1");
|
|
|
|
if (!mPaintSuppressionTimer)
|
|
|
|
// Uh-oh. We must be out of memory. No point in keeping painting locked down.
|
|
|
|
mPaintingSuppressed = PR_FALSE;
|
|
|
|
else {
|
|
|
|
// Initialize the timer.
|
2004-04-29 23:34:19 +00:00
|
|
|
|
|
|
|
// Default to PAINTLOCK_EVENT_DELAY if we can't get the pref value.
|
|
|
|
PRInt32 delay =
|
|
|
|
nsContentUtils::GetIntPref("nglayout.initialpaint.delay",
|
|
|
|
PAINTLOCK_EVENT_DELAY);
|
2002-09-07 05:38:16 +00:00
|
|
|
|
2004-04-29 23:34:19 +00:00
|
|
|
mPaintSuppressionTimer->InitWithFuncCallback(sPaintSuppressionCallback,
|
|
|
|
this, delay,
|
2002-09-07 05:38:16 +00:00
|
|
|
nsITimer::TYPE_ONE_SHOT);
|
2001-05-03 01:41:10 +00:00
|
|
|
}
|
2001-04-25 19:52:49 +00:00
|
|
|
}
|
|
|
|
|
1998-09-10 19:32:14 +00:00
|
|
|
return NS_OK; //XXX this needs to be real. MMP
|
|
|
|
}
|
|
|
|
|
2001-04-25 19:52:49 +00:00
|
|
|
void
|
|
|
|
PresShell::sPaintSuppressionCallback(nsITimer *aTimer, void* aPresShell)
|
|
|
|
{
|
2007-07-08 07:08:04 +00:00
|
|
|
PresShell* self = static_cast<PresShell*>(aPresShell);
|
2001-04-25 19:52:49 +00:00
|
|
|
if (self)
|
2001-05-01 22:54:11 +00:00
|
|
|
self->UnsuppressPainting();
|
2001-04-25 19:52:49 +00:00
|
|
|
}
|
|
|
|
|
1998-09-10 19:32:14 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::ResizeReflow(nscoord aWidth, nscoord aHeight)
|
|
|
|
{
|
2007-05-16 03:22:45 +00:00
|
|
|
NS_PRECONDITION(!mIsReflowing, "Shouldn't be in reflow here!");
|
2008-03-12 22:04:45 +00:00
|
|
|
NS_PRECONDITION(aWidth != NS_UNCONSTRAINEDSIZE,
|
|
|
|
"shouldn't use unconstrained widths anymore");
|
2007-05-16 03:22:45 +00:00
|
|
|
|
2005-05-13 19:47:38 +00:00
|
|
|
// If we don't have a root frame yet, that means we haven't had our initial
|
|
|
|
// reflow... If that's the case, and aWidth or aHeight is unconstrained,
|
|
|
|
// ignore them altogether.
|
|
|
|
nsIFrame* rootFrame = FrameManager()->GetRootFrame();
|
|
|
|
|
2008-03-12 22:04:45 +00:00
|
|
|
if (!rootFrame && aHeight == NS_UNCONSTRAINEDSIZE) {
|
|
|
|
// We can't do the work needed for SizeToContent without a root
|
|
|
|
// frame, and we want to return before setting the visible area.
|
2005-05-13 19:47:38 +00:00
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
}
|
1998-09-10 19:32:14 +00:00
|
|
|
|
2007-04-25 15:49:55 +00:00
|
|
|
mPresContext->SetVisibleArea(nsRect(0, 0, aWidth, aHeight));
|
1999-11-01 22:12:45 +00:00
|
|
|
|
2007-04-25 15:49:55 +00:00
|
|
|
// There isn't anything useful we can do if the initial reflow hasn't happened
|
|
|
|
if (!rootFrame)
|
|
|
|
return NS_OK;
|
1998-10-02 01:12:39 +00:00
|
|
|
|
2008-01-29 04:10:59 +00:00
|
|
|
if (!GetPresContext()->SupressingResizeReflow())
|
|
|
|
{
|
|
|
|
NS_ASSERTION(mViewManager, "Must have view manager");
|
|
|
|
nsCOMPtr<nsIViewManager> viewManagerDeathGrip = mViewManager;
|
|
|
|
nsIViewManager::UpdateViewBatch batch(mViewManager);
|
2007-04-26 01:34:28 +00:00
|
|
|
|
2008-01-29 04:10:59 +00:00
|
|
|
// Take this ref after viewManager so it'll make sure to go away first
|
|
|
|
nsCOMPtr<nsIPresShell> kungFuDeathGrip(this);
|
2006-04-18 05:44:02 +00:00
|
|
|
|
2008-01-29 04:10:59 +00:00
|
|
|
// Make sure style is up to date
|
|
|
|
mFrameConstructor->ProcessPendingRestyles();
|
2007-09-20 02:46:28 +00:00
|
|
|
|
2008-01-29 04:10:59 +00:00
|
|
|
if (!mIsDestroying) {
|
|
|
|
// XXX Do a full invalidate at the beginning so that invalidates along
|
|
|
|
// the way don't have region accumulation issues?
|
2007-09-20 02:46:28 +00:00
|
|
|
|
2008-03-11 02:18:15 +00:00
|
|
|
{
|
2008-03-14 23:08:57 +00:00
|
|
|
nsAutoCauseReflowNotifier crNotifier(this);
|
|
|
|
WillDoReflow();
|
|
|
|
|
2008-01-29 04:10:59 +00:00
|
|
|
// Kick off a top-down reflow
|
|
|
|
AUTO_LAYOUT_PHASE_ENTRY_POINT(GetPresContext(), Reflow);
|
|
|
|
mIsReflowing = PR_TRUE;
|
|
|
|
|
|
|
|
mDirtyRoots.RemoveElement(rootFrame);
|
|
|
|
DoReflow(rootFrame);
|
|
|
|
mIsReflowing = PR_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
DidDoReflow();
|
2007-09-20 23:28:26 +00:00
|
|
|
}
|
|
|
|
|
2008-01-29 04:10:59 +00:00
|
|
|
batch.EndUpdateViewBatch(NS_VMREFRESH_NO_SYNC);
|
2007-04-25 10:44:29 +00:00
|
|
|
}
|
2007-04-25 15:49:55 +00:00
|
|
|
|
2008-03-12 22:04:45 +00:00
|
|
|
if (aHeight == NS_UNCONSTRAINEDSIZE) {
|
|
|
|
mPresContext->SetVisibleArea(
|
|
|
|
nsRect(0, 0, aWidth, rootFrame->GetRect().height));
|
|
|
|
}
|
|
|
|
|
2007-09-20 23:28:26 +00:00
|
|
|
if (!mIsDestroying) {
|
|
|
|
CreateResizeEventTimer();
|
|
|
|
}
|
2007-04-25 15:49:55 +00:00
|
|
|
|
2001-04-17 23:25:21 +00:00
|
|
|
return NS_OK; //XXX this needs to be real. MMP
|
|
|
|
}
|
|
|
|
|
|
|
|
#define RESIZE_EVENT_DELAY 200
|
|
|
|
|
|
|
|
void
|
|
|
|
PresShell::CreateResizeEventTimer ()
|
|
|
|
{
|
|
|
|
KillResizeEventTimer();
|
|
|
|
|
2001-05-01 22:54:11 +00:00
|
|
|
if (mIsDocumentGone)
|
|
|
|
return;
|
|
|
|
|
2001-04-17 23:25:21 +00:00
|
|
|
mResizeEventTimer = do_CreateInstance("@mozilla.org/timer;1");
|
|
|
|
if (mResizeEventTimer) {
|
2002-09-07 05:38:16 +00:00
|
|
|
mResizeEventTimer->InitWithFuncCallback(sResizeEventCallback, this, RESIZE_EVENT_DELAY,
|
|
|
|
nsITimer::TYPE_ONE_SHOT);
|
2001-04-17 23:25:21 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
PresShell::KillResizeEventTimer()
|
|
|
|
{
|
|
|
|
if(mResizeEventTimer) {
|
|
|
|
mResizeEventTimer->Cancel();
|
|
|
|
mResizeEventTimer = nsnull;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
PresShell::sResizeEventCallback(nsITimer *aTimer, void* aPresShell)
|
|
|
|
{
|
2007-07-08 07:08:04 +00:00
|
|
|
PresShell* self = static_cast<PresShell*>(aPresShell);
|
2001-04-17 23:25:21 +00:00
|
|
|
if (self) {
|
|
|
|
self->FireResizeEvent();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
PresShell::FireResizeEvent()
|
|
|
|
{
|
2001-05-01 22:54:11 +00:00
|
|
|
if (mIsDocumentGone)
|
|
|
|
return;
|
|
|
|
|
2000-05-17 05:27:22 +00:00
|
|
|
//Send resize event from here.
|
2005-04-28 23:48:28 +00:00
|
|
|
nsEvent event(PR_TRUE, NS_RESIZE_EVENT);
|
2000-11-08 00:31:06 +00:00
|
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
2000-05-17 05:27:22 +00:00
|
|
|
|
2005-11-28 23:56:44 +00:00
|
|
|
nsPIDOMWindow *window = mDocument->GetWindow();
|
|
|
|
if (window) {
|
2006-03-07 17:08:51 +00:00
|
|
|
nsEventDispatcher::Dispatch(window, mPresContext, &event, nsnull, &status);
|
2001-05-04 03:04:40 +00:00
|
|
|
}
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2001-12-01 00:22:00 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::SetIgnoreFrameDestruction(PRBool aIgnore)
|
|
|
|
{
|
|
|
|
mIgnoreFrameDestruction = aIgnore;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-07-16 23:27:46 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::NotifyDestroyingFrame(nsIFrame* aFrame)
|
|
|
|
{
|
2001-12-01 00:22:00 +00:00
|
|
|
if (!mIgnoreFrameDestruction) {
|
2005-04-01 23:07:00 +00:00
|
|
|
mFrameConstructor->NotifyDestroyingFrame(aFrame);
|
|
|
|
|
2007-05-16 03:22:45 +00:00
|
|
|
for (PRInt32 idx = mDirtyRoots.Count(); idx; ) {
|
|
|
|
--idx;
|
|
|
|
if (mDirtyRoots[idx] == aFrame) {
|
|
|
|
mDirtyRoots.RemoveElementAt(idx);
|
|
|
|
}
|
|
|
|
}
|
1999-07-16 23:27:46 +00:00
|
|
|
|
2001-12-01 00:22:00 +00:00
|
|
|
// Notify the frame manager
|
2004-03-06 04:46:11 +00:00
|
|
|
FrameManager()->NotifyDestroyingFrame(aFrame);
|
2004-08-24 18:50:29 +00:00
|
|
|
|
|
|
|
// Remove frame properties
|
|
|
|
mPresContext->PropertyTable()->DeleteAllPropertiesFor(aFrame);
|
1999-08-05 20:17:44 +00:00
|
|
|
}
|
|
|
|
|
1999-07-16 23:27:46 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-02-13 04:45:44 +00:00
|
|
|
|
2003-02-27 23:09:51 +00:00
|
|
|
// note that this can return a null caret, but NS_OK
|
1999-02-13 04:45:44 +00:00
|
|
|
NS_IMETHODIMP PresShell::GetCaret(nsICaret **outCaret)
|
|
|
|
{
|
2003-02-27 23:09:51 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(outCaret);
|
|
|
|
|
|
|
|
*outCaret = mCaret;
|
|
|
|
NS_IF_ADDREF(*outCaret);
|
|
|
|
return NS_OK;
|
1999-02-13 04:45:44 +00:00
|
|
|
}
|
|
|
|
|
2006-11-07 01:35:36 +00:00
|
|
|
NS_IMETHODIMP_(void) PresShell::MaybeInvalidateCaretPosition()
|
|
|
|
{
|
|
|
|
if (mCaret) {
|
|
|
|
mCaret->InvalidateOutsideCaret();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-09-22 21:06:58 +00:00
|
|
|
void PresShell::SetCaret(nsICaret *aNewCaret)
|
2006-04-17 23:16:46 +00:00
|
|
|
{
|
|
|
|
mCaret = aNewCaret;
|
2007-09-22 21:06:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void PresShell::RestoreCaret()
|
|
|
|
{
|
|
|
|
mCaret = mOriginalCaret;
|
2006-04-17 23:16:46 +00:00
|
|
|
}
|
|
|
|
|
1999-08-04 20:46:16 +00:00
|
|
|
NS_IMETHODIMP PresShell::SetCaretEnabled(PRBool aInEnable)
|
1999-04-01 23:58:11 +00:00
|
|
|
{
|
2000-06-16 14:05:03 +00:00
|
|
|
nsresult result = NS_OK;
|
|
|
|
PRBool oldEnabled = mCaretEnabled;
|
2003-03-12 03:22:11 +00:00
|
|
|
|
2000-06-16 14:05:03 +00:00
|
|
|
mCaretEnabled = aInEnable;
|
2003-03-12 03:22:11 +00:00
|
|
|
|
2000-06-16 14:05:03 +00:00
|
|
|
if (mCaret && (mCaretEnabled != oldEnabled))
|
|
|
|
{
|
2000-09-07 05:26:25 +00:00
|
|
|
/* Don't change the caret's selection here! This was an evil side-effect of SetCaretEnabled()
|
2000-06-01 02:39:52 +00:00
|
|
|
nsCOMPtr<nsIDOMSelection> domSel;
|
|
|
|
if (NS_SUCCEEDED(GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(domSel))) && domSel)
|
|
|
|
mCaret->SetCaretDOMSelection(domSel);
|
2000-09-07 05:26:25 +00:00
|
|
|
*/
|
2000-06-01 02:39:52 +00:00
|
|
|
result = mCaret->SetCaretVisible(mCaretEnabled);
|
2000-06-16 14:05:03 +00:00
|
|
|
}
|
2003-03-12 03:22:11 +00:00
|
|
|
|
2000-06-16 14:05:03 +00:00
|
|
|
return result;
|
1999-04-01 23:58:11 +00:00
|
|
|
}
|
|
|
|
|
2000-05-11 04:25:43 +00:00
|
|
|
NS_IMETHODIMP PresShell::SetCaretReadOnly(PRBool aReadOnly)
|
|
|
|
{
|
2003-02-27 23:09:51 +00:00
|
|
|
if (mCaret)
|
|
|
|
mCaret->SetCaretReadOnly(aReadOnly);
|
|
|
|
return NS_OK;
|
2000-05-11 04:25:43 +00:00
|
|
|
}
|
|
|
|
|
1999-08-04 20:46:16 +00:00
|
|
|
NS_IMETHODIMP PresShell::GetCaretEnabled(PRBool *aOutEnabled)
|
|
|
|
{
|
2003-02-27 23:09:51 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aOutEnabled);
|
1999-08-04 20:46:16 +00:00
|
|
|
*aOutEnabled = mCaretEnabled;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2003-06-25 01:14:25 +00:00
|
|
|
NS_IMETHODIMP PresShell::SetCaretVisibilityDuringSelection(PRBool aVisibility)
|
|
|
|
{
|
|
|
|
if (mCaret)
|
|
|
|
mCaret->SetVisibilityDuringSelection(aVisibility);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2008-04-08 18:52:48 +00:00
|
|
|
NS_IMETHODIMP PresShell::GetCaretVisible(PRBool *aOutIsVisible)
|
|
|
|
{
|
|
|
|
*aOutIsVisible = PR_FALSE;
|
|
|
|
if (mCaret) {
|
|
|
|
nsresult rv = mCaret->GetCaretVisible(aOutIsVisible);
|
|
|
|
NS_ENSURE_SUCCESS(rv,rv);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-12-18 01:29:49 +00:00
|
|
|
NS_IMETHODIMP PresShell::SetSelectionFlags(PRInt16 aInEnable)
|
1999-05-17 00:21:18 +00:00
|
|
|
{
|
2001-12-18 21:05:55 +00:00
|
|
|
mSelectionFlags = aInEnable;
|
1999-05-17 00:21:18 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-12-18 01:29:49 +00:00
|
|
|
NS_IMETHODIMP PresShell::GetSelectionFlags(PRInt16 *aOutEnable)
|
1999-05-17 00:21:18 +00:00
|
|
|
{
|
1999-08-04 20:46:16 +00:00
|
|
|
if (!aOutEnable)
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
2001-12-18 21:05:55 +00:00
|
|
|
*aOutEnable = mSelectionFlags;
|
1999-05-17 00:21:18 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-12-02 21:45:21 +00:00
|
|
|
//implementation of nsISelectionController
|
1999-04-01 23:58:11 +00:00
|
|
|
|
1999-10-22 00:19:18 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::CharacterMove(PRBool aForward, PRBool aExtend)
|
1999-02-19 23:47:36 +00:00
|
|
|
{
|
1999-12-11 00:02:08 +00:00
|
|
|
return mSelection->CharacterMove(aForward, aExtend);
|
1999-10-22 00:19:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::WordMove(PRBool aForward, PRBool aExtend)
|
|
|
|
{
|
1999-12-11 00:02:08 +00:00
|
|
|
return mSelection->WordMove(aForward, aExtend);
|
1999-10-22 00:19:18 +00:00
|
|
|
}
|
|
|
|
|
2006-07-18 07:28:38 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::WordExtendForDelete(PRBool aForward)
|
|
|
|
{
|
|
|
|
return mSelection->WordExtendForDelete(aForward);
|
|
|
|
}
|
|
|
|
|
1999-10-22 00:19:18 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::LineMove(PRBool aForward, PRBool aExtend)
|
|
|
|
{
|
2001-06-20 04:48:10 +00:00
|
|
|
nsresult result = mSelection->LineMove(aForward, aExtend);
|
2005-11-20 22:05:24 +00:00
|
|
|
// if we can't go down/up any more we must then move caret completely to
|
2001-06-20 04:48:10 +00:00
|
|
|
// end/beginning respectively.
|
|
|
|
if (NS_FAILED(result))
|
|
|
|
result = CompleteMove(aForward,aExtend);
|
|
|
|
return result;
|
1999-10-22 00:19:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::IntraLineMove(PRBool aForward, PRBool aExtend)
|
|
|
|
{
|
1999-12-11 00:02:08 +00:00
|
|
|
return mSelection->IntraLineMove(aForward, aExtend);
|
1999-10-22 00:19:18 +00:00
|
|
|
}
|
|
|
|
|
2002-08-26 20:55:30 +00:00
|
|
|
|
|
|
|
|
1999-10-22 00:19:18 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::PageMove(PRBool aForward, PRBool aExtend)
|
|
|
|
{
|
2002-08-26 20:55:30 +00:00
|
|
|
nsresult result;
|
2003-06-30 10:46:59 +00:00
|
|
|
nsIViewManager* viewManager = GetViewManager();
|
2002-08-26 20:55:30 +00:00
|
|
|
nsIScrollableView *scrollableView;
|
|
|
|
if (!viewManager)
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
result = viewManager->GetRootScrollableView(&scrollableView);
|
|
|
|
if (NS_FAILED(result))
|
|
|
|
return result;
|
|
|
|
if (!scrollableView)
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
nsIView *scrolledView;
|
|
|
|
result = scrollableView->GetScrolledView(scrolledView);
|
2006-04-26 02:01:07 +00:00
|
|
|
mSelection->CommonPageMove(aForward, aExtend, scrollableView);
|
2008-02-28 15:28:37 +00:00
|
|
|
// After ScrollSelectionIntoView(), the pending notifications might be
|
|
|
|
// flushed and PresShell/PresContext/Frames may be dead. See bug 418470.
|
2002-08-26 20:55:30 +00:00
|
|
|
return ScrollSelectionIntoView(nsISelectionController::SELECTION_NORMAL, nsISelectionController::SELECTION_FOCUS_REGION, PR_TRUE);
|
1999-10-22 00:19:18 +00:00
|
|
|
}
|
|
|
|
|
2002-08-26 20:55:30 +00:00
|
|
|
|
|
|
|
|
1999-10-22 00:19:18 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::ScrollPage(PRBool aForward)
|
1999-12-11 00:02:08 +00:00
|
|
|
{
|
2004-09-21 04:41:08 +00:00
|
|
|
nsIScrollableView* scrollView = GetViewToScroll(nsLayoutUtils::eVertical);
|
2004-08-06 15:55:17 +00:00
|
|
|
if (scrollView) {
|
|
|
|
scrollView->ScrollByPages(0, aForward ? 1 : -1);
|
1999-12-11 00:02:08 +00:00
|
|
|
}
|
2004-08-06 15:55:17 +00:00
|
|
|
return NS_OK;
|
1999-12-11 00:02:08 +00:00
|
|
|
}
|
|
|
|
|
1999-12-15 03:54:52 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::ScrollLine(PRBool aForward)
|
|
|
|
{
|
2004-09-21 04:41:08 +00:00
|
|
|
nsIScrollableView* scrollView = GetViewToScroll(nsLayoutUtils::eVertical);
|
2004-08-06 15:55:17 +00:00
|
|
|
if (scrollView) {
|
2002-04-12 02:05:12 +00:00
|
|
|
#ifdef MOZ_WIDGET_COCOA
|
2004-08-06 15:55:17 +00:00
|
|
|
// Emulate the Mac IE behavior of scrolling a minimum of 2 lines
|
|
|
|
// rather than 1. This vastly improves scrolling speed.
|
|
|
|
scrollView->ScrollByLines(0, aForward ? 2 : -2);
|
2002-04-12 02:05:12 +00:00
|
|
|
#else
|
2004-08-06 15:55:17 +00:00
|
|
|
scrollView->ScrollByLines(0, aForward ? 1 : -1);
|
2002-04-12 02:05:12 +00:00
|
|
|
#endif
|
|
|
|
|
1999-12-15 03:54:52 +00:00
|
|
|
//NEW FOR LINES
|
2004-08-06 15:55:17 +00:00
|
|
|
// force the update to happen now, otherwise multiple scrolls can
|
|
|
|
// occur before the update is processed. (bug #7354)
|
1999-12-15 03:54:52 +00:00
|
|
|
|
2004-08-06 15:55:17 +00:00
|
|
|
// I'd use Composite here, but it doesn't always work.
|
|
|
|
// vm->Composite();
|
|
|
|
nsIViewManager* viewManager = GetViewManager();
|
|
|
|
if (viewManager) {
|
2000-01-26 23:04:40 +00:00
|
|
|
viewManager->ForceUpdate();
|
1999-12-15 03:54:52 +00:00
|
|
|
}
|
|
|
|
}
|
2004-08-06 15:55:17 +00:00
|
|
|
return NS_OK;
|
1999-12-15 03:54:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::ScrollHorizontal(PRBool aLeft)
|
|
|
|
{
|
2004-09-21 04:41:08 +00:00
|
|
|
nsIScrollableView* scrollView = GetViewToScroll(nsLayoutUtils::eHorizontal);
|
2004-08-06 15:55:17 +00:00
|
|
|
if (scrollView) {
|
|
|
|
scrollView->ScrollByLines(aLeft ? -1 : 1, 0);
|
2000-05-16 11:35:12 +00:00
|
|
|
//NEW FOR LINES
|
2004-08-06 15:55:17 +00:00
|
|
|
// force the update to happen now, otherwise multiple scrolls can
|
|
|
|
// occur before the update is processed. (bug #7354)
|
2000-05-16 11:35:12 +00:00
|
|
|
|
2004-08-06 15:55:17 +00:00
|
|
|
// I'd use Composite here, but it doesn't always work.
|
|
|
|
// vm->Composite();
|
|
|
|
nsIViewManager* viewManager = GetViewManager();
|
|
|
|
if (viewManager) {
|
2000-05-16 11:35:12 +00:00
|
|
|
viewManager->ForceUpdate();
|
|
|
|
}
|
|
|
|
}
|
2004-08-06 15:55:17 +00:00
|
|
|
return NS_OK;
|
1999-12-15 03:54:52 +00:00
|
|
|
}
|
|
|
|
|
1999-12-11 00:02:08 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::CompleteScroll(PRBool aForward)
|
|
|
|
{
|
2004-09-21 04:41:08 +00:00
|
|
|
nsIScrollableView* scrollView = GetViewToScroll(nsLayoutUtils::eVertical);
|
2004-08-06 15:55:17 +00:00
|
|
|
if (scrollView) {
|
|
|
|
scrollView->ScrollByWhole(!aForward);//TRUE = top, aForward TRUE=bottom
|
1999-12-16 22:48:02 +00:00
|
|
|
}
|
2004-08-06 15:55:17 +00:00
|
|
|
return NS_OK;
|
1999-12-11 00:02:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::CompleteMove(PRBool aForward, PRBool aExtend)
|
2007-04-14 16:51:20 +00:00
|
|
|
{
|
2008-02-28 15:28:37 +00:00
|
|
|
// Beware! This may flush notifications via synchronous
|
|
|
|
// ScrollSelectionIntoView.
|
2007-04-14 16:51:20 +00:00
|
|
|
return CompleteMoveInner(aForward, aExtend, PR_TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
PresShell::CompleteMoveInner(PRBool aForward, PRBool aExtend, PRBool aScrollIntoView)
|
1999-10-22 00:19:18 +00:00
|
|
|
{
|
2007-07-19 09:47:49 +00:00
|
|
|
nsIContent* root = mSelection->GetAncestorLimiter();
|
2007-11-12 14:46:13 +00:00
|
|
|
nsIDocument* doc;
|
|
|
|
if (root && (doc = root->GetOwnerDoc()) && doc->GetRootContent() != root) {
|
|
|
|
// Make the caret be either at the very beginning (0) or the very end of
|
|
|
|
// root. Only do this when not moving to the beginning or end of the
|
|
|
|
// document (root is null or root is the documentElement), that's handled
|
|
|
|
// below by moving to beginning or end of the scrollable view.
|
2007-07-19 09:47:49 +00:00
|
|
|
nsIContent* node = root;
|
|
|
|
PRInt32 offset = 0;
|
|
|
|
nsFrameSelection::HINT hint = nsFrameSelection::HINTLEFT;
|
|
|
|
if (aForward) {
|
|
|
|
nsIContent* next = node;
|
|
|
|
PRUint32 count;
|
|
|
|
while ((count = next->GetChildCount()) > 0) {
|
|
|
|
node = next;
|
|
|
|
offset = count;
|
|
|
|
next = next->GetChildAt(count - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (offset > 0 && node->GetChildAt(offset - 1)->Tag() == nsGkAtoms::br) {
|
|
|
|
--offset;
|
|
|
|
hint = nsFrameSelection::HINTRIGHT; // for bug 106855
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mSelection->HandleClick(node, offset, offset, aExtend, PR_FALSE, hint);
|
|
|
|
|
|
|
|
// HandleClick resets ancestorLimiter, so set it again.
|
|
|
|
mSelection->SetAncestorLimiter(root);
|
|
|
|
|
|
|
|
if (aScrollIntoView) {
|
2008-02-28 15:28:37 +00:00
|
|
|
// After ScrollSelectionIntoView(), the pending notifications might be
|
|
|
|
// flushed and PresShell/PresContext/Frames may be dead. See bug 418470.
|
2007-07-19 09:47:49 +00:00
|
|
|
return
|
|
|
|
ScrollSelectionIntoView(nsISelectionController::SELECTION_NORMAL,
|
|
|
|
nsISelectionController::SELECTION_FOCUS_REGION,
|
|
|
|
PR_TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2002-08-26 20:55:30 +00:00
|
|
|
nsIScrollableView *scrollableView;
|
|
|
|
if (!mViewManager)
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
nsresult result = mViewManager->GetRootScrollableView(&scrollableView);
|
|
|
|
if (NS_FAILED(result))
|
|
|
|
return result;
|
|
|
|
if (!scrollableView)
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
nsIView *scrolledView;
|
|
|
|
result = scrollableView->GetScrolledView(scrolledView);
|
|
|
|
// get a frame
|
2003-06-30 10:46:59 +00:00
|
|
|
nsIFrame *frame = (nsIFrame*)scrolledView->GetClientData();
|
2002-08-26 20:55:30 +00:00
|
|
|
if (!frame)
|
2000-09-14 11:45:01 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
2002-09-10 00:10:09 +00:00
|
|
|
//we need to get to the area frame.
|
2003-10-31 20:19:18 +00:00
|
|
|
nsIAtom* frameType;
|
2002-09-10 00:10:09 +00:00
|
|
|
do
|
|
|
|
{
|
2003-10-31 20:19:18 +00:00
|
|
|
frameType = frame->GetType();
|
2006-12-26 17:47:52 +00:00
|
|
|
if (frameType != nsGkAtoms::areaFrame)
|
2002-09-10 00:10:09 +00:00
|
|
|
{
|
2004-01-09 14:20:53 +00:00
|
|
|
frame = frame->GetFirstChild(nsnull);
|
|
|
|
if (!frame)
|
2002-09-10 00:10:09 +00:00
|
|
|
break;
|
|
|
|
}
|
2006-12-26 17:47:52 +00:00
|
|
|
}while(frameType != nsGkAtoms::areaFrame);
|
2002-09-10 00:10:09 +00:00
|
|
|
|
|
|
|
if (!frame)
|
|
|
|
return NS_ERROR_FAILURE; //could not find an area frame.
|
2000-09-14 11:45:01 +00:00
|
|
|
|
2004-11-29 20:28:46 +00:00
|
|
|
nsPeekOffsetStruct pos = frame->GetExtremeCaretPosition(!aForward);
|
|
|
|
|
2006-07-13 06:06:29 +00:00
|
|
|
mSelection->HandleClick(pos.mResultContent ,pos.mContentOffset ,pos.mContentOffset/*End*/ ,aExtend, PR_FALSE, aForward);
|
2007-04-14 16:51:20 +00:00
|
|
|
|
|
|
|
if (aScrollIntoView) {
|
2008-02-28 15:28:37 +00:00
|
|
|
// After ScrollSelectionIntoView(), the pending notifications might be
|
|
|
|
// flushed and PresShell/PresContext/Frames may be dead. See bug 418470.
|
2007-04-14 16:51:20 +00:00
|
|
|
result = ScrollSelectionIntoView(nsISelectionController::SELECTION_NORMAL,
|
|
|
|
nsISelectionController::SELECTION_FOCUS_REGION, PR_TRUE);
|
|
|
|
if (NS_FAILED(result))
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
return NS_OK;
|
1999-10-22 00:19:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::SelectAll()
|
|
|
|
{
|
1999-12-11 00:02:08 +00:00
|
|
|
return mSelection->SelectAll();
|
1999-02-19 23:47:36 +00:00
|
|
|
}
|
|
|
|
|
2000-07-26 11:31:12 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::CheckVisibility(nsIDOMNode *node, PRInt16 startOffset, PRInt16 EndOffset, PRBool *_retval)
|
|
|
|
{
|
|
|
|
if (!node || startOffset>EndOffset || !_retval || startOffset<0 || EndOffset<0)
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
*_retval = PR_FALSE; //initialize return parameter
|
|
|
|
nsCOMPtr<nsIContent> content(do_QueryInterface(node));
|
|
|
|
if (!content)
|
|
|
|
return NS_ERROR_FAILURE;
|
2005-08-22 22:24:29 +00:00
|
|
|
nsIFrame *frame = GetPrimaryFrameFor(content);
|
2000-08-17 23:55:32 +00:00
|
|
|
if (!frame) //no frame to look at so it must not be visible
|
|
|
|
return NS_OK;
|
2000-07-26 11:31:12 +00:00
|
|
|
//start process now to go through all frames to find startOffset. then check chars after that to see
|
|
|
|
//if anything until EndOffset is visible.
|
|
|
|
PRBool finished = PR_FALSE;
|
|
|
|
frame->CheckVisibility(mPresContext,startOffset,EndOffset,PR_TRUE,&finished, _retval);
|
|
|
|
return NS_OK;//dont worry about other return val
|
|
|
|
}
|
|
|
|
|
1999-12-02 21:45:21 +00:00
|
|
|
//end implementations nsISelectionController
|
1999-10-22 00:19:18 +00:00
|
|
|
|
|
|
|
|
1998-11-06 16:16:01 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::StyleChangeReflow()
|
|
|
|
{
|
2007-04-25 10:44:29 +00:00
|
|
|
nsIFrame* rootFrame = FrameManager()->GetRootFrame();
|
2007-04-25 15:49:55 +00:00
|
|
|
// At the moment at least, we don't have a root frame before the initial
|
|
|
|
// reflow; it's safe to just ignore the request in that case
|
|
|
|
if (!rootFrame)
|
|
|
|
return NS_OK;
|
2007-04-25 10:44:29 +00:00
|
|
|
|
2007-05-06 19:16:51 +00:00
|
|
|
return FrameNeedsReflow(rootFrame, eStyleChange, NS_FRAME_IS_DIRTY);
|
1998-11-06 16:16:01 +00:00
|
|
|
}
|
|
|
|
|
2004-09-02 03:08:51 +00:00
|
|
|
nsIFrame*
|
|
|
|
nsIPresShell::GetRootFrame() const
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2004-09-02 03:08:51 +00:00
|
|
|
return FrameManager()->GetRootFrame();
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2006-02-01 19:55:35 +00:00
|
|
|
nsIFrame*
|
|
|
|
nsIPresShell::GetRootScrollFrame() const
|
|
|
|
{
|
|
|
|
nsIFrame* rootFrame = FrameManager()->GetRootFrame();
|
|
|
|
// Ensure root frame is a viewport frame
|
2006-12-26 17:47:52 +00:00
|
|
|
if (!rootFrame || nsGkAtoms::viewportFrame != rootFrame->GetType())
|
2006-02-01 19:55:35 +00:00
|
|
|
return nsnull;
|
|
|
|
nsIFrame* theFrame = rootFrame->GetFirstChild(nsnull);
|
2006-12-26 17:47:52 +00:00
|
|
|
if (!theFrame || nsGkAtoms::scrollFrame != theFrame->GetType())
|
2006-02-01 19:55:35 +00:00
|
|
|
return nsnull;
|
|
|
|
return theFrame;
|
|
|
|
}
|
|
|
|
|
2007-02-18 10:43:12 +00:00
|
|
|
nsIScrollableFrame*
|
|
|
|
nsIPresShell::GetRootScrollFrameAsScrollable() const
|
|
|
|
{
|
|
|
|
nsIFrame* frame = GetRootScrollFrame();
|
|
|
|
if (!frame)
|
|
|
|
return nsnull;
|
|
|
|
nsIScrollableFrame* scrollableFrame = nsnull;
|
|
|
|
CallQueryInterface(frame, &scrollableFrame);
|
2007-05-23 00:11:05 +00:00
|
|
|
NS_ASSERTION(scrollableFrame,
|
|
|
|
"All scroll frames must implement nsIScrollableFrame");
|
2007-02-18 10:43:12 +00:00
|
|
|
return scrollableFrame;
|
|
|
|
}
|
|
|
|
|
1998-12-07 03:43:02 +00:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 17:45:58 +00:00
|
|
|
PresShell::GetPageSequenceFrame(nsIPageSequenceFrame** aResult) const
|
1998-12-07 03:43:02 +00:00
|
|
|
{
|
1999-02-12 17:45:58 +00:00
|
|
|
NS_PRECONDITION(nsnull != aResult, "null ptr");
|
|
|
|
if (nsnull == aResult) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
|
|
|
|
*aResult = nsnull;
|
2005-04-05 22:46:56 +00:00
|
|
|
nsIFrame* frame = mFrameConstructor->GetPageSequenceFrame();
|
|
|
|
if (frame) {
|
|
|
|
CallQueryInterface(frame, aResult);
|
|
|
|
}
|
|
|
|
return *aResult ? NS_OK : NS_ERROR_FAILURE;
|
1998-12-07 03:43:02 +00:00
|
|
|
}
|
|
|
|
|
2007-09-05 08:00:40 +00:00
|
|
|
nsIFrame*
|
|
|
|
PresShell::GetFrameForPoint(nsIFrame* aFrame, nsPoint aPt)
|
|
|
|
{
|
|
|
|
return nsLayoutUtils::GetFrameForPoint(aFrame, aPt);
|
|
|
|
}
|
|
|
|
|
2004-01-24 00:46:17 +00:00
|
|
|
void
|
2003-10-02 21:29:40 +00:00
|
|
|
PresShell::BeginUpdate(nsIDocument *aDocument, nsUpdateType aUpdateType)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2004-12-02 01:26:20 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
mUpdateCount++;
|
|
|
|
#endif
|
2004-04-12 21:53:22 +00:00
|
|
|
mFrameConstructor->BeginUpdate();
|
|
|
|
|
2004-12-02 01:26:20 +00:00
|
|
|
if (aUpdateType & UPDATE_STYLE)
|
2004-01-08 19:23:12 +00:00
|
|
|
mStyleSet->BeginUpdate();
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2004-01-24 00:46:17 +00:00
|
|
|
void
|
2003-10-02 21:29:40 +00:00
|
|
|
PresShell::EndUpdate(nsIDocument *aDocument, nsUpdateType aUpdateType)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2004-12-02 01:26:20 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
NS_PRECONDITION(0 != mUpdateCount, "too many EndUpdate's");
|
|
|
|
--mUpdateCount;
|
|
|
|
#endif
|
|
|
|
|
2004-04-12 21:53:22 +00:00
|
|
|
if (aUpdateType & UPDATE_STYLE) {
|
2004-01-08 19:23:12 +00:00
|
|
|
mStyleSet->EndUpdate();
|
2004-12-02 01:26:20 +00:00
|
|
|
if (mStylesHaveChanged)
|
2004-04-12 21:53:22 +00:00
|
|
|
ReconstructStyleData();
|
|
|
|
}
|
2004-01-08 19:23:12 +00:00
|
|
|
|
2004-04-12 21:53:22 +00:00
|
|
|
mFrameConstructor->EndUpdate();
|
1998-06-03 15:46:54 +00:00
|
|
|
}
|
|
|
|
|
2004-01-24 00:46:17 +00:00
|
|
|
void
|
2007-04-26 02:33:02 +00:00
|
|
|
PresShell::RestoreRootScrollPosition()
|
1998-06-03 15:46:54 +00:00
|
|
|
{
|
2000-06-15 00:35:46 +00:00
|
|
|
// Restore frame state for the root scroll frame
|
2005-05-12 20:53:33 +00:00
|
|
|
nsCOMPtr<nsILayoutHistoryState> historyState =
|
2007-04-26 02:33:02 +00:00
|
|
|
mDocument->GetLayoutHistoryState();
|
2005-01-27 21:18:30 +00:00
|
|
|
// Make sure we don't reenter reflow via the sync paint that happens while
|
|
|
|
// we're scrolling to our restored position. Entering reflow for the
|
|
|
|
// scrollable frame will cause it to reenter ScrollToRestoredPosition(), and
|
|
|
|
// it'll get all confused.
|
2008-03-14 23:08:57 +00:00
|
|
|
nsAutoScriptBlocker scriptBlocker;
|
2005-01-27 21:18:30 +00:00
|
|
|
++mChangeNestCount;
|
|
|
|
|
2006-02-01 19:55:35 +00:00
|
|
|
if (historyState) {
|
|
|
|
nsIFrame* scrollFrame = GetRootScrollFrame();
|
2000-06-15 00:35:46 +00:00
|
|
|
if (scrollFrame) {
|
2004-07-23 21:39:47 +00:00
|
|
|
nsIScrollableFrame* scrollableFrame;
|
|
|
|
CallQueryInterface(scrollFrame, &scrollableFrame);
|
|
|
|
if (scrollableFrame) {
|
2004-09-13 02:10:29 +00:00
|
|
|
FrameManager()->RestoreFrameStateFor(scrollFrame, historyState,
|
|
|
|
nsIStatefulFrame::eDocumentScrollState);
|
2004-07-23 21:39:47 +00:00
|
|
|
scrollableFrame->ScrollToRestoredPosition();
|
|
|
|
}
|
2000-06-15 00:35:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-01-27 21:18:30 +00:00
|
|
|
--mChangeNestCount;
|
2007-04-26 02:33:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
PresShell::BeginLoad(nsIDocument *aDocument)
|
|
|
|
{
|
|
|
|
#ifdef MOZ_PERF_METRICS
|
|
|
|
// Reset style resolution stopwatch maintained by style set
|
|
|
|
MOZ_TIMER_DEBUGLOG(("Reset: Style Resolution: PresShell::BeginLoad(), this=%p\n", (void*)this));
|
|
|
|
#endif
|
|
|
|
mDocumentLoading = PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
PresShell::EndLoad(nsIDocument *aDocument)
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(aDocument == mDocument, "Wrong document");
|
|
|
|
|
|
|
|
RestoreRootScrollPosition();
|
2005-01-27 21:18:30 +00:00
|
|
|
|
1999-10-19 22:27:20 +00:00
|
|
|
#ifdef MOZ_PERF_METRICS
|
1999-09-20 06:55:24 +00:00
|
|
|
// Dump reflow, style resolution and frame construction times here.
|
1999-11-10 03:41:09 +00:00
|
|
|
MOZ_TIMER_DEBUGLOG(("Stop: Reflow: PresShell::EndLoad(), this=%p\n", this));
|
|
|
|
MOZ_TIMER_STOP(mReflowWatch);
|
|
|
|
MOZ_TIMER_LOG(("Reflow time (this=%p): ", this));
|
|
|
|
MOZ_TIMER_PRINT(mReflowWatch);
|
|
|
|
|
|
|
|
MOZ_TIMER_DEBUGLOG(("Stop: Frame Creation: PresShell::EndLoad(), this=%p\n", this));
|
|
|
|
MOZ_TIMER_STOP(mFrameCreationWatch);
|
|
|
|
MOZ_TIMER_LOG(("Frame construction plus style resolution time (this=%p): ", this));
|
|
|
|
MOZ_TIMER_PRINT(mFrameCreationWatch);
|
1999-09-20 06:55:24 +00:00
|
|
|
|
|
|
|
// Print style resolution stopwatch maintained by style set
|
2000-02-11 01:21:05 +00:00
|
|
|
MOZ_TIMER_DEBUGLOG(("Stop: Style Resolution: PresShell::EndLoad(), this=%p\n", this));
|
2000-04-17 07:13:57 +00:00
|
|
|
#endif
|
2000-05-16 01:11:29 +00:00
|
|
|
mDocumentLoading = PR_FALSE;
|
1998-06-03 15:46:54 +00:00
|
|
|
}
|
|
|
|
|
2007-04-30 06:17:03 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
void
|
|
|
|
PresShell::VerifyHasDirtyRootAncestor(nsIFrame* aFrame)
|
|
|
|
{
|
|
|
|
// XXXbz due to bug 372769, can't actually assert anything here...
|
|
|
|
return;
|
|
|
|
|
|
|
|
// XXXbz shouldn't need this part; remove it once FrameNeedsReflow
|
|
|
|
// handles the root frame correctly.
|
|
|
|
if (!aFrame->GetParent()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure that there is a reflow root ancestor of |aFrame| that's
|
|
|
|
// in mDirtyRoots already.
|
|
|
|
while (aFrame && (aFrame->GetStateBits() & NS_FRAME_HAS_DIRTY_CHILDREN)) {
|
|
|
|
if (((aFrame->GetStateBits() & NS_FRAME_REFLOW_ROOT) ||
|
|
|
|
!aFrame->GetParent()) &&
|
|
|
|
mDirtyRoots.IndexOf(aFrame) != -1) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
aFrame = aFrame->GetParent();
|
|
|
|
}
|
|
|
|
NS_NOTREACHED("Frame has dirty bits set but isn't scheduled to be "
|
|
|
|
"reflowed?");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
NS_IMETHODIMP
|
2007-05-06 19:16:51 +00:00
|
|
|
PresShell::FrameNeedsReflow(nsIFrame *aFrame, IntrinsicDirty aIntrinsicDirty,
|
2007-05-06 22:50:21 +00:00
|
|
|
nsFrameState aBitToAdd)
|
2004-05-02 18:07:12 +00:00
|
|
|
{
|
2007-05-06 22:50:21 +00:00
|
|
|
NS_PRECONDITION(aBitToAdd == NS_FRAME_IS_DIRTY ||
|
|
|
|
aBitToAdd == NS_FRAME_HAS_DIRTY_CHILDREN,
|
2007-05-06 19:16:51 +00:00
|
|
|
"Unexpected bits being added");
|
2004-05-02 18:07:12 +00:00
|
|
|
|
2007-05-16 03:22:45 +00:00
|
|
|
NS_ASSERTION(!mIsReflowing, "can't mark frame dirty during reflow");
|
2004-05-02 18:07:12 +00:00
|
|
|
|
2001-08-07 18:57:15 +00:00
|
|
|
// If we've not yet done the initial reflow, then don't bother
|
|
|
|
// enqueuing a reflow command yet.
|
|
|
|
if (! mDidInitialReflow)
|
|
|
|
return NS_OK;
|
|
|
|
|
2005-07-07 17:10:40 +00:00
|
|
|
// If we're already destroying, don't bother with this either.
|
|
|
|
if (mIsDestroying)
|
|
|
|
return NS_OK;
|
|
|
|
|
1999-09-15 00:27:05 +00:00
|
|
|
#ifdef DEBUG
|
2000-10-28 22:17:53 +00:00
|
|
|
//printf("gShellCounter: %d\n", gShellCounter++);
|
1998-11-26 18:11:02 +00:00
|
|
|
if (mInVerifyReflow) {
|
1998-12-29 04:56:31 +00:00
|
|
|
return NS_OK;
|
2005-02-08 00:59:52 +00:00
|
|
|
}
|
2007-05-23 00:11:05 +00:00
|
|
|
|
1999-12-23 02:02:33 +00:00
|
|
|
if (VERIFY_REFLOW_NOISY_RC & gVerifyReflowFlags) {
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
printf("\nPresShell@%p: frame %p needs reflow\n", (void*)this, (void*)aFrame);
|
1999-12-23 02:02:33 +00:00
|
|
|
if (VERIFY_REFLOW_REALLY_NOISY_RC & gVerifyReflowFlags) {
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("Current content model:\n");
|
2003-10-22 06:09:48 +00:00
|
|
|
nsIContent *rootContent = mDocument->GetRootContent();
|
1999-12-23 02:02:33 +00:00
|
|
|
if (rootContent) {
|
|
|
|
rootContent->List(stdout, 0);
|
1999-09-15 00:27:05 +00:00
|
|
|
}
|
|
|
|
}
|
1999-12-23 02:02:33 +00:00
|
|
|
}
|
1998-11-26 18:11:02 +00:00
|
|
|
#endif
|
2000-09-12 00:35:11 +00:00
|
|
|
|
2007-06-16 05:12:58 +00:00
|
|
|
// Grab |wasDirty| now so we can go ahead and update the bits on aFrame.
|
2007-05-06 19:16:51 +00:00
|
|
|
PRBool wasDirty = NS_SUBTREE_DIRTY(aFrame);
|
2007-05-06 22:50:21 +00:00
|
|
|
aFrame->AddStateBits(aBitToAdd);
|
2007-06-16 05:12:58 +00:00
|
|
|
|
|
|
|
// Now if aFrame is a reflow root we can cut off this reflow at it if the bit
|
|
|
|
// being added is NS_FRAME_HAS_DIRTY_CHILDREN.
|
|
|
|
PRBool targetFrameDirty = (aBitToAdd == NS_FRAME_IS_DIRTY);
|
|
|
|
|
2007-05-06 19:16:51 +00:00
|
|
|
#define FRAME_IS_REFLOW_ROOT(_f) \
|
|
|
|
((_f->GetStateBits() & NS_FRAME_REFLOW_ROOT) && \
|
|
|
|
(_f != aFrame || !targetFrameDirty))
|
|
|
|
|
|
|
|
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
// Mark the intrinsic widths as dirty on the frame, all of its ancestors,
|
|
|
|
// and all of its descendants, if needed:
|
|
|
|
|
|
|
|
if (aIntrinsicDirty != eResize) {
|
2007-05-06 19:16:51 +00:00
|
|
|
// Mark argument and all ancestors dirty. (Unless we hit a reflow root that
|
|
|
|
// should contain the reflow. That root could be aFrame itself if it's not
|
|
|
|
// dirty, or it could be some ancestor of aFrame.)
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
for (nsIFrame *a = aFrame;
|
2007-05-06 19:16:51 +00:00
|
|
|
a && !FRAME_IS_REFLOW_ROOT(a);
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
a = a->GetParent())
|
|
|
|
a->MarkIntrinsicWidthsDirty();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (aIntrinsicDirty == eStyleChange) {
|
|
|
|
// Mark all descendants dirty (using an nsVoidArray stack rather than
|
|
|
|
// recursion).
|
|
|
|
nsVoidArray stack;
|
|
|
|
stack.AppendElement(aFrame);
|
|
|
|
|
|
|
|
while (stack.Count() != 0) {
|
|
|
|
nsIFrame *f =
|
2007-07-08 07:08:04 +00:00
|
|
|
static_cast<nsIFrame*>(stack.FastElementAt(stack.Count() - 1));
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
stack.RemoveElementAt(stack.Count() - 1);
|
|
|
|
|
|
|
|
PRInt32 childListIndex = 0;
|
|
|
|
nsIAtom *childListName;
|
|
|
|
do {
|
|
|
|
childListName = f->GetAdditionalChildListName(childListIndex++);
|
|
|
|
for (nsIFrame *kid = f->GetFirstChild(childListName); kid;
|
|
|
|
kid = kid->GetNextSibling()) {
|
|
|
|
kid->MarkIntrinsicWidthsDirty();
|
|
|
|
stack.AppendElement(kid);
|
|
|
|
}
|
|
|
|
} while (childListName);
|
2004-05-02 18:07:12 +00:00
|
|
|
}
|
1999-11-09 03:23:26 +00:00
|
|
|
}
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
|
|
|
|
// Set NS_FRAME_HAS_DIRTY_CHILDREN bits (via nsIFrame::ChildIsDirty) up the
|
|
|
|
// tree until we reach either a frame that's already dirty or a reflow root.
|
|
|
|
nsIFrame *f = aFrame;
|
|
|
|
for (;;) {
|
2007-05-06 19:16:51 +00:00
|
|
|
if (FRAME_IS_REFLOW_ROOT(f) || !f->GetParent()) {
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
// we've hit a reflow root or the root frame
|
|
|
|
if (!wasDirty) {
|
|
|
|
mDirtyRoots.AppendElement(f);
|
|
|
|
}
|
2007-04-30 06:17:03 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
else {
|
|
|
|
VerifyHasDirtyRootAncestor(f);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIFrame *child = f;
|
|
|
|
f = f->GetParent();
|
2007-05-06 19:16:51 +00:00
|
|
|
wasDirty = NS_SUBTREE_DIRTY(f);
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
f->ChildIsDirty(child);
|
|
|
|
NS_ASSERTION(f->GetStateBits() & NS_FRAME_HAS_DIRTY_CHILDREN,
|
|
|
|
"ChildIsDirty didn't do its job");
|
|
|
|
if (wasDirty) {
|
|
|
|
// This frame was already marked dirty.
|
2007-04-30 06:17:03 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
VerifyHasDirtyRootAncestor(f);
|
|
|
|
#endif
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
break;
|
|
|
|
}
|
2001-12-17 22:39:59 +00:00
|
|
|
}
|
1999-11-09 03:23:26 +00:00
|
|
|
|
2007-04-25 15:49:55 +00:00
|
|
|
PostReflowEvent();
|
2000-04-17 07:13:57 +00:00
|
|
|
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
return NS_OK;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2004-08-06 15:55:17 +00:00
|
|
|
nsIScrollableView*
|
2004-09-21 04:41:08 +00:00
|
|
|
PresShell::GetViewToScroll(nsLayoutUtils::Direction aDirection)
|
2004-08-06 15:55:17 +00:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIEventStateManager> esm = mPresContext->EventStateManager();
|
|
|
|
nsIScrollableView* scrollView = nsnull;
|
2004-09-01 14:58:34 +00:00
|
|
|
nsCOMPtr<nsIContent> focusedContent;
|
|
|
|
esm->GetFocusedContent(getter_AddRefs(focusedContent));
|
2004-10-19 02:24:27 +00:00
|
|
|
if (!focusedContent && mSelection) {
|
2006-04-26 02:01:07 +00:00
|
|
|
nsISelection* domSelection = mSelection->
|
|
|
|
GetSelection(nsISelectionController::SELECTION_NORMAL);
|
2004-10-19 02:24:27 +00:00
|
|
|
if (domSelection) {
|
|
|
|
nsCOMPtr<nsIDOMNode> focusedNode;
|
|
|
|
domSelection->GetFocusNode(getter_AddRefs(focusedNode));
|
|
|
|
focusedContent = do_QueryInterface(focusedNode);
|
|
|
|
}
|
|
|
|
}
|
2004-09-01 14:58:34 +00:00
|
|
|
if (focusedContent) {
|
2005-08-22 22:24:29 +00:00
|
|
|
nsIFrame* startFrame = GetPrimaryFrameFor(focusedContent);
|
2004-09-01 14:58:34 +00:00
|
|
|
if (startFrame) {
|
2007-06-23 07:39:40 +00:00
|
|
|
nsIScrollableViewProvider* svp;
|
|
|
|
CallQueryInterface(startFrame, &svp);
|
2004-10-19 02:24:27 +00:00
|
|
|
// If this very frame provides a scroll view, start there instead of frame's
|
|
|
|
// closest view, because the scroll view may be inside a child frame.
|
|
|
|
// For example, this happens in the case of overflow:scroll.
|
|
|
|
// In that case we still use GetNearestScrollingView() because
|
|
|
|
// we need a scrolling view that matches aDirection.
|
2005-01-16 21:25:15 +00:00
|
|
|
nsIScrollableView* sv;
|
|
|
|
nsIView* startView = svp && (sv = svp->GetScrollableView()) ? sv->View() : startFrame->GetClosestView();
|
2004-10-19 02:24:27 +00:00
|
|
|
NS_ASSERTION(startView, "No view to start searching for scrollable view from");
|
|
|
|
scrollView = nsLayoutUtils::GetNearestScrollingView(startView, aDirection);
|
2004-08-06 15:55:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!scrollView) {
|
|
|
|
nsIViewManager* viewManager = GetViewManager();
|
|
|
|
if (viewManager) {
|
|
|
|
viewManager->GetRootScrollableView(&scrollView);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return scrollView;
|
|
|
|
}
|
2000-06-14 23:18:54 +00:00
|
|
|
|
2001-03-13 06:38:59 +00:00
|
|
|
NS_IMETHODIMP
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
PresShell::CancelAllPendingReflows()
|
2001-03-13 06:38:59 +00:00
|
|
|
{
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
mDirtyRoots.Clear();
|
2001-03-14 07:47:00 +00:00
|
|
|
|
2000-09-20 07:20:23 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2005-06-10 13:57:27 +00:00
|
|
|
#ifdef ACCESSIBILITY
|
|
|
|
void nsIPresShell::InvalidateAccessibleSubtree(nsIContent *aContent)
|
|
|
|
{
|
2007-05-04 02:19:18 +00:00
|
|
|
if (gIsAccessibilityActive) {
|
2005-06-10 13:57:27 +00:00
|
|
|
nsCOMPtr<nsIAccessibilityService> accService =
|
|
|
|
do_GetService("@mozilla.org/accessibilityService;1");
|
|
|
|
if (accService) {
|
|
|
|
accService->InvalidateSubtreeFor(this, aContent,
|
2007-08-11 01:44:44 +00:00
|
|
|
nsIAccessibleEvent::EVENT_ASYNCH_SIGNIFICANT_CHANGE);
|
2005-06-10 13:57:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2002-10-22 06:07:52 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::RecreateFramesFor(nsIContent* aContent)
|
|
|
|
{
|
|
|
|
NS_ENSURE_TRUE(mPresContext, NS_ERROR_FAILURE);
|
2007-05-08 04:46:55 +00:00
|
|
|
if (!mDidInitialReflow) {
|
|
|
|
// Nothing to do here. In fact, if we proceed and aContent is the
|
|
|
|
// root we will crash.
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2002-10-22 06:07:52 +00:00
|
|
|
|
|
|
|
// Don't call RecreateFramesForContent since that is not exported and we want
|
|
|
|
// to keep the number of entrypoints down.
|
|
|
|
|
2005-10-25 22:32:13 +00:00
|
|
|
NS_ASSERTION(mViewManager, "Should have view manager");
|
2008-01-26 23:59:50 +00:00
|
|
|
nsIViewManager::UpdateViewBatch batch(mViewManager);
|
2005-10-25 22:32:13 +00:00
|
|
|
|
|
|
|
// Have to make sure that the content notifications are flushed before we
|
|
|
|
// start messing with the frame model; otherwise we can get content doubling.
|
|
|
|
mDocument->FlushPendingNotifications(Flush_ContentAndNotify);
|
|
|
|
|
2008-03-14 23:08:57 +00:00
|
|
|
nsAutoScriptBlocker scriptBlocker;
|
|
|
|
|
2002-10-22 06:07:52 +00:00
|
|
|
nsStyleChangeList changeList;
|
|
|
|
changeList.AppendChange(nsnull, aContent, nsChangeHint_ReconstructFrame);
|
2004-10-09 01:39:21 +00:00
|
|
|
|
2007-10-19 03:51:15 +00:00
|
|
|
// Mark ourselves as not safe to flush while we're doing frame construction.
|
|
|
|
++mChangeNestCount;
|
2005-02-18 16:11:53 +00:00
|
|
|
nsresult rv = mFrameConstructor->ProcessRestyledFrames(changeList);
|
2007-10-19 03:51:15 +00:00
|
|
|
--mChangeNestCount;
|
|
|
|
|
2008-01-26 23:59:50 +00:00
|
|
|
batch.EndUpdateViewBatch(NS_VMREFRESH_NO_SYNC);
|
2005-06-10 13:57:27 +00:00
|
|
|
#ifdef ACCESSIBILITY
|
|
|
|
InvalidateAccessibleSubtree(aContent);
|
|
|
|
#endif
|
2004-10-09 01:39:21 +00:00
|
|
|
return rv;
|
2002-10-22 06:07:52 +00:00
|
|
|
}
|
|
|
|
|
1999-02-12 17:45:58 +00:00
|
|
|
NS_IMETHODIMP
|
1998-11-19 00:43:36 +00:00
|
|
|
PresShell::ClearFrameRefs(nsIFrame* aFrame)
|
|
|
|
{
|
2004-02-27 17:17:37 +00:00
|
|
|
mPresContext->EventStateManager()->ClearFrameRefs(aFrame);
|
1999-04-01 23:58:11 +00:00
|
|
|
|
1998-11-21 00:19:36 +00:00
|
|
|
if (aFrame == mCurrentEventFrame) {
|
2003-06-30 10:46:59 +00:00
|
|
|
mCurrentEventContent = aFrame->GetContent();
|
1998-11-21 00:19:36 +00:00
|
|
|
mCurrentEventFrame = nsnull;
|
|
|
|
}
|
1999-09-02 18:14:01 +00:00
|
|
|
|
2007-02-20 20:22:19 +00:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
if (aFrame == mDrawEventTargetFrame) {
|
|
|
|
mDrawEventTargetFrame = nsnull;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1999-09-02 18:14:01 +00:00
|
|
|
for (int i=0; i<mCurrentEventFrameStack.Count(); i++) {
|
|
|
|
if (aFrame == (nsIFrame*)mCurrentEventFrameStack.ElementAt(i)) {
|
2000-04-24 04:41:27 +00:00
|
|
|
//One of our stack frames was deleted. Get its content so that when we
|
|
|
|
//pop it we can still get its new frame from its content
|
2003-06-30 10:46:59 +00:00
|
|
|
nsIContent *currentEventContent = aFrame->GetContent();
|
2004-09-13 03:22:46 +00:00
|
|
|
mCurrentEventContentStack.ReplaceObjectAt(currentEventContent, i);
|
1999-09-02 18:14:01 +00:00
|
|
|
mCurrentEventFrameStack.ReplaceElementAt(nsnull, i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-12 07:41:11 +00:00
|
|
|
nsWeakFrame* weakFrame = mWeakFrames;
|
|
|
|
while (weakFrame) {
|
|
|
|
nsWeakFrame* prev = weakFrame->GetPreviousWeakFrame();
|
|
|
|
if (weakFrame->GetFrame() == aFrame) {
|
|
|
|
// This removes weakFrame from mWeakFrames.
|
|
|
|
weakFrame->Clear(this);
|
|
|
|
}
|
|
|
|
weakFrame = prev;
|
|
|
|
}
|
|
|
|
|
1999-02-12 17:45:58 +00:00
|
|
|
return NS_OK;
|
1998-11-19 00:43:36 +00:00
|
|
|
}
|
|
|
|
|
1999-02-05 18:25:29 +00:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 17:45:58 +00:00
|
|
|
PresShell::CreateRenderingContext(nsIFrame *aFrame,
|
|
|
|
nsIRenderingContext** aResult)
|
1998-10-02 01:12:39 +00:00
|
|
|
{
|
1999-02-12 17:45:58 +00:00
|
|
|
NS_PRECONDITION(nsnull != aResult, "null ptr");
|
|
|
|
if (nsnull == aResult) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
|
2006-06-15 03:19:32 +00:00
|
|
|
nsIWidget* widget = nsnull;
|
2007-02-18 04:44:21 +00:00
|
|
|
nsPoint offset(0,0);
|
|
|
|
if (mPresContext->IsScreen()) {
|
|
|
|
// Get the widget to create the rendering context for and calculate
|
|
|
|
// the offset from the frame to it. (Calculating the offset is important
|
|
|
|
// if the frame isn't the root frame.)
|
|
|
|
nsPoint viewOffset;
|
|
|
|
nsIView* view = aFrame->GetClosestView(&viewOffset);
|
|
|
|
nsPoint widgetOffset;
|
|
|
|
widget = view->GetNearestWidget(&widgetOffset);
|
|
|
|
offset = viewOffset + widgetOffset;
|
|
|
|
} else {
|
|
|
|
nsIFrame* pageFrame = nsLayoutUtils::GetPageFrame(aFrame);
|
|
|
|
// This might not always come up with a frame, i.e. during reflow;
|
|
|
|
// that's fine, because the translation doesn't matter during reflow.
|
|
|
|
if (pageFrame)
|
|
|
|
offset = aFrame->GetOffsetTo(pageFrame);
|
|
|
|
}
|
1998-10-02 01:12:39 +00:00
|
|
|
|
2006-06-15 03:19:32 +00:00
|
|
|
nsresult rv;
|
1999-02-12 17:45:58 +00:00
|
|
|
nsIRenderingContext* result = nsnull;
|
2004-02-02 22:17:21 +00:00
|
|
|
nsIDeviceContext *deviceContext = mPresContext->DeviceContext();
|
|
|
|
if (widget) {
|
2004-05-18 01:13:45 +00:00
|
|
|
rv = deviceContext->CreateRenderingContext(widget, result);
|
2004-02-02 22:17:21 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
rv = deviceContext->CreateRenderingContext(result);
|
1999-02-12 17:45:58 +00:00
|
|
|
}
|
|
|
|
*aResult = result;
|
1998-10-02 01:12:39 +00:00
|
|
|
|
2007-05-12 13:06:16 +00:00
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
result->Translate(offset.x, offset.y);
|
|
|
|
}
|
2007-02-18 04:44:21 +00:00
|
|
|
|
1998-10-02 01:12:39 +00:00
|
|
|
return rv;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
1999-02-12 05:39:33 +00:00
|
|
|
NS_IMETHODIMP
|
2003-01-13 23:10:53 +00:00
|
|
|
PresShell::GoToAnchor(const nsAString& aAnchorName, PRBool aScroll)
|
1999-02-12 05:39:33 +00:00
|
|
|
{
|
2004-05-27 22:08:42 +00:00
|
|
|
if (!mDocument) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2004-02-27 17:17:37 +00:00
|
|
|
// Hold a reference to the ESM in case event dispatch tears us down.
|
|
|
|
nsCOMPtr<nsIEventStateManager> esm = mPresContext->EventStateManager();
|
|
|
|
|
2003-01-13 23:10:53 +00:00
|
|
|
if (aAnchorName.IsEmpty()) {
|
|
|
|
NS_ASSERTION(!aScroll, "can't scroll to empty anchor name");
|
2004-02-27 17:17:37 +00:00
|
|
|
esm->SetContentState(nsnull, NS_EVENT_STATE_URLTARGET);
|
2003-01-13 23:10:53 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-10-11 13:50:45 +00:00
|
|
|
nsCOMPtr<nsIDOMDocument> doc = do_QueryInterface(mDocument);
|
|
|
|
nsCOMPtr<nsIDOMHTMLDocument> htmlDoc = do_QueryInterface(mDocument);
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
nsCOMPtr<nsIContent> content;
|
1999-02-12 05:39:33 +00:00
|
|
|
|
2000-10-11 13:50:45 +00:00
|
|
|
// Search for an element with a matching "id" attribute
|
|
|
|
if (doc) {
|
1999-02-12 05:39:33 +00:00
|
|
|
nsCOMPtr<nsIDOMElement> element;
|
2000-07-28 21:48:08 +00:00
|
|
|
rv = doc->GetElementById(aAnchorName, getter_AddRefs(element));
|
1999-04-09 04:28:15 +00:00
|
|
|
if (NS_SUCCEEDED(rv) && element) {
|
1999-02-12 05:39:33 +00:00
|
|
|
// Get the nsIContent interface, because that's what we need to
|
|
|
|
// get the primary frame
|
2000-10-11 13:50:45 +00:00
|
|
|
content = do_QueryInterface(element);
|
1999-03-20 01:51:00 +00:00
|
|
|
}
|
|
|
|
}
|
1999-02-12 05:39:33 +00:00
|
|
|
|
2000-10-11 13:50:45 +00:00
|
|
|
// Search for an anchor element with a matching "name" attribute
|
|
|
|
if (!content && htmlDoc) {
|
|
|
|
nsCOMPtr<nsIDOMNodeList> list;
|
|
|
|
// Find a matching list of named nodes
|
|
|
|
rv = htmlDoc->GetElementsByName(aAnchorName, getter_AddRefs(list));
|
|
|
|
if (NS_SUCCEEDED(rv) && list) {
|
|
|
|
PRUint32 i;
|
|
|
|
// Loop through the named nodes looking for the first anchor
|
2003-03-15 16:30:09 +00:00
|
|
|
for (i = 0; PR_TRUE; i++) {
|
2000-10-11 13:50:45 +00:00
|
|
|
nsCOMPtr<nsIDOMNode> node;
|
|
|
|
rv = list->Item(i, getter_AddRefs(node));
|
2003-03-15 16:30:09 +00:00
|
|
|
if (!node) { // End of list
|
2000-10-11 13:50:45 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
// Ensure it's an anchor element
|
2003-03-15 16:30:09 +00:00
|
|
|
content = do_QueryInterface(node);
|
|
|
|
if (content) {
|
2006-12-26 17:47:52 +00:00
|
|
|
if (content->Tag() == nsGkAtoms::a &&
|
2006-05-05 06:52:21 +00:00
|
|
|
content->IsNodeOfType(nsINode::eHTML)) {
|
2000-10-11 13:50:45 +00:00
|
|
|
break;
|
|
|
|
}
|
2003-03-15 16:30:09 +00:00
|
|
|
content = nsnull;
|
2000-10-11 13:50:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Search for anchor in the HTML namespace with a matching name
|
|
|
|
if (!content && !htmlDoc)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNodeList> list;
|
|
|
|
NS_NAMED_LITERAL_STRING(nameSpace, "http://www.w3.org/1999/xhtml");
|
|
|
|
// Get the list of anchor elements
|
|
|
|
rv = doc->GetElementsByTagNameNS(nameSpace, NS_LITERAL_STRING("a"), getter_AddRefs(list));
|
|
|
|
if (NS_SUCCEEDED(rv) && list) {
|
|
|
|
PRUint32 i;
|
|
|
|
// Loop through the named nodes looking for the first anchor
|
2003-03-15 16:30:09 +00:00
|
|
|
for (i = 0; PR_TRUE; i++) {
|
2000-10-11 13:50:45 +00:00
|
|
|
nsCOMPtr<nsIDOMNode> node;
|
|
|
|
rv = list->Item(i, getter_AddRefs(node));
|
2003-03-15 16:30:09 +00:00
|
|
|
if (!node) { // End of list
|
2000-10-11 13:50:45 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
// Compare the name attribute
|
|
|
|
nsCOMPtr<nsIDOMElement> element = do_QueryInterface(node);
|
|
|
|
nsAutoString value;
|
|
|
|
if (element && NS_SUCCEEDED(element->GetAttribute(NS_LITERAL_STRING("name"), value))) {
|
2002-02-19 22:49:12 +00:00
|
|
|
if (value.Equals(aAnchorName)) {
|
2000-10-11 13:50:45 +00:00
|
|
|
content = do_QueryInterface(element);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Fixes bug 66597, bug 103284, bug 114440, bug 120023, bug 128741, bug 19259. Cleans up browse with caret, makes it work with XML content docs, creates keyboard toggle for it (Accel+shift+K), synchronizes focus and document selection so that users can tab navigate relative to their last find or click in text, or vice versa, makes tabbing move relative to named anchor that has been jumped to. r=bryner, sr=alecf, a=asa
2002-03-10 06:21:48 +00:00
|
|
|
nsCOMPtr<nsIDOMRange> jumpToRange;
|
2003-03-19 23:45:42 +00:00
|
|
|
nsCOMPtr<nsIXPointerResult> xpointerResult;
|
|
|
|
if (!content) {
|
|
|
|
nsCOMPtr<nsIDOMXMLDocument> xmldoc = do_QueryInterface(mDocument);
|
|
|
|
if (xmldoc) {
|
2005-02-20 09:55:02 +00:00
|
|
|
// Try XPointer
|
2003-03-19 23:45:42 +00:00
|
|
|
xmldoc->EvaluateXPointer(aAnchorName, getter_AddRefs(xpointerResult));
|
|
|
|
if (xpointerResult) {
|
|
|
|
xpointerResult->Item(0, getter_AddRefs(jumpToRange));
|
|
|
|
if (!jumpToRange) {
|
|
|
|
// We know it was an XPointer, so there is no point in
|
|
|
|
// trying any other pointer types, let's just return
|
|
|
|
// an error.
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-02-20 09:55:02 +00:00
|
|
|
// Finally try FIXptr
|
|
|
|
if (!jumpToRange) {
|
|
|
|
xmldoc->EvaluateFIXptr(aAnchorName,getter_AddRefs(jumpToRange));
|
|
|
|
}
|
|
|
|
|
Fixes bug 66597, bug 103284, bug 114440, bug 120023, bug 128741, bug 19259. Cleans up browse with caret, makes it work with XML content docs, creates keyboard toggle for it (Accel+shift+K), synchronizes focus and document selection so that users can tab navigate relative to their last find or click in text, or vice versa, makes tabbing move relative to named anchor that has been jumped to. r=bryner, sr=alecf, a=asa
2002-03-10 06:21:48 +00:00
|
|
|
if (jumpToRange) {
|
2001-12-20 05:15:52 +00:00
|
|
|
nsCOMPtr<nsIDOMNode> node;
|
Fixes bug 66597, bug 103284, bug 114440, bug 120023, bug 128741, bug 19259. Cleans up browse with caret, makes it work with XML content docs, creates keyboard toggle for it (Accel+shift+K), synchronizes focus and document selection so that users can tab navigate relative to their last find or click in text, or vice versa, makes tabbing move relative to named anchor that has been jumped to. r=bryner, sr=alecf, a=asa
2002-03-10 06:21:48 +00:00
|
|
|
jumpToRange->GetStartContainer(getter_AddRefs(node));
|
2001-12-20 05:15:52 +00:00
|
|
|
if (node) {
|
2005-02-20 09:55:02 +00:00
|
|
|
PRUint16 nodeType;
|
|
|
|
node->GetNodeType(&nodeType);
|
|
|
|
PRInt32 offset = -1;
|
|
|
|
jumpToRange->GetStartOffset(&offset);
|
|
|
|
switch (nodeType) {
|
|
|
|
case nsIDOMNode::ATTRIBUTE_NODE:
|
|
|
|
{
|
|
|
|
// XXX Assuming jumping to the ownerElement is the sanest action.
|
|
|
|
nsCOMPtr<nsIAttribute> attr = do_QueryInterface(node);
|
|
|
|
content = attr->GetContent();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case nsIDOMNode::DOCUMENT_NODE:
|
|
|
|
{
|
|
|
|
if (offset >= 0) {
|
|
|
|
nsCOMPtr<nsIDocument> document = do_QueryInterface(node);
|
|
|
|
content = document->GetChildAt(offset);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case nsIDOMNode::DOCUMENT_FRAGMENT_NODE:
|
|
|
|
case nsIDOMNode::ELEMENT_NODE:
|
|
|
|
case nsIDOMNode::ENTITY_REFERENCE_NODE:
|
|
|
|
{
|
|
|
|
if (offset >= 0) {
|
|
|
|
nsCOMPtr<nsIContent> parent = do_QueryInterface(node);
|
|
|
|
content = parent->GetChildAt(offset);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case nsIDOMNode::CDATA_SECTION_NODE:
|
|
|
|
case nsIDOMNode::COMMENT_NODE:
|
|
|
|
case nsIDOMNode::TEXT_NODE:
|
|
|
|
case nsIDOMNode::PROCESSING_INSTRUCTION_NODE:
|
|
|
|
{
|
|
|
|
// XXX This should scroll to a specific position in the text.
|
|
|
|
content = do_QueryInterface(node);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2001-12-20 05:15:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-02-20 09:55:02 +00:00
|
|
|
|
2004-02-27 17:17:37 +00:00
|
|
|
esm->SetContentState(content, NS_EVENT_STATE_URLTARGET);
|
2000-10-11 13:50:45 +00:00
|
|
|
|
2003-01-13 23:10:53 +00:00
|
|
|
if (content) {
|
2003-05-06 05:46:46 +00:00
|
|
|
if (aScroll) {
|
2007-03-06 09:53:56 +00:00
|
|
|
rv = ScrollContentIntoView(content, NS_PRESSHELL_SCROLL_TOP,
|
|
|
|
NS_PRESSHELL_SCROLL_ANYWHERE);
|
2004-11-12 21:58:12 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2008-02-27 10:01:17 +00:00
|
|
|
|
|
|
|
nsIScrollableFrame* rootScroll = GetRootScrollFrameAsScrollable();
|
|
|
|
if (rootScroll) {
|
|
|
|
mLastAnchorScrolledTo = content;
|
|
|
|
mLastAnchorScrollPositionY = rootScroll->GetScrollPosition().y;
|
|
|
|
}
|
2004-11-12 21:58:12 +00:00
|
|
|
}
|
2001-03-27 23:59:56 +00:00
|
|
|
|
2004-11-12 21:58:12 +00:00
|
|
|
// Should we select the target? This action is controlled by a
|
|
|
|
// preference: the default is to not select.
|
|
|
|
PRBool selectAnchor = nsContentUtils::GetBoolPref("layout.selectanchor");
|
2004-04-29 23:34:19 +00:00
|
|
|
|
2004-11-12 21:58:12 +00:00
|
|
|
// Even if select anchor pref is false, we must still move the
|
|
|
|
// caret there. That way tabbing will start from the new
|
|
|
|
// location
|
|
|
|
if (!jumpToRange) {
|
|
|
|
jumpToRange = do_CreateInstance(kRangeCID);
|
|
|
|
if (jumpToRange) {
|
|
|
|
while (content && content->GetChildCount() > 0) {
|
|
|
|
content = content->GetChildAt(0);
|
Fixes bug 66597, bug 103284, bug 114440, bug 120023, bug 128741, bug 19259. Cleans up browse with caret, makes it work with XML content docs, creates keyboard toggle for it (Accel+shift+K), synchronizes focus and document selection so that users can tab navigate relative to their last find or click in text, or vice versa, makes tabbing move relative to named anchor that has been jumped to. r=bryner, sr=alecf, a=asa
2002-03-10 06:21:48 +00:00
|
|
|
}
|
2004-11-12 21:58:12 +00:00
|
|
|
nsCOMPtr<nsIDOMNode> node(do_QueryInterface(content));
|
2005-11-20 22:05:24 +00:00
|
|
|
NS_ASSERTION(node, "No nsIDOMNode for descendant of anchor");
|
2004-11-12 21:58:12 +00:00
|
|
|
jumpToRange->SelectNodeContents(node);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (jumpToRange) {
|
|
|
|
// Select the anchor
|
2006-04-26 02:01:07 +00:00
|
|
|
nsISelection* sel = mSelection->
|
|
|
|
GetSelection(nsISelectionController::SELECTION_NORMAL);
|
|
|
|
if (sel) {
|
2004-11-12 21:58:12 +00:00
|
|
|
sel->RemoveAllRanges();
|
|
|
|
sel->AddRange(jumpToRange);
|
|
|
|
if (!selectAnchor) {
|
|
|
|
// Use a caret (collapsed selection) at the start of the anchor
|
|
|
|
sel->CollapseToStart();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (selectAnchor && xpointerResult) {
|
|
|
|
// Select the rest (if any) of the ranges in XPointerResult
|
|
|
|
PRUint32 count, i;
|
|
|
|
xpointerResult->GetLength(&count);
|
|
|
|
for (i = 1; i < count; i++) { // jumpToRange is i = 0
|
|
|
|
nsCOMPtr<nsIDOMRange> range;
|
|
|
|
xpointerResult->Item(i, getter_AddRefs(range));
|
|
|
|
sel->AddRange(range);
|
Fixes bug 66597, bug 103284, bug 114440, bug 120023, bug 128741, bug 19259. Cleans up browse with caret, makes it work with XML content docs, creates keyboard toggle for it (Accel+shift+K), synchronizes focus and document selection so that users can tab navigate relative to their last find or click in text, or vice versa, makes tabbing move relative to named anchor that has been jumped to. r=bryner, sr=alecf, a=asa
2002-03-10 06:21:48 +00:00
|
|
|
}
|
2001-03-27 23:59:56 +00:00
|
|
|
}
|
2005-04-12 20:25:49 +00:00
|
|
|
// Selection is at anchor.
|
|
|
|
// Now focus the document itself if focus is on an element within it.
|
2005-08-12 04:11:00 +00:00
|
|
|
nsPIDOMWindow *win = mDocument->GetWindow();
|
2005-07-30 20:57:07 +00:00
|
|
|
|
2005-04-12 20:25:49 +00:00
|
|
|
if (win) {
|
|
|
|
nsCOMPtr<nsIFocusController> focusController = win->GetRootFocusController();
|
|
|
|
if (focusController) {
|
|
|
|
nsCOMPtr<nsIDOMWindowInternal> focusedWin;
|
|
|
|
focusController->GetFocusedWindow(getter_AddRefs(focusedWin));
|
2005-08-12 04:11:00 +00:00
|
|
|
if (SameCOMIdentity(win, focusedWin)) {
|
2005-04-12 20:25:49 +00:00
|
|
|
esm->ChangeFocusWith(nsnull, nsIEventStateManager::eEventFocusedByApplication);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-02-12 05:39:33 +00:00
|
|
|
}
|
|
|
|
} else {
|
2001-10-17 01:06:19 +00:00
|
|
|
rv = NS_ERROR_FAILURE; //changed to NS_OK in quirks mode if ScrollTo is called
|
|
|
|
|
|
|
|
// Scroll to the top/left if the anchor can not be
|
2001-10-20 03:12:33 +00:00
|
|
|
// found and it is labelled top (quirks mode only). @see bug 80784
|
2006-02-03 14:18:39 +00:00
|
|
|
if ((NS_LossyConvertUTF16toASCII(aAnchorName).LowerCaseEqualsLiteral("top")) &&
|
2003-12-24 21:51:50 +00:00
|
|
|
(mPresContext->CompatibilityMode() == eCompatibility_NavQuirks)) {
|
2003-01-13 23:10:53 +00:00
|
|
|
rv = NS_OK;
|
|
|
|
// Check |aScroll| after setting |rv| so we set |rv| to the same
|
|
|
|
// thing whether or not |aScroll| is true.
|
|
|
|
if (aScroll && mViewManager) {
|
|
|
|
// Get the viewport scroller
|
|
|
|
nsIScrollableView* scrollingView;
|
|
|
|
mViewManager->GetRootScrollableView(&scrollingView);
|
|
|
|
if (scrollingView) {
|
|
|
|
// Scroll to the top of the page
|
|
|
|
scrollingView->ScrollTo(0, 0, NS_VMREFRESH_IMMEDIATE);
|
|
|
|
}
|
2001-10-17 01:06:19 +00:00
|
|
|
}
|
|
|
|
}
|
1999-02-12 05:39:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2008-02-27 10:01:17 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::ScrollToAnchor()
|
|
|
|
{
|
|
|
|
if (!mLastAnchorScrolledTo)
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
nsIScrollableFrame* rootScroll = GetRootScrollFrameAsScrollable();
|
|
|
|
if (!rootScroll ||
|
|
|
|
mLastAnchorScrollPositionY != rootScroll->GetScrollPosition().y)
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
nsresult rv = ScrollContentIntoView(mLastAnchorScrolledTo, NS_PRESSHELL_SCROLL_TOP,
|
|
|
|
NS_PRESSHELL_SCROLL_ANYWHERE);
|
|
|
|
mLastAnchorScrolledTo = nsnull;
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2007-07-16 05:53:19 +00:00
|
|
|
/*
|
|
|
|
* Helper (per-continuation) for ScrollContentIntoView.
|
|
|
|
*
|
|
|
|
* @param aFrame [in] Frame whose bounds should be unioned
|
|
|
|
* @param aVPercent [in] same as for ScrollContentIntoView
|
|
|
|
* @param aRect [inout] rect into which its bounds should be unioned
|
2007-07-16 05:55:04 +00:00
|
|
|
* @param aHaveRect [inout] whether aRect contains data yet
|
2007-07-16 05:53:19 +00:00
|
|
|
* @param aClosestScrolledView [inout] the view to which aRect is relative.
|
|
|
|
* If null, should be filled in appropriately. If non-null, the function
|
|
|
|
* will no-op if the closest scrolling view doesn't match.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
UnionRectForClosestScrolledView(nsIFrame* aFrame,
|
|
|
|
PRIntn aVPercent,
|
|
|
|
nsRect& aRect,
|
2007-07-16 05:55:04 +00:00
|
|
|
PRBool& aHaveRect,
|
2007-07-16 05:53:19 +00:00
|
|
|
nsIView*& aClosestScrolledView)
|
|
|
|
{
|
|
|
|
nsRect frameBounds = aFrame->GetRect();
|
|
|
|
nsPoint offset;
|
|
|
|
nsIView* closestView;
|
|
|
|
aFrame->GetOffsetFromView(offset, &closestView);
|
|
|
|
frameBounds.MoveTo(offset);
|
|
|
|
|
|
|
|
// If this is an inline frame and either the bounds height is 0 (quirks
|
|
|
|
// layout model) or aVPercent is not NS_PRESSHELL_SCROLL_ANYWHERE, we need to
|
|
|
|
// change the top of the bounds to include the whole line.
|
|
|
|
if (frameBounds.height == 0 || aVPercent != NS_PRESSHELL_SCROLL_ANYWHERE) {
|
|
|
|
nsIAtom* frameType = NULL;
|
|
|
|
nsIFrame *prevFrame = aFrame;
|
|
|
|
nsIFrame *f = aFrame;
|
|
|
|
|
|
|
|
while (f &&
|
|
|
|
(frameType = f->GetType()) == nsGkAtoms::inlineFrame) {
|
|
|
|
prevFrame = f;
|
|
|
|
f = prevFrame->GetParent();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (f != aFrame &&
|
|
|
|
f &&
|
|
|
|
frameType == nsGkAtoms::blockFrame) {
|
|
|
|
// find the line containing aFrame and increase the top of |offset|.
|
|
|
|
nsCOMPtr<nsILineIterator> lines(do_QueryInterface(f));
|
|
|
|
|
|
|
|
if (lines) {
|
|
|
|
PRInt32 index = -1;
|
|
|
|
lines->FindLineContaining(prevFrame, &index);
|
|
|
|
if (index >= 0) {
|
|
|
|
nsIFrame *trash1;
|
|
|
|
PRInt32 trash2;
|
|
|
|
nsRect lineBounds;
|
|
|
|
PRUint32 trash3;
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(lines->GetLine(index, &trash1, &trash2,
|
|
|
|
lineBounds, &trash3))) {
|
|
|
|
nsPoint blockOffset;
|
|
|
|
nsIView* blockView;
|
|
|
|
f->GetOffsetFromView(blockOffset, &blockView);
|
|
|
|
|
|
|
|
if (blockView == closestView) {
|
|
|
|
// XXX If views not equal, this is hard. Do we want to bother?
|
|
|
|
nscoord newoffset = lineBounds.y + blockOffset.y;
|
|
|
|
|
|
|
|
if (newoffset < frameBounds.y)
|
|
|
|
frameBounds.y = newoffset;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_ASSERTION(closestView && !closestView->ToScrollableView(),
|
|
|
|
"What happened to the scrolled view? "
|
|
|
|
"The frame should not be directly in the scrolling view!");
|
|
|
|
|
|
|
|
// Walk up the view hierarchy. Make sure to add the view's position
|
|
|
|
// _after_ we get the parent and see whether it's scrollable. We want to
|
|
|
|
// make sure to get the scrolled view's position after it has been scrolled.
|
|
|
|
while (closestView) {
|
|
|
|
nsIView* parent = closestView->GetParent();
|
|
|
|
if (parent && parent->ToScrollableView())
|
|
|
|
break;
|
|
|
|
frameBounds += closestView->GetPosition();
|
|
|
|
closestView = parent;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!aClosestScrolledView)
|
|
|
|
aClosestScrolledView = closestView;
|
|
|
|
|
|
|
|
if (aClosestScrolledView == closestView) {
|
2007-07-16 05:55:04 +00:00
|
|
|
if (aHaveRect) {
|
|
|
|
// We can't use nsRect::UnionRect since it drops empty rects on
|
|
|
|
// the floor, and we need to include them. (Thus we need
|
|
|
|
// aHaveRect to know when to drop the initial value on the floor.)
|
2008-02-27 09:46:22 +00:00
|
|
|
aRect.UnionRectIncludeEmpty(aRect, frameBounds);
|
2007-07-16 05:55:04 +00:00
|
|
|
} else {
|
|
|
|
aHaveRect = PR_TRUE;
|
|
|
|
aRect = frameBounds;
|
|
|
|
}
|
2007-07-16 05:53:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-11-12 04:38:28 +00:00
|
|
|
/**
|
|
|
|
* This function takes a scrolling view, a rect, and a scroll position and
|
|
|
|
* attempts to scroll that rect to that position in that view. The rect
|
|
|
|
* should be in the coordinate system of the _scrolled_ view.
|
|
|
|
*/
|
|
|
|
static void ScrollViewToShowRect(nsIScrollableView* aScrollingView,
|
|
|
|
nsRect & aRect,
|
|
|
|
PRIntn aVPercent,
|
|
|
|
PRIntn aHPercent)
|
|
|
|
{
|
|
|
|
// Determine the visible rect in the scrolling view's coordinate space.
|
|
|
|
// The size of the visible area is the clip view size
|
2004-09-20 22:25:07 +00:00
|
|
|
nsRect visibleRect = aScrollingView->View()->GetBounds(); // get width and height
|
2002-11-12 04:38:28 +00:00
|
|
|
aScrollingView->GetScrollPosition(visibleRect.x, visibleRect.y);
|
|
|
|
|
|
|
|
// The actual scroll offsets
|
|
|
|
nscoord scrollOffsetX = visibleRect.x;
|
|
|
|
nscoord scrollOffsetY = visibleRect.y;
|
|
|
|
|
|
|
|
nscoord lineHeight;
|
|
|
|
aScrollingView->GetLineHeight(&lineHeight);
|
|
|
|
|
|
|
|
// See how the rect should be positioned vertically
|
2006-12-13 20:43:59 +00:00
|
|
|
if (NS_PRESSHELL_SCROLL_ANYWHERE == aVPercent ||
|
|
|
|
(NS_PRESSHELL_SCROLL_IF_NOT_VISIBLE == aVPercent &&
|
|
|
|
aRect.height < lineHeight)) {
|
2002-11-12 04:38:28 +00:00
|
|
|
// The caller doesn't care where the frame is positioned vertically,
|
|
|
|
// so long as it's fully visible
|
|
|
|
if (aRect.y < visibleRect.y) {
|
|
|
|
// Scroll up so the frame's top edge is visible
|
|
|
|
scrollOffsetY = aRect.y;
|
|
|
|
} else if (aRect.YMost() > visibleRect.YMost()) {
|
|
|
|
// Scroll down so the frame's bottom edge is visible. Make sure the
|
|
|
|
// frame's top edge is still visible
|
|
|
|
scrollOffsetY += aRect.YMost() - visibleRect.YMost();
|
|
|
|
if (scrollOffsetY > aRect.y) {
|
|
|
|
scrollOffsetY = aRect.y;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (NS_PRESSHELL_SCROLL_IF_NOT_VISIBLE == aVPercent) {
|
|
|
|
// Scroll only if no part of the frame is visible in this view
|
|
|
|
if (aRect.YMost() - lineHeight < visibleRect.y) {
|
|
|
|
// Scroll up so the frame's top edge is visible
|
|
|
|
scrollOffsetY = aRect.y;
|
|
|
|
} else if (aRect.y + lineHeight > visibleRect.YMost()) {
|
|
|
|
// Scroll down so the frame's bottom edge is visible. Make sure the
|
|
|
|
// frame's top edge is still visible
|
|
|
|
scrollOffsetY += aRect.YMost() - visibleRect.YMost();
|
|
|
|
if (scrollOffsetY > aRect.y) {
|
|
|
|
scrollOffsetY = aRect.y;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Align the frame edge according to the specified percentage
|
|
|
|
nscoord frameAlignY =
|
2003-02-27 01:38:20 +00:00
|
|
|
NSToCoordRound(aRect.y + aRect.height * (aVPercent / 100.0f));
|
2002-11-12 04:38:28 +00:00
|
|
|
scrollOffsetY =
|
2003-02-27 01:38:20 +00:00
|
|
|
NSToCoordRound(frameAlignY - visibleRect.height * (aVPercent / 100.0f));
|
2002-11-12 04:38:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// See how the frame should be positioned horizontally
|
2006-12-13 20:43:59 +00:00
|
|
|
if (NS_PRESSHELL_SCROLL_ANYWHERE == aHPercent ||
|
|
|
|
(NS_PRESSHELL_SCROLL_IF_NOT_VISIBLE == aHPercent &&
|
|
|
|
aRect.width < lineHeight)) {
|
2002-11-12 04:38:28 +00:00
|
|
|
// The caller doesn't care where the frame is positioned horizontally,
|
|
|
|
// so long as it's fully visible
|
|
|
|
if (aRect.x < visibleRect.x) {
|
|
|
|
// Scroll left so the frame's left edge is visible
|
|
|
|
scrollOffsetX = aRect.x;
|
|
|
|
} else if (aRect.XMost() > visibleRect.XMost()) {
|
|
|
|
// Scroll right so the frame's right edge is visible. Make sure the
|
|
|
|
// frame's left edge is still visible
|
|
|
|
scrollOffsetX += aRect.XMost() - visibleRect.XMost();
|
|
|
|
if (scrollOffsetX > aRect.x) {
|
|
|
|
scrollOffsetX = aRect.x;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (NS_PRESSHELL_SCROLL_IF_NOT_VISIBLE == aHPercent) {
|
|
|
|
// Scroll only if no part of the frame is visible in this view
|
|
|
|
// XXXbz using the line height here is odd, but there are no
|
|
|
|
// natural dimensions to use here, really....
|
|
|
|
if (aRect.XMost() - lineHeight < visibleRect.x) {
|
|
|
|
// Scroll left so the frame's left edge is visible
|
|
|
|
scrollOffsetX = aRect.x;
|
|
|
|
} else if (aRect.x + lineHeight > visibleRect.XMost()) {
|
|
|
|
// Scroll right so the frame's right edge is visible. Make sure the
|
|
|
|
// frame's left edge is still visible
|
|
|
|
scrollOffsetX += aRect.XMost() - visibleRect.XMost();
|
|
|
|
if (scrollOffsetX > aRect.x) {
|
|
|
|
scrollOffsetX = aRect.x;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Align the frame edge according to the specified percentage
|
|
|
|
nscoord frameAlignX =
|
2003-02-27 01:38:20 +00:00
|
|
|
NSToCoordRound(aRect.x + (aRect.width) * (aHPercent / 100.0f));
|
2002-11-12 04:38:28 +00:00
|
|
|
scrollOffsetX =
|
2003-02-27 01:38:20 +00:00
|
|
|
NSToCoordRound(frameAlignX - visibleRect.width * (aHPercent / 100.0f));
|
2002-11-12 04:38:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
aScrollingView->ScrollTo(scrollOffsetX, scrollOffsetY,
|
|
|
|
NS_VMREFRESH_IMMEDIATE);
|
|
|
|
}
|
|
|
|
|
1999-02-18 22:52:21 +00:00
|
|
|
NS_IMETHODIMP
|
2007-03-07 19:08:36 +00:00
|
|
|
PresShell::ScrollContentIntoView(nsIContent* aContent,
|
|
|
|
PRIntn aVPercent,
|
|
|
|
PRIntn aHPercent) const
|
1999-02-18 22:52:21 +00:00
|
|
|
{
|
2007-03-07 19:08:36 +00:00
|
|
|
nsCOMPtr<nsIContent> content = aContent; // Keep content alive while flushing.
|
|
|
|
NS_ENSURE_TRUE(content, NS_ERROR_NULL_POINTER);
|
|
|
|
nsCOMPtr<nsIDocument> currentDoc = content->GetCurrentDoc();
|
|
|
|
NS_ENSURE_STATE(currentDoc);
|
|
|
|
currentDoc->FlushPendingNotifications(Flush_Layout);
|
|
|
|
nsIFrame* frame = GetPrimaryFrameFor(content);
|
|
|
|
if (!frame) {
|
1999-02-18 22:52:21 +00:00
|
|
|
return NS_ERROR_NULL_POINTER;
|
1999-07-19 18:38:33 +00:00
|
|
|
}
|
2000-11-04 08:21:20 +00:00
|
|
|
|
2000-05-11 22:40:51 +00:00
|
|
|
// Before we scroll the frame into view, ask the command dispatcher
|
|
|
|
// if we're resetting focus because a window just got an activate
|
|
|
|
// event. If we are, we do not want to scroll the frame into view.
|
|
|
|
// Example: The user clicks on an anchor, and then deactivates the
|
|
|
|
// window. When they reactivate the window, the expected behavior
|
|
|
|
// is not for the anchor link to scroll back into view. That is what
|
|
|
|
// this check is preventing.
|
|
|
|
// XXX: The dependency on the command dispatcher needs to be fixed.
|
2007-03-07 19:08:36 +00:00
|
|
|
nsPIDOMWindow* ourWindow = currentDoc->GetWindow();
|
|
|
|
if(ourWindow) {
|
|
|
|
nsIFocusController *focusController = ourWindow->GetRootFocusController();
|
|
|
|
if (focusController) {
|
|
|
|
PRBool dontScroll = PR_FALSE;
|
|
|
|
focusController->GetSuppressFocusScroll(&dontScroll);
|
|
|
|
if(dontScroll) {
|
|
|
|
return NS_OK;
|
2000-11-04 08:21:20 +00:00
|
|
|
}
|
2000-05-11 22:40:51 +00:00
|
|
|
}
|
|
|
|
}
|
2000-11-04 08:21:20 +00:00
|
|
|
|
2002-11-12 04:38:28 +00:00
|
|
|
// This is a two-step process.
|
|
|
|
// Step 1: Find the bounds of the rect we want to scroll into view. For
|
2003-10-10 02:35:05 +00:00
|
|
|
// example, for an inline frame we may want to scroll in the whole
|
|
|
|
// line.
|
2002-11-12 04:38:28 +00:00
|
|
|
// Step 2: Walk the views that are parents of the frame and scroll them
|
|
|
|
// appropriately.
|
|
|
|
|
2007-07-16 05:53:19 +00:00
|
|
|
nsIView *closestView = nsnull;
|
|
|
|
nsRect frameBounds;
|
2007-07-16 05:55:04 +00:00
|
|
|
PRBool haveRect = PR_FALSE;
|
2007-07-16 05:53:19 +00:00
|
|
|
do {
|
2007-07-16 05:55:04 +00:00
|
|
|
UnionRectForClosestScrolledView(frame, aVPercent, frameBounds, haveRect,
|
|
|
|
closestView);
|
2007-07-16 05:53:19 +00:00
|
|
|
} while ((frame = frame->GetNextContinuation()));
|
2007-07-14 05:18:09 +00:00
|
|
|
|
2002-11-12 04:38:28 +00:00
|
|
|
// Walk up the view hierarchy. Make sure to add the view's position
|
|
|
|
// _after_ we get the parent and see whether it's scrollable. We want to
|
|
|
|
// make sure to get the scrolled view's position after it has been scrolled.
|
|
|
|
nsIScrollableView* scrollingView = nsnull;
|
|
|
|
while (closestView) {
|
2003-06-30 10:46:59 +00:00
|
|
|
nsIView* parent = closestView->GetParent();
|
2002-11-12 04:38:28 +00:00
|
|
|
if (parent) {
|
2004-11-24 00:19:21 +00:00
|
|
|
scrollingView = parent->ToScrollableView();
|
2002-11-12 04:38:28 +00:00
|
|
|
if (scrollingView) {
|
|
|
|
ScrollViewToShowRect(scrollingView, frameBounds, aVPercent, aHPercent);
|
2001-11-18 06:04:17 +00:00
|
|
|
}
|
1999-02-18 22:52:21 +00:00
|
|
|
}
|
2007-07-12 23:48:37 +00:00
|
|
|
frameBounds += closestView->GetPosition();
|
2002-11-12 04:38:28 +00:00
|
|
|
closestView = parent;
|
1999-02-18 22:52:21 +00:00
|
|
|
}
|
2001-11-18 06:04:17 +00:00
|
|
|
|
2002-11-12 04:38:28 +00:00
|
|
|
return NS_OK;
|
1999-02-18 22:52:21 +00:00
|
|
|
}
|
|
|
|
|
2002-08-01 21:36:02 +00:00
|
|
|
// GetLinkLocation: copy link location to clipboard
|
|
|
|
NS_IMETHODIMP PresShell::GetLinkLocation(nsIDOMNode* aNode, nsAString& aLocationString)
|
2001-04-18 06:06:31 +00:00
|
|
|
{
|
|
|
|
#ifdef DEBUG_dr
|
2002-08-01 21:36:02 +00:00
|
|
|
printf("dr :: PresShell::GetLinkLocation\n");
|
2001-04-18 06:06:31 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
NS_ENSURE_ARG_POINTER(aNode);
|
|
|
|
nsresult rv;
|
2001-09-12 23:31:37 +00:00
|
|
|
nsAutoString anchorText;
|
2002-03-12 05:29:31 +00:00
|
|
|
static char strippedChars[] = {'\t','\r','\n'};
|
2001-04-18 06:06:31 +00:00
|
|
|
|
|
|
|
// are we an anchor?
|
2001-09-12 23:31:37 +00:00
|
|
|
nsCOMPtr<nsIDOMHTMLAnchorElement> anchor(do_QueryInterface(aNode));
|
|
|
|
nsCOMPtr<nsIDOMHTMLAreaElement> area;
|
|
|
|
nsCOMPtr<nsIDOMHTMLLinkElement> link;
|
|
|
|
nsAutoString xlinkType;
|
2001-04-18 06:06:31 +00:00
|
|
|
if (anchor) {
|
|
|
|
rv = anchor->GetHref(anchorText);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2001-09-12 23:31:37 +00:00
|
|
|
} else {
|
|
|
|
// area?
|
|
|
|
area = do_QueryInterface(aNode);
|
|
|
|
if (area) {
|
|
|
|
rv = area->GetHref(anchorText);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
} else {
|
|
|
|
// link?
|
|
|
|
link = do_QueryInterface(aNode);
|
|
|
|
if (link) {
|
|
|
|
rv = link->GetHref(anchorText);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
} else {
|
|
|
|
// Xlink?
|
|
|
|
nsCOMPtr<nsIDOMElement> element(do_QueryInterface(aNode));
|
|
|
|
if (element) {
|
|
|
|
NS_NAMED_LITERAL_STRING(xlinkNS,"http://www.w3.org/1999/xlink");
|
|
|
|
element->GetAttributeNS(xlinkNS,NS_LITERAL_STRING("type"),xlinkType);
|
2004-04-28 17:48:02 +00:00
|
|
|
if (xlinkType.EqualsLiteral("simple")) {
|
2001-09-12 23:31:37 +00:00
|
|
|
element->GetAttributeNS(xlinkNS,NS_LITERAL_STRING("href"),anchorText);
|
|
|
|
if (!anchorText.IsEmpty()) {
|
|
|
|
// Resolve the full URI using baseURI property
|
|
|
|
|
|
|
|
nsAutoString base;
|
|
|
|
nsCOMPtr<nsIDOM3Node> node(do_QueryInterface(aNode,&rv));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
node->GetBaseURI(base);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIIOService>
|
|
|
|
ios(do_GetService("@mozilla.org/network/io-service;1", &rv));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIURI> baseURI;
|
2006-02-03 14:18:39 +00:00
|
|
|
rv = ios->NewURI(NS_ConvertUTF16toUTF8(base),nsnull,nsnull,getter_AddRefs(baseURI));
|
2001-09-12 23:31:37 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2001-11-18 06:04:17 +00:00
|
|
|
|
2002-03-06 07:48:55 +00:00
|
|
|
nsCAutoString spec;
|
2006-02-03 14:18:39 +00:00
|
|
|
rv = baseURI->Resolve(NS_ConvertUTF16toUTF8(anchorText),spec);
|
2001-09-12 23:31:37 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2003-06-24 01:46:50 +00:00
|
|
|
CopyUTF8toUTF16(spec, anchorText);
|
2001-09-12 23:31:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2001-05-10 02:35:00 +00:00
|
|
|
|
2004-04-30 13:23:43 +00:00
|
|
|
if (anchor || area || link || xlinkType.EqualsLiteral("simple")) {
|
2002-03-12 05:29:31 +00:00
|
|
|
//Remove all the '\t', '\r' and '\n' from 'anchorText'
|
|
|
|
anchorText.StripChars(strippedChars);
|
2001-05-10 02:35:00 +00:00
|
|
|
|
2002-08-01 21:36:02 +00:00
|
|
|
aLocationString = anchorText;
|
|
|
|
|
|
|
|
return NS_OK;
|
2001-04-18 06:06:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// if no link, fail.
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2005-08-29 15:19:13 +00:00
|
|
|
NS_IMETHODIMP
|
2003-04-22 18:11:12 +00:00
|
|
|
PresShell::GetSelectionForCopy(nsISelection** outSelection)
|
1999-04-07 03:56:07 +00:00
|
|
|
{
|
2007-01-17 05:16:13 +00:00
|
|
|
nsresult rv = NS_OK;
|
2003-11-26 10:23:03 +00:00
|
|
|
|
2003-04-22 18:11:12 +00:00
|
|
|
*outSelection = nsnull;
|
|
|
|
|
2004-08-02 04:52:55 +00:00
|
|
|
if (!mDocument) return NS_ERROR_FAILURE;
|
2001-11-18 06:04:17 +00:00
|
|
|
|
2003-11-26 10:23:03 +00:00
|
|
|
nsCOMPtr<nsIContent> content;
|
2005-11-28 23:56:44 +00:00
|
|
|
nsPIDOMWindow *ourWindow = mDocument->GetWindow();
|
2003-11-26 10:23:03 +00:00
|
|
|
if (ourWindow) {
|
2004-05-03 21:48:36 +00:00
|
|
|
nsIFocusController *focusController = ourWindow->GetRootFocusController();
|
2003-11-26 10:23:03 +00:00
|
|
|
if (focusController) {
|
|
|
|
nsCOMPtr<nsIDOMElement> focusedElement;
|
|
|
|
focusController->GetFocusedElement(getter_AddRefs(focusedElement));
|
|
|
|
content = do_QueryInterface(focusedElement);
|
|
|
|
}
|
|
|
|
}
|
2001-10-13 09:27:46 +00:00
|
|
|
|
2003-04-22 18:11:12 +00:00
|
|
|
nsCOMPtr<nsISelection> sel;
|
2003-11-26 10:23:03 +00:00
|
|
|
if (content)
|
2000-07-14 21:58:50 +00:00
|
|
|
{
|
|
|
|
//check to see if we need to get selection from frame
|
|
|
|
//optimization that MAY need to be expanded as more things implement their own "selection"
|
|
|
|
nsCOMPtr<nsIDOMNSHTMLInputElement> htmlInputElement(do_QueryInterface(content));
|
|
|
|
nsCOMPtr<nsIDOMNSHTMLTextAreaElement> htmlTextAreaElement(do_QueryInterface(content));
|
|
|
|
if (htmlInputElement || htmlTextAreaElement)
|
2000-06-14 02:57:26 +00:00
|
|
|
{
|
2005-08-22 22:24:29 +00:00
|
|
|
nsIFrame *htmlInputFrame = GetPrimaryFrameFor(content);
|
2003-04-22 18:11:12 +00:00
|
|
|
if (!htmlInputFrame) return NS_ERROR_FAILURE;
|
2001-10-13 09:27:46 +00:00
|
|
|
|
2000-07-14 21:58:50 +00:00
|
|
|
nsCOMPtr<nsISelectionController> selCon;
|
2006-04-26 02:01:07 +00:00
|
|
|
rv = htmlInputFrame->
|
|
|
|
GetSelectionController(mPresContext,getter_AddRefs(selCon));
|
2003-04-22 18:11:12 +00:00
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
if (!selCon) return NS_ERROR_FAILURE;
|
2001-10-13 09:27:46 +00:00
|
|
|
|
2006-04-26 02:01:07 +00:00
|
|
|
rv = selCon->GetSelection(nsISelectionController::SELECTION_NORMAL,
|
|
|
|
getter_AddRefs(sel));
|
2000-06-14 02:57:26 +00:00
|
|
|
}
|
2000-07-14 21:58:50 +00:00
|
|
|
}
|
2006-04-26 02:01:07 +00:00
|
|
|
if (!sel) {
|
|
|
|
sel = mSelection->GetSelection(nsISelectionController::SELECTION_NORMAL);
|
|
|
|
rv = NS_OK;
|
|
|
|
}
|
|
|
|
|
2003-04-22 18:11:12 +00:00
|
|
|
*outSelection = sel;
|
|
|
|
NS_IF_ADDREF(*outSelection);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::DoGetContents(const nsACString& aMimeType, PRUint32 aFlags, PRBool aSelectionOnly, nsAString& aOutValue)
|
|
|
|
{
|
|
|
|
aOutValue.Truncate();
|
|
|
|
|
2004-08-02 04:52:55 +00:00
|
|
|
if (!mDocument) return NS_ERROR_FAILURE;
|
2003-04-22 18:11:12 +00:00
|
|
|
|
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsISelection> sel;
|
|
|
|
|
|
|
|
// Now we have the selection. Make sure it's nonzero:
|
|
|
|
if (aSelectionOnly)
|
|
|
|
{
|
|
|
|
rv = GetSelectionForCopy(getter_AddRefs(sel));
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
if (!sel) return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
PRBool isCollapsed;
|
|
|
|
sel->GetIsCollapsed(&isCollapsed);
|
|
|
|
if (isCollapsed)
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// call the copy code
|
2004-08-02 04:52:55 +00:00
|
|
|
return nsCopySupport::GetContents(aMimeType, aFlags, sel,
|
|
|
|
mDocument, aOutValue);
|
2003-04-22 18:11:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::DoCopy()
|
|
|
|
{
|
2004-08-02 04:52:55 +00:00
|
|
|
if (!mDocument) return NS_ERROR_FAILURE;
|
2003-04-22 18:11:12 +00:00
|
|
|
|
|
|
|
nsCOMPtr<nsISelection> sel;
|
|
|
|
nsresult rv = GetSelectionForCopy(getter_AddRefs(sel));
|
2001-10-13 09:27:46 +00:00
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return rv;
|
|
|
|
if (!sel)
|
|
|
|
return NS_ERROR_FAILURE;
|
2000-07-14 21:58:50 +00:00
|
|
|
|
2000-08-28 22:28:56 +00:00
|
|
|
// Now we have the selection. Make sure it's nonzero:
|
|
|
|
PRBool isCollapsed;
|
|
|
|
sel->GetIsCollapsed(&isCollapsed);
|
|
|
|
if (isCollapsed)
|
|
|
|
return NS_OK;
|
|
|
|
|
2001-02-15 13:22:26 +00:00
|
|
|
// call the copy code
|
2004-08-02 04:52:55 +00:00
|
|
|
rv = nsCopySupport::HTMLCopy(sel, mDocument, nsIClipboard::kGlobalClipboard);
|
2001-02-15 13:22:26 +00:00
|
|
|
if (NS_FAILED(rv))
|
2000-07-14 21:58:50 +00:00
|
|
|
return rv;
|
2001-02-19 21:50:04 +00:00
|
|
|
|
2000-07-14 21:58:50 +00:00
|
|
|
// Now that we have copied, update the Paste menu item
|
2005-11-28 23:56:44 +00:00
|
|
|
nsPIDOMWindow *domWindow = mDocument->GetWindow();
|
2000-07-14 21:58:50 +00:00
|
|
|
if (domWindow)
|
|
|
|
{
|
2001-11-14 01:33:42 +00:00
|
|
|
domWindow->UpdateCommands(NS_LITERAL_STRING("clipboard"));
|
2000-07-14 21:58:50 +00:00
|
|
|
}
|
|
|
|
|
1999-04-07 03:56:07 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-08-30 22:38:58 +00:00
|
|
|
NS_IMETHODIMP
|
2000-06-15 00:35:46 +00:00
|
|
|
PresShell::CaptureHistoryState(nsILayoutHistoryState** aState, PRBool aLeavingPage)
|
1999-08-30 22:38:58 +00:00
|
|
|
{
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
|
|
|
|
NS_PRECONDITION(nsnull != aState, "null state pointer");
|
|
|
|
|
2005-05-12 20:53:33 +00:00
|
|
|
// We actually have to mess with the docshell here, since we want to
|
|
|
|
// store the state back in it.
|
|
|
|
// XXXbz this isn't really right, since this is being called in the
|
|
|
|
// content viewer's Hide() method... by that point the docshell's
|
|
|
|
// state could be wrong. We should sort out a better ownership
|
|
|
|
// model for the layout history state.
|
2004-02-01 10:09:07 +00:00
|
|
|
nsCOMPtr<nsISupports> container = mPresContext->GetContainer();
|
2003-05-30 00:21:01 +00:00
|
|
|
if (!container)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(container));
|
|
|
|
if (!docShell)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsCOMPtr<nsILayoutHistoryState> historyState;
|
|
|
|
docShell->GetLayoutHistoryState(getter_AddRefs(historyState));
|
2001-05-12 15:52:06 +00:00
|
|
|
if (!historyState) {
|
2000-01-14 09:28:54 +00:00
|
|
|
// Create the document state object
|
2001-05-12 15:52:06 +00:00
|
|
|
rv = NS_NewLayoutHistoryState(getter_AddRefs(historyState));
|
1999-08-30 22:38:58 +00:00
|
|
|
|
2000-01-14 09:28:54 +00:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
*aState = nsnull;
|
|
|
|
return rv;
|
2000-02-11 22:54:37 +00:00
|
|
|
}
|
1999-08-30 22:38:58 +00:00
|
|
|
|
2003-05-30 00:21:01 +00:00
|
|
|
docShell->SetLayoutHistoryState(historyState);
|
2000-01-14 09:28:54 +00:00
|
|
|
}
|
2001-05-12 15:52:06 +00:00
|
|
|
|
|
|
|
*aState = historyState;
|
|
|
|
NS_IF_ADDREF(*aState);
|
2000-01-14 09:28:54 +00:00
|
|
|
|
2000-02-11 22:54:37 +00:00
|
|
|
// Capture frame state for the entire frame hierarchy
|
2004-03-06 04:46:11 +00:00
|
|
|
nsIFrame* rootFrame = FrameManager()->GetRootFrame();
|
2004-02-23 21:29:06 +00:00
|
|
|
if (!rootFrame) return NS_OK;
|
2000-06-15 00:35:46 +00:00
|
|
|
// Capture frame state for the root scroll frame
|
2005-11-20 22:05:24 +00:00
|
|
|
// Don't capture state when first creating doc element hierarchy
|
2000-06-15 00:35:46 +00:00
|
|
|
// As the scroll position is 0 and this will cause us to loose
|
|
|
|
// our previously saved place!
|
|
|
|
if (aLeavingPage) {
|
2006-02-01 19:55:35 +00:00
|
|
|
nsIFrame* scrollFrame = GetRootScrollFrame();
|
2000-06-15 00:35:46 +00:00
|
|
|
if (scrollFrame) {
|
2004-09-13 02:10:29 +00:00
|
|
|
FrameManager()->CaptureFrameStateFor(scrollFrame, historyState,
|
|
|
|
nsIStatefulFrame::eDocumentScrollState);
|
2000-06-15 00:35:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-03-06 04:46:11 +00:00
|
|
|
FrameManager()->CaptureFrameState(rootFrame, historyState);
|
2000-01-14 09:28:54 +00:00
|
|
|
|
2004-02-23 21:29:06 +00:00
|
|
|
return NS_OK;
|
1999-08-30 22:38:58 +00:00
|
|
|
}
|
|
|
|
|
2001-04-25 19:52:49 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::IsPaintingSuppressed(PRBool* aResult)
|
|
|
|
{
|
|
|
|
*aResult = mPaintingSuppressed;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
PresShell::UnsuppressAndInvalidate()
|
|
|
|
{
|
2005-01-20 03:39:09 +00:00
|
|
|
if (!mPresContext->EnsureVisible(PR_FALSE)) {
|
|
|
|
// No point; we're about to be torn down anyway.
|
|
|
|
return;
|
2001-05-01 22:54:11 +00:00
|
|
|
}
|
2005-01-20 03:39:09 +00:00
|
|
|
|
2004-02-23 21:29:06 +00:00
|
|
|
mPaintingSuppressed = PR_FALSE;
|
2004-03-06 04:46:11 +00:00
|
|
|
nsIFrame* rootFrame = FrameManager()->GetRootFrame();
|
2004-02-23 21:29:06 +00:00
|
|
|
if (rootFrame) {
|
2004-03-10 03:09:05 +00:00
|
|
|
// let's assume that outline on a root frame is not supported
|
|
|
|
nsRect rect(nsPoint(0, 0), rootFrame->GetSize());
|
|
|
|
rootFrame->Invalidate(rect, PR_FALSE);
|
2001-04-25 19:52:49 +00:00
|
|
|
}
|
2001-05-31 22:19:43 +00:00
|
|
|
|
2005-01-20 03:39:09 +00:00
|
|
|
// This makes sure to get the same thing that nsPresContext::EnsureVisible()
|
|
|
|
// got.
|
|
|
|
nsCOMPtr<nsISupports> container = mPresContext->GetContainer();
|
|
|
|
nsCOMPtr<nsPIDOMWindow> ourWindow = do_GetInterface(container);
|
2006-05-15 17:18:59 +00:00
|
|
|
nsCOMPtr<nsIFocusController> focusController =
|
2005-01-20 03:39:09 +00:00
|
|
|
ourWindow ? ourWindow->GetRootFocusController() : nsnull;
|
|
|
|
|
2001-06-04 23:23:35 +00:00
|
|
|
if (ourWindow)
|
|
|
|
CheckForFocus(ourWindow, focusController, mDocument);
|
2001-06-04 00:22:43 +00:00
|
|
|
|
|
|
|
if (focusController) // Unsuppress now that we've shown the new window and focused it.
|
|
|
|
focusController->SetSuppressFocus(PR_FALSE, "PresShell suppression on Web page loads");
|
2004-06-22 04:32:52 +00:00
|
|
|
|
2004-06-24 21:56:29 +00:00
|
|
|
if (mViewManager)
|
|
|
|
mViewManager->SynthesizeMouseMove(PR_FALSE);
|
2007-04-14 16:51:20 +00:00
|
|
|
|
|
|
|
// If there is no selection, create a collapsed selection at the top of the document.
|
|
|
|
if (mSelection) {
|
|
|
|
nsISelection* domSelection = mSelection->
|
|
|
|
GetSelection(nsISelectionController::SELECTION_NORMAL);
|
|
|
|
if (domSelection) {
|
|
|
|
PRInt32 rangeCount;
|
|
|
|
domSelection->GetRangeCount(&rangeCount);
|
|
|
|
if (rangeCount == 0)
|
|
|
|
CompleteMoveInner(PR_FALSE, PR_FALSE, PR_FALSE);
|
|
|
|
}
|
|
|
|
}
|
2001-04-25 19:52:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2001-05-01 22:54:11 +00:00
|
|
|
PresShell::UnsuppressPainting()
|
2001-04-25 19:52:49 +00:00
|
|
|
{
|
2001-05-01 22:54:11 +00:00
|
|
|
if (mPaintSuppressionTimer) {
|
2001-04-25 19:52:49 +00:00
|
|
|
mPaintSuppressionTimer->Cancel();
|
|
|
|
mPaintSuppressionTimer = nsnull;
|
|
|
|
}
|
|
|
|
|
2001-05-01 22:54:11 +00:00
|
|
|
if (mIsDocumentGone || !mPaintingSuppressed)
|
2001-04-25 19:52:49 +00:00
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
// If we have reflows pending, just wait until we process
|
|
|
|
// the reflows and get all the frames where we want them
|
|
|
|
// before actually unlocking the painting. Otherwise
|
|
|
|
// go ahead and unlock now.
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
if (mDirtyRoots.Count() > 0)
|
2001-04-25 19:52:49 +00:00
|
|
|
mShouldUnsuppressPainting = PR_TRUE;
|
|
|
|
else
|
|
|
|
UnsuppressAndInvalidate();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-10-09 03:08:41 +00:00
|
|
|
|
2002-09-21 01:03:38 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::DisableThemeSupport()
|
|
|
|
{
|
|
|
|
// Doesn't have to be dynamic. Just set the bool.
|
|
|
|
mIsThemeSupportDisabled = PR_TRUE;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRBool
|
|
|
|
PresShell::IsThemeSupportEnabled()
|
|
|
|
{
|
|
|
|
return !mIsThemeSupportDisabled;
|
|
|
|
}
|
|
|
|
|
2000-07-13 23:00:59 +00:00
|
|
|
// Post a request to handle an arbitrary callback after reflow has finished.
|
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::PostReflowCallback(nsIReflowCallback* aCallback)
|
|
|
|
{
|
2004-04-13 00:28:44 +00:00
|
|
|
void* result = AllocateFrame(sizeof(nsCallbackEventRequest));
|
2006-02-11 04:14:48 +00:00
|
|
|
if (NS_UNLIKELY(!result)) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
nsCallbackEventRequest* request = (nsCallbackEventRequest*)result;
|
2000-07-13 23:00:59 +00:00
|
|
|
|
|
|
|
request->callback = aCallback;
|
|
|
|
request->next = nsnull;
|
|
|
|
|
|
|
|
if (mLastCallbackEventRequest) {
|
|
|
|
mLastCallbackEventRequest = mLastCallbackEventRequest->next = request;
|
|
|
|
} else {
|
|
|
|
mFirstCallbackEventRequest = request;
|
|
|
|
mLastCallbackEventRequest = request;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-10-07 00:49:08 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::CancelReflowCallback(nsIReflowCallback* aCallback)
|
|
|
|
{
|
|
|
|
nsCallbackEventRequest* before = nsnull;
|
|
|
|
nsCallbackEventRequest* node = mFirstCallbackEventRequest;
|
|
|
|
while(node)
|
|
|
|
{
|
|
|
|
nsIReflowCallback* callback = node->callback;
|
|
|
|
|
|
|
|
if (callback == aCallback)
|
|
|
|
{
|
|
|
|
nsCallbackEventRequest* toFree = node;
|
|
|
|
if (node == mFirstCallbackEventRequest) {
|
2003-10-14 23:29:07 +00:00
|
|
|
node = node->next;
|
|
|
|
mFirstCallbackEventRequest = node;
|
|
|
|
NS_ASSERTION(before == nsnull, "impossible");
|
2000-10-07 00:49:08 +00:00
|
|
|
} else {
|
2003-10-14 23:29:07 +00:00
|
|
|
node = node->next;
|
|
|
|
before->next = node;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (toFree == mLastCallbackEventRequest) {
|
|
|
|
mLastCallbackEventRequest = before;
|
2000-10-07 00:49:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
FreeFrame(sizeof(nsCallbackEventRequest), toFree);
|
|
|
|
} else {
|
|
|
|
before = node;
|
|
|
|
node = node->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2007-12-01 07:22:44 +00:00
|
|
|
void
|
|
|
|
PresShell::CancelPostedReflowCallbacks()
|
|
|
|
{
|
|
|
|
while (mFirstCallbackEventRequest) {
|
|
|
|
nsCallbackEventRequest* node = mFirstCallbackEventRequest;
|
|
|
|
mFirstCallbackEventRequest = node->next;
|
|
|
|
if (!mFirstCallbackEventRequest) {
|
|
|
|
mLastCallbackEventRequest = nsnull;
|
|
|
|
}
|
|
|
|
nsIReflowCallback* callback = node->callback;
|
|
|
|
FreeFrame(sizeof(nsCallbackEventRequest), node);
|
|
|
|
if (callback) {
|
|
|
|
callback->ReflowCallbackCanceled();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-07-13 23:00:59 +00:00
|
|
|
void
|
|
|
|
PresShell::HandlePostedReflowCallbacks()
|
|
|
|
{
|
|
|
|
PRBool shouldFlush = PR_FALSE;
|
|
|
|
|
2003-10-14 23:29:07 +00:00
|
|
|
while (mFirstCallbackEventRequest) {
|
|
|
|
nsCallbackEventRequest* node = mFirstCallbackEventRequest;
|
|
|
|
mFirstCallbackEventRequest = node->next;
|
|
|
|
if (!mFirstCallbackEventRequest) {
|
|
|
|
mLastCallbackEventRequest = nsnull;
|
|
|
|
}
|
|
|
|
nsIReflowCallback* callback = node->callback;
|
|
|
|
FreeFrame(sizeof(nsCallbackEventRequest), node);
|
2007-03-05 01:39:53 +00:00
|
|
|
if (callback) {
|
|
|
|
if (callback->ReflowFinished()) {
|
|
|
|
shouldFlush = PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
2003-10-14 23:29:07 +00:00
|
|
|
}
|
2000-07-13 23:00:59 +00:00
|
|
|
|
|
|
|
if (shouldFlush)
|
2004-05-27 22:08:42 +00:00
|
|
|
FlushPendingNotifications(Flush_Layout);
|
2000-07-13 23:00:59 +00:00
|
|
|
}
|
|
|
|
|
2000-10-17 05:07:39 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::IsSafeToFlush(PRBool& aIsSafeToFlush)
|
|
|
|
{
|
2008-03-14 23:08:57 +00:00
|
|
|
// XXX technically we don't need to check anything but
|
|
|
|
// nsContentUtils::IsSafeToRunScript here since that should be false
|
|
|
|
// if any of the other flags are set.
|
|
|
|
|
|
|
|
// Not safe if we are reflowing or in the middle of frame construction
|
2008-04-18 17:20:11 +00:00
|
|
|
aIsSafeToFlush = !mIsReflowing &&
|
2008-03-14 23:08:57 +00:00
|
|
|
!mChangeNestCount;
|
2000-10-17 05:07:39 +00:00
|
|
|
|
2008-03-14 23:08:57 +00:00
|
|
|
if (aIsSafeToFlush) {
|
2000-10-17 05:07:39 +00:00
|
|
|
// Not safe if we are painting
|
2003-06-30 10:46:59 +00:00
|
|
|
nsIViewManager* viewManager = GetViewManager();
|
|
|
|
if (viewManager) {
|
2000-10-17 05:07:39 +00:00
|
|
|
PRBool isPainting = PR_FALSE;
|
|
|
|
viewManager->IsPainting(isPainting);
|
|
|
|
if (isPainting) {
|
|
|
|
aIsSafeToFlush = PR_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-03-14 23:08:57 +00:00
|
|
|
|
|
|
|
NS_ASSERTION(aIsSafeToFlush == nsContentUtils::IsSafeToRunScript(),
|
|
|
|
"Someone forgot to block scripts");
|
|
|
|
|
2000-10-17 05:07:39 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-01-28 22:58:17 +00:00
|
|
|
NS_IMETHODIMP
|
2004-05-27 22:08:42 +00:00
|
|
|
PresShell::FlushPendingNotifications(mozFlushType aType)
|
2000-01-28 22:58:17 +00:00
|
|
|
{
|
2007-08-22 02:57:06 +00:00
|
|
|
return DoFlushPendingNotifications(aType, PR_FALSE);
|
|
|
|
}
|
|
|
|
|
2007-08-22 03:16:18 +00:00
|
|
|
nsresult
|
2007-08-22 02:57:06 +00:00
|
|
|
PresShell::DoFlushPendingNotifications(mozFlushType aType,
|
|
|
|
PRBool aInterruptibleReflow)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aType >= Flush_Frames, "Why did we get called?");
|
2004-05-27 22:08:42 +00:00
|
|
|
|
2000-10-17 05:07:39 +00:00
|
|
|
PRBool isSafeToFlush;
|
|
|
|
IsSafeToFlush(isSafeToFlush);
|
|
|
|
|
2004-10-09 01:39:21 +00:00
|
|
|
NS_ASSERTION(!isSafeToFlush || mViewManager, "Must have view manager");
|
2007-08-21 21:45:00 +00:00
|
|
|
// Make sure the view manager stays alive while batching view updates.
|
2008-01-26 23:59:50 +00:00
|
|
|
nsCOMPtr<nsIViewManager> viewManagerDeathGrip = mViewManager;
|
|
|
|
if (isSafeToFlush && mViewManager) {
|
2007-04-23 05:53:27 +00:00
|
|
|
// Processing pending notifications can kill us, and some callers only
|
|
|
|
// hold weak refs when calling FlushPendingNotifications(). :(
|
|
|
|
nsCOMPtr<nsIPresShell> kungFuDeathGrip(this);
|
|
|
|
|
2004-10-09 01:39:21 +00:00
|
|
|
// Style reresolves not in conjunction with reflows can't cause
|
|
|
|
// painting or geometry changes, so don't bother with view update
|
|
|
|
// batching if we only have style reresolve
|
2008-01-26 23:59:50 +00:00
|
|
|
nsIViewManager::UpdateViewBatch batch(mViewManager);
|
2001-08-31 04:28:26 +00:00
|
|
|
|
2007-09-04 08:31:01 +00:00
|
|
|
// Force flushing of any pending content notifications that might have
|
|
|
|
// queued up while our event was pending. That will ensure that we don't
|
|
|
|
// construct frames for content right now that's still waiting to be
|
|
|
|
// notified on,
|
|
|
|
mDocument->FlushPendingNotifications(Flush_ContentAndNotify);
|
2007-09-18 01:16:39 +00:00
|
|
|
|
|
|
|
// Process pending restyles, since any flush of the presshell wants
|
|
|
|
// up-to-date style data.
|
2007-09-04 08:31:01 +00:00
|
|
|
if (!mIsDestroying) {
|
|
|
|
mFrameConstructor->ProcessPendingRestyles();
|
|
|
|
}
|
2004-08-10 03:24:41 +00:00
|
|
|
|
2007-09-18 01:16:39 +00:00
|
|
|
// Process whatever XBL constructors those restyles queued up. This
|
|
|
|
// ensures that onload doesn't fire too early and that we won't do extra
|
|
|
|
// reflows after those constructors run.
|
2007-09-14 19:15:44 +00:00
|
|
|
if (!mIsDestroying) {
|
|
|
|
mDocument->BindingManager()->ProcessAttachedQueue();
|
|
|
|
}
|
|
|
|
|
2007-09-18 01:16:39 +00:00
|
|
|
// Now those constructors might have posted restyle events. At the same
|
|
|
|
// time, we still need up-to-date style data. In particular, reflow
|
|
|
|
// depends on style being completely up to date. If it's not, then style
|
|
|
|
// context reparenting, which can happen during reflow, might suddenly pick
|
|
|
|
// up the new rules and we'll end up with frames whose style doesn't match
|
|
|
|
// the frame type.
|
|
|
|
if (!mIsDestroying) {
|
|
|
|
mFrameConstructor->ProcessPendingRestyles();
|
|
|
|
}
|
|
|
|
|
|
|
|
// There might be more pending constructors now, but we're not going to
|
|
|
|
// worry about them. They can't be triggered during reflow, so we should
|
|
|
|
// be good.
|
|
|
|
|
2007-08-22 02:57:06 +00:00
|
|
|
if (aType >= Flush_Layout && !mIsDestroying) {
|
2007-04-16 00:11:34 +00:00
|
|
|
mFrameConstructor->RecalcQuotesAndCounters();
|
2007-08-22 02:57:06 +00:00
|
|
|
ProcessReflowCommands(aInterruptibleReflow);
|
2004-05-27 22:08:42 +00:00
|
|
|
}
|
2001-08-31 04:28:26 +00:00
|
|
|
|
2004-10-09 01:39:21 +00:00
|
|
|
PRUint32 updateFlags = NS_VMREFRESH_NO_SYNC;
|
2007-08-22 02:57:06 +00:00
|
|
|
if (aType >= Flush_Display) {
|
2004-10-09 01:39:21 +00:00
|
|
|
// Flushing paints, so perform the invalidates and drawing
|
|
|
|
// immediately
|
|
|
|
updateFlags = NS_VMREFRESH_IMMEDIATE;
|
2001-08-31 04:28:26 +00:00
|
|
|
}
|
2007-08-22 02:57:06 +00:00
|
|
|
else if (aType < Flush_Layout) {
|
2005-01-27 21:17:08 +00:00
|
|
|
// Not flushing reflows, so do deferred invalidates. This will keep us
|
|
|
|
// from possibly flushing out reflows due to invalidates being processed
|
|
|
|
// at the end of this view batch.
|
|
|
|
updateFlags = NS_VMREFRESH_DEFERRED;
|
|
|
|
}
|
2008-01-26 23:59:50 +00:00
|
|
|
batch.EndUpdateViewBatch(updateFlags);
|
2000-01-28 22:58:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-02-09 15:48:01 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::IsReflowLocked(PRBool* aIsReflowLocked)
|
|
|
|
{
|
2000-04-17 07:13:57 +00:00
|
|
|
*aIsReflowLocked = mIsReflowing;
|
2000-02-09 15:48:01 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2004-01-24 00:46:17 +00:00
|
|
|
void
|
2004-02-20 21:38:31 +00:00
|
|
|
PresShell::CharacterDataChanged(nsIDocument *aDocument,
|
|
|
|
nsIContent* aContent,
|
2006-11-03 21:51:01 +00:00
|
|
|
CharacterDataChangeInfo* aInfo)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2005-03-25 04:27:21 +00:00
|
|
|
NS_PRECONDITION(!mIsDocumentGone, "Unexpected CharacterDataChanged");
|
2005-02-18 16:11:53 +00:00
|
|
|
NS_PRECONDITION(aDocument == mDocument, "Unexpected aDocument");
|
|
|
|
|
2008-03-14 23:08:57 +00:00
|
|
|
nsAutoCauseReflowNotifier crNotifier(this);
|
|
|
|
|
2006-08-17 20:58:31 +00:00
|
|
|
if (mCaret) {
|
|
|
|
// Invalidate the caret's current location before we call into the frame
|
|
|
|
// constructor. It is important to do this now, and not wait until the
|
|
|
|
// resulting reflow, because this call causes continuation frames of the
|
|
|
|
// text frame the caret is in to forget what part of the content they
|
|
|
|
// refer to, making it hard for them to return the correct continuation
|
|
|
|
// frame to the caret.
|
|
|
|
mCaret->InvalidateOutsideCaret();
|
|
|
|
}
|
2008-02-19 06:17:07 +00:00
|
|
|
|
|
|
|
// Call this here so it only happens for real content mutations and
|
|
|
|
// not cases when the frame constructor calls its own methods to force
|
|
|
|
// frame reconstruction.
|
|
|
|
nsIContent *container = aContent->GetParent();
|
|
|
|
PRUint32 selectorFlags =
|
|
|
|
container ? (container->GetFlags() & NODE_ALL_SELECTOR_FLAGS) : 0;
|
|
|
|
if (selectorFlags != 0) {
|
|
|
|
PRUint32 index;
|
|
|
|
if (aInfo->mAppend &&
|
|
|
|
container->GetChildAt((index = container->GetChildCount() - 1)) ==
|
|
|
|
aContent)
|
|
|
|
mFrameConstructor->RestyleForAppend(container, index);
|
|
|
|
else
|
|
|
|
mFrameConstructor->RestyleForInsertOrChange(container, aContent);
|
|
|
|
}
|
|
|
|
|
2006-11-03 21:51:01 +00:00
|
|
|
mFrameConstructor->CharacterDataChanged(aContent, aInfo->mAppend);
|
1999-09-21 07:53:49 +00:00
|
|
|
VERIFY_STYLE_TREE;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2004-01-24 00:46:17 +00:00
|
|
|
void
|
1999-04-20 00:06:58 +00:00
|
|
|
PresShell::ContentStatesChanged(nsIDocument* aDocument,
|
|
|
|
nsIContent* aContent1,
|
2002-03-07 03:34:29 +00:00
|
|
|
nsIContent* aContent2,
|
2002-04-11 03:49:30 +00:00
|
|
|
PRInt32 aStateMask)
|
1999-02-27 07:15:09 +00:00
|
|
|
{
|
2005-02-18 16:11:53 +00:00
|
|
|
NS_PRECONDITION(!mIsDocumentGone, "Unexpected ContentStatesChanged");
|
|
|
|
NS_PRECONDITION(aDocument == mDocument, "Unexpected aDocument");
|
|
|
|
|
2007-07-12 20:05:45 +00:00
|
|
|
if (mDidInitialReflow) {
|
2008-03-14 23:08:57 +00:00
|
|
|
nsAutoCauseReflowNotifier crNotifier(this);
|
2007-07-12 20:05:45 +00:00
|
|
|
mFrameConstructor->ContentStatesChanged(aContent1, aContent2, aStateMask);
|
|
|
|
VERIFY_STYLE_TREE;
|
|
|
|
}
|
1999-02-27 07:15:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-01-24 00:46:17 +00:00
|
|
|
void
|
2005-11-02 00:41:51 +00:00
|
|
|
PresShell::AttributeChanged(nsIDocument* aDocument,
|
|
|
|
nsIContent* aContent,
|
|
|
|
PRInt32 aNameSpaceID,
|
|
|
|
nsIAtom* aAttribute,
|
2007-07-12 20:05:45 +00:00
|
|
|
PRInt32 aModType,
|
|
|
|
PRUint32 aStateMask)
|
1998-09-18 19:53:27 +00:00
|
|
|
{
|
2005-03-25 04:27:21 +00:00
|
|
|
NS_PRECONDITION(!mIsDocumentGone, "Unexpected AttributeChanged");
|
2005-02-18 16:11:53 +00:00
|
|
|
NS_PRECONDITION(aDocument == mDocument, "Unexpected aDocument");
|
|
|
|
|
2001-10-17 05:34:35 +00:00
|
|
|
// XXXwaterson it might be more elegant to wait until after the
|
|
|
|
// initial reflow to begin observing the document. That would
|
|
|
|
// squelch any other inappropriate notifications as well.
|
|
|
|
if (mDidInitialReflow) {
|
2008-03-14 23:08:57 +00:00
|
|
|
nsAutoCauseReflowNotifier crNotifier(this);
|
2005-02-18 16:11:53 +00:00
|
|
|
mFrameConstructor->AttributeChanged(aContent, aNameSpaceID,
|
2007-07-12 20:05:45 +00:00
|
|
|
aAttribute, aModType, aStateMask);
|
2001-10-17 05:34:35 +00:00
|
|
|
VERIFY_STYLE_TREE;
|
|
|
|
}
|
1998-09-18 19:53:27 +00:00
|
|
|
}
|
|
|
|
|
2004-01-24 00:46:17 +00:00
|
|
|
void
|
1998-07-22 23:32:19 +00:00
|
|
|
PresShell::ContentAppended(nsIDocument *aDocument,
|
1998-09-10 19:32:14 +00:00
|
|
|
nsIContent* aContainer,
|
|
|
|
PRInt32 aNewIndexInContainer)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2005-02-18 16:11:53 +00:00
|
|
|
NS_PRECONDITION(!mIsDocumentGone, "Unexpected ContentAppended");
|
|
|
|
NS_PRECONDITION(aDocument == mDocument, "Unexpected aDocument");
|
2008-02-19 06:17:07 +00:00
|
|
|
NS_PRECONDITION(aContainer, "must have container");
|
2005-02-18 16:11:53 +00:00
|
|
|
|
2003-10-11 00:27:45 +00:00
|
|
|
if (!mDidInitialReflow) {
|
2004-01-24 00:46:17 +00:00
|
|
|
return;
|
2003-10-11 00:27:45 +00:00
|
|
|
}
|
|
|
|
|
2008-03-14 23:08:57 +00:00
|
|
|
nsAutoCauseReflowNotifier crNotifier(this);
|
1999-11-10 03:41:09 +00:00
|
|
|
MOZ_TIMER_DEBUGLOG(("Start: Frame Creation: PresShell::ContentAppended(), this=%p\n", this));
|
|
|
|
MOZ_TIMER_START(mFrameCreationWatch);
|
2001-05-01 22:54:11 +00:00
|
|
|
|
2008-02-19 06:17:07 +00:00
|
|
|
// Call this here so it only happens for real content mutations and
|
|
|
|
// not cases when the frame constructor calls its own methods to force
|
|
|
|
// frame reconstruction.
|
|
|
|
mFrameConstructor->RestyleForAppend(aContainer, aNewIndexInContainer);
|
|
|
|
|
2005-02-18 16:11:53 +00:00
|
|
|
mFrameConstructor->ContentAppended(aContainer, aNewIndexInContainer);
|
1999-09-21 07:53:49 +00:00
|
|
|
VERIFY_STYLE_TREE;
|
1999-08-31 14:35:50 +00:00
|
|
|
|
1999-11-10 03:41:09 +00:00
|
|
|
MOZ_TIMER_DEBUGLOG(("Stop: Frame Creation: PresShell::ContentAppended(), this=%p\n", this));
|
|
|
|
MOZ_TIMER_STOP(mFrameCreationWatch);
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2004-01-24 00:46:17 +00:00
|
|
|
void
|
1998-09-10 19:32:14 +00:00
|
|
|
PresShell::ContentInserted(nsIDocument* aDocument,
|
|
|
|
nsIContent* aContainer,
|
|
|
|
nsIContent* aChild,
|
|
|
|
PRInt32 aIndexInContainer)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2005-03-25 04:27:21 +00:00
|
|
|
NS_PRECONDITION(!mIsDocumentGone, "Unexpected ContentInserted");
|
2005-02-18 16:11:53 +00:00
|
|
|
NS_PRECONDITION(aDocument == mDocument, "Unexpected aDocument");
|
|
|
|
|
2003-10-11 00:27:45 +00:00
|
|
|
if (!mDidInitialReflow) {
|
2004-01-24 00:46:17 +00:00
|
|
|
return;
|
2003-10-11 00:27:45 +00:00
|
|
|
}
|
|
|
|
|
2008-03-14 23:08:57 +00:00
|
|
|
nsAutoCauseReflowNotifier crNotifier(this);
|
2008-02-19 06:17:07 +00:00
|
|
|
|
|
|
|
// Call this here so it only happens for real content mutations and
|
|
|
|
// not cases when the frame constructor calls its own methods to force
|
|
|
|
// frame reconstruction.
|
|
|
|
if (aContainer)
|
|
|
|
mFrameConstructor->RestyleForInsertOrChange(aContainer, aChild);
|
|
|
|
|
2005-08-16 21:35:58 +00:00
|
|
|
mFrameConstructor->ContentInserted(aContainer, aChild,
|
2007-08-15 23:20:25 +00:00
|
|
|
aIndexInContainer, nsnull);
|
1999-09-21 07:53:49 +00:00
|
|
|
VERIFY_STYLE_TREE;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2004-01-24 00:46:17 +00:00
|
|
|
void
|
1998-09-24 21:39:47 +00:00
|
|
|
PresShell::ContentRemoved(nsIDocument *aDocument,
|
|
|
|
nsIContent* aContainer,
|
|
|
|
nsIContent* aChild,
|
|
|
|
PRInt32 aIndexInContainer)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2005-03-25 04:27:21 +00:00
|
|
|
NS_PRECONDITION(!mIsDocumentGone, "Unexpected ContentRemoved");
|
2005-02-18 16:11:53 +00:00
|
|
|
NS_PRECONDITION(aDocument == mDocument, "Unexpected aDocument");
|
|
|
|
|
2006-04-17 23:16:46 +00:00
|
|
|
// Make sure that the caret doesn't leave a turd where the child used to be.
|
2005-08-22 00:25:20 +00:00
|
|
|
if (mCaret) {
|
2006-04-28 04:33:41 +00:00
|
|
|
mCaret->InvalidateOutsideCaret();
|
2005-08-22 00:25:20 +00:00
|
|
|
}
|
|
|
|
|
2001-11-29 00:04:31 +00:00
|
|
|
// Notify the ESM that the content has been removed, so that
|
|
|
|
// it can clean up any state related to the content.
|
2004-02-27 17:17:37 +00:00
|
|
|
mPresContext->EventStateManager()->ContentRemoved(aChild);
|
2001-11-29 00:04:31 +00:00
|
|
|
|
2008-03-14 23:08:57 +00:00
|
|
|
nsAutoCauseReflowNotifier crNotifier(this);
|
2008-02-19 06:17:07 +00:00
|
|
|
|
|
|
|
// Call this here so it only happens for real content mutations and
|
|
|
|
// not cases when the frame constructor calls its own methods to force
|
|
|
|
// frame reconstruction.
|
|
|
|
if (aContainer)
|
|
|
|
mFrameConstructor->RestyleForRemove(aContainer, aChild, aIndexInContainer);
|
|
|
|
|
2007-11-08 04:39:02 +00:00
|
|
|
PRBool didReconstruct;
|
2005-02-18 16:11:53 +00:00
|
|
|
mFrameConstructor->ContentRemoved(aContainer, aChild,
|
2007-11-08 04:39:02 +00:00
|
|
|
aIndexInContainer, &didReconstruct);
|
2002-09-10 04:36:00 +00:00
|
|
|
|
1999-09-21 07:53:49 +00:00
|
|
|
VERIFY_STYLE_TREE;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
1998-11-26 01:34:53 +00:00
|
|
|
nsresult
|
|
|
|
PresShell::ReconstructFrames(void)
|
1998-11-17 02:14:38 +00:00
|
|
|
{
|
2008-03-14 23:08:57 +00:00
|
|
|
nsAutoCauseReflowNotifier crNotifier(this);
|
|
|
|
nsresult rv = mFrameConstructor->ReconstructDocElementHierarchy();
|
1999-09-21 07:53:49 +00:00
|
|
|
VERIFY_STYLE_TREE;
|
1999-03-01 16:57:35 +00:00
|
|
|
|
1998-11-17 02:14:38 +00:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2004-08-29 03:08:44 +00:00
|
|
|
void
|
|
|
|
nsIPresShell::ReconstructStyleDataInternal()
|
2001-12-17 22:51:39 +00:00
|
|
|
{
|
2004-01-07 22:30:53 +00:00
|
|
|
mStylesHaveChanged = PR_FALSE;
|
|
|
|
|
2005-11-06 18:01:17 +00:00
|
|
|
if (!mDidInitialReflow) {
|
|
|
|
// Nothing to do here, since we have no frames yet
|
2004-08-29 03:08:44 +00:00
|
|
|
return;
|
2005-11-06 18:01:17 +00:00
|
|
|
}
|
2001-12-17 22:51:39 +00:00
|
|
|
|
2005-11-08 04:07:13 +00:00
|
|
|
if (mIsDestroying) {
|
|
|
|
// We don't want to mess with restyles at this point
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-11-06 18:01:17 +00:00
|
|
|
nsIContent* root = mDocument->GetRootContent();
|
|
|
|
if (!root) {
|
|
|
|
// No content to restyle
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
mFrameConstructor->PostRestyleEvent(root, eReStyle_Self, NS_STYLE_HINT_NONE);
|
2005-06-10 13:57:27 +00:00
|
|
|
|
|
|
|
#ifdef ACCESSIBILITY
|
|
|
|
InvalidateAccessibleSubtree(nsnull);
|
|
|
|
#endif
|
2004-08-29 03:08:44 +00:00
|
|
|
}
|
2004-01-24 00:46:17 +00:00
|
|
|
|
2004-08-29 03:08:44 +00:00
|
|
|
void
|
|
|
|
nsIPresShell::ReconstructStyleDataExternal()
|
|
|
|
{
|
|
|
|
ReconstructStyleDataInternal();
|
2001-12-17 22:51:39 +00:00
|
|
|
}
|
|
|
|
|
2004-01-24 00:46:17 +00:00
|
|
|
void
|
1998-11-26 01:34:53 +00:00
|
|
|
PresShell::StyleSheetAdded(nsIDocument *aDocument,
|
2004-07-28 07:08:41 +00:00
|
|
|
nsIStyleSheet* aStyleSheet,
|
|
|
|
PRBool aDocumentSheet)
|
1998-11-26 01:34:53 +00:00
|
|
|
{
|
2002-12-03 05:48:14 +00:00
|
|
|
// We only care when enabled sheets are added
|
|
|
|
NS_PRECONDITION(aStyleSheet, "Must have a style sheet!");
|
|
|
|
PRBool applicable;
|
|
|
|
aStyleSheet->GetApplicable(applicable);
|
|
|
|
|
2003-10-02 21:29:40 +00:00
|
|
|
if (applicable && aStyleSheet->HasRules()) {
|
|
|
|
mStylesHaveChanged = PR_TRUE;
|
2003-07-04 01:44:24 +00:00
|
|
|
}
|
1998-11-26 01:34:53 +00:00
|
|
|
}
|
|
|
|
|
2004-01-24 00:46:17 +00:00
|
|
|
void
|
1999-02-03 19:38:16 +00:00
|
|
|
PresShell::StyleSheetRemoved(nsIDocument *aDocument,
|
2004-07-28 07:08:41 +00:00
|
|
|
nsIStyleSheet* aStyleSheet,
|
|
|
|
PRBool aDocumentSheet)
|
1999-02-03 19:38:16 +00:00
|
|
|
{
|
2002-12-03 05:48:14 +00:00
|
|
|
// We only care when enabled sheets are removed
|
|
|
|
NS_PRECONDITION(aStyleSheet, "Must have a style sheet!");
|
|
|
|
PRBool applicable;
|
|
|
|
aStyleSheet->GetApplicable(applicable);
|
2003-10-02 21:29:40 +00:00
|
|
|
if (applicable && aStyleSheet->HasRules()) {
|
|
|
|
mStylesHaveChanged = PR_TRUE;
|
2002-12-03 05:48:14 +00:00
|
|
|
}
|
1999-02-03 19:38:16 +00:00
|
|
|
}
|
|
|
|
|
2004-01-24 00:46:17 +00:00
|
|
|
void
|
2002-12-03 05:48:14 +00:00
|
|
|
PresShell::StyleSheetApplicableStateChanged(nsIDocument *aDocument,
|
|
|
|
nsIStyleSheet* aStyleSheet,
|
|
|
|
PRBool aApplicable)
|
1998-11-26 01:34:53 +00:00
|
|
|
{
|
2003-10-02 21:29:40 +00:00
|
|
|
if (aStyleSheet->HasRules()) {
|
|
|
|
mStylesHaveChanged = PR_TRUE;
|
2003-07-04 01:44:24 +00:00
|
|
|
}
|
1998-11-26 01:34:53 +00:00
|
|
|
}
|
|
|
|
|
2004-01-24 00:46:17 +00:00
|
|
|
void
|
1998-11-26 01:34:53 +00:00
|
|
|
PresShell::StyleRuleChanged(nsIDocument *aDocument,
|
|
|
|
nsIStyleSheet* aStyleSheet,
|
2003-06-18 01:59:57 +00:00
|
|
|
nsIStyleRule* aOldStyleRule,
|
|
|
|
nsIStyleRule* aNewStyleRule)
|
1998-11-26 01:34:53 +00:00
|
|
|
{
|
2003-10-02 21:29:40 +00:00
|
|
|
mStylesHaveChanged = PR_TRUE;
|
1998-11-26 01:34:53 +00:00
|
|
|
}
|
|
|
|
|
2004-01-24 00:46:17 +00:00
|
|
|
void
|
1998-11-26 01:34:53 +00:00
|
|
|
PresShell::StyleRuleAdded(nsIDocument *aDocument,
|
|
|
|
nsIStyleSheet* aStyleSheet,
|
|
|
|
nsIStyleRule* aStyleRule)
|
2003-10-02 21:29:40 +00:00
|
|
|
{
|
|
|
|
mStylesHaveChanged = PR_TRUE;
|
1998-11-26 01:34:53 +00:00
|
|
|
}
|
|
|
|
|
2004-01-24 00:46:17 +00:00
|
|
|
void
|
1998-11-26 01:34:53 +00:00
|
|
|
PresShell::StyleRuleRemoved(nsIDocument *aDocument,
|
|
|
|
nsIStyleSheet* aStyleSheet,
|
|
|
|
nsIStyleRule* aStyleRule)
|
2003-10-02 21:29:40 +00:00
|
|
|
{
|
|
|
|
mStylesHaveChanged = PR_TRUE;
|
1998-11-26 01:34:53 +00:00
|
|
|
}
|
|
|
|
|
2005-08-22 22:24:29 +00:00
|
|
|
nsIFrame*
|
|
|
|
PresShell::GetPrimaryFrameFor(nsIContent* aContent) const
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2006-11-13 21:27:44 +00:00
|
|
|
return FrameManager()->GetPrimaryFrameFor(aContent, -1);
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2008-01-30 04:17:57 +00:00
|
|
|
nsIFrame*
|
|
|
|
PresShell::GetRealPrimaryFrameFor(nsIContent* aContent) const
|
|
|
|
{
|
|
|
|
nsIFrame *primaryFrame = FrameManager()->GetPrimaryFrameFor(aContent, -1);
|
|
|
|
if (!primaryFrame)
|
|
|
|
return nsnull;
|
|
|
|
return nsPlaceholderFrame::GetRealFrameFor(primaryFrame);
|
|
|
|
}
|
|
|
|
|
1999-02-10 23:21:22 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::GetLayoutObjectFor(nsIContent* aContent,
|
|
|
|
nsISupports** aResult) const
|
|
|
|
{
|
|
|
|
nsresult result = NS_ERROR_NULL_POINTER;
|
|
|
|
if ((nsnull!=aResult) && (nsnull!=aContent))
|
|
|
|
{
|
|
|
|
*aResult = nsnull;
|
2005-08-22 22:24:29 +00:00
|
|
|
nsIFrame *primaryFrame = GetPrimaryFrameFor(aContent);
|
|
|
|
if (primaryFrame)
|
1999-02-10 23:21:22 +00:00
|
|
|
{
|
2000-01-04 20:24:09 +00:00
|
|
|
result = primaryFrame->QueryInterface(NS_GET_IID(nsISupports),
|
|
|
|
(void**)aResult);
|
1999-02-10 23:21:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
2000-03-03 23:15:29 +00:00
|
|
|
|
1998-12-29 03:38:16 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::GetPlaceholderFrameFor(nsIFrame* aFrame,
|
1999-02-12 17:45:58 +00:00
|
|
|
nsIFrame** aResult) const
|
1998-12-29 03:38:16 +00:00
|
|
|
{
|
2004-03-06 04:46:11 +00:00
|
|
|
*aResult = FrameManager()->GetPlaceholderFrameFor(aFrame);
|
2004-02-23 21:29:06 +00:00
|
|
|
return NS_OK;
|
1998-12-29 03:38:16 +00:00
|
|
|
}
|
2001-12-06 05:45:07 +00:00
|
|
|
|
1998-08-28 02:54:06 +00:00
|
|
|
//nsIViewObserver
|
|
|
|
|
2006-01-26 02:29:17 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::ComputeRepaintRegionForCopy(nsIView* aRootView,
|
|
|
|
nsIView* aMovingView,
|
|
|
|
nsPoint aDelta,
|
|
|
|
const nsRect& aCopyRect,
|
|
|
|
nsRegion* aRepaintRegion)
|
|
|
|
{
|
|
|
|
return nsLayoutUtils::ComputeRepaintRegionForCopy(
|
2007-07-08 07:08:04 +00:00
|
|
|
static_cast<nsIFrame*>(aRootView->GetClientData()),
|
|
|
|
static_cast<nsIFrame*>(aMovingView->GetClientData()),
|
2006-01-26 02:29:17 +00:00
|
|
|
aDelta, aCopyRect, aRepaintRegion);
|
|
|
|
}
|
2000-04-25 04:43:11 +00:00
|
|
|
|
2006-01-26 02:29:17 +00:00
|
|
|
NS_IMETHODIMP
|
2007-05-23 00:11:05 +00:00
|
|
|
PresShell::RenderDocument(const nsRect& aRect, PRBool aUntrusted,
|
|
|
|
PRBool aIgnoreViewportScrolling,
|
|
|
|
nscolor aBackgroundColor,
|
|
|
|
gfxContext* aThebesContext)
|
2006-01-26 02:29:17 +00:00
|
|
|
{
|
2007-05-23 00:11:05 +00:00
|
|
|
NS_ENSURE_TRUE(!aUntrusted, NS_ERROR_NOT_IMPLEMENTED);
|
2006-01-26 02:29:17 +00:00
|
|
|
|
2007-11-08 04:43:36 +00:00
|
|
|
gfxRect r(0, 0,
|
|
|
|
nsPresContext::AppUnitsToFloatCSSPixels(aRect.width),
|
|
|
|
nsPresContext::AppUnitsToFloatCSSPixels(aRect.height));
|
|
|
|
aThebesContext->Save();
|
|
|
|
aThebesContext->Clip(r);
|
|
|
|
|
2007-05-23 00:11:05 +00:00
|
|
|
aThebesContext->PushGroup(NS_GET_A(aBackgroundColor) == 0xff ?
|
|
|
|
gfxASurface::CONTENT_COLOR :
|
|
|
|
gfxASurface::CONTENT_COLOR_ALPHA);
|
2006-01-26 02:29:17 +00:00
|
|
|
|
2007-05-23 00:11:05 +00:00
|
|
|
aThebesContext->Save();
|
2006-01-26 02:29:17 +00:00
|
|
|
|
2007-05-23 00:11:05 +00:00
|
|
|
// draw background color
|
|
|
|
if (NS_GET_A(aBackgroundColor) > 0) {
|
|
|
|
aThebesContext->SetColor(gfxRGBA(aBackgroundColor));
|
|
|
|
aThebesContext->SetOperator(gfxContext::OPERATOR_SOURCE);
|
|
|
|
aThebesContext->Paint();
|
2002-03-07 07:03:03 +00:00
|
|
|
}
|
|
|
|
|
2007-05-23 00:11:05 +00:00
|
|
|
// we want the window to be composited as a single image using
|
|
|
|
// whatever operator was set, so set this to the default OVER;
|
|
|
|
// the original operator will be present when we PopGroup
|
|
|
|
aThebesContext->SetOperator(gfxContext::OPERATOR_OVER);
|
2002-03-07 07:03:03 +00:00
|
|
|
|
2006-01-26 02:29:17 +00:00
|
|
|
nsIFrame* rootFrame = FrameManager()->GetRootFrame();
|
2007-05-23 00:11:05 +00:00
|
|
|
if (rootFrame) {
|
|
|
|
nsDisplayListBuilder builder(rootFrame, PR_FALSE, PR_FALSE);
|
|
|
|
nsDisplayList list;
|
|
|
|
|
|
|
|
nsRect rect(aRect);
|
|
|
|
nsIFrame* rootScrollFrame = GetRootScrollFrame();
|
|
|
|
if (aIgnoreViewportScrolling && rootScrollFrame) {
|
|
|
|
nsPoint pos = GetRootScrollFrameAsScrollable()->GetScrollPosition();
|
|
|
|
rect.MoveBy(-pos);
|
|
|
|
builder.SetIgnoreScrollFrame(rootScrollFrame);
|
|
|
|
}
|
2000-04-25 04:43:11 +00:00
|
|
|
|
2007-05-23 00:11:05 +00:00
|
|
|
builder.EnterPresShell(rootFrame, rect);
|
2006-04-17 23:16:46 +00:00
|
|
|
|
2007-05-23 00:11:05 +00:00
|
|
|
nsresult rv = rootFrame->BuildDisplayListForStackingContext(&builder, rect, &list);
|
2006-04-17 23:16:46 +00:00
|
|
|
|
2007-05-23 00:11:05 +00:00
|
|
|
builder.LeavePresShell(rootFrame, rect);
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
// Ensure that r.x,r.y gets drawn at (0,0)
|
|
|
|
aThebesContext->Save();
|
2007-11-08 04:43:36 +00:00
|
|
|
aThebesContext->Translate(gfxPoint(-nsPresContext::AppUnitsToFloatCSSPixels(rect.x),
|
|
|
|
-nsPresContext::AppUnitsToFloatCSSPixels(rect.y)));
|
2007-05-23 00:11:05 +00:00
|
|
|
|
|
|
|
nsIDeviceContext* devCtx = mPresContext->DeviceContext();
|
2007-11-08 04:43:36 +00:00
|
|
|
gfxFloat scale = gfxFloat(devCtx->AppUnitsPerDevPixel())/nsPresContext::AppUnitsPerCSSPixel();
|
|
|
|
aThebesContext->Scale(scale, scale);
|
|
|
|
|
2007-05-23 00:11:05 +00:00
|
|
|
nsCOMPtr<nsIRenderingContext> rc;
|
|
|
|
devCtx->CreateRenderingContextInstance(*getter_AddRefs(rc));
|
|
|
|
rc->Init(devCtx, aThebesContext);
|
2000-04-25 04:43:11 +00:00
|
|
|
|
2007-05-23 00:11:05 +00:00
|
|
|
nsRegion region(rect);
|
|
|
|
list.OptimizeVisibility(&builder, ®ion);
|
|
|
|
list.Paint(&builder, rc, rect);
|
|
|
|
// Flush the list so we don't trigger the IsEmpty-on-destruction assertion
|
|
|
|
list.DeleteAll();
|
|
|
|
|
|
|
|
aThebesContext->Restore();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
aThebesContext->Restore();
|
|
|
|
aThebesContext->PopGroupToSource();
|
|
|
|
aThebesContext->Paint();
|
2002-03-07 07:03:03 +00:00
|
|
|
|
2007-11-08 04:43:36 +00:00
|
|
|
aThebesContext->Restore();
|
|
|
|
|
2006-01-26 02:29:17 +00:00
|
|
|
return NS_OK;
|
2002-03-07 07:03:03 +00:00
|
|
|
}
|
|
|
|
|
2007-03-20 12:14:52 +00:00
|
|
|
/*
|
|
|
|
* Clip the display list aList to a range. Returns the clipped
|
|
|
|
* rectangle surrounding the range.
|
|
|
|
*/
|
|
|
|
nsRect
|
|
|
|
PresShell::ClipListToRange(nsDisplayListBuilder *aBuilder,
|
|
|
|
nsDisplayList* aList,
|
2007-08-17 03:43:00 +00:00
|
|
|
nsIRange* aRange)
|
2007-03-20 12:14:52 +00:00
|
|
|
{
|
|
|
|
// iterate though the display items and add up the bounding boxes of each.
|
|
|
|
// This will allow the total area of the frames within the range to be
|
|
|
|
// determined. To do this, remove an item from the bottom of the list, check
|
|
|
|
// whether it should be part of the range, and if so, append it to the top
|
|
|
|
// of the temporary list tmpList. If the item is a text frame at the end of
|
|
|
|
// the selection range, wrap it in an nsDisplayClip to clip the display to
|
|
|
|
// the portion of the text frame that is part of the selection. Then, append
|
|
|
|
// the wrapper to the top of the list. Otherwise, just delete the item and
|
|
|
|
// don't append it.
|
|
|
|
nsRect surfaceRect;
|
|
|
|
nsDisplayList tmpList;
|
|
|
|
|
|
|
|
nsDisplayItem* i;
|
|
|
|
while ((i = aList->RemoveBottom())) {
|
|
|
|
// itemToInsert indiciates the item that should be inserted into the
|
|
|
|
// temporary list. If null, no item should be inserted.
|
|
|
|
nsDisplayItem* itemToInsert = nsnull;
|
|
|
|
nsIFrame* frame = i->GetUnderlyingFrame();
|
|
|
|
if (frame) {
|
|
|
|
nsIContent* content = frame->GetContent();
|
|
|
|
if (content) {
|
|
|
|
PRBool atStart = (content == aRange->GetStartParent());
|
|
|
|
PRBool atEnd = (content == aRange->GetEndParent());
|
|
|
|
if ((atStart || atEnd) && frame->GetType() == nsGkAtoms::textFrame) {
|
|
|
|
PRInt32 frameStartOffset, frameEndOffset;
|
|
|
|
frame->GetOffsets(frameStartOffset, frameEndOffset);
|
|
|
|
|
|
|
|
PRInt32 hilightStart =
|
|
|
|
atStart ? PR_MAX(aRange->StartOffset(), frameStartOffset) : frameStartOffset;
|
|
|
|
PRInt32 hilightEnd =
|
|
|
|
atEnd ? PR_MIN(aRange->EndOffset(), frameEndOffset) : frameEndOffset;
|
|
|
|
if (hilightStart < hilightEnd) {
|
|
|
|
// determine the location of the start and end edges of the range.
|
|
|
|
nsPoint startPoint, endPoint;
|
2007-08-17 03:43:00 +00:00
|
|
|
frame->GetPointFromOffset(hilightStart, &startPoint);
|
|
|
|
frame->GetPointFromOffset(hilightEnd, &endPoint);
|
2007-03-20 12:14:52 +00:00
|
|
|
|
|
|
|
// the clip rectangle is determined by taking the the start and
|
|
|
|
// end points of the range, offset from the reference frame.
|
|
|
|
// Because of rtl, the end point may be to the left of the
|
|
|
|
// start point, so x is set to the lowest value
|
|
|
|
nsRect textRect(aBuilder->ToReferenceFrame(frame), frame->GetSize());
|
|
|
|
nscoord x = PR_MIN(startPoint.x, endPoint.x);
|
|
|
|
textRect.x += x;
|
|
|
|
textRect.width = PR_MAX(startPoint.x, endPoint.x) - x;
|
|
|
|
surfaceRect.UnionRect(surfaceRect, textRect);
|
|
|
|
|
|
|
|
// wrap the item in an nsDisplayClip so that it can be clipped to
|
|
|
|
// the selection. If the allocation fails, fall through and delete
|
|
|
|
// the item below.
|
2008-04-18 09:21:21 +00:00
|
|
|
itemToInsert = new (aBuilder)nsDisplayClip(frame, frame, i, textRect);
|
2007-03-20 12:14:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// if the node is within the range, append it to the temporary list
|
|
|
|
PRBool before, after;
|
|
|
|
nsRange::CompareNodeToRange(content, aRange, &before, &after);
|
|
|
|
if (!before && !after) {
|
|
|
|
itemToInsert = i;
|
|
|
|
surfaceRect.UnionRect(surfaceRect, i->GetBounds(aBuilder));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// insert the item into the list if necessary. If the item has a child
|
|
|
|
// list, insert that as well
|
|
|
|
nsDisplayList* sublist = i->GetList();
|
|
|
|
if (itemToInsert || sublist) {
|
|
|
|
tmpList.AppendToTop(itemToInsert ? itemToInsert : i);
|
|
|
|
// if the item is a list, iterate over it as well
|
|
|
|
if (sublist)
|
|
|
|
surfaceRect.UnionRect(surfaceRect,
|
2007-08-17 03:43:00 +00:00
|
|
|
ClipListToRange(aBuilder, sublist, aRange));
|
2007-03-20 12:14:52 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
// otherwise, just delete the item and don't readd it to the list
|
|
|
|
i->~nsDisplayItem();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// now add all the items back onto the original list again
|
|
|
|
aList->AppendToTop(&tmpList);
|
|
|
|
|
|
|
|
return surfaceRect;
|
|
|
|
}
|
|
|
|
|
|
|
|
RangePaintInfo*
|
|
|
|
PresShell::CreateRangePaintInfo(nsIDOMRange* aRange,
|
|
|
|
nsRect& aSurfaceRect)
|
|
|
|
{
|
|
|
|
RangePaintInfo* info = nsnull;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIRange> range = do_QueryInterface(aRange);
|
|
|
|
if (!range)
|
|
|
|
return nsnull;
|
|
|
|
|
2007-03-29 23:58:59 +00:00
|
|
|
nsIFrame* ancestorFrame;
|
|
|
|
nsIFrame* rootFrame = GetRootFrame();
|
|
|
|
|
|
|
|
// If the start or end of the range is the document, just use the root
|
|
|
|
// frame, otherwise get the common ancestor of the two endpoints of the
|
|
|
|
// range.
|
|
|
|
nsINode* startParent = range->GetStartParent();
|
|
|
|
nsINode* endParent = range->GetEndParent();
|
|
|
|
nsIDocument* doc = startParent->GetCurrentDoc();
|
|
|
|
if (startParent == doc || endParent == doc) {
|
|
|
|
ancestorFrame = rootFrame;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
nsINode* ancestor = nsContentUtils::GetCommonAncestor(startParent, endParent);
|
|
|
|
NS_ASSERTION(!ancestor || ancestor->IsNodeOfType(nsINode::eCONTENT),
|
|
|
|
"common ancestor is not content");
|
|
|
|
if (!ancestor || !ancestor->IsNodeOfType(nsINode::eCONTENT))
|
|
|
|
return nsnull;
|
2007-03-20 12:14:52 +00:00
|
|
|
|
2007-07-08 07:08:04 +00:00
|
|
|
nsIContent* ancestorContent = static_cast<nsIContent*>(ancestor);
|
2007-03-29 23:58:59 +00:00
|
|
|
ancestorFrame = GetPrimaryFrameFor(ancestorContent);
|
2007-03-20 12:14:52 +00:00
|
|
|
|
2007-03-29 23:58:59 +00:00
|
|
|
// use the nearest ancestor frame that includes all continuations as the
|
|
|
|
// root for building the display list
|
|
|
|
while (ancestorFrame &&
|
|
|
|
nsLayoutUtils::GetNextContinuationOrSpecialSibling(ancestorFrame))
|
|
|
|
ancestorFrame = ancestorFrame->GetParent();
|
|
|
|
}
|
2007-03-20 12:14:52 +00:00
|
|
|
|
|
|
|
if (!ancestorFrame)
|
|
|
|
return nsnull;
|
|
|
|
|
|
|
|
info = new RangePaintInfo(range, ancestorFrame);
|
|
|
|
if (!info)
|
|
|
|
return nsnull;
|
|
|
|
|
|
|
|
nsRect ancestorRect = ancestorFrame->GetOverflowRect();
|
|
|
|
|
|
|
|
// get a display list containing the range
|
|
|
|
info->mBuilder.SetPaintAllFrames();
|
|
|
|
info->mBuilder.EnterPresShell(ancestorFrame, ancestorRect);
|
|
|
|
ancestorFrame->BuildDisplayListForStackingContext(&info->mBuilder,
|
|
|
|
ancestorRect, &info->mList);
|
|
|
|
info->mBuilder.LeavePresShell(ancestorFrame, ancestorRect);
|
|
|
|
|
2007-08-17 03:43:00 +00:00
|
|
|
nsRect rangeRect = ClipListToRange(&info->mBuilder, &info->mList, range);
|
2007-03-20 12:14:52 +00:00
|
|
|
|
|
|
|
// determine the offset of the reference frame for the display list
|
|
|
|
// to the root frame. This will allow the coordinates used when painting
|
|
|
|
// to all be offset from the same point
|
2007-03-29 23:58:59 +00:00
|
|
|
info->mRootOffset = ancestorFrame->GetOffsetTo(rootFrame);
|
2007-03-20 12:14:52 +00:00
|
|
|
rangeRect.MoveBy(info->mRootOffset);
|
|
|
|
aSurfaceRect.UnionRect(aSurfaceRect, rangeRect);
|
|
|
|
|
|
|
|
return info;
|
|
|
|
}
|
|
|
|
|
|
|
|
already_AddRefed<gfxASurface>
|
|
|
|
PresShell::PaintRangePaintInfo(nsTArray<nsAutoPtr<RangePaintInfo> >* aItems,
|
|
|
|
nsISelection* aSelection,
|
|
|
|
nsIRegion* aRegion,
|
|
|
|
nsRect aArea,
|
|
|
|
nsPoint& aPoint,
|
|
|
|
nsRect* aScreenRect)
|
|
|
|
{
|
|
|
|
nsPresContext* pc = GetPresContext();
|
2007-05-17 10:14:35 +00:00
|
|
|
if (!pc || aArea.width == 0 || aArea.height == 0)
|
2007-03-20 12:14:52 +00:00
|
|
|
return nsnull;
|
|
|
|
|
|
|
|
nsIDeviceContext* deviceContext = pc->DeviceContext();
|
|
|
|
|
|
|
|
// use the rectangle to create the surface
|
|
|
|
nsRect pixelArea = aArea;
|
|
|
|
pixelArea.ScaleRoundOut(1.0 / pc->AppUnitsPerDevPixel());
|
|
|
|
|
|
|
|
// if the area of the image is larger than the maximum area, scale it down
|
|
|
|
float scale = 0.0;
|
|
|
|
nsIntRect rootScreenRect = GetRootFrame()->GetScreenRect();
|
|
|
|
|
|
|
|
// if the image is larger in one or both directions than half the size of
|
|
|
|
// the available screen area, scale the image down to that size.
|
|
|
|
nsRect maxSize;
|
|
|
|
deviceContext->GetClientRect(maxSize);
|
|
|
|
nscoord maxWidth = pc->AppUnitsToDevPixels(maxSize.width >> 1);
|
|
|
|
nscoord maxHeight = pc->AppUnitsToDevPixels(maxSize.height >> 1);
|
|
|
|
PRBool resize = (pixelArea.width > maxWidth || pixelArea.height > maxHeight);
|
|
|
|
if (resize) {
|
|
|
|
scale = 1.0;
|
|
|
|
// divide the maximum size by the image size in both directions. Whichever
|
|
|
|
// direction produces the smallest result determines how much should be
|
|
|
|
// scaled.
|
|
|
|
if (pixelArea.width > maxWidth)
|
|
|
|
scale = PR_MIN(scale, float(maxWidth) / pixelArea.width);
|
|
|
|
if (pixelArea.height > maxHeight)
|
|
|
|
scale = PR_MIN(scale, float(maxHeight) / pixelArea.height);
|
|
|
|
|
|
|
|
pixelArea.width = NSToIntFloor(float(pixelArea.width) * scale);
|
|
|
|
pixelArea.height = NSToIntFloor(float(pixelArea.height) * scale);
|
|
|
|
|
|
|
|
// adjust the screen position based on the rescaled size
|
|
|
|
nscoord left = rootScreenRect.x + pixelArea.x;
|
|
|
|
nscoord top = rootScreenRect.y + pixelArea.y;
|
|
|
|
aScreenRect->x = NSToIntFloor(aPoint.x - float(aPoint.x - left) * scale);
|
|
|
|
aScreenRect->y = NSToIntFloor(aPoint.y - float(aPoint.y - top) * scale);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// move aScreenRect to the position of the surface in screen coordinates
|
|
|
|
aScreenRect->MoveTo(rootScreenRect.x + pixelArea.x, rootScreenRect.y + pixelArea.y);
|
|
|
|
}
|
|
|
|
aScreenRect->width = pixelArea.width;
|
|
|
|
aScreenRect->height = pixelArea.height;
|
|
|
|
|
|
|
|
gfxImageSurface* surface =
|
|
|
|
new gfxImageSurface(gfxIntSize(pixelArea.width, pixelArea.height),
|
|
|
|
gfxImageSurface::ImageFormatARGB32);
|
2007-05-17 10:14:35 +00:00
|
|
|
if (!surface || surface->CairoStatus()) {
|
|
|
|
delete surface;
|
2007-03-20 12:14:52 +00:00
|
|
|
return nsnull;
|
2007-05-17 10:14:35 +00:00
|
|
|
}
|
2007-03-20 12:14:52 +00:00
|
|
|
|
|
|
|
// clear the image
|
|
|
|
gfxContext context(surface);
|
|
|
|
context.SetOperator(gfxContext::OPERATOR_CLEAR);
|
|
|
|
context.Rectangle(gfxRect(0, 0, pixelArea.width, pixelArea.height));
|
|
|
|
context.Fill();
|
|
|
|
|
|
|
|
nsCOMPtr<nsIRenderingContext> rc;
|
|
|
|
deviceContext->CreateRenderingContextInstance(*getter_AddRefs(rc));
|
|
|
|
rc->Init(deviceContext, surface);
|
|
|
|
|
|
|
|
if (aRegion)
|
|
|
|
rc->SetClipRegion(*aRegion, nsClipCombine_kReplace);
|
|
|
|
|
|
|
|
if (resize)
|
|
|
|
rc->Scale(scale, scale);
|
|
|
|
|
|
|
|
// translate so that points are relative to the surface area
|
|
|
|
rc->Translate(-aArea.x, -aArea.y);
|
|
|
|
|
|
|
|
// temporarily hide the selection so that text is drawn normally. If a
|
|
|
|
// selection is being rendered, use that, otherwise use the presshell's
|
|
|
|
// selection.
|
|
|
|
nsCOMPtr<nsFrameSelection> frameSelection;
|
|
|
|
if (aSelection) {
|
|
|
|
nsCOMPtr<nsISelectionPrivate> selpriv = do_QueryInterface(aSelection);
|
|
|
|
selpriv->GetFrameSelection(getter_AddRefs(frameSelection));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
frameSelection = FrameSelection();
|
|
|
|
}
|
|
|
|
PRInt16 oldDisplaySelection = frameSelection->GetDisplaySelection();
|
|
|
|
frameSelection->SetDisplaySelection(nsISelectionController::SELECTION_HIDDEN);
|
|
|
|
|
|
|
|
// next, paint each range in the selection
|
|
|
|
PRInt32 count = aItems->Length();
|
|
|
|
for (PRInt32 i = 0; i < count; i++) {
|
|
|
|
RangePaintInfo* rangeInfo = (*aItems)[i];
|
|
|
|
// the display lists paint relative to the offset from the reference
|
|
|
|
// frame, so translate the rendering context
|
|
|
|
nsIRenderingContext::AutoPushTranslation
|
|
|
|
translate(rc, rangeInfo->mRootOffset.x, rangeInfo->mRootOffset.y);
|
|
|
|
|
|
|
|
aArea.MoveBy(-rangeInfo->mRootOffset.x, -rangeInfo->mRootOffset.y);
|
|
|
|
rangeInfo->mList.Paint(&rangeInfo->mBuilder, rc, aArea);
|
|
|
|
aArea.MoveBy(rangeInfo->mRootOffset.x, rangeInfo->mRootOffset.y);
|
|
|
|
}
|
|
|
|
|
|
|
|
// restore the old selection display state
|
|
|
|
frameSelection->SetDisplaySelection(oldDisplaySelection);
|
|
|
|
|
|
|
|
NS_ADDREF(surface);
|
|
|
|
return surface;
|
|
|
|
}
|
|
|
|
|
|
|
|
already_AddRefed<gfxASurface>
|
|
|
|
PresShell::RenderNode(nsIDOMNode* aNode,
|
|
|
|
nsIRegion* aRegion,
|
|
|
|
nsPoint& aPoint,
|
|
|
|
nsRect* aScreenRect)
|
|
|
|
{
|
|
|
|
// area will hold the size of the surface needed to draw the node, measured
|
|
|
|
// from the root frame.
|
|
|
|
nsRect area;
|
|
|
|
nsTArray<nsAutoPtr<RangePaintInfo> > rangeItems;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMRange> range;
|
|
|
|
NS_NewRange(getter_AddRefs(range));
|
|
|
|
range->SelectNode(aNode);
|
|
|
|
|
2007-08-17 03:43:00 +00:00
|
|
|
RangePaintInfo* info = CreateRangePaintInfo(range, area);
|
2007-03-20 12:14:52 +00:00
|
|
|
if (info && !rangeItems.AppendElement(info)) {
|
|
|
|
delete info;
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (aRegion) {
|
|
|
|
// combine the area with the supplied region
|
|
|
|
nsRect rrectPixels;
|
|
|
|
aRegion->GetBoundingBox(&rrectPixels.x, &rrectPixels.y,
|
|
|
|
&rrectPixels.width, &rrectPixels.height);
|
|
|
|
|
|
|
|
nsRect rrect = rrectPixels;
|
|
|
|
rrect.ScaleRoundOut(nsPresContext::AppUnitsPerCSSPixel());
|
|
|
|
area.IntersectRect(area, rrect);
|
|
|
|
|
|
|
|
nsPresContext* pc = GetPresContext();
|
|
|
|
if (!pc)
|
|
|
|
return nsnull;
|
|
|
|
|
|
|
|
// move the region so that it is offset from the topleft corner of the surface
|
|
|
|
aRegion->Offset(-rrectPixels.x + (rrectPixels.x - pc->AppUnitsToDevPixels(area.x)),
|
|
|
|
-rrectPixels.y + (rrectPixels.y - pc->AppUnitsToDevPixels(area.y)));
|
|
|
|
}
|
|
|
|
|
|
|
|
return PaintRangePaintInfo(&rangeItems, nsnull, aRegion, area, aPoint,
|
|
|
|
aScreenRect);
|
|
|
|
}
|
|
|
|
|
|
|
|
already_AddRefed<gfxASurface>
|
|
|
|
PresShell::RenderSelection(nsISelection* aSelection,
|
|
|
|
nsPoint& aPoint,
|
|
|
|
nsRect* aScreenRect)
|
|
|
|
{
|
|
|
|
// area will hold the size of the surface needed to draw the selection,
|
|
|
|
// measured from the root frame.
|
|
|
|
nsRect area;
|
|
|
|
nsTArray<nsAutoPtr<RangePaintInfo> > rangeItems;
|
|
|
|
|
|
|
|
// iterate over each range and collect them into the rangeItems array.
|
|
|
|
// This is done so that the size of selection can be determined so as
|
|
|
|
// to allocate a surface area
|
|
|
|
PRInt32 numRanges;
|
|
|
|
aSelection->GetRangeCount(&numRanges);
|
2007-05-17 10:14:35 +00:00
|
|
|
NS_ASSERTION(numRanges > 0, "RenderSelection called with no selection");
|
|
|
|
|
2007-03-20 12:14:52 +00:00
|
|
|
for (PRInt32 r = 0; r < numRanges; r++)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMRange> range;
|
|
|
|
aSelection->GetRangeAt(r, getter_AddRefs(range));
|
|
|
|
|
2007-08-17 03:43:00 +00:00
|
|
|
RangePaintInfo* info = CreateRangePaintInfo(range, area);
|
2007-03-20 12:14:52 +00:00
|
|
|
if (info && !rangeItems.AppendElement(info)) {
|
|
|
|
delete info;
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return PaintRangePaintInfo(&rangeItems, aSelection, nsnull, area, aPoint,
|
|
|
|
aScreenRect);
|
|
|
|
}
|
|
|
|
|
1998-12-18 15:54:23 +00:00
|
|
|
NS_IMETHODIMP
|
2006-01-26 02:29:17 +00:00
|
|
|
PresShell::Paint(nsIView* aView,
|
|
|
|
nsIRenderingContext* aRenderingContext,
|
|
|
|
const nsRegion& aDirtyRegion)
|
1998-08-28 02:54:06 +00:00
|
|
|
{
|
2006-04-18 05:44:02 +00:00
|
|
|
AUTO_LAYOUT_PHASE_ENTRY_POINT(GetPresContext(), Paint);
|
1998-08-30 19:16:11 +00:00
|
|
|
nsIFrame* frame;
|
1998-10-30 22:06:14 +00:00
|
|
|
nsresult rv = NS_OK;
|
1998-08-28 02:54:06 +00:00
|
|
|
|
2002-04-26 20:44:38 +00:00
|
|
|
if (mIsDestroying) {
|
|
|
|
NS_ASSERTION(PR_FALSE, "A paint message was dispatched to a destroyed PresShell");
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1998-08-28 02:54:06 +00:00
|
|
|
NS_ASSERTION(!(nsnull == aView), "null view");
|
|
|
|
|
2007-07-08 07:08:04 +00:00
|
|
|
frame = static_cast<nsIFrame*>(aView->GetClientData());
|
2006-02-06 20:38:47 +00:00
|
|
|
nscolor backgroundColor;
|
|
|
|
mViewManager->GetDefaultBackgroundColor(&backgroundColor);
|
2006-09-07 08:50:43 +00:00
|
|
|
for (nsIView *view = aView; view; view = view->GetParent()) {
|
|
|
|
if (view->HasWidget()) {
|
2007-12-19 19:40:18 +00:00
|
|
|
PRBool widgetIsTransparent;
|
|
|
|
view->GetWidget()->GetHasTransparentBackground(widgetIsTransparent);
|
|
|
|
if (widgetIsTransparent) {
|
2006-09-07 08:50:43 +00:00
|
|
|
backgroundColor = NS_RGBA(0,0,0,0);
|
|
|
|
break;
|
|
|
|
}
|
2006-02-06 20:38:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!frame) {
|
|
|
|
if (NS_GET_A(backgroundColor) > 0) {
|
|
|
|
aRenderingContext->SetColor(backgroundColor);
|
|
|
|
aRenderingContext->FillRect(aDirtyRegion.GetBounds());
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1998-08-28 02:54:06 +00:00
|
|
|
|
2006-02-06 20:38:47 +00:00
|
|
|
nsLayoutUtils::PaintFrame(aRenderingContext, frame, aDirtyRegion,
|
|
|
|
backgroundColor);
|
2000-10-11 13:50:45 +00:00
|
|
|
|
1998-08-28 02:54:06 +00:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
1999-06-15 03:14:28 +00:00
|
|
|
nsIFrame*
|
|
|
|
PresShell::GetCurrentEventFrame()
|
|
|
|
{
|
|
|
|
if (!mCurrentEventFrame && mCurrentEventContent) {
|
1999-11-03 07:11:45 +00:00
|
|
|
// Make sure the content still has a document reference. If not,
|
|
|
|
// then we assume it is no longer in the content tree and the
|
|
|
|
// frame shouldn't get an event, nor should we even assume its
|
|
|
|
// safe to try and find the frame.
|
2003-07-28 21:25:13 +00:00
|
|
|
if (mCurrentEventContent->GetDocument()) {
|
2005-08-22 22:24:29 +00:00
|
|
|
mCurrentEventFrame = GetPrimaryFrameFor(mCurrentEventContent);
|
1999-11-03 07:11:45 +00:00
|
|
|
}
|
1999-06-15 03:14:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return mCurrentEventFrame;
|
|
|
|
}
|
|
|
|
|
2000-06-24 03:58:13 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::GetEventTargetFrame(nsIFrame** aFrame)
|
|
|
|
{
|
2003-03-12 03:22:11 +00:00
|
|
|
*aFrame = GetCurrentEventFrame();
|
|
|
|
return NS_OK;
|
2000-06-24 03:58:13 +00:00
|
|
|
}
|
|
|
|
|
2003-02-14 21:43:06 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::GetEventTargetContent(nsEvent* aEvent, nsIContent** aContent)
|
|
|
|
{
|
|
|
|
if (mCurrentEventContent) {
|
|
|
|
*aContent = mCurrentEventContent;
|
|
|
|
NS_IF_ADDREF(*aContent);
|
|
|
|
} else {
|
|
|
|
nsIFrame* currentEventFrame = GetCurrentEventFrame();
|
|
|
|
if (currentEventFrame) {
|
|
|
|
currentEventFrame->GetContentForEvent(mPresContext, aEvent, aContent);
|
|
|
|
} else {
|
|
|
|
*aContent = nsnull;
|
|
|
|
}
|
|
|
|
}
|
2003-03-12 03:22:11 +00:00
|
|
|
return NS_OK;
|
2003-02-14 21:43:06 +00:00
|
|
|
}
|
|
|
|
|
1999-09-02 18:14:01 +00:00
|
|
|
void
|
2000-04-24 04:41:27 +00:00
|
|
|
PresShell::PushCurrentEventInfo(nsIFrame* aFrame, nsIContent* aContent)
|
1999-09-02 18:14:01 +00:00
|
|
|
{
|
2000-04-24 04:41:27 +00:00
|
|
|
if (mCurrentEventFrame || mCurrentEventContent) {
|
1999-09-02 18:14:01 +00:00
|
|
|
mCurrentEventFrameStack.InsertElementAt((void*)mCurrentEventFrame, 0);
|
2004-09-13 03:22:46 +00:00
|
|
|
mCurrentEventContentStack.InsertObjectAt(mCurrentEventContent, 0);
|
1999-09-02 18:14:01 +00:00
|
|
|
}
|
2000-04-24 04:41:27 +00:00
|
|
|
mCurrentEventFrame = aFrame;
|
|
|
|
mCurrentEventContent = aContent;
|
1999-09-02 18:14:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2000-04-24 04:41:27 +00:00
|
|
|
PresShell::PopCurrentEventInfo()
|
1999-09-02 18:14:01 +00:00
|
|
|
{
|
|
|
|
mCurrentEventFrame = nsnull;
|
2004-09-13 03:22:46 +00:00
|
|
|
mCurrentEventContent = nsnull;
|
1999-09-02 18:14:01 +00:00
|
|
|
|
1999-09-02 19:21:45 +00:00
|
|
|
if (0 != mCurrentEventFrameStack.Count()) {
|
1999-09-02 18:14:01 +00:00
|
|
|
mCurrentEventFrame = (nsIFrame*)mCurrentEventFrameStack.ElementAt(0);
|
|
|
|
mCurrentEventFrameStack.RemoveElementAt(0);
|
2004-09-13 03:22:46 +00:00
|
|
|
mCurrentEventContent = mCurrentEventContentStack.ObjectAt(0);
|
|
|
|
mCurrentEventContentStack.RemoveObjectAt(0);
|
1999-09-02 18:14:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-01-07 02:09:06 +00:00
|
|
|
PRBool PresShell::InZombieDocument(nsIContent *aContent)
|
|
|
|
{
|
2005-08-05 20:01:52 +00:00
|
|
|
// If a content node points to a null document, or the document is not
|
|
|
|
// attached to a window, then it is possibly in a zombie document,
|
|
|
|
// about to be replaced by a newly loading document.
|
2003-01-07 02:09:06 +00:00
|
|
|
// Such documents cannot handle DOM events.
|
|
|
|
// It might actually be in a node not attached to any document,
|
|
|
|
// in which case there is not parent presshell to retarget it to.
|
2005-08-05 20:01:52 +00:00
|
|
|
nsIDocument *doc = aContent->GetDocument();
|
2005-11-28 23:56:44 +00:00
|
|
|
return !doc || !doc->GetWindow();
|
2003-01-07 02:09:06 +00:00
|
|
|
}
|
|
|
|
|
2006-10-27 00:01:19 +00:00
|
|
|
nsresult PresShell::RetargetEventToParent(nsGUIEvent* aEvent,
|
|
|
|
nsEventStatus* aEventStatus)
|
2003-01-07 02:09:06 +00:00
|
|
|
{
|
2005-02-05 17:00:46 +00:00
|
|
|
// Send this events straight up to the parent pres shell.
|
2006-10-27 00:01:19 +00:00
|
|
|
// We do this for keystroke events in zombie documents or if either a frame
|
|
|
|
// or a root content is not present.
|
2003-01-07 02:09:06 +00:00
|
|
|
// That way at least the UI key bindings can work.
|
|
|
|
|
|
|
|
nsCOMPtr<nsIPresShell> kungFuDeathGrip(this);
|
2004-02-01 10:09:07 +00:00
|
|
|
nsCOMPtr<nsISupports> container = mPresContext->GetContainer();
|
2005-08-22 01:55:34 +00:00
|
|
|
if (!container)
|
|
|
|
container = do_QueryReferent(mForwardingContainer);
|
2003-01-07 02:09:06 +00:00
|
|
|
|
|
|
|
// Now, find the parent pres shell and send the event there
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> treeItem =
|
|
|
|
do_QueryInterface(container);
|
|
|
|
NS_ASSERTION(treeItem, "No tree item for container.");
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> parentTreeItem;
|
|
|
|
treeItem->GetParent(getter_AddRefs(parentTreeItem));
|
|
|
|
nsCOMPtr<nsIDocShell> parentDocShell =
|
|
|
|
do_QueryInterface(parentTreeItem);
|
|
|
|
if (!parentDocShell || treeItem == parentTreeItem) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIPresShell> parentPresShell;
|
|
|
|
parentDocShell->GetPresShell(getter_AddRefs(parentPresShell));
|
|
|
|
nsCOMPtr<nsIViewObserver> parentViewObserver =
|
|
|
|
do_QueryInterface(parentPresShell);
|
|
|
|
if (!parentViewObserver) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2006-10-27 00:01:19 +00:00
|
|
|
// Fake the event as though it'ss from the parent pres shell's root view.
|
|
|
|
nsIView *parentRootView;
|
|
|
|
parentPresShell->GetViewManager()->GetRootView(parentRootView);
|
|
|
|
|
|
|
|
return parentViewObserver->HandleEvent(parentRootView, aEvent,
|
2006-01-26 02:29:17 +00:00
|
|
|
aEventStatus);
|
2003-01-07 02:09:06 +00:00
|
|
|
}
|
|
|
|
|
1998-12-18 15:54:23 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::HandleEvent(nsIView *aView,
|
|
|
|
nsGUIEvent* aEvent,
|
2006-01-26 02:29:17 +00:00
|
|
|
nsEventStatus* aEventStatus)
|
1998-08-28 02:54:06 +00:00
|
|
|
{
|
2003-05-12 07:11:16 +00:00
|
|
|
NS_ASSERTION(aView, "null view");
|
2000-03-22 02:43:08 +00:00
|
|
|
|
2008-03-19 01:37:09 +00:00
|
|
|
if (mIsDestroying || mIsReflowing || mChangeNestCount) {
|
1998-11-18 05:25:26 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-08-17 03:13:07 +00:00
|
|
|
#ifdef ACCESSIBILITY
|
2003-05-12 07:11:16 +00:00
|
|
|
if (aEvent->eventStructType == NS_ACCESSIBLE_EVENT) {
|
2008-03-19 01:37:09 +00:00
|
|
|
// Accessibility events come through OS requests and not from scripts,
|
|
|
|
// so it is safe to handle here
|
2006-03-07 17:08:51 +00:00
|
|
|
return HandleEventInternal(aEvent, aView, aEventStatus);
|
2003-05-12 07:11:16 +00:00
|
|
|
}
|
2001-08-17 03:13:07 +00:00
|
|
|
#endif
|
2008-04-18 17:20:11 +00:00
|
|
|
|
|
|
|
NS_ASSERTION(nsContentUtils::IsSafeToRunScript(),
|
|
|
|
"How did we get here if it's not safe to run scripts?");
|
2001-04-01 01:01:33 +00:00
|
|
|
|
2001-12-17 22:51:39 +00:00
|
|
|
// Check for a theme change up front, since the frame type is irrelevant
|
2003-05-12 07:11:16 +00:00
|
|
|
if (aEvent->message == NS_THEMECHANGED && mPresContext) {
|
2004-07-29 19:41:39 +00:00
|
|
|
mPresContext->ThemeChanged();
|
|
|
|
return NS_OK;
|
2003-05-12 07:11:16 +00:00
|
|
|
}
|
2001-04-01 01:01:33 +00:00
|
|
|
|
2003-05-12 07:11:16 +00:00
|
|
|
// Check for a system color change up front, since the frame type is
|
|
|
|
// irrelevant
|
2002-06-04 17:47:54 +00:00
|
|
|
if ((aEvent->message == NS_SYSCOLORCHANGED) && mPresContext) {
|
2003-06-30 10:46:59 +00:00
|
|
|
nsIViewManager* vm = GetViewManager();
|
|
|
|
if (vm) {
|
2002-06-04 17:47:54 +00:00
|
|
|
// Only dispatch system color change when the message originates from
|
|
|
|
// from the root views widget. This is necessary to prevent us from
|
|
|
|
// dispatching the SysColorChanged notification for each child window
|
|
|
|
// which may be redundant.
|
2004-05-17 16:29:13 +00:00
|
|
|
nsIView *view;
|
|
|
|
vm->GetRootView(view);
|
|
|
|
if (view == aView) {
|
2002-06-04 17:47:54 +00:00
|
|
|
*aEventStatus = nsEventStatus_eConsumeDoDefault;
|
2004-07-29 19:41:39 +00:00
|
|
|
mPresContext->SysColorChanged();
|
|
|
|
return NS_OK;
|
2002-06-04 17:47:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2006-01-26 02:29:17 +00:00
|
|
|
|
2007-07-08 07:08:04 +00:00
|
|
|
nsIFrame* frame = static_cast<nsIFrame*>(aView->GetClientData());
|
1998-08-28 02:54:06 +00:00
|
|
|
|
2006-01-26 02:29:17 +00:00
|
|
|
PRBool dispatchUsingCoordinates =
|
|
|
|
!NS_IS_KEY_EVENT(aEvent) && !NS_IS_IME_EVENT(aEvent) &&
|
2006-11-16 21:35:39 +00:00
|
|
|
!NS_IS_CONTEXT_MENU_KEY(aEvent) && !NS_IS_FOCUS_EVENT(aEvent);
|
2006-02-27 02:47:13 +00:00
|
|
|
|
|
|
|
// if this event has no frame, we need to retarget it at a parent
|
|
|
|
// view that has a frame.
|
|
|
|
if (!frame &&
|
|
|
|
(dispatchUsingCoordinates || NS_IS_KEY_EVENT(aEvent) ||
|
|
|
|
NS_IS_IME_EVENT(aEvent))) {
|
|
|
|
nsIView* targetView = aView;
|
|
|
|
while (targetView && !targetView->GetClientData()) {
|
|
|
|
targetView = targetView->GetParent();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (targetView) {
|
|
|
|
aView = targetView;
|
2007-07-08 07:08:04 +00:00
|
|
|
frame = static_cast<nsIFrame*>(aView->GetClientData());
|
2006-02-27 02:47:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dispatchUsingCoordinates) {
|
|
|
|
NS_ASSERTION(frame, "Nothing to handle this event!");
|
|
|
|
if (!frame)
|
|
|
|
return NS_OK;
|
2006-11-29 23:09:13 +00:00
|
|
|
|
2007-03-30 21:11:41 +00:00
|
|
|
nsPresContext* framePresContext = frame->PresContext();
|
2006-11-29 23:09:13 +00:00
|
|
|
nsPresContext* rootPresContext = framePresContext->RootPresContext();
|
2007-08-03 00:09:18 +00:00
|
|
|
NS_ASSERTION(rootPresContext == mPresContext->RootPresContext(),
|
2006-11-29 23:09:13 +00:00
|
|
|
"How did we end up outside the connected prescontext/viewmanager hierarchy?");
|
|
|
|
// If we aren't starting our event dispatch from the root frame of the root prescontext,
|
|
|
|
// then someone must be capturing the mouse. In that case we don't want to search the popup
|
|
|
|
// list.
|
|
|
|
if (framePresContext == rootPresContext &&
|
|
|
|
frame == FrameManager()->GetRootFrame()) {
|
2007-07-16 14:53:32 +00:00
|
|
|
|
2007-07-24 00:04:36 +00:00
|
|
|
#ifdef MOZ_XUL
|
2007-07-16 14:53:32 +00:00
|
|
|
nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
|
|
|
|
if (pm) {
|
|
|
|
nsTArray<nsIFrame*> popups = pm->GetOpenPopups();
|
2007-12-01 07:22:44 +00:00
|
|
|
PRUint32 i;
|
2007-07-16 14:53:32 +00:00
|
|
|
// Search from top to bottom
|
|
|
|
for (i = 0; i < popups.Length(); i++) {
|
|
|
|
nsIFrame* popup = popups[i];
|
|
|
|
if (popup->GetOverflowRect().Contains(
|
|
|
|
nsLayoutUtils::GetEventCoordinatesRelativeTo(aEvent, popup))) {
|
|
|
|
// The event should target the popup
|
|
|
|
frame = popup;
|
|
|
|
break;
|
|
|
|
}
|
2006-11-29 23:09:13 +00:00
|
|
|
}
|
|
|
|
}
|
2007-07-24 00:04:36 +00:00
|
|
|
#endif
|
2006-11-29 23:09:13 +00:00
|
|
|
}
|
|
|
|
|
2006-01-26 02:29:17 +00:00
|
|
|
nsPoint eventPoint
|
|
|
|
= nsLayoutUtils::GetEventCoordinatesRelativeTo(aEvent, frame);
|
2008-01-30 04:53:46 +00:00
|
|
|
nsIFrame* targetFrame;
|
|
|
|
{
|
|
|
|
nsAutoDisableGetUsedXAssertions disableAssert;
|
|
|
|
targetFrame = nsLayoutUtils::GetFrameForPoint(frame, eventPoint);
|
|
|
|
}
|
|
|
|
|
2006-01-26 02:29:17 +00:00
|
|
|
if (targetFrame) {
|
|
|
|
PresShell* shell =
|
2007-07-08 07:08:04 +00:00
|
|
|
static_cast<PresShell*>(targetFrame->PresContext()->PresShell());
|
2006-01-26 02:29:17 +00:00
|
|
|
if (shell != this) {
|
2006-05-12 03:49:38 +00:00
|
|
|
// Handle the event in the correct shell.
|
|
|
|
// Prevent deletion until we're done with event handling (bug 336582).
|
2007-06-23 07:39:40 +00:00
|
|
|
nsCOMPtr<nsIPresShell> kungFuDeathGrip(shell);
|
2006-01-26 02:29:17 +00:00
|
|
|
nsIView* subshellRootView;
|
|
|
|
shell->GetViewManager()->GetRootView(subshellRootView);
|
|
|
|
// We pass the subshell's root view as the view to start from. This is
|
|
|
|
// the only correct alternative; if the event was captured then it
|
|
|
|
// must have been captured by us or some ancestor shell and we
|
|
|
|
// now ask the subshell to dispatch it normally.
|
|
|
|
return shell->HandlePositionedEvent(subshellRootView, targetFrame,
|
|
|
|
aEvent, aEventStatus);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!targetFrame) {
|
|
|
|
targetFrame = frame;
|
|
|
|
}
|
|
|
|
return HandlePositionedEvent(aView, targetFrame, aEvent, aEventStatus);
|
|
|
|
}
|
|
|
|
|
2003-05-12 07:11:16 +00:00
|
|
|
nsresult rv = NS_OK;
|
|
|
|
|
|
|
|
if (frame) {
|
2000-04-24 04:41:27 +00:00
|
|
|
PushCurrentEventInfo(nsnull, nsnull);
|
1999-05-20 23:16:53 +00:00
|
|
|
|
2003-05-12 07:11:16 +00:00
|
|
|
// key and IME events go to the focused frame
|
2006-01-26 02:29:17 +00:00
|
|
|
nsIEventStateManager *esm = mPresContext->EventStateManager();
|
2004-03-22 18:13:11 +00:00
|
|
|
|
2006-01-26 02:29:17 +00:00
|
|
|
if (NS_IS_KEY_EVENT(aEvent) || NS_IS_IME_EVENT(aEvent) ||
|
2006-11-16 21:35:39 +00:00
|
|
|
NS_IS_CONTEXT_MENU_KEY(aEvent)) {
|
2004-03-22 18:13:11 +00:00
|
|
|
esm->GetFocusedFrame(&mCurrentEventFrame);
|
2005-09-23 17:55:12 +00:00
|
|
|
if (mCurrentEventFrame) {
|
|
|
|
esm->GetFocusedContent(getter_AddRefs(mCurrentEventContent));
|
2006-01-26 02:29:17 +00:00
|
|
|
} else {
|
2008-02-20 07:16:06 +00:00
|
|
|
if (NS_TargetUnfocusedEventToLastFocusedContent(aEvent)) {
|
2005-11-28 23:56:44 +00:00
|
|
|
nsPIDOMWindow *ourWindow = mDocument->GetWindow();
|
2003-05-12 07:11:16 +00:00
|
|
|
if (ourWindow) {
|
2004-05-03 21:48:36 +00:00
|
|
|
nsIFocusController *focusController =
|
|
|
|
ourWindow->GetRootFocusController();
|
2003-05-12 07:11:16 +00:00
|
|
|
if (focusController) {
|
|
|
|
PRBool active = PR_FALSE;
|
|
|
|
// check input focus is in Mozilla
|
|
|
|
focusController->GetActive(&active);
|
|
|
|
if (!active) {
|
|
|
|
// if not, search for pre-focused element
|
|
|
|
nsCOMPtr<nsIDOMElement> focusedElement;
|
|
|
|
focusController->GetFocusedElement(getter_AddRefs(focusedElement));
|
|
|
|
if (focusedElement) {
|
|
|
|
// get mCurrentEventContent from focusedElement
|
2004-09-13 03:22:46 +00:00
|
|
|
mCurrentEventContent = do_QueryInterface(focusedElement);
|
2002-09-11 02:02:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2000-03-22 02:43:08 +00:00
|
|
|
}
|
2003-05-12 07:11:16 +00:00
|
|
|
if (!mCurrentEventContent) {
|
2004-09-13 03:22:46 +00:00
|
|
|
mCurrentEventContent = mDocument->GetRootContent();
|
2003-01-07 02:09:06 +00:00
|
|
|
}
|
2004-01-07 22:18:37 +00:00
|
|
|
mCurrentEventFrame = nsnull; // XXXldb Isn't it already?
|
1999-07-26 15:02:19 +00:00
|
|
|
}
|
2006-08-28 02:04:16 +00:00
|
|
|
if (!mCurrentEventContent || InZombieDocument(mCurrentEventContent)) {
|
2006-10-27 00:01:19 +00:00
|
|
|
rv = RetargetEventToParent(aEvent, aEventStatus);
|
|
|
|
PopCurrentEventInfo();
|
|
|
|
return rv;
|
2003-05-12 07:11:16 +00:00
|
|
|
}
|
|
|
|
} else {
|
2006-01-26 02:29:17 +00:00
|
|
|
mCurrentEventFrame = frame;
|
1998-11-18 05:25:26 +00:00
|
|
|
}
|
2003-05-12 07:11:16 +00:00
|
|
|
if (GetCurrentEventFrame()) {
|
2006-03-07 17:08:51 +00:00
|
|
|
rv = HandleEventInternal(aEvent, aView, aEventStatus);
|
2003-05-12 07:11:16 +00:00
|
|
|
}
|
2006-01-26 02:29:17 +00:00
|
|
|
|
2000-02-03 02:49:58 +00:00
|
|
|
#ifdef NS_DEBUG
|
2006-01-26 02:29:17 +00:00
|
|
|
ShowEventTargetDebug();
|
2000-02-03 02:49:58 +00:00
|
|
|
#endif
|
2000-04-24 04:41:27 +00:00
|
|
|
PopCurrentEventInfo();
|
2006-01-26 02:29:17 +00:00
|
|
|
} else {
|
2003-05-12 07:11:16 +00:00
|
|
|
// Focus events need to be dispatched even if no frame was found, since
|
|
|
|
// we don't want the focus controller to be out of sync.
|
|
|
|
|
|
|
|
if (!NS_EVENT_NEEDS_FRAME(aEvent)) {
|
|
|
|
mCurrentEventFrame = nsnull;
|
2006-03-07 17:08:51 +00:00
|
|
|
return HandleEventInternal(aEvent, aView, aEventStatus);
|
2003-05-12 07:11:16 +00:00
|
|
|
}
|
2003-07-24 08:48:59 +00:00
|
|
|
else if (NS_IS_KEY_EVENT(aEvent)) {
|
|
|
|
// Keypress events in new blank tabs should not be completely thrown away.
|
|
|
|
// Retarget them -- the parent chrome shell might make use of them.
|
2006-10-27 00:01:19 +00:00
|
|
|
return RetargetEventToParent(aEvent, aEventStatus);
|
2003-07-24 08:48:59 +00:00
|
|
|
}
|
2006-01-26 02:29:17 +00:00
|
|
|
}
|
2003-05-12 07:11:16 +00:00
|
|
|
|
2006-01-26 02:29:17 +00:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef NS_DEBUG
|
|
|
|
void
|
|
|
|
PresShell::ShowEventTargetDebug()
|
|
|
|
{
|
2007-02-20 20:22:19 +00:00
|
|
|
if (nsIFrameDebug::GetShowEventTargetFrameBorder() &&
|
|
|
|
GetCurrentEventFrame()) {
|
|
|
|
if (mDrawEventTargetFrame) {
|
|
|
|
mDrawEventTargetFrame->Invalidate(
|
|
|
|
nsRect(nsPoint(0, 0), mDrawEventTargetFrame->GetSize()));
|
2006-01-26 02:29:17 +00:00
|
|
|
}
|
2007-02-20 20:22:19 +00:00
|
|
|
|
|
|
|
mDrawEventTargetFrame = mCurrentEventFrame;
|
|
|
|
mDrawEventTargetFrame->Invalidate(
|
|
|
|
nsRect(nsPoint(0, 0), mDrawEventTargetFrame->GetSize()));
|
2006-01-26 02:29:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
PresShell::HandlePositionedEvent(nsIView* aView,
|
|
|
|
nsIFrame* aTargetFrame,
|
|
|
|
nsGUIEvent* aEvent,
|
|
|
|
nsEventStatus* aEventStatus)
|
|
|
|
{
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
|
|
|
|
PushCurrentEventInfo(nsnull, nsnull);
|
|
|
|
|
|
|
|
mCurrentEventFrame = aTargetFrame;
|
|
|
|
|
|
|
|
if (mCurrentEventFrame) {
|
|
|
|
nsCOMPtr<nsIContent> targetElement;
|
|
|
|
mCurrentEventFrame->GetContentForEvent(mPresContext, aEvent,
|
|
|
|
getter_AddRefs(targetElement));
|
|
|
|
|
|
|
|
// If there is no content for this frame, target it anyway. Some
|
|
|
|
// frames can be targeted but do not have content, particularly
|
|
|
|
// windows with scrolling off.
|
|
|
|
if (targetElement) {
|
|
|
|
// Bug 103055, bug 185889: mouse events apply to *elements*, not all
|
|
|
|
// nodes. Thus we get the nearest element parent here.
|
|
|
|
// XXX we leave the frame the same even if we find an element
|
|
|
|
// parent, so that the text frame will receive the event (selection
|
|
|
|
// and friends are the ones who care about that anyway)
|
|
|
|
//
|
|
|
|
// We use weak pointers because during this tight loop, the node
|
|
|
|
// will *not* go away. And this happens on every mousemove.
|
|
|
|
while (targetElement &&
|
2006-05-05 06:52:21 +00:00
|
|
|
!targetElement->IsNodeOfType(nsINode::eELEMENT)) {
|
2006-01-26 02:29:17 +00:00
|
|
|
targetElement = targetElement->GetParent();
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we found an element, target it. Otherwise, target *nothing*.
|
|
|
|
if (!targetElement) {
|
|
|
|
mCurrentEventContent = nsnull;
|
|
|
|
mCurrentEventFrame = nsnull;
|
|
|
|
} else if (targetElement != mCurrentEventContent) {
|
|
|
|
mCurrentEventContent = targetElement;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (GetCurrentEventFrame()) {
|
2006-03-07 17:08:51 +00:00
|
|
|
rv = HandleEventInternal(aEvent, aView, aEventStatus);
|
1998-11-21 00:19:36 +00:00
|
|
|
}
|
1998-08-28 02:54:06 +00:00
|
|
|
|
2006-01-26 02:29:17 +00:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
ShowEventTargetDebug();
|
|
|
|
#endif
|
|
|
|
PopCurrentEventInfo();
|
1998-08-28 02:54:06 +00:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2000-04-24 04:41:27 +00:00
|
|
|
NS_IMETHODIMP
|
2006-03-07 17:08:51 +00:00
|
|
|
PresShell::HandleEventWithTarget(nsEvent* aEvent, nsIFrame* aFrame,
|
|
|
|
nsIContent* aContent, nsEventStatus* aStatus)
|
2000-04-24 04:41:27 +00:00
|
|
|
{
|
|
|
|
nsresult ret;
|
|
|
|
|
|
|
|
PushCurrentEventInfo(aFrame, aContent);
|
2006-03-07 17:08:51 +00:00
|
|
|
ret = HandleEventInternal(aEvent, nsnull, aStatus);
|
2000-04-24 04:41:27 +00:00
|
|
|
PopCurrentEventInfo();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2004-06-22 04:32:52 +00:00
|
|
|
inline PRBool
|
|
|
|
IsSynthesizedMouseMove(nsEvent* aEvent)
|
|
|
|
{
|
|
|
|
return aEvent->eventStructType == NS_MOUSE_EVENT &&
|
2007-07-08 07:08:04 +00:00
|
|
|
static_cast<nsMouseEvent*>(aEvent)->reason != nsMouseEvent::eReal;
|
2004-06-22 04:32:52 +00:00
|
|
|
}
|
|
|
|
|
2000-04-24 04:41:27 +00:00
|
|
|
nsresult
|
2003-05-12 07:11:16 +00:00
|
|
|
PresShell::HandleEventInternal(nsEvent* aEvent, nsIView *aView,
|
2006-03-07 17:08:51 +00:00
|
|
|
nsEventStatus* aStatus)
|
2000-04-24 04:41:27 +00:00
|
|
|
{
|
2001-08-17 03:13:07 +00:00
|
|
|
#ifdef ACCESSIBILITY
|
2001-04-01 01:01:33 +00:00
|
|
|
if (aEvent->eventStructType == NS_ACCESSIBLE_EVENT)
|
|
|
|
{
|
2007-07-08 07:08:04 +00:00
|
|
|
static_cast<nsAccessibleEvent*>(aEvent)->accessible = nsnull;
|
2003-04-15 08:45:55 +00:00
|
|
|
nsCOMPtr<nsIAccessibilityService> accService =
|
|
|
|
do_GetService("@mozilla.org/accessibilityService;1");
|
|
|
|
if (accService) {
|
2005-07-15 02:35:19 +00:00
|
|
|
nsCOMPtr<nsISupports> container = mPresContext->GetContainer();
|
|
|
|
if (!container) {
|
|
|
|
// This presshell is not active. This often happens when a
|
|
|
|
// preshell is being held onto for fastback.
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2003-04-15 08:45:55 +00:00
|
|
|
nsIAccessible* acc;
|
|
|
|
nsCOMPtr<nsIDOMNode> domNode(do_QueryInterface(mDocument));
|
|
|
|
NS_ASSERTION(domNode, "No dom node for doc");
|
|
|
|
accService->GetAccessibleInShell(domNode, this, &acc);
|
|
|
|
// Addref this - it's not a COM Ptr
|
|
|
|
// We'll make sure the right number of Addref's occur before
|
|
|
|
// handing this back to the accessibility client
|
2007-07-08 07:08:04 +00:00
|
|
|
static_cast<nsAccessibleEvent*>(aEvent)->accessible = acc;
|
2007-05-04 18:09:02 +00:00
|
|
|
// Ensure this is set in case a11y was activated before any
|
|
|
|
// nsPresShells existed to observe "a11y-init-or-shutdown" topic
|
|
|
|
gIsAccessibilityActive = PR_TRUE;
|
2003-04-15 08:45:55 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2001-04-01 01:01:33 +00:00
|
|
|
}
|
2001-08-17 03:13:07 +00:00
|
|
|
#endif
|
2001-04-01 01:01:33 +00:00
|
|
|
|
2004-02-27 17:17:37 +00:00
|
|
|
nsCOMPtr<nsIEventStateManager> manager = mPresContext->EventStateManager();
|
|
|
|
nsresult rv = NS_OK;
|
2000-04-24 04:41:27 +00:00
|
|
|
|
2004-02-27 17:17:37 +00:00
|
|
|
if (!NS_EVENT_NEEDS_FRAME(aEvent) || GetCurrentEventFrame()) {
|
2004-09-04 19:28:46 +00:00
|
|
|
PRBool isHandlingUserInput = PR_FALSE;
|
|
|
|
|
2006-04-10 17:04:54 +00:00
|
|
|
if (NS_IS_TRUSTED_EVENT(aEvent)) {
|
2004-09-04 19:28:46 +00:00
|
|
|
switch (aEvent->message) {
|
|
|
|
case NS_GOTFOCUS:
|
|
|
|
case NS_LOSTFOCUS:
|
|
|
|
case NS_ACTIVATE:
|
|
|
|
case NS_DEACTIVATE:
|
|
|
|
// Treat focus/blur events as user input if they happen while
|
|
|
|
// executing trusted script, or no script at all. If they
|
|
|
|
// happen during execution of non-trusted script, then they
|
2005-11-20 22:05:24 +00:00
|
|
|
// should not be considered user input.
|
2004-09-04 19:28:46 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
break;
|
|
|
|
}
|
2006-11-16 21:35:39 +00:00
|
|
|
case NS_MOUSE_BUTTON_DOWN:
|
|
|
|
case NS_MOUSE_BUTTON_UP:
|
2004-09-04 19:28:46 +00:00
|
|
|
case NS_KEY_PRESS:
|
|
|
|
case NS_KEY_DOWN:
|
|
|
|
case NS_KEY_UP:
|
|
|
|
isHandlingUserInput = PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
nsAutoHandlingUserInputStatePusher userInpStatePusher(isHandlingUserInput);
|
|
|
|
|
|
|
|
nsAutoPopupStatePusher popupStatePusher(nsDOMEvent::GetEventPopupControlState(aEvent));
|
2000-04-24 04:41:27 +00:00
|
|
|
|
2006-03-12 20:12:36 +00:00
|
|
|
// FIXME. If the event was reused, we need to clear the old target,
|
|
|
|
// bug 329430
|
|
|
|
aEvent->target = nsnull;
|
|
|
|
|
2007-11-22 15:08:13 +00:00
|
|
|
nsWeakView weakView(aView);
|
2003-05-12 07:11:16 +00:00
|
|
|
// 1. Give event to event manager for pre event state changes and
|
|
|
|
// generation of synthetic events.
|
|
|
|
rv = manager->PreHandleEvent(mPresContext, aEvent, mCurrentEventFrame,
|
|
|
|
aStatus, aView);
|
|
|
|
|
|
|
|
// 2. Give event to the DOM for third party and JS use.
|
2005-09-16 06:04:25 +00:00
|
|
|
if ((GetCurrentEventFrame()) && NS_SUCCEEDED(rv)) {
|
|
|
|
// We want synthesized mouse moves to cause mouseover and mouseout
|
|
|
|
// DOM events (PreHandleEvent above), but not mousemove DOM events.
|
|
|
|
if (!IsSynthesizedMouseMove(aEvent)) {
|
2006-03-07 17:08:51 +00:00
|
|
|
nsPresShellEventCB eventCB(this);
|
2005-09-16 06:04:25 +00:00
|
|
|
if (mCurrentEventContent) {
|
2006-03-07 17:08:51 +00:00
|
|
|
nsEventDispatcher::Dispatch(mCurrentEventContent, mPresContext,
|
|
|
|
aEvent, nsnull, aStatus, &eventCB);
|
2005-09-16 06:04:25 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
nsCOMPtr<nsIContent> targetContent;
|
|
|
|
rv = mCurrentEventFrame->GetContentForEvent(mPresContext, aEvent,
|
|
|
|
getter_AddRefs(targetContent));
|
|
|
|
if (NS_SUCCEEDED(rv) && targetContent) {
|
2006-03-07 17:08:51 +00:00
|
|
|
nsEventDispatcher::Dispatch(targetContent, mPresContext, aEvent,
|
|
|
|
nsnull, aStatus, &eventCB);
|
2006-12-01 11:09:53 +00:00
|
|
|
} else if (mDocument) {
|
|
|
|
nsEventDispatcher::Dispatch(mDocument, mPresContext, aEvent,
|
|
|
|
nsnull, aStatus, nsnull);
|
2005-09-16 06:04:25 +00:00
|
|
|
}
|
2002-11-09 00:25:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-03-07 17:08:51 +00:00
|
|
|
// 3. Give event to event manager for post event state changes and
|
2003-05-12 07:11:16 +00:00
|
|
|
// generation of synthetic events.
|
2007-11-20 22:30:27 +00:00
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
rv = manager->PostHandleEvent(mPresContext, aEvent,
|
2007-11-22 15:08:13 +00:00
|
|
|
GetCurrentEventFrame(), aStatus,
|
|
|
|
weakView.GetView());
|
2000-04-24 04:41:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2000-06-29 02:02:43 +00:00
|
|
|
// Dispatch event to content only (NOT full processing)
|
|
|
|
// See also HandleEventWithTarget which does full event processing.
|
|
|
|
NS_IMETHODIMP
|
2006-03-07 17:08:51 +00:00
|
|
|
PresShell::HandleDOMEventWithTarget(nsIContent* aTargetContent, nsEvent* aEvent,
|
|
|
|
nsEventStatus* aStatus)
|
2000-06-29 02:02:43 +00:00
|
|
|
{
|
|
|
|
PushCurrentEventInfo(nsnull, aTargetContent);
|
|
|
|
|
|
|
|
// Bug 41013: Check if the event should be dispatched to content.
|
|
|
|
// It's possible that we are in the middle of destroying the window
|
|
|
|
// and the js context is out of date. This check detects the case
|
|
|
|
// that caused a crash in bug 41013, but there may be a better way
|
|
|
|
// to handle this situation!
|
2004-02-01 10:09:07 +00:00
|
|
|
nsCOMPtr<nsISupports> container = mPresContext->GetContainer();
|
|
|
|
if (container) {
|
2000-06-29 02:02:43 +00:00
|
|
|
|
|
|
|
// Dispatch event to content
|
2006-03-07 17:08:51 +00:00
|
|
|
nsEventDispatcher::Dispatch(aTargetContent, mPresContext, aEvent, nsnull,
|
|
|
|
aStatus);
|
2000-06-29 02:02:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
PopCurrentEventInfo();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1998-12-18 15:54:23 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::ResizeReflow(nsIView *aView, nscoord aWidth, nscoord aHeight)
|
1998-08-28 02:54:06 +00:00
|
|
|
{
|
|
|
|
return ResizeReflow(aWidth, aHeight);
|
|
|
|
}
|
|
|
|
|
2004-10-14 21:51:00 +00:00
|
|
|
NS_IMETHODIMP_(PRBool)
|
|
|
|
PresShell::IsVisible()
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsISupports> container = mPresContext->GetContainer();
|
|
|
|
nsCOMPtr<nsIBaseWindow> bw = do_QueryInterface(container);
|
|
|
|
if (!bw)
|
|
|
|
return PR_FALSE;
|
|
|
|
PRBool res = PR_TRUE;
|
|
|
|
bw->GetVisibility(&res);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2005-01-20 03:39:09 +00:00
|
|
|
NS_IMETHODIMP_(void)
|
|
|
|
PresShell::WillPaint()
|
|
|
|
{
|
2005-02-25 04:03:13 +00:00
|
|
|
// Don't reenter reflow and don't reflow during frame construction. Also
|
|
|
|
// don't bother reflowing if some viewmanager in our tree is painting while
|
|
|
|
// we still have painting suppressed.
|
|
|
|
if (mIsReflowing || mChangeNestCount || mPaintingSuppressed) {
|
2005-01-20 03:39:09 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Process reflows, if we have them, to reduce flicker due to invalidates and
|
|
|
|
// reflow being interspersed. Note that we _do_ allow this to be
|
|
|
|
// interruptible; if we can't do all the reflows it's better to flicker a bit
|
|
|
|
// than to freeze up.
|
2007-08-22 02:57:06 +00:00
|
|
|
DoFlushPendingNotifications(Flush_Layout, PR_TRUE);
|
2005-01-20 03:39:09 +00:00
|
|
|
}
|
|
|
|
|
2004-01-07 22:30:53 +00:00
|
|
|
nsresult
|
|
|
|
PresShell::GetAgentStyleSheets(nsCOMArray<nsIStyleSheet>& aSheets)
|
|
|
|
{
|
|
|
|
aSheets.Clear();
|
|
|
|
PRInt32 sheetCount = mStyleSet->SheetCount(nsStyleSet::eAgentSheet);
|
|
|
|
|
|
|
|
for (PRInt32 i = 0; i < sheetCount; ++i) {
|
|
|
|
nsIStyleSheet *sheet = mStyleSet->StyleSheetAt(nsStyleSet::eAgentSheet, i);
|
|
|
|
if (!aSheets.AppendObject(sheet))
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
PresShell::SetAgentStyleSheets(const nsCOMArray<nsIStyleSheet>& aSheets)
|
|
|
|
{
|
|
|
|
return mStyleSet->ReplaceSheets(nsStyleSet::eAgentSheet, aSheets);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
PresShell::AddOverrideStyleSheet(nsIStyleSheet *aSheet)
|
|
|
|
{
|
2004-07-28 07:08:41 +00:00
|
|
|
return mStyleSet->PrependStyleSheet(nsStyleSet::eOverrideSheet, aSheet);
|
2004-01-07 22:30:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
PresShell::RemoveOverrideStyleSheet(nsIStyleSheet *aSheet)
|
|
|
|
{
|
|
|
|
return mStyleSet->RemoveStyleSheet(nsStyleSet::eOverrideSheet, aSheet);
|
|
|
|
}
|
|
|
|
|
2005-05-04 20:22:32 +00:00
|
|
|
static void
|
|
|
|
StopPluginInstance(PresShell *aShell, nsIContent *aContent)
|
|
|
|
{
|
2006-11-13 21:27:44 +00:00
|
|
|
nsIFrame *frame = aShell->FrameManager()->GetPrimaryFrameFor(aContent, -1);
|
2005-05-04 20:22:32 +00:00
|
|
|
|
|
|
|
nsIObjectFrame *objectFrame = nsnull;
|
|
|
|
if (frame)
|
|
|
|
CallQueryInterface(frame, &objectFrame);
|
|
|
|
if (!objectFrame)
|
|
|
|
return;
|
|
|
|
|
2005-11-01 11:37:25 +00:00
|
|
|
objectFrame->StopPlugin();
|
2005-05-04 20:22:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
PR_STATIC_CALLBACK(PRBool)
|
|
|
|
FreezeSubDocument(nsIDocument *aDocument, void *aData)
|
|
|
|
{
|
2007-05-01 22:24:20 +00:00
|
|
|
nsIPresShell *shell = aDocument->GetPrimaryShell();
|
2005-05-04 20:22:32 +00:00
|
|
|
if (shell)
|
|
|
|
shell->Freeze();
|
|
|
|
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
PresShell::Freeze()
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(mDocument);
|
|
|
|
if (domDoc) {
|
|
|
|
EnumeratePlugins(domDoc, NS_LITERAL_STRING("object"), StopPluginInstance);
|
|
|
|
EnumeratePlugins(domDoc, NS_LITERAL_STRING("applet"), StopPluginInstance);
|
|
|
|
EnumeratePlugins(domDoc, NS_LITERAL_STRING("embed"), StopPluginInstance);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mCaret)
|
|
|
|
mCaret->SetCaretVisible(PR_FALSE);
|
|
|
|
|
2005-07-01 07:12:02 +00:00
|
|
|
mPaintingSuppressed = PR_TRUE;
|
|
|
|
|
2005-05-04 20:22:32 +00:00
|
|
|
if (mDocument)
|
|
|
|
mDocument->EnumerateSubDocuments(FreezeSubDocument, nsnull);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
StartPluginInstance(PresShell *aShell, nsIContent *aContent)
|
|
|
|
{
|
2005-12-03 11:27:42 +00:00
|
|
|
nsCOMPtr<nsIObjectLoadingContent> objlc(do_QueryInterface(aContent));
|
2006-01-15 13:31:10 +00:00
|
|
|
if (!objlc)
|
|
|
|
return;
|
|
|
|
|
2005-12-03 11:27:42 +00:00
|
|
|
nsCOMPtr<nsIPluginInstance> inst;
|
|
|
|
objlc->EnsureInstantiation(getter_AddRefs(inst));
|
2005-05-04 20:22:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
PR_STATIC_CALLBACK(PRBool)
|
|
|
|
ThawSubDocument(nsIDocument *aDocument, void *aData)
|
|
|
|
{
|
2007-05-01 22:24:20 +00:00
|
|
|
nsIPresShell *shell = aDocument->GetPrimaryShell();
|
2005-05-04 20:22:32 +00:00
|
|
|
if (shell)
|
2005-07-19 17:07:40 +00:00
|
|
|
shell->Thaw();
|
2005-05-04 20:22:32 +00:00
|
|
|
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2005-07-19 17:07:40 +00:00
|
|
|
PresShell::Thaw()
|
2005-05-04 20:22:32 +00:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(mDocument);
|
|
|
|
if (domDoc) {
|
|
|
|
EnumeratePlugins(domDoc, NS_LITERAL_STRING("object"), StartPluginInstance);
|
|
|
|
EnumeratePlugins(domDoc, NS_LITERAL_STRING("applet"), StartPluginInstance);
|
|
|
|
EnumeratePlugins(domDoc, NS_LITERAL_STRING("embed"), StartPluginInstance);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mDocument)
|
|
|
|
mDocument->EnumerateSubDocuments(ThawSubDocument, nsnull);
|
2005-07-01 07:12:02 +00:00
|
|
|
|
2005-07-19 17:07:40 +00:00
|
|
|
UnsuppressPainting();
|
2005-05-04 20:22:32 +00:00
|
|
|
}
|
|
|
|
|
2000-04-17 07:13:57 +00:00
|
|
|
//--------------------------------------------------------
|
|
|
|
// Start of protected and private methods on the PresShell
|
|
|
|
//--------------------------------------------------------
|
|
|
|
|
|
|
|
//-------------- Begin Reflow Event Definition ------------------------
|
|
|
|
|
2006-05-10 17:30:15 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::ReflowEvent::Run() {
|
|
|
|
// Take an owning reference to the PresShell during this call to ensure
|
|
|
|
// that it doesn't get killed off prematurely.
|
|
|
|
nsRefPtr<PresShell> ps = mPresShell;
|
|
|
|
if (ps) {
|
2000-04-17 07:13:57 +00:00
|
|
|
#ifdef DEBUG
|
2006-05-10 17:30:15 +00:00
|
|
|
if (VERIFY_REFLOW_NOISY_RC & gVerifyReflowFlags) {
|
|
|
|
printf("\n*** Handling reflow event: PresShell=%p, event=%p\n", (void*)ps, (void*)this);
|
|
|
|
}
|
2000-04-17 07:13:57 +00:00
|
|
|
#endif
|
2006-05-10 17:30:15 +00:00
|
|
|
// NOTE: the ReflowEvent class is a friend of the PresShell class
|
|
|
|
ps->ClearReflowEventStatus();
|
2007-01-17 22:28:33 +00:00
|
|
|
// Set a kung fu death grip on the view manager associated with the pres shell
|
|
|
|
// before processing that pres shell's reflow commands. Fixes bug 54868.
|
|
|
|
nsCOMPtr<nsIViewManager> viewManager = ps->GetViewManager();
|
2007-08-22 02:57:06 +00:00
|
|
|
|
|
|
|
ps->DoFlushPendingNotifications(Flush_Layout, PR_TRUE);
|
2007-01-17 22:28:33 +00:00
|
|
|
|
|
|
|
// Now, explicitly release the pres shell before the view manager
|
|
|
|
ps = nsnull;
|
|
|
|
viewManager = nsnull;
|
2000-04-17 07:13:57 +00:00
|
|
|
}
|
2006-05-10 17:30:15 +00:00
|
|
|
return NS_OK;
|
2000-04-17 07:13:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//-------------- End Reflow Event Definition ---------------------------
|
|
|
|
|
|
|
|
void
|
|
|
|
PresShell::PostReflowEvent()
|
|
|
|
{
|
2006-05-10 17:30:15 +00:00
|
|
|
if (mReflowEvent.IsPending() || mIsDestroying || mIsReflowing ||
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
mDirtyRoots.Count() == 0)
|
2006-05-10 17:30:15 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
nsRefPtr<ReflowEvent> ev = new ReflowEvent(this);
|
|
|
|
if (NS_FAILED(NS_DispatchToCurrentThread(ev))) {
|
|
|
|
NS_WARNING("failed to dispatch reflow event");
|
|
|
|
} else {
|
|
|
|
mReflowEvent = ev;
|
2003-10-06 01:46:31 +00:00
|
|
|
#ifdef DEBUG
|
2006-05-10 17:30:15 +00:00
|
|
|
if (VERIFY_REFLOW_NOISY_RC & gVerifyReflowFlags) {
|
|
|
|
printf("\n*** PresShell::PostReflowEvent(), this=%p, event=%p\n", (void*)this, (void*)ev);
|
2003-10-06 01:46:31 +00:00
|
|
|
}
|
2006-05-10 17:30:15 +00:00
|
|
|
#endif
|
2000-04-17 07:13:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
PresShell::DidCauseReflow()
|
2001-09-19 07:08:15 +00:00
|
|
|
{
|
2005-01-20 03:39:09 +00:00
|
|
|
NS_ASSERTION(mChangeNestCount != 0, "Unexpected call to DidCauseReflow()");
|
|
|
|
if (--mChangeNestCount == 0) {
|
|
|
|
// We may have had more reflow commands appended to the queue during
|
|
|
|
// our reflow. Make sure these get processed at some point.
|
2007-10-19 03:51:15 +00:00
|
|
|
|
|
|
|
// XXXbz why is this really needed? ProcessReflowCommands handles posting
|
|
|
|
// reflow events if there are reflow roots remaining, and FrameNeedsReflow
|
|
|
|
// posts events as needed as well. I think we should remove this.
|
2006-04-19 15:08:44 +00:00
|
|
|
PostReflowEvent();
|
2000-05-16 01:11:29 +00:00
|
|
|
}
|
2000-09-12 00:35:11 +00:00
|
|
|
|
2008-03-14 23:08:57 +00:00
|
|
|
nsContentUtils::RemoveScriptBlocker();
|
|
|
|
|
2000-04-17 07:13:57 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2006-04-28 04:33:41 +00:00
|
|
|
void
|
|
|
|
PresShell::WillDoReflow()
|
|
|
|
{
|
|
|
|
// We just reflowed, tell the caret that its frame might have moved.
|
2007-10-02 04:37:36 +00:00
|
|
|
// XXXbz that comment makes no sense
|
2006-04-28 04:33:41 +00:00
|
|
|
if (mCaret) {
|
|
|
|
mCaret->InvalidateOutsideCaret();
|
2006-08-23 02:06:39 +00:00
|
|
|
mCaret->UpdateCaretPosition();
|
2006-04-28 04:33:41 +00:00
|
|
|
}
|
2007-10-02 04:37:36 +00:00
|
|
|
|
|
|
|
mFrameConstructor->BeginUpdate();
|
2006-04-28 04:33:41 +00:00
|
|
|
}
|
|
|
|
|
2004-02-04 00:11:59 +00:00
|
|
|
void
|
|
|
|
PresShell::DidDoReflow()
|
|
|
|
{
|
2007-10-02 04:37:36 +00:00
|
|
|
mFrameConstructor->EndUpdate();
|
|
|
|
|
2004-02-04 00:11:59 +00:00
|
|
|
HandlePostedReflowCallbacks();
|
2004-06-22 04:32:52 +00:00
|
|
|
// Null-check mViewManager in case this happens during Destroy. See
|
|
|
|
// bugs 244435 and 238546.
|
|
|
|
if (!mPaintingSuppressed && mViewManager)
|
|
|
|
mViewManager->SynthesizeMouseMove(PR_FALSE);
|
2006-08-23 02:06:39 +00:00
|
|
|
if (mCaret) {
|
|
|
|
// Update the caret's position now to account for any changes created by
|
|
|
|
// the reflow.
|
2006-04-28 04:33:41 +00:00
|
|
|
mCaret->InvalidateOutsideCaret();
|
2006-08-23 02:06:39 +00:00
|
|
|
mCaret->UpdateCaretPosition();
|
|
|
|
}
|
2004-02-04 00:11:59 +00:00
|
|
|
}
|
|
|
|
|
2007-04-25 15:49:55 +00:00
|
|
|
void
|
|
|
|
PresShell::DoReflow(nsIFrame* target)
|
|
|
|
{
|
|
|
|
nsIFrame* rootFrame = FrameManager()->GetRootFrame();
|
|
|
|
|
|
|
|
nsCOMPtr<nsIRenderingContext> rcx;
|
|
|
|
// Always create the rendering context relative to the root frame during
|
|
|
|
// reflow; otherwise, it crashes on the mac (I'm not quite sure why)
|
|
|
|
nsresult rv = CreateRenderingContext(rootFrame, getter_AddRefs(rcx));
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
NS_NOTREACHED("CreateRenderingContext failure");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
target->WillReflow(mPresContext);
|
|
|
|
|
|
|
|
// If the target frame is the root of the frame hierarchy, then
|
|
|
|
// use all the available space. If it's simply a `reflow root',
|
|
|
|
// then use the target frame's size as the available space.
|
|
|
|
nsSize size;
|
|
|
|
if (target == rootFrame)
|
|
|
|
size = mPresContext->GetVisibleArea().Size();
|
|
|
|
else
|
|
|
|
size = target->GetSize();
|
|
|
|
|
|
|
|
NS_ASSERTION(!target->GetNextInFlow() && !target->GetPrevInFlow(),
|
|
|
|
"reflow roots should never split");
|
|
|
|
|
|
|
|
// Don't pass size directly to the reflow state, since a
|
|
|
|
// constrained height implies page/column breaking.
|
|
|
|
// Exception: the root frame always uses a constrained reflow
|
|
|
|
nsSize reflowSize;
|
|
|
|
if (target != rootFrame)
|
|
|
|
reflowSize = nsSize(size.width, NS_UNCONSTRAINEDSIZE);
|
|
|
|
else
|
|
|
|
reflowSize = size;
|
|
|
|
nsHTMLReflowState reflowState(mPresContext, target, rcx, reflowSize);
|
|
|
|
|
|
|
|
// fix the computed height
|
|
|
|
NS_ASSERTION(reflowState.mComputedMargin == nsMargin(0, 0, 0, 0),
|
|
|
|
"reflow state should not set margin for reflow roots");
|
2007-05-01 17:15:08 +00:00
|
|
|
if (size.height != NS_UNCONSTRAINEDSIZE) {
|
2007-08-02 18:08:05 +00:00
|
|
|
nscoord computedHeight =
|
2007-05-01 17:15:08 +00:00
|
|
|
size.height - reflowState.mComputedBorderPadding.TopBottom();
|
2007-08-02 18:08:05 +00:00
|
|
|
computedHeight = PR_MAX(computedHeight, 0);
|
|
|
|
reflowState.SetComputedHeight(computedHeight);
|
2007-05-01 17:15:08 +00:00
|
|
|
}
|
2007-04-25 15:49:55 +00:00
|
|
|
NS_ASSERTION(reflowState.ComputedWidth() ==
|
|
|
|
size.width -
|
|
|
|
reflowState.mComputedBorderPadding.LeftRight(),
|
|
|
|
"reflow state computed incorrect width");
|
|
|
|
|
|
|
|
nsReflowStatus status;
|
|
|
|
nsHTMLReflowMetrics desiredSize;
|
|
|
|
target->Reflow(mPresContext, desiredSize, reflowState, status);
|
|
|
|
|
|
|
|
// If an incremental reflow is initiated at a frame other than the
|
2007-05-01 17:15:08 +00:00
|
|
|
// root frame, then its desired size had better not change! If it's
|
|
|
|
// initiated at the root, then the size better not change unless its
|
|
|
|
// height was unconstrained to start with.
|
|
|
|
NS_ASSERTION((target == rootFrame && size.height == NS_UNCONSTRAINEDSIZE) ||
|
2007-04-25 15:49:55 +00:00
|
|
|
(desiredSize.width == size.width &&
|
|
|
|
desiredSize.height == size.height),
|
|
|
|
"non-root frame's desired size changed during an "
|
|
|
|
"incremental reflow");
|
|
|
|
NS_ASSERTION(desiredSize.mOverflowArea ==
|
|
|
|
nsRect(nsPoint(0, 0),
|
|
|
|
nsSize(desiredSize.width, desiredSize.height)),
|
|
|
|
"reflow roots must not have visible overflow");
|
|
|
|
NS_ASSERTION(status == NS_FRAME_COMPLETE,
|
|
|
|
"reflow roots should never split");
|
|
|
|
|
|
|
|
target->SetSize(nsSize(desiredSize.width, desiredSize.height));
|
|
|
|
|
|
|
|
nsContainerFrame::SyncFrameViewAfterReflow(mPresContext, target,
|
|
|
|
target->GetView(),
|
|
|
|
&desiredSize.mOverflowArea);
|
|
|
|
|
|
|
|
target->DidReflow(mPresContext, nsnull, NS_FRAME_REFLOW_FINISHED);
|
2007-05-01 17:15:08 +00:00
|
|
|
if (target == rootFrame && size.height == NS_UNCONSTRAINEDSIZE) {
|
|
|
|
mPresContext->SetVisibleArea(nsRect(0, 0, desiredSize.width,
|
|
|
|
desiredSize.height));
|
|
|
|
}
|
2007-04-25 15:49:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
void
|
|
|
|
PresShell::DoVerifyReflow()
|
|
|
|
{
|
|
|
|
if (nsIFrameDebug::GetVerifyTreeEnable()) {
|
|
|
|
nsIFrameDebug* frameDebug;
|
|
|
|
nsIFrame* rootFrame = FrameManager()->GetRootFrame();
|
|
|
|
if (NS_SUCCEEDED(rootFrame->QueryInterface(NS_GET_IID(nsIFrameDebug),
|
|
|
|
(void**)&frameDebug))) {
|
|
|
|
frameDebug->VerifyTree();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (GetVerifyReflowEnable()) {
|
|
|
|
// First synchronously render what we have so far so that we can
|
|
|
|
// see it.
|
|
|
|
nsIView* rootView;
|
|
|
|
mViewManager->GetRootView(rootView);
|
|
|
|
mViewManager->UpdateView(rootView, NS_VMREFRESH_IMMEDIATE);
|
|
|
|
|
|
|
|
FlushPendingNotifications(Flush_Layout);
|
|
|
|
mInVerifyReflow = PR_TRUE;
|
|
|
|
PRBool ok = VerifyIncrementalReflow();
|
|
|
|
mInVerifyReflow = PR_FALSE;
|
|
|
|
if (VERIFY_REFLOW_ALL & gVerifyReflowFlags) {
|
|
|
|
printf("ProcessReflowCommands: finished (%s)\n",
|
|
|
|
ok ? "ok" : "failed");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (0 != mDirtyRoots.Count()) {
|
|
|
|
printf("XXX yikes! reflow commands queued during verify-reflow\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2000-04-17 07:13:57 +00:00
|
|
|
nsresult
|
|
|
|
PresShell::ProcessReflowCommands(PRBool aInterruptible)
|
|
|
|
{
|
|
|
|
MOZ_TIMER_DEBUGLOG(("Start: Reflow: PresShell::ProcessReflowCommands(), this=%p\n", this));
|
|
|
|
MOZ_TIMER_START(mReflowWatch);
|
|
|
|
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
if (0 != mDirtyRoots.Count()) {
|
2000-04-17 07:13:57 +00:00
|
|
|
|
|
|
|
#ifdef DEBUG
|
2007-04-25 15:49:55 +00:00
|
|
|
if (VERIFY_REFLOW_DUMP_COMMANDS & gVerifyReflowFlags) {
|
|
|
|
printf("ProcessReflowCommands: begin incremental reflow\n");
|
2000-04-17 07:13:57 +00:00
|
|
|
}
|
|
|
|
#endif
|
2002-05-10 18:22:41 +00:00
|
|
|
|
2006-04-28 04:33:41 +00:00
|
|
|
WillDoReflow();
|
|
|
|
|
2002-05-10 18:22:41 +00:00
|
|
|
// If reflow is interruptible, then make a note of our deadline.
|
2004-04-13 03:13:46 +00:00
|
|
|
const PRIntervalTime deadline = aInterruptible
|
|
|
|
? PR_IntervalNow() + PR_MicrosecondsToInterval(gMaxRCProcessingTime)
|
|
|
|
: (PRIntervalTime)0;
|
2002-05-10 18:22:41 +00:00
|
|
|
|
2007-09-21 02:47:19 +00:00
|
|
|
// Scope for the reflow entry point
|
|
|
|
{
|
2008-03-14 23:08:57 +00:00
|
|
|
nsAutoScriptBlocker scriptBlocker;
|
2006-04-18 21:48:12 +00:00
|
|
|
AUTO_LAYOUT_PHASE_ENTRY_POINT(GetPresContext(), Reflow);
|
|
|
|
mIsReflowing = PR_TRUE;
|
|
|
|
|
|
|
|
do {
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
// Send an incremental reflow notification to the target frame.
|
|
|
|
PRInt32 idx = mDirtyRoots.Count() - 1;
|
2007-07-08 07:08:04 +00:00
|
|
|
nsIFrame *target = static_cast<nsIFrame*>(mDirtyRoots[idx]);
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
mDirtyRoots.RemoveElementAt(idx);
|
|
|
|
|
2007-05-06 19:16:51 +00:00
|
|
|
if (!NS_SUBTREE_DIRTY(target)) {
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
// It's not dirty anymore, which probably means the notification
|
|
|
|
// was posted in the middle of a reflow (perhaps with a reflow
|
|
|
|
// root in the middle). Don't do anything.
|
|
|
|
continue;
|
2002-05-10 18:22:41 +00:00
|
|
|
}
|
|
|
|
|
2007-04-25 15:49:55 +00:00
|
|
|
DoReflow(target);
|
2002-05-10 18:22:41 +00:00
|
|
|
|
2006-04-18 21:48:12 +00:00
|
|
|
// Keep going until we're out of reflow commands, or we've run
|
|
|
|
// past our deadline.
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
} while (mDirtyRoots.Count() &&
|
2006-04-18 21:48:12 +00:00
|
|
|
(!aInterruptible || PR_IntervalNow() < deadline));
|
2002-05-10 18:22:41 +00:00
|
|
|
|
2006-04-18 21:48:12 +00:00
|
|
|
// XXXwaterson for interruptible reflow, examine the tree and
|
|
|
|
// re-enqueue any unflowed reflow targets.
|
2002-05-10 18:22:41 +00:00
|
|
|
|
2006-04-18 21:48:12 +00:00
|
|
|
mIsReflowing = PR_FALSE;
|
|
|
|
}
|
2002-05-10 18:22:41 +00:00
|
|
|
|
2008-03-14 23:08:57 +00:00
|
|
|
// Exiting the scriptblocker might have killed us
|
|
|
|
if (!mIsDestroying) {
|
|
|
|
DidDoReflow();
|
|
|
|
}
|
2007-04-25 15:49:55 +00:00
|
|
|
|
2007-09-20 23:28:26 +00:00
|
|
|
// DidDoReflow might have killed us
|
|
|
|
if (!mIsDestroying) {
|
2000-04-17 07:13:57 +00:00
|
|
|
#ifdef DEBUG
|
2007-09-20 23:28:26 +00:00
|
|
|
if (VERIFY_REFLOW_DUMP_COMMANDS & gVerifyReflowFlags) {
|
|
|
|
printf("\nPresShell::ProcessReflowCommands() finished: this=%p\n",
|
|
|
|
(void*)this);
|
|
|
|
}
|
|
|
|
DoVerifyReflow();
|
2000-04-17 07:13:57 +00:00
|
|
|
#endif
|
2001-05-30 19:28:37 +00:00
|
|
|
|
2007-09-20 23:28:26 +00:00
|
|
|
// If any new reflow commands were enqueued during the reflow, schedule
|
|
|
|
// another reflow event to process them. Note that we want to do this
|
|
|
|
// after DidDoReflow(), since that method can change whether there are
|
|
|
|
// dirty roots around by flushing, and there's no point in posting a
|
|
|
|
// reflow event just to have the flush revoke it.
|
|
|
|
if (mDirtyRoots.Count())
|
|
|
|
PostReflowEvent();
|
|
|
|
}
|
2000-04-17 07:13:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
MOZ_TIMER_DEBUGLOG(("Stop: Reflow: PresShell::ProcessReflowCommands(), this=%p\n", this));
|
|
|
|
MOZ_TIMER_STOP(mReflowWatch);
|
|
|
|
|
2007-09-20 23:28:26 +00:00
|
|
|
if (!mIsDestroying && mShouldUnsuppressPainting &&
|
|
|
|
mDirtyRoots.Count() == 0) {
|
2001-04-25 19:52:49 +00:00
|
|
|
// We only unlock if we're out of reflows. It's pointless
|
|
|
|
// to unlock if reflows are still pending, since reflows
|
|
|
|
// are just going to thrash the frames around some more. By
|
|
|
|
// waiting we avoid an overeager "jitter" effect.
|
|
|
|
mShouldUnsuppressPainting = PR_FALSE;
|
|
|
|
UnsuppressAndInvalidate();
|
|
|
|
}
|
|
|
|
|
2000-04-17 07:13:57 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2006-05-10 17:30:15 +00:00
|
|
|
void
|
2002-07-26 03:29:07 +00:00
|
|
|
PresShell::ClearReflowEventStatus()
|
2000-04-17 07:13:57 +00:00
|
|
|
{
|
2006-05-10 17:30:15 +00:00
|
|
|
mReflowEvent.Forget();
|
2000-04-17 07:13:57 +00:00
|
|
|
}
|
|
|
|
|
2004-07-18 01:16:27 +00:00
|
|
|
#ifdef MOZ_XUL
|
|
|
|
/*
|
|
|
|
* It's better to add stuff to the |DidSetStyleContext| method of the
|
|
|
|
* relevant frames than adding it here. These methods should (ideally,
|
|
|
|
* anyway) go away.
|
|
|
|
*/
|
|
|
|
|
|
|
|
// Return value says whether to walk children.
|
|
|
|
typedef PRBool (* PR_CALLBACK frameWalkerFn)(nsIFrame *aFrame, void *aClosure);
|
|
|
|
|
|
|
|
PR_STATIC_CALLBACK(PRBool)
|
|
|
|
ReResolveMenusAndTrees(nsIFrame *aFrame, void *aClosure)
|
|
|
|
{
|
|
|
|
// Trees have a special style cache that needs to be flushed when
|
|
|
|
// the theme changes.
|
|
|
|
nsCOMPtr<nsITreeBoxObject> treeBox(do_QueryInterface(aFrame));
|
|
|
|
if (treeBox)
|
|
|
|
treeBox->ClearStyleAndImageCaches();
|
|
|
|
|
|
|
|
// We deliberately don't re-resolve style on a menu's popup
|
|
|
|
// sub-content, since doing so slows menus to a crawl. That means we
|
|
|
|
// have to special-case them on a skin switch, and ensure that the
|
|
|
|
// popup frames just get destroyed completely.
|
2007-07-04 15:49:38 +00:00
|
|
|
if (aFrame && aFrame->GetType() == nsGkAtoms::menuFrame)
|
2007-07-08 07:08:04 +00:00
|
|
|
(static_cast<nsMenuFrame *>(aFrame))->CloseMenu(PR_TRUE);
|
2004-07-18 01:16:27 +00:00
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
|
2004-07-27 23:31:08 +00:00
|
|
|
PR_STATIC_CALLBACK(PRBool)
|
2004-12-02 01:26:20 +00:00
|
|
|
ReframeImageBoxes(nsIFrame *aFrame, void *aClosure)
|
|
|
|
{
|
2007-07-08 07:08:04 +00:00
|
|
|
nsStyleChangeList *list = static_cast<nsStyleChangeList*>(aClosure);
|
2006-12-26 17:47:52 +00:00
|
|
|
if (aFrame->GetType() == nsGkAtoms::imageBoxFrame) {
|
2004-12-02 01:26:20 +00:00
|
|
|
list->AppendChange(aFrame, aFrame->GetContent(),
|
|
|
|
NS_STYLE_HINT_FRAMECHANGE);
|
|
|
|
return PR_FALSE; // don't walk descendants
|
2004-07-27 23:31:08 +00:00
|
|
|
}
|
|
|
|
return PR_TRUE; // walk descendants
|
|
|
|
}
|
|
|
|
|
2004-07-18 01:16:27 +00:00
|
|
|
static void
|
2004-07-31 23:15:21 +00:00
|
|
|
WalkFramesThroughPlaceholders(nsPresContext *aPresContext, nsIFrame *aFrame,
|
2004-07-18 01:16:27 +00:00
|
|
|
frameWalkerFn aFunc, void *aClosure)
|
|
|
|
{
|
|
|
|
PRBool walkChildren = (*aFunc)(aFrame, aClosure);
|
|
|
|
if (!walkChildren)
|
|
|
|
return;
|
|
|
|
|
|
|
|
PRInt32 listIndex = 0;
|
|
|
|
nsIAtom* childList = nsnull;
|
|
|
|
|
|
|
|
do {
|
|
|
|
nsIFrame *child = aFrame->GetFirstChild(childList);
|
|
|
|
while (child) {
|
|
|
|
if (!(child->GetStateBits() & NS_FRAME_OUT_OF_FLOW)) {
|
2005-04-14 15:30:35 +00:00
|
|
|
// only do frames that are in flow, and recur through the
|
|
|
|
// out-of-flows of placeholders.
|
|
|
|
WalkFramesThroughPlaceholders(aPresContext,
|
|
|
|
nsPlaceholderFrame::GetRealFrameFor(child),
|
|
|
|
aFunc, aClosure);
|
2004-07-18 01:16:27 +00:00
|
|
|
}
|
|
|
|
child = child->GetNextSibling();
|
|
|
|
}
|
|
|
|
|
|
|
|
childList = aFrame->GetAdditionalChildListName(listIndex++);
|
|
|
|
} while (childList);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::Observe(nsISupports* aSubject,
|
|
|
|
const char* aTopic,
|
|
|
|
const PRUnichar* aData)
|
|
|
|
{
|
|
|
|
#ifdef MOZ_XUL
|
|
|
|
if (!nsCRT::strcmp(aTopic, "chrome-flush-skin-caches")) {
|
2004-09-02 03:08:51 +00:00
|
|
|
nsIFrame *rootFrame = FrameManager()->GetRootFrame();
|
2004-07-18 21:55:24 +00:00
|
|
|
// Need to null-check because "chrome-flush-skin-caches" can happen
|
|
|
|
// at interesting times during startup.
|
2004-07-27 23:31:08 +00:00
|
|
|
if (rootFrame) {
|
2004-10-09 01:39:21 +00:00
|
|
|
NS_ASSERTION(mViewManager, "View manager must exist");
|
2008-01-26 23:59:50 +00:00
|
|
|
nsIViewManager::UpdateViewBatch batch(mViewManager);
|
2004-10-09 01:39:21 +00:00
|
|
|
|
2004-07-18 21:55:24 +00:00
|
|
|
WalkFramesThroughPlaceholders(mPresContext, rootFrame,
|
|
|
|
&ReResolveMenusAndTrees, nsnull);
|
2004-07-27 23:31:08 +00:00
|
|
|
|
2004-12-02 01:26:20 +00:00
|
|
|
// Because "chrome:" URL equality is messy, reframe image box
|
|
|
|
// frames (hack!).
|
|
|
|
nsStyleChangeList changeList;
|
2004-07-27 23:31:08 +00:00
|
|
|
WalkFramesThroughPlaceholders(mPresContext, rootFrame,
|
2004-12-02 01:26:20 +00:00
|
|
|
ReframeImageBoxes, &changeList);
|
2007-10-19 03:51:15 +00:00
|
|
|
// Mark ourselves as not safe to flush while we're doing frame
|
|
|
|
// construction.
|
2008-03-14 23:08:57 +00:00
|
|
|
{
|
|
|
|
nsAutoScriptBlocker scriptBlocker;
|
|
|
|
++mChangeNestCount;
|
|
|
|
mFrameConstructor->ProcessRestyledFrames(changeList);
|
|
|
|
--mChangeNestCount;
|
|
|
|
}
|
2004-10-09 01:39:21 +00:00
|
|
|
|
2008-01-26 23:59:50 +00:00
|
|
|
batch.EndUpdateViewBatch(NS_VMREFRESH_NO_SYNC);
|
2005-06-10 13:57:27 +00:00
|
|
|
#ifdef ACCESSIBILITY
|
|
|
|
InvalidateAccessibleSubtree(nsnull);
|
|
|
|
#endif
|
2004-07-27 23:31:08 +00:00
|
|
|
}
|
2004-07-18 01:16:27 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-08-10 20:21:44 +00:00
|
|
|
if (!nsCRT::strcmp(aTopic, NS_LINK_VISITED_EVENT_TOPIC)) {
|
|
|
|
nsCOMPtr<nsIURI> uri = do_QueryInterface(aSubject);
|
|
|
|
if (uri && mDocument) {
|
|
|
|
mDocument->NotifyURIVisitednessChanged(uri);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2006-06-08 14:32:20 +00:00
|
|
|
if (!nsCRT::strcmp(aTopic, "agent-sheet-added") && mStyleSet) {
|
|
|
|
AddAgentSheet(aSubject);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!nsCRT::strcmp(aTopic, "user-sheet-added") && mStyleSet) {
|
|
|
|
AddUserSheet(aSubject);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!nsCRT::strcmp(aTopic, "agent-sheet-removed") && mStyleSet) {
|
|
|
|
RemoveSheet(nsStyleSet::eAgentSheet, aSubject);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!nsCRT::strcmp(aTopic, "user-sheet-removed") && mStyleSet) {
|
|
|
|
RemoveSheet(nsStyleSet::eUserSheet, aSubject);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2007-05-04 02:19:18 +00:00
|
|
|
#ifdef ACCESSIBILITY
|
|
|
|
if (!nsCRT::strcmp(aTopic, "a11y-init-or-shutdown")) {
|
|
|
|
gIsAccessibilityActive = aData && *aData == '1';
|
|
|
|
}
|
|
|
|
#endif
|
2004-07-18 01:16:27 +00:00
|
|
|
NS_WARNING("unrecognized topic in PresShell::Observe");
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2005-05-04 20:22:32 +00:00
|
|
|
void
|
|
|
|
PresShell::EnumeratePlugins(nsIDOMDocument *aDocument,
|
|
|
|
const nsString &aPluginTag,
|
|
|
|
nsPluginEnumCallback aCallback)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNodeList> nodes;
|
|
|
|
aDocument->GetElementsByTagName(aPluginTag, getter_AddRefs(nodes));
|
|
|
|
if (!nodes)
|
|
|
|
return;
|
|
|
|
|
|
|
|
PRUint32 length;
|
|
|
|
nodes->GetLength(&length);
|
|
|
|
|
|
|
|
for (PRUint32 i = 0; i < length; ++i) {
|
|
|
|
nsCOMPtr<nsIDOMNode> node;
|
|
|
|
nodes->Item(i, getter_AddRefs(node));
|
|
|
|
|
|
|
|
nsCOMPtr<nsIContent> content = do_QueryInterface(node);
|
|
|
|
if (content)
|
|
|
|
aCallback(this, content);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-04-17 07:13:57 +00:00
|
|
|
//------------------------------------------------------
|
|
|
|
// End of protected and private methods on the PresShell
|
|
|
|
//------------------------------------------------------
|
|
|
|
|
|
|
|
// Start of DEBUG only code
|
|
|
|
|
1998-07-13 19:49:42 +00:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
#include "nsViewsCID.h"
|
|
|
|
#include "nsWidgetsCID.h"
|
|
|
|
#include "nsIDeviceContext.h"
|
|
|
|
#include "nsIURL.h"
|
1999-04-03 21:54:32 +00:00
|
|
|
#include "nsILinkHandler.h"
|
1998-07-13 19:49:42 +00:00
|
|
|
|
2000-01-04 20:24:09 +00:00
|
|
|
static NS_DEFINE_CID(kViewManagerCID, NS_VIEW_MANAGER_CID);
|
|
|
|
static NS_DEFINE_CID(kWidgetCID, NS_CHILD_CID);
|
1998-07-13 19:49:42 +00:00
|
|
|
|
|
|
|
static void
|
1998-11-25 18:41:02 +00:00
|
|
|
LogVerifyMessage(nsIFrame* k1, nsIFrame* k2, const char* aMsg)
|
|
|
|
{
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("verifyreflow: ");
|
1998-11-25 18:41:02 +00:00
|
|
|
nsAutoString name;
|
|
|
|
if (nsnull != k1) {
|
1999-11-01 22:12:45 +00:00
|
|
|
nsIFrameDebug* frameDebug;
|
|
|
|
|
2000-01-04 20:24:09 +00:00
|
|
|
if (NS_SUCCEEDED(k1->QueryInterface(NS_GET_IID(nsIFrameDebug),
|
|
|
|
(void**)&frameDebug))) {
|
1999-11-01 22:12:45 +00:00
|
|
|
frameDebug->GetFrameName(name);
|
|
|
|
}
|
1998-11-25 18:41:02 +00:00
|
|
|
}
|
|
|
|
else {
|
2001-10-11 01:30:52 +00:00
|
|
|
name.Assign(NS_LITERAL_STRING("(null)"));
|
1998-11-25 18:41:02 +00:00
|
|
|
}
|
2006-02-03 14:18:39 +00:00
|
|
|
fputs(NS_LossyConvertUTF16toASCII(name).get(), stdout);
|
2000-10-28 22:17:53 +00:00
|
|
|
|
2007-04-25 15:49:55 +00:00
|
|
|
fprintf(stdout, " %p ", (void*)k1);
|
|
|
|
|
2000-10-28 22:17:53 +00:00
|
|
|
printf(" != ");
|
1998-11-25 18:41:02 +00:00
|
|
|
|
|
|
|
if (nsnull != k2) {
|
1999-11-01 22:12:45 +00:00
|
|
|
nsIFrameDebug* frameDebug;
|
|
|
|
|
2000-01-04 20:24:09 +00:00
|
|
|
if (NS_SUCCEEDED(k2->QueryInterface(NS_GET_IID(nsIFrameDebug),
|
|
|
|
(void**)&frameDebug))) {
|
1999-11-01 22:12:45 +00:00
|
|
|
frameDebug->GetFrameName(name);
|
|
|
|
}
|
1998-11-25 18:41:02 +00:00
|
|
|
}
|
|
|
|
else {
|
2001-10-11 01:30:52 +00:00
|
|
|
name.Assign(NS_LITERAL_STRING("(null)"));
|
1998-11-25 18:41:02 +00:00
|
|
|
}
|
2006-02-03 14:18:39 +00:00
|
|
|
fputs(NS_LossyConvertUTF16toASCII(name).get(), stdout);
|
1998-11-25 18:41:02 +00:00
|
|
|
|
2007-04-25 15:49:55 +00:00
|
|
|
fprintf(stdout, " %p ", (void*)k2);
|
|
|
|
|
2000-10-28 22:17:53 +00:00
|
|
|
printf(" %s", aMsg);
|
1998-11-25 18:41:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
LogVerifyMessage(nsIFrame* k1, nsIFrame* k2, const char* aMsg,
|
|
|
|
const nsRect& r1, const nsRect& r2)
|
1998-07-13 19:49:42 +00:00
|
|
|
{
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("VerifyReflow Error:\n");
|
1998-11-19 17:22:29 +00:00
|
|
|
nsAutoString name;
|
1999-11-01 22:12:45 +00:00
|
|
|
nsIFrameDebug* frameDebug;
|
|
|
|
|
2000-01-04 20:24:09 +00:00
|
|
|
if (NS_SUCCEEDED(k1->QueryInterface(NS_GET_IID(nsIFrameDebug),
|
|
|
|
(void**)&frameDebug))) {
|
2000-10-28 22:17:53 +00:00
|
|
|
fprintf(stdout, " ");
|
1999-11-01 22:12:45 +00:00
|
|
|
frameDebug->GetFrameName(name);
|
2006-02-03 14:18:39 +00:00
|
|
|
fputs(NS_LossyConvertUTF16toASCII(name).get(), stdout);
|
2001-04-18 06:06:31 +00:00
|
|
|
fprintf(stdout, " %p ", (void*)k1);
|
1999-11-01 22:12:45 +00:00
|
|
|
}
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("{%d, %d, %d, %d}", r1.x, r1.y, r1.width, r1.height);
|
1998-11-25 18:41:02 +00:00
|
|
|
|
2000-10-28 22:17:53 +00:00
|
|
|
printf(" != \n");
|
1998-11-25 18:41:02 +00:00
|
|
|
|
2000-01-04 20:24:09 +00:00
|
|
|
if (NS_SUCCEEDED(k2->QueryInterface(NS_GET_IID(nsIFrameDebug),
|
|
|
|
(void**)&frameDebug))) {
|
2000-10-28 22:17:53 +00:00
|
|
|
fprintf(stdout, " ");
|
1999-11-01 22:12:45 +00:00
|
|
|
frameDebug->GetFrameName(name);
|
2006-02-03 14:18:39 +00:00
|
|
|
fputs(NS_LossyConvertUTF16toASCII(name).get(), stdout);
|
2001-04-18 06:06:31 +00:00
|
|
|
fprintf(stdout, " %p ", (void*)k2);
|
1999-11-01 22:12:45 +00:00
|
|
|
}
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("{%d, %d, %d, %d}\n", r2.x, r2.y, r2.width, r2.height);
|
1998-11-25 18:41:02 +00:00
|
|
|
|
2000-10-28 22:17:53 +00:00
|
|
|
printf(" %s\n", aMsg);
|
1998-07-13 19:49:42 +00:00
|
|
|
}
|
1998-04-13 20:24:54 +00:00
|
|
|
|
1999-04-03 18:58:04 +00:00
|
|
|
static PRBool
|
2004-07-31 23:15:21 +00:00
|
|
|
CompareTrees(nsPresContext* aFirstPresContext, nsIFrame* aFirstFrame,
|
|
|
|
nsPresContext* aSecondPresContext, nsIFrame* aSecondFrame)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2000-03-22 23:19:10 +00:00
|
|
|
if (!aFirstPresContext || !aFirstFrame || !aSecondPresContext || !aSecondFrame)
|
|
|
|
return PR_TRUE;
|
2007-05-23 00:11:05 +00:00
|
|
|
// XXX Evil hack to reduce false positives; I can't seem to figure
|
|
|
|
// out how to flush scrollbar changes correctly
|
|
|
|
//if (aFirstFrame->GetType() == nsGkAtoms::scrollbarFrame)
|
|
|
|
// return PR_TRUE;
|
1999-04-03 18:58:04 +00:00
|
|
|
PRBool ok = PR_TRUE;
|
1998-11-25 18:41:02 +00:00
|
|
|
nsIAtom* listName = nsnull;
|
|
|
|
PRInt32 listIndex = 0;
|
|
|
|
do {
|
2004-01-09 14:20:53 +00:00
|
|
|
nsIFrame* k1 = aFirstFrame->GetFirstChild(listName);
|
|
|
|
nsIFrame* k2 = aSecondFrame->GetFirstChild(listName);
|
1998-11-25 18:41:02 +00:00
|
|
|
PRInt32 l1 = nsContainerFrame::LengthOf(k1);
|
|
|
|
PRInt32 l2 = nsContainerFrame::LengthOf(k2);
|
|
|
|
if (l1 != l2) {
|
1999-04-03 18:58:04 +00:00
|
|
|
ok = PR_FALSE;
|
1998-11-25 18:41:02 +00:00
|
|
|
LogVerifyMessage(k1, k2, "child counts don't match: ");
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("%d != %d\n", l1, l2);
|
1999-09-10 18:49:23 +00:00
|
|
|
if (0 == (VERIFY_REFLOW_ALL & gVerifyReflowFlags)) {
|
1998-11-25 18:41:02 +00:00
|
|
|
break;
|
1998-07-13 19:49:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1998-11-25 18:41:02 +00:00
|
|
|
nsRect r1, r2;
|
|
|
|
nsIView* v1, *v2;
|
|
|
|
for (;;) {
|
|
|
|
if (((nsnull == k1) && (nsnull != k2)) ||
|
|
|
|
((nsnull != k1) && (nsnull == k2))) {
|
1999-04-03 18:58:04 +00:00
|
|
|
ok = PR_FALSE;
|
1998-11-25 18:41:02 +00:00
|
|
|
LogVerifyMessage(k1, k2, "child lists are different\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else if (nsnull != k1) {
|
|
|
|
// Verify that the frames are the same size
|
2003-06-30 10:46:59 +00:00
|
|
|
if (k1->GetRect() != k2->GetRect()) {
|
1999-04-03 18:58:04 +00:00
|
|
|
ok = PR_FALSE;
|
2003-06-30 10:46:59 +00:00
|
|
|
LogVerifyMessage(k1, k2, "(frame rects)", k1->GetRect(), k2->GetRect());
|
1998-11-25 18:41:02 +00:00
|
|
|
}
|
1998-07-13 19:49:42 +00:00
|
|
|
|
1998-11-25 18:41:02 +00:00
|
|
|
// Make sure either both have views or neither have views; if they
|
|
|
|
// do have views, make sure the views are the same size. If the
|
|
|
|
// views have widgets, make sure they both do or neither does. If
|
|
|
|
// they do, make sure the widgets are the same size.
|
2003-06-30 10:46:59 +00:00
|
|
|
v1 = k1->GetView();
|
|
|
|
v2 = k2->GetView();
|
1998-11-25 18:41:02 +00:00
|
|
|
if (((nsnull == v1) && (nsnull != v2)) ||
|
|
|
|
((nsnull != v1) && (nsnull == v2))) {
|
1999-04-03 18:58:04 +00:00
|
|
|
ok = PR_FALSE;
|
1998-11-25 18:41:02 +00:00
|
|
|
LogVerifyMessage(k1, k2, "child views are not matched\n");
|
|
|
|
}
|
|
|
|
else if (nsnull != v1) {
|
2003-06-30 10:46:59 +00:00
|
|
|
if (v1->GetBounds() != v2->GetBounds()) {
|
|
|
|
LogVerifyMessage(k1, k2, "(view rects)", v1->GetBounds(), v2->GetBounds());
|
1998-11-25 18:41:02 +00:00
|
|
|
}
|
1998-07-13 19:49:42 +00:00
|
|
|
|
2003-06-30 10:46:59 +00:00
|
|
|
nsIWidget* w1 = v1->GetWidget();
|
|
|
|
nsIWidget* w2 = v2->GetWidget();
|
1998-11-25 18:41:02 +00:00
|
|
|
if (((nsnull == w1) && (nsnull != w2)) ||
|
|
|
|
((nsnull != w1) && (nsnull == w2))) {
|
1999-04-03 18:58:04 +00:00
|
|
|
ok = PR_FALSE;
|
1998-11-25 18:41:02 +00:00
|
|
|
LogVerifyMessage(k1, k2, "child widgets are not matched\n");
|
|
|
|
}
|
|
|
|
else if (nsnull != w1) {
|
|
|
|
w1->GetBounds(r1);
|
|
|
|
w2->GetBounds(r2);
|
|
|
|
if (r1 != r2) {
|
|
|
|
LogVerifyMessage(k1, k2, "(widget rects)", r1, r2);
|
|
|
|
}
|
1998-07-13 19:49:42 +00:00
|
|
|
}
|
|
|
|
}
|
1999-09-10 18:49:23 +00:00
|
|
|
if (!ok && (0 == (VERIFY_REFLOW_ALL & gVerifyReflowFlags))) {
|
1998-11-25 18:41:02 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2000-03-22 23:19:10 +00:00
|
|
|
// verify that neither frame has a space manager,
|
|
|
|
// or they both do and the space managers are equivalent
|
2007-07-08 07:08:04 +00:00
|
|
|
nsSpaceManager *sm1 = static_cast<nsSpaceManager*>
|
|
|
|
(k1->GetProperty(nsGkAtoms::spaceManagerProperty));
|
2004-02-23 21:29:06 +00:00
|
|
|
|
2000-03-22 23:19:10 +00:00
|
|
|
// look at the test frame
|
2007-07-08 07:08:04 +00:00
|
|
|
nsSpaceManager *sm2 = static_cast<nsSpaceManager*>
|
|
|
|
(k2->GetProperty(nsGkAtoms::spaceManagerProperty));
|
2004-02-23 21:29:06 +00:00
|
|
|
|
2000-03-22 23:19:10 +00:00
|
|
|
// now compare the space managers
|
|
|
|
if (((nsnull == sm1) && (nsnull != sm2)) ||
|
|
|
|
((nsnull != sm1) && (nsnull == sm2))) { // one is null, and the other is not
|
|
|
|
ok = PR_FALSE;
|
|
|
|
LogVerifyMessage(k1, k2, "space managers are not matched\n");
|
|
|
|
}
|
|
|
|
else if (sm1 && sm2) { // both are not null, compare them
|
|
|
|
// first, compare yMost
|
|
|
|
nscoord yMost1, yMost2;
|
|
|
|
nsresult smresult = sm1->YMost(yMost1);
|
|
|
|
if (NS_ERROR_ABORT != smresult)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(smresult), "bad result");
|
|
|
|
smresult = sm2->YMost(yMost2);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(smresult), "bad result");
|
|
|
|
if (yMost1 != yMost2) {
|
|
|
|
LogVerifyMessage(k1, k2, "yMost of space managers differs\n");
|
|
|
|
}
|
|
|
|
// now compare bands by sampling
|
|
|
|
PRInt32 yIncrement = yMost1/100;
|
|
|
|
if (0==yIncrement) {
|
|
|
|
yIncrement = 1; // guarantee we make progress in the loop below
|
|
|
|
}
|
|
|
|
nscoord yOffset = 0;
|
|
|
|
for ( ; ok && yOffset < yMost1; yOffset += yIncrement)
|
|
|
|
{
|
|
|
|
nscoord small=5, large=100;
|
|
|
|
nsBandData band1, band2;
|
|
|
|
nsBandTrapezoid trap1[20], trap2[20];
|
|
|
|
band1.mSize = band2.mSize = 20;
|
|
|
|
band1.mTrapezoids = trap1;
|
|
|
|
band2.mTrapezoids = trap2;
|
|
|
|
sm1->GetBandData(yOffset, nsSize(small,small), band1);
|
|
|
|
sm2->GetBandData(yOffset, nsSize(small,small), band2);
|
|
|
|
if (band1.mCount != band2.mCount)
|
|
|
|
{ // count mismatch, stop comparing
|
|
|
|
LogVerifyMessage(k1, k2, "band.mCount of space managers differs\n");
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("count1= %d, count2=%d, yOffset = %d, size=%d\n",
|
|
|
|
band1.mCount, band2.mCount, yOffset, small);
|
2000-03-22 23:19:10 +00:00
|
|
|
ok = PR_FALSE;
|
|
|
|
|
|
|
|
}
|
|
|
|
else // band counts match, compare individual traps
|
|
|
|
{
|
|
|
|
PRInt32 trapIndex=0;
|
|
|
|
for ( ;trapIndex<band1.mCount; trapIndex++)
|
|
|
|
{
|
|
|
|
PRBool match = (trap1[trapIndex].EqualGeometry(trap2[trapIndex])) &&
|
2007-08-30 15:29:06 +00:00
|
|
|
((trap1[trapIndex].mFrames!=nsnull) == (trap2[trapIndex].mFrames!=nsnull));
|
2000-03-22 23:19:10 +00:00
|
|
|
if (!match)
|
|
|
|
{
|
|
|
|
LogVerifyMessage(k1, k2, "band.mTrapezoids of space managers differs\n");
|
2000-10-28 22:17:53 +00:00
|
|
|
printf ("index %d\n", trapIndex);
|
2000-03-22 23:19:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// test the larger maxSize
|
|
|
|
sm1->GetBandData(yOffset, nsSize(large,large), band1);
|
|
|
|
sm2->GetBandData(yOffset, nsSize(large,large), band2);
|
|
|
|
if (band1.mCount != band2.mCount)
|
|
|
|
{ // count mismatch, stop comparing
|
|
|
|
LogVerifyMessage(k1, k2, "band.mCount of space managers differs\n");
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("count1= %d, count2=%d, yOffset = %d, size=%d\n",
|
2000-03-22 23:19:10 +00:00
|
|
|
band1.mCount, band2.mCount, yOffset, small);
|
|
|
|
ok = PR_FALSE;
|
|
|
|
|
|
|
|
}
|
|
|
|
else // band counts match, compare individual traps
|
|
|
|
{
|
|
|
|
PRInt32 trapIndex=0;
|
|
|
|
for ( ; trapIndex<band1.mCount; trapIndex++)
|
|
|
|
{
|
|
|
|
PRBool match = (trap1[trapIndex].EqualGeometry(trap2[trapIndex])) &&
|
2007-08-30 15:29:06 +00:00
|
|
|
((trap1[trapIndex].mFrames!=nsnull) == (trap2[trapIndex].mFrames!=nsnull));
|
2000-03-22 23:19:10 +00:00
|
|
|
if (!match)
|
|
|
|
{
|
|
|
|
LogVerifyMessage(k1, k2, "band.mTrapezoids of space managers differs\n");
|
2000-10-28 22:17:53 +00:00
|
|
|
printf ("index %d\n", trapIndex);
|
2000-03-22 23:19:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
1998-11-25 18:41:02 +00:00
|
|
|
// Compare the sub-trees too
|
2000-03-17 01:50:54 +00:00
|
|
|
if (!CompareTrees(aFirstPresContext, k1, aSecondPresContext, k2)) {
|
1999-09-10 18:49:23 +00:00
|
|
|
ok = PR_FALSE;
|
|
|
|
if (0 == (VERIFY_REFLOW_ALL & gVerifyReflowFlags)) {
|
1999-04-03 18:58:04 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
1998-11-25 18:41:02 +00:00
|
|
|
|
|
|
|
// Advance to next sibling
|
2003-06-30 10:46:59 +00:00
|
|
|
k1 = k1->GetNextSibling();
|
|
|
|
k2 = k2->GetNextSibling();
|
1998-07-13 19:49:42 +00:00
|
|
|
}
|
|
|
|
else {
|
1998-11-25 18:41:02 +00:00
|
|
|
break;
|
1998-07-13 19:49:42 +00:00
|
|
|
}
|
|
|
|
}
|
1999-09-10 18:49:23 +00:00
|
|
|
if (!ok && (0 == (VERIFY_REFLOW_ALL & gVerifyReflowFlags))) {
|
1998-11-25 18:41:02 +00:00
|
|
|
break;
|
1998-07-13 19:49:42 +00:00
|
|
|
}
|
1998-11-25 18:41:02 +00:00
|
|
|
|
2004-01-09 14:20:53 +00:00
|
|
|
nsIAtom* listName1 = aFirstFrame->GetAdditionalChildListName(listIndex);
|
|
|
|
nsIAtom* listName2 = aSecondFrame->GetAdditionalChildListName(listIndex);
|
1998-11-25 18:41:02 +00:00
|
|
|
listIndex++;
|
|
|
|
if (listName1 != listName2) {
|
1999-09-10 18:49:23 +00:00
|
|
|
if (0 == (VERIFY_REFLOW_ALL & gVerifyReflowFlags)) {
|
|
|
|
ok = PR_FALSE;
|
|
|
|
}
|
1998-11-25 18:41:02 +00:00
|
|
|
LogVerifyMessage(k1, k2, "child list names are not matched: ");
|
|
|
|
nsAutoString tmp;
|
|
|
|
if (nsnull != listName1) {
|
|
|
|
listName1->ToString(tmp);
|
2006-02-03 14:18:39 +00:00
|
|
|
fputs(NS_LossyConvertUTF16toASCII(tmp).get(), stdout);
|
1998-11-25 18:41:02 +00:00
|
|
|
}
|
|
|
|
else
|
2000-10-28 22:17:53 +00:00
|
|
|
fputs("(null)", stdout);
|
|
|
|
printf(" != ");
|
1998-11-25 18:41:02 +00:00
|
|
|
if (nsnull != listName2) {
|
|
|
|
listName2->ToString(tmp);
|
2006-02-03 14:18:39 +00:00
|
|
|
fputs(NS_LossyConvertUTF16toASCII(tmp).get(), stdout);
|
1998-11-25 18:41:02 +00:00
|
|
|
}
|
|
|
|
else
|
2000-10-28 22:17:53 +00:00
|
|
|
fputs("(null)", stdout);
|
|
|
|
printf("\n");
|
1998-11-25 18:41:02 +00:00
|
|
|
break;
|
1998-07-13 19:49:42 +00:00
|
|
|
}
|
1998-11-25 18:41:02 +00:00
|
|
|
listName = listName1;
|
1999-04-03 18:58:04 +00:00
|
|
|
} while (ok && (listName != nsnull));
|
|
|
|
|
|
|
|
return ok;
|
|
|
|
}
|
1999-11-01 22:12:45 +00:00
|
|
|
#endif
|
1999-04-03 18:58:04 +00:00
|
|
|
|
|
|
|
#if 0
|
|
|
|
static nsIFrame*
|
|
|
|
FindTopFrame(nsIFrame* aRoot)
|
|
|
|
{
|
2003-06-30 10:46:59 +00:00
|
|
|
if (aRoot) {
|
|
|
|
nsIContent* content = aRoot->GetContent();
|
|
|
|
if (content) {
|
1999-04-03 18:58:04 +00:00
|
|
|
nsIAtom* tag;
|
|
|
|
content->GetTag(tag);
|
|
|
|
if (nsnull != tag) {
|
|
|
|
NS_RELEASE(tag);
|
|
|
|
return aRoot;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Try one of the children
|
2004-01-09 14:20:53 +00:00
|
|
|
nsIFrame* kid = aRoot->GetFirstChild(nsnull);
|
1999-04-03 18:58:04 +00:00
|
|
|
while (nsnull != kid) {
|
|
|
|
nsIFrame* result = FindTopFrame(kid);
|
|
|
|
if (nsnull != result) {
|
|
|
|
return result;
|
|
|
|
}
|
2003-06-30 10:46:59 +00:00
|
|
|
kid = kid->GetNextSibling();
|
1999-04-03 18:58:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1998-07-13 19:49:42 +00:00
|
|
|
|
1999-11-01 22:12:45 +00:00
|
|
|
#ifdef DEBUG
|
2004-01-07 22:30:53 +00:00
|
|
|
|
|
|
|
nsresult
|
|
|
|
PresShell::CloneStyleSet(nsStyleSet* aSet, nsStyleSet** aResult)
|
|
|
|
{
|
|
|
|
nsStyleSet *clone = new nsStyleSet();
|
|
|
|
if (!clone) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRInt32 i, n = aSet->SheetCount(nsStyleSet::eOverrideSheet);
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
nsIStyleSheet* ss = aSet->StyleSheetAt(nsStyleSet::eOverrideSheet, i);
|
|
|
|
if (ss)
|
|
|
|
clone->AppendStyleSheet(nsStyleSet::eOverrideSheet, ss);
|
|
|
|
}
|
|
|
|
|
2007-05-23 00:11:05 +00:00
|
|
|
// The document expects to insert document stylesheets itself
|
|
|
|
#if 0
|
2004-01-07 22:30:53 +00:00
|
|
|
n = aSet->SheetCount(nsStyleSet::eDocSheet);
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
nsIStyleSheet* ss = aSet->StyleSheetAt(nsStyleSet::eDocSheet, i);
|
|
|
|
if (ss)
|
|
|
|
clone->AddDocStyleSheet(ss, mDocument);
|
|
|
|
}
|
2007-05-23 00:11:05 +00:00
|
|
|
#endif
|
|
|
|
|
2004-01-07 22:30:53 +00:00
|
|
|
n = aSet->SheetCount(nsStyleSet::eUserSheet);
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
nsIStyleSheet* ss = aSet->StyleSheetAt(nsStyleSet::eUserSheet, i);
|
|
|
|
if (ss)
|
|
|
|
clone->AppendStyleSheet(nsStyleSet::eUserSheet, ss);
|
|
|
|
}
|
|
|
|
|
|
|
|
n = aSet->SheetCount(nsStyleSet::eAgentSheet);
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
nsIStyleSheet* ss = aSet->StyleSheetAt(nsStyleSet::eAgentSheet, i);
|
|
|
|
if (ss)
|
|
|
|
clone->AppendStyleSheet(nsStyleSet::eAgentSheet, ss);
|
|
|
|
}
|
|
|
|
*aResult = clone;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2007-05-23 00:11:05 +00:00
|
|
|
#ifdef DEBUG_Eli
|
|
|
|
static nsresult
|
|
|
|
DumpToPNG(nsIPresShell* shell, nsAString& name) {
|
|
|
|
PRInt32 width=1000, height=1000;
|
|
|
|
nsRect r(0, 0, shell->GetPresContext()->DevPixelsToAppUnits(width),
|
|
|
|
shell->GetPresContext()->DevPixelsToAppUnits(height));
|
|
|
|
|
|
|
|
nsRefPtr<gfxImageSurface> imgSurface =
|
|
|
|
new gfxImageSurface(gfxIntSize(width, height),
|
|
|
|
gfxImageSurface::ImageFormatARGB32);
|
|
|
|
NS_ENSURE_TRUE(imgSurface, NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
|
|
|
|
nsRefPtr<gfxContext> imgContext = new gfxContext(imgSurface);
|
|
|
|
|
|
|
|
nsRefPtr<gfxASurface> surface =
|
|
|
|
gfxPlatform::GetPlatform()->
|
|
|
|
CreateOffscreenSurface(gfxIntSize(width, height),
|
|
|
|
gfxASurface::ImageFormatARGB32);
|
|
|
|
NS_ENSURE_TRUE(surface, NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
|
|
|
|
nsRefPtr<gfxContext> context = new gfxContext(surface);
|
|
|
|
NS_ENSURE_TRUE(context, NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
|
|
|
|
nsresult rv = shell->RenderDocument(r, PR_FALSE, PR_FALSE,
|
|
|
|
NS_RGB(255, 255, 0), context);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
imgContext->DrawSurface(surface, gfxSize(width, height));
|
|
|
|
|
|
|
|
nsCOMPtr<imgIEncoder> encoder = do_CreateInstance("@mozilla.org/image/encoder;2?type=image/png");
|
|
|
|
NS_ENSURE_TRUE(encoder, NS_ERROR_FAILURE);
|
|
|
|
encoder->InitFromData(imgSurface->Data(), imgSurface->Stride() * height,
|
|
|
|
width, height, imgSurface->Stride(),
|
|
|
|
imgIEncoder::INPUT_FORMAT_HOSTARGB, EmptyString());
|
|
|
|
|
|
|
|
// XXX not sure if this is the right way to write to a file
|
|
|
|
nsCOMPtr<nsILocalFile> file = do_CreateInstance("@mozilla.org/file/local;1");
|
|
|
|
NS_ENSURE_TRUE(file, NS_ERROR_FAILURE);
|
|
|
|
rv = file->InitWithPath(name);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
PRUint32 length;
|
|
|
|
encoder->Available(&length);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIOutputStream> outputStream;
|
|
|
|
rv = NS_NewLocalFileOutputStream(getter_AddRefs(outputStream), file);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIOutputStream> bufferedOutputStream;
|
|
|
|
rv = NS_NewBufferedOutputStream(getter_AddRefs(bufferedOutputStream),
|
|
|
|
outputStream, length);
|
|
|
|
|
|
|
|
PRUint32 numWritten;
|
|
|
|
rv = bufferedOutputStream->WriteFrom(encoder, length, &numWritten);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1998-07-13 19:49:42 +00:00
|
|
|
// After an incremental reflow, we verify the correctness by doing a
|
|
|
|
// full reflow into a fresh frame tree.
|
1999-09-10 18:49:23 +00:00
|
|
|
PRBool
|
1998-07-13 19:49:42 +00:00
|
|
|
PresShell::VerifyIncrementalReflow()
|
|
|
|
{
|
2000-04-17 14:40:46 +00:00
|
|
|
if (VERIFY_REFLOW_NOISY & gVerifyReflowFlags) {
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("Building Verification Tree...\n");
|
2000-04-17 14:40:46 +00:00
|
|
|
}
|
1998-07-13 19:49:42 +00:00
|
|
|
|
|
|
|
// Create a presentation context to view the new frame tree
|
2007-04-25 15:49:55 +00:00
|
|
|
nsCOMPtr<nsPresContext> cx =
|
|
|
|
new nsPresContext(mDocument, mPresContext->IsPaginated() ?
|
|
|
|
nsPresContext::eContext_PrintPreview :
|
|
|
|
nsPresContext::eContext_Galley);
|
|
|
|
NS_ENSURE_TRUE(cx, PR_FALSE);
|
2000-04-17 07:13:57 +00:00
|
|
|
|
2004-02-02 22:17:21 +00:00
|
|
|
nsIDeviceContext *dc = mPresContext->DeviceContext();
|
2004-07-29 19:41:39 +00:00
|
|
|
nsresult rv = cx->Init(dc);
|
2007-04-25 15:49:55 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, PR_FALSE);
|
1998-07-13 19:49:42 +00:00
|
|
|
|
2004-05-17 16:29:13 +00:00
|
|
|
// Get our scrolling preference
|
|
|
|
nsIView* rootView;
|
|
|
|
mViewManager->GetRootView(rootView);
|
|
|
|
void* nativeParentWidget = rootView->GetWidget()->GetNativeData(NS_NATIVE_WIDGET);
|
1998-07-13 19:49:42 +00:00
|
|
|
|
|
|
|
// Create a new view manager.
|
2007-04-25 15:49:55 +00:00
|
|
|
nsCOMPtr<nsIViewManager> vm = do_CreateInstance(kViewManagerCID);
|
|
|
|
NS_ENSURE_TRUE(vm, PR_FALSE);
|
2004-05-17 16:29:13 +00:00
|
|
|
rv = vm->Init(dc);
|
2007-04-25 15:49:55 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, PR_FALSE);
|
1998-08-28 02:54:06 +00:00
|
|
|
|
1998-07-13 19:49:42 +00:00
|
|
|
// Create a child window of the parent that is our "root view/window"
|
|
|
|
// Create a view
|
2004-02-01 10:09:07 +00:00
|
|
|
nsRect tbounds = mPresContext->GetVisibleArea();
|
2004-11-04 15:06:50 +00:00
|
|
|
nsIView* view = vm->CreateView(tbounds, nsnull);
|
2007-04-25 15:49:55 +00:00
|
|
|
NS_ENSURE_TRUE(view, PR_FALSE);
|
1998-11-04 04:14:10 +00:00
|
|
|
|
|
|
|
//now create the widget for the view
|
2004-05-17 16:29:13 +00:00
|
|
|
rv = view->CreateWidget(kWidgetCID, nsnull, nativeParentWidget, PR_TRUE);
|
2007-04-25 15:49:55 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, PR_FALSE);
|
1998-11-04 04:14:10 +00:00
|
|
|
|
2004-05-17 16:29:13 +00:00
|
|
|
// Setup hierarchical relationship in view manager
|
|
|
|
vm->SetRootView(view);
|
|
|
|
|
1998-07-13 19:49:42 +00:00
|
|
|
// Make the new presentation context the same size as our
|
|
|
|
// presentation context.
|
2004-02-01 10:09:07 +00:00
|
|
|
nsRect r = mPresContext->GetVisibleArea();
|
1998-07-13 19:49:42 +00:00
|
|
|
cx->SetVisibleArea(r);
|
1999-04-03 18:58:04 +00:00
|
|
|
|
1998-11-25 18:41:02 +00:00
|
|
|
// Create a new presentation shell to view the document. Use the
|
|
|
|
// exact same style information that this document has.
|
2004-01-08 19:23:12 +00:00
|
|
|
nsAutoPtr<nsStyleSet> newSet;
|
2004-01-08 21:10:33 +00:00
|
|
|
rv = CloneStyleSet(mStyleSet, getter_Transfers(newSet));
|
2007-04-25 15:49:55 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, PR_FALSE);
|
|
|
|
nsCOMPtr<nsIPresShell> sh;
|
|
|
|
rv = mDocument->CreateShell(cx, vm, newSet, getter_AddRefs(sh));
|
|
|
|
NS_ENSURE_SUCCESS(rv, PR_FALSE);
|
|
|
|
newSet.forget();
|
|
|
|
// Note that after we create the shell, we must make sure to destroy it
|
2000-03-17 01:50:54 +00:00
|
|
|
sh->SetVerifyReflowEnable(PR_FALSE); // turn off verify reflow while we're reflowing the test frame tree
|
2007-04-25 15:49:55 +00:00
|
|
|
vm->SetViewObserver((nsIViewObserver *)((PresShell*)sh.get()));
|
|
|
|
WillCauseReflow();
|
|
|
|
sh->InitialReflow(r.width, r.height);
|
|
|
|
DidCauseReflow();
|
|
|
|
mDocument->BindingManager()->ProcessAttachedQueue();
|
|
|
|
sh->FlushPendingNotifications(Flush_Layout);
|
2000-03-17 01:50:54 +00:00
|
|
|
sh->SetVerifyReflowEnable(PR_TRUE); // turn on verify reflow again now that we're done reflowing the test frame tree
|
2007-05-23 00:11:05 +00:00
|
|
|
// Force the non-primary presshell to unsuppress; it doesn't want to normally
|
|
|
|
// because it thinks it's hidden
|
|
|
|
((PresShell*)sh.get())->mPaintingSuppressed = PR_FALSE;
|
2000-04-17 14:40:46 +00:00
|
|
|
if (VERIFY_REFLOW_NOISY & gVerifyReflowFlags) {
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("Verification Tree built, comparing...\n");
|
2000-04-17 14:40:46 +00:00
|
|
|
}
|
1998-07-13 19:49:42 +00:00
|
|
|
|
|
|
|
// Now that the document has been reflowed, use its frame tree to
|
|
|
|
// compare against our frame tree.
|
2004-03-06 04:46:11 +00:00
|
|
|
nsIFrame* root1 = FrameManager()->GetRootFrame();
|
2004-09-02 03:08:51 +00:00
|
|
|
nsIFrame* root2 = sh->FrameManager()->GetRootFrame();
|
2000-03-17 01:50:54 +00:00
|
|
|
PRBool ok = CompareTrees(mPresContext, root1, cx, root2);
|
1999-09-10 18:49:23 +00:00
|
|
|
if (!ok && (VERIFY_REFLOW_NOISY & gVerifyReflowFlags)) {
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("Verify reflow failed, primary tree:\n");
|
1999-11-01 22:12:45 +00:00
|
|
|
nsIFrameDebug* frameDebug;
|
|
|
|
|
2007-04-25 15:49:55 +00:00
|
|
|
if (NS_SUCCEEDED(CallQueryInterface(root1, &frameDebug))) {
|
2005-09-06 21:34:50 +00:00
|
|
|
frameDebug->List(stdout, 0);
|
1999-11-01 22:12:45 +00:00
|
|
|
}
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("Verification tree:\n");
|
2007-04-25 15:49:55 +00:00
|
|
|
if (NS_SUCCEEDED(CallQueryInterface(root2, &frameDebug))) {
|
2005-09-06 21:34:50 +00:00
|
|
|
frameDebug->List(stdout, 0);
|
1999-11-01 22:12:45 +00:00
|
|
|
}
|
1999-04-03 18:58:04 +00:00
|
|
|
}
|
1998-07-13 19:49:42 +00:00
|
|
|
|
2007-05-23 00:11:05 +00:00
|
|
|
#ifdef DEBUG_Eli
|
|
|
|
// Sample code for dumping page to png
|
|
|
|
// XXX Needs to be made more flexible
|
|
|
|
if (!ok) {
|
|
|
|
nsString stra;
|
|
|
|
static int num = 0;
|
|
|
|
stra.AppendLiteral("C:\\mozilla\\mozilla\\debug\\filea");
|
|
|
|
stra.AppendInt(num);
|
|
|
|
stra.AppendLiteral(".png");
|
|
|
|
DumpToPNG(sh, stra);
|
|
|
|
nsString strb;
|
|
|
|
strb.AppendLiteral("C:\\mozilla\\mozilla\\debug\\fileb");
|
|
|
|
strb.AppendInt(num);
|
|
|
|
strb.AppendLiteral(".png");
|
|
|
|
DumpToPNG(this, strb);
|
|
|
|
++num;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1999-04-03 18:58:04 +00:00
|
|
|
sh->EndObservingDocument();
|
2007-04-25 15:49:55 +00:00
|
|
|
sh->Destroy();
|
2000-04-17 14:40:46 +00:00
|
|
|
if (VERIFY_REFLOW_NOISY & gVerifyReflowFlags) {
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("Finished Verifying Reflow...\n");
|
2000-04-17 14:40:46 +00:00
|
|
|
}
|
1999-09-10 18:49:23 +00:00
|
|
|
|
|
|
|
return ok;
|
1998-07-13 19:49:42 +00:00
|
|
|
}
|
2004-01-07 22:30:53 +00:00
|
|
|
|
|
|
|
// Layout debugging hooks
|
|
|
|
void
|
|
|
|
PresShell::ListStyleContexts(nsIFrame *aRootFrame, FILE *out, PRInt32 aIndent)
|
|
|
|
{
|
|
|
|
nsStyleContext *sc = aRootFrame->GetStyleContext();
|
|
|
|
if (sc)
|
|
|
|
sc->List(out, aIndent);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
PresShell::ListStyleSheets(FILE *out, PRInt32 aIndent)
|
|
|
|
{
|
|
|
|
PRInt32 sheetCount = mStyleSet->SheetCount(nsStyleSet::eDocSheet);
|
|
|
|
for (PRInt32 i = 0; i < sheetCount; ++i) {
|
|
|
|
mStyleSet->StyleSheetAt(nsStyleSet::eDocSheet, i)->List(out, aIndent);
|
|
|
|
fputs("\n", out);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-11-06 18:01:17 +00:00
|
|
|
void
|
|
|
|
PresShell::VerifyStyleTree()
|
|
|
|
{
|
|
|
|
VERIFY_STYLE_TREE;
|
|
|
|
}
|
1998-07-13 19:49:42 +00:00
|
|
|
#endif
|
1999-10-15 04:29:30 +00:00
|
|
|
|
2001-03-13 01:47:22 +00:00
|
|
|
//=============================================================
|
|
|
|
//=============================================================
|
|
|
|
//-- Debug Reflow Counts
|
|
|
|
//=============================================================
|
|
|
|
//=============================================================
|
2000-04-21 14:59:47 +00:00
|
|
|
#ifdef MOZ_REFLOW_PERF
|
2000-04-28 23:32:04 +00:00
|
|
|
//-------------------------------------------------------------
|
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::DumpReflows()
|
|
|
|
{
|
|
|
|
if (mReflowCountMgr) {
|
2002-03-06 07:48:55 +00:00
|
|
|
nsCAutoString uriStr;
|
2000-04-28 23:32:04 +00:00
|
|
|
if (mDocument) {
|
2004-01-09 23:54:21 +00:00
|
|
|
nsIURI *uri = mDocument->GetDocumentURI();
|
2000-04-28 23:32:04 +00:00
|
|
|
if (uri) {
|
2002-03-06 07:48:55 +00:00
|
|
|
uri->GetPath(uriStr);
|
2000-04-28 23:32:04 +00:00
|
|
|
}
|
|
|
|
}
|
2002-03-06 07:48:55 +00:00
|
|
|
mReflowCountMgr->DisplayTotals(uriStr.get());
|
|
|
|
mReflowCountMgr->DisplayHTMLTotals(uriStr.get());
|
2000-04-28 23:32:04 +00:00
|
|
|
mReflowCountMgr->DisplayDiffsInTotals("Differences");
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-04-21 14:59:47 +00:00
|
|
|
//-------------------------------------------------------------
|
|
|
|
NS_IMETHODIMP
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
PresShell::CountReflows(const char * aName, nsIFrame * aFrame)
|
2000-04-21 14:59:47 +00:00
|
|
|
{
|
|
|
|
if (mReflowCountMgr) {
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
mReflowCountMgr->Add(aName, aFrame);
|
2000-04-21 14:59:47 +00:00
|
|
|
}
|
2001-03-13 06:38:59 +00:00
|
|
|
|
2000-04-21 14:59:47 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-03-13 01:47:22 +00:00
|
|
|
//-------------------------------------------------------------
|
|
|
|
NS_IMETHODIMP
|
2004-07-31 23:15:21 +00:00
|
|
|
PresShell::PaintCount(const char * aName, nsIRenderingContext* aRenderingContext, nsPresContext* aPresContext, nsIFrame * aFrame, PRUint32 aColor)
|
2001-03-13 01:47:22 +00:00
|
|
|
{
|
|
|
|
if (mReflowCountMgr) {
|
|
|
|
mReflowCountMgr->PaintCount(aName, aRenderingContext, aPresContext, aFrame, aColor);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------------
|
|
|
|
NS_IMETHODIMP
|
|
|
|
PresShell::SetPaintFrameCount(PRBool aPaintFrameCounts)
|
|
|
|
{
|
|
|
|
if (mReflowCountMgr) {
|
|
|
|
mReflowCountMgr->SetPaintFrameCounts(aPaintFrameCounts);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-04-21 14:59:47 +00:00
|
|
|
//------------------------------------------------------------------
|
|
|
|
//-- Reflow Counter Classes Impls
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
ReflowCounter::ReflowCounter(ReflowCountMgr * aMgr) :
|
|
|
|
mMgr(aMgr)
|
|
|
|
{
|
|
|
|
ClearTotals();
|
2000-04-28 23:32:04 +00:00
|
|
|
SetTotalsCache();
|
2000-04-21 14:59:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
ReflowCounter::~ReflowCounter()
|
|
|
|
{
|
2001-03-13 01:47:22 +00:00
|
|
|
|
2000-04-21 14:59:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
void ReflowCounter::ClearTotals()
|
|
|
|
{
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
mTotal = 0;
|
2000-04-21 14:59:47 +00:00
|
|
|
}
|
|
|
|
|
2000-04-28 23:32:04 +00:00
|
|
|
//------------------------------------------------------------------
|
|
|
|
void ReflowCounter::SetTotalsCache()
|
|
|
|
{
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
mCacheTotal = mTotal;
|
2000-04-28 23:32:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
void ReflowCounter::CalcDiffInTotals()
|
|
|
|
{
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
mCacheTotal = mTotal - mCacheTotal;
|
2000-04-28 23:32:04 +00:00
|
|
|
}
|
|
|
|
|
2000-04-21 14:59:47 +00:00
|
|
|
//------------------------------------------------------------------
|
|
|
|
void ReflowCounter::DisplayTotals(const char * aStr)
|
|
|
|
{
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
DisplayTotals(mTotal, aStr?aStr:"Totals");
|
2000-04-28 23:32:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
void ReflowCounter::DisplayDiffTotals(const char * aStr)
|
|
|
|
{
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
DisplayTotals(mCacheTotal, aStr?aStr:"Diff Totals");
|
2000-04-21 14:59:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
void ReflowCounter::DisplayHTMLTotals(const char * aStr)
|
|
|
|
{
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
DisplayHTMLTotals(mTotal, aStr?aStr:"Totals");
|
2000-04-21 14:59:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
void ReflowCounter::DisplayTotals(PRUint32 aTotal, const char * aTitle)
|
2000-04-21 14:59:47 +00:00
|
|
|
{
|
2000-04-28 23:32:04 +00:00
|
|
|
// figure total
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
if (aTotal == 0) {
|
2000-04-21 14:59:47 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
ReflowCounter * gTots = (ReflowCounter *)mMgr->LookUp(kGrandTotalsStr);
|
|
|
|
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("%25s\t", aTitle);
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
printf("%d\t", aTotal);
|
|
|
|
if (gTots != this && aTotal > 0) {
|
|
|
|
gTots->Add(aTotal);
|
2000-04-21 14:59:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
void ReflowCounter::DisplayHTMLTotals(PRUint32 aTotal, const char * aTitle)
|
2000-04-21 14:59:47 +00:00
|
|
|
{
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
if (aTotal == 0) {
|
2000-04-21 14:59:47 +00:00
|
|
|
return;
|
|
|
|
}
|
2000-04-28 23:32:04 +00:00
|
|
|
|
2000-04-21 14:59:47 +00:00
|
|
|
ReflowCounter * gTots = (ReflowCounter *)mMgr->LookUp(kGrandTotalsStr);
|
|
|
|
FILE * fd = mMgr->GetOutFile();
|
|
|
|
if (!fd) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(fd, "<tr><td><center>%s</center></td>", aTitle);
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
fprintf(fd, "<td><center>%d</center></td></tr>\n", aTotal);
|
|
|
|
|
|
|
|
if (gTots != this && aTotal > 0) {
|
|
|
|
gTots->Add(aTotal);
|
2000-04-21 14:59:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-03-13 01:47:22 +00:00
|
|
|
//------------------------------------------------------------------
|
|
|
|
//-- ReflowCountMgr
|
2000-04-21 14:59:47 +00:00
|
|
|
//------------------------------------------------------------------
|
|
|
|
ReflowCountMgr::ReflowCountMgr()
|
|
|
|
{
|
|
|
|
mCounts = PL_NewHashTable(10, PL_HashString, PL_CompareStrings,
|
|
|
|
PL_CompareValues, nsnull, nsnull);
|
2001-02-22 13:58:17 +00:00
|
|
|
mIndiFrameCounts = PL_NewHashTable(10, PL_HashString, PL_CompareStrings,
|
|
|
|
PL_CompareValues, nsnull, nsnull);
|
2001-03-13 01:47:22 +00:00
|
|
|
mCycledOnce = PR_FALSE;
|
|
|
|
mDumpFrameCounts = PR_FALSE;
|
|
|
|
mDumpFrameByFrameCounts = PR_FALSE;
|
|
|
|
mPaintFrameByFrameCounts = PR_FALSE;
|
2000-04-21 14:59:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
ReflowCountMgr::~ReflowCountMgr()
|
|
|
|
{
|
|
|
|
CleanUp();
|
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
ReflowCounter * ReflowCountMgr::LookUp(const char * aName)
|
|
|
|
{
|
|
|
|
if (nsnull != mCounts) {
|
|
|
|
ReflowCounter * counter = (ReflowCounter *)PL_HashTableLookup(mCounts, aName);
|
|
|
|
return counter;
|
|
|
|
}
|
|
|
|
return nsnull;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
void ReflowCountMgr::Add(const char * aName, nsIFrame * aFrame)
|
2000-04-21 14:59:47 +00:00
|
|
|
{
|
2001-02-22 13:58:17 +00:00
|
|
|
NS_ASSERTION(aName != nsnull, "Name shouldn't be null!");
|
|
|
|
|
2001-03-13 01:47:22 +00:00
|
|
|
if (mDumpFrameCounts && nsnull != mCounts) {
|
2000-04-21 14:59:47 +00:00
|
|
|
ReflowCounter * counter = (ReflowCounter *)PL_HashTableLookup(mCounts, aName);
|
|
|
|
if (counter == nsnull) {
|
|
|
|
counter = new ReflowCounter(this);
|
|
|
|
NS_ASSERTION(counter != nsnull, "null ptr");
|
2006-11-17 01:49:06 +00:00
|
|
|
char * name = NS_strdup(aName);
|
2000-04-21 14:59:47 +00:00
|
|
|
NS_ASSERTION(name != nsnull, "null ptr");
|
|
|
|
PL_HashTableAdd(mCounts, name, counter);
|
|
|
|
}
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
counter->Add();
|
2000-04-21 14:59:47 +00:00
|
|
|
}
|
2001-02-22 13:58:17 +00:00
|
|
|
|
2001-03-13 01:47:22 +00:00
|
|
|
if ((mDumpFrameByFrameCounts || mPaintFrameByFrameCounts) &&
|
|
|
|
nsnull != mIndiFrameCounts &&
|
|
|
|
aFrame != nsnull) {
|
2001-02-22 13:58:17 +00:00
|
|
|
char * key = new char[16];
|
2002-08-24 14:41:28 +00:00
|
|
|
sprintf(key, "%p", (void*)aFrame);
|
2001-02-22 13:58:17 +00:00
|
|
|
IndiReflowCounter * counter = (IndiReflowCounter *)PL_HashTableLookup(mIndiFrameCounts, key);
|
|
|
|
if (counter == nsnull) {
|
|
|
|
counter = new IndiReflowCounter(this);
|
|
|
|
NS_ASSERTION(counter != nsnull, "null ptr");
|
|
|
|
counter->mFrame = aFrame;
|
2004-07-25 12:18:04 +00:00
|
|
|
counter->mName.AssignASCII(aName);
|
2001-02-22 13:58:17 +00:00
|
|
|
PL_HashTableAdd(mIndiFrameCounts, key, counter);
|
|
|
|
}
|
|
|
|
// this eliminates extra counts from super classes
|
2004-07-21 20:18:39 +00:00
|
|
|
if (counter != nsnull && counter->mName.EqualsASCII(aName)) {
|
2001-02-22 13:58:17 +00:00
|
|
|
counter->mCount++;
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
counter->mCounter.Add(1);
|
2001-02-22 13:58:17 +00:00
|
|
|
}
|
|
|
|
}
|
2000-04-21 14:59:47 +00:00
|
|
|
}
|
|
|
|
|
2001-03-13 01:47:22 +00:00
|
|
|
//------------------------------------------------------------------
|
|
|
|
void ReflowCountMgr::PaintCount(const char * aName,
|
|
|
|
nsIRenderingContext* aRenderingContext,
|
2004-07-31 23:15:21 +00:00
|
|
|
nsPresContext* aPresContext,
|
2001-03-13 01:47:22 +00:00
|
|
|
nsIFrame* aFrame,
|
|
|
|
PRUint32 aColor)
|
|
|
|
{
|
|
|
|
if (mPaintFrameByFrameCounts &&
|
|
|
|
nsnull != mIndiFrameCounts &&
|
|
|
|
aFrame != nsnull) {
|
|
|
|
char * key = new char[16];
|
2002-08-24 14:41:28 +00:00
|
|
|
sprintf(key, "%p", (void*)aFrame);
|
2001-03-13 01:47:22 +00:00
|
|
|
IndiReflowCounter * counter = (IndiReflowCounter *)PL_HashTableLookup(mIndiFrameCounts, key);
|
2004-07-21 20:18:39 +00:00
|
|
|
if (counter != nsnull && counter->mName.EqualsASCII(aName)) {
|
2001-03-13 01:47:22 +00:00
|
|
|
aRenderingContext->PushState();
|
2007-02-07 07:46:44 +00:00
|
|
|
nsFont font("Times", NS_FONT_STYLE_NORMAL, NS_FONT_VARIANT_NORMAL,
|
|
|
|
NS_FONT_WEIGHT_NORMAL, 0,
|
|
|
|
nsPresContext::CSSPixelsToAppUnits(11));
|
2001-03-13 01:47:22 +00:00
|
|
|
|
2004-07-29 19:41:39 +00:00
|
|
|
nsCOMPtr<nsIFontMetrics> fm = aPresContext->GetMetricsFor(font);
|
2001-03-13 01:47:22 +00:00
|
|
|
aRenderingContext->SetFont(fm);
|
|
|
|
char buf[16];
|
|
|
|
sprintf(buf, "%d", counter->mCount);
|
2001-10-30 22:58:00 +00:00
|
|
|
nscoord x = 0, y;
|
2001-03-13 01:47:22 +00:00
|
|
|
nscoord width, height;
|
2007-01-23 02:58:55 +00:00
|
|
|
aRenderingContext->SetTextRunRTL(PR_FALSE);
|
2001-03-13 01:47:22 +00:00
|
|
|
aRenderingContext->GetWidth((char*)buf, width);
|
|
|
|
fm->GetHeight(height);
|
2001-10-30 22:58:00 +00:00
|
|
|
fm->GetMaxAscent(y);
|
2001-03-13 01:47:22 +00:00
|
|
|
|
|
|
|
PRUint32 color;
|
|
|
|
PRUint32 color2;
|
|
|
|
if (aColor != 0) {
|
|
|
|
color = aColor;
|
|
|
|
color2 = NS_RGB(0,0,0);
|
|
|
|
} else {
|
2003-05-30 19:47:39 +00:00
|
|
|
PRUint8 rc = 0, gc = 0, bc = 0;
|
2001-03-13 01:47:22 +00:00
|
|
|
if (counter->mCount < 5) {
|
|
|
|
rc = 255;
|
|
|
|
gc = 255;
|
|
|
|
} else if ( counter->mCount < 11) {
|
|
|
|
gc = 255;
|
|
|
|
} else {
|
|
|
|
rc = 255;
|
|
|
|
}
|
|
|
|
color = NS_RGB(rc,gc,bc);
|
|
|
|
color2 = NS_RGB(rc/2,gc/2,bc/2);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsRect rect(0,0, width+15, height+15);
|
|
|
|
aRenderingContext->SetColor(NS_RGB(0,0,0));
|
|
|
|
aRenderingContext->FillRect(rect);
|
|
|
|
aRenderingContext->SetColor(color2);
|
2001-10-30 22:58:00 +00:00
|
|
|
aRenderingContext->DrawString(buf, strlen(buf), x+15,y+15);
|
2001-03-13 01:47:22 +00:00
|
|
|
aRenderingContext->SetColor(color);
|
2001-10-30 22:58:00 +00:00
|
|
|
aRenderingContext->DrawString(buf, strlen(buf), x,y);
|
2001-03-13 01:47:22 +00:00
|
|
|
|
2004-04-18 13:13:35 +00:00
|
|
|
aRenderingContext->PopState();
|
2001-03-13 01:47:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-04-21 14:59:47 +00:00
|
|
|
//------------------------------------------------------------------
|
|
|
|
PRIntn ReflowCountMgr::RemoveItems(PLHashEntry *he, PRIntn i, void *arg)
|
|
|
|
{
|
|
|
|
char *str = (char *)he->key;
|
|
|
|
ReflowCounter * counter = (ReflowCounter *)he->value;
|
|
|
|
delete counter;
|
2006-11-17 01:49:06 +00:00
|
|
|
NS_Free(str);
|
2000-04-21 14:59:47 +00:00
|
|
|
|
|
|
|
return HT_ENUMERATE_REMOVE;
|
|
|
|
}
|
|
|
|
|
2001-02-22 13:58:17 +00:00
|
|
|
//------------------------------------------------------------------
|
|
|
|
PRIntn ReflowCountMgr::RemoveIndiItems(PLHashEntry *he, PRIntn i, void *arg)
|
|
|
|
{
|
|
|
|
char *str = (char *)he->key;
|
|
|
|
IndiReflowCounter * counter = (IndiReflowCounter *)he->value;
|
|
|
|
delete counter;
|
2006-11-17 01:49:06 +00:00
|
|
|
NS_Free(str);
|
2001-02-22 13:58:17 +00:00
|
|
|
|
|
|
|
return HT_ENUMERATE_REMOVE;
|
|
|
|
}
|
|
|
|
|
2000-04-21 14:59:47 +00:00
|
|
|
//------------------------------------------------------------------
|
|
|
|
void ReflowCountMgr::CleanUp()
|
|
|
|
{
|
|
|
|
if (nsnull != mCounts) {
|
|
|
|
PL_HashTableEnumerateEntries(mCounts, RemoveItems, nsnull);
|
|
|
|
PL_HashTableDestroy(mCounts);
|
|
|
|
mCounts = nsnull;
|
2001-03-13 01:47:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (nsnull != mIndiFrameCounts) {
|
|
|
|
PL_HashTableEnumerateEntries(mIndiFrameCounts, RemoveIndiItems, nsnull);
|
|
|
|
PL_HashTableDestroy(mIndiFrameCounts);
|
|
|
|
mIndiFrameCounts = nsnull;
|
2000-04-21 14:59:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
PRIntn ReflowCountMgr::DoSingleTotal(PLHashEntry *he, PRIntn i, void *arg)
|
|
|
|
{
|
|
|
|
char *str = (char *)he->key;
|
|
|
|
ReflowCounter * counter = (ReflowCounter *)he->value;
|
|
|
|
|
|
|
|
counter->DisplayTotals(str);
|
|
|
|
|
|
|
|
return HT_ENUMERATE_NEXT;
|
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
void ReflowCountMgr::DoGrandTotals()
|
|
|
|
{
|
|
|
|
if (nsnull != mCounts) {
|
|
|
|
ReflowCounter * gTots = (ReflowCounter *)PL_HashTableLookup(mCounts, kGrandTotalsStr);
|
|
|
|
if (gTots == nsnull) {
|
|
|
|
gTots = new ReflowCounter(this);
|
2006-11-17 01:49:06 +00:00
|
|
|
PL_HashTableAdd(mCounts, NS_strdup(kGrandTotalsStr), gTots);
|
2000-04-21 14:59:47 +00:00
|
|
|
} else {
|
|
|
|
gTots->ClearTotals();
|
|
|
|
}
|
|
|
|
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
printf("\t\t\t\tTotal\n");
|
|
|
|
for (PRUint32 i=0;i<78;i++) {
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("-");
|
2000-04-21 14:59:47 +00:00
|
|
|
}
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("\n");
|
2000-04-21 14:59:47 +00:00
|
|
|
PL_HashTableEnumerateEntries(mCounts, DoSingleTotal, this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-07-31 23:15:21 +00:00
|
|
|
static void RecurseIndiTotals(nsPresContext* aPresContext,
|
2001-02-22 13:58:17 +00:00
|
|
|
PLHashTable * aHT,
|
|
|
|
nsIFrame * aParentFrame,
|
|
|
|
PRInt32 aLevel)
|
|
|
|
{
|
|
|
|
if (aParentFrame == nsnull) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
char key[16];
|
2002-08-24 14:41:28 +00:00
|
|
|
sprintf(key, "%p", (void*)aParentFrame);
|
2001-02-22 13:58:17 +00:00
|
|
|
IndiReflowCounter * counter = (IndiReflowCounter *)PL_HashTableLookup(aHT, key);
|
|
|
|
if (counter) {
|
|
|
|
counter->mHasBeenOutput = PR_TRUE;
|
2001-09-29 08:28:41 +00:00
|
|
|
char * name = ToNewCString(counter->mName);
|
2001-02-22 13:58:17 +00:00
|
|
|
for (PRInt32 i=0;i<aLevel;i++) printf(" ");
|
2002-08-24 14:41:28 +00:00
|
|
|
printf("%s - %p [%d][", name, (void*)aParentFrame, counter->mCount);
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
printf("%d", counter->mCounter.GetTotal());
|
2001-02-22 13:58:17 +00:00
|
|
|
printf("]\n");
|
|
|
|
nsMemory::Free(name);
|
|
|
|
}
|
|
|
|
|
2004-01-09 14:20:53 +00:00
|
|
|
nsIFrame* child = aParentFrame->GetFirstChild(nsnull);
|
2001-02-22 13:58:17 +00:00
|
|
|
while (child) {
|
|
|
|
RecurseIndiTotals(aPresContext, aHT, child, aLevel+1);
|
2003-06-30 10:46:59 +00:00
|
|
|
child = child->GetNextSibling();
|
2001-02-22 13:58:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
PRIntn ReflowCountMgr::DoSingleIndi(PLHashEntry *he, PRIntn i, void *arg)
|
|
|
|
{
|
|
|
|
IndiReflowCounter * counter = (IndiReflowCounter *)he->value;
|
|
|
|
if (counter && !counter->mHasBeenOutput) {
|
2001-09-29 08:28:41 +00:00
|
|
|
char * name = ToNewCString(counter->mName);
|
2002-08-24 14:41:28 +00:00
|
|
|
printf("%s - %p [%d][", name, (void*)counter->mFrame, counter->mCount);
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
printf("%d", counter->mCounter.GetTotal());
|
2001-02-22 13:58:17 +00:00
|
|
|
printf("]\n");
|
|
|
|
nsMemory::Free(name);
|
|
|
|
}
|
|
|
|
return HT_ENUMERATE_NEXT;
|
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
void ReflowCountMgr::DoIndiTotalsTree()
|
|
|
|
{
|
|
|
|
if (nsnull != mCounts) {
|
|
|
|
printf("\n------------------------------------------------\n");
|
|
|
|
printf("-- Individual Frame Counts\n");
|
|
|
|
printf("------------------------------------------------\n");
|
|
|
|
|
|
|
|
if (mPresShell) {
|
2004-09-02 03:08:51 +00:00
|
|
|
nsIFrame * rootFrame = mPresShell->FrameManager()->GetRootFrame();
|
2001-02-22 13:58:17 +00:00
|
|
|
RecurseIndiTotals(mPresContext, mIndiFrameCounts, rootFrame, 0);
|
|
|
|
printf("------------------------------------------------\n");
|
|
|
|
printf("-- Individual Counts of Frames not in Root Tree\n");
|
|
|
|
printf("------------------------------------------------\n");
|
|
|
|
PL_HashTableEnumerateEntries(mIndiFrameCounts, DoSingleIndi, this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-04-21 14:59:47 +00:00
|
|
|
//------------------------------------------------------------------
|
|
|
|
PRIntn ReflowCountMgr::DoSingleHTMLTotal(PLHashEntry *he, PRIntn i, void *arg)
|
|
|
|
{
|
|
|
|
char *str = (char *)he->key;
|
|
|
|
ReflowCounter * counter = (ReflowCounter *)he->value;
|
|
|
|
|
|
|
|
counter->DisplayHTMLTotals(str);
|
|
|
|
|
|
|
|
return HT_ENUMERATE_NEXT;
|
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
void ReflowCountMgr::DoGrandHTMLTotals()
|
|
|
|
{
|
|
|
|
if (nsnull != mCounts) {
|
|
|
|
ReflowCounter * gTots = (ReflowCounter *)PL_HashTableLookup(mCounts, kGrandTotalsStr);
|
|
|
|
if (gTots == nsnull) {
|
|
|
|
gTots = new ReflowCounter(this);
|
2006-11-17 01:49:06 +00:00
|
|
|
PL_HashTableAdd(mCounts, NS_strdup(kGrandTotalsStr), gTots);
|
2000-04-21 14:59:47 +00:00
|
|
|
} else {
|
|
|
|
gTots->ClearTotals();
|
|
|
|
}
|
|
|
|
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
static const char * title[] = {"Class", "Reflows"};
|
2000-04-21 14:59:47 +00:00
|
|
|
fprintf(mFD, "<tr>");
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
for (PRUint32 i=0; i < NS_ARRAY_LENGTH(title); i++) {
|
2000-04-21 14:59:47 +00:00
|
|
|
fprintf(mFD, "<td><center><b>%s<b></center></td>", title[i]);
|
|
|
|
}
|
|
|
|
fprintf(mFD, "</tr>\n");
|
|
|
|
PL_HashTableEnumerateEntries(mCounts, DoSingleHTMLTotal, this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------
|
|
|
|
void ReflowCountMgr::DisplayTotals(const char * aStr)
|
|
|
|
{
|
2001-07-18 04:29:14 +00:00
|
|
|
#ifdef DEBUG_rods
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("%s\n", aStr?aStr:"No name");
|
2001-07-18 04:29:14 +00:00
|
|
|
#endif
|
2001-03-13 01:47:22 +00:00
|
|
|
if (mDumpFrameCounts) {
|
|
|
|
DoGrandTotals();
|
|
|
|
}
|
|
|
|
if (mDumpFrameByFrameCounts) {
|
|
|
|
DoIndiTotalsTree();
|
|
|
|
}
|
2000-04-21 14:59:47 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
//------------------------------------
|
|
|
|
void ReflowCountMgr::DisplayHTMLTotals(const char * aStr)
|
|
|
|
{
|
2000-04-28 23:32:04 +00:00
|
|
|
#ifdef WIN32x // XXX NOT XP!
|
2000-04-21 14:59:47 +00:00
|
|
|
char name[1024];
|
|
|
|
|
|
|
|
char * sptr = strrchr(aStr, '/');
|
|
|
|
if (sptr) {
|
|
|
|
sptr++;
|
|
|
|
strcpy(name, sptr);
|
|
|
|
char * eptr = strrchr(name, '.');
|
|
|
|
if (eptr) {
|
|
|
|
*eptr = 0;
|
|
|
|
}
|
|
|
|
strcat(name, "_stats.html");
|
|
|
|
}
|
|
|
|
mFD = fopen(name, "w");
|
|
|
|
if (mFD) {
|
|
|
|
fprintf(mFD, "<html><head><title>Reflow Stats</title></head><body>\n");
|
|
|
|
const char * title = aStr?aStr:"No name";
|
|
|
|
fprintf(mFD, "<center><b>%s</b><br><table border=1 style=\"background-color:#e0e0e0\">", title);
|
|
|
|
DoGrandHTMLTotals();
|
|
|
|
fprintf(mFD, "</center></table>\n");
|
|
|
|
fprintf(mFD, "</body></html>\n");
|
|
|
|
fclose(mFD);
|
|
|
|
mFD = nsnull;
|
|
|
|
}
|
|
|
|
#endif // not XP!
|
|
|
|
}
|
2000-04-28 23:32:04 +00:00
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
PRIntn ReflowCountMgr::DoClearTotals(PLHashEntry *he, PRIntn i, void *arg)
|
|
|
|
{
|
|
|
|
ReflowCounter * counter = (ReflowCounter *)he->value;
|
|
|
|
counter->ClearTotals();
|
|
|
|
|
|
|
|
return HT_ENUMERATE_NEXT;
|
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
void ReflowCountMgr::ClearTotals()
|
|
|
|
{
|
|
|
|
PL_HashTableEnumerateEntries(mCounts, DoClearTotals, this);
|
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
void ReflowCountMgr::ClearGrandTotals()
|
|
|
|
{
|
|
|
|
if (nsnull != mCounts) {
|
|
|
|
ReflowCounter * gTots = (ReflowCounter *)PL_HashTableLookup(mCounts, kGrandTotalsStr);
|
|
|
|
if (gTots == nsnull) {
|
|
|
|
gTots = new ReflowCounter(this);
|
2006-11-17 01:49:06 +00:00
|
|
|
PL_HashTableAdd(mCounts, NS_strdup(kGrandTotalsStr), gTots);
|
2000-04-28 23:32:04 +00:00
|
|
|
} else {
|
|
|
|
gTots->ClearTotals();
|
|
|
|
gTots->SetTotalsCache();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
PRIntn ReflowCountMgr::DoDisplayDiffTotals(PLHashEntry *he, PRIntn i, void *arg)
|
|
|
|
{
|
2001-08-15 01:33:22 +00:00
|
|
|
PRBool cycledOnce = (arg != 0);
|
2000-04-28 23:32:04 +00:00
|
|
|
|
|
|
|
char *str = (char *)he->key;
|
|
|
|
ReflowCounter * counter = (ReflowCounter *)he->value;
|
|
|
|
|
|
|
|
if (cycledOnce) {
|
|
|
|
counter->CalcDiffInTotals();
|
|
|
|
counter->DisplayDiffTotals(str);
|
|
|
|
}
|
|
|
|
counter->SetTotalsCache();
|
|
|
|
|
|
|
|
return HT_ENUMERATE_NEXT;
|
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
void ReflowCountMgr::DisplayDiffsInTotals(const char * aStr)
|
|
|
|
{
|
|
|
|
if (mCycledOnce) {
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("Differences\n");
|
2000-04-28 23:32:04 +00:00
|
|
|
for (PRInt32 i=0;i<78;i++) {
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("-");
|
2000-04-28 23:32:04 +00:00
|
|
|
}
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("\n");
|
2000-04-28 23:32:04 +00:00
|
|
|
ClearGrandTotals();
|
|
|
|
}
|
|
|
|
PL_HashTableEnumerateEntries(mCounts, DoDisplayDiffTotals, (void *)mCycledOnce);
|
|
|
|
|
|
|
|
mCycledOnce = PR_TRUE;
|
|
|
|
}
|
|
|
|
|
2000-04-21 14:59:47 +00:00
|
|
|
#endif // MOZ_REFLOW_PERF
|
2000-10-11 08:33:01 +00:00
|
|
|
|
|
|
|
// make a color string like #RRGGBB
|
|
|
|
void ColorToString(nscolor aColor, nsAutoString &aString)
|
|
|
|
{
|
2004-01-18 14:44:43 +00:00
|
|
|
char buf[8];
|
2000-10-11 08:33:01 +00:00
|
|
|
|
2004-01-18 14:44:43 +00:00
|
|
|
PR_snprintf(buf, sizeof(buf), "#%02x%02x%02x",
|
|
|
|
NS_GET_R(aColor), NS_GET_G(aColor), NS_GET_B(aColor));
|
|
|
|
CopyASCIItoUTF16(buf, aString);
|
2000-10-11 08:33:01 +00:00
|
|
|
}
|
2008-01-22 07:39:06 +00:00
|
|
|
|
|
|
|
nsIFrame* nsIPresShell::GetAbsoluteContainingBlock(nsIFrame *aFrame)
|
|
|
|
{
|
|
|
|
return FrameConstructor()->GetAbsoluteContainingBlock(aFrame);
|
|
|
|
}
|