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 base::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 base::string16 GetDialogButtonLabel(
  82       ui::DialogButton button) const OVERRIDE;
  83   virtual bool IsDialogButtonEnabled(ui::DialogButton button) const OVERRIDE;
  84   virtual views::View* CreateExtraView() OVERRIDE;
  85   virtual ui::ModalType GetModalType() const OVERRIDE;
  86   virtual bool CanResize() const  OVERRIDE;
  87   virtual base::string16 GetWindowTitle() const  OVERRIDE;
  88   virtual bool Accept() OVERRIDE;
  89
  90   // views::View:
  91   virtual gfx::Size GetPreferredSize() OVERRIDE;
  92   virtual void GetAccessibleState(ui::AccessibleViewState* state) OVERRIDE;
  93
  94   // views::TreeViewController:
  95   virtual void OnTreeViewSelectionChanged(views::TreeView* tree_view) OVERRIDE;
  96   virtual bool CanEdit(views::TreeView* tree_view,
  97                        ui::TreeModelNode* node) OVERRIDE;
  98
  99   // views::TextfieldController:
 100   virtual void ContentsChanged(views::Textfield* sender,
 101                                const base::string16& new_contents) OVERRIDE;
 102   virtual bool HandleKeyEvent(views::Textfield* sender,
 103                               const ui::KeyEvent& key_event) OVERRIDE;
 104
 105   // views::ButtonListener:
 106   virtual void ButtonPressed(views::Button* sender,
 107                              const ui::Event& event) OVERRIDE;
 108
 109   // ui::SimpleMenuModel::Delegate:
 110   virtual bool IsCommandIdChecked(int command_id) const OVERRIDE;
 111   virtual bool IsCommandIdEnabled(int command_id) const OVERRIDE;
 112   virtual bool GetAcceleratorForCommandId(
 113       int command_id,
 114       ui::Accelerator* accelerator) OVERRIDE;
 115   virtual void ExecuteCommand(int command_id, int event_flags) OVERRIDE;
 116
 117   // Creates a Window and adds the BookmarkEditorView to it. When the window is
 118   // closed the BookmarkEditorView is deleted.
 119   void Show(gfx::NativeWindow parent);
 120
 121   // views::ContextMenuController:
 122   virtual void ShowContextMenuForView(views::View* source,
 123                                       const gfx::Point& point,
 124                                       ui::MenuSourceType source_type) OVERRIDE;
 125
 126  private:
 127   friend class BookmarkEditorViewTest;
 128
 129   // Creates the necessary sub-views, configures them, adds them to the layout,
 130   // and requests the entries to display from the database.
 131   void Init();
 132
 133   // BookmarkModel observer methods. Any structural change results in
 134   // resetting the tree model.
 135   virtual void BookmarkModelLoaded(BookmarkModel* model,
 136                                    bool ids_reassigned) OVERRIDE {}
 137   virtual void BookmarkNodeMoved(BookmarkModel* model,
 138                                  const BookmarkNode* old_parent,
 139                                  int old_index,
 140                                  const BookmarkNode* new_parent,
 141                                  int new_index) OVERRIDE;
 142   virtual void BookmarkNodeAdded(BookmarkModel* model,
 143                                  const BookmarkNode* parent,
 144                                  int index) OVERRIDE;
 145   virtual void BookmarkNodeRemoved(BookmarkModel* model,
 146                                    const BookmarkNode* parent,
 147                                    int index,
 148                                    const BookmarkNode* node) OVERRIDE;
 149   virtual void BookmarkAllNodesRemoved(BookmarkModel* model) OVERRIDE;
 150   virtual void BookmarkNodeChanged(BookmarkModel* model,
 151                                    const BookmarkNode* node) OVERRIDE {}
 152   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
 153                                              const BookmarkNode* node) OVERRIDE;
 154   virtual void BookmarkNodeFaviconChanged(BookmarkModel* model,
 155                                           const BookmarkNode* node) OVERRIDE {}
 156
 157   // Resets the model of the tree and updates the various buttons appropriately.
 158   void Reset();
 159
 160   // Expands all the nodes in the tree and selects the parent node of the
 161   // url we're editing or the most recent parent if the url being editted isn't
 162   // starred.
 163   void ExpandAndSelect();
 164
 165   // Creates a returns the new root node. This invokes CreateNodes to do
 166   // the real work.
 167   EditorNode* CreateRootNode();
 168
 169   // Adds and creates a child node in b_node for all children of bb_node that
 170   // are folders.
 171   void CreateNodes(const BookmarkNode* bb_node, EditorNode* b_node);
 172
 173   // Returns the node with the specified id, or NULL if one can't be found.
 174   EditorNode* FindNodeWithID(BookmarkEditorView::EditorNode* node, int64 id);
 175
 176   // Invokes ApplyEdits with the selected node.
 177   void ApplyEdits();
 178
 179   // Applies the edits done by the user. |parent| gives the parent of the URL
 180   // being edited.
 181   void ApplyEdits(EditorNode* parent);
 182
 183   // Recursively adds newly created folders and sets the title of nodes to
 184   // match the user edited title.
 185   //
 186   // bb_node gives the BookmarkNode the edits are to be applied to, with b_node
 187   // the source of the edits.
 188   //
 189   // If b_node == parent_b_node, parent_bb_node is set to bb_node. This is
 190   // used to determine the new BookmarkNode parent based on the EditorNode
 191   // parent.
 192   void ApplyNameChangesAndCreateNewFolders(
 193       const BookmarkNode* bb_node,
 194       BookmarkEditorView::EditorNode* b_node,
 195       BookmarkEditorView::EditorNode* parent_b_node,
 196       const BookmarkNode** parent_bb_node);
 197
 198   // Returns the current url the user has input.
 199   GURL GetInputURL() const;
 200
 201   // Invoked when the url or title has possibly changed. Updates the background
 202   // of Textfields and ok button appropriately.
 203   void UserInputChanged();
 204
 205   // Creates a new folder as a child of the selected node. If no node is
 206   // selected, the new folder is added as a child of the bookmark node. Starts
 207   // editing on the new gorup as well.
 208   void NewFolder();
 209
 210   // Creates a new EditorNode as the last child of parent. The new node is
 211   // added to the model and returned. This does NOT start editing. This is used
 212   // internally by NewFolder and broken into a separate method for testing.
 213   EditorNode* AddNewFolder(EditorNode* parent);
 214
 215   // If |editor_node| is expanded it's added to |expanded_nodes| and this is
 216   // recursively invoked for all the children.
 217   void UpdateExpandedNodes(EditorNode* editor_node,
 218                            BookmarkExpandedStateTracker::Nodes* expanded_nodes);
 219
 220   ui::SimpleMenuModel* GetMenuModel();
 221
 222   // Profile the entry is from.
 223   Profile* profile_;
 224
 225   // Model driving the TreeView.
 226   scoped_ptr<EditorTreeModel> tree_model_;
 227
 228   // Displays star folder.
 229   views::TreeView* tree_view_;
 230
 231   // Used to create a new folder.
 232   scoped_ptr<views::LabelButton> new_folder_button_;
 233
 234   // The label for the url text field.
 235   views::Label* url_label_;
 236
 237   // The text field used for editing the URL.
 238   views::Textfield* url_tf_;
 239
 240   // The label for the title text field.
 241   views::Label* title_label_;
 242
 243   // The text field used for editing the title.
 244   views::Textfield* title_tf_;
 245
 246   // Initial parent to select. Is only used if |details_.existing_node| is
 247   // NULL.
 248   const BookmarkNode* parent_;
 249
 250   const EditDetails details_;
 251
 252   // The context menu.
 253   scoped_ptr<ui::SimpleMenuModel> context_menu_model_;
 254   scoped_ptr<views::MenuRunner> context_menu_runner_;
 255
 256   // Mode used to create nodes from.
 257   BookmarkModel* bb_model_;
 258
 259   // If true, we're running the menu for the bookmark bar or other bookmarks
 260   // nodes.
 261   bool running_menu_for_root_;
 262
 263   // Is the tree shown?
 264   bool show_tree_;
 265
 266   // List of deleted bookmark folders.
 267   std::vector<int64> deletes_;
 268
 269   DISALLOW_COPY_AND_ASSIGN(BookmarkEditorView);
 270 };
 271
 272 #endif  // CHROME_BROWSER_UI_VIEWS_BOOKMARKS_BOOKMARK_EDITOR_VIEW_H_