bookmark_editor_view.h revision eb525c5499e34cc9c4b825d6d9e75bb07cc06ace 
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
25namespace views {
26class Label;
27class LabelButton;
28class MenuRunner;
29class TreeView;
30}
31
32class BookmarkEditorViewTest;
33class GURL;
34class Menu;
35class 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
47class 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  // Closes the dialog.
120  void Close();
121
122  // views::ContextMenuController:
123  virtual void ShowContextMenuForView(views::View* source,
124                                      const gfx::Point& point,
125                                      ui::MenuSourceType source_type) OVERRIDE;
126
127 private:
128  friend class BookmarkEditorViewTest;
129
130  // Creates the necessary sub-views, configures them, adds them to the layout,
131  // and requests the entries to display from the database.
132  void Init();
133
134  // BookmarkModel observer methods. Any structural change results in
135  // resetting the tree model.
136  virtual void Loaded(BookmarkModel* model, 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_
273