diff options
Diffstat (limited to 'ui/aura/remote_window_tree_host_win.h')
| -rw-r--r-- | ui/aura/remote_window_tree_host_win.h | 309 |
1 files changed, 309 insertions, 0 deletions
diff --git a/ui/aura/remote_window_tree_host_win.h b/ui/aura/remote_window_tree_host_win.h new file mode 100644 index 0000000..738cb17 --- /dev/null +++ b/ui/aura/remote_window_tree_host_win.h @@ -0,0 +1,309 @@ +// Copyright (c) 2012 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 UI_AURA_REMOTE_WINDOW_TREE_HOST_WIN_H_ +#define UI_AURA_REMOTE_WINDOW_TREE_HOST_WIN_H_ + +#include <vector> + +#include "base/callback.h" +#include "base/compiler_specific.h" +#include "base/strings/string16.h" +#include "ui/aura/window_tree_host.h" +#include "ui/base/ime/remote_input_method_delegate_win.h" +#include "ui/events/event.h" +#include "ui/events/event_constants.h" +#include "ui/events/event_source.h" +#include "ui/gfx/native_widget_types.h" +#include "ui/metro_viewer/ime_types.h" + +struct MetroViewerHostMsg_MouseButtonParams; + +namespace base { +class FilePath; +} + +namespace ui { +class RemoteInputMethodPrivateWin; +class ViewProp; +} + +namespace IPC { +class Message; +class Sender; +} + +namespace aura { + +typedef base::Callback<void(const base::FilePath&, int, void*)> + OpenFileCompletion; + +typedef base::Callback<void(const std::vector<base::FilePath>&, void*)> + OpenMultipleFilesCompletion; + +typedef base::Callback<void(const base::FilePath&, int, void*)> + SaveFileCompletion; + +typedef base::Callback<void(const base::FilePath&, int, void*)> + SelectFolderCompletion; + +typedef base::Callback<void(void*)> FileSelectionCanceled; + +// Handles the open file operation for Metro Chrome Ash. The on_success +// callback passed in is invoked when we receive the opened file name from +// the metro viewer. The on failure callback is invoked on failure. +AURA_EXPORT void HandleOpenFile(const base::string16& title, + const base::FilePath& default_path, + const base::string16& filter, + const OpenFileCompletion& on_success, + const FileSelectionCanceled& on_failure); + +// Handles the open multiple file operation for Metro Chrome Ash. The +// on_success callback passed in is invoked when we receive the opened file +// names from the metro viewer. The on failure callback is invoked on failure. +AURA_EXPORT void HandleOpenMultipleFiles( + const base::string16& title, + const base::FilePath& default_path, + const base::string16& filter, + const OpenMultipleFilesCompletion& on_success, + const FileSelectionCanceled& on_failure); + +// Handles the save file operation for Metro Chrome Ash. The on_success +// callback passed in is invoked when we receive the saved file name from +// the metro viewer. The on failure callback is invoked on failure. +AURA_EXPORT void HandleSaveFile(const base::string16& title, + const base::FilePath& default_path, + const base::string16& filter, + int filter_index, + const base::string16& default_extension, + const SaveFileCompletion& on_success, + const FileSelectionCanceled& on_failure); + +// Handles the select folder for Metro Chrome Ash. The on_success +// callback passed in is invoked when we receive the folder name from the +// metro viewer. The on failure callback is invoked on failure. +AURA_EXPORT void HandleSelectFolder(const base::string16& title, + const SelectFolderCompletion& on_success, + const FileSelectionCanceled& on_failure); + +// Handles the activate desktop command for Metro Chrome Ash. The |ash_exit| +// parameter indicates whether the Ash process would be shutdown after +// activating the desktop. +AURA_EXPORT void HandleActivateDesktop( + const base::FilePath& shortcut, + bool ash_exit); + +// Handles the metro exit command. Notifies the metro viewer to shutdown +// gracefully. +AURA_EXPORT void HandleMetroExit(); + +// WindowTreeHost implementaton that receives events from a different +// process. In the case of Windows this is the Windows 8 (aka Metro) +// frontend process, which forwards input events to this class. +class AURA_EXPORT RemoteWindowTreeHostWin + : public WindowTreeHost, + public ui::EventSource, + public ui::internal::RemoteInputMethodDelegateWin { + public: + // Returns the only RemoteWindowTreeHostWin, if this is the first time + // this function is called, it will call Create() wiht empty bounds. + static RemoteWindowTreeHostWin* Instance(); + static RemoteWindowTreeHostWin* Create(const gfx::Rect& bounds); + + // Returns true if there is a RemoteWindowTreeHostWin and it has a valid + // HWND. A return value of false typically indicates we're not in metro mode. + static bool IsValid(); + + // Sets the handle to the remote window. The |remote_window| is the actual + // window owned by the viewer process. Call this before Connected() for some + // customers like input method initialization which needs the handle. + void SetRemoteWindowHandle(HWND remote_window); + + // The |host| can be used when we need to send a message to it. + void Connected(IPC::Sender* host); + // Called when the remote process has closed its IPC connection. + void Disconnected(); + + // Called when we have a message from the remote process. + bool OnMessageReceived(const IPC::Message& message); + + void HandleOpenURLOnDesktop(const base::FilePath& shortcut, + const base::string16& url); + + // The |ash_exit| parameter indicates whether the Ash process would be + // shutdown after activating the desktop. + void HandleActivateDesktop(const base::FilePath& shortcut, bool ash_exit); + + // Notify the metro viewer that it should shut itself down. + void HandleMetroExit(); + + void HandleOpenFile(const base::string16& title, + const base::FilePath& default_path, + const base::string16& filter, + const OpenFileCompletion& on_success, + const FileSelectionCanceled& on_failure); + + void HandleOpenMultipleFiles(const base::string16& title, + const base::FilePath& default_path, + const base::string16& filter, + const OpenMultipleFilesCompletion& on_success, + const FileSelectionCanceled& on_failure); + + void HandleSaveFile(const base::string16& title, + const base::FilePath& default_path, + const base::string16& filter, + int filter_index, + const base::string16& default_extension, + const SaveFileCompletion& on_success, + const FileSelectionCanceled& on_failure); + + void HandleSelectFolder(const base::string16& title, + const SelectFolderCompletion& on_success, + const FileSelectionCanceled& on_failure); + + void HandleWindowSizeChanged(uint32 width, uint32 height); + + // Returns the active ASH root window. + Window* GetAshWindow(); + + // Returns true if the remote window is the foreground window according to the + // OS. + bool IsForegroundWindow(); + + private: + explicit RemoteWindowTreeHostWin(const gfx::Rect& bounds); + virtual ~RemoteWindowTreeHostWin(); + + // IPC message handing methods: + void OnMouseMoved(int32 x, int32 y, int32 flags); + void OnMouseButton(const MetroViewerHostMsg_MouseButtonParams& params); + void OnKeyDown(uint32 vkey, + uint32 repeat_count, + uint32 scan_code, + uint32 flags); + void OnKeyUp(uint32 vkey, + uint32 repeat_count, + uint32 scan_code, + uint32 flags); + void OnChar(uint32 key_code, + uint32 repeat_count, + uint32 scan_code, + uint32 flags); + void OnWindowActivated(); + void OnEdgeGesture(); + void OnTouchDown(int32 x, int32 y, uint64 timestamp, uint32 pointer_id); + void OnTouchUp(int32 x, int32 y, uint64 timestamp, uint32 pointer_id); + void OnTouchMoved(int32 x, int32 y, uint64 timestamp, uint32 pointer_id); + void OnFileSaveAsDone(bool success, + const base::FilePath& filename, + int filter_index); + void OnFileOpenDone(bool success, const base::FilePath& filename); + void OnMultiFileOpenDone(bool success, + const std::vector<base::FilePath>& files); + void OnSelectFolderDone(bool success, const base::FilePath& folder); + void OnSetCursorPosAck(); + + // For Input Method support: + ui::RemoteInputMethodPrivateWin* GetRemoteInputMethodPrivate(); + void OnImeCandidatePopupChanged(bool visible); + void OnImeCompositionChanged( + const base::string16& text, + int32 selection_start, + int32 selection_end, + const std::vector<metro_viewer::UnderlineInfo>& underlines); + void OnImeTextCommitted(const base::string16& text); + void OnImeInputSourceChanged(uint16 language_id, bool is_ime); + + // WindowTreeHost overrides: + virtual RootWindow* GetRootWindow() OVERRIDE; + virtual gfx::AcceleratedWidget GetAcceleratedWidget() OVERRIDE; + virtual void Show() OVERRIDE; + virtual void Hide() OVERRIDE; + virtual void ToggleFullScreen() OVERRIDE; + virtual gfx::Rect GetBounds() const OVERRIDE; + virtual void SetBounds(const gfx::Rect& bounds) OVERRIDE; + virtual gfx::Insets GetInsets() const OVERRIDE; + virtual void SetInsets(const gfx::Insets& insets) OVERRIDE; + virtual gfx::Point GetLocationOnNativeScreen() const OVERRIDE; + virtual void SetCapture() OVERRIDE; + virtual void ReleaseCapture() OVERRIDE; + virtual void SetCursor(gfx::NativeCursor cursor) OVERRIDE; + virtual bool QueryMouseLocation(gfx::Point* location_return) OVERRIDE; + virtual bool ConfineCursorToRootWindow() OVERRIDE; + virtual void UnConfineCursor() OVERRIDE; + virtual void OnCursorVisibilityChanged(bool show) OVERRIDE; + virtual void MoveCursorTo(const gfx::Point& location) OVERRIDE; + virtual void PostNativeEvent(const base::NativeEvent& native_event) OVERRIDE; + virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE; + virtual void PrepareForShutdown() OVERRIDE; + + // ui::EventSource: + virtual ui::EventProcessor* GetEventProcessor() OVERRIDE; + + // ui::internal::RemoteInputMethodDelegateWin overrides: + virtual void CancelComposition() OVERRIDE; + virtual void OnTextInputClientUpdated( + const std::vector<int32>& input_scopes, + const std::vector<gfx::Rect>& composition_character_bounds) OVERRIDE; + + // Helper function to dispatch a keyboard message to the desired target. + // The default target is the WindowTreeHostDelegate. For nested message loop + // invocations we post a synthetic keyboard message directly into the message + // loop. The dispatcher for the nested loop would then decide how this + // message is routed. + void DispatchKeyboardMessage(ui::EventType type, + uint32 vkey, + uint32 repeat_count, + uint32 scan_code, + uint32 flags, + bool is_character); + + // Sets the event flags. |flags| is a bitmask of EventFlags. If there is a + // change the system virtual key state is updated as well. This way if chrome + // queries for key state it matches that of event being dispatched. + void SetEventFlags(uint32 flags); + + uint32 mouse_event_flags() const { + return event_flags_ & (ui::EF_LEFT_MOUSE_BUTTON | + ui::EF_MIDDLE_MOUSE_BUTTON | + ui::EF_RIGHT_MOUSE_BUTTON); + } + + uint32 key_event_flags() const { + return event_flags_ & (ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | + ui::EF_ALT_DOWN | ui::EF_CAPS_LOCK_DOWN); + } + + HWND remote_window_; + IPC::Sender* host_; + scoped_ptr<ui::ViewProp> prop_; + + // Saved callbacks which inform the caller about the result of the open file/ + // save file/select operations. + OpenFileCompletion file_open_completion_callback_; + OpenMultipleFilesCompletion multi_file_open_completion_callback_; + SaveFileCompletion file_saveas_completion_callback_; + SelectFolderCompletion select_folder_completion_callback_; + FileSelectionCanceled failure_callback_; + + // Set to true if we need to ignore mouse messages until the SetCursorPos + // operation is acked by the viewer. + bool ignore_mouse_moves_until_set_cursor_ack_; + + // Tracking last click event for synthetically generated mouse events. + scoped_ptr<ui::MouseEvent> last_mouse_click_event_; + + // State of the keyboard/mouse at the time of the last input event. See + // description of SetEventFlags(). + uint32 event_flags_; + + // Current size of this root window. + gfx::Size window_size_; + + DISALLOW_COPY_AND_ASSIGN(RemoteWindowTreeHostWin); +}; + +} // namespace aura + +#endif // UI_AURA_REMOTE_WINDOW_TREE_HOST_WIN_H_ |