Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-08 10:44:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

r=akkana sr=sfrasier 125146 a=asa This patch will make the embedding API's a better friend to all. It eliminates the use of multibyte strings in command names and also allows for simple command to not require the nsICommandParams interface to be filled.

Browse Source
This commit is contained in:
mjudge%netscape.com 2002-07-15 22:04:13 +00:00
parent f479f38af4
commit 47e8fbc7bf
40 changed files with 697 additions and 747 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
content/xbl/src/nsXBLPrototypeHandler.cpp
View File

@ -290,10 +290,10 @@ nsXBLPrototypeHandler::ExecuteHandler(nsIDOMEventReceiver* aReceiver,
privateWindow->GetRootFocusController(getter_AddRefs(focusController));
}
nsDependentString command(mHandlerText);
nsCAutoString command;
command.AssignWithConversion(mHandlerText);
if (focusController)
focusController->GetControllerForCommand(command, getter_AddRefs(controller));
focusController->GetControllerForCommand(command.get(), getter_AddRefs(controller));
else GetController(aReceiver, getter_AddRefs(controller)); // We're attached to the receiver possibly.
nsAutoString type;
@ -323,7 +323,7 @@ nsXBLPrototypeHandler::ExecuteHandler(nsIDOMEventReceiver* aReceiver,
aEvent->PreventDefault();
if (controller)
controller->DoCommand(command);
controller->DoCommand(command.get());
return NS_OK;
}

20
content/xul/document/public/nsIController.idl
View File

@ -40,12 +40,12 @@
[scriptable, uuid(D5B61B82-1DA4-11d3-BF87-00105A1B0627)]
interface nsIController : nsISupports {
boolean isCommandEnabled(in DOMString command);
boolean supportsCommand(in DOMString command);
boolean isCommandEnabled(in string command);
boolean supportsCommand(in string command);
void doCommand(in DOMString command);
void doCommand(in string command);
void onEvent(in DOMString eventName);
void onEvent(in string eventName);
};
@ -62,9 +62,9 @@ interface nsICommandParams;
interface nsICommandController : nsISupports
{
void getCommandState( in nsICommandParams aCommandParams);
void getCommandState( in string command, in nsICommandParams aCommandParams);
void doCommand(in nsICommandParams aCommandParams);
void doCommand(in string command, in nsICommandParams aCommandParams);
};
@ -79,17 +79,17 @@ interface nsISimpleEnumerator;
interface nsIControllerCommandGroup : nsISupports
{
void addCommandToGroup(in DOMString aCommand, in DOMString aGroup);
void removeCommandFromGroup(in DOMString aCommand, in DOMString aGroup);
void addCommandToGroup(in string aCommand, in string aGroup);
void removeCommandFromGroup(in string aCommand, in string aGroup);
boolean isCommandInGroup(in DOMString aCommand, in DOMString aGroup);
boolean isCommandInGroup(in string aCommand, in string aGroup);
/*
We should expose some methods that allow for enumeration.
*/
nsISimpleEnumerator getGroupsEnumerator();
nsISimpleEnumerator getEnumeratorForGroup(in DOMString aGroup);
nsISimpleEnumerator getEnumeratorForGroup(in string aGroup);
};

20
content/xul/document/public/nsIControllerCommand.idl
View File

@ -61,7 +61,7 @@ interface nsIControllerCommand : nsISupports
* allowing the command to get some context information.
* The contents of this cookie are implementation-defined.
*/
boolean isCommandEnabled(in DOMString aCommandName, in nsISupports aCommandRefCon);
boolean isCommandEnabled(in string aCommandName, in nsISupports aCommandRefCon);
/**
* Execute the name command.
@ -72,7 +72,7 @@ interface nsIControllerCommand : nsISupports
* allowing the command to get some context information.
* The contents of this cookie are implementation-defined.
*/
void doCommand(in DOMString aCommandName, in nsISupports aCommandRefCon);
void doCommand(in string aCommandName, in nsISupports aCommandRefCon);
};
@ -100,7 +100,7 @@ interface nsIStateUpdatingControllerCommand : nsISupports
* allowing the command to get some context information.
* The contents of this cookie are implementation-defined.
*/
void updateCommandState(in DOMString aCommandName, in nsISupports aCommandRefCon);
void updateCommandState(in string aCommandName, in nsISupports aCommandRefCon);
};
@ -129,15 +129,15 @@ interface nsIControllerCommandManager : nsISupports
*
* @param aCommand the handler for this command.
*/
void registerCommand(in DOMString aCommandName, in nsIControllerCommand aCommand);
void unregisterCommand(in DOMString aCommandName, in nsIControllerCommand aCommand);
void registerCommand(in string aCommandName, in nsIControllerCommand aCommand);
void unregisterCommand(in string aCommandName, in nsIControllerCommand aCommand);
/**
* Find the command handler which has been registered to handle the named command.
*
* @param aCommandName the name of the command to find the handler for.
*/
nsIControllerCommand findCommandHandler(in DOMString aCommandName);
nsIControllerCommand findCommandHandler(in string aCommandName);
/**
* Get whether the named command is enabled.
@ -145,7 +145,7 @@ interface nsIControllerCommandManager : nsISupports
* @param aCommandName the name of the command to test
* @param aCommandRefCon the command context data
*/
boolean isCommandEnabled(in DOMString aCommandName, in nsISupports aCommandRefCon);
boolean isCommandEnabled(in string aCommandName, in nsISupports aCommandRefCon);
/**
* Tell the command to udpate its state (if it is a state updating command)
@ -153,7 +153,7 @@ interface nsIControllerCommandManager : nsISupports
* @param aCommandName the name of the command to update
* @param aCommandRefCon the command context data
*/
void updateCommandState(in DOMString aCommandName, in nsISupports aCommandRefCon);
void updateCommandState(in string aCommandName, in nsISupports aCommandRefCon);
/**
* Get whether the named command is supported.
@ -161,7 +161,7 @@ interface nsIControllerCommandManager : nsISupports
* @param aCommandName the name of the command to test
* @param aCommandRefCon the command context data
*/
boolean supportsCommand(in DOMString aCommandName, in nsISupports aCommandRefCon);
boolean supportsCommand(in string aCommandName, in nsISupports aCommandRefCon);
/**
* Execute the named command.
@ -169,7 +169,7 @@ interface nsIControllerCommandManager : nsISupports
* @param aCommandName the name of the command to execute
* @param aCommandRefCon the command context data
*/
void doCommand(in DOMString aCommandName, in nsISupports aCommandRefCon);
void doCommand(in string aCommandName, in nsISupports aCommandRefCon);
};

2
content/xul/document/public/nsIControllers.idl
View File

@ -45,7 +45,7 @@ interface nsIControllers : nsISupports
{
attribute nsIDOMXULCommandDispatcher commandDispatcher;
nsIController getControllerForCommand(in DOMString command);
nsIController getControllerForCommand(in string command);
void insertControllerAt(in unsigned long index, in nsIController controller);
nsIController removeControllerAt(in unsigned long index);

2
content/xul/document/src/nsXULCommandDispatcher.cpp
View File

@ -420,7 +420,7 @@ nsXULCommandDispatcher::GetControllers(nsIControllers** aResult)
}
NS_IMETHODIMP
nsXULCommandDispatcher::GetControllerForCommand(const nsAString& aCommand, nsIController** _retval)
nsXULCommandDispatcher::GetControllerForCommand(const char *aCommand, nsIController** _retval)
{
EnsureFocusController();
return mFocusController->GetControllerForCommand(aCommand, _retval);

2
content/xul/document/src/nsXULControllers.cpp
View File

@ -130,7 +130,7 @@ nsXULControllers::SetCommandDispatcher(nsIDOMXULCommandDispatcher* aCommandDispa
}
NS_IMETHODIMP
nsXULControllers::GetControllerForCommand(const nsAString& aCommand, nsIController** _retval)
nsXULControllers::GetControllerForCommand(const char *aCommand, nsIController** _retval)
{
NS_ENSURE_ARG_POINTER(_retval);
*_retval = nsnull;

34
docshell/base/nsWebShell.cpp
View File

@ -989,7 +989,7 @@ nsresult nsWebShell::EndPageLoad(nsIWebProgress *aProgress,
#endif
nsresult
nsWebShell::GetControllerForCommand ( const nsAString & inCommand, nsIController** outController )
nsWebShell::GetControllerForCommand ( const char * inCommand, nsIController** outController )
{
NS_ENSURE_ARG_POINTER(outController);
*outController = nsnull;
@ -1010,7 +1010,7 @@ nsWebShell::GetControllerForCommand ( const nsAString & inCommand, nsIController
nsresult
nsWebShell::IsCommandEnabled ( const nsAString & inCommand, PRBool* outEnabled )
nsWebShell::IsCommandEnabled ( const char * inCommand, PRBool* outEnabled )
{
NS_ENSURE_ARG_POINTER(outEnabled);
*outEnabled = PR_FALSE;
@ -1027,7 +1027,7 @@ nsWebShell::IsCommandEnabled ( const nsAString & inCommand, PRBool* outEnabled )
nsresult
nsWebShell::DoCommand ( const nsAString & inCommand )
nsWebShell::DoCommand ( const char * inCommand )
{
nsresult rv = NS_ERROR_FAILURE;
@ -1043,81 +1043,81 @@ nsWebShell::DoCommand ( const nsAString & inCommand )
NS_IMETHODIMP
nsWebShell::CanCutSelection(PRBool* aResult)
{
return IsCommandEnabled ( NS_LITERAL_STRING("cmd_cut"), aResult );
return IsCommandEnabled ( "cmd_cut", aResult );
}
NS_IMETHODIMP
nsWebShell::CanCopySelection(PRBool* aResult)
{
return IsCommandEnabled ( NS_LITERAL_STRING("cmd_copy"), aResult );
return IsCommandEnabled ( "cmd_copy", aResult );
}
NS_IMETHODIMP
nsWebShell::CanCopyLinkLocation(PRBool* aResult)
{
return IsCommandEnabled ( NS_LITERAL_STRING("cmd_copyLink"), aResult );
return IsCommandEnabled ( "cmd_copyLink", aResult );
}
NS_IMETHODIMP
nsWebShell::CanCopyImageLocation(PRBool* aResult)
{
return IsCommandEnabled ( NS_LITERAL_STRING("cmd_copyImageLocation"),
return IsCommandEnabled ( "cmd_copyImageLocation",
aResult );
}
NS_IMETHODIMP
nsWebShell::CanCopyImageContents(PRBool* aResult)
{
return IsCommandEnabled ( NS_LITERAL_STRING("cmd_copyImageContents"),
return IsCommandEnabled ( "cmd_copyImageContents",
aResult );
}
NS_IMETHODIMP
nsWebShell::CanPaste(PRBool* aResult)
{
return IsCommandEnabled ( NS_LITERAL_STRING("cmd_paste"), aResult );
return IsCommandEnabled ( "cmd_paste", aResult );
}
NS_IMETHODIMP
nsWebShell::CutSelection(void)
{
return DoCommand ( NS_LITERAL_STRING("cmd_cut") );
return DoCommand ( "cmd_cut" );
}
NS_IMETHODIMP
nsWebShell::CopySelection(void)
{
return DoCommand ( NS_LITERAL_STRING("cmd_copy") );
return DoCommand ( "cmd_copy" );
}
NS_IMETHODIMP
nsWebShell::CopyLinkLocation(void)
{
return DoCommand ( NS_LITERAL_STRING("cmd_copyLink") );
return DoCommand ( "cmd_copyLink" );
}
NS_IMETHODIMP
nsWebShell::CopyImageLocation(void)
{
return DoCommand ( NS_LITERAL_STRING("cmd_copyImageLocation") );
return DoCommand ( "cmd_copyImageLocation" );
}
NS_IMETHODIMP
nsWebShell::CopyImageContents(void)
{
return DoCommand ( NS_LITERAL_STRING("cmd_copyImageContents") );
return DoCommand ( "cmd_copyImageContents" );
}
NS_IMETHODIMP
nsWebShell::Paste(void)
{
return DoCommand ( NS_LITERAL_STRING("cmd_paste") );
return DoCommand ( "cmd_paste" );
}
NS_IMETHODIMP
nsWebShell::SelectAll(void)
{
return DoCommand ( NS_LITERAL_STRING("cmd_selectAll") );
return DoCommand ( "cmd_selectAll" );
}
@ -1130,7 +1130,7 @@ nsWebShell::SelectAll(void)
NS_IMETHODIMP
nsWebShell::SelectNone(void)
{
return DoCommand ( NS_LITERAL_STRING("cmd_selectNone") );
return DoCommand ( "cmd_selectNone" );
}

6
docshell/base/nsWebShell.h
View File

@ -101,9 +101,9 @@ protected:
void InitFrameData();
// helpers for executing commands
virtual nsresult GetControllerForCommand ( const nsAString & inCommand, nsIController** outController );
virtual nsresult IsCommandEnabled ( const nsAString & inCommand, PRBool* outEnabled );
virtual nsresult DoCommand ( const nsAString & inCommand );
virtual nsresult GetControllerForCommand ( const char *inCommand, nsIController** outController );
virtual nsresult IsCommandEnabled ( const char * inCommand, PRBool* outEnabled );
virtual nsresult DoCommand ( const char * inCommand );
nsresult EnsureCommandHandler();
//

2
dom/public/base/nsIFocusController.h
View File

@ -59,7 +59,7 @@ public:
NS_IMETHOD GetPopupNode(nsIDOMNode** aNode)=0;
NS_IMETHOD SetPopupNode(nsIDOMNode* aNode)=0;
NS_IMETHOD GetControllerForCommand(const nsAString& aCommand, nsIController** aResult)=0;
NS_IMETHOD GetControllerForCommand(const char * aCommand, nsIController** aResult)=0;
NS_IMETHOD GetControllers(nsIControllers** aResult)=0;
NS_IMETHOD MoveFocus(PRBool aForward, nsIDOMElement* aElt)=0;

2
dom/public/idl/xul/nsIDOMXULCommandDispatcher.idl
View File

@ -59,7 +59,7 @@ interface nsIDOMXULCommandDispatcher : nsISupports
void updateCommands(in DOMString eventName);
nsIController getControllerForCommand(in DOMString command);
nsIController getControllerForCommand(in string command);
nsIControllers getControllers();
void advanceFocus();

2
dom/src/base/nsFocusController.cpp
View File

@ -357,7 +357,7 @@ nsFocusController::GetParentWindowFromDocument(nsIDOMDocument* aDocument, nsIDOM
}
NS_IMETHODIMP
nsFocusController::GetControllerForCommand(const nsAString& aCommand, nsIController** _retval)
nsFocusController::GetControllerForCommand(const char * aCommand, nsIController** _retval)
{
NS_ENSURE_ARG_POINTER(_retval);
*_retval = nsnull;

2
dom/src/base/nsFocusController.h
View File

@ -68,7 +68,7 @@ public:
NS_IMETHOD GetPopupNode(nsIDOMNode** aNode);
NS_IMETHOD SetPopupNode(nsIDOMNode* aNode);
NS_IMETHOD GetControllerForCommand(const nsAString& aCommand, nsIController** aResult);
NS_IMETHOD GetControllerForCommand(const char *aCommand, nsIController** aResult);
NS_IMETHOD GetControllers(nsIControllers** aResult);
NS_IMETHOD MoveFocus(PRBool aForward, nsIDOMElement* aElt);

223
dom/src/base/nsGlobalWindow.cpp
View File

@ -5985,7 +5985,7 @@ nsDOMWindowController::GetSelectionController(nsISelectionController **aSelCon)
NS_IMETHODIMP
nsDOMWindowController::IsCommandEnabled(const nsAString& aCommand,
nsDOMWindowController::IsCommandEnabled(const char* aCommand,
PRBool *aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
@ -5998,33 +5998,31 @@ nsDOMWindowController::IsCommandEnabled(const nsAString& aCommand,
NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_TRUE(editInterface, NS_ERROR_NOT_INITIALIZED);
nsCAutoString commandName;
commandName.AssignWithConversion(aCommand);
if (commandName.Equals(sCopyString)) {
if (!nsCRT::strcmp(sCopyString,aCommand)) {
rv = editInterface->GetCopyable(aResult);
}
else if (commandName.Equals(sCutString)) {
else if (!nsCRT::strcmp(sCutString,aCommand)) {
rv = editInterface->GetCutable(aResult);
}
else if (commandName.Equals(sPasteString)) {
else if (!nsCRT::strcmp(sPasteString,aCommand)) {
rv = editInterface->GetPasteable(aResult);
}
else if (commandName.Equals(sSelectAllString)) {
else if (!nsCRT::strcmp(sSelectAllString,aCommand)) {
*aResult = PR_TRUE;
rv = NS_OK;
}
else if (commandName.Equals(sSelectNoneString)) {
else if (!nsCRT::strcmp(sSelectNoneString,aCommand)) {
*aResult = PR_TRUE;
rv = NS_OK;
}
else if (commandName.Equals(sCopyLinkString)) {
else if (!nsCRT::strcmp(sCopyLinkString,aCommand)) {
rv = editInterface->GetInLink(aResult);
}
else if (commandName.Equals(sCopyImageLocationString)) {
else if (!nsCRT::strcmp(sCopyImageLocationString,aCommand)) {
rv = editInterface->GetInImage(aResult);
}
else if (commandName.Equals(sCopyImageContentsString)) {
else if (!nsCRT::strcmp(sCopyImageContentsString,aCommand)) {
rv = editInterface->GetInImage(aResult);
}
@ -6032,48 +6030,45 @@ nsDOMWindowController::IsCommandEnabled(const nsAString& aCommand,
}
NS_IMETHODIMP
nsDOMWindowController::SupportsCommand(const nsAString& aCommand,
nsDOMWindowController::SupportsCommand(const char * aCommand,
PRBool *outSupported)
{
NS_ENSURE_ARG_POINTER(outSupported);
*outSupported = PR_FALSE;
nsCAutoString commandName;
commandName.AssignWithConversion(aCommand);
if (commandName.Equals(sCopyString) ||
commandName.Equals(sSelectAllString) ||
commandName.Equals(sSelectNoneString) ||
commandName.Equals(sCutString) ||
commandName.Equals(sPasteString) ||
commandName.Equals(sScrollTopString) ||
commandName.Equals(sScrollBottomString) ||
commandName.Equals(sCopyLinkString) ||
commandName.Equals(sCopyImageLocationString) ||
commandName.Equals(sCopyImageContentsString) ||
commandName.Equals(sScrollPageUpString) ||
commandName.Equals(sScrollPageDownString) ||
commandName.Equals(sScrollLineUpString) ||
commandName.Equals(sScrollLineDownString) ||
commandName.Equals(sScrollLeftString) ||
commandName.Equals(sScrollRightString) ||
commandName.Equals(sSelectCharPreviousString) ||
commandName.Equals(sSelectCharNextString) ||
commandName.Equals(sWordPreviousString) ||
commandName.Equals(sWordNextString) ||
commandName.Equals(sSelectWordPreviousString) ||
commandName.Equals(sSelectWordNextString) ||
commandName.Equals(sBeginLineString) ||
commandName.Equals(sEndLineString) ||
commandName.Equals(sSelectBeginLineString) ||
commandName.Equals(sSelectEndLineString) ||
commandName.Equals(sSelectLinePreviousString) ||
commandName.Equals(sSelectLineNextString) ||
commandName.Equals(sSelectPagePreviousString) ||
commandName.Equals(sSelectPageNextString) ||
commandName.Equals(sSelectMoveTopString) ||
commandName.Equals(sSelectMoveBottomString)
if (!nsCRT::strcmp(aCommand,sCopyString) ||
!nsCRT::strcmp(aCommand,sSelectAllString) ||
!nsCRT::strcmp(aCommand,sSelectNoneString) ||
!nsCRT::strcmp(aCommand,sCutString) ||
!nsCRT::strcmp(aCommand,sPasteString) ||
!nsCRT::strcmp(aCommand,sScrollTopString) ||
!nsCRT::strcmp(aCommand,sScrollBottomString) ||
!nsCRT::strcmp(aCommand,sCopyLinkString) ||
!nsCRT::strcmp(aCommand,sCopyImageLocationString) ||
!nsCRT::strcmp(aCommand,sCopyImageContentsString) ||
!nsCRT::strcmp(aCommand,sScrollPageUpString) ||
!nsCRT::strcmp(aCommand,sScrollPageDownString) ||
!nsCRT::strcmp(aCommand,sScrollLineUpString) ||
!nsCRT::strcmp(aCommand,sScrollLineDownString) ||
!nsCRT::strcmp(aCommand,sScrollLeftString) ||
!nsCRT::strcmp(aCommand,sScrollRightString) ||
!nsCRT::strcmp(aCommand,sSelectCharPreviousString) ||
!nsCRT::strcmp(aCommand,sSelectCharNextString) ||
!nsCRT::strcmp(aCommand,sWordPreviousString) ||
!nsCRT::strcmp(aCommand,sWordNextString) ||
!nsCRT::strcmp(aCommand,sSelectWordPreviousString) ||
!nsCRT::strcmp(aCommand,sSelectWordNextString) ||
!nsCRT::strcmp(aCommand,sBeginLineString) ||
!nsCRT::strcmp(aCommand,sEndLineString) ||
!nsCRT::strcmp(aCommand,sSelectBeginLineString) ||
!nsCRT::strcmp(aCommand,sSelectEndLineString) ||
!nsCRT::strcmp(aCommand,sSelectLinePreviousString) ||
!nsCRT::strcmp(aCommand,sSelectLineNextString) ||
!nsCRT::strcmp(aCommand,sSelectPagePreviousString) ||
!nsCRT::strcmp(aCommand,sSelectPageNextString) ||
!nsCRT::strcmp(aCommand,sSelectMoveTopString) ||
!nsCRT::strcmp(aCommand,sSelectMoveBottomString)
)
*outSupported = PR_TRUE;
@ -6081,45 +6076,43 @@ nsDOMWindowController::SupportsCommand(const nsAString& aCommand,
}
NS_IMETHODIMP
nsDOMWindowController::DoCommand(const nsAString & aCommand)
nsDOMWindowController::DoCommand(const char *aCommand)
{
nsresult rv = NS_ERROR_FAILURE;
nsCAutoString commandName;
commandName.AssignWithConversion(aCommand);
if (commandName.Equals(sCopyString) ||
commandName.Equals(sSelectAllString) ||
commandName.Equals(sSelectNoneString) ||
commandName.Equals(sCutString) ||
commandName.Equals(sPasteString) ||
commandName.Equals(sCopyLinkString) ||
commandName.Equals(sCopyImageLocationString) ||
commandName.Equals(sCopyImageContentsString)) {
rv = DoCommandWithEditInterface(commandName);
if (!nsCRT::strcmp(aCommand,sCopyString) ||
!nsCRT::strcmp(aCommand,sSelectAllString) ||
!nsCRT::strcmp(aCommand,sSelectNoneString) ||
!nsCRT::strcmp(aCommand,sCutString) ||
!nsCRT::strcmp(aCommand,sPasteString) ||
!nsCRT::strcmp(aCommand,sCopyLinkString) ||
!nsCRT::strcmp(aCommand,sCopyImageLocationString) ||
!nsCRT::strcmp(aCommand,sCopyImageContentsString)) {
rv = DoCommandWithEditInterface(aCommand);
}
else if (commandName.Equals(sScrollTopString) ||
commandName.Equals(sScrollBottomString) ||
commandName.Equals(sScrollPageUpString) ||
commandName.Equals(sScrollPageDownString) ||
commandName.Equals(sScrollLineUpString) ||
commandName.Equals(sScrollLineDownString) ||
commandName.Equals(sScrollLeftString) ||
commandName.Equals(sScrollRightString) ||
commandName.Equals(sSelectCharPreviousString) ||
commandName.Equals(sSelectCharNextString) ||
commandName.Equals(sWordPreviousString) ||
commandName.Equals(sWordNextString) ||
commandName.Equals(sSelectWordPreviousString) ||
commandName.Equals(sSelectWordNextString) ||
commandName.Equals(sBeginLineString) ||
commandName.Equals(sEndLineString) ||
commandName.Equals(sSelectBeginLineString) ||
commandName.Equals(sSelectEndLineString) ||
commandName.Equals(sSelectLinePreviousString) ||
commandName.Equals(sSelectLineNextString) ||
commandName.Equals(sSelectMoveTopString) ||
commandName.Equals(sSelectMoveBottomString)) {
rv = DoCommandWithSelectionController(commandName);
else if (!nsCRT::strcmp(aCommand,sScrollTopString) ||
!nsCRT::strcmp(aCommand,sScrollBottomString) ||
!nsCRT::strcmp(aCommand,sScrollPageUpString) ||
!nsCRT::strcmp(aCommand,sScrollPageDownString) ||
!nsCRT::strcmp(aCommand,sScrollLineUpString) ||
!nsCRT::strcmp(aCommand,sScrollLineDownString) ||
!nsCRT::strcmp(aCommand,sScrollLeftString) ||
!nsCRT::strcmp(aCommand,sScrollRightString) ||
!nsCRT::strcmp(aCommand,sSelectCharPreviousString) ||
!nsCRT::strcmp(aCommand,sSelectCharNextString) ||
!nsCRT::strcmp(aCommand,sWordPreviousString) ||
!nsCRT::strcmp(aCommand,sWordNextString) ||
!nsCRT::strcmp(aCommand,sSelectWordPreviousString) ||
!nsCRT::strcmp(aCommand,sSelectWordNextString) ||
!nsCRT::strcmp(aCommand,sBeginLineString) ||
!nsCRT::strcmp(aCommand,sEndLineString) ||
!nsCRT::strcmp(aCommand,sSelectBeginLineString) ||
!nsCRT::strcmp(aCommand,sSelectEndLineString) ||
!nsCRT::strcmp(aCommand,sSelectLinePreviousString) ||
!nsCRT::strcmp(aCommand,sSelectLineNextString) ||
!nsCRT::strcmp(aCommand,sSelectMoveTopString) ||
!nsCRT::strcmp(aCommand,sSelectMoveBottomString)) {
rv = DoCommandWithSelectionController(aCommand);
// If the user moves the caret in browse with caret mode
// Focus whatever they move onto, if it's focusable
if (mBrowseWithCaret) {
@ -6135,7 +6128,7 @@ nsDOMWindowController::DoCommand(const nsAString & aCommand)
}
nsresult
nsDOMWindowController::DoCommandWithEditInterface(const nsCString& aCommandName)
nsDOMWindowController::DoCommandWithEditInterface(const char *aCommandName)
{
// get edit interface...
nsCOMPtr<nsIContentViewerEdit> editInterface;
@ -6146,21 +6139,21 @@ nsDOMWindowController::DoCommandWithEditInterface(const nsCString& aCommandName)
rv = NS_ERROR_FAILURE;
if (aCommandName.Equals(sCopyString))
if (!nsCRT::strcmp(aCommandName,sCopyString))
rv = editInterface->CopySelection();
else if (aCommandName.Equals(sSelectAllString))
else if (!nsCRT::strcmp(aCommandName,sSelectAllString))
rv = editInterface->SelectAll();
else if (aCommandName.Equals(sSelectNoneString))
else if (!nsCRT::strcmp(aCommandName,sSelectNoneString))
rv = editInterface->ClearSelection();
else if (aCommandName.Equals(sCutString))
else if (!nsCRT::strcmp(aCommandName,sCutString))
rv = editInterface->CutSelection();
else if (aCommandName.Equals(sPasteString))
else if (!nsCRT::strcmp(aCommandName,sPasteString))
rv = editInterface->Paste();
else if (aCommandName.Equals(sCopyLinkString))
else if (!nsCRT::strcmp(aCommandName,sCopyLinkString))
rv = editInterface->CopyLinkLocation();
else if (aCommandName.Equals(sCopyImageLocationString))
else if (!nsCRT::strcmp(aCommandName,sCopyImageLocationString))
rv = editInterface->CopyImageLocation();
else if (aCommandName.Equals(sCopyImageContentsString))
else if (!nsCRT::strcmp(aCommandName,sCopyImageContentsString))
rv = editInterface->CopyImageContents();
return rv;
@ -6168,7 +6161,7 @@ nsDOMWindowController::DoCommandWithEditInterface(const nsCString& aCommandName)
}
nsresult
nsDOMWindowController::DoCommandWithSelectionController(const nsCString& aCommandName) {
nsDOMWindowController::DoCommandWithSelectionController(const char *aCommandName) {
// get selection controller...
nsCOMPtr<nsISelectionController> selCont;
@ -6179,51 +6172,51 @@ nsDOMWindowController::DoCommandWithSelectionController(const nsCString& aComman
rv = NS_ERROR_FAILURE;
if (aCommandName.Equals(sScrollTopString))
if (!nsCRT::strcmp(aCommandName,sScrollTopString))
rv = (mBrowseWithCaret? selCont->CompleteMove(PR_FALSE, PR_FALSE): selCont->CompleteScroll(PR_FALSE));
else if (aCommandName.Equals(sScrollBottomString))
else if (!nsCRT::strcmp(aCommandName,sScrollBottomString))
rv = (mBrowseWithCaret? selCont->CompleteMove(PR_TRUE, PR_FALSE): selCont->CompleteScroll(PR_TRUE));
else if (aCommandName.Equals(sScrollPageUpString))
else if (!nsCRT::strcmp(aCommandName,sScrollPageUpString))
rv = (mBrowseWithCaret? selCont->PageMove(PR_FALSE, PR_FALSE): selCont->ScrollPage(PR_FALSE));
else if (aCommandName.Equals(sScrollPageDownString))
else if (!nsCRT::strcmp(aCommandName,sScrollPageDownString))
rv = (mBrowseWithCaret? selCont->PageMove(PR_TRUE, PR_FALSE): selCont->ScrollPage(PR_TRUE));
else if (aCommandName.Equals(sScrollLineUpString))
else if (!nsCRT::strcmp(aCommandName,sScrollLineUpString))
rv = (mBrowseWithCaret? selCont->LineMove(PR_FALSE, PR_FALSE): selCont->ScrollLine(PR_FALSE));
else if (aCommandName.Equals(sScrollLineDownString))
else if (!nsCRT::strcmp(aCommandName,sScrollLineDownString))
rv = (mBrowseWithCaret? selCont->LineMove(PR_TRUE, PR_FALSE): selCont->ScrollLine(PR_TRUE));
else if (aCommandName.Equals(sScrollLeftString))
else if (!nsCRT::strcmp(aCommandName,sScrollLeftString))
rv = (mBrowseWithCaret? selCont->CharacterMove(PR_FALSE, PR_FALSE): selCont->ScrollHorizontal(PR_TRUE));
else if (aCommandName.Equals(sScrollRightString))
else if (!nsCRT::strcmp(aCommandName,sScrollRightString))
rv = (mBrowseWithCaret? selCont->CharacterMove(PR_TRUE, PR_FALSE): selCont->ScrollHorizontal(PR_FALSE));
// These commands are so the browser can use editor navigation key bindings -
// Helps with accessibility - aaronl@chorus.net
else if (aCommandName.Equals(sSelectCharPreviousString))
else if (!nsCRT::strcmp(aCommandName,sSelectCharPreviousString))
rv = selCont->CharacterMove(PR_FALSE, PR_TRUE);
else if (aCommandName.Equals(sSelectCharNextString))
else if (!nsCRT::strcmp(aCommandName,sSelectCharNextString))
rv = selCont->CharacterMove(PR_TRUE, PR_TRUE);
else if (aCommandName.Equals(sWordPreviousString))
else if (!nsCRT::strcmp(aCommandName,sWordPreviousString))
rv = selCont->WordMove(PR_FALSE, PR_FALSE);
else if (aCommandName.Equals(sWordNextString))
else if (!nsCRT::strcmp(aCommandName,sWordNextString))
rv = selCont->WordMove(PR_TRUE, PR_FALSE);
else if (aCommandName.Equals(sSelectWordPreviousString))
else if (!nsCRT::strcmp(aCommandName,sSelectWordPreviousString))
rv = selCont->WordMove(PR_FALSE, PR_TRUE);
else if (aCommandName.Equals(sSelectWordNextString))
else if (!nsCRT::strcmp(aCommandName,sSelectWordNextString))
rv = selCont->WordMove(PR_TRUE, PR_TRUE);
else if (aCommandName.Equals(sBeginLineString))
else if (!nsCRT::strcmp(aCommandName,sBeginLineString))
rv = selCont->IntraLineMove(PR_FALSE, PR_FALSE);
else if (aCommandName.Equals(sEndLineString))
else if (!nsCRT::strcmp(aCommandName,sEndLineString))
rv = selCont->IntraLineMove(PR_TRUE, PR_FALSE);
else if (aCommandName.Equals(sSelectBeginLineString))
else if (!nsCRT::strcmp(aCommandName,sSelectBeginLineString))
rv = selCont->IntraLineMove(PR_FALSE, PR_TRUE);
else if (aCommandName.Equals(sSelectEndLineString))
else if (!nsCRT::strcmp(aCommandName,sSelectEndLineString))
rv = selCont->IntraLineMove(PR_TRUE, PR_TRUE);
else if (aCommandName.Equals(sSelectLinePreviousString))
else if (!nsCRT::strcmp(aCommandName,sSelectLinePreviousString))
rv = selCont->LineMove(PR_FALSE, PR_TRUE);
else if (aCommandName.Equals(sSelectLineNextString))
else if (!nsCRT::strcmp(aCommandName,sSelectLineNextString))
rv = selCont->LineMove(PR_TRUE, PR_TRUE);
else if (aCommandName.Equals(sSelectMoveTopString))
else if (!nsCRT::strcmp(aCommandName,sSelectMoveTopString))
rv = selCont->CompleteMove(PR_FALSE, PR_TRUE);
else if (aCommandName.Equals(sSelectMoveBottomString))
else if (!nsCRT::strcmp(aCommandName,sSelectMoveBottomString))
rv = selCont->CompleteMove(PR_TRUE, PR_TRUE);
return rv;
@ -6231,7 +6224,7 @@ nsDOMWindowController::DoCommandWithSelectionController(const nsCString& aComman
}
NS_IMETHODIMP
nsDOMWindowController::OnEvent(const nsAString & aEventName)
nsDOMWindowController::OnEvent(const char * aEventName)
{
return NS_OK;
}

4
dom/src/base/nsGlobalWindow.h
View File

@ -460,8 +460,8 @@ private:
nsresult GetEditInterface( nsIContentViewerEdit** aEditInterface);
nsresult GetSelectionController(nsISelectionController ** aSelCon);
nsresult DoCommandWithEditInterface(const nsCString& aCommandName);
nsresult DoCommandWithSelectionController(const nsCString& aCommandName);
nsresult DoCommandWithEditInterface(const char * aCommandName);
nsresult DoCommandWithSelectionController(const char * aCommandName);
nsIDOMWindowInternal *mWindow;
PRBool mBrowseWithCaret;

181
editor/composer/src/nsComposerCommands.cpp
View File

@ -68,13 +68,13 @@ nsresult GetListItemState(nsIEditor *aEditor, PRBool *aMixed, PRUnichar **_retva
//defines
#define COMMAND_NAME NS_LITERAL_STRING("cmd_name")
#define STATE_ENABLED NS_LITERAL_STRING("state_enabled")
#define STATE_ALL NS_LITERAL_STRING("state_all")
#define STATE_ATTRIBUTE NS_LITERAL_STRING("state_attribute")
#define STATE_BEGIN NS_LITERAL_STRING("state_begin")
#define STATE_END NS_LITERAL_STRING("state_end")
#define STATE_MIXED NS_LITERAL_STRING("state_mixed")
#define COMMAND_NAME "cmd_name"
#define STATE_ENABLED "state_enabled"
#define STATE_ALL "state_all"
#define STATE_ATTRIBUTE "state_attribute"
#define STATE_BEGIN "state_begin"
#define STATE_END "state_end"
#define STATE_MIXED "state_mixed"
@ -178,7 +178,7 @@ nsBaseStateUpdatingCommand::~nsBaseStateUpdatingCommand()
NS_IMPL_ISUPPORTS_INHERITED1(nsBaseStateUpdatingCommand, nsBaseComposerCommand, nsIStateUpdatingControllerCommand);
NS_IMETHODIMP
nsBaseStateUpdatingCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *refCon, PRBool *outCmdEnabled)
nsBaseStateUpdatingCommand::IsCommandEnabled(const char *aCommandName, nsISupports *refCon, PRBool *outCmdEnabled)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
*outCmdEnabled = PR_FALSE;
@ -195,7 +195,7 @@ nsBaseStateUpdatingCommand::IsCommandEnabled(const nsAString & aCommandName, nsI
NS_IMETHODIMP
nsBaseStateUpdatingCommand::DoCommand(const nsAString & aCommandName, nsISupports *refCon)
nsBaseStateUpdatingCommand::DoCommand(const char *aCommandName, nsISupports *refCon)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
if (!editorShell) return NS_ERROR_NOT_INITIALIZED;
@ -207,7 +207,7 @@ nsBaseStateUpdatingCommand::DoCommand(const nsAString & aCommandName, nsISupport
}
NS_IMETHODIMP
nsBaseStateUpdatingCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *refCon)
nsBaseStateUpdatingCommand::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *refCon)
{
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
if (!editor)
@ -220,7 +220,7 @@ nsBaseStateUpdatingCommand::DoCommandParams(nsICommandParams *aParams, nsISuppor
}
NS_IMETHODIMP
nsBaseStateUpdatingCommand::GetCommandState(nsICommandParams *aParams, nsISupports *refCon)
nsBaseStateUpdatingCommand::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *refCon)
{
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
nsresult rv = NS_OK;
@ -232,7 +232,7 @@ nsBaseStateUpdatingCommand::GetCommandState(nsICommandParams *aParams, nsISuppor
}
NS_IMETHODIMP
nsBaseStateUpdatingCommand::UpdateCommandState(const nsAString & aCommandName, nsISupports *refCon)
nsBaseStateUpdatingCommand::UpdateCommandState(const char * aCommandName, nsISupports *refCon)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
nsresult rv = NS_OK;
@ -245,7 +245,9 @@ nsBaseStateUpdatingCommand::UpdateCommandState(const nsAString & aCommandName, n
if (!mGotState || (stateIsSet != mState))
{
// poke the UI
SetCommandNodeState(aCommandName, editorShell, NS_ConvertASCIItoUCS2(stateIsSet ? "true" : "false"));
nsAutoString commandName;
commandName.AssignWithConversion(aCommandName);
SetCommandNodeState(commandName, editorShell, NS_ConvertASCIItoUCS2(stateIsSet ? "true" : "false"));
mGotState = PR_TRUE;
mState = stateIsSet;
@ -296,7 +298,7 @@ nsCloseCommand::DoCommand(const nsAString & aCommandName, const nsAString & aCom
#endif
NS_IMETHODIMP
nsPasteQuotationCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *refCon, PRBool *outCmdEnabled)
nsPasteQuotationCommand::IsCommandEnabled(const char * aCommandName, nsISupports *refCon, PRBool *outCmdEnabled)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
*outCmdEnabled = PR_FALSE;
@ -313,7 +315,7 @@ nsPasteQuotationCommand::IsCommandEnabled(const nsAString & aCommandName, nsISup
NS_IMETHODIMP
nsPasteQuotationCommand::DoCommand(const nsAString & aCommandName, nsISupports *refCon)
nsPasteQuotationCommand::DoCommand(const char *aCommandName, nsISupports *refCon)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
@ -327,7 +329,7 @@ nsPasteQuotationCommand::DoCommand(const nsAString & aCommandName, nsISupports *
}
NS_IMETHODIMP
nsPasteQuotationCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *refCon)
nsPasteQuotationCommand::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *refCon)
{
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
@ -341,7 +343,7 @@ nsPasteQuotationCommand::DoCommandParams(nsICommandParams *aParams, nsISupports
}
NS_IMETHODIMP
nsPasteQuotationCommand::GetCommandState(nsICommandParams *aParams, nsISupports *refCon)
nsPasteQuotationCommand::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *refCon)
{
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
PRBool enabled = PR_FALSE;
@ -720,7 +722,7 @@ nsListItemCommand::ToggleState(nsIEditor *aEditor, const char* aTagName)
#endif
NS_IMETHODIMP
nsRemoveListCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *refCon, PRBool *outCmdEnabled)
nsRemoveListCommand::IsCommandEnabled(const char * aCommandName, nsISupports *refCon, PRBool *outCmdEnabled)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
*outCmdEnabled = PR_FALSE;
@ -745,7 +747,7 @@ nsRemoveListCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupport
NS_IMETHODIMP
nsRemoveListCommand::DoCommand(const nsAString & aCommandName, nsISupports *refCon)
nsRemoveListCommand::DoCommand(const char *aCommandName, nsISupports *refCon)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
@ -758,7 +760,7 @@ nsRemoveListCommand::DoCommand(const nsAString & aCommandName, nsISupports *refC
}
NS_IMETHODIMP
nsRemoveListCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *refCon)
nsRemoveListCommand::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *refCon)
{
nsCOMPtr<nsIHTMLEditor> editor = do_QueryInterface(refCon);
@ -774,12 +776,10 @@ nsRemoveListCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *ref
}
NS_IMETHODIMP
nsRemoveListCommand::GetCommandState(nsICommandParams *aParams, nsISupports *refCon)
nsRemoveListCommand::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *refCon)
{
nsString tString;
PRBool outCmdEnabled = PR_FALSE;
aParams->GetStringValue(COMMAND_NAME,tString);
IsCommandEnabled(tString, refCon, &outCmdEnabled);
IsCommandEnabled(aCommandName, refCon, &outCmdEnabled);
return aParams->SetBooleanValue(STATE_ENABLED,outCmdEnabled);
}
@ -788,7 +788,7 @@ nsRemoveListCommand::GetCommandState(nsICommandParams *aParams, nsISupports *ref
#endif
NS_IMETHODIMP
nsIndentCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *refCon, PRBool *outCmdEnabled)
nsIndentCommand::IsCommandEnabled(const char * aCommandName, nsISupports *refCon, PRBool *outCmdEnabled)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
*outCmdEnabled = PR_FALSE;
@ -805,7 +805,7 @@ nsIndentCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *r
NS_IMETHODIMP
nsIndentCommand::DoCommand(const nsAString & aCommandName, nsISupports *refCon)
nsIndentCommand::DoCommand(const char *aCommandName, nsISupports *refCon)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
@ -820,7 +820,7 @@ nsIndentCommand::DoCommand(const nsAString & aCommandName, nsISupports *refCon)
}
NS_IMETHODIMP
nsIndentCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *refCon)
nsIndentCommand::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *refCon)
{
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
@ -838,12 +838,10 @@ nsIndentCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *refCon)
}
NS_IMETHODIMP
nsIndentCommand::GetCommandState(nsICommandParams *aParams, nsISupports *refCon)
nsIndentCommand::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *refCon)
{
nsString tString;
PRBool outCmdEnabled = PR_FALSE;
aParams->GetStringValue(COMMAND_NAME,tString);
IsCommandEnabled(tString, refCon, &outCmdEnabled);
IsCommandEnabled(aCommandName, refCon, &outCmdEnabled);
return aParams->SetBooleanValue(STATE_ENABLED,outCmdEnabled);
}
@ -851,7 +849,7 @@ nsIndentCommand::GetCommandState(nsICommandParams *aParams, nsISupports *refCon)
//OUTDENT
NS_IMETHODIMP
nsOutdentCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *refCon, PRBool *outCmdEnabled)
nsOutdentCommand::IsCommandEnabled(const char * aCommandName, nsISupports *refCon, PRBool *outCmdEnabled)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
*outCmdEnabled = PR_FALSE;
@ -874,7 +872,7 @@ nsOutdentCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *
NS_IMETHODIMP
nsOutdentCommand::DoCommand(const nsAString & aCommandName, nsISupports *refCon)
nsOutdentCommand::DoCommand(const char *aCommandName, nsISupports *refCon)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
@ -889,7 +887,7 @@ nsOutdentCommand::DoCommand(const nsAString & aCommandName, nsISupports *refCon)
}
NS_IMETHODIMP
nsOutdentCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *refCon)
nsOutdentCommand::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *refCon)
{
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
@ -907,12 +905,10 @@ nsOutdentCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *refCon
}
NS_IMETHODIMP
nsOutdentCommand::GetCommandState(nsICommandParams *aParams, nsISupports *refCon)
nsOutdentCommand::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *refCon)
{
nsString tString;
PRBool outCmdEnabled = PR_FALSE;
aParams->GetStringValue(COMMAND_NAME,tString);
IsCommandEnabled(tString, refCon, &outCmdEnabled);
IsCommandEnabled(aCommandName, refCon, &outCmdEnabled);
return aParams->SetBooleanValue(STATE_ENABLED,outCmdEnabled);
}
@ -934,7 +930,7 @@ nsMultiStateCommand::~nsMultiStateCommand()
NS_IMPL_ISUPPORTS_INHERITED1(nsMultiStateCommand, nsBaseComposerCommand, nsIStateUpdatingControllerCommand);
NS_IMETHODIMP
nsMultiStateCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *refCon, PRBool *outCmdEnabled)
nsMultiStateCommand::IsCommandEnabled(const char * aCommandName, nsISupports *refCon, PRBool *outCmdEnabled)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
*outCmdEnabled = PR_FALSE;
@ -960,7 +956,7 @@ nsMultiStateCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupport
NS_IMETHODIMP
nsMultiStateCommand::DoCommand(const nsAString & aCommandName, nsISupports *refCon)
nsMultiStateCommand::DoCommand(const char *aCommandName, nsISupports *refCon)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
@ -970,7 +966,9 @@ nsMultiStateCommand::DoCommand(const nsAString & aCommandName, nsISupports *refC
// we have to grab the state attribute on our command node to find out
// what format to set the paragraph to
nsAutoString stateAttribute;
rv = GetCommandNodeState(aCommandName, editorShell, stateAttribute);
nsAutoString commandName;
commandName.AssignWithConversion(aCommandName);
rv = GetCommandNodeState(commandName, editorShell, stateAttribute);
if (NS_FAILED(rv)) return rv;
rv = SetState(editorShell, stateAttribute);
@ -980,7 +978,7 @@ nsMultiStateCommand::DoCommand(const nsAString & aCommandName, nsISupports *refC
}
NS_IMETHODIMP
nsMultiStateCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *refCon)
nsMultiStateCommand::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *refCon)
{
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
@ -989,17 +987,20 @@ nsMultiStateCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *ref
{
// we have to grab the state attribute on our command node to find out
// what format to set the paragraph to
nsAutoString tValue;
char *tValue;
nsresult rv;
aParams->GetStringValue(STATE_ATTRIBUTE,tValue);
rv = SetState(editor, tValue);
aParams->GetCStringValue(STATE_ATTRIBUTE,&tValue);
nsAutoString tString;
tString.AssignWithConversion(tValue);
nsMemory::Free(tValue);
rv = SetState(editor, tString);
}
return rv;
}
NS_IMETHODIMP
nsMultiStateCommand::UpdateCommandState(const nsAString & aCommandName, nsISupports *refCon)
nsMultiStateCommand::UpdateCommandState(const char * aCommandName, nsISupports *refCon)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
nsresult rv = NS_OK;
@ -1017,7 +1018,9 @@ nsMultiStateCommand::UpdateCommandState(const nsAString & aCommandName, nsISuppo
if (!mGotState || (curFormat != mStateString))
{
// poke the UI
SetCommandNodeState(aCommandName, editorShell, curFormat);
nsAutoString commandName;
commandName.AssignWithConversion(aCommandName);
SetCommandNodeState(commandName, editorShell, curFormat);
mGotState = PR_TRUE;
mStateString = curFormat;
@ -1027,7 +1030,7 @@ nsMultiStateCommand::UpdateCommandState(const nsAString & aCommandName, nsISuppo
}
NS_IMETHODIMP
nsMultiStateCommand::GetCommandState(nsICommandParams *aParams, nsISupports *refCon)
nsMultiStateCommand::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *refCon)
{
nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
nsresult rv = NS_OK;
@ -1067,12 +1070,14 @@ nsParagraphStateCommand::GetCurrentState(nsIEditor *aEditor, nsICommandParams *a
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
if (!htmlEditor) return NS_ERROR_FAILURE;
PRBool outMixed;
nsString outStateString;
nsAutoString outStateString;
nsresult rv = htmlEditor->GetParagraphState(&outMixed, outStateString);
if (NS_SUCCEEDED(rv))
{
nsCAutoString tOutStateString;
tOutStateString.AssignWithConversion(outStateString);
aParams->SetBooleanValue(STATE_MIXED,outMixed);
aParams->SetStringValue(STATE_ATTRIBUTE, outStateString);
aParams->SetCStringValue(STATE_ATTRIBUTE, tOutStateString.get());
}
return rv;
}
@ -1131,13 +1136,15 @@ nsFontFaceStateCommand::GetCurrentState(nsIEditor *aEditor, nsICommandParams *aP
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
if (!htmlEditor) return NS_ERROR_FAILURE;
nsString outStateString;
nsAutoString outStateString;
PRBool outMixed;
nsresult rv = htmlEditor->GetFontFaceState(&outMixed, outStateString);
if (NS_SUCCEEDED(rv))
{
nsCAutoString tOutStateString;
tOutStateString.AssignWithConversion(outStateString);
aParams->SetBooleanValue(STATE_MIXED,outMixed);
aParams->SetStringValue(STATE_ATTRIBUTE,outStateString);
aParams->SetCStringValue(STATE_ATTRIBUTE, tOutStateString.get());
}
return rv;
}
@ -1247,12 +1254,14 @@ nsFontColorStateCommand::GetCurrentState(nsIEditor *aEditor, nsICommandParams *a
if (!htmlEditor) return NS_ERROR_FAILURE;
PRBool outMixed;
nsString outStateString;
nsAutoString outStateString;
nsresult rv = htmlEditor->GetFontColorState(&outMixed, outStateString);
if (NS_SUCCEEDED(rv))
{
nsCAutoString tOutStateString;
tOutStateString.AssignWithConversion(outStateString);
aParams->SetBooleanValue(STATE_MIXED,outMixed);
aParams->SetStringValue(STATE_ATTRIBUTE,outStateString);
aParams->SetCStringValue(STATE_ATTRIBUTE, tOutStateString.get());
}
return rv;
}
@ -1334,12 +1343,14 @@ nsHighlightColorStateCommand::GetCurrentState(nsIEditor *aEditor, nsICommandPara
if (!htmlEditor) return NS_ERROR_FAILURE;
PRBool outMixed;
nsString outStateString;
nsAutoString outStateString;
nsresult rv = htmlEditor->GetHighlightColorState(&outMixed, outStateString);
if (NS_SUCCEEDED(rv))
{
nsCAutoString tOutStateString;
tOutStateString.AssignWithConversion(outStateString);
aParams->SetBooleanValue(STATE_MIXED,outMixed);
aParams->SetStringValue(STATE_ATTRIBUTE,outStateString);
aParams->SetCStringValue(STATE_ATTRIBUTE, tOutStateString.get());
}
return rv;
}
@ -1389,7 +1400,7 @@ nsHighlightColorStateCommand::SetState(nsIEditorShell *aEditorShell, nsString& n
}
NS_IMETHODIMP
nsHighlightColorStateCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *refCon, PRBool *outCmdEnabled)
nsHighlightColorStateCommand::IsCommandEnabled(const char * aCommandName, nsISupports *refCon, PRBool *outCmdEnabled)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
*outCmdEnabled = PR_FALSE;
@ -1447,12 +1458,14 @@ nsBackgroundColorStateCommand::GetCurrentState(nsIEditor *aEditor, nsICommandPar
if (!htmlEditor) return NS_ERROR_FAILURE;
PRBool outMixed;
nsString outStateString;
nsAutoString outStateString;
nsresult rv = htmlEditor->GetBackgroundColorState(&outMixed, outStateString);
if (NS_SUCCEEDED(rv))
{
aParams->SetBooleanValue(STATE_MIXED, outMixed);
aParams->SetStringValue(STATE_ATTRIBUTE, outStateString);
nsCAutoString tOutStateString;
tOutStateString.AssignWithConversion(outStateString);
aParams->SetBooleanValue(STATE_MIXED,outMixed);
aParams->SetCStringValue(STATE_ATTRIBUTE, tOutStateString.get());
}
return rv;
}
@ -1536,7 +1549,7 @@ nsAlignCommand::GetCurrentState(nsIEditor *aEditor, nsICommandParams *aParams)
nsIHTMLEditor::EAlignment firstAlign;
PRBool outMixed;
nsString outStateString;
nsAutoString outStateString;
nsresult rv = htmlEditor->GetAlignment(&outMixed, &firstAlign);
if (NS_FAILED(rv))
@ -1561,8 +1574,10 @@ nsAlignCommand::GetCurrentState(nsIEditor *aEditor, nsICommandParams *aParams)
outStateString.Assign(NS_LITERAL_STRING("justify"));
break;
}
aParams->SetBooleanValue(STATE_MIXED, outMixed);
aParams->SetStringValue(STATE_ATTRIBUTE, outStateString);
nsCAutoString tOutStateString;
tOutStateString.AssignWithConversion(outStateString);
aParams->SetBooleanValue(STATE_MIXED,outMixed);
aParams->SetCStringValue(STATE_ATTRIBUTE, tOutStateString.get());
return NS_OK;
}
@ -1596,7 +1611,7 @@ nsAlignCommand::SetState(nsIEditorShell *aEditorShell, nsString& newState)
#endif
NS_IMETHODIMP
nsRemoveStylesCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *refCon, PRBool *outCmdEnabled)
nsRemoveStylesCommand::IsCommandEnabled(const char * aCommandName, nsISupports *refCon, PRBool *outCmdEnabled)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
nsCOMPtr<nsIEditor>editor;
@ -1620,7 +1635,7 @@ nsRemoveStylesCommand::IsCommandEnabled(const nsAString & aCommandName, nsISuppo
NS_IMETHODIMP
nsRemoveStylesCommand::DoCommand(const nsAString & aCommandName, nsISupports *refCon)
nsRemoveStylesCommand::DoCommand(const char *aCommandName, nsISupports *refCon)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
@ -1641,20 +1656,16 @@ nsRemoveStylesCommand::DoCommand(const nsAString & aCommandName, nsISupports *re
}
NS_IMETHODIMP
nsRemoveStylesCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *refCon)
nsRemoveStylesCommand::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *refCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
return DoCommand(tString, refCon);
return DoCommand(aCommandName, refCon);
}
NS_IMETHODIMP
nsRemoveStylesCommand::GetCommandState(nsICommandParams *aParams, nsISupports *refCon)
nsRemoveStylesCommand::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *refCon)
{
nsString tString;
PRBool outCmdEnabled = PR_FALSE;
aParams->GetStringValue(COMMAND_NAME,tString);
IsCommandEnabled(tString, refCon, &outCmdEnabled);
IsCommandEnabled(aCommandName, refCon, &outCmdEnabled);
return aParams->SetBooleanValue(STATE_ENABLED,outCmdEnabled);
}
@ -1663,7 +1674,7 @@ nsRemoveStylesCommand::GetCommandState(nsICommandParams *aParams, nsISupports *r
#endif
NS_IMETHODIMP
nsIncreaseFontSizeCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *refCon, PRBool *outCmdEnabled)
nsIncreaseFontSizeCommand::IsCommandEnabled(const char * aCommandName, nsISupports *refCon, PRBool *outCmdEnabled)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
nsCOMPtr<nsIEditor>editor;
@ -1685,7 +1696,7 @@ nsIncreaseFontSizeCommand::IsCommandEnabled(const nsAString & aCommandName, nsIS
NS_IMETHODIMP
nsIncreaseFontSizeCommand::DoCommand(const nsAString & aCommandName, nsISupports *refCon)
nsIncreaseFontSizeCommand::DoCommand(const char *aCommandName, nsISupports *refCon)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
@ -1699,7 +1710,7 @@ nsIncreaseFontSizeCommand::DoCommand(const nsAString & aCommandName, nsISupports
}
NS_IMETHODIMP
nsIncreaseFontSizeCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *refCon)
nsIncreaseFontSizeCommand::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *refCon)
{
nsCOMPtr<nsIHTMLEditor> editor = do_QueryInterface(refCon);
@ -1713,12 +1724,10 @@ nsIncreaseFontSizeCommand::DoCommandParams(nsICommandParams *aParams, nsISupport
}
NS_IMETHODIMP
nsIncreaseFontSizeCommand::GetCommandState(nsICommandParams *aParams, nsISupports *refCon)
nsIncreaseFontSizeCommand::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *refCon)
{
nsString tString;
PRBool outCmdEnabled = PR_FALSE;
aParams->GetStringValue(COMMAND_NAME,tString);
IsCommandEnabled(tString, refCon, &outCmdEnabled);
IsCommandEnabled(aCommandName, refCon, &outCmdEnabled);
return aParams->SetBooleanValue(STATE_ENABLED,outCmdEnabled);
}
@ -1727,7 +1736,7 @@ nsIncreaseFontSizeCommand::GetCommandState(nsICommandParams *aParams, nsISupport
#endif
NS_IMETHODIMP
nsDecreaseFontSizeCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *refCon, PRBool *outCmdEnabled)
nsDecreaseFontSizeCommand::IsCommandEnabled(const char * aCommandName, nsISupports *refCon, PRBool *outCmdEnabled)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
nsCOMPtr<nsIEditor>editor;
@ -1750,7 +1759,7 @@ nsDecreaseFontSizeCommand::IsCommandEnabled(const nsAString & aCommandName, nsIS
NS_IMETHODIMP
nsDecreaseFontSizeCommand::DoCommand(const nsAString & aCommandName, nsISupports *refCon)
nsDecreaseFontSizeCommand::DoCommand(const char *aCommandName, nsISupports *refCon)
{
nsCOMPtr<nsIEditorShell> editorShell = do_QueryInterface(refCon);
@ -1764,7 +1773,7 @@ nsDecreaseFontSizeCommand::DoCommand(const nsAString & aCommandName, nsISupports
}
NS_IMETHODIMP
nsDecreaseFontSizeCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *refCon)
nsDecreaseFontSizeCommand::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *refCon)
{
nsCOMPtr<nsIHTMLEditor> editor = do_QueryInterface(refCon);
@ -1778,12 +1787,10 @@ nsDecreaseFontSizeCommand::DoCommandParams(nsICommandParams *aParams, nsISupport
}
NS_IMETHODIMP
nsDecreaseFontSizeCommand::GetCommandState(nsICommandParams *aParams, nsISupports *refCon)
nsDecreaseFontSizeCommand::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *refCon)
{
nsString tString;
PRBool outCmdEnabled = PR_FALSE;
aParams->GetStringValue(COMMAND_NAME,tString);
IsCommandEnabled(tString, refCon, &outCmdEnabled);
IsCommandEnabled(aCommandName, refCon, &outCmdEnabled);
return aParams->SetBooleanValue(STATE_ENABLED,outCmdEnabled);
}

6
editor/composer/src/nsComposerCommands.h
View File

@ -64,8 +64,8 @@ public:
NS_DECL_ISUPPORTS
// nsIControllerCommand. Declared longhand so we can make them pure virtual
NS_IMETHOD IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCommandRefCon, PRBool *_retval) = 0;
NS_IMETHOD DoCommand(const nsAString & aCommandName, nsISupports *aCommandRefCon) = 0;
NS_IMETHOD IsCommandEnabled(const char * aCommandName, nsISupports *aCommandRefCon, PRBool *_retval) = 0;
NS_IMETHOD DoCommand(const char * aCommandName, nsISupports *aCommandRefCon) = 0;
protected:
@ -256,7 +256,7 @@ protected:
virtual nsresult GetCurrentState(nsIEditorShell *aEditorShell, nsString& outStateString, PRBool& outMixed);
virtual nsresult SetState(nsIEditorShell *aEditorShell, nsString& newState);
NS_IMETHOD IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCommandRefCon, PRBool *_retval);
NS_IMETHOD IsCommandEnabled(const char *aCommandName, nsISupports *aCommandRefCon, PRBool *_retval);
virtual nsresult GetCurrentState(nsIEditor *aEditor, nsICommandParams* aParams);
virtual nsresult SetState(nsIEditor *aEditor, nsString& newState);

6
editor/composer/src/nsComposerCommandsUpdater.cpp
View File

@ -271,9 +271,9 @@ nsComposerCommandsUpdater::CallUpdateCommands(const nsAString& aCommand)
nsCOMPtr<nsPICommandUpdater> commandUpdater = do_QueryInterface(commandManager);
if (!commandUpdater) return NS_ERROR_FAILURE;
commandUpdater->CommandStatusChanged(NS_LITERAL_STRING("cmd_bold"));
commandUpdater->CommandStatusChanged(NS_LITERAL_STRING("cmd_italic"));
commandUpdater->CommandStatusChanged(NS_LITERAL_STRING("cmd_underline"));
commandUpdater->CommandStatusChanged("cmd_bold");
commandUpdater->CommandStatusChanged("cmd_italic");
commandUpdater->CommandStatusChanged("cmd_underline");
return NS_OK;
}

27
editor/composer/src/nsComposerController.cpp
View File

@ -128,7 +128,7 @@ nsComposerController::GetInterface(const nsIID & aIID, void * *result)
_cmdClass* theCmd; \
NS_NEWXPCOM(theCmd, _cmdClass); \
if (!theCmd) return NS_ERROR_OUT_OF_MEMORY; \
rv = inCommandManager->RegisterCommand(NS_LITERAL_STRING(_cmdName), \
rv = inCommandManager->RegisterCommand(_cmdName, \
NS_STATIC_CAST(nsIControllerCommand *, theCmd)); \
}
@ -137,15 +137,15 @@ nsComposerController::GetInterface(const nsIID & aIID, void * *result)
_cmdClass* theCmd; \
NS_NEWXPCOM(theCmd, _cmdClass); \
if (!theCmd) return NS_ERROR_OUT_OF_MEMORY; \
rv = inCommandManager->RegisterCommand(NS_LITERAL_STRING(_cmdName), \
rv = inCommandManager->RegisterCommand(_cmdName, \
NS_STATIC_CAST(nsIControllerCommand *, theCmd));
#define NS_REGISTER_NEXT_COMMAND(_cmdClass, _cmdName) \
rv = inCommandManager->RegisterCommand(NS_LITERAL_STRING(_cmdName), \
rv = inCommandManager->RegisterCommand(_cmdName, \
NS_STATIC_CAST(nsIControllerCommand *, theCmd));
#define NS_REGISTER_LAST_COMMAND(_cmdClass, _cmdName) \
rv = inCommandManager->RegisterCommand(NS_LITERAL_STRING(_cmdName), \
rv = inCommandManager->RegisterCommand(_cmdName, \
NS_STATIC_CAST(nsIControllerCommand *, theCmd)); \
}
@ -153,7 +153,7 @@ nsComposerController::GetInterface(const nsIID & aIID, void * *result)
{ \
_cmdClass* theCmd = new _cmdClass(_styleTag); \
if (!theCmd) return NS_ERROR_OUT_OF_MEMORY; \
rv = inCommandManager->RegisterCommand(NS_LITERAL_STRING(_cmdName), \
rv = inCommandManager->RegisterCommand(_cmdName, \
NS_STATIC_CAST(nsIControllerCommand *, theCmd)); \
}
@ -210,6 +210,7 @@ nsresult nsComposerController::RegisterComposerCommands(nsIControllerCommandMana
NS_REGISTER_ONE_COMMAND(nsIncreaseFontSizeCommand, "cmd_increaseFont");
NS_REGISTER_ONE_COMMAND(nsDecreaseFontSizeCommand, "cmd_decreaseFont");
return NS_OK;
}
@ -218,7 +219,7 @@ nsresult nsComposerController::RegisterComposerCommands(nsIControllerCommandMana
* ======================================================================= */
NS_IMETHODIMP
nsComposerController::IsCommandEnabled(const nsAString & aCommand,
nsComposerController::IsCommandEnabled(const char * aCommand,
PRBool *aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
@ -226,7 +227,7 @@ nsComposerController::IsCommandEnabled(const nsAString & aCommand,
}
NS_IMETHODIMP
nsComposerController::SupportsCommand(const nsAString & aCommand,
nsComposerController::SupportsCommand(const char * aCommand,
PRBool *aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
@ -234,13 +235,13 @@ nsComposerController::SupportsCommand(const nsAString & aCommand,
}
NS_IMETHODIMP
nsComposerController::DoCommand(const nsAString & aCommand)
nsComposerController::DoCommand(const char *aCommand)
{
return mCommandManager->DoCommand(aCommand, mCommandRefCon);
}
NS_IMETHODIMP
nsComposerController::OnEvent(const nsAString & aEventName)
nsComposerController::OnEvent(const char * aEventName)
{
return NS_OK;
}
@ -282,17 +283,17 @@ state_all : true,false
state_mixed : true,false
*/
/* void getCommandState (in DOMString aCommandName, inout nsICommandParams aCommandParams); */
NS_IMETHODIMP nsComposerController::GetCommandState(nsICommandParams *aCommandParams)
NS_IMETHODIMP nsComposerController::GetCommandState(const char *aCommand, nsICommandParams *aCommandParams)
{
if (!mCommandRefCon || !mCommandManager)
return NS_ERROR_NOT_INITIALIZED;
return mCommandManager->GetCommandState(aCommandParams,mCommandRefCon);
return mCommandManager->GetCommandState(aCommand,aCommandParams,mCommandRefCon);
}
/* void doCommand (in DOMString aCommandName, in nsICommandParams aCommandParams); */
NS_IMETHODIMP nsComposerController::DoCommand(nsICommandParams *aCommandParams)
NS_IMETHODIMP nsComposerController::DoCommand(const char *aCommand, nsICommandParams *aCommandParams)
{
if (!mCommandRefCon || !mCommandManager)
return NS_ERROR_NOT_INITIALIZED;
return mCommandManager->DoCommandParams(aCommandParams,mCommandRefCon);
return mCommandManager->DoCommandParams(aCommand, aCommandParams,mCommandRefCon);
}

6
editor/composer/src/nsEditorShell.cpp
View File

@ -1429,7 +1429,7 @@ nsEditorShell::FinishHTMLSource(void)
if (mHTMLSourceMode)
{
// Call the JS command to convert and switch to previous edit mode
return DoControllerCommand(NS_LITERAL_STRING("cmd_FinishHTMLSource"));
return DoControllerCommand("cmd_FinishHTMLSource");
}
return NS_OK;
}
@ -1721,7 +1721,7 @@ nsEditorShell::UpdateWindowTitleAndRecentMenu(PRBool aSaveToPrefs)
// For now, don't update the menu at all if aSaveToPrefs is false
if (aSaveToPrefs)
{
res = DoControllerCommand(NS_LITERAL_STRING("cmd_buildRecentPagesMenu"));
res = DoControllerCommand("cmd_buildRecentPagesMenu");
}
return res;
@ -4680,7 +4680,7 @@ nsEditorShell::CheckPrefAndNormalizeTable()
nsresult
nsEditorShell::DoControllerCommand(const nsAString& aCommand)
nsEditorShell::DoControllerCommand(const char *aCommand)
{
// Get the list of controllers...
nsCOMPtr<nsIControllers> controllers;

2
editor/composer/src/nsEditorShell.h
View File

@ -152,7 +152,7 @@ class nsEditorShell : public nsIEditorShell,
nsresult RemoveOneProperty(const nsString& aProp, const nsString& aAttr);
nsresult DoFind(PRBool aFindNext);
// To allow executing JavaScript commands from C++ via nsIEditorController interface
nsresult DoControllerCommand(const nsAString& aCommand);
nsresult DoControllerCommand(const char* aCommand);
void Alert(const nsString& aTitle, const nsString& aMsg);
// Bring up a Yes/No dialog WE REALLY NEED A Yes/No/Cancel dialog and would like to set our own caption as well!

2
editor/idl/nsIEditorController.idl
View File

@ -59,7 +59,7 @@ interface nsIEditorController : nsISupports
/** Execute the command identified by the ID string
* param: commandName ID string of the command
*/
void DoCommand( in DOMString commandName );
void DoCommand( in string commandName );
/* Should we expose nsEditorController::IsCommandEnabled() as well? */
};

262
editor/libeditor/base/nsEditorCommands.cpp
View File

@ -49,8 +49,8 @@
#include "nsEditorCommands.h"
#define COMMAND_NAME NS_LITERAL_STRING("cmd_name")
#define STATE_ENABLED NS_LITERAL_STRING("state_enabled")
#define COMMAND_NAME "cmd_name"
#define STATE_ENABLED "state_enabled"
nsBaseEditorCommand::nsBaseEditorCommand()
@ -66,7 +66,7 @@ NS_IMPL_ISUPPORTS1(nsBaseEditorCommand, nsIControllerCommand)
NS_IMETHODIMP
nsUndoCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCommandRefCon, PRBool *outCmdEnabled)
nsUndoCommand::IsCommandEnabled(const char * aCommandName, nsISupports *aCommandRefCon, PRBool *outCmdEnabled)
{
nsCOMPtr<nsIEditor> aEditor = do_QueryInterface(aCommandRefCon);
*outCmdEnabled = PR_FALSE;
@ -80,7 +80,7 @@ nsUndoCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCo
NS_IMETHODIMP
nsUndoCommand::DoCommand(const nsAString & aCommandName, nsISupports *aCommandRefCon)
nsUndoCommand::DoCommand(const char *aCommandName, nsISupports *aCommandRefCon)
{
nsCOMPtr<nsIEditor> aEditor = do_QueryInterface(aCommandRefCon);
if (aEditor)
@ -90,25 +90,21 @@ nsUndoCommand::DoCommand(const nsAString & aCommandName, nsISupports *aCommandRe
}
NS_IMETHODIMP
nsUndoCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsUndoCommand::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
return DoCommand(tString,aCommandRefCon);
return DoCommand(aCommandName,aCommandRefCon);
}
NS_IMETHODIMP
nsUndoCommand::GetCommandState(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsUndoCommand::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
PRBool canUndo;
IsCommandEnabled(tString, aCommandRefCon, &canUndo);
IsCommandEnabled(aCommandName, aCommandRefCon, &canUndo);
return aParams->SetBooleanValue(STATE_ENABLED,canUndo);
}
NS_IMETHODIMP
nsRedoCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCommandRefCon, PRBool *outCmdEnabled)
nsRedoCommand::IsCommandEnabled(const char * aCommandName, nsISupports *aCommandRefCon, PRBool *outCmdEnabled)
{
nsCOMPtr<nsIEditor> aEditor = do_QueryInterface(aCommandRefCon);
*outCmdEnabled = PR_FALSE;
@ -122,7 +118,7 @@ nsRedoCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCo
NS_IMETHODIMP
nsRedoCommand::DoCommand(const nsAString & aCommandName, nsISupports *aCommandRefCon)
nsRedoCommand::DoCommand(const char *aCommandName, nsISupports *aCommandRefCon)
{
nsCOMPtr<nsIEditor> aEditor = do_QueryInterface(aCommandRefCon);
if (aEditor)
@ -132,25 +128,21 @@ nsRedoCommand::DoCommand(const nsAString & aCommandName, nsISupports *aCommandRe
}
NS_IMETHODIMP
nsRedoCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsRedoCommand::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
return DoCommand(tString,aCommandRefCon);
return DoCommand(aCommandName, aCommandRefCon);
}
NS_IMETHODIMP
nsRedoCommand::GetCommandState(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsRedoCommand::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
PRBool canUndo;
IsCommandEnabled(tString, aCommandRefCon, &canUndo);
IsCommandEnabled(aCommandName, aCommandRefCon, &canUndo);
return aParams->SetBooleanValue(STATE_ENABLED,canUndo);
}
NS_IMETHODIMP
nsCutCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCommandRefCon, PRBool *outCmdEnabled)
nsCutCommand::IsCommandEnabled(const char * aCommandName, nsISupports *aCommandRefCon, PRBool *outCmdEnabled)
{
nsCOMPtr<nsIEditor> aEditor = do_QueryInterface(aCommandRefCon);
*outCmdEnabled = PR_FALSE;
@ -162,7 +154,7 @@ nsCutCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCom
NS_IMETHODIMP
nsCutCommand::DoCommand(const nsAString & aCommandName, nsISupports *aCommandRefCon)
nsCutCommand::DoCommand(const char *aCommandName, nsISupports *aCommandRefCon)
{
nsCOMPtr<nsIEditor> aEditor = do_QueryInterface(aCommandRefCon);
if (aEditor)
@ -172,26 +164,22 @@ nsCutCommand::DoCommand(const nsAString & aCommandName, nsISupports *aCommandRef
}
NS_IMETHODIMP
nsCutCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsCutCommand::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
return DoCommand(tString,aCommandRefCon);
return DoCommand(aCommandName, aCommandRefCon);
}
NS_IMETHODIMP
nsCutCommand::GetCommandState(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsCutCommand::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
PRBool canUndo;
IsCommandEnabled(tString, aCommandRefCon, &canUndo);
IsCommandEnabled(aCommandName, aCommandRefCon, &canUndo);
return aParams->SetBooleanValue(STATE_ENABLED,canUndo);
}
NS_IMETHODIMP
nsCutOrDeleteCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCommandRefCon, PRBool *outCmdEnabled)
nsCutOrDeleteCommand::IsCommandEnabled(const char * aCommandName, nsISupports *aCommandRefCon, PRBool *outCmdEnabled)
{
nsCOMPtr<nsIEditor> editor = do_QueryInterface(aCommandRefCon);
*outCmdEnabled = (editor != nsnull);
@ -200,7 +188,7 @@ nsCutOrDeleteCommand::IsCommandEnabled(const nsAString & aCommandName, nsISuppor
NS_IMETHODIMP
nsCutOrDeleteCommand::DoCommand(const nsAString & aCommandName, nsISupports *aCommandRefCon)
nsCutOrDeleteCommand::DoCommand(const char *aCommandName, nsISupports *aCommandRefCon)
{
nsCOMPtr<nsIEditor> editor = do_QueryInterface(aCommandRefCon);
if (editor)
@ -221,25 +209,21 @@ nsCutOrDeleteCommand::DoCommand(const nsAString & aCommandName, nsISupports *aCo
}
NS_IMETHODIMP
nsCutOrDeleteCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsCutOrDeleteCommand::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
return DoCommand(tString,aCommandRefCon);
return DoCommand(aCommandName, aCommandRefCon);
}
NS_IMETHODIMP
nsCutOrDeleteCommand::GetCommandState(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsCutOrDeleteCommand::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
PRBool canUndo;
IsCommandEnabled(tString, aCommandRefCon, &canUndo);
IsCommandEnabled(aCommandName, aCommandRefCon, &canUndo);
return aParams->SetBooleanValue(STATE_ENABLED,canUndo);
}
NS_IMETHODIMP
nsCopyCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCommandRefCon, PRBool *outCmdEnabled)
nsCopyCommand::IsCommandEnabled(const char * aCommandName, nsISupports *aCommandRefCon, PRBool *outCmdEnabled)
{
nsCOMPtr<nsIEditor> aEditor = do_QueryInterface(aCommandRefCon);
*outCmdEnabled = PR_FALSE;
@ -251,7 +235,7 @@ nsCopyCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCo
NS_IMETHODIMP
nsCopyCommand::DoCommand(const nsAString & aCommandName, nsISupports *aCommandRefCon)
nsCopyCommand::DoCommand(const char *aCommandName, nsISupports *aCommandRefCon)
{
nsCOMPtr<nsIEditor> aEditor = do_QueryInterface(aCommandRefCon);
if (aEditor)
@ -261,25 +245,21 @@ nsCopyCommand::DoCommand(const nsAString & aCommandName, nsISupports *aCommandRe
}
NS_IMETHODIMP
nsCopyCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsCopyCommand::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
return DoCommand(tString,aCommandRefCon);
return DoCommand(aCommandName, aCommandRefCon);
}
NS_IMETHODIMP
nsCopyCommand::GetCommandState(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsCopyCommand::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
PRBool canUndo;
IsCommandEnabled(tString, aCommandRefCon, &canUndo);
IsCommandEnabled(aCommandName, aCommandRefCon, &canUndo);
return aParams->SetBooleanValue(STATE_ENABLED,canUndo);
}
NS_IMETHODIMP
nsCopyOrDeleteCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCommandRefCon, PRBool *outCmdEnabled)
nsCopyOrDeleteCommand::IsCommandEnabled(const char * aCommandName, nsISupports *aCommandRefCon, PRBool *outCmdEnabled)
{
nsCOMPtr<nsIEditor> editor = do_QueryInterface(aCommandRefCon);
*outCmdEnabled = (editor != nsnull);
@ -288,7 +268,7 @@ nsCopyOrDeleteCommand::IsCommandEnabled(const nsAString & aCommandName, nsISuppo
NS_IMETHODIMP
nsCopyOrDeleteCommand::DoCommand(const nsAString & aCommandName, nsISupports *aCommandRefCon)
nsCopyOrDeleteCommand::DoCommand(const char *aCommandName, nsISupports *aCommandRefCon)
{
nsCOMPtr<nsIEditor> editor = do_QueryInterface(aCommandRefCon);
if (editor)
@ -309,25 +289,21 @@ nsCopyOrDeleteCommand::DoCommand(const nsAString & aCommandName, nsISupports *aC
}
NS_IMETHODIMP
nsCopyOrDeleteCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsCopyOrDeleteCommand::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
return DoCommand(tString,aCommandRefCon);
return DoCommand(aCommandName, aCommandRefCon);
}
NS_IMETHODIMP
nsCopyOrDeleteCommand::GetCommandState(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsCopyOrDeleteCommand::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
PRBool canUndo;
IsCommandEnabled(tString, aCommandRefCon, &canUndo);
IsCommandEnabled(aCommandName, aCommandRefCon, &canUndo);
return aParams->SetBooleanValue(STATE_ENABLED,canUndo);
}
NS_IMETHODIMP
nsPasteCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCommandRefCon, PRBool *outCmdEnabled)
nsPasteCommand::IsCommandEnabled(const char *aCommandName, nsISupports *aCommandRefCon, PRBool *outCmdEnabled)
{
nsCOMPtr<nsIEditor> aEditor = do_QueryInterface(aCommandRefCon);
*outCmdEnabled = PR_FALSE;
@ -339,17 +315,16 @@ nsPasteCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *aC
NS_IMETHODIMP
nsPasteCommand::DoCommand(const nsAString & aCommandName, nsISupports *aCommandRefCon)
nsPasteCommand::DoCommand(const char *aCommandName, nsISupports *aCommandRefCon)
{
nsCOMPtr<nsIEditor> aEditor = do_QueryInterface(aCommandRefCon);
if (!aEditor)
return NS_ERROR_FAILURE;
nsresult rv = NS_OK;
nsAutoString cmdString(aCommandName);
if (cmdString.Equals(NS_LITERAL_STRING("cmd_paste")))
if (!nsCRT::strcmp("cmd_paste",aCommandName))
rv = aEditor->Paste(nsIClipboard::kGlobalClipboard);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_pasteQuote")))
else if (!nsCRT::strcmp("cmd_pasteQuote",aCommandName))
{
nsCOMPtr<nsIEditorMailSupport> mailEditor = do_QueryInterface(aEditor, &rv);
if (mailEditor)
@ -360,26 +335,22 @@ nsPasteCommand::DoCommand(const nsAString & aCommandName, nsISupports *aCommandR
}
NS_IMETHODIMP
nsPasteCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsPasteCommand::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
return DoCommand(tString,aCommandRefCon);
return DoCommand(aCommandName,aCommandRefCon);
}
NS_IMETHODIMP
nsPasteCommand::GetCommandState(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsPasteCommand::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
PRBool canUndo;
IsCommandEnabled(tString, aCommandRefCon, &canUndo);
IsCommandEnabled(aCommandName, aCommandRefCon, &canUndo);
return aParams->SetBooleanValue(STATE_ENABLED,canUndo);
}
NS_IMETHODIMP
nsDeleteCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCommandRefCon, PRBool *outCmdEnabled)
nsDeleteCommand::IsCommandEnabled(const char * aCommandName, nsISupports *aCommandRefCon, PRBool *outCmdEnabled)
{
nsCOMPtr<nsIEditor> aEditor = do_QueryInterface(aCommandRefCon);
*outCmdEnabled = PR_FALSE;
@ -389,21 +360,19 @@ nsDeleteCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *a
nsresult rv = NS_OK;
nsAutoString cmdString(aCommandName);
if (cmdString.Equals(NS_LITERAL_STRING("cmd_delete")))
if (!nsCRT::strcmp(aCommandName,"cmd_delete"))
rv = aEditor->CanCut(outCmdEnabled);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_deleteCharBackward")))
else if (!nsCRT::strcmp(aCommandName,"cmd_deleteCharBackward"))
*outCmdEnabled = PR_TRUE;
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_deleteCharForward")))
else if (!nsCRT::strcmp(aCommandName,"cmd_deleteCharForward"))
*outCmdEnabled = PR_TRUE;
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_deleteWordBackward")))
else if (!nsCRT::strcmp(aCommandName,"cmd_deleteWordBackward"))
*outCmdEnabled = PR_TRUE;
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_deleteWordForward")))
else if (!nsCRT::strcmp(aCommandName,"cmd_deleteWordForward"))
*outCmdEnabled = PR_TRUE;
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_deleteToBeginningOfLine")))
else if (!nsCRT::strcmp(aCommandName,"cmd_deleteToBeginningOfLine"))
*outCmdEnabled = PR_TRUE;
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_deleteToEndOfLine")))
else if (!nsCRT::strcmp(aCommandName,"cmd_deleteToEndOfLine"))
*outCmdEnabled = PR_TRUE;
return rv;
@ -411,54 +380,50 @@ nsDeleteCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *a
NS_IMETHODIMP
nsDeleteCommand::DoCommand(const nsAString & aCommandName, nsISupports *aCommandRefCon)
nsDeleteCommand::DoCommand(const char *aCommandName, nsISupports *aCommandRefCon)
{
nsCOMPtr<nsIEditor> aEditor = do_QueryInterface(aCommandRefCon);
if (!aEditor)
return NS_ERROR_FAILURE;
nsAutoString cmdString(aCommandName);
nsCAutoString cmdString(aCommandName);
nsIEditor::EDirection deleteDir = nsIEditor::eNone;
if (cmdString.Equals(NS_LITERAL_STRING("cmd_delete")))
if (!nsCRT::strcmp("cmd_delete",aCommandName))
deleteDir = nsIEditor::ePrevious;
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_deleteCharBackward")))
else if (!nsCRT::strcmp("cmd_deleteCharBackward",aCommandName))
deleteDir = nsIEditor::ePrevious;
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_deleteCharForward")))
else if (!nsCRT::strcmp("cmd_deleteCharForward",aCommandName))
deleteDir = nsIEditor::eNext;
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_deleteWordBackward")))
else if (!nsCRT::strcmp("cmd_deleteWordBackward",aCommandName))
deleteDir = nsIEditor::ePreviousWord;
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_deleteWordForward")))
else if (!nsCRT::strcmp("cmd_deleteWordForward",aCommandName))
deleteDir = nsIEditor::eNextWord;
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_deleteToBeginningOfLine")))
else if (!nsCRT::strcmp("cmd_deleteToBeginningOfLine",aCommandName))
deleteDir = nsIEditor::eToBeginningOfLine;
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_deleteToEndOfLine")))
else if (!nsCRT::strcmp("cmd_deleteToEndOfLine",aCommandName))
deleteDir = nsIEditor::eToEndOfLine;
return aEditor->DeleteSelection(deleteDir);
}
NS_IMETHODIMP
nsDeleteCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsDeleteCommand::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
return DoCommand(tString,aCommandRefCon);
return DoCommand(aCommandName, aCommandRefCon);
}
NS_IMETHODIMP
nsDeleteCommand::GetCommandState(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsDeleteCommand::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
PRBool canUndo;
IsCommandEnabled(tString, aCommandRefCon, &canUndo);
IsCommandEnabled(aCommandName, aCommandRefCon, &canUndo);
return aParams->SetBooleanValue(STATE_ENABLED,canUndo);
}
NS_IMETHODIMP
nsSelectAllCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCommandRefCon, PRBool *outCmdEnabled)
nsSelectAllCommand::IsCommandEnabled(const char * aCommandName, nsISupports *aCommandRefCon, PRBool *outCmdEnabled)
{
nsCOMPtr<nsIEditor> aEditor = do_QueryInterface(aCommandRefCon);
*outCmdEnabled = PR_FALSE;
@ -470,7 +435,7 @@ nsSelectAllCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports
NS_IMETHODIMP
nsSelectAllCommand::DoCommand(const nsAString & aCommandName, nsISupports *aCommandRefCon)
nsSelectAllCommand::DoCommand(const char *aCommandName, nsISupports *aCommandRefCon)
{
nsCOMPtr<nsIEditor> aEditor = do_QueryInterface(aCommandRefCon);
if (aEditor)
@ -480,26 +445,22 @@ nsSelectAllCommand::DoCommand(const nsAString & aCommandName, nsISupports *aComm
}
NS_IMETHODIMP
nsSelectAllCommand::DoCommandParams(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsSelectAllCommand::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
return DoCommand(tString,aCommandRefCon);
return DoCommand(aCommandName, aCommandRefCon);
}
NS_IMETHODIMP
nsSelectAllCommand::GetCommandState(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsSelectAllCommand::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
PRBool canUndo;
IsCommandEnabled(tString, aCommandRefCon, &canUndo);
IsCommandEnabled(aCommandName, aCommandRefCon, &canUndo);
return aParams->SetBooleanValue(STATE_ENABLED,canUndo);
}
NS_IMETHODIMP
nsSelectionMoveCommands::IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCommandRefCon, PRBool *outCmdEnabled)
nsSelectionMoveCommands::IsCommandEnabled(const char * aCommandName, nsISupports *aCommandRefCon, PRBool *outCmdEnabled)
{
nsCOMPtr<nsIEditor> aEditor = do_QueryInterface(aCommandRefCon);
*outCmdEnabled = PR_FALSE;
@ -512,7 +473,7 @@ nsSelectionMoveCommands::IsCommandEnabled(const nsAString & aCommandName, nsISup
NS_IMETHODIMP
nsSelectionMoveCommands::DoCommand(const nsAString & aCommandName, nsISupports *aCommandRefCon)
nsSelectionMoveCommands::DoCommand(const char *aCommandName, nsISupports *aCommandRefCon)
{
nsCOMPtr<nsIEditor> aEditor = do_QueryInterface(aCommandRefCon);
if (!aEditor)
@ -527,103 +488,98 @@ nsSelectionMoveCommands::DoCommand(const nsAString & aCommandName, nsISupports *
if (!selCont)
return NS_ERROR_FAILURE;
nsAutoString cmdString(aCommandName);
// complete scroll commands
if (cmdString.Equals(NS_LITERAL_STRING("cmd_scrollTop")))
if (!nsCRT::strcmp(aCommandName,"cmd_scrollTop"))
return selCont->CompleteScroll(PR_FALSE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_scrollBottom")))
else if (!nsCRT::strcmp(aCommandName,"cmd_scrollBottom"))
return selCont->CompleteScroll(PR_TRUE);
// complete move commands
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_moveTop")))
else if (!nsCRT::strcmp(aCommandName,"cmd_moveTop"))
return selCont->CompleteMove(PR_FALSE, PR_FALSE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_moveBottom")))
else if (!nsCRT::strcmp(aCommandName,"cmd_moveBottom"))
return selCont->CompleteMove(PR_TRUE, PR_FALSE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_selectTop")))
else if (!nsCRT::strcmp(aCommandName,"cmd_selectTop"))
return selCont->CompleteMove(PR_FALSE, PR_TRUE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_selectBottom")))
else if (!nsCRT::strcmp(aCommandName,"cmd_selectBottom"))
return selCont->CompleteMove(PR_TRUE, PR_TRUE);
// line move commands
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_lineNext")))
else if (!nsCRT::strcmp(aCommandName,"cmd_lineNext"))
return selCont->LineMove(PR_TRUE, PR_FALSE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_linePrevious")))
else if (!nsCRT::strcmp(aCommandName,"cmd_linePrevious"))
return selCont->LineMove(PR_FALSE, PR_FALSE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_selectLineNext")))
else if (!nsCRT::strcmp(aCommandName,"cmd_selectLineNext"))
return selCont->LineMove(PR_TRUE, PR_TRUE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_selectLinePrevious")))
else if (!nsCRT::strcmp(aCommandName,"cmd_selectLinePrevious"))
return selCont->LineMove(PR_FALSE, PR_TRUE);
// character move commands
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_charPrevious")))
else if (!nsCRT::strcmp(aCommandName,"cmd_charPrevious"))
return selCont->CharacterMove(PR_FALSE, PR_FALSE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_charNext")))
else if (!nsCRT::strcmp(aCommandName,"cmd_charNext"))
return selCont->CharacterMove(PR_TRUE, PR_FALSE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_selectCharPrevious")))
else if (!nsCRT::strcmp(aCommandName,"cmd_selectCharPrevious"))
return selCont->CharacterMove(PR_FALSE, PR_TRUE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_selectCharNext")))
else if (!nsCRT::strcmp(aCommandName,"cmd_selectCharNext"))
return selCont->CharacterMove(PR_TRUE, PR_TRUE);
// intra line move commands
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_beginLine")))
else if (!nsCRT::strcmp(aCommandName,"cmd_beginLine"))
return selCont->IntraLineMove(PR_FALSE, PR_FALSE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_endLine")))
else if (!nsCRT::strcmp(aCommandName,"cmd_endLine"))
return selCont->IntraLineMove(PR_TRUE, PR_FALSE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_selectBeginLine")))
else if (!nsCRT::strcmp(aCommandName,"cmd_selectBeginLine"))
return selCont->IntraLineMove(PR_FALSE, PR_TRUE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_selectEndLine")))
else if (!nsCRT::strcmp(aCommandName,"cmd_selectEndLine"))
return selCont->IntraLineMove(PR_TRUE, PR_TRUE);
// word move commands
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_wordPrevious")))
else if (!nsCRT::strcmp(aCommandName,"cmd_wordPrevious"))
return selCont->WordMove(PR_FALSE, PR_FALSE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_wordNext")))
else if (!nsCRT::strcmp(aCommandName,"cmd_wordNext"))
return selCont->WordMove(PR_TRUE, PR_FALSE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_selectWordPrevious")))
else if (!nsCRT::strcmp(aCommandName,"cmd_selectWordPrevious"))
return selCont->WordMove(PR_FALSE, PR_TRUE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_selectWordNext")))
else if (!nsCRT::strcmp(aCommandName,"cmd_selectWordNext"))
return selCont->WordMove(PR_TRUE, PR_TRUE);
// scroll page commands
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_scrollPageUp")))
else if (!nsCRT::strcmp(aCommandName,"cmd_scrollPageUp"))
return selCont->ScrollPage(PR_FALSE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_scrollPageDown")))
else if (!nsCRT::strcmp(aCommandName,"cmd_scrollPageDown"))
return selCont->ScrollPage(PR_TRUE);
// scroll line commands
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_scrollLineUp")))
else if (!nsCRT::strcmp(aCommandName,"cmd_scrollLineUp"))
return selCont->ScrollLine(PR_FALSE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_scrollLineDown")))
else if (!nsCRT::strcmp(aCommandName,"cmd_scrollLineDown"))
return selCont->ScrollLine(PR_TRUE);
// page move commands
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_movePageUp")))
else if (!nsCRT::strcmp(aCommandName,"cmd_movePageUp"))
return selCont->PageMove(PR_FALSE, PR_FALSE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_movePageDown")))
else if (!nsCRT::strcmp(aCommandName,"cmd_movePageDown"))
return selCont->PageMove(PR_TRUE, PR_FALSE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_selectPageUp")))
else if (!nsCRT::strcmp(aCommandName,"cmd_selectPageUp"))
return selCont->PageMove(PR_FALSE, PR_TRUE);
else if (cmdString.Equals(NS_LITERAL_STRING("cmd_selectPageDown")))
else if (!nsCRT::strcmp(aCommandName,"cmd_selectPageDown"))
return selCont->PageMove(PR_TRUE, PR_TRUE);
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsSelectionMoveCommands::DoCommandParams(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsSelectionMoveCommands::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
return DoCommand(tString,aCommandRefCon);
return DoCommand(aCommandName, aCommandRefCon);
}
NS_IMETHODIMP
nsSelectionMoveCommands::GetCommandState(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsSelectionMoveCommands::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
nsString tString;
aParams->GetStringValue(COMMAND_NAME,tString);
PRBool canUndo;
IsCommandEnabled(tString, aCommandRefCon, &canUndo);
IsCommandEnabled(aCommandName, aCommandRefCon, &canUndo);
return aParams->SetBooleanValue(STATE_ENABLED,canUndo);
}

16
editor/libeditor/base/nsEditorCommands.h
View File

@ -55,8 +55,8 @@ public:
NS_DECL_ISUPPORTS
NS_IMETHOD IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCommandRefCon, PRBool *_retval) = 0;
NS_IMETHOD DoCommand(const nsAString & aCommandName, nsISupports *aCommandRefCon) = 0;
NS_IMETHOD IsCommandEnabled(const char * aCommandName, nsISupports *aCommandRefCon, PRBool *_retval) = 0;
NS_IMETHOD DoCommand(const char *aCommandName, nsISupports *aCommandRefCon) = 0;
};
@ -65,10 +65,10 @@ public:
class _cmd : public nsBaseEditorCommand \
{ \
public: \
NS_IMETHOD IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCommandRefCon, PRBool *_retval); \
NS_IMETHOD DoCommand(const nsAString & aCommandName, nsISupports *aCommandRefCon); \
NS_IMETHOD DoCommandParams(nsICommandParams *aParams, nsISupports *aCommandRefCon); \
NS_IMETHOD GetCommandState(nsICommandParams *aParams, nsISupports *aCommandRefCon); \
NS_IMETHOD IsCommandEnabled(const char * aCommandName, nsISupports *aCommandRefCon, PRBool *_retval); \
NS_IMETHOD DoCommand(const char *aCommandName, nsISupports *aCommandRefCon); \
NS_IMETHOD DoCommandParams(const char *aCommandName,nsICommandParams *aParams, nsISupports *aCommandRefCon); \
NS_IMETHOD GetCommandState(const char *aCommandName,nsICommandParams *aParams, nsISupports *aCommandRefCon); \
};
@ -92,14 +92,14 @@ NS_DECL_EDITOR_COMMAND(nsSelectionMoveCommands)
#if 0
// template for new command
NS_IMETHODIMP
nsFooCommand::IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCommandRefCon, PRBool *_retval)
nsFooCommand::IsCommandEnabled(const char * aCommandName, nsISupports *aCommandRefCon, PRBool *_retval)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsFooCommand::DoCommand(const nsAString & aCommandName, const nsAString & aCommandParams, nsISupports *aCommandRefCon)
nsFooCommand::DoCommand(const char *aCommandName, const nsAString & aCommandParams, nsISupports *aCommandRefCon)
{
return NS_ERROR_NOT_IMPLEMENTED;
}

27
editor/libeditor/base/nsEditorController.cpp
View File

@ -51,6 +51,7 @@ NS_IMPL_RELEASE(nsEditorController)
NS_INTERFACE_MAP_BEGIN(nsEditorController)
NS_INTERFACE_MAP_ENTRY(nsIController)
NS_INTERFACE_MAP_ENTRY(nsICommandController)
NS_INTERFACE_MAP_ENTRY(nsIEditorController)
NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIEditorController)
@ -103,7 +104,7 @@ NS_IMETHODIMP nsEditorController::GetInterface(const nsIID & aIID, void * *resul
_cmdClass* theCmd; \
NS_NEWXPCOM(theCmd, _cmdClass); \
if (!theCmd) return NS_ERROR_OUT_OF_MEMORY; \
rv = inCommandManager->RegisterCommand(NS_LITERAL_STRING(_cmdName), \
rv = inCommandManager->RegisterCommand(_cmdName, \
NS_STATIC_CAST(nsIControllerCommand *, theCmd)); \
}
@ -112,15 +113,15 @@ NS_IMETHODIMP nsEditorController::GetInterface(const nsIID & aIID, void * *resul
_cmdClass* theCmd; \
NS_NEWXPCOM(theCmd, _cmdClass); \
if (!theCmd) return NS_ERROR_OUT_OF_MEMORY; \
rv = inCommandManager->RegisterCommand(NS_LITERAL_STRING(_cmdName), \
rv = inCommandManager->RegisterCommand(_cmdName, \
NS_STATIC_CAST(nsIControllerCommand *, theCmd));
#define NS_REGISTER_NEXT_COMMAND(_cmdClass, _cmdName) \
rv = inCommandManager->RegisterCommand(NS_LITERAL_STRING(_cmdName), \
rv = inCommandManager->RegisterCommand(_cmdName, \
NS_STATIC_CAST(nsIControllerCommand *, theCmd));
#define NS_REGISTER_LAST_COMMAND(_cmdClass, _cmdName) \
rv = inCommandManager->RegisterCommand(NS_LITERAL_STRING(_cmdName), \
rv = inCommandManager->RegisterCommand(_cmdName, \
NS_STATIC_CAST(nsIControllerCommand *, theCmd)); \
}
@ -190,24 +191,34 @@ nsresult nsEditorController::RegisterEditorCommands(nsIControllerCommandManager
* nsIController
* ======================================================================= */
NS_IMETHODIMP nsEditorController::IsCommandEnabled(const nsAString & aCommand, PRBool *aResult)
NS_IMETHODIMP nsEditorController::IsCommandEnabled(const char *aCommand, PRBool *aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
return mCommandManager->IsCommandEnabled(aCommand, mCommandRefCon, aResult);
}
NS_IMETHODIMP nsEditorController::SupportsCommand(const nsAString & aCommand, PRBool *aResult)
NS_IMETHODIMP nsEditorController::SupportsCommand(const char *aCommand, PRBool *aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
return mCommandManager->SupportsCommand(aCommand, mCommandRefCon, aResult);
}
NS_IMETHODIMP nsEditorController::DoCommand(const nsAString & aCommand)
NS_IMETHODIMP nsEditorController::DoCommand(const char *aCommand)
{
return mCommandManager->DoCommand(aCommand, mCommandRefCon);
}
NS_IMETHODIMP nsEditorController::OnEvent(const nsAString & aEventName)
NS_IMETHODIMP nsEditorController::DoCommand(const char *aCommand, nsICommandParams *aParams)
{
return mCommandManager->DoCommandParams(aCommand, aParams, mCommandRefCon);
}
NS_IMETHODIMP nsEditorController::GetCommandState(const char *aCommand, nsICommandParams *aParams)
{
return mCommandManager->GetCommandState(aCommand, aParams, mCommandRefCon);
}
NS_IMETHODIMP nsEditorController::OnEvent(const char * aEventName)
{
return NS_OK;
}

6
editor/libeditor/base/nsEditorController.h
View File

@ -62,7 +62,8 @@ class nsIEditor;
class nsEditorController : public nsIController,
public nsIEditorController,
public nsIInterfaceRequestor
public nsIInterfaceRequestor,
public nsICommandController
{
public:
@ -75,6 +76,9 @@ public:
// nsIController
NS_DECL_NSICONTROLLER
// nsICommandController
NS_DECL_NSICOMMANDCONTROLLER
/** init the controller */
NS_IMETHOD Init(nsISupports *aCommandRefCon);

13
embedding/components/commandhandler/public/nsICommandManager.idl
View File

@ -64,7 +64,7 @@ interface nsICommandManager : nsISupports
* multiple times.
*/
void addCommandObserver(in nsIObserver aCommandObserver,
in DOMString aCommandToObserve);
in string aCommandToObserve);
/*
* Stop an observer from observering the specified command. If the observer
@ -74,19 +74,19 @@ interface nsICommandManager : nsISupports
* from all commands.
*/
void removeCommandObserver(in nsIObserver aCommandObserver,
in DOMString aCommandObserved);
in string aCommandObserved);
/*
* Ask the command manager if the specified command is supported.
*
*/
boolean isCommandSupported(in DOMString aCommandName);
boolean isCommandSupported(in string aCommandName);
/*
* Ask the command manager if the specified command is currently.
* enabled.
*/
boolean isCommandEnabled(in DOMString aCommandName);
boolean isCommandEnabled(in string aCommandName);
/*
* Get the state of the specified commands.
@ -97,10 +97,11 @@ interface nsICommandManager : nsISupports
* and, in return will be set to indicate whether the command is enabled
* (equivalent to calling isCommandEnabled).
*
* aCommandName is te name of the command that needs the state
* On output: aCommandParams: values set by the caller filled in with
* state from the command.
*/
void getCommandState(in nsICommandParams aCommandParams);
void getCommandState(in string aCommandName, in nsICommandParams aCommandParams);
/*
* Execute the specified command.
@ -109,7 +110,7 @@ interface nsICommandManager : nsISupports
* may be null for parameter-less commands.
*
*/
void doCommand(in nsICommandParams aCommandParams);
void doCommand(in string aCommandName, in nsICommandParams aCommandParams);
};

36
embedding/components/commandhandler/public/nsICommandParams.idl
View File

@ -58,13 +58,14 @@ interface nsICommandParams : nsISupports
const short eDoubleType = 3;
const short eWStringType = 4;
const short eISupportsType = 5;
const short eStringType = 6;
/*
* getValueType
*
* Get the type of a specified parameter
*/
short getValueType(in AString name);
short getValueType(in string name);
/*
* get_Value
@ -78,11 +79,12 @@ interface nsICommandParams : nsISupports
* for it to contain nsICommandParams, but not *this*
* one (i.e. self-containing is not allowed).
*/
boolean getBooleanValue(in AString name);
long getLongValue(in AString name);
double getDoubleValue(in AString name);
AString getStringValue(in AString name);
nsISupports getISupportsValue(in AString name);
boolean getBooleanValue(in string name);
long getLongValue(in string name);
double getDoubleValue(in string name);
AString getStringValue(in string name);
string getCStringValue(in string name);
nsISupports getISupportsValue(in string name);
/*
* set_Value
@ -95,18 +97,19 @@ interface nsICommandParams : nsISupports
* for it to contain nsICommandParams, but not *this*
* one (i.e. self-containing is not allowed).
*/
void setBooleanValue(in AString name, in boolean value);
void setLongValue(in AString name, in long value);
void setDoubleValue(in AString name, in double value);
void setStringValue(in AString name, in AString value);
void setISupportsValue(in AString name, in nsISupports value);
void setBooleanValue(in string name, in boolean value);
void setLongValue(in string name, in long value);
void setDoubleValue(in string name, in double value);
void setStringValue(in string name, in AString value);
void setCStringValue(in string name, in string value);
void setISupportsValue(in string name, in nsISupports value);
/*
* removeValue
*
* Remove the specified parameter from the list.
*/
void removeValue(in AString name);
void removeValue(in string name);
/*
* Enumeration methods
@ -118,7 +121,14 @@ interface nsICommandParams : nsISupports
*/
boolean hasMoreElements();
void first();
AString getNext();
/**
* GetNext()
*
* @return string pointer that will be allocated and is up
* to the caller to free
*/
string getNext();
};

10
embedding/components/commandhandler/public/nsIControllerCommand.idl
View File

@ -46,9 +46,9 @@ interface nsIControllerCommand : nsISupports
* allowing the command to get some context information.
* The contents of this cookie are implementation-defined.
*/
boolean isCommandEnabled(in DOMString aCommandName, in nsISupports aCommandRefCon);
boolean isCommandEnabled(in string aCommandName, in nsISupports aCommandRefCon);
void getCommandState(in nsICommandParams aParams, in nsISupports aCommandRefCon);
void getCommandState(in string aCommandName, in nsICommandParams aParams, in nsISupports aCommandRefCon);
/**
* Execute the name command.
@ -59,9 +59,9 @@ interface nsIControllerCommand : nsISupports
* allowing the command to get some context information.
* The contents of this cookie are implementation-defined.
*/
void doCommand(in DOMString aCommandName, in nsISupports aCommandRefCon);
void doCommand(in string aCommandName, in nsISupports aCommandRefCon);
void doCommandParams(in nsICommandParams aParams, in nsISupports aCommandRefCon);
void doCommandParams(in string aCommandName, in nsICommandParams aParams, in nsISupports aCommandRefCon);
};
@ -89,7 +89,7 @@ interface nsIStateUpdatingControllerCommand : nsISupports
* allowing the command to get some context information.
* The contents of this cookie are implementation-defined.
*/
void updateCommandState(in DOMString aCommandName, in nsISupports aCommandRefCon);
void updateCommandState(in string aCommandName, in nsISupports aCommandRefCon);
/**
* Gets the command states based on the input parameters

18
embedding/components/commandhandler/public/nsIControllerCommandManager.idl
View File

@ -47,15 +47,15 @@ interface nsIControllerCommandManager : nsISupports
*
* @param aCommand the handler for this command.
*/
void registerCommand(in DOMString aCommandName, in nsIControllerCommand aCommand);
void unregisterCommand(in DOMString aCommandName, in nsIControllerCommand aCommand);
void registerCommand(in string aCommandName, in nsIControllerCommand aCommand);
void unregisterCommand(in string aCommandName, in nsIControllerCommand aCommand);
/**
* Find the command handler which has been registered to handle the named command.
*
* @param aCommandName the name of the command to find the handler for.
*/
nsIControllerCommand findCommandHandler(in DOMString aCommandName);
nsIControllerCommand findCommandHandler(in string aCommandName);
/**
* Get whether the named command is enabled.
@ -63,7 +63,7 @@ interface nsIControllerCommandManager : nsISupports
* @param aCommandName the name of the command to test
* @param aCommandRefCon the command context data
*/
boolean isCommandEnabled(in DOMString aCommandName, in nsISupports aCommandRefCon);
boolean isCommandEnabled(in string aCommandName, in nsISupports aCommandRefCon);
/**
* Tell the command to udpate its state (if it is a state updating command)
@ -71,7 +71,7 @@ interface nsIControllerCommandManager : nsISupports
* @param aCommandName the name of the command to update
* @param aCommandRefCon the command context data
*/
void updateCommandState(in DOMString aCommandName, in nsISupports aCommandRefCon);
void updateCommandState(in string aCommandName, in nsISupports aCommandRefCon);
/**
* Get whether the named command is supported.
@ -79,7 +79,7 @@ interface nsIControllerCommandManager : nsISupports
* @param aCommandName the name of the command to test
* @param aCommandRefCon the command context data
*/
boolean supportsCommand(in DOMString aCommandName, in nsISupports aCommandRefCon);
boolean supportsCommand(in string aCommandName, in nsISupports aCommandRefCon);
/**
* Execute the named command.
@ -87,11 +87,11 @@ interface nsIControllerCommandManager : nsISupports
* @param aCommandName the name of the command to execute
* @param aCommandRefCon the command context data
*/
void doCommand(in DOMString aCommandName, in nsISupports aCommandRefCon);
void doCommand(in string aCommandName, in nsISupports aCommandRefCon);
void doCommandParams(in nsICommandParams aParam, in nsISupports aCommandRefCon);
void doCommandParams(in string aCommandName, in nsICommandParams aParam, in nsISupports aCommandRefCon);
void getCommandState(in nsICommandParams aParam, in nsISupports aCommandRefCon);
void getCommandState(in string aCommandName, in nsICommandParams aParam, in nsISupports aCommandRefCon);
};

2
embedding/components/commandhandler/public/nsPICommandUpdater.idl
View File

@ -65,7 +65,7 @@ interface nsPICommandUpdater : nsISupports
* changed. It may have changed from enabled to disabled,
* or vice versa, or become toggled etc.
*/
void commandStatusChanged(in DOMString aCommandName);
void commandStatusChanged(in string aCommandName);
};

41
embedding/components/commandhandler/src/nsCommandGroup.cpp
View File

@ -45,6 +45,7 @@
#include "nsCommandGroup.h"
#include "nsIControllerCommand.h"
#include "nsCRT.h"
class nsGroupsEnumerator : public nsISimpleEnumerator
@ -66,7 +67,7 @@ protected:
nsHashtable& mHashTable;
PRInt32 mIndex;
PRUnichar** mGroupNames; // array of pointers to PRUnichar* in the hash table
char ** mGroupNames; // array of pointers to PRUnichar* in the hash table
PRBool mInitted;
};
@ -123,9 +124,9 @@ nsGroupsEnumerator::GetNext(nsISupports **_retval)
if (mIndex >= mHashTable.Count())
return NS_ERROR_FAILURE;
PRUnichar *thisGroupName = mGroupNames[mIndex];
char *thisGroupName = mGroupNames[mIndex];
nsCOMPtr<nsISupportsWString> supportsString = do_CreateInstance(NS_SUPPORTS_WSTRING_CONTRACTID, &rv);
nsCOMPtr<nsISupportsString> supportsString = do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID, &rv);
if (NS_FAILED(rv)) return rv;
supportsString->SetData(thisGroupName);
@ -138,9 +139,9 @@ PRBool
nsGroupsEnumerator::HashEnum(nsHashKey *aKey, void *aData, void* aClosure)
{
nsGroupsEnumerator* groupsEnum = NS_REINTERPRET_CAST(nsGroupsEnumerator *, aClosure);
nsStringKey* stringKey = NS_STATIC_CAST(nsStringKey*, aKey);
nsCStringKey* stringKey = NS_STATIC_CAST(nsCStringKey*, aKey);
groupsEnum->mGroupNames[groupsEnum->mIndex] = (PRUnichar*)stringKey->GetString();
groupsEnum->mGroupNames[groupsEnum->mIndex] = (char*)stringKey->GetString();
groupsEnum->mIndex ++;
return PR_TRUE;
}
@ -150,7 +151,7 @@ nsGroupsEnumerator::Initialize()
{
if (mInitted) return NS_OK;
mGroupNames = new PRUnichar*[mHashTable.Count()];
mGroupNames = new char*[mHashTable.Count()];
if (!mGroupNames) return NS_ERROR_OUT_OF_MEMORY;
mIndex = 0;
@ -258,9 +259,9 @@ nsControllerCommandGroup::ClearGroupsHash()
/* void addCommandToGroup (in DOMString aCommand, in DOMString aGroup); */
NS_IMETHODIMP
nsControllerCommandGroup::AddCommandToGroup(const nsAString & aCommand, const nsAString & aGroup)
nsControllerCommandGroup::AddCommandToGroup(const char * aCommand, const char *aGroup)
{
nsStringKey groupKey(aGroup);
nsCStringKey groupKey(aGroup);
nsVoidArray* commandList;
if ((commandList = (nsVoidArray *)mGroupsHash.Get(&groupKey)) == nsnull)
{
@ -269,7 +270,7 @@ nsControllerCommandGroup::AddCommandToGroup(const nsAString & aCommand, const ns
mGroupsHash.Put(&groupKey, (void *)commandList);
}
// add the command to the list. Note that we're not checking for duplicates here
PRUnichar* commandString = ToNewUnicode(aCommand); // we store allocated PRUnichar* in the array
char* commandString = nsCRT::strdup(aCommand); // we store allocated PRUnichar* in the array
if (!commandString) return NS_ERROR_OUT_OF_MEMORY;
PRBool appended = commandList->AppendElement((void *)commandString);
@ -280,17 +281,17 @@ nsControllerCommandGroup::AddCommandToGroup(const nsAString & aCommand, const ns
/* void removeCommandFromGroup (in DOMString aCommand, in DOMString aGroup); */
NS_IMETHODIMP
nsControllerCommandGroup::RemoveCommandFromGroup(const nsAString & aCommand, const nsAString & aGroup)
nsControllerCommandGroup::RemoveCommandFromGroup(const char * aCommand, const char * aGroup)
{
nsStringKey groupKey(aGroup);
nsCStringKey groupKey(aGroup);
nsVoidArray* commandList = (nsVoidArray *)mGroupsHash.Get(&groupKey);
if (!commandList) return NS_OK; // no group
PRInt32 numEntries = commandList->Count();
for (PRInt32 i = 0; i < numEntries; i ++)
{
PRUnichar* commandString = (PRUnichar*)commandList->ElementAt(i);
if (aCommand.Equals(commandString))
char* commandString = (char*)commandList->ElementAt(i);
if (!nsCRT::strcmp(aCommand,commandString))
{
commandList->RemoveElementAt(i);
nsMemory::Free(commandString);
@ -303,20 +304,20 @@ nsControllerCommandGroup::RemoveCommandFromGroup(const nsAString & aCommand, con
/* boolean isCommandInGroup (in DOMString aCommand, in DOMString aGroup); */
NS_IMETHODIMP
nsControllerCommandGroup::IsCommandInGroup(const nsAString & aCommand, const nsAString & aGroup, PRBool *_retval)
nsControllerCommandGroup::IsCommandInGroup(const char * aCommand, const char * aGroup, PRBool *_retval)
{
NS_ENSURE_ARG_POINTER(_retval);
*_retval = PR_FALSE;
nsStringKey groupKey(aGroup);
nsCStringKey groupKey(aGroup);
nsVoidArray* commandList = (nsVoidArray *)mGroupsHash.Get(&groupKey);
if (!commandList) return NS_OK; // no group
PRInt32 numEntries = commandList->Count();
for (PRInt32 i = 0; i < numEntries; i ++)
{
PRUnichar* commandString = (PRUnichar*)commandList->ElementAt(i);
if (aCommand.Equals(commandString))
char* commandString = (char*)commandList->ElementAt(i);
if (!nsCRT::strcmp(aCommand,commandString))
{
*_retval = PR_TRUE;
break;
@ -337,9 +338,9 @@ nsControllerCommandGroup::GetGroupsEnumerator(nsISimpleEnumerator **_retval)
/* nsISimpleEnumerator getEnumeratorForGroup (in DOMString aGroup); */
NS_IMETHODIMP
nsControllerCommandGroup::GetEnumeratorForGroup(const nsAString & aGroup, nsISimpleEnumerator **_retval)
nsControllerCommandGroup::GetEnumeratorForGroup(const char * aGroup, nsISimpleEnumerator **_retval)
{
nsStringKey groupKey(aGroup);
nsCStringKey groupKey(aGroup);
nsVoidArray* commandList = (nsVoidArray *)mGroupsHash.Get(&groupKey); // may be null
nsNamedGroupEnumerator* theGroupEnum = new nsNamedGroupEnumerator(commandList);
@ -360,7 +361,7 @@ PRBool nsControllerCommandGroup::ClearEnumerator(nsHashKey *aKey, void *aData, v
PRInt32 numEntries = commandList->Count();
for (PRInt32 i = 0; i < numEntries; i ++)
{
PRUnichar* commandString = (PRUnichar*)commandList->ElementAt(i);
char* commandString = (char*)commandList->ElementAt(i);
nsMemory::Free(commandString);
}

46
embedding/components/commandhandler/src/nsCommandManager.cpp
View File

@ -84,11 +84,10 @@ nsCommandManager::Init(nsIDOMWindow *aWindow)
/* void commandStatusChanged (in DOMString aCommandName, in long aChangeFlags); */
NS_IMETHODIMP
nsCommandManager::CommandStatusChanged(const nsAString & aCommandName)
nsCommandManager::CommandStatusChanged(const char * aCommandName)
{
nsStringKey hashKey(aCommandName);
nsCStringKey hashKey(aCommandName);
nsPromiseFlatString flatCommand = PromiseFlatString(aCommandName);
nsresult rv = NS_OK;
nsCOMPtr<nsISupports> commandSupports = getter_AddRefs(mCommandObserversTable.Get(&hashKey));
@ -108,7 +107,7 @@ nsCommandManager::CommandStatusChanged(const nsAString & aCommandName)
if (itemObserver)
{
// should we get the command state to pass here? This might be expensive.
itemObserver->Observe((nsICommandManager *)this, "command_status_changed", flatCommand.get());
itemObserver->Observe((nsICommandManager *)this, aCommandName,NS_LITERAL_STRING("command_status_changed").get());
}
}
}
@ -122,7 +121,7 @@ nsCommandManager::CommandStatusChanged(const nsAString & aCommandName)
/* void addCommandObserver (in nsIObserver aCommandObserver, in wstring aCommandToObserve); */
NS_IMETHODIMP
nsCommandManager::AddCommandObserver(nsIObserver *aCommandObserver, const nsAString & aCommandToObserve)
nsCommandManager::AddCommandObserver(nsIObserver *aCommandObserver, const char *aCommandToObserve)
{
NS_ENSURE_ARG(aCommandObserver);
@ -131,7 +130,7 @@ nsCommandManager::AddCommandObserver(nsIObserver *aCommandObserver, const nsAStr
// XXX todo: handle special cases of aCommandToObserve being null, or empty
// for each command in the table, we make a list of observers for that command
nsStringKey hashKey(aCommandToObserve);
nsCStringKey hashKey(aCommandToObserve);
nsCOMPtr<nsISupports> commandSupports = getter_AddRefs(mCommandObserversTable.Get(&hashKey));
nsCOMPtr<nsISupportsArray> commandObservers = do_QueryInterface(commandSupports);
@ -158,12 +157,12 @@ nsCommandManager::AddCommandObserver(nsIObserver *aCommandObserver, const nsAStr
/* void removeCommandObserver (in nsIObserver aCommandObserver, in wstring aCommandObserved); */
NS_IMETHODIMP
nsCommandManager::RemoveCommandObserver(nsIObserver *aCommandObserver, const nsAString & aCommandObserved)
nsCommandManager::RemoveCommandObserver(nsIObserver *aCommandObserver, const char *aCommandObserved)
{
NS_ENSURE_ARG(aCommandObserver);
// XXX todo: handle special cases of aCommandToObserve being null, or empty
nsStringKey hashKey(aCommandObserved);
nsCStringKey hashKey(aCommandObserved);
nsCOMPtr<nsISupports> commandSupports = getter_AddRefs(mCommandObserversTable.Get(&hashKey));
nsCOMPtr<nsISupportsArray> commandObservers = do_QueryInterface(commandSupports);
@ -176,7 +175,7 @@ nsCommandManager::RemoveCommandObserver(nsIObserver *aCommandObserver, const nsA
/* boolean isCommandSupported (in wstring aCommandName); */
NS_IMETHODIMP
nsCommandManager::IsCommandSupported(const nsAString & aCommandName, PRBool *outCommandSupported)
nsCommandManager::IsCommandSupported(const char *aCommandName, PRBool *outCommandSupported)
{
NS_ENSURE_ARG_POINTER(outCommandSupported);
@ -188,7 +187,7 @@ nsCommandManager::IsCommandSupported(const nsAString & aCommandName, PRBool *out
/* boolean isCommandEnabled (in wstring aCommandName); */
NS_IMETHODIMP
nsCommandManager::IsCommandEnabled(const nsAString & aCommandName, PRBool *outCommandEnabled)
nsCommandManager::IsCommandEnabled(const char *aCommandName, PRBool *outCommandEnabled)
{
NS_ENSURE_ARG_POINTER(outCommandEnabled);
@ -204,51 +203,40 @@ nsCommandManager::IsCommandEnabled(const nsAString & aCommandName, PRBool *outCo
return NS_OK;
}
#define COMMAND_NAME NS_ConvertASCIItoUCS2("cmd_name")
/* void getCommandState (in DOMString aCommandName, inout nsICommandParams aCommandParams); */
NS_IMETHODIMP
nsCommandManager::GetCommandState(nsICommandParams *aCommandParams)
nsCommandManager::GetCommandState(const char *aCommandName, nsICommandParams *aCommandParams)
{
nsCOMPtr<nsIController> controller;
nsAutoString tValue;
nsresult rv;
if (NS_SUCCEEDED(rv = aCommandParams->GetStringValue(COMMAND_NAME,tValue)))
{
nsresult rv = GetControllerForCommand(tValue, getter_AddRefs(controller));
nsresult rv = GetControllerForCommand(aCommandName, getter_AddRefs(controller));
if (!controller)
return NS_ERROR_FAILURE;
nsCOMPtr<nsICommandController> commandController = do_QueryInterface(controller);
if (commandController)
rv = commandController->GetCommandState(aCommandParams);
rv = commandController->GetCommandState(aCommandName,aCommandParams);
else
rv = NS_ERROR_NOT_IMPLEMENTED;
}
return rv;
}
/* void doCommand (nsICommandParams aCommandParams); */
#define COMMAND_NAME NS_ConvertASCIItoUCS2("cmd_name")
NS_IMETHODIMP
nsCommandManager::DoCommand(nsICommandParams *aCommandParams)
nsCommandManager::DoCommand(const char *aCommandName, nsICommandParams *aCommandParams)
{
nsCOMPtr<nsIController> controller;
nsAutoString tValue;
nsresult rv;
if (NS_SUCCEEDED(rv = aCommandParams->GetStringValue(COMMAND_NAME,tValue)))
{
nsresult rv = GetControllerForCommand(tValue, getter_AddRefs(controller));
nsresult rv = GetControllerForCommand(aCommandName, getter_AddRefs(controller));
if (!controller)
return NS_ERROR_FAILURE;
nsCOMPtr<nsICommandController> commandController = do_QueryInterface(controller);
if (commandController)
rv = commandController->DoCommand(aCommandParams);
rv = commandController->DoCommand(aCommandName,aCommandParams);
else
rv = controller->DoCommand(tValue);
}
rv = controller->DoCommand(aCommandName);
return rv;
}
@ -257,7 +245,7 @@ nsCommandManager::DoCommand(nsICommandParams *aCommandParams)
#endif
nsresult
nsCommandManager::GetControllerForCommand(const nsAString& aCommand, nsIController** outController)
nsCommandManager::GetControllerForCommand(const char *aCommand, nsIController** outController)
{
nsresult rv = NS_ERROR_FAILURE;

2
embedding/components/commandhandler/src/nsCommandManager.h
View File

@ -73,7 +73,7 @@ public:
protected:
nsresult GetControllerForCommand(const nsAString& aCommand, nsIController** outController);
nsresult GetControllerForCommand(const char * aCommand, nsIController** outController);
protected:

74
embedding/components/commandhandler/src/nsCommandParams.cpp
View File

@ -85,7 +85,7 @@ nsCommandParams::Init()
#endif
/* short getValueType (in string name); */
NS_IMETHODIMP nsCommandParams::GetValueType(const nsAString & name, PRInt16 *_retval)
NS_IMETHODIMP nsCommandParams::GetValueType(const char * name, PRInt16 *_retval)
{
NS_ENSURE_ARG_POINTER(_retval);
*_retval = eNoType;
@ -100,7 +100,7 @@ NS_IMETHODIMP nsCommandParams::GetValueType(const nsAString & name, PRInt16 *_re
}
/* boolean getBooleanValue (in AString name); */
NS_IMETHODIMP nsCommandParams::GetBooleanValue(const nsAString & name, PRBool *_retval)
NS_IMETHODIMP nsCommandParams::GetBooleanValue(const char * name, PRBool *_retval)
{
NS_ENSURE_ARG_POINTER(_retval);
*_retval = PR_FALSE;
@ -116,7 +116,7 @@ NS_IMETHODIMP nsCommandParams::GetBooleanValue(const nsAString & name, PRBool *_
}
/* long getLongValue (in AString name); */
NS_IMETHODIMP nsCommandParams::GetLongValue(const nsAString & name, PRInt32 *_retval)
NS_IMETHODIMP nsCommandParams::GetLongValue(const char * name, PRInt32 *_retval)
{
NS_ENSURE_ARG_POINTER(_retval);
*_retval = PR_FALSE;
@ -132,7 +132,7 @@ NS_IMETHODIMP nsCommandParams::GetLongValue(const nsAString & name, PRInt32 *_re
}
/* double getDoubleValue (in AString name); */
NS_IMETHODIMP nsCommandParams::GetDoubleValue(const nsAString & name, double *_retval)
NS_IMETHODIMP nsCommandParams::GetDoubleValue(const char * name, double *_retval)
{
NS_ENSURE_ARG_POINTER(_retval);
*_retval = 0.0;
@ -148,7 +148,7 @@ NS_IMETHODIMP nsCommandParams::GetDoubleValue(const nsAString & name, double *_r
}
/* AString getStringValue (in AString name); */
NS_IMETHODIMP nsCommandParams::GetStringValue(const nsAString & name, nsAString & _retval)
NS_IMETHODIMP nsCommandParams::GetStringValue(const char *name, nsAString & _retval)
{
_retval.Truncate();
HashEntry* foundEntry = GetNamedEntry(name);
@ -162,8 +162,22 @@ NS_IMETHODIMP nsCommandParams::GetStringValue(const nsAString & name, nsAString
return NS_ERROR_FAILURE;
}
/* AString getStringValue (in AString name); */
NS_IMETHODIMP nsCommandParams::GetCStringValue(const char * name, char **_retval)
{
HashEntry* foundEntry = GetNamedEntry(name);
if (foundEntry && foundEntry->mEntryType == eStringType)
{
NS_ASSERTION(foundEntry->mCString, "Null string");
*_retval= nsCRT::strdup((*foundEntry->mCString).get());
return NS_OK;
}
return NS_ERROR_FAILURE;
}
/* nsISupports getISupportsValue (in AString name); */
NS_IMETHODIMP nsCommandParams::GetISupportsValue(const nsAString & name, nsISupports **_retval)
NS_IMETHODIMP nsCommandParams::GetISupportsValue(const char * name, nsISupports **_retval)
{
NS_ENSURE_ARG_POINTER(_retval);
*_retval = nsnull;
@ -183,7 +197,7 @@ NS_IMETHODIMP nsCommandParams::GetISupportsValue(const nsAString & name, nsISupp
#endif
/* void setBooleanValue (in AString name, in boolean value); */
NS_IMETHODIMP nsCommandParams::SetBooleanValue(const nsAString & name, PRBool value)
NS_IMETHODIMP nsCommandParams::SetBooleanValue(const char * name, PRBool value)
{
HashEntry* foundEntry;
GetOrMakeEntry(name, eBooleanType, foundEntry);
@ -195,7 +209,7 @@ NS_IMETHODIMP nsCommandParams::SetBooleanValue(const nsAString & name, PRBool va
}
/* void setLongValue (in AString name, in long value); */
NS_IMETHODIMP nsCommandParams::SetLongValue(const nsAString & name, PRInt32 value)
NS_IMETHODIMP nsCommandParams::SetLongValue(const char * name, PRInt32 value)
{
HashEntry* foundEntry;
GetOrMakeEntry(name, eLongType, foundEntry);
@ -206,7 +220,7 @@ NS_IMETHODIMP nsCommandParams::SetLongValue(const nsAString & name, PRInt32 valu
}
/* void setDoubleValue (in AString name, in double value); */
NS_IMETHODIMP nsCommandParams::SetDoubleValue(const nsAString & name, double value)
NS_IMETHODIMP nsCommandParams::SetDoubleValue(const char * name, double value)
{
HashEntry* foundEntry;
GetOrMakeEntry(name, eDoubleType, foundEntry);
@ -217,7 +231,7 @@ NS_IMETHODIMP nsCommandParams::SetDoubleValue(const nsAString & name, double val
}
/* void setStringValue (in AString name, in AString value); */
NS_IMETHODIMP nsCommandParams::SetStringValue(const nsAString & name, const nsAString & value)
NS_IMETHODIMP nsCommandParams::SetStringValue(const char * name, const nsAString & value)
{
HashEntry* foundEntry;
GetOrMakeEntry(name, eWStringType, foundEntry);
@ -227,8 +241,19 @@ NS_IMETHODIMP nsCommandParams::SetStringValue(const nsAString & name, const nsAS
return NS_OK;
}
/* void setCStringValue (in string name, in string value); */
NS_IMETHODIMP nsCommandParams::SetCStringValue(const char * name, const char * value)
{
HashEntry* foundEntry;
GetOrMakeEntry(name, eStringType, foundEntry);
if (!foundEntry)
return NS_ERROR_OUT_OF_MEMORY;
foundEntry->mCString = new nsCString(value);
return NS_OK;
}
/* void setISupportsValue (in AString name, in nsISupports value); */
NS_IMETHODIMP nsCommandParams::SetISupportsValue(const nsAString & name, nsISupports *value)
NS_IMETHODIMP nsCommandParams::SetISupportsValue(const char * name, nsISupports *value)
{
HashEntry* foundEntry;
GetOrMakeEntry(name, eISupportsType, foundEntry);
@ -240,12 +265,11 @@ NS_IMETHODIMP nsCommandParams::SetISupportsValue(const nsAString & name, nsISupp
/* void removeValue (in AString name); */
NS_IMETHODIMP
nsCommandParams::RemoveValue(const nsAString & name)
nsCommandParams::RemoveValue(const char * name)
{
nsPromiseFlatString flatName = PromiseFlatString(name);
// PL_DHASH_REMOVE doesn't tell us if the entry was really removed, so we return
// NS_OK unconditionally.
(void)PL_DHashTableOperate(&mValuesHash, (void *)flatName.get(), PL_DHASH_REMOVE);
(void)PL_DHashTableOperate(&mValuesHash, (void *)name, PL_DHASH_REMOVE);
// inval the number of entries
mNumEntries = eNumEntriesUnknown;
@ -257,10 +281,9 @@ nsCommandParams::RemoveValue(const nsAString & name)
#endif
nsCommandParams::HashEntry*
nsCommandParams::GetNamedEntry(const nsAString& name)
nsCommandParams::GetNamedEntry(const char * name)
{
nsPromiseFlatString flatName = PromiseFlatString(name);
HashEntry *foundEntry = (HashEntry *)PL_DHashTableOperate(&mValuesHash, (void *)flatName.get(), PL_DHASH_LOOKUP);
HashEntry *foundEntry = (HashEntry *)PL_DHashTableOperate(&mValuesHash, (void *)name, PL_DHASH_LOOKUP);
if (PL_DHASH_ENTRY_IS_BUSY(foundEntry))
return foundEntry;
@ -281,7 +304,7 @@ nsCommandParams::GetIndexedEntry(PRInt32 index)
if (!PL_DHASH_ENTRY_IS_LIVE(entry))
continue;
if (entryCount == index)
if ((PRInt32)entryCount == index)
return entry;
entryCount ++;
@ -308,11 +331,10 @@ nsCommandParams::GetNumEntries()
}
nsresult
nsCommandParams::GetOrMakeEntry(const nsAString& name, PRUint8 entryType, HashEntry*& outEntry)
nsCommandParams::GetOrMakeEntry(const char * name, PRUint8 entryType, HashEntry*& outEntry)
{
nsPromiseFlatString flatName = PromiseFlatString(name);
HashEntry *foundEntry = (HashEntry *)PL_DHashTableOperate(&mValuesHash, (void *)flatName.get(), PL_DHASH_LOOKUP);
HashEntry *foundEntry = (HashEntry *)PL_DHashTableOperate(&mValuesHash, (void *)name, PL_DHASH_LOOKUP);
if (PL_DHASH_ENTRY_IS_BUSY(foundEntry)) // reuse existing entry
{
foundEntry->Reset(entryType);
@ -321,7 +343,7 @@ nsCommandParams::GetOrMakeEntry(const nsAString& name, PRUint8 entryType, HashEn
return NS_OK;
}
foundEntry = (HashEntry *)PL_DHashTableOperate(&mValuesHash, (void *)flatName.get(), PL_DHASH_ADD);
foundEntry = (HashEntry *)PL_DHashTableOperate(&mValuesHash, (void *)name, PL_DHASH_ADD);
if (!foundEntry) return NS_ERROR_OUT_OF_MEMORY;
// placement new that sucker. Our ctor does not clobber keyHash, which is important.
@ -344,14 +366,14 @@ nsCommandParams::HashGetKey(PLDHashTable *table, PLDHashEntryHdr *entry)
PLDHashNumber
nsCommandParams::HashKey(PLDHashTable *table, const void *key)
{
return nsCRT::HashCode((const PRUnichar*)key);
return nsCRT::HashCode((const char *)key);
}
PRBool
nsCommandParams::HashMatchEntry(PLDHashTable *table,
const PLDHashEntryHdr *entry, const void *key)
{
const PRUnichar* keyString = (const PRUnichar*)key;
const char* keyString = (const char*)key;
const HashEntry* thisEntry = NS_STATIC_CAST(const HashEntry*, entry);
return thisEntry->mEntryName.Equals(keyString);
@ -403,13 +425,13 @@ nsCommandParams::First()
/* AString getNext (); */
NS_IMETHODIMP
nsCommandParams::GetNext(nsAString & _retval)
nsCommandParams::GetNext(char **_retval)
{
HashEntry* thisEntry = GetIndexedEntry(mCurEntry);
if (!thisEntry)
return NS_ERROR_FAILURE;
_retval.Assign(thisEntry->mEntryName);
*_retval = nsCRT::strdup(thisEntry->mEntryName.get());
mCurEntry++;
return NS_OK;
}

21
embedding/components/commandhandler/src/nsCommandParams.h
View File

@ -68,7 +68,7 @@ protected:
struct HashEntry : public PLDHashEntryHdr
{
nsString mEntryName;
nsCString mEntryName;
PRUint8 mEntryType;
union {
@ -80,11 +80,13 @@ protected:
// put these outside the union to avoid clobbering other fields
nsString* mString;
nsCString* mCString;
nsCOMPtr<nsISupports> mISupports;
HashEntry(PRUint8 inType, const nsAString& inEntryName)
: mEntryName(inEntryName)
, mEntryType(inType)
HashEntry(PRUint8 inType, const char * inEntryName)
: mEntryType(inType)
, mEntryName(inEntryName)
, mString(nsnull)
{
mData.mDouble = 0.0;
@ -104,6 +106,10 @@ protected:
NS_ASSERTION(inRHS.mString, "Source entry has no string");
mString = new nsString(*inRHS.mString);
break;
case eStringType:
NS_ASSERTION(inRHS.mCString, "Source entry has no string");
mCString = new nsCString(*inRHS.mCString);
break;
case eISupportsType:
mISupports = inRHS.mISupports.get(); // additional addref
break;
@ -116,6 +122,8 @@ protected:
{
if (mEntryType == eWStringType)
delete mString;
else if (mEntryType == eStringType)
delete mCString;
}
void Reset(PRUint8 inNewType)
@ -128,6 +136,7 @@ protected:
case eDoubleType: mData.mDouble = 0.0; break;
case eWStringType: delete mString; mString = nsnull; break;
case eISupportsType: mISupports = nsnull; break; // clear the nsCOMPtr
case eStringType: delete mCString; mCString = nsnull; break;
default:
NS_ASSERTION(0, "Unknown type");
}
@ -138,11 +147,11 @@ protected:
};
HashEntry* GetNamedEntry(const nsAString& name);
HashEntry* GetNamedEntry(const char * name);
HashEntry* GetIndexedEntry(PRInt32 index);
PRUint32 GetNumEntries();
nsresult GetOrMakeEntry(const nsAString& name, PRUint8 entryType, HashEntry*& outEntry);
nsresult GetOrMakeEntry(const char * name, PRUint8 entryType, HashEntry*& outEntry);
protected:

52
embedding/components/commandhandler/src/nsControllerCommandManager.cpp
View File

@ -64,9 +64,9 @@ NS_IMPL_ISUPPORTS2(nsControllerCommandManager, nsIControllerCommandManager, nsIS
NS_IMETHODIMP
nsControllerCommandManager::RegisterCommand(const nsAString & aCommandName, nsIControllerCommand *aCommand)
nsControllerCommandManager::RegisterCommand(const char * aCommandName, nsIControllerCommand *aCommand)
{
nsStringKey commandKey(aCommandName);
nsCStringKey commandKey(aCommandName);
if (mCommandsTable.Put (&commandKey, aCommand))
{
@ -79,9 +79,9 @@ nsControllerCommandManager::RegisterCommand(const nsAString & aCommandName, nsIC
NS_IMETHODIMP
nsControllerCommandManager::UnregisterCommand(const nsAString & aCommandName, nsIControllerCommand *aCommand)
nsControllerCommandManager::UnregisterCommand(const char * aCommandName, nsIControllerCommand *aCommand)
{
nsStringKey commandKey(aCommandName);
nsCStringKey commandKey(aCommandName);
PRBool wasRemoved = mCommandsTable.Remove (&commandKey);
return wasRemoved ? NS_OK : NS_ERROR_FAILURE;
@ -89,13 +89,13 @@ nsControllerCommandManager::UnregisterCommand(const nsAString & aCommandName, ns
NS_IMETHODIMP
nsControllerCommandManager::FindCommandHandler(const nsAString & aCommandName, nsIControllerCommand **outCommand)
nsControllerCommandManager::FindCommandHandler(const char * aCommandName, nsIControllerCommand **outCommand)
{
NS_ENSURE_ARG_POINTER(outCommand);
*outCommand = NULL;
nsStringKey commandKey(aCommandName);
nsCStringKey commandKey(aCommandName);
nsISupports* foundCommand = mCommandsTable.Get(&commandKey); // this does the addref
if (!foundCommand) return NS_ERROR_FAILURE;
@ -107,7 +107,7 @@ nsControllerCommandManager::FindCommandHandler(const nsAString & aCommandName, n
/* boolean isCommandEnabled (in wstring command); */
NS_IMETHODIMP
nsControllerCommandManager::IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCommandRefCon, PRBool *aResult)
nsControllerCommandManager::IsCommandEnabled(const char * aCommandName, nsISupports *aCommandRefCon, PRBool *aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
@ -129,7 +129,7 @@ nsControllerCommandManager::IsCommandEnabled(const nsAString & aCommandName, nsI
NS_IMETHODIMP
nsControllerCommandManager::UpdateCommandState(const nsAString & aCommandName, nsISupports *aCommandRefCon)
nsControllerCommandManager::UpdateCommandState(const char * aCommandName, nsISupports *aCommandRefCon)
{
// find the command
nsCOMPtr<nsIControllerCommand> commandHandler;
@ -155,7 +155,7 @@ nsControllerCommandManager::UpdateCommandState(const nsAString & aCommandName, n
}
NS_IMETHODIMP
nsControllerCommandManager::SupportsCommand(const nsAString & aCommandName, nsISupports *aCommandRefCon, PRBool *aResult)
nsControllerCommandManager::SupportsCommand(const char * aCommandName, nsISupports *aCommandRefCon, PRBool *aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
@ -173,7 +173,7 @@ nsControllerCommandManager::SupportsCommand(const nsAString & aCommandName, nsIS
/* void doCommand (in wstring command); */
NS_IMETHODIMP
nsControllerCommandManager::DoCommand(const nsAString & aCommandName, nsISupports *aCommandRefCon)
nsControllerCommandManager::DoCommand(const char * aCommandName, nsISupports *aCommandRefCon)
{
// find the command
nsCOMPtr<nsIControllerCommand> commandHandler;
@ -189,51 +189,39 @@ nsControllerCommandManager::DoCommand(const nsAString & aCommandName, nsISupport
return commandHandler->DoCommand(aCommandName, aCommandRefCon);
}
#define COMMAND_NAME NS_ConvertASCIItoUCS2("cmd_name")
NS_IMETHODIMP
nsControllerCommandManager::DoCommandParams(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsControllerCommandManager::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
// find the command
nsCOMPtr<nsIControllerCommand> commandHandler;
nsAutoString tValue;
nsresult rv;
if (NS_SUCCEEDED(rv = aParams->GetStringValue(COMMAND_NAME,tValue)))
{
FindCommandHandler(tValue, getter_AddRefs(commandHandler));
rv = FindCommandHandler(aCommandName, getter_AddRefs(commandHandler));
if (!commandHandler)
{
#if DEBUG
#if DEBUG
NS_WARNING("Controller command manager asked to do a command that it does not handle -- ");
#endif
#endif
return NS_OK; // we don't handle this command
}
return commandHandler->DoCommandParams(aParams, aCommandRefCon);
}
return rv;
return commandHandler->DoCommandParams(aCommandName, aParams, aCommandRefCon);
}
NS_IMETHODIMP
nsControllerCommandManager::GetCommandState(nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsControllerCommandManager::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
{
// find the command
nsCOMPtr<nsIControllerCommand> commandHandler;
nsAutoString tValue;
nsresult rv;
if (NS_SUCCEEDED(rv = aParams->GetStringValue(COMMAND_NAME,tValue)))
{
FindCommandHandler(tValue, getter_AddRefs(commandHandler));
rv = FindCommandHandler(aCommandName, getter_AddRefs(commandHandler));
if (!commandHandler)
{
#if DEBUG
#if DEBUG
NS_WARNING("Controller command manager asked to do a command that it does not handle -- ");
#endif
#endif
return NS_OK; // we don't handle this command
}
return commandHandler->GetCommandState(aParams, aCommandRefCon);
}
return rv;
return commandHandler->GetCommandState(aCommandName, aParams, aCommandRefCon);
}

171
embedding/tests/mfcembed/EditorFrm.cpp
View File

@ -38,45 +38,45 @@
//------------------------------------------------------------
// Editor Command/Parameter Names
//------------------------------------------------------------
#define BOLD_COMMAND NS_LITERAL_STRING("cmd_bold")
#define ITALIC_COMMAND NS_LITERAL_STRING("cmd_italic")
#define UNDERLINE_COMMAND NS_LITERAL_STRING("cmd_underline")
#define INDENT_COMMAND NS_LITERAL_STRING("cmd_indent")
#define OUTDENT_COMMAND NS_LITERAL_STRING("cmd_outdent")
#define FONTCOLOR_COMMAND NS_LITERAL_STRING("cmd_fontColor")
#define BACKGROUNDCOLOR_COMMAND NS_LITERAL_STRING("cmd_backgroundColor")
#define COMMAND_NAME NS_LITERAL_STRING("cmd_name")
#define INCREASEFONT_COMMAND NS_LITERAL_STRING("cmd_increaseFont")
#define DECREASEFONT_COMMAND NS_LITERAL_STRING("cmd_decreaseFont")
#define FONTFACE_COMMAND NS_LITERAL_STRING("cmd_fontFace")
#define ALIGN_COMMAND NS_LITERAL_STRING("cmd_align")
#define UNDO_COMMAND NS_LITERAL_STRING("cmd_undo")
#define REDO_COMMAND NS_LITERAL_STRING("cmd_redo")
#define BOLD_COMMAND "cmd_bold"
#define ITALIC_COMMAND "cmd_italic"
#define UNDERLINE_COMMAND "cmd_underline"
#define INDENT_COMMAND "cmd_indent"
#define OUTDENT_COMMAND "cmd_outdent"
#define FONTCOLOR_COMMAND "cmd_fontColor"
#define BACKGROUNDCOLOR_COMMAND "cmd_backgroundColor"
#define COMMAND_NAME "cmd_name"
#define INCREASEFONT_COMMAND "cmd_increaseFont"
#define DECREASEFONT_COMMAND "cmd_decreaseFont"
#define FONTFACE_COMMAND "cmd_fontFace"
#define ALIGN_COMMAND "cmd_align"
#define UNDO_COMMAND "cmd_undo"
#define REDO_COMMAND "cmd_redo"
//states
#define STATE_ALL NS_LITERAL_STRING("state_all")
#define STATE_MIXED NS_LITERAL_STRING("state_mixed")
#define STATE_ATTRIBUTE NS_LITERAL_STRING("state_attribute")
#define STATE_ENABLED NS_LITERAL_STRING("state_enabled")
#define STATE_ALL "state_all"
#define STATE_MIXED "state_mixed"
#define STATE_ATTRIBUTE "state_attribute"
#define STATE_ENABLED "state_enabled"
//colors
#define COLOR_RED NS_LITERAL_STRING("#FF0000")
#define COLOR_BLACK NS_LITERAL_STRING("#000000")
#define COLOR_RED "#FF0000"
#define COLOR_BLACK "#000000"
//fonts
#define FONT_ARIAL NS_LITERAL_STRING("Helvetica, Arial, sans-serif")
#define FONT_TIMES NS_LITERAL_STRING("Times New Roman, Times, serif")
#define FONT_COURIER NS_LITERAL_STRING("Courier New, Courier, monospace")
#define FONT_ARIAL "Helvetica, Arial, sans-serif"
#define FONT_TIMES "Times New Roman, Times, serif"
#define FONT_COURIER "Courier New, Courier, monospace"
//align
#define ALIGN_LEFT NS_LITERAL_STRING("left")
#define ALIGN_RIGHT NS_LITERAL_STRING("right")
#define ALIGN_CENTER NS_LITERAL_STRING("center")
#define ALIGN_LEFT "left"
#define ALIGN_RIGHT "right"
#define ALIGN_CENTER "center"
//value
#define STATE_EMPTY NS_LITERAL_STRING("")
#define STATE_EMPTY ""
IMPLEMENT_DYNAMIC(CEditorFrame, CBrowserFrame)
@ -112,10 +112,10 @@ BEGIN_MESSAGE_MAP(CEditorFrame, CBrowserFrame)
ON_COMMAND(ID_ALIGNCENTER, OnAligncenter)
ON_UPDATE_COMMAND_UI(ID_ALIGNCENTER, OnUpdateAligncenter)
ON_COMMAND(ID_INSERTLINK, OnInsertlink)
ON_COMMAND(ID_EDIT_UNDO, OnEditUndo)
ON_COMMAND(ID_EDIT_REDO, OnEditRedo)
ON_UPDATE_COMMAND_UI(ID_EDIT_REDO, OnUpdateEditRedo)
ON_UPDATE_COMMAND_UI(ID_EDIT_UNDO, OnUpdateEditUndo)
ON_COMMAND(ID_EDITOR_UNDO, OnEditUndo)
ON_COMMAND(ID_EDITOR_REDO, OnEditRedo)
ON_UPDATE_COMMAND_UI(ID_EDITOR_REDO, OnUpdateEditRedo)
ON_UPDATE_COMMAND_UI(ID_EDITOR_UNDO, OnUpdateEditUndo)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
@ -175,7 +175,7 @@ void CEditorFrame::OnUpdateUnderline(CCmdUI* pCmdUI)
//Called to make a nsICommandParams with the 1 value pair of command name
NS_METHOD
CEditorFrame::MakeCommandParams(const nsAString &aCommand,nsICommandParams **aParams)
CEditorFrame::MakeCommandParams(const char *aCommand,nsICommandParams **aParams)
{
nsresult rv;
nsCOMPtr<nsICommandParams> params = do_CreateInstance(NS_COMMAND_PARAMS_CONTRACTID,&rv);
@ -183,7 +183,6 @@ CEditorFrame::MakeCommandParams(const nsAString &aCommand,nsICommandParams **aPa
return rv;
if (!params)
return NS_ERROR_FAILURE;
rv = params->SetStringValue(COMMAND_NAME, aCommand);
*aParams = params;
NS_ADDREF(*aParams);
return rv;
@ -195,31 +194,23 @@ CEditorFrame::MakeCommandParams(const nsAString &aCommand,nsICommandParams **aPa
// are clicked
//
NS_METHOD
CEditorFrame::ExecuteStyleCommand(const nsAString &aCommand)
CEditorFrame::ExecuteStyleCommand(const char *aCommand)
{
nsCOMPtr<nsICommandParams> params;
nsresult rv = MakeCommandParams(aCommand,getter_AddRefs(params));
if (NS_FAILED(rv))
return rv;
if (!params)
return NS_ERROR_FAILURE;
params->SetBooleanValue(STATE_ALL, true);
return DoCommand(params);
return DoCommand(aCommand,0);
}
// Called in response to the UPDATE_COMMAND_UI messages for
// style related toolbar buttons(bold, italic etc.)
// to update their current state
//
void CEditorFrame::UpdateStyleToolBarBtn(const nsAString &aCommand, CCmdUI* pCmdUI)
void CEditorFrame::UpdateStyleToolBarBtn(const char *aCommand, CCmdUI* pCmdUI)
{
nsCOMPtr<nsICommandParams> params;
nsresult rv;
rv = MakeCommandParams(aCommand,getter_AddRefs(params));
if (NS_FAILED(rv) || !params)
return;
rv = GetCommandState(params);
rv = GetCommandState(aCommand,params);
if (NS_SUCCEEDED(rv))
{
// Does our current selection span mixed styles?
@ -258,80 +249,39 @@ CEditorFrame::MakeEditable()
if (!domWindow)
return NS_ERROR_FAILURE;
nsCOMPtr<nsIScriptGlobalObject> scriptGlobalObject = do_QueryInterface(domWindow);
if (!scriptGlobalObject)
return NS_ERROR_FAILURE;
nsCOMPtr<nsIDocShell> docShell;
rv = scriptGlobalObject->GetDocShell(getter_AddRefs(docShell));
if (NS_FAILED(rv))
return rv;
if (!docShell)
return NS_ERROR_FAILURE;
nsCOMPtr<nsIEditingSession> editingSession = do_GetInterface(docShell);
nsCOMPtr<nsIEditingSession> editingSession = do_GetInterface(m_wndBrowserView.mWebBrowser);
if (!editingSession)
return NS_ERROR_FAILURE;
rv= editingSession->MakeWindowEditable(domWindow, PR_TRUE);
// this can fail for the root (if it's a frameset), but we still want
// to make children editable
nsCOMPtr<nsISimpleEnumerator> docShellEnumerator;
docShell->GetDocShellEnumerator( nsIDocShellTreeItem::typeContent,
nsIDocShell::ENUMERATE_FORWARDS,
getter_AddRefs(docShellEnumerator));
if (docShellEnumerator)
{
PRBool hasMore;
while (NS_SUCCEEDED(docShellEnumerator->HasMoreElements(&hasMore)) && hasMore)
{
nsCOMPtr<nsISupports> curSupports;
rv = docShellEnumerator->GetNext(getter_AddRefs(curSupports));
if (NS_FAILED(rv)) break;
nsCOMPtr<nsIDocShell> curShell = do_QueryInterface(curSupports, &rv);
if (NS_FAILED(rv)) break;
nsCOMPtr<nsIDOMWindow> childWindow = do_GetInterface(curShell,&rv);
if (childWindow)
editingSession->MakeWindowEditable(childWindow, PR_FALSE);
}
}
return NS_OK;
return rv;
}
NS_METHOD
CEditorFrame::DoCommand(nsICommandParams *aCommandParams)
CEditorFrame::DoCommand(const char *aCommand, nsICommandParams *aCommandParams)
{
return mCommandManager ? mCommandManager->DoCommand(aCommandParams) : NS_ERROR_FAILURE;
return mCommandManager ? mCommandManager->DoCommand(aCommand, aCommandParams) : NS_ERROR_FAILURE;
}
NS_METHOD
CEditorFrame::IsCommandEnabled(const nsAString &aCommand, PRBool *retval)
CEditorFrame::IsCommandEnabled(const char *aCommand, PRBool *retval)
{
return mCommandManager ? mCommandManager->IsCommandEnabled(aCommand, retval) : NS_ERROR_FAILURE;
}
NS_METHOD
CEditorFrame::GetCommandState(nsICommandParams *aCommandParams)
CEditorFrame::GetCommandState(const char *aCommand, nsICommandParams *aCommandParams)
{
return mCommandManager ? mCommandManager->GetCommandState(aCommandParams) : NS_ERROR_FAILURE;
return mCommandManager ? mCommandManager->GetCommandState(aCommand,aCommandParams) : NS_ERROR_FAILURE;
}
NS_METHOD
CEditorFrame::ExecuteNoParam(const nsAString &aCommand)
CEditorFrame::ExecuteNoParam(const char *aCommand)
{
nsresult rv;
nsCOMPtr<nsICommandParams> params;
rv = MakeCommandParams(aCommand,getter_AddRefs(params));
if (NS_FAILED(rv))
return rv;
if (!params)
return NS_ERROR_FAILURE;
return DoCommand(params);
return DoCommand(aCommand,0);
}
void CEditorFrame::OnIndent()
@ -359,7 +309,7 @@ void CEditorFrame::OnUpdateOutdent(CCmdUI* pCmdUI)
}
NS_METHOD
CEditorFrame::ExecuteAttribParam(const nsAString &aCommand, const nsAString &aAttribute)
CEditorFrame::ExecuteAttribParam(const char *aCommand, const char *aAttribute)
{
nsresult rv;
nsCOMPtr<nsICommandParams> params;
@ -368,12 +318,12 @@ CEditorFrame::ExecuteAttribParam(const nsAString &aCommand, const nsAString &aAt
return rv;
if (!params)
return NS_ERROR_FAILURE;
params->SetStringValue(STATE_ATTRIBUTE, aAttribute);
return DoCommand(params);
params->SetCStringValue(STATE_ATTRIBUTE, aAttribute);
return DoCommand(aCommand,params);
}
NS_METHOD
CEditorFrame::GetAttributeParamValue(const nsAString &aCommand, nsString &aValue)
CEditorFrame::GetAttributeParamValue(const char *aCommand, nsCString &aValue)
{
nsresult rv;
nsCOMPtr<nsICommandParams> params;
@ -382,10 +332,13 @@ CEditorFrame::GetAttributeParamValue(const nsAString &aCommand, nsString &aValue
return rv;
if (!params)
return NS_ERROR_FAILURE;
rv = GetCommandState(params);
rv = GetCommandState(aCommand, params);
if (NS_SUCCEEDED(rv))
{
return params->GetStringValue(STATE_ATTRIBUTE,aValue);
char *tchar;
rv = params->GetCStringValue(STATE_ATTRIBUTE,&tchar);
aValue.Adopt(tchar);
return rv;
}
return rv;
}
@ -481,12 +434,12 @@ void CEditorFrame::OnAlignleft()
void CEditorFrame::OnUpdateAlignleft(CCmdUI* pCmdUI)
{
// TODO: Add your command update UI handler code here
nsString tValue;
nsCAutoString tValue;
nsresult rv = GetAttributeParamValue(ALIGN_COMMAND,tValue);
if (NS_SUCCEEDED(rv))
{
if (tValue == ALIGN_LEFT)
if (tValue.Equals(ALIGN_LEFT))
pCmdUI->SetCheck(1);
else
pCmdUI->SetCheck(0);
@ -504,11 +457,11 @@ void CEditorFrame::OnUpdateAlignright(CCmdUI* pCmdUI)
{
// TODO: Add your command update UI handler code here
// TODO: Add your command update UI handler code here
nsString tValue;
nsCAutoString tValue;
nsresult rv = GetAttributeParamValue(ALIGN_COMMAND,tValue);
if (NS_SUCCEEDED(rv))
{
if (tValue == ALIGN_RIGHT)
if (tValue.Equals(ALIGN_RIGHT))
pCmdUI->SetCheck(1);
else
pCmdUI->SetCheck(0);
@ -526,11 +479,11 @@ void CEditorFrame::OnUpdateAligncenter(CCmdUI* pCmdUI)
{
// TODO: Add your command update UI handler code here
// TODO: Add your command update UI handler code here
nsString tValue;
nsCAutoString tValue;
nsresult rv = GetAttributeParamValue(ALIGN_COMMAND,tValue);
if (NS_SUCCEEDED(rv))
{
if (tValue == ALIGN_CENTER)
if (tValue.Equals(ALIGN_CENTER))
pCmdUI->SetCheck(1);
else
pCmdUI->SetCheck(0);
@ -565,7 +518,7 @@ void CEditorFrame::OnUpdateEditRedo(CCmdUI* pCmdUI)
return;
if (!params)
return;
rv = GetCommandState(params);
rv = GetCommandState(REDO_COMMAND, params);
if (NS_SUCCEEDED(rv))
{
PRBool tValue;
@ -589,7 +542,7 @@ void CEditorFrame::OnUpdateEditUndo(CCmdUI* pCmdUI)
return;
if (!params)
return;
rv = GetCommandState(params);
rv = GetCommandState(UNDO_COMMAND, params);
if (NS_SUCCEEDED(rv))
{
PRBool tValue;

18
embedding/tests/mfcembed/EditorFrm.h
View File

@ -51,9 +51,9 @@ protected:
public:
BOOL InitEditor();
NS_METHOD MakeEditable();
NS_METHOD DoCommand(nsICommandParams *aCommandParams);
NS_METHOD IsCommandEnabled(const nsAString &aCommand, PRBool *retval);
NS_METHOD GetCommandState(nsICommandParams *aCommandParams);
NS_METHOD DoCommand(const char *aCommand, nsICommandParams *aCommandParams);
NS_METHOD IsCommandEnabled(const char *aCommand, PRBool *retval);
NS_METHOD GetCommandState(const char *aCommand, nsICommandParams *aCommandParams);
// Generated message map functions
protected:
@ -97,13 +97,13 @@ protected:
DECLARE_MESSAGE_MAP()
private:
NS_METHOD ExecuteStyleCommand(const nsAString &aCommand);
NS_METHOD ExecuteNoParam(const nsAString &aCommand);
NS_METHOD MakeCommandParams(const nsAString &aCommand,nsICommandParams **aParams);
NS_METHOD ExecuteAttribParam(const nsAString &aCommand, const nsAString &aAttribute);
NS_METHOD GetAttributeParamValue(const nsAString &aCommand, nsString &aValue);
NS_METHOD ExecuteStyleCommand(const char *aCommand);
NS_METHOD ExecuteNoParam(const char *aCommand);
NS_METHOD MakeCommandParams(const char *aCommand,nsICommandParams **aParams);
NS_METHOD ExecuteAttribParam(const char *aCommand, const char *aAttribute);
NS_METHOD GetAttributeParamValue(const char *aCommand, nsCString &aValue);
void UpdateStyleToolBarBtn(const nsAString &aCommand, CCmdUI* pCmdUI);
void UpdateStyleToolBarBtn(const char *aCommand, CCmdUI* pCmdUI);
private:
nsCOMPtr<nsICommandManager> mCommandManager;

7
embedding/tests/mfcembed/MfcEmbed.rc
View File

@ -274,8 +274,8 @@ BEGIN
END
POPUP "&Edit"
BEGIN
MENUITEM "Undo\tCtrl+Z", ID_EDIT_UNDO
MENUITEM "Redo\tCtrl+Shift+Z", ID_EDIT_REDO
MENUITEM "Undo\tCtrl+Z", ID_EDITOR_UNDO
MENUITEM "Redo\tCtrl+Shift+Z", ID_EDITOR_REDO
MENUITEM SEPARATOR
MENUITEM "Cu&t\tCtrl+X", ID_EDIT_CUT
MENUITEM "&Copy\tCtrl+C", ID_EDIT_COPY
@ -324,8 +324,11 @@ BEGIN
VK_INSERT, ID_EDIT_PASTE, VIRTKEY, SHIFT, NOINVERT
"X", ID_EDIT_CUT, VIRTKEY, CONTROL, NOINVERT
"Z", ID_EDIT_UNDO, VIRTKEY, CONTROL, NOINVERT
"Z", ID_EDITOR_UNDO, VIRTKEY, CONTROL, NOINVERT
"Z", ID_EDIT_REDO, VIRTKEY, SHIFT, CONTROL,
NOINVERT
"Z", ID_EDITOR_REDO, VIRTKEY, SHIFT, CONTROL,
NOINVERT
END

5
embedding/tests/mfcembed/resource.h
View File

@ -132,6 +132,9 @@
#define ID_ALIGNCENTER 32809
#define ID_ALIGNRIGHT 32810
#define ID_INSERTLINK 32811
#define ID_EDITOR_UNDO 32813
#define ID_EDITOR_REDO 32814
// Next default values for new objects
//
@ -139,7 +142,7 @@
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_3D_CONTROLS 1
#define _APS_NEXT_RESOURCE_VALUE 160
#define _APS_NEXT_COMMAND_VALUE 32813
#define _APS_NEXT_COMMAND_VALUE 32815
#define _APS_NEXT_CONTROL_VALUE 1058
#define _APS_NEXT_SYMED_VALUE 102
#endif