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
|
// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef BASE_BASE_DROP_TARGET_H_
#define BASE_BASE_DROP_TARGET_H_
#include <objidl.h>
#include "base/ref_counted.h"
struct IDropTargetHelper;
// A DropTarget implementation that takes care of the nitty gritty
// of dnd. While this class is concrete, subclasses will most likely
// want to override various OnXXX methods.
//
// Because BaseDropTarget is ref counted you shouldn't delete it directly,
// rather wrap it in a scoped_refptr. Be sure and invoke RevokeDragDrop(m_hWnd)
// before the HWND is deleted too.
//
// This class is meant to be used in a STA and is not multithread-safe.
class BaseDropTarget : public IDropTarget {
public:
// Create a new BaseDropTarget associating it with the given HWND.
explicit BaseDropTarget(HWND hwnd);
virtual ~BaseDropTarget();
// When suspend is set to |true|, the drop target does not receive drops from
// drags initiated within the owning HWND.
// TODO(beng): (http://b/1085385) figure out how we will handle legitimate
// drag-drop operations within the same HWND, such as dragging
// selected text to an edit field.
void set_suspend(bool suspend) { suspend_ = suspend; }
// IDropTarget implementation:
HRESULT __stdcall DragEnter(IDataObject* data_object,
DWORD key_state,
POINTL cursor_position,
DWORD* effect);
HRESULT __stdcall DragOver(DWORD key_state,
POINTL cursor_position,
DWORD* effect);
HRESULT __stdcall DragLeave();
HRESULT __stdcall Drop(IDataObject* data_object,
DWORD key_state,
POINTL cursor_position,
DWORD* effect);
// IUnknown implementation:
HRESULT __stdcall QueryInterface(const IID& iid, void** object);
ULONG __stdcall AddRef();
ULONG __stdcall Release();
protected:
// Returns the hosting HWND.
HWND GetHWND() { return hwnd_; }
// Invoked when the cursor first moves over the hwnd during a dnd session.
// This should return a bitmask of the supported drop operations:
// DROPEFFECT_NONE, DROPEFFECT_COPY, DROPEFFECT_LINK and/or
// DROPEFFECT_MOVE.
virtual DWORD OnDragEnter(IDataObject* data_object,
DWORD key_state,
POINT cursor_position,
DWORD effect);
// Invoked when the cursor moves over the window during a dnd session.
// This should return a bitmask of the supported drop operations:
// DROPEFFECT_NONE, DROPEFFECT_COPY, DROPEFFECT_LINK and/or
// DROPEFFECT_MOVE.
virtual DWORD OnDragOver(IDataObject* data_object,
DWORD key_state,
POINT cursor_position,
DWORD effect);
// Invoked when the cursor moves outside the bounds of the hwnd during a
// dnd session.
virtual void OnDragLeave(IDataObject* data_object);
// Invoked when the drop ends on the window. This should return the operation
// that was taken.
virtual DWORD OnDrop(IDataObject* data_object,
DWORD key_state,
POINT cursor_position,
DWORD effect);
// Return the drag identity.
static int32 GetDragIdentity() { return drag_identity_; }
private:
// Returns the cached drop helper, creating one if necessary. The returned
// object is not addrefed. May return NULL if the object couldn't be created.
static IDropTargetHelper* DropHelper();
// The data object currently being dragged over this drop target.
scoped_refptr<IDataObject> current_data_object_;
// A helper object that is used to provide drag image support while the mouse
// is dragging over the content area.
//
// DO NOT ACCESS DIRECTLY! Use DropHelper() instead, which will lazily create
// this if it doesn't exist yet. This object can take tens of milliseconds to
// create, and we don't want to block any window opening for this, especially
// since often, DnD will never be used. Instead, we force this penalty to the
// first time it is actually used.
static IDropTargetHelper* cached_drop_target_helper_;
// The drag identity (id). An up-counter that increases when the cursor first
// moves over the HWND in a DnD session (OnDragEnter). 0 is reserved to mean
// the "no/unknown" identity, and is used for initialization. The identity is
// sent to the renderer in drag enter notifications. Note: the identity value
// is passed over the renderer NPAPI interface to gears, so use int32 instead
// of int here.
static int32 drag_identity_;
// The HWND of the source. This HWND is used to determine coordinates for
// mouse events that are sent to the renderer notifying various drag states.
HWND hwnd_;
// Whether or not we are currently processing drag notifications for drags
// initiated in this window.
bool suspend_;
LONG ref_count_;
DISALLOW_EVIL_CONSTRUCTORS(BaseDropTarget);
};
#endif // BASE_BASE_DROP_TARGET_H_
|
