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
9 #include "nsIController.h"
10 #include "nsIControllers.h"
11 #include "nsIObserver.h"
12
13 #include "nsIComponentManager.h"
14
15 #include "nsServiceManagerUtils.h"
16 #include "nsIScriptSecurityManager.h"
17
18 #include "nsContentUtils.h"
19 #include "nsIDOMWindow.h"
20 #include "nsPIDOMWindow.h"
21 #include "nsPIWindowRoot.h"
22 #include "nsIFocusManager.h"
23
24 #include "nsCOMArray.h"
25
26 #include "nsCommandManager.h"
27
nsCommandManager()28 nsCommandManager::nsCommandManager() : mWindow(nullptr) {}
29
~nsCommandManager()30 nsCommandManager::~nsCommandManager() {}
31
32 NS_IMPL_CYCLE_COLLECTION_CLASS(nsCommandManager)
33
34 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsCommandManager)
35 tmp->mObserversTable.Clear();
36 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
37 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsCommandManager)
38 for (auto iter = tmp->mObserversTable.Iter(); !iter.Done(); iter.Next()) {
39 nsCommandManager::ObserverList* observers = iter.UserData();
40 int32_t numItems = observers->Length();
41 for (int32_t i = 0; i < numItems; ++i) {
42 cb.NoteXPCOMChild(observers->ElementAt(i));
43 }
44 }
45 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
46
NS_IMPL_CYCLE_COLLECTING_ADDREF(nsCommandManager)47 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsCommandManager)
48 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsCommandManager)
49
50 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsCommandManager)
51 NS_INTERFACE_MAP_ENTRY(nsICommandManager)
52 NS_INTERFACE_MAP_ENTRY(nsPICommandUpdater)
53 NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
54 NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsICommandManager)
55 NS_INTERFACE_MAP_END
56
57 NS_IMETHODIMP
58 nsCommandManager::Init(mozIDOMWindowProxy* aWindow) {
59 NS_ENSURE_ARG_POINTER(aWindow);
60
61 mWindow = aWindow; // weak ptr
62 return NS_OK;
63 }
64
65 NS_IMETHODIMP
CommandStatusChanged(const char * aCommandName)66 nsCommandManager::CommandStatusChanged(const char* aCommandName) {
67 ObserverList* commandObservers;
68 mObserversTable.Get(aCommandName, &commandObservers);
69
70 if (commandObservers) {
71 // XXX Should we worry about observers removing themselves from Observe()?
72 int32_t i, numItems = commandObservers->Length();
73 for (i = 0; i < numItems; ++i) {
74 nsCOMPtr<nsIObserver> observer = commandObservers->ElementAt(i);
75 // should we get the command state to pass here? This might be expensive.
76 observer->Observe(NS_ISUPPORTS_CAST(nsICommandManager*, this),
77 aCommandName, u"command_status_changed");
78 }
79 }
80
81 return NS_OK;
82 }
83
84 #if 0
85 #pragma mark -
86 #endif
87
88 NS_IMETHODIMP
AddCommandObserver(nsIObserver * aCommandObserver,const char * aCommandToObserve)89 nsCommandManager::AddCommandObserver(nsIObserver* aCommandObserver,
90 const char* aCommandToObserve) {
91 NS_ENSURE_ARG(aCommandObserver);
92
93 // XXX todo: handle special cases of aCommandToObserve being null, or empty
94
95 // for each command in the table, we make a list of observers for that command
96 ObserverList* commandObservers =
97 mObserversTable.LookupForAdd(aCommandToObserve).OrInsert([]() {
98 return new ObserverList;
99 });
100
101 // need to check that this command observer hasn't already been registered
102 int32_t existingIndex = commandObservers->IndexOf(aCommandObserver);
103 if (existingIndex == -1) {
104 commandObservers->AppendElement(aCommandObserver);
105 } else {
106 NS_WARNING("Registering command observer twice on the same command");
107 }
108
109 return NS_OK;
110 }
111
112 NS_IMETHODIMP
RemoveCommandObserver(nsIObserver * aCommandObserver,const char * aCommandObserved)113 nsCommandManager::RemoveCommandObserver(nsIObserver* aCommandObserver,
114 const char* aCommandObserved) {
115 NS_ENSURE_ARG(aCommandObserver);
116
117 // XXX todo: handle special cases of aCommandToObserve being null, or empty
118
119 ObserverList* commandObservers;
120 if (!mObserversTable.Get(aCommandObserved, &commandObservers)) {
121 return NS_ERROR_UNEXPECTED;
122 }
123
124 commandObservers->RemoveElement(aCommandObserver);
125
126 return NS_OK;
127 }
128
129 NS_IMETHODIMP
IsCommandSupported(const char * aCommandName,mozIDOMWindowProxy * aTargetWindow,bool * aResult)130 nsCommandManager::IsCommandSupported(const char* aCommandName,
131 mozIDOMWindowProxy* aTargetWindow,
132 bool* aResult) {
133 NS_ENSURE_ARG_POINTER(aResult);
134
135 nsCOMPtr<nsIController> controller;
136 GetControllerForCommand(aCommandName, aTargetWindow,
137 getter_AddRefs(controller));
138 *aResult = (controller.get() != nullptr);
139 return NS_OK;
140 }
141
142 NS_IMETHODIMP
IsCommandEnabled(const char * aCommandName,mozIDOMWindowProxy * aTargetWindow,bool * aResult)143 nsCommandManager::IsCommandEnabled(const char* aCommandName,
144 mozIDOMWindowProxy* aTargetWindow,
145 bool* aResult) {
146 NS_ENSURE_ARG_POINTER(aResult);
147
148 bool commandEnabled = false;
149
150 nsCOMPtr<nsIController> controller;
151 GetControllerForCommand(aCommandName, aTargetWindow,
152 getter_AddRefs(controller));
153 if (controller) {
154 controller->IsCommandEnabled(aCommandName, &commandEnabled);
155 }
156 *aResult = commandEnabled;
157 return NS_OK;
158 }
159
160 NS_IMETHODIMP
GetCommandState(const char * aCommandName,mozIDOMWindowProxy * aTargetWindow,nsICommandParams * aCommandParams)161 nsCommandManager::GetCommandState(const char* aCommandName,
162 mozIDOMWindowProxy* aTargetWindow,
163 nsICommandParams* aCommandParams) {
164 nsCOMPtr<nsIController> controller;
165 nsAutoString tValue;
166 nsresult rv = GetControllerForCommand(aCommandName, aTargetWindow,
167 getter_AddRefs(controller));
168 if (!controller) {
169 return NS_ERROR_FAILURE;
170 }
171
172 nsCOMPtr<nsICommandController> commandController =
173 do_QueryInterface(controller);
174 if (commandController) {
175 rv = commandController->GetCommandStateWithParams(aCommandName,
176 aCommandParams);
177 } else {
178 rv = NS_ERROR_NOT_IMPLEMENTED;
179 }
180 return rv;
181 }
182
183 NS_IMETHODIMP
DoCommand(const char * aCommandName,nsICommandParams * aCommandParams,mozIDOMWindowProxy * aTargetWindow)184 nsCommandManager::DoCommand(const char* aCommandName,
185 nsICommandParams* aCommandParams,
186 mozIDOMWindowProxy* aTargetWindow) {
187 nsCOMPtr<nsIController> controller;
188 nsresult rv = GetControllerForCommand(aCommandName, aTargetWindow,
189 getter_AddRefs(controller));
190 if (!controller) {
191 return NS_ERROR_FAILURE;
192 }
193
194 nsCOMPtr<nsICommandController> commandController =
195 do_QueryInterface(controller);
196 if (commandController && aCommandParams) {
197 rv = commandController->DoCommandWithParams(aCommandName, aCommandParams);
198 } else {
199 rv = controller->DoCommand(aCommandName);
200 }
201 return rv;
202 }
203
GetControllerForCommand(const char * aCommand,mozIDOMWindowProxy * aTargetWindow,nsIController ** aResult)204 nsresult nsCommandManager::GetControllerForCommand(
205 const char* aCommand, mozIDOMWindowProxy* aTargetWindow,
206 nsIController** aResult) {
207 nsresult rv = NS_ERROR_FAILURE;
208 *aResult = nullptr;
209
210 // check if we're in content or chrome
211 // if we're not chrome we must have a target window or we bail
212 if (!nsContentUtils::LegacyIsCallerChromeOrNativeCode()) {
213 if (!aTargetWindow) {
214 return rv;
215 }
216
217 // if a target window is specified, it must be the window we expect
218 if (aTargetWindow != mWindow) {
219 return NS_ERROR_FAILURE;
220 }
221 }
222
223 if (auto* targetWindow = nsPIDOMWindowOuter::From(aTargetWindow)) {
224 // get the controller for this particular window
225 nsCOMPtr<nsIControllers> controllers;
226 rv = targetWindow->GetControllers(getter_AddRefs(controllers));
227 if (NS_FAILED(rv)) {
228 return rv;
229 }
230 if (!controllers) {
231 return NS_ERROR_FAILURE;
232 }
233
234 // dispatch the command
235 return controllers->GetControllerForCommand(aCommand, aResult);
236 }
237
238 auto* window = nsPIDOMWindowOuter::From(mWindow);
239 NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
240 nsCOMPtr<nsPIWindowRoot> root = window->GetTopWindowRoot();
241 NS_ENSURE_TRUE(root, NS_ERROR_FAILURE);
242
243 // no target window; send command to focus controller
244 return root->GetControllerForCommand(aCommand, false /* for any window */,
245 aResult);
246 }
247