The Tor Browser / file comparison

comparison: editor/libeditor/text/nsPlaintextDataTransfer.cpp

editor/libeditor/text/nsPlaintextDataTransfer.cpp

branch
TOR_BUG_3246
changeset 7
129ffea94266
equal deleted inserted replaced
-1:000000000000 0:330234797281
1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 #include "mozilla/ArrayUtils.h"
7 #include "mozilla/MouseEvents.h"
8 #include "nsAString.h"
9 #include "nsCOMPtr.h"
10 #include "nsCRT.h"
11 #include "nsComponentManagerUtils.h"
12 #include "nsContentUtils.h"
13 #include "nsDebug.h"
14 #include "nsEditor.h"
15 #include "nsEditorUtils.h"
16 #include "nsError.h"
17 #include "nsIClipboard.h"
18 #include "nsIContent.h"
19 #include "nsIDOMDataTransfer.h"
20 #include "nsIDOMDocument.h"
21 #include "nsIDOMDragEvent.h"
22 #include "nsIDOMEvent.h"
23 #include "nsIDOMNode.h"
24 #include "nsIDOMRange.h"
25 #include "nsIDOMUIEvent.h"
26 #include "nsIDocument.h"
27 #include "nsIDragService.h"
28 #include "nsIDragSession.h"
29 #include "nsIEditor.h"
30 #include "nsIEditorIMESupport.h"
31 #include "nsIDocShell.h"
32 #include "nsIDocShellTreeItem.h"
33 #include "nsIPrincipal.h"
34 #include "nsIFormControl.h"
35 #include "nsIPlaintextEditor.h"
36 #include "nsISelection.h"
37 #include "nsISupportsPrimitives.h"
38 #include "nsITransferable.h"
39 #include "nsIVariant.h"
40 #include "nsLiteralString.h"
41 #include "nsPlaintextEditor.h"
42 #include "nsSelectionState.h"
43 #include "nsServiceManagerUtils.h"
44 #include "nsString.h"
45 #include "nsXPCOM.h"
46 #include "nscore.h"
47
48 class nsILoadContext;
49 class nsISupports;
50
51 using namespace mozilla;
52 using namespace mozilla::dom;
53
54 NS_IMETHODIMP nsPlaintextEditor::PrepareTransferable(nsITransferable **transferable)
55 {
56 // Create generic Transferable for getting the data
57 nsresult rv = CallCreateInstance("@mozilla.org/widget/transferable;1", transferable);
58 NS_ENSURE_SUCCESS(rv, rv);
59
60 // Get the nsITransferable interface for getting the data from the clipboard
61 if (transferable) {
62 nsCOMPtr<nsIDocument> destdoc = GetDocument();
63 nsILoadContext* loadContext = destdoc ? destdoc->GetLoadContext() : nullptr;
64 (*transferable)->Init(loadContext);
65
66 (*transferable)->AddDataFlavor(kUnicodeMime);
67 (*transferable)->AddDataFlavor(kMozTextInternal);
68 };
69 return NS_OK;
70 }
71
72 nsresult nsPlaintextEditor::InsertTextAt(const nsAString &aStringToInsert,
73 nsIDOMNode *aDestinationNode,
74 int32_t aDestOffset,
75 bool aDoDeleteSelection)
76 {
77 if (aDestinationNode)
78 {
79 nsresult res;
80 nsCOMPtr<nsISelection>selection;
81 res = GetSelection(getter_AddRefs(selection));
82 NS_ENSURE_SUCCESS(res, res);
83
84 nsCOMPtr<nsIDOMNode> targetNode = aDestinationNode;
85 int32_t targetOffset = aDestOffset;
86
87 if (aDoDeleteSelection)
88 {
89 // Use an auto tracker so that our drop point is correctly
90 // positioned after the delete.
91 nsAutoTrackDOMPoint tracker(mRangeUpdater, &targetNode, &targetOffset);
92 res = DeleteSelection(eNone, eStrip);
93 NS_ENSURE_SUCCESS(res, res);
94 }
95
96 res = selection->Collapse(targetNode, targetOffset);
97 NS_ENSURE_SUCCESS(res, res);
98 }
99
100 return InsertText(aStringToInsert);
101 }
102
103 NS_IMETHODIMP nsPlaintextEditor::InsertTextFromTransferable(nsITransferable *aTransferable,
104 nsIDOMNode *aDestinationNode,
105 int32_t aDestOffset,
106 bool aDoDeleteSelection)
107 {
108 nsresult rv = NS_OK;
109 char* bestFlavor = nullptr;
110 nsCOMPtr<nsISupports> genericDataObj;
111 uint32_t len = 0;
112 if (NS_SUCCEEDED(aTransferable->GetAnyTransferData(&bestFlavor, getter_AddRefs(genericDataObj), &len))
113 && bestFlavor && (0 == nsCRT::strcmp(bestFlavor, kUnicodeMime) ||
114 0 == nsCRT::strcmp(bestFlavor, kMozTextInternal)))
115 {
116 nsAutoTxnsConserveSelection dontSpazMySelection(this);
117 nsCOMPtr<nsISupportsString> textDataObj ( do_QueryInterface(genericDataObj) );
118 if (textDataObj && len > 0)
119 {
120 nsAutoString stuffToPaste;
121 textDataObj->GetData(stuffToPaste);
122 NS_ASSERTION(stuffToPaste.Length() <= (len/2), "Invalid length!");
123
124 // Sanitize possible carriage returns in the string to be inserted
125 nsContentUtils::PlatformToDOMLineBreaks(stuffToPaste);
126
127 nsAutoEditBatch beginBatching(this);
128 rv = InsertTextAt(stuffToPaste, aDestinationNode, aDestOffset, aDoDeleteSelection);
129 }
130 }
131 NS_Free(bestFlavor);
132
133 // Try to scroll the selection into view if the paste/drop succeeded
134
135 if (NS_SUCCEEDED(rv))
136 ScrollSelectionIntoView(false);
137
138 return rv;
139 }
140
141 nsresult nsPlaintextEditor::InsertFromDataTransfer(DataTransfer *aDataTransfer,
142 int32_t aIndex,
143 nsIDOMDocument *aSourceDoc,
144 nsIDOMNode *aDestinationNode,
145 int32_t aDestOffset,
146 bool aDoDeleteSelection)
147 {
148 nsCOMPtr<nsIVariant> data;
149 aDataTransfer->MozGetDataAt(NS_LITERAL_STRING("text/plain"), aIndex,
150 getter_AddRefs(data));
151 if (data) {
152 nsAutoString insertText;
153 data->GetAsAString(insertText);
154 nsContentUtils::PlatformToDOMLineBreaks(insertText);
155
156 nsAutoEditBatch beginBatching(this);
157 return InsertTextAt(insertText, aDestinationNode, aDestOffset, aDoDeleteSelection);
158 }
159
160 return NS_OK;
161 }
162
163 nsresult nsPlaintextEditor::InsertFromDrop(nsIDOMEvent* aDropEvent)
164 {
165 ForceCompositionEnd();
166
167 nsCOMPtr<nsIDOMDragEvent> dragEvent(do_QueryInterface(aDropEvent));
168 NS_ENSURE_TRUE(dragEvent, NS_ERROR_FAILURE);
169
170 nsCOMPtr<nsIDOMDataTransfer> domDataTransfer;
171 dragEvent->GetDataTransfer(getter_AddRefs(domDataTransfer));
172 nsCOMPtr<DataTransfer> dataTransfer = do_QueryInterface(domDataTransfer);
173 NS_ENSURE_TRUE(dataTransfer, NS_ERROR_FAILURE);
174
175 nsCOMPtr<nsIDragSession> dragSession = nsContentUtils::GetDragSession();
176 NS_ASSERTION(dragSession, "No drag session");
177
178 nsCOMPtr<nsIDOMNode> sourceNode;
179 dataTransfer->GetMozSourceNode(getter_AddRefs(sourceNode));
180
181 nsCOMPtr<nsIDOMDocument> srcdomdoc;
182 if (sourceNode) {
183 sourceNode->GetOwnerDocument(getter_AddRefs(srcdomdoc));
184 NS_ENSURE_TRUE(sourceNode, NS_ERROR_FAILURE);
185 }
186
187 if (nsContentUtils::CheckForSubFrameDrop(dragSession,
188 aDropEvent->GetInternalNSEvent()->AsDragEvent())) {
189 // Don't allow drags from subframe documents with different origins than
190 // the drop destination.
191 if (srcdomdoc && !IsSafeToInsertData(srcdomdoc))
192 return NS_OK;
193 }
194
195 // Current doc is destination
196 nsCOMPtr<nsIDOMDocument> destdomdoc = GetDOMDocument();
197 NS_ENSURE_TRUE(destdomdoc, NS_ERROR_NOT_INITIALIZED);
198
199 uint32_t numItems = 0;
200 nsresult rv = dataTransfer->GetMozItemCount(&numItems);
201 NS_ENSURE_SUCCESS(rv, rv);
202 if (numItems < 1) return NS_ERROR_FAILURE; // nothing to drop?
203
204 // Combine any deletion and drop insertion into one transaction
205 nsAutoEditBatch beginBatching(this);
206
207 bool deleteSelection = false;
208
209 // We have to figure out whether to delete and relocate caret only once
210 // Parent and offset are under the mouse cursor
211 nsCOMPtr<nsIDOMUIEvent> uiEvent = do_QueryInterface(aDropEvent);
212 NS_ENSURE_TRUE(uiEvent, NS_ERROR_FAILURE);
213
214 nsCOMPtr<nsIDOMNode> newSelectionParent;
215 rv = uiEvent->GetRangeParent(getter_AddRefs(newSelectionParent));
216 NS_ENSURE_SUCCESS(rv, rv);
217 NS_ENSURE_TRUE(newSelectionParent, NS_ERROR_FAILURE);
218
219 int32_t newSelectionOffset;
220 rv = uiEvent->GetRangeOffset(&newSelectionOffset);
221 NS_ENSURE_SUCCESS(rv, rv);
222
223 nsCOMPtr<nsISelection> selection;
224 rv = GetSelection(getter_AddRefs(selection));
225 NS_ENSURE_SUCCESS(rv, rv);
226 NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
227
228 bool isCollapsed = selection->Collapsed();
229
230 // Only the nsHTMLEditor::FindUserSelectAllNode returns a node.
231 nsCOMPtr<nsIDOMNode> userSelectNode = FindUserSelectAllNode(newSelectionParent);
232 if (userSelectNode)
233 {
234 // The drop is happening over a "-moz-user-select: all"
235 // subtree so make sure the content we insert goes before
236 // the root of the subtree.
237 //
238 // XXX: Note that inserting before the subtree matches the
239 // current behavior when dropping on top of an image.
240 // The decision for dropping before or after the
241 // subtree should really be done based on coordinates.
242
243 newSelectionParent = GetNodeLocation(userSelectNode, &newSelectionOffset);
244
245 NS_ENSURE_TRUE(newSelectionParent, NS_ERROR_FAILURE);
246 }
247
248 // Check if mouse is in the selection
249 // if so, jump through some hoops to determine if mouse is over selection (bail)
250 // and whether user wants to copy selection or delete it
251 if (!isCollapsed)
252 {
253 // We never have to delete if selection is already collapsed
254 bool cursorIsInSelection = false;
255
256 int32_t rangeCount;
257 rv = selection->GetRangeCount(&rangeCount);
258 NS_ENSURE_SUCCESS(rv, rv);
259
260 for (int32_t j = 0; j < rangeCount; j++)
261 {
262 nsCOMPtr<nsIDOMRange> range;
263 rv = selection->GetRangeAt(j, getter_AddRefs(range));
264 if (NS_FAILED(rv) || !range)
265 continue; // don't bail yet, iterate through them all
266
267 rv = range->IsPointInRange(newSelectionParent, newSelectionOffset, &cursorIsInSelection);
268 if (cursorIsInSelection)
269 break;
270 }
271
272 if (cursorIsInSelection)
273 {
274 // Dragging within same doc can't drop on itself -- leave!
275 if (srcdomdoc == destdomdoc)
276 return NS_OK;
277
278 // Dragging from another window onto a selection
279 // XXX Decision made to NOT do this,
280 // note that 4.x does replace if dropped on
281 //deleteSelection = true;
282 }
283 else
284 {
285 // We are NOT over the selection
286 if (srcdomdoc == destdomdoc)
287 {
288 // Within the same doc: delete if user doesn't want to copy
289 uint32_t dropEffect;
290 dataTransfer->GetDropEffectInt(&dropEffect);
291 deleteSelection = !(dropEffect & nsIDragService::DRAGDROP_ACTION_COPY);
292 }
293 else
294 {
295 // Different source doc: Don't delete
296 deleteSelection = false;
297 }
298 }
299 }
300
301 if (IsPlaintextEditor()) {
302 nsCOMPtr<nsIContent> content = do_QueryInterface(newSelectionParent);
303 while (content) {
304 nsCOMPtr<nsIFormControl> formControl(do_QueryInterface(content));
305 if (formControl && !formControl->AllowDrop()) {
306 // Don't allow dropping into a form control that doesn't allow being
307 // dropped into.
308 return NS_OK;
309 }
310 content = content->GetParent();
311 }
312 }
313
314 for (uint32_t i = 0; i < numItems; ++i) {
315 InsertFromDataTransfer(dataTransfer, i, srcdomdoc, newSelectionParent,
316 newSelectionOffset, deleteSelection);
317 }
318
319 if (NS_SUCCEEDED(rv))
320 ScrollSelectionIntoView(false);
321
322 return rv;
323 }
324
325 NS_IMETHODIMP nsPlaintextEditor::Paste(int32_t aSelectionType)
326 {
327 if (!FireClipboardEvent(NS_PASTE, aSelectionType))
328 return NS_OK;
329
330 // Get Clipboard Service
331 nsresult rv;
332 nsCOMPtr<nsIClipboard> clipboard(do_GetService("@mozilla.org/widget/clipboard;1", &rv));
333 if ( NS_FAILED(rv) )
334 return rv;
335
336 // Get the nsITransferable interface for getting the data from the clipboard
337 nsCOMPtr<nsITransferable> trans;
338 rv = PrepareTransferable(getter_AddRefs(trans));
339 if (NS_SUCCEEDED(rv) && trans)
340 {
341 // Get the Data from the clipboard
342 if (NS_SUCCEEDED(clipboard->GetData(trans, aSelectionType)) && IsModifiable())
343 {
344 // handle transferable hooks
345 nsCOMPtr<nsIDOMDocument> domdoc = GetDOMDocument();
346 if (!nsEditorHookUtils::DoInsertionHook(domdoc, nullptr, trans))
347 return NS_OK;
348
349 rv = InsertTextFromTransferable(trans, nullptr, 0, true);
350 }
351 }
352
353 return rv;
354 }
355
356 NS_IMETHODIMP nsPlaintextEditor::PasteTransferable(nsITransferable *aTransferable)
357 {
358 // Use an invalid value for the clipboard type as data comes from aTransferable
359 // and we don't currently implement a way to put that in the data transfer yet.
360 if (!FireClipboardEvent(NS_PASTE, -1))
361 return NS_OK;
362
363 if (!IsModifiable())
364 return NS_OK;
365
366 // handle transferable hooks
367 nsCOMPtr<nsIDOMDocument> domdoc = GetDOMDocument();
368 if (!nsEditorHookUtils::DoInsertionHook(domdoc, nullptr, aTransferable))
369 return NS_OK;
370
371 return InsertTextFromTransferable(aTransferable, nullptr, 0, true);
372 }
373
374 NS_IMETHODIMP nsPlaintextEditor::CanPaste(int32_t aSelectionType, bool *aCanPaste)
375 {
376 NS_ENSURE_ARG_POINTER(aCanPaste);
377 *aCanPaste = false;
378
379 // can't paste if readonly
380 if (!IsModifiable())
381 return NS_OK;
382
383 nsresult rv;
384 nsCOMPtr<nsIClipboard> clipboard(do_GetService("@mozilla.org/widget/clipboard;1", &rv));
385 NS_ENSURE_SUCCESS(rv, rv);
386
387 // the flavors that we can deal with
388 const char* textEditorFlavors[] = { kUnicodeMime };
389
390 bool haveFlavors;
391 rv = clipboard->HasDataMatchingFlavors(textEditorFlavors,
392 ArrayLength(textEditorFlavors),
393 aSelectionType, &haveFlavors);
394 NS_ENSURE_SUCCESS(rv, rv);
395
396 *aCanPaste = haveFlavors;
397 return NS_OK;
398 }
399
400
401 NS_IMETHODIMP nsPlaintextEditor::CanPasteTransferable(nsITransferable *aTransferable, bool *aCanPaste)
402 {
403 NS_ENSURE_ARG_POINTER(aCanPaste);
404
405 // can't paste if readonly
406 if (!IsModifiable()) {
407 *aCanPaste = false;
408 return NS_OK;
409 }
410
411 // If |aTransferable| is null, assume that a paste will succeed.
412 if (!aTransferable) {
413 *aCanPaste = true;
414 return NS_OK;
415 }
416
417 nsCOMPtr<nsISupports> data;
418 uint32_t dataLen;
419 nsresult rv = aTransferable->GetTransferData(kUnicodeMime,
420 getter_AddRefs(data),
421 &dataLen);
422 if (NS_SUCCEEDED(rv) && data)
423 *aCanPaste = true;
424 else
425 *aCanPaste = false;
426
427 return NS_OK;
428 }
429
430 bool nsPlaintextEditor::IsSafeToInsertData(nsIDOMDocument* aSourceDoc)
431 {
432 // Try to determine whether we should use a sanitizing fragment sink
433 bool isSafe = false;
434
435 nsCOMPtr<nsIDocument> destdoc = GetDocument();
436 NS_ASSERTION(destdoc, "Where is our destination doc?");
437 nsCOMPtr<nsIDocShellTreeItem> dsti = destdoc->GetDocShell();
438 nsCOMPtr<nsIDocShellTreeItem> root;
439 if (dsti)
440 dsti->GetRootTreeItem(getter_AddRefs(root));
441 nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(root);
442 uint32_t appType;
443 if (docShell && NS_SUCCEEDED(docShell->GetAppType(&appType)))
444 isSafe = appType == nsIDocShell::APP_TYPE_EDITOR;
445 if (!isSafe && aSourceDoc) {
446 nsCOMPtr<nsIDocument> srcdoc = do_QueryInterface(aSourceDoc);
447 NS_ASSERTION(srcdoc, "Where is our source doc?");
448
449 nsIPrincipal* srcPrincipal = srcdoc->NodePrincipal();
450 nsIPrincipal* destPrincipal = destdoc->NodePrincipal();
451 NS_ASSERTION(srcPrincipal && destPrincipal, "How come we don't have a principal?");
452 srcPrincipal->Subsumes(destPrincipal, &isSafe);
453 }
454
455 return isSafe;
456 }
457

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial