text: // Copyright (c) 2012 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.
  
  #ifndef CHROME_BROWSER_UI_VIEWS_BOOKMARKS_BOOKMARK_BAR_VIEW_H_
  #define CHROME_BROWSER_UI_VIEWS_BOOKMARKS_BOOKMARK_BAR_VIEW_H_
  
  #include <set>
  
  #include "base/basictypes.h"
  #include "base/compiler_specific.h"
  #include "base/gtest_prod_util.h"
  #include "base/memory/weak_ptr.h"
  #include "base/observer_list.h"
  #include "base/prefs/pref_change_registrar.h"
  #include "chrome/browser/bookmarks/bookmark_stats.h"
  #include "chrome/browser/ui/bookmarks/bookmark_bar.h"
  #include "chrome/browser/ui/bookmarks/bookmark_bar_instructions_delegate.h"
  #include "chrome/browser/ui/views/bookmarks/bookmark_bubble_view_observer.h"
  #include "chrome/browser/ui/views/bookmarks/bookmark_menu_controller_observer.h"
  #include "chrome/browser/ui/views/detachable_toolbar_view.h"
  #include "components/bookmarks/browser/bookmark_model_observer.h"
  #include "components/bookmarks/browser/bookmark_node_data.h"
  #include "ui/gfx/animation/animation_delegate.h"
  #include "ui/views/context_menu_controller.h"
  #include "ui/views/controls/button/button.h"
  #include "ui/views/controls/button/menu_button_listener.h"
  #include "ui/views/controls/menu/menu_types.h"
  #include "ui/views/drag_controller.h"
  
  class BookmarkBarViewObserver;
  class BookmarkContextMenu;
  class BookmarkModel;
  class Browser;
  class BrowserView;
  class ChromeBookmarkClient;
  class Profile;
  
  namespace content {
  class PageNavigator;
  }
  
  namespace gfx {
  class SlideAnimation;
  }
  
  namespace views {
  class CustomButton;
  class MenuButton;
  class MenuItemView;
  class LabelButton;
  }
  
  // BookmarkBarView renders the BookmarkModel.  Each starred entry on the
  // BookmarkBar is rendered as a MenuButton. An additional MenuButton aligned to
  // the right allows the user to quickly see recently starred entries.
  //
  // BookmarkBarView shows the bookmarks from a specific Profile. BookmarkBarView
  // waits until the HistoryService for the profile has been loaded before
  // creating the BookmarkModel.
  class BookmarkBarView : public DetachableToolbarView,
                          public BookmarkModelObserver,
                          public views::MenuButtonListener,
                          public views::ButtonListener,
                          public views::ContextMenuController,
                          public views::DragController,
                          public gfx::AnimationDelegate,
                          public BookmarkMenuControllerObserver,
                          public BookmarkBarInstructionsDelegate,
                          public BookmarkBubbleViewObserver {
   public:
    // The internal view class name.
    static const char kViewClassName[];
  
    // Constant used in Browser View, as well as here.
    // How inset the bookmarks bar is when displayed on the new tab page.
    static const int kNewtabHorizontalPadding;
  
    // Maximum size of buttons on the bookmark bar.
    static const int kMaxButtonWidth;
  
    // Number of pixels the attached bookmark bar overlaps with the toolbar.
    static const int kToolbarAttachedBookmarkBarOverlap;
  
    // |browser_view| can be NULL during tests.
    BookmarkBarView(Browser* browser, BrowserView* browser_view);
    virtual ~BookmarkBarView();
  
    static void DisableAnimationsForTesting(bool disabled);
  
    // Returns the current browser.
    Browser* browser() const { return browser_; }
  
    void AddObserver(BookmarkBarViewObserver* observer);
    void RemoveObserver(BookmarkBarViewObserver* observer);
  
    // Sets the PageNavigator that is used when the user selects an entry on
    // the bookmark bar.
    void SetPageNavigator(content::PageNavigator* navigator);
  
    // Sets whether the containing browser is showing an infobar.  This affects
    // layout during animation.
    void set_infobar_visible(bool infobar_visible) {
      infobar_visible_ = infobar_visible;
    }
  
    // Changes the state of the bookmark bar.
    void SetBookmarkBarState(BookmarkBar::State state,
                             BookmarkBar::AnimateChangeType animate_type);
  
    // Returns the toolbar overlap when fully detached.
    int GetFullyDetachedToolbarOverlap() const;
  
    // Whether or not we are animating.
    bool is_animating();
  
    // If |loc| is over a bookmark button the node is returned corresponding to
    // the button and |model_start_index| is set to 0. If a overflow button is
    // showing and |loc| is over the overflow button, the bookmark bar node is
    // returned and |model_start_index| is set to the index of the first node
    // contained in the overflow menu.
    const BookmarkNode* GetNodeForButtonAtModelIndex(const gfx::Point& loc,
                                                     int* model_start_index);
  
    // Returns the MenuButton for node.
    views::MenuButton* GetMenuButtonForNode(const BookmarkNode* node);
  
    // Returns the position to anchor the menu for |button| at.
    void GetAnchorPositionForButton(views::MenuButton* button,
                                    views::MenuAnchorPosition* anchor);
  
    // Returns the button responsible for showing bookmarks in the other bookmark
    // folder.
    views::MenuButton* other_bookmarked_button() const {
      return other_bookmarked_button_;
    }
  
    // Returns the button used when not all the items on the bookmark bar fit.
    views::MenuButton* overflow_button() const { return overflow_button_; }
  
    // Returns the active MenuItemView, or NULL if a menu isn't showing.
    views::MenuItemView* GetMenu();
  
    // Returns the context menu, or null if one isn't showing.
    views::MenuItemView* GetContextMenu();
  
    // Returns the drop MenuItemView, or NULL if a menu isn't showing.
    views::MenuItemView* GetDropMenu();
  
    // If a button is currently throbbing, it is stopped. If immediate is true
    // the throb stops immediately, otherwise it stops after a couple more
    // throbs.
    void StopThrobbing(bool immediate);
  
    // Returns the tooltip text for the specified url and title. The returned
    // text is clipped to fit within the bounds of the monitor. |context| is
    // used to determine which gfx::Screen is used to retrieve bounds.
    //
    // Note that we adjust the direction of both the URL and the title based on
    // the locale so that pure LTR strings are displayed properly in RTL locales.
    static base::string16 CreateToolTipForURLAndTitle(const views::Widget* widget,
                                                const gfx::Point& screen_loc,
                                                const GURL& url,
                                                const base::string16& title,
                                                Profile* profile);
  
    // DetachableToolbarView methods:
    virtual bool IsDetached() const OVERRIDE;
    virtual double GetAnimationValue() const OVERRIDE;
    virtual int GetToolbarOverlap() const OVERRIDE;
  
    // View methods:
    virtual gfx::Size GetPreferredSize() const OVERRIDE;
    virtual gfx::Size GetMinimumSize() const OVERRIDE;
    virtual bool CanProcessEventsWithinSubtree() const OVERRIDE;
    virtual void Layout() OVERRIDE;
    virtual void ViewHierarchyChanged(
        const ViewHierarchyChangedDetails& details) OVERRIDE;
    virtual void PaintChildren(gfx::Canvas* canvas,
                               const views::CullSet& cull_set) OVERRIDE;
    virtual bool GetDropFormats(
        int* formats,
        std::set<ui::OSExchangeData::CustomFormat>* custom_formats) OVERRIDE;
    virtual bool AreDropTypesRequired() OVERRIDE;
    virtual bool CanDrop(const ui::OSExchangeData& data) OVERRIDE;
    virtual void OnDragEntered(const ui::DropTargetEvent& event) OVERRIDE;
    virtual int OnDragUpdated(const ui::DropTargetEvent& event) OVERRIDE;
    virtual void OnDragExited() OVERRIDE;
    virtual int OnPerformDrop(const ui::DropTargetEvent& event) OVERRIDE;
    virtual void OnThemeChanged() OVERRIDE;
    virtual const char* GetClassName() const OVERRIDE;
    virtual void SetVisible(bool visible) OVERRIDE;
  
    // AccessiblePaneView:
    virtual void GetAccessibleState(ui::AXViewState* state) OVERRIDE;
  
    // gfx::AnimationDelegate:
    virtual void AnimationProgressed(const gfx::Animation* animation) OVERRIDE;
    virtual void AnimationEnded(const gfx::Animation* animation) OVERRIDE;
  
    // BookmarkMenuControllerObserver:
    virtual void BookmarkMenuControllerDeleted(
        BookmarkMenuController* controller) OVERRIDE;
  
    // BookmarkBarInstructionsDelegate:
    virtual void ShowImportDialog() OVERRIDE;
  
    // BookmarkBubbleViewObserver:
    virtual void OnBookmarkBubbleShown(const GURL& url) OVERRIDE;
    virtual void OnBookmarkBubbleHidden() OVERRIDE;
  
    // BookmarkModelObserver:
    virtual void BookmarkModelLoaded(BookmarkModel* model,
                                     bool ids_reassigned) OVERRIDE;
    virtual void BookmarkModelBeingDeleted(BookmarkModel* model) OVERRIDE;
    virtual void BookmarkNodeMoved(BookmarkModel* model,
                                   const BookmarkNode* old_parent,
                                   int old_index,
                                   const BookmarkNode* new_parent,
                                   int new_index) OVERRIDE;
    virtual void BookmarkNodeAdded(BookmarkModel* model,
                                   const BookmarkNode* parent,
                                   int index) OVERRIDE;
    virtual void BookmarkNodeRemoved(BookmarkModel* model,
                                     const BookmarkNode* parent,
                                     int old_index,
                                     const BookmarkNode* node,
                                     const std::set<GURL>& removed_urls) OVERRIDE;
    virtual void BookmarkAllUserNodesRemoved(
        BookmarkModel* model,
        const std::set<GURL>& removed_urls) OVERRIDE;
    virtual void BookmarkNodeChanged(BookmarkModel* model,
                                     const BookmarkNode* node) OVERRIDE;
    virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
                                               const BookmarkNode* node) OVERRIDE;
    virtual void BookmarkNodeFaviconChanged(BookmarkModel* model,
                                            const BookmarkNode* node) OVERRIDE;
  
    // views::DragController:
    virtual void WriteDragDataForView(views::View* sender,
                                      const gfx::Point& press_pt,
                                      ui::OSExchangeData* data) OVERRIDE;
    virtual int GetDragOperationsForView(views::View* sender,
                                         const gfx::Point& p) OVERRIDE;
    virtual bool CanStartDragForView(views::View* sender,
                                     const gfx::Point& press_pt,
                                     const gfx::Point& p) OVERRIDE;
  
    // views::MenuButtonListener:
    virtual void OnMenuButtonClicked(views::View* view,
                                     const gfx::Point& point) OVERRIDE;
  
    // views::ButtonListener:
    virtual void ButtonPressed(views::Button* sender,
                               const ui::Event& event) OVERRIDE;
  
    // views::ContextMenuController:
    virtual void ShowContextMenuForView(views::View* source,
                                        const gfx::Point& point,
                                        ui::MenuSourceType source_type) OVERRIDE;
  
   private:
    class ButtonSeparatorView;
    struct DropInfo;
    struct DropLocation;
  
    friend class BookmarkBarViewEventTestBase;
    FRIEND_TEST_ALL_PREFIXES(BookmarkBarViewTest, SwitchProfile);
    FRIEND_TEST_ALL_PREFIXES(BookmarkBarViewTest,
                             ManagedShowAppsShortcutInBookmarksBar);
    FRIEND_TEST_ALL_PREFIXES(BookmarkBarViewInstantExtendedTest,
                             AppsShortcutVisibility);
  
    // Used to identify what the user is dropping onto.
    enum DropButtonType {
      DROP_BOOKMARK,
      DROP_OTHER_FOLDER,
      DROP_OVERFLOW
    };
  
    // Creates recent bookmark button and when visible button as well as
    // calculating the preferred height.
    void Init();
  
    // NOTE: unless otherwise stated all methods that take an int for an index are
    // in terms of the bookmark bar view. Typically the view index and model index
    // are the same, but they may differ during animations or drag and drop.
    //
    // It's easy to get the mapping wrong. For this reason all these methods are
    // private.
  
    // Returns the number of buttons corresponding to starred urls/folders. This
    // is equivalent to the number of children the bookmark bar node from the
    // bookmark bar model has.
    int GetBookmarkButtonCount() const;
  
    // Returns the button at the specified index.
    views::LabelButton* GetBookmarkButton(int index);
  
    // Returns BOOKMARK_LAUNCH_LOCATION_DETACHED_BAR or
    // BOOKMARK_LAUNCH_LOCATION_ATTACHED_BAR based on detached state.
    BookmarkLaunchLocation GetBookmarkLaunchLocation() const;
  
    // Returns the index of the first hidden bookmark button. If all buttons are
    // visible, this returns GetBookmarkButtonCount().
    int GetFirstHiddenNodeIndex();
  
    // Creates the button showing the other bookmarked items.
    views::MenuButton* CreateOtherBookmarkedButton();
  
    // Creates the button showing the managed bookmarks items.
    views::MenuButton* CreateManagedBookmarksButton();
  
    // Creates the button used when not all bookmark buttons fit.
    views::MenuButton* CreateOverflowButton();
  
    // Creates the button for rendering the specified bookmark node.
    views::View* CreateBookmarkButton(const BookmarkNode* node);
  
    // Creates the button for rendering the apps page shortcut.
    views::LabelButton* CreateAppsPageShortcutButton();
  
    // Configures the button from the specified node. This sets the text,
    // and icon.
    void ConfigureButton(const BookmarkNode* node, views::LabelButton* button);
  
    // Implementation for BookmarkNodeAddedImpl.
    void BookmarkNodeAddedImpl(BookmarkModel* model,
                               const BookmarkNode* parent,
                               int index);
  
    // Implementation for BookmarkNodeRemoved.
    void BookmarkNodeRemovedImpl(BookmarkModel* model,
                                 const BookmarkNode* parent,
                                 int index);
  
    // If the node is a child of the root node, the button is updated
    // appropriately.
    void BookmarkNodeChangedImpl(BookmarkModel* model, const BookmarkNode* node);
  
    // Shows the menu used during drag and drop for the specified node.
    void ShowDropFolderForNode(const BookmarkNode* node);
  
    // Cancels the timer used to show a drop menu.
    void StopShowFolderDropMenuTimer();
  
    // Stars the timer used to show a drop menu for node.
    void StartShowFolderDropMenuTimer(const BookmarkNode* node);
  
    // Calculates the location for the drop in |location|.
    void CalculateDropLocation(const ui::DropTargetEvent& event,
                               const bookmarks::BookmarkNodeData& data,
                               DropLocation* location);
  
    // Writes a BookmarkNodeData for node to data.
    void WriteBookmarkDragData(const BookmarkNode* node,
                               ui::OSExchangeData* data);
  
    // This determines which view should throb and starts it
    // throbbing (e.g when the bookmark bubble is showing).
    // If |overflow_only| is true, start throbbing only if |node| is hidden in
    // the overflow menu.
    void StartThrobbing(const BookmarkNode* node, bool overflow_only);
  
    // Returns the view to throb when a node is removed. |parent| is the parent of
    // the node that was removed, and |old_index| the index of the node that was
    // removed.
    views::CustomButton* DetermineViewToThrobFromRemove(
        const BookmarkNode* parent,
        int old_index);
  
    // Updates the colors for all the child objects in the bookmarks bar.
    void UpdateColors();
  
    // Updates the visibility of |other_bookmarked_button_| and
    // |managed_bookmarks_button_|. Also shows or hides the separator if required.
    void UpdateButtonsVisibility();
  
    // Updates the visibility of |bookmarks_separator_view_|.
    void UpdateBookmarksSeparatorVisibility();
  
    // This method computes the bounds for the bookmark bar items.
    void LayoutItems();
  
    // Updates the visibility of the apps shortcut based on the pref value.
    void OnAppsPageShortcutVisibilityPrefChanged();
  
    // Needed to react to kShowAppsShortcutInBookmarkBar changes.
    PrefChangeRegistrar profile_pref_registrar_;
  
    // Used for opening urls.
    content::PageNavigator* page_navigator_;
  
    // BookmarkModel that owns the entries and folders that are shown in this
    // view. This is owned by the Profile.
    BookmarkModel* model_;
  
    // ChromeBookmarkClient. This is owned by the Profile.
    ChromeBookmarkClient* client_;
  
    // Used to manage showing a Menu, either for the most recently bookmarked
    // entries, or for the starred folder.
    BookmarkMenuController* bookmark_menu_;
  
    // Used when showing a menu for drag and drop. That is, if the user drags
    // over a folder this becomes non-null and manages the menu showing the
    // contents of the node.
    BookmarkMenuController* bookmark_drop_menu_;
  
    // If non-NULL we're showing a context menu for one of the items on the
    // bookmark bar.
    scoped_ptr<BookmarkContextMenu> context_menu_;
  
    // Shows the other bookmark entries.
    views::MenuButton* other_bookmarked_button_;
  
    // Shows the managed bookmarks entries.
    views::MenuButton* managed_bookmarks_button_;
  
    // Shows the Apps page shortcut.
    views::LabelButton* apps_page_shortcut_;
  
    // Used to track drops on the bookmark bar view.
    scoped_ptr<DropInfo> drop_info_;
  
    // Visible if not all the bookmark buttons fit.
    views::MenuButton* overflow_button_;
  
    // Shows a text and a link to import bookmarks if there are no bookmarks in
    // the Bookmarks Bar.
    views::View* instructions_;
  
    ButtonSeparatorView* bookmarks_separator_view_;
  
    Browser* browser_;
    BrowserView* browser_view_;
  
    // True if the owning browser is showing an infobar.
    bool infobar_visible_;
  
    // Animation controlling showing and hiding of the bar.
    scoped_ptr<gfx::SlideAnimation> size_animation_;
  
    // If the bookmark bubble is showing, this is the visible ancestor of the URL.
    // The visible ancestor is either the other_bookmarked_button_,
    // overflow_button_ or a button on the bar.
    views::CustomButton* throbbing_view_;
  
    BookmarkBar::State bookmark_bar_state_;
  
    // Are we animating to or from the detached state?
    bool animating_detached_;
  
    ObserverList<BookmarkBarViewObserver> observers_;
  
    // Factory used to delay showing of the drop menu.
    base::WeakPtrFactory<BookmarkBarView> show_folder_method_factory_;
  
    DISALLOW_COPY_AND_ASSIGN(BookmarkBarView);
  };
  
  #endif  // CHROME_BROWSER_UI_VIEWS_BOOKMARKS_BOOKMARK_BAR_VIEW_H_
  