gecko-dev/dom/commandhandler/nsCommandManager.cpp

262 строки
7.8 KiB
C++

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsString.h"
#include "nsIController.h"
#include "nsIControllers.h"
#include "nsIObserver.h"
#include "nsIComponentManager.h"
#include "nsServiceManagerUtils.h"
#include "nsIScriptSecurityManager.h"
#include "nsContentUtils.h"
#include "nsIDOMWindow.h"
#include "nsPIDOMWindow.h"
#include "nsPIWindowRoot.h"
#include "nsIFocusManager.h"
#include "nsCOMArray.h"
#include "nsCommandManager.h"
nsCommandManager::nsCommandManager()
: mWindow(nullptr)
{
}
nsCommandManager::~nsCommandManager()
{
}
NS_IMPL_CYCLE_COLLECTION_CLASS(nsCommandManager)
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsCommandManager)
tmp->mObserversTable.Clear();
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsCommandManager)
for (auto iter = tmp->mObserversTable.Iter(); !iter.Done(); iter.Next()) {
nsCommandManager::ObserverList* observers = iter.UserData();
int32_t numItems = observers->Length();
for (int32_t i = 0; i < numItems; ++i) {
cb.NoteXPCOMChild(observers->ElementAt(i));
}
}
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
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_END
NS_IMETHODIMP
nsCommandManager::Init(mozIDOMWindowProxy* aWindow)
{
NS_ENSURE_ARG_POINTER(aWindow);
mWindow = aWindow; // weak ptr
return NS_OK;
}
NS_IMETHODIMP
nsCommandManager::CommandStatusChanged(const char* aCommandName)
{
ObserverList* commandObservers;
mObserversTable.Get(aCommandName, &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) {
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),
aCommandName,
u"command_status_changed");
}
}
return NS_OK;
}
#if 0
#pragma mark -
#endif
NS_IMETHODIMP
nsCommandManager::AddCommandObserver(nsIObserver* aCommandObserver,
const char* aCommandToObserve)
{
NS_ENSURE_ARG(aCommandObserver);
// 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
ObserverList* commandObservers =
mObserversTable.LookupForAdd(aCommandToObserve).OrInsert(
[] () { return new ObserverList; });
// need to check that this command observer hasn't already been registered
int32_t existingIndex = commandObservers->IndexOf(aCommandObserver);
if (existingIndex == -1) {
commandObservers->AppendElement(aCommandObserver);
} else {
NS_WARNING("Registering command observer twice on the same command");
}
return NS_OK;
}
NS_IMETHODIMP
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)) {
return NS_ERROR_UNEXPECTED;
}
commandObservers->RemoveElement(aCommandObserver);
return NS_OK;
}
NS_IMETHODIMP
nsCommandManager::IsCommandSupported(const char* aCommandName,
mozIDOMWindowProxy* aTargetWindow,
bool* aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
nsCOMPtr<nsIController> controller;
GetControllerForCommand(aCommandName, aTargetWindow,
getter_AddRefs(controller));
*aResult = (controller.get() != nullptr);
return NS_OK;
}
NS_IMETHODIMP
nsCommandManager::IsCommandEnabled(const char* aCommandName,
mozIDOMWindowProxy* aTargetWindow,
bool* aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
bool commandEnabled = false;
nsCOMPtr<nsIController> controller;
GetControllerForCommand(aCommandName, aTargetWindow,
getter_AddRefs(controller));
if (controller) {
controller->IsCommandEnabled(aCommandName, &commandEnabled);
}
*aResult = commandEnabled;
return NS_OK;
}
NS_IMETHODIMP
nsCommandManager::GetCommandState(const char* aCommandName,
mozIDOMWindowProxy* aTargetWindow,
nsICommandParams* aCommandParams)
{
nsCOMPtr<nsIController> controller;
nsAutoString tValue;
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 {
rv = NS_ERROR_NOT_IMPLEMENTED;
}
return rv;
}
NS_IMETHODIMP
nsCommandManager::DoCommand(const char* aCommandName,
nsICommandParams* aCommandParams,
mozIDOMWindowProxy* aTargetWindow)
{
nsCOMPtr<nsIController> controller;
nsresult rv = GetControllerForCommand(aCommandName, aTargetWindow,
getter_AddRefs(controller));
if (!controller) {
return NS_ERROR_FAILURE;
}
nsCOMPtr<nsICommandController> commandController =
do_QueryInterface(controller);
if (commandController && aCommandParams) {
rv = commandController->DoCommandWithParams(aCommandName, aCommandParams);
} else {
rv = controller->DoCommand(aCommandName);
}
return rv;
}
nsresult
nsCommandManager::GetControllerForCommand(const char* aCommand,
mozIDOMWindowProxy* aTargetWindow,
nsIController** aResult)
{
nsresult rv = NS_ERROR_FAILURE;
*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::LegacyIsCallerChromeOrNativeCode()) {
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 (auto* targetWindow = nsPIDOMWindowOuter::From(aTargetWindow)) {
// get the controller for this particular window
nsCOMPtr<nsIControllers> controllers;
rv = targetWindow->GetControllers(getter_AddRefs(controllers));
if (NS_FAILED(rv)) {
return rv;
}
if (!controllers) {
return NS_ERROR_FAILURE;
}
// dispatch the command
return controllers->GetControllerForCommand(aCommand, aResult);
}
auto* window = nsPIDOMWindowOuter::From(mWindow);
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
nsCOMPtr<nsPIWindowRoot> root = window->GetTopWindowRoot();
NS_ENSURE_TRUE(root, NS_ERROR_FAILURE);
// no target window; send command to focus controller
return root->GetControllerForCommand(aCommand, false /* for any window */,
aResult);
}