1// Copyright 2013 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 "mojo/services/native_viewport/platform_viewport.h" 6 7#include "base/command_line.h" 8#include "base/message_loop/message_loop.h" 9#include "mojo/services/public/cpp/input_events/lib/mojo_extended_key_event_data.h" 10#include "ui/events/event.h" 11#include "ui/events/event_utils.h" 12#include "ui/events/platform/platform_event_dispatcher.h" 13#include "ui/events/platform/platform_event_source.h" 14#include "ui/gfx/rect.h" 15#include "ui/platform_window/platform_window.h" 16#include "ui/platform_window/platform_window_delegate.h" 17#include "ui/platform_window/x11/x11_window.h" 18 19namespace mojo { 20 21class PlatformViewportX11 : public PlatformViewport, 22 public ui::PlatformWindowDelegate { 23 public: 24 explicit PlatformViewportX11(Delegate* delegate) : delegate_(delegate) { 25 } 26 27 virtual ~PlatformViewportX11() { 28 // Destroy the platform-window while |this| is still alive. 29 platform_window_.reset(); 30 } 31 32 private: 33 // Overridden from PlatformViewport: 34 virtual void Init(const gfx::Rect& bounds) OVERRIDE { 35 CHECK(!event_source_); 36 CHECK(!platform_window_); 37 38 event_source_ = ui::PlatformEventSource::CreateDefault(); 39 40 platform_window_.reset(new ui::X11Window(this)); 41 platform_window_->SetBounds(bounds); 42 } 43 44 virtual void Show() OVERRIDE { 45 platform_window_->Show(); 46 } 47 48 virtual void Hide() OVERRIDE { 49 platform_window_->Hide(); 50 } 51 52 virtual void Close() OVERRIDE { 53 platform_window_->Close(); 54 } 55 56 virtual gfx::Size GetSize() OVERRIDE { 57 return bounds_.size(); 58 } 59 60 virtual void SetBounds(const gfx::Rect& bounds) OVERRIDE { 61 platform_window_->SetBounds(bounds); 62 } 63 64 virtual void SetCapture() OVERRIDE { 65 platform_window_->SetCapture(); 66 } 67 68 virtual void ReleaseCapture() OVERRIDE { 69 platform_window_->ReleaseCapture(); 70 } 71 72 // ui::PlatformWindowDelegate: 73 virtual void OnBoundsChanged(const gfx::Rect& new_bounds) OVERRIDE { 74 bounds_ = new_bounds; 75 delegate_->OnBoundsChanged(new_bounds); 76 } 77 78 virtual void OnDamageRect(const gfx::Rect& damaged_region) OVERRIDE { 79 } 80 81 virtual void DispatchEvent(ui::Event* event) OVERRIDE { 82 delegate_->OnEvent(event); 83 84 // We want to emulate the WM_CHAR generation behaviour of Windows. 85 // 86 // On Linux, we've previously inserted characters by having 87 // InputMethodAuraLinux take all key down events and send a character event 88 // to the TextInputClient. This causes a mismatch in code that has to be 89 // shared between Windows and Linux, including blink code. Now that we're 90 // trying to have one way of doing things, we need to standardize on and 91 // emulate Windows character events. 92 // 93 // This is equivalent to what we're doing in the current Linux port, but 94 // done once instead of done multiple times in different places. 95 if (event->type() == ui::ET_KEY_PRESSED) { 96 ui::KeyEvent* key_press_event = static_cast<ui::KeyEvent*>(event); 97 ui::KeyEvent char_event(key_press_event->GetCharacter(), 98 key_press_event->key_code(), 99 key_press_event->flags()); 100 101 DCHECK_EQ(key_press_event->GetCharacter(), char_event.GetCharacter()); 102 DCHECK_EQ(key_press_event->key_code(), char_event.key_code()); 103 DCHECK_EQ(key_press_event->flags(), char_event.flags()); 104 105 char_event.SetExtendedKeyEventData(scoped_ptr<ui::ExtendedKeyEventData>( 106 new MojoExtendedKeyEventData( 107 key_press_event->GetLocatedWindowsKeyboardCode(), 108 key_press_event->GetText(), 109 key_press_event->GetUnmodifiedText()))); 110 char_event.set_platform_keycode(key_press_event->platform_keycode()); 111 112 delegate_->OnEvent(&char_event); 113 } 114 } 115 116 virtual void OnCloseRequest() OVERRIDE { 117 platform_window_->Close(); 118 } 119 120 virtual void OnClosed() OVERRIDE { 121 delegate_->OnDestroyed(); 122 } 123 124 virtual void OnWindowStateChanged(ui::PlatformWindowState state) OVERRIDE { 125 } 126 127 virtual void OnLostCapture() OVERRIDE { 128 } 129 130 virtual void OnAcceleratedWidgetAvailable( 131 gfx::AcceleratedWidget widget) OVERRIDE { 132 delegate_->OnAcceleratedWidgetAvailable(widget); 133 } 134 135 virtual void OnActivationChanged(bool active) OVERRIDE {} 136 137 scoped_ptr<ui::PlatformEventSource> event_source_; 138 scoped_ptr<ui::PlatformWindow> platform_window_; 139 Delegate* delegate_; 140 gfx::Rect bounds_; 141 142 DISALLOW_COPY_AND_ASSIGN(PlatformViewportX11); 143}; 144 145// static 146scoped_ptr<PlatformViewport> PlatformViewport::Create(Delegate* delegate) { 147 return scoped_ptr<PlatformViewport>(new PlatformViewportX11(delegate)).Pass(); 148} 149 150} // namespace mojo 151