mozilla
/
pjs
зеркало из https://github.com/mozilla/pjs.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

MOved XULCommand to src and it is now acting like a menu delegate, 

all that reminas is to rename it.
This commit is contained in:
rods%netscape.com 1999-02-21 21:04:21 +00:00
Родитель cb93818b9b
Коммит cf7b150f21
4 изменённых файлов: 429 добавлений и 584 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

511
xpfe/appshell/src/nsWebShellWindow.cpp
Просмотреть файл

@ -33,7 +33,6 @@
#include "nsIWidgetController.h"
#include "nsAppShellCIDs.h"
#include "nsIXULCommand.h"
#include "nsXULCommand.h"
#include "nsIDOMCharacterData.h"
#include "nsIDOMNodeList.h"
@ -53,8 +52,10 @@
#include "nsIDOMNode.h"
#include "nsIDOMElement.h"
#include "nsIDocumentLoader.h"
#include "nsIDOMHTMLInputElement.h"
#include "nsIDOMHTMLImageElement.h"
//#include "nsIDOMHTMLInputElement.h"
//#include "nsIDOMHTMLImageElement.h"
#include "nsIContent.h" // for menus
// For calculating size
#include "nsIFrame.h"
@ -70,7 +71,6 @@ static NS_DEFINE_IID(kAppShellServiceCID, NS_APPSHELL_SERVICE_CID);
static NS_DEFINE_IID(kMenuBarCID, NS_MENUBAR_CID);
static NS_DEFINE_IID(kMenuCID, NS_MENU_CID);
static NS_DEFINE_IID(kMenuItemCID, NS_MENUITEM_CID);
static NS_DEFINE_IID(kXULCommandCID, NS_XULCOMMAND_CID);
/* Define Interface IDs */
static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
@ -85,16 +85,17 @@ static NS_DEFINE_IID(kIDocumentViewerIID, NS_IDOCUMENT_VIEWER_IID);
static NS_DEFINE_IID(kIDOMDocumentIID, NS_IDOMDOCUMENT_IID);
static NS_DEFINE_IID(kIDOMNodeIID, NS_IDOMNODE_IID);
static NS_DEFINE_IID(kIDOMElementIID, NS_IDOMELEMENT_IID);
static NS_DEFINE_IID(kIXULCommandIID, NS_IXULCOMMAND_IID);
static NS_DEFINE_IID(kIDOMCharacterDataIID, NS_IDOMCHARACTERDATA_IID);
static NS_DEFINE_IID(kIDOMHTMLInputElementIID, NS_IDOMHTMLINPUTELEMENT_IID);
static NS_DEFINE_IID(kIDOMHTMLImageElementIID, NS_IDOMHTMLIMAGEELEMENT_IID);
//static NS_DEFINE_IID(kIDOMHTMLInputElementIID, NS_IDOMHTMLINPUTELEMENT_IID);
//static NS_DEFINE_IID(kIDOMHTMLImageElementIID, NS_IDOMHTMLIMAGEELEMENT_IID);
static NS_DEFINE_IID(kIMenuIID, NS_IMENU_IID);
static NS_DEFINE_IID(kIMenuBarIID, NS_IMENUBAR_IID);
static NS_DEFINE_IID(kIMenuItemIID, NS_IMENUITEM_IID);
static NS_DEFINE_IID(kIMenuIID, NS_IMENU_IID);
static NS_DEFINE_IID(kIMenuBarIID, NS_IMENUBAR_IID);
static NS_DEFINE_IID(kIMenuItemIID, NS_IMENUITEM_IID);
static NS_DEFINE_IID(kIXULCommandIID, NS_IXULCOMMAND_IID);
static NS_DEFINE_IID(kIContentIID, NS_ICONTENT_IID);
#define DEBUGCMDS 0
#define DEBUG_MENUSDEL 1
#include "nsIWebShell.h"
@ -108,9 +109,6 @@ nsWebShellWindow::nsWebShellWindow()
mWebShell = nsnull;
mWindow = nsnull;
mController = nsnull;
mStatusText = nsnull;
mURLBarText = nsnull;
mThrobber = nsnull;
}
@ -123,9 +121,6 @@ nsWebShellWindow::~nsWebShellWindow()
NS_IF_RELEASE(mWindow);
NS_IF_RELEASE(mController);
NS_IF_RELEASE(mStatusText);
NS_IF_RELEASE(mURLBarText);
NS_IF_RELEASE(mThrobber);
}
@ -204,7 +199,7 @@ nsresult nsWebShellWindow::Initialize(nsIWidget* aParent,
rv = nsRepository::CreateInstance(kWindowCID, nsnull, kIWidgetIID,
(void**)&mWindow);
if (NS_OK != rv) {
goto done;
return rv;
}
initData.mBorderStyle = eBorderStyle_dialog;
@ -225,7 +220,7 @@ nsresult nsWebShellWindow::Initialize(nsIWidget* aParent,
kIWebShellIID,
(void**)&mWebShell);
if (NS_OK != rv) {
goto done;
return rv;
}
r.x = r.y = 0;
@ -256,7 +251,6 @@ nsresult nsWebShellWindow::Initialize(nsIWidget* aParent,
//rv = nsRepository::CreateInstance(iid, nsnull,
// kIWidgetControllerIID,
// (void**)&mController);
done:
return rv;
}
@ -322,25 +316,6 @@ NS_IMETHODIMP
nsWebShellWindow::WillLoadURL(nsIWebShell* aShell, const PRUnichar* aURL,
nsLoadType aReason)
{
if (nsnull != mThrobber) {
mThrobber->SetSrc(kThrobberOnStr);
}
nsAutoString url(aURL);
nsAutoString gecko("Gecko - ");
gecko.Append(url);
mWindow->SetTitle(gecko);
if (nsnull != mURLBarText) {
mURLBarText->SetValue(url);
}
if (nsnull != mStatusText) {
nsAutoString msg(aURL);
msg.Append(" :Start");
mStatusText->SetData(msg);
}
return NS_OK;
}
@ -354,17 +329,6 @@ NS_IMETHODIMP
nsWebShellWindow::ProgressLoadURL(nsIWebShell* aShell, const PRUnichar* aURL,
PRInt32 aProgress, PRInt32 aProgressMax)
{
if (nsnull != mStatusText) {
nsAutoString url(aURL);
url.Append(": progress ");
url.Append(aProgress, 10);
if (0 != aProgressMax) {
url.Append(" (out of ");
url.Append(aProgressMax, 10);
url.Append(")");
}
mStatusText->SetData(url);
}
return NS_OK;
}
@ -372,16 +336,6 @@ NS_IMETHODIMP
nsWebShellWindow::EndLoadURL(nsIWebShell* aWebShell, const PRUnichar* aURL,
PRInt32 aStatus)
{
if (nsnull != mThrobber) {
mThrobber->SetSrc(kThrobberOffStr);
}
if (nsnull != mStatusText) {
nsAutoString msg(aURL);
msg.Append(" :Stop");
mStatusText->SetData(msg);
}
return NS_OK;
}
@ -412,14 +366,100 @@ nsCOMPtr<nsIDOMNode> nsWebShellWindow::FindNamedParentFromDoc(nsIDOMDocument * a
return node;
}
//----------------------------------------
NS_IMETHODIMP nsWebShellWindow::CreateMenu(nsIMenuBar * aMenuBar,
nsIDOMNode * aMenuNode,
nsString & aMenuName)
{
// Create nsMenu
nsIMenu * pnsMenu = nsnull;
nsresult rv = nsRepository::CreateInstance(kMenuCID, nsnull, kIMenuIID, (void**)&pnsMenu);
if (NS_OK == rv) {
// Call Create
pnsMenu->Create(aMenuBar, aMenuName);
// Set nsMenu Name
pnsMenu->SetLabel(aMenuName);
// Make nsMenu a child of nsMenuBar
aMenuBar->AddMenu(pnsMenu); // XXX adds an additional menu
// Begin menuitem inner loop
nsCOMPtr<nsIDOMNode> menuitemNode;
aMenuNode->GetFirstChild(getter_AddRefs(menuitemNode));
while (menuitemNode) {
nsCOMPtr<nsIDOMElement> menuitemElement(do_QueryInterface(menuitemNode));
if (menuitemElement) {
nsString menuitemNodeType;
nsString menuitemName;
nsString menuitemCmd;
menuitemElement->GetNodeName(menuitemNodeType);
if (menuitemNodeType.Equals("menuitem")) {
menuitemElement->GetAttribute(nsAutoString("name"), menuitemName);
menuitemElement->GetAttribute(nsAutoString("cmd"), menuitemCmd);
//printf("Creating MenuItem [%s]\n", menuitemName.ToNewCString()); // this leaks
// Create nsMenuItem
nsIMenuItem * pnsMenuItem = nsnull;
rv = nsRepository::CreateInstance(kMenuItemCID, nsnull, kIMenuItemIID, (void**)&pnsMenuItem);
if (NS_OK == rv) {
pnsMenuItem->Create(pnsMenu, menuitemName, 0);
// Set nsMenuItem Name
pnsMenuItem->SetLabel(menuitemName);
// Make nsMenuItem a child of nsMenu
pnsMenu->AddMenuItem(pnsMenuItem); // XXX adds an additional item
// Create MenuDelegate - this is the intermediator inbetween
// the DOM node and the nsIMenuItem
// The nsWebShellWindow wacthes for Document changes and then notifies the
// the appropriate nsMenuDelegate object
nsCOMPtr<nsIDOMElement> domElement(do_QueryInterface(menuitemNode));
if (!domElement) {
return NS_ERROR_FAILURE;
}
nsAutoString cmdAtom("onClick");
nsString cmdName;
domElement->GetAttribute(cmdAtom, cmdName);
nsXULCommand * menuDelegate = new nsXULCommand();
menuDelegate->SetCommand(cmdName);
menuDelegate->SetWebShell(mWebShell);
menuDelegate->SetDOMElement(domElement);
menuDelegate->SetMenuItem(pnsMenuItem);
nsIXULCommand * icmd;
if (NS_OK == menuDelegate->QueryInterface(kIXULCommandIID, (void**) &icmd)) {
mMenuDelegates.AppendElement(icmd);
nsCOMPtr<nsIMenuListener> listener(do_QueryInterface(menuDelegate));
if (listener) {
pnsMenuItem->AddMenuListener(listener);
if (DEBUG_MENUSDEL) printf("Adding menu listener to [%s]\n", menuitemName.ToNewCString());
} else {
if (DEBUG_MENUSDEL) printf("*** NOT Adding menu listener to [%s]\n", menuitemName.ToNewCString());
}
}
}
} else if (menuitemNodeType.Equals("separator")) {
pnsMenu->AddSeparator();
}
}
nsCOMPtr<nsIDOMNode> oldmenuitemNode(menuitemNode);
oldmenuitemNode->GetNextSibling(getter_AddRefs(menuitemNode));
} // end menu item innner loop
}
return NS_OK;
}
//----------------------------------------
void nsWebShellWindow::LoadMenus(nsIDOMDocument * aDOMDoc, nsIWidget * aParentWindow)
{
// locate the window element which holds toolbars and menus and commands
nsCOMPtr<nsIDOMElement> element;
aDOMDoc->GetDocumentElement(getter_AddRefs(element));
if (!element)
if (!element) {
return;
}
nsCOMPtr<nsIDOMNode> window(do_QueryInterface(element));
nsresult rv;
@ -428,120 +468,42 @@ void nsWebShellWindow::LoadMenus(nsIDOMDocument * aDOMDoc, nsIWidget * aParentWi
if (menubarNode) {
nsIMenuBar * pnsMenuBar = nsnull;
rv = nsRepository::CreateInstance(kMenuBarCID, nsnull, kIMenuBarIID, (void**)&pnsMenuBar);
if (NS_OK != rv) {
// Error
}
if (nsnull != pnsMenuBar) {
pnsMenuBar->Create(aParentWindow);
if (NS_OK == rv) {
if (nsnull != pnsMenuBar) {
pnsMenuBar->Create(aParentWindow);
// set pnsMenuBar as a nsMenuListener on aParentWindow
nsCOMPtr<nsIMenuListener> menuListener;
pnsMenuBar->QueryInterface(kIMenuListenerIID, getter_AddRefs(menuListener));
mWindow->AddMenuListener(menuListener);
// set pnsMenuBar as a nsMenuListener on aParentWindow
nsCOMPtr<nsIMenuListener> menuListener;
pnsMenuBar->QueryInterface(kIMenuListenerIID, getter_AddRefs(menuListener));
mWindow->AddMenuListener(menuListener);
nsCOMPtr<nsIDOMNode> menuNode;
menubarNode->GetFirstChild(getter_AddRefs(menuNode));
while (menuNode) {
nsCOMPtr<nsIDOMElement> menuElement(do_QueryInterface(menuNode));
if (menuElement) {
nsString menuNodeType;
nsString menuName;
menuElement->GetNodeName(menuNodeType);
if (menuNodeType.Equals("menu")) {
menuElement->GetAttribute(nsAutoString("name"), menuName);
printf("Creating Menu [%s] \n", menuName.ToNewCString()); // this leaks
// Create nsMenu
nsIMenu * pnsMenu = nsnull;
rv = nsRepository::CreateInstance(kMenuCID, nsnull, kIMenuIID, (void**)&pnsMenu);
if (NS_OK == rv) {
// Call Create
pnsMenu->Create(pnsMenuBar, menuName);
// Set nsMenu Name
pnsMenu->SetLabel(menuName);
// Make nsMenu a child of nsMenuBar
pnsMenuBar->AddMenu(pnsMenu); // XXX adds an additional menu
nsCOMPtr<nsIDOMNode> menuNode;
menubarNode->GetFirstChild(getter_AddRefs(menuNode));
while (menuNode) {
nsCOMPtr<nsIDOMElement> menuElement(do_QueryInterface(menuNode));
if (menuElement) {
nsString menuNodeType;
nsString menuName;
menuElement->GetNodeName(menuNodeType);
if (menuNodeType.Equals("menu")) {
menuElement->GetAttribute(nsAutoString("name"), menuName);
printf("Creating Menu [%s] \n", menuName.ToNewCString()); // this leaks
CreateMenu(pnsMenuBar, menuNode, menuName);
}
// Begin menuitem inner loop
nsCOMPtr<nsIDOMNode> menuitemNode;
menuNode->GetFirstChild(getter_AddRefs(menuitemNode));
while (menuitemNode) {
nsCOMPtr<nsIDOMElement>
menuitemElement(do_QueryInterface(menuitemNode));
if (menuitemElement) {
nsString menuitemNodeType;
nsString menuitemName;
nsString menuitemCmd;
menuitemElement->GetNodeName(menuitemNodeType);
printf("Type [%s] %d\n", menuitemNodeType.ToNewCString(), menuitemNodeType.Equals("separator"));
if (menuitemNodeType.Equals("menuitem")) {
menuitemElement->GetAttribute(nsAutoString("name"), menuitemName);
menuitemElement->GetAttribute(nsAutoString("cmd"), menuitemCmd);
//printf("Creating MenuItem [%s]\n", menuitemName.ToNewCString()); // this leaks
// Create nsMenuItem
nsIMenuItem * pnsMenuItem = nsnull;
rv = nsRepository::CreateInstance(kMenuItemCID, nsnull, kIMenuItemIID, (void**)&pnsMenuItem);
if (NS_OK == rv) {
pnsMenuItem->Create(pnsMenu, menuitemName, 0);
// Set nsMenuItem Name
pnsMenuItem->SetLabel(menuitemName);
// Make nsMenuItem a child of nsMenu
pnsMenu->AddMenuItem(pnsMenuItem); // XXX adds an additional item
//ConnectCommandToOneGUINode(menuitemNode);
#if 1
//-----------------------------------------------------------
// This block contains temporary menu hookup code.
//-----------------------------------------------------------
{
nsCOMPtr<nsIDOMElement> domElement(do_QueryInterface(menuitemNode));
if (!domElement)
return;
nsAutoString cmdAtom("onClick");
nsString cmdName;
domElement->GetAttribute(cmdAtom, cmdName);
nsXULCommand * xulCmd = new nsXULCommand();
xulCmd->SetName(cmdName);
xulCmd->SetCommand(cmdName);
xulCmd->SetWebShell(mWebShell);
xulCmd->SetDOMElement(domElement);
nsIXULCommand * icmd;
if (NS_OK == xulCmd->QueryInterface(kIXULCommandIID, (void**) &icmd)) {
mMenuDelegates.AppendElement(icmd);
}
nsCOMPtr<nsIMenuListener> listener(do_QueryInterface(icmd));
pnsMenuItem->AddMenuListener(listener);
}
//-----------------------------------------------------------
#endif
}
} else if (menuitemNodeType.Equals("separator")) {
pnsMenu->AddSeparator();
}
}
nsCOMPtr<nsIDOMNode> oldmenuitemNode(menuitemNode);
oldmenuitemNode->GetNextSibling(getter_AddRefs(menuitemNode));
} // end menu item innner loop
}
}
}
nsCOMPtr<nsIDOMNode> oldmenuNode(menuNode);
oldmenuNode->GetNextSibling(getter_AddRefs(menuNode));
} // end while (nsnull != menuNode)
}
nsCOMPtr<nsIDOMNode> oldmenuNode(menuNode);
oldmenuNode->GetNextSibling(getter_AddRefs(menuNode));
} // end while (nsnull != menuNode)
// Give the aParentWindow this nsMenuBar to hold onto.
mWindow->SetMenuBar(pnsMenuBar);
// Give the aParentWindow this nsMenuBar to hold onto.
mWindow->SetMenuBar(pnsMenuBar);
// HACK: force a paint for now
pnsMenuBar->Paint();
// HACK: force a paint for now
pnsMenuBar->Paint();
} // end if ( nsnull != pnsMenuBar )
} // end if (nsnull != node)
}
} // end if (menuBar)
} // nsWebShellWindow::LoadMenus
@ -715,7 +677,25 @@ PRInt32 nsWebShellWindow::GetDocHeight(nsIDocument * aDoc)
//----------------------------------------
NS_IMETHODIMP nsWebShellWindow::OnConnectionsComplete()
{
if (DEBUGCMDS) printf("OnConnectionsComplete\n");
if (DEBUG_MENUSDEL) printf("OnConnectionsComplete\n");
// register as document listener
// this is needed for menus
nsCOMPtr<nsIContentViewer> cv;
mWebShell->GetContentViewer(getter_AddRefs(cv));
if (cv) {
nsCOMPtr<nsIDocumentViewer> docv(do_QueryInterface(cv));
if (!docv)
return NS_OK;
nsCOMPtr<nsIDocument> doc;
docv->GetDocument(*getter_AddRefs(doc));
if (!doc)
return NS_OK;
doc->AddObserver(NS_STATIC_CAST(nsIDocumentObserver*, this));
}
ExecuteStartupCode();
@ -726,25 +706,6 @@ NS_IMETHODIMP nsWebShellWindow::OnConnectionsComplete()
if (menubarDOMDoc)
LoadMenus(menubarDOMDoc, mWindow);
///////////////////////////////
// Find the Status Text DOM Node. EVIL ASSUMPTION THAT ALL SUCH WINDOWS HAVE ONE.
///////////////////////////////
nsCOMPtr<nsIDOMDocument> statusDOMDoc(GetNamedDOMDoc(nsAutoString("status")));
if (!statusDOMDoc)
return NS_ERROR_FAILURE;
nsCOMPtr<nsIDOMNode> parent(GetParentNodeFromDOMDoc(statusDOMDoc));
if (!parent)
return NS_ERROR_FAILURE;
PRInt32 count = 0;
nsCOMPtr<nsIDOMNode> statusNode(FindNamedDOMNode(nsAutoString("#text"), parent, count, 7));
if (!statusNode)
return NS_ERROR_FAILURE;
nsCOMPtr<nsIDOMCharacterData> charData(do_QueryInterface(statusNode));
if (!charData)
return NS_ERROR_FAILURE;
mStatusText = charData;
mStatusText->SetData(nsAutoString("Ready.....")); // <<====== EVIL HARD-CODED STRING.
// Calculate size of windows
#if 0
@ -839,7 +800,7 @@ void nsWebShellWindow::ExecuteJavaScriptString(nsString& aJavaScript)
PRBool isUndefined = PR_FALSE;
nsString rVal("xxx");
scriptContext->EvaluateString(aJavaScript, url, 0, rVal, &isUndefined);
if (DEBUGCMDS) printf("EvaluateString - %d [%s]\n", isUndefined, rVal.ToNewCString());
if (DEBUG_MENUSDEL) printf("EvaluateString - %d [%s]\n", isUndefined, rVal.ToNewCString());
}
}
@ -866,3 +827,173 @@ void nsWebShellWindow::ExecuteStartupCode()
if (NS_SUCCEEDED(webshellElement->GetAttribute("onConstruction", startupCode)))
ExecuteJavaScriptString(startupCode);
}
//----------------------------------------------------------------
//-- nsIDocumentObserver
//----------------------------------------------------------------
NS_IMETHODIMP
nsWebShellWindow::BeginUpdate(nsIDocument *aDocument)
{
return NS_OK;
}
NS_IMETHODIMP
nsWebShellWindow::EndUpdate(nsIDocument *aDocument)
{
return NS_OK;
}
NS_IMETHODIMP
nsWebShellWindow::BeginLoad(nsIDocument *aDocument)
{
return NS_OK;
}
NS_IMETHODIMP
nsWebShellWindow::EndLoad(nsIDocument *aDocument)
{
return NS_OK;
}
NS_IMETHODIMP
nsWebShellWindow::BeginReflow(nsIDocument *aDocument, nsIPresShell* aShell)
{
return NS_OK;
}
NS_IMETHODIMP
nsWebShellWindow::EndReflow(nsIDocument *aDocument, nsIPresShell* aShell)
{
return NS_OK;
}
///////////////////////////////////////////////////////////////
// nsIDocumentObserver
// this is needed for menu changes
///////////////////////////////////////////////////////////////
NS_IMETHODIMP
nsWebShellWindow::ContentChanged(nsIDocument *aDocument,
nsIContent* aContent,
nsISupports* aSubContent)
{
return NS_OK;
}
NS_IMETHODIMP
nsWebShellWindow::AttributeChanged(nsIDocument *aDocument,
nsIContent* aContent,
nsIAtom* aAttribute,
PRInt32 aHint)
{
//printf("AttributeChanged\n");
PRInt32 i;
for (i=0;i<mMenuDelegates.Count();i++) {
nsIXULCommand * cmd = (nsIXULCommand *)mMenuDelegates[i];
nsIDOMElement * node;
cmd->GetDOMElement(&node);
//nsCOMPtr<nsIContent> content(do_QueryInterface(node));
// Doing this for the must speed
nsIContent * content;
if (NS_OK == node->QueryInterface(kIContentIID, (void**) &content)) {
if (content == aContent) {
nsAutoString attr;
aAttribute->ToString(attr);
cmd->AttributeHasBeenSet(attr);
}
NS_RELEASE(content);
}
}
return NS_OK;
}
NS_IMETHODIMP
nsWebShellWindow::ContentAppended(nsIDocument *aDocument,
nsIContent* aContainer,
PRInt32 aNewIndexInContainer)
{
return NS_OK;
}
NS_IMETHODIMP
nsWebShellWindow::ContentInserted(nsIDocument *aDocument,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInContainer)
{
return NS_OK;
}
NS_IMETHODIMP
nsWebShellWindow::ContentReplaced(nsIDocument *aDocument,
nsIContent* aContainer,
nsIContent* aOldChild,
nsIContent* aNewChild,
PRInt32 aIndexInContainer)
{
return NS_OK;
}
NS_IMETHODIMP
nsWebShellWindow::ContentRemoved(nsIDocument *aDocument,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInContainer)
{
return NS_OK;
}
NS_IMETHODIMP
nsWebShellWindow::StyleSheetAdded(nsIDocument *aDocument,
nsIStyleSheet* aStyleSheet)
{
return NS_OK;
}
NS_IMETHODIMP
nsWebShellWindow::StyleSheetRemoved(nsIDocument *aDocument,
nsIStyleSheet* aStyleSheet)
{
return NS_OK;
}
NS_IMETHODIMP
nsWebShellWindow::StyleSheetDisabledStateChanged(nsIDocument *aDocument,
nsIStyleSheet* aStyleSheet,
PRBool aDisabled)
{
return NS_OK;
}
NS_IMETHODIMP
nsWebShellWindow::StyleRuleChanged(nsIDocument *aDocument,
nsIStyleSheet* aStyleSheet,
nsIStyleRule* aStyleRule,
PRInt32 aHint)
{
return NS_OK;
}
NS_IMETHODIMP
nsWebShellWindow::StyleRuleAdded(nsIDocument *aDocument,
nsIStyleSheet* aStyleSheet,
nsIStyleRule* aStyleRule)
{
return NS_OK;
}
NS_IMETHODIMP
nsWebShellWindow::StyleRuleRemoved(nsIDocument *aDocument,
nsIStyleSheet* aStyleSheet,
nsIStyleRule* aStyleRule)
{
return NS_OK;
}
NS_IMETHODIMP
nsWebShellWindow::DocumentWillBeDestroyed(nsIDocument *aDocument)
{
return NS_OK;
}

60
xpfe/appshell/src/nsWebShellWindow.h
Просмотреть файл

@ -25,12 +25,12 @@
#include "nsGUIEvent.h"
#include "nsIWebShell.h"
#include "nsIDocumentLoaderObserver.h"
#include "nsIDocumentObserver.h"
#include "nsVoidArray.h"
// can't use forward class decl's because of template bugs on Solaris
#include "nsIDOMDocument.h"
#include "nsIDOMNode.h"
#include "nsIXULCommand.h"
#include "nsCOMPtr.h"
@ -46,9 +46,12 @@ class nsIDOMElement;
class nsIStreamObserver;
class nsIDocument;
class nsIContent;
class nsWebShellWindow : public nsIWebShellWindow,
public nsIWebShellContainer,
public nsIDocumentLoaderObserver
public nsIDocumentLoaderObserver,
public nsIDocumentObserver
{
public:
nsWebShellWindow();
@ -99,6 +102,55 @@ public:
NS_IMETHOD OnStartURLLoad(nsIURL* aURL, const char* aContentType, nsIContentViewer* aViewer);
NS_IMETHOD OnConnectionsComplete();
// nsIDocumentObserver
NS_IMETHOD BeginUpdate(nsIDocument *aDocument);
NS_IMETHOD EndUpdate(nsIDocument *aDocument);
NS_IMETHOD BeginLoad(nsIDocument *aDocument);
NS_IMETHOD EndLoad(nsIDocument *aDocument);
NS_IMETHOD BeginReflow(nsIDocument *aDocument, nsIPresShell* aShell);
NS_IMETHOD EndReflow(nsIDocument *aDocument, nsIPresShell* aShell);
NS_IMETHOD ContentChanged(nsIDocument *aDocument,
nsIContent* aContent,
nsISupports* aSubContent);
NS_IMETHOD AttributeChanged(nsIDocument *aDocument,
nsIContent* aContent,
nsIAtom* aAttribute,
PRInt32 aHint);
NS_IMETHOD ContentAppended(nsIDocument *aDocument,
nsIContent* aContainer,
PRInt32 aNewIndexInContainer);
NS_IMETHOD ContentInserted(nsIDocument *aDocument,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInContainer);
NS_IMETHOD ContentReplaced(nsIDocument *aDocument,
nsIContent* aContainer,
nsIContent* aOldChild,
nsIContent* aNewChild,
PRInt32 aIndexInContainer);
NS_IMETHOD ContentRemoved(nsIDocument *aDocument,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInContainer);
NS_IMETHOD StyleSheetAdded(nsIDocument *aDocument,
nsIStyleSheet* aStyleSheet);
NS_IMETHOD StyleSheetRemoved(nsIDocument *aDocument,
nsIStyleSheet* aStyleSheet);
NS_IMETHOD StyleSheetDisabledStateChanged(nsIDocument *aDocument,
nsIStyleSheet* aStyleSheet,
PRBool aDisabled);
NS_IMETHOD StyleRuleChanged(nsIDocument *aDocument,
nsIStyleSheet* aStyleSheet,
nsIStyleRule* aStyleRule,
PRInt32 aHint);
NS_IMETHOD StyleRuleAdded(nsIDocument *aDocument,
nsIStyleSheet* aStyleSheet,
nsIStyleRule* aStyleRule);
NS_IMETHOD StyleRuleRemoved(nsIDocument *aDocument,
nsIStyleSheet* aStyleSheet,
nsIStyleRule* aStyleRule);
NS_IMETHOD DocumentWillBeDestroyed(nsIDocument *aDocument);
protected:
void ExecuteJavaScriptString(nsString& aJavaScript);
@ -109,6 +161,7 @@ protected:
nsCOMPtr<nsIDOMNode> FindNamedDOMNode(const nsString &aName, nsIDOMNode * aParent, PRInt32 & aCount, PRInt32 aEndCount);
nsCOMPtr<nsIDOMDocument> GetNamedDOMDoc(const nsString & aWebShellName);
nsCOMPtr<nsIDOMNode> GetParentNodeFromDOMDoc(nsIDOMDocument * aDOMDoc);
NS_IMETHOD CreateMenu(nsIMenuBar * aMenuBar, nsIDOMNode * aMenuNode, nsString & aMenuName);
nsCOMPtr<nsIDOMNode> GetDOMNodeFromWebShell(nsIWebShell *aShell);
void ExecuteStartupCode();
@ -121,9 +174,6 @@ protected:
nsIWidget* mWindow;
nsIWebShell* mWebShell;
nsIWidgetController* mController;
nsIDOMCharacterData* mStatusText;
nsIDOMHTMLInputElement* mURLBarText;
nsIDOMHTMLImageElement* mThrobber;
nsVoidArray mMenuDelegates;
};

383
xpfe/appshell/src/nsXULCommand.cpp
Просмотреть файл

@ -17,10 +17,7 @@
* Netscape Communications Corporation. All Rights Reserved.
*/
#include "nsIDOMNode.h"
#include "nsIDOMEvent.h"
#include "nsIDOMEventReceiver.h"
#include "nsIDOMHTMLInputElement.h"
#include "nsIDOMHTMLButtonElement.h"
#include "nsIMenuItem.h"
// FOr JS Execution
#include "nsIScriptContextOwner.h"
@ -29,39 +26,30 @@
#include "nsXULCommand.h"
#define DEBUGCMDS 0
#define DEBUG_MENUSDEL 1
//----------------------------------------------------------------------
// Class IID's
static NS_DEFINE_IID(kXULCommandCID, NS_XULCOMMAND_CID);
// IID's
static NS_DEFINE_IID(kIXULCommandIID, NS_IXULCOMMAND_IID);
static NS_DEFINE_IID(kIFactoryIID, NS_IFACTORY_IID);
static NS_DEFINE_IID(kIDOMNodeIID, NS_IDOMNODE_IID);
static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
static NS_DEFINE_IID(kIDOMMouseListenerIID, NS_IDOMMOUSELISTENER_IID);
static NS_DEFINE_IID(kIDOMKeyListenerIID, NS_IDOMKEYLISTENER_IID);
static NS_DEFINE_IID(kIDOMEventReceiverIID, NS_IDOMEVENTRECEIVER_IID);
static NS_DEFINE_IID(kIDOMHTMLInputElementIID, NS_IDOMHTMLINPUTELEMENT_IID);
static NS_DEFINE_IID(kIDOMHTMLButtonElement, NS_IDOMHTMLBUTTONELEMENT_IID);
static NS_DEFINE_IID(kIScriptContextOwnerIID, NS_ISCRIPTCONTEXTOWNER_IID);
static NS_DEFINE_IID(kIXULCommandIID, NS_IXULCOMMAND_IID);
//----------------------------------------------------------------------
nsXULCommand::nsXULCommand()
{
NS_INIT_REFCNT();
mIsEnabled = PR_FALSE;
mMenuItem = nsnull;
}
//----------------------------------------------------------------------
nsXULCommand::~nsXULCommand()
{
while (mSrcWidgets.Count() > 0) {
nsCOMPtr<nsIDOMNode> node = dont_AddRef(NS_STATIC_CAST(nsIDOMNode*,mSrcWidgets.ElementAt(0)));
mSrcWidgets.RemoveElementAt(0);
}
NS_IF_RELEASE(mMenuItem);
}
@ -77,100 +65,33 @@ nsXULCommand::QueryInterface(REFNSIID aIID, void** aInstancePtr)
if (NULL == aInstancePtr) {
return NS_ERROR_NULL_POINTER;
}
if (aIID.Equals(kIMenuListenerIID)) {
*aInstancePtr = (void*)(nsIMenuListener*)this;
NS_ADDREF_THIS();
return NS_OK;
}
if (aIID.Equals(kIXULCommandIID)) {
*aInstancePtr = (void*)(nsIXULCommand*)this;
NS_ADDREF_THIS();
return NS_OK;
}
if (aIID.Equals(kIDOMMouseListenerIID)) {
NS_ADDREF_THIS(); // Increase reference count for caller
*aInstancePtr = (void *)((nsIDOMMouseListener*)this);
return NS_OK;
}
if (aIID.Equals(kIDOMKeyListenerIID)) {
NS_ADDREF_THIS(); // Increase reference count for caller
*aInstancePtr = (void *)((nsIDOMKeyListener*)this);
return NS_OK;
}
if (aIID.Equals(kISupportsIID)) {
*aInstancePtr = (void*)(nsISupports*)(nsIXULCommand*)this;
*aInstancePtr = (void*)(nsISupports*)this;
NS_ADDREF_THIS();
return NS_OK;
}
return rv;
return NS_ERROR_NO_INTERFACE;
}
// XUL UI Objects
//----------------------------------------------------------------------
NS_IMETHODIMP nsXULCommand::SetName(const nsString &aName)
NS_IMETHODIMP nsXULCommand::GetDOMElement(nsIDOMElement ** aDOMElement)
{
mName = aName;
*aDOMElement = mDOMElement;
return NS_OK;
}
//----------------------------------------------------------------------
NS_IMETHODIMP nsXULCommand::GetName(nsString &aName) const
{
aName = mName;
return NS_OK;
}
//----------------------------------------------------------------------
NS_IMETHODIMP nsXULCommand::AddUINode(nsIDOMNode * aNode)
{
NS_PRECONDITION(nsnull != aNode, "adding event listener to null node");
nsCOMPtr<nsIDOMEventReceiver> receiver ( aNode );
if ( receiver ) {
receiver->AddEventListener((nsIDOMMouseListener*)this, kIDOMMouseListenerIID);
receiver->AddEventListener((nsIDOMKeyListener*)this, kIDOMKeyListenerIID);
mSrcWidgets.AppendElement(aNode);
NS_ADDREF(aNode);
return NS_OK;
}
return NS_ERROR_FAILURE;
}
//----------------------------------------------------------------------
NS_IMETHODIMP nsXULCommand::RemoveUINode(nsIDOMNode * aCmd)
{
PRInt32 index = mSrcWidgets.IndexOf(aCmd);
if (index > 0) {
mSrcWidgets.RemoveElementAt(index);
}
return NS_OK;
}
//----------------------------------------------------------------------
NS_IMETHODIMP nsXULCommand::SetEnabled(PRBool aIsEnabled)
{
mIsEnabled = aIsEnabled;
PRInt32 i, n = mSrcWidgets.Count();
for (i = 0; i < n; i++) {
nsCOMPtr<nsIDOMNode> node = dont_AddRef(NS_STATIC_CAST(nsIDOMNode*,mSrcWidgets.ElementAt(i)));
nsCOMPtr<nsIDOMHTMLInputElement> input ( do_QueryInterface(node) );
//*** rewrite this part to set an attribute on a nsIDOMElement
if ( input ) {
input->SetDisabled(aIsEnabled);
} else {
nsCOMPtr<nsIDOMHTMLButtonElement> btn ( do_QueryInterface(node) );
if ( btn )
btn->SetDisabled(!aIsEnabled);
}
//***
}
return NS_OK;
}
//----------------------------------------------------------------------
NS_IMETHODIMP nsXULCommand::GetEnabled(PRBool & aIsEnabled)
{
//*** rewrite this part to get an attribute on a nsIDOMElement
aIsEnabled = mIsEnabled;
return NS_OK;
}
//----------------------------------------------------------------------
@ -180,6 +101,27 @@ NS_IMETHODIMP nsXULCommand::SetCommand(const nsString & aStrCmd)
return NS_OK;
}
//----------------------------------------------------------------------
NS_IMETHODIMP nsXULCommand::SetMenuItem(nsIMenuItem * aMenuItem)
{
mMenuItem = aMenuItem;
NS_ADDREF(mMenuItem);
return NS_OK;
}
//----------------------------------------------------------------------
NS_IMETHODIMP nsXULCommand::AttributeHasBeenSet(const nsString & aAttr)
{
nsAutoString value;
mDOMElement->GetAttribute(aAttr, value);
if (DEBUG_MENUSDEL) printf("New value is [%s]=[%s]\n", aAttr.ToNewCString(), value.ToNewCString());
if (aAttr.Equals("disabled")) {
mMenuItem->SetEnabled((PRBool)(!value.Equals("true")));
}
return NS_OK;
}
//----------------------------------------------------------------------
NS_IMETHODIMP nsXULCommand::DoCommand()
{
@ -187,7 +129,7 @@ NS_IMETHODIMP nsXULCommand::DoCommand()
mWebShell->GetName( &name);
nsAutoString str(name);
if (DEBUGCMDS) printf("DoCommand - mWebShell is [%s] 0x%x\n", str.ToNewCString(), mWebShell);
if (DEBUG_MENUSDEL) printf("DoCommand - mWebShell is [%s] 0x%x\n", str.ToNewCString(), mWebShell);
return ExecuteJavaScriptString(mWebShell, mCommandStr);
}
@ -227,125 +169,16 @@ NS_IMETHODIMP nsXULCommand::ExecuteJavaScriptString(nsIWebShell* aWebShell, nsSt
PRBool isUndefined = PR_FALSE;
nsString rVal("xxx");
scriptContext->EvaluateString(aJavaScript, url, 0, rVal, &isUndefined);
if (DEBUGCMDS) printf("EvaluateString - %d [%s]\n", isUndefined, rVal.ToNewCString());
if (DEBUG_MENUSDEL) printf("EvaluateString - %d [%s]\n", isUndefined, rVal.ToNewCString());
}
}
return status;
}
//----------------------------------------------------------------------
NS_IMETHODIMP nsXULCommand::SetTooltip(const nsString &aTip)
{
mTooltip = aTip;
return NS_OK;
}
//----------------------------------------------------------------------
NS_IMETHODIMP nsXULCommand::GetTooltip(nsString &aTip) const
{
aTip = mTooltip;
return NS_OK;
}
//----------------------------------------------------------------------
NS_IMETHODIMP nsXULCommand::SetDescription(const nsString &aDescription)
{
mDescription = aDescription;
return NS_OK;
}
//----------------------------------------------------------------------
NS_IMETHODIMP nsXULCommand::GetDescription(nsString &aDescription) const
{
aDescription = mDescription;
return NS_OK;
}
//-----------------------------------------------------------------
//-- nsIDOMMouseListener
//-----------------------------------------------------------------
//-----------------------------------------------------------------
nsresult nsXULCommand::ProcessEvent(nsIDOMEvent* aEvent)
{
return NS_OK;
}
//-----------------------------------------------------------------
nsresult nsXULCommand::MouseUp(nsIDOMEvent* aMouseEvent)
{
return NS_OK;
}
//-----------------------------------------------------------------
nsresult nsXULCommand::MouseDown(nsIDOMEvent* aMouseEvent)
{
return NS_OK;
}
//-----------------------------------------------------------------
nsresult nsXULCommand::MouseClick(nsIDOMEvent* aMouseEvent)
{
if (DEBUGCMDS) printf("Executing [%s]\n", mCommandStr.ToNewCString());
if (mIsEnabled) {
DoCommand();
}
return NS_OK;
}
//-----------------------------------------------------------------
nsresult nsXULCommand::MouseDblClick(nsIDOMEvent* aMouseEvent)
{
return NS_OK;
}
//-----------------------------------------------------------------
nsresult nsXULCommand::MouseOver(nsIDOMEvent* aMouseEvent)
{
return NS_OK;
}
//-----------------------------------------------------------------
nsresult nsXULCommand::MouseOut(nsIDOMEvent* aMouseEvent)
{
return NS_OK;
}
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// nsIDOMKeyListener
//-----------------------------------------------------------------
nsresult nsXULCommand::KeyDown(nsIDOMEvent* aKeyEvent)
{
PRUint32 type;
aKeyEvent->GetKeyCode(&type);
return NS_OK;
}
//-----------------------------------------------------------------
nsresult nsXULCommand::KeyUp(nsIDOMEvent* aKeyEvent)
{
PRUint32 type;
aKeyEvent->GetKeyCode(&type);
if (nsIDOMEvent::VK_RETURN != type) {
return NS_OK;
}
nsCOMPtr<nsIDOMHTMLInputElement> input ( do_QueryInterface(mDOMElement) );
if ( input ) {
nsAutoString value;
input->GetValue(value);
//printf("Value [%s]\n", value.ToNewCString());
mWebShell->LoadURL(value);
}
return NS_OK;
}
//-----------------------------------------------------------------
nsresult nsXULCommand::KeyPress(nsIDOMEvent* aKeyEvent)
{
return NS_OK;
}
/////////////////////////////////////////////////////////////////////////
// nsIMenuListener Method(s)
/////////////////////////////////////////////////////////////////////////
nsEventStatus nsXULCommand::MenuSelected(const nsMenuEvent & aMenuEvent)
{
@ -353,135 +186,3 @@ nsEventStatus nsXULCommand::MenuSelected(const nsMenuEvent & aMenuEvent)
return nsEventStatus_eConsumeNoDefault;
}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------
// Factory code for creating nsXULCommand's
class nsXULCommandFactory : public nsIFactory
{
public:
nsXULCommandFactory();
virtual ~nsXULCommandFactory();
// nsISupports methods
NS_IMETHOD QueryInterface(const nsIID &aIID, void **aResult);
NS_IMETHOD_(nsrefcnt) AddRef(void);
NS_IMETHOD_(nsrefcnt) Release(void);
// nsIFactory methods
NS_IMETHOD CreateInstance(nsISupports *aOuter,
const nsIID &aIID,
void **aResult);
NS_IMETHOD LockFactory(PRBool aLock);
private:
nsrefcnt mRefCnt;
};
nsXULCommandFactory::nsXULCommandFactory()
{
mRefCnt = 0;
}
nsXULCommandFactory::~nsXULCommandFactory()
{
NS_ASSERTION(mRefCnt == 0, "non-zero refcnt at destruction");
}
nsresult
nsXULCommandFactory::QueryInterface(const nsIID &aIID, void **aResult)
{
if (aResult == NULL) {
return NS_ERROR_NULL_POINTER;
}
// Always NULL result, in case of failure
*aResult = NULL;
if (aIID.Equals(kISupportsIID)) {
*aResult = (void *)(nsISupports*)this;
} else if (aIID.Equals(kIFactoryIID)) {
*aResult = (void *)(nsIFactory*)this;
}
if (*aResult == NULL) {
return NS_NOINTERFACE;
}
NS_ADDREF_THIS(); // Increase reference count for caller
return NS_OK;
}
nsrefcnt
nsXULCommandFactory::AddRef()
{
return ++mRefCnt;
}
nsrefcnt
nsXULCommandFactory::Release()
{
if (--mRefCnt == 0) {
delete this;
return 0; // Don't access mRefCnt after deleting!
}
return mRefCnt;
}
nsresult
nsXULCommandFactory::CreateInstance(nsISupports *aOuter,
const nsIID &aIID,
void **aResult)
{
nsresult rv;
nsXULCommand *inst;
if (aResult == NULL) {
return NS_ERROR_NULL_POINTER;
}
*aResult = NULL;
if (nsnull != aOuter) {
rv = NS_ERROR_NO_AGGREGATION;
goto done;
}
NS_NEWXPCOM(inst, nsXULCommand);
if (inst == NULL) {
rv = NS_ERROR_OUT_OF_MEMORY;
goto done;
}
NS_ADDREF(inst);
rv = inst->QueryInterface(aIID, aResult);
NS_RELEASE(inst);
done:
return rv;
}
nsresult
nsXULCommandFactory::LockFactory(PRBool aLock)
{
// Not implemented in simplest case.
return NS_OK;
}
extern "C" nsresult
NS_NewXULCommandFactory(nsIFactory** aFactory)
{
nsresult rv = NS_OK;
nsIFactory* inst = new nsXULCommandFactory();
if (nsnull == inst) {
rv = NS_ERROR_OUT_OF_MEMORY;
}
else {
NS_ADDREF(inst);
}
*aFactory = inst;
return rv;
}

59
xpfe/appshell/src/nsXULCommand.h
Просмотреть файл

@ -20,10 +20,8 @@
#ifndef nsXULCommand_h__
#define nsXULCommand_h__
//#include "nsIMenuListener.h"
#include "nsIXULCommand.h"
#include "nsIDOMMouseListener.h"
#include "nsIDOMKeyListener.h"
#include "nsVoidArray.h"
#include "nsString.h"
#include "nsCRT.h"
#include "nsIDOMElement.h" // for some older c++ compilers.
@ -37,9 +35,7 @@ class nsIDOMEvent;
//----------------------------------------------------------------------
class nsXULCommand : public nsIXULCommand,
public nsIDOMMouseListener,
public nsIDOMKeyListener
class nsXULCommand : public nsIXULCommand //public nsIMenuListener
{
public:
@ -49,44 +45,16 @@ public:
// nsISupports
NS_DECL_ISUPPORTS
// XUL UI Objects
NS_IMETHOD SetName(const nsString &aName);
NS_IMETHOD GetName(nsString &aName) const;
NS_IMETHOD AddUINode(nsIDOMNode * aNode);
NS_IMETHOD RemoveUINode(nsIDOMNode * aCmd);
NS_IMETHOD SetEnabled(PRBool aIsEnabled);
NS_IMETHOD GetEnabled(PRBool & aIsEnabled);
NS_IMETHOD SetTooltip(const nsString &aTip);
NS_IMETHOD GetTooltip(nsString &aTip) const;
NS_IMETHOD SetDescription(const nsString &aDescription);
NS_IMETHOD GetDescription(nsString &aDescription) const;
NS_IMETHOD SetMenuItem(nsIMenuItem * aMenuItem);
NS_IMETHOD AttributeHasBeenSet(const nsString & aAttr);
NS_IMETHOD SetDOMElement(nsIDOMElement * aDOMElement);
NS_IMETHOD GetDOMElement(nsIDOMElement ** aDOMElement);
NS_IMETHOD SetWebShell(nsIWebShell * aWebShell);
NS_IMETHOD SetCommand(const nsString & aStrCmd);
NS_IMETHOD DoCommand();
// Non-Interface Methods
NS_IMETHOD SetDOMElement(nsIDOMElement * aDOMNode);
NS_IMETHOD SetWebShell(nsIWebShell * aWebShell);
NS_IMETHOD SetCommand(const nsString & aStrCmd);
// nsIDOMEventListener
virtual nsresult ProcessEvent(nsIDOMEvent* aEvent);
// nsIDOMMouseListener (is derived from nsIDOMEventListener)
virtual nsresult MouseDown(nsIDOMEvent* aMouseEvent);
virtual nsresult MouseUp(nsIDOMEvent* aMouseEvent);
virtual nsresult MouseClick(nsIDOMEvent* aMouseEvent);
virtual nsresult MouseDblClick(nsIDOMEvent* aMouseEvent);
virtual nsresult MouseOver(nsIDOMEvent* aMouseEvent);
virtual nsresult MouseOut(nsIDOMEvent* aMouseEvent);
// nsIDOMKeyListener
virtual nsresult KeyDown(nsIDOMEvent* aKeyEvent);
virtual nsresult KeyUp(nsIDOMEvent* aKeyEvent);
virtual nsresult KeyPress(nsIDOMEvent* aKeyEvent);
// nsIMenuListener
virtual nsEventStatus MenuSelected(const nsMenuEvent & aMenuEvent);
@ -94,17 +62,12 @@ public:
protected:
NS_IMETHOD ExecuteJavaScriptString(nsIWebShell* aWebShell, nsString& aJavaScript);
nsString mName;
nsString mCommandStr;
nsString mTooltip;
nsString mDescription;
PRBool mIsEnabled;
nsVoidArray mSrcWidgets;
nsString mCommandStr;
nsCOMPtr<nsIWebShell> mWebShell;
nsCOMPtr<nsIDOMElement> mDOMElement;
nsIMenuItem * mMenuItem;
};