1 // Copyright 2014 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 COMPONENTS_INFOBARS_CORE_INFOBAR_H_ 6 #define COMPONENTS_INFOBARS_CORE_INFOBAR_H_ 7 8 #include <utility> 9 10 #include "base/memory/scoped_ptr.h" 11 #include "components/infobars/core/infobar_delegate.h" 12 #include "third_party/skia/include/core/SkColor.h" 13 #include "ui/gfx/animation/animation_delegate.h" 14 #include "ui/gfx/animation/slide_animation.h" 15 #include "ui/gfx/size.h" 16 17 namespace infobars { 18 19 class InfoBarContainer; 20 class InfoBarManager; 21 22 // InfoBar is a cross-platform base class for an infobar "view" (in the MVC 23 // sense), which owns a corresponding InfoBarDelegate "model". Typically, 24 // a caller will call XYZInfoBarDelegate::Create() and pass in the 25 // InfoBarManager for the relevant tab. This will create an XYZInfoBarDelegate, 26 // create a platform-specific subclass of InfoBar to own it, and then call 27 // InfoBarManager::AddInfoBar() to give it ownership of the infobar. 28 // During its life, the InfoBar may be shown and hidden as the owning tab is 29 // switched between the foreground and background. Eventually, InfoBarManager 30 // will instruct the InfoBar to close itself. At this point, the InfoBar will 31 // optionally animate closed; once it's no longer visible, it deletes itself, 32 // destroying the InfoBarDelegate in the process. 33 // 34 // Thus, InfoBarDelegate and InfoBar implementations can assume they share 35 // lifetimes, and not NULL-check each other; but if one needs to reach back into 36 // the owning InfoBarManager, it must check whether that's still possible. 37 class InfoBar : public gfx::AnimationDelegate { 38 public: 39 // These are the types passed as Details for infobar-related notifications. 40 typedef InfoBar AddedDetails; 41 typedef std::pair<InfoBar*, bool> RemovedDetails; 42 43 // Platforms must define these. 44 static const int kDefaultBarTargetHeight; 45 static const int kSeparatorLineHeight; 46 static const int kDefaultArrowTargetHeight; 47 static const int kMaximumArrowTargetHeight; 48 // The half-width (see comments on |arrow_half_width_| below) scales to its 49 // default and maximum values proportionally to how the height scales to its. 50 static const int kDefaultArrowTargetHalfWidth; 51 static const int kMaximumArrowTargetHalfWidth; 52 53 explicit InfoBar(scoped_ptr<InfoBarDelegate> delegate); 54 virtual ~InfoBar(); 55 56 static SkColor GetTopColor(InfoBarDelegate::Type infobar_type); 57 static SkColor GetBottomColor(InfoBarDelegate::Type infobar_type); 58 owner()59 InfoBarManager* owner() { return owner_; } delegate()60 InfoBarDelegate* delegate() const { return delegate_.get(); } set_container(InfoBarContainer * container)61 void set_container(InfoBarContainer* container) { container_ = container; } 62 63 // Sets |owner_|. This also calls StoreActiveEntryUniqueID() on |delegate_|. 64 // This must only be called once as there's no way to extract an infobar from 65 // its owner without deleting it, for reparenting in another tab. 66 void SetOwner(InfoBarManager* owner); 67 68 // Makes the infobar visible. If |animate| is true, the infobar is then 69 // animated to full size. 70 void Show(bool animate); 71 72 // Makes the infobar hidden. If |animate| is false, the infobar is 73 // immediately removed from the container, and, if now unowned, deleted. If 74 // |animate| is true, the infobar is animated to zero size, ultimately 75 // triggering a call to AnimationEnded(). 76 void Hide(bool animate); 77 78 // Changes the target height of the arrow portion of the infobar. This has no 79 // effect once the infobar is animating closed. 80 void SetArrowTargetHeight(int height); 81 82 // Notifies the infobar that it is no longer owned and should delete itself 83 // once it is invisible. 84 void CloseSoon(); 85 86 // Forwards a close request to our owner. This is a no-op if we're already 87 // unowned. 88 void RemoveSelf(); 89 90 // Changes the target height of the main ("bar") portion of the infobar. 91 void SetBarTargetHeight(int height); 92 animation()93 const gfx::SlideAnimation& animation() const { return animation_; } arrow_height()94 int arrow_height() const { return arrow_height_; } arrow_target_height()95 int arrow_target_height() const { return arrow_target_height_; } arrow_half_width()96 int arrow_half_width() const { return arrow_half_width_; } total_height()97 int total_height() const { return arrow_height_ + bar_height_; } 98 99 protected: 100 // gfx::AnimationDelegate: 101 virtual void AnimationProgressed(const gfx::Animation* animation) OVERRIDE; 102 container()103 const InfoBarContainer* container() const { return container_; } container()104 InfoBarContainer* container() { return container_; } animation()105 gfx::SlideAnimation* animation() { return &animation_; } bar_height()106 int bar_height() const { return bar_height_; } bar_target_height()107 int bar_target_height() const { return bar_target_height_; } 108 109 // Platforms may optionally override these if they need to do work during 110 // processing of the given calls. PlatformSpecificSetOwner()111 virtual void PlatformSpecificSetOwner() {} PlatformSpecificShow(bool animate)112 virtual void PlatformSpecificShow(bool animate) {} PlatformSpecificHide(bool animate)113 virtual void PlatformSpecificHide(bool animate) {} PlatformSpecificOnCloseSoon()114 virtual void PlatformSpecificOnCloseSoon() {} PlatformSpecificOnHeightsRecalculated()115 virtual void PlatformSpecificOnHeightsRecalculated() {} 116 117 private: 118 // gfx::AnimationDelegate: 119 virtual void AnimationEnded(const gfx::Animation* animation) OVERRIDE; 120 121 // Finds the new desired arrow and bar heights, and if they differ from the 122 // current ones, calls PlatformSpecificOnHeightRecalculated(). Informs our 123 // container our state has changed if either the heights have changed or 124 // |force_notify| is set. 125 void RecalculateHeights(bool force_notify); 126 127 // Checks whether the infobar is unowned and done with all animations. If so, 128 // notifies the container that it should remove this infobar, and deletes 129 // itself. 130 void MaybeDelete(); 131 132 InfoBarManager* owner_; 133 scoped_ptr<InfoBarDelegate> delegate_; 134 InfoBarContainer* container_; 135 gfx::SlideAnimation animation_; 136 137 // The current and target heights of the arrow and bar portions, and half the 138 // current arrow width. (It's easier to work in half-widths as we draw the 139 // arrow as two halves on either side of a center point.) 140 int arrow_height_; // Includes both fill and top stroke. 141 int arrow_target_height_; 142 int arrow_half_width_; // Includes only fill. 143 int bar_height_; // Includes both fill and bottom separator. 144 int bar_target_height_; 145 146 DISALLOW_COPY_AND_ASSIGN(InfoBar); 147 }; 148 149 } // namespace infobars 150 151 #endif // COMPONENTS_INFOBARS_CORE_INFOBAR_H_ 152