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#include "ui/views/controls/image_view.h"
6
7#include "base/logging.h"
8#include "base/strings/utf_string_conversions.h"
9#include "third_party/skia/include/core/SkPaint.h"
10#include "ui/base/accessibility/accessible_view_state.h"
11#include "ui/gfx/canvas.h"
12#include "ui/gfx/insets.h"
13
14namespace views {
15
16ImageView::ImageView()
17    : image_size_set_(false),
18      horiz_alignment_(CENTER),
19      vert_alignment_(CENTER),
20      interactive_(true) {
21}
22
23ImageView::~ImageView() {
24}
25
26void ImageView::SetImage(const gfx::ImageSkia& img) {
27  gfx::Size pref_size(GetPreferredSize());
28  image_ = img;
29  if (pref_size != GetPreferredSize())
30    PreferredSizeChanged();
31  SchedulePaint();
32}
33
34void ImageView::SetImage(const gfx::ImageSkia* image_skia) {
35  if (image_skia) {
36    SetImage(*image_skia);
37  } else {
38    gfx::ImageSkia t;
39    SetImage(t);
40  }
41}
42
43const gfx::ImageSkia& ImageView::GetImage() {
44  return image_;
45}
46
47void ImageView::SetImageSize(const gfx::Size& image_size) {
48  image_size_set_ = true;
49  image_size_ = image_size;
50  PreferredSizeChanged();
51}
52
53bool ImageView::GetImageSize(gfx::Size* image_size) {
54  DCHECK(image_size);
55  if (image_size_set_)
56    *image_size = image_size_;
57  return image_size_set_;
58}
59
60gfx::Rect ImageView::GetImageBounds() const {
61  gfx::Size image_size(image_size_set_ ?
62    image_size_ : gfx::Size(image_.width(), image_.height()));
63  return gfx::Rect(ComputeImageOrigin(image_size), image_size);
64}
65
66void ImageView::ResetImageSize() {
67  image_size_set_ = false;
68}
69
70gfx::Size ImageView::GetPreferredSize() {
71  gfx::Insets insets = GetInsets();
72  if (image_size_set_) {
73    gfx::Size image_size;
74    GetImageSize(&image_size);
75    image_size.Enlarge(insets.width(), insets.height());
76    return image_size;
77  }
78  return gfx::Size(image_.width() + insets.width(),
79                   image_.height() + insets.height());
80}
81
82gfx::Point ImageView::ComputeImageOrigin(const gfx::Size& image_size) const {
83  gfx::Insets insets = GetInsets();
84
85  int x;
86  // In order to properly handle alignment of images in RTL locales, we need
87  // to flip the meaning of trailing and leading. For example, if the
88  // horizontal alignment is set to trailing, then we'll use left alignment for
89  // the image instead of right alignment if the UI layout is RTL.
90  Alignment actual_horiz_alignment = horiz_alignment_;
91  if (base::i18n::IsRTL() && (horiz_alignment_ != CENTER))
92    actual_horiz_alignment = (horiz_alignment_ == LEADING) ? TRAILING : LEADING;
93  switch (actual_horiz_alignment) {
94    case LEADING:  x = insets.left();                                 break;
95    case TRAILING: x = width() - insets.right() - image_size.width(); break;
96    case CENTER:   x = (width() - image_size.width()) / 2;            break;
97    default:       NOTREACHED(); x = 0;                               break;
98  }
99
100  int y;
101  switch (vert_alignment_) {
102    case LEADING:  y = insets.top();                                     break;
103    case TRAILING: y = height() - insets.bottom() - image_size.height(); break;
104    case CENTER:   y = (height() - image_size.height()) / 2;             break;
105    default:       NOTREACHED(); y = 0;                                  break;
106  }
107
108  return gfx::Point(x, y);
109}
110
111void ImageView::OnPaint(gfx::Canvas* canvas) {
112  View::OnPaint(canvas);
113
114  if (image_.isNull())
115    return;
116
117  gfx::Rect image_bounds(GetImageBounds());
118  if (image_bounds.IsEmpty())
119    return;
120
121  if (image_bounds.size() != gfx::Size(image_.width(), image_.height())) {
122    // Resize case
123    SkPaint paint;
124    paint.setFilterBitmap(true);
125    canvas->DrawImageInt(image_, 0, 0, image_.width(), image_.height(),
126        image_bounds.x(), image_bounds.y(), image_bounds.width(),
127        image_bounds.height(), true, paint);
128  } else {
129    canvas->DrawImageInt(image_, image_bounds.x(), image_bounds.y());
130  }
131}
132
133void ImageView::GetAccessibleState(ui::AccessibleViewState* state) {
134  state->role = ui::AccessibilityTypes::ROLE_GRAPHIC;
135  state->name = tooltip_text_;
136}
137
138void ImageView::SetHorizontalAlignment(Alignment ha) {
139  if (ha != horiz_alignment_) {
140    horiz_alignment_ = ha;
141    SchedulePaint();
142  }
143}
144
145ImageView::Alignment ImageView::GetHorizontalAlignment() const {
146  return horiz_alignment_;
147}
148
149void ImageView::SetVerticalAlignment(Alignment va) {
150  if (va != vert_alignment_) {
151    vert_alignment_ = va;
152    SchedulePaint();
153  }
154}
155
156ImageView::Alignment ImageView::GetVerticalAlignment() const {
157  return vert_alignment_;
158}
159
160void ImageView::SetTooltipText(const string16& tooltip) {
161  tooltip_text_ = tooltip;
162}
163
164string16 ImageView::GetTooltipText() const {
165  return tooltip_text_;
166}
167
168bool ImageView::GetTooltipText(const gfx::Point& p, string16* tooltip) const {
169  if (tooltip_text_.empty())
170    return false;
171
172  *tooltip = GetTooltipText();
173  return true;
174}
175
176bool ImageView::HitTestRect(const gfx::Rect& rect) const {
177  return interactive_ ? View::HitTestRect(rect) : false;
178}
179
180}  // namespace views
181