1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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/. */
#ifndef nsBaseDragService_h__
#define nsBaseDragService_h__
#include "nsIDragService.h"
#include "nsIDragSession.h"
#include "nsCOMPtr.h"
#include "nsRect.h"
#include "nsPoint.h"
#include "nsString.h"
#include "mozilla/RefPtr.h"
#include "mozilla/dom/ContentParent.h"
#include "mozilla/dom/HTMLCanvasElement.h"
#include "mozilla/dom/RemoteDragStartData.h"
#include "mozilla/Logging.h"
#include "nsTArray.h"
#include "nsRegion.h"
#include "Units.h"
extern mozilla::LazyLogModule sWidgetDragServiceLog;
#define MOZ_DRAGSERVICE_LOG(...) \
MOZ_LOG(sWidgetDragServiceLog, mozilla::LogLevel::Debug, (__VA_ARGS__))
#define MOZ_DRAGSERVICE_LOG_ENABLED() \
MOZ_LOG_TEST(sWidgetDragServiceLog, mozilla::LogLevel::Debug)
// translucency level for drag images
#define DRAG_TRANSLUCENCY 0.65
class nsIContent;
class nsINode;
class nsPresContext;
class nsIImageLoadingContent;
namespace mozilla {
namespace gfx {
class SourceSurface;
} // namespace gfx
namespace dom {
class DataTransfer;
class Selection;
} // namespace dom
} // namespace mozilla
/**
* XP DragService wrapper base class
*/
class nsBaseDragService : public nsIDragService, public nsIDragSession {
public:
typedef mozilla::gfx::SourceSurface SourceSurface;
nsBaseDragService();
// nsISupports
NS_DECL_ISUPPORTS
// nsIDragSession and nsIDragService
NS_DECL_NSIDRAGSERVICE
NS_DECL_NSIDRAGSESSION
void SetDragEndPoint(nsIntPoint aEndDragPoint) {
mEndDragPoint =
mozilla::LayoutDeviceIntPoint::FromUnknownPoint(aEndDragPoint);
}
void SetDragEndPoint(mozilla::LayoutDeviceIntPoint aEndDragPoint) {
mEndDragPoint = aEndDragPoint;
}
uint16_t GetInputSource() { return mInputSource; }
int32_t TakeChildProcessDragAction();
protected:
virtual ~nsBaseDragService();
/**
* Called from nsBaseDragService to initiate a platform drag from a source
* in this process. This is expected to ensure that StartDragSession() and
* EndDragSession() get called if the platform drag is successfully invoked.
*/
MOZ_CAN_RUN_SCRIPT virtual nsresult InvokeDragSessionImpl(
nsIArray* aTransferableArray,
const mozilla::Maybe<mozilla::CSSIntRegion>& aRegion,
uint32_t aActionType) = 0;
/**
* Draw the drag image, if any, to a surface and return it. The drag image
* is constructed from mImage if specified, or aDOMNode if mImage is null.
*
* aRegion may be used to draw only a subset of the element. This region
* should be supplied using x and y coordinates measured in css pixels
* that are relative to the upper-left corner of the window.
*
* aScreenPosition should be the screen coordinates of the mouse click
* for the drag. These are in CSS pixels.
*
* On return, aScreenDragRect will contain the screen coordinates of the
* area being dragged. This is used by the platform-specific part of the
* drag service to determine the drag feedback. This rect will be in the
* device pixels of the presContext.
*
* If there is no drag image, the returned surface will be null, but
* aScreenDragRect will still be set to the drag area.
*
* aPresContext will be set to the nsPresContext used determined from
* whichever of mImage or aDOMNode is used.
*/
nsresult DrawDrag(nsINode* aDOMNode,
const mozilla::Maybe<mozilla::CSSIntRegion>& aRegion,
mozilla::CSSIntPoint aScreenPosition,
mozilla::LayoutDeviceIntRect* aScreenDragRect,
RefPtr<SourceSurface>* aSurface,
nsPresContext** aPresContext);
/**
* Draw a drag image for an image node specified by aImageLoader or aCanvas.
* This is called by DrawDrag.
*/
nsresult DrawDragForImage(nsPresContext* aPresContext,
nsIImageLoadingContent* aImageLoader,
mozilla::dom::HTMLCanvasElement* aCanvas,
mozilla::LayoutDeviceIntRect* aScreenDragRect,
RefPtr<SourceSurface>* aSurface);
/**
* If the drag image is a popup, open the popup when the drag begins.
*/
void OpenDragPopup();
/**
* Free resources contained in DataTransferItems that aren't needed by JS.
*/
void DiscardInternalTransferData();
// Returns true if a drag event was dispatched to a child process after
// the previous TakeDragEventDispatchedToChildProcess() call.
bool TakeDragEventDispatchedToChildProcess() {
bool retval = mDragEventDispatchedToChildProcess;
mDragEventDispatchedToChildProcess = false;
return retval;
}
bool mCanDrop;
bool mOnlyChromeDrop;
bool mDoingDrag;
bool mSessionIsSynthesizedForTests;
bool mIsDraggingTextInTextControl;
// true if in EndDragSession
bool mEndingSession;
// true if mImage should be used to set a drag image
bool mHasImage;
// true if the user cancelled the drag operation
bool mUserCancelled;
bool mDragEventDispatchedToChildProcess;
uint32_t mDragAction;
uint32_t mDragActionFromChildProcess;
// mEffectAllowedForTests stores allowed effects at invoking the drag
// for tests.
uint32_t mEffectAllowedForTests;
nsCOMPtr<nsINode> mSourceNode;
nsCOMPtr<nsIPrincipal> mTriggeringPrincipal;
nsCOMPtr<nsIContentSecurityPolicy> mCsp;
// the document at the drag source. will be null if it came from outside the
// app.
RefPtr<mozilla::dom::Document> mSourceDocument;
RefPtr<mozilla::dom::WindowContext> mSourceWindowContext;
RefPtr<mozilla::dom::WindowContext> mSourceTopWindowContext;
// the contentpolicy type passed to the channel when initiating the drag
// session
nsContentPolicyType mContentPolicyType;
RefPtr<mozilla::dom::DataTransfer> mDataTransfer;
// used to determine the image to appear on the cursor while dragging
nsCOMPtr<nsINode> mImage;
// offset of cursor within the image
mozilla::CSSIntPoint mImageOffset;
// set if a selection is being dragged
RefPtr<mozilla::dom::Selection> mSelection;
// remote drag data
RefPtr<mozilla::dom::RemoteDragStartData> mDragStartData;
// set if the image in mImage is a popup. If this case, the popup will be
// opened and moved instead of using a drag image.
nsCOMPtr<mozilla::dom::Element> mDragPopup;
// the screen position where drag gesture occurred, used for positioning the
// drag image.
mozilla::CSSIntPoint mScreenPosition;
// The position relative to the top level widget where the drag ended.
mozilla::LayoutDeviceIntPoint mEndDragPoint;
uint32_t mSuppressLevel;
// The input source of the drag event. Possible values are from MouseEvent.
uint16_t mInputSource;
nsTArray<RefPtr<mozilla::dom::ContentParent>> mChildProcesses;
// Sub-region for tree-selections.
mozilla::Maybe<mozilla::CSSIntRegion> mRegion;
};
#endif // nsBaseDragService_h__
|
