dom/commandhandler/nsControllerCommandTable.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "nsString.h"
   8 #include "nsIControllerCommand.h"
   9 #include "nsControllerCommandTable.h"
  10 #include "nsGlobalWindowCommands.h"
  11 #include "mozilla/EditorController.h"
  12 #include "mozilla/HTMLEditorController.h"
  13
  14 // this value is used to size the hash table. Just a sensible upper bound
  15 #define NUM_COMMANDS_LENGTH 32
  16
  17 nsControllerCommandTable::nsControllerCommandTable()
  18     : mCommandsTable(NUM_COMMANDS_LENGTH), mMutable(true) {}
  19
  20 nsControllerCommandTable::~nsControllerCommandTable() = default;
  21
  22 NS_IMPL_ISUPPORTS(nsControllerCommandTable, nsIControllerCommandTable,
  23                   nsISupportsWeakReference)
  24
  25 NS_IMETHODIMP
  26 nsControllerCommandTable::MakeImmutable(void) {
  27   mMutable = false;
  28   return NS_OK;
  29 }
  30
  31 NS_IMETHODIMP
  32 nsControllerCommandTable::RegisterCommand(const char* aCommandName,
  33                                           nsIControllerCommand* aCommand) {
  34   NS_ENSURE_TRUE(mMutable, NS_ERROR_FAILURE);
  35
  36   mCommandsTable.InsertOrUpdate(nsDependentCString(aCommandName), aCommand);
  37
  38   return NS_OK;
  39 }
  40
  41 NS_IMETHODIMP
  42 nsControllerCommandTable::UnregisterCommand(const char* aCommandName,
  43                                             nsIControllerCommand* aCommand) {
  44   NS_ENSURE_TRUE(mMutable, NS_ERROR_FAILURE);
  45
  46   nsDependentCString commandKey(aCommandName);
  47   if (!mCommandsTable.Get(commandKey, nullptr)) {
  48     return NS_ERROR_FAILURE;
  49   }
  50
  51   mCommandsTable.Remove(commandKey);
  52   return NS_OK;
  53 }
  54
  55 NS_IMETHODIMP
  56 nsControllerCommandTable::FindCommandHandler(const char* aCommandName,
  57                                              nsIControllerCommand** aResult) {
  58   NS_ENSURE_ARG_POINTER(aResult);
  59
  60   *aResult = nullptr;
  61
  62   nsCOMPtr<nsIControllerCommand> foundCommand;
  63   mCommandsTable.Get(nsDependentCString(aCommandName),
  64                      getter_AddRefs(foundCommand));
  65   if (!foundCommand) {
  66     return NS_ERROR_FAILURE;
  67   }
  68
  69   foundCommand.forget(aResult);
  70   return NS_OK;
  71 }
  72
  73 NS_IMETHODIMP
  74 nsControllerCommandTable::IsCommandEnabled(const char* aCommandName,
  75                                            nsISupports* aCommandRefCon,
  76                                            bool* aResult) {
  77   NS_ENSURE_ARG_POINTER(aResult);
  78
  79   *aResult = false;
  80
  81   nsCOMPtr<nsIControllerCommand> commandHandler;
  82   FindCommandHandler(aCommandName, getter_AddRefs(commandHandler));
  83   if (!commandHandler) {
  84     NS_WARNING(
  85         "Controller command table asked about a command that it does "
  86         "not handle");
  87     return NS_OK;
  88   }
  89
  90   return commandHandler->IsCommandEnabled(aCommandName, aCommandRefCon,
  91                                           aResult);
  92 }
  93
  94 NS_IMETHODIMP
  95 nsControllerCommandTable::UpdateCommandState(const char* aCommandName,
  96                                              nsISupports* aCommandRefCon) {
  97   nsCOMPtr<nsIControllerCommand> commandHandler;
  98   FindCommandHandler(aCommandName, getter_AddRefs(commandHandler));
  99   if (!commandHandler) {
 100     NS_WARNING(
 101         "Controller command table asked to update the state of a "
 102         "command that it does not handle");
 103     return NS_OK;
 104   }
 105
 106   return NS_ERROR_NOT_IMPLEMENTED;
 107 }
 108
 109 NS_IMETHODIMP
 110 nsControllerCommandTable::SupportsCommand(const char* aCommandName,
 111                                           nsISupports* aCommandRefCon,
 112                                           bool* aResult) {
 113   NS_ENSURE_ARG_POINTER(aResult);
 114
 115   // XXX: need to check the readonly and disabled states
 116
 117   *aResult = false;
 118
 119   nsCOMPtr<nsIControllerCommand> commandHandler;
 120   FindCommandHandler(aCommandName, getter_AddRefs(commandHandler));
 121
 122   *aResult = (commandHandler.get() != nullptr);
 123   return NS_OK;
 124 }
 125
 126 NS_IMETHODIMP
 127 nsControllerCommandTable::DoCommand(const char* aCommandName,
 128                                     nsISupports* aCommandRefCon) {
 129   nsCOMPtr<nsIControllerCommand> commandHandler;
 130   FindCommandHandler(aCommandName, getter_AddRefs(commandHandler));
 131   if (!commandHandler) {
 132     NS_WARNING(
 133         "Controller command table asked to do a command that it does "
 134         "not handle");
 135     return NS_OK;
 136   }
 137
 138   return commandHandler->DoCommand(aCommandName, aCommandRefCon);
 139 }
 140
 141 NS_IMETHODIMP
 142 nsControllerCommandTable::DoCommandParams(const char* aCommandName,
 143                                           nsICommandParams* aParams,
 144                                           nsISupports* aCommandRefCon) {
 145   nsCOMPtr<nsIControllerCommand> commandHandler;
 146   FindCommandHandler(aCommandName, getter_AddRefs(commandHandler));
 147   if (!commandHandler) {
 148     NS_WARNING(
 149         "Controller command table asked to do a command that it does "
 150         "not handle");
 151     return NS_OK;
 152   }
 153   return commandHandler->DoCommandParams(aCommandName, aParams, aCommandRefCon);
 154 }
 155
 156 NS_IMETHODIMP
 157 nsControllerCommandTable::GetCommandState(const char* aCommandName,
 158                                           nsICommandParams* aParams,
 159                                           nsISupports* aCommandRefCon) {
 160   nsCOMPtr<nsIControllerCommand> commandHandler;
 161   FindCommandHandler(aCommandName, getter_AddRefs(commandHandler));
 162   if (!commandHandler) {
 163     NS_WARNING(
 164         "Controller command table asked to do a command that it does "
 165         "not handle");
 166     return NS_OK;
 167   }
 168   return commandHandler->GetCommandStateParams(aCommandName, aParams,
 169                                                aCommandRefCon);
 170 }
 171
 172 NS_IMETHODIMP
 173 nsControllerCommandTable::GetSupportedCommands(nsTArray<nsCString>& aCommands) {
 174   mozilla::AppendToArray(aCommands, mCommandsTable.Keys());
 175
 176   return NS_OK;
 177 }
 178
 179 using CommandTableRegistrar = nsresult (*)(nsControllerCommandTable*);
 180
 181 static already_AddRefed<nsControllerCommandTable>
 182 CreateCommandTableWithCommands(CommandTableRegistrar aRegistrar) {
 183   RefPtr<nsControllerCommandTable> commandTable =
 184       new nsControllerCommandTable();
 185
 186   nsresult rv = aRegistrar(commandTable);
 187   if (NS_FAILED(rv)) return nullptr;
 188
 189   // we don't know here whether we're being created as an instance,
 190   // or a service, so we can't become immutable
 191
 192   return commandTable.forget();
 193 }
 194
 195 // static
 196 already_AddRefed<nsControllerCommandTable>
 197 nsControllerCommandTable::CreateEditorCommandTable() {
 198   return CreateCommandTableWithCommands(
 199       mozilla::EditorController::RegisterEditorCommands);
 200 }
 201
 202 // static
 203 already_AddRefed<nsControllerCommandTable>
 204 nsControllerCommandTable::CreateEditingCommandTable() {
 205   return CreateCommandTableWithCommands(
 206       mozilla::EditorController::RegisterEditingCommands);
 207 }
 208
 209 // static
 210 already_AddRefed<nsControllerCommandTable>
 211 nsControllerCommandTable::CreateHTMLEditorCommandTable() {
 212   return CreateCommandTableWithCommands(
 213       mozilla::HTMLEditorController::RegisterHTMLEditorCommands);
 214 }
 215
 216 // static
 217 already_AddRefed<nsControllerCommandTable>
 218 nsControllerCommandTable::CreateHTMLEditorDocStateCommandTable() {
 219   return CreateCommandTableWithCommands(
 220       mozilla::HTMLEditorController::RegisterEditorDocStateCommands);
 221 }
 222
 223 // static
 224 already_AddRefed<nsControllerCommandTable>
 225 nsControllerCommandTable::CreateWindowCommandTable() {
 226   return CreateCommandTableWithCommands(
 227       nsWindowCommandRegistration::RegisterWindowCommands);
 228 }