Renames browser/gtk/bookmark_context_menu to...

chrome/browser/gtk/bookmark_context_menu_gtk.cc

 // Copyright (c) 2009 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/browser/gtk/bookmark_context_menu.h"
+#include "chrome/browser/gtk/bookmark_context_menu_gtk.h"
 
 #include "app/l10n_util.h"
 #include "base/compiler_specific.h"
 #include "chrome/browser/bookmarks/bookmark_editor.h"
 #include "chrome/browser/bookmarks/bookmark_manager.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/input_window_dialog.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/page_navigator.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "grit/generated_resources.h"
 
-// TODO(port): Port these files.
-#if defined(OS_WIN)
-#include "views/window/window.h"
-#endif
-
 namespace {
 
 // Returns true if the specified node is of type URL, or has a descendant
 // of type URL.
 bool NodeHasURLs(const BookmarkNode* node) {
   if (node->is_url())
     return true;
 
   for (int i = 0; i < node->GetChildCount(); ++i) {
     if (NodeHasURLs(node->GetChild(i)))
@@ skipping 60 matching lines @@
   // InputWindowDialog::Delegate methods.
   virtual bool IsValid(const std::wstring& text) {
     return !text.empty();
   }
 
   virtual void InputAccepted(const std::wstring& text) {
     if (is_new_) {
       ALLOW_UNUSED const BookmarkNode* node =
           model_->AddGroup(node_, node_->GetChildCount(), text);
       if (show_in_manager_) {
-#if defined(OS_WIN) || (defined(OS_LINUX) && !defined(TOOLKIT_VIEWS))
         BookmarkManager::SelectInTree(profile_, node);
-#else
-        NOTIMPLEMENTED() << "BookmarkManager not yet implemented";
-#endif
       }
     } else {
       model_->SetTitle(node_, text);
     }
   }
 
   virtual void InputCanceled() {
   }
 
   // BookmarkModelObserver methods, all invoke ModelChanged and close the
@@ skipping 52 matching lines @@
   bool is_new_;
 
   // If is_new_ is true and a new node is created, it is selected in the
   // bookmark manager.
   bool show_in_manager_;
   InputWindowDialog* dialog_;
 
   DISALLOW_COPY_AND_ASSIGN(EditFolderController);
 };
 
-#if defined(OS_WIN)  || (defined(OS_LINUX) && !defined(TOOLKIT_VIEWS))
 // SelectOnCreationHandler ----------------------------------------------------
 
 // Used when adding a new bookmark. If a new bookmark is created it is selected
 // in the bookmark manager.
 class SelectOnCreationHandler : public BookmarkEditor::Handler {
  public:
   explicit SelectOnCreationHandler(Profile* profile) : profile_(profile) {
   }
 
   virtual void NodeCreated(const BookmarkNode* new_node) {
     BookmarkManager::SelectInTree(profile_, new_node);
   }
 
  private:
   Profile* profile_;
 
   DISALLOW_COPY_AND_ASSIGN(SelectOnCreationHandler);
 };
-#endif  // #if defined(OS_WIN) || (defined(OS_LINUX) && !defined(TOOLKIT_VIEWS))
 
 }  // namespace
 
-// BookmarkContextMenu -------------------------------------------
+// BookmarkContextMenuGtk -------------------------------------------
 
-BookmarkContextMenu::BookmarkContextMenu(
+BookmarkContextMenuGtk::BookmarkContextMenuGtk(
     gfx::NativeView wnd,
     Profile* profile,
     Browser* browser,
     PageNavigator* navigator,
     const BookmarkNode* parent,
     const std::vector<const BookmarkNode*>& selection,
     ConfigurationType configuration,
     Delegate* delegate)
     : wnd_(wnd),
       profile_(profile),
@@ skipping 62 matching lines @@
 
   if (configuration == BOOKMARK_BAR) {
     AppendSeparator();
     AppendItem(IDS_BOOKMARK_MANAGER);
     AppendCheckboxItem(IDS_BOOMARK_BAR_ALWAYS_SHOW);
   }
 
   model_->AddObserver(this);
 }
 
-BookmarkContextMenu::~BookmarkContextMenu() {
+BookmarkContextMenuGtk::~BookmarkContextMenuGtk() {
   if (model_)
     model_->RemoveObserver(this);
 }
 
-void BookmarkContextMenu::DelegateDestroyed() {
+void BookmarkContextMenuGtk::PopupAsContext(guint32 event_time) {
+  menu_->PopupAsContext(event_time);
+}
+
+void BookmarkContextMenuGtk::DelegateDestroyed() {
   delegate_ = NULL;
 }
 
-void BookmarkContextMenu::ExecuteCommand(int id) {
+void BookmarkContextMenuGtk::ExecuteCommand(int id) {
   if (delegate_)
     delegate_->WillExecuteCommand();
 
   switch (id) {
     case IDS_BOOMARK_BAR_OPEN_ALL:
     case IDS_BOOMARK_BAR_OPEN_ALL_INCOGNITO:
     case IDS_BOOMARK_BAR_OPEN_ALL_NEW_WINDOW: {
       PageNavigator* navigator = browser_ ?
           browser_->GetSelectedTabContents() : navigator_;
       WindowOpenDisposition initial_disposition;
@@ skipping 19 matching lines @@
     case IDS_BOOKMARK_BAR_RENAME_FOLDER:
     case IDS_BOOKMARK_BAR_EDIT:
       UserMetrics::RecordAction(L"BookmarkBar_ContextMenu_Edit", profile_);
 
       if (selection_.size() != 1) {
         NOTREACHED();
         return;
       }
 
       if (selection_[0]->is_url()) {
-#if defined(OS_WIN) || (defined(OS_LINUX) && !defined(TOOLKIT_VIEWS))
         BookmarkEditor::Configuration editor_config;
         if (configuration_ == BOOKMARK_BAR)
           editor_config = BookmarkEditor::SHOW_TREE;
         else
           editor_config = BookmarkEditor::NO_TREE;
         BookmarkEditor::Show(wnd_, profile_, parent_, selection_[0],
                              editor_config, NULL);
-#else
-        NOTIMPLEMENTED();
-#endif
       } else {
         EditFolderController::Show(profile_, wnd_, selection_[0], false,
                                    false);
       }
       break;
 
     case IDS_BOOKMARK_BAR_REMOVE: {
       UserMetrics::RecordAction(L"BookmarkBar_ContextMenu_Remove", profile_);
       BookmarkModel* model = RemoveModelObserver();
 
       for (size_t i = 0; i < selection_.size(); ++i) {
         model->Remove(selection_[i]->GetParent(),
                       selection_[i]->GetParent()->IndexOfChild(selection_[i]));
       }
       selection_.clear();
       break;
     }
 
     case IDS_BOOMARK_BAR_ADD_NEW_BOOKMARK: {
       UserMetrics::RecordAction(L"BookmarkBar_ContextMenu_Add", profile_);
 
-#if defined(OS_WIN) || (defined(OS_LINUX) && !defined(TOOLKIT_VIEWS))
       BookmarkEditor::Configuration editor_config;
       BookmarkEditor::Handler* handler = NULL;
       if (configuration_ == BOOKMARK_BAR) {
         editor_config = BookmarkEditor::SHOW_TREE;
       } else {
         editor_config = BookmarkEditor::NO_TREE;
         // This is owned by the BookmarkEditorView.
         handler = new SelectOnCreationHandler(profile_);
       }
       BookmarkEditor::Show(wnd_, profile_, GetParentForNewNodes(), NULL,
                            editor_config, handler);
-#else
-      NOTIMPLEMENTED();
-#endif
       break;
     }
 
     case IDS_BOOMARK_BAR_NEW_FOLDER: {
       UserMetrics::RecordAction(L"BookmarkBar_ContextMenu_NewFolder",
                                 profile_);
       EditFolderController::Show(profile_, wnd_, GetParentForNewNodes(),
                                  true, (configuration_ != BOOKMARK_BAR));
       break;
     }
 
     case IDS_BOOMARK_BAR_ALWAYS_SHOW:
       bookmark_utils::ToggleWhenVisible(profile_);
       break;
 
     case IDS_BOOKMARK_MANAGER_SHOW_IN_FOLDER:
       UserMetrics::RecordAction(L"BookmarkBar_ContextMenu_ShowInFolder",
                                 profile_);
 
       if (selection_.size() != 1) {
         NOTREACHED();
         return;
       }
 
-#if defined(OS_WIN) || (defined(OS_LINUX) && !defined(TOOLKIT_VIEWS))
       BookmarkManager::SelectInTree(profile_, selection_[0]);
-#else
-      NOTIMPLEMENTED() << "Bookmark Manager not implemented";
-#endif
       break;
 
     case IDS_BOOKMARK_MANAGER:
       UserMetrics::RecordAction(L"ShowBookmarkManager", profile_);
-#if defined(OS_WIN) || (defined(OS_LINUX) && !defined(TOOLKIT_VIEWS))
       BookmarkManager::Show(profile_);
-#else
-      NOTIMPLEMENTED() << "Bookmark Manager not implemented";
-#endif
       break;
 
     case IDS_BOOKMARK_MANAGER_SORT:
       UserMetrics::RecordAction(L"BookmarkManager_Sort", profile_);
       model_->SortChildren(parent_);
       break;
 
     case IDS_COPY:
     case IDS_CUT:
       bookmark_utils::CopyToClipboard(profile_->GetBookmarkModel(),
@@ skipping 12 matching lines @@
       bookmark_utils::PasteFromClipboard(profile_->GetBookmarkModel(),
                                          parent_, index);
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
-bool BookmarkContextMenu::IsItemChecked(int id) const {
+bool BookmarkContextMenuGtk::IsItemChecked(int id) const {
   DCHECK(id == IDS_BOOMARK_BAR_ALWAYS_SHOW);
   return profile_->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar);
 }
 
-bool BookmarkContextMenu::IsCommandEnabled(int id) const {
+bool BookmarkContextMenuGtk::IsCommandEnabled(int id) const {
   bool is_root_node =
       (selection_.size() == 1 &&
        selection_[0]->GetParent() == model_->root_node());
   switch (id) {
     case IDS_BOOMARK_BAR_OPEN_INCOGNITO:
       return !profile_->IsOffTheRecord();
 
     case IDS_BOOMARK_BAR_OPEN_ALL_INCOGNITO:
       return HasURLs() && !profile_->IsOffTheRecord();
 
@@ skipping 24 matching lines @@
     case IDS_CUT:
       return selection_.size() > 0 && !is_root_node;
 
     case IDS_PASTE:
       // Always paste to parent.
       return bookmark_utils::CanPasteFromClipboard(parent_);
   }
   return true;
 }
 
-void BookmarkContextMenu::BookmarkModelBeingDeleted(BookmarkModel* model) {
+void BookmarkContextMenuGtk::BookmarkModelBeingDeleted(BookmarkModel* model) {
   ModelChanged();
 }
 
-void BookmarkContextMenu::BookmarkNodeMoved(BookmarkModel* model,
-                                            const BookmarkNode* old_parent,
-                                            int old_index,
-                                            const BookmarkNode* new_parent,
-                                            int new_index) {
+void BookmarkContextMenuGtk::BookmarkNodeMoved(BookmarkModel* model,
+                                               const BookmarkNode* old_parent,
+                                               int old_index,
+                                               const BookmarkNode* new_parent,
+                                               int new_index) {
   ModelChanged();
 }
 
-void BookmarkContextMenu::BookmarkNodeAdded(BookmarkModel* model,
-                                            const BookmarkNode* parent,
-                                            int index) {
+void BookmarkContextMenuGtk::BookmarkNodeAdded(BookmarkModel* model,
+                                               const BookmarkNode* parent,
+                                               int index) {
   ModelChanged();
 }
 
-void BookmarkContextMenu::BookmarkNodeRemoved(BookmarkModel* model,
-                                              const BookmarkNode* parent,
-                                              int index,
-                                              const BookmarkNode* node) {
+void BookmarkContextMenuGtk::BookmarkNodeRemoved(BookmarkModel* model,
+                                                 const BookmarkNode* parent,
+                                                 int index,
+                                                 const BookmarkNode* node) {
   ModelChanged();
 }
 
-void BookmarkContextMenu::BookmarkNodeChanged(BookmarkModel* model,
-                                              const BookmarkNode* node) {
+void BookmarkContextMenuGtk::BookmarkNodeChanged(BookmarkModel* model,
+                                                 const BookmarkNode* node) {
   ModelChanged();
 }
 
-void BookmarkContextMenu::BookmarkNodeChildrenReordered(
+void BookmarkContextMenuGtk::BookmarkNodeChildrenReordered(
     BookmarkModel* model, const BookmarkNode* node) {
   ModelChanged();
 }
 
-void BookmarkContextMenu::ModelChanged() {
+void BookmarkContextMenuGtk::ModelChanged() {
   menu_->Cancel();
 }
 
-BookmarkModel* BookmarkContextMenu::RemoveModelObserver() {
+void BookmarkContextMenuGtk::CreateMenuObject() {
+  menu_.reset(new MenuGtk(this, false));
+}
+
+void BookmarkContextMenuGtk::AppendItem(int id) {
+  menu_->AppendMenuItemWithLabel(id, l10n_util::GetStringUTF8(id));
+}
+
+void BookmarkContextMenuGtk::AppendItem(int id, int localization_id) {
+  menu_->AppendMenuItemWithLabel(id, l10n_util::GetStringUTF8(localization_id));
+}
+
+void BookmarkContextMenuGtk::AppendSeparator() {
+  menu_->AppendSeparator();
+}
+
+void BookmarkContextMenuGtk::AppendCheckboxItem(int id) {
+  menu_->AppendCheckMenuItemWithLabel(id, l10n_util::GetStringUTF8(id));
+}
+
+BookmarkModel* BookmarkContextMenuGtk::RemoveModelObserver() {
   BookmarkModel* model = model_;
   model_->RemoveObserver(this);
   model_ = NULL;
   return model;
 }
 
-bool BookmarkContextMenu::HasURLs() const {
+bool BookmarkContextMenuGtk::HasURLs() const {
   for (size_t i = 0; i < selection_.size(); ++i) {
     if (NodeHasURLs(selection_[i]))
       return true;
   }
   return false;
 }
 
-const BookmarkNode* BookmarkContextMenu::GetParentForNewNodes() const {
+const BookmarkNode* BookmarkContextMenuGtk::GetParentForNewNodes() const {
   return (selection_.size() == 1 && selection_[0]->is_folder()) ?
       selection_[0] : parent_;
 }