ui/aura/remote_window_tree_host_win.cc

   1 // Copyright (c) 2012 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/aura/remote_window_tree_host_win.h"
   6
   7 #include <windows.h>
   8
   9 #include <algorithm>
  10
  11 #include "base/message_loop/message_loop.h"
  12 #include "ipc/ipc_message.h"
  13 #include "ipc/ipc_sender.h"
  14 #include "ui/aura/client/aura_constants.h"
  15 #include "ui/aura/client/cursor_client.h"
  16 #include "ui/aura/window_event_dispatcher.h"
  17 #include "ui/aura/window_property.h"
  18 #include "ui/base/cursor/cursor_loader_win.h"
  19 #include "ui/base/ime/composition_text.h"
  20 #include "ui/base/ime/input_method.h"
  21 #include "ui/base/ime/remote_input_method_win.h"
  22 #include "ui/base/ime/text_input_client.h"
  23 #include "ui/base/view_prop.h"
  24 #include "ui/events/event_utils.h"
  25 #include "ui/events/keycodes/keyboard_code_conversion_win.h"
  26 #include "ui/gfx/insets.h"
  27 #include "ui/gfx/win/dpi.h"
  28 #include "ui/metro_viewer/metro_viewer_messages.h"
  29
  30 namespace aura {
  31
  32 namespace {
  33
  34 const char* kWindowTreeHostWinKey = "__AURA_REMOTE_WINDOW_TREE_HOST_WIN__";
  35
  36 // Sets the keystate for the virtual key passed in to down or up.
  37 void SetKeyState(uint8* key_states, bool key_down, uint32 virtual_key_code) {
  38   DCHECK(key_states);
  39
  40   if (key_down)
  41     key_states[virtual_key_code] |= 0x80;
  42   else
  43     key_states[virtual_key_code] &= 0x7F;
  44 }
  45
  46 // Sets the keyboard states for the Shift/Control/Alt/Caps lock keys.
  47 void SetVirtualKeyStates(uint32 flags) {
  48   uint8 keyboard_state[256] = {0};
  49   ::GetKeyboardState(keyboard_state);
  50
  51   SetKeyState(keyboard_state, !!(flags & ui::EF_SHIFT_DOWN), VK_SHIFT);
  52   SetKeyState(keyboard_state, !!(flags & ui::EF_CONTROL_DOWN), VK_CONTROL);
  53   SetKeyState(keyboard_state, !!(flags & ui::EF_ALT_DOWN), VK_MENU);
  54   SetKeyState(keyboard_state, !!(flags & ui::EF_CAPS_LOCK_DOWN), VK_CAPITAL);
  55   SetKeyState(keyboard_state, !!(flags & ui::EF_LEFT_MOUSE_BUTTON), VK_LBUTTON);
  56   SetKeyState(keyboard_state, !!(flags & ui::EF_RIGHT_MOUSE_BUTTON),
  57               VK_RBUTTON);
  58   SetKeyState(keyboard_state, !!(flags & ui::EF_MIDDLE_MOUSE_BUTTON),
  59               VK_MBUTTON);
  60
  61   ::SetKeyboardState(keyboard_state);
  62 }
  63
  64 void FillCompositionText(
  65     const base::string16& text,
  66     int32 selection_start,
  67     int32 selection_end,
  68     const std::vector<metro_viewer::UnderlineInfo>& underlines,
  69     ui::CompositionText* composition_text) {
  70   composition_text->Clear();
  71   composition_text->text = text;
  72   composition_text->selection.set_start(selection_start);
  73   composition_text->selection.set_end(selection_end);
  74   composition_text->underlines.resize(underlines.size());
  75   for (size_t i = 0; i < underlines.size(); ++i) {
  76     composition_text->underlines[i].start_offset = underlines[i].start_offset;
  77     composition_text->underlines[i].end_offset = underlines[i].end_offset;
  78     composition_text->underlines[i].color = SK_ColorBLACK;
  79     composition_text->underlines[i].thick = underlines[i].thick;
  80     composition_text->underlines[i].background_color = SK_ColorTRANSPARENT;
  81   }
  82 }
  83
  84 }  // namespace
  85
  86 RemoteWindowTreeHostWin* g_instance = NULL;
  87
  88 // static
  89 RemoteWindowTreeHostWin* RemoteWindowTreeHostWin::Instance() {
  90   return g_instance;
  91 }
  92
  93 RemoteWindowTreeHostWin::RemoteWindowTreeHostWin()
  94     : remote_window_(NULL),
  95       host_(NULL),
  96       ignore_mouse_moves_until_set_cursor_ack_(0),
  97       event_flags_(0),
  98       window_size_(aura::WindowTreeHost::GetNativeScreenSize()) {
  99   CHECK(!g_instance);
 100   g_instance = this;
 101   prop_.reset(new ui::ViewProp(NULL, kWindowTreeHostWinKey, this));
 102   CreateCompositor(GetAcceleratedWidget());
 103 }
 104
 105 RemoteWindowTreeHostWin::~RemoteWindowTreeHostWin() {
 106   DestroyCompositor();
 107   DestroyDispatcher();
 108   DCHECK_EQ(g_instance, this);
 109   g_instance = NULL;
 110 }
 111
 112 // static
 113 bool RemoteWindowTreeHostWin::IsValid() {
 114   return Instance()->remote_window_ != NULL;
 115 }
 116
 117 void RemoteWindowTreeHostWin::SetRemoteWindowHandle(HWND remote_window) {
 118   remote_window_ = remote_window;
 119 }
 120
 121 void RemoteWindowTreeHostWin::Connected(IPC::Sender* host) {
 122   CHECK(host_ == NULL);
 123   DCHECK(remote_window_);
 124   host_ = host;
 125   // Recreate the compositor for the target surface represented by the
 126   // remote_window HWND.
 127   CreateCompositor(remote_window_);
 128   InitCompositor();
 129 }
 130
 131 void RemoteWindowTreeHostWin::Disconnected() {
 132   // Don't CHECK here, Disconnected is called on a channel error which can
 133   // happen before we're successfully Connected.
 134   if (!host_)
 135     return;
 136   ui::RemoteInputMethodPrivateWin* remote_input_method_private =
 137       GetRemoteInputMethodPrivate();
 138   if (remote_input_method_private)
 139     remote_input_method_private->SetRemoteDelegate(NULL);
 140   host_ = NULL;
 141   remote_window_ = NULL;
 142 }
 143
 144 bool RemoteWindowTreeHostWin::OnMessageReceived(const IPC::Message& message) {
 145   bool handled = true;
 146   IPC_BEGIN_MESSAGE_MAP(RemoteWindowTreeHostWin, message)
 147     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_MouseMoved, OnMouseMoved)
 148     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_MouseButton, OnMouseButton)
 149     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_KeyDown, OnKeyDown)
 150     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_KeyUp, OnKeyUp)
 151     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_Character, OnChar)
 152     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_WindowActivated,
 153                         OnWindowActivated)
 154     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_EdgeGesture, OnEdgeGesture)
 155     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_TouchDown,
 156                         OnTouchDown)
 157     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_TouchUp,
 158                         OnTouchUp)
 159     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_TouchMoved,
 160                         OnTouchMoved)
 161     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_SetCursorPosAck,
 162                         OnSetCursorPosAck)
 163     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_ImeCandidatePopupChanged,
 164                         OnImeCandidatePopupChanged)
 165     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_ImeCompositionChanged,
 166                         OnImeCompositionChanged)
 167     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_ImeTextCommitted,
 168                         OnImeTextCommitted)
 169     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_ImeInputSourceChanged,
 170                         OnImeInputSourceChanged)
 171     IPC_MESSAGE_UNHANDLED(handled = false)
 172   IPC_END_MESSAGE_MAP()
 173   return handled;
 174 }
 175
 176 void RemoteWindowTreeHostWin::HandleOpenURLOnDesktop(
 177     const base::FilePath& shortcut,
 178     const base::string16& url) {
 179   if (!host_)
 180     return;
 181   host_->Send(new MetroViewerHostMsg_OpenURLOnDesktop(shortcut, url));
 182 }
 183
 184 void RemoteWindowTreeHostWin::HandleWindowSizeChanged(uint32 width,
 185                                                       uint32 height) {
 186   SetBounds(gfx::Rect(0, 0, width, height));
 187 }
 188
 189 bool RemoteWindowTreeHostWin::IsForegroundWindow() {
 190   return ::GetForegroundWindow() == remote_window_;
 191 }
 192
 193 Window* RemoteWindowTreeHostWin::GetAshWindow() {
 194   return window();
 195 }
 196
 197 ui::EventSource* RemoteWindowTreeHostWin::GetEventSource() {
 198   return this;
 199 }
 200
 201 gfx::AcceleratedWidget RemoteWindowTreeHostWin::GetAcceleratedWidget() {
 202   if (remote_window_)
 203     return remote_window_;
 204   // Getting here should only happen for ash_unittests.exe and related code.
 205   return ::GetDesktopWindow();
 206 }
 207
 208 void RemoteWindowTreeHostWin::Show() {
 209   ui::RemoteInputMethodPrivateWin* remote_input_method_private =
 210       GetRemoteInputMethodPrivate();
 211   if (remote_input_method_private)
 212     remote_input_method_private->SetRemoteDelegate(this);
 213 }
 214
 215 void RemoteWindowTreeHostWin::Hide() {
 216   NOTIMPLEMENTED();
 217 }
 218
 219 gfx::Rect RemoteWindowTreeHostWin::GetBounds() const {
 220   return gfx::Rect(window_size_);
 221 }
 222
 223 void RemoteWindowTreeHostWin::SetBounds(const gfx::Rect& bounds) {
 224   window_size_ = bounds.size();
 225   OnHostResized(bounds.size());
 226 }
 227
 228 gfx::Point RemoteWindowTreeHostWin::GetLocationOnNativeScreen() const {
 229   return gfx::Point(0, 0);
 230 }
 231
 232 void RemoteWindowTreeHostWin::SetCapture() {
 233 }
 234
 235 void RemoteWindowTreeHostWin::ReleaseCapture() {
 236 }
 237
 238 void RemoteWindowTreeHostWin::SetCursorNative(gfx::NativeCursor native_cursor) {
 239   if (!host_)
 240     return;
 241   host_->Send(
 242       new MetroViewerHostMsg_SetCursor(uint64(native_cursor.platform())));
 243 }
 244
 245 void RemoteWindowTreeHostWin::MoveCursorToNative(const gfx::Point& location) {
 246   VLOG(1) << "In MoveCursorTo: " << location.x() << ", " << location.y();
 247   if (!host_)
 248     return;
 249
 250   // This function can be called in cases like when the mouse cursor is
 251   // restricted within a viewport (For e.g. LockCursor) which assumes that
 252   // subsequent mouse moves would be received starting with the new cursor
 253   // coordinates. This is a challenge for Windows ASH for the reasons
 254   // outlined below.
 255   // Other cases which don't expect this behavior should continue to work
 256   // without issues.
 257
 258   // The mouse events are received by the viewer process and sent to the
 259   // browser. If we invoke the SetCursor API here we continue to receive
 260   // mouse messages from the viewer which were posted before the SetCursor
 261   // API executes which messes up the state in the browser. To workaround
 262   // this we invoke the SetCursor API in the viewer process and ignore
 263   // mouse messages until we received an ACK from the viewer indicating that
 264   // the SetCursor operation completed.
 265   ignore_mouse_moves_until_set_cursor_ack_++;
 266   VLOG(1) << "In MoveCursorTo. Sending IPC";
 267   host_->Send(new MetroViewerHostMsg_SetCursorPos(location.x(), location.y()));
 268 }
 269
 270 void RemoteWindowTreeHostWin::OnCursorVisibilityChangedNative(bool show) {
 271   NOTIMPLEMENTED();
 272 }
 273
 274 void RemoteWindowTreeHostWin::PostNativeEvent(
 275     const base::NativeEvent& native_event) {
 276 }
 277
 278 ui::EventProcessor* RemoteWindowTreeHostWin::GetEventProcessor() {
 279   return dispatcher();
 280 }
 281
 282 void RemoteWindowTreeHostWin::CancelComposition() {
 283   if (!host_)
 284     return;
 285   host_->Send(new MetroViewerHostMsg_ImeCancelComposition);
 286 }
 287
 288 void RemoteWindowTreeHostWin::OnTextInputClientUpdated(
 289     const std::vector<int32>& input_scopes,
 290     const std::vector<gfx::Rect>& composition_character_bounds) {
 291   if (!host_)
 292     return;
 293   std::vector<metro_viewer::CharacterBounds> character_bounds;
 294   for (size_t i = 0; i < composition_character_bounds.size(); ++i) {
 295     const gfx::Rect& rect = composition_character_bounds[i];
 296     metro_viewer::CharacterBounds bounds;
 297     bounds.left = rect.x();
 298     bounds.top = rect.y();
 299     bounds.right = rect.right();
 300     bounds.bottom = rect.bottom();
 301     character_bounds.push_back(bounds);
 302   }
 303   host_->Send(new MetroViewerHostMsg_ImeTextInputClientUpdated(
 304       input_scopes, character_bounds));
 305 }
 306
 307 gfx::Point PointFromNativeEvent(int32 x, int32 y) {
 308   static float scale_factor = gfx::GetDPIScale();
 309   gfx::Point result( x * scale_factor, y * scale_factor);
 310   return result;
 311 }
 312
 313 void RemoteWindowTreeHostWin::OnMouseMoved(int32 x, int32 y, int32 flags) {
 314   if (ignore_mouse_moves_until_set_cursor_ack_)
 315     return;
 316
 317   gfx::Point location = PointFromNativeEvent(x, y);
 318   ui::MouseEvent event(ui::ET_MOUSE_MOVED, location, location, flags, 0);
 319   SendEventToProcessor(&event);
 320 }
 321
 322 void RemoteWindowTreeHostWin::OnMouseButton(
 323     const MetroViewerHostMsg_MouseButtonParams& params) {
 324   gfx::Point location = PointFromNativeEvent(params.x, params.y);
 325   ui::MouseEvent mouse_event(params.event_type, location, location,
 326                              static_cast<int>(params.flags),
 327                              static_cast<int>(params.changed_button));
 328
 329   SetEventFlags(params.flags | key_event_flags());
 330   if (params.event_type == ui::ET_MOUSEWHEEL) {
 331     int x_offset = params.is_horizontal_wheel ? params.extra : 0;
 332     int y_offset = !params.is_horizontal_wheel ? params.extra : 0;
 333     ui::MouseWheelEvent wheel_event(mouse_event, x_offset, y_offset);
 334     SendEventToProcessor(&wheel_event);
 335   } else if (params.event_type == ui::ET_MOUSE_PRESSED) {
 336     // TODO(shrikant): Ideally modify code in event.cc by adding automatic
 337     // tracking of double clicks in synthetic MouseEvent constructor code.
 338     // Non-synthetic MouseEvent constructor code does automatically track
 339     // this. Need to use some caution while modifying synthetic constructor
 340     // as many tests and other code paths depend on it and apparently
 341     // specifically depend on non implicit tracking of previous mouse event.
 342     if (last_mouse_click_event_ &&
 343         ui::MouseEvent::IsRepeatedClickEvent(mouse_event,
 344                                              *last_mouse_click_event_)) {
 345       mouse_event.SetClickCount(2);
 346     } else {
 347       mouse_event.SetClickCount(1);
 348     }
 349     last_mouse_click_event_ .reset(new ui::MouseEvent(mouse_event));
 350     SendEventToProcessor(&mouse_event);
 351   } else {
 352     SendEventToProcessor(&mouse_event);
 353   }
 354 }
 355
 356 void RemoteWindowTreeHostWin::OnKeyDown(uint32 vkey,
 357                                         uint32 repeat_count,
 358                                         uint32 scan_code,
 359                                         uint32 flags) {
 360   DispatchKeyboardMessage(ui::ET_KEY_PRESSED, vkey, repeat_count, scan_code,
 361                           flags, false);
 362 }
 363
 364 void RemoteWindowTreeHostWin::OnKeyUp(uint32 vkey,
 365                                       uint32 repeat_count,
 366                                       uint32 scan_code,
 367                                       uint32 flags) {
 368   DispatchKeyboardMessage(ui::ET_KEY_RELEASED, vkey, repeat_count, scan_code,
 369                           flags, false);
 370 }
 371
 372 void RemoteWindowTreeHostWin::OnChar(uint32 key_code,
 373                                      uint32 repeat_count,
 374                                      uint32 scan_code,
 375                                      uint32 flags) {
 376   DispatchKeyboardMessage(ui::ET_KEY_PRESSED, key_code, repeat_count,
 377                           scan_code, flags, true);
 378 }
 379
 380 void RemoteWindowTreeHostWin::OnWindowActivated(bool repaint) {
 381   OnHostActivated();
 382   if (repaint && compositor())
 383     compositor()->ScheduleFullRedraw();
 384 }
 385
 386 void RemoteWindowTreeHostWin::OnEdgeGesture() {
 387   ui::GestureEvent event(
 388       0,
 389       0,
 390       0,
 391       ui::EventTimeForNow(),
 392       ui::GestureEventDetails(ui::ET_GESTURE_WIN8_EDGE_SWIPE, 0, 0));
 393   SendEventToProcessor(&event);
 394 }
 395
 396 void RemoteWindowTreeHostWin::OnTouchDown(int32 x,
 397                                           int32 y,
 398                                           uint64 timestamp,
 399                                           uint32 pointer_id) {
 400   gfx::Point location = PointFromNativeEvent(x, y);
 401   ui::TouchEvent event(ui::ET_TOUCH_PRESSED,
 402                        location,
 403                        pointer_id,
 404                        base::TimeDelta::FromMicroseconds(timestamp));
 405   SendEventToProcessor(&event);
 406 }
 407
 408 void RemoteWindowTreeHostWin::OnTouchUp(int32 x,
 409                                         int32 y,
 410                                         uint64 timestamp,
 411                                         uint32 pointer_id) {
 412   gfx::Point location = PointFromNativeEvent(x, y);
 413   ui::TouchEvent event(ui::ET_TOUCH_RELEASED,
 414                        location,
 415                        pointer_id,
 416                        base::TimeDelta::FromMicroseconds(timestamp));
 417   SendEventToProcessor(&event);
 418 }
 419
 420 void RemoteWindowTreeHostWin::OnTouchMoved(int32 x,
 421                                            int32 y,
 422                                            uint64 timestamp,
 423                                            uint32 pointer_id) {
 424   gfx::Point location = PointFromNativeEvent(x, y);
 425   ui::TouchEvent event(ui::ET_TOUCH_MOVED,
 426                        location,
 427                        pointer_id,
 428                        base::TimeDelta::FromMicroseconds(timestamp));
 429   SendEventToProcessor(&event);
 430 }
 431
 432 void RemoteWindowTreeHostWin::OnSetCursorPosAck() {
 433   DCHECK_GT(ignore_mouse_moves_until_set_cursor_ack_, 0);
 434   ignore_mouse_moves_until_set_cursor_ack_--;
 435 }
 436
 437 ui::RemoteInputMethodPrivateWin*
 438 RemoteWindowTreeHostWin::GetRemoteInputMethodPrivate() {
 439   ui::InputMethod* input_method = GetAshWindow()->GetProperty(
 440       aura::client::kRootWindowInputMethodKey);
 441   return ui::RemoteInputMethodPrivateWin::Get(input_method);
 442 }
 443
 444 void RemoteWindowTreeHostWin::OnImeCandidatePopupChanged(bool visible) {
 445   ui::RemoteInputMethodPrivateWin* remote_input_method_private =
 446       GetRemoteInputMethodPrivate();
 447   if (!remote_input_method_private)
 448     return;
 449   remote_input_method_private->OnCandidatePopupChanged(visible);
 450 }
 451
 452 void RemoteWindowTreeHostWin::OnImeCompositionChanged(
 453     const base::string16& text,
 454     int32 selection_start,
 455     int32 selection_end,
 456     const std::vector<metro_viewer::UnderlineInfo>& underlines) {
 457   ui::RemoteInputMethodPrivateWin* remote_input_method_private =
 458       GetRemoteInputMethodPrivate();
 459   if (!remote_input_method_private)
 460     return;
 461   ui::CompositionText composition_text;
 462   FillCompositionText(
 463       text, selection_start, selection_end, underlines, &composition_text);
 464   remote_input_method_private->OnCompositionChanged(composition_text);
 465 }
 466
 467 void RemoteWindowTreeHostWin::OnImeTextCommitted(const base::string16& text) {
 468   ui::RemoteInputMethodPrivateWin* remote_input_method_private =
 469       GetRemoteInputMethodPrivate();
 470   if (!remote_input_method_private)
 471     return;
 472   remote_input_method_private->OnTextCommitted(text);
 473 }
 474
 475 void RemoteWindowTreeHostWin::OnImeInputSourceChanged(uint16 language_id,
 476                                                       bool is_ime) {
 477   ui::RemoteInputMethodPrivateWin* remote_input_method_private =
 478       GetRemoteInputMethodPrivate();
 479   if (!remote_input_method_private)
 480     return;
 481   remote_input_method_private->OnInputSourceChanged(language_id, is_ime);
 482 }
 483
 484 void RemoteWindowTreeHostWin::DispatchKeyboardMessage(ui::EventType type,
 485                                                       uint32 vkey,
 486                                                       uint32 repeat_count,
 487                                                       uint32 scan_code,
 488                                                       uint32 flags,
 489                                                       bool is_character) {
 490   SetEventFlags(flags | mouse_event_flags());
 491   if (base::MessageLoop::current()->IsNested()) {
 492     int index = (flags & ui::EF_ALT_DOWN) ? 1 : 0;
 493     const int char_message[] = {WM_CHAR, WM_SYSCHAR};
 494     const int keydown_message[] = {WM_KEYDOWN, WM_SYSKEYDOWN};
 495     const int keyup_message[] = {WM_KEYUP, WM_SYSKEYUP};
 496     uint32 message = is_character
 497                          ? char_message[index]
 498                          : (type == ui::ET_KEY_PRESSED ? keydown_message[index]
 499                                                        : keyup_message[index]);
 500     ::PostThreadMessage(::GetCurrentThreadId(),
 501                         message,
 502                         vkey,
 503                         repeat_count | scan_code >> 15);
 504   } else if (is_character) {
 505     ui::KeyEvent event(static_cast<base::char16>(vkey),
 506                        ui::KeyboardCodeForWindowsKeyCode(vkey),
 507                        flags);
 508     SendEventToProcessor(&event);
 509   } else {
 510     ui::KeyEvent event(type,
 511                        ui::KeyboardCodeForWindowsKeyCode(vkey),
 512                        flags);
 513     SendEventToProcessor(&event);
 514   }
 515 }
 516
 517 void RemoteWindowTreeHostWin::SetEventFlags(uint32 flags) {
 518   if (flags == event_flags_)
 519     return;
 520   event_flags_ = flags;
 521   SetVirtualKeyStates(event_flags_);
 522 }
 523
 524 }  // namespace aura