chrome/browser/notifications/balloon.h


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

// Copyright (c) 2011 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.

// Handles the visible notification (or balloons).

#ifndef CHROME_BROWSER_NOTIFICATIONS_BALLOON_H_
#define CHROME_BROWSER_NOTIFICATIONS_BALLOON_H_
#pragma once

#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
#include "ui/gfx/point.h"
#include "ui/gfx/rect.h"
#include "ui/gfx/size.h"

class Balloon;
class BalloonCollection;
class BalloonHost;
class Notification;
class Profile;
class SiteInstance;

// Interface for a view that displays a balloon.
class BalloonView {
 public:
  virtual ~BalloonView() { }

  // Show the view on the screen.
  virtual void Show(Balloon* balloon) = 0;

  // Notify that the content of notification has chagned.
  virtual void Update() = 0;

  // Reposition the view to match the position of its balloon.
  virtual void RepositionToBalloon() = 0;

  // Close the view.
  virtual void Close(bool by_user) = 0;

  // The total size of the view.
  virtual gfx::Size GetSize() const = 0;

  // The host for the view's contents.
  virtual BalloonHost* GetHost() const = 0;
};

// Represents a Notification on the screen.
class Balloon {
 public:
  Balloon(const Notification& notification,
          Profile* profile,
          BalloonCollection* collection);
  virtual ~Balloon();

  const Notification& notification() const { return *notification_.get(); }
  Profile* profile() const { return profile_; }

  gfx::Point GetPosition() const {
    return position_.Add(offset_);
  }
  void SetPosition(const gfx::Point& upper_left, bool reposition);

  const gfx::Point& offset() { return offset_;}
  void set_offset(const gfx::Point& offset) { offset_ = offset; }
  void add_offset(const gfx::Point& offset) { offset_ = offset_.Add(offset); }

  const gfx::Size& content_size() const { return content_size_; }
  void set_content_size(const gfx::Size& size) { content_size_ = size; }

  const BalloonCollection* collection() const { return collection_; }

  const gfx::Size& min_scrollbar_size() const { return min_scrollbar_size_; }
  void set_min_scrollbar_size(const gfx::Size& size) {
    min_scrollbar_size_ = size;
  }

  // Request a new content size for this balloon.  This will get passed
  // to the balloon collection for checking against available space and
  // min/max restrictions.
  void SetContentPreferredSize(const gfx::Size& size);

  // Provides a view for this balloon.  Ownership transfers
  // to this object.
  void set_view(BalloonView* balloon_view);

  // Returns the balloon view associated with the balloon.
  BalloonView* view() const {
    return balloon_view_.get();
  }

  // Returns the viewing size for the balloon (content + frame).
  gfx::Size GetViewSize() const { return balloon_view_->GetSize(); }

  // Shows the balloon.
  virtual void Show();

  // Notify that the content of notification has changed.
  virtual void Update(const Notification& notification);

  // Called when the balloon is clicked by the user.
  virtual void OnClick();

  // Called when the balloon is closed, either by user (through the UI)
  // or by a script.
  virtual void OnClose(bool by_user);

  // Called by script to cause the balloon to close.
  virtual void CloseByScript();

 private:
  // Non-owned pointer to the profile.
  Profile* profile_;

  // The notification being shown in this balloon.
  scoped_ptr<Notification> notification_;

  // The collection that this balloon belongs to.  Non-owned pointer.
  BalloonCollection* collection_;

  // The actual UI element for the balloon.
  scoped_ptr<BalloonView> balloon_view_;

  // Position and size of the balloon on the screen.
  gfx::Point position_;
  gfx::Size content_size_;

  // Temporary offset for balloons that need to be positioned in a non-standard
  // position for keeping the close buttons under the mouse cursor.
  gfx::Point offset_;

  // Smallest size for this balloon where scrollbars will be shown.
  gfx::Size min_scrollbar_size_;

  DISALLOW_COPY_AND_ASSIGN(Balloon);
};

#endif  // CHROME_BROWSER_NOTIFICATIONS_BALLOON_H_