Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-02-17 22:32:51 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1130096 - Convert embedding/components/commandhandler/ to Gecko style. r=mccr8

Browse Source
This commit is contained in:
Birunthan Mohanathas 2015-05-11 12:35:14 -07:00
parent a70a5c37db
commit 916fc10422
10 changed files with 361 additions and 417 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
embedding/components/commandhandler/nsBaseCommandController.cpp
View File

@ -31,20 +31,22 @@ nsBaseCommandController::~nsBaseCommandController()
}
NS_IMETHODIMP
nsBaseCommandController::Init(nsIControllerCommandTable *aCommandTable)
nsBaseCommandController::Init(nsIControllerCommandTable* aCommandTable)
{
nsresult rv = NS_OK;
if (aCommandTable)
mCommandTable = aCommandTable; // owning addref
else
mCommandTable = do_CreateInstance(NS_CONTROLLERCOMMANDTABLE_CONTRACTID, &rv);
if (aCommandTable) {
mCommandTable = aCommandTable;
} else {
mCommandTable =
do_CreateInstance(NS_CONTROLLERCOMMANDTABLE_CONTRACTID, &rv);
}
return rv;
}
NS_IMETHODIMP
nsBaseCommandController::SetCommandContext(nsISupports *aCommandContext)
nsBaseCommandController::SetCommandContext(nsISupports* aCommandContext)
{
mCommandContextWeakPtr = nullptr;
mCommandContextRawPtr = nullptr;
@ -55,8 +57,7 @@ nsBaseCommandController::SetCommandContext(nsISupports *aCommandContext)
nsresult rv =
weak->GetWeakReference(getter_AddRefs(mCommandContextWeakPtr));
NS_ENSURE_SUCCESS(rv, rv);
}
else {
} else {
mCommandContextRawPtr = aCommandContext;
}
}
@ -65,32 +66,30 @@ nsBaseCommandController::SetCommandContext(nsISupports *aCommandContext)
}
NS_IMETHODIMP
nsBaseCommandController::GetInterface(const nsIID & aIID, void * *result)
nsBaseCommandController::GetInterface(const nsIID& aIID, void** aResult)
{
NS_ENSURE_ARG_POINTER(result);
NS_ENSURE_ARG_POINTER(aResult);
if (NS_SUCCEEDED(QueryInterface(aIID, result)))
if (NS_SUCCEEDED(QueryInterface(aIID, aResult))) {
return NS_OK;
}
if (aIID.Equals(NS_GET_IID(nsIControllerCommandTable)))
{
if (mCommandTable)
return mCommandTable->QueryInterface(aIID, result);
if (aIID.Equals(NS_GET_IID(nsIControllerCommandTable))) {
if (mCommandTable) {
return mCommandTable->QueryInterface(aIID, aResult);
}
return NS_ERROR_NOT_INITIALIZED;
}
return NS_NOINTERFACE;
}
/* =======================================================================
* nsIController
* ======================================================================= */
NS_IMETHODIMP
nsBaseCommandController::IsCommandEnabled(const char *aCommand,
bool *aResult)
nsBaseCommandController::IsCommandEnabled(const char* aCommand, bool* aResult)
{
NS_ENSURE_ARG_POINTER(aCommand);
NS_ENSURE_ARG_POINTER(aResult);
@ -106,7 +105,7 @@ nsBaseCommandController::IsCommandEnabled(const char *aCommand,
}
NS_IMETHODIMP
nsBaseCommandController::SupportsCommand(const char *aCommand, bool *aResult)
nsBaseCommandController::SupportsCommand(const char* aCommand, bool* aResult)
{
NS_ENSURE_ARG_POINTER(aCommand);
NS_ENSURE_ARG_POINTER(aResult);
@ -122,7 +121,7 @@ nsBaseCommandController::SupportsCommand(const char *aCommand, bool *aResult)
}
NS_IMETHODIMP
nsBaseCommandController::DoCommand(const char *aCommand)
nsBaseCommandController::DoCommand(const char* aCommand)
{
NS_ENSURE_ARG_POINTER(aCommand);
NS_ENSURE_STATE(mCommandTable);
@ -137,8 +136,8 @@ nsBaseCommandController::DoCommand(const char *aCommand)
}
NS_IMETHODIMP
nsBaseCommandController::DoCommandWithParams(const char *aCommand,
nsICommandParams *aParams)
nsBaseCommandController::DoCommandWithParams(const char* aCommand,
nsICommandParams* aParams)
{
NS_ENSURE_ARG_POINTER(aCommand);
NS_ENSURE_STATE(mCommandTable);
@ -153,8 +152,8 @@ nsBaseCommandController::DoCommandWithParams(const char *aCommand,
}
NS_IMETHODIMP
nsBaseCommandController::GetCommandStateWithParams(const char *aCommand,
nsICommandParams *aParams)
nsBaseCommandController::GetCommandStateWithParams(const char* aCommand,
nsICommandParams* aParams)
{
NS_ENSURE_ARG_POINTER(aCommand);
NS_ENSURE_STATE(mCommandTable);
@ -169,14 +168,15 @@ nsBaseCommandController::GetCommandStateWithParams(const char *aCommand,
}
NS_IMETHODIMP
nsBaseCommandController::OnEvent(const char * aEventName)
nsBaseCommandController::OnEvent(const char* aEventName)
{
NS_ENSURE_ARG_POINTER(aEventName);
return NS_OK;
}
NS_IMETHODIMP
nsBaseCommandController::GetSupportedCommands(uint32_t* aCount, char*** aCommands)
nsBaseCommandController::GetSupportedCommands(uint32_t* aCount,
char*** aCommands)
{
NS_ENSURE_STATE(mCommandTable);
return mCommandTable->GetSupportedCommands(aCount, aCommands);

38
embedding/components/commandhandler/nsBaseCommandController.h
View File

@ -7,10 +7,9 @@
#define nsBaseCommandController_h__
#define NS_BASECOMMANDCONTROLLER_CID \
{ 0xbf88b48c, 0xfd8e, 0x40b4, { 0xba, 0x36, 0xc7, 0xc3, 0xad, 0x6d, 0x8a, 0xc9 } }
{ 0xbf88b48c, 0xfd8e, 0x40b4, { 0xba, 0x36, 0xc7, 0xc3, 0xad, 0x6d, 0x8a, 0xc9 } }
#define NS_BASECOMMANDCONTROLLER_CONTRACTID \
"@mozilla.org/embedcomp/base-command-controller;1"
"@mozilla.org/embedcomp/base-command-controller;1"
#include "nsIController.h"
#include "nsIControllerContext.h"
@ -18,43 +17,32 @@
#include "nsIInterfaceRequestor.h"
#include "nsIWeakReferenceUtils.h"
// The base editor controller is used for both text widgets,
// and all other text and html editing
class nsBaseCommandController : public nsIController,
public nsIControllerContext,
public nsIInterfaceRequestor,
public nsICommandController
// The base editor controller is used for both text widgets, and all other text
// and html editing
class nsBaseCommandController
: public nsIController
, public nsIControllerContext
, public nsIInterfaceRequestor
, public nsICommandController
{
public:
nsBaseCommandController();
// nsISupports
NS_DECL_ISUPPORTS
// nsIController
NS_DECL_NSICONTROLLER
// nsICommandController
NS_DECL_NSICOMMANDCONTROLLER
//nsIControllerContext
NS_DECL_NSICONTROLLERCONTEXT
// nsIInterfaceRequestor
NS_DECL_NSIINTERFACEREQUESTOR
protected:
virtual ~nsBaseCommandController();
private:
nsWeakPtr mCommandContextWeakPtr;
nsISupports* mCommandContextRawPtr;
nsWeakPtr mCommandContextWeakPtr;
nsISupports* mCommandContextRawPtr;
// Our reference to the command manager
nsCOMPtr<nsIControllerCommandTable> mCommandTable;
// Our reference to the command manager
nsCOMPtr<nsIControllerCommandTable> mCommandTable;
};
#endif /* nsBaseCommandController_h_ */

224
embedding/components/commandhandler/nsCommandGroup.cpp
View File

@ -14,11 +14,11 @@
#include "nsIControllerCommand.h"
#include "nsCRT.h"
class nsGroupsEnumerator : public nsISimpleEnumerator
{
public:
explicit nsGroupsEnumerator(nsControllerCommandGroup::GroupsHashtable &inHashTable);
explicit nsGroupsEnumerator(
nsControllerCommandGroup::GroupsHashtable& aInHashTable);
NS_DECL_ISUPPORTS
NS_DECL_NSISIMPLEENUMERATOR
@ -26,84 +26,90 @@ public:
protected:
virtual ~nsGroupsEnumerator();
static PLDHashOperator HashEnum(const nsACString &aKey, nsTArray<nsCString> *aData, void *aClosure);
static PLDHashOperator HashEnum(const nsACString& aKey,
nsTArray<nsCString>* aData, void* aClosure);
nsresult Initialize();
protected:
nsControllerCommandGroup::GroupsHashtable &mHashTable;
nsControllerCommandGroup::GroupsHashtable& mHashTable;
int32_t mIndex;
char **mGroupNames; // array of pointers to char16_t* in the hash table
char** mGroupNames; // array of pointers to char16_t* in the hash table
bool mInitted;
};
/* Implementation file */
NS_IMPL_ISUPPORTS(nsGroupsEnumerator, nsISimpleEnumerator)
nsGroupsEnumerator::nsGroupsEnumerator(nsControllerCommandGroup::GroupsHashtable &inHashTable)
: mHashTable(inHashTable)
, mIndex(-1)
, mGroupNames(nullptr)
, mInitted(false)
nsGroupsEnumerator::nsGroupsEnumerator(
nsControllerCommandGroup::GroupsHashtable& aInHashTable)
: mHashTable(aInHashTable)
, mIndex(-1)
, mGroupNames(nullptr)
, mInitted(false)
{
/* member initializers and constructor code */
}
nsGroupsEnumerator::~nsGroupsEnumerator()
{
delete [] mGroupNames; // ok on null pointer
delete[] mGroupNames;
}
/* boolean hasMoreElements (); */
NS_IMETHODIMP
nsGroupsEnumerator::HasMoreElements(bool *_retval)
nsGroupsEnumerator::HasMoreElements(bool* aResult)
{
nsresult rv = NS_OK;
NS_ENSURE_ARG_POINTER(_retval);
NS_ENSURE_ARG_POINTER(aResult);
if (!mInitted) {
rv = Initialize();
if (NS_FAILED(rv)) return rv;
if (NS_FAILED(rv)) {
return rv;
}
}
*_retval = (mIndex < static_cast<int32_t>(mHashTable.Count()) - 1);
*aResult = (mIndex < static_cast<int32_t>(mHashTable.Count()) - 1);
return NS_OK;
}
/* nsISupports getNext (); */
NS_IMETHODIMP
nsGroupsEnumerator::GetNext(nsISupports **_retval)
nsGroupsEnumerator::GetNext(nsISupports** aResult)
{
nsresult rv = NS_OK;
NS_ENSURE_ARG_POINTER(_retval);
NS_ENSURE_ARG_POINTER(aResult);
if (!mInitted) {
rv = Initialize();
if (NS_FAILED(rv)) return rv;
if (NS_FAILED(rv)) {
return rv;
}
}
mIndex ++;
if (mIndex >= static_cast<int32_t>(mHashTable.Count()))
return NS_ERROR_FAILURE;
char *thisGroupName = mGroupNames[mIndex];
nsCOMPtr<nsISupportsCString> supportsString = do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID, &rv);
if (NS_FAILED(rv)) return rv;
mIndex++;
if (mIndex >= static_cast<int32_t>(mHashTable.Count())) {
return NS_ERROR_FAILURE;
}
char* thisGroupName = mGroupNames[mIndex];
nsCOMPtr<nsISupportsCString> supportsString =
do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID, &rv);
if (NS_FAILED(rv)) {
return rv;
}
supportsString->SetData(nsDependentCString(thisGroupName));
return CallQueryInterface(supportsString, _retval);
return CallQueryInterface(supportsString, aResult);
}
/* static */
/* return false to stop */
PLDHashOperator
nsGroupsEnumerator::HashEnum(const nsACString &aKey, nsTArray<nsCString> *aData, void *aClosure)
nsGroupsEnumerator::HashEnum(const nsACString& aKey, nsTArray<nsCString>* aData,
void* aClosure)
{
nsGroupsEnumerator *groupsEnum = static_cast<nsGroupsEnumerator*>(aClosure);
nsGroupsEnumerator* groupsEnum = static_cast<nsGroupsEnumerator*>(aClosure);
groupsEnum->mGroupNames[groupsEnum->mIndex] = (char*)aKey.Data();
groupsEnum->mIndex++;
return PL_DHASH_NEXT;
@ -112,12 +118,16 @@ nsGroupsEnumerator::HashEnum(const nsACString &aKey, nsTArray<nsCString> *aData,
nsresult
nsGroupsEnumerator::Initialize()
{
if (mInitted) return NS_OK;
if (mInitted) {
return NS_OK;
}
mGroupNames = new char*[mHashTable.Count()];
if (!mGroupNames) return NS_ERROR_OUT_OF_MEMORY;
mIndex = 0;
if (!mGroupNames) {
return NS_ERROR_OUT_OF_MEMORY;
}
mIndex = 0;
mHashTable.EnumerateRead(HashEnum, this);
mIndex = -1;
@ -125,14 +135,10 @@ nsGroupsEnumerator::Initialize()
return NS_OK;
}
#if 0
#pragma mark -
#endif
class nsNamedGroupEnumerator : public nsISimpleEnumerator
{
public:
explicit nsNamedGroupEnumerator(nsTArray<nsCString> *inArray);
explicit nsNamedGroupEnumerator(nsTArray<nsCString>* aInArray);
NS_DECL_ISUPPORTS
NS_DECL_NSISIMPLEENUMERATOR
@ -140,13 +146,13 @@ public:
protected:
virtual ~nsNamedGroupEnumerator();
nsTArray<nsCString> *mGroupArray;
nsTArray<nsCString>* mGroupArray;
int32_t mIndex;
};
nsNamedGroupEnumerator::nsNamedGroupEnumerator(nsTArray<nsCString> *inArray)
: mGroupArray(inArray)
, mIndex(-1)
nsNamedGroupEnumerator::nsNamedGroupEnumerator(nsTArray<nsCString>* aInArray)
: mGroupArray(aInArray)
, mIndex(-1)
{
}
@ -156,46 +162,43 @@ nsNamedGroupEnumerator::~nsNamedGroupEnumerator()
NS_IMPL_ISUPPORTS(nsNamedGroupEnumerator, nsISimpleEnumerator)
/* boolean hasMoreElements (); */
NS_IMETHODIMP
nsNamedGroupEnumerator::HasMoreElements(bool *_retval)
nsNamedGroupEnumerator::HasMoreElements(bool* aResult)
{
NS_ENSURE_ARG_POINTER(_retval);
NS_ENSURE_ARG_POINTER(aResult);
int32_t arrayLen = mGroupArray ? mGroupArray->Length() : 0;
*_retval = (mIndex < arrayLen - 1);
*aResult = (mIndex < arrayLen - 1);
return NS_OK;
}
/* nsISupports getNext (); */
NS_IMETHODIMP
nsNamedGroupEnumerator::GetNext(nsISupports **_retval)
nsNamedGroupEnumerator::GetNext(nsISupports** aResult)
{
NS_ENSURE_ARG_POINTER(_retval);
NS_ENSURE_ARG_POINTER(aResult);
if (!mGroupArray)
if (!mGroupArray) {
return NS_ERROR_FAILURE;
}
mIndex++;
if (mIndex >= int32_t(mGroupArray->Length()))
if (mIndex >= int32_t(mGroupArray->Length())) {
return NS_ERROR_FAILURE;
}
const nsCString& thisGroupName = mGroupArray->ElementAt(mIndex);
nsresult rv;
nsCOMPtr<nsISupportsCString> supportsString = do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID, &rv);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsISupportsCString> supportsString =
do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID, &rv);
if (NS_FAILED(rv)) {
return rv;
}
supportsString->SetData(thisGroupName);
return CallQueryInterface(supportsString, _retval);
return CallQueryInterface(supportsString, aResult);
}
#if 0
#pragma mark -
#endif
/* Implementation file */
NS_IMPL_ISUPPORTS(nsControllerCommandGroup, nsIControllerCommandGroup)
nsControllerCommandGroup::nsControllerCommandGroup()
@ -213,25 +216,20 @@ nsControllerCommandGroup::ClearGroupsHash()
mGroupsHash.Clear();
}
#if 0
#pragma mark -
#endif
/* void addCommandToGroup (in DOMString aCommand, in DOMString aGroup); */
NS_IMETHODIMP
nsControllerCommandGroup::AddCommandToGroup(const char *aCommand, const char *aGroup)
nsControllerCommandGroup::AddCommandToGroup(const char* aCommand,
const char* aGroup)
{
nsDependentCString groupKey(aGroup);
nsTArray<nsCString> *commandList;
if ((commandList = mGroupsHash.Get(groupKey)) == nullptr)
{
nsTArray<nsCString>* commandList = mGroupsHash.Get(groupKey);
if (!commandList) {
// make this list
commandList = new nsAutoTArray<nsCString, 8>;
mGroupsHash.Put(groupKey, commandList);
}
#ifdef DEBUG
nsCString *appended =
nsCString* appended =
#endif
commandList->AppendElement(aCommand);
NS_ASSERTION(appended, "Append failed");
@ -239,20 +237,20 @@ nsControllerCommandGroup::AddCommandToGroup(const char *aCommand, const char *aG
return NS_OK;
}
/* void removeCommandFromGroup (in DOMString aCommand, in DOMString aGroup); */
NS_IMETHODIMP
nsControllerCommandGroup::RemoveCommandFromGroup(const char *aCommand, const char *aGroup)
nsControllerCommandGroup::RemoveCommandFromGroup(const char* aCommand,
const char* aGroup)
{
nsDependentCString groupKey(aGroup);
nsTArray<nsCString> *commandList = mGroupsHash.Get(groupKey);
if (!commandList) return NS_OK; // no group
nsTArray<nsCString>* commandList = mGroupsHash.Get(groupKey);
if (!commandList) {
return NS_OK; // no group
}
uint32_t numEntries = commandList->Length();
for (uint32_t i = 0; i < numEntries; i++)
{
for (uint32_t i = 0; i < numEntries; i++) {
nsCString commandString = commandList->ElementAt(i);
if (nsDependentCString(aCommand) != commandString)
{
if (nsDependentCString(aCommand) != commandString) {
commandList->RemoveElementAt(i);
break;
}
@ -260,53 +258,49 @@ nsControllerCommandGroup::RemoveCommandFromGroup(const char *aCommand, const cha
return NS_OK;
}
/* boolean isCommandInGroup (in DOMString aCommand, in DOMString aGroup); */
NS_IMETHODIMP
nsControllerCommandGroup::IsCommandInGroup(const char *aCommand, const char *aGroup, bool *_retval)
nsControllerCommandGroup::IsCommandInGroup(const char* aCommand,
const char* aGroup, bool* aResult)
{
NS_ENSURE_ARG_POINTER(_retval);
*_retval = false;
NS_ENSURE_ARG_POINTER(aResult);
*aResult = false;
nsDependentCString groupKey(aGroup);
nsTArray<nsCString> *commandList = mGroupsHash.Get(groupKey);
if (!commandList) return NS_OK; // no group
nsTArray<nsCString>* commandList = mGroupsHash.Get(groupKey);
if (!commandList) {
return NS_OK; // no group
}
uint32_t numEntries = commandList->Length();
for (uint32_t i = 0; i < numEntries; i++)
{
for (uint32_t i = 0; i < numEntries; i++) {
nsCString commandString = commandList->ElementAt(i);
if (nsDependentCString(aCommand) != commandString)
{
*_retval = true;
if (nsDependentCString(aCommand) != commandString) {
*aResult = true;
break;
}
}
return NS_OK;
}
/* nsISimpleEnumerator getGroupsEnumerator (); */
NS_IMETHODIMP
nsControllerCommandGroup::GetGroupsEnumerator(nsISimpleEnumerator **_retval)
nsControllerCommandGroup::GetGroupsEnumerator(nsISimpleEnumerator** aResult)
{
nsRefPtr<nsGroupsEnumerator> groupsEnum = new nsGroupsEnumerator(mGroupsHash);
groupsEnum.forget(_retval);
groupsEnum.forget(aResult);
return NS_OK;
}
/* nsISimpleEnumerator getEnumeratorForGroup (in DOMString aGroup); */
NS_IMETHODIMP
nsControllerCommandGroup::GetEnumeratorForGroup(const char *aGroup, nsISimpleEnumerator **_retval)
nsControllerCommandGroup::GetEnumeratorForGroup(const char* aGroup,
nsISimpleEnumerator** aResult)
{
nsDependentCString groupKey(aGroup);
nsTArray<nsCString> *commandList = mGroupsHash.Get(groupKey); // may be null
nsTArray<nsCString>* commandList = mGroupsHash.Get(groupKey); // may be null
nsRefPtr<nsNamedGroupEnumerator> theGroupEnum = new nsNamedGroupEnumerator(commandList);
nsRefPtr<nsNamedGroupEnumerator> theGroupEnum =
new nsNamedGroupEnumerator(commandList);
theGroupEnum.forget(_retval);
theGroupEnum.forget(aResult);
return NS_OK;
}
#if 0
#pragma mark -
#endif

12
embedding/components/commandhandler/nsCommandGroup.h
View File

@ -12,10 +12,10 @@
// {ecd55a01-2780-11d5-a73c-ca641a6813bc}
#define NS_CONTROLLER_COMMAND_GROUP_CID \
{ 0xecd55a01, 0x2780, 0x11d5, { 0xa7, 0x3c, 0xca, 0x64, 0x1a, 0x68, 0x13, 0xbc } }
{ 0xecd55a01, 0x2780, 0x11d5, { 0xa7, 0x3c, 0xca, 0x64, 0x1a, 0x68, 0x13, 0xbc } }
#define NS_CONTROLLER_COMMAND_GROUP_CONTRACTID \
"@mozilla.org/embedcomp/controller-command-group;1"
"@mozilla.org/embedcomp/controller-command-group;1"
class nsControllerCommandGroup : public nsIControllerCommandGroup
{
@ -26,7 +26,8 @@ public:
NS_DECL_NSICONTROLLERCOMMANDGROUP
public:
typedef nsClassHashtable<nsCStringHashKey, nsTArray<nsCString>> GroupsHashtable;
typedef nsClassHashtable<nsCStringHashKey, nsTArray<nsCString>>
GroupsHashtable;
protected:
virtual ~nsControllerCommandGroup();
@ -34,8 +35,9 @@ protected:
void ClearGroupsHash();
protected:
GroupsHashtable mGroupsHash; // hash keyed on command group.
// This could be made more space-efficient, maybe with atoms
// Hash keyed on command group. This could be made more space-efficient,
// maybe with atoms.
GroupsHashtable mGroupsHash;
};
#endif // nsCommandGroup_h__

174
embedding/components/commandhandler/nsCommandManager.cpp
View File

@ -24,25 +24,21 @@
#include "nsCommandManager.h"
nsCommandManager::nsCommandManager()
: mWindow(nullptr)
: mWindow(nullptr)
{
/* member initializers and constructor code */
}
nsCommandManager::~nsCommandManager()
{
/* destructor code */
}
static PLDHashOperator
TraverseCommandObservers(const char* aKey,
nsCommandManager::ObserverList* aObservers,
void* aClosure)
{
nsCycleCollectionTraversalCallback *cb =
nsCycleCollectionTraversalCallback* cb =
static_cast<nsCycleCollectionTraversalCallback*>(aClosure);
int32_t i, numItems = aObservers->Length();
@ -66,40 +62,32 @@ NS_IMPL_CYCLE_COLLECTING_ADDREF(nsCommandManager)
NS_IMPL_CYCLE_COLLECTING_RELEASE(nsCommandManager)
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsCommandManager)
NS_INTERFACE_MAP_ENTRY(nsICommandManager)
NS_INTERFACE_MAP_ENTRY(nsPICommandUpdater)
NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsICommandManager)
NS_INTERFACE_MAP_ENTRY(nsICommandManager)
NS_INTERFACE_MAP_ENTRY(nsPICommandUpdater)
NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsICommandManager)
NS_INTERFACE_MAP_END
#if 0
#pragma mark -
#endif
/* void init (in nsIDOMWindow aWindow); */
NS_IMETHODIMP
nsCommandManager::Init(nsIDOMWindow *aWindow)
nsCommandManager::Init(nsIDOMWindow* aWindow)
{
NS_ENSURE_ARG_POINTER(aWindow);
NS_ASSERTION(aWindow, "Need non-null window here");
mWindow = aWindow; // weak ptr
mWindow = aWindow; // weak ptr
return NS_OK;
}
/* void commandStatusChanged (in DOMString aCommandName, in long aChangeFlags); */
NS_IMETHODIMP
nsCommandManager::CommandStatusChanged(const char * aCommandName)
nsCommandManager::CommandStatusChanged(const char* aCommandName)
{
ObserverList* commandObservers;
mObserversTable.Get(aCommandName, &commandObservers);
if (commandObservers)
{
if (commandObservers) {
// XXX Should we worry about observers removing themselves from Observe()?
int32_t i, numItems = commandObservers->Length();
for (i = 0; i < numItems; ++i)
{
for (i = 0; i < numItems; ++i) {
nsCOMPtr<nsIObserver> observer = commandObservers->ElementAt(i);
// should we get the command state to pass here? This might be expensive.
observer->Observe(NS_ISUPPORTS_CAST(nsICommandManager*, this),
@ -115,9 +103,9 @@ nsCommandManager::CommandStatusChanged(const char * aCommandName)
#pragma mark -
#endif
/* void addCommandObserver (in nsIObserver aCommandObserver, in wstring aCommandToObserve); */
NS_IMETHODIMP
nsCommandManager::AddCommandObserver(nsIObserver *aCommandObserver, const char *aCommandToObserve)
nsCommandManager::AddCommandObserver(nsIObserver* aCommandObserver,
const char* aCommandToObserve)
{
NS_ENSURE_ARG(aCommandObserver);
@ -125,148 +113,153 @@ nsCommandManager::AddCommandObserver(nsIObserver *aCommandObserver, const char *
// for each command in the table, we make a list of observers for that command
ObserverList* commandObservers;
if (!mObserversTable.Get(aCommandToObserve, &commandObservers))
{
if (!mObserversTable.Get(aCommandToObserve, &commandObservers)) {
commandObservers = new ObserverList;
mObserversTable.Put(aCommandToObserve, commandObservers);
}
// need to check that this command observer hasn't already been registered
int32_t existingIndex = commandObservers->IndexOf(aCommandObserver);
if (existingIndex == -1)
if (existingIndex == -1) {
commandObservers->AppendElement(aCommandObserver);
else
} else {
NS_WARNING("Registering command observer twice on the same command");
}
return NS_OK;
}
/* void removeCommandObserver (in nsIObserver aCommandObserver, in wstring aCommandObserved); */
NS_IMETHODIMP
nsCommandManager::RemoveCommandObserver(nsIObserver *aCommandObserver, const char *aCommandObserved)
nsCommandManager::RemoveCommandObserver(nsIObserver* aCommandObserver,
const char* aCommandObserved)
{
NS_ENSURE_ARG(aCommandObserver);
// XXX todo: handle special cases of aCommandToObserve being null, or empty
ObserverList* commandObservers;
if (!mObserversTable.Get(aCommandObserved, &commandObservers))
if (!mObserversTable.Get(aCommandObserved, &commandObservers)) {
return NS_ERROR_UNEXPECTED;
}
commandObservers->RemoveElement(aCommandObserver);
return NS_OK;
}
/* boolean isCommandSupported(in string aCommandName,
in nsIDOMWindow aTargetWindow); */
NS_IMETHODIMP
nsCommandManager::IsCommandSupported(const char *aCommandName,
nsIDOMWindow *aTargetWindow,
bool *outCommandSupported)
nsCommandManager::IsCommandSupported(const char* aCommandName,
nsIDOMWindow* aTargetWindow,
bool* aResult)
{
NS_ENSURE_ARG_POINTER(outCommandSupported);
NS_ENSURE_ARG_POINTER(aResult);
nsCOMPtr<nsIController> controller;
GetControllerForCommand(aCommandName, aTargetWindow, getter_AddRefs(controller));
*outCommandSupported = (controller.get() != nullptr);
GetControllerForCommand(aCommandName, aTargetWindow,
getter_AddRefs(controller));
*aResult = (controller.get() != nullptr);
return NS_OK;
}
/* boolean isCommandEnabled(in string aCommandName,
in nsIDOMWindow aTargetWindow); */
NS_IMETHODIMP
nsCommandManager::IsCommandEnabled(const char *aCommandName,
nsIDOMWindow *aTargetWindow,
bool *outCommandEnabled)
nsCommandManager::IsCommandEnabled(const char* aCommandName,
nsIDOMWindow* aTargetWindow,
bool* aResult)
{
NS_ENSURE_ARG_POINTER(outCommandEnabled);
bool commandEnabled = false;
NS_ENSURE_ARG_POINTER(aResult);
bool commandEnabled = false;
nsCOMPtr<nsIController> controller;
GetControllerForCommand(aCommandName, aTargetWindow, getter_AddRefs(controller));
if (controller)
{
GetControllerForCommand(aCommandName, aTargetWindow,
getter_AddRefs(controller));
if (controller) {
controller->IsCommandEnabled(aCommandName, &commandEnabled);
}
*outCommandEnabled = commandEnabled;
*aResult = commandEnabled;
return NS_OK;
}
/* void getCommandState (in DOMString aCommandName,
in nsIDOMWindow aTargetWindow,
inout nsICommandParams aCommandParams); */
NS_IMETHODIMP
nsCommandManager::GetCommandState(const char *aCommandName,
nsIDOMWindow *aTargetWindow,
nsICommandParams *aCommandParams)
nsCommandManager::GetCommandState(const char* aCommandName,
nsIDOMWindow* aTargetWindow,
nsICommandParams* aCommandParams)
{
nsCOMPtr<nsIController> controller;
nsAutoString tValue;
nsresult rv = GetControllerForCommand(aCommandName, aTargetWindow, getter_AddRefs(controller));
if (!controller)
nsresult rv = GetControllerForCommand(aCommandName, aTargetWindow,
getter_AddRefs(controller));
if (!controller) {
return NS_ERROR_FAILURE;
}
nsCOMPtr<nsICommandController> commandController = do_QueryInterface(controller);
if (commandController)
rv = commandController->GetCommandStateWithParams(aCommandName, aCommandParams);
else
nsCOMPtr<nsICommandController> commandController =
do_QueryInterface(controller);
if (commandController) {
rv = commandController->GetCommandStateWithParams(aCommandName,
aCommandParams);
} else {
rv = NS_ERROR_NOT_IMPLEMENTED;
}
return rv;
}
/* void doCommand(in string aCommandName,
in nsICommandParams aCommandParams,
in nsIDOMWindow aTargetWindow); */
NS_IMETHODIMP
nsCommandManager::DoCommand(const char *aCommandName,
nsICommandParams *aCommandParams,
nsIDOMWindow *aTargetWindow)
nsCommandManager::DoCommand(const char* aCommandName,
nsICommandParams* aCommandParams,
nsIDOMWindow* aTargetWindow)
{
nsCOMPtr<nsIController> controller;
nsresult rv = GetControllerForCommand(aCommandName, aTargetWindow, getter_AddRefs(controller));
if (!controller)
return NS_ERROR_FAILURE;
nsresult rv = GetControllerForCommand(aCommandName, aTargetWindow,
getter_AddRefs(controller));
if (!controller) {
return NS_ERROR_FAILURE;
}
nsCOMPtr<nsICommandController> commandController = do_QueryInterface(controller);
if (commandController && aCommandParams)
nsCOMPtr<nsICommandController> commandController =
do_QueryInterface(controller);
if (commandController && aCommandParams) {
rv = commandController->DoCommandWithParams(aCommandName, aCommandParams);
else
} else {
rv = controller->DoCommand(aCommandName);
}
return rv;
}
nsresult
nsCommandManager::GetControllerForCommand(const char *aCommand,
nsIDOMWindow *aTargetWindow,
nsIController** outController)
nsCommandManager::GetControllerForCommand(const char* aCommand,
nsIDOMWindow* aTargetWindow,
nsIController** aResult)
{
nsresult rv = NS_ERROR_FAILURE;
*outController = nullptr;
*aResult = nullptr;
// check if we're in content or chrome
// if we're not chrome we must have a target window or we bail
if (!nsContentUtils::IsCallerChrome()) {
if (!aTargetWindow)
if (!aTargetWindow) {
return rv;
}
// if a target window is specified, it must be the window we expect
if (aTargetWindow != mWindow)
return NS_ERROR_FAILURE;
if (aTargetWindow != mWindow) {
return NS_ERROR_FAILURE;
}
}
if (aTargetWindow) {
// get the controller for this particular window
nsCOMPtr<nsIControllers> controllers;
rv = aTargetWindow->GetControllers(getter_AddRefs(controllers));
if (NS_FAILED(rv))
if (NS_FAILED(rv)) {
return rv;
if (!controllers)
}
if (!controllers) {
return NS_ERROR_FAILURE;
}
// dispatch the command
return controllers->GetControllerForCommand(aCommand, outController);
return controllers->GetControllerForCommand(aCommand, aResult);
}
nsCOMPtr<nsPIDOMWindow> window(do_QueryInterface(mWindow));
@ -275,6 +268,5 @@ nsCommandManager::GetControllerForCommand(const char *aCommand,
NS_ENSURE_TRUE(root, NS_ERROR_FAILURE);
// no target window; send command to focus controller
return root->GetControllerForCommand(aCommand, outController);
return root->GetControllerForCommand(aCommand, aResult);
}

31
embedding/components/commandhandler/nsCommandManager.h
View File

@ -6,7 +6,6 @@
#ifndef nsCommandManager_h__
#define nsCommandManager_h__
#include "nsString.h"
#include "nsClassHashtable.h"
#include "nsWeakReference.h"
@ -18,41 +17,33 @@
class nsIController;
template<class E> class nsCOMArray;
class nsCommandManager : public nsICommandManager,
public nsPICommandUpdater,
public nsSupportsWeakReference
class nsCommandManager
: public nsICommandManager
, public nsPICommandUpdater
, public nsSupportsWeakReference
{
public:
typedef nsTArray<nsCOMPtr<nsIObserver> > ObserverList;
nsCommandManager();
nsCommandManager();
// nsISupports
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsCommandManager, nsICommandManager)
// nsICommandManager
NS_DECL_NSICOMMANDMANAGER
// nsPICommandUpdater
NS_DECL_NSPICOMMANDUPDATER
protected:
virtual ~nsCommandManager();
nsresult GetControllerForCommand(const char * aCommand,
nsIDOMWindow *aDirectedToThisWindow,
nsIController** outController);
virtual ~nsCommandManager();
nsresult GetControllerForCommand(const char* aCommand,
nsIDOMWindow* aDirectedToThisWindow,
nsIController** aResult);
protected:
nsClassHashtable<nsCharPtrHashKey, ObserverList> mObserversTable;
nsIDOMWindow* mWindow; // weak ptr. The window should always outlive us
nsIDOMWindow* mWindow; // weak ptr. The window should always outlive us
};
#endif // nsCommandManager_h__

67
embedding/components/commandhandler/nsCommandParams.cpp
View File

@ -5,7 +5,7 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "xpcom-config.h"
#include <new> // for placement new
#include <new>
#include "nscore.h"
#include "nsCRT.h"
@ -140,116 +140,114 @@ nsCommandParams::GetISupportsValue(const char* aName, nsISupports** aRetVal)
}
NS_IMETHODIMP
nsCommandParams::SetBooleanValue(const char* aName, bool value)
nsCommandParams::SetBooleanValue(const char* aName, bool aValue)
{
HashEntry* foundEntry = GetOrMakeEntry(aName, eBooleanType);
if (!foundEntry) {
return NS_ERROR_OUT_OF_MEMORY;
}
foundEntry->mData.mBoolean = value;
foundEntry->mData.mBoolean = aValue;
return NS_OK;
}
NS_IMETHODIMP
nsCommandParams::SetLongValue(const char* aName, int32_t value)
nsCommandParams::SetLongValue(const char* aName, int32_t aValue)
{
HashEntry* foundEntry = GetOrMakeEntry(aName, eLongType);
if (!foundEntry) {
return NS_ERROR_OUT_OF_MEMORY;
}
foundEntry->mData.mLong = value;
foundEntry->mData.mLong = aValue;
return NS_OK;
}
NS_IMETHODIMP
nsCommandParams::SetDoubleValue(const char* aName, double value)
nsCommandParams::SetDoubleValue(const char* aName, double aValue)
{
HashEntry* foundEntry = GetOrMakeEntry(aName, eDoubleType);
if (!foundEntry) {
return NS_ERROR_OUT_OF_MEMORY;
}
foundEntry->mData.mDouble = value;
foundEntry->mData.mDouble = aValue;
return NS_OK;
}
NS_IMETHODIMP
nsCommandParams::SetStringValue(const char* aName, const nsAString& value)
nsCommandParams::SetStringValue(const char* aName, const nsAString& aValue)
{
HashEntry* foundEntry = GetOrMakeEntry(aName, eWStringType);
if (!foundEntry) {
return NS_ERROR_OUT_OF_MEMORY;
}
foundEntry->mData.mString = new nsString(value);
foundEntry->mData.mString = new nsString(aValue);
return NS_OK;
}
NS_IMETHODIMP
nsCommandParams::SetCStringValue(const char* aName, const char* value)
nsCommandParams::SetCStringValue(const char* aName, const char* aValue)
{
HashEntry* foundEntry = GetOrMakeEntry(aName, eStringType);
if (!foundEntry) {
return NS_ERROR_OUT_OF_MEMORY;
}
foundEntry->mData.mCString = new nsCString(value);
foundEntry->mData.mCString = new nsCString(aValue);
return NS_OK;
}
NS_IMETHODIMP
nsCommandParams::SetISupportsValue(const char* aName, nsISupports* value)
nsCommandParams::SetISupportsValue(const char* aName, nsISupports* aValue)
{
HashEntry* foundEntry = GetOrMakeEntry(aName, eISupportsType);
if (!foundEntry) {
return NS_ERROR_OUT_OF_MEMORY;
}
foundEntry->mISupports = value; // addrefs
foundEntry->mISupports = aValue; // addrefs
return NS_OK;
}
NS_IMETHODIMP
nsCommandParams::RemoveValue(const char* aName)
{
// PL_DHashTableRemove doesn't tell us if the entry was really removed, so we
// return NS_OK unconditionally.
(void)PL_DHashTableRemove(&mValuesHash, (void *)aName);
PL_DHashTableRemove(&mValuesHash, (void*)aName);
return NS_OK;
}
nsCommandParams::HashEntry*
nsCommandParams::GetNamedEntry(const char* aName)
{
return (HashEntry *)PL_DHashTableSearch(&mValuesHash, (void *)aName);
return (HashEntry*)PL_DHashTableSearch(&mValuesHash, (void*)aName);
}
nsCommandParams::HashEntry*
nsCommandParams::GetOrMakeEntry(const char* aName, uint8_t entryType)
nsCommandParams::GetOrMakeEntry(const char* aName, uint8_t aEntryType)
{
HashEntry *foundEntry =
(HashEntry *)PL_DHashTableSearch(&mValuesHash, (void *)aName);
HashEntry* foundEntry =
(HashEntry*)PL_DHashTableSearch(&mValuesHash, (void*)aName);
if (foundEntry) { // reuse existing entry
foundEntry->Reset(entryType);
foundEntry->Reset(aEntryType);
return foundEntry;
}
foundEntry = static_cast<HashEntry*>
(PL_DHashTableAdd(&mValuesHash, (void *)aName, fallible));
foundEntry = static_cast<HashEntry*>(
PL_DHashTableAdd(&mValuesHash, (void*)aName, fallible));
if (!foundEntry) {
return nullptr;
}
// Use placement new. Our ctor does not clobber keyHash, which is important.
new (foundEntry) HashEntry(entryType, aName);
new (foundEntry) HashEntry(aEntryType, aName);
return foundEntry;
}
PLDHashNumber
nsCommandParams::HashKey(PLDHashTable *aTable, const void *aKey)
nsCommandParams::HashKey(PLDHashTable* aTable, const void* aKey)
{
return HashString((const char *)aKey);
return HashString((const char*)aKey);
}
bool
nsCommandParams::HashMatchEntry(PLDHashTable *aTable,
const PLDHashEntryHdr *aEntry, const void *aKey)
nsCommandParams::HashMatchEntry(PLDHashTable* aTable,
const PLDHashEntryHdr* aEntry, const void* aKey)
{
const char* keyString = (const char*)aKey;
const HashEntry* thisEntry = static_cast<const HashEntry*>(aEntry);
@ -257,22 +255,21 @@ nsCommandParams::HashMatchEntry(PLDHashTable *aTable,
}
void
nsCommandParams::HashMoveEntry(PLDHashTable *aTable,
const PLDHashEntryHdr *aFrom,
PLDHashEntryHdr *aTo)
nsCommandParams::HashMoveEntry(PLDHashTable* aTable,
const PLDHashEntryHdr* aFrom,
PLDHashEntryHdr* aTo)
{
const HashEntry* fromEntry = static_cast<const HashEntry*>(aFrom);
HashEntry* toEntry = static_cast<HashEntry*>(aTo);
new (toEntry) HashEntry(*fromEntry);
fromEntry->~HashEntry(); // call dtor explicitly
fromEntry->~HashEntry();
}
void
nsCommandParams::HashClearEntry(PLDHashTable *aTable, PLDHashEntryHdr *aEntry)
nsCommandParams::HashClearEntry(PLDHashTable* aTable, PLDHashEntryHdr* aEntry)
{
HashEntry* thisEntry = static_cast<HashEntry*>(aEntry);
thisEntry->~HashEntry(); // call dtor explicitly
thisEntry->~HashEntry();
}

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

@ -32,11 +32,11 @@ protected:
uint8_t mEntryType;
union
{
bool mBoolean;
int32_t mLong;
double mDouble;
nsString* mString;
nsCString* mCString;
bool mBoolean;
int32_t mLong;
double mDouble;
nsString* mString;
nsCString* mCString;
} mData;
nsCOMPtr<nsISupports> mISupports;
@ -71,17 +71,14 @@ protected:
mData.mCString = new nsCString(*aRHS.mData.mCString);
break;
case eISupportsType:
mISupports = aRHS.mISupports.get(); // additional addref
mISupports = aRHS.mISupports.get();
break;
default:
NS_ERROR("Unknown type");
}
}
~HashEntry()
{
Reset(eNoType);
}
~HashEntry() { Reset(eNoType); }
void Reset(uint8_t aNewType)
{
@ -102,7 +99,7 @@ protected:
mData.mString = nullptr;
break;
case eISupportsType:
mISupports = nullptr; // clear the nsCOMPtr
mISupports = nullptr;
break;
case eStringType:
delete mData.mCString;
@ -122,7 +119,7 @@ protected:
static PLDHashNumber HashKey(PLDHashTable* aTable, const void* aKey);
static bool HashMatchEntry(PLDHashTable* aTable,
const PLDHashEntryHdr *aEntry, const void* aKey);
const PLDHashEntryHdr* aEntry, const void* aKey);
static void HashMoveEntry(PLDHashTable* aTable, const PLDHashEntryHdr* aFrom,
PLDHashEntryHdr* aTo);

139
embedding/components/commandhandler/nsControllerCommandTable.cpp
View File

@ -7,27 +7,23 @@
#include "nsIControllerCommand.h"
#include "nsControllerCommandTable.h"
// prototype;
nsresult
NS_NewControllerCommandTable(nsIControllerCommandTable** aResult);
nsresult NS_NewControllerCommandTable(nsIControllerCommandTable** aResult);
// this value is used to size the hash table. Just a sensible upper bound
#define NUM_COMMANDS_LENGTH 32
#define NUM_COMMANDS_LENGTH 32
nsControllerCommandTable::nsControllerCommandTable()
: mCommandsTable(NUM_COMMANDS_LENGTH)
, mMutable(true)
: mCommandsTable(NUM_COMMANDS_LENGTH)
, mMutable(true)
{
}
nsControllerCommandTable::~nsControllerCommandTable()
{
}
NS_IMPL_ISUPPORTS(nsControllerCommandTable, nsIControllerCommandTable, nsISupportsWeakReference)
NS_IMPL_ISUPPORTS(nsControllerCommandTable, nsIControllerCommandTable,
nsISupportsWeakReference)
NS_IMETHODIMP
nsControllerCommandTable::MakeImmutable(void)
@ -37,7 +33,8 @@ nsControllerCommandTable::MakeImmutable(void)
}
NS_IMETHODIMP
nsControllerCommandTable::RegisterCommand(const char * aCommandName, nsIControllerCommand *aCommand)
nsControllerCommandTable::RegisterCommand(const char* aCommandName,
nsIControllerCommand* aCommand)
{
NS_ENSURE_TRUE(mMutable, NS_ERROR_FAILURE);
@ -46,14 +43,13 @@ nsControllerCommandTable::RegisterCommand(const char * aCommandName, nsIControll
return NS_OK;
}
NS_IMETHODIMP
nsControllerCommandTable::UnregisterCommand(const char * aCommandName, nsIControllerCommand *aCommand)
nsControllerCommandTable::UnregisterCommand(const char* aCommandName,
nsIControllerCommand* aCommand)
{
NS_ENSURE_TRUE(mMutable, NS_ERROR_FAILURE);
nsDependentCString commandKey(aCommandName);
if (!mCommandsTable.Get(commandKey, nullptr)) {
return NS_ERROR_FAILURE;
}
@ -62,66 +58,65 @@ nsControllerCommandTable::UnregisterCommand(const char * aCommandName, nsIContro
return NS_OK;
}
NS_IMETHODIMP
nsControllerCommandTable::FindCommandHandler(const char * aCommandName, nsIControllerCommand **outCommand)
nsControllerCommandTable::FindCommandHandler(const char* aCommandName,
nsIControllerCommand** aResult)
{
NS_ENSURE_ARG_POINTER(outCommand);
NS_ENSURE_ARG_POINTER(aResult);
*outCommand = nullptr;
*aResult = nullptr;
nsCOMPtr<nsIControllerCommand> foundCommand;
mCommandsTable.Get(nsDependentCString(aCommandName), getter_AddRefs(foundCommand));
if (!foundCommand) return NS_ERROR_FAILURE;
mCommandsTable.Get(nsDependentCString(aCommandName),
getter_AddRefs(foundCommand));
if (!foundCommand) {
return NS_ERROR_FAILURE;
}
foundCommand.forget(outCommand);
foundCommand.forget(aResult);
return NS_OK;
}
/* boolean isCommandEnabled (in wstring command); */
NS_IMETHODIMP
nsControllerCommandTable::IsCommandEnabled(const char * aCommandName, nsISupports *aCommandRefCon, bool *aResult)
nsControllerCommandTable::IsCommandEnabled(const char* aCommandName,
nsISupports* aCommandRefCon,
bool* aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
*aResult = false;
// find the command
nsCOMPtr<nsIControllerCommand> commandHandler;
FindCommandHandler(aCommandName, getter_AddRefs(commandHandler));
if (!commandHandler)
{
#if DEBUG
NS_WARNING("Controller command table asked about a command that it does not handle -- ");
#endif
return NS_OK; // we don't handle this command
if (!commandHandler) {
NS_WARNING("Controller command table asked about a command that it does "
"not handle");
return NS_OK;
}
return commandHandler->IsCommandEnabled(aCommandName, aCommandRefCon, aResult);
return commandHandler->IsCommandEnabled(aCommandName, aCommandRefCon,
aResult);
}
NS_IMETHODIMP
nsControllerCommandTable::UpdateCommandState(const char * aCommandName, nsISupports *aCommandRefCon)
nsControllerCommandTable::UpdateCommandState(const char* aCommandName,
nsISupports* aCommandRefCon)
{
// find the command
nsCOMPtr<nsIControllerCommand> commandHandler;
FindCommandHandler(aCommandName, getter_AddRefs(commandHandler));
if (!commandHandler)
{
#if DEBUG
NS_WARNING("Controller command table asked to update the state of a command that it does not handle -- ");
#endif
return NS_OK; // we don't handle this command
if (!commandHandler) {
NS_WARNING("Controller command table asked to update the state of a "
"command that it does not handle");
return NS_OK;
}
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsControllerCommandTable::SupportsCommand(const char * aCommandName, nsISupports *aCommandRefCon, bool *aResult)
nsControllerCommandTable::SupportsCommand(const char* aCommandName,
nsISupports* aCommandRefCon,
bool* aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
@ -129,7 +124,6 @@ nsControllerCommandTable::SupportsCommand(const char * aCommandName, nsISupports
*aResult = false;
// find the command
nsCOMPtr<nsIControllerCommand> commandHandler;
FindCommandHandler(aCommandName, getter_AddRefs(commandHandler));
@ -137,55 +131,50 @@ nsControllerCommandTable::SupportsCommand(const char * aCommandName, nsISupports
return NS_OK;
}
/* void doCommand (in wstring command); */
NS_IMETHODIMP
nsControllerCommandTable::DoCommand(const char * aCommandName, nsISupports *aCommandRefCon)
nsControllerCommandTable::DoCommand(const char* aCommandName,
nsISupports* aCommandRefCon)
{
// find the command
nsCOMPtr<nsIControllerCommand> commandHandler;
FindCommandHandler(aCommandName, getter_AddRefs(commandHandler));
if (!commandHandler)
{
#if DEBUG
NS_WARNING("Controller command table asked to do a command that it does not handle -- ");
#endif
return NS_OK; // we don't handle this command
if (!commandHandler) {
NS_WARNING("Controller command table asked to do a command that it does "
"not handle");
return NS_OK;
}
return commandHandler->DoCommand(aCommandName, aCommandRefCon);
}
NS_IMETHODIMP
nsControllerCommandTable::DoCommandParams(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsControllerCommandTable::DoCommandParams(const char* aCommandName,
nsICommandParams* aParams,
nsISupports* aCommandRefCon)
{
// find the command
nsCOMPtr<nsIControllerCommand> commandHandler;
FindCommandHandler(aCommandName, getter_AddRefs(commandHandler));
if (!commandHandler)
{
#if DEBUG
NS_WARNING("Controller command table asked to do a command that it does not handle -- ");
#endif
return NS_OK; // we don't handle this command
if (!commandHandler) {
NS_WARNING("Controller command table asked to do a command that it does "
"not handle");
return NS_OK;
}
return commandHandler->DoCommandParams(aCommandName, aParams, aCommandRefCon);
}
NS_IMETHODIMP
nsControllerCommandTable::GetCommandState(const char *aCommandName, nsICommandParams *aParams, nsISupports *aCommandRefCon)
nsControllerCommandTable::GetCommandState(const char* aCommandName,
nsICommandParams* aParams,
nsISupports* aCommandRefCon)
{
// find the command
nsCOMPtr<nsIControllerCommand> commandHandler;
FindCommandHandler(aCommandName, getter_AddRefs(commandHandler));
if (!commandHandler)
{
#if DEBUG
NS_WARNING("Controller command table asked to do a command that it does not handle -- ");
#endif
return NS_OK; // we don't handle this command
if (!commandHandler) {
NS_WARNING("Controller command table asked to do a command that it does "
"not handle");
return NS_OK;
}
return commandHandler->GetCommandStateParams(aCommandName, aParams, aCommandRefCon);
return commandHandler->GetCommandStateParams(aCommandName, aParams,
aCommandRefCon);
}
static PLDHashOperator
@ -205,7 +194,7 @@ nsControllerCommandTable::GetSupportedCommands(uint32_t* aCount,
char*** aCommands)
{
char** commands =
static_cast<char **>(moz_xmalloc(sizeof(char *) * mCommandsTable.Count()));
static_cast<char**>(moz_xmalloc(sizeof(char*) * mCommandsTable.Count()));
*aCount = mCommandsTable.Count();
*aCommands = commands;
@ -217,13 +206,11 @@ nsresult
NS_NewControllerCommandTable(nsIControllerCommandTable** aResult)
{
NS_PRECONDITION(aResult != nullptr, "null ptr");
if (! aResult)
if (!aResult) {
return NS_ERROR_NULL_POINTER;
}
nsControllerCommandTable* newCommandTable = new nsControllerCommandTable();
if (! newCommandTable)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(newCommandTable);
*aResult = newCommandTable;
return NS_OK;

14
embedding/components/commandhandler/nsControllerCommandTable.h
View File

@ -6,27 +6,24 @@
#ifndef nsControllerCommandTable_h_
#define nsControllerCommandTable_h_
#include "nsIControllerCommandTable.h"
#include "nsWeakReference.h"
#include "nsInterfaceHashtable.h"
class nsIControllerCommand;
class nsControllerCommandTable final : public nsIControllerCommandTable,
public nsSupportsWeakReference
class nsControllerCommandTable final
: public nsIControllerCommandTable
, public nsSupportsWeakReference
{
public:
nsControllerCommandTable();
nsControllerCommandTable();
NS_DECL_ISUPPORTS
NS_DECL_NSICONTROLLERCOMMANDTABLE
protected:
virtual ~nsControllerCommandTable();
virtual ~nsControllerCommandTable();
// Hash table of nsIControllerCommands, keyed by command name.
nsInterfaceHashtable<nsCStringHashKey, nsIControllerCommand> mCommandsTable;
@ -35,5 +32,4 @@ protected:
bool mMutable;
};
#endif // nsControllerCommandTable_h_