Migrate Event API methods to Google Style.

views/widget/root_view.cc

 // Copyright (c) 2011 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 "views/widget/root_view.h"
 
 #include <algorithm>
 
 #if defined(TOUCH_UI) && defined(HAVE_XINPUT2)
 #include <gdk/gdkx.h>
@@ skipping 368 matching lines @@
   return status;
 }
 #endif
 
 bool RootView::OnMousePressed(const MouseEvent& e) {
   // This function does not normally handle non-client messages except for
   // non-client double-clicks. Actually, all double-clicks are special as the
   // are formed from a single-click followed by a double-click event. When the
   // double-click event lands on a different view than its single-click part,
   // we transform it into a single-click which prevents odd things.
-  if ((e.GetFlags() & MouseEvent::EF_IS_NON_CLIENT) &&
-      !(e.GetFlags() & MouseEvent::EF_IS_DOUBLE_CLICK)) {
+  if ((e.flags() & MouseEvent::EF_IS_NON_CLIENT) &&
+      !(e.flags() & MouseEvent::EF_IS_DOUBLE_CLICK)) {
     last_click_handler_ = NULL;
     return false;
   }
 
   UpdateCursor(e);
   SetMouseLocationAndFlags(e);
 
   // If mouse_pressed_handler_ is non null, we are currently processing
   // a pressed -> drag -> released session. In that case we send the
   // event to mouse_pressed_handler_
@@ skipping 16 matching lines @@
       hit_disabled_view = true;
       break;
     }
 
     // See if this view wants to handle the mouse press.
     MouseEvent mouse_pressed_event(e, this, mouse_pressed_handler_);
 
     // Remove the double-click flag if the handler is different than the
     // one which got the first click part of the double-click.
     if (mouse_pressed_handler_ != last_click_handler_)
-      mouse_pressed_event.set_flags(e.GetFlags() &
+      mouse_pressed_event.set_flags(e.flags() &
                                     ~MouseEvent::EF_IS_DOUBLE_CLICK);
 
     drag_info.Reset();
     bool handled = mouse_pressed_handler_->ProcessMousePressed(
         mouse_pressed_event, &drag_info);
 
     // The view could have removed itself from the tree when handling
     // OnMousePressed().  In this case, the removal notification will have
     // reset mouse_pressed_handler_ to NULL out from under us.  Detect this
     // case and stop.  (See comments in view.h.)
@@ skipping 24 matching lines @@
     GtkWidget* widget = GetWidget()->GetNativeView();
     if (!gtk_widget_is_focus(widget))
       gtk_widget_grab_focus(widget);
 #endif
   }
 
   // In the event that a double-click is not handled after traversing the
   // entire hierarchy (even as a single-click when sent to a different view),
   // it must be marked as handled to avoid anything happening from default
   // processing if it the first click-part was handled by us.
-  if (last_click_handler_ && e.GetFlags() & MouseEvent::EF_IS_DOUBLE_CLICK)
+  if (last_click_handler_ && e.flags() & MouseEvent::EF_IS_DOUBLE_CLICK)
     hit_disabled_view = true;
 
   last_click_handler_ = NULL;
   return hit_disabled_view;
 }
 
 bool RootView::ConvertPointToMouseHandler(const gfx::Point& l,
                                           gfx::Point* p) {
   //
   // If the mouse_handler was set explicitly, we need to keep
@@ skipping 18 matching lines @@
   }
   return true;
 }
 
 void RootView::UpdateCursor(const MouseEvent& e) {
   gfx::NativeCursor cursor = NULL;
   View* v = GetViewForPoint(e.location());
   if (v && v != this) {
     gfx::Point l(e.location());
     View::ConvertPointToView(this, v, &l);
-    cursor = v->GetCursorForPoint(e.GetType(), l);
+    cursor = v->GetCursorForPoint(e.type(), l);
   }
   SetActiveCursor(cursor);
 }
 
 bool RootView::OnMouseDragged(const MouseEvent& e) {
   UpdateCursor(e);
 
   if (mouse_pressed_handler_) {
     SetMouseLocationAndFlags(e);
 
     gfx::Point p;
     ConvertPointToMouseHandler(e.location(), &p);
-    MouseEvent mouse_event(e.GetType(), p.x(), p.y(), e.GetFlags());
+    MouseEvent mouse_event(e.type(), p.x(), p.y(), e.flags());
     return mouse_pressed_handler_->ProcessMouseDragged(mouse_event, &drag_info);
   }
   return false;
 }
 
 void RootView::OnMouseReleased(const MouseEvent& e, bool canceled) {
   UpdateCursor(e);
 
   if (mouse_pressed_handler_) {
     gfx::Point p;
     ConvertPointToMouseHandler(e.location(), &p);
-    MouseEvent mouse_released(e.GetType(), p.x(), p.y(), e.GetFlags());
+    MouseEvent mouse_released(e.type(), p.x(), p.y(), e.flags());
     // We allow the view to delete us from ProcessMouseReleased. As such,
     // configure state such that we're done first, then call View.
     View* mouse_pressed_handler = mouse_pressed_handler_;
     mouse_pressed_handler_ = NULL;
     explicit_mouse_handler_ = false;
     mouse_pressed_handler->ProcessMouseReleased(mouse_released, canceled);
     // WARNING: we may have been deleted.
   }
 }
 
@@ skipping 22 matching lines @@
       mouse_move_handler_->OnMouseEntered(entered_event);
     }
     MouseEvent moved_event(Event::ET_MOUSE_MOVED,
                            this,
                            mouse_move_handler_,
                            e.location(),
                            0);
     mouse_move_handler_->OnMouseMoved(moved_event);
 
     gfx::NativeCursor cursor = mouse_move_handler_->GetCursorForPoint(
-        moved_event.GetType(), moved_event.location());
+        moved_event.type(), moved_event.location());
     SetActiveCursor(cursor);
   } else if (mouse_move_handler_ != NULL) {
     MouseEvent exited_event(Event::ET_MOUSE_EXITED, 0, 0, 0);
     mouse_move_handler_->OnMouseExited(exited_event);
     SetActiveCursor(NULL);
   }
 }
 
 void RootView::ProcessOnMouseExited() {
   if (mouse_move_handler_ != NULL) {
@@ skipping 83 matching lines @@
                                                 gfx::NativeView native_view) {
   PropagateNativeViewHierarchyChanged(attached, native_view, this);
 }
 
 bool RootView::ProcessKeyEvent(const KeyEvent& event) {
   bool consumed = false;
 
   View* v = GetFocusedView();
   // Special case to handle right-click context menus triggered by the
   // keyboard.
-  if (v && v->IsEnabled() && ((event.GetKeyCode() == ui::VKEY_APPS) ||
-     (event.GetKeyCode() == ui::VKEY_F10 && event.IsShiftDown()))) {
+  if (v && v->IsEnabled() && ((event.key_code() == ui::VKEY_APPS) ||
+     (event.key_code() == ui::VKEY_F10 && event.IsShiftDown()))) {
     v->ShowContextMenu(v->GetKeyboardContextMenuLocation(), false);
     return true;
   }
   for (; v && v != this && !consumed; v = v->parent()) {
-    consumed = (event.GetType() == Event::ET_KEY_PRESSED) ?
+    consumed = (event.type() == Event::ET_KEY_PRESSED) ?
         v->OnKeyPressed(event) : v->OnKeyReleased(event);
   }
 
   if (!consumed && default_keyboard_handler_) {
-    consumed = (event.GetType() == Event::ET_KEY_PRESSED) ?
+    consumed = (event.type() == Event::ET_KEY_PRESSED) ?
         default_keyboard_handler_->OnKeyPressed(event) :
         default_keyboard_handler_->OnKeyReleased(event);
   }
 
   return consumed;
 }
 
 bool RootView::ProcessMouseWheelEvent(const MouseWheelEvent& e) {
   View* v;
   bool consumed = false;
@@ skipping 46 matching lines @@
     return;
   view->registered_for_visible_bounds_notification_ = false;
   View* ancestor = view->parent();
   while (ancestor) {
     ancestor->RemoveDescendantToNotify(view);
     ancestor = ancestor->parent();
   }
 }
 
 void RootView::SetMouseLocationAndFlags(const MouseEvent& e) {
-  last_mouse_event_flags_ = e.GetFlags();
+  last_mouse_event_flags_ = e.flags();
   last_mouse_event_x_ = e.x();
   last_mouse_event_y_ = e.y();
 }
 
 std::string RootView::GetClassName() const {
   return kViewClassName;
 }
 
 void RootView::ClearPaintRect() {
   invalid_rect_.SetRect(0, 0, 0, 0);
@@ skipping 37 matching lines @@
   if (!TouchFactory::GetInstance()->is_cursor_visible()) {
     cursor = gfx::GetCursor(GDK_BLANK_CURSOR);
   }
 #endif
 
   gdk_window_set_cursor(native_view->window, cursor);
 #endif
 }
 
 }  // namespace views