This is a copy of regalloc_code2_BRANCH from Netscape's private repository,

as it existed in January of 1998.


git-svn-id: svn://10.0.0.236/branches/regalloc_code2_BRANCH@22571 18797224-902f-48f8-a5cc-f745e15eee43

mozilla/content/shared/public/nsXULAtomList.h

@@ -1,129 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL") you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1999 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-/******
-
-  This file contains the list of all XUL nsIAtoms and their values
-  
-  It is designed to be used as inline input to nsXULAtoms.cpp *only*
-  through the magic of C preprocessing.
-
-  All entires must be enclosed in the macro XUL_ATOM which will have cruel
-  and unusual things done to it
-
-  It is recommended (but not strictly necessary) to keep all entries
-  in alphabetical order
-
-  The first argument to XUL_ATOM is the C++ identifier of the atom
-  The second argument is the string value of the atom
-
- ******/
-
-
-XUL_ATOM(button, "button")
-XUL_ATOM(spinner, "spinner")
-XUL_ATOM(scrollbar, "scrollbar")
-XUL_ATOM(slider, "slider")
-XUL_ATOM(colorpicker, "colorpicker")
-XUL_ATOM(palettename, "palettename")
-XUL_ATOM(fontpicker, "fontpicker")
-XUL_ATOM(radio, "radio")
-XUL_ATOM(text, "text")
-XUL_ATOM(toolbar, "toolbar")
-XUL_ATOM(toolbaritem, "toolbaritem")
-XUL_ATOM(toolbox, "toolbox")
-
-  // The tree atoms
-XUL_ATOM(tree, "tree") // The start of a tree view
-XUL_ATOM(treecaption, "treecaption") // The caption of a tree view
-XUL_ATOM(treehead, "treehead") // The header of the tree view
-XUL_ATOM(treerow, "treerow") // A row in the tree view
-XUL_ATOM(treecell, "treecell") // An item in the tree view
-XUL_ATOM(treeitem, "treeitem") // A cell in the tree view
-XUL_ATOM(treechildren, "treechildren") // The children of an item in the tree view
-XUL_ATOM(treeindentation, "treeindentation") // Specifies that the indentation for the level should occur here.
-XUL_ATOM(allowevents, "allowevents") // Lets events be handled on the cell contents or in menus.
-XUL_ATOM(treecol, "treecol") // A column in the tree view
-XUL_ATOM(treecolgroup, "treecolgroup") // A column group in the tree view
-XUL_ATOM(treefoot, "treefoot") // The footer of the tree view
-XUL_ATOM(treepusher, "treepusher") // A column pusher (left or right) for the tree view
-XUL_ATOM(scrollbarlist, "scrollbarlist") // An atom for internal use by the tree view
-
-XUL_ATOM(open, "open") // Whether or not a menu, tree, etc. is open
-
-XUL_ATOM(menubar, "menubar") // An XP menu bar.
-XUL_ATOM(menu, "menu") // Represents an XP menu
-XUL_ATOM(menuitem, "menuitem") // Represents an XP menu item
-XUL_ATOM(menupopup, "menupopup") // The XP menu's children.
-XUL_ATOM(menuactive, "menuactive") // Whether or not a menu is active (without necessarily being open)
-XUL_ATOM(accesskey, "accesskey") // The shortcut key for a menu or menu item
-XUL_ATOM(acceltext, "acceltext") // Text to use for the accelerator
-XUL_ATOM(popupset, "popupset") // Contains popup menus, context menus, and tooltips
-XUL_ATOM(popup, "popup") // The popup for a context menu, popup menu, or tooltip
-XUL_ATOM(menugenerated, "menugenerated") // Internal
-
-XUL_ATOM(key, "key") // A key element
-XUL_ATOM(broadcaster, "broadcaster") // A broadcaster
-XUL_ATOM(observes, "observes") // The observes element
-XUL_ATOM(templateAtom, "template") // A XUL template
-
-XUL_ATOM(progressmeter, "progressmeter")
-XUL_ATOM(titledbutton, "titledbutton")
-XUL_ATOM(crop, "crop")
-
-XUL_ATOM(mode, "mode")
-XUL_ATOM(box, "box")
-XUL_ATOM(flex, "flex")
-XUL_ATOM(spring, "spring")
-
-XUL_ATOM(deck, "deck")
-XUL_ATOM(tabcontrol, "tabcontrol")
-XUL_ATOM(tab, "tab")
-XUL_ATOM(tabpanel, "tabpanel")
-XUL_ATOM(tabpage, "tabpage")
-XUL_ATOM(tabbox, "tabbox")
-XUL_ATOM(index, "index")
-XUL_ATOM(maxpos, "maxpos")
-XUL_ATOM(curpos, "curpos")
-XUL_ATOM(scrollbarbutton, "scrollbarbutton")
-XUL_ATOM(increment, "increment")
-XUL_ATOM(pageincrement, "pageincrement")
-XUL_ATOM(thumb, "thumb")
-XUL_ATOM(toggled, "toggled")
-XUL_ATOM(grippy, "grippy")
-XUL_ATOM(splitter, "splitter")
-XUL_ATOM(collapse, "collapse")
-XUL_ATOM(resizebefore, "resizebefore")
-XUL_ATOM(resizeafter, "resizeafter")
-XUL_ATOM(state, "state")
-
-// toolbar & toolbar d&d atoms
-XUL_ATOM(tbDropLocation, "tb-droplocation")
-XUL_ATOM(tbDropLocationCoord, "tb-droplocationcoord")
-XUL_ATOM(tbDropOn, "tb-dropon")
-XUL_ATOM(tbTriggerRepaint, "tb-triggerrepaint")
-XUL_ATOM(container, "container")
-
-
-XUL_ATOM(widget, "widget")
-XUL_ATOM(window, "window")
-
-XUL_ATOM(iframe, "iframe")
-XUL_ATOM(browser, "browser")
-XUL_ATOM(editor, "editor")
-

mozilla/content/shared/public/nsXULAtoms.h

@@ -1,54 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-#ifndef nsXULAtoms_h___
-#define nsXULAtoms_h___
-
-#include "prtypes.h"
-#include "nsIAtom.h"
-
-class nsINameSpaceManager;
-
-/**
- * This class wraps up the creation and destruction of the standard
- * set of xul atoms used during normal xul handling. This object
- * is created when the first xul content object is created, and
- * destroyed when the last such content object is destroyed.
- */
-class nsXULAtoms {
-public:
-
-  static void AddRefAtoms();
-  static void ReleaseAtoms();
-
-  // XUL namespace ID, good for the life of the nsXULAtoms object
-  static PRInt32  nameSpaceID;
-
-  /* Declare all atoms
-
-     The atom names and values are stored in nsCSSAtomList.h and
-     are brought to you by the magic of C preprocessing
-
-     Add new atoms to nsCSSAtomList and all support logic will be auto-generated
-   */
-#define XUL_ATOM(_name, _value) static nsIAtom* _name;
-#include "nsXULAtomList.h"
-#undef XUL_ATOM
-
-};
-
-#endif /* nsXULAtoms_h___ */

mozilla/content/shared/src/nsXULAtoms.cpp

@@ -1,68 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#include "nsString.h"
-#include "nsINameSpaceManager.h"
-#include "nsXULAtoms.h"
-
-static const char kXULNameSpace[] = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
-
-PRInt32  nsXULAtoms::nameSpaceID;
-
-// define storage for all atoms
-#define XUL_ATOM(_name, _value) nsIAtom* nsXULAtoms::_name;
-#include "nsXULAtomList.h"
-#undef XUL_ATOM
-
-
-static nsrefcnt gRefCnt = 0;
-static nsINameSpaceManager* gNameSpaceManager;
-
-void nsXULAtoms::AddRefAtoms() {
-
-  if (gRefCnt == 0) {
-    /* XUL Atoms registers the XUL name space ID because it's a convenient
-       place to do this, if you don't want a permanent, "well-known" ID.
-    */
-    if (NS_SUCCEEDED(NS_NewNameSpaceManager(&gNameSpaceManager))) {
-//    gNameSpaceManager->CreateRootNameSpace(namespace);
-      nsAutoString nameSpace(kXULNameSpace);
-      gNameSpaceManager->RegisterNameSpace(nameSpace, nameSpaceID);
-    } else {
-      NS_ASSERTION(0, "failed to create xul atoms namespace manager");
-    }
-
-    // now register the atoms
-#define XUL_ATOM(_name, _value) _name = NS_NewAtom(_value);
-#include "nsXULAtomList.h"
-#undef XUL_ATOM
-  }
-  ++gRefCnt;
-}
-
-void nsXULAtoms::ReleaseAtoms() {
-
-  NS_PRECONDITION(gRefCnt != 0, "bad release of xul atoms");
-  if (--gRefCnt == 0) {
-#define XUL_ATOM(_name, _value) NS_RELEASE(_name);
-#include "nsXULAtomList.h"
-#undef XUL_ATOM
-
-    NS_IF_RELEASE(gNameSpaceManager);
-  }
-}

mozilla/ef/Compiler/RegisterAllocator/BitSet.cpp

@@ -0,0 +1,134 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "BitSet.h"
+
+// Return the next bit after index set to true or -1 if none.
+//
+Int32 BitSet::nextOne(Int32 pos) const
+{
+	++pos;
+
+	if (pos < 0 || Uint32(pos) >= universeSize)
+		return -1;
+
+	Uint32 offset = getWordOffset(pos);
+	Uint8 index = getBitOffset(pos);
+	Word* ptr = &word[offset];
+	Word currentWord = *ptr++ >> index;
+	
+	if (currentWord != Word(0)) {
+		while ((currentWord & Word(1)) == 0) {
+			++index;
+			currentWord >>= 1;
+		}
+		return (offset << nBitsInWordLog2) + index;
+	}
+
+	Word* limit = &word[getSizeInWords(universeSize)];
+	while (ptr < limit) {
+		++offset;
+		currentWord = *ptr++;
+		if (currentWord != Word(0)) {
+			index = 0;
+			while ((currentWord & Word(1)) == 0) {
+				++index;
+				currentWord >>= 1;
+			}
+			return (offset << nBitsInWordLog2) + index;
+		}
+	}
+	return -1;
+}
+
+// Return the next bit after index set to false or -1 if none.
+//
+Int32 BitSet::nextZero(Int32 pos) const
+{
+	++pos;
+
+	if (pos < 0 || Uint32(pos) >= universeSize)
+		return -1;
+
+	Uint32 offset = getWordOffset(pos);
+	Uint8 index = getBitOffset(pos);
+	Word* ptr = &word[offset];
+	Word currentWord = *ptr++ >> index;
+	
+	if (currentWord != Word(~0)) {
+		for (; index < nBitsInWord; ++index) {
+			if ((currentWord & Word(1)) == 0) {
+				Int32 ret = (offset << nBitsInWordLog2) + index;
+				return (Uint32(ret) < universeSize) ? ret : -1;
+			}
+			currentWord >>= 1;
+		}
+	}
+
+	Word* limit = &word[getSizeInWords(universeSize)];
+	while (ptr < limit) {
+		++offset;
+		currentWord = *ptr++;
+		if (currentWord != Word(~0)) {
+			for (index = 0; index < nBitsInWord; ++index) {
+				if ((currentWord & Word(1)) == 0) {
+					Int32 ret = (offset << nBitsInWordLog2) + index;
+					return (Uint32(ret) < universeSize) ? ret : -1;
+				}
+				currentWord >>= 1;
+			}
+		}
+	}
+	return -1;
+}
+
+#ifdef DEBUG_LOG
+
+// Print the set.
+//
+void BitSet::printPretty(LogModuleObject log)
+{
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("[ "));
+
+	for (Int32 i = firstOne(); i != -1; i = nextOne(i)) {
+		Int32 currentBit = i;
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("%d", currentBit));
+
+		Int32 nextBit = nextOne(currentBit);
+		if (nextBit != currentBit + 1) {
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, (" "));
+			continue;
+		}
+		  
+		while ((nextBit != -1) && (nextBit == (currentBit + 1))) {
+			currentBit = nextBit;
+			nextBit = nextOne(nextBit);
+		}
+
+		if (currentBit > (i+1))
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("-%d ", currentBit));
+		else
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, (" %d ", currentBit));
+
+		i = currentBit;
+	}
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("]\n"));
+}
+
+#endif // DEBUG_LOG

mozilla/ef/Compiler/RegisterAllocator/BitSet.h

@@ -0,0 +1,195 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _BITSET_H_
+#define _BITSET_H_
+
+#include "Fundamentals.h"
+#include "LogModule.h"
+#include "Pool.h"
+#include <string.h>
+
+//------------------------------------------------------------------------------
+// BitSet -
+
+class BitSet
+{
+private:
+
+#if (PR_BITS_PER_WORD == 64)
+	typedef Uint64 Word;
+#elif (PR_BITS_PER_WORD == 32)
+	typedef Uint32 Word;
+#endif
+
+	static const nBitsInWord = 		PR_BITS_PER_WORD;
+	static const nBytesInWord = 	PR_BYTES_PER_WORD;
+	static const nBitsInWordLog2 =	PR_BITS_PER_WORD_LOG2;
+	static const nBytesInWordLog2 = PR_BYTES_PER_WORD_LOG2;
+
+	// Return the number of Word need to store the universe.
+	static Uint32 getSizeInWords(Uint32 sizeOfUniverse) {return (sizeOfUniverse + (nBitsInWord - 1)) >> nBitsInWordLog2;}
+	// Return the given element offset in its containing Word.
+	static Uint32 getBitOffset(Uint32 element) {return element & (nBitsInWord - 1);}
+	// Return the Word offset for the given element int the universe.
+	static Uint32 getWordOffset(Uint32 element) {return element >> nBitsInWordLog2;}
+	// Return the mask for the given bit index.
+	static Word getMask(Uint8 index) {return Word(1) << index;}
+	
+private:
+
+	Uint32							universeSize;			// Size of the universe
+	Word*							word;					// universe memory.
+
+private:
+
+	// No copy constructor.
+	BitSet(const BitSet&);
+
+	// Check if the given set's universe is of the same size than this universe.
+	void checkUniverseCompatibility(const BitSet& set) const {assert(set.universeSize == universeSize);}
+	// Check if pos is valid for this set's universe.
+	void checkMember(Int32 pos) const {assert(pos >=0 && Uint32(pos) < universeSize);}
+
+public:
+
+	// Create a bitset of universeSize bits.
+	BitSet(Pool& pool, Uint32 universeSize) : universeSize(universeSize) {word = new(pool) Word[getSizeInWords(universeSize)]; clear();}
+
+	// Return the size of this bitset.
+	Uint32 getSize() const {return universeSize;}
+
+	// Clear the bitset.
+	void clear() {memset(word, 0x00, getSizeInWords(universeSize) << nBytesInWordLog2);}
+	// Clear the bit at index.
+	void clear(Uint32 index) {checkMember(index); word[getWordOffset(index)] &= ~getMask(index);}
+	// Set the bitset.
+	void set() {memset(word, 0xFF, getSizeInWords(universeSize) << nBytesInWordLog2);}
+	// Set the bit at index.
+	void set(Uint32 index) {checkMember(index); word[getWordOffset(index)] |= getMask(index);}
+	// Return true if the bit at index is set.
+	bool test(Uint32 index) const {checkMember(index); return (word[getWordOffset(index)] & getMask(index)) != 0;}
+	// Union with the given bitset.
+	inline void or(const BitSet& set);
+	// Intersection with the given bitset.
+	inline void and(const BitSet& set);
+	// Difference with the given bitset.
+	inline void difference(const BitSet& set);
+	// Copy set.
+	inline BitSet& operator = (const BitSet& set);
+	// Return true if the bitset are identical.
+	friend bool operator == (const BitSet& set1, const BitSet& set2);
+	// Return true if the bitset are different.
+	friend bool operator != (const BitSet& set1, const BitSet& set2);
+
+	// Logical operators.
+	BitSet& operator |= (const BitSet& set) {or(set); return *this;}
+	BitSet& operator &= (const BitSet& set) {and(set); return *this;}
+	BitSet& operator -= (const BitSet& set) {difference(set); return *this;}
+
+	// Return the first bit at set to true or -1 if none.
+	Int32 firstOne() const {return nextOne(-1);}
+	// Return the next bit after index set to true or -1 if none.
+	Int32 nextOne(Int32 pos) const;
+	// Return the first bit at set to false or -1 if none.
+	Int32 firstZero() const {return nextZero(-1);}
+	// Return the next bit after index set to false or -1 if none.
+	Int32 nextZero(Int32 pos) const;
+
+	// Iterator to conform with the set API.
+	typedef Int32 iterator;
+	// Return true if the walk is ordered.
+	static bool isOrdered() {return true;}
+	// Return the iterator for the first element of this set.
+	iterator begin() const {return firstOne();}
+	// Return the next iterator.
+	iterator advance(iterator pos) const {return nextOne(pos);}
+	// Return true if the iterator is at the end of the set.
+	bool done(iterator pos) const {return pos == -1;}
+	// Return the element corresponding to the given iterator.
+	Uint32 get(iterator pos) const {return pos;}
+
+#ifdef DEBUG_LOG
+	// Print the set.
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+// Union with the given bitset.
+//
+inline void  BitSet::or(const BitSet& set)
+{
+	checkUniverseCompatibility(set);
+	Word* src = set.word;
+	Word* dst = word;
+	Word* limit = &src[getSizeInWords(universeSize)];
+
+	while (src < limit)
+		*dst++ |= *src++;
+}
+
+// Intersection with the given bitset.
+//
+inline void  BitSet::and(const BitSet& set)
+{
+	checkUniverseCompatibility(set);
+	Word* src = set.word;
+	Word* dst = word;
+	Word* limit = &src[getSizeInWords(universeSize)];
+
+	while (src < limit)
+		*dst++ &= *src++;
+}
+
+// Difference with the given bitset.
+//
+inline void BitSet::difference(const BitSet& set)
+{
+	checkUniverseCompatibility(set);
+	Word* src = set.word;
+	Word* dst = word;
+	Word* limit = &src[getSizeInWords(universeSize)];
+
+	while (src < limit)
+		*dst++ &= ~*src++;
+}
+
+// Copy the given set into this set.
+//
+inline BitSet& BitSet::operator = (const BitSet& set)
+{
+	checkUniverseCompatibility(set);
+	if (this != &set)
+		memcpy(word, set.word, getSizeInWords(universeSize) << nBytesInWordLog2);
+	return *this;
+}
+
+// Return true if the given set is identical to this set.
+inline bool operator == (const BitSet& set1, const BitSet& set2)
+{
+	set1.checkUniverseCompatibility(set2);
+
+	if (&set1 == &set2)
+		return true;
+
+	return memcmp(set1.word, set2.word, BitSet::getSizeInWords(set1.universeSize) << BitSet::nBytesInWordLog2) == 0;
+}
+
+inline bool operator != (const BitSet& set1, const BitSet& set2) {return !(set1 == set2);}
+
+#endif // _BITSET_H

mozilla/ef/Compiler/RegisterAllocator/Coalescing.h

@@ -0,0 +1,159 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _COALESCING_H_
+#define _COALESCING_H_
+
+#include "Fundamentals.h"
+#include "Pool.h"
+#include "RegisterPressure.h"
+#include "InterferenceGraph.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "SparseSet.h"
+#include "RegisterAllocator.h"
+#include "RegisterAllocatorTools.h"
+
+#if 1
+// Performing an ultra conservative coalescing meens that when we look at
+// candidates (source,destination) for coalescing we need to make sure
+// that the combined interference of the source and destination register
+// will not exceed the total number of register available for the register
+// class. 
+#define ULTRA_CONSERVATIVE_COALESCING
+#else
+// If we are not doing an ultra conservative coalescing we have to make sure 
+// that the total number of neighbor whose degree is greater than the total 
+// number of register is not greater than the total number of register.
+#undef ULTRA_CONSERVATIVE_COALESCING
+#endif
+
+template <class RegisterPressure>
+struct Coalescing
+{
+	static bool coalesce(RegisterAllocator& registerAllocator);
+};
+
+template <class RegisterPressure>
+bool Coalescing<RegisterPressure>::coalesce(RegisterAllocator& registerAllocator)
+{
+	Pool& pool = registerAllocator.pool;
+
+   	// Initialize the lookup table
+	//
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	RegisterName* newRange = new RegisterName[2 * rangeCount];
+	RegisterName* coalescedRange = &newRange[rangeCount];
+	RegisterName* name2range = registerAllocator.name2range;
+
+	init(coalescedRange, rangeCount);
+
+	SparseSet interferences(pool, rangeCount);
+	InterferenceGraph<RegisterPressure>& iGraph = registerAllocator.iGraph;
+	bool removedInstructions = false;
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.lndList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+
+	// Walk the nodes in the loop nesting depth list.
+	for (Int32 n = nNodes - 1; n >= 0; n--) {
+		InstructionList& instructions = nodes[n]->getInstructions();
+
+		InstructionList::iterator it = instructions.begin();
+		while (!instructions.done(it)) {
+			Instruction& instruction = instructions.get(it);
+			it = instructions.advance(it);
+
+			if ((instruction.getFlags() & ifCopy) != 0) {
+				assert(instruction.getInstructionUseBegin() != instruction.getInstructionUseEnd() && instruction.getInstructionUseBegin()[0].isRegister());
+				assert(instruction.getInstructionDefineBegin() != instruction.getInstructionDefineEnd() && instruction.getInstructionDefineBegin()[0].isRegister());
+
+				RegisterName source = findRoot(name2range[instruction.getInstructionUseBegin()[0].getRegisterName()], coalescedRange);
+				RegisterName destination = findRoot(name2range[instruction.getInstructionDefineBegin()[0].getRegisterName()], coalescedRange);
+
+				if (source == destination) {
+					instruction.remove();
+				} else if (!iGraph.interfere(source, destination)) {
+					InterferenceVector* sourceVector = iGraph.getInterferenceVector(source);
+					InterferenceVector* destinationVector = iGraph.getInterferenceVector(destination);
+
+#ifdef ULTRA_CONSERVATIVE_COALESCING
+					interferences.clear();
+
+					InterferenceVector* vector;
+					for (vector = sourceVector; vector != NULL; vector = vector->next) {
+						RegisterName* neighbors = vector->neighbors;
+						for (Uint32 i = 0; i < vector->count; i++)
+							interferences.set(findRoot(neighbors[i], coalescedRange));
+					}
+					for (vector = destinationVector; vector != NULL; vector = vector->next) {
+						RegisterName* neighbors = vector->neighbors;
+						for (Uint32 i = 0; i < vector->count; i++)
+							interferences.set(findRoot(neighbors[i], coalescedRange));
+					}
+
+					Uint32 count = interferences.getSize();
+#else // ULTRA_CONSERVATIVE_COALESCING
+					trespass("not implemented");
+					Uint32 count = 0;
+#endif // ULTRA_CONSERVATIVE_COALESCING
+
+					if (count < 6 /* FIX: should get the number from the class */) {
+						// Update the interferences vector.
+						if (sourceVector == NULL) {
+							iGraph.setInterferenceVector(source, destinationVector);
+							sourceVector = destinationVector;
+						} else if (destinationVector == NULL)
+							iGraph.setInterferenceVector(destination, sourceVector);
+						else {
+							InterferenceVector* last = NULL;
+							for (InterferenceVector* v = sourceVector; v != NULL; v = v->next)
+								last = v;
+							assert(last);
+							last->next = destinationVector;
+							iGraph.setInterferenceVector(destination, sourceVector);
+						}
+						// Update the interference matrix.
+						for (InterferenceVector* v = sourceVector; v != NULL; v = v->next) {
+							RegisterName* neighbors = v->neighbors;
+							for (Uint32 i = 0; i < v->count; i++) {
+								RegisterName neighbor = findRoot(neighbors[i], coalescedRange);
+								iGraph.setInterference(neighbor, source);
+								iGraph.setInterference(neighbor, destination);
+							}
+						}
+
+						instruction.remove();
+						coalescedRange[source] = destination;
+						removedInstructions = true;
+					}
+				}
+			}
+		}
+	}
+
+	registerAllocator.rangeCount = compress(registerAllocator.name2range, coalescedRange, registerAllocator.nameCount, rangeCount);
+	delete newRange;
+
+	return removedInstructions;
+}
+
+#endif // _COALESCING_H_

mozilla/ef/Compiler/RegisterAllocator/Coloring.cpp

@@ -0,0 +1,283 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef NEW_LAURENTM_CODE
+
+#include "Coloring.h"
+#include "VirtualRegister.h"
+#include "FastBitSet.h"
+#include "FastBitMatrix.h"
+#include "CpuInfo.h"
+
+bool Coloring::
+assignRegisters(FastBitMatrix& interferenceMatrix)
+{
+  PRUint32 *stackPtr = new(pool) PRUint32[vRegManager.count()];
+
+  return select(interferenceMatrix, stackPtr, simplify(interferenceMatrix, stackPtr));
+}
+
+PRInt32 Coloring::
+getLowestSpillCostRegister(FastBitSet& bitset)
+{
+  PRInt32 lowest = bitset.firstOne();
+  if (lowest != -1)
+	{
+	  Flt32 cost = vRegManager.getVirtualRegister(lowest).spillInfo.spillCost;
+	  for (PRInt32 r = bitset.nextOne(lowest); r != -1; r = bitset.nextOne(r))
+		{
+		  VirtualRegister& vReg = vRegManager.getVirtualRegister(r);
+		  if (!vReg.spillInfo.infiniteSpillCost && (vReg.spillInfo.spillCost < cost))
+			{
+			  cost = vReg.spillInfo.spillCost;
+			  lowest = r;
+			}
+		}
+	}
+  return lowest;
+}
+
+PRUint32* Coloring::
+simplify(FastBitMatrix interferenceMatrix, PRUint32* stackPtr)
+{
+  // first we construct the sets low and high. low contains all nodes of degree
+  // inferior to the number of register available on the processor. All the
+  // nodes with an high degree and a finite spill cost are placed in high.
+  // Nodes of high degree and infinite spill cost are not included in either sets.
+
+  PRUint32 nRegisters = vRegManager.count();
+  FastBitSet low(pool, nRegisters);
+  FastBitSet high(pool, nRegisters);
+  FastBitSet stack(pool, nRegisters);
+
+  for (VirtualRegisterManager::iterator i = vRegManager.begin(); !vRegManager.done(i); i = vRegManager.advance(i))
+	{
+	  VirtualRegister& vReg = vRegManager.getVirtualRegister(i);
+	  
+	  if (vReg.getClass() == vrcStackSlot)
+		{
+		  stack.set(i);
+		  vReg.colorRegister(nRegisters);
+		}
+	  else
+		{
+		  if (vReg.colorInfo.interferenceDegree < NUMBER_OF_REGISTERS)
+			low.set(i);
+		  else // if (!vReg.spillInfo.infiniteSpillCost)
+			high.set(i);
+
+		  // Set coloring info.
+		  vReg.spillInfo.willSpill = false;
+
+		  switch(vReg.getClass())
+			{
+			case vrcInteger:
+			  vReg.colorRegister(LAST_GREGISTER + 1);
+			  break;
+			case vrcFloatingPoint:
+			case vrcFixedPoint:
+			  vReg.colorRegister(LAST_FPREGISTER + 1);
+			  break;
+			default:
+			  PR_ASSERT(false); // Cannot happen.
+			}
+		}
+	}
+
+  // push the stack registers
+  PRInt32 j;
+  for (j = stack.firstOne(); j != -1; j = stack.nextOne(j))
+	*stackPtr++ = j;
+
+  // simplify
+  while (true)
+	{
+	  PRInt32 r;
+	  while ((r = getLowestSpillCostRegister(low)) != -1)
+		{
+		  VirtualRegister& vReg = vRegManager.getVirtualRegister(r);
+
+		  /* update low and high */
+		  FastBitSet inter(interferenceMatrix.getRow(r), nRegisters);
+		  for (j = inter.firstOne(); j != -1; j = inter.nextOne(j))
+			{
+			  VirtualRegister& neighbor = vRegManager.getVirtualRegister(j);
+			  // if the new interference degree of one of his neighbor becomes
+			  // NUMBER_OF_REGISTERS - 1 then it is added to the set 'low'.
+			  
+			  PRUint32 maxInterference = 0;
+			  switch (neighbor.getClass())
+				{
+				case vrcInteger:
+				  maxInterference = NUMBER_OF_GREGISTERS;
+				  break;
+				case vrcFloatingPoint:
+				case vrcFixedPoint:
+				  maxInterference = NUMBER_OF_FPREGISTERS;
+				  break;
+				default:
+				  PR_ASSERT(false);
+				}
+			  if ((vRegManager.getVirtualRegister(j).colorInfo.interferenceDegree-- == maxInterference))
+				{
+				  high.clear(j);
+				  low.set(j);
+				}
+			  vReg.colorInfo.interferenceDegree--;
+			  interferenceMatrix.clear(r, j);
+			  interferenceMatrix.clear(j, r);
+			}
+		  low.clear(r);
+
+		  // Push this register.
+		  *stackPtr++ = r;
+		}
+	  if ((r = getLowestSpillCostRegister(high)) != -1)
+		{
+		  high.clear(r);
+		  low.set(r);
+		}
+	  else
+		break;
+	}
+
+  return stackPtr;
+}
+
+bool Coloring::
+select(FastBitMatrix& interferenceMatrix, PRUint32* stackBase, PRUint32* stackPtr)
+{
+  PRUint32 nRegisters = vRegManager.count();
+  FastBitSet usedRegisters(NUMBER_OF_REGISTERS + 1); // usedRegisters if used for both GR & FPR.
+  FastBitSet preColoredRegisters(NUMBER_OF_REGISTERS + 1);
+  FastBitSet usedStack(nRegisters + 1);
+  bool success = true;
+  Int32 lastUsedSSR = -1;
+
+  // select
+  while (stackPtr != stackBase)
+	{
+	  // Pop one register.
+	  PRUint32 r = *--stackPtr;
+	  VirtualRegister& vReg = vRegManager.getVirtualRegister(r);
+
+	  FastBitSet neighbors(interferenceMatrix.getRow(r), nRegisters);
+		  
+	  if (vReg.getClass() == vrcStackSlot)
+		// Stack slots coloring.
+		{
+		  usedStack.clear();
+
+		  for (PRInt32 i = neighbors.firstOne(); i != -1; i = neighbors.nextOne(i))
+			usedStack.set(vRegManager.getVirtualRegister(i).getColor());
+
+		  Int32 color = usedStack.firstZero();
+		  vReg.colorRegister(color);
+		  if (color > lastUsedSSR)
+			  lastUsedSSR = color;
+		}
+	  else
+		// Integer & Floating point register coloring.
+		{
+		  usedRegisters.clear();
+		  preColoredRegisters.clear();
+		  
+		  for (PRInt32 i = neighbors.firstOne(); i != -1; i = neighbors.nextOne(i))
+			{
+			  VirtualRegister& nvReg = vRegManager.getVirtualRegister(i);
+			  usedRegisters.set(nvReg.getColor());
+			  if (nvReg.isPreColored())
+				preColoredRegisters.set(nvReg.getPreColor());
+			}
+		  if (vReg.hasSpecialInterference)
+			usedRegisters |= vReg.specialInterference;
+
+		  PRInt8 c = -1;
+		  PRInt8 maxColor = 0;
+		  PRInt8 firstColor = 0;
+		  switch (vReg.getClass())
+			{
+			case vrcInteger:
+			  firstColor = FIRST_GREGISTER;
+			  maxColor = LAST_GREGISTER;
+			  break;
+			case vrcFloatingPoint:
+			case vrcFixedPoint:
+			  firstColor = FIRST_FPREGISTER;
+			  maxColor = LAST_FPREGISTER;
+			  break;
+			default:
+			  PR_ASSERT(false);
+			}
+
+		  if (vReg.isPreColored())
+			{
+			  c = vReg.getPreColor();
+			  if (usedRegisters.test(c))
+				c = -1;
+			}
+		  else
+			{
+			  for (c = usedRegisters.nextZero(firstColor - 1); (c >= 0) && (c <= maxColor) && (preColoredRegisters.test(c)); 
+				   c = usedRegisters.nextZero(c)) {}
+			}
+
+		  if ((c >= 0) && (c <= maxColor))
+			{
+			  vReg.colorRegister(c);
+			}
+		  else
+			{
+			  VirtualRegister& stackRegister = vRegManager.newVirtualRegister(vrcStackSlot);
+			  vReg.equivalentRegister[vrcStackSlot] = &stackRegister;	  
+			  vReg.spillInfo.willSpill = true;
+			  success = false;
+			}
+		}
+	}
+  
+#ifdef DEBUG
+  if (success)
+	{
+	  for (VirtualRegisterManager::iterator i = vRegManager.begin(); !vRegManager.done(i); i = vRegManager.advance(i))
+		{
+		  VirtualRegister& vReg = vRegManager.getVirtualRegister(i);
+		  switch (vReg.getClass())
+			{
+			case vrcInteger:
+			  if (vReg.getColor() > LAST_GREGISTER)
+				PR_ASSERT(false);
+			  break;
+			case vrcFloatingPoint:
+			case vrcFixedPoint:
+#if NUMBER_OF_FPREGISTERS != 0
+			  if (vReg.getColor() > LAST_FPREGISTER)
+				PR_ASSERT(false);
+#endif
+			  break;
+			default:
+			  break;
+			}
+		}
+	}
+#endif
+
+  vRegManager.nUsedStackSlots = lastUsedSSR + 1;
+  return success;
+}
+#endif // NEW_LAURENTM_CODE

mozilla/ef/Compiler/RegisterAllocator/Coloring.h

@@ -0,0 +1,284 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "RegisterAllocator.h"
+#include "VirtualRegister.h"
+#include "InterferenceGraph.h"
+#include "SparseSet.h"
+#include "Spilling.h"
+#include "Splits.h"
+
+UT_EXTERN_LOG_MODULE(RegAlloc);
+
+template <class RegisterPressure>
+class Coloring
+{
+private:
+	static RegisterName* simplify(RegisterAllocator& registerAllocator, RegisterName* coloringStack);
+	static bool select(RegisterAllocator& registerAllocator, RegisterName* coloringStack, RegisterName* coloringStackPtr);
+
+public:
+	static bool color(RegisterAllocator& registerAllocator);
+	static void finalColoring(RegisterAllocator& registerAllocator);
+};
+
+
+template <class RegisterPressure>
+void Coloring<RegisterPressure>::finalColoring(RegisterAllocator& registerAllocator)
+{
+	RegisterName* color = registerAllocator.color;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		InstructionList& instructions = nodes[n]->getInstructions();
+
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					usePtr->setRegisterName(color[name2range[usePtr->getRegisterName()]]);
+#ifdef DEBUG
+					RegisterID rid = usePtr->getRegisterID();
+					setColoredRegister(rid);
+					usePtr->setRegisterID(rid);
+#endif // DEBUG
+				}
+
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister()) {
+					definePtr->setRegisterName(color[name2range[definePtr->getRegisterName()]]);
+#ifdef DEBUG
+					RegisterID rid = definePtr->getRegisterID();
+					setColoredRegister(rid);
+					definePtr->setRegisterID(rid);
+#endif // DEBUG
+				}
+		}
+	}
+}
+
+template <class RegisterPressure>
+bool Coloring<RegisterPressure>::select(RegisterAllocator& registerAllocator, RegisterName* coloringStack, RegisterName* coloringStackPtr)
+{
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	RegisterName* color = new RegisterName[rangeCount];
+	registerAllocator.color = color;
+
+	for (Uint32 r = 1; r < rangeCount; r++)
+		color[r] = RegisterName(6); // FIX;
+
+	// Color the preColored registers.
+	//
+	VirtualRegisterManager& vrManager = registerAllocator.vrManager;
+	RegisterName* name2range = registerAllocator.name2range;
+	PreColoredRegister* machineEnd = vrManager.getMachineRegistersEnd();
+	for (PreColoredRegister* machinePtr = vrManager.getMachineRegistersBegin(); machinePtr < machineEnd; machinePtr++)
+		if (machinePtr->id != invalidID) {
+			color[name2range[getName(machinePtr->id)]] = machinePtr->color;
+			UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\twill preColor range %d as %d\n", name2range[getName(machinePtr->id)], machinePtr->color));
+		}
+
+	SpillCost* cost = registerAllocator.spillCost;
+	Pool& pool = registerAllocator.pool;
+	SparseSet& spill = *new(pool) SparseSet(pool, rangeCount);
+	registerAllocator.willSpill = &spill;
+	SparseSet neighborColors(pool, 6); // FIX
+	InterferenceGraph<RegisterPressure>& iGraph = registerAllocator.iGraph;
+
+	bool coloringFailed = false;
+	while (coloringStackPtr > coloringStack) {
+		RegisterName range = *--coloringStackPtr;
+
+		if (!cost[range].infinite && cost[range].cost < 0) {
+			coloringFailed = true;
+			spill.set(range);
+			UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\tfailed to color %d, will spill.\n", range));
+		} else {
+			neighborColors.clear();
+
+			for (InterferenceVector* vector = iGraph.getInterferenceVector(range); vector != NULL; vector = vector->next)
+				for (Int32 i = vector->count - 1; i >= 0; --i) {
+					RegisterName neighborColor = color[vector->neighbors[i]];
+					if (neighborColor < 6) // FIX
+						neighborColors.set(neighborColor);
+				}
+
+			if (neighborColors.getSize() == 6) { // FIX
+				coloringFailed = true;
+				UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\tfailed to color %d, ", range));
+
+				if (!Splits<RegisterPressure>::findSplit(registerAllocator, color, range)) {
+					UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("will spill.\n"));
+					spill.set(range);
+				} else
+					UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("will split.\n"));
+			} else {
+				for (Uint32 i = 0; i < 6; i++) // FIX
+					if (!neighborColors.test(i)) {
+						fprintf(stdout, "\twill color %d as %d\n", range, i);
+						color[range] = RegisterName(i);
+						break;
+					}
+			}
+		}
+	}
+
+#ifdef DEBUG_LOG
+	if (coloringFailed) {
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("Coloring failed:\n"));
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\twill spill: "));
+		spill.printPretty(UT_LOG_MODULE(RegAlloc));
+	} else {
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("Coloring succeeded:\n"));
+		for (Uint32 i = 1; i < rangeCount; i++)
+			UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\trange %d colored as %d\n", i, color[i]));
+	}
+#endif
+
+	return !coloringFailed;
+}
+
+template <class RegisterPressure>
+RegisterName* Coloring<RegisterPressure>::simplify(RegisterAllocator& registerAllocator, RegisterName* coloringStack)
+{
+	InterferenceGraph<RegisterPressure>& iGraph = registerAllocator.iGraph;
+	SpillCost* spillCost = registerAllocator.spillCost;
+	Uint32 rangeCount = registerAllocator.rangeCount;
+
+	Uint32* degree = new Uint32[rangeCount];
+	for (RegisterName i = RegisterName(1); i < rangeCount; i = RegisterName(i + 1)) {
+		InterferenceVector* vector = iGraph.getInterferenceVector(i);
+		degree[i] = (vector != NULL) ? vector->count : 0;
+	}
+
+	Pool& pool = registerAllocator.pool;
+	SparseSet low(pool, rangeCount);
+	SparseSet high(pool, rangeCount);
+	SparseSet highInfinite(pool, rangeCount);
+	SparseSet preColored(pool, rangeCount);
+
+	// Get the precolored registers.
+	//
+	VirtualRegisterManager& vrManager = registerAllocator.vrManager;
+	RegisterName* name2range = registerAllocator.name2range;
+	PreColoredRegister* machineEnd = vrManager.getMachineRegistersEnd();
+	for (PreColoredRegister* machinePtr = vrManager.getMachineRegistersBegin(); machinePtr < machineEnd; machinePtr++)
+		if (machinePtr->id != invalidID)
+			preColored.set(name2range[getName(machinePtr->id)]);
+
+	// Insert the live ranges in the sets.
+	//
+	for (Uint32 range = 1; range < rangeCount; range++)
+		if (!preColored.test(range))
+			if (degree[range] < 6) // FIX
+				low.set(range);
+			else if (!spillCost[range].infinite)
+				high.set(range);
+			else
+				highInfinite.set(range);
+
+#ifdef DEBUG_LOG
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("Coloring sets:\n\tlow = "));
+	low.printPretty(UT_LOG_MODULE(RegAlloc));
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\thigh = "));
+	high.printPretty(UT_LOG_MODULE(RegAlloc));
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\thighInfinite = "));
+	highInfinite.printPretty(UT_LOG_MODULE(RegAlloc));
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\tpreColored = "));
+	preColored.printPretty(UT_LOG_MODULE(RegAlloc));
+#endif // DEBUG_LOG
+
+	RegisterName* coloringStackPtr = coloringStack;
+
+	while (low.getSize() != 0 || high.getSize() != 0) {
+		while (low.getSize() != 0) {
+			RegisterName range = RegisterName(low.getOne());
+			low.clear(range);
+			*coloringStackPtr++ = range;
+
+			for (InterferenceVector* vector = iGraph.getInterferenceVector(range); vector != NULL; vector = vector->next)
+				for (Int32 i = (vector->count - 1); i >= 0; --i) {
+					RegisterName neighbor = vector->neighbors[i];
+					degree[neighbor]--;
+
+					if (degree[neighbor] < 6) // FIX
+						if (high.test(neighbor)) {
+							high.clear(neighbor);
+							low.set(neighbor);
+						} else if (highInfinite.test(neighbor)) {
+							highInfinite.clear(neighbor);
+							low.set(neighbor);
+						}
+				}
+		}
+
+		if (high.getSize() != 0) {
+			RegisterName best = RegisterName(high.getOne());
+			double bestCost = spillCost[best].cost;
+			double bestDegree = degree[best];
+
+			// Choose the next best candidate.
+			//
+			for (SparseSet::iterator i = high.begin(); !high.done(i); i = high.advance(i)) {
+				RegisterName range = RegisterName(high.get(i));
+				double thisCost = spillCost[range].cost;
+				double thisDegree = degree[range];
+
+				if (thisCost * bestDegree < bestCost * thisDegree) {
+					best = range;
+					bestCost = thisCost;
+					bestDegree = thisDegree;
+				}
+			}
+			
+			high.clear(best);
+			low.set(best);
+		}
+ 	}
+	assert(highInfinite.getSize() == 0);
+
+	delete degree;
+
+#ifdef DEBUG_LOG
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("Coloring stack:\n\t"));
+	for (RegisterName* sp = coloringStack; sp < coloringStackPtr; ++sp)
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("%d ", *sp));
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\n"));
+#endif // DEBUG_LOG
+
+	return coloringStackPtr;
+}
+
+
+template <class RegisterPressure>
+bool Coloring<RegisterPressure>::color(RegisterAllocator& registerAllocator)
+{
+	RegisterName* coloringStack = new RegisterName[registerAllocator.rangeCount];
+	return select(registerAllocator, coloringStack, simplify(registerAllocator, coloringStack));
+}

mozilla/ef/Compiler/RegisterAllocator/DominatorGraph.cpp

@@ -0,0 +1,212 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include <string.h>
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+
+#include "DominatorGraph.h"
+
+DominatorGraph::DominatorGraph(ControlGraph& controlGraph) : controlGraph(controlGraph)
+{
+	Uint32 nNodes = controlGraph.nNodes;
+
+	GtoV = new Uint32[nNodes + 1];
+	VtoG = new Uint32[nNodes + 1];
+
+	Uint32 v = 1;
+	for (Uint32 n = 0; n < nNodes; n++) {
+		VtoG[v] = n;
+		GtoV[n] = v++;
+	}
+
+	// Initialize all the 1-based arrays.
+	//
+	parent =	new Uint32[v];
+	semi =		new Uint32[v];
+	vertex =	new Uint32[v];
+	label =		new Uint32[v];
+	size =		new Uint32[v];
+	ancestor =	new Uint32[v];
+	child =		new Uint32[v];
+	dom =		new Uint32[v];
+	bucket =	new DGLinkedList*[v];
+
+	memset(semi, '\0', v * sizeof(Uint32));
+	memset(bucket, '\0', v * sizeof(DGLinkedList*));
+
+	vCount = v;
+
+	build();
+
+	delete parent;
+	delete semi;
+	delete vertex;
+	delete label;
+	delete size;
+	delete ancestor;
+	delete child;
+	delete dom;
+	delete bucket;
+}
+
+Uint32 DominatorGraph::DFS(Uint32 vx, Uint32 n)
+{
+	semi[vx] = ++n;
+	vertex[n] = label[vx] = vx;
+	ancestor[vx] = child[vx] = 0;
+	size[vx] = 1;
+
+
+	ControlNode& node = *controlGraph.dfsList[VtoG[vx]];
+	ControlEdge* successorEnd = node.getSuccessorsEnd();
+	for (ControlEdge* successorPtr = node.getSuccessorsBegin(); successorPtr < successorEnd; successorPtr++) {
+		Uint32 w = GtoV[successorPtr->getTarget().dfsNum];
+		if (semi[w] == 0) {
+			parent[w] = vx;
+			n = DFS(w, n);
+		}
+	}
+	return n;
+}
+
+void DominatorGraph::LINK(Uint32 vx, Uint32 w)
+{
+    Uint32 s = w;
+
+	while (semi[label[w]] < semi[label[child[s]]]) {
+		if (size[s] + size[child[child[s]]] >= (size[child[s]] << 1)) {
+			ancestor[child[s]] = s;
+			child[s] = child[child[s]];
+		} else {
+			size[child[s]] = size[s];
+			s = ancestor[s] = child[s];
+		}
+	}
+	label[s] = label[w];
+	size[vx] += size[w];
+	if(size[vx] < (size[w] << 1)) {
+		Uint32 t = s;
+		s = child[vx]; 
+		child[vx] = t;
+	}
+	while( s != 0 ) {
+		ancestor[s] = vx;
+		s = child[s];
+	}
+}
+
+
+void DominatorGraph::COMPRESS(Uint32 vx)
+{
+	if(ancestor[ancestor[vx]] != 0) {
+		COMPRESS(ancestor[vx]);
+		if(semi[label[ancestor[vx]]] < semi[label[vx]])
+			label[vx] = label[ancestor[vx]];
+		ancestor[vx] = ancestor[ancestor[vx]];
+	}
+}
+
+Uint32 DominatorGraph::EVAL(Uint32 vx)
+{
+	if(ancestor[vx] == 0) 
+		return label[vx];
+	COMPRESS(vx);
+	return (semi[label[ancestor[vx]]] >= semi[label[vx]]) ? label[vx] : label[ancestor[vx]];
+}
+
+void DominatorGraph::build()
+{
+	Uint32 n = DFS(GtoV[0], 0);
+	size[0] = label[0] = semi[0];
+
+	for (Uint32 i = n; i >= 2; i--) {
+		Uint32 w = vertex[i];
+
+		ControlNode& node = *controlGraph.dfsList[VtoG[w]];
+		const DoublyLinkedList<ControlEdge>& predecessors = node.getPredecessors();
+		for (DoublyLinkedList<ControlEdge>::iterator p = predecessors.begin(); !predecessors.done(p); p = predecessors.advance(p)) {
+			Uint32 vx = GtoV[predecessors.get(p).getSource().dfsNum];
+			Uint32 u = EVAL(vx);
+
+			if(semi[u] < semi[w])
+				semi[w] = semi[u];
+		}
+
+		DGLinkedList* elem = new DGLinkedList();
+		elem->next = bucket[vertex[semi[w]]];
+		elem->index = w;
+		bucket[vertex[semi[w]]] = elem;
+
+		LINK(parent[w], w);
+
+		elem = bucket[parent[w]];
+		while(elem != NULL) {
+			Uint32 vx = elem->index;
+			Uint32 u = EVAL(vx);
+			dom[vx] = (semi[u] < semi[vx]) ? u : parent[w];
+			elem = elem->next;
+		}
+	}
+
+	memset(size, '\0', n * sizeof(Uint32));
+	Pool& pool = controlGraph.pool;
+	nodes = new(pool) DGNode[n];
+
+	for(Uint32 j = 2; j <= n; j++) {
+		Uint32 w = vertex[j];
+		Uint32 d = dom[w];
+		if(d != vertex[semi[w]]) {
+			d = dom[d];
+			dom[w] = d;
+		}
+		size[d]++;
+	}
+	dom[GtoV[0]] = 0;
+
+	for (Uint32 k = 1; k <= n; k++) {
+		DGNode& node = nodes[VtoG[k]];
+		Uint32 count = size[k];
+		node.successorsEnd = node.successorsBegin = (count) ? new(pool) Uint32[count] : (Uint32*) 0;
+	}
+
+	for (Uint32 l = 2; l <= n; l++)
+		*(nodes[VtoG[dom[l]]].successorsEnd)++ = VtoG[l];
+}
+
+#ifdef DEBUG_LOG
+void DominatorGraph::printPretty(LogModuleObject log)
+{
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Dominator Graph:\n"));
+	Uint32 nNodes = controlGraph.nNodes;
+	for (Uint32 i = 0; i < nNodes; i++) {
+		DGNode& node = nodes[i];
+		if (node.successorsBegin !=  node.successorsEnd) {
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\tN%d dominates ", i));
+			for (Uint32* successorsPtr = node.successorsBegin; successorsPtr < node.successorsEnd; successorsPtr++)
+				UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("N%d ", *successorsPtr));
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+		}
+	}
+}
+
+#endif // DEBUG_LOG
+
+
+

mozilla/ef/Compiler/RegisterAllocator/DominatorGraph.h

@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _DOMINATOR_GRAPH_H_
+#define _DOMINATOR_GRAPH_H_
+
+#include "LogModule.h"
+
+class ControlGraph;
+
+struct DGNode
+{
+	Uint32* successorsBegin;
+	Uint32* successorsEnd;
+};
+
+struct DGLinkedList
+{
+	DGLinkedList* next;
+	Uint32 index;
+};
+
+class DominatorGraph
+{
+private:
+
+	ControlGraph&	controlGraph;
+
+	Uint32			vCount;
+
+	Uint32*			VtoG;
+	Uint32*			GtoV;
+	Uint32*			parent;
+	Uint32*			semi;
+	Uint32*			vertex;
+	Uint32*			label;
+	Uint32*			size;
+	Uint32*			ancestor;
+	Uint32*			child;
+	Uint32*			dom;
+	DGLinkedList**	bucket;
+	DGNode*			nodes;
+	
+private:
+
+	void build();
+
+	Uint32 DFS(Uint32 vx, Uint32 n);
+	void LINK(Uint32 vx, Uint32 w);
+	void COMPRESS(Uint32 vx);
+	Uint32 EVAL(Uint32 vx);
+
+public:
+
+	DominatorGraph(ControlGraph& controlGraph);
+
+	Uint32* getSuccessorsBegin(Uint32 n) const {return nodes[n].successorsBegin;}
+	Uint32* getSuccessorsEnd(Uint32 n) const {return nodes[n].successorsEnd;}
+
+#ifdef DEBUG_LOG
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+#endif // _DOMINATOR_GRAPH_H_

mozilla/ef/Compiler/RegisterAllocator/HashSet.cpp

@@ -0,0 +1,20 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "HashSet.h"

mozilla/ef/Compiler/RegisterAllocator/HashSet.h

@@ -0,0 +1,97 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _HASH_SET_H_
+#define _HASH_SET_H_
+
+#include "Fundamentals.h"
+#include "Pool.h"
+#include <string.h>
+
+struct HashSetElement
+{
+	Uint32 index;
+	HashSetElement* next;
+};
+
+class HashSet
+{
+private:
+
+	static const hashSize = 64;
+
+	// Return the hash code for the given element index.
+	static Uint32 getHashCode(Uint32 index) {return index & (hashSize - 1);} // Could be better !
+
+private:
+
+	Pool&					allocationPool;
+	HashSetElement**		bucket;
+	HashSetElement*			free;
+
+private:
+
+	// No copy constructor.
+	HashSet(const HashSet&);
+	// No copy operator.
+	void operator = (const HashSet&);
+
+public:
+
+	// Create a new HashSet.
+	inline HashSet(Pool& pool, Uint32 universeSize);
+
+	// Clear the hashset.
+	void clear();
+	// Clear the element for the given index.
+	void clear(Uint32 index);
+	// Set the element for the given index.
+	void set(Uint32 index);
+	// Return true if the element at index is a member.
+	bool test(Uint32 index) const;
+	// Union with the given hashset.
+	inline void or(const HashSet& set);
+	// Intersection with the given hashset.
+	inline void and(const HashSet& set);
+	// Difference with the given hashset.
+	inline void difference(const HashSet& set);
+
+	// Logical operators.
+	HashSet& operator |= (const HashSet& set) {or(set); return *this;}
+	HashSet& operator &= (const HashSet& set) {and(set); return *this;}
+	HashSet& operator -= (const HashSet& set) {difference(set); return *this;}
+
+	// Iterator to conform with the set API.
+	typedef HashSetElement* iterator;
+	// Return the iterator for the first element of this set.
+	iterator begin() const;
+	// Return the next iterator.
+	iterator advance(iterator pos) const;
+	// Return true if the iterator is at the end of the set.
+	bool done(iterator pos) const {return pos == NULL;}
+};
+
+
+inline HashSet::HashSet(Pool& pool, Uint32 /*universeSize*/)
+	: allocationPool(pool), free(NULL)
+{
+	bucket = new(pool) HashSetElement*[hashSize];
+	memset(bucket, '\0', sizeof(HashSetElement*));
+}
+
+#endif // _HASH_SET_H_

mozilla/ef/Compiler/RegisterAllocator/IndexedPool.h

@@ -0,0 +1,213 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _INDEXED_POOL_H_
+#define _INDEXED_POOL_H_
+
+#include "Fundamentals.h"
+#include <string.h>
+#include <stdlib.h>
+
+//------------------------------------------------------------------------------
+// IndexedPool<IndexedObjectSubclass> is an indexed pool of objects. The
+// template parameter 'IndexedObjectSubclass' must be a subclass of the struct
+// IndexedObject.
+// 
+// When the indexed pool is ask to allocate and initialize a new object (using
+// the operator new(anIndexedPool) it will zero the memory used to store the
+// object and initialize the field 'index' of this object to its position in
+// the pool.
+//
+// An object allocated by the indexed pool can be freed by calling the method
+// IndexedPool::release(IndexedElement& objectIndex).
+//
+// example:
+//
+//   IndexedPool<IndexedElement> elementPool;
+//
+//   IndexedElement& element1 = *new(elementPool) IndexedElement();
+//   IndexedElement& element2 = *new(elementPool) IndexedElement();
+//
+//   indexedPool.release(element1);
+//   IndexedElement& element3 = *new(elementPool) IndexedElement();
+//
+//  At this point element1 is no longer a valid object, element2 is at
+//  index 2 and element3 is at index 1.
+//
+
+//------------------------------------------------------------------------------
+// IndexedObject -
+//
+
+template<class Object>
+struct IndexedObject
+{
+	Uint32			index;				// Index in the pool.
+	Object*			next;				// Used to link IndexedObject together.
+
+	Uint32 getIndex() {return index;}
+};
+
+//------------------------------------------------------------------------------
+// IndexedPool<IndexedObject> -
+//
+
+template <class IndexedObject>
+class IndexedPool
+{
+private:
+
+	static const	blockSize = 4;		// Size of one block.
+
+	Uint32			nBlocks;			// Number of blocks in the pool.
+	IndexedObject**	block;				// Array of block pointers.
+	IndexedObject*  freeObjects;		// Chained list of free IndexedObjects.
+	Uint32			nextIndex;			// Index of the next free object in the last block. 
+
+private:
+
+	void allocateAnotherBlock();
+	IndexedObject& newObject();
+
+public:
+
+	IndexedPool() : nBlocks(0), block(NULL), freeObjects(NULL), nextIndex(1) {}
+	~IndexedPool();
+
+	IndexedObject& get(Uint32 index) const;
+	void release(IndexedObject& object);
+
+	void setSize(Uint32 size) {assert(size < nextIndex); nextIndex = size;}
+
+	// Return the universe size.
+	Uint32 getSize() {return nextIndex;}
+
+	friend void* operator new(size_t, IndexedPool<IndexedObject>& pool); // Needs to call newObject().
+};
+
+// Free all the memory allocated for this object.
+//
+template <class IndexedObject>
+IndexedPool<IndexedObject>::~IndexedPool()
+{
+	for (Uint32 n = 0; n < nBlocks; n++)
+		free(&((IndexedObject **) &block[n][n*blockSize])[-(n + 1)]);
+}
+
+// Release the given. This object will be iserted in the chained
+// list of free IndexedObjects. To minimize the fragmentation the chained list 
+// is ordered by ascending indexes.
+//
+template <class IndexedObject>
+void IndexedPool<IndexedObject>::release(IndexedObject& object)
+{
+	Uint32 index = object.index;
+	IndexedObject* list = freeObjects;
+
+	assert(&object == &get(index)); // Make sure that object is owned by this pool.
+
+	if (list == NULL) { // The list is empty.
+		freeObjects = &object;
+		object.next = NULL;
+	} else { // The list contains at least 1 element.
+		if (index < list->index) { // insert as first element.
+			freeObjects = &object;
+			object.next = list;
+		} else { // Find this object's place.
+			while ((list->next) != NULL && (list->next->index < index))
+				list = list->next;
+
+			object.next = list->next;
+			list->next = &object;
+		}
+	}
+
+#ifdef DEBUG
+	// Sanity check to be sure that the list is correctly ordered.
+	for (IndexedObject* obj = freeObjects; obj != NULL; obj = obj->next)
+		if (obj->next != NULL)
+			assert(obj->index < obj->next->index);
+#endif
+}
+
+// Create a new block of IndexedObjects. We will allocate the memory to
+// store IndexedPool::blockSize IndexedObject and the new Array of block
+// pointers.
+// The newly created IndexedObjects will not be initialized.
+//
+template <class IndexedObject>
+void IndexedPool<IndexedObject>::allocateAnotherBlock()
+{
+	void* memory = (void *) malloc((nBlocks + 1) * sizeof(Uint32) + blockSize * sizeof(IndexedObject));
+
+	memcpy(memory, block, nBlocks * sizeof(Uint32));
+
+	block = (IndexedObject **) memory;
+	IndexedObject* objects = (IndexedObject *) &block[nBlocks + 1];
+
+	block[nBlocks] = &objects[-(nBlocks * blockSize)];
+	nBlocks++;
+}
+
+// Return the IndexedObject at the position 'index' in the pool.
+//
+template <class IndexedObject>
+IndexedObject& IndexedPool<IndexedObject>::get(Uint32 index) const
+{
+	Uint32 blockIndex = index / blockSize;
+	assert(blockIndex < nBlocks);
+
+	return block[blockIndex][index];
+}
+
+// Return the reference of an unused object in the pool.
+//
+template <class IndexedObject>
+IndexedObject& IndexedPool<IndexedObject>::newObject()
+{
+	if (freeObjects != NULL) {
+		IndexedObject& newObject = *freeObjects;
+		freeObjects = newObject.next;
+		return newObject;
+	}
+	
+	Uint32 nextIndex = this->nextIndex++;
+	Uint32 blockIndex = nextIndex / blockSize;
+
+	while (blockIndex >= nBlocks)
+		allocateAnotherBlock();
+	
+	IndexedObject& newObject = block[blockIndex][nextIndex];
+	newObject.index = nextIndex;
+
+	return newObject;
+}
+
+// Return the address of the next unsused object in the given
+// indexed pool. The field index of the newly allocated object
+// will be initialized to the corresponding index of this object
+// in the pool.
+//
+template <class IndexedObject>
+void* operator new(size_t size, IndexedPool<IndexedObject>& pool)
+{
+	assert(size == sizeof(IndexedObject));
+	return (void *) &pool.newObject();
+}
+
+#endif // _INDEXED_POOL_H_

mozilla/ef/Compiler/RegisterAllocator/InterferenceGraph.h

@@ -0,0 +1,258 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _INTERFERENCE_GRAPH_H_
+#define _INTERFERENCE_GRAPH_H_
+
+#include "Fundamentals.h"
+#include "ControlGraph.h"
+#include "Primitives.h"
+#include "Instruction.h"
+#include "VirtualRegister.h"
+#include "RegisterPressure.h"
+#include "SparseSet.h"
+#include <string.h>
+
+struct InterferenceVector
+{
+	Uint32				count;
+	InterferenceVector*	next;
+	RegisterName*		neighbors;
+
+	InterferenceVector() : count(0), next(NULL) {}
+};
+
+class RegisterAllocator;
+
+template <class RegisterPressure>
+class InterferenceGraph
+{
+private:
+
+	RegisterAllocator&			registerAllocator;
+
+	RegisterPressure::Set*		interferences;
+	InterferenceVector**		vector;
+	Uint32*						offset;
+	Uint32 						rangeCount;
+
+private:
+
+	// No copy constructor.
+	InterferenceGraph(const InterferenceGraph&);
+	// No copy operator.
+	void operator = (const InterferenceGraph&);
+
+	// Check if reg is a member of the universe.
+	void checkMember(RegisterName name) {assert(name < rangeCount);}
+	// Return the edge index for the interference between name1 and name2.
+	Uint32 getEdgeIndex(RegisterName name1, RegisterName name2);
+
+public:
+	InterferenceGraph(RegisterAllocator& registerAllocator) : registerAllocator(registerAllocator) {}
+
+	// Calculate the interferences.
+	void build();
+	// Return true if reg1 and reg2 interfere.
+	bool interfere(RegisterName name1, RegisterName name2);
+	// Return the interference vector for the given register or NULL if there is none.
+	InterferenceVector* getInterferenceVector(RegisterName name) {return vector[name];}
+	// Set the interference between name1 and name2.
+	void setInterference(RegisterName name1, RegisterName name2);
+	// Set the interference vector for the given register.
+	void setInterferenceVector(RegisterName name, InterferenceVector* v) {vector[name] = v;}
+
+
+#ifdef DEBUG_LOG
+	// Print the interferences.
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+template <class RegisterPressure>
+void InterferenceGraph<RegisterPressure>::build()
+{
+	Pool& pool = registerAllocator.pool;
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	this->rangeCount = rangeCount;
+
+	// Initialize the structures.
+	//
+	offset = new(pool) Uint32[rangeCount + 1];
+	vector = new(pool) InterferenceVector*[rangeCount];
+	memset(vector, '\0', sizeof(InterferenceVector*) * rangeCount);
+
+	Uint32 o = 0;
+	offset[0] = 0;
+	for (Uint32 i = 1; i <= rangeCount; ++i) {
+		offset[i] = o;
+		o += i;
+	}
+	
+	interferences = new(pool) RegisterPressure::Set(pool, (rangeCount * rangeCount) / 2);
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	RegisterName* name2range = registerAllocator.name2range;
+	LivenessInfo<RegisterPressure> liveness = Liveness<RegisterPressure>::analysis(controlGraph, rangeCount, name2range);
+	registerAllocator.liveness = liveness;
+	SparseSet currentLive(pool, rangeCount);
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		ControlNode& node = *nodes[n];
+		currentLive = liveness.liveOut[n];
+
+		InstructionList& instructions = node.getInstructions();
+		for (InstructionList::iterator i = instructions.end(); !instructions.done(i); i = instructions.retreat(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useBegin = instruction.getInstructionUseBegin();
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			InstructionUse* usePtr;
+			InstructionDefine* defineBegin = instruction.getInstructionDefineBegin();
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			InstructionDefine* definePtr;
+
+			// Handle the copy instruction to avoid unnecessary interference between the 2 registers.
+			if ((instruction.getFlags() & ifCopy) != 0) {
+				assert(useBegin != useEnd && useBegin[0].isRegister());
+				currentLive.clear(name2range[useBegin[0].getRegisterName()]);
+			}
+
+			// Create the interferences.
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister()) {
+					RegisterName define = name2range[definePtr->getRegisterName()];
+
+					for (SparseSet::iterator e = currentLive.begin(); !currentLive.done(e); e = currentLive.advance(e)) {
+						RegisterName live = RegisterName(currentLive.get(e));
+
+						if ((live != define) && !interfere(live, define) && registerAllocator.canInterfere(live, define)) {
+
+							if (vector[define] == NULL)
+								vector[define] = new(pool) InterferenceVector();
+							vector[define]->count++;
+
+							if (vector[live] == NULL)
+								vector[live] = new(pool) InterferenceVector();
+							vector[live]->count++;
+
+							setInterference(live, define);
+						}
+					}
+				}
+
+			// Now update the liveness.
+			//
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					currentLive.clear(name2range[definePtr->getRegisterName()]);
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					currentLive.set(name2range[usePtr->getRegisterName()]);
+		}
+	}
+
+	// Allocate the memory to store the interferences.
+	//
+	for (Uint32 e = 0; e < rangeCount; e++)
+		if (vector[e] != NULL) {
+			InterferenceVector& v = *vector[e];
+			v.neighbors = new(pool) RegisterName[v.count];
+			v.count = 0;
+		}
+
+	// Initialize the edges.
+	//
+	if (RegisterPressure::Set::isOrdered()) {
+		RegisterName name1 = RegisterName(0);
+
+		for (RegisterPressure::Set::iterator i = interferences->begin(); !interferences->done(i); i = interferences->advance(i)) {
+			Uint32 interferenceIndex = interferences->get(i);
+
+			while(interferenceIndex >= offset[name1 + 1])
+				name1 = RegisterName(name1 + 1);
+
+			assert((interferenceIndex >= offset[name1]) && (interferenceIndex < offset[name1 + 1]));
+
+			RegisterName name2 = RegisterName(interferenceIndex - offset[name1]);
+
+			assert(interfere(name1, name2));
+
+			InterferenceVector& vector1 = *vector[name1];
+			vector1.neighbors[vector1.count++] = name2;
+		
+			InterferenceVector& vector2 = *vector[name2];
+			vector2.neighbors[vector2.count++] = name1;
+		}
+	} else {
+		trespass("not Implemented"); // FIX: need one more pass to initialize the vectors.
+	}
+}
+
+template <class RegisterPressure>
+Uint32 InterferenceGraph<RegisterPressure>::getEdgeIndex(RegisterName name1, RegisterName name2)
+{
+	checkMember(name1); checkMember(name2);
+	assert(name1 != name2); // This is not possible.
+	return (name1 < name2) ? offset[name2] + name1 : offset[name1] + name2;
+}
+
+template <class RegisterPressure>
+void InterferenceGraph<RegisterPressure>::setInterference(RegisterName name1, RegisterName name2)
+{
+	interferences->set(getEdgeIndex(name1, name2));
+}
+
+template <class RegisterPressure>
+bool InterferenceGraph<RegisterPressure>::interfere(RegisterName name1, RegisterName name2)
+{
+	return interferences->test(getEdgeIndex(name1, name2));
+}
+
+#ifdef DEBUG_LOG
+template <class RegisterPressure>
+void InterferenceGraph<RegisterPressure>::printPretty(LogModuleObject log)
+{
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Interference Vectors:\n"));
+	for (Uint32 i = 1; i < rangeCount; i++) {
+		if (vector[i] != NULL) {
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\tvr%d: (", i));
+			for (InterferenceVector* v = vector[i]; v != NULL; v = v->next)
+				for (Uint32 j = 0; j < v->count; j++) {
+					UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("%d", v->neighbors[j]));
+					if (v->next != NULL || j != (v->count - 1))
+						UT_OBJECTLOG(log, PR_LOG_ALWAYS, (","));
+				}
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, (")\n"));
+		}
+	}
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Interference Matrix:\n"));
+	for (RegisterName name1 = RegisterName(1); name1 < rangeCount; name1 = RegisterName(name1 + 1)) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\t%d:\t", name1));
+		for (RegisterName name2 = RegisterName(1); name2 < rangeCount; name2 = RegisterName(name2 + 1))
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("%c", ((name1 != name2) && interfere(name1, name2)) ? '1' : '0'));
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+	}
+}
+#endif // DEBUG_LOG
+
+#endif // _INTERFERENCE_GRAPH_H_

mozilla/ef/Compiler/RegisterAllocator/LiveRange.h

@@ -0,0 +1,87 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _LIVE_RANGE_H_
+#define _LIVE_RANGE_H_
+
+#include "Fundamentals.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Primitives.h"
+#include "Instruction.h"
+#include "RegisterAllocator.h"
+#include "RegisterAllocatorTools.h"
+
+template <class RegisterPressure>
+struct LiveRange
+{
+	static void build(RegisterAllocator& registerAllocator);
+};
+
+template <class RegisterPressure>
+void LiveRange<RegisterPressure>::build(RegisterAllocator& registerAllocator)
+{
+	// Intialize the lookup table.
+	//
+	Uint32 nameCount = registerAllocator.nameCount;
+	RegisterName* nameTable = new(registerAllocator.pool) RegisterName[2*nameCount];
+	RegisterName* rangeName = &nameTable[nameCount];
+
+	init(rangeName, nameCount);
+
+	// Walk the graph.
+	//
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	SparseSet destination(registerAllocator.pool, nameCount);
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		InstructionList& phiNodes = nodes[n]->getPhiNodeInstructions();
+
+		destination.clear();
+		for (InstructionList::iterator i = phiNodes.begin(); !phiNodes.done(i); i = phiNodes.advance(i)) {
+			Instruction& phiNode = phiNodes.get(i);
+			assert(phiNode.getInstructionDefineBegin() != phiNode.getInstructionDefineEnd() && phiNode.getInstructionDefineBegin()[0].isRegister());
+			destination.set(findRoot(phiNode.getInstructionDefineBegin()[0].getRegisterName(), rangeName));
+		}
+
+		for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+			Instruction& phiNode = phiNodes.get(p);
+
+			assert(phiNode.getInstructionDefineBegin() != phiNode.getInstructionDefineEnd() && phiNode.getInstructionDefineBegin()[0].isRegister());
+			RegisterName destinationName = phiNode.getInstructionDefineBegin()[0].getRegisterName();
+			RegisterName destinationRoot = findRoot(destinationName, rangeName);
+
+			InstructionUse* useEnd = phiNode.getInstructionUseEnd();
+			for (InstructionUse* usePtr = phiNode.getInstructionUseBegin(); usePtr < useEnd; usePtr++) {
+				assert(usePtr->isRegister());
+				RegisterName sourceName = usePtr->getRegisterName();
+				RegisterName sourceRoot = findRoot(sourceName, rangeName);
+
+				if (sourceRoot != destinationRoot && !destination.test(sourceRoot))
+					rangeName[sourceRoot] = destinationRoot;
+			}
+		}
+	}
+
+	registerAllocator.rangeCount = compress(registerAllocator.name2range, rangeName, nameCount, nameCount);
+}
+
+#endif // _LIVE_RANGE_H_

mozilla/ef/Compiler/RegisterAllocator/LiveRangeGraph.h

@@ -0,0 +1,163 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _LIVE_RANGE_GRAPH_
+#define _LIVE_RANGE_GRAPH_
+
+#include "Fundamentals.h"
+#include "Pool.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "RegisterTypes.h"
+
+class RegisterAllocator;
+
+template <class RegisterPressure>
+class LiveRangeGraph
+{
+private:
+
+	RegisterAllocator&		registerAllocator;
+
+	RegisterPressure::Set*	edges;
+	Uint32					rangeCount;
+
+public:
+	//
+	//
+	LiveRangeGraph(RegisterAllocator& registerAllocator) : registerAllocator(registerAllocator) {}
+
+	//
+	//
+	void build();
+
+	//
+	//
+	void addEdge(RegisterName name1, RegisterName name2);
+
+	//
+	//
+	bool haveEdge(RegisterName name1, RegisterName name2);
+
+#ifdef DEBUG_LOG
+	//
+	//
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+template <class RegisterPressure>
+void LiveRangeGraph<RegisterPressure>::build()
+{
+	Pool& pool = registerAllocator.pool;
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	this->rangeCount = rangeCount;
+
+	edges = new(pool) RegisterPressure::Set(pool, rangeCount * rangeCount);
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	RegisterName* name2range = registerAllocator.name2range;
+	LivenessInfo<RegisterPressure>& liveness = registerAllocator.liveness;
+	SparseSet currentLive(pool, rangeCount);
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		ControlNode& node = *nodes[n];
+		currentLive = liveness.liveOut[n];
+
+		InstructionList& instructions = node.getInstructions();
+		for (InstructionList::iterator i = instructions.end(); !instructions.done(i); i = instructions.retreat(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useBegin = instruction.getInstructionUseBegin();
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			InstructionUse* usePtr;
+			InstructionDefine* defineBegin = instruction.getInstructionDefineBegin();
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			InstructionDefine* definePtr;
+
+			if ((instruction.getFlags() & ifCopy) != 0) {
+				assert(useBegin != useEnd && useBegin[0].isRegister());
+				currentLive.clear(name2range[useBegin[0].getRegisterName()]);
+			}
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister()) {
+					RegisterName define = name2range[definePtr->getRegisterName()];
+
+					for (SparseSet::iterator l = currentLive.begin(); !currentLive.done(l); l = currentLive.advance(l)) {
+						RegisterName live = RegisterName(currentLive.get(l));
+						if (define != live && registerAllocator.canInterfere(define, live))
+							addEdge(define, live);
+					}
+				}
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					currentLive.clear(name2range[definePtr->getRegisterName()]);
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					currentLive.set(name2range[usePtr->getRegisterName()]);
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					RegisterName use = name2range[usePtr->getRegisterName()];
+
+					for (SparseSet::iterator l = currentLive.begin(); !currentLive.done(l); l = currentLive.advance(l)) {
+						RegisterName live = RegisterName(currentLive.get(l));
+						if (use != live && registerAllocator.canInterfere(use, live))
+							addEdge(use, live);
+					}
+				}
+		}
+	}
+}
+
+template <class RegisterPressure>
+void LiveRangeGraph<RegisterPressure>::addEdge(RegisterName name1, RegisterName name2)
+{
+	assert(name1 != name2);
+	edges->set(name1 * rangeCount + name2);
+}
+
+template <class RegisterPressure>
+bool LiveRangeGraph<RegisterPressure>::haveEdge(RegisterName name1, RegisterName name2)
+{
+	assert(name1 != name2);
+	return edges->test(name1 * rangeCount + name2);
+}
+
+#ifdef DEBUG_LOG
+template <class RegisterPressure>
+void LiveRangeGraph<RegisterPressure>::printPretty(LogModuleObject log)
+{
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Live ranges graph:\n"));
+	for (RegisterName name1 = RegisterName(1); name1 < rangeCount; name1 = RegisterName(name1 + 1)) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\t%d:\t", name1));
+		for (RegisterName name2 = RegisterName(1); name2 < rangeCount; name2 = RegisterName(name2 + 1))
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("%c", ((name1 != name2) && haveEdge(name1, name2)) ? '1' : '0'));
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+	}
+}
+#endif // DEBUG_LOG
+
+#endif // _LIVE_RANGE_GRAPH_

mozilla/ef/Compiler/RegisterAllocator/Liveness.cpp

@@ -0,0 +1,21 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "Liveness.h"
+

mozilla/ef/Compiler/RegisterAllocator/Liveness.h

@@ -0,0 +1,301 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _LIVENESS_H_
+#define _LIVENESS_H_
+
+#include "Fundamentals.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "RegisterTypes.h"
+
+// ----------------------------------------------------------------------------
+// LivenessInfo -
+
+template <class RegisterPressure>
+struct LivenessInfo
+{
+	RegisterPressure::Set*	liveIn;
+	RegisterPressure::Set*	liveOut;
+	DEBUG_LOG_ONLY(Uint32	size);
+
+#ifdef DEBUG_LOG
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+// ----------------------------------------------------------------------------
+// Liveness
+//
+// The liveness is defined by the following data-flow equations:
+//
+//		LiveIn(n) = LocalLive(n) U (LiveOut(n) - Killed(n)).
+//		LiveOut(n) = U LiveIn(s) (s a successor of n).
+//
+//	where LocalLive(n) is the set of used registers in the block n, Killed(n)
+//  is the set of defined registers in the block n, LiveIn(n) is the set of
+//  live registers at the begining of the block n and LiveOut(n) is the set
+//  of live registers at the end of the block n.
+//
+//
+// We will compute the liveness analysis in two stages:
+//
+//	1- Build LocalLive(n) (wich is an approximation of LiveIn(n)) and Killed(n) 
+//     for each block n.
+//  2- Perform a backward data-flow analysis to propagate the liveness information
+//     through the entire control-flow graph.
+//
+
+template <class RegisterPressure>
+struct Liveness
+{
+	static LivenessInfo<RegisterPressure> analysis(ControlGraph& controlGraph, Uint32 rangeCount, const RegisterName* name2range);
+	static LivenessInfo<RegisterPressure> analysis(ControlGraph& controlGraph, Uint32 nameCount);
+};
+
+template <class RegisterPressure>
+LivenessInfo<RegisterPressure> Liveness<RegisterPressure>::analysis(ControlGraph& controlGraph, Uint32 rangeCount, const RegisterName* name2range)
+{
+	Pool& pool = controlGraph.pool;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	// Allocate the temporary sets.
+	RegisterPressure::Set* killed = new(pool) RegisterPressure::Set[nNodes](pool, rangeCount);
+	
+	// Allocate the globals sets.
+	RegisterPressure::Set* liveIn = new(pool) RegisterPressure::Set[nNodes](pool, rangeCount);
+	RegisterPressure::Set* liveOut = new(pool) RegisterPressure::Set[nNodes](pool, rangeCount);
+
+	// First stage of the liveness analysis: Compute the sets LocalLive(stored in LiveIn) and Killed.
+	//
+	for (Uint32 n = 0; n < (nNodes - 1); n++) {
+		ControlNode& node = *nodes[n];
+
+		RegisterPressure::Set& currentLocalLive = liveIn[n];
+		RegisterPressure::Set& currentKilled = killed[n];
+		
+		// Find the instructions contributions to the sets LocalLive and Killed.
+		//
+		InstructionList& instructions = node.getInstructions();
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			// If a VirtualRegister is 'used' before being 'defined' then we add it to set LocalLive.
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					Uint32 index = name2range[usePtr->getRegisterName()];
+
+					if (!currentKilled.test(index))
+						currentLocalLive.set(index);
+				}
+
+			// If a Virtualregister is 'defined' then we add it to the set Killed.
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					currentKilled.set(name2range[definePtr->getRegisterName()]);
+		}
+	}
+
+	// Second stage of the liveness analysis: We propagate the LiveIn & LiveOut through the entire 
+	// control-flow graph.
+	//
+	RegisterPressure::Set temp(pool, rangeCount);
+
+	bool changed;
+	do {
+		changed = false;
+
+		// For all nodes is this graph except the endNode.
+		for (Int32 n = (nNodes - 2); n >= 0; n--) {
+			ControlNode& node = *nodes[n];
+
+			RegisterPressure::Set& currentLiveIn = liveIn[n];
+			RegisterPressure::Set& currentLiveOut = liveOut[n];
+
+			// Compute temp = Union of LiveIn(s) (s a successor of this node) | usedByPhiNodes(n).
+			// temp will be the new LiveOut(n).
+			Uint32 nSuccessors = node.nSuccessors();
+			if (nSuccessors != 0) {
+				temp = liveIn[node.nthSuccessor(0).getTarget().dfsNum];
+				for (Uint32 s = 1; s < nSuccessors; s++)
+					temp |= liveIn[node.nthSuccessor(s).getTarget().dfsNum];
+			} else 
+				temp.clear();
+
+			// If temp and LiveOut(n) differ then set LiveOut(n) = temp and recalculate the
+			// new LiveIn(n).
+			if (currentLiveOut != temp) {
+				currentLiveOut = temp;
+				temp -= killed[n]; // FIX: could be optimized with one call to unionDiff !
+				temp |= currentLiveIn;
+			
+				if (currentLiveIn != temp) {
+					currentLiveIn = temp;
+					changed = true;
+				}
+			}
+		}
+	} while(changed);
+
+	LivenessInfo<RegisterPressure> liveness;
+	liveness.liveIn = liveIn;
+	liveness.liveOut = liveOut;
+	DEBUG_LOG_ONLY(liveness.size = nNodes);
+	return liveness;
+}
+
+template <class RegisterPressure>
+LivenessInfo<RegisterPressure> Liveness<RegisterPressure>::analysis(ControlGraph& controlGraph, Uint32 nameCount)
+{
+	Pool& pool = controlGraph.pool;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	// Allocate the temporary sets.
+	RegisterPressure::Set* killed = new(pool) RegisterPressure::Set[nNodes](pool, nameCount);
+	RegisterPressure::Set* usedByPhiNodes = NULL;
+	
+	// Allocate the globals sets.
+	RegisterPressure::Set* liveIn = new(pool) RegisterPressure::Set[nNodes](pool, nameCount);
+	RegisterPressure::Set* liveOut = new(pool) RegisterPressure::Set[nNodes](pool, nameCount);
+
+	// First stage of the liveness analysis: Compute the sets LocalLive(stored in LiveIn) and Killed.
+	//
+	for (Uint32 n = 0; n < (nNodes - 1); n++) {
+		ControlNode& node = *nodes[n];
+
+		RegisterPressure::Set& currentLocalLive = liveIn[n];
+		RegisterPressure::Set& currentKilled = killed[n];
+		
+		InstructionList& phiNodes = node.getPhiNodeInstructions();
+
+		if ((usedByPhiNodes == NULL) && !phiNodes.empty())
+			usedByPhiNodes = new(pool) RegisterPressure::Set[nNodes](pool, nameCount);
+
+		for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+			Instruction& phiNode = phiNodes.get(p);
+
+			InstructionDefine& define = phiNode.getInstructionDefineBegin()[0];
+			currentKilled.set(define.getRegisterName());
+
+			typedef DoublyLinkedList<ControlEdge> ControlEdgeList;
+			const ControlEdgeList& predecessors = node.getPredecessors();
+			ControlEdgeList::iterator p = predecessors.begin();
+			InstructionUse* useEnd = phiNode.getInstructionUseEnd();
+			for (InstructionUse* usePtr = phiNode.getInstructionUseBegin(); usePtr < useEnd; usePtr++, p = predecessors.advance(p))
+				if (usePtr->isRegister())
+					usedByPhiNodes[predecessors.get(p).getSource().dfsNum].set(usePtr->getRegisterName());
+		}
+
+		// Find the instructions contributions to the sets LocalLive and Killed.
+		//
+		InstructionList& instructions = node.getInstructions();
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			// If a VirtualRegister is 'used' before being 'defined' then we add it to set LocalLive.
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					Uint32 index = usePtr->getRegisterName();
+
+					if (!currentKilled.test(index))
+						currentLocalLive.set(index);
+				}
+
+			// If a Virtualregister is 'defined' then we add it to the set Killed.
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					currentKilled.set(definePtr->getRegisterName());
+		}
+	}
+
+	// Second stage of the liveness analysis: We propagate the LiveIn & LiveOut through the entire 
+	// control-flow graph.
+	//
+	RegisterPressure::Set temp(pool, nameCount);
+
+	bool changed;
+	do {
+		changed = false;
+
+		// For all nodes is this graph except the endNode.
+		for (Int32 n = (nNodes - 2); n >= 0; n--) {
+			ControlNode& node = *nodes[n];
+
+			RegisterPressure::Set& currentLiveIn = liveIn[n];
+			RegisterPressure::Set& currentLiveOut = liveOut[n];
+
+			// Compute temp = Union of LiveIn(s) (s a successor of this node) | usedByPhiNodes(n).
+			// temp will be the new LiveOut(n).
+			Uint32 nSuccessors = node.nSuccessors();
+			if (nSuccessors != 0) {
+				temp = liveIn[node.nthSuccessor(0).getTarget().dfsNum];
+				for (Uint32 s = 1; s < nSuccessors; s++)
+					temp |= liveIn[node.nthSuccessor(s).getTarget().dfsNum];
+			} else 
+				temp.clear();
+
+			// Insert the phiNodes contribution.
+			if (usedByPhiNodes != NULL)
+				temp |= usedByPhiNodes[n];
+
+			// If temp and LiveOut(n) differ then set LiveOut(n) = temp and recalculate the
+			// new LiveIn(n).
+			if (currentLiveOut != temp) {
+				currentLiveOut = temp;
+				temp -= killed[n]; // FIX: could be optimized with one call to unionDiff !
+				temp |= currentLiveIn;
+			
+				if (currentLiveIn != temp) {
+					currentLiveIn = temp;
+					changed = true;
+				}
+			}
+		}
+	} while(changed);
+
+	LivenessInfo<RegisterPressure> liveness;
+	liveness.liveIn = liveIn;
+	liveness.liveOut = liveOut;
+	DEBUG_LOG_ONLY(liveness.size = nNodes);
+	return liveness;
+}
+
+#ifdef DEBUG_LOG
+template <class RegisterPressure>
+void LivenessInfo<RegisterPressure>::printPretty(LogModuleObject log)
+{
+	for (Uint32 n = 0; n < size; n++) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Node N%d:\n\tliveIn = ", n));
+		liveIn[n].printPretty(log);
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\tliveOut = "));
+		liveOut[n].printPretty(log);
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+	}
+}
+#endif // DEBUG_LOG
+
+#endif // _LIVENESS_H_

mozilla/ef/Compiler/RegisterAllocator/Makefile

@@ -0,0 +1,40 @@
+#! gmake
+
+DEPTH			= ../..
+
+MODULE_NAME		= RegisterAllocator
+
+include $(DEPTH)/config/config.mk
+
+INCLUDES		+=										\
+	-I$(DEPTH)/Utilities/General						\
+	-I$(DEPTH)/Utilities/zlib							\
+	-I$(DEPTH)/Runtime/ClassReader						\
+	-I$(DEPTH)/Runtime/NativeMethods					\
+	-I$(DEPTH)/Runtime/System							\
+	-I$(DEPTH)/Runtime/ClassInfo						\
+	-I$(DEPTH)/Runtime/FileReader						\
+	-I$(DEPTH)/Compiler/PrimitiveGraph					\
+	-I$(DEPTH)/Compiler/FrontEnd						\
+	-I$(DEPTH)/Compiler/Optimizer						\
+	-I$(DEPTH)/Compiler/CodeGenerator					\
+	-I$(DEPTH)/Compiler/CodeGenerator/md				\
+	-I$(DEPTH)/Compiler/CodeGenerator/md/$(CPU_ARCH)	\
+	-I$(DEPTH)/Compiler/RegisterAllocator				\
+	-I$(DEPTH)/Driver/StandAloneJava					\
+	-I$(DEPTH)/Debugger									\
+	$(NULL)
+
+CXXSRCS 		=										\
+	RegisterAllocator.cpp								\
+	RegisterAllocatorTools.cpp							\
+	DominatorGraph.cpp									\
+	VirtualRegister.cpp									\
+	BitSet.cpp											\
+	SparseSet.cpp										\
+	$(NULL)
+
+
+include $(DEPTH)/config/rules.mk
+
+libs:: $(MODULE)

mozilla/ef/Compiler/RegisterAllocator/PhiNodeRemover.h

@@ -0,0 +1,392 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _PHI_NODE_REMOVER_H_
+#define _PHI_NODE_REMOVER_H_
+
+#include "Fundamentals.h"
+#include "Pool.h"
+#include "ControlGraph.h"
+#include "DominatorGraph.h"
+#include "VirtualRegister.h"
+#include "RegisterPressure.h"
+#include "Liveness.h"
+#include "Instruction.h"
+#include "InstructionEmitter.h"
+#include "SparseSet.h"
+#include <string.h>
+
+//------------------------------------------------------------------------------
+// RegisterNameNode -
+
+struct RegisterNameNode 
+{
+	RegisterNameNode*	next;
+	RegisterName		newName;
+	Uint32				nextPushed;
+};
+
+//------------------------------------------------------------------------------
+// CopyData -
+
+struct CopyData
+{
+	RegisterName		source;
+	RegisterClassKind	classKind;
+	Uint32				useCount;
+	bool				isLiveOut;
+	RegisterName		sourceNameToUse;
+	RegisterName		temporaryName;
+	RegisterNameNode*	newName;
+};
+
+//------------------------------------------------------------------------------
+// PhiNodeRemover<RegisterPressure> -
+
+template <class RegisterPressure>
+struct PhiNodeRemover
+{
+	// Replace the phi nodes by copy instructions.
+	static void replacePhiNodes(ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter);
+};
+
+// Split some of the critical edges and return true if there are still some
+// in the graph after that.
+//
+static bool splitCriticalEdges(ControlGraph& /*cg*/)
+{
+	// FIX: not implemented.
+	return true;
+}
+
+inline void pushName(Pool& pool, RegisterNameNode** stack, SparseSet& pushed, Uint32* nodeListPointer, RegisterName oldName, RegisterName newName)
+{
+	RegisterNameNode& newNode = *new(pool) RegisterNameNode();
+
+	if (pushed.test(oldName))
+		(*stack)->newName = newName;
+	else {
+		newNode.newName = newName;
+		newNode.nextPushed = *nodeListPointer;
+		*nodeListPointer = oldName;
+		newNode.next = *stack;
+		*stack = &newNode;
+		pushed.set(oldName);
+	}
+}
+
+template <class RegisterPressure>
+void PhiNodeRemover<RegisterPressure>::replacePhiNodes(ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter)
+{
+	Pool& pool = controlGraph.pool;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	// Initialize the local variables.
+	//
+
+	// When we insert the copies we will also need to create new VirtualRegisters for
+	// the insertion of temporaries. The maximum number of temporary register will not
+	// exceed the number of phiNodes in the primitive graph.
+	Uint32 nameCount = vrManager.getSize();
+	Uint32 maxNameCount = nameCount;
+	for (Uint32 n = 0; n < nNodes; n++)
+		maxNameCount += nodes[n]->getPhiNodes().length();
+
+	// If the CFG contains some critical edges (backward edge which source has more than one
+	// outgoing edge and destination has more than one incomimg edge) then we need the liveness
+	// information to be able to insert temporary copies.
+	RegisterPressure::Set* liveOut = NULL;
+	if (splitCriticalEdges(controlGraph))
+		liveOut = Liveness<LowRegisterPressure>::analysis(controlGraph, nameCount).liveOut;
+
+	DominatorGraph dGraph(controlGraph);
+
+	SparseSet pushed(pool, maxNameCount);
+	SparseSet destinationList(pool, maxNameCount);
+	SparseSet workList(pool, maxNameCount);
+
+	CopyData* copyStats = new(pool) CopyData[maxNameCount];
+	memset(copyStats, '\0', maxNameCount*sizeof(CopyData));
+
+	struct NodeStack {
+		Uint32* next;
+		Uint32* limit;
+		Uint32 pushedList;
+	};
+
+	// Allocate the node stack and initialize the node stack pointer.
+	NodeStack* nodeStack = new(pool) NodeStack[nNodes + 1];
+	NodeStack* nodeStackPtr = nodeStack;
+
+	// We start by the begin node. 
+	Uint32 startNode = 0;
+	Uint32* next = &startNode;
+	Uint32* limit = &startNode + 1;
+
+	while (true) {
+
+		if (next == limit) {
+			// If there are no more node in the sibling, we have to pop the current
+			// frame from the stack and update the copyStats of the pushed nodes.
+			//
+			if (nodeStackPtr == nodeStack)
+				// We are at the bottom of the stack and there are no more nodes
+				// to look at. We are done !
+				break;
+
+			--nodeStackPtr;
+			// We are done with all the children of this node in the dominator tree.
+			// We need to update the copy information of all the new names pushed
+			// during the walk over this node.
+			Uint32 pushedList = nodeStackPtr->pushedList;
+			while (pushedList != 0) {
+				Uint32 nextName = copyStats[pushedList].newName->nextPushed;
+				copyStats[pushedList].newName = copyStats[pushedList].newName->next;
+				pushedList = nextName;
+			}
+
+			// restore the previous frame.
+			next = nodeStackPtr->next;
+			limit = nodeStackPtr->limit;
+		} else {
+			Uint32 currentNode = *next++;
+			Uint32 pushedList = 0;
+
+
+			// Initialize the sets.
+			pushed.clear();
+			destinationList.clear();
+
+			// STEP1:
+			//  Walk the instruction list and to replace all the instruction uses with their new name. 
+			//  If the instruction is a phi node and its defined register is alive at the end of this 
+			//  block then we push the defined register into the stack.
+			//
+			ControlNode& node = *nodes[currentNode];
+			RegisterPressure::Set* currentLiveOut = (liveOut != NULL) ? &liveOut[currentNode] : (RegisterPressure::Set*) 0;
+
+			InstructionList& phiNodes = node.getPhiNodeInstructions();
+			for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+				Instruction& phiNode = phiNodes.get(p);
+
+				InstructionUse* useEnd = phiNode.getInstructionUseEnd();
+				for (InstructionUse* usePtr = phiNode.getInstructionUseBegin(); usePtr < useEnd; usePtr++) {
+					assert(usePtr->isRegister());
+					RegisterName name = usePtr->getRegisterName();
+
+					if (copyStats[name].newName != NULL && copyStats[name].newName->newName != name)
+						usePtr->setRegisterName(copyStats[name].newName->newName);
+				}
+
+				if (currentLiveOut != NULL) {
+					// This is a phi node and we have to push its defined name if it is live
+					// at the end of the node. We only need to do this if the CFG has critical edges.
+					assert(phiNode.getInstructionDefineBegin() != phiNode.getInstructionDefineEnd() && phiNode.getInstructionDefineBegin()[0].isRegister());
+					RegisterName name = phiNode.getInstructionDefineBegin()[0].getRegisterName();
+
+					if (currentLiveOut->test(name))
+						pushName(pool, &(copyStats[name].newName), pushed, &pushedList, name, name);
+				}
+				
+			}
+
+			InstructionList& instructions = node.getInstructions();
+			for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+				Instruction& instruction = instructions.get(i);
+
+				InstructionUse* useEnd = instruction.getInstructionUseEnd();
+				for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+					if (usePtr->isRegister()) {
+						RegisterName name = usePtr->getRegisterName();
+
+						if (copyStats[name].newName != NULL && copyStats[name].newName->newName != name)
+							usePtr->setRegisterName(copyStats[name].newName->newName);
+					}
+			}
+
+			// STEP2:
+			//  Look at this node's successors' phiNodes. We keep track of the number of time
+			//  a VR will be used by another copy instruction and insert each definition into the 
+			//  destinationList. This is the only pass over this node's successors as we will
+			//  get all the information we need in the CopyData structures.
+			//
+			ControlEdge* successorEdgeEnd = node.getSuccessorsEnd();
+			for (ControlEdge* successorEdgePtr = node.getSuccessorsBegin(); successorEdgePtr < successorEdgeEnd; successorEdgePtr++) {
+				Uint32 useIndex = successorEdgePtr->getIndex();
+				ControlNode& successor = successorEdgePtr->getTarget();
+
+				// Look at its phi nodes. The phi nodes are at the top of the instruction list. We exit
+				// as soon as we find an instruction which is not a phi node
+				InstructionList& phiNodes = successor.getPhiNodeInstructions();
+				for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+					Instruction& phiNode = phiNodes.get(p);
+					
+					assert((phiNode.getInstructionUseBegin() + useIndex) < phiNode.getInstructionUseEnd());
+					assert(phiNode.getInstructionDefineBegin() != phiNode.getInstructionDefineEnd());
+
+					InstructionUse& source = phiNode.getInstructionUseBegin()[useIndex];
+					InstructionDefine& destination = phiNode.getInstructionDefineBegin()[0];
+
+					assert(source.isRegister() && destination.isRegister());
+
+					RegisterName sourceName = source.getRegisterName();
+					RegisterName destinationName = destination.getRegisterName();
+
+					// Get the correct name for the source.
+					if (copyStats[sourceName].newName != NULL)
+						sourceName = copyStats[sourceName].newName->newName;
+
+					// Update the CopyData structures.
+					if ((sourceName != rnInvalid) && (sourceName != destinationName)) {
+						copyStats[destinationName].source = sourceName;
+						copyStats[destinationName].classKind = destination.getRegisterClass();
+						copyStats[destinationName].isLiveOut = (currentLiveOut != NULL) ? currentLiveOut->test(destinationName) : false;
+						copyStats[destinationName].sourceNameToUse = destinationName;
+						copyStats[sourceName].sourceNameToUse = sourceName;
+						copyStats[sourceName].useCount++;
+						destinationList.set(destinationName);
+					}
+				}
+			}
+
+			// STEP3:
+			//  Insert into the worklist only the destination registers that will be not used in 
+			//  another copy instruction in this block.
+			//
+			assert(workList.getSize() == 0);
+			for (SparseSet::iterator d = destinationList.begin(); !destinationList.done(d); d = destinationList.advance(d)) {
+				Uint32 dest = destinationList.get(d);
+				if (copyStats[dest].useCount == 0)
+					workList.set(dest);
+			}
+
+			// STEP4:
+			//  Insert the copy instructions.
+			//
+			Uint32 destinationListSize = destinationList.getSize();
+			InstructionList::iterator endOfTheNode = instructions.end();
+
+			// Find the right place to insert the copy instructions.
+			if (destinationListSize != 0)
+				while (instructions.get(endOfTheNode).getFlags() & ifControl)
+					endOfTheNode = instructions.retreat(endOfTheNode);
+
+			while (destinationListSize != 0) {
+				while(workList.getSize()) {
+					RegisterName destinationName = RegisterName(workList.getOne());
+					RegisterName sourceName = copyStats[destinationName].source;
+
+					workList.clear(destinationName);
+					if (copyStats[destinationName].isLiveOut && !copyStats[destinationName].temporaryName) {
+						// Lost copy problem.
+						copyStats[destinationName].isLiveOut = false;
+
+						RegisterName sourceName = destinationName;
+						RegisterClassKind classKind = copyStats[sourceName].classKind;
+						RegisterName destinationName = getName(vrManager.newVirtualRegister(classKind));
+						assert(destinationName < maxNameCount);
+
+						copyStats[destinationName].classKind = classKind;
+						copyStats[sourceName].useCount = 0;
+				
+						// We need to insert a copy to a temporary register to keep the
+						// source register valid at the end of the node defining it.
+						// This copy will be inserted right after the phi node defining it.
+						RegisterName from = copyStats[sourceName].sourceNameToUse;
+						Instruction* definingPhiNode = vrManager.getVirtualRegister(from).getDefiningInstruction();
+						assert(definingPhiNode && (definingPhiNode->getFlags() & ifPhiNode) != 0);
+
+						RegisterID fromID = buildRegisterID(from, classKind);
+						RegisterID toID = buildRegisterID(destinationName, classKind);
+						Instruction& copy = emitter.newCopy(*definingPhiNode->getPrimitive(), fromID, toID);
+						vrManager.getVirtualRegister(destinationName).setDefiningInstruction(copy);
+						definingPhiNode->getPrimitive()->getContainer()->getInstructions().addFirst(copy);
+
+						copyStats[sourceName].temporaryName = destinationName;
+						copyStats[sourceName].sourceNameToUse = destinationName;
+						pushName(pool, &(copyStats[sourceName].newName), pushed, &pushedList, sourceName, destinationName);
+					}
+
+					// Insert the copy instruction at the end of the current node.
+					RegisterName from = copyStats[sourceName].sourceNameToUse;
+
+					RegisterClassKind classKind = copyStats[destinationName].classKind;
+					RegisterID fromID = buildRegisterID(from, classKind);
+					RegisterID toID = buildRegisterID(destinationName, classKind);
+					Instruction& copy = emitter.newCopy(*vrManager.getVirtualRegister(from).getDefiningInstruction()->getPrimitive(), fromID, toID);
+					instructions.insertAfter(copy, endOfTheNode);
+					endOfTheNode = instructions.advance(endOfTheNode);
+
+					copyStats[sourceName].useCount = 0;
+					if (destinationList.test(sourceName) && copyStats[sourceName].isLiveOut)
+						pushName(pool, &(copyStats[sourceName].newName), pushed, &pushedList, sourceName, destinationName);
+					copyStats[sourceName].isLiveOut = false;
+					copyStats[sourceName].sourceNameToUse = destinationName;
+
+					if (destinationList.test(sourceName))
+						workList.set(sourceName);
+					destinationList.clear(destinationName);
+				}
+
+				destinationListSize = destinationList.getSize();
+				if (destinationListSize != 0) {
+					RegisterName sourceName = RegisterName(destinationList.getOne());
+					RegisterName destinationName;
+
+					if (!copyStats[sourceName].temporaryName) {
+						// Cycle problem.
+						RegisterClassKind classKind = copyStats[sourceName].classKind;
+						destinationName = getName(vrManager.newVirtualRegister(classKind));
+						assert(destinationName < maxNameCount);
+				
+						copyStats[destinationName].classKind = classKind;
+						copyStats[sourceName].temporaryName = destinationName;
+
+						// Insert the copy instruction at the end of the current node.
+						RegisterName from = copyStats[sourceName].sourceNameToUse;
+
+						RegisterID fromID = buildRegisterID(from, classKind);
+						RegisterID toID = buildRegisterID(destinationName, classKind);
+						Instruction& copy = emitter.newCopy(*vrManager.getVirtualRegister(from).getDefiningInstruction()->getPrimitive(), fromID, toID);
+						vrManager.getVirtualRegister(destinationName).setDefiningInstruction(copy);
+						instructions.insertAfter(copy, endOfTheNode);
+						endOfTheNode = instructions.advance(endOfTheNode);
+					} else 
+						destinationName = copyStats[sourceName].temporaryName;
+
+					copyStats[sourceName].useCount = 0;
+					copyStats[sourceName].isLiveOut = false;
+					copyStats[sourceName].sourceNameToUse = destinationName;
+					pushName(pool, &(copyStats[sourceName].newName), pushed, &pushedList, sourceName, destinationName);
+
+					workList.set(sourceName);
+				}
+			}
+
+			nodeStackPtr->pushedList = pushedList;
+			nodeStackPtr->next = next;
+			nodeStackPtr->limit = limit;
+			++nodeStackPtr;
+			next = dGraph.getSuccessorsBegin(currentNode);
+			limit = dGraph.getSuccessorsEnd(currentNode);
+		}
+	}
+}
+
+#endif // _PHI_NODE_REMOVER_H_

mozilla/ef/Compiler/RegisterAllocator/RegisterAllocator.cpp

@@ -0,0 +1,155 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "LogModule.h"
+#include "RegisterAllocator.h"
+#include "RegisterPressure.h"
+#include "RegisterAllocatorTools.h"
+#include "PhiNodeRemover.h"
+#include "LiveRange.h"
+#include "Liveness.h"
+#include "InterferenceGraph.h"
+#include "LiveRangeGraph.h"
+#include "Coalescing.h"
+#include "Spilling.h"
+#include "Coloring.h"
+#include "Splits.h"
+
+class Pool;
+class ControlGraph;
+class VirtualRegisterManager;
+class InstructionEmitter;
+
+UT_DEFINE_LOG_MODULE(RegAlloc);
+
+void RegisterAllocator::allocateRegisters(Pool& pool, ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter)
+{
+	// Insert the phi node instructions. We want to do this to have a single defined register per instruction.
+	// If we keep the PhiNode (as a DataNode) and a PhiNode is of DoubleWordKind then we have to execute
+	// some special code for the high word annotation.
+	//
+	RegisterAllocatorTools::insertPhiNodeInstructions(controlGraph, emitter);
+
+	// Perform some tests on the instruction graph.
+	//
+	DEBUG_ONLY(RegisterAllocatorTools::testTheInstructionGraph(controlGraph, vrManager));
+
+	// Replace the phi node instructions by their equivalent copy instructions.
+	//
+	PhiNodeRemover<LowRegisterPressure>::replacePhiNodes(controlGraph, vrManager, emitter);
+
+	// Do the register allocation.
+	//
+	RegisterAllocator registerAllocator(pool, controlGraph, vrManager, emitter);
+	registerAllocator.doGraphColoring();
+}
+
+void RegisterAllocator::doGraphColoring()
+{
+	// Initialize the liverange map.
+	//
+	initLiveRanges();
+
+	// Build the live ranges. We do this to compress the number of RegisterNames 
+	// used in the insterference graph.
+	//
+	LiveRange<LowRegisterPressure>::build(*this);
+
+	// Remove unnecessary copies.
+	//
+	RegisterAllocatorTools::removeUnnecessaryCopies(*this);
+
+	for (Uint8 loop = 0; loop < 10; loop++) {
+
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("********* RegisterAllocator loop %d *********\n", loop));
+
+		while(true) {
+			// Build the interference graph.
+			//
+			iGraph.build();
+
+			// Coalesce the copy instructions.
+			//
+			if (!Coalescing<LowRegisterPressure>::coalesce(*this))
+				break;
+		}
+
+		// Print the interference graph.
+		//
+		DEBUG_LOG_ONLY(iGraph.printPretty(UT_LOG_MODULE(RegAlloc)));
+
+		// Calculate the spill costs.
+		//
+		Spilling<LowRegisterPressure>::calculateSpillCosts(*this);
+		DEBUG_LOG_ONLY(RegisterAllocatorTools::printSpillCosts(*this));
+
+		// Calculate the split costs.
+		//
+		Splits<LowRegisterPressure>::calculateSplitCosts(*this);
+		DEBUG_LOG_ONLY(RegisterAllocatorTools::printSplitCosts(*this));
+
+		// Build the live range graph.
+		//
+		lGraph.build();
+		DEBUG_LOG_ONLY(lGraph.printPretty(UT_LOG_MODULE(RegAlloc)));
+
+		// Color the graph. If it succeeds then we're done with the
+		// register allocation.
+		//
+		if (Coloring<LowRegisterPressure>::color(*this)) {
+			// Write the final colors in the instruction graph.
+			//
+			Coloring<LowRegisterPressure>::finalColoring(*this);
+
+			UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("********** RegisterAllocator  done **********\n"));
+			DEBUG_LOG_ONLY(RegisterAllocatorTools::printInstructions(*this));
+
+			return;
+		}
+
+		// We need to spill some registers.
+		//
+		Spilling<LowRegisterPressure>::insertSpillCode(*this);
+
+		// Insert the split instructions.
+		//
+		Splits<LowRegisterPressure>::insertSplitCode(*this);
+
+		// Update the live ranges.
+		// 
+		// FIX
+	}
+
+#ifdef DEBUG_LOG
+	RegisterAllocatorTools::updateInstructionGraph(*this);
+	RegisterAllocatorTools::printInstructions(*this);
+#endif
+	fprintf(stderr, "!!! Coloring failed after 10 loops !!!\n");
+	abort();
+}
+
+void RegisterAllocator::initLiveRanges()
+{
+	Uint32 count = this->nameCount;
+	RegisterName* name2range = new(pool) RegisterName[nameCount];
+	for (RegisterName r = RegisterName(1); r < count; r = RegisterName(r + 1))
+		name2range[r] = r;
+	this->name2range = name2range;
+	rangeCount = count;
+}

mozilla/ef/Compiler/RegisterAllocator/RegisterAllocator.h

@@ -0,0 +1,88 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _REGISTER_ALLOCATOR_H_
+#define _REGISTER_ALLOCATOR_H_
+
+class Pool;
+class ControlGraph;
+class InstructionEmitter;
+struct SpillCost;
+struct SplitCost;
+
+#include "Liveness.h"
+#include "VirtualRegister.h"
+#include "RegisterPressure.h" // This should included by Backend.cpp
+#include "InterferenceGraph.h"
+#include "LiveRangeGraph.h"
+
+//template <class RegisterPressure>
+class RegisterAllocator
+{
+public:
+
+	Pool&									pool;			//
+	ControlGraph&							controlGraph;	//
+	VirtualRegisterManager&					vrManager;		//
+	InstructionEmitter&						emitter;		//
+
+	RegisterName*							name2range;		//
+	RegisterName*							color;			//
+	SpillCost*								spillCost;		//
+	SparseSet*								willSpill;		//
+	SplitCost*								splitCost;		//
+	NameLinkedList**						splitAround;	//
+	InterferenceGraph<LowRegisterPressure>	iGraph;			//
+	LiveRangeGraph<LowRegisterPressure>		lGraph;			//
+	LivenessInfo<LowRegisterPressure>		liveness;		//
+	Uint32									nameCount;		//
+	Uint32									rangeCount;		//
+	bool									splitFound;		//
+
+private:
+
+	//
+	//
+	void doGraphColoring();
+
+public:
+
+	//
+	//
+	inline RegisterAllocator(Pool& pool, ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter);
+
+	//
+	//
+	bool canInterfere(RegisterName /*name1*/, RegisterName /*name2*/) const {return true;}
+
+	//
+	//
+	void initLiveRanges();
+
+	//
+	//
+	static void allocateRegisters(Pool& pool, ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter);
+};
+
+//
+//
+inline RegisterAllocator::RegisterAllocator(Pool& pool, ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter)
+	: pool(pool), controlGraph(controlGraph), vrManager(vrManager), emitter(emitter), iGraph(*this), lGraph(*this), nameCount(vrManager.getSize()) {}
+
+#endif // _REGISTER_ALLOCATOR_H_
+

mozilla/ef/Compiler/RegisterAllocator/RegisterAllocatorTools.cpp

@@ -0,0 +1,355 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "LogModule.h"
+#include "RegisterAllocatorTools.h"
+#include "Pool.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Primitives.h"
+#include "InstructionEmitter.h"
+#include "Instruction.h"
+#include "RegisterAllocator.h"
+#include "Spilling.h"
+#include "Splits.h"
+#include "BitSet.h"
+
+UT_EXTERN_LOG_MODULE(RegAlloc);
+
+#ifdef DEBUG
+void RegisterAllocatorTools::testTheInstructionGraph(ControlGraph& controlGraph, VirtualRegisterManager& vrManager)
+{
+	// Test the declared VirtualRegisters. The register allocator tries to condense the register universe.
+	// Any gap in the VirtualRegister names will be a loss of efficiency !!!!
+
+	Uint32 nameCount = vrManager.getSize();
+	BitSet registerSeen(controlGraph.pool, nameCount);
+
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+
+		InstructionList& instructions = nodes[n]->getInstructions();
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					registerSeen.set(usePtr->getRegisterName());
+
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					registerSeen.set(definePtr->getRegisterName());
+		}
+
+		InstructionList& phiNodes = nodes[n]->getPhiNodeInstructions();
+		for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+			Instruction& instruction = phiNodes.get(p);
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					registerSeen.set(usePtr->getRegisterName());
+
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					registerSeen.set(definePtr->getRegisterName());
+		}
+	}
+
+	bool renameRegisters = false;
+	for (BitSet::iterator i = registerSeen.nextZero(0); !registerSeen.done(i); i = registerSeen.nextZero(i)) {
+		renameRegisters = true;
+		fprintf(stderr, 
+				"WARNING: The VirtualRegister vr%d has been allocated during CodeGeneration but\n"
+				"         is never used nor defined by any instruction in the instruction graph\n"
+				"                                  PLEASE FIX                                  \n",
+				i);
+	}
+	if (renameRegisters) {
+		Instruction** definingInstruction = new Instruction*[nameCount];
+		memset(definingInstruction, '\0', nameCount * sizeof(Instruction*));
+		RegisterName* newName = new RegisterName[nameCount];
+		memset(newName, '\0', nameCount * sizeof(RegisterName));
+		RegisterName nextName = RegisterName(1);
+
+		for (Uint32 n = 0; n < nNodes; n++) {
+
+			InstructionList& instructions = nodes[n]->getInstructions();
+			for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+				Instruction& instruction = instructions.get(i);
+
+				InstructionUse* useEnd = instruction.getInstructionUseEnd();
+				for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+					if (usePtr->isRegister()) {
+						RegisterName name = usePtr->getRegisterName();
+						if (newName[name] == rnInvalid) {
+							newName[name] = nextName;
+							definingInstruction[nextName] = vrManager.getVirtualRegister(name).getDefiningInstruction();
+							nextName = RegisterName(nextName + 1);
+						}
+						usePtr->setRegisterName(newName[name]);
+					}
+
+				InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+				for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+					if (definePtr->isRegister()) {
+						RegisterName name = definePtr->getRegisterName();
+						if (newName[name] == rnInvalid) {
+							newName[name] = nextName;
+							definingInstruction[nextName] = vrManager.getVirtualRegister(name).getDefiningInstruction();
+							nextName = RegisterName(nextName + 1);
+						}
+						definePtr->setRegisterName(newName[name]);
+					}
+			}
+
+			InstructionList& phiNodes = nodes[n]->getPhiNodeInstructions();
+			for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+				Instruction& instruction = phiNodes.get(p);
+
+				InstructionUse* useEnd = instruction.getInstructionUseEnd();
+				for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+					if (usePtr->isRegister()) {
+						RegisterName name = usePtr->getRegisterName();
+						if (newName[name] == rnInvalid) {
+							newName[name] = nextName;
+							definingInstruction[nextName] = vrManager.getVirtualRegister(name).getDefiningInstruction();
+							nextName = RegisterName(nextName + 1);
+						}
+						usePtr->setRegisterName(newName[name]);
+					}
+
+				InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+				for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+					if (definePtr->isRegister()) {
+						RegisterName name = definePtr->getRegisterName();
+						if (newName[name] == rnInvalid) {
+							newName[name] = nextName;
+							definingInstruction[nextName] = vrManager.getVirtualRegister(name).getDefiningInstruction();
+							nextName = RegisterName(nextName + 1);
+						}
+						definePtr->setRegisterName(newName[name]);
+					}
+			}
+		}
+		
+		vrManager.setSize(nextName);
+
+		for (RegisterName r = RegisterName(1); r < nextName; r = RegisterName(r + 1))
+			vrManager.getVirtualRegister(r).definingInstruction = definingInstruction[r];
+
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("RegisterMap:\n"));
+		for (Uint32 i = 1; i < nameCount; i++)
+			if (newName[i] != 0)
+				UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\tvr%d becomes vr%d.\n", i, newName[i]));
+			else
+				UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\tvr%d is dead.\n", i));
+
+
+		delete newName;
+		delete definingInstruction;
+	}
+
+}
+#endif // DEBUG
+
+void RegisterAllocatorTools::removeUnnecessaryCopies(RegisterAllocator& registerAllocator)
+{
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		InstructionList& instructions = nodes[n]->getInstructions();
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i);) {
+			Instruction& instruction = instructions.get(i);
+			i = instructions.advance(i);
+
+			if (instruction.getFlags() & ifCopy) {
+				assert(instruction.getInstructionUseBegin() != instruction.getInstructionUseEnd() && instruction.getInstructionUseBegin()[0].isRegister());
+				assert(instruction.getInstructionDefineBegin() != instruction.getInstructionDefineEnd() && instruction.getInstructionDefineBegin()[0].isRegister());
+				
+				RegisterName source = name2range[instruction.getInstructionUseBegin()[0].getRegisterName()];
+				RegisterName destination = name2range[instruction.getInstructionDefineBegin()[0].getRegisterName()];
+
+				if (source == destination)
+					instruction.remove();
+			}
+		}
+	}
+}
+
+
+void RegisterAllocatorTools::updateInstructionGraph(RegisterAllocator& registerAllocator)
+{
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		InstructionList& instructions = nodes[n]->getInstructions();
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					usePtr->setRegisterName(name2range[usePtr->getRegisterName()]);
+
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					definePtr->setRegisterName(name2range[definePtr->getRegisterName()]);
+		}
+
+		InstructionList& phiNodes = nodes[n]->getPhiNodeInstructions();
+		for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+			Instruction& instruction = phiNodes.get(p);
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					usePtr->setRegisterName(name2range[usePtr->getRegisterName()]);
+
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					definePtr->setRegisterName(name2range[definePtr->getRegisterName()]);
+		}
+	}
+}
+
+
+void RegisterAllocatorTools::insertPhiNodeInstructions(ControlGraph& controlGraph, InstructionEmitter& emitter)
+{
+	Pool& pool = controlGraph.pool;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+	
+	for (Uint32 n = 0; n < nNodes; n++) {
+		ControlNode& node = *nodes[n];
+		DoublyLinkedList<PhiNode>& phiNodes = node.getPhiNodes();
+
+		if (!phiNodes.empty()) {
+
+			// Set the index of the incoming edges.
+			Uint32 index = 0;
+			const DoublyLinkedList<ControlEdge>& predecessors = node.getPredecessors();
+			for (DoublyLinkedList<ControlEdge>::iterator p = predecessors.begin(); !predecessors.done(p); p = predecessors.advance(p))
+				predecessors.get(p).setIndex(index++);
+
+			// Insert the phi node instruction in the instruction list.
+			for (DoublyLinkedList<PhiNode>::iterator i = phiNodes.begin(); !phiNodes.done(i); i = phiNodes.advance(i)) {
+				PhiNode& phiNode = phiNodes.get(i);
+				ValueKind kind = phiNode.getKind();
+
+				if (!isStorableKind(kind))
+					continue;
+
+				RegisterClassKind classKind = rckGeneral; // FIX: get class kind from phi node kind.
+				Uint32 nInputs = phiNode.nInputs();
+
+				PhiNodeInstruction& phiNodeInstruction = *new(pool) PhiNodeInstruction(&phiNode, pool, nInputs);
+
+				emitter.defineProducer(phiNode, phiNodeInstruction, 0, classKind, drLow);
+				for (Uint32 whichInput = 0; whichInput < nInputs; whichInput++)
+					emitter.useProducer(phiNode.nthInputVariable(whichInput), phiNodeInstruction, whichInput, classKind, drLow);
+
+				node.addPhiNodeInstruction(phiNodeInstruction);
+
+				if (isDoublewordKind(kind)) {
+					PhiNodeInstruction& phiNodeInstruction = *new(pool) PhiNodeInstruction(&phiNode, pool, nInputs);
+
+					emitter.defineProducer(phiNode, phiNodeInstruction, 0, classKind, drHigh);
+					for (Uint32 whichInput = 0; whichInput < nInputs; whichInput++)
+						emitter.useProducer(phiNode.nthInputVariable(whichInput), phiNodeInstruction, whichInput, classKind, drHigh);
+
+					node.addPhiNodeInstruction(phiNodeInstruction);
+				}
+			}
+		}
+	}
+}
+
+#ifdef DEBUG_LOG
+
+void RegisterAllocatorTools::printSpillCosts(RegisterAllocator& registerAllocator)
+{
+	LogModuleObject log = UT_LOG_MODULE(RegAlloc);
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	SpillCost* cost = registerAllocator.spillCost;
+
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Spill costs:\n"));
+	for (Uint32 i = 1; i < rangeCount; i++) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\trange %d : ", i));
+		if (cost[i].infinite)
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("infinite\n"));
+		else
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("%f\n", cost[i].cost));
+	}
+}
+
+void RegisterAllocatorTools::printSplitCosts(RegisterAllocator& registerAllocator)
+{
+	LogModuleObject log = UT_LOG_MODULE(RegAlloc);
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	SplitCost* cost = registerAllocator.splitCost;
+
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Split costs:\n"));
+	for (Uint32 i = 1; i < rangeCount; i++) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\trange %d : loads = %f stores = %f\n", i, cost[i].loads, cost[i].stores));
+	}
+}
+
+void RegisterAllocatorTools::printInstructions(RegisterAllocator& registerAllocator)
+{
+	LogModuleObject log = UT_LOG_MODULE(RegAlloc);
+	ControlNode** nodes = registerAllocator.controlGraph.dfsList;
+	Uint32 nNodes = registerAllocator.controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("N%d:\n", n));
+
+		InstructionList& phiNodes = nodes[n]->getPhiNodeInstructions();
+		InstructionList& instructions = nodes[n]->getInstructions();
+
+		if (!phiNodes.empty()) {
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, (" PhiNodes:\n", n));
+			for(InstructionList::iterator i = phiNodes.begin(); !phiNodes.done(i); i = phiNodes.advance(i)) {
+				phiNodes.get(i).printPretty(log);
+				UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+			}
+			if (!instructions.empty())
+				UT_OBJECTLOG(log, PR_LOG_ALWAYS, (" Instructions:\n", n));
+		}
+
+		for(InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			instructions.get(i).printPretty(log);
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+		}
+	}
+}
+#endif // DEBUG_LOG

mozilla/ef/Compiler/RegisterAllocator/RegisterAllocatorTools.h

@@ -0,0 +1,117 @@
+//	-*- mode:C++; tab-width:4; truncate-lines:t -*-
+//
+//           CONFIDENTIAL AND PROPRIETARY SOURCE CODE OF
+//              NETSCAPE COMMUNICATIONS CORPORATION
+// Copyright © 1996, 1997 Netscape Communications Corporation.  All Rights
+// Reserved.  Use of this Source Code is subject to the terms of the
+// applicable license agreement from Netscape Communications Corporation.
+// The copyright notice(s) in this Source Code does not indicate actual or
+// intended publication of this Source Code.
+//
+// $Id: RegisterAllocatorTools.h,v 1.1.2.1 1999-03-02 16:12:05 fur%netscape.com Exp $
+//
+
+#ifndef _REGISTER_ALLOCATOR_TOOLS_H_
+#define _REGISTER_ALLOCATOR_TOOLS_H_
+
+#include "LogModule.h"
+#include "RegisterTypes.h"
+#include <string.h>
+
+class RegisterAllocator;
+class ControlGraph;
+class InstructionEmitter;
+class VirtualRegisterManager;
+
+struct RegisterAllocatorTools
+{
+	//
+	//
+	static void insertPhiNodeInstructions(ControlGraph& controlGraph, InstructionEmitter& emitter);
+
+	//
+	//
+	static void updateInstructionGraph(RegisterAllocator& registerAllocator);
+
+	//
+	//
+	static void removeUnnecessaryCopies(RegisterAllocator& registerAllocator);
+
+#ifdef DEBUG
+	//
+	//
+	static void testTheInstructionGraph(ControlGraph& controlGraph, VirtualRegisterManager& vrManager);
+#endif // DEBUG
+
+#ifdef DEBUG_LOG
+	//
+	//
+	static void printInstructions(RegisterAllocator& registerAllocator);
+
+	//
+	//
+	static void printSpillCosts(RegisterAllocator& registerAllocator);
+
+	//
+	//
+	static void printSplitCosts(RegisterAllocator& registerAllocator);
+#endif // DEBUG_LOG
+};
+
+//
+// FIX: this should go in a class (LookupTable ?)
+//
+
+inline RegisterName findRoot(RegisterName name, RegisterName* table)
+{
+	RegisterName* stack = table;
+	RegisterName* stackPtr = stack;
+
+	RegisterName newName;
+	while((newName = table[name]) != name) {
+		*--stackPtr = name;
+		name = newName;
+	}
+
+	while (stackPtr != stack)
+		table[*stackPtr++] = name;
+
+	return name;
+}
+
+inline void init(RegisterName* table, Uint32 nameCount)
+{
+	for (RegisterName r = RegisterName(0); r < nameCount; r = RegisterName(r + 1))
+		table[r] = r;
+}
+
+inline Uint32 compress(RegisterName* name2range, RegisterName* table, Uint32 nameCount, Uint32 tableSize)
+{
+	RegisterName* liveRange = new RegisterName[tableSize];
+	memset(liveRange, '\0', tableSize * sizeof(RegisterName));
+
+	// Update the lookup table.
+	for (RegisterName r = RegisterName(1); r < tableSize; r = RegisterName(r + 1))
+		findRoot(r, table);
+
+	// Count the liveranges.
+	Uint32 liveRangeCount = 1;
+	for (RegisterName s = RegisterName(1); s < tableSize; s = RegisterName(s + 1))
+		if (table[s] == s)
+			liveRange[s] = RegisterName(liveRangeCount++);
+
+	for (RegisterName t = RegisterName(1); t < nameCount; t = RegisterName(t + 1))
+		name2range[t] = liveRange[table[name2range[t]]];
+
+	return liveRangeCount;
+}
+
+inline double doLog10(Uint32 power)
+{
+	double log = 1.0;
+	while (power--)
+		log *= 10.0;
+	return log;
+}
+
+#endif // _REGISTER_ALLOCATOR_TOOLS_H_

mozilla/ef/Compiler/RegisterAllocator/RegisterAssigner.h

@@ -1,4 +1,4 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  *
  * The contents of this file are subject to the Netscape Public License
  * Version 1.0 (the "NPL"); you may not use this file except in
@@ -16,40 +16,23 @@
  * Reserved.
  */
 
-//
-// nsRepeatService
-//
-#ifndef nsRepeatService_h__
-#define nsRepeatService_h__
+#ifndef _REGISTER_ASSIGNER_H_
+#define _REGISTER_ASSIGNER_H_
 
-#include "nsCOMPtr.h"
-#include "nsITimerCallback.h"
-#include "nsITimer.h"
+#include "Fundamentals.h"
+#include "VirtualRegister.h"
 
-class nsITimer;
+class FastBitMatrix;
 
-class nsRepeatService : public nsITimerCallback
+class RegisterAssigner
 {
-public:
-
-  virtual void Notify(nsITimer *timer);
-
-  void Start(nsITimerCallback* aCallback);
-  void Stop();
-
-  static nsRepeatService* GetInstance();
-
-  NS_DECL_ISUPPORTS
-  virtual ~nsRepeatService();
-
 protected:
-  nsRepeatService();
+  VirtualRegisterManager& vRegManager;
+  
+public:
+  RegisterAssigner(VirtualRegisterManager& vrMan) : vRegManager(vrMan) {}
+  
+  virtual bool assignRegisters(FastBitMatrix& interferenceMatrix) = 0;
+};
 
-private:
-  nsCOMPtr<nsITimerCallback> mCallback;
-  nsCOMPtr<nsITimer>         mRepeatTimer;
-  static nsRepeatService*    gInstance;
-
-}; // class nsRepeatService
-
-#endif
+#endif /* _REGISTER_ASSIGNER_H_ */

mozilla/ef/Compiler/RegisterAllocator/RegisterClass.h

@@ -0,0 +1,25 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _REGISTER_CLASS_H_
+#define _REGISTER_CLASS_H_
+
+#include "Fundamentals.h"
+#include "RegisterTypes.h"
+
+#endif // _REGISTER_CLASS_H_

mozilla/ef/Compiler/RegisterAllocator/RegisterPressure.h

@@ -0,0 +1,37 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _REGISTER_PRESSURE_H_
+#define _REGISTER_PRESSURE_H_
+
+#include "BitSet.h"
+#include "HashSet.h"
+
+struct LowRegisterPressure
+{
+	typedef BitSet Set;
+	static const bool setIsOrdered = true;
+};
+
+struct HighRegisterPressure
+{
+	typedef HashSet Set;
+	static const bool setIsOrdered = false;
+};
+
+#endif // _REGISTER_PRESSURE_H_

mozilla/ef/Compiler/RegisterAllocator/RegisterTypes.h

@@ -0,0 +1,104 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _REGISTER_TYPES_H_
+#define _REGISTER_TYPES_H_
+
+#include "Fundamentals.h"
+
+//------------------------------------------------------------------------------
+// RegisterName -
+//
+
+enum RegisterName {
+	rnInvalid = 0,
+};
+
+//------------------------------------------------------------------------------
+// RegisterClassKind -
+//
+
+enum RegisterClassKind {
+	rckInvalid = 0,
+	rckGeneral,
+	rckStackSlot,
+
+	nRegisterClassKind
+};
+
+//------------------------------------------------------------------------------
+// RegisterID -
+//
+
+enum RegisterID {
+	invalidID = 0
+};
+
+//------------------------------------------------------------------------------
+// RegisterKind -
+//
+
+enum RegisterKind {
+	rkCallerSave = 0,
+	rkCalleeSave,
+};
+
+struct NameLinkedList {
+	RegisterName name;
+	NameLinkedList* next;
+};
+
+#ifdef DEBUG
+
+const registerNameMask = 		0x03ffffff;
+const coloredRegisterMask = 	0x04000000;
+const machineRegisterMask = 	0x08000000;
+const registerClassMask = 		0xf0000000;
+
+const registerNameShift = 		0;
+const coloredRegisterShift = 	26;
+const machineRegisterShift = 	27;
+const registerClassShift = 		28;
+
+#else // DEBUG
+
+const registerNameMask = 		0x0fffffff;
+const registerClassMask = 		0xf0000000;
+
+const registerNameShift = 		0;
+const registerClassShift = 		28;
+
+#endif // DEBUG
+
+
+inline RegisterClassKind getClass(RegisterID registerID) {return RegisterClassKind((registerID & registerClassMask) >> registerClassShift);}
+inline RegisterName getName(RegisterID registerID) {return RegisterName((registerID & registerNameMask) >> registerNameShift);}
+inline void setClass(RegisterID& registerID, RegisterClassKind classKind) {registerID = RegisterID((registerID & ~registerClassMask) | ((classKind << registerClassShift) & registerClassMask));}
+inline void setName(RegisterID& registerID, RegisterName name) {assert((name & ~registerNameMask) == 0); registerID = RegisterID((registerID & ~registerNameMask) | ((name << registerNameShift) & registerNameMask));}
+inline RegisterID buildRegisterID(RegisterName name, RegisterClassKind classKind) {return RegisterID(((classKind << registerClassShift) & registerClassMask) | ((name << registerNameShift) & registerNameMask));}
+
+#ifdef DEBUG
+
+inline bool isMachineRegister(RegisterID rid) {return (rid & machineRegisterMask) != 0;}
+inline void setMachineRegister(RegisterID& rid) {rid = RegisterID(rid | machineRegisterMask);}
+inline bool isColoredRegister(RegisterID rid) {return (rid & coloredRegisterMask) != 0;}
+inline void setColoredRegister(RegisterID& rid) {rid = RegisterID(rid | coloredRegisterMask);}
+
+#endif // DEBUG
+
+#endif // _REGISTER_TYPES_H_

mozilla/ef/Compiler/RegisterAllocator/SSATools.cpp

@@ -0,0 +1,32 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "SSATools.h"
+#include "ControlGraph.h"
+#include "VirtualRegister.h"
+#include "Liveness.h"
+
+void replacePhiNodes(ControlGraph& controlGraph, VirtualRegisterManager& vrManager)
+{
+	if (!controlGraph.hasBackEdges)
+		return;
+
+	Liveness liveness(controlGraph.pool);
+	liveness.buildLivenessAnalysis(controlGraph, vrManager);
+}

mozilla/ef/Compiler/RegisterAllocator/SSATools.h

@@ -0,0 +1,29 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _SSA_TOOLS_H_
+#define _SSA_TOOLS_H_
+
+#include "Fundamentals.h"
+
+class ControlGraph;
+class VirtualRegisterManager;
+
+extern void replacePhiNodes(ControlGraph& controlGraph, VirtualRegisterManager& vrManager);
+
+#endif // _SSA_TOOLS_H_

mozilla/ef/Compiler/RegisterAllocator/SparseSet.cpp

@@ -0,0 +1,37 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "SparseSet.h"
+#include "BitSet.h"
+#include "Pool.h"
+
+#ifdef DEBUG_LOG
+// Print the set.
+//
+void SparseSet::printPretty(LogModuleObject log)
+{
+	Pool pool;
+	BitSet set(pool, universeSize);
+
+	for (Uint32 i = 0; i < count; i++)
+	   set.set(node[i].element);
+
+	set.printPretty(log);
+}
+#endif // DEBUG_LOG

mozilla/ef/Compiler/RegisterAllocator/SparseSet.h

@@ -0,0 +1,168 @@
+//	-*- mode:C++; tab-width:4; truncate-lines:t -*-
+//
+//           CONFIDENTIAL AND PROPRIETARY SOURCE CODE OF
+//              NETSCAPE COMMUNICATIONS CORPORATION
+// Copyright © 1996, 1997 Netscape Communications Corporation.  All Rights
+// Reserved.  Use of this Source Code is subject to the terms of the
+// applicable license agreement from Netscape Communications Corporation.
+// The copyright notice(s) in this Source Code does not indicate actual or
+// intended publication of this Source Code.
+//
+// $Id: SparseSet.h,v 1.1.2.1 1999-03-02 16:12:07 fur%netscape.com Exp $
+//
+
+#ifndef _SPARSE_SET_H_
+#define _SPARSE_SET_H_
+
+#include "Fundamentals.h"
+#include "Pool.h"
+#include "LogModule.h"
+#include "BitSet.h"
+
+class SparseSet
+{
+private:
+
+	struct Node {
+		Uint32		element;
+		Uint32		stackIndex;
+	};
+
+	Node*			node;
+	Uint32			count;
+	Uint32			universeSize;
+
+private:
+
+	// No copy constructor.
+	SparseSet(const SparseSet&);
+
+	// Check if the given set's universe is of the same size than this universe.
+	void checkUniverseCompatibility(const SparseSet& set) const {assert(set.universeSize == universeSize);}
+	// Check if pos is valid for this set's universe.
+	void checkMember(Int32 pos) const {assert(pos >=0 && Uint32(pos) < universeSize);}
+
+public:
+
+	SparseSet(Pool& pool, Uint32 universeSize) : universeSize(universeSize) {node = new(pool) Node[universeSize]; clear();}
+
+	// Clear the sparse set.
+	void clear() {count = 0;}
+	// Clear the element at index.
+	inline void clear(Uint32 index);
+	// Set the element at index.
+	inline void set(Uint32 index);
+	// Return true if the element at index is set.
+	inline bool test(Uint32 index) const;
+	// Union with the given sparse set.
+	inline void or(const SparseSet& set);
+	// Intersection with the given sparse set.
+	inline void and(const SparseSet& set);
+	// Difference with the given sparse set.
+	inline void difference(const SparseSet& set);
+	// Copy set.
+	inline SparseSet& operator = (const SparseSet& set);
+	inline SparseSet& operator = (const BitSet& set);
+	// Return true if the sparse sets are identical.
+	friend bool operator == (const SparseSet& set1, const SparseSet& set2);
+	// Return true if the sparse sets are different.
+	friend bool operator != (const SparseSet& set1, const SparseSet& set2);
+
+	// Logical operators.
+	SparseSet& operator |= (const SparseSet& set) {or(set); return *this;}
+	SparseSet& operator &= (const SparseSet& set) {and(set); return *this;}
+	SparseSet& operator -= (const SparseSet& set) {difference(set); return *this;}
+
+	// Iterator to conform with the set API.
+	typedef Int32 iterator;
+	// Return the iterator for the first element of this set.
+	iterator begin() const {return count - 1;}
+	// Return the next iterator.
+	iterator advance(iterator pos) const {return --pos;}
+	// Return true if the iterator is at the end of the set.
+	bool done(iterator pos) const {return pos < 0;}
+	// Return the element for the given iterator;
+	Uint32 get(iterator pos) const {return node[pos].element;}
+	// Return one element of this set.
+	Uint32 getOne() const {assert(count > 0); return node[0].element;}
+	// Return the size of this set.
+	Uint32 getSize() const {return count;}
+
+#ifdef DEBUG_LOG
+	// Print the set.
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+inline void SparseSet::clear(Uint32 element)
+{
+	checkMember(element);
+	Uint32 count = this->count;
+	Node* node = this->node;
+
+	Uint32 stackIndex = node[element].stackIndex;
+
+	if ((stackIndex < count) && (node[stackIndex].element == element)) {
+		Uint32 stackTop = node[count - 1].element;
+
+		node[stackIndex].element = stackTop;
+		node[stackTop].stackIndex = stackIndex;
+		this->count = count - 1;
+	}
+}
+
+inline void SparseSet::set(Uint32 element)
+{
+	checkMember(element);
+  	Uint32 count = this->count;
+	Node* node = this->node;
+
+	Uint32 stackIndex = node[element].stackIndex;
+
+	if ((stackIndex >= count) || (node[stackIndex].element != element)) {
+		node[count].element = element;
+		node[element].stackIndex = count;
+		this->count = count + 1;
+	}
+}
+
+inline bool SparseSet::test(Uint32 element) const
+{
+	checkMember(element);
+	Node* node = this->node;
+
+	Uint32 stackIndex = node[element].stackIndex;
+	return ((stackIndex < count) && (node[stackIndex].element == element));
+}
+
+inline SparseSet& SparseSet::operator = (const SparseSet& set)
+{
+	checkUniverseCompatibility(set);
+	Uint32 sourceCount = set.getSize();
+	Node* node = this->node;
+
+	memcpy(node, set.node, sourceCount * sizeof(Node));
+
+	for (Uint32 i = 0; i < sourceCount; i++) {
+		Uint32 element = node[i].element;
+		node[element].stackIndex = i;
+	}
+
+	count = sourceCount;
+
+	return *this;
+}
+
+
+inline SparseSet& SparseSet::operator = (const BitSet& set)
+{
+	// FIX: there's room for optimization here.
+	assert(universeSize == set.getSize());
+
+	clear();
+	for (Int32 i = set.firstOne(); i != -1; i = set.nextOne(i))
+		this->set(i);
+	return *this;
+}
+
+#endif // _SPARSE_SET_H_

mozilla/ef/Compiler/RegisterAllocator/Spilling.cpp

@@ -0,0 +1,270 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef NEW_LAURENTM_CODE
+#define INCLUDE_EMITTER
+#include "CpuInfo.h"
+#include "Fundamentals.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "InstructionEmitter.h"
+#include "Spilling.h"
+
+
+void Spilling::
+insertSpillCode(ControlNode** dfsList, Uint32 nNodes)
+{
+  PRUint32 nVirtualRegisters = vRegManager.count();
+  FastBitSet currentLive(vRegManager.pool, nVirtualRegisters);
+  FastBitSet usedInThisInstruction(vRegManager.pool, nVirtualRegisters);
+  RegisterFifo grNeedLoad(nVirtualRegisters);
+  RegisterFifo fpNeedLoad(nVirtualRegisters);
+
+  for (PRInt32 n = nNodes - 1; n >= 0; n--)
+	{
+	  PR_ASSERT(grNeedLoad.empty() & fpNeedLoad.empty());
+	  ControlNode& node = *dfsList[n];
+
+	  currentLive = node.liveAtEnd;
+
+	  PRUint32 nGeneralAlive = 0;
+	  PRUint32 nFloatingPointAlive = 0;
+
+	  // Get the number of registers alive at the end of this node.
+	  for (PRInt32 j = currentLive.firstOne(); j != -1; j = currentLive.nextOne(j))
+		{
+		  VirtualRegister& vReg = vRegManager.getVirtualRegister(j);
+		  if (vReg.spillInfo.willSpill)
+			{
+			  currentLive.clear(j);
+			}
+		  else
+			{
+			  switch (vReg.getClass())
+				{
+				case vrcInteger:
+				  nGeneralAlive++;
+				  break;
+				case vrcFloatingPoint:
+				case vrcFixedPoint:
+				  nFloatingPointAlive++;
+				  break;
+				default:
+				  break;
+				}
+			}
+		}
+	  
+//		  if(node.dfsNum == 8) printf("\n________Begin Node %d________\n", node.dfsNum);
+
+		InstructionList& instructions = node.getInstructions();
+	  for (InstructionList::iterator i = instructions.end(); !instructions.done(i); i = instructions.retreat(i))
+		{
+		  Instruction&       instruction = instructions.get(i);
+		  InstructionUse*    useBegin    = instruction.getInstructionUseBegin();
+		  InstructionUse*    useEnd      = instruction.getInstructionUseEnd();
+		  InstructionUse*    usePtr;
+		  InstructionDefine* defBegin    = instruction.getInstructionDefineBegin();
+		  InstructionDefine* defEnd      = instruction.getInstructionDefineEnd();
+		  InstructionDefine* defPtr;
+
+//		if(node.dfsNum == 8)  { printf("\n");
+//		instruction.printPretty(stdout);
+//		printf("\n"); }
+
+		  // Handle definitions
+		  for (defPtr = defBegin; defPtr < defEnd; defPtr++)
+			if (defPtr->isVirtualRegister())
+			  {
+				VirtualRegister& vReg = defPtr->getVirtualRegister();
+				currentLive.clear(vReg.getRegisterIndex());
+				switch (vReg.getClass())
+				  {
+				  case vrcInteger:
+					nGeneralAlive--;
+					break;
+				  case vrcFloatingPoint:
+				  case vrcFixedPoint:
+					nFloatingPointAlive--;
+					break;
+				  default:
+					break;
+				  }
+			  }
+
+		  // Check for deaths
+		  for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+			if (usePtr->isVirtualRegister())
+			  {
+				VirtualRegister& vReg = usePtr->getVirtualRegister();
+				if (!currentLive.test(vReg.getRegisterIndex()))
+				  // This is the last use of this register.
+				  {
+					currentLive.set(vReg.getRegisterIndex());
+					switch (vReg.getClass())
+					  {
+					  case vrcInteger:
+						nGeneralAlive++;
+						while (/*(nGeneralAlive > NUMBER_OF_GREGISTERS) &&*/ !grNeedLoad.empty())
+						  {
+							PRUint32 toLoad = grNeedLoad.get();
+							currentLive.clear(toLoad);
+							nGeneralAlive--;
+							
+							VirtualRegister& nReg = vRegManager.getVirtualRegister(toLoad);
+							Instruction& lastUsingInstruction = *nReg.spillInfo.lastUsingInstruction;
+							emitter.emitLoadAfter(*lastUsingInstruction.getPrimitive(), lastUsingInstruction.getLinks().prev,
+												  nReg.getAlias(), *nReg.equivalentRegister[vrcStackSlot]);
+							nReg.releaseSelf();
+						  }
+						break;
+					  case vrcFloatingPoint:
+					  case vrcFixedPoint:
+						nFloatingPointAlive++;
+						while (/*(nFloatingPointAlive > NUMBER_OF_FPREGISTERS) &&*/ !fpNeedLoad.empty())
+						  {
+							PRUint32 toLoad = fpNeedLoad.get();
+							currentLive.clear(toLoad);
+							nFloatingPointAlive--;
+							
+							VirtualRegister& nReg = vRegManager.getVirtualRegister(toLoad);
+							Instruction& lastUsingInstruction = *nReg.spillInfo.lastUsingInstruction;
+							emitter.emitLoadAfter(*lastUsingInstruction.getPrimitive(), lastUsingInstruction.getLinks().prev,
+												  nReg.getAlias(), *nReg.equivalentRegister[vrcStackSlot]);
+							nReg.releaseSelf();
+						  }
+						break;
+					  default:
+						break;
+					  }
+				  }
+			  }
+
+		  // Handle uses
+		  for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+			if (usePtr->isVirtualRegister())
+			  {
+				VirtualRegister& vReg = usePtr->getVirtualRegister();
+				PRUint32 registerIndex = vReg.getRegisterIndex();
+
+				if (vReg.spillInfo.willSpill) {
+#if defined(GENERATE_FOR_X86)
+				  if (!instruction.switchUseToSpill((usePtr - useBegin), *vReg.equivalentRegister[vrcStackSlot]))
+#endif
+					{
+					  switch (vReg.getClass())
+						{
+						case vrcInteger:
+						  if (!grNeedLoad.test(registerIndex))
+							{
+							  grNeedLoad.put(registerIndex);
+							  VirtualRegister& alias = vRegManager.newVirtualRegister(vrcInteger);
+							  if (vReg.isPreColored())
+								  alias.preColorRegister(vReg.getPreColor());
+							  /* if (vReg.hasSpecialInterference) {
+								  alias.specialInterference.sizeTo(NUMBER_OF_REGISTERS);
+								  alias.specialInterference = vReg.specialInterference;
+								  alias.hasSpecialInterference = true;
+							  } */
+							  vReg.setAlias(alias);
+							  vReg.retainSelf();
+							}
+						  break;
+						case vrcFloatingPoint:
+						case vrcFixedPoint:
+						  if (!fpNeedLoad.test(registerIndex))
+							{
+							  fpNeedLoad.put(registerIndex);
+							  VirtualRegister& alias = vRegManager.newVirtualRegister(vReg.getClass());
+							  if (vReg.isPreColored())
+								  alias.preColorRegister(vReg.getPreColor());
+							  /*if (vReg.hasSpecialInterference) {
+								  alias.specialInterference.sizeTo(NUMBER_OF_REGISTERS);
+								  alias.specialInterference = vReg.specialInterference;
+								  alias.hasSpecialInterference = true;
+							  } */
+							  vReg.setAlias(alias);
+							  vReg.retainSelf();
+							}
+						  break;
+						default:
+						  break;
+						}
+					  usePtr->getVirtualRegisterPtr().initialize(vReg.getAlias());
+					  usedInThisInstruction.set(registerIndex);
+					  vReg.spillInfo.lastUsingInstruction = &instruction;
+					}
+				  currentLive.clear(registerIndex);
+				} else { // will not spill
+				  currentLive.set(registerIndex);
+				}
+			  }
+		  
+		  // Handle definitions
+		  for (defPtr = defBegin; defPtr < defEnd; defPtr++)
+			if (defPtr->isVirtualRegister())
+			  {
+				VirtualRegister& vReg = defPtr->getVirtualRegister();
+				
+				if (vReg.spillInfo.willSpill)
+#if defined(GENERATE_FOR_X86)
+				  if (!instruction.switchDefineToSpill((defPtr - defBegin), *vReg.equivalentRegister[vrcStackSlot]))
+#endif
+					{
+					  if (usedInThisInstruction.test(vReg.getRegisterIndex()))
+						// this virtualRegister was used in this instruction and is also defined. We need to move 
+						// this virtual register to its alias first and then save it to memory.
+						{
+						  emitter.emitStoreAfter(*instruction.getPrimitive(), &instruction.getLinks(), 
+												 vReg.getAlias(), *vReg.equivalentRegister[vrcStackSlot]);
+						  defPtr->getVirtualRegisterPtr().initialize(vReg.getAlias());
+						}
+					  else
+						{
+						  emitter.emitStoreAfter(*instruction.getPrimitive(), &instruction.getLinks(), 
+												 vReg, *vReg.equivalentRegister[vrcStackSlot]);
+						}
+					}
+			  }
+		}
+	  while (!grNeedLoad.empty())
+		{
+		  PRUint32 nl = grNeedLoad.get();
+		  VirtualRegister& nlReg = vRegManager.getVirtualRegister(nl);
+		  Instruction& lastUse = *nlReg.spillInfo.lastUsingInstruction;
+		  
+		  emitter.emitLoadAfter(*lastUse.getPrimitive(), lastUse.getLinks().prev, 
+								nlReg.getAlias(), *nlReg.equivalentRegister[vrcStackSlot]);
+		  nlReg.releaseSelf();
+		}
+	  while (!fpNeedLoad.empty())
+		{
+		  PRUint32 nl = fpNeedLoad.get();
+		  VirtualRegister& nlReg = vRegManager.getVirtualRegister(nl);
+		  Instruction& lastUse = *nlReg.spillInfo.lastUsingInstruction;
+
+		  emitter.emitLoadAfter(*lastUse.getPrimitive(), lastUse.getLinks().prev, 
+								nlReg.getAlias(), *nlReg.equivalentRegister[vrcStackSlot]);
+		  nlReg.releaseSelf();
+		}
+
+//	  if(node.dfsNum == 8) printf("\n________End Node %d________\n", node.dfsNum);
+
+	}
+}
+#endif

mozilla/ef/Compiler/RegisterAllocator/Spilling.h

@@ -0,0 +1,269 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _SPILLING_H_
+#define _SPILLING_H_
+
+#include "Fundamentals.h"
+#include <string.h>
+#include "RegisterAllocator.h"
+#include "RegisterAllocatorTools.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "SparseSet.h"
+
+template <class RegisterPressure>
+class Spilling
+{
+private:
+	static void insertStoreAfter(Instruction& instruction, RegisterName name);
+	static void insertLoadBefore(Instruction& instruction, RegisterName name);
+
+public:
+	static void calculateSpillCosts(RegisterAllocator& registerAllocator);
+	static void insertSpillCode(RegisterAllocator& registerAllocator);
+};
+
+struct SpillCost
+{
+	double loads;
+	double stores;
+	double copies;
+	double cost;
+	bool infinite;
+};
+
+template <class RegisterPressure>
+void Spilling<RegisterPressure>::insertSpillCode(RegisterAllocator& registerAllocator)
+{
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	Pool& pool = registerAllocator.pool;
+	SparseSet currentLive(pool, rangeCount);
+	SparseSet needLoad(pool, rangeCount);
+	SparseSet mustSpill(pool, rangeCount);
+	SparseSet& willSpill = *registerAllocator.willSpill;
+	
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	RegisterPressure::Set* liveOut = registerAllocator.liveness.liveOut;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+
+		needLoad.clear();
+		currentLive = liveOut[n];
+		mustSpill = currentLive;
+
+		InstructionList& instructions = nodes[n]->getInstructions();
+		for (InstructionList::iterator i = instructions.end(); !instructions.done(i);) {
+			Instruction& instruction = instructions.get(i);
+			i = instructions.retreat(i);
+
+			InstructionUse* useBegin = instruction.getInstructionUseBegin();
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			InstructionUse* usePtr;
+			InstructionDefine* defineBegin = instruction.getInstructionDefineBegin();
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			InstructionDefine* definePtr;
+
+			bool foundLiveDefine = false;
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister()) {
+					if (currentLive.test(name2range[definePtr->getRegisterName()])) {
+						foundLiveDefine = true;
+						break;
+					}
+				} else {
+					foundLiveDefine = true;
+					break;
+				}
+			if (defineBegin != defineEnd && !foundLiveDefine) {
+				fprintf(stderr, "!!! Removed instruction because it was only defining unused registers !!!\n");
+				instruction.remove();
+			}
+
+ 			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister()) {
+					RegisterName range = name2range[definePtr->getRegisterName()];
+#ifdef DEBUG
+					if (needLoad.test(range))
+						if (!mustSpill.test(range) && registerAllocator.spillCost[range].infinite && willSpill.test(range)) {
+							fprintf(stderr, "Tried to spill a register with infinite spill cost\n");
+							abort();
+						}
+#endif // DEBUG
+					if (willSpill.test(range))
+						insertStoreAfter(instruction, range);
+
+					needLoad.clear(range);
+				}
+
+			if (instruction.getFlags() & ifCopy)
+				for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+					if (usePtr->isRegister()) {
+						RegisterName range = name2range[usePtr->getRegisterName()];
+						if (!currentLive.test(range))
+							for (SparseSet::iterator r = needLoad.begin(); !needLoad.done(r); r = needLoad.advance(r)) {
+								RegisterName load = RegisterName(needLoad.get(r));
+								if (willSpill.test(load))
+									insertLoadBefore(instruction, load);
+								mustSpill.set(load);
+							}
+						needLoad.clear();
+					}
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister())
+					currentLive.clear(name2range[definePtr->getRegisterName()]);
+
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					RegisterName range = name2range[usePtr->getRegisterName()];
+					currentLive.set(range);
+					needLoad.set(range);
+				}
+		}
+
+		for (SparseSet::iterator l = needLoad.begin(); !needLoad.done(l); l = needLoad.advance(l)) {
+			RegisterName load = RegisterName(needLoad.get(l));
+			if (willSpill.test(load))
+				insertLoadBefore(instructions.first(), load);
+		}		
+	}
+}
+
+template <class RegisterPressure>
+void Spilling<RegisterPressure>::insertLoadBefore(Instruction& /*instruction*/, RegisterName name)
+{
+	fprintf(stdout, "will insert load for range %d\n", name);
+}
+
+template <class RegisterPressure>
+void Spilling<RegisterPressure>::insertStoreAfter(Instruction& /*instruction*/, RegisterName name)
+{
+	fprintf(stdout, "will insert store for range %d\n", name);
+}
+
+template <class RegisterPressure>
+void Spilling<RegisterPressure>::calculateSpillCosts(RegisterAllocator& registerAllocator)
+{
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	Pool& pool = registerAllocator.pool;
+	SparseSet live(pool, rangeCount);
+	SparseSet needLoad(pool, rangeCount);
+	SparseSet mustSpill(pool, rangeCount);
+
+	SparseSet alreadyStored(pool, rangeCount); // FIX: should get this from previous spilling.
+
+	SpillCost* cost = new SpillCost[rangeCount];
+	memset(cost, '\0', rangeCount * sizeof(SpillCost));
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	RegisterPressure::Set* liveOut = registerAllocator.liveness.liveOut;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		ControlNode& node = *nodes[n];
+
+		double weight = doLog10(node.loopDepth);
+
+		needLoad.clear();
+		live = liveOut[n];
+		mustSpill = live;
+
+		InstructionList& instructions = nodes[n]->getInstructions();
+		for (InstructionList::iterator i = instructions.end(); !instructions.done(i); i = instructions.retreat(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useBegin = instruction.getInstructionUseBegin();
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			InstructionUse* usePtr;
+			InstructionDefine* defineBegin = instruction.getInstructionDefineBegin();
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			InstructionDefine* definePtr;
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister()) {
+					RegisterName range = name2range[definePtr->getRegisterName()];
+
+					if (needLoad.test(range))
+						if (!mustSpill.test(range))
+							cost[range].infinite = true;
+
+					if ((false /* !rematerializable(range) */ || !needLoad.test(range)) && !alreadyStored.test(range))
+						cost[range].stores += weight;
+
+					needLoad.clear(range);
+				}
+
+			if (instruction.getFlags() & ifCopy)
+				for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+					if (usePtr->isRegister())
+						if (!live.test(name2range[usePtr->getRegisterName()])) {
+							for (SparseSet::iterator l = needLoad.begin(); !needLoad.done(l); l = needLoad.advance(l)) {
+								Uint32 range = needLoad.get(l);
+								cost[range].loads += weight;
+								mustSpill.set(range);
+							}
+							needLoad.clear();
+						}
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister())
+					live.clear(name2range[definePtr->getRegisterName()]);
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					RegisterName range = name2range[usePtr->getRegisterName()];
+
+					live.set(range);
+					needLoad.set(range);
+				}
+
+			if (instruction.getFlags() & ifCopy) {
+				assert(useBegin != useEnd && useBegin[0].isRegister());
+				assert(defineBegin != defineEnd && defineBegin[0].isRegister());
+
+				RegisterName source = name2range[useBegin[0].getRegisterName()];
+				RegisterName destination = name2range[defineBegin[0].getRegisterName()];
+
+				cost[source].copies += weight;
+				cost[destination].copies += weight;
+			}			
+		}
+
+		for (SparseSet::iterator s = needLoad.begin(); !needLoad.done(s); s = needLoad.advance(s))
+			cost[needLoad.get(s)].loads += weight;
+	}
+	
+	for (Uint32 r = 0; r < rangeCount; r++) {
+		SpillCost& c = cost[r];
+		c.cost = 2 * (c.loads + c.stores) - c.copies;
+	}
+
+	registerAllocator.spillCost = cost;
+}
+
+#endif // _SPILLING_H_

mozilla/ef/Compiler/RegisterAllocator/Splits.h

@@ -0,0 +1,239 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _SPLITS_H_
+#define _SPLITS_H_
+
+#include "Fundamentals.h"
+#include <string.h>
+#include "Pool.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "RegisterAllocator.h"
+#include "RegisterAllocatorTools.h"
+
+UT_EXTERN_LOG_MODULE(RegAlloc);
+
+template <class RegisterPressure>
+struct Splits
+{
+	static void calculateSplitCosts(RegisterAllocator& registerAllocator);
+	static bool findSplit(RegisterAllocator& registerAllocator, RegisterName* color, RegisterName range);
+	static void insertSplitCode(RegisterAllocator& registerAllocator);
+};
+
+struct SplitCost
+{
+	double loads;
+	double stores;
+};
+
+template <class RegisterPressure>
+void Splits<RegisterPressure>::insertSplitCode(RegisterAllocator& /*registerAllocator*/)
+{
+	// FIX
+}
+
+template <class RegisterPressure>
+bool Splits<RegisterPressure>::findSplit(RegisterAllocator& registerAllocator, RegisterName* color, RegisterName range)
+{
+	Pool& pool = registerAllocator.pool;
+	NameLinkedList** neighborsWithColor = new(pool) NameLinkedList*[6]; // FIX
+	memset(neighborsWithColor, '\0', 6 * sizeof(NameLinkedList*));
+
+	InterferenceGraph<RegisterPressure>& iGraph = registerAllocator.iGraph;
+
+	for (InterferenceVector* vector = iGraph.getInterferenceVector(range); vector != NULL; vector = vector->next)
+		for (Int32 i = vector->count - 1; i >=0; --i) {
+			RegisterName neighbor = vector->neighbors[i];
+			RegisterName c = color[neighbor];
+
+			if (c < 6) { // FIX
+				NameLinkedList* node = new(pool) NameLinkedList();
+				node->name = neighbor;
+				node->next = neighborsWithColor[c];
+				neighborsWithColor[c] = node;
+			}
+		}
+
+	bool splitAroundName = true;
+
+	LiveRangeGraph<RegisterPressure>& lGraph = registerAllocator.lGraph;
+	RegisterName bestColor = RegisterName(6); // FIX
+	double bestCost = registerAllocator.spillCost[range].cost;
+	SplitCost* splitCost = registerAllocator.splitCost;
+
+	for (RegisterName i = RegisterName(0); i < 6; i = RegisterName(i + 1)) { // FIX
+
+		double splitAroundNameCost = 0.0;
+		bool canSplitAroundName = true;
+
+		SplitCost& sCost = splitCost[range];
+		double addedCost = 2.0 * (sCost.stores + sCost.loads);
+
+		for (NameLinkedList* node = neighborsWithColor[i]; node != NULL; node = node->next) {
+			RegisterName neighbor = node->name;
+			if (lGraph.haveEdge(neighbor, range)) {
+				canSplitAroundName = false;
+				break;
+			} else
+				splitAroundNameCost += addedCost;
+		}
+		if (canSplitAroundName && splitAroundNameCost < bestCost) {
+			bestCost = splitAroundNameCost;
+			bestColor = i;
+			splitAroundName = true;
+		}
+
+		double splitAroundColorCost = 0.0;
+		bool canSplitAroundColor = true;
+
+		for (NameLinkedList* node = neighborsWithColor[i]; node != NULL; node = node->next) {
+			RegisterName neighbor = node->name;
+			if (lGraph.haveEdge(range, neighbor)) {
+				canSplitAroundColor = false;
+				break;
+			} else {
+				SplitCost& sCost = splitCost[neighbor];
+				double addedCost = 2.0 * (sCost.stores + sCost.loads);
+				splitAroundColorCost += addedCost;
+			}
+		}
+		if (canSplitAroundColor && splitAroundColorCost < bestCost) {
+			bestCost = splitAroundColorCost;
+			bestColor = i;
+			splitAroundName = false;
+		}
+ 	}
+	if (bestColor < RegisterName(6)) {
+		color[range] = bestColor;
+		registerAllocator.splitFound = true;
+
+		NameLinkedList** splitAround = registerAllocator.splitAround;
+
+		if (splitAroundName)
+			for (NameLinkedList* node = neighborsWithColor[bestColor]; node != NULL; node = node->next) {
+				NameLinkedList* newNode = new(pool) NameLinkedList();
+				newNode->name = node->name;
+				newNode->next = splitAround[range];
+				splitAround[range] = newNode;
+			}
+		else
+			for (NameLinkedList* node = neighborsWithColor[bestColor]; node != NULL; node = node->next) {
+				NameLinkedList* newNode = new(pool) NameLinkedList();
+				RegisterName neighbor = node->name;
+				newNode->name = range;
+				newNode->next = splitAround[neighbor];
+				splitAround[neighbor] = newNode;
+			}
+
+		trespass("Found a split");
+		return true;
+	}
+
+	return false;
+}
+
+template <class RegisterPressure>
+void Splits<RegisterPressure>::calculateSplitCosts(RegisterAllocator& registerAllocator)
+{
+	Pool& pool = registerAllocator.pool;
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	SplitCost* splitCost = new(pool) SplitCost[rangeCount];
+	memset(splitCost, '\0', rangeCount * sizeof(SplitCost));
+
+	SparseSet live(pool, rangeCount);
+	RegisterPressure::Set* liveIn = registerAllocator.liveness.liveIn;
+	RegisterPressure::Set* liveOut = registerAllocator.liveness.liveOut;
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		ControlNode& node = *nodes[n];
+		double weight = doLog10(node.loopDepth);
+
+		live = liveOut[n];
+
+		ControlEdge* successorsEnd = node.getSuccessorsEnd();
+		for (ControlEdge* successorsPtr = node.getSuccessorsBegin(); successorsPtr < successorsEnd; successorsPtr++) {
+			ControlNode& successor = successorsPtr->getTarget();
+
+			if (successor.getControlKind() != ckEnd) {
+				RegisterPressure::Set& successorLiveIn = liveIn[successor.dfsNum];
+
+				for (SparseSet::iterator i = live.begin(); !live.done(i); i = live.advance(i)) {
+					RegisterName name = RegisterName(live.get(i));
+					if (!successorLiveIn.test(name))
+						splitCost[name].loads += doLog10(successor.loopDepth);
+				}
+			}
+		}
+
+		InstructionList& instructions = node.getInstructions();
+		for (InstructionList::iterator i = instructions.end(); !instructions.done(i); i = instructions.retreat(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useBegin = instruction.getInstructionUseBegin();
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			InstructionUse* usePtr;
+			InstructionDefine* defineBegin = instruction.getInstructionDefineBegin();
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			InstructionDefine* definePtr;
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister())
+					splitCost[name2range[definePtr->getRegisterName()]].stores += weight;
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					RegisterName range = name2range[usePtr->getRegisterName()];
+					if (!live.test(range)) {
+						if (&instruction != &instructions.last())
+							splitCost[range].loads += weight;
+						else {
+							ControlEdge* successorsEnd = node.getSuccessorsEnd();
+							for (ControlEdge* successorsPtr = node.getSuccessorsBegin(); successorsPtr < successorsEnd; successorsPtr++)
+								splitCost[range].loads += doLog10(successorsPtr->getTarget().loopDepth);
+						}
+					}
+				}
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister())
+					live.clear(name2range[definePtr->getRegisterName()]);
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					live.set(name2range[usePtr->getRegisterName()]);
+		}
+	}
+
+	NameLinkedList** splitAround = new(pool) NameLinkedList*[rangeCount];
+	memset(splitAround, '\0', rangeCount * sizeof(NameLinkedList*));
+	registerAllocator.splitAround = splitAround;
+
+	registerAllocator.splitCost = splitCost;
+	registerAllocator.splitFound = false;
+}
+
+#endif // _SPLITS_H_

mozilla/ef/Compiler/RegisterAllocator/Timer.cpp

@@ -0,0 +1,186 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "HashTable.h"
+#include "Timer.h"
+#include "Pool.h"
+
+static Pool pool;											// Pool for the Timer class.
+static HashTable<TimerEntry*> timerEntries(pool);			// Timers hashtable.
+
+const nTimersInABlock = 128;								// Number of timers in a block.
+static PRTime *timers = new(pool) PRTime[nTimersInABlock];	// A block of timers.
+static Uint8 nextTimer = 0;									// nextAvailableTimer.
+
+//
+// Calibrate the call to PR_Now().
+//
+static PRTime calibrate()
+{
+	PRTime t = PR_Now();
+	PRTime& a = *new(pool) PRTime();
+
+	// Call 10 times the PR_Now() function.
+	a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); 
+	a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); 
+	t = (PR_Now() - t + 9) / 10;
+
+	return t;
+}
+
+static PRTime adjust = calibrate();
+
+//
+// Return the named timer..
+//
+TimerEntry& Timer::getTimerEntry(const char* name)
+{
+	if (!timerEntries.exists(name)) {
+		TimerEntry* newEntry = new(pool) TimerEntry();
+		newEntry->accumulator = 0;
+		newEntry->running = false;
+		timerEntries.add(name, newEntry);
+	}
+
+	return *timerEntries[name];
+}
+
+//
+// Return a reference to a new timer.
+//
+PRTime& Timer::getNewTimer()
+{
+	if (nextTimer >= nTimersInABlock) {
+		timers = new(pool) PRTime[nTimersInABlock];
+		nextTimer = 0;
+	}
+	return timers[nextTimer++];
+}
+
+static Uint32 timersAreFrozen = 0;
+
+//
+// Start the named timer.
+//
+void Timer::start(const char* name)
+{
+	if (timersAreFrozen)
+		return;
+
+	freezeTimers();
+
+	TimerEntry& timer = getTimerEntry(name);
+	PR_ASSERT(!timer.running);
+
+	timer.accumulator = 0;
+	timer.running = true;
+	timer.done = false;
+
+	unfreezeTimers();
+}
+
+//
+// Stop the named timer.
+//
+void Timer::stop(const char* name)
+{
+	if (timersAreFrozen)
+		return;
+
+	freezeTimers();
+
+	TimerEntry& timer = getTimerEntry(name);
+	PR_ASSERT(timer.running);
+	timer.running = false;
+	timer.done = true;
+
+	unfreezeTimers();
+}
+
+//
+// Freeze all the running timers.
+//
+void Timer::freezeTimers()
+{
+	PRTime when = PR_Now() - adjust;
+
+	if (timersAreFrozen == 0) {
+		Vector<TimerEntry*> entries = timerEntries;
+		Uint32 count = entries.size();
+
+		for (Uint32 i = 0; i < count; i++) {
+			TimerEntry& entry = *entries[i];
+			if (entry.running) {
+				entry.accumulator += (when - *entry.startTime);
+			}
+		}
+	}
+	timersAreFrozen++;
+}
+ 
+//
+// Unfreeze all the running timers.
+//
+void Timer::unfreezeTimers()
+{
+	PR_ASSERT(timersAreFrozen != 0);
+	timersAreFrozen--;
+
+	if (timersAreFrozen == 0) {
+		Vector<TimerEntry *> entries = timerEntries;
+		Uint32 count = entries.size();
+		
+		PRTime& newStart = getNewTimer();
+		
+		for (Uint32 i = 0; i < count; i++) {
+			TimerEntry& entry = *entries[i];
+			if (entry.running) {
+				entry.startTime = &newStart;
+			}
+		}
+		
+		newStart = PR_Now();
+	}
+}
+
+//
+// Print the named timer in the file f.
+//
+void Timer::print(FILE* f, const char *name)
+{
+	if (timersAreFrozen)
+		return;
+
+	freezeTimers();
+
+	TimerEntry& timer = getTimerEntry(name);
+  
+	PR_ASSERT(timer.done);
+	PRTime elapsed = timer.accumulator;
+
+	if (elapsed >> 32) {
+		fprintf(f, "[timer %s out of range]\n", name);
+	} else {
+		fprintf(f, "[%dus in %s]\n", Uint32(elapsed), name);
+	}
+	fflush(f);
+
+	unfreezeTimers();
+}
+

mozilla/ef/Compiler/RegisterAllocator/Timer.h

@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _TIMER_H_
+#define _TIMER_H_
+
+#include "Fundamentals.h"
+#include "HashTable.h"
+#include "prtime.h"
+
+//
+// Naming convention:
+//  As the class Timer contains only static methods, the timer's name should start with the 
+//  module name. Otherwise starting 2 timers with the same name will assert.
+//
+
+#ifndef NO_TIMER
+
+struct TimerEntry
+{
+	PRTime *startTime;					// Current time when we start the timer.
+	PRTime accumulator;					// Time spent in this timer.
+	bool running;						// True if the timer is running.
+	bool done;							// True if the timer was running and was stopped. 
+};
+
+class Timer
+{
+private:
+
+	// Return the named timer.
+	static TimerEntry& getTimerEntry(const char* name);
+	// Return a reference to a new Timer.
+	static PRTime& getNewTimer();
+
+public:
+
+	// Start the timer.
+	static void start(const char* name);
+	// Stop the timer.
+	static void stop(const char* name);
+	// Freeze all the running timers.
+	static void freezeTimers();
+	// Unfreeze all the running timers.
+	static void unfreezeTimers();
+	// Print the timer.
+	static void print(FILE* f, const char *name);
+};
+
+inline void startTimer(const char* name) 		{Timer::start(name);}
+inline void stopTimer(const char* name) 		{Timer::stop(name); Timer::print(stdout, name);}
+#define START_TIMER_SAFE						Timer::freezeTimers();
+#define END_TIMER_SAFE							Timer::unfreezeTimers();
+#define TIMER_SAFE(x)							START_TIMER_SAFE x; END_TIMER_SAFE
+
+#else /* NO_TIMER */
+
+inline void startTimer(const char* /*name*/) 	{} 
+inline void stopTimer(const char* /*name*/) 	{} 
+#define START_TIMER_SAFE
+#define END_TIMER_SAFE
+#define TIMER_SAFE(x)							x;
+
+#endif /* NO_TIMER */
+#endif /* _TIMER_H_ */

mozilla/ef/Compiler/RegisterAllocator/VirtualRegister.cpp

@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "VirtualRegister.h"
+#include "Instruction.h"
+
+//------------------------------------------------------------------------------
+// VirtualRegister -
+
+#ifdef MANUAL_TEMPLATES
+template class IndexedPool<VirtualRegister>;
+#endif
+
+// Set the defining instruction.
+//
+void VirtualRegister::setDefiningInstruction(Instruction& instruction)
+{
+	if (definingInstruction != NULL) {
+		if ((instruction.getFlags() & ifCopy) && (definingInstruction->getFlags() & ifPhiNode))
+			return;
+	}
+	definingInstruction = &instruction;
+}
+

mozilla/ef/Compiler/RegisterAllocator/VirtualRegister.h

@@ -0,0 +1,116 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _VIRTUAL_REGISTER_H_
+#define _VIRTUAL_REGISTER_H_
+
+#include "Fundamentals.h"
+#include "IndexedPool.h"
+#include <string.h>
+
+#include "RegisterTypes.h"
+#include "RegisterClass.h"
+
+
+//------------------------------------------------------------------------------
+// VirtualRegister - 24b
+
+class Instruction;
+
+class VirtualRegister : public IndexedObject<VirtualRegister>
+{
+public:
+
+	Instruction*					definingInstruction;	// Instruction defining this VR.
+
+	// Initialize a VR of the given classKind.
+	VirtualRegister(RegisterClassKind /*classKind*/) : definingInstruction(NULL) {}
+
+	// Return the defining instruction for this VR.
+	Instruction* getDefiningInstruction() const {return definingInstruction;}
+	// Set the defining instruction.
+	void setDefiningInstruction(Instruction& insn);
+};
+
+// Return true if the VirtualRegisters are equals. The only way 2 VRs can be equal is if
+// they have the same index. If they have the same index then they are at the same
+// address in the indexed pool.
+//
+inline bool operator == (const VirtualRegister& regA, const VirtualRegister& regB) {return &regA == &regB;}
+
+//------------------------------------------------------------------------------
+// VirtualRegisterManager -
+
+struct PreColoredRegister
+{
+	RegisterID id;
+	RegisterName color;
+};
+
+class VirtualRegisterManager
+{
+private:
+
+	IndexedPool<VirtualRegister> registerPool;
+	PreColoredRegister machineRegister[6];
+
+public:
+	VirtualRegisterManager()
+		{
+			for (Uint32 i = 0; i < 6; i++)
+				machineRegister[i].id = invalidID;
+		}
+
+	// Return the VirtualRegister at the given index.
+	VirtualRegister& getVirtualRegister(RegisterName name) const {return registerPool.get(name);}
+
+	// Return a new VirtualRegister.
+	RegisterID newVirtualRegister(RegisterClassKind classKind)
+		{
+			VirtualRegister& vReg = *new(registerPool) VirtualRegister(classKind);
+			RegisterID rid;
+
+			setName(rid, RegisterName(vReg.getIndex()));
+			setClass(rid, classKind);
+			return rid;
+		}
+
+	RegisterID newMachineRegister(RegisterName name, RegisterClassKind classKind)
+		{
+			RegisterID rid = machineRegister[name].id;
+
+			if (rid == invalidID) {
+				rid = newVirtualRegister(classKind);
+				DEBUG_ONLY(setMachineRegister(rid));
+				machineRegister[name].id = rid;
+				machineRegister[name].color = name;
+			}
+
+			return rid;
+		}
+
+	PreColoredRegister* getMachineRegistersBegin() const {return (PreColoredRegister*) machineRegister;} // FIX
+	PreColoredRegister* getMachineRegistersEnd() const {return (PreColoredRegister*) &machineRegister[6];} // FIX
+
+	// Return the VirtualRegister universe size.
+	Uint32 getSize() {return registerPool.getSize();}
+
+	void setSize(Uint32 size) {registerPool.setSize(size);}
+};
+
+#endif // _VIRTUAL_REGISTER_H_

mozilla/layout/xul/Makefile.in

@@ -1,28 +0,0 @@
-#
-# The contents of this file are subject to the Netscape Public License
-# Version 1.0 (the "NPL"); you may not use this file except in
-# compliance with the NPL.  You may obtain a copy of the NPL at
-# http://www.mozilla.org/NPL/
-#
-# Software distributed under the NPL is distributed on an "AS IS" basis,
-# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
-# for the specific language governing rights and limitations under the
-# NPL.
-#
-# The Initial Developer of this code under the NPL is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
-# Reserved.
-#
-
-DEPTH		= ../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-DIRS		= content base
-
-include $(topsrcdir)/config/rules.mk
-

mozilla/layout/xul/base/Makefile.in

@@ -1,28 +0,0 @@
-#
-# The contents of this file are subject to the Netscape Public License
-# Version 1.0 (the "NPL"); you may not use this file except in
-# compliance with the NPL.  You may obtain a copy of the NPL at
-# http://www.mozilla.org/NPL/
-#
-# Software distributed under the NPL is distributed on an "AS IS" basis,
-# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
-# for the specific language governing rights and limitations under the
-# NPL.
-#
-# The Initial Developer of this code under the NPL is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
-# Reserved.
-#
-
-DEPTH		= ../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-DIRS		= public src
-
-include $(topsrcdir)/config/rules.mk
-

mozilla/layout/xul/base/makefile.win

@@ -1,22 +0,0 @@
-#!nmake
-#
-# The contents of this file are subject to the Netscape Public License
-# Version 1.0 (the "NPL"); you may not use this file except in
-# compliance with the NPL.  You may obtain a copy of the NPL at
-# http://www.mozilla.org/NPL/
-#
-# Software distributed under the NPL is distributed on an "AS IS" basis,
-# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
-# for the specific language governing rights and limitations under the
-# NPL.
-#
-# The Initial Developer of this code under the NPL is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
-# Reserved.
-
-DEPTH=..\..\..
-
-DIRS=public src
-
-include <$(DEPTH)\config\rules.mak>

mozilla/layout/xul/base/public/Makefile.in

@@ -1,31 +0,0 @@
-#
-# The contents of this file are subject to the Netscape Public License
-# Version 1.0 (the "NPL"); you may not use this file except in
-# compliance with the NPL.  You may obtain a copy of the NPL at
-# http://www.mozilla.org/NPL/
-#
-# Software distributed under the NPL is distributed on an "AS IS" basis,
-# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
-# for the specific language governing rights and limitations under the
-# NPL.
-#
-# The Initial Developer of this code under the NPL is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
-# Reserved.
-#
-
-DEPTH		= ../../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-MODULE		= layout
-
-EXPORTS		= nsIPopupSetFrame.h
-EXPORTS		:= $(addprefix $(srcdir)/, $(EXPORTS))
-
-include $(topsrcdir)/config/rules.mk
-

mozilla/layout/xul/base/public/Manifest

@@ -1,2 +0,0 @@
-nsIPopupSetFrame.h
-

mozilla/layout/xul/base/public/makefile.win

@@ -1,26 +0,0 @@
-#!nmake
-#
-# The contents of this file are subject to the Netscape Public License
-# Version 1.0 (the "NPL"); you may not use this file except in
-# compliance with the NPL.  You may obtain a copy of the NPL at
-# http://www.mozilla.org/NPL/
-#
-# Software distributed under the NPL is distributed on an "AS IS" basis,
-# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
-# for the specific language governing rights and limitations under the
-# NPL.
-#
-# The Initial Developer of this code under the NPL is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
-# Reserved.
-
-DEPTH=..\..\..\.. 
-
-EXPORTS =				\
-	nsIPopupSetFrame.h	\
-    $(NULL)
-
-MODULE=raptor 
-
-include <$(DEPTH)\config\rules.mak>

mozilla/layout/xul/base/public/nsIMenuParent.h

@@ -1,52 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-#ifndef nsIMenuParent_h___
-#define nsIMenuParent_h___
-
-
-// {D407BF61-3EFA-11d3-97FA-00400553EEF0}
-#define NS_IMENUPARENT_IID \
-{ 0xd407bf61, 0x3efa, 0x11d3, { 0x97, 0xfa, 0x0, 0x40, 0x5, 0x53, 0xee, 0xf0 } }
-
-class nsIMenuFrame;
-
-class nsIMenuParent : public nsISupports {
-
-public:
-  static const nsIID& GetIID() { static nsIID iid = NS_IMENUPARENT_IID; return iid; }
-
-  NS_IMETHOD SetCurrentMenuItem(nsIMenuFrame* aMenuItem) = 0;
-  NS_IMETHOD GetNextMenuItem(nsIMenuFrame* aStart, nsIMenuFrame** aResult) = 0;
-  NS_IMETHOD GetPreviousMenuItem(nsIMenuFrame* aStart, nsIMenuFrame** aResult) = 0;
-
-  NS_IMETHOD SetActive(PRBool aActiveFlag) = 0;
-  NS_IMETHOD GetIsActive(PRBool& isActive) = 0;
-  NS_IMETHOD GetWidget(nsIWidget **aWidget) = 0;
-  
-  NS_IMETHOD IsMenuBar(PRBool& isMenuBar) = 0;
-
-  NS_IMETHOD DismissChain() = 0;
-  NS_IMETHOD HideChain() = 0;
-
-  NS_IMETHOD CreateDismissalListener() = 0;
-};
-
-#endif
-

mozilla/layout/xul/base/public/nsIPopupSetFrame.h

@@ -1,47 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-#ifndef nsIPopupSetFrame_h___
-#define nsIPopupSetFrame_h___
-
-// {E2D804A1-50CA-11d3-BF87-00105A1B0627}
-#define NS_IPOPUPSETFRAME_IID \
-{ 0xe2d804a1, 0x50ca, 0x11d3, { 0xbf, 0x87, 0x0, 0x10, 0x5a, 0x1b, 0x6, 0x27 } }
-
-class nsIFrame;
-class nsIContent;
-
-#include "nsString.h"
-
-class nsIPopupSetFrame : public nsISupports {
-
-public:
-  static const nsIID& GetIID() { static nsIID iid = NS_IPOPUPSETFRAME_IID; return iid; }
-
-  NS_IMETHOD CreatePopup(nsIFrame* aElementFrame, nsIContent* aPopupContent, 
-                         PRInt32 aXPos, PRInt32 aYPos, 
-                         const nsString& aPopupType, const nsString& anAnchorAlignment,
-                         const nsString& aPopupAlignment) = 0;
-
-  NS_IMETHOD HidePopup() = 0;
-  NS_IMETHOD DestroyPopup() = 0;
-};
-
-#endif
-

mozilla/layout/xul/base/src/Makefile.in

@@ -1,85 +0,0 @@
-#
-# The contents of this file are subject to the Netscape Public License
-# Version 1.0 (the "NPL"); you may not use this file except in
-# compliance with the NPL.  You may obtain a copy of the NPL at
-# http://www.mozilla.org/NPL/
-#
-# Software distributed under the NPL is distributed on an "AS IS" basis,
-# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
-# for the specific language governing rights and limitations under the
-# NPL.
-#
-# The Initial Developer of this code under the NPL is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
-# Reserved.
-#
-
-DEPTH		= ../../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-MODULE		= layout
-LIBRARY_NAME	= raptorxulbase_s
-
-CPPSRCS		= \
-		nsFrameNavigator.cpp \
-		nsSplitterFrame.cpp \
-		nsGrippyFrame.cpp \
-		nsTabFrame.cpp \
-		nsDeckFrame.cpp \
-		nsBoxFrame.cpp \
-		nsProgressMeterFrame.cpp \
-		nsTitledButtonFrame.cpp \
-		nsToolbarFrame.cpp \
-		nsToolbarDragListener.cpp \
-		nsToolboxFrame.cpp \
-		nsTreeOuterFrame.cpp \
-		nsTreeFrame.cpp \
-		nsTreeRowGroupFrame.cpp \
-		nsTreeIndentationFrame.cpp \
-		nsTreeCellFrame.cpp \
-		nsTreeRowFrame.cpp \
-		nsTreeTwistyListener.cpp \
-		nsSpinnerFrame.cpp \
-		nsScrollbarFrame.cpp \
-		nsScrollbarButtonFrame.cpp \
-		nsSliderFrame.cpp \
-		nsColorPickerFrame.cpp \
-		nsStdColorPicker.cpp \
-		nsFontPickerFrame.cpp \
-		nsToolbarItemFrame.cpp \
-		nsMenuPopupFrame.cpp \
-		nsMenuFrame.cpp \
-		nsMenuBarFrame.cpp \
-		nsMenuBarListener.cpp \
-		nsMenuDismissalListener.cpp \
-		nsPopupSetFrame.cpp \
-		nsRepeatService.cpp \
-		$(NULL)
-
-include $(topsrcdir)/config/config.mk
-
-# we don't want the shared lib, but we want to force the creation of a static lib.
-override NO_SHARED_LIB=1
-override NO_STATIC_LIB=
-
-include $(topsrcdir)/config/rules.mk
-
-DEFINES		+= -D_IMPL_NS_HTML
-
-LOCAL_INCLUDES	= \
-		-I$(srcdir)/../../../base/src \
-		-I$(srcdir)/../../../html/table/src \
-		-I$(srcdir)/../../../html/style/src \
-		-I$(srcdir)/../../../html/base/src \
-		-I$(srcdir)/../../../html/forms/src \
-		-I$(srcdir)/../../content/src \
-		-I$(srcdir)/../../../html/content/src \
-		-I$(srcdir)/../../../xml/content/src \
-		-I$(srcdir)/../../../base/public \
-		$(NULL)
-

mozilla/layout/xul/base/src/makefile.win

@@ -1,123 +0,0 @@
-#!nmake
-#
-# The contents of this file are subject to the Netscape Public License
-# Version 1.0 (the "NPL"); you may not use this file except in
-# compliance with the NPL.  You may obtain a copy of the NPL at
-# http://www.mozilla.org/NPL/
-#
-# Software distributed under the NPL is distributed on an "AS IS" basis,
-# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
-# for the specific language governing rights and limitations under the
-# NPL.
-#
-# The Initial Developer of this code under the NPL is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
-# Reserved.
-
-DEPTH=..\..\..\.. 
-
-LIBRARY_NAME=raptorxulbase_s 
-MODULE=raptor 
-REQUIRES=xpcom raptor pref
-
-DEFINES=-D_IMPL_NS_HTML -DWIN32_LEAN_AND_MEAN
-
-CPPSRCS=					\
-        nsFrameNavigator.cpp        \
-        nsRepeatService.cpp        \
-        nsToolbarDragListener.cpp        \
-        nsToolbarItemFrame.cpp        \
-        nsSplitterFrame.cpp        \
-        nsGrippyFrame.cpp        \
-        nsTabFrame.cpp        \
-        nsDeckFrame.cpp        \
-        nsBoxFrame.cpp        \
-        nsProgressMeterFrame.cpp        \
-        nsTitledButtonFrame.cpp        \
-	nsToolboxFrame.cpp		\
-	nsToolbarFrame.cpp		\
-	nsTreeOuterFrame.cpp \
-	nsTreeFrame.cpp			\
-	nsTreeRowGroupFrame.cpp \
-	nsTreeRowFrame.cpp \
-	nsTreeIndentationFrame.cpp \
-	nsTreeCellFrame.cpp \
-	nsTreeTwistyListener.cpp \
-	nsSpinnerFrame.cpp \
-	nsScrollbarFrame.cpp \
-        nsScrollbarButtonFrame.cpp \
-	nsSliderFrame.cpp \
-	nsColorPickerFrame.cpp \
-	nsStdColorPicker.cpp \
-	nsFontPickerFrame.cpp \
-	nsMenuPopupFrame.cpp \
-	nsMenuFrame.cpp \
-	nsMenuBarFrame.cpp \
-	nsMenuBarListener.cpp \
-	nsMenuDismissalListener.cpp \
-	nsPopupSetFrame.cpp \
-	$(NULL)
-
-CPP_OBJS=					\
-        .\$(OBJDIR)\nsFrameNavigator.obj    \
-        .\$(OBJDIR)\nsRepeatService.obj    \
-        .\$(OBJDIR)\nsToolbarDragListener.obj    \
-        .\$(OBJDIR)\nsToolbarItemFrame.obj    \
-        .\$(OBJDIR)\nsGrippyFrame.obj    \
-        .\$(OBJDIR)\nsSplitterFrame.obj    \
-        .\$(OBJDIR)\nsTabFrame.obj    \
-        .\$(OBJDIR)\nsDeckFrame.obj    \
-        .\$(OBJDIR)\nsBoxFrame.obj    \
-        .\$(OBJDIR)\nsProgressMeterFrame.obj    \
-        .\$(OBJDIR)\nsTitledButtonFrame.obj    \
-	.\$(OBJDIR)\nsToolboxFrame.obj		\
-	.\$(OBJDIR)\nsToolbarFrame.obj		\
-	.\$(OBJDIR)\nsTreeOuterFrame.obj \
-	.\$(OBJDIR)\nsTreeFrame.obj	\
-	.\$(OBJDIR)\nsTreeRowFrame.obj \
-	.\$(OBJDIR)\nsTreeRowGroupFrame.obj \
-	.\$(OBJDIR)\nsTreeIndentationFrame.obj \
-	.\$(OBJDIR)\nsTreeCellFrame.obj \
-	.\$(OBJDIR)\nsTreeTwistyListener.obj \
-	.\$(OBJDIR)\nsSpinnerFrame.obj \
-	.\$(OBJDIR)\nsScrollbarFrame.obj \
-	.\$(OBJDIR)\nsScrollbarButtonFrame.obj \
-	.\$(OBJDIR)\nsSliderFrame.obj \
-	.\$(OBJDIR)\nsColorPickerFrame.obj \
-	.\$(OBJDIR)\nsStdColorPicker.obj \
-	.\$(OBJDIR)\nsFontPickerFrame.obj \
-	.\$(OBJDIR)\nsMenuPopupFrame.obj \
-	.\$(OBJDIR)\nsMenuFrame.obj \
-	.\$(OBJDIR)\nsMenuBarFrame.obj \
-	.\$(OBJDIR)\nsMenuBarListener.obj \
-	.\$(OBJDIR)\nsMenuDismissalListener.obj \
-	.\$(OBJDIR)\nsPopupSetFrame.obj \
-	$(NULL)
-
-EXPORTS =					\
-	$(NULL)
-
-LINCS=-I$(PUBLIC)\xpcom -I$(PUBLIC)\raptor -I$(PUBLIC)\js \
-  -I..\..\..\html\style\src -I..\..\..\html\base\src -I$(PUBLIC)\dom \
-   -I..\..\..\html\document\src \
-   -I..\..\..\html\content\src \
-   -I..\..\..\html\table\src \
-   -I..\..\content\src \
-   -I..\..\..\html\forms\src \
-  -I$(PUBLIC)\netlib -I..\..\..\base\src -I$(PUBLIC)\pref \
-  -I..\..\..\xml\content\src \
-  -I..\..\..\base\public
-
-LCFLAGS = \
-        $(LCFLAGS) \
-        $(DEFINES) \
-        $(NULL)
-
-include <$(DEPTH)\config\rules.mak>
-
-libs:: $(LIBRARY)
-	$(MAKE_INSTALL) $(LIBRARY) $(DIST)\lib
-
-clobber::
-	rm -f $(DIST)\lib\$(LIBRARY_NAME).lib

mozilla/layout/xul/base/src/nsBoxFrame.h

@@ -1,196 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-/**
-
-  Eric D Vaughan
-  nsBoxFrame is a frame that can lay its children out either vertically or horizontally.
-  It lays them out according to a min max or preferred size.
- 
-**/
-
-#ifndef nsBoxFrame_h___
-#define nsBoxFrame_h___
-
-#include "nsCOMPtr.h"
-#include "nsHTMLContainerFrame.h"
-#include "nsIBox.h"
-#include "nsISpaceManager.h"
-class nsBoxFrameInner;
-class nsBoxDebugInner;
-
-class nsHTMLReflowCommand;
-
-class nsCalculatedBoxInfo : public nsBoxInfo {
-public:
-    nsSize calculatedSize;
-    PRBool prefWidthIntrinsic;
-    PRBool prefHeightIntrinsic;
-    PRBool sizeValid;
-    PRBool needsReflow;
-    PRBool needsRecalc;
-    PRBool collapsed;
-    PRBool isIncremental;
-
-    nsCalculatedBoxInfo();
-    nsCalculatedBoxInfo(const nsBoxInfo& aInfo);
-    virtual void clear();
-
-};
-
-class nsBoxFrame : public nsHTMLContainerFrame, public nsIBox
-{
-public:
-
-  friend nsresult NS_NewBoxFrame(nsIFrame** aNewFrame, PRUint32 aFlags = 0);
-  // gets the rect inside our border and debug border. If you wish to paint inside a box
-  // call this method to get the rect so you don't draw on the debug border or outer border.
-  virtual void GetInnerRect(nsRect& aInner);
-
-  NS_IMETHOD GetFrameForPoint(nsIPresContext* aPresContext,
-                              const nsPoint& aPoint, 
-                             nsIFrame**     aFrame);
-
-  NS_IMETHOD GetCursor(nsIPresContext& aPresContext,
-                                     nsPoint&        aPoint,
-                                     PRInt32&        aCursor);
-
-
-
-  // nsIBox methods
-  NS_IMETHOD GetBoxInfo(nsIPresContext& aPresContext, const nsHTMLReflowState& aReflowState, nsBoxInfo& aSize);
-  NS_IMETHOD Dirty(nsIPresContext& aPresContext, const nsHTMLReflowState& aReflowState, nsIFrame*& aIncrementalChild);
-
-  NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr); 
-
-  NS_IMETHOD DidReflow(nsIPresContext& aPresContext,
-                      nsDidReflowStatus aStatus);
-
-
-  NS_IMETHOD  Init(nsIPresContext&  aPresContext,
-                   nsIContent*      aContent,
-                   nsIFrame*        aParent,
-                   nsIStyleContext* aContext,
-                   nsIFrame*        asPrevInFlow);
-
- 
-  NS_IMETHOD AttributeChanged(nsIPresContext* aPresContext,
-                              nsIContent* aChild,
-                              PRInt32 aNameSpaceID,
-                              nsIAtom* aAttribute,
-                              PRInt32 aHint);
-
-  NS_IMETHOD Paint ( nsIPresContext& aPresContext,
-                      nsIRenderingContext& aRenderingContext,
-                      const nsRect& aDirtyRect,
-                      nsFramePaintLayer aWhichLayer);
-
-  NS_IMETHOD Reflow(nsIPresContext&          aPresContext,
-                    nsHTMLReflowMetrics&     aDesiredSize,
-                    const nsHTMLReflowState& aReflowState,
-                    nsReflowStatus&          aStatus);
-
-  NS_IMETHOD  AppendFrames(nsIPresContext& aPresContext,
-                           nsIPresShell&   aPresShell,
-                           nsIAtom*        aListName,
-                           nsIFrame*       aFrameList);
-
-  NS_IMETHOD  InsertFrames(nsIPresContext& aPresContext,
-                           nsIPresShell&   aPresShell,
-                           nsIAtom*        aListName,
-                           nsIFrame*       aPrevFrame,
-                           nsIFrame*       aFrameList);
-
-  NS_IMETHOD  RemoveFrame(nsIPresContext& aPresContext,
-                          nsIPresShell&   aPresShell,
-                          nsIAtom*        aListName,
-                          nsIFrame*       aOldFrame);
-
-  NS_IMETHOD GetFrameName(nsString& aResult) const;
-
-  virtual PRBool IsHorizontal() const { return mHorizontal; }
-
-  
-  NS_IMETHOD_(nsrefcnt) AddRef(void);
-  NS_IMETHOD_(nsrefcnt) Release(void);
-
-  virtual ~nsBoxFrame();
-
-  virtual void GetChildBoxInfo(PRInt32 aIndex, nsBoxInfo& aSize);
-  virtual void SetChildNeedsRecalc(PRInt32 aIndex, PRBool aRecalc);
-
-  // Paint one child frame
-  virtual void PaintChild(nsIPresContext&      aPresContext,
-                             nsIRenderingContext& aRenderingContext,
-                             const nsRect&        aDirtyRect,
-                             nsIFrame*            aFrame,
-                             nsFramePaintLayer    aWhichLayer);
-
-
-protected:
-    nsBoxFrame(PRUint32 aFlags = 0);
-
-    virtual void GetRedefinedMinPrefMax(nsIPresContext& aPresContext, nsIFrame* aFrame, nsCalculatedBoxInfo& aSize);
-    virtual nsresult GetChildBoxInfo(nsIPresContext& aPresContext, const nsHTMLReflowState& aReflowState, nsIFrame* aFrame, nsCalculatedBoxInfo& aSize);
-    virtual nsresult FlowChildren(nsIPresContext&   aPresContext,
-                     nsHTMLReflowMetrics&     aDesiredSize,
-                     const nsHTMLReflowState& aReflowState,
-                     nsReflowStatus&          aStatus,
-                     nsRect& availableSize); 
-
-    virtual nsresult FlowChildAt(nsIFrame* frame, 
-                     nsIPresContext& aPresContext,
-                     nsHTMLReflowMetrics&     aDesiredSize,
-                     const nsHTMLReflowState& aReflowState,
-                     nsReflowStatus&          aStatus,
-                     nsCalculatedBoxInfo&     aInfo,
-                     PRBool& needsRedraw,
-                     nsString& aReason);
-
-    virtual nsresult PlaceChildren(nsIPresContext& aPresContext, nsRect& boxRect);
-    virtual void ChildResized(nsIFrame* aFrame, nsHTMLReflowMetrics& aDesiredSize, nsRect& aRect, nsCalculatedBoxInfo& aInfo, PRBool* aResized, nscoord& aChangedIndex, PRBool& aFinished, nscoord aIndex, nsString& aReason);
-    virtual void LayoutChildrenInRect(nsRect& size);
-    virtual void AddChildSize(nsBoxInfo& aInfo, nsBoxInfo& aChildInfo);
-    virtual void BoundsCheck(const nsBoxInfo& aBoxInfo, nsRect& aRect);
-    virtual void InvalidateChildren();
-    virtual void AddSize(const nsSize& a, nsSize& b, PRBool largest);
-
-    virtual PRIntn GetSkipSides() const { return 0; }
-
-    virtual void GetInset(nsMargin& margin); 
-    virtual void CollapseChild(nsIPresContext& aPresContext, nsIFrame* frame, PRBool hide);
-
-    nsresult GenerateDirtyReflowCommand(nsIPresContext& aPresContext,
-                                        nsIPresShell&   aPresShell);
-
-    PRBool mHorizontal;
-    nsCalculatedBoxInfo mSprings[100];
-    nscoord mSpringCount;
-
-private: 
-  
-    friend class nsBoxFrameInner;
-    friend class nsBoxDebugInner;
-    nsBoxFrameInner* mInner;
-}; // class nsBoxFrame
-
-
-
-#endif
-

mozilla/layout/xul/base/src/nsColorPickerCID.h

@@ -1,27 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Mozilla browser.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation. Portions created by Netscape are
- * Copyright (C) 1999 Netscape Communications Corporation. All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *   Stuart Parmenter <pavlov@netscape.com>
- */
-
-// 1936f892-1dd2-11b2-aba4-bd254241f938
-#define NS_DEFCOLORPICKER_CID \
-{ 0x1936f892, 0x1dd2, 0x11b2, \
-    {0xab, 0xa4, 0xbd, 0x25, 0x42, 0x41, 0xf9, 0x38} }

mozilla/layout/xul/base/src/nsColorPickerFrame.cpp

@@ -1,230 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-
-#include "nsColorPickerFrame.h"
-
-#include "nsIDOMElement.h"
-#include "nsIContent.h"
-#include "prtypes.h"
-#include "nsIAtom.h"
-#include "nsHTMLAtoms.h"
-#include "nsIPresContext.h"
-#include "nsIStyleContext.h"
-#include "nsCSSRendering.h"
-#include "nsINameSpaceManager.h"
-#include "nsColor.h"
-#include "nsIServiceManager.h"
-#include "nsStdColorPicker.h"
-#include "nsColorPickerCID.h"
-//
-// NS_NewColorPickerFrame
-//
-// Wrapper for creating a new color picker
-//
-nsresult
-NS_NewColorPickerFrame(nsIFrame** aNewFrame)
-{
-  NS_PRECONDITION(aNewFrame, "null OUT ptr");
-  if (nsnull == aNewFrame) {
-    return NS_ERROR_NULL_POINTER;
-  }
-  nsColorPickerFrame* it = new nsColorPickerFrame;
-  if ( !it )
-    return NS_ERROR_OUT_OF_MEMORY;
-  *aNewFrame = it;
-  return NS_OK;
-}
-
-// static NS_DEFINE_IID(kDefColorPickerCID, NS_DEFCOLORPICKER_CID);
-
-//
-// nsColorPickerFrame cntr
-//
-nsColorPickerFrame::nsColorPickerFrame()
-{
-
-}
-
-nsColorPickerFrame::~nsColorPickerFrame()
-{
-  delete mColorPicker;
-}
-
-
-NS_IMETHODIMP
-nsColorPickerFrame::Init(nsIPresContext&  aPresContext,
-                         nsIContent*      aContent,
-                         nsIFrame*        aParent,
-                         nsIStyleContext* aContext,
-                         nsIFrame*        aPrevInFlow)
-{
- 
-  nsresult rv = nsLeafFrame::Init(aPresContext, aContent, aParent, aContext,
-                                  aPrevInFlow);
-
-
-  nsAutoString type;
-  mContent->GetAttribute(kNameSpaceID_None, nsHTMLAtoms::type, type);
-
-  if (type.EqualsIgnoreCase("swatch") || type.Equals(""))
-  {
-    mColorPicker = new nsStdColorPicker();
-    mColorPicker->Init(mContent);
-  }
-
-  return rv;
-}
-
-
-
-NS_IMETHODIMP
-nsColorPickerFrame::HandleEvent(nsIPresContext& aPresContext, 
-                                nsGUIEvent*     aEvent,
-                                nsEventStatus&  aEventStatus)
-{
-  aEventStatus = nsEventStatus_eConsumeDoDefault;
-	if (aEvent->message == NS_MOUSE_LEFT_BUTTON_DOWN)
-		HandleMouseDownEvent(aPresContext, aEvent, aEventStatus);
-
-  return NS_OK;
-}
-
-nsresult
-nsColorPickerFrame::HandleMouseDownEvent(nsIPresContext& aPresContext, 
-                                         nsGUIEvent*     aEvent,
-                                         nsEventStatus&  aEventStatus)
-{
-  int x,y;
-  char *color;
-  // figure out what color we just picked
-#ifdef DEBUG_pavlov
-  printf("got mouse down.. x = %i, y = %i\n", aEvent->refPoint.x, aEvent->refPoint.y);
-#endif
-  x = aEvent->refPoint.x;
-  y = aEvent->refPoint.y;
-
-  nsCOMPtr<nsIDOMElement> node( do_QueryInterface(mContent) );
-
-  nsresult rv = mColorPicker->GetColor(x, y, &color);
-
-  if (NS_FAILED(rv))
-    node->RemoveAttribute("color");
-  else
-    node->SetAttribute("color", color);
-
-  return NS_OK;
-}
-
-//
-// Paint
-//
-//
-NS_METHOD 
-nsColorPickerFrame::Paint(nsIPresContext& aPresContext,
-                          nsIRenderingContext& aRenderingContext,
-                          const nsRect& aDirtyRect,
-                          nsFramePaintLayer aWhichLayer)
-{
-  float p2t;
-
-  aPresContext.GetScaledPixelsToTwips(&p2t);
-
-  const nsStyleDisplay* disp = (const nsStyleDisplay*)
-  mStyleContext->GetStyleData(eStyleStruct_Display);
-
-  // if we aren't visible then we are done.
-  if (!disp->mVisible) 
-	   return NS_OK;  
-
-  // if we are visible then tell our superclass to paint
-  nsLeafFrame::Paint(aPresContext, aRenderingContext, aDirtyRect,
-                     aWhichLayer);
-
-  // get our border
-	const nsStyleSpacing* spacing = (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing);
-	nsMargin border(0,0,0,0);
-	spacing->CalcBorderFor(this, border);
-
-  /*
-    const nsStyleColor* colorStyle = (const nsStyleColor*)mStyleContext->GetStyleData(eStyleStruct_Color);
-    nscolor color = colorStyle->mColor;
-  */
-
-  aRenderingContext.PushState();
-
-  // set the clip region
-  PRInt32 width, height;
-  mColorPicker->GetSize(&width, &height);
-  nsRect rect(0, 0, PRInt32(width*p2t), PRInt32(height*p2t));
-
-  PRBool clipState;
-
-  // Clip so we don't render outside the inner rect
-  aRenderingContext.SetClipRect(rect, nsClipCombine_kIntersect, clipState);
-
-  // call the color picker's paint method
-  mColorPicker->Paint(&aPresContext, &aRenderingContext);
-
-  aRenderingContext.PopState(clipState);
-
-  return NS_OK;
-}
-
-
-//
-// GetDesiredSize
-//
-// For now, be as big as CSS wants us to be, or some small default size.
-//
-void
-nsColorPickerFrame::GetDesiredSize(nsIPresContext* aPresContext,
-                                   const nsHTMLReflowState& aReflowState,
-                                   nsHTMLReflowMetrics& aDesiredSize)
-{
-  float p2t;
-
-  aPresContext->GetScaledPixelsToTwips(&p2t);
-
-
-   // if the width is set use it
-	if (NS_INTRINSICSIZE != aReflowState.mComputedWidth) 
-	  aDesiredSize.width = aReflowState.mComputedWidth;
-  else
-    aDesiredSize.width = -1;
-
-	// if the height is set use it
- 	if (NS_INTRINSICSIZE != aReflowState.mComputedHeight) 
-		aDesiredSize.height = aReflowState.mComputedHeight;
-  else
-    aDesiredSize.height = -1;
-
-  mColorPicker->SetSize((aDesiredSize.width == -1) ? -1 : PRInt32(aDesiredSize.width/p2t),
-                        (aDesiredSize.height == -1) ? -1 : PRInt32(aDesiredSize.height/p2t));
-
-
-  int width, height;
-  
-  mColorPicker->GetSize(&width, &height);
-  
-  aDesiredSize.width = nscoord(width * p2t);
-  aDesiredSize.height = nscoord(height * p2t);
-  aDesiredSize.ascent = nscoord(height * p2t);
-  aDesiredSize.descent = 0;
-
-} // GetDesiredSize

mozilla/layout/xul/base/src/nsColorPickerFrame.h

@@ -1,81 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-//
-// nsColorPickerFrame
-//
-
-#ifndef nsColorPickerFrame_h__
-#define nsColorPickerFrame_h__
-
-
-#include "nsLeafFrame.h"
-#include "prtypes.h"
-#include "nsIAtom.h"
-#include "nsCOMPtr.h"
-#include "nsIColorPicker.h"
-
-class nsString;
-
-
-nsresult NS_NewColorPickerFrame(nsIFrame** aResult) ;
-
-
-class nsColorPickerFrame : public nsLeafFrame
-{
-public:
-  nsColorPickerFrame();
-  virtual ~nsColorPickerFrame();
-
-  NS_IMETHOD Init(nsIPresContext&  aPresContext,
-                  nsIContent*      aContent,
-                  nsIFrame*        aParent,
-                  nsIStyleContext* aContext,
-                  nsIFrame*        aPrevInFlow);
-
-#ifdef DEBUG
-  NS_IMETHOD GetFrameName(nsString& aResult) const {
-    return MakeFrameName("ColorPickerFrame", aResult);
-  }
-#endif
-
-  // nsIFrame overrides
-  NS_IMETHOD HandleEvent(nsIPresContext& aPresContext, 
-                         nsGUIEvent*     aEvent,
-                         nsEventStatus&  aEventStatus);
-  nsresult HandleMouseDownEvent(nsIPresContext& aPresContext,
-                                nsGUIEvent*     aEvent,
-                                nsEventStatus&  aEventStatus);
-
-  NS_IMETHOD Paint(nsIPresContext& aPresContext,
-                   nsIRenderingContext& aRenderingContext,
-                   const nsRect& aDirtyRect,
-                   nsFramePaintLayer aWhichLayer);
-  
-protected:
-  virtual void GetDesiredSize(nsIPresContext* aPresContext,
-                              const nsHTMLReflowState& aReflowState,
-                              nsHTMLReflowMetrics& aDesiredSize) ;
-
-
-private:
-  nsIColorPicker *mColorPicker;
-
-}; // class nsColorPickerFrame
-
-#endif

mozilla/layout/xul/base/src/nsDeckFrame.cpp

@@ -1,363 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-//
-// Eric Vaughan
-// Netscape Communications
-//
-// See documentation in associated header file
-//
-
-#include "nsDeckFrame.h"
-#include "nsIStyleContext.h"
-#include "nsIPresContext.h"
-#include "nsIContent.h"
-#include "nsCOMPtr.h"
-#include "nsHTMLIIDs.h"
-#include "nsUnitConversion.h"
-#include "nsINameSpaceManager.h"
-#include "nsXULAtoms.h"
-#include "nsHTMLAtoms.h"
-#include "nsIReflowCommand.h"
-#include "nsHTMLParts.h"
-#include "nsIPresShell.h"
-#include "nsStyleChangeList.h"
-#include "nsCSSRendering.h"
-#include "nsIViewManager.h"
-
-
-nsresult
-NS_NewDeckFrame ( nsIFrame** aNewFrame )
-{
-  NS_PRECONDITION(aNewFrame, "null OUT ptr");
-  if (nsnull == aNewFrame) {
-    return NS_ERROR_NULL_POINTER;
-  }
-  nsDeckFrame* it = new nsDeckFrame;
-  if (nsnull == it)
-    return NS_ERROR_OUT_OF_MEMORY;
-
-  *aNewFrame = it;
-  return NS_OK;
-  
-} // NS_NewDeckFrame
-
-NS_IMETHODIMP
-nsDeckFrame::Init(nsIPresContext&  aPresContext,
-              nsIContent*      aContent,
-              nsIFrame*        aParent,
-              nsIStyleContext* aContext,
-              nsIFrame*        aPrevInFlow)
-{
-   // Get the element's tag
-  nsresult  rv = nsBoxFrame::Init(aPresContext, aContent, aParent, aContext, aPrevInFlow);
-  //CreateViewForFrame(aPresContext,this,aContext,PR_TRUE);
-  return rv;
-}
-
-
-NS_IMETHODIMP
-nsDeckFrame::AttributeChanged(nsIPresContext* aPresContext,
-                               nsIContent* aChild,
-                               PRInt32 aNameSpaceID,
-                               nsIAtom* aAttribute,
-                               PRInt32 aHint)
-{
-  nsresult rv = nsBoxFrame::AttributeChanged(aPresContext, aChild,
-                                              aNameSpaceID, aAttribute, aHint);
-
-
-   // if the index changed hide the old element and make the now element visible
-  if (aAttribute == nsHTMLAtoms::index) {
-      /*
-            nsCOMPtr<nsIPresShell> shell;
-            aPresContext->GetShell(getter_AddRefs(shell));
-
-            nsCOMPtr<nsIReflowCommand> reflowCmd;
-            rv = NS_NewHTMLReflowCommand(getter_AddRefs(reflowCmd), this,
-                                         nsIReflowCommand::StyleChanged);
-            if (NS_SUCCEEDED(rv)) 
-              shell->AppendReflowCommand(reflowCmd);
-     */
-
-    Invalidate(aPresContext, nsRect(0,0,mRect.width,mRect.height), PR_FALSE);
-
-     int index = 0;
-
-      // get the index attribute
-      nsAutoString value;
-      if (NS_CONTENT_ATTR_HAS_VALUE == mContent->GetAttribute(kNameSpaceID_None, nsHTMLAtoms::index, value))
-      {
-        PRInt32 error;
-
-        // convert it to an integer
-        index = value.ToInteger(&error);
-      }
-
-      nsIFrame* childFrame = mFrames.FirstChild(); 
-      nscoord count = 0;
-      while (nsnull != childFrame) 
-      {
-        // make collapsed children not show up
-        if (index != count) 
-           CollapseChild(*aPresContext, childFrame, PR_TRUE);
-        else
-           CollapseChild(*aPresContext, childFrame, PR_FALSE);
-
-        rv = childFrame->GetNextSibling(&childFrame);
-        NS_ASSERTION(rv == NS_OK,"failed to get next child");
-        count++;
-      }
-
-  }
-
-
-  
-
-  if (NS_OK != rv) {
-    return rv;
-  }
-
-  return NS_OK;
-}
-
-nsIFrame* 
-nsDeckFrame::GetSelectedFrame()
-{
- // ok we want to paint only the child that as at the given index
-
-  // default index is 0
-  int index = 0;
-
-  // get the index attribute
-  nsAutoString value;
-  if (NS_CONTENT_ATTR_HAS_VALUE == mContent->GetAttribute(kNameSpaceID_None, nsXULAtoms::index, value))
-  {
-    PRInt32 error;
-
-    // convert it to an integer
-    index = value.ToInteger(&error);
-  }
-
-  // get the child at that index. 
-  nsIFrame* childFrame = mFrames.FrameAt(index); 
-  return childFrame;
-}
-
-
-NS_IMETHODIMP
-nsDeckFrame::Paint(nsIPresContext& aPresContext,
-                                nsIRenderingContext& aRenderingContext,
-                                const nsRect& aDirtyRect,
-                                nsFramePaintLayer aWhichLayer)
-{
-  // if a tab is hidden all its children are too.
- 	const nsStyleDisplay* disp = (const nsStyleDisplay*)
-	mStyleContext->GetStyleData(eStyleStruct_Display);
-	if (!disp->mVisible)
-		return NS_OK;
-
-  if (NS_FRAME_PAINT_LAYER_BACKGROUND == aWhichLayer) {
-    if (disp->mVisible && mRect.width && mRect.height) {
-      // Paint our background and border
-      PRIntn skipSides = GetSkipSides();
-      const nsStyleColor* color = (const nsStyleColor*)
-        mStyleContext->GetStyleData(eStyleStruct_Color);
-      const nsStyleSpacing* spacing = (const nsStyleSpacing*)
-        mStyleContext->GetStyleData(eStyleStruct_Spacing);
-
-      nsRect  rect(0, 0, mRect.width, mRect.height);
-      nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this,
-                                      aDirtyRect, rect, *color, *spacing, 0, 0);
-      nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this,
-                                  aDirtyRect, rect, *spacing, mStyleContext, skipSides);
-    }
-  }
-
-  nsIFrame* frame = GetSelectedFrame();
-
-  if (frame != nsnull)
-    PaintChild(aPresContext, aRenderingContext, aDirtyRect, frame, aWhichLayer);
-
-  return NS_OK;
-
-}
-
-
-NS_IMETHODIMP  nsDeckFrame::GetFrameForPoint(nsIPresContext* aPresContext,
-                                             const nsPoint& aPoint, 
-                                             nsIFrame**     aFrame)
-{
-  // if its not in our child just return us.
-  *aFrame = this;
-
-  // get the selected frame and see if the point is in it.
-  nsIFrame* selectedFrame = GetSelectedFrame();
-
-  if (nsnull != selectedFrame)
-  {
-    nsRect childRect;
-    selectedFrame->GetRect(childRect);
-
-    if (childRect.Contains(aPoint)) {
-      // adjust the point
-      nsPoint p = aPoint;
-      p.x -= childRect.x;
-      p.y -= childRect.y;
-      return selectedFrame->GetFrameForPoint(aPresContext, p, aFrame);
-    }
-  }
-    
-  return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsDeckFrame::SetInitialChildList(nsIPresContext& aPresContext,
-                                              nsIAtom*        aListName,
-                                              nsIFrame*       aChildList)
-{
-  nsresult r = nsBoxFrame::SetInitialChildList(aPresContext, aListName, aChildList);
-  return r;
-}
-
-
-
-void
-nsDeckFrame::AddChildSize(nsBoxInfo& aInfo, nsBoxInfo& aChildInfo)
-{
-     // largest preferred size
-    if (aChildInfo.prefSize.width > aInfo.prefSize.width)
-      aInfo.prefSize.width = aChildInfo.prefSize.width;
-
-    if (aChildInfo.prefSize.height > aInfo.prefSize.height)
-      aInfo.prefSize.height = aChildInfo.prefSize.height;
-
-    // largest min size
-    if (aChildInfo.minSize.width > aInfo.minSize.width)
-      aInfo.minSize.width = aChildInfo.minSize.width;
-
-    if (aChildInfo.minSize.height > aInfo.minSize.height)
-      aInfo.minSize.height = aChildInfo.minSize.height;
-
-    // smallest max size
-    if (aChildInfo.maxSize.width < aInfo.maxSize.width)
-      aInfo.maxSize.width = aChildInfo.maxSize.width;
-
-    if (aChildInfo.maxSize.height < aInfo.maxSize.height)
-      aInfo.maxSize.height = aChildInfo.maxSize.height;
-}
-
-nsresult
-nsDeckFrame::PlaceChildren(nsIPresContext& aPresContext, nsRect& boxRect)
-{
-  // ------- set the childs positions ---------
-  nsIFrame* childFrame = mFrames.FirstChild(); 
-  nscoord count = 0;
-  while (nsnull != childFrame) 
-  {
-    nsresult rv;
-    // make collapsed children not show up
-    if (mSprings[count].collapsed) {
-       //nsRect rect(0,0,0,0);
-       //childFrame->GetRect(rect);
-       //if (rect.width > 0 || rect.height > 0) {
-       //   childFrame->SizeTo(0,0);
-          CollapseChild(aPresContext, childFrame, PR_TRUE);
-       //}
-    } else {
-      childFrame->MoveTo(&aPresContext, boxRect.x, boxRect.y);
-    }
-
-    rv = childFrame->GetNextSibling(&childFrame);
-    NS_ASSERTION(rv == NS_OK,"failed to get next child");
-    count++;
-  }
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsDeckFrame::DidReflow(nsIPresContext& aPresContext,
-                      nsDidReflowStatus aStatus)
-{
-  int index = 0;
-
-  // get the index attribute
-  nsAutoString value;
-  if (NS_CONTENT_ATTR_HAS_VALUE == mContent->GetAttribute(kNameSpaceID_None, nsHTMLAtoms::index, value))
-  {
-    PRInt32 error;
-
-    // convert it to an integer
-    index = value.ToInteger(&error);
-  }
-
-  nsresult rv = nsBoxFrame::DidReflow(aPresContext, aStatus);
-  NS_ASSERTION(rv == NS_OK,"DidReflow failed");
-
-  nsIFrame* childFrame = mFrames.FirstChild(); 
-  nscoord count = 0;
-  while (nsnull != childFrame) 
-  {
-    // make collapsed children not show up
-    if (index != count) 
-       CollapseChild(aPresContext, childFrame, PR_TRUE);
-    else
-       CollapseChild(aPresContext, childFrame, PR_FALSE);
-
-    rv = childFrame->GetNextSibling(&childFrame);
-    NS_ASSERTION(rv == NS_OK,"failed to get next child");
-    count++;
-  }
-
-  return rv;
-}
-
-
-void
-nsDeckFrame::ChildResized(nsIFrame* aFrame, nsHTMLReflowMetrics& aDesiredSize, nsRect& aRect, nsCalculatedBoxInfo& aInfo, PRBool* aResized, nscoord& aChangedIndex, PRBool& aFinished, nscoord aIndex, nsString& aReason)
-{
-  if (aDesiredSize.width > aRect.width) {
-    aRect.width = aDesiredSize.width;
-    InvalidateChildren();
-    LayoutChildrenInRect(aRect);
-    aReason = "child's width got bigger";
-    aChangedIndex = aIndex;
-    aFinished = PR_FALSE;
-  } else if (aDesiredSize.height > aRect.height) {
-    aRect.height = aDesiredSize.height;
-    InvalidateChildren();
-    LayoutChildrenInRect(aRect);
-    aReason = "child's height got bigger";
-    aChangedIndex = aIndex;
-    aFinished = PR_FALSE;    
-  }
-}
-
-void
-nsDeckFrame::LayoutChildrenInRect(nsRect& size)
-{
-  for (int i=0; i<mSpringCount; i++) {
-      mSprings[i].calculatedSize.width = size.width;
-      mSprings[i].calculatedSize.height = size.height;
-      mSprings[i].sizeValid = PR_TRUE;
-  }
-}
-

mozilla/layout/xul/base/src/nsDeckFrame.h

@@ -1,93 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-/**
-
-  Eric D Vaughan
-  A frame that can have multiple children. Only one child may be displayed at one time. So the
-  can be flipped though like a deck of cards.
- 
-**/
-
-#ifndef nsDeckFrame_h___
-#define nsDeckFrame_h___
-
-#include "nsBoxFrame.h"
-
-class nsDeckFrame : public nsBoxFrame
-{
-public:
-
-  friend nsresult NS_NewDeckFrame(nsIFrame** aNewFrame);
-
- 
-
-  NS_IMETHOD  Init(nsIPresContext&  aPresContext,
-                   nsIContent*      aContent,
-                   nsIFrame*        aParent,
-                   nsIStyleContext* aContext,
-                   nsIFrame*        asPrevInFlow);
-
-
-  NS_IMETHOD AttributeChanged(nsIPresContext* aPresContext,
-                              nsIContent* aChild,
-                              PRInt32 aNameSpaceID,
-                              nsIAtom* aAttribute,
-                              PRInt32 aHint);
-
-  NS_IMETHOD DidReflow(nsIPresContext& aPresContext,
-                      nsDidReflowStatus aStatus);
-
-  NS_IMETHOD Paint(nsIPresContext& aPresContext,
-                    nsIRenderingContext& aRenderingContext,
-                    const nsRect& aDirtyRect,
-                    nsFramePaintLayer aWhichLayer);
-
- 
-  NS_IMETHOD SetInitialChildList(nsIPresContext& aPresContext,
-                                              nsIAtom*        aListName,
-                                              nsIFrame*       aChildList);
-
-
-  NS_IMETHOD  GetFrameForPoint(nsIPresContext* aPresContext,
-                               const nsPoint& aPoint, 
-                               nsIFrame**     aFrame);
-
-  virtual PRIntn GetSkipSides() const { return 0; }  
-
-protected:
-
-  virtual nsIFrame* GetSelectedFrame();
-    virtual nsresult PlaceChildren(nsIPresContext& aPresContext, nsRect& boxRect);
-    virtual void ChildResized(nsIFrame* aFrame, nsHTMLReflowMetrics& aDesiredSize, nsRect& aRect, nsCalculatedBoxInfo& aInfo, PRBool* aResized, nscoord& aChangedIndex, PRBool& aFinished, nscoord aIndex, nsString& aReason);
-    virtual void LayoutChildrenInRect(nsRect& size);
-    virtual void AddChildSize(nsBoxInfo& aInfo, nsBoxInfo& aChildInfo);
-
-
-
-private:
-
-  nsIFrame* mSelected;
-
-}; // class nsDeckFrame
-
-
-
-#endif
-

mozilla/layout/xul/base/src/nsFontPickerFrame.cpp

@@ -1,111 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-
-#include "nsFontPickerFrame.h"
-
-#include "nsIContent.h"
-#include "prtypes.h"
-#include "nsIAtom.h"
-#include "nsIPresContext.h"
-#include "nsIStyleContext.h"
-#include "nsCSSRendering.h"
-#include "nsINameSpaceManager.h"
-
-
-//
-// NS_NewFontPickerFrame
-//
-// Wrapper for creating a new font picker
-//
-nsresult
-NS_NewFontPickerFrame(nsIFrame** aNewFrame)
-{
-  NS_PRECONDITION(aNewFrame, "null OUT ptr");
-  if (nsnull == aNewFrame) {
-    return NS_ERROR_NULL_POINTER;
-  }
-  nsFontPickerFrame* it = new nsFontPickerFrame;
-  if ( !it )
-    return NS_ERROR_OUT_OF_MEMORY;
-  *aNewFrame = it;
-  return NS_OK;
-}
-
-
-//
-// nsFontPickerFrame cntr
-//
-nsFontPickerFrame::nsFontPickerFrame()
-{
-
-} // cntr
-
-
-//
-// Paint
-//
-// Overidden to handle ???
-//
-NS_METHOD 
-nsFontPickerFrame::Paint(nsIPresContext& aPresContext,
-                              nsIRenderingContext& aRenderingContext,
-                              const nsRect& aDirtyRect,
-                              nsFramePaintLayer aWhichLayer)
-{
-  return nsLeafFrame::Paint(aPresContext, aRenderingContext, aDirtyRect, aWhichLayer);
-}
-
-
-//
-// GetDesiredSize
-//
-// For now, be as big as CSS wants us to be, or some small default size.
-//
-void
-nsFontPickerFrame :: GetDesiredSize(nsIPresContext* aPresContext,
-                                           const nsHTMLReflowState& aReflowState,
-                                           nsHTMLReflowMetrics& aDesiredLayoutSize)
-{
-  const int CSS_NOTSET = -1;
-
-  nsSize styleSize;
-  if (NS_UNCONSTRAINEDSIZE != aReflowState.mComputedWidth) {
-    styleSize.width = aReflowState.mComputedWidth;
-  }
-  else {
-    styleSize.width = CSS_NOTSET;
-  }
-  if (NS_UNCONSTRAINEDSIZE != aReflowState.mComputedHeight) {
-    styleSize.height = aReflowState.mComputedHeight;
-  }
-  else {
-    styleSize.height = CSS_NOTSET;
-  }
-
-  // subclasses should always override this method, but if not and no css, make it small
-  aDesiredLayoutSize.width  = (styleSize.width  > CSS_NOTSET) ? styleSize.width  : 200;
-  aDesiredLayoutSize.height = (styleSize.height > CSS_NOTSET) ? styleSize.height : 200;
-  aDesiredLayoutSize.ascent = aDesiredLayoutSize.height;
-  aDesiredLayoutSize.descent = 0;
-  if (aDesiredLayoutSize.maxElementSize) {
-    aDesiredLayoutSize.maxElementSize->width  = aDesiredLayoutSize.width;
-    aDesiredLayoutSize.maxElementSize->height = aDesiredLayoutSize.height;
-  }
-
-} // GetDesiredSize

mozilla/layout/xul/base/src/nsFontPickerFrame.h

@@ -1,63 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-//
-// nsFontPickerFrame
-//
-
-#ifndef nsFontPickerFrame_h__
-#define nsFontPickerFrame_h__
-
-
-#include "nsLeafFrame.h"
-#include "prtypes.h"
-#include "nsIAtom.h"
-#include "nsCOMPtr.h"
-
-class nsString;
-
-
-nsresult NS_NewFontPickerFrame(nsIFrame** aResult) ;
-
-
-class nsFontPickerFrame : public nsLeafFrame
-{
-public:
-  nsFontPickerFrame();
-
-#ifdef DEBUG
-  NS_IMETHOD GetFrameName(nsString& aResult) const {
-    return MakeFrameName("FontPickerFrame", aResult);
-  }
-#endif
-
-  // nsIFrame overrides
-  NS_IMETHOD Paint(nsIPresContext& aPresContext,
-                   nsIRenderingContext& aRenderingContext,
-                   const nsRect& aDirtyRect,
-                   nsFramePaintLayer aWhichLayer);
-  
-protected:
-
-  virtual void GetDesiredSize(nsIPresContext* aPresContext,
-                              const nsHTMLReflowState& aReflowState,
-                              nsHTMLReflowMetrics& aDesiredSize) ;
-
-}; // class nsFontPickerFrame
-
-#endif

mozilla/layout/xul/base/src/nsFrameNavigator.cpp

@@ -1,127 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-//
-// Eric Vaughan
-// Netscape Communications
-//
-// See documentation in associated header file
-//
-
-#include "nsFrameNavigator.h"
-#include "nsCOMPtr.h"
-#include "nsIContent.h"
-
-nsIAtom*
-nsFrameNavigator::GetTag(nsIFrame* frame)
-{
-   nsCOMPtr<nsIContent> content;
-   frame->GetContent(getter_AddRefs(content));
-   if (content) {
-     nsIAtom* atom = nsnull;
-     content->GetTag(atom);
-     return atom; 
-   }
-
-   return nsnull;
-}
-
-nsIFrame*
-nsFrameNavigator::GetChildBeforeAfter(nsIFrame* start, PRBool before)
-{
-   nsIFrame* parent = nsnull;
-   start->GetParent(&parent);
-   PRInt32 index = IndexOf(parent,start);
-   PRInt32 count = CountFrames(parent);
-
-   if (index == -1) 
-     return nsnull;
-
-   if (before) {
-     if (index == 0) {
-         return nsnull;
-     }
-
-     return GetChildAt(parent, index-1);
-   }
-
-
-   if (index == count-1)
-       return nsnull;
-
-   return GetChildAt(parent, index+1);
-}
-
-PRInt32
-nsFrameNavigator::IndexOf(nsIFrame* parent, nsIFrame* child)
-{
-  PRInt32 count = 0;
-
-  nsIFrame* childFrame;
-  parent->FirstChild(nsnull, &childFrame); 
-  while (nsnull != childFrame) 
-  {    
-    if (childFrame == child)
-       return count;
-
-    nsresult rv = childFrame->GetNextSibling(&childFrame);
-    NS_ASSERTION(rv == NS_OK,"failed to get next child");
-    count++;
-  }
-
-  return -1;
-}
-
-PRInt32
-nsFrameNavigator::CountFrames(nsIFrame* aFrame)
-{
-  PRInt32 count = 0;
-
-  nsIFrame* childFrame;
-  aFrame->FirstChild(nsnull, &childFrame); 
-  while (nsnull != childFrame) 
-  {    
-    nsresult rv = childFrame->GetNextSibling(&childFrame);
-    NS_ASSERTION(rv == NS_OK,"failed to get next child");
-    count++;
-  }
-
-  return count;
-}
-
-nsIFrame*
-nsFrameNavigator::GetChildAt(nsIFrame* parent, PRInt32 index)
-{
-  PRInt32 count = 0;
-
-  nsIFrame* childFrame;
-  parent->FirstChild(nsnull, &childFrame); 
-  while (nsnull != childFrame) 
-  {    
-    if (count == index)
-       return childFrame;
-
-    nsresult rv = childFrame->GetNextSibling(&childFrame);
-    NS_ASSERTION(rv == NS_OK,"failed to get next child");
-    count++;
-  }
-
-  return nsnull;
-}
-

mozilla/layout/xul/base/src/nsFrameNavigator.h

@@ -1,47 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-/**
-
-  Eric D Vaughan
-  This class lays out its children either vertically or horizontally
- 
-**/
-
-#ifndef nsGrippyFrame_h___
-#define nsGrippyFrame_h___
-
-#include "nsIFrame.h"
-
-class nsFrameNavigator 
-{
-public:
-
-  static nsIFrame* GetChildBeforeAfter(nsIFrame* start, PRBool before);
-  static nsIFrame* GetChildAt(nsIFrame* parent, PRInt32 index);
-  static PRInt32 IndexOf(nsIFrame* parent, nsIFrame* child);
-  static PRInt32 CountFrames(nsIFrame* aFrame);
-  static nsIAtom* GetTag(nsIFrame* frame);
-
-}; 
-
-
-
-#endif
-

mozilla/layout/xul/base/src/nsGrippyFrame.cpp

@@ -1,240 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-//
-// Eric Vaughan
-// Netscape Communications
-//
-// See documentation in associated header file
-//
-
-#include "nsGrippyFrame.h"
-#include "nsScrollbarButtonFrame.h"
-#include "nsIStyleContext.h"
-#include "nsIPresContext.h"
-#include "nsIContent.h"
-#include "nsCOMPtr.h"
-#include "nsHTMLIIDs.h"
-#include "nsUnitConversion.h"
-#include "nsINameSpaceManager.h"
-#include "nsHTMLAtoms.h"
-#include "nsXULAtoms.h"
-#include "nsIReflowCommand.h"
-//#include "nsSliderFrame.h"
-#include "nsIDOMElement.h"
-#include "nsIDOMDocument.h"
-#include "nsDocument.h"
-#include "nsHTMLParts.h"
-#include "nsIPresShell.h"
-#include "nsIView.h"
-#include "nsIViewManager.h"
-#include "nsHTMLContainerFrame.h"
-
-
-//
-// NS_NewToolbarFrame
-//
-// Creates a new Toolbar frame and returns it in |aNewFrame|
-//
-nsresult
-NS_NewGrippyFrame ( nsIFrame** aNewFrame )
-{
-  NS_PRECONDITION(aNewFrame, "null OUT ptr");
-  if (nsnull == aNewFrame) {
-    return NS_ERROR_NULL_POINTER;
-  }
-  nsGrippyFrame* it = new nsGrippyFrame;
-  if (nsnull == it)
-    return NS_ERROR_OUT_OF_MEMORY;
-
-  *aNewFrame = it;
-  return NS_OK;
-  
-} // NS_NewGrippyFrame
-
-nsGrippyFrame::nsGrippyFrame():mCollapsed(PR_FALSE)
-{
-}
-
-void
-nsGrippyFrame::MouseClicked(nsIPresContext& aPresContext) 
-{
-    nsIFrame* splitter;
-    nsScrollbarButtonFrame::GetParentWithTag(nsXULAtoms::splitter, this, splitter);
-    if (splitter == nsnull)
-       return;
-
-    // get the splitters content node
-    nsCOMPtr<nsIContent> content;
-    splitter->GetContent(getter_AddRefs(content));
- 
-	nsString a = "collapsed";
-	nsString value;
-    if (NS_CONTENT_ATTR_HAS_VALUE == content->GetAttribute(kNameSpaceID_None, nsXULAtoms::state, value))
-    {
-     if (value=="collapsed")
-       a = "open";
-    }
-
-    content->SetAttribute(kNameSpaceID_None, nsXULAtoms::state, a, PR_TRUE);
-}
-
-/*
-void
-nsGrippyFrame::MouseClicked(nsIPresContext& aPresContext) 
-{
-
-  nsString style;
-
-  if (mCollapsed) {
-    style = mCollapsedChildStyle;
-  } else {
-    // when clicked see if we are in a splitter. 
-    nsIFrame* splitter;
-    nsScrollbarButtonFrame::GetParentWithTag(nsXULAtoms::splitter, this, splitter);
-
-    if (splitter == nsnull)
-       return;
-
-    // get the splitters content node
-    nsCOMPtr<nsIContent> content;
-    splitter->GetContent(getter_AddRefs(content));
-
-    // get the collapse attribute. If the attribute is not set collapse
-    // the child before otherwise collapse the child after
-    PRBool before = PR_TRUE;
-    nsString value;
-    if (NS_CONTENT_ATTR_HAS_VALUE == content->GetAttribute(kNameSpaceID_None, nsXULAtoms::collapse, value))
-    {
-     if (value=="after")
-       before = PR_FALSE;
-    }
-
-    // find the child just in the box just before the splitter. If we are not currently collapsed then
-    // then get the childs style attribute and store it. Then set the child style attribute to be display none.
-    // if we are already collapsed then set the child's style back to our stored value.
-    nsIFrame* child = GetChildBeforeAfter(splitter,before);
-    if (child == nsnull)
-      return;
-
-    child->GetContent(getter_AddRefs(mCollapsedChild));
-
-    style = "visibility: collapse";
-    mCollapsedChildStyle = "";
-    mCollapsedChild->GetAttribute(kNameSpaceID_None, nsHTMLAtoms::style, mCollapsedChildStyle);
-  }
-
-  mCollapsedChild->SetAttribute(kNameSpaceID_None, nsHTMLAtoms::style, style, PR_TRUE);
-
-  mCollapsed = !mCollapsed;
-
-}
-*/
-
-
-nsIFrame*
-nsGrippyFrame::GetChildBeforeAfter(nsIFrame* start, PRBool before)
-{
-   nsIFrame* parent = nsnull;
-   start->GetParent(&parent);
-   PRInt32 index = IndexOf(parent,start);
-   PRInt32 count = CountFrames(parent);
-
-   if (index == -1) 
-     return nsnull;
-
-   if (before) {
-     if (index == 0) {
-         return nsnull;
-     }
-
-     return GetChildAt(parent, index-1);
-   }
-
-
-   if (index == count-1)
-       return nsnull;
-
-   return GetChildAt(parent, index+1);
-
-}
-
-PRInt32
-nsGrippyFrame::IndexOf(nsIFrame* parent, nsIFrame* child)
-{
-  PRInt32 count = 0;
-
-  nsIFrame* childFrame;
-  parent->FirstChild(nsnull, &childFrame); 
-  while (nsnull != childFrame) 
-  {    
-    if (childFrame == child)
-       return count;
-
-    nsresult rv = childFrame->GetNextSibling(&childFrame);
-    NS_ASSERTION(rv == NS_OK,"failed to get next child");
-    count++;
-  }
-
-  return -1;
-}
-
-PRInt32
-nsGrippyFrame::CountFrames(nsIFrame* aFrame)
-{
-  PRInt32 count = 0;
-
-  nsIFrame* childFrame;
-  aFrame->FirstChild(nsnull, &childFrame); 
-  while (nsnull != childFrame) 
-  {    
-    nsresult rv = childFrame->GetNextSibling(&childFrame);
-    NS_ASSERTION(rv == NS_OK,"failed to get next child");
-    count++;
-  }
-
-  return count;
-}
-
-nsIFrame*
-nsGrippyFrame::GetChildAt(nsIFrame* parent, PRInt32 index)
-{
-  PRInt32 count = 0;
-
-  nsIFrame* childFrame;
-  parent->FirstChild(nsnull, &childFrame); 
-  while (nsnull != childFrame) 
-  {    
-    if (count == index)
-       return childFrame;
-
-    nsresult rv = childFrame->GetNextSibling(&childFrame);
-    NS_ASSERTION(rv == NS_OK,"failed to get next child");
-    count++;
-  }
-
-  return nsnull;
-}
-
-NS_IMETHODIMP
-nsGrippyFrame::GetFrameName(nsString& aResult) const
-{
-  aResult = "Grippy";
-  return NS_OK;
-}

mozilla/layout/xul/base/src/nsGrippyFrame.h

@@ -1,63 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-/**
-
-  Eric D Vaughan
-  This class lays out its children either vertically or horizontally
- 
-**/
-
-#ifndef nsGrippyFrame_h___
-#define nsGrippyFrame_h___
-
-#include "nsTitledButtonFrame.h"
-#include "nsCOMPtr.h"
-#include "nsIContent.h"
-
-
-class nsGrippyFrame : public nsTitledButtonFrame
-{
-public:
-
-  friend nsresult NS_NewGrippyFrame(nsIFrame** aNewFrame);
-
-  NS_IMETHOD GetFrameName(nsString& aResult) const;
-
-  static nsIFrame* GetChildBeforeAfter(nsIFrame* start, PRBool before);
-  static nsIFrame* GetChildAt(nsIFrame* parent, PRInt32 index);
-  static PRInt32 IndexOf(nsIFrame* parent, nsIFrame* child);
-  static PRInt32 CountFrames(nsIFrame* aFrame);
-  nsGrippyFrame();  
-
-protected:
-  virtual void MouseClicked(nsIPresContext& aPresContext);
-
-private:
-
-  PRBool mCollapsed;
-  nsString mCollapsedChildStyle;
-  nsCOMPtr<nsIContent> mCollapsedChild;
-  PRBool mDidDrag;
-}; // class nsTabFrame
-
-
-
-#endif
-

mozilla/layout/xul/base/src/nsIBox.h

@@ -1,77 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-/**
-
-  Eric D Vaughan
-  nsBoxFrame is a frame that can lay its children out either vertically or horizontally.
-  It lays them out according to a min max or preferred size.
- 
-**/
-
-#ifndef nsIBox_h___
-#define nsIBox_h___
-
-class nsIPresContext;
-class nsIFrame;
-struct nsHTMLReflowState;
-class nsBoxInfo;
-
-// {02A560C0-01BF-11d3-B35C-00A0CC3C1CDE} 
-#define NS_IBOX_IID { 0x2a560c0, 0x1bf, 0x11d3, { 0xb3, 0x5c, 0x0, 0xa0, 0xcc, 0x3c, 0x1c, 0xde } }
-static NS_DEFINE_IID(kIBoxIID,     NS_IBOX_IID);
-
-class nsBoxInfo {
-public:
-    nsSize prefSize;
-    nsSize minSize;
-    nsSize maxSize; 
-
-    float flex;
-
-    nsBoxInfo() { clear(); }
-
-    virtual void clear()
-    {
-      prefSize.width = 0;
-      prefSize.height = 0;
-
-      minSize.width = 0;
-      minSize.height = 0;
-
-      flex = 0.0;
-
-      maxSize.width = NS_INTRINSICSIZE;
-      maxSize.height = NS_INTRINSICSIZE;
-    }
-  
-};
-
-class nsIBox : public nsISupports {
-
-public:
-
-  static const nsIID& GetIID() { static nsIID iid = NS_IBOX_IID; return iid; }
-
-  NS_IMETHOD GetBoxInfo(nsIPresContext& aPresContext, const nsHTMLReflowState& aReflowState, nsBoxInfo& aSize)=0;
-  NS_IMETHOD Dirty(nsIPresContext& aPresContext, const nsHTMLReflowState& aReflowState, nsIFrame*& incrementalChild)=0;
-};
-
-#endif
-

mozilla/layout/xul/base/src/nsIColorPicker.h

@@ -1,77 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Mozilla browser.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation. Portions created by Netscape are
- * Copyright (C) 1999 Netscape Communications Corporation. All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *   Stuart Parmenter <pavlov@netscape.com>
- */
-
-#ifndef __nsIColorPicker_h__
-#define __nsIColorPicker_h__
-
-#include "nsISupports.h"
-#include "nsrootidl.h"
-#include "nsIPresContext.h"
-#include "nsIRenderingContext.h"
-
-/* starting interface:    nsIColorPicker */
-
-#define NS_ICOLORPICKER_IID_STR "ed133d04-1dd1-11b2-957f-a04e70608d6e"
-
-#define NS_ICOLORPICKER_IID \
-  {0xed133d04, 0x1dd1, 0x11b2, \
-    { 0x95, 0x7f, 0xa0, 0x4e, 0x70, 0x60, 0x8d, 0x6e }}
-
-class nsIColorPicker : public nsISupports {
- public: 
-  NS_DEFINE_STATIC_IID_ACCESSOR(NS_ICOLORPICKER_IID)
-
-  /* void Init (in nsIContent aContent); */
-  NS_IMETHOD  Init(nsIContent * aContent) = 0;
-
-  /* void Paint (in nsIPresContext aPresContext, in nsIRenderingContext aRenderingContext); */
-  NS_IMETHOD  Paint(nsIPresContext * aPresContext, nsIRenderingContext * aRenderingContext) = 0;
-
-  /* void GetColor (in PRInt32 aX, in PRInt32 aY, out string aColor); */
-  NS_IMETHOD  GetColor(PRInt32 aX, PRInt32 aY, char **aColor) = 0;
-
-  /* void SetColor (in PRInt32 aWidth, in PRInt32 aHeight); */
-  NS_IMETHOD  SetSize(PRInt32 aWidth, PRInt32 aHeight) = 0;
-
-  /* void GetSize (out PRInt32 aWidth, out PRInt32 aHeight); */
-  NS_IMETHOD  GetSize(PRInt32 *aWidth, PRInt32 *aHeight) = 0;
-};
-
-/* Use this macro when declaring classes that implement this interface. */
-#define NS_DECL_NSICOLORPICKER \
-  NS_IMETHOD  Init(nsIContent * aContent); \
-  NS_IMETHOD  Paint(nsIPresContext * aPresContext, nsIRenderingContext * aRenderingContext); \
-  NS_IMETHOD  GetColor(PRInt32 aX, PRInt32 aY, char **aColor); \
-  NS_IMETHOD  SetSize(PRInt32 aWidth, PRInt32 aHeight); \
-  NS_IMETHOD  GetSize(PRInt32 *aWidth, PRInt32 *aHeight); 
-
-/* Use this macro to declare functions that forward the behavior of this interface to another object. */
-#define NS_FORWARD_NSICOLORPICKER(_to) \
-  NS_IMETHOD  Init(nsIContent * aContent) { return _to ##  Init(aContent); } \
-  NS_IMETHOD  Paint(nsIPresContext * aPresContext, nsIRenderingContext * aRenderingContext) { return _to ##  Paint(aPresContext, aRenderingContext); } \
-  NS_IMETHOD  GetColor(PRInt32 aX, PRInt32 aY, char **aColor) { return _to ##  GetColor(aX, aY, aColor); } \
-  NS_IMETHOD  SetSize(PRInt32 aWidth, PRInt32 aHeight) { return _to ##  SetSize(aWidth, aHeight); } \
-  NS_IMETHOD  GetSize(PRInt32 *aWidth, PRInt32 *aHeight) { return _to ##  GetSize(aWidth, aHeight); } 
-
-
-#endif /* __nsIColorPicker_h__ */

mozilla/layout/xul/base/src/nsIMenuFrame.h

@@ -1,63 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-#ifndef nsIMenuFrame_h___
-#define nsIMenuFrame_h___
-
-// {6A4CDE51-6C05-11d3-BB50-00104B7B7DEB}
-#define NS_IMENUFRAME_IID \
-{ 0x6a4cde51, 0x6c05, 0x11d3, { 0xbb, 0x50, 0x0, 0x10, 0x4b, 0x7b, 0x7d, 0xeb } }
-
-class nsIMenuParent;
-
-enum nsMenuType {
-  eMenuType_Normal = 0,
-  eMenuType_Checkbox = 1,
-  eMenuType_Radio = 2
-};
-
-class nsIMenuFrame : public nsISupports {
-
-public:
-  static const nsIID& GetIID() { static nsIID iid = NS_IMENUFRAME_IID; return iid; }
-
-  NS_IMETHOD ActivateMenu(PRBool aFlag) = 0;
-  NS_IMETHOD SelectMenu(PRBool aFlag) = 0;
-  NS_IMETHOD OpenMenu(PRBool aFlag) = 0;
-
-  NS_IMETHOD MenuIsOpen(PRBool& aResult) = 0;
-  NS_IMETHOD MenuIsContainer(PRBool& aResult) = 0;
-  NS_IMETHOD MenuIsChecked(PRBool& aResult) = 0;
-
-  NS_IMETHOD SelectFirstItem() = 0;
-
-  NS_IMETHOD Escape(PRBool& aHandledFlag) = 0;
-  NS_IMETHOD Enter() = 0;
-  NS_IMETHOD ShortcutNavigation(PRUint32 aLetter, PRBool& aHandledFlag) = 0;
-  NS_IMETHOD KeyboardNavigation(PRUint32 aDirection, PRBool& aHandledFlag) = 0;
-
-  NS_IMETHOD GetMenuParent(nsIMenuParent** aMenuParent) = 0;
-  NS_IMETHOD GetRadioGroupName(nsString &aName) = 0;
-  NS_IMETHOD GetMenuType(nsMenuType &aType) = 0;
-
-  NS_IMETHOD MarkAsGenerated() = 0;
-};
-
-#endif
-

mozilla/layout/xul/base/src/nsIMenuParent.h

@@ -1,52 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-#ifndef nsIMenuParent_h___
-#define nsIMenuParent_h___
-
-
-// {D407BF61-3EFA-11d3-97FA-00400553EEF0}
-#define NS_IMENUPARENT_IID \
-{ 0xd407bf61, 0x3efa, 0x11d3, { 0x97, 0xfa, 0x0, 0x40, 0x5, 0x53, 0xee, 0xf0 } }
-
-class nsIMenuFrame;
-
-class nsIMenuParent : public nsISupports {
-
-public:
-  static const nsIID& GetIID() { static nsIID iid = NS_IMENUPARENT_IID; return iid; }
-
-  NS_IMETHOD SetCurrentMenuItem(nsIMenuFrame* aMenuItem) = 0;
-  NS_IMETHOD GetNextMenuItem(nsIMenuFrame* aStart, nsIMenuFrame** aResult) = 0;
-  NS_IMETHOD GetPreviousMenuItem(nsIMenuFrame* aStart, nsIMenuFrame** aResult) = 0;
-
-  NS_IMETHOD SetActive(PRBool aActiveFlag) = 0;
-  NS_IMETHOD GetIsActive(PRBool& isActive) = 0;
-  NS_IMETHOD GetWidget(nsIWidget **aWidget) = 0;
-  
-  NS_IMETHOD IsMenuBar(PRBool& isMenuBar) = 0;
-
-  NS_IMETHOD DismissChain() = 0;
-  NS_IMETHOD HideChain() = 0;
-
-  NS_IMETHOD CreateDismissalListener() = 0;
-};
-
-#endif
-

mozilla/layout/xul/base/src/nsIScrollbarListener.h

@@ -1,44 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-#ifndef nsIScrollbarListener_h___
-#define nsIScrollbarListener_h___
-
-// {A0ADBD81-2911-11d3-97FA-00400553EEF0}
-#define NS_ISCROLLBARLISTENER_IID \
-{ 0xa0adbd81, 0x2911, 0x11d3, { 0x97, 0xfa, 0x0, 0x40, 0x5, 0x53, 0xee, 0xf0 } }
-
-static NS_DEFINE_IID(kIScrollbarListenerIID,     NS_ISCROLLBARLISTENER_IID);
-
-class nsIPresContext;
-
-class nsIScrollbarListener : public nsISupports {
-
-public:
-
-  static const nsIID& GetIID() { static nsIID iid = NS_ISCROLLBARLISTENER_IID; return iid; }
-  
-  NS_IMETHOD PositionChanged(nsIPresContext& aPresContext, PRInt32 aOldIndex, PRInt32 aNewIndex) = 0;
-
-  NS_IMETHOD PagedUpDown() = 0;
-  //  NS_IMETHOD GoingAway() = 0;
-};
-
-#endif
-

mozilla/layout/xul/base/src/nsMenuBarFrame.cpp

@@ -1,537 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-
-#include "nsMenuBarFrame.h"
-
-#include "nsIContent.h"
-#include "prtypes.h"
-#include "nsIAtom.h"
-#include "nsIPresContext.h"
-#include "nsIStyleContext.h"
-#include "nsCSSRendering.h"
-#include "nsINameSpaceManager.h"
-#include "nsIDocument.h"
-#include "nsIDOMEventReceiver.h"
-#include "nsXULAtoms.h"
-#include "nsHTMLAtoms.h"
-#include "nsMenuFrame.h"
-#include "nsIView.h"
-#include "nsIViewManager.h"
-#include "nsMenuPopupFrame.h"
-
-static NS_DEFINE_IID(kIFrameIID, NS_IFRAME_IID);
-
-//
-// NS_NewMenuBarFrame
-//
-// Wrapper for creating a new menu Bar container
-//
-nsresult
-NS_NewMenuBarFrame(nsIFrame** aNewFrame)
-{
-  NS_PRECONDITION(aNewFrame, "null OUT ptr");
-  if (nsnull == aNewFrame) {
-    return NS_ERROR_NULL_POINTER;
-  }
-  nsMenuBarFrame* it = new nsMenuBarFrame;
-  if ( !it )
-    return NS_ERROR_OUT_OF_MEMORY;
-  *aNewFrame = it;
-  return NS_OK;
-}
-
-NS_IMETHODIMP_(nsrefcnt) 
-nsMenuBarFrame::AddRef(void)
-{
-  return NS_OK;
-}
-
-NS_IMETHODIMP_(nsrefcnt) 
-nsMenuBarFrame::Release(void)
-{
-    return NS_OK;
-}
-
-NS_IMETHODIMP nsMenuBarFrame::QueryInterface(REFNSIID aIID, void** aInstancePtr)      
-{           
-  if (NULL == aInstancePtr) {                                            
-    return NS_ERROR_NULL_POINTER;                                        
-  }                                                                      
-                                                                         
-  *aInstancePtr = NULL;                                                  
-                                                                                        
-  if (aIID.Equals(nsIMenuParent::GetIID())) {                                         
-    *aInstancePtr = (void*)(nsIMenuParent*) this;                                        
-    NS_ADDREF_THIS();                                                    
-    return NS_OK;                                                        
-  }   
-
-  return nsToolbarFrame::QueryInterface(aIID, aInstancePtr);                                     
-}
-//
-// nsMenuBarFrame cntr
-//
-nsMenuBarFrame::nsMenuBarFrame()
-:mIsActive(PR_FALSE), mTarget(nsnull)
-{
-
-} // cntr
-
-nsMenuBarFrame::~nsMenuBarFrame()
-{
-}
-
-NS_IMETHODIMP
-nsMenuBarFrame::Init(nsIPresContext&  aPresContext,
-                     nsIContent*      aContent,
-                     nsIFrame*        aParent,
-                     nsIStyleContext* aContext,
-                     nsIFrame*        aPrevInFlow)
-{
-  nsresult  rv = nsToolbarFrame::Init(aPresContext, aContent, aParent, aContext, aPrevInFlow);
-
-  // XXX hack
-  mPresContext = &aPresContext;
-
-  // Create the menu bar listener.
-  mMenuBarListener = new nsMenuBarListener(this);
-
-  // Hook up the menu bar as a key listener (capturer) on the whole document.  It will see every
-  // key press that occurs before anyone else does and will know when to take control.
-  nsCOMPtr<nsIDocument> doc;
-  aContent->GetDocument(*getter_AddRefs(doc));
-  nsCOMPtr<nsIDOMEventReceiver> target = do_QueryInterface(doc);
-  nsIDOMEventListener* domEventListener = (nsIDOMKeyListener*)mMenuBarListener;
-
-  mTarget = target;
-
-  target->AddEventListener("keypress", domEventListener, PR_TRUE); 
-	target->AddEventListener("keydown", domEventListener, PR_TRUE);  
-  target->AddEventListener("keyup", domEventListener, PR_TRUE);   
-  
-  return rv;
-}
-
-NS_IMETHODIMP
-nsMenuBarFrame::SetActive(PRBool aActiveFlag)
-{
-  mIsActive = aActiveFlag;
-  return NS_OK;
-}
-
-void
-nsMenuBarFrame::ToggleMenuActiveState()
-{
-  if (mIsActive) {
-    // Deactivate the menu bar
-    mIsActive = PR_FALSE;
-    if (mCurrentMenu) {
-      // Deactivate the menu.
-      mCurrentMenu->OpenMenu(PR_FALSE);
-      mCurrentMenu->SelectMenu(PR_FALSE);
-      mCurrentMenu = nsnull;
-    }
-  }
-  else {
-    // Activate the menu bar
-    SetActive(PR_TRUE);
-
-    // Set the active menu to be the top left item (e.g., the File menu).
-    // We use an attribute called "active" to track the current active menu.
-    nsCOMPtr<nsIContent> firstMenuItem;
-    nsIMenuFrame* firstFrame;
-    GetNextMenuItem(nsnull, &firstFrame);
-    if (firstFrame) {
-      firstFrame->SelectMenu(PR_TRUE);
-      
-      // Track this item for keyboard navigation.
-      mCurrentMenu = firstFrame;
-    }
-  }
-}
-
-nsIMenuFrame*
-nsMenuBarFrame::FindMenuWithShortcut(PRUint32 aLetter)
-{
-  // Enumerate over our list of frames.
-  nsIFrame* currFrame = mFrames.FirstChild();
-  while (currFrame) {
-    nsCOMPtr<nsIContent> current;
-    currFrame->GetContent(getter_AddRefs(current));
-    
-    // See if it's a menu item.
-    if (IsValidItem(current)) {
-      // Get the shortcut attribute.
-      nsString shortcutKey = "";
-      current->GetAttribute(kNameSpaceID_None, nsXULAtoms::accesskey, shortcutKey);
-      shortcutKey.ToUpperCase();
-      if (shortcutKey.Length() > 0) {
-        // We've got something.
-        PRUnichar shortcutChar = shortcutKey.CharAt(0);
-        if (shortcutChar == aLetter) {
-          // We match!
-          nsCOMPtr<nsIMenuFrame> menuFrame = do_QueryInterface(currFrame);
-          if (menuFrame)
-            return menuFrame.get();
-          return nsnull;
-        }
-      }
-    }
-    currFrame->GetNextSibling(&currFrame);
-  }
-  return nsnull;
-}
-
-void 
-nsMenuBarFrame::ShortcutNavigation(PRUint32 aLetter, PRBool& aHandledFlag)
-{
-  if (mCurrentMenu) {
-    PRBool isOpen = PR_FALSE;
-    mCurrentMenu->MenuIsOpen(isOpen);
-    if (isOpen) {
-      // No way this applies to us. Give it to our child.
-      mCurrentMenu->ShortcutNavigation(aLetter, aHandledFlag);
-      return;
-    }
-  }
-
-  // This applies to us. Let's see if one of the shortcuts applies
-  nsIMenuFrame* result = FindMenuWithShortcut(aLetter);
-  if (result) {
-    // We got one!
-    aHandledFlag = PR_TRUE;
-    mIsActive = PR_TRUE;
-    SetCurrentMenuItem(result);
-    result->OpenMenu(PR_TRUE);
-    result->SelectFirstItem();
-  }
-}
-
-void
-nsMenuBarFrame::KeyboardNavigation(PRUint32 aDirection)
-{
-  if (!mCurrentMenu)
-    return;
-  
-  PRBool isContainer = PR_FALSE;
-  PRBool isOpen = PR_FALSE;
-  mCurrentMenu->MenuIsContainer(isContainer);
-  mCurrentMenu->MenuIsOpen(isOpen);
-
-  PRBool handled = PR_FALSE;
-  
-  if (isOpen) {
-    // Let the child menu try to handle it.
-    mCurrentMenu->KeyboardNavigation(aDirection, handled);
-  }
-
-  if (handled)
-    return;
-
-  if (aDirection == NS_VK_RIGHT || aDirection == NS_VK_LEFT) {
-    
-    nsIMenuFrame* nextItem;
-    
-    if (aDirection == NS_VK_RIGHT)
-      GetNextMenuItem(mCurrentMenu, &nextItem);
-    else GetPreviousMenuItem(mCurrentMenu, &nextItem);
-
-    SetCurrentMenuItem(nextItem);
-    if (nextItem) {
-      PRBool nextIsOpen;
-      nextItem->MenuIsOpen(nextIsOpen);
-      if (nextIsOpen) {
-        // Select the first item.
-        nextItem->SelectFirstItem();
-      }
-    }
-  }
-  else if (aDirection == NS_VK_UP || aDirection == NS_VK_DOWN) {
-    // Open the menu and select its first item.
-    mCurrentMenu->OpenMenu(PR_TRUE);
-    mCurrentMenu->SelectFirstItem();
-  }
-}
-
-NS_IMETHODIMP
-nsMenuBarFrame::GetNextMenuItem(nsIMenuFrame* aStart, nsIMenuFrame** aResult)
-{
-  nsIFrame* currFrame = nsnull;
-  nsIFrame* startFrame = nsnull;
-  if (aStart) {
-    aStart->QueryInterface(kIFrameIID, (void**)&currFrame); 
-    if (currFrame) {
-      startFrame = currFrame;
-      currFrame->GetNextSibling(&currFrame);
-    }
-  }
-  else currFrame = mFrames.FirstChild();
-
-  while (currFrame) {
-    nsCOMPtr<nsIContent> current;
-    currFrame->GetContent(getter_AddRefs(current));
-
-    // See if it's a menu item.
-    if (IsValidItem(current)) {
-      nsCOMPtr<nsIMenuFrame> menuFrame = do_QueryInterface(currFrame);
-      *aResult = menuFrame.get();
-      NS_IF_ADDREF(*aResult);
-      return NS_OK;
-    }
-    currFrame->GetNextSibling(&currFrame);
-  }
-
-  currFrame = mFrames.FirstChild();
-
-  // Still don't have anything. Try cycling from the beginning.
-  while (currFrame && currFrame != startFrame) {
-    nsCOMPtr<nsIContent> current;
-    currFrame->GetContent(getter_AddRefs(current));
-    
-    // See if it's a menu item.
-    if (IsValidItem(current)) {
-      nsCOMPtr<nsIMenuFrame> menuFrame = do_QueryInterface(currFrame);
-      *aResult = menuFrame.get();
-      NS_IF_ADDREF(*aResult);
-      return NS_OK;
-    }
-
-    currFrame->GetNextSibling(&currFrame);
-  }
-
-  // No luck. Just return our start value.
-  *aResult = aStart;
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsMenuBarFrame::GetPreviousMenuItem(nsIMenuFrame* aStart, nsIMenuFrame** aResult)
-{
-  nsIFrame* currFrame = nsnull;
-  nsIFrame* startFrame = nsnull;
-  if (aStart) {
-    aStart->QueryInterface(kIFrameIID, (void**)&currFrame);
-    if (currFrame) {
-      startFrame = currFrame;
-      currFrame = mFrames.GetPrevSiblingFor(currFrame);
-    }
-  }
-  else currFrame = mFrames.LastChild();
-
-  while (currFrame) {
-    nsCOMPtr<nsIContent> current;
-    currFrame->GetContent(getter_AddRefs(current));
-
-    // See if it's a menu item.
-    if (IsValidItem(current)) {
-      nsCOMPtr<nsIMenuFrame> menuFrame = do_QueryInterface(currFrame);
-      *aResult = menuFrame.get();
-      NS_IF_ADDREF(*aResult);
-      return NS_OK;
-    }
-    currFrame = mFrames.GetPrevSiblingFor(currFrame);
-  }
-
-  currFrame = mFrames.LastChild();
-
-  // Still don't have anything. Try cycling from the end.
-  while (currFrame && currFrame != startFrame) {
-    nsCOMPtr<nsIContent> current;
-    currFrame->GetContent(getter_AddRefs(current));
-    
-    // See if it's a menu item.
-    if (IsValidItem(current)) {
-      nsCOMPtr<nsIMenuFrame> menuFrame = do_QueryInterface(currFrame);
-      *aResult = menuFrame.get();
-      NS_IF_ADDREF(*aResult);
-      return NS_OK;
-    }
-
-    currFrame = mFrames.GetPrevSiblingFor(currFrame);
-  }
-
-  // No luck. Just return our start value.
-  *aResult = aStart;
-  return NS_OK;
-}
-
-NS_IMETHODIMP nsMenuBarFrame::SetCurrentMenuItem(nsIMenuFrame* aMenuItem)
-{
-  if (mCurrentMenu == aMenuItem)
-    return NS_OK;
-
-  PRBool wasOpen = PR_FALSE;
-  
-  // Unset the current child.
-  if (mCurrentMenu) {
-    mCurrentMenu->MenuIsOpen(wasOpen);
-    mCurrentMenu->SelectMenu(PR_FALSE);
-    if (wasOpen)
-      mCurrentMenu->OpenMenu(PR_FALSE);
-  }
-
-  // Set the new child.
-  if (aMenuItem) {
-    aMenuItem->SelectMenu(PR_TRUE);
-    aMenuItem->MarkAsGenerated(); // Have the menu building. Get it ready to be shown.
-
-    if (wasOpen)
-      aMenuItem->OpenMenu(PR_TRUE);
-  }
-
-  mCurrentMenu = aMenuItem;
-
-  return NS_OK;
-}
-
-void 
-nsMenuBarFrame::Escape()
-{
-  if (!mCurrentMenu)
-    return;
-
-  // See if our menu is open.
-  PRBool isOpen = PR_FALSE;
-  mCurrentMenu->MenuIsOpen(isOpen);
-  if (isOpen) {
-    // Let the child menu handle this.
-    PRBool handled = PR_FALSE;
-    mCurrentMenu->Escape(handled);
-    if (!handled) {
-      // Close up this menu but keep our current menu item
-      // designation.
-      mCurrentMenu->OpenMenu(PR_FALSE);
-    }
-    return;
-  }
-
-  // It's us. Just set our active flag to false.
-  mIsActive = PR_FALSE;
-
-  // Clear our current menu item if we've got one.
-  SetCurrentMenuItem(nsnull);
-
-  // Clear out our dismissal listener
-  if (nsMenuFrame::mDismissalListener)
-    nsMenuFrame::mDismissalListener->Unregister();
-}
-
-void 
-nsMenuBarFrame::Enter()
-{
-  if (!mCurrentMenu)
-    return;
-
-  // See if our menu is open.
-  PRBool isOpen = PR_FALSE;
-  mCurrentMenu->MenuIsOpen(isOpen);
-  if (isOpen) {
-    // Let the child menu handle this.
-    mCurrentMenu->Enter();
-    return;
-  }
-
-  // It's us. Open the current menu.
-  mCurrentMenu->OpenMenu(PR_TRUE);
-  mCurrentMenu->SelectFirstItem();
-}
-
-NS_IMETHODIMP
-nsMenuBarFrame::HideChain()
-{
-  // Stop capturing rollups
-  // (must do this during Hide, which happens before the menu item is executed,
-  // since this reinstates normal event handling.)
-  if (nsMenuFrame::mDismissalListener)
-    nsMenuFrame::mDismissalListener->Unregister();
-
-  if (mCurrentMenu) {
-    mCurrentMenu->ActivateMenu(PR_FALSE);
-    mCurrentMenu->SelectMenu(PR_FALSE);
-  }
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsMenuBarFrame::DismissChain()
-{
-  // Stop capturing rollups
-  if (nsMenuFrame::mDismissalListener)
-    nsMenuFrame::mDismissalListener->Unregister();
-  
-  SetCurrentMenuItem(nsnull);
-  SetActive(PR_FALSE);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsMenuBarFrame::GetWidget(nsIWidget **aWidget)
-{
-  // Get parent view
-  nsIView * view = nsnull;
-  nsMenuPopupFrame::GetNearestEnclosingView(mPresContext, this, &view);
-  if (!view)
-    return NS_OK;
-
-  view->GetWidget(*aWidget);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsMenuBarFrame::CreateDismissalListener()
-{
-  NS_ADDREF(nsMenuFrame::mDismissalListener = new nsMenuDismissalListener());
-  return NS_OK;
-}
-
-PRBool 
-nsMenuBarFrame::IsValidItem(nsIContent* aContent)
-{
-  nsCOMPtr<nsIAtom> tag;
-  aContent->GetTag(*getter_AddRefs(tag));
-  if (tag && (tag.get() == nsXULAtoms::menu ||
-              tag.get() == nsXULAtoms::menuitem) &&
-      !IsDisabled(aContent))
-      return PR_TRUE;
-
-  return PR_FALSE;
-}
-
-PRBool 
-nsMenuBarFrame::IsDisabled(nsIContent* aContent)
-{
-  nsString disabled = "";
-  aContent->GetAttribute(kNameSpaceID_None, nsHTMLAtoms::disabled, disabled);
-  if (disabled == "true")
-    return PR_TRUE;
-  return PR_FALSE;
-}
-
-NS_IMETHODIMP
-nsMenuBarFrame::Destroy(nsIPresContext& aPresContext)
-{
-  mTarget->RemoveEventListener("keypress", mMenuBarListener, PR_TRUE); 
-	mTarget->RemoveEventListener("keydown", mMenuBarListener, PR_TRUE);  
-  mTarget->RemoveEventListener("keyup", mMenuBarListener, PR_TRUE);
-
-  delete mMenuBarListener;
-  mMenuBarListener = nsnull;
-
-  return nsToolbarFrame::Destroy(aPresContext);
-}

mozilla/layout/xul/base/src/nsMenuBarFrame.h

@@ -1,108 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-//
-// nsMenuBarFrame
-//
-
-#ifndef nsMenuBarFrame_h__
-#define nsMenuBarFrame_h__
-
-#include "prtypes.h"
-#include "nsIAtom.h"
-#include "nsCOMPtr.h"
-#include "nsToolbarFrame.h"
-#include "nsMenuBarListener.h"
-#include "nsIMenuParent.h"
-#include "nsIWidget.h"
-
-class nsIContent;
-class nsIMenuFrame;
-
-nsresult NS_NewMenuBarFrame(nsIFrame** aResult) ;
-
-class nsMenuBarFrame : public nsToolbarFrame, public nsIMenuParent
-{
-public:
-  nsMenuBarFrame();
-  ~nsMenuBarFrame();
-
-  NS_DECL_ISUPPORTS
-
-  // nsIMenuParentInterface
-  NS_IMETHOD SetCurrentMenuItem(nsIMenuFrame* aMenuItem);
-  NS_IMETHOD GetNextMenuItem(nsIMenuFrame* aStart, nsIMenuFrame** aResult);
-  NS_IMETHOD GetPreviousMenuItem(nsIMenuFrame* aStart, nsIMenuFrame** aResult);
-  NS_IMETHOD SetActive(PRBool aActiveFlag); 
-  NS_IMETHOD GetIsActive(PRBool& isActive) { isActive = IsActive(); return NS_OK; };
-  NS_IMETHOD IsMenuBar(PRBool& isMenuBar) { isMenuBar = PR_TRUE; return NS_OK; };
-
-  NS_IMETHOD IsActive() { return mIsActive; };
-
-  // Closes up the chain of open cascaded menus.
-  NS_IMETHOD DismissChain();
-
-  // Hides the chain of cascaded menus without closing them up.
-  NS_IMETHOD HideChain();
-
-  NS_IMETHOD GetWidget(nsIWidget **aWidget);
-  // The dismissal listener gets created and attached to the window.
-  NS_IMETHOD CreateDismissalListener();
-
-  NS_IMETHOD Init(nsIPresContext&  aPresContext,
-                  nsIContent*      aContent,
-                  nsIFrame*        aParent,
-                  nsIStyleContext* aContext,
-                  nsIFrame*        aPrevInFlow);
-
-  NS_IMETHOD Destroy(nsIPresContext& aPresContext);
-
-// Non-interface helpers
-
-  // Called when a menu on the menu bar is clicked on.
-  void ToggleMenuActiveState();
-  
-  // Used to move up, down, left, and right in menus.
-  void KeyboardNavigation(PRUint32 aDirection);
-  
-  // Used to handle ALT+key combos
-  void ShortcutNavigation(PRUint32 aLetter, PRBool& aHandledFlag);
-  nsIMenuFrame* FindMenuWithShortcut(PRUint32 aLetter);
-
-  // Called when the ESC key is held down to close levels of menus.
-  void Escape();
-
-  // Called to execute a menu item.
-  void Enter();
-
-  PRBool IsValidItem(nsIContent* aContent);
-  PRBool IsDisabled(nsIContent* aContent);
-
-protected:
-  nsMenuBarListener* mMenuBarListener; // The listener that tells us about key and mouse events.
-  PRBool mIsActive; // Whether or not the menu bar is active (a menu item is highlighted or shown).
-  nsIMenuFrame* mCurrentMenu; // The current menu that is active.
-
-  nsIDOMEventReceiver* mTarget;
-
-  // XXX Hack
-  nsIPresContext* mPresContext;  // weak reference
-
-}; // class nsMenuBarFrame
-
-#endif

mozilla/layout/xul/base/src/nsMenuBarListener.cpp

@@ -1,190 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-#include "nsMenuBarListener.h"
-#include "nsMenuBarFrame.h"
-#include "nsIDOMKeyListener.h"
-#include "nsIDOMEventReceiver.h"
-#include "nsIDOMEventListener.h"
-
-// Drag & Drop, Clipboard
-#include "nsIServiceManager.h"
-#include "nsWidgetsCID.h"
-#include "nsCOMPtr.h"
-#include "nsIDOMKeyEvent.h"
-#include "nsIPresContext.h"
-#include "nsIContent.h"
-#include "nsIDOMNode.h"
-#include "nsIDOMElement.h"
-#include "nsXULAtoms.h"
-
-#include "nsIEventStateManager.h"
-
-#include "nsIViewManager.h"
-#include "nsIView.h"
-#include "nsISupportsArray.h"
-
-/*
- * nsMenuBarListener implementation
- */
-
-NS_IMPL_ADDREF(nsMenuBarListener)
-NS_IMPL_RELEASE(nsMenuBarListener)
-
-
-////////////////////////////////////////////////////////////////////////
-
-nsMenuBarListener::nsMenuBarListener(nsMenuBarFrame* aMenuBar) 
-:mAltKeyDown(PR_FALSE)
-{
-  NS_INIT_REFCNT();
-  mMenuBarFrame = aMenuBar;
-}
-
-////////////////////////////////////////////////////////////////////////
-nsMenuBarListener::~nsMenuBarListener() 
-{
-}
-
-////////////////////////////////////////////////////////////////////////
-nsresult
-nsMenuBarListener::QueryInterface(REFNSIID aIID, void** aInstancePtr)
-{
-  if (nsnull == aInstancePtr) {
-    return NS_ERROR_NULL_POINTER;
-  }
-
-  if (aIID.Equals(nsCOMTypeInfo<nsIDOMEventReceiver>::GetIID())) {
-    *aInstancePtr = (void*)(nsIDOMEventListener*)(nsIDOMKeyListener*)this;
-    NS_ADDREF_THIS();
-    return NS_OK;
-  }
-  if (aIID.Equals(nsCOMTypeInfo<nsIDOMKeyListener>::GetIID())) {
-    *aInstancePtr = (void*)(nsIDOMKeyListener*)this;
-    NS_ADDREF_THIS();
-    return NS_OK;
-  }
-  if (aIID.Equals(nsCOMTypeInfo<nsISupports>::GetIID())) {                                      
-    *aInstancePtr = (void*)(nsISupports*)(nsIDOMKeyListener*)this;                        
-    NS_ADDREF_THIS();                                                    
-    return NS_OK;                                                        
-  }
-  return NS_NOINTERFACE;
-}
-
-////////////////////////////////////////////////////////////////////////
-nsresult
-nsMenuBarListener::KeyUp(nsIDOMEvent* aKeyEvent)
-{  
-  // On a press of the ALT key by itself, we toggle the menu's 
-  // active/inactive state.
-  // Get the ascii key code.
-  nsCOMPtr<nsIDOMKeyEvent> keyEvent = do_QueryInterface(aKeyEvent);
-  PRUint32 theChar;
-	keyEvent->GetKeyCode(&theChar);
-  if (theChar == NS_VK_ALT && mAltKeyDown) {
-    // The ALT key was down and is now up.
-    mAltKeyDown = PR_FALSE;
-    mMenuBarFrame->ToggleMenuActiveState();
-  }
-  
-  PRBool active = mMenuBarFrame->IsActive();
-  if (active)
-    return NS_ERROR_BASE; // I am consuming event
-  return NS_OK; // means I am NOT consuming event
-}
-
-////////////////////////////////////////////////////////////////////////
-nsresult
-nsMenuBarListener::KeyDown(nsIDOMEvent* aKeyEvent)
-{
-  PRBool active = mMenuBarFrame->IsActive();
-
-  nsCOMPtr<nsIDOMKeyEvent> keyEvent = do_QueryInterface(aKeyEvent);
-  PRUint32 theChar;
-	keyEvent->GetKeyCode(&theChar);
-  if (theChar == NS_VK_ALT) {
-    // The ALT key just went down. Track this.
-    mAltKeyDown = PR_TRUE;
-    return NS_OK;
-  }
-  
-  PRBool altKeyWasDown = mAltKeyDown;
-  mAltKeyDown = PR_FALSE;
-
-  if (theChar == NS_VK_LEFT ||
-      theChar == NS_VK_RIGHT ||
-      theChar == NS_VK_UP ||
-      theChar == NS_VK_DOWN) {
-    // The arrow keys were pressed. User is moving around within
-    // the menus.
-    if (active) 
-      mMenuBarFrame->KeyboardNavigation(theChar);
-  }
-  else if (theChar == NS_VK_ESCAPE) {
-    // Close one level.
-    if (active)
-      mMenuBarFrame->Escape();
-  }
-  else if (theChar == NS_VK_ENTER ||
-           theChar == NS_VK_RETURN) {
-    // Open one level.
-    if (active)
-      mMenuBarFrame->Enter();
-  }
-  else if (active || altKeyWasDown) {
-    // Get the character code.
-    nsCOMPtr<nsIDOMKeyEvent> keyEvent = do_QueryInterface(aKeyEvent);
-    if (keyEvent) {
-      // See if a letter was pressed.
-      PRUint32 charCode;
-      keyEvent->GetKeyCode(&charCode);
-
-      // Do shortcut navigation.
-      // A letter was pressed. We want to see if a shortcut gets matched. If
-      // so, we'll know the menu got activated.
-      mMenuBarFrame->ShortcutNavigation(charCode, active);
-    }
-  }
-  if (active)
-    return NS_ERROR_BASE; // I am consuming event
-  return NS_OK; // means I am NOT consuming event
-}
-
-////////////////////////////////////////////////////////////////////////
-nsresult
-nsMenuBarListener::KeyPress(nsIDOMEvent* aKeyEvent)
-{
-  nsCOMPtr<nsIDOMKeyEvent> keyEvent = do_QueryInterface(aKeyEvent);
-
-  PRBool active = mMenuBarFrame->IsActive();
-  
-  if (active)
-    return NS_ERROR_BASE; // I am consuming event
-  return NS_OK; // means I am NOT consuming event
-}
-
-  ////////////////////////////////////////////////////////////////////////
-nsresult
-nsMenuBarListener::HandleEvent(nsIDOMEvent* aEvent)
-{
-  return NS_OK;
-}
-
-

mozilla/layout/xul/base/src/nsMenuBarListener.h

@@ -1,56 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-#ifndef nsMenuBarListener_h__
-#define nsMenuBarListener_h__
-
-#include "nsIDOMMouseMotionListener.h"
-#include "nsIDOMMouseListener.h"
-#include "nsIDOMKeyListener.h"
-#include "nsIDOMEventReceiver.h"
-
-class nsMenuBarFrame;
-class nsIPresContext;
-
-/** editor Implementation of the DragListener interface
- */
-class nsMenuBarListener : public nsIDOMKeyListener
-{
-public:
-  /** default constructor
-   */
-  nsMenuBarListener(nsMenuBarFrame* aMenuBar);
-  /** default destructor
-   */
-  virtual ~nsMenuBarListener();
-   
-  virtual nsresult HandleEvent(nsIDOMEvent* aEvent);
-  
-  virtual nsresult KeyUp(nsIDOMEvent* aMouseEvent);
-  virtual nsresult KeyDown(nsIDOMEvent* aMouseEvent);
-  virtual nsresult KeyPress(nsIDOMEvent* aMouseEvent);
-  
-  NS_DECL_ISUPPORTS
-
-protected:
-  nsMenuBarFrame* mMenuBarFrame; // The menu bar object.
-  PRBool mAltKeyDown;            // Whether or not the ALT key is currently down.
-};
-
-
-#endif

mozilla/layout/xul/base/src/nsMenuDismissalListener.cpp

@@ -1,140 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-#include "nsMenuDismissalListener.h"
-#include "nsIMenuParent.h"
-#include "nsMenuFrame.h"
-
-/*
- * nsMenuDismissalListener implementation
- */
-
-NS_IMPL_ADDREF(nsMenuDismissalListener)
-NS_IMPL_RELEASE(nsMenuDismissalListener)
-
-
-////////////////////////////////////////////////////////////////////////
-
-nsMenuDismissalListener::nsMenuDismissalListener() :
-  mWidget(0), mEnabled(PR_TRUE)
-{
-  NS_INIT_REFCNT();
-  mMenuParent = nsnull;
-}
-
-////////////////////////////////////////////////////////////////////////
-nsMenuDismissalListener::~nsMenuDismissalListener() 
-{
-}
-
-////////////////////////////////////////////////////////////////////////
-nsresult
-nsMenuDismissalListener::QueryInterface(REFNSIID aIID, void** aInstancePtr)
-{
-  if (nsnull == aInstancePtr) {
-    return NS_ERROR_NULL_POINTER;
-  }
-
-  if (aIID.Equals(nsCOMTypeInfo<nsIDOMEventReceiver>::GetIID())) {
-    *aInstancePtr = (void*)(nsIDOMEventListener*)(nsIDOMKeyListener*)this;
-    NS_ADDREF_THIS();
-    return NS_OK;
-  }
-  if (aIID.Equals(nsCOMTypeInfo<nsIDOMMouseListener>::GetIID())) {
-    *aInstancePtr = (void*)(nsIDOMMouseListener*)this;
-    NS_ADDREF_THIS();
-    return NS_OK;
-  }
-  if (aIID.Equals(nsCOMTypeInfo<nsIRollupListener>::GetIID())) {
-    *aInstancePtr = (void*)(nsIRollupListener*)this;
-    NS_ADDREF_THIS();
-    return NS_OK;
-  }
-  if (aIID.Equals(nsCOMTypeInfo<nsISupports>::GetIID())) {                                      
-    *aInstancePtr = (void*)(nsISupports*)(nsIDOMMouseListener*)this;                        
-    NS_ADDREF_THIS();                                                    
-    return NS_OK;                                                        
-  }
-  return NS_NOINTERFACE;
-}
-
-////////////////////////////////////////////////////////////////////////
-nsresult
-nsMenuDismissalListener::MouseDown(nsIDOMEvent* aMouseEvent)
-{
-  return NS_OK;
-}
-
-void
-nsMenuDismissalListener::SetCurrentMenuParent(nsIMenuParent* aMenuParent)
-{
-  if (aMenuParent == mMenuParent)
-    return;
-
-  nsCOMPtr<nsIRollupListener> kungFuDeathGrip = this;
-  Unregister();
-  
-  mMenuParent = aMenuParent;
-  if (!aMenuParent)
-    return;
-
-  nsCOMPtr<nsIWidget> widget;
-  aMenuParent->GetWidget(getter_AddRefs(widget));
-  if (!widget)
-    return;
-
-  widget->CaptureRollupEvents(this, PR_TRUE, PR_FALSE);
-  mWidget = widget;
-
-  NS_ADDREF(nsMenuFrame::mDismissalListener = this);
-}
-
-NS_IMETHODIMP
-nsMenuDismissalListener::Rollup()
-{
-  if (mEnabled) {
-    if (mMenuParent) {
-      AddRef();
-      mMenuParent->HideChain();
-      mMenuParent->DismissChain();
-      Release();
-    }
-    else
-      Unregister();
-  }
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsMenuDismissalListener::Unregister()
-{
-  if (mWidget)
-    mWidget->CaptureRollupEvents(this, PR_FALSE, PR_FALSE);    
-  
-  NS_RELEASE(nsMenuFrame::mDismissalListener);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsMenuDismissalListener::EnableListener(PRBool aEnabled)
-{
-  mEnabled = aEnabled;
-  return NS_OK;
-}
-

mozilla/layout/xul/base/src/nsMenuDismissalListener.h

@@ -1,67 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-#ifndef nsMenuDismissalListener_h__
-#define nsMenuDismissalListener_h__
-
-#include "nsIWidget.h"
-#include "nsIDOMMouseListener.h"
-#include "nsIRollupListener.h"
-#include "nsIDOMEventReceiver.h"
-
-class nsMenuPopupFrame;
-class nsIPresContext;
-class nsIMenuParent;
-
-/** editor Implementation of the DragListener interface
- */
-class nsMenuDismissalListener : public nsIDOMMouseListener, public nsIRollupListener
-{
-public:
-  /** default constructor
-   */
-  nsMenuDismissalListener();
-  
-  /** default destructor
-   */
-  virtual ~nsMenuDismissalListener();
-   
-  virtual nsresult HandleEvent(nsIDOMEvent* aEvent) { return NS_OK; };
-  
-  virtual nsresult MouseDown(nsIDOMEvent* aMouseEvent);
-  virtual nsresult MouseUp(nsIDOMEvent* aMouseEvent) { return NS_OK; };
-  virtual nsresult MouseClick(nsIDOMEvent* aMouseEvent) { return NS_OK; };
-  virtual nsresult MouseDblClick(nsIDOMEvent* aMouseEvent) { return NS_OK; };
-  virtual nsresult MouseOver(nsIDOMEvent* aMouseEvent) { return NS_OK; };
-  virtual nsresult MouseOut(nsIDOMEvent* aMouseEvent) { return NS_OK; };
-  
-  NS_IMETHOD Rollup();
-  NS_DECL_ISUPPORTS
-
-  NS_IMETHOD EnableListener(PRBool aEnabled);
-  void SetCurrentMenuParent(nsIMenuParent* aMenuParent);
-  NS_IMETHOD Unregister();
-  
-protected:
-  nsIMenuParent* mMenuParent;
-  nsIWidget* mWidget;
-  PRBool mEnabled;
-};
-
-
-#endif

mozilla/layout/xul/base/src/nsMenuFrame.h

@@ -1,199 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-//
-// nsMenuFrame
-//
-
-#ifndef nsMenuFrame_h__
-#define nsMenuFrame_h__
-
-#include "prtypes.h"
-#include "nsIAtom.h"
-#include "nsCOMPtr.h"
-
-#include "nsIAnonymousContentCreator.h"
-#include "nsBoxFrame.h"
-#include "nsFrameList.h"
-#include "nsIMenuParent.h"
-#include "nsIMenuFrame.h"
-#include "nsMenuDismissalListener.h"
-#include "nsITimer.h"
-#include "nsITimerCallback.h"
-#include "nsISupportsArray.h"
-#include "nsIDOMText.h"
-#include "nsIContent.h"
-
-nsresult NS_NewMenuFrame(nsIFrame** aResult, PRUint32 aFlags) ;
-
-class nsMenuBarFrame;
-class nsMenuPopupFrame;
-
-class nsMenuFrame : public nsBoxFrame, 
-                    public nsIMenuFrame,
-                    public nsITimerCallback, 
-                    public nsIAnonymousContentCreator
-{
-public:
-  nsMenuFrame();
-
-  NS_DECL_ISUPPORTS
-  
-  // The nsIAnonymousContentCreator interface
-  NS_IMETHOD CreateAnonymousContent(nsISupportsArray& aAnonymousItems);
-  
-  // The nsITimerCallback interface
-  virtual void Notify(nsITimer *timer);
-
-  NS_IMETHOD Init(nsIPresContext&  aPresContext,
-                  nsIContent*      aContent,
-                  nsIFrame*        aParent,
-                  nsIStyleContext* aContext,
-                  nsIFrame*        aPrevInFlow);
-
-  NS_IMETHOD IsActive(PRBool& aResult) { aResult = PR_TRUE; return NS_OK; };
-
-  // The following four methods are all overridden so that the menu children
-  // can be stored in a separate list (so that they don't impact reflow of the
-  // actual menu item at all).
-  NS_IMETHOD FirstChild(nsIAtom*   aListName,
-                        nsIFrame** aFirstChild) const;
-  NS_IMETHOD SetInitialChildList(nsIPresContext& aPresContext,
-                                 nsIAtom*        aListName,
-                                 nsIFrame*       aChildList);
-  NS_IMETHOD GetAdditionalChildListName(PRInt32   aIndex,
-                                        nsIAtom** aListName) const;
-  NS_IMETHOD Destroy(nsIPresContext& aPresContext);
-
-  // Overridden to prevent events from ever going to children of the menu.
-  NS_IMETHOD GetFrameForPoint(nsIPresContext* aPresContext,
-                              const nsPoint& aPoint, 
-                              nsIFrame**     aFrame);
-
-  NS_IMETHOD HandleEvent(nsIPresContext& aPresContext, 
-                         nsGUIEvent*     aEvent,
-                         nsEventStatus&  aEventStatus);
-
-  // Reflow methods
-  NS_IMETHOD Reflow(nsIPresContext&   aPresContext,
-                    nsHTMLReflowMetrics&     aDesiredSize,
-                    const nsHTMLReflowState& aReflowState,
-                    nsReflowStatus&          aStatus);
-  NS_IMETHOD DidReflow(nsIPresContext& aPresContext,
-                            nsDidReflowStatus aStatus);
-
-  NS_IMETHOD Dirty(nsIPresContext& aPresContext, const nsHTMLReflowState& aReflowState, nsIFrame*& incrementalChild);
-
-  NS_IMETHOD  AppendFrames(nsIPresContext& aPresContext,
-                           nsIPresShell&   aPresShell,
-                           nsIAtom*        aListName,
-                           nsIFrame*       aFrameList);
-
-  NS_IMETHOD  InsertFrames(nsIPresContext& aPresContext,
-                           nsIPresShell&   aPresShell,
-                           nsIAtom*        aListName,
-                           nsIFrame*       aPrevFrame,
-                           nsIFrame*       aFrameList);
-
-  NS_IMETHOD  RemoveFrame(nsIPresContext& aPresContext,
-                          nsIPresShell&   aPresShell,
-                          nsIAtom*        aListName,
-                          nsIFrame*       aOldFrame);
-
-  // nsIMenuFrame Interface
-
-  NS_IMETHOD ActivateMenu(PRBool aActivateFlag);
-  NS_IMETHOD SelectMenu(PRBool aActivateFlag);
-  NS_IMETHOD OpenMenu(PRBool aActivateFlag);
-
-  NS_IMETHOD MenuIsOpen(PRBool& aResult) { aResult = IsOpen(); return NS_OK; };
-  NS_IMETHOD MenuIsContainer(PRBool& aResult) { aResult = IsMenu(); return NS_OK; };
-  NS_IMETHOD MenuIsChecked(PRBool& aResult) { aResult = mChecked; return NS_OK; };
-  
-  NS_IMETHOD SelectFirstItem();
-
-  NS_IMETHOD Escape(PRBool& aHandledFlag);
-  NS_IMETHOD Enter();
-  NS_IMETHOD ShortcutNavigation(PRUint32 aLetter, PRBool& aHandledFlag);
-  NS_IMETHOD KeyboardNavigation(PRUint32 aDirection, PRBool& aHandledFlag);
-
-  NS_IMETHOD GetMenuParent(nsIMenuParent** aResult) { NS_IF_ADDREF(mMenuParent); *aResult = mMenuParent; return NS_OK; };
-  NS_IMETHOD GetRadioGroupName(nsString &aName) { aName = mGroupName; return NS_OK; };
-  NS_IMETHOD GetMenuType(nsMenuType &aType) { aType = mType; return NS_OK; };
-
-  NS_IMETHOD MarkAsGenerated();
-
-  // nsMenuFrame methods 
-
-  PRBool IsOpen() { return mMenuOpen; };
-  PRBool IsMenu();
-  PRBool IsDisabled();
-  PRBool IsGenerated();
-  NS_IMETHOD ToggleMenuState();
-
-  void SetIsMenu(PRBool aIsMenu) { mIsMenu = aIsMenu; };
-
-protected:
-  static void UpdateDismissalListener(nsIMenuParent* aMenuParent);
-  void UpdateMenuType();
-  void UpdateMenuSpecialState();
-
-  void OpenMenuInternal(PRBool aActivateFlag);
-  void GetMenuChildrenElement(nsIContent** aResult);
-
-  // Called to split the accesskey attribute up based on the specified string.
-  void SplitOnShortcut(nsString& aBeforeString, nsString& aAccessString, nsString& aAfterString);
-
-  // Examines the key node and builds the accelerator.
-  void BuildAcceleratorText(nsString& aAccelString);
-
-  // Called to execute our command handler.
-  void Execute();
-
-  // Called as a hook just before the menu gets opened.
-  PRBool OnCreate();
-
-  // Called as a hook just before the menu goes away.
-  PRBool OnDestroy();
-
-  NS_IMETHOD AttributeChanged(nsIPresContext* aPresContext,
-                              nsIContent* aChild,
-                              PRInt32 aNameSpaceID,
-                              nsIAtom* aAttribute,
-                              PRInt32 aHint);
-
-protected:
-  nsFrameList mPopupFrames;
-  PRPackedBool mIsMenu; // Whether or not we can even have children or not.
-  PRPackedBool mMenuOpen;
-  PRPackedBool mHasAnonymousContent;  // Do we have anonymous content frames?
-  PRPackedBool mChecked;              // if so, are we checked?
-  nsMenuType mType;
-
-  nsCOMPtr<nsIContent> mMenuText;
-  nsCOMPtr<nsIContent> mAccelText;
-  nsIMenuParent* mMenuParent; // Our parent menu.
-  nsCOMPtr<nsITimer> mOpenTimer;
-  nsIPresContext* mPresContext; // Our pres context.
-  nsString mGroupName;
-
-public:
-  static nsMenuDismissalListener* mDismissalListener; // The listener that dismisses menus.
-}; // class nsMenuFrame
-
-#endif

mozilla/layout/xul/base/src/nsMenuPopupFrame.cpp

@@ -1,757 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-
-#include "nsMenuPopupFrame.h"
-#include "nsXULAtoms.h"
-#include "nsHTMLAtoms.h"
-#include "nsIContent.h"
-#include "prtypes.h"
-#include "nsIAtom.h"
-#include "nsIPresContext.h"
-#include "nsIStyleContext.h"
-#include "nsCSSRendering.h"
-#include "nsINameSpaceManager.h"
-#include "nsIViewManager.h"
-#include "nsWidgetsCID.h"
-#include "nsMenuFrame.h"
-#include "nsIPopupSetFrame.h"
-
-const PRInt32 kMaxZ = 0x7fffffff; //XXX: Shouldn't there be a define somewhere for MaxInt for PRInt32
-
-static NS_DEFINE_IID(kIFrameIID, NS_IFRAME_IID);
-
-// NS_NewMenuPopupFrame
-//
-// Wrapper for creating a new menu popup container
-//
-nsresult
-NS_NewMenuPopupFrame(nsIFrame** aNewFrame)
-{
-  NS_PRECONDITION(aNewFrame, "null OUT ptr");
-  if (nsnull == aNewFrame) {
-    return NS_ERROR_NULL_POINTER;
-  }
-  nsMenuPopupFrame* it = new nsMenuPopupFrame;
-  if ( !it )
-    return NS_ERROR_OUT_OF_MEMORY;
-  *aNewFrame = it;
-  return NS_OK;
-}
-
-NS_IMETHODIMP_(nsrefcnt) 
-nsMenuPopupFrame::AddRef(void)
-{
-  return NS_OK;
-}
-
-NS_IMETHODIMP_(nsrefcnt) 
-nsMenuPopupFrame::Release(void)
-{
-    return NS_OK;
-}
-
-NS_IMETHODIMP nsMenuPopupFrame::QueryInterface(REFNSIID aIID, void** aInstancePtr)      
-{           
-  if (NULL == aInstancePtr) {                                            
-    return NS_ERROR_NULL_POINTER;                                        
-  }                                                                      
-                                                                         
-  *aInstancePtr = NULL;                                                  
-                                                                                        
-  if (aIID.Equals(nsIMenuParent::GetIID())) {                                         
-    *aInstancePtr = (void*)(nsIMenuParent*) this;                                        
-    NS_ADDREF_THIS();                                                    
-    return NS_OK;                                                        
-  }   
-
-  return nsBoxFrame::QueryInterface(aIID, aInstancePtr);                                     
-}
-
-
-//
-// nsMenuPopupFrame cntr
-//
-nsMenuPopupFrame::nsMenuPopupFrame()
-:mCurrentMenu(nsnull)
-{
-
-} // cntr
-
-NS_IMETHODIMP
-nsMenuPopupFrame::Init(nsIPresContext&  aPresContext,
-                       nsIContent*      aContent,
-                       nsIFrame*        aParent,
-                       nsIStyleContext* aContext,
-                       nsIFrame*        aPrevInFlow)
-{
-  nsresult rv = nsBoxFrame::Init(aPresContext, aContent, aParent, aContext, aPrevInFlow);
-
-  // XXX Hack
-  mPresContext = &aPresContext;
-
-  // We default to being vertical.
-  nsString value;
-  mContent->GetAttribute(kNameSpaceID_None, nsHTMLAtoms::align, value);
-  mHorizontal = PR_FALSE;
-  if (value.EqualsIgnoreCase("vertical"))
-    mHorizontal = PR_FALSE;
-  else if (value.EqualsIgnoreCase("horizontal"))
-    mHorizontal = PR_TRUE;
-
-  CreateViewForFrame(aPresContext, this, aContext, PR_TRUE);
-
-  // Now that we've made a view, remove it and insert it at the correct
-  // position in the view hierarchy (as the root view).  We do this so that we
-  // can draw the menus outside the confines of the window.
-  nsIView* ourView;
-  GetView(&aPresContext, &ourView);
-
-  nsIFrame* parent;
-  aParent->GetParentWithView(&aPresContext, &parent);
-  nsIView* parentView;
-  parent->GetView(&aPresContext, &parentView);
-
-  nsCOMPtr<nsIViewManager> viewManager;
-  parentView->GetViewManager(*getter_AddRefs(viewManager));
-
-  // Remove the view from its old position.
-  viewManager->RemoveChild(parentView, ourView);
-
-  // Reinsert ourselves as the root view with a maximum z-index.
-  nsIView* rootView;
-  viewManager->GetRootView(rootView);
-  viewManager->InsertChild(rootView, ourView, kMaxZ);
-
-  // XXX Hack. Change our transparency to be non-transparent
-  // until the bug related to update of transparency on show/hide
-  // is fixed.
-  viewManager->SetViewContentTransparency(ourView, PR_FALSE);
-
-  // Create a widget for ourselves.
-  nsWidgetInitData widgetData;
-  ourView->SetZIndex(kMaxZ);
-  widgetData.mWindowType = eWindowType_popup;
-  widgetData.mBorderStyle = eBorderStyle_default;
-
-  // XXX make sure we are hidden (shouldn't this be done automatically?)
-  ourView->SetVisibility(nsViewVisibility_kHide);
-#ifdef XP_MAC
-  printf("XP Popups: This is a nag to indicate that an inconsistent hack is being done on the Mac for popups.\n");
-  static NS_DEFINE_IID(kCPopupCID,  NS_POPUP_CID);
-  ourView->CreateWidget(kCPopupCID, &widgetData, nsnull);
-#else
-  static NS_DEFINE_IID(kCChildCID,  NS_CHILD_CID);
-  ourView->CreateWidget(kCChildCID, &widgetData, nsnull);
-#endif   
-
-  return rv;
-}
-
-void
-nsMenuPopupFrame::GetViewOffset(nsIViewManager* aManager, nsIView* aView, 
-  nsPoint& aPoint)
-{
-  aPoint.x = 0;
-  aPoint.y = 0;
- 
-  nsIView *parent;
-  nsRect bounds;
-
-  parent = aView;
-  while (nsnull != parent) {
-    parent->GetBounds(bounds);
-    aPoint.x += bounds.x;
-    aPoint.y += bounds.y;
-    parent->GetParent(parent);
-  }
-}
-
-void
-nsMenuPopupFrame::GetNearestEnclosingView(nsIPresContext* aPresContext, nsIFrame* aStartFrame, nsIView** aResult)
-{
-  *aResult = nsnull;
-  aStartFrame->GetView(aPresContext, aResult);
-  if (!*aResult) {
-    nsIFrame* parent;
-    aStartFrame->GetParentWithView(aPresContext, &parent);
-    if (parent)
-      parent->GetView(aPresContext, aResult);
-  }
-}
-
-nsresult 
-nsMenuPopupFrame::SyncViewWithFrame(nsIPresContext& aPresContext,
-                                    PRBool aOnMenuBar, 
-                                    nsIFrame* aFrame, 
-                                    PRInt32 aXPos, PRInt32 aYPos)
-{
-  nsPoint parentPos;
-  nsCOMPtr<nsIViewManager> viewManager;
-
-  //Get the nearest enclosing parent view to aFrame.
-  nsIView* parentView = nsnull;
-  GetNearestEnclosingView(&aPresContext, aFrame, &parentView);
-  if (!parentView)
-    return NS_OK;
-
-  parentView->GetViewManager(*getter_AddRefs(viewManager));
-  GetViewOffset(viewManager, parentView, parentPos);
-  nsIView* view = nsnull;
-  GetView(&aPresContext, &view);
-
-  nsIView* containingView = nsnull;
-  nsPoint offset;
-  aFrame->GetOffsetFromView(&aPresContext, offset, &containingView);
-  
-  nsRect parentRect;
-  aFrame->GetRect(parentRect);
-
-  const nsStyleDisplay* disp; 
-  GetStyleData(eStyleStruct_Display, (const nsStyleStruct*&) disp);
-  PRBool viewIsVisible = (NS_STYLE_VISIBILITY_VISIBLE == disp->mVisible);
-  nsViewVisibility  oldVisibility;
-  view->GetVisibility(oldVisibility);
-  PRBool viewWasVisible = (oldVisibility == nsViewVisibility_kShow);
-
-  if (viewWasVisible && (! viewIsVisible)) {
-    view->SetVisibility(nsViewVisibility_kHide);
-  }
-
-  viewManager->ResizeView(view, mRect.width, mRect.height);
-  if (aXPos != -1 || aYPos != -1) {
-    // Convert the screen coords to twips
-    float p2t;
-    aPresContext.GetScaledPixelsToTwips(&p2t);
-    PRInt32 xpos = NSIntPixelsToTwips(aXPos, p2t);
-    PRInt32 ypos = NSIntPixelsToTwips(aYPos, p2t);
-    viewManager->MoveViewTo(view, xpos, ypos);
-  }
-
-  else if (aOnMenuBar)
-    viewManager->MoveViewTo(view, parentPos.x + offset.x, parentPos.y + parentRect.height + offset.y );
-  else viewManager->MoveViewTo(view, parentPos.x + parentRect.width + offset.x, parentPos.y + offset.y );
-
-  if ((! viewWasVisible) && viewIsVisible) {
-    view->SetVisibility(nsViewVisibility_kShow);
-  }
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsMenuPopupFrame::DidReflow(nsIPresContext& aPresContext,
-                            nsDidReflowStatus aStatus)
-{
-  // Copied from nsContainerFrame reflow WITHOUT the call
-  // nsFrame::DidReflow().  nsFrame::DidReflow() will move us to the
-  // wrong place.
-  nsresult result = NS_OK; /* = nsFrame::DidReflow(aPresContext, aStatus) */
-
-  if (NS_FRAME_REFLOW_FINISHED == aStatus) {
-    // Apply DidReflow to each and every list that this frame implements
-    nsIAtom* listName = nsnull;
-    PRInt32 listIndex = 0;
-    do {
-      nsIFrame* kid;
-      FirstChild(listName, &kid);
-      while (nsnull != kid) {
-        kid->DidReflow(aPresContext, aStatus);
-        kid->GetNextSibling(&kid);
-      }
-      NS_IF_RELEASE(listName);
-      GetAdditionalChildListName(listIndex++, &listName);
-    } while(nsnull != listName);
-  }
-
-  NS_FRAME_TRACE_OUT("nsContainerFrame::DidReflow");
-  return result;
-}
-
-NS_IMETHODIMP
-nsMenuPopupFrame::GetNextMenuItem(nsIMenuFrame* aStart, nsIMenuFrame** aResult)
-{
-  nsIFrame* currFrame = nsnull;
-  nsIFrame* startFrame = nsnull;
-  if (aStart) {
-    aStart->QueryInterface(kIFrameIID, (void**)&currFrame); 
-    if (currFrame) {
-      startFrame = currFrame;
-      currFrame->GetNextSibling(&currFrame);
-    }
-  }
-  else currFrame = mFrames.FirstChild();
-  
-  while (currFrame) {
-    nsCOMPtr<nsIContent> current;
-    currFrame->GetContent(getter_AddRefs(current));
-
-    // See if it's a menu item.
-    if (IsValidItem(current)) {
-      nsCOMPtr<nsIMenuFrame> menuFrame = do_QueryInterface(currFrame);
-      *aResult = menuFrame.get();
-      NS_IF_ADDREF(*aResult);
-      return NS_OK;
-    }
-    currFrame->GetNextSibling(&currFrame);
-  }
-
-  currFrame = mFrames.FirstChild();
-
-  // Still don't have anything. Try cycling from the beginning.
-  while (currFrame && currFrame != startFrame) {
-    nsCOMPtr<nsIContent> current;
-    currFrame->GetContent(getter_AddRefs(current));
-    
-    // See if it's a menu item.
-    if (IsValidItem(current)) {
-      nsCOMPtr<nsIMenuFrame> menuFrame = do_QueryInterface(currFrame);
-      *aResult = menuFrame.get();
-      NS_IF_ADDREF(*aResult);
-      return NS_OK;
-    }
-
-    currFrame->GetNextSibling(&currFrame);
-  }
-
-  // No luck. Just return our start value.
-  *aResult = aStart;
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsMenuPopupFrame::GetPreviousMenuItem(nsIMenuFrame* aStart, nsIMenuFrame** aResult)
-{
-  nsIFrame* currFrame = nsnull;
-  nsIFrame* startFrame = nsnull;
-  if (aStart) {
-    aStart->QueryInterface(kIFrameIID, (void**)&currFrame);
-    if (currFrame) {
-      startFrame = currFrame;
-      currFrame = mFrames.GetPrevSiblingFor(currFrame);
-    }
-  }
-  else currFrame = mFrames.LastChild();
-
-  while (currFrame) {
-    nsCOMPtr<nsIContent> current;
-    currFrame->GetContent(getter_AddRefs(current));
-
-    // See if it's a menu item.
-    if (IsValidItem(current)) {
-      nsCOMPtr<nsIMenuFrame> menuFrame = do_QueryInterface(currFrame);
-      *aResult = menuFrame.get();
-      NS_IF_ADDREF(*aResult);
-      return NS_OK;
-    }
-    currFrame = mFrames.GetPrevSiblingFor(currFrame);
-  }
-
-  currFrame = mFrames.LastChild();
-
-  // Still don't have anything. Try cycling from the end.
-  while (currFrame && currFrame != startFrame) {
-    nsCOMPtr<nsIContent> current;
-    currFrame->GetContent(getter_AddRefs(current));
-    
-    // See if it's a menu item.
-    if (IsValidItem(current)) {
-      nsCOMPtr<nsIMenuFrame> menuFrame = do_QueryInterface(currFrame);
-      *aResult = menuFrame.get();
-      NS_IF_ADDREF(*aResult);
-      return NS_OK;
-    }
-
-    currFrame = mFrames.GetPrevSiblingFor(currFrame);
-  }
-
-  // No luck. Just return our start value.
-  *aResult = aStart;
-  return NS_OK;
-}
-
-NS_IMETHODIMP nsMenuPopupFrame::SetCurrentMenuItem(nsIMenuFrame* aMenuItem)
-{
-  if (mCurrentMenu == aMenuItem)
-    return NS_OK;
-  
-  // Unset the current child.
-  if (mCurrentMenu) {
-    PRBool isOpen = PR_FALSE;
-    mCurrentMenu->MenuIsOpen(isOpen);
-    mCurrentMenu->SelectMenu(PR_FALSE);
-    if (isOpen)
-      mCurrentMenu->OpenMenu(PR_FALSE);
-
-  }
-
-  // Set the new child.
-  if (aMenuItem) {
-    aMenuItem->SelectMenu(PR_TRUE);
-  }
-
-  mCurrentMenu = aMenuItem;
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsMenuPopupFrame::CaptureMouseEvents(nsIPresContext* aPresContext, PRBool aGrabMouseEvents)
-{
-  // get its view
-  nsIView* view = nsnull;
-  GetView(aPresContext, &view);
-  nsCOMPtr<nsIViewManager> viewMan;
-  PRBool result;
-
-  nsCOMPtr<nsIWidget> widget;
-
-  if (view) {
-    view->GetViewManager(*getter_AddRefs(viewMan));
-    if (viewMan) {
-      view->GetWidget(*getter_AddRefs(widget));
-      if (aGrabMouseEvents) {
-        viewMan->GrabMouseEvents(view,result);
-        mIsCapturingMouseEvents = PR_TRUE;
-        //widget->CaptureMouse(PR_TRUE);
-      } else {
-        viewMan->GrabMouseEvents(nsnull,result);
-        mIsCapturingMouseEvents = PR_FALSE;
-        //widget->CaptureMouse(PR_FALSE);
-      }
-    }
-  }
-
-  return NS_OK;
-}
-
-void
-nsMenuPopupFrame::Escape(PRBool& aHandledFlag)
-{
-  if (!mCurrentMenu)
-    return;
-
-  // See if our menu is open.
-  PRBool isOpen = PR_FALSE;
-  mCurrentMenu->MenuIsOpen(isOpen);
-  if (isOpen) {
-    // Let the child menu handle this.
-    mCurrentMenu->Escape(aHandledFlag);
-    if (!aHandledFlag) {
-      // We should close up.
-      mCurrentMenu->OpenMenu(PR_FALSE);
-      aHandledFlag = PR_TRUE;
-    }
-    return;
-  }
-}
-
-void
-nsMenuPopupFrame::Enter()
-{
-  // Give it to the child.
-  if (mCurrentMenu)
-    mCurrentMenu->Enter();
-}
-
-nsIMenuFrame*
-nsMenuPopupFrame::FindMenuWithShortcut(PRUint32 aLetter)
-{
-  // Enumerate over our list of frames.
-  nsIFrame* currFrame = mFrames.FirstChild();
-  while (currFrame) {
-    nsCOMPtr<nsIContent> current;
-    currFrame->GetContent(getter_AddRefs(current));
-    
-    // See if it's a menu item.
-    if (IsValidItem(current)) {
-      // Get the shortcut attribute.
-      nsString shortcutKey = "";
-      current->GetAttribute(kNameSpaceID_None, nsXULAtoms::accesskey, shortcutKey);
-      shortcutKey.ToUpperCase();
-      if (shortcutKey.Length() > 0) {
-        // We've got something.
-        PRUnichar shortcutChar = shortcutKey.CharAt(0);
-        if (shortcutChar == aLetter) {
-          // We match!
-          nsCOMPtr<nsIMenuFrame> menuFrame = do_QueryInterface(currFrame);
-          if (menuFrame)
-            return menuFrame.get();
-          return nsnull;
-        }
-      }
-    }
-    currFrame->GetNextSibling(&currFrame);
-  }
-  return nsnull;
-}
-
-void 
-nsMenuPopupFrame::ShortcutNavigation(PRUint32 aLetter, PRBool& aHandledFlag)
-{
-  if (mCurrentMenu) {
-    PRBool isOpen = PR_FALSE;
-    mCurrentMenu->MenuIsOpen(isOpen);
-    if (isOpen) {
-      // No way this applies to us. Give it to our child.
-      mCurrentMenu->ShortcutNavigation(aLetter, aHandledFlag);
-      return;
-    }
-  }
-
-  // This applies to us. Let's see if one of the shortcuts applies
-  nsIMenuFrame* result = FindMenuWithShortcut(aLetter);
-  if (result) {
-    // We got one!
-    aHandledFlag = PR_TRUE;
-    SetCurrentMenuItem(result);
-    result->OpenMenu(PR_TRUE);
-    result->SelectFirstItem();
-
-    // XXX For menu items, do an execution of the oncommand handler!
-    // Still needed or did I do this already? I'm going senile. - Dave
-  }
-}
-
-void
-nsMenuPopupFrame::KeyboardNavigation(PRUint32 aDirection, PRBool& aHandledFlag)
-{
-  // This method only gets called if we're open.
-  if (!mCurrentMenu && (aDirection == NS_VK_RIGHT || aDirection == NS_VK_LEFT)) {
-    // We've been opened, but we haven't had anything selected.
-    // We can handle RIGHT, but our parent handles LEFT.
-    if (aDirection == NS_VK_RIGHT) {
-      nsIMenuFrame* nextItem;
-      GetNextMenuItem(nsnull, &nextItem);
-      if (nextItem) {
-        aHandledFlag = PR_TRUE;
-        SetCurrentMenuItem(nextItem);
-      }
-    }
-    return;
-  }
-
-  PRBool isContainer = PR_FALSE;
-  PRBool isOpen = PR_FALSE;
-  if (mCurrentMenu) {
-    mCurrentMenu->MenuIsContainer(isContainer);
-    mCurrentMenu->MenuIsOpen(isOpen);
-
-    if (isOpen) {
-      // Give our child a shot.
-      mCurrentMenu->KeyboardNavigation(aDirection, aHandledFlag);
-    }
-    else if (aDirection == NS_VK_RIGHT && isContainer) {
-      // The menu is not yet open. Open it and select the first item.
-      aHandledFlag = PR_TRUE;
-      mCurrentMenu->OpenMenu(PR_TRUE);
-      mCurrentMenu->SelectFirstItem();
-    }
-  }
-
-  if (aHandledFlag)
-    return; // The child menu took it for us.
-
-  // For the vertical direction, we can move up or down.
-  if (aDirection == NS_VK_UP || aDirection == NS_VK_DOWN) {
-    
-    nsIMenuFrame* nextItem;
-    
-    if (aDirection == NS_VK_DOWN)
-      GetNextMenuItem(mCurrentMenu, &nextItem);
-    else GetPreviousMenuItem(mCurrentMenu, &nextItem);
-
-    SetCurrentMenuItem(nextItem);
-
-    aHandledFlag = PR_TRUE;
-  }
-  else if (mCurrentMenu && isContainer && isOpen) {
-    if (aDirection == NS_VK_LEFT) {
-      // Close it up.
-      mCurrentMenu->OpenMenu(PR_FALSE);
-      aHandledFlag = PR_TRUE;
-    }
-  }
-}
-
-NS_IMETHODIMP
-nsMenuPopupFrame::GetParentPopup(nsIMenuParent** aMenuParent)
-{
-  *aMenuParent = nsnull;
-  nsIFrame* frame;
-  GetParent(&frame);
-  if (frame) {
-    nsIFrame* grandparent;
-    frame->GetParent(&grandparent);
-    if (grandparent) {
-      nsCOMPtr<nsIMenuParent> menuParent = do_QueryInterface(grandparent);
-      if (menuParent) {
-        *aMenuParent = menuParent.get();
-        NS_ADDREF(*aMenuParent);
-      }
-    }
-  }
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsMenuPopupFrame::HideChain()
-{
-  // Stop capturing rollups
-  // (must do this during Hide, which happens before the menu item is executed,
-  // since this reinstates normal event handling.)
-  if (nsMenuFrame::mDismissalListener)
-    nsMenuFrame::mDismissalListener->Unregister();
-  
-  nsIFrame* frame;
-  GetParent(&frame);
-  if (frame) {
-    nsCOMPtr<nsIPopupSetFrame> popupSetFrame = do_QueryInterface(frame);
-    if (popupSetFrame) {
-      // Destroy the popup.
-      popupSetFrame->HidePopup();
-      return NS_OK;
-    }
-    
-    nsCOMPtr<nsIMenuFrame> menuFrame = do_QueryInterface(frame);
-    if (!menuFrame)
-      return NS_OK;
-
-    menuFrame->ActivateMenu(PR_FALSE);
-    menuFrame->SelectMenu(PR_FALSE);
-
-    // Get the parent.
-    nsCOMPtr<nsIMenuParent> menuParent;
-    menuFrame->GetMenuParent(getter_AddRefs(menuParent));
-    if (menuParent)
-      menuParent->HideChain();
-  }
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsMenuPopupFrame::DismissChain()
-{
-  // Stop capturing rollups
-  if (nsMenuFrame::mDismissalListener)
-    nsMenuFrame::mDismissalListener->Unregister();
-  
-  // Get our menu parent.
-  nsIFrame* frame;
-  GetParent(&frame);
-  if (frame) {
-    nsCOMPtr<nsIPopupSetFrame> popupSetFrame = do_QueryInterface(frame);
-    if (popupSetFrame) {
-      // Destroy the popup.
-      popupSetFrame->DestroyPopup();
-      return NS_OK;
-    }
-
-    nsCOMPtr<nsIMenuFrame> menuFrame = do_QueryInterface(frame);
-    if (!menuFrame)
-      return NS_OK;
-    
-    menuFrame->OpenMenu(PR_FALSE);
-
-    // Get the parent.
-    nsCOMPtr<nsIMenuParent> menuParent;
-    menuFrame->GetMenuParent(getter_AddRefs(menuParent));
-    if (menuParent)
-      menuParent->DismissChain();
-  }
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsMenuPopupFrame::GetWidget(nsIWidget **aWidget)
-{
-  // Get parent view
-  nsIView * view = nsnull;
-  nsMenuPopupFrame::GetNearestEnclosingView(mPresContext, this, &view);
-  if (!view)
-    return NS_OK;
-
-  view->GetWidget(*aWidget);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsMenuPopupFrame::CreateDismissalListener()
-{
-  nsMenuDismissalListener *listener = new nsMenuDismissalListener();
-  if (!listener) return NS_ERROR_OUT_OF_MEMORY;
-  nsMenuFrame::mDismissalListener = listener;
-  NS_ADDREF(listener);
-  return NS_OK;
-}
-
-PRBool 
-nsMenuPopupFrame::IsValidItem(nsIContent* aContent)
-{
-  nsCOMPtr<nsIAtom> tag;
-  aContent->GetTag(*getter_AddRefs(tag));
-  if (tag && (tag.get() == nsXULAtoms::menu ||
-              tag.get() == nsXULAtoms::menuitem) &&
-      !IsDisabled(aContent))
-      return PR_TRUE;
-
-  return PR_FALSE;
-}
-
-PRBool 
-nsMenuPopupFrame::IsDisabled(nsIContent* aContent)
-{
-  nsString disabled = "";
-  aContent->GetAttribute(kNameSpaceID_None, nsHTMLAtoms::disabled, disabled);
-  if (disabled == "true")
-    return PR_TRUE;
-  return PR_FALSE;
-}
-
-NS_IMETHODIMP 
-nsMenuPopupFrame::HandleEvent(nsIPresContext& aPresContext, 
-                              nsGUIEvent*     aEvent,
-                              nsEventStatus&  aEventStatus)
-{
-  return nsBoxFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
-}
-
-NS_IMETHODIMP
-nsMenuPopupFrame::Destroy(nsIPresContext& aPresContext)
-{
-  //nsCOMPtr<nsIDOMEventReceiver> target = do_QueryInterface(mContent);
-  //target->RemoveEventListener("mousemove", mMenuPopupEntryListener, PR_TRUE);
-  return nsBoxFrame::Destroy(aPresContext);
-}
-
-NS_IMETHODIMP
-nsMenuPopupFrame::GetFrameForPoint(nsIPresContext* aPresContext,
-                                   const nsPoint& aPoint,
-                                   nsIFrame** aFrame)
-{
-  nsRect rect;
-  GetRect(rect);
-  if (rect.Contains(aPoint)) {
-    return nsBoxFrame::GetFrameForPoint(aPresContext, aPoint, aFrame);
-  }
-  
-  *aFrame = this;
-  return NS_OK;
-}

mozilla/layout/xul/base/src/nsMenuPopupFrame.h

@@ -1,113 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-//
-// nsMenuPopupFrame
-//
-
-#ifndef nsMenuPopupFrame_h__
-#define nsMenuPopupFrame_h__
-
-#include "prtypes.h"
-#include "nsIAtom.h"
-#include "nsCOMPtr.h"
-
-#include "nsBoxFrame.h"
-#include "nsIMenuParent.h"
-#include "nsIWidget.h"
-
-nsresult NS_NewMenuPopupFrame(nsIFrame** aResult) ;
-
-class nsIViewManager;
-class nsIView;
-class nsIMenuParent;
-class nsIMenuFrame;
-
-class nsMenuPopupFrame : public nsBoxFrame, public nsIMenuParent
-{
-public:
-  nsMenuPopupFrame();
-
-  NS_DECL_ISUPPORTS
-
-  // nsIMenuParentInterface
-  NS_IMETHOD SetCurrentMenuItem(nsIMenuFrame* aMenuItem);
-  NS_IMETHOD GetNextMenuItem(nsIMenuFrame* aStart, nsIMenuFrame** aResult);
-  NS_IMETHOD GetPreviousMenuItem(nsIMenuFrame* aStart, nsIMenuFrame** aResult);
-  NS_IMETHOD SetActive(PRBool aActiveFlag) { return NS_OK; }; // We don't care.
-  NS_IMETHOD GetIsActive(PRBool& isActive) { isActive = PR_FALSE; return NS_OK; };
-  NS_IMETHOD IsMenuBar(PRBool& isMenuBar) { isMenuBar = PR_FALSE; return NS_OK; };
-  
-  NS_IMETHOD GetParentPopup(nsIMenuParent** aResult);
-
-  // Closes up the chain of open cascaded menus.
-  NS_IMETHOD DismissChain();
-
-  // Hides the chain of cascaded menus without closing them up.
-  NS_IMETHOD HideChain();
-
-  NS_IMETHOD GetWidget(nsIWidget **aWidget);
-
-  // The dismissal listener gets created and attached to the window.
-  NS_IMETHOD CreateDismissalListener();
-
-  // Overridden methods
-  NS_IMETHOD Init(nsIPresContext&  aPresContext,
-                       nsIContent*      aContent,
-                       nsIFrame*        aParent,
-                       nsIStyleContext* aContext,
-                       nsIFrame*        aPrevInFlow);
-
-  NS_IMETHOD DidReflow(nsIPresContext& aPresContext,
-                       nsDidReflowStatus aStatus);
-
-  NS_IMETHOD HandleEvent(nsIPresContext& aPresContext, 
-                         nsGUIEvent*     aEvent,
-                         nsEventStatus&  aEventStatus);
-
-  NS_IMETHOD Destroy(nsIPresContext& aPresContext);
-
-  NS_IMETHOD GetFrameForPoint(nsIPresContext* aPresContext, const nsPoint& aPoint, nsIFrame** aFrame);
-
-  void GetViewOffset(nsIViewManager* aManager, nsIView* aView, nsPoint& aPoint);
-  static void GetNearestEnclosingView(nsIPresContext* aPresContext, nsIFrame* aStartFrame, nsIView** aResult);
-
-  nsresult SyncViewWithFrame(nsIPresContext& aPresContext, PRBool aOnMenuBar, 
-                             nsIFrame* aFrame, PRInt32 aXPos, PRInt32 aYPos);
-
-  NS_IMETHOD CaptureMouseEvents(nsIPresContext* aPresContext, PRBool aGrabMouseEvents);
-
-  void KeyboardNavigation(PRUint32 aDirection, PRBool& aHandledFlag);
-  
-  void ShortcutNavigation(PRUint32 aLetter, PRBool& aHandledFlag);
-  nsIMenuFrame* FindMenuWithShortcut(PRUint32 aLetter);
-
-  void Escape(PRBool& aHandledFlag);
-  void Enter();
-
-  PRBool IsValidItem(nsIContent* aContent);
-  PRBool IsDisabled(nsIContent* aContent);
-
-protected:
-  nsIMenuFrame* mCurrentMenu; // The current menu that is active.
-  PRBool mIsCapturingMouseEvents; // Whether or not we're grabbing the mouse events.
-  // XXX Hack
-  nsIPresContext* mPresContext;  // weak reference
-}; // class nsMenuPopupFrame
-
-#endif

mozilla/layout/xul/base/src/nsPopupSetFrame.cpp

@@ -1,547 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#include "nsXULAtoms.h"
-#include "nsHTMLAtoms.h"
-#include "nsPopupSetFrame.h"
-#include "nsIMenuParent.h"
-#include "nsMenuFrame.h"
-#include "nsBoxFrame.h"
-#include "nsIContent.h"
-#include "prtypes.h"
-#include "nsIAtom.h"
-#include "nsIPresContext.h"
-#include "nsIStyleContext.h"
-#include "nsIReflowCommand.h"
-#include "nsCSSRendering.h"
-#include "nsINameSpaceManager.h"
-#include "nsLayoutAtoms.h"
-#include "nsMenuPopupFrame.h"
-#include "nsMenuBarFrame.h"
-#include "nsIView.h"
-#include "nsIWidget.h"
-#include "nsIDocument.h"
-#include "nsIDOMNSDocument.h"
-#include "nsIDOMDocument.h"
-#include "nsIDOMXULDocument.h"
-#include "nsIDOMElement.h"
-#include "nsISupportsArray.h"
-#include "nsIDOMText.h"
-
-#define NS_MENU_POPUP_LIST_INDEX   (NS_AREA_FRAME_ABSOLUTE_LIST_INDEX + 1)
-
-//
-// NS_NewPopupSetFrame
-//
-// Wrapper for creating a new menu popup container
-//
-nsresult
-NS_NewPopupSetFrame(nsIFrame** aNewFrame)
-{
-  NS_PRECONDITION(aNewFrame, "null OUT ptr");
-  if (nsnull == aNewFrame) {
-    return NS_ERROR_NULL_POINTER;
-  }
-  nsPopupSetFrame* it = new nsPopupSetFrame;
-  if ( !it )
-    return NS_ERROR_OUT_OF_MEMORY;
-  *aNewFrame = it;
-  return NS_OK;
-}
-
-NS_IMETHODIMP_(nsrefcnt) 
-nsPopupSetFrame::AddRef(void)
-{
-  return NS_OK;
-}
-
-NS_IMETHODIMP_(nsrefcnt) 
-nsPopupSetFrame::Release(void)
-{
-    return NS_OK;
-}
-
-NS_IMETHODIMP nsPopupSetFrame::QueryInterface(REFNSIID aIID, void** aInstancePtr)      
-{           
-  if (NULL == aInstancePtr) {                                            
-    return NS_ERROR_NULL_POINTER;                                        
-  }   
-  
-  *aInstancePtr = NULL;                                                  
-                                                                                        
-  if (aIID.Equals(nsIPopupSetFrame::GetIID())) {                                         
-    *aInstancePtr = (void*)(nsIPopupSetFrame*) this;                                        
-    NS_ADDREF_THIS();                                                    
-    return NS_OK;                                                        
-  }   
-
-  return nsBoxFrame::QueryInterface(aIID, aInstancePtr);                                     
-}
-
-//
-// nsPopupSetFrame cntr
-//
-nsPopupSetFrame::nsPopupSetFrame()
-:mPresContext(nsnull), mElementFrame(nsnull)
-{
-
-} // cntr
-
-nsIFrame*
-nsPopupSetFrame::GetActiveChild()
-{
-  return mPopupFrames.FirstChild();
-}
-
-NS_IMETHODIMP
-nsPopupSetFrame::Init(nsIPresContext&  aPresContext,
-                     nsIContent*      aContent,
-                     nsIFrame*        aParent,
-                     nsIStyleContext* aContext,
-                     nsIFrame*        aPrevInFlow)
-{
-  mPresContext = &aPresContext; // Don't addref it.  Our lifetime is shorter.
-  nsresult  rv = nsBoxFrame::Init(aPresContext, aContent, aParent, aContext, aPrevInFlow);
-  return rv;
-}
-
-// The following methods are all overridden to ensure that the menupopup frames
-// are placed in the appropriate list.
-NS_IMETHODIMP
-nsPopupSetFrame::FirstChild(nsIAtom*   aListName,
-                        nsIFrame** aFirstChild) const
-{
-  if (nsLayoutAtoms::popupList == aListName) {
-    *aFirstChild = mPopupFrames.FirstChild();
-  } else {
-    nsBoxFrame::FirstChild(aListName, aFirstChild);
-  }
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsPopupSetFrame::SetInitialChildList(nsIPresContext& aPresContext,
-                                               nsIAtom*        aListName,
-                                               nsIFrame*       aChildList)
-{
-  nsresult rv = NS_OK;
-  if (nsLayoutAtoms::popupList == aListName) {
-    mPopupFrames.SetFrames(aChildList);
-  } else {
-
-    nsFrameList frames(aChildList);
-
-    // We may have menupopups in here. Get them out, and move them into
-    // the popup frame list.
-    nsIFrame* frame = frames.FirstChild();
-    while (frame) {
-      nsCOMPtr<nsIContent> content;
-      frame->GetContent(getter_AddRefs(content));
-      nsCOMPtr<nsIAtom> tag;
-      content->GetTag(*getter_AddRefs(tag));
-      if (tag.get() == nsXULAtoms::popup) {
-        // Remove this frame from the list and place it in the other list.
-        frames.RemoveFrame(frame);
-        mPopupFrames.AppendFrame(this, frame);
-        nsIFrame* first = frames.FirstChild();
-        rv = nsBoxFrame::SetInitialChildList(aPresContext, aListName, first);
-        return rv;
-      }
-      frame->GetNextSibling(&frame);
-    }
-
-    // Didn't find it.
-    rv = nsBoxFrame::SetInitialChildList(aPresContext, aListName, aChildList);
-  }
-  return rv;
-}
-
-NS_IMETHODIMP
-nsPopupSetFrame::GetAdditionalChildListName(PRInt32   aIndex,
-                                        nsIAtom** aListName) const
-{
-   // Maintain a separate child list for the menu contents.
-   // This is necessary because we don't want the menu contents to be included in the layout
-   // of the menu's single item because it would take up space, when it is supposed to
-   // be floating above the display.
-  /*NS_PRECONDITION(nsnull != aListName, "null OUT parameter pointer");
-  
-  *aListName = nsnull;
-  if (NS_MENU_POPUP_LIST_INDEX == aIndex) {
-    *aListName = nsLayoutAtoms::popupList;
-    NS_ADDREF(*aListName);
-    return NS_OK;
-  }*/
-  return nsBoxFrame::GetAdditionalChildListName(aIndex, aListName);
-}
-
-NS_IMETHODIMP
-nsPopupSetFrame::Destroy(nsIPresContext& aPresContext)
-{
-   // Cleanup frames in popup child list
-  mPopupFrames.DestroyFrames(aPresContext);
-  return nsBoxFrame::Destroy(aPresContext);
-}
-
-NS_IMETHODIMP
-nsPopupSetFrame::Reflow(nsIPresContext&   aPresContext,
-                    nsHTMLReflowMetrics&     aDesiredSize,
-                    const nsHTMLReflowState& aReflowState,
-                    nsReflowStatus&          aStatus)
-{
-  nsresult rv = nsBoxFrame::Reflow(aPresContext, aDesiredSize, aReflowState, aStatus);
-  nsIFrame* frame = GetActiveChild();
-    
-  if (!frame || (rv != NS_OK))
-    return rv;
-
-  // Constrain the child's width and height to aAvailableWidth and aAvailableHeight
-  nsSize availSize(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
-  nsHTMLReflowState kidReflowState(aPresContext, aReflowState, frame,
-                                   availSize);
-  kidReflowState.mComputedWidth = NS_UNCONSTRAINEDSIZE;
-  kidReflowState.mComputedHeight = NS_UNCONSTRAINEDSIZE;
-    
-   // Reflow child
-  nscoord w = aDesiredSize.width;
-  nscoord h = aDesiredSize.height;
-  
-  rv = ReflowChild(frame, aPresContext, aDesiredSize, kidReflowState, aStatus);
-
-   // Set the child's width and height to its desired size
-  nsRect rect;
-  frame->GetRect(rect);
-  rect.width = aDesiredSize.width;
-  rect.height = aDesiredSize.height;
-  frame->SetRect(&aPresContext, rect);
-
-  // Don't let it affect our size.
-  aDesiredSize.width = w;
-  aDesiredSize.height = h;
-  
-  return rv;
-}
-
-
-NS_IMETHODIMP
-nsPopupSetFrame::DidReflow(nsIPresContext& aPresContext,
-                            nsDidReflowStatus aStatus)
-{
-  // Sync up the view.
-  nsIFrame* activeChild = GetActiveChild();
-  if (activeChild) {
-    ((nsMenuPopupFrame*)activeChild)->SyncViewWithFrame(aPresContext, PR_TRUE, mElementFrame, mXPos, mYPos);
-  }
-
-  return nsBoxFrame::DidReflow(aPresContext, aStatus);
-}
-
-// Overridden Box method.
-NS_IMETHODIMP
-nsPopupSetFrame::Dirty(nsIPresContext& aPresContext,  const nsHTMLReflowState& aReflowState, nsIFrame*& incrementalChild)
-{
-  incrementalChild = nsnull;
-  nsresult rv = NS_OK;
-
-  // Dirty any children that need it.
-  nsIFrame* frame;
-  aReflowState.reflowCommand->GetNext(frame, PR_FALSE);
-  if (frame == nsnull) {
-    incrementalChild = this;
-    return rv;
-  }
-
-  // Now call our original box frame method
-  rv = nsBoxFrame::Dirty(aPresContext, aReflowState, incrementalChild);
-  if (rv != NS_OK || incrementalChild)
-    return rv;
-
-  nsIFrame* popup = GetActiveChild();
-  if (popup && (frame == popup)) {
-    // An incremental reflow command is targeting something inside our
-    // hidden popup view.  We can't actually return the child, since it
-    // won't ever be found by box.  Instead return ourselves, so that box
-    // will later send us an incremental reflow command.
-    incrementalChild = this;
-
-    // In order for the child box to know what it needs to reflow, we need
-    // to call its Dirty method...
-    nsIFrame* ignore;
-    nsIBox* ibox;
-    if (NS_SUCCEEDED(popup->QueryInterface(nsIBox::GetIID(), (void**)&ibox)) && ibox)
-      ibox->Dirty(aPresContext, aReflowState, ignore);
-  }
-
-  return rv;
-}
-
-NS_IMETHODIMP
-nsPopupSetFrame::RemoveFrame(nsIPresContext& aPresContext,
-                           nsIPresShell& aPresShell,
-                           nsIAtom* aListName,
-                           nsIFrame* aOldFrame)
-{
-  // need to rebuild all the springs.
-  for (int i=0; i < mSpringCount; i++) 
-    mSprings[i].clear();
-
-  nsresult  rv;
-  
-  if (mPopupFrames.ContainsFrame(aOldFrame)) {
-    // Go ahead and remove this frame.
-    mPopupFrames.DestroyFrame(aPresContext, aOldFrame);
-    rv = GenerateDirtyReflowCommand(aPresContext, aPresShell);
-  } else {
-    rv = nsBoxFrame::RemoveFrame(aPresContext, aPresShell, aListName, aOldFrame);
-  }
-
-  return rv;
-}
-
-NS_IMETHODIMP
-nsPopupSetFrame::InsertFrames(nsIPresContext& aPresContext,
-                            nsIPresShell& aPresShell,
-                            nsIAtom* aListName,
-                            nsIFrame* aPrevFrame,
-                            nsIFrame* aFrameList)
-{
-  // need to rebuild all the springs.
-  for (int i=0; i < mSpringCount; i++) 
-    mSprings[i].clear();
-
-  nsCOMPtr<nsIContent> frameChild;
-  aFrameList->GetContent(getter_AddRefs(frameChild));
-  nsCOMPtr<nsIAtom> tag;
-  nsresult          rv;
-  frameChild->GetTag(*getter_AddRefs(tag));
-  if (tag && tag.get() == nsXULAtoms::popup) {
-    mPopupFrames.InsertFrames(nsnull, nsnull, aFrameList);
-    rv = GenerateDirtyReflowCommand(aPresContext, aPresShell);
-  } else {
-    rv = nsBoxFrame::InsertFrames(aPresContext, aPresShell, aListName, aPrevFrame, aFrameList);  
-  }
-
-  return rv;
-}
-
-NS_IMETHODIMP
-nsPopupSetFrame::AppendFrames(nsIPresContext& aPresContext,
-                           nsIPresShell&   aPresShell,
-                           nsIAtom*        aListName,
-                           nsIFrame*       aFrameList)
-{
-  if (!aFrameList)
-    return NS_OK;
-
-  // need to rebuild all the springs.
-  for (int i=0; i < mSpringCount; i++) 
-    mSprings[i].clear();
-
-  nsCOMPtr<nsIContent> frameChild;
-  aFrameList->GetContent(getter_AddRefs(frameChild));
-
-  nsCOMPtr<nsIAtom> tag;
-  nsresult          rv;
-  
-  frameChild->GetTag(*getter_AddRefs(tag));
-  if (tag && tag.get() == nsXULAtoms::popup) {
-    mPopupFrames.AppendFrames(nsnull, aFrameList);
-    rv = GenerateDirtyReflowCommand(aPresContext, aPresShell);
-  } else {
-    rv = nsBoxFrame::AppendFrames(aPresContext, aPresShell, aListName, aFrameList); 
-  }
-
-  return rv;
-}
-
-NS_IMETHODIMP
-nsPopupSetFrame::CreatePopup(nsIFrame* aElementFrame, nsIContent* aPopupContent, 
-                             PRInt32 aXPos, PRInt32 aYPos, 
-                             const nsString& aPopupType, const nsString& anAnchorAlignment,
-                             const nsString& aPopupAlignment)
-{
-  // Cache the element frame.
-  mElementFrame = aElementFrame;
-
-  // Show the popup at the specified position.
-  mXPos = aXPos;
-  mYPos = aYPos;
-
-  printf("X Pos: %d\n", mXPos);
-  printf("Y Pos: %d\n", mYPos);
-
-  if (!OnCreate(aPopupContent))
-    return NS_OK;
-
-  // Generate the popup.
-  MarkAsGenerated(aPopupContent);
-
-  // Now we'll have it in our child frame list.
-  
-  // Now open the popup.
-  OpenPopup(PR_TRUE);
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsPopupSetFrame::HidePopup()
-{
-  ActivatePopup(PR_FALSE);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsPopupSetFrame::DestroyPopup()
-{
-  OpenPopup(PR_FALSE);
-  return NS_OK;
-}
-
-void
-nsPopupSetFrame::MarkAsGenerated(nsIContent* aPopupContent)
-{
-  // Ungenerate all other popups in the set. No more than one can exist
-  // at any point in time.
-  PRInt32 childCount;
-  mContent->ChildCount(childCount);
-  for (PRInt32 i = 0; i < childCount; i++) {
-    nsCOMPtr<nsIContent> childContent;
-    mContent->ChildAt(i, *getter_AddRefs(childContent));
-
-    // Retrieve the menugenerated attribute.
-    nsAutoString value;
-    childContent->GetAttribute(kNameSpaceID_None, nsXULAtoms::menugenerated, 
-                               value);
-    if (value == "true") {
-      // Ungenerate this element.
-      childContent->UnsetAttribute(kNameSpaceID_None, nsXULAtoms::menugenerated,
-                                   PR_TRUE);
-    }
-  }
-
-  // Set our attribute, but only if we aren't already generated.
-  // Retrieve the menugenerated attribute.
-  nsAutoString value;
-  aPopupContent->GetAttribute(kNameSpaceID_None, nsXULAtoms::menugenerated, 
-                              value);
-  if (value != "true") {
-    // Generate this element.
-    aPopupContent->SetAttribute(kNameSpaceID_None, nsXULAtoms::menugenerated, "true",
-                                PR_TRUE);
-  }
-}
-
-void
-nsPopupSetFrame::OpenPopup(PRBool aActivateFlag)
-{
-  if (aActivateFlag) {
-    ActivatePopup(PR_TRUE);
-    
-    nsIFrame* activeChild = GetActiveChild();
-
-    nsCOMPtr<nsIMenuParent> childPopup = do_QueryInterface(activeChild);
-    UpdateDismissalListener(childPopup);
-  }
-  else {
-    if (!OnDestroy())
-      return;
-
-    // Unregister.
-    if (nsMenuFrame::mDismissalListener) {
-      nsMenuFrame::mDismissalListener->Unregister();
-    }
-
-    ActivatePopup(PR_FALSE);
-  }
-}
-
-void
-nsPopupSetFrame::ActivatePopup(PRBool aActivateFlag)
-{
-  nsCOMPtr<nsIContent> content;
-  GetActiveChildElement(getter_AddRefs(content));
-  if (content) {
-    if (aActivateFlag)
-      content->SetAttribute(kNameSpaceID_None, nsXULAtoms::menuactive, "true", PR_TRUE);
-    else content->UnsetAttribute(kNameSpaceID_None, nsXULAtoms::menuactive, PR_TRUE);
-  }
-}
-
-PRBool
-nsPopupSetFrame::OnCreate(nsIContent* aPopupContent)
-{
-  nsEventStatus status = nsEventStatus_eIgnore;
-  nsMouseEvent event;
-  event.eventStructType = NS_EVENT;
-  event.message = NS_MENU_CREATE;
-
-  if (aPopupContent) {
-    nsresult rv = aPopupContent->HandleDOMEvent(*mPresContext, &event, nsnull, NS_EVENT_FLAG_INIT, status);
-    if ( NS_FAILED(rv) || status == nsEventStatus_eConsumeNoDefault )
-      return PR_FALSE;
-  }
-
-  return PR_TRUE;
-}
-
-PRBool
-nsPopupSetFrame::OnDestroy()
-{
-  nsEventStatus status = nsEventStatus_eIgnore;
-  nsMouseEvent event;
-  event.eventStructType = NS_EVENT;
-  event.message = NS_MENU_DESTROY;
-
-  nsCOMPtr<nsIContent> content;
-  GetActiveChildElement(getter_AddRefs(content));
-  
-  if (content) {
-    nsresult rv = content->HandleDOMEvent(*mPresContext, &event, nsnull, NS_EVENT_FLAG_INIT, status);
-    if ( NS_FAILED(rv) || status == nsEventStatus_eConsumeNoDefault )
-      return PR_FALSE;
-  }
-  return PR_TRUE;
-}
-
-void
-nsPopupSetFrame::GetActiveChildElement(nsIContent** aResult)
-{
-  *aResult = nsnull;
-  nsIFrame* child = GetActiveChild();
-  if (child) {
-    child->GetContent(aResult);
-  }
-}
-
-void
-nsPopupSetFrame::UpdateDismissalListener(nsIMenuParent* aMenuParent)
-{
-  if (!nsMenuFrame::mDismissalListener) {
-    if (!aMenuParent)
-       return;
-    // Create the listener and attach it to the outermost window.
-    aMenuParent->CreateDismissalListener();
-  }
-  
-  // Make sure the menu dismissal listener knows what the current
-  // innermost menu popup frame is.
-  nsMenuFrame::mDismissalListener->SetCurrentMenuParent(aMenuParent);
-}
-
-

mozilla/layout/xul/base/src/nsPopupSetFrame.h

@@ -1,125 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-//
-// nsPopupSetFrame
-//
-
-#ifndef nsPopupSetFrame_h__
-#define nsPopupSetFrame_h__
-
-#include "prtypes.h"
-#include "nsIAtom.h"
-#include "nsCOMPtr.h"
-
-#include "nsIPopupSetFrame.h"
-#include "nsIAnonymousContentCreator.h"
-#include "nsBoxFrame.h"
-#include "nsFrameList.h"
-#include "nsIMenuParent.h"
-#include "nsITimer.h"
-#include "nsITimerCallback.h"
-#include "nsISupportsArray.h"
-
-nsresult NS_NewPopupSetFrame(nsIFrame** aResult) ;
-
-class nsPopupSetFrame : public nsBoxFrame, public nsIPopupSetFrame
-{
-public:
-  nsPopupSetFrame();
-
-  NS_DECL_ISUPPORTS
-  
-  NS_IMETHOD Init(nsIPresContext&  aPresContext,
-                  nsIContent*      aContent,
-                  nsIFrame*        aParent,
-                  nsIStyleContext* aContext,
-                  nsIFrame*        aPrevInFlow);
-
-  // The following four methods are all overridden so that the menu children
-  // can be stored in a separate list (so that they don't impact reflow of the
-  // actual menu item at all).
-  NS_IMETHOD FirstChild(nsIAtom*   aListName,
-                        nsIFrame** aFirstChild) const;
-  NS_IMETHOD SetInitialChildList(nsIPresContext& aPresContext,
-                                 nsIAtom*        aListName,
-                                 nsIFrame*       aChildList);
-  NS_IMETHOD GetAdditionalChildListName(PRInt32   aIndex,
-                                        nsIAtom** aListName) const;
-  NS_IMETHOD Destroy(nsIPresContext& aPresContext);
-
-  // Reflow methods
-  NS_IMETHOD Reflow(nsIPresContext&   aPresContext,
-                    nsHTMLReflowMetrics&     aDesiredSize,
-                    const nsHTMLReflowState& aReflowState,
-                    nsReflowStatus&          aStatus);
-  NS_IMETHOD DidReflow(nsIPresContext& aPresContext,
-                            nsDidReflowStatus aStatus);
-
-  NS_IMETHOD Dirty(nsIPresContext& aPresContext, const nsHTMLReflowState& aReflowState, nsIFrame*& incrementalChild);
-
-  NS_IMETHOD  AppendFrames(nsIPresContext& aPresContext,
-                           nsIPresShell&   aPresShell,
-                           nsIAtom*        aListName,
-                           nsIFrame*       aFrameList);
-
-  NS_IMETHOD  InsertFrames(nsIPresContext& aPresContext,
-                           nsIPresShell&   aPresShell,
-                           nsIAtom*        aListName,
-                           nsIFrame*       aPrevFrame,
-                           nsIFrame*       aFrameList);
-
-  NS_IMETHOD  RemoveFrame(nsIPresContext& aPresContext,
-                          nsIPresShell&   aPresShell,
-                          nsIAtom*        aListName,
-                          nsIFrame*       aOldFrame);
-
-  NS_IMETHOD CreatePopup(nsIFrame* aElementFrame, nsIContent* aPopupContent, 
-                         PRInt32 aXPos, PRInt32 aYPos, 
-                         const nsString& aPopupType, const nsString& anAnchorAlignment,
-                         const nsString& aPopupAlignment);
-
-  NS_IMETHOD HidePopup();
-  NS_IMETHOD DestroyPopup();
-
-  PRBool OnCreate(nsIContent* aPopupContent);
-  PRBool OnDestroy();
-
-  void ActivatePopup(PRBool aActivateFlag);
-  void OpenPopup(PRBool aOpenFlag);
-
-  nsIFrame* GetActiveChild();
-  void GetActiveChildElement(nsIContent** aResult);
-
-protected:
-  void MarkAsGenerated(nsIContent* aPopupContent);
-  void UpdateDismissalListener(nsIMenuParent* aMenuParent);
-
-protected:
-  nsFrameList mPopupFrames;
-  nsIPresContext* mPresContext; // Our pres context.
-
-  nsIFrame* mElementFrame; // The frame that is having something popped up over it.
-
-  PRInt32 mXPos; // Active child's x position
-  PRInt32 mYPos; // Active child's y position
-
-
-}; // class nsPopupSetFrame
-
-#endif

mozilla/layout/xul/base/src/nsProgressMeterFrame.cpp

@@ -1,813 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-//
-// Eric Vaughan
-// Netscape Communications
-//
-// See documentation in associated header file
-//
-
-static float STRIPE_SKEW  = 1.0;      // pixels
-static int   STRIPE_WIDTH = 20;       // pixels
-static int   ANIMATION_INCREMENT = 4; // pixels
-static int   ANIMATION_SPEED = 50;    // miliseconds
-
-#include "nsINameSpaceManager.h"
-#include "nsProgressMeterFrame.h"
-#include "nsIStyleContext.h"
-#include "nsCSSRendering.h"
-#include "nsIContent.h"
-#include "nsIPresContext.h"
-#include "nsHTMLAtoms.h"
-#include "nsXULAtoms.h"
-#include "nsINameSpaceManager.h"
-#include "nsITimerCallback.h"
-#include "nsITimer.h"
-#include "nsIView.h"
-#include "nsIViewManager.h"
-#include "nsIReflowCommand.h"
-#include "nsHTMLParts.h"
-#include "nsIPresShell.h"
-
-class StripeTimer : public nsITimerCallback {
-public:
-  StripeTimer();
-  virtual ~StripeTimer();
-
-  NS_DECL_ISUPPORTS
-
-  void AddFrame(nsIPresContext* aPresContext, nsProgressMeterFrame* aFrame);
-
-  PRBool RemoveFrame(nsProgressMeterFrame* aFrame);
-
-  PRInt32 FrameCount();
-
-  void Start();
-
-  void Stop();
-
-  virtual void Notify(nsITimer *timer);
-
-  PRInt32 GetFrameData(nsProgressMeterFrame* aFrame);
-
-  struct FrameData {
-    nsIPresContext*       mPresContext;  // pres context associated with the frame
-    nsProgressMeterFrame* mFrame;
-
-
-    FrameData(nsIPresContext*       aPresContext,
-              nsProgressMeterFrame* aFrame)
-      : mPresContext(aPresContext), mFrame(aFrame) {}
-  };
-
-  nsITimer* mTimer;
-  nsVoidArray mFrames;
-};
-
-static StripeTimer* gStripeAnimator;
-
-StripeTimer::StripeTimer()
-{
-  NS_INIT_REFCNT();
-  mTimer = nsnull;
-}
-
-StripeTimer::~StripeTimer()
-{
-  Stop();
-}
-
-void StripeTimer::Start()
-{
-  nsresult rv = NS_NewTimer(&mTimer);
-  if (NS_OK == rv) {
-    mTimer->Init(this, ANIMATION_SPEED);
-  }
-}
-
-void StripeTimer::Stop()
-{
-  if (nsnull != mTimer) {
-    mTimer->Cancel();
-    NS_RELEASE(mTimer);
-  }
-}
-
-static NS_DEFINE_IID(kITimerCallbackIID, NS_ITIMERCALLBACK_IID);
-NS_IMPL_ISUPPORTS(StripeTimer, kITimerCallbackIID);
-
-PRInt32 StripeTimer::GetFrameData(nsProgressMeterFrame* aFrame)
-{
-  PRInt32 i, n = mFrames.Count();
-  for (i = 0; i < n; i++) {
-    FrameData* frameData = (FrameData*) mFrames.ElementAt(i);
-
-    if (frameData->mFrame == aFrame) {
-      return i;
-    }
-  }
-
-  return -1;
-}
-
-void StripeTimer::AddFrame(nsIPresContext* aPresContext, nsProgressMeterFrame* aFrame) {
-
-  // see if the frame is already here.
-  if (GetFrameData(aFrame) > -1)
-	  return;
-
-  // if not add it.
-  FrameData* frameData = new FrameData(aPresContext, aFrame);
-  mFrames.AppendElement(frameData);
-  if (1 == mFrames.Count()) {
-    Start();
-  }
-}
-
-PRBool StripeTimer::RemoveFrame(nsProgressMeterFrame* aFrame) {
-  PRBool  rv = PR_FALSE;
-  PRInt32 i = GetFrameData(aFrame);
-
-  if (i > -1) {
-    FrameData*  frameData = (FrameData*)mFrames.ElementAt(i);
-    rv = mFrames.RemoveElementAt(i);
-    delete frameData;
-  }
-  if (0 == mFrames.Count()) {
-    Stop();
-  }
-  return rv;
-}
-
-PRInt32 StripeTimer::FrameCount() {
-  return mFrames.Count();
-}
-
-void StripeTimer::Notify(nsITimer *timer)
-{
-  // XXX hack to get auto-repeating timers; restart before doing
-  // expensive work so that time between ticks is more even
-  Stop();
-  Start();
-
-  PRInt32 i, n = mFrames.Count();
-  for (i = 0; i < n; i++) {
-    FrameData*  frameData = (FrameData*) mFrames.ElementAt(i);
-    frameData->mFrame->animate();
-
-    // Determine damaged area and tell view manager to redraw it
-    nsPoint offset;
-    nsRect bounds;
-    frameData->mFrame->GetRect(bounds);
-    nsIView* view;
-    frameData->mFrame->GetOffsetFromView(frameData->mPresContext, offset, &view);
-    nsIViewManager* vm;
-    view->GetViewManager(vm);
-    bounds.x = offset.x;
-    bounds.y = offset.y;
-    vm->UpdateView(view, bounds, 0);
-    NS_RELEASE(vm);
-  }
-}
-
-//
-// NS_NewToolbarFrame
-//
-// Creates a new Toolbar frame and returns it in |aNewFrame|
-//
-nsresult
-NS_NewProgressMeterFrame ( nsIFrame** aNewFrame )
-{
-  NS_PRECONDITION(aNewFrame, "null OUT ptr");
-  if (nsnull == aNewFrame) {
-    return NS_ERROR_NULL_POINTER;
-  }
-  nsProgressMeterFrame* it = new nsProgressMeterFrame;
-  if (nsnull == it)
-    return NS_ERROR_OUT_OF_MEMORY;
-
-  // it->SetFlags(aFlags);
-  *aNewFrame = it;
-  return NS_OK;
-  
-} // NS_NewProgressMeterFrame
-
-//
-// nsProgressMeterFrame cntr
-//
-// Init, if necessary
-//
-nsProgressMeterFrame :: nsProgressMeterFrame ( )
-{
-	// if we haven't created the timer create it.
-	if (nsnull == gStripeAnimator) {
-	gStripeAnimator = new StripeTimer();
-	}
-
-	NS_ADDREF(gStripeAnimator);
-
-	mProgress = float(0.0);
-	mHorizontal = PR_TRUE;
-	mUndetermined = PR_FALSE;
-	mStripeOffset = STRIPE_WIDTH;
-}
-
-//
-// nsProgressMeterFrame dstr
-//
-// Cleanup, if necessary
-//
-nsProgressMeterFrame :: ~nsProgressMeterFrame ( )
-{
-
-    gStripeAnimator->RemoveFrame(this);
-}
-
-NS_IMETHODIMP
-nsProgressMeterFrame::Init(nsIPresContext&  aPresContext,
-                   nsIContent*      aContent,
-                   nsIFrame*        aParent,
-                   nsIStyleContext* aContext,
-                   nsIFrame*        aPrevInFlow)
-{
- 
-  nsresult  rv = nsLeafFrame::Init(aPresContext, aContent, aParent, aContext,
-                                   aPrevInFlow);
-
-  // get the value
-  nsAutoString value;
-  if ((NS_CONTENT_ATTR_HAS_VALUE == mContent->GetAttribute(kNameSpaceID_None, nsHTMLAtoms::value, value)) &&
-      (value.Length() > 0)) {
-	  setProgress(value);
-  }
-
-
-   // get the alignment
-  nsAutoString align;
-  mContent->GetAttribute(kNameSpaceID_None, nsHTMLAtoms::align, align);
-  setAlignment(align); 
-
-  // get the mode
-  nsAutoString mode;
-  mContent->GetAttribute(kNameSpaceID_None, nsXULAtoms::mode, mode);
-  setMode(mode); 
-
-  nsCOMPtr<nsIAtom> barPseudo ( dont_AddRef(NS_NewAtom(":progressmeter-stripe")) );
-  nsIStyleContext* barStyle = nsnull;
-  aPresContext.ProbePseudoStyleContextFor(aContent, barPseudo, aContext, 
-                                          PR_FALSE, &barStyle);
-  mBarStyle = barStyle;
-
-  return rv;
-}
-
-void
-nsProgressMeterFrame::setProgress(nsAutoString progress)
-{
-	// convert to and integer
-	PRInt32 error;
-	PRInt32 v = progress.ToInteger(&error);
- 
-	// adjust to 0 and 100
-	if (v < 0)
-		v = 0;
-	else if (v > 100)
-		v = 100;
-
-//	printf("ProgressMeter value=%d\n", v);
-    mProgress = float(v)/float(100);
-}
-
-void
-nsProgressMeterFrame::setSize(nsAutoString sizeString, int& size, PRBool& isPercent)
-{
-	// -1 means unset
-	size = -1;
-
-	int length = sizeString.Length();
-	if (length == 0)
-		return;
-
-	char w[100];
-	sizeString.ToCString(w,100);
-    
-	if (w[length-1] == '%')
-		isPercent = PR_TRUE;
-	else
-		isPercent = PR_FALSE;
-
-	// convert to and integer
-	PRInt32 error;
-	PRInt32 v = sizeString.ToInteger(&error);
- 
-	// adjust to 0 and 100
-	if (isPercent) {
-		if (v < 0)
-			v = 0;
-		else if (v > 100)
-			v = 100;
-	}
-
-	printf("size=%d\n", v);
-
-    size = v;
-}
-
-
-
-void
-nsProgressMeterFrame::setAlignment(nsAutoString progress)
-{
-    if (progress.EqualsIgnoreCase("vertical"))
-		mHorizontal = PR_FALSE;
-    else
-		mHorizontal = PR_TRUE;
-}
-
-void
-nsProgressMeterFrame::setMode(nsAutoString mode)
-{
-    if (mode.EqualsIgnoreCase("undetermined"))
-		mUndetermined = PR_TRUE;
-    else
-		mUndetermined = PR_FALSE;
-}
-
-
-//
-// Paint
-//
-// Paint our background and border like normal frames, but before we draw the
-// children, draw our grippies for each toolbar.
-//
-NS_IMETHODIMP
-nsProgressMeterFrame :: Paint ( nsIPresContext& aPresContext,
-                            nsIRenderingContext& aRenderingContext,
-                            const nsRect& aDirtyRect,
-                            nsFramePaintLayer aWhichLayer)
-{
-  const nsStyleDisplay* disp = (const nsStyleDisplay*)
-  mStyleContext->GetStyleData(eStyleStruct_Display);
-
-  // if we aren't visible then we are done.
-  if (!disp->mVisible) 
-	   return NS_OK;  
-
-  // if we are visible then tell our superclass to paint
-  nsLeafFrame::Paint(aPresContext, aRenderingContext, aDirtyRect,
-                       aWhichLayer);
-
-  // get our border
-	const nsStyleSpacing* spacing =
-		(const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing);
-	nsMargin border(0,0,0,0);
-	spacing->CalcBorderFor(this, border);
-
-	const nsStyleColor* colorStyle =
-		(const nsStyleColor*)mStyleContext->GetStyleData(eStyleStruct_Color);
-
-    nscolor color = colorStyle->mColor;
-		
-	// figure our twips convertion ratio
-    //	float p2t;
-    //	aPresContext.GetScaledPixelsToTwips(p2t);
-    //	nscoord onePixel = NSIntPixelsToTwips(1, p2t);
-
-	// figure out our rectangle
-    nsRect rect(0,0,mRect.width, mRect.height);
-
-	// if its vertical then transform the coords to the X coordinate system
-	// and do our calculations there.
-	if (!mHorizontal)
-  		rect = TransformYtoX(rect);
-
-    //CalcSize(aPresContext,rect.width,rect.height);
-	rect.x = border.left;
-	rect.y = border.top;
-	rect.width -= border.left*2;
-	rect.height -= border.top*2;
-
-	// paint the current progress in blue
-	PaintBar(aPresContext, aRenderingContext, rect, mProgress, color);
-	
- 
-  return NS_OK;  
-} // Paint
-
-void
-nsProgressMeterFrame :: PaintBar ( nsIPresContext& aPresContext,
-                            nsIRenderingContext& aRenderingContext,
-                            const nsRect& rect,
-							float progress,
-							nscolor color) {
-
-	// if the bar is undetermined then use the whole progress area.
-	// if the bar is determined then figure out the current progress and make
-	// the bar only that percent of the full progress meter.
-
-	nsRect bar(rect);
-
-    if (!mUndetermined) 
-	{
-	  int p = (int)(bar.width*progress);
-	  bar.width = p;
-	}
-
-	// fill the bar first then we will do the shading over it.
-    aRenderingContext.SetColor(color);
-
-	if (mHorizontal)
-		aRenderingContext.FillRect(bar);
-	else { // if we are vert then transfrom to the y cood system.
-		nsRect nbar = TransformXtoY(bar);
-		aRenderingContext.FillRect(nbar);
-	}
-
-	// draw the stripped barber shop if undetermined.
-    if (mUndetermined) 
-      PaintBarStripped(aPresContext,aRenderingContext,bar, color);
-    else 
-	  PaintBarSolid(aPresContext,aRenderingContext,bar, color, 0);
-	
-
-}
-
-nsRect 
-nsProgressMeterFrame::TransformXtoY(const nsRect& rect)
-{
-   return nsRect(rect.y, mRect.height - (rect.x + rect.width), rect.height, rect.width);
-}
-
-nsRect 
-nsProgressMeterFrame::TransformYtoX(const nsRect& rect)
-{
-   return nsRect(mRect.width - (rect.y + rect.height), rect.x, rect.height, rect.width);
-}
-
-nscolor 
-nsProgressMeterFrame::BrightenBy(nscolor c, PRUint8 amount)
-{
-	PRUint8 r = NS_GET_R(c);
-	PRUint8 g = NS_GET_G(c);
-	PRUint8 b = NS_GET_B(c);
-
-	return NS_RGB(r+amount, g+amount, b+amount);
-}
-
-PRUint8 
-nsProgressMeterFrame::GetBrightness(nscolor c)
-{
-     
-	    // get the biggest rgb component;
-
-        PRUint8 r = NS_GET_R(c);
-        PRUint8 g = NS_GET_G(c);
-        PRUint8 b = NS_GET_B(c);
-
-		PRUint8 biggest = r;
-
-		if (r > g && r > b)
-			biggest = r;
-		else if (g > r && g > b)
-			biggest = g;
-		else if (b > r && b > g)
-			biggest = b;
-
-       return biggest;
-}
-
-void 
-nsProgressMeterFrame::PaintBarSolid(nsIPresContext& aPresContext, nsIRenderingContext& aRenderingContext, 
-                                    const nsRect& rect, nscolor color, float skew)
-{
-
-	    // figure out a pixel size
-		float p2t;
-		aPresContext.GetScaledPixelsToTwips(&p2t);
-		nscoord onePixel = NSIntPixelsToTwips(1, p2t);
-
-		// how many pixel lines will fit?
-		int segments = (rect.height/2) / onePixel;
-
-		// get the skew in pixels;
-		int skewedPixels = int(skew * onePixel);
-
-		// we will draw from the top to center and from the bottom to center at the same time
-		// so we need 2 rects one for the top and one for the bottom
-
-		// top.
-
-		nsRect tr(rect);
-		tr.height= onePixel;
-
-		// bottom
-		nsRect br(rect);
-		br.height = onePixel;
-		br.y = rect.y + 2*segments*onePixel;
-	    br.x = rect.x + 2*segments*skewedPixels;
-
-		// get the brightness of the color
-		PRUint8 brightness = GetBrightness(color);
-
-		// we need to figure out how bright we can get.
-		PRUint8 units = (255 - brightness)/segments;
-
-		// get a color we can set
-		nscolor c(color);
-
-        for (int i=0; i <= segments; i++)
-		{
-			// set the color and fill the top and bottom lines
-		    aRenderingContext.SetColor(c);
-
-			if (mHorizontal) {
-				aRenderingContext.FillRect(tr);
-				aRenderingContext.FillRect(br);
-			} else {
-				aRenderingContext.FillRect(TransformXtoY(tr));
-				aRenderingContext.FillRect(TransformXtoY(br));
-			}
-			// brighten the color
-			c = BrightenBy(c, units);
-
-			// move one line down
-			tr.x += skewedPixels;
-			tr.y += onePixel;
-
-			// move one line up
-			br.y -= onePixel;
-			br.x -= skewedPixels;
-		}
-}
-
-
-void 
-nsProgressMeterFrame::PaintBarStripped(nsIPresContext& aPresContext, nsIRenderingContext& aRenderingContext, 
-                                       const nsRect& r, nscolor color)
-{
-	// get stripe color from the style system
-	nsCOMPtr<nsIStyleContext> style (mBarStyle) ;
-
-	nscolor altColor = NS_RGB(128,128,128);
-
-	// if we got a style then get the color from it
-	if (style != 0)
-	{
-		const nsStyleColor*   barColor   = (const nsStyleColor*)style->GetStyleData(eStyleStruct_Color);
-		altColor = barColor->mColor;
-	}
-
-  float skew = STRIPE_SKEW;
-  float stripeWidth = float(STRIPE_WIDTH);
-
-  nsRect rect(r);
-
-  PRBool clipState;
-
-  // Clip so we don't render outside the inner rect
-  aRenderingContext.PushState();
-  if (mHorizontal) 
-	aRenderingContext.SetClipRect(rect, nsClipCombine_kIntersect, clipState);
-  else
-	aRenderingContext.SetClipRect(TransformXtoY(rect), nsClipCombine_kIntersect, clipState);
- 
- 
-  float p2t;
-  aPresContext.GetScaledPixelsToTwips(&p2t);
-  // nscoord onePixel = NSIntPixelsToTwips(1, p2t);
-
-  int stripeWidthInTwips = (int)(stripeWidth * p2t);
- 
-  int offset = int(float(r.height) * skew);
-
-  //make things a little bigger and just clip them
-    rect.width += offset*2;
-  rect.x -= (offset + int(float(mStripeOffset)*p2t));
- 
-  int stripes = rect.width / (stripeWidthInTwips/2) + 2;
-
-  nsRect sr(rect.x,rect.y,stripeWidthInTwips,rect.height);
-
-  PRBool onoff = PR_FALSE;
-  nscolor c;
-
-
-  for (int i=0; i < stripes; i++)
-  {
-	 if (onoff)
-		 c = color;
-	 else
-		 c = altColor;
-
-	 PaintBarSolid(aPresContext,aRenderingContext,sr, c, skew);
-	 sr.x += (stripeWidthInTwips/2);
-
-	 onoff = !onoff;
-  }
-
-  aRenderingContext.PopState(clipState);
-}
-
-void
-nsProgressMeterFrame::animate()
-{
-    mStripeOffset -= ANIMATION_INCREMENT;
-  // 	printf("animate=%d\n", mStripeOffset);
-	if (mStripeOffset < 0)
-		mStripeOffset = STRIPE_WIDTH;
-}
-
-
-//
-// Reflow
-//
-// Handle moving children around.
-//
-NS_IMETHODIMP
-nsProgressMeterFrame :: Reflow ( nsIPresContext&          aPresContext,
-                            nsHTMLReflowMetrics&     aDesiredSize,
-                            const nsHTMLReflowState& aReflowState,
-                            nsReflowStatus&          aStatus)
-{	
-
-  if (eReflowReason_Incremental == aReflowState.reason) {
-    nsIFrame* targetFrame;
-  
-    // See if it's targeted at us
-    aReflowState.reflowCommand->GetTarget(targetFrame);
-    if (this == targetFrame) {
-      Invalidate(&aPresContext, nsRect(0,0,mRect.width,mRect.height), PR_FALSE);
-    }
-  }
-
-  if (mUndetermined)
-     gStripeAnimator->AddFrame(&aPresContext, this);
-  else 
-	 gStripeAnimator->RemoveFrame(this);
-
-  return nsLeafFrame::Reflow ( aPresContext, aDesiredSize, aReflowState, aStatus );
-
-} // Reflow 
-
-void
-nsProgressMeterFrame::GetDesiredSize(nsIPresContext* aPresContext,
-                             const nsHTMLReflowState& aReflowState,
-                             nsHTMLReflowMetrics& aDesiredSize)
-{
-
-  CalcSize(*aPresContext,aDesiredSize.width,aDesiredSize.height);
-
-   // if the width is set use it
-	if (NS_INTRINSICSIZE != aReflowState.mComputedWidth) 
-	  aDesiredSize.width = aReflowState.mComputedWidth;
-
-	// if the height is set use it
- 	if (NS_INTRINSICSIZE != aReflowState.mComputedHeight) 
-		aDesiredSize.height = aReflowState.mComputedHeight;
-}
-
-
-void
-nsProgressMeterFrame::CalcSize(nsIPresContext& aPresContext, int& width, int& height)
-{
-	// make sure we convert to twips.
-	float p2t;
-  aPresContext.GetScaledPixelsToTwips(&p2t);
-
-	if (mHorizontal) {
-		width = (int)(100 * p2t);
-		height = (int)(16 * p2t);
-	} else {
-		height = (int)(100 * p2t);
-		width = (int)(16 * p2t);
-	}
-}
-
-NS_IMETHODIMP
-nsProgressMeterFrame::AttributeChanged(nsIPresContext* aPresContext,
-                               nsIContent* aChild,
-                               PRInt32 aNameSpaceID,
-                               nsIAtom* aAttribute,
-                               PRInt32 aHint)
-{
-  nsresult rv = nsLeafFrame::AttributeChanged(aPresContext, aChild,
-                                              aNameSpaceID, aAttribute, aHint);
-  if (NS_OK != rv) {
-    return rv;
-  }
-
-  // did the progress change?
-  if (nsHTMLAtoms::value == aAttribute) {
-    nsAutoString newValue;
-
-	// get attribute and set it
-    aChild->GetAttribute(kNameSpaceID_None, nsHTMLAtoms::value, newValue);
-    setProgress(newValue);
-
-    Redraw(aPresContext);
-
-  } else if (nsXULAtoms::mode == aAttribute) {
-    nsAutoString newValue;
-
-    aChild->GetAttribute(kNameSpaceID_None, nsXULAtoms::mode, newValue);
-    setMode(newValue);
-
-    // needs to reflow so we start the timer.
-    if (aHint != NS_STYLE_HINT_REFLOW)
-      Reflow(aPresContext);
-
-  } else if (nsHTMLAtoms::align == aAttribute) {
-    nsAutoString newValue;
-
-	// get attribute and set it
-    aChild->GetAttribute(kNameSpaceID_None, nsHTMLAtoms::align, newValue);
-    setAlignment(newValue);
-
-    if (aHint != NS_STYLE_HINT_REFLOW)
-      Reflow(aPresContext);
-  }
-
-  return NS_OK;
-}
-
-void
-nsProgressMeterFrame::Reflow(nsIPresContext* aPresContext)
-{
-   // reflow
-    nsCOMPtr<nsIPresShell> shell;
-    aPresContext->GetShell(getter_AddRefs(shell));
-    
-    nsCOMPtr<nsIReflowCommand> reflowCmd;
-    nsresult rv = NS_NewHTMLReflowCommand(getter_AddRefs(reflowCmd), this,
-                                          nsIReflowCommand::StyleChanged);
-    if (NS_SUCCEEDED(rv)) 
-      shell->AppendReflowCommand(reflowCmd);
-}
-
-void
-nsProgressMeterFrame::Redraw(nsIPresContext* aPresContext)
-{
-   	nsRect frameRect;
-	  GetRect(frameRect);
-	  nsRect rect(0, 0, frameRect.width, frameRect.height);
-    Invalidate(aPresContext, rect, PR_TRUE);
-}
-
-
-NS_IMETHODIMP
-nsProgressMeterFrame::GetAdditionalStyleContext(PRInt32 aIndex, 
-                                                nsIStyleContext** aStyleContext) const
-{
-  NS_PRECONDITION(nsnull != aStyleContext, "null OUT parameter pointer");
-  if (aIndex < 0) {
-    return NS_ERROR_INVALID_ARG;
-  }
-  *aStyleContext = nsnull;
-  switch (aIndex) {
-  case NS_PROGRESS_METER_STRIPE_CONTEXT_INDEX:
-    *aStyleContext = mBarStyle;
-    NS_IF_ADDREF(*aStyleContext);
-    break;
-  default:
-    return NS_ERROR_INVALID_ARG;
-  }
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsProgressMeterFrame::SetAdditionalStyleContext(PRInt32 aIndex, 
-                                                nsIStyleContext* aStyleContext)
-{
-  if (aIndex < 0) {
-    return NS_ERROR_INVALID_ARG;
-  }
-  switch (aIndex) {
-  case NS_PROGRESS_METER_STRIPE_CONTEXT_INDEX:
-    mBarStyle = aStyleContext;
-    break;
-  }
-  return NS_OK;
-}
-
-
-
-
-
-

mozilla/layout/xul/base/src/nsProgressMeterFrame.h

@@ -1,140 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-/**
-
-  Eric D Vaughan.
-
-  A simple progress meter. 
-
-  Attributes:
-
-  value: A number between 0% adn 100%
-  align: horizontal, or vertical
-  mode: determined, undetermined (one shows progress other shows animated candy cane)
-
-  Style:
-
-  Bar gets its color from the color style
-  Alternating stripes can be set with the seudo style:
-
-	:PROGRESSMETER-STRIPE {
-		color: gray
-	}
-
-**/
-
-#include "nsLeafFrame.h"
-#include "nsColor.h"
-#include "nsCOMPtr.h"
-#include "nsIStyleContext.h"
-#include "nsIPresContext.h"
-
-#include "prtypes.h"
-
-class nsIPresContext;
-class nsIStyleContext;
-
-#define NS_PROGRESS_METER_STRIPE_CONTEXT_INDEX 1
-
-class nsProgressMeterFrame : public nsLeafFrame
-{
-public:
-  friend nsresult NS_NewProgressMeterFrame(nsIFrame** aNewFrame);
-
-  NS_IMETHOD Init(nsIPresContext&  aPresContext,
-                  nsIContent*      aContent,
-                  nsIFrame*        aParent,
-                  nsIStyleContext* aContext,
-                  nsIFrame*        aPrevInFlow);
-  
-    // nsIHTMLReflow overrides
-  NS_IMETHOD Reflow(nsIPresContext&          aPresContext,
-                    nsHTMLReflowMetrics&     aDesiredSize,
-                    const nsHTMLReflowState& aReflowState,
-                    nsReflowStatus&          aStatus);
-  NS_IMETHOD  Paint(nsIPresContext& aPresContext,
-                    nsIRenderingContext& aRenderingContext,
-                    const nsRect& aDirtyRect,
-                    nsFramePaintLayer aWhichLayer);
-
-  NS_IMETHOD AttributeChanged(nsIPresContext* aPresContext,
-                              nsIContent* aChild,
-                              PRInt32 aNameSpaceID,
-                              nsIAtom* aAttribute,
-                              PRInt32 aHint);
-
-  NS_IMETHOD  GetAdditionalStyleContext(PRInt32 aIndex, 
-                                        nsIStyleContext** aStyleContext) const;
-  NS_IMETHOD  SetAdditionalStyleContext(PRInt32 aIndex, 
-                                        nsIStyleContext* aStyleContext);
-
-  virtual void animate();
-
-  virtual void Reflow(nsIPresContext* aPresContext);
-
-  virtual void Redraw(nsIPresContext* aPresContext);
-
-protected:
-  nsProgressMeterFrame();
-  virtual ~nsProgressMeterFrame();
-
-  virtual void GetDesiredSize(nsIPresContext* aPresContext,
-                              const nsHTMLReflowState& aReflowState,
-                              nsHTMLReflowMetrics& aDesiredSize);
-
-  virtual void CalcSize(nsIPresContext& aPresContext, int& width, int& height);
-
-  virtual void  PaintBar ( nsIPresContext& aPresContext,
-                           nsIRenderingContext& aRenderingContext,
-                           const nsRect& rect, 
-							float progress,
-							nscolor color);
-
-
-  virtual void PaintBarStripped(nsIPresContext& aPresContext, nsIRenderingContext& aRenderingContext, 
-                                           const nsRect& rect, nscolor color);
-
-  virtual void PaintBarSolid(nsIPresContext& aPresContext, nsIRenderingContext& aRenderingContext, 
-                                           const nsRect& rect, nscolor color, float skew);
-
-
-  virtual nscolor BrightenBy(nscolor color, PRUint8 amount);
-  virtual PRUint8 GetBrightness(nscolor c);
-  virtual nsRect TransformXtoY(const nsRect& rect);
-  virtual nsRect TransformYtoX(const nsRect& rect);
-
-    // pass-by-value not allowed for a coordinator because it corresponds 1-to-1
-    // with an element in the UI.
-  nsProgressMeterFrame ( const nsProgressMeterFrame& aFrame ) ;	            // DO NOT IMPLEMENT
-  nsProgressMeterFrame& operator= ( const nsProgressMeterFrame& aFrame ) ;  // DO NOT IMPLEMENT
-
-private:
- 
-  void setProgress(nsAutoString progress);
-  void setAlignment(nsAutoString alignment);
-  void setMode(nsAutoString mode);
-  void setSize(nsAutoString s, int& size, PRBool& isPercent);
-
-  nsCOMPtr<nsIStyleContext>    mBarStyle;
-  float   mProgress;
-  PRBool  mHorizontal;
-  PRBool  mUndetermined;
-  int     mStripeOffset;
-}; // class nsProgressMeterFrame

mozilla/layout/xul/base/src/nsRepeatService.cpp

@@ -1,90 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-//
-// Eric Vaughan
-// Netscape Communications
-//
-// See documentation in associated header file
-//
-
-#include "nsRepeatService.h"
-
-#define INITAL_REPEAT_DELAY 250
-#define REPEAT_DELAY        50
-
-nsRepeatService* nsRepeatService::gInstance = nsnull;
-
-nsRepeatService::nsRepeatService()
-{
-}
-
-nsRepeatService::~nsRepeatService()
-{
-  mCallback = nsnull;
-  Stop();
-}
-
-nsRepeatService* 
-nsRepeatService::GetInstance()
-{
-  if (!gInstance) {
-     gInstance = new nsRepeatService();
-     gInstance->mRefCnt = 1;
-  }
-
-  return gInstance;
-}
-
-void nsRepeatService::Start(nsITimerCallback* aCallback)
-{
-  mCallback = aCallback;
-  nsresult rv = NS_NewTimer(getter_AddRefs(mRepeatTimer));
-
-  if (NS_OK == rv)  {
-    mRepeatTimer->Init(this, INITAL_REPEAT_DELAY);
-  }
-
-}
-
-void nsRepeatService::Stop()
-{
-  //printf("Stopping repeat timer\n");
-  if (mRepeatTimer) {
-     mRepeatTimer->Cancel();
-     mRepeatTimer = nsnull;
-     mCallback = nsnull;
-  }
-}
-
-void nsRepeatService::Notify(nsITimer *timer)
-{
-   // if the repeat delay is the initial one reset it.
-  if (mRepeatTimer) {
-     mRepeatTimer->Cancel();
-     NS_NewTimer(getter_AddRefs(mRepeatTimer));
-     mRepeatTimer->Init(this, REPEAT_DELAY);
-  }
-
-  mCallback->Notify(timer);
-}
-
-static NS_DEFINE_IID(kITimerCallbackIID, NS_ITIMERCALLBACK_IID);
-NS_IMPL_ISUPPORTS(nsRepeatService, kITimerCallbackIID);
-

mozilla/layout/xul/base/src/nsScrollbarButtonFrame.cpp

@@ -1,244 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-//
-// Eric Vaughan
-// Netscape Communications
-//
-// See documentation in associated header file
-//
-
-#include "nsScrollbarButtonFrame.h"
-#include "nsIStyleContext.h"
-#include "nsIPresContext.h"
-#include "nsIContent.h"
-#include "nsCOMPtr.h"
-#include "nsHTMLIIDs.h"
-#include "nsUnitConversion.h"
-#include "nsINameSpaceManager.h"
-#include "nsHTMLAtoms.h"
-#include "nsXULAtoms.h"
-#include "nsIReflowCommand.h"
-#include "nsSliderFrame.h"
-#include "nsRepeatService.h"
-
-//
-// NS_NewToolbarFrame
-//
-// Creates a new Toolbar frame and returns it in |aNewFrame|
-//
-nsresult
-NS_NewScrollbarButtonFrame ( nsIFrame** aNewFrame )
-{
-  NS_PRECONDITION(aNewFrame, "null OUT ptr");
-  if (nsnull == aNewFrame) {
-    return NS_ERROR_NULL_POINTER;
-  }
-  nsScrollbarButtonFrame* it = new nsScrollbarButtonFrame;
-  if (nsnull == it)
-    return NS_ERROR_OUT_OF_MEMORY;
-
-  *aNewFrame = it;
-  return NS_OK;
-  
-} // NS_NewScrollBarButtonFrame
-
-/*
-nsScrollbarButtonFrame::nsScrollbarButtonFrame()
-{
-}*/
-
-static NS_DEFINE_IID(kITimerCallbackIID, NS_ITIMERCALLBACK_IID);
-
-
-NS_IMETHODIMP 
-nsScrollbarButtonFrame::QueryInterface(REFNSIID aIID, void** aInstancePtr)      
-{           
-  if (aIID.Equals(kITimerCallbackIID)) {                                         
-    *aInstancePtr = (void*)(nsITimerCallback*) this;                                        
-    NS_ADDREF_THIS();                                                    
-    return NS_OK;                                                        
-  }   
-
-  return nsTitledButtonFrame::QueryInterface(aIID, aInstancePtr);                                     
-}
-
-NS_IMETHODIMP
-nsScrollbarButtonFrame::HandleEvent(nsIPresContext& aPresContext, 
-                                      nsGUIEvent* aEvent,
-                                      nsEventStatus& aEventStatus)
-{  
-  // XXX hack until handle release is actually called in nsframe.
-  if (aEvent->message == NS_MOUSE_EXIT|| aEvent->message == NS_MOUSE_RIGHT_BUTTON_UP || aEvent->message == NS_MOUSE_LEFT_BUTTON_UP)
-     HandleRelease(aPresContext, aEvent, aEventStatus);
-  
-  return nsTitledButtonFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
-}
-
-
-NS_IMETHODIMP
-nsScrollbarButtonFrame::HandlePress(nsIPresContext& aPresContext, 
-                     nsGUIEvent*     aEvent,
-                     nsEventStatus&  aEventStatus)
-{
-  nsRepeatService::GetInstance()->Start(this);
-  return NS_OK;
-}
-
-NS_IMETHODIMP 
-nsScrollbarButtonFrame::HandleRelease(nsIPresContext& aPresContext, 
-                                 nsGUIEvent*     aEvent,
-                                 nsEventStatus&  aEventStatus)
-{
-  nsRepeatService::GetInstance()->Stop();
-  return NS_OK;
-}
-
-
-void nsScrollbarButtonFrame::Notify(nsITimer *timer)
-{
-  MouseClicked();
-}
-
-void
-nsScrollbarButtonFrame::MouseClicked(nsIPresContext& aPresContext) 
-{
-  MouseClicked();
-}
-
-void
-nsScrollbarButtonFrame::MouseClicked() 
-{
-   // when we are clicked either increment or decrement the slider position.
-
-   // get the scrollbar control
-   nsIFrame* scrollbar;
-   GetParentWithTag(nsXULAtoms::scrollbar, this, scrollbar);
-
-   if (scrollbar == nsnull)
-       return;
-
-   // get the scrollbars content node
-   nsCOMPtr<nsIContent> content;
-   scrollbar->GetContent(getter_AddRefs(content));
-
-   // get the current pos
-   PRInt32 curpos = nsSliderFrame::GetCurrentPosition(content);
-
-   // get the max pos
-   PRInt32 maxpos = nsSliderFrame::GetMaxPosition(content);
-
-   // get the increment amount
-   PRInt32 increment = nsSliderFrame::GetIncrement(content);
-
-   nsString value;
-   if (NS_CONTENT_ATTR_HAS_VALUE == mContent->GetAttribute(kNameSpaceID_None, nsHTMLAtoms::type, value))
-   {
-     // if our class is DecrementButton subtract the current pos by increment amount
-     // if our class is IncrementButton increment the current pos by the decrement amount
-     if (value.Equals("decrement"))
-         curpos -= increment;
-     else if (value.Equals("increment"))
-         curpos += increment;
-
-      // make sure the current positon is between the current and max positions
-    if (curpos < 0)
-       curpos = 0;
-    else if (curpos > maxpos)
-       curpos = maxpos;
-
-    // set the current position of the slider.
-    char v[100];
-    sprintf(v, "%d", curpos);
-
-    content->SetAttribute(kNameSpaceID_None, nsXULAtoms::curpos, v, PR_TRUE);
-   
-   }
-
-
-}
-
-nsresult
-nsScrollbarButtonFrame::GetChildWithTag(nsIAtom* atom, nsIFrame* start, nsIFrame*& result)
-{
-  // recursively search our children
-  nsIFrame* childFrame;
-  start->FirstChild(nsnull, &childFrame); 
-  while (nsnull != childFrame) 
-  {    
-    // get the content node
-    nsCOMPtr<nsIContent> child;  
-    childFrame->GetContent(getter_AddRefs(child));
-
-    if (child) {
-      // see if it is the child
-       nsIAtom* tag = nsnull;
-       child->GetTag(tag);
-       if (tag == atom)
-       {
-         result = childFrame;
-         return NS_OK;
-       }
-    }
-
-     // recursive search the child
-     GetChildWithTag(atom, childFrame, result);
-     if (result != nsnull) 
-       return NS_OK;
-
-    nsresult rv = childFrame->GetNextSibling(&childFrame);
-    NS_ASSERTION(rv == NS_OK,"failed to get next child");
-  }
-
-  result = nsnull;
-  return NS_OK;
-}
-
-nsresult
-nsScrollbarButtonFrame::GetParentWithTag(nsIAtom* toFind, nsIFrame* start, nsIFrame*& result)
-{
-   while(nsnull != start)
-   {
-      start->GetParent(&start);
-
-      if (start) {
-        // get the content node
-        nsCOMPtr<nsIContent> child;  
-        start->GetContent(getter_AddRefs(child));
-
-        nsIAtom* atom;
-        if (child && child->GetTag(atom) == NS_OK && atom == toFind) {
-           result = start;
-           return NS_OK;
-        }
-      }
-   }
-
-   result = nsnull;
-   return NS_OK;
-}
-
-NS_IMETHODIMP
-nsScrollbarButtonFrame::Destroy(nsIPresContext& aPresContext)
-{
-  // Ensure our repeat service isn't going... it's possible that a scrollbar can disappear out
-  // from under you while you're in the process of scrolling.
-  nsRepeatService::GetInstance()->Stop();
-  return nsTitledButtonFrame::Destroy(aPresContext);
-}

mozilla/layout/xul/base/src/nsScrollbarButtonFrame.h

@@ -1,86 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-/**
-
-  Eric D Vaughan
-  This class lays out its children either vertically or horizontally
- 
-**/
-
-#ifndef nsScrollbarButtonFrame_h___
-#define nsScrollbarButtonFrame_h___
-
-#include "nsTitledButtonFrame.h"
-#include "nsITimerCallback.h"
-
-class nsSliderFrame;
-
-class nsScrollbarButtonFrame : public nsTitledButtonFrame, 
-                               public nsITimerCallback
-{
-public:
-
-  // Overrides
-  NS_IMETHOD Destroy(nsIPresContext& aPresContext);
-
-  friend nsresult NS_NewScrollBarButtonFrame(nsIFrame** aNewFrame);
-
-  NS_IMETHOD HandleEvent(nsIPresContext& aPresContext, 
-                         nsGUIEvent* aEvent,
-                         nsEventStatus& aEventStatus);
-
-
-  static nsresult GetChildWithTag(nsIAtom* atom, nsIFrame* start, nsIFrame*& result);
-  static nsresult GetParentWithTag(nsIAtom* atom, nsIFrame* start, nsIFrame*& result);
-
-   NS_IMETHOD HandlePress(nsIPresContext& aPresContext,
-                         nsGUIEvent *    aEvent,
-                         nsEventStatus&  aEventStatus);
-
-  NS_IMETHOD HandleMultiplePress(nsIPresContext& aPresContext,
-                         nsGUIEvent *    aEvent,
-                         nsEventStatus&  aEventStatus)  { return NS_OK; }
-
-  NS_IMETHOD HandleDrag(nsIPresContext& aPresContext,
-                        nsGUIEvent *    aEvent,
-                        nsEventStatus&  aEventStatus) { return NS_OK; }
-
-  NS_IMETHOD HandleRelease(nsIPresContext& aPresContext,
-                           nsGUIEvent *    aEvent,
-                           nsEventStatus&  aEventStatus);
-
-  virtual void Notify(nsITimer *timer);
-
-  NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr);
-  NS_IMETHOD_(nsrefcnt) AddRef(void) { return NS_OK; }
-  NS_IMETHOD_(nsrefcnt) Release(void) { return NS_OK; }
-
-
-protected:
-  virtual void MouseClicked(nsIPresContext& aPresContext);
-  virtual void MouseClicked();
-
-  
-}; // class nsTabFrame
-
-
-
-#endif
-

mozilla/layout/xul/base/src/nsScrollbarFrame.cpp

@@ -1,390 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-//
-// Eric Vaughan
-// Netscape Communications
-//
-// See documentation in associated header file
-//
-
-#include "nsScrollbarFrame.h"
-#include "nsScrollbarButtonFrame.h"
-#include "nsXULAtoms.h"
-#include "nsHTMLAtoms.h"
-#include "nsISupportsArray.h"
-#include "nsXULAtoms.h"
-#include "nsHTMLAtoms.h"
-#include "nsINameSpaceManager.h"
-#include "nsIXMLContent.h"
-#include "nsIDOMDocument.h"
-#include "nsIDocument.h"
-#include "nsIDOMElement.h"
-#include "nsXMLElement.h"
-#include "nsIStyledContent.h"
-#include "nsGenericElement.h"
-#include "nsIStyleRule.h"
-#include "nsHTMLValue.h"
-#include "nsIAnonymousContent.h"
-#include "nsIView.h"
-
-static NS_DEFINE_IID(kIAnonymousContentCreatorIID,     NS_IANONYMOUS_CONTENT_CREATOR_IID);
-static NS_DEFINE_IID(kIStyledContentIID,               NS_ISTYLEDCONTENT_IID);
-static NS_DEFINE_IID(kIAnonymousContentIID,            NS_IANONYMOUS_CONTENT_IID);
-
-class AnonymousElement : public nsXMLElement, nsIStyledContent, nsIAnonymousContent
-{
-public:
-  AnonymousElement(nsIAtom *aTag):nsXMLElement(aTag) {}
-
-  // nsIStyledContent
-  NS_IMETHOD GetID(nsIAtom*& aResult) const;
-  NS_IMETHOD GetClasses(nsVoidArray& aArray) const;
-  NS_IMETHOD HasClass(nsIAtom* aClass) const;
-
-  NS_IMETHOD GetContentStyleRules(nsISupportsArray* aRules);
-
-  NS_IMETHOD GetInlineStyleRules(nsISupportsArray* aRules);
-
-  NS_IMETHOD GetMappedAttributeImpact(const nsIAtom* aAttribute, 
-                                           PRInt32& aHint) const;
-
-  // nsISupports
-  NS_DECL_ISUPPORTS_INHERITED
-
-  NS_IMPL_ICONTENT_USING_GENERIC(mInner)
-
-
-  // NS_IMPL_ICONTENT_USING_GENERIC_DOM_DATA(mInner)
-
-};
-
-NS_IMETHODIMP
-AnonymousElement::SizeOf(nsISizeOfHandler* aSizer, PRUint32* aResult) const {
-  return this->nsXMLElement::SizeOf(aSizer, aResult);
-}
-
-/*
-NS_IMETHODIMP 
-AnonymousElement::GetTag(nsIAtom*& aResult) const
-{
-   return mInner.GetTag(aResult);
-}
-
-
-NS_IMETHODIMP
-AnonymousElement::List(FILE* out, PRInt32 aIndent) const
-{
-  
-  NS_PRECONDITION(nsnull != mInner.mDocument, "bad content");
-
-  PRInt32 indx;
-  for (indx = aIndent; --indx >= 0; ) fputs("  ", out);
-
-  fprintf(out, "Comment refcount=%d<", mRefCnt);
-
-  nsAutoString tmp;
-  mInner.ToCString(tmp, 0, mInner.mText.GetLength());
-  fputs(tmp, out);
-
-  fputs(">\n", out);
- 
-  return mInner.List(out, aIndent);
-}
-*/
-
-NS_IMETHODIMP
-AnonymousElement::HandleDOMEvent(nsIPresContext& aPresContext,
-                              nsEvent* aEvent,
-                              nsIDOMEvent** aDOMEvent,
-                              PRUint32 aFlags,
-                              nsEventStatus& aEventStatus)
-{
-  /*
-  // if our parent is not anonymous then we don't want to bubble the event
-  // so lets set our parent in nsnull to prevent it. Then we will set it
-  // back.
-  nsIContent* parent = nsnull;
-  GetParent(parent);
-
-  nsCOMPtr<nsIAnonymousContent> anonymousParent(do_QueryInterface(parent));
-
-
-  if (!anonymousParent) 
-    SetParent(nsnull);
-*/
-
-  nsresult rv = mInner.HandleDOMEvent(aPresContext, aEvent, aDOMEvent,
-                               aFlags, aEventStatus);
-
-  /*
-  if (!anonymousParent)
-    SetParent(parent);
-*/
-  return rv;
-}
-
-
-// nsIStyledContent Implementation
-NS_IMETHODIMP
-AnonymousElement::GetID(nsIAtom*& aResult) const
-{
-  /*
-  nsAutoString value;
-  GetAttribute(kNameSpaceID_None, kIdAtom, value);
-
-  aResult = NS_NewAtom(value); // The NewAtom call does the AddRef.
-  */
-
-  aResult = nsnull;
-
-  return NS_OK;
-}
-    
-NS_IMETHODIMP
-AnonymousElement::GetClasses(nsVoidArray& aArray) const
-{
-	return NS_OK;
-}
-
-NS_IMETHODIMP 
-AnonymousElement::HasClass(nsIAtom* aClass) const
-{
-	return NS_COMFALSE;
-}
-
-NS_IMETHODIMP
-AnonymousElement::GetContentStyleRules(nsISupportsArray* aRules)
-{
-  return NS_OK;
-}
-    
-NS_IMETHODIMP
-AnonymousElement::GetInlineStyleRules(nsISupportsArray* aRules)
-{
-  // we don't currently support the style attribute
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-AnonymousElement::GetMappedAttributeImpact(const nsIAtom* aAttribute, 
-                                         PRInt32& aHint) const
-{
-  aHint = NS_STYLE_HINT_CONTENT;  // we never map attribtes to style
-  return NS_OK;
-}
-
-NS_IMETHODIMP 
-AnonymousElement::QueryInterface(REFNSIID aIID, void** aInstancePtr)      
-{         
-  if (aIID.Equals(kIStyledContentIID)) {
-    nsIStyledContent* tmp = this;
-    *aInstancePtr = (void*) tmp;
-    NS_ADDREF_THIS();
-    return NS_OK;
-  } else if (aIID.Equals(kIAnonymousContentIID)) {
-    nsIAnonymousContent* tmp = this;
-    *aInstancePtr = (void*) tmp;
-    NS_ADDREF_THIS();
-    return NS_OK;
-  }
-
-  return nsXMLElement::QueryInterface(aIID, aInstancePtr);                                                                                                                                                       
-}
-
-NS_IMPL_ADDREF_INHERITED(AnonymousElement, nsXMLElement)
-NS_IMPL_RELEASE_INHERITED(AnonymousElement, nsXMLElement)
-
-nsresult NS_CreateAnonymousNode(nsIContent* aParent, nsIAtom* aTag, PRInt32 aNameSpaceId, nsCOMPtr<nsIContent>& aNewNode)
-{
-   
-    // create the xml element
-    nsCOMPtr<nsIXMLContent> content;
-    //NS_NewXMLElement(getter_AddRefs(content), aTag);
-    content = new AnonymousElement(aTag);
-
-    content->SetNameSpaceID(aNameSpaceId);
-        
-    aNewNode = content;
-
-  /*
-    nsCOMPtr<nsIDocument> document;
-    aParent->GetDocument(*getter_AddRefs(document));
-
-    nsCOMPtr<nsIDOMDocument> domDocument(do_QueryInterface(document));
-    nsCOMPtr<nsIDOMElement> element;
-    nsString name;
-    aTag->ToString(name);
-    domDocument->CreateElement(name, getter_AddRefs(element));
-    aNewNode = do_QueryInterface(element);
-*/
-
-    return NS_OK;
-}
-
-
-//
-// NS_NewToolbarFrame
-//
-// Creates a new Toolbar frame and returns it in |aNewFrame|
-//
-nsresult
-NS_NewScrollbarFrame ( nsIFrame** aNewFrame )
-{
-  NS_PRECONDITION(aNewFrame, "null OUT ptr");
-  if (nsnull == aNewFrame) {
-    return NS_ERROR_NULL_POINTER;
-  }
-  nsScrollbarFrame* it = new nsScrollbarFrame;
-  if (nsnull == it)
-    return NS_ERROR_OUT_OF_MEMORY;
-
-  *aNewFrame = it;
-  return NS_OK;
-  
-} // NS_NewScrollbarFrame
-
-/**
- * Anonymous interface
- */
-NS_IMETHODIMP
-nsScrollbarFrame::CreateAnonymousContent(nsISupportsArray& aAnonymousChildren)
-{
-  // if not content the create some anonymous content
-  PRInt32 count = 0;
-  mContent->ChildCount(count); 
-
-  if (count == 0) {
- 
-    nsCOMPtr<nsIContent> content;
-    NS_CreateAnonymousNode(mContent, nsXULAtoms::scrollbarbutton, nsXULAtoms::nameSpaceID, content);
-    content->SetAttribute(kNameSpaceID_None, nsHTMLAtoms::type, "decrement", PR_FALSE);
-    aAnonymousChildren.AppendElement(content);
-
-    NS_CreateAnonymousNode(mContent, nsXULAtoms::slider, nsXULAtoms::nameSpaceID, content);
-    content->SetAttribute(kNameSpaceID_None, nsXULAtoms::flex, "1", PR_FALSE);
-    aAnonymousChildren.AppendElement(content);
-
-    NS_CreateAnonymousNode(mContent, nsXULAtoms::scrollbarbutton, nsXULAtoms::nameSpaceID, content);
-    content->SetAttribute(kNameSpaceID_None, nsHTMLAtoms::type, "increment", PR_FALSE);
-    aAnonymousChildren.AppendElement(content);
-  }
-
-
-  return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsScrollbarFrame::Init(nsIPresContext&  aPresContext,
-              nsIContent*      aContent,
-              nsIFrame*        aParent,
-              nsIStyleContext* aContext,
-              nsIFrame*        aPrevInFlow)
-{
-  nsresult  rv = nsBoxFrame::Init(aPresContext, aContent, aParent, aContext, aPrevInFlow);
-  CreateViewForFrame(aPresContext,this,aContext,PR_TRUE);
-  nsIView* view;
-  GetView(&aPresContext, &view);
-  view->SetContentTransparency(PR_TRUE);
-  return rv;
-}
-
-
-NS_IMETHODIMP
-nsScrollbarFrame::AttributeChanged(nsIPresContext* aPresContext,
-                               nsIContent* aChild,
-                               PRInt32 aNameSpaceID,
-                               nsIAtom* aAttribute,
-                               PRInt32 aHint)
-{
-  nsresult rv = nsBoxFrame::AttributeChanged(aPresContext, aChild,
-                                              aNameSpaceID, aAttribute, aHint);
-  // if the current position changes
-  if (       aAttribute == nsXULAtoms::curpos || 
-             aAttribute == nsXULAtoms::maxpos || 
-             aAttribute == nsXULAtoms::pageincrement ||
-             aAttribute == nsXULAtoms::increment) {
-     // tell the slider its attribute changed so it can 
-     // update itself
-     nsIFrame* slider;
-     nsScrollbarButtonFrame::GetChildWithTag(nsXULAtoms::slider, this, slider);
-     if (slider)
-        slider->AttributeChanged(aPresContext, aChild, aNameSpaceID, aAttribute, aHint);
-  }
-
-  return rv;
-}
-
-NS_IMETHODIMP 
-nsScrollbarFrame::QueryInterface(REFNSIID aIID, void** aInstancePtr)      
-{           
-  if (NULL == aInstancePtr) {                                            
-    return NS_ERROR_NULL_POINTER;                                        
-  }                                                                      
-                                                                         
-  *aInstancePtr = NULL;                                                  
-                                                                                        
-  if (aIID.Equals(kIAnonymousContentCreatorIID)) {                                         
-    *aInstancePtr = (void*)(nsIAnonymousContentCreator*) this;                                        
-    NS_ADDREF_THIS();                                                    
-    return NS_OK;                                                        
-  }
-
-  if (aIID.Equals(kIStyledContentIID)) {                                         
-    *aInstancePtr = (void*)(nsIStyledContent*) this;                                        
-    NS_ADDREF_THIS();                                                    
-    return NS_OK;                                                        
-  }
-
-  return nsBoxFrame::QueryInterface(aIID, aInstancePtr);                                     
-}
-
-NS_IMETHODIMP
-nsScrollbarFrame::HandlePress(nsIPresContext& aPresContext, 
-                     nsGUIEvent*     aEvent,
-                     nsEventStatus&  aEventStatus)
-{
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsScrollbarFrame::HandleMultiplePress(nsIPresContext& aPresContext, 
-                     nsGUIEvent*     aEvent,
-                     nsEventStatus&  aEventStatus)
-{
-  return NS_OK;
-}
-
-NS_IMETHODIMP 
-nsScrollbarFrame::HandleDrag(nsIPresContext& aPresContext, 
-                              nsGUIEvent*     aEvent,
-                              nsEventStatus&  aEventStatus)
-{
-  return NS_OK;
-}
-
-NS_IMETHODIMP 
-nsScrollbarFrame::HandleRelease(nsIPresContext& aPresContext, 
-                                 nsGUIEvent*     aEvent,
-                                 nsEventStatus&  aEventStatus)
-{
-  return NS_OK;
-}
-

mozilla/layout/xul/base/src/nsScrollbarFrame.h

@@ -1,85 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-//
-// nsScrollbarFrame
-//
-
-#ifndef nsScrollbarFrame_h__
-#define nsScrollbarFrame_h__
-
-
-#include "nsBoxFrame.h"
-#include "nsIAnonymousContentCreator.h"
-
-class nsISupportsArray;
-
-nsresult NS_NewScrollbarFrame(nsIFrame** aResult) ;
-
-class nsScrollbarFrame : public nsBoxFrame,
-                         public nsIAnonymousContentCreator
-{
-public:
-  nsScrollbarFrame() {}
-
-#ifdef DEBUG
-  NS_IMETHOD GetFrameName(nsString& aResult) const {
-    return MakeFrameName("ScrollbarFrame", aResult);
-  }
-#endif
-
-  // nsIFrame overrides
-  NS_IMETHOD AttributeChanged(nsIPresContext* aPresContext,
-                              nsIContent* aChild,
-                              PRInt32 aNameSpaceID,
-                              nsIAtom* aAttribute,
-                              PRInt32 aHint);
-
-  // nsIAnonymousConentCreator
-  NS_IMETHOD  CreateAnonymousContent(nsISupportsArray& aAnonymousItems);
-
-  NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr);
-  NS_IMETHOD_(nsrefcnt) AddRef() { return NS_OK; }
-  NS_IMETHOD_(nsrefcnt) Release() { return NS_OK; }
-
-   NS_IMETHOD HandlePress(nsIPresContext& aPresContext,
-                         nsGUIEvent *    aEvent,
-                         nsEventStatus&  aEventStatus);
-
-  NS_IMETHOD HandleMultiplePress(nsIPresContext& aPresContext,
-                         nsGUIEvent *    aEvent,
-                         nsEventStatus&  aEventStatus);
-
-  NS_IMETHOD HandleDrag(nsIPresContext& aPresContext,
-                        nsGUIEvent *    aEvent,
-                        nsEventStatus&  aEventStatus);
-
-  NS_IMETHOD HandleRelease(nsIPresContext& aPresContext,
-                           nsGUIEvent *    aEvent,
-                           nsEventStatus&  aEventStatus);
-
-  NS_IMETHOD Init(nsIPresContext&  aPresContext,
-              nsIContent*      aContent,
-              nsIFrame*        aParent,
-              nsIStyleContext* aContext,
-              nsIFrame*        aPrevInFlow);
-
-
-}; // class nsScrollbarFrame
-
-#endif

mozilla/layout/xul/base/src/nsSliderFrame.h

@@ -1,234 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-//
-// nsSliderFrame
-//
-
-#ifndef nsSliderFrame_h__
-#define nsSliderFrame_h__
-
-
-#include "nsHTMLContainerFrame.h"
-#include "prtypes.h"
-#include "nsIAtom.h"
-#include "nsCOMPtr.h"
-#include "nsIDOMMouseListener.h"
-#include "nsIAnonymousContentCreator.h"
-#include "nsITimerCallback.h"
-
-class nsString;
-class nsIScrollbarListener;
-class nsISupportsArray;
-class nsITimer;
-
-#define INITAL_REPEAT_DELAY 500
-#define REPEAT_DELAY        50
-
-nsresult NS_NewSliderFrame(nsIFrame** aResult) ;
-
-
-class nsSliderFrame : public nsHTMLContainerFrame, 
-                             nsIDOMMouseListener, 
-                             nsIAnonymousContentCreator,
-                             nsITimerCallback
-{
-public:
-  nsSliderFrame();
-  virtual ~nsSliderFrame();
-
-#ifdef DEBUG
-  NS_IMETHOD GetFrameName(nsString& aResult) const {
-    return MakeFrameName("SliderFrame", aResult);
-  }
-#endif
-
-  // nsIFrame overrides
-  NS_IMETHOD Destroy(nsIPresContext& aPresContext);
-
-  NS_IMETHOD Paint(nsIPresContext& aPresContext,
-                   nsIRenderingContext& aRenderingContext,
-                   const nsRect& aDirtyRect,
-                   nsFramePaintLayer aWhichLayer);
- 
-    NS_IMETHOD AttributeChanged(nsIPresContext* aPresContext,
-                              nsIContent* aChild,
-                              PRInt32 aNameSpaceID,
-                              nsIAtom* aAttribute,
-                              PRInt32 aHint);
-
-    virtual nsresult CurrentPositionChanged(nsIPresContext* aPresContext);
-
-     NS_IMETHOD  Init(nsIPresContext&  aPresContext,
-                   nsIContent*      aContent,
-                   nsIFrame*        aParent,
-                   nsIStyleContext* aContext,
-                   nsIFrame*        asPrevInFlow);
-
-       NS_IMETHOD  CreateAnonymousContent(nsISupportsArray& aAnonymousItems);
-
-   NS_IMETHOD Reflow(nsIPresContext&          aPresContext,
-                    nsHTMLReflowMetrics&     aDesiredSize,
-                    const nsHTMLReflowState& aReflowState,
-                    nsReflowStatus&          aStatus);
-
-     NS_IMETHOD  AppendFrames(nsIPresContext& aPresContext,
-                           nsIPresShell&   aPresShell,
-                           nsIAtom*        aListName,
-                           nsIFrame*       aFrameList);
-
-  NS_IMETHOD  InsertFrames(nsIPresContext& aPresContext,
-                           nsIPresShell&   aPresShell,
-                           nsIAtom*        aListName,
-                           nsIFrame*       aPrevFrame,
-                           nsIFrame*       aFrameList);
-
-  NS_IMETHOD  RemoveFrame(nsIPresContext& aPresContext,
-                          nsIPresShell&   aPresShell,
-                          nsIAtom*        aListName,
-                          nsIFrame*       aOldFrame);
-
-
-   NS_IMETHOD HandleEvent(nsIPresContext& aPresContext, 
-                         nsGUIEvent* aEvent,
-                         nsEventStatus& aEventStatus);
-
-    NS_IMETHOD GetFrameForPoint(nsIPresContext* aPresContext,
-                                const nsPoint& aPoint, nsIFrame** aFrame);
-
-    NS_IMETHOD SetInitialChildList(nsIPresContext& aPresContext,
-                                 nsIAtom*        aListName,
-                                 nsIFrame*       aChildList);
-
- /**
-  * Processes a mouse down event
-  * @param aMouseEvent @see nsIDOMEvent.h 
-  * @returns whether the event was consumed or ignored. @see nsresult
-  */
-  virtual nsresult MouseDown(nsIDOMEvent* aMouseEvent);
-
-  /**
-   * Processes a mouse up event
-   * @param aMouseEvent @see nsIDOMEvent.h 
-   * @returns whether the event was consumed or ignored. @see nsresult
-   */
-  virtual nsresult MouseUp(nsIDOMEvent* aMouseEvent);
-
-  /**
-   * Processes a mouse click event
-   * @param aMouseEvent @see nsIDOMEvent.h 
-   * @returns whether the event was consumed or ignored. @see nsresult
-   *
-   */
-  virtual nsresult MouseClick(nsIDOMEvent* aMouseEvent) { return NS_OK; }
-
-  /**
-   * Processes a mouse click event
-   * @param aMouseEvent @see nsIDOMEvent.h 
-   * @returns whether the event was consumed or ignored. @see nsresult
-   *
-   */
-  virtual nsresult MouseDblClick(nsIDOMEvent* aMouseEvent) { return NS_OK; }
-
-  /**
-   * Processes a mouse enter event
-   * @param aMouseEvent @see nsIDOMEvent.h 
-   * @returns whether the event was consumed or ignored. @see nsresult
-   */
-  virtual nsresult MouseOver(nsIDOMEvent* aMouseEvent) { return NS_OK; }
-
-  /**
-   * Processes a mouse leave event
-   * @param aMouseEvent @see nsIDOMEvent.h 
-   * @returns whether the event was consumed or ignored. @see nsresult
-   */
-  virtual nsresult MouseOut(nsIDOMEvent* aMouseEvent) { return NS_OK; }
-
-  NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr); 
-  NS_IMETHOD_(nsrefcnt) AddRef(void);
-  NS_IMETHOD_(nsrefcnt) Release(void);
-
-  virtual nsresult HandleEvent(nsIDOMEvent* aEvent) { return NS_OK; }
-
-  static PRInt32 GetCurrentPosition(nsIContent* content);
-  static PRInt32 GetMaxPosition(nsIContent* content);
-  static PRInt32 GetIncrement(nsIContent* content);
-  static PRInt32 GetPageIncrement(nsIContent* content);
-  static PRInt32 GetIntegerAttribute(nsIContent* content, nsIAtom* atom, PRInt32 defaultValue);
-  static PRInt32 IsHorizontal(nsIContent* content);
-
-  void SetScrollbarListener(nsIScrollbarListener* aListener);
-
-
-  NS_IMETHOD HandlePress(nsIPresContext& aPresContext,
-                         nsGUIEvent *    aEvent,
-                         nsEventStatus&  aEventStatus);
-
-  NS_IMETHOD HandleMultiplePress(nsIPresContext& aPresContext,
-                         nsGUIEvent *    aEvent,
-                         nsEventStatus&  aEventStatus)  { return NS_OK; }
-
-  NS_IMETHOD HandleDrag(nsIPresContext& aPresContext,
-                        nsGUIEvent *    aEvent,
-                        nsEventStatus&  aEventStatus)  { return NS_OK; }
-
-  NS_IMETHOD HandleRelease(nsIPresContext& aPresContext,
-                           nsGUIEvent *    aEvent,
-                           nsEventStatus&  aEventStatus);
-
-  virtual void Notify(nsITimer *timer);
-
-protected:
-
-  virtual nsresult ReflowThumb(nsIPresContext&   aPresContext,
-                     nsHTMLReflowMetrics&     aDesiredSize,
-                     const nsHTMLReflowState& aReflowState,
-                     nsReflowStatus&          aStatus,
-                     nsIFrame* thumbFrame,
-                     nsSize available,
-                     nsSize computed);
-
-  virtual PRIntn GetSkipSides() const { return 0; }
-
- 
-private:
-
-  nsIContent* GetScrollBar();
-  void PageUpDown(nsIFrame* aThumbFrame, nscoord change);
-  void SetCurrentPosition(nsIContent* scrollbar, nsIFrame* aThumbFrame, nscoord pos);
-  NS_IMETHOD DragThumb(nsIPresContext* aPresContext, PRBool aGrabMouseEvents);
-  void AddListener();
-  void RemoveListener();
-  PRBool isDraggingThumb(nsIPresContext* aPresContext);
-
-  float mRatio;
-
-  nscoord mDragStartPx;
-  nscoord mThumbStart;
-
-  PRInt32 mCurPos;
-
-  nsIScrollbarListener* mScrollbarListener;
-
-  // XXX Hack
-  nsIPresContext* mPresContext;  // weak reference
-
-  static nscoord gChange;
-}; // class nsSliderFrame
-
-#endif

mozilla/layout/xul/base/src/nsSpinnerFrame.cpp

@@ -1,111 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-
-#include "nsSpinnerFrame.h"
-
-#include "nsIContent.h"
-#include "prtypes.h"
-#include "nsIAtom.h"
-#include "nsIPresContext.h"
-#include "nsIStyleContext.h"
-#include "nsCSSRendering.h"
-#include "nsINameSpaceManager.h"
-
-
-//
-// NS_NewSpinnerFrame
-//
-// Wrapper for creating a new spinner
-//
-nsresult
-NS_NewSpinnerFrame(nsIFrame** aNewFrame)
-{
-  NS_PRECONDITION(aNewFrame, "null OUT ptr");
-  if (nsnull == aNewFrame) {
-    return NS_ERROR_NULL_POINTER;
-  }
-  nsSpinnerFrame* it = new nsSpinnerFrame;
-  if ( !it )
-    return NS_ERROR_OUT_OF_MEMORY;
-  *aNewFrame = it;
-  return NS_OK;
-}
-
-
-//
-// nsSpinnerFrame cntr
-//
-nsSpinnerFrame::nsSpinnerFrame()
-{
-
-} // cntr
-
-
-//
-// Paint
-//
-// Overidden to handle ???
-//
-NS_METHOD 
-nsSpinnerFrame::Paint(nsIPresContext& aPresContext,
-                              nsIRenderingContext& aRenderingContext,
-                              const nsRect& aDirtyRect,
-                              nsFramePaintLayer aWhichLayer)
-{
-  return nsLeafFrame::Paint(aPresContext, aRenderingContext, aDirtyRect, aWhichLayer);
-}
-
-
-//
-// GetDesiredSize
-//
-// For now, be as big as CSS wants us to be, or some small default size.
-//
-void
-nsSpinnerFrame :: GetDesiredSize(nsIPresContext* aPresContext,
-                                           const nsHTMLReflowState& aReflowState,
-                                           nsHTMLReflowMetrics& aDesiredLayoutSize)
-{
-  const int CSS_NOTSET = -1;
-
-  nsSize styleSize;
-  if (NS_UNCONSTRAINEDSIZE != aReflowState.mComputedWidth) {
-    styleSize.width = aReflowState.mComputedWidth;
-  }
-  else {
-    styleSize.width = CSS_NOTSET;
-  }
-  if (NS_UNCONSTRAINEDSIZE != aReflowState.mComputedHeight) {
-    styleSize.height = aReflowState.mComputedHeight;
-  }
-  else {
-    styleSize.height = CSS_NOTSET;
-  }
-
-  // subclasses should always override this method, but if not and no css, make it small
-  aDesiredLayoutSize.width  = (styleSize.width  > CSS_NOTSET) ? styleSize.width  : 200;
-  aDesiredLayoutSize.height = (styleSize.height > CSS_NOTSET) ? styleSize.height : 200;
-  aDesiredLayoutSize.ascent = aDesiredLayoutSize.height;
-  aDesiredLayoutSize.descent = 0;
-  if (aDesiredLayoutSize.maxElementSize) {
-    aDesiredLayoutSize.maxElementSize->width  = aDesiredLayoutSize.width;
-    aDesiredLayoutSize.maxElementSize->height = aDesiredLayoutSize.height;
-  }
-
-} // GetDesiredSize

mozilla/layout/xul/base/src/nsSpinnerFrame.h

@@ -1,63 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-//
-// nsSpinnerFrame
-//
-
-#ifndef nsSpinnerFrame_h__
-#define nsSpinnerFrame_h__
-
-
-#include "nsLeafFrame.h"
-#include "prtypes.h"
-#include "nsIAtom.h"
-#include "nsCOMPtr.h"
-
-class nsString;
-
-
-nsresult NS_NewSpinnerFrame(nsIFrame** aResult) ;
-
-
-class nsSpinnerFrame : public nsLeafFrame
-{
-public:
-  nsSpinnerFrame();
-
-#ifdef DEBUG
-  NS_IMETHOD GetFrameName(nsString& aResult) const {
-    return MakeFrameName("SpinnerFrame", aResult);
-  }
-#endif
-
-  // nsIFrame overrides
-  NS_IMETHOD Paint(nsIPresContext& aPresContext,
-                   nsIRenderingContext& aRenderingContext,
-                   const nsRect& aDirtyRect,
-                   nsFramePaintLayer aWhichLayer);
-  
-protected:
-
-  virtual void GetDesiredSize(nsIPresContext* aPresContext,
-                              const nsHTMLReflowState& aReflowState,
-                              nsHTMLReflowMetrics& aDesiredSize) ;
-
-}; // class nsSpinnerFrame
-
-#endif

mozilla/layout/xul/base/src/nsSplitterFrame.h

@@ -1,103 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-//
-// nsSplitterFrame
-//
-
-#ifndef nsSplitterFrame_h__
-#define nsSplitterFrame_h__
-
-
-#include "nsBoxFrame.h"
-#include "nsIAnonymousContentCreator.h"
-
-class nsISupportsArray;
-class nsSplitterFrameImpl;
-
-nsresult NS_NewSplitterFrame(nsIFrame** aResult) ;
-
-class nsSplitterFrame : public nsBoxFrame, public nsIAnonymousContentCreator
-{
-public:
-  nsSplitterFrame();
-  ~nsSplitterFrame();
-
-#ifdef DEBUG
-  NS_IMETHOD GetFrameName(nsString& aResult) const {
-    return MakeFrameName("SplitterFrame", aResult);
-  }
-#endif
-
-  // nsIFrame overrides
-  NS_IMETHOD AttributeChanged(nsIPresContext* aPresContext,
-                              nsIContent* aChild,
-                              PRInt32 aNameSpaceID,
-                              nsIAtom* aAttribute,
-                              PRInt32 aHint);
-
-  NS_IMETHOD  Init(nsIPresContext&  aPresContext,
-                                    nsIContent*      aContent,
-                                    nsIFrame*        aParent,
-                                    nsIStyleContext* aContext,
-                                    nsIFrame*        aPrevInFlow);
-
-  NS_IMETHOD GetCursor(nsIPresContext& aPresContext,
-                                     nsPoint&        aPoint,
-                                     PRInt32&        aCursor);
-
-
-  // nsIAnonymousContentCreator
-  NS_IMETHOD  CreateAnonymousContent(nsISupportsArray& aAnonymousItems);
-  NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr); 
-  NS_IMETHOD_(nsrefcnt) AddRef(void) { return NS_OK; }
-  NS_IMETHOD_(nsrefcnt) Release(void) { return NS_OK; }
-
-   NS_IMETHOD HandlePress(nsIPresContext& aPresContext,
-                         nsGUIEvent *    aEvent,
-                         nsEventStatus&  aEventStatus);
-
-  NS_IMETHOD HandleMultiplePress(nsIPresContext& aPresContext,
-                         nsGUIEvent *    aEvent,
-                         nsEventStatus&  aEventStatus);
-
-  NS_IMETHOD HandleDrag(nsIPresContext& aPresContext,
-                        nsGUIEvent *    aEvent,
-                        nsEventStatus&  aEventStatus);
-
-  NS_IMETHOD HandleRelease(nsIPresContext& aPresContext,
-                           nsGUIEvent *    aEvent,
-                           nsEventStatus&  aEventStatus);
-
-  NS_IMETHOD HandleEvent(nsIPresContext& aPresContext, 
-                         nsGUIEvent* aEvent,
-                         nsEventStatus& aEventStatus);
-
-  NS_IMETHOD GetFrameForPoint(nsIPresContext* aPresContext, const nsPoint& aPoint, nsIFrame** aFrame);
-
-
-private:
-
-  friend class nsSplitterFrameImpl;
-  nsSplitterFrameImpl* mImpl;
-  // XXX Hack
-  nsIPresContext* mPresContext;  // weak reference
-
-}; // class nsSplitterFrame
-
-#endif

mozilla/layout/xul/base/src/nsStdColorPicker.cpp

@@ -1,256 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Mozilla browser.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation. Portions created by Netscape are
- * Copyright (C) 1999 Netscape Communications Corporation. All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *   Stuart Parmenter <pavlov@netscape.com>
- */
-
-#include "nsStdColorPicker.h"
-#include "nsColor.h"
-#include "nsCRT.h"
-
-#include "nsXULAtoms.h"
-#include "nsIDOMElement.h"
-#include "nsIContent.h"
-#include "prtypes.h"
-#include "nsIAtom.h"
-#include "nsIPresContext.h"
-#include "nsIStyleContext.h"
-#include "nsCSSRendering.h"
-#include "nsINameSpaceManager.h"
-
-static char *NosePalette[] = {
-  "#00FF00","#00ED00","#00DB00","#00C900","#00B700","#00A500","#009300","#008100","#006F00","#005D00",
-  "#FFFF00","#EDED00","#DBDB00","#C9C900","#B7B700","#A5A500","#939300","#818100","#6F6F00","#5D5D00",
-  "#FFFF00","#F5ED00","#EBDB00","#E1C900","#D7B700","#CDA500","#C39300","#B98100","#AF6F00","#A55D00"
-};
-
-static char* StandardPalette[] = {
-  "#FFFFFF","#FFCCCC","#FFCC99","#FFFF99","#FFFFCC","#99FF99","#99FFFF","#CCFFFF","#CCCCFF","#FFCCFF",
-  "#CCCCCC","#FF6666","#FFCC33","#FFFF66","#FFFF99","#66FF99","#33FFFF","#66FFFF","#9999FF","#FF99FF",
-  "#C0C0C0","#FF0000","#FF9900","#FFCC66","#FFFF00","#33FF33","#66CCCC","#33CCFF","#6666CC","#CC66CC",
-  "#999999","#CC0000","#FF6600","#FFCC33","#FFCC00","#33CC00","#00CCCC","#3366FF","#6633FF","#CC33CC",
-  "#666666","#990000","#CC6600","#CC9933","#999900","#009900","#339999","#3333FF","#6600CC","#993399",
-  "#333333","#660000","#993300","#996633","#666600","#006600","#336666","#000099","#333399","#663366",
-  "#000000","#330000","#663300","#663333","#333300","#003300","#003333","#000066","#330099","#330033"
-};
-
-static char *WebPalette[] = {
-  "#FFFFFF", "#FFFFCC", "#FFFF99", "#FFFF66", "#FFFF33", "#FFFF00", "#FFCCFF", "#FFCCCC",
-  "#FFCC99", "#FFCC66", "#FFCC33", "#FFCC00", "#FF99FF", "#FF99CC", "#FF9999", "#FF9966",
-  "#FF9933", "#FF9900", "#FF66FF", "#FF66CC", "#FF6699", "#FF6666", "#FF6633", "#FF6600",
-  "#FF33FF", "#FF33CC", "#FF3399", "#FF3366", "#FF3333", "#FF3300", "#FF00FF", "#FF00CC",
-  "#FF0099", "#FF0066", "#FF0033", "#FF0000", "#CCFFFF", "#CCFFCC", "#CCFF99", "#CCFF66",
-  "#CCFF33", "#CCFF00", "#CCCCFF", "#CCCCCC", "#CCCC99", "#CCCC66", "#CCCC33", "#CCCC00",
-  "#CC99FF", "#CC99CC", "#CC9999", "#CC9966", "#CC9933", "#CC9900", "#CC66FF", "#CC66CC",
-  "#CC6699", "#CC6666", "#CC6633", "#CC6600", "#CC33FF", "#CC33CC", "#CC3399", "#CC3366",
-  "#CC3333", "#CC3300", "#CC00FF", "#CC00CC", "#CC0099", "#CC0066", "#CC0033", "#CC0000",
-  "#99FFFF", "#99FFCC", "#99FF99", "#99FF66", "#99FF33", "#99FF00", "#99CCFF", "#99CCCC",
-  "#99CC99", "#99CC66", "#99CC33", "#99CC00", "#9999FF", "#9999CC", "#999999", "#999966",
-  "#999933", "#999900", "#9966FF", "#9966CC", "#996699", "#996666", "#996633", "#996600",
-  "#9933FF", "#9933CC", "#993399", "#993366", "#993333", "#993300", "#9900FF", "#9900CC",
-  "#990099", "#990066", "#990033", "#990000", "#66FFFF", "#66FFCC", "#66FF99", "#66FF66",
-  "#66FF33", "#66FF00", "#66CCFF", "#66CCCC", "#66CC99", "#66CC66", "#66CC33", "#66CC00",
-  "#6699FF", "#6699CC", "#669999", "#669966", "#669933", "#669900", "#6666FF", "#6666CC",
-  "#666699", "#666666", "#666633", "#666600", "#6633FF", "#6633CC", "#663399", "#663366",
-  "#663333", "#663300", "#6600FF", "#6600CC", "#660099", "#660066", "#660033", "#660000",
-  "#33FFFF", "#33FFCC", "#33FF99", "#33FF66", "#33FF33", "#33FF00", "#33CCFF", "#33CCCC",
-  "#33CC99", "#33CC66", "#33CC33", "#33CC00", "#3399FF", "#3399CC", "#339999", "#339966",
-  "#339933", "#339900", "#3366FF", "#3366CC", "#336699", "#336666", "#336633", "#336600",
-  "#3333FF", "#3333CC", "#333399", "#333366", "#333333", "#333300", "#3300FF", "#3300CC",
-  "#330099", "#330066", "#330033", "#330000", "#00FFFF", "#00FFCC", "#00FF99", "#00FF66",
-  "#00FF33", "#00FF00", "#00CCFF", "#00CCCC", "#00CC99", "#00CC66", "#00CC33", "#00CC00",
-  "#0099FF", "#0099CC", "#009999", "#009966", "#009933", "#009900", "#0066FF", "#0066CC",
-  "#006699", "#006666", "#006633", "#006600", "#0033FF", "#0033CC", "#003399", "#003366",
-  "#003333", "#003300", "#0000FF", "#0000CC", "#000099", "#000066", "#000033", "#000000"
-};
-
-static char *GrayPalette[] = {
-  "#000000", "#010101", "#020202", "#030303", "#040404", "#050505", "#060606", "#070707", 
-  "#080808", "#090909", "#0A0A0A", "#0B0B0B", "#0C0C0C", "#0D0D0D", "#0E0E0E", "#0F0F0F", 
-  "#101010", "#111111", "#121212", "#131313", "#141414", "#151515", "#161616", "#171717", 
-  "#181818", "#191919", "#1A1A1A", "#1B1B1B", "#1C1C1C", "#1D1D1D", "#1E1E1E", "#1F1F1F", 
-  "#202020", "#212121", "#222222", "#232323", "#242424", "#252525", "#262626", "#272727", 
-  "#282828", "#292929", "#2A2A2A", "#2B2B2B", "#2C2C2C", "#2D2D2D", "#2E2E2E", "#2F2F2F", 
-  "#303030", "#313131", "#323232", "#333333", "#343434", "#353535", "#363636", "#373737", 
-  "#383838", "#393939", "#3A3A3A", "#3B3B3B", "#3C3C3C", "#3D3D3D", "#3E3E3E", "#3F3F3F", 
-  "#404040", "#414141", "#424242", "#434343", "#444444", "#454545", "#464646", "#474747", 
-  "#484848", "#494949", "#4A4A4A", "#4B4B4B", "#4C4C4C", "#4D4D4D", "#4E3E3E", "#4F4F4F", 
-  "#505050", "#515151", "#525252", "#534343", "#545454", "#555555", "#565656", "#575757", 
-  "#585858", "#595959", "#5A5A5A", "#5B5B5B", "#5C5C5C", "#5D5D5D", "#5E5E5E", "#5F5F5F", 
-  "#606060", "#616161", "#626262", "#636363", "#646464", "#656565", "#666666", "#676767", 
-  "#686868", "#696969", "#6A6A6A", "#6B6B6B", "#6C6C6C", "#6D6D6D", "#6E6E6E", "#6F6F6F", 
-  "#707070", "#717171", "#727272", "#737373", "#747474", "#757575", "#767676", "#777777", 
-  "#787878", "#797979", "#7A7A7A", "#7B7B7B", "#7C7C7C", "#7D7D7D", "#7E7E7E", "#7F7F7F", 
-  "#808080", "#818181", "#828282", "#838383", "#848484", "#858585", "#868686", "#878787", 
-  "#888888", "#898989", "#8A8A8A", "#8B8B8B", "#8C8C8C", "#8D8D8D", "#8E8E8E", "#8F8F8F", 
-  "#909090", "#919191", "#929292", "#939393", "#949494", "#959595", "#969696", "#979797", 
-  "#989898", "#999999", "#9A9A9A", "#9B9B9B", "#9C9C9C", "#9D9D9D", "#9E9E9E", "#9F9F9F", 
-  "#A0A0A0", "#A1A1A1", "#A2A2A2", "#A3A3A3", "#A4A4A4", "#A5A5A5", "#A6A6A6", "#A7A7A7", 
-  "#A8A8A8", "#A9A9A9", "#AAAAAA", "#ABABAB", "#ACACAC", "#ADADAD", "#AEAEAE", "#AFAFAF", 
-  "#B0B0B0", "#B1B1B1", "#B2B2B2", "#B3B3B3", "#B4B4B4", "#B5B5B5", "#B6B6B6", "#B7B7B7", 
-  "#B8B8B8", "#B9B9B9", "#BABABA", "#BBBBBB", "#BCBCBC", "#BDBDBD", "#BEBEBE", "#BFBFBF", 
-  "#C0C0C0", "#C1C1C1", "#C2C2C2", "#C3C3C3", "#C4C4C4", "#C5C5C5", "#C6C6C6", "#C7C7C7", 
-  "#C8C8C8", "#C9C9C9", "#CACACA", "#CBCBCB", "#CCCCCC", "#CDCDCD", "#CECECE", "#CFCFCF", 
-  "#D0D0D0", "#D1D1D1", "#D2D2D2", "#D3D3D3", "#D4D4D4", "#D5D5D5", "#D6D6D6", "#D7D7D7", 
-  "#D8D8D8", "#D9D9D9", "#DADADA", "#DBDBDB", "#DCDCDC", "#DDDDDD", "#DEDEDE", "#DFDFDF", 
-  "#E0E0E0", "#E1E1E1", "#E2E2E2", "#E3E3E3", "#E4E4E4", "#E5E5E5", "#E6E6E6", "#E7E7E7", 
-  "#E8E8E8", "#E9E9E9", "#EAEAEA", "#EBEBEB", "#ECECEC", "#EDEDED", "#EEEEEE", "#EFEFEF", 
-  "#F0F0F0", "#F1F1F1", "#F2F2F2", "#F3F3F3", "#F4F4F4", "#F5F5F5", "#F6F6F6", "#F7F7F7", 
-  "#F8F8F8", "#F9F9F9", "#FAFAFA", "#FBFBFB", "#FCFCFC", "#FDFDFD", "#FEFEFE", "#FFFFFF"
-};
-
-NS_IMPL_ISUPPORTS1(nsStdColorPicker, nsIColorPicker)
-
-nsStdColorPicker::nsStdColorPicker()
-{
-  mColors = 0;
-
-  mNumCols = 0;
-  mNumRows = 0;
-
-  mFrameWidth = 0;
-  mFrameHeight = 0;
-
-  mBlockWidth = 20;
-  mBlockHeight = 20;
-}
-
-nsStdColorPicker::~nsStdColorPicker()
-{
-
-}
-
-NS_IMETHODIMP nsStdColorPicker::Init(nsIContent *aContent)
-{
-  nsAutoString palette;
-  aContent->GetAttribute(kNameSpaceID_None, nsXULAtoms::palettename, palette);
-
-  if (palette.EqualsIgnoreCase("web"))
-  {
-    printf("web picked\n");
-    mPalette = WebPalette;
-    mNumCols = 12;
-    mColors = sizeof(WebPalette) / sizeof(char *);
-  }
-  else if (palette.EqualsIgnoreCase("nose"))
-  {
-    printf("nose picked\n");
-    mPalette = NosePalette;
-    mNumCols = 10;
-    mColors = sizeof(NosePalette) / sizeof(char *);
-  }
-  else if (palette.EqualsIgnoreCase("gray") || palette.EqualsIgnoreCase("grey"))
-  {
-    printf("gray picked\n");
-    mPalette = GrayPalette;
-    mNumCols = 10;
-    mColors = sizeof(GrayPalette) / sizeof(char *);
-  }
-  else
-  {
-    printf("standard picked\n");
-    mPalette = StandardPalette;
-    mNumCols = 10;
-    mColors = sizeof(StandardPalette) / sizeof(char *);
-  }
-
-  mNumRows = NSToIntCeil(nscoord(mColors/mNumCols)) - 1;
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP nsStdColorPicker::Paint(nsIPresContext * aPresContext, nsIRenderingContext * aRenderingContext)
-{
-  int i = 0;
-  int row = 0;
-  int col = 0;
-  nscolor color = 0;
-  float p2t;
-  PRInt32 width, height;
-
-  aPresContext->GetScaledPixelsToTwips(&p2t);
-
-  width = NSToIntRound(mBlockWidth * p2t);
-  height = NSToIntRound(mBlockHeight * p2t);
-
-  //  aRenderingContext->SetColor(0);
-  //  aRenderingContext->FillRect(0, 0, (mNumCols)*width, mNumRows*height);
-
-  for (i=0;i<mColors;i++)
-  {
-    NS_LooseHexToRGB(mPalette[i], &color);
-
-    aRenderingContext->SetColor(color);
-    aRenderingContext->FillRect(col*width, row*height, width, height);
-
-    if (col+1 == mNumCols)
-    {
-      col = 0;
-      row++;
-    }
-    else
-      col++;
-  }
-
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP nsStdColorPicker::GetColor(PRInt32 aX, PRInt32 aY, char **aColor)
-{
-  int cur_col = aX / mBlockWidth;
-  int cur_row = aY / mBlockHeight;
-
-  int f = mNumCols * cur_row + cur_col;
-
-  if (f >= mColors)
-  {
-    return NS_ERROR_FAILURE;
-  }
-
-  *aColor = nsCRT::strdup(mPalette[f]);
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP nsStdColorPicker::SetSize(PRInt32 aWidth, PRInt32 aHeight)
-{
-  mFrameWidth = aWidth;
-  mFrameHeight = aHeight;
-
-  if (aWidth != -1)
-    mBlockWidth = NSToIntRound(nscoord(aWidth / mNumCols));
-
-  if (aWidth != -1)
-    mBlockHeight = NSToIntRound(nscoord(aHeight / mNumRows));
-
-  mFrameWidth = NSToIntRound(nscoord((mNumCols) * mBlockWidth));
-  mFrameHeight = NSToIntRound(nscoord((mNumRows) * mBlockHeight));
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP nsStdColorPicker::GetSize(PRInt32 *aWidth, PRInt32 *aHeight)
-{
-  *aWidth = mFrameWidth;
-  *aHeight = mFrameHeight;
-
-  return NS_OK;
-}

mozilla/layout/xul/base/src/nsStdColorPicker.h

@@ -1,55 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Mozilla browser.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation. Portions created by Netscape are
- * Copyright (C) 1999 Netscape Communications Corporation. All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *   Stuart Parmenter <pavlov@netscape.com>
- */
-
-
-#ifndef __nsStdColorPicker_h__
-#define __nsStdColorPicker_h__
-
-#include "nsISupports.h"
-#include "nsrootidl.h"
-#include "nsIPresContext.h"
-#include "nsIRenderingContext.h"
-#include "nsIColorPicker.h"
-
-class nsStdColorPicker : public nsIColorPicker {
-public: 
-  nsStdColorPicker();
-  virtual ~nsStdColorPicker();
-
-  NS_DECL_ISUPPORTS
-
-  NS_DECL_NSICOLORPICKER
-
-private:
-  char  **mPalette;
-  PRInt32 mColors;
-
-  PRInt32 mNumCols;
-  PRInt32 mNumRows;
-  PRInt32 mBlockWidth;
-  PRInt32 mBlockHeight;
-  PRInt32 mFrameWidth;
-  PRInt32 mFrameHeight;
-};
-
-#endif /* __nsStdColorPicker_h__ */

mozilla/layout/xul/base/src/nsTabFrame.cpp

@@ -1,173 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-//
-// Eric Vaughan
-// Netscape Communications
-//
-// See documentation in associated header file
-//
-
-#include "nsTabFrame.h"
-#include "nsIStyleContext.h"
-#include "nsIPresContext.h"
-#include "nsIContent.h"
-#include "nsCOMPtr.h"
-#include "nsHTMLIIDs.h"
-#include "nsUnitConversion.h"
-#include "nsINameSpaceManager.h"
-#include "nsHTMLAtoms.h"
-#include "nsXULAtoms.h"
-#include "nsIReflowCommand.h"
-#include <stdio.h>
-
-//
-// NS_NewToolbarFrame
-//
-// Creates a new Toolbar frame and returns it in |aNewFrame|
-//
-nsresult
-NS_NewTabFrame ( nsIFrame** aNewFrame )
-{
-  NS_PRECONDITION(aNewFrame, "null OUT ptr");
-  if (nsnull == aNewFrame) {
-    return NS_ERROR_NULL_POINTER;
-  }
-  nsTabFrame* it = new nsTabFrame;
-  if (nsnull == it)
-    return NS_ERROR_OUT_OF_MEMORY;
-
-  *aNewFrame = it;
-  return NS_OK;
-  
-} // NS_NewTabFrame
-
-void
-nsTabFrame::MouseClicked(nsIPresContext* aPresContext) 
-{
-   // get our index
-   PRInt32 index = 0;
-   GetIndexInParent(mContent, index);
-
-   // get the tab control
-   nsIContent* tabcontrol = nsnull;
-   GetTabControl(mContent, tabcontrol);
-
-   // get the tab panel
-   nsIContent* tabpanel = nsnull;
-   GetChildWithTag(nsXULAtoms::tabpanel, tabcontrol, tabpanel);
-
-   if (!tabpanel) {
-	return;
-   }
-
-   // unselect the old tab
-
-   // get the current index
-   nsAutoString v;
-   PRInt32 error;
-   tabpanel->GetAttribute(kNameSpaceID_None, nsHTMLAtoms::index, v);
-   PRInt32 oldIndex = v.ToInteger(&error);
-
-   if (oldIndex != index)
-   {
-      // get the tab box
-      nsIContent* parent;
-      mContent->GetParent(parent);
-
-      // get child
-      nsIContent* child;
-      parent->ChildAt(oldIndex, child);
-
-      // set the old tab to be unselected
-      child->SetAttribute(kNameSpaceID_None, nsHTMLAtoms::selected, "false", PR_TRUE);
-
-      // set the new tab to be selected
-      mContent->SetAttribute(kNameSpaceID_None, nsHTMLAtoms::selected, "true", PR_TRUE);
-   }
-
-   // set the panels index
-   char value[100];
-   sprintf(value, "%d", index);
-
-   tabpanel->SetAttribute(kNameSpaceID_None, nsHTMLAtoms::index, value, PR_TRUE);
-
-}
-
-nsresult
-nsTabFrame::GetChildWithTag(nsIAtom* atom, nsIContent* start, nsIContent*& tabpanel)
-{
-  // recursively search our children
-  PRInt32 count = 0;
-  start->ChildCount(count); 
-  for (PRInt32 i = 0; i < count; i++)
-  {
-     nsIContent* child = nsnull;
-     start->ChildAt(i,child);
-
-     // see if it is the child
-     nsCOMPtr<nsIAtom> tag;
-     child->GetTag(*getter_AddRefs(tag));
-     if (tag.get() == atom)
-     {
-       tabpanel = child;
-       return NS_OK;
-     }
-
-     // recursive search the child
-     nsIContent* found = nsnull;
-     GetChildWithTag(atom, child, found);
-     if (found != nsnull) {
-       tabpanel = found;
-       return NS_OK;
-     }
-  }
-
-  tabpanel = nsnull;
-  return NS_OK;
-}
-
-nsresult
-nsTabFrame::GetTabControl(nsIContent* content, nsIContent*& tabcontrol)
-{
-   while(nsnull != content)
-   {
-      content->GetParent(content);
-
-      if (content) {
-        nsCOMPtr<nsIAtom> atom;
-        if (content->GetTag(*getter_AddRefs(atom)) == NS_OK && atom.get() == nsXULAtoms::tabcontrol) {
-           tabcontrol = content;
-           return NS_OK;
-        }
-      }
-   }
-
-   tabcontrol = nsnull;
-   return NS_OK;
-}
-
-nsresult
-nsTabFrame::GetIndexInParent(nsIContent* content, PRInt32& index)
-{
-   nsIContent* parent;
-   content->GetParent(parent);
-   return parent->IndexOf(content, index);
-}
-

mozilla/layout/xul/base/src/nsTabFrame.h

@@ -1,78 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-/**
-
-  Eric D Vaughan
-  This class lays out its children either vertically or horizontally
- 
-**/
-
-#ifndef nsTabFrame_h___
-#define nsTabFrame_h___
-
-#include "nsHTMLButtonControlFrame.h"
-
-class nsTabControlFrame;
-
-class nsTabFrame : public nsHTMLButtonControlFrame
-{
-public:
-
-  friend nsresult NS_NewTabFrame(nsIFrame** aNewFrame);
-
- 
-  virtual void MouseClicked(nsIPresContext* aPresContext);
-
-protected:
-
-  virtual nsresult GetChildWithTag(nsIAtom* atom, nsIContent* start, nsIContent*& tabpanel);
-  virtual nsresult GetTabControl(nsIContent* content, nsIContent*& tabcontrol);
-  virtual nsresult GetIndexInParent(nsIContent* content, PRInt32& index);
- // Selection Methods
-  // XXX Doc me... (in nsIFrame.h puhleeze)
-  // XXX If these are selection specific, then the name should imply selection
-  // rather than generic event processing, e.g., SelectionHandlePress...
-  NS_IMETHOD HandlePress(nsIPresContext& aPresContext,
-                         nsGUIEvent *    aEvent,
-                         nsEventStatus&  aEventStatus) { return NS_OK; }
-
-  NS_IMETHOD HandleMultiplePress(nsIPresContext& aPresContext,
-                         nsGUIEvent *    aEvent,
-                         nsEventStatus&  aEventStatus)  { return NS_OK; }
-
-
-  NS_IMETHOD HandleDrag(nsIPresContext& aPresContext,
-                        nsGUIEvent *    aEvent,
-                        nsEventStatus&  aEventStatus) { return NS_OK; }
-
-  NS_IMETHOD HandleRelease(nsIPresContext& aPresContext,
-                           nsGUIEvent *    aEvent,
-                           nsEventStatus&  aEventStatus)  { return NS_OK; }
-
-private:
-   
-  nsTabControlFrame* mTabControlFrame;
-
-}; // class nsTabFrame
-
-
-
-#endif
-

mozilla/layout/xul/base/src/nsTitledButtonFrame.h

@@ -1,180 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-#ifndef nsTitledButtonFrame_h___
-#define nsTitledButtonFrame_h___
-
-#include "nsHTMLImageLoader.h"
-#include "nsLeafFrame.h"
-#include "nsIBox.h"
-
-class nsIPopUpMenu;
-class nsTitledButtonRenderer;
-
-class nsTitledButtonFrame : public nsLeafFrame, public nsIBox
-{
-public:
-
-  enum CroppingStyle { CropNone, CropLeft, CropRight, CropCenter };
-
-  friend nsresult NS_NewTitledButtonFrame(nsIFrame** aNewFrame);
-
-  // nsIBox frame interface
-  NS_IMETHOD GetBoxInfo(nsIPresContext& aPresContext, const nsHTMLReflowState& aReflowState, nsBoxInfo& aSize);
-  NS_IMETHOD Dirty(nsIPresContext& aPresContext, const nsHTMLReflowState& aReflowState, nsIFrame*& incrementalChild);
-
-  NS_DECL_ISUPPORTS
-
-  NS_IMETHOD  Init(nsIPresContext&  aPresContext,
-                   nsIContent*      aContent,
-                   nsIFrame*        aParent,
-                   nsIStyleContext* aContext,
-                   nsIFrame*        asPrevInFlow);
-
-  NS_IMETHOD AttributeChanged(nsIPresContext* aPresContext,
-                              nsIContent* aChild,
-                              PRInt32 aNameSpaceID,
-                              nsIAtom* aAttribute,
-                              PRInt32 aHint);
-
-  NS_IMETHOD  GetAdditionalStyleContext(PRInt32 aIndex, 
-                                        nsIStyleContext** aStyleContext) const;
-  NS_IMETHOD  SetAdditionalStyleContext(PRInt32 aIndex, 
-                                        nsIStyleContext* aStyleContext);
-  NS_IMETHOD  DidSetStyleContext (nsIPresContext* aPresContext);
-
-  NS_IMETHOD Destroy(nsIPresContext& aPresContext);
-
-  NS_IMETHOD GetFrameName(nsString& aResult) const;
-
-  virtual void UpdateAttributes(nsIPresContext&  aPresContext);
-  virtual void UpdateImage(nsIPresContext&  aPresContext);
-
-  // nsIHTMLReflow overrides
-  NS_IMETHOD Reflow(nsIPresContext&          aPresContext,
-                    nsHTMLReflowMetrics&     aDesiredSize,
-                    const nsHTMLReflowState& aReflowState,
-                    nsReflowStatus&          aStatus);
-
-  NS_IMETHOD  Paint(nsIPresContext& aPresContext,
-                    nsIRenderingContext& aRenderingContext,
-                    const nsRect& aDirtyRect,
-                    nsFramePaintLayer aWhichLayer);
-
-  NS_IMETHOD HandleEvent(nsIPresContext& aPresContext, 
-                         nsGUIEvent* aEvent,
-                         nsEventStatus& aEventStatus);
-
- 
-  ~nsTitledButtonFrame();
-protected:
-
-  enum CheckState { eUnset, eOff, eOn, eMixed } ;
-
-  CheckState GetCurrentCheckState();
-  void SetCurrentCheckState(CheckState aState);
-  void UpdateAccessUnderline();
-
-  virtual void MouseClicked(nsIPresContext & aPresContext);
-
-  NS_IMETHOD  PaintTitle(nsIPresContext& aPresContext,
-                         nsIRenderingContext& aRenderingContext,
-                         const nsRect& aDirtyRect,
-                         nsFramePaintLayer aWhichLayer);
-
-  NS_IMETHOD  PaintImage(nsIPresContext& aPresContext,
-                         nsIRenderingContext& aRenderingContext,
-                         const nsRect& aDirtyRect,
-                         nsFramePaintLayer aWhichLayer);
-
-  virtual void LayoutTitleAndImage(nsIPresContext& aPresContext,
-                                   nsIRenderingContext& aRenderingContext,
-                                   const nsRect& aDirtyRect,
-                                   nsFramePaintLayer aWhichLayer);
-
-  virtual void GetDesiredSize(nsIPresContext* aPresContext,
-                              const nsHTMLReflowState& aReflowState,
-                              nsHTMLReflowMetrics& aDesiredSize);
-
-
-  void DisplayAltFeedback(nsIPresContext&      aPresContext,
-                          nsIRenderingContext& aRenderingContext,
-                          PRInt32              aIconId);
-  void DisplayAltText(nsIPresContext&      aPresContext,
-                      nsIRenderingContext& aRenderingContext,
-                      const nsString&      aAltText,
-                      const nsRect&        aRect);
-
-  void MeasureString(const PRUnichar*     aString,
-                     PRInt32              aLength,
-                     nscoord              aMaxWidth,
-                     PRUint32&            aMaxFit,
-                     nsIRenderingContext& aContext);
-
-  nsTitledButtonFrame();
-
-  virtual void CalculateTitleForWidth(nsIPresContext& aPresContext, nsIRenderingContext& aRenderingContext, nscoord aWidth);
-
-  virtual void GetTextSize(nsIPresContext& aPresContext, nsIRenderingContext& aRenderingContext, const nsString& aString, nsSize& aSize);
-
-  virtual void SetDisabled(nsAutoString aDisabled);
-
-  static nsresult UpdateImageFrame(nsIPresContext* aPresContext,
-                                   nsHTMLImageLoader* aLoader,
-                                   nsIFrame* aFrame,
-                                   void* aClosure,
-                                   PRUint32 aStatus);
-
-  void GetImageSource(nsString& aResult);
-
-  virtual void GetImageSize(nsIPresContext* aPresContext);
-
-private:
-
-  // tri state methods
-  void CheckStateToString ( CheckState inState, nsString& outStateAsString ) ;
-  CheckState StringToCheckState ( const nsString & aStateAsString ) ;
-
-  PRBool mHasOnceBeenInMixedState;
- 
-  CroppingStyle mCropType;
-  PRIntn mAlign;
-  nsString mTitle;
-  nsString mCroppedTitle;
-
-  nsHTMLImageLoader mImageLoader;
-  PRBool mSizeFrozen;
-  nsMargin mBorderPadding;
-  nsRect mImageRect;
-  nsRect mTitleRect;
-  PRBool mNeedsLayout;
-  nscoord mSpacing;
-  nsTitledButtonRenderer* mRenderer;
-  PRBool mHasImage;
-
-  // accesskey highlighting
-  PRBool mNeedsAccessUpdate;
-  PRInt32 mAccesskeyIndex;
-  nscoord mBeforeWidth, mAccessWidth, mAccessUnderlineSize, mAccessOffset;
-
- // nsIPopUpMenu * mPopUpMenu;
- // PRBool         mMenuIsPoppedUp;
- 
-}; // class nsTitledButtonFrame
-
-#endif /* nsTitledButtonFrame_h___ */

mozilla/layout/xul/base/src/nsToolbarDragListener.cpp

@@ -1,457 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-#include "nsToolbarDragListener.h"
-#include "nsToolbarFrame.h"
-
-#include "nsCOMPtr.h"
-#include "nsIDOMMouseEvent.h"
-#include "nsIPresContext.h"
-#include "nsIContent.h"
-#include "nsIDOMElement.h"
-#include "nsXULAtoms.h"
-#include "nsIEventStateManager.h"
-#include "nsISupportsPrimitives.h"
-#include "nsINameSpaceManager.h"
-#include "nsIDOMXULDocument.h"
-#include "nsIDocument.h"
-#include "nsIPresShell.h"
-
-
-NS_IMPL_ADDREF(nsToolbarDragListener)
-NS_IMPL_RELEASE(nsToolbarDragListener)
-
-
-//
-// nsToolbarDragListener ctor
-//
-// Init member variables. We can't really do much of anything important here because
-// any subframes might not be totally intialized yet, or in the hash table
-//
-nsToolbarDragListener :: nsToolbarDragListener ( nsToolbarFrame* inToolbar, nsIPresContext* inPresContext )
-  : mToolbar(inToolbar), mPresContext(inPresContext), mCurrentDropLoc(-1)
-{
-  NS_INIT_REFCNT();
-  
-  // we really need this all over the place. just be safe that we have it.
-  NS_ASSERTION ( mPresContext, "no pres context set on toolbar drag listener" );
- 
-} // nsToolbarDragListener ctor
-
-
-//
-// nsToolbarDragListener dtor
-//
-// Cleanup.
-//
-nsToolbarDragListener::~nsToolbarDragListener() 
-{
-}
-
-
-//
-// QueryInterface
-//
-// Modeled after scc's reference implementation
-//   http://www.mozilla.org/projects/xpcom/QI.html
-//
-nsresult
-nsToolbarDragListener::QueryInterface(REFNSIID aIID, void** aInstancePtr)
-{
-  if ( !aInstancePtr)
-    return NS_ERROR_NULL_POINTER;
-
-  if (aIID.Equals(nsCOMTypeInfo<nsIDOMEventListener>::GetIID()))
-    *aInstancePtr = NS_STATIC_CAST(nsIDOMEventListener*, NS_STATIC_CAST(nsIDOMDragListener*, this));
-  else if (aIID.Equals(nsCOMTypeInfo<nsIDOMDragListener>::GetIID()))
-    *aInstancePtr = NS_STATIC_CAST(nsIDOMDragListener*, this);
-  else if (aIID.Equals(nsCOMTypeInfo<nsISupports>::GetIID()))                                   
-    *aInstancePtr = NS_STATIC_CAST(nsISupports*, NS_STATIC_CAST(nsIDOMDragListener*, this));
-  else
-    *aInstancePtr = 0;
-  
-  nsresult status;
-  if ( !*aInstancePtr )
-    status = NS_NOINTERFACE;
-  else {
-    NS_ADDREF( NS_REINTERPRET_CAST(nsISupports*, *aInstancePtr) );
-    status = NS_OK;
-  }
-  return status;
-}
-
-
-////////////////////////////////////////////////////////////////////////
-nsresult
-nsToolbarDragListener::HandleEvent(nsIDOMEvent* aEvent)
-{
-  return NS_OK;
-}
-
-
-////////////////////////////////////////////////////////////////////////
-nsresult
-nsToolbarDragListener::DragGesture(nsIDOMEvent* aDragEvent)
-{
-  // this code should all be in JS.
-  return NS_OK;
-}
-
-
-////////////////////////////////////////////////////////////////////////
-nsresult
-nsToolbarDragListener::DragEnter(nsIDOMEvent* aDragEvent)
-{
-  // We don't need to do anything special here. If anything does need to be done, 
-  // the code should all be in JS.
-  return NS_OK;
-}
-
-
-//
-// ItemMouseIsOver
-//
-// Figure out which child item mouse is over. |outIndex| is the index of the item the object 
-// should be dropped _before_. Therefore if the item should be dropped at the end, the index 
-// will be greater than the number of items in the list. |outOnChild| is true if the item
-// is a container and the drop would be "on" that item.
-// 
-void
-nsToolbarDragListener :: ItemMouseIsOver ( nsIDOMEvent* aDragEvent, nscoord* outXLoc, 
-                                             PRUint32* outIndex, PRBool* outOnChild )
-{
-  *outOnChild = PR_FALSE;
-
-  // figure out which frame is the right one for determining the drop feedback. Do we
-  // want to do this every time? We certainly can't do it upon toolbar creation (hash
-  // tables not setup at that time), so we're forced to do it now. What happens if while
-  // we're dragging some rule gets fired that causes the frame to go away? 
-  nsIFrame* dropAreaFrame = LocateDropAreaFrame();
-  if ( !dropAreaFrame ) {
-    // gaaak, we're doomed.
-    outIndex = 0;
-    outXLoc = 0;
-    return;
-  }
-  
-  //
-  // Get the mouse coordinates from the DOM event, but they will be in the 
-  // window/widget coordinate system. We must first get them into the frame-relative
-  // coordinate system. Yuck.
-  //
-  
-  // get mouse coordinates and translate them into twips
-  nsCOMPtr<nsIDOMMouseEvent> mouseEvent(do_QueryInterface(aDragEvent));
-  PRInt32 x,y = 0;
-  mouseEvent->GetClientX(&x);
-  mouseEvent->GetClientY(&y);
-  float p2t;
-  mPresContext->GetScaledPixelsToTwips(&p2t);
-  nscoord onePixel = NSIntPixelsToTwips(1, p2t);
-  nscoord xp       = NSIntPixelsToTwips(x, p2t);
-  nscoord yp       = NSIntPixelsToTwips(y, p2t);
-  
-  // compute the offset to top level in twips
-  PRInt32 frameOffsetX = 0, frameOffsetY = 0;
-  nsIFrame* curr = dropAreaFrame;
-  curr->GetParent(&curr);
-  float t2p;
-  mPresContext->GetTwipsToPixels(&t2p);
-  while ( curr ) {
-    nsPoint origin;
-    curr->GetOrigin(origin);      // in twips    
-    frameOffsetX += origin.x;     // build the offset incrementally
-    frameOffsetY += origin.y;    
-    curr->GetParent(&curr);       // moving up the chain
-  } // until we reach the top  
-
-  // subtract the offset from the x,y coord to put into frame relative coordinates.
-  xp -= frameOffsetX;
-  yp -= frameOffsetY;
-  nsPoint pnt(xp, yp);
-  
-  // get the toolbar's rect
-  nsRect tbRect;
-  dropAreaFrame->GetRect(tbRect);
-
-  PRUint32 count = 0;
-  PRBool found = PR_FALSE;
-  nsIFrame* childFrame;
-  nsRect    rect;             // child frame's rect
-  nsRect    prevRect(-1, -1, 0, 0);
-
-  //
-  // Now loop through the child and see if the mouse is over a child
-  //
-  
-  dropAreaFrame->FirstChild(nsnull, &childFrame); 
-  while ( childFrame ) {    
-
-    // The mouse coords are in the toolbar's domain
-    // Get child's rect and adjust to the toolbar's domain
-    childFrame->GetRect(rect);
-    rect.MoveBy(tbRect.x, tbRect.y);
-
-    // remember the previous child x location
-    if (pnt.x < rect.x && prevRect.x == -1)
-      prevRect = rect;
-
-    // now check to see if the mouse inside an items bounds
-    if (rect.Contains(pnt)) {
-      nsCOMPtr<nsIContent> content;
-      childFrame->GetContent(getter_AddRefs(content));
-      if ( content ) {
-        nsCOMPtr<nsIAtom> tag;
-        content->GetTag(*getter_AddRefs(tag));
-
-        // for now I am checking for both titlebutton and toolbar items
-        // XXX but the check for titlebutton should be removed in the future
-        if (tag.get() == nsXULAtoms::titledbutton || tag.get() == nsXULAtoms::toolbaritem) {
-
-          // now check if item is a container
-          PRBool isContainer = PR_FALSE;
-          nsCOMPtr<nsIDOMElement> domElement ( do_QueryInterface(content) );
-          if ( domElement ) {
-            nsAutoString value;
-            domElement->GetAttribute(nsAutoString("container"), value);  // can't use an atom here =(
-            isContainer = value.Equals("true");
-          }
-          else
-            NS_WARNING("Not a DOM element");        
-
-          // if we have a container, the area is broken up into 3 pieces (left, middle, right). If
-          // it isn't it's only broken up into two (left and right)
-          PRInt32 xc = -1;
-          if ( isContainer ) {
-            if (pnt.x <= (rect.x + (rect.width / 4))) {
-              *outIndex = count;
-              xc = rect.x - tbRect.x;
-            } 
-            else if (pnt.x >= (rect.x + PRInt32(float(rect.width) *0.75))) {
-              *outIndex = count + 1;
-              xc = rect.x - tbRect.x + rect.width - onePixel;
-            } 
-            else {
-              // we're on a container, don't draw anything so xc shouldn't get set.
-              *outIndex = count;
-              *outOnChild = PR_TRUE;
-            }
-          } else {
-            if (pnt.x <= (rect.x + (rect.width / 2))) {
-              *outIndex = count;
-              xc = rect.x - tbRect.x;
-            }
-            else {
-              *outIndex = count + 1;
-              xc = rect.x - tbRect.x + rect.width + onePixel;
-            }
-          }
-          
-          *outXLoc = xc;
-        }
-        else {
-          // mouse is over something (probably a spacer) so return the left side of
-          // the spacer.
-          *outXLoc = rect.x - tbRect.x;
-          *outIndex = count;
-        }
-        
-        // found something, break out of the loop
-        found = PR_TRUE;
-        break;
-      }
-    } // if mouse is in an item
-
-    nsresult rv = childFrame->GetNextSibling(&childFrame);
-    NS_ASSERTION(rv == NS_OK,"failed to get next child");
-    count++;
-  } // foreach child
-
-  if (!found) {
-    *outIndex = count;  // already incremented past last item
-    if ( count )
-      *outXLoc = prevRect.x - tbRect.x + rect.width + onePixel;
-    else
-      *outXLoc = onePixel;
-  }
-}
-
-
-//
-// DragOver
-//
-// The mouse has moved over the toolbar while a drag is happening. We really just want to
-// "annotate" the toolbar with the current drop location. We don't want to make any judgement
-// as this stage as to whether or not the drag should be accepted or draw any feedback. 
-//
-nsresult
-nsToolbarDragListener::DragOver(nsIDOMEvent* aDragEvent)
-{
-
-#if 0
-nsCOMPtr<nsIContent> c;
-mToolbar->GetContent ( getter_AddRefs(c) );
-nsCOMPtr<nsIDOMNode> d ( do_QueryInterface(c) );
-nsCOMPtr<nsIDOMNode> t;
-aDragEvent->GetTarget ( getter_AddRefs(t) );
-printf ( "DRAGOVER:: toolbar content is %ld, as DOMNode %ld, target is %ld\n", c, d, t );
-#endif
-
-  // Check to see if the mouse is over an item and which one it is.
-  nscoord xLoc = 0;
-  PRBool onChild;
-  PRUint32 beforeIndex = 0;
-  ItemMouseIsOver(aDragEvent, &xLoc, &beforeIndex, &onChild);
-  if ( xLoc != mCurrentDropLoc ) {
-  
-    // stash the new location in the toolbar's content model. Note that the toolbar code doesn't
-    // care at all about "tb-droplocation", only the coordinate so there is no need to send the
-    // AttributeChanged() about that attribute.
-    nsCOMPtr<nsIContent> content;
-    mToolbar->GetContent ( getter_AddRefs(content) );
-    if ( content ) {
-      char buffer[10];
-
-      	// need the cast, because on some platforms, PR[U]int32 != long, but we're using "%ld"
-      sprintf(buffer, "%ld", NS_STATIC_CAST(long, xLoc));
-      content->SetAttribute ( kNameSpaceID_None, nsXULAtoms::tbDropLocationCoord, buffer, PR_TRUE );
-      sprintf(buffer, "%ld", NS_STATIC_CAST(long, beforeIndex));
-      content->SetAttribute ( kNameSpaceID_None, nsXULAtoms::tbDropLocation, "1", PR_FALSE );
-      content->SetAttribute ( kNameSpaceID_None, nsXULAtoms::tbDropOn, onChild ? "true" : "false", PR_FALSE );
-    }
-    
-    // cache the current drop location
-    mCurrentDropLoc = xLoc;
-  }
-  
-  // NS_OK means event is NOT consumed. We want to make sure JS gets this so it
-  // can determine if the drag is allowed.
-  return NS_OK; 
-}
-
-
-////////////////////////////////////////////////////////////////////////
-nsresult
-nsToolbarDragListener::DragExit(nsIDOMEvent* aDragEvent)
-{
-// there are some bugs that cause us to not be able to correctly track dragExit events
-// so until then we just get on our knees and pray we don't get fooled again.
-#if 0
-nsCOMPtr<nsIContent> c;
-mToolbar->GetContent ( getter_AddRefs(c) );
-nsCOMPtr<nsIDOMNode> d ( do_QueryInterface(c) );
-nsCOMPtr<nsIDOMNode> t;
-aDragEvent->GetTarget ( getter_AddRefs(t) );
-printf ( "DRAGEXIT:: toolbar DOMNode %ld, target is %ld\n", d, t );
-
-  nsCOMPtr<nsIContent> content;
-  mToolbar->GetContent ( getter_AddRefs(content) );
-
-  // we will get a drag exit event on sub items because we catch the event on the way down. If
-  // the target is not our toolbar, then ignore it.
-  nsCOMPtr<nsIDOMNode> toolbarDOMNode ( do_QueryInterface(content) );
-  nsCOMPtr<nsIDOMNode> eventTarget;
-  aDragEvent->GetTarget ( getter_AddRefs(eventTarget) );
-  if ( eventTarget != toolbarDOMNode )
-    return NS_OK;
-
-printf("***REAL EXIT EVENT\n");
-
-  // tell the toolbar to not do any more drop feedback. Note that the toolbar code doesn't
-  // care at all about "tb-droplocation", only the coordinate so there is no need to send the
-  // AttributeChanged() about that attribute.
-  char buffer[10];
-  sprintf(buffer, "%ld", -1);
-  content->SetAttribute ( kNameSpaceID_None, nsXULAtoms::tbDropLocationCoord, buffer, PR_TRUE );
-  content->SetAttribute ( kNameSpaceID_None, nsXULAtoms::tbDropLocation, buffer, PR_FALSE );
-    
-  // cache the current drop location
-  mCurrentDropLoc = -1;
-#endif
-
-  return NS_OK; // don't consume event
-}
-
-
-
-////////////////////////////////////////////////////////////////////////
-nsresult
-nsToolbarDragListener::DragDrop(nsIDOMEvent* aMouseEvent)
-{
-  // this code should all be in JS.
-  return NS_OK;
-}
-
-
-//
-// LocateDropAreaFrame
-//
-// Returns the frame (or subframe) that contains the buttons that can be dragged.
-// Either it will be the toolbar frame as a whole, or it will be some subframe of the bar id'd by
-// the |dragdroparea| attribute.
-//
-nsIFrame*
-nsToolbarDragListener :: LocateDropAreaFrame ( )
-{
-  nsIFrame* retVal = nsnull;
-  
-  // is a subframe the drag/drop area? determine if the attribute is set.
-  nsString dropAreaID;
-  PRBool dropAreaIsSubframe = PR_FALSE;
-  nsCOMPtr<nsIContent> toolbarContent;
-  mToolbar->GetContent ( getter_AddRefs(toolbarContent) );
-  if ( toolbarContent ) {
-    if ( toolbarContent->GetAttribute(kNameSpaceID_None, nsXULAtoms::tbDragDropArea, dropAreaID) == NS_CONTENT_ATTR_HAS_VALUE )
-      dropAreaIsSubframe = PR_TRUE;
-  }
-
-  // if there is a named subframe, go find it, otherwise use the entire toolbar
-  if ( dropAreaIsSubframe ) {
-  
-    // get the presShell so we can call GetPrimaryFrameFor later.
-    nsCOMPtr<nsIPresShell> presShell;
-    mPresContext->GetShell ( getter_AddRefs(presShell) );
-    
-    // get the document so we can get do a GetElementByID.
-    nsCOMPtr<nsIDocument> document;
-    toolbarContent->GetDocument ( *getter_AddRefs(document) );
-    if ( document ) {
-      nsCOMPtr<nsIDOMXULDocument> xulDoc ( do_QueryInterface(document) );
-      if ( xulDoc ) {
-        nsCOMPtr<nsIDOMElement> domElementOfSubframe;
-        xulDoc->GetElementById ( dropAreaID, getter_AddRefs(domElementOfSubframe) );
-
-        // finally get the frame associated with that dom node
-        nsCOMPtr<nsIContent> contentOfSubframe ( do_QueryInterface(domElementOfSubframe) );
-        if ( contentOfSubframe && presShell )
-          presShell->GetPrimaryFrameFor ( contentOfSubframe, &retVal );       
-      }
-    }
-    
-  } // if named subframe
-  else
-    retVal = mToolbar;
-    
-  NS_ASSERTION ( retVal, "toolbar drag listener couldn't figure out the drag area." );
-  return retVal;
-  
-} // LocateDropAreaFrame
-
-
-

mozilla/layout/xul/base/src/nsToolbarDragListener.h

@@ -1,70 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (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/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
- 
-#ifndef nsToolbarDragListener_h__
-#define nsToolbarDragListener_h__
-
-#include "nsIDOMDragListener.h"
-#include "nsCoord.h"
-
-
-class nsToolbarFrame;
-class nsIPresContext;
-class nsIDOMEvent;
-class nsIFrame;
-
-
-class nsToolbarDragListener : public nsIDOMDragListener
-{
-public:
-
-    // default ctor and dtor
-  nsToolbarDragListener ( nsToolbarFrame* inToolbar, nsIPresContext* inPresContext );
-  virtual ~nsToolbarDragListener();
-
-    // interfaces for addref and release and queryinterface
-  NS_DECL_ISUPPORTS
-
-    // nsIDOMDragListener
-  virtual nsresult HandleEvent(nsIDOMEvent* aEvent);
-  virtual nsresult DragEnter(nsIDOMEvent* aDragEvent);
-  virtual nsresult DragOver(nsIDOMEvent* aDragEvent);
-  virtual nsresult DragExit(nsIDOMEvent* aDragEvent);
-  virtual nsresult DragDrop(nsIDOMEvent* aDragEvent);
-  virtual nsresult DragGesture(nsIDOMEvent* aDragEvent);
-
-protected:
-
-    // Figure out which child item mouse is over. |outIndex| is the index of the item the object 
-    // should be dropped _before_. Therefore if the item should be dropped at the end, the index 
-    // will be greater than the number of items in the list. |outOnChild| is true if the item
-    // is a container and the drop would be "on" that item.
-  void ItemMouseIsOver(nsIDOMEvent* aDragEvent, nscoord* outXLoc, PRUint32* outIndex, PRBool* outOnChild);
-
-    // Find the frame (or subframe) that contains the buttons that can be dragged.
-  nsIFrame* LocateDropAreaFrame ( ) ;
-  
-  nsToolbarFrame * mToolbar;         // toolbar owns me, don't be circular
-  nsIPresContext * mPresContext;     // weak reference
-  PRInt32          mCurrentDropLoc;
-
-}; // class nsToolbarDragListener
-
-
-#endif