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
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
|
// Copyright (c) 2010 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.
#include "chrome/browser/dock_info.h"
#include "base/basictypes.h"
#include "chrome/browser/browser.h"
#include "chrome/browser/browser_list.h"
#include "chrome/browser/browser_window.h"
#include "chrome/browser/views/frame/browser_view.h"
#include "chrome/browser/views/tabs/tab.h"
namespace {
// BaseWindowFinder -----------------------------------------------------------
// Base class used to locate a window. This is intended to be used with the
// various win32 functions that iterate over windows.
//
// A subclass need only override ShouldStopIterating to determine when
// iteration should stop.
class BaseWindowFinder {
public:
// Creates a BaseWindowFinder with the specified set of HWNDs to ignore.
explicit BaseWindowFinder(const std::set<HWND>& ignore) : ignore_(ignore) {}
virtual ~BaseWindowFinder() {}
protected:
// Returns true if iteration should stop, false if iteration should continue.
virtual bool ShouldStopIterating(HWND window) = 0;
static BOOL CALLBACK WindowCallbackProc(HWND hwnd, LPARAM lParam) {
BaseWindowFinder* finder = reinterpret_cast<BaseWindowFinder*>(lParam);
if (finder->ignore_.find(hwnd) != finder->ignore_.end())
return TRUE;
return finder->ShouldStopIterating(hwnd) ? FALSE : TRUE;
}
private:
const std::set<HWND>& ignore_;
DISALLOW_COPY_AND_ASSIGN(BaseWindowFinder);
};
// TopMostFinder --------------------------------------------------------------
// Helper class to determine if a particular point of a window is not obscured
// by another window.
class TopMostFinder : public BaseWindowFinder {
public:
// Returns true if |window| is the topmost window at the location
// |screen_loc|, not including the windows in |ignore|.
static bool IsTopMostWindowAtPoint(HWND window,
const gfx::Point& screen_loc,
const std::set<HWND>& ignore) {
TopMostFinder finder(window, screen_loc, ignore);
return finder.is_top_most_;
}
virtual bool ShouldStopIterating(HWND hwnd) {
if (hwnd == target_) {
// Window is topmost, stop iterating.
is_top_most_ = true;
return true;
}
if (!IsWindowVisible(hwnd)) {
// The window isn't visible, keep iterating.
return false;
}
RECT r;
if (!GetWindowRect(hwnd, &r) || !PtInRect(&r, screen_loc_.ToPOINT())) {
// The window doesn't contain the point, keep iterating.
return false;
}
LONG ex_styles = GetWindowLong(hwnd, GWL_EXSTYLE);
if (ex_styles & WS_EX_TRANSPARENT || ex_styles & WS_EX_LAYERED) {
// Mouse events fall through WS_EX_TRANSPARENT windows, so we ignore them.
//
// WS_EX_LAYERED is trickier. Apps like Switcher create a totally
// transparent WS_EX_LAYERED window that is always on top. If we don't
// ignore WS_EX_LAYERED windows and there are totally transparent
// WS_EX_LAYERED windows then there are effectively holes on the screen
// that the user can't reattach tabs to. So we ignore them. This is a bit
// problematic in so far as WS_EX_LAYERED windows need not be totally
// transparent in which case we treat chrome windows as not being obscured
// when they really are, but this is better than not being able to
// reattach tabs.
return false;
}
// hwnd is at the point. Make sure the point is within the windows region.
if (GetWindowRgn(hwnd, tmp_region_.Get()) == ERROR) {
// There's no region on the window and the window contains the point. Stop
// iterating.
return true;
}
// The region is relative to the window's rect.
BOOL is_point_in_region = PtInRegion(tmp_region_.Get(),
screen_loc_.x() - r.left, screen_loc_.y() - r.top);
tmp_region_ = CreateRectRgn(0, 0, 0, 0);
// Stop iterating if the region contains the point.
return !!is_point_in_region;
}
private:
TopMostFinder(HWND window,
const gfx::Point& screen_loc,
const std::set<HWND>& ignore)
: BaseWindowFinder(ignore),
target_(window),
screen_loc_(screen_loc),
is_top_most_(false),
tmp_region_(CreateRectRgn(0, 0, 0, 0)) {
EnumWindows(WindowCallbackProc, reinterpret_cast<LPARAM>(this));
}
// The window we're looking for.
HWND target_;
// Location of window to find.
gfx::Point screen_loc_;
// Is target_ the top most window? This is initially false but set to true
// in ShouldStopIterating if target_ is passed in.
bool is_top_most_;
ScopedRegion tmp_region_;
DISALLOW_COPY_AND_ASSIGN(TopMostFinder);
};
// WindowFinder ---------------------------------------------------------------
// Helper class to determine if a particular point contains a window from our
// process.
class LocalProcessWindowFinder : public BaseWindowFinder {
public:
// Returns the hwnd from our process at screen_loc that is not obscured by
// another window. Returns NULL otherwise.
static HWND GetProcessWindowAtPoint(const gfx::Point& screen_loc,
const std::set<HWND>& ignore) {
LocalProcessWindowFinder finder(screen_loc, ignore);
if (finder.result_ &&
TopMostFinder::IsTopMostWindowAtPoint(finder.result_, screen_loc,
ignore)) {
return finder.result_;
}
return NULL;
}
protected:
virtual bool ShouldStopIterating(HWND hwnd) {
RECT r;
if (IsWindowVisible(hwnd) && GetWindowRect(hwnd, &r) &&
PtInRect(&r, screen_loc_.ToPOINT())) {
result_ = hwnd;
return true;
}
return false;
}
private:
LocalProcessWindowFinder(const gfx::Point& screen_loc,
const std::set<HWND>& ignore)
: BaseWindowFinder(ignore),
screen_loc_(screen_loc),
result_(NULL) {
EnumThreadWindows(GetCurrentThreadId(), WindowCallbackProc,
reinterpret_cast<LPARAM>(this));
}
// Position of the mouse.
gfx::Point screen_loc_;
// The resulting window. This is initially null but set to true in
// ShouldStopIterating if an appropriate window is found.
HWND result_;
DISALLOW_COPY_AND_ASSIGN(LocalProcessWindowFinder);
};
// DockToWindowFinder ---------------------------------------------------------
// Helper class for creating a DockInfo from a specified point.
class DockToWindowFinder : public BaseWindowFinder {
public:
// Returns the DockInfo for the specified point. If there is no docking
// position for the specified point the returned DockInfo has a type of NONE.
static DockInfo GetDockInfoAtPoint(const gfx::Point& screen_loc,
const std::set<HWND>& ignore) {
DockToWindowFinder finder(screen_loc, ignore);
if (!finder.result_.window() ||
!TopMostFinder::IsTopMostWindowAtPoint(finder.result_.window(),
finder.result_.hot_spot(),
ignore)) {
finder.result_.set_type(DockInfo::NONE);
}
return finder.result_;
}
protected:
virtual bool ShouldStopIterating(HWND hwnd) {
BrowserView* window = BrowserView::GetBrowserViewForNativeWindow(hwnd);
RECT bounds;
if (!window || !IsWindowVisible(hwnd) ||
!GetWindowRect(hwnd, &bounds)) {
return false;
}
// Check the three corners we allow docking to. We don't currently allow
// docking to top of window as it conflicts with docking to the tab strip.
if (CheckPoint(hwnd, bounds.left, (bounds.top + bounds.bottom) / 2,
DockInfo::LEFT_OF_WINDOW) ||
CheckPoint(hwnd, bounds.right - 1, (bounds.top + bounds.bottom) / 2,
DockInfo::RIGHT_OF_WINDOW) ||
CheckPoint(hwnd, (bounds.left + bounds.right) / 2, bounds.bottom - 1,
DockInfo::BOTTOM_OF_WINDOW)) {
return true;
}
return false;
}
private:
DockToWindowFinder(const gfx::Point& screen_loc,
const std::set<HWND>& ignore)
: BaseWindowFinder(ignore),
screen_loc_(screen_loc) {
HMONITOR monitor = MonitorFromPoint(screen_loc.ToPOINT(),
MONITOR_DEFAULTTONULL);
MONITORINFO monitor_info = {0};
monitor_info.cbSize = sizeof(MONITORINFO);
if (monitor && GetMonitorInfo(monitor, &monitor_info)) {
result_.set_monitor_bounds(gfx::Rect(monitor_info.rcWork));
EnumThreadWindows(GetCurrentThreadId(), WindowCallbackProc,
reinterpret_cast<LPARAM>(this));
}
}
bool CheckPoint(HWND hwnd, int x, int y, DockInfo::Type type) {
bool in_enable_area;
if (DockInfo::IsCloseToPoint(screen_loc_, x, y, &in_enable_area)) {
result_.set_in_enable_area(in_enable_area);
result_.set_window(hwnd);
result_.set_type(type);
result_.set_hot_spot(gfx::Point(x, y));
// Only show the hotspot if the monitor contains the bounds of the popup
// window. Otherwise we end with a weird situation where the popup window
// isn't completely visible.
return result_.monitor_bounds().Contains(result_.GetPopupRect());
}
return false;
}
// The location to look for.
gfx::Point screen_loc_;
// The resulting DockInfo.
DockInfo result_;
DISALLOW_COPY_AND_ASSIGN(DockToWindowFinder);
};
} // namespace
// DockInfo -------------------------------------------------------------------
// static
DockInfo DockInfo::GetDockInfoAtPoint(const gfx::Point& screen_point,
const std::set<HWND>& ignore) {
if (factory_)
return factory_->GetDockInfoAtPoint(screen_point, ignore);
// Try docking to a window first.
DockInfo info = DockToWindowFinder::GetDockInfoAtPoint(screen_point, ignore);
if (info.type() != DockInfo::NONE)
return info;
// No window relative positions. Try monitor relative positions.
const gfx::Rect& m_bounds = info.monitor_bounds();
int mid_x = m_bounds.x() + m_bounds.width() / 2;
int mid_y = m_bounds.y() + m_bounds.height() / 2;
bool result =
info.CheckMonitorPoint(screen_point, mid_x, m_bounds.y(),
DockInfo::MAXIMIZE) ||
info.CheckMonitorPoint(screen_point, mid_x, m_bounds.bottom(),
DockInfo::BOTTOM_HALF) ||
info.CheckMonitorPoint(screen_point, m_bounds.x(), mid_y,
DockInfo::LEFT_HALF) ||
info.CheckMonitorPoint(screen_point, m_bounds.right(), mid_y,
DockInfo::RIGHT_HALF);
return info;
}
HWND DockInfo::GetLocalProcessWindowAtPoint(const gfx::Point& screen_point,
const std::set<HWND>& ignore) {
if (factory_)
return factory_->GetLocalProcessWindowAtPoint(screen_point, ignore);
return
LocalProcessWindowFinder::GetProcessWindowAtPoint(screen_point, ignore);
}
bool DockInfo::GetWindowBounds(gfx::Rect* bounds) const {
RECT window_rect;
if (!window() || !GetWindowRect(window(), &window_rect))
return false;
*bounds = gfx::Rect(window_rect);
return true;
}
void DockInfo::SizeOtherWindowTo(const gfx::Rect& bounds) const {
if (IsZoomed(window())) {
// We're docking relative to another window, we need to make sure the
// window we're docking to isn't maximized.
ShowWindow(window(), SW_RESTORE | SW_SHOWNA);
}
SetWindowPos(window(), HWND_TOP, bounds.x(), bounds.y(), bounds.width(),
bounds.height(), SWP_NOACTIVATE | SWP_NOOWNERZORDER);
}
|