Context menu for title bar doesn't appear...

chrome/views/chrome_menu.cc

 // Copyright (c) 2006-2008 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 "chrome/views/chrome_menu.h"
 
 #include <windows.h>
 #include <uxtheme.h>
 #include <Vssym32.h>
 
@@ skipping 107 matching lines @@
 static bool show_mnemonics;
 
 using gfx::NativeTheme;
 
 namespace views {
 
 namespace {
 
 // Returns the font menus are to use.
 ChromeFont GetMenuFont() {
-        NONCLIENTMETRICS metrics;
+  NONCLIENTMETRICS metrics;
   win_util::GetNonClientMetrics(&metrics);
 
   HFONT font = CreateFontIndirect(&metrics.lfMenuFont);
   DLOG_ASSERT(font);
   return ChromeFont::CreateFont(font);
 }
 
 // Calculates all sizes that we can from the OS.
 //
 // This is invoked prior to Running a menu.
@@ skipping 68 matching lines @@
 }
 
 // MenuScrollTask --------------------------------------------------------------
 
 // MenuScrollTask is used when the SubmenuView does not all fit on screen and
 // the mouse is over the scroll up/down buttons. MenuScrollTask schedules
 // itself with a RepeatingTimer. When Run is invoked MenuScrollTask scrolls
 // appropriately.
 
 class MenuScrollTask {
-public:
+ public:
   MenuScrollTask() : submenu_(NULL) {
     pixels_per_second_ = pref_menu_height * 20;
   }
 
   void Update(const MenuController::MenuPart& part) {
     if (!part.is_scroll()) {
       StopScrolling();
       return;
     }
     DCHECK(part.submenu);
@@ skipping 51 matching lines @@
 
   // Time we started scrolling at.
   Time start_scroll_time_;
 
   // How many pixels to scroll per second.
   int pixels_per_second_;
 
   // Y-coordinate of submenu_view_ when scrolling started.
   int start_y_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(MenuScrollTask);
+  DISALLOW_COPY_AND_ASSIGN(MenuScrollTask);
 };
 
 // MenuScrollButton ------------------------------------------------------------
 
 // MenuScrollButton is used for the scroll buttons when not all menu items fit
 // on screen. MenuScrollButton forwards appropriate events to the
 // MenuController.
 
 class MenuScrollButton : public View {
  public:
@@ skipping 59 matching lines @@
  private:
   // SubmenuView we were created for.
   SubmenuView* host_;
 
   // Direction of the button.
   bool is_up_;
 
   // Preferred height.
   int pref_height_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(MenuScrollButton);
+  DISALLOW_COPY_AND_ASSIGN(MenuScrollButton);
 };
 
 // MenuScrollView --------------------------------------------------------------
 
 // MenuScrollView is a viewport for the SubmenuView. It's reason to exist is so
 // that ScrollRectToVisible works.
 //
 // NOTE: It is possible to use ScrollView directly (after making it deal with
 // null scrollbars), but clicking on a child of ScrollView forces the window to
 // become active, which we don't want. As we really only need a fraction of
@@ skipping 16 matching lines @@
     y = std::max(0, std::min(pref.height() - this->height(), y));
     child->SetY(-y);
   }
 
   // Returns the contents, which is the SubmenuView.
   View* GetContents() {
     return GetChildViewAt(0);
   }
 
  private:
-  DISALLOW_EVIL_CONSTRUCTORS(MenuScrollView);
+  DISALLOW_COPY_AND_ASSIGN(MenuScrollView);
 };
 
 // MenuScrollViewContainer -----------------------------------------------------
 
 // MenuScrollViewContainer contains the SubmenuView (through a MenuScrollView)
 // and two scroll buttons. The scroll buttons are only visible and enabled if
 // the preferred height of the SubmenuView is bigger than our bounds.
 class MenuScrollViewContainer : public View {
  public:
   explicit MenuScrollViewContainer(SubmenuView* content_view) {
@@ skipping 64 matching lines @@
   }
 
  private:
   // The scroll buttons.
   View* scroll_up_button_;
   View* scroll_down_button_;
 
   // The scroll view.
   MenuScrollView* scroll_view_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(MenuScrollViewContainer);
+  DISALLOW_COPY_AND_ASSIGN(MenuScrollViewContainer);
 };
 
 // MenuSeparator ---------------------------------------------------------------
 
 // Renders a separator.
 
 class MenuSeparator : public View {
  public:
   MenuSeparator() {
   }
@@ skipping 14 matching lines @@
       start_x = gutter_bounds.left + gutter_width;
       start_y = 0;
     }
     RECT separator_bounds = { start_x, start_y, width(), height() };
     NativeTheme::instance()->PaintMenuSeparator(dc, MENU_POPUPSEPARATOR,
                                                 MPI_NORMAL, &separator_bounds);
     canvas->endPlatformPaint();
   }
 
   gfx::Size GetPreferredSize() {
-    return gfx::Size(10, // Just in case we're the only item in a menu.
+    return gfx::Size(10,  // Just in case we're the only item in a menu.
                      separator_height);
   }
 
  private:
-  DISALLOW_EVIL_CONSTRUCTORS(MenuSeparator);
+  DISALLOW_COPY_AND_ASSIGN(MenuSeparator);
 };
 
 // MenuHostRootView ----------------------------------------------------------
 
 // MenuHostRootView is the RootView of the window showing the menu.
 // SubmenuView's scroll view is added as a child of MenuHostRootView.
 // MenuHostRootView forwards relevant events to the MenuController.
 //
 // As all the menu items are owned by the root menu item, care must be taken
 // such that when MenuHostRootView is deleted it doesn't delete the menu items.
@@ skipping 77 matching lines @@
 
   void SuspendEvents() {
     suspend_events_ = true;
   }
 
  private:
   MenuController* GetMenuController() {
     return submenu_->GetMenuItem()->GetMenuController();
   }
 
-  /// The SubmenuView we contain.
+  // The SubmenuView we contain.
   SubmenuView* submenu_;
 
   // Whether mouse dragged/released should be forwarded to the MenuController.
   bool forward_drag_to_menu_controller_;
 
   // Whether events are suspended. If true, no events are forwarded to the
   // MenuController.
   bool suspend_events_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(MenuHostRootView);
+  DISALLOW_COPY_AND_ASSIGN(MenuHostRootView);
 };
 
 // MenuHost ------------------------------------------------------------------
 
 // MenuHost is the window responsible for showing a single menu.
 //
 // Similar to MenuHostRootView, care must be taken such that when MenuHost is
 // deleted, it doesn't delete the menu items. MenuHost is closed via a
 // DelayedClosed, which avoids timing issues with deleting the window while
 // capture or events are directed at it.
@@ skipping 100 matching lines @@
  private:
   // If true, we've been closed.
   bool closed_;
 
   // If true, we own the capture and need to release it.
   bool owns_capture_;
 
   // The view we contain.
   SubmenuView* submenu_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(MenuHost);
+  DISALLOW_COPY_AND_ASSIGN(MenuHost);
 };
 
 // EmptyMenuMenuItem ---------------------------------------------------------
 
 // EmptyMenuMenuItem is used when a menu has no menu items. EmptyMenuMenuItem
 // is itself a MenuItemView, but it uses a different ID so that it isn't
 // identified as a MenuItemView.
 
 class EmptyMenuMenuItem : public MenuItemView {
  public:
   // ID used for EmptyMenuMenuItem.
   static const int kEmptyMenuItemViewID;
 
   EmptyMenuMenuItem(MenuItemView* parent) : MenuItemView(parent, 0, NORMAL) {
     SetTitle(l10n_util::GetString(IDS_MENU_EMPTY_SUBMENU));
     // Set this so that we're not identified as a normal menu item.
     SetID(kEmptyMenuItemViewID);
     SetEnabled(false);
   }
 
  private:
-  DISALLOW_EVIL_CONSTRUCTORS(EmptyMenuMenuItem);
+  DISALLOW_COPY_AND_ASSIGN(EmptyMenuMenuItem);
 };
 
 // static
 const int EmptyMenuMenuItem::kEmptyMenuItemViewID =
     MenuItemView::kMenuItemViewID + 1;
 
 }  // namespace
 
 // SubmenuView ---------------------------------------------------------------
 
@@ skipping 1020 matching lines @@
                                            press_loc.y(), data);
 
       scoped_refptr<BaseDragSource> drag_source(new BaseDragSource);
       int drag_ops = item->GetDelegate()->GetDragOperations(item);
       DWORD effects;
       StopScrolling();
       DoDragDrop(data, drag_source,
                  DragDropTypes::DragOperationToDropEffect(drag_ops),
                  &effects);
       if (GetActiveInstance() == this) {
-        if (showing_ ) {
+        if (showing_) {
           // We're still showing, close all menus.
           CloseAllNestedMenus();
           Cancel(true);
-        } // else case, drop was on us.
-      } // else case, someone canceled us, don't do anything
+        }  // else case, drop was on us.
+      }  // else case, someone canceled us, don't do anything
     }
     return;
   }
   if (part.type == MenuPart::MENU_ITEM) {
     if (!part.menu)
       part.menu = source->GetMenuItem();
     SetSelection(part.menu ? part.menu : state_.item, true, false);
   }
   any_menu_contains_mouse_ = (part.type == MenuPart::MENU_ITEM);
 }
@@ skipping 750 matching lines @@
 void MenuController::IncrementSelection(int delta) {
   MenuItemView* item = pending_state_.item;
   DCHECK(item);
   if (pending_state_.submenu_open && item->HasSubmenu() &&
       item->GetSubmenu()->IsShowing()) {
     // A menu is selected and open, but none of its children are selected,
     // select the first menu item.
     if (item->GetSubmenu()->GetMenuItemCount()) {
       SetSelection(item->GetSubmenu()->GetMenuItemAt(0), false, false);
       ScrollToVisible(item->GetSubmenu()->GetMenuItemAt(0));
-      return; // return so else case can fall through.
+      return;  // return so else case can fall through.
     }
   }
   if (item->GetParentMenuItem()) {
     MenuItemView* parent = item->GetParentMenuItem();
     int parent_count = parent->GetSubmenu()->GetMenuItemCount();
     if (parent_count > 1) {
       for (int i = 0; i < parent_count; ++i) {
         if (parent->GetSubmenu()->GetMenuItemAt(i) == item) {
           int next_index = (i + delta + parent_count) % parent_count;
           ScrollToVisible(parent->GetSubmenu()->GetMenuItemAt(next_index));
@@ skipping 147 matching lines @@
     else if (event.IsRightMouseButton())
       event_type = in_client_area ? WM_RBUTTONDOWN : WM_NCRBUTTONDOWN;
     else
       event_type = 0;  // Unknown mouse press.
 
     if (event_type) {
       if (in_client_area) {
         PostMessage(window, event_type, event.GetWindowsFlags(),
                     MAKELPARAM(window_x, window_y));
       } else {
-        PostMessage(window, WM_NCLBUTTONDOWN, nc_hit_result,
-                    MAKELPARAM(window_x, window_y));
+        PostMessage(window, event_type, nc_hit_result,
+                    MAKELPARAM(screen_loc.x(), screen_loc.y()));
       }
     }
   }
 }
 
 void MenuController::SetDropMenuItem(
     MenuItemView* new_target,
     MenuDelegate::DropPosition new_position) {
   if (new_target == drop_target_ && new_position == drop_position_)
     return;
@@ skipping 17 matching lines @@
   if (!scroll_task_.get())
     scroll_task_.reset(new MenuScrollTask());
   scroll_task_->Update(part);
 }
 
 void MenuController::StopScrolling() {
   scroll_task_.reset(NULL);
 }
 
 }  // namespace views