| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "ui/views/controls/native_control.h" | |
| 6 | |
| 7 #include <atlbase.h> | |
| 8 #include <atlapp.h> | |
| 9 #include <atlcrack.h> | |
| 10 #include <atlframe.h> | |
| 11 #include <atlmisc.h> | |
| 12 | |
| 13 #include "base/logging.h" | |
| 14 #include "base/memory/scoped_ptr.h" | |
| 15 #include "ui/base/accessibility/accessibility_types.h" | |
| 16 #include "ui/base/l10n/l10n_util_win.h" | |
| 17 #include "ui/base/view_prop.h" | |
| 18 #include "ui/events/keycodes/keyboard_code_conversion_win.h" | |
| 19 #include "ui/events/keycodes/keyboard_codes.h" | |
| 20 #include "ui/gfx/win/hwnd_util.h" | |
| 21 #include "ui/views/background.h" | |
| 22 #include "ui/views/controls/native/native_view_host.h" | |
| 23 #include "ui/views/focus/focus_manager.h" | |
| 24 #include "ui/views/widget/widget.h" | |
| 25 | |
| 26 using ui::ViewProp; | |
| 27 | |
| 28 namespace views { | |
| 29 | |
| 30 // Maps to the NativeControl. | |
| 31 static const char* const kNativeControlKey = "__NATIVE_CONTROL__"; | |
| 32 | |
| 33 class NativeControlContainer : public CWindowImpl<NativeControlContainer, | |
| 34 CWindow, | |
| 35 CWinTraits<WS_CHILD | WS_CLIPSIBLINGS | | |
| 36 WS_CLIPCHILDREN>> { | |
| 37 public: | |
| 38 explicit NativeControlContainer(NativeControl* parent) | |
| 39 : parent_(parent), | |
| 40 control_(NULL), | |
| 41 original_handler_(NULL) { | |
| 42 } | |
| 43 | |
| 44 void Init() { | |
| 45 Create(parent_->GetWidget()->GetNativeView()); | |
| 46 ::ShowWindow(m_hWnd, SW_SHOW); | |
| 47 } | |
| 48 | |
| 49 virtual ~NativeControlContainer() { | |
| 50 } | |
| 51 | |
| 52 // NOTE: If you add a new message, be sure and verify parent_ is valid before | |
| 53 // calling into parent_. | |
| 54 DECLARE_FRAME_WND_CLASS(L"ChromeViewsNativeControlContainer", NULL); | |
| 55 BEGIN_MSG_MAP(NativeControlContainer); | |
| 56 MSG_WM_CREATE(OnCreate); | |
| 57 MSG_WM_ERASEBKGND(OnEraseBkgnd); | |
| 58 MSG_WM_PAINT(OnPaint); | |
| 59 MSG_WM_SIZE(OnSize); | |
| 60 MSG_WM_NOTIFY(OnNotify); | |
| 61 MSG_WM_COMMAND(OnCommand); | |
| 62 MSG_WM_DESTROY(OnDestroy); | |
| 63 MSG_WM_CONTEXTMENU(OnContextMenu); | |
| 64 MSG_WM_CTLCOLORBTN(OnCtlColorBtn); | |
| 65 MSG_WM_CTLCOLORSTATIC(OnCtlColorStatic) | |
| 66 END_MSG_MAP(); | |
| 67 | |
| 68 HWND GetControl() { | |
| 69 return control_; | |
| 70 } | |
| 71 | |
| 72 // Called when the parent is getting deleted. This control stays around until | |
| 73 // it gets the OnFinalMessage call. | |
| 74 void ResetParent() { | |
| 75 parent_ = NULL; | |
| 76 } | |
| 77 | |
| 78 void OnFinalMessage(HWND hwnd) { | |
| 79 if (parent_) | |
| 80 parent_->NativeControlDestroyed(); | |
| 81 delete this; | |
| 82 } | |
| 83 | |
| 84 private: | |
| 85 friend class NativeControl; | |
| 86 | |
| 87 LRESULT OnCreate(LPCREATESTRUCT create_struct) { | |
| 88 control_ = parent_->CreateNativeControl(m_hWnd); | |
| 89 | |
| 90 // We subclass the control hwnd so we get the WM_KEYDOWN messages. | |
| 91 original_handler_ = gfx::SetWindowProc( | |
| 92 control_, &NativeControl::NativeControlWndProc); | |
| 93 prop_.reset(new ViewProp(control_, kNativeControlKey , parent_)); | |
| 94 | |
| 95 ::ShowWindow(control_, SW_SHOW); | |
| 96 return 1; | |
| 97 } | |
| 98 | |
| 99 LRESULT OnEraseBkgnd(HDC dc) { | |
| 100 return 1; | |
| 101 } | |
| 102 | |
| 103 void OnPaint(HDC ignore) { | |
| 104 PAINTSTRUCT ps; | |
| 105 HDC dc = ::BeginPaint(*this, &ps); | |
| 106 ::EndPaint(*this, &ps); | |
| 107 } | |
| 108 | |
| 109 void OnSize(int type, const CSize& sz) { | |
| 110 ::MoveWindow(control_, 0, 0, sz.cx, sz.cy, TRUE); | |
| 111 } | |
| 112 | |
| 113 LRESULT OnCommand(UINT code, int id, HWND source) { | |
| 114 return parent_ ? parent_->OnCommand(code, id, source) : 0; | |
| 115 } | |
| 116 | |
| 117 LRESULT OnNotify(int w_param, LPNMHDR l_param) { | |
| 118 if (parent_) | |
| 119 return parent_->OnNotify(w_param, l_param); | |
| 120 else | |
| 121 return 0; | |
| 122 } | |
| 123 | |
| 124 void OnDestroy() { | |
| 125 if (parent_) | |
| 126 parent_->OnDestroy(); | |
| 127 } | |
| 128 | |
| 129 void OnContextMenu(HWND window, const POINT& location) { | |
| 130 if (parent_) | |
| 131 parent_->OnContextMenu(location); | |
| 132 } | |
| 133 | |
| 134 // We need to find an ancestor with a non-null background, and | |
| 135 // ask it for a (solid color) brush that approximates | |
| 136 // the background. The caller will use this when drawing | |
| 137 // the native control as a background color, particularly | |
| 138 // for radiobuttons and XP style pushbuttons. | |
| 139 LRESULT OnCtlColor(UINT msg, HDC dc, HWND control) { | |
| 140 const View *ancestor = parent_; | |
| 141 while (ancestor) { | |
| 142 const Background *background = ancestor->background(); | |
| 143 if (background) { | |
| 144 HBRUSH brush = background->GetNativeControlBrush(); | |
| 145 if (brush) | |
| 146 return reinterpret_cast<LRESULT>(brush); | |
| 147 } | |
| 148 ancestor = ancestor->parent(); | |
| 149 } | |
| 150 | |
| 151 // COLOR_BTNFACE is the default for dialog box backgrounds. | |
| 152 return reinterpret_cast<LRESULT>(GetSysColorBrush(COLOR_BTNFACE)); | |
| 153 } | |
| 154 | |
| 155 LRESULT OnCtlColorBtn(HDC dc, HWND control) { | |
| 156 return OnCtlColor(WM_CTLCOLORBTN, dc, control); | |
| 157 } | |
| 158 | |
| 159 LRESULT OnCtlColorStatic(HDC dc, HWND control) { | |
| 160 return OnCtlColor(WM_CTLCOLORSTATIC, dc, control); | |
| 161 } | |
| 162 | |
| 163 NativeControl* parent_; | |
| 164 HWND control_; | |
| 165 | |
| 166 // Message handler that was set before we reset it. | |
| 167 WNDPROC original_handler_; | |
| 168 | |
| 169 scoped_ptr<ViewProp> prop_; | |
| 170 | |
| 171 DISALLOW_COPY_AND_ASSIGN(NativeControlContainer); | |
| 172 }; | |
| 173 | |
| 174 NativeControl::NativeControl() : hwnd_view_(NULL), | |
| 175 container_(NULL), | |
| 176 fixed_width_(-1), | |
| 177 horizontal_alignment_(CENTER), | |
| 178 fixed_height_(-1), | |
| 179 vertical_alignment_(CENTER) { | |
| 180 SetFocusable(true); | |
| 181 } | |
| 182 | |
| 183 NativeControl::~NativeControl() { | |
| 184 if (container_) { | |
| 185 container_->ResetParent(); | |
| 186 ::DestroyWindow(*container_); | |
| 187 } | |
| 188 } | |
| 189 | |
| 190 void NativeControl::ValidateNativeControl() { | |
| 191 if (hwnd_view_ == NULL) { | |
| 192 hwnd_view_ = new NativeViewHost; | |
| 193 AddChildView(hwnd_view_); | |
| 194 } | |
| 195 | |
| 196 if (!container_ && visible()) { | |
| 197 container_ = new NativeControlContainer(this); | |
| 198 container_->Init(); | |
| 199 hwnd_view_->Attach(*container_); | |
| 200 if (!enabled()) | |
| 201 EnableWindow(GetNativeControlHWND(), enabled()); | |
| 202 | |
| 203 // This message ensures that the focus border is shown. | |
| 204 ::SendMessage(container_->GetControl(), | |
| 205 WM_CHANGEUISTATE, | |
| 206 MAKELPARAM(UIS_CLEAR, UISF_HIDEFOCUS), | |
| 207 0); | |
| 208 } | |
| 209 } | |
| 210 | |
| 211 void NativeControl::ViewHierarchyChanged( | |
| 212 const ViewHierarchyChangedDetails& details) { | |
| 213 if (details.is_add && details.parent != this && !container_ && GetWidget()) { | |
| 214 ValidateNativeControl(); | |
| 215 Layout(); | |
| 216 } | |
| 217 } | |
| 218 | |
| 219 void NativeControl::Layout() { | |
| 220 if (!container_ && GetWidget()) | |
| 221 ValidateNativeControl(); | |
| 222 | |
| 223 if (hwnd_view_) { | |
| 224 gfx::Rect lb = GetLocalBounds(); | |
| 225 | |
| 226 int x = lb.x(); | |
| 227 int y = lb.y(); | |
| 228 int width = lb.width(); | |
| 229 int height = lb.height(); | |
| 230 if (fixed_width_ > 0) { | |
| 231 width = std::min(fixed_width_, width); | |
| 232 switch (horizontal_alignment_) { | |
| 233 case LEADING: | |
| 234 // Nothing to do. | |
| 235 break; | |
| 236 case CENTER: | |
| 237 x += (lb.width() - width) / 2; | |
| 238 break; | |
| 239 case TRAILING: | |
| 240 x = x + lb.width() - width; | |
| 241 break; | |
| 242 default: | |
| 243 NOTREACHED(); | |
| 244 } | |
| 245 } | |
| 246 | |
| 247 if (fixed_height_ > 0) { | |
| 248 height = std::min(fixed_height_, height); | |
| 249 switch (vertical_alignment_) { | |
| 250 case LEADING: | |
| 251 // Nothing to do. | |
| 252 break; | |
| 253 case CENTER: | |
| 254 y += (lb.height() - height) / 2; | |
| 255 break; | |
| 256 case TRAILING: | |
| 257 y = y + lb.height() - height; | |
| 258 break; | |
| 259 default: | |
| 260 NOTREACHED(); | |
| 261 } | |
| 262 } | |
| 263 | |
| 264 hwnd_view_->SetBounds(x, y, width, height); | |
| 265 } | |
| 266 } | |
| 267 | |
| 268 void NativeControl::OnContextMenu(const POINT& location) { | |
| 269 if (!context_menu_controller()) | |
| 270 return; | |
| 271 | |
| 272 if (location.x == -1 && location.y == -1) { | |
| 273 ShowContextMenu(GetKeyboardContextMenuLocation(), | |
| 274 ui::MENU_SOURCE_KEYBOARD); | |
| 275 } else { | |
| 276 ShowContextMenu(gfx::Point(location), ui::MENU_SOURCE_MOUSE); | |
| 277 } | |
| 278 } | |
| 279 | |
| 280 void NativeControl::OnFocus() { | |
| 281 if (container_) { | |
| 282 DCHECK(container_->GetControl()); | |
| 283 ::SetFocus(container_->GetControl()); | |
| 284 NotifyAccessibilityEvent(ui::AccessibilityTypes::EVENT_FOCUS, false); | |
| 285 } | |
| 286 } | |
| 287 | |
| 288 HWND NativeControl::GetNativeControlHWND() { | |
| 289 if (container_) | |
| 290 return container_->GetControl(); | |
| 291 else | |
| 292 return NULL; | |
| 293 } | |
| 294 | |
| 295 void NativeControl::NativeControlDestroyed() { | |
| 296 if (hwnd_view_) | |
| 297 hwnd_view_->Detach(); | |
| 298 container_ = NULL; | |
| 299 } | |
| 300 | |
| 301 void NativeControl::SetVisible(bool is_visible) { | |
| 302 if (is_visible != visible()) { | |
| 303 View::SetVisible(is_visible); | |
| 304 if (!is_visible && container_) | |
| 305 ::DestroyWindow(*container_); | |
| 306 else if (is_visible && !container_) | |
| 307 ValidateNativeControl(); | |
| 308 } | |
| 309 } | |
| 310 | |
| 311 void NativeControl::OnEnabledChanged() { | |
| 312 View::OnEnabledChanged(); | |
| 313 if (GetNativeControlHWND()) | |
| 314 EnableWindow(GetNativeControlHWND(), enabled()); | |
| 315 } | |
| 316 | |
| 317 void NativeControl::OnPaint(gfx::Canvas* canvas) { | |
| 318 } | |
| 319 | |
| 320 void NativeControl::VisibilityChanged(View* starting_from, bool is_visible) { | |
| 321 SetVisible(is_visible); | |
| 322 } | |
| 323 | |
| 324 void NativeControl::SetFixedWidth(int width, Alignment alignment) { | |
| 325 DCHECK_GT(width, 0); | |
| 326 fixed_width_ = width; | |
| 327 horizontal_alignment_ = alignment; | |
| 328 } | |
| 329 | |
| 330 void NativeControl::SetFixedHeight(int height, Alignment alignment) { | |
| 331 DCHECK_GT(height, 0); | |
| 332 fixed_height_ = height; | |
| 333 vertical_alignment_ = alignment; | |
| 334 } | |
| 335 | |
| 336 DWORD NativeControl::GetAdditionalExStyle() const { | |
| 337 // If the UI for the view is mirrored, we should make sure we add the | |
| 338 // extended window style for a right-to-left layout so the subclass creates | |
| 339 // a mirrored HWND for the underlying control. | |
| 340 DWORD ex_style = 0; | |
| 341 if (base::i18n::IsRTL()) | |
| 342 ex_style |= l10n_util::GetExtendedStyles(); | |
| 343 | |
| 344 return ex_style; | |
| 345 } | |
| 346 | |
| 347 DWORD NativeControl::GetAdditionalRTLStyle() const { | |
| 348 // If the UI for the view is mirrored, we should make sure we add the | |
| 349 // extended window style for a right-to-left layout so the subclass creates | |
| 350 // a mirrored HWND for the underlying control. | |
| 351 DWORD ex_style = 0; | |
| 352 if (base::i18n::IsRTL()) | |
| 353 ex_style |= l10n_util::GetExtendedTooltipStyles(); | |
| 354 | |
| 355 return ex_style; | |
| 356 } | |
| 357 | |
| 358 // static | |
| 359 LRESULT CALLBACK NativeControl::NativeControlWndProc(HWND window, | |
| 360 UINT message, | |
| 361 WPARAM w_param, | |
| 362 LPARAM l_param) { | |
| 363 NativeControl* native_control = static_cast<NativeControl*>( | |
| 364 ViewProp::GetValue(window, kNativeControlKey)); | |
| 365 DCHECK(native_control); | |
| 366 WNDPROC original_handler = native_control->container_->original_handler_; | |
| 367 DCHECK(original_handler); | |
| 368 | |
| 369 if (message == WM_KEYDOWN && | |
| 370 native_control->OnKeyDown(ui::KeyboardCodeForWindowsKeyCode(w_param))) { | |
| 371 return 0; | |
| 372 } else if (message == WM_SETFOCUS) { | |
| 373 // Let the focus manager know that the focus changed. | |
| 374 FocusManager* focus_manager = native_control->GetFocusManager(); | |
| 375 if (focus_manager) { | |
| 376 focus_manager->SetFocusedView(native_control); | |
| 377 } else { | |
| 378 NOTREACHED(); | |
| 379 } | |
| 380 } else if (message == WM_DESTROY) { | |
| 381 gfx::SetWindowProc(window, reinterpret_cast<WNDPROC>(original_handler)); | |
| 382 native_control->container_->prop_.reset(); | |
| 383 } | |
| 384 | |
| 385 return CallWindowProc(reinterpret_cast<WNDPROC>(original_handler), window, | |
| 386 message, w_param, l_param); | |
| 387 } | |
| 388 | |
| 389 } // namespace views | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 136003015:
Remove native_control* and some other non-Aura windows code (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src