chrome/browser/ui/views/bookmarks/bookmark_editor_view.h

   1 // Copyright (c) 2012 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 #ifndef CHROME_BROWSER_UI_VIEWS_BOOKMARKS_BOOKMARK_EDITOR_VIEW_H_
   6 #define CHROME_BROWSER_UI_VIEWS_BOOKMARKS_BOOKMARK_EDITOR_VIEW_H_
   7
   8 #include <vector>
   9
  10 #include "base/compiler_specific.h"
  11 #include "base/gtest_prod_util.h"
  12 #include "base/strings/string16.h"
  13 #include "chrome/browser/bookmarks/bookmark_expanded_state_tracker.h"
  14 #include "chrome/browser/bookmarks/bookmark_model_observer.h"
  15 #include "chrome/browser/ui/bookmarks/bookmark_editor.h"
  16 #include "ui/base/models/simple_menu_model.h"
  17 #include "ui/base/models/tree_node_model.h"
  18 #include "ui/views/context_menu_controller.h"
  19 #include "ui/views/controls/button/button.h"
  20 #include "ui/views/controls/textfield/textfield.h"
  21 #include "ui/views/controls/textfield/textfield_controller.h"
  22 #include "ui/views/controls/tree/tree_view_controller.h"
  23 #include "ui/views/window/dialog_delegate.h"
  24
  25 namespace views {
  26 class Label;
  27 class LabelButton;
  28 class MenuRunner;
  29 class TreeView;
  30 }
  31
  32 class BookmarkEditorViewTest;
  33 class GURL;
  34 class Menu;
  35 class Profile;
  36
  37 // View that allows the user to edit a bookmark/starred URL. The user can
  38 // change the URL, title and where the bookmark appears as well as adding
  39 // new folders and changing the name of other folders. The editor is used for
  40 // both editing a url bookmark, as well as editing a folder bookmark when
  41 // created from 'Bookmark all tabs'.
  42 //
  43 // Edits are applied to the BookmarkModel when the user presses 'OK'.
  44 //
  45 // To use BookmarkEditorView invoke the static show method.
  46
  47 class BookmarkEditorView : public BookmarkEditor,
  48                            public views::ButtonListener,
  49                            public views::TreeViewController,
  50                            public views::DialogDelegateView,
  51                            public views::TextfieldController,
  52                            public views::ContextMenuController,
  53                            public ui::SimpleMenuModel::Delegate,
  54                            public BookmarkModelObserver {
  55  public:
  56   // Type of node in the tree. Public purely for testing.
  57   typedef ui::TreeNodeWithValue<int64> EditorNode;
  58
  59   // Model for the TreeView. Trivial subclass that doesn't allow titles with
  60   // empty strings. Public purely for testing.
  61   class EditorTreeModel : public ui::TreeNodeModel<EditorNode> {
  62    public:
  63     explicit EditorTreeModel(EditorNode* root)
  64         : ui::TreeNodeModel<EditorNode>(root) {}
  65
  66     virtual void SetTitle(ui::TreeModelNode* node,
  67                           const string16& title) OVERRIDE;
  68
  69    private:
  70     DISALLOW_COPY_AND_ASSIGN(EditorTreeModel);
  71   };
  72
  73   BookmarkEditorView(Profile* profile,
  74                      const BookmarkNode* parent,
  75                      const EditDetails& details,
  76                      BookmarkEditor::Configuration configuration);
  77
  78   virtual ~BookmarkEditorView();
  79
  80   // views::DialogDelegateView:
  81   virtual string16 GetDialogButtonLabel(ui::DialogButton button) const OVERRIDE;
  82   virtual bool IsDialogButtonEnabled(ui::DialogButton button) const OVERRIDE;
  83   virtual views::View* CreateExtraView() OVERRIDE;
  84   virtual ui::ModalType GetModalType() const OVERRIDE;
  85   virtual bool CanResize() const  OVERRIDE;
  86   virtual string16 GetWindowTitle() const  OVERRIDE;
  87   virtual bool Accept() OVERRIDE;
  88
  89   // views::View:
  90   virtual gfx::Size GetPreferredSize() OVERRIDE;
  91
  92   // views::TreeViewController:
  93   virtual void OnTreeViewSelectionChanged(views::TreeView* tree_view) OVERRIDE;
  94   virtual bool CanEdit(views::TreeView* tree_view,
  95                        ui::TreeModelNode* node) OVERRIDE;
  96
  97   // views::TextfieldController:
  98   virtual void ContentsChanged(views::Textfield* sender,
  99                                const string16& new_contents) OVERRIDE;
 100   virtual bool HandleKeyEvent(views::Textfield* sender,
 101                               const ui::KeyEvent& key_event) OVERRIDE;
 102
 103   // views::ButtonListener:
 104   virtual void ButtonPressed(views::Button* sender,
 105                              const ui::Event& event) OVERRIDE;
 106
 107   // ui::SimpleMenuModel::Delegate:
 108   virtual bool IsCommandIdChecked(int command_id) const OVERRIDE;
 109   virtual bool IsCommandIdEnabled(int command_id) const OVERRIDE;
 110   virtual bool GetAcceleratorForCommandId(
 111       int command_id,
 112       ui::Accelerator* accelerator) OVERRIDE;
 113   virtual void ExecuteCommand(int command_id, int event_flags) OVERRIDE;
 114
 115   // Creates a Window and adds the BookmarkEditorView to it. When the window is
 116   // closed the BookmarkEditorView is deleted.
 117   void Show(gfx::NativeWindow parent);
 118
 119   // views::ContextMenuController:
 120   virtual void ShowContextMenuForView(views::View* source,
 121                                       const gfx::Point& point,
 122                                       ui::MenuSourceType source_type) OVERRIDE;
 123
 124  private:
 125   friend class BookmarkEditorViewTest;
 126
 127   // Creates the necessary sub-views, configures them, adds them to the layout,
 128   // and requests the entries to display from the database.
 129   void Init();
 130
 131   // BookmarkModel observer methods. Any structural change results in
 132   // resetting the tree model.
 133   virtual void Loaded(BookmarkModel* model, bool ids_reassigned) OVERRIDE {}
 134   virtual void BookmarkNodeMoved(BookmarkModel* model,
 135                                  const BookmarkNode* old_parent,
 136                                  int old_index,
 137                                  const BookmarkNode* new_parent,
 138                                  int new_index) OVERRIDE;
 139   virtual void BookmarkNodeAdded(BookmarkModel* model,
 140                                  const BookmarkNode* parent,
 141                                  int index) OVERRIDE;
 142   virtual void BookmarkNodeRemoved(BookmarkModel* model,
 143                                    const BookmarkNode* parent,
 144                                    int index,
 145                                    const BookmarkNode* node) OVERRIDE;
 146   virtual void BookmarkAllNodesRemoved(BookmarkModel* model) OVERRIDE;
 147   virtual void BookmarkNodeChanged(BookmarkModel* model,
 148                                    const BookmarkNode* node) OVERRIDE {}
 149   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
 150                                              const BookmarkNode* node) OVERRIDE;
 151   virtual void BookmarkNodeFaviconChanged(BookmarkModel* model,
 152                                           const BookmarkNode* node) OVERRIDE {}
 153
 154   // Resets the model of the tree and updates the various buttons appropriately.
 155   void Reset();
 156
 157   // Expands all the nodes in the tree and selects the parent node of the
 158   // url we're editing or the most recent parent if the url being editted isn't
 159   // starred.
 160   void ExpandAndSelect();
 161
 162   // Creates a returns the new root node. This invokes CreateNodes to do
 163   // the real work.
 164   EditorNode* CreateRootNode();
 165
 166   // Adds and creates a child node in b_node for all children of bb_node that
 167   // are folders.
 168   void CreateNodes(const BookmarkNode* bb_node, EditorNode* b_node);
 169
 170   // Returns the node with the specified id, or NULL if one can't be found.
 171   EditorNode* FindNodeWithID(BookmarkEditorView::EditorNode* node, int64 id);
 172
 173   // Invokes ApplyEdits with the selected node.
 174   void ApplyEdits();
 175
 176   // Applies the edits done by the user. |parent| gives the parent of the URL
 177   // being edited.
 178   void ApplyEdits(EditorNode* parent);
 179
 180   // Recursively adds newly created folders and sets the title of nodes to
 181   // match the user edited title.
 182   //
 183   // bb_node gives the BookmarkNode the edits are to be applied to, with b_node
 184   // the source of the edits.
 185   //
 186   // If b_node == parent_b_node, parent_bb_node is set to bb_node. This is
 187   // used to determine the new BookmarkNode parent based on the EditorNode
 188   // parent.
 189   void ApplyNameChangesAndCreateNewFolders(
 190       const BookmarkNode* bb_node,
 191       BookmarkEditorView::EditorNode* b_node,
 192       BookmarkEditorView::EditorNode* parent_b_node,
 193       const BookmarkNode** parent_bb_node);
 194
 195   // Returns the current url the user has input.
 196   GURL GetInputURL() const;
 197
 198   // Invoked when the url or title has possibly changed. Updates the background
 199   // of Textfields and ok button appropriately.
 200   void UserInputChanged();
 201
 202   // Creates a new folder as a child of the selected node. If no node is
 203   // selected, the new folder is added as a child of the bookmark node. Starts
 204   // editing on the new gorup as well.
 205   void NewFolder();
 206
 207   // Creates a new EditorNode as the last child of parent. The new node is
 208   // added to the model and returned. This does NOT start editing. This is used
 209   // internally by NewFolder and broken into a separate method for testing.
 210   EditorNode* AddNewFolder(EditorNode* parent);
 211
 212   // If |editor_node| is expanded it's added to |expanded_nodes| and this is
 213   // recursively invoked for all the children.
 214   void UpdateExpandedNodes(EditorNode* editor_node,
 215                            BookmarkExpandedStateTracker::Nodes* expanded_nodes);
 216
 217   ui::SimpleMenuModel* GetMenuModel();
 218
 219   // Profile the entry is from.
 220   Profile* profile_;
 221
 222   // Model driving the TreeView.
 223   scoped_ptr<EditorTreeModel> tree_model_;
 224
 225   // Displays star folder.
 226   views::TreeView* tree_view_;
 227
 228   // Used to create a new folder.
 229   scoped_ptr<views::LabelButton> new_folder_button_;
 230
 231   // The label for the url text field.
 232   views::Label* url_label_;
 233
 234   // The text field used for editing the URL.
 235   views::Textfield* url_tf_;
 236
 237   // The label for the title text field.
 238   views::Label* title_label_;
 239
 240   // The text field used for editing the title.
 241   views::Textfield* title_tf_;
 242
 243   // Initial parent to select. Is only used if |details_.existing_node| is
 244   // NULL.
 245   const BookmarkNode* parent_;
 246
 247   const EditDetails details_;
 248
 249   // The context menu.
 250   scoped_ptr<ui::SimpleMenuModel> context_menu_model_;
 251   scoped_ptr<views::MenuRunner> context_menu_runner_;
 252
 253   // Mode used to create nodes from.
 254   BookmarkModel* bb_model_;
 255
 256   // If true, we're running the menu for the bookmark bar or other bookmarks
 257   // nodes.
 258   bool running_menu_for_root_;
 259
 260   // Is the tree shown?
 261   bool show_tree_;
 262
 263   // List of deleted bookmark folders.
 264   std::vector<int64> deletes_;
 265
 266   DISALLOW_COPY_AND_ASSIGN(BookmarkEditorView);
 267 };
 268
 269 #endif  // CHROME_BROWSER_UI_VIEWS_BOOKMARKS_BOOKMARK_EDITOR_VIEW_H_