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/accessibility/ax_view_state.h" 11#include "ui/gfx/canvas.h" 12#include "ui/gfx/insets.h" 13#include "ui/views/painter.h" 14 15namespace views { 16 17namespace { 18 19// Returns the pixels for the bitmap in |image| at scale |image_scale|. 20void* GetBitmapPixels(const gfx::ImageSkia& img, float image_scale) { 21 DCHECK_NE(0.0f, image_scale); 22 const SkBitmap& bitmap = img.GetRepresentation(image_scale).sk_bitmap(); 23 SkAutoLockPixels pixel_lock(bitmap); 24 return bitmap.getPixels(); 25} 26 27} // namespace 28 29ImageView::ImageView() 30 : image_size_set_(false), 31 horiz_alignment_(CENTER), 32 vert_alignment_(CENTER), 33 interactive_(true), 34 last_paint_scale_(0.f), 35 last_painted_bitmap_pixels_(NULL), 36 focus_painter_(Painter::CreateDashedFocusPainter()) { 37} 38 39ImageView::~ImageView() { 40} 41 42void ImageView::SetImage(const gfx::ImageSkia& img) { 43 if (IsImageEqual(img)) 44 return; 45 46 last_painted_bitmap_pixels_ = NULL; 47 gfx::Size pref_size(GetPreferredSize()); 48 image_ = img; 49 if (pref_size != GetPreferredSize()) 50 PreferredSizeChanged(); 51 SchedulePaint(); 52} 53 54void ImageView::SetImage(const gfx::ImageSkia* image_skia) { 55 if (image_skia) { 56 SetImage(*image_skia); 57 } else { 58 gfx::ImageSkia t; 59 SetImage(t); 60 } 61} 62 63const gfx::ImageSkia& ImageView::GetImage() { 64 return image_; 65} 66 67void ImageView::SetImageSize(const gfx::Size& image_size) { 68 image_size_set_ = true; 69 image_size_ = image_size; 70 PreferredSizeChanged(); 71} 72 73bool ImageView::GetImageSize(gfx::Size* image_size) const { 74 DCHECK(image_size); 75 if (image_size_set_) 76 *image_size = image_size_; 77 return image_size_set_; 78} 79 80gfx::Rect ImageView::GetImageBounds() const { 81 gfx::Size image_size(image_size_set_ ? 82 image_size_ : gfx::Size(image_.width(), image_.height())); 83 return gfx::Rect(ComputeImageOrigin(image_size), image_size); 84} 85 86void ImageView::ResetImageSize() { 87 image_size_set_ = false; 88} 89 90void ImageView::SetFocusPainter(scoped_ptr<Painter> focus_painter) { 91 focus_painter_ = focus_painter.Pass(); 92} 93 94gfx::Size ImageView::GetPreferredSize() const { 95 gfx::Insets insets = GetInsets(); 96 if (image_size_set_) { 97 gfx::Size image_size; 98 GetImageSize(&image_size); 99 image_size.Enlarge(insets.width(), insets.height()); 100 return image_size; 101 } 102 return gfx::Size(image_.width() + insets.width(), 103 image_.height() + insets.height()); 104} 105 106bool ImageView::IsImageEqual(const gfx::ImageSkia& img) const { 107 // Even though we copy ImageSkia in SetImage() the backing store 108 // (ImageSkiaStorage) is not copied and may have changed since the last call 109 // to SetImage(). The expectation is that SetImage() with different pixels is 110 // treated as though the image changed. For this reason we compare not only 111 // the backing store but also the pixels of the last image we painted. 112 return image_.BackedBySameObjectAs(img) && 113 last_paint_scale_ != 0.0f && 114 last_painted_bitmap_pixels_ == GetBitmapPixels(img, last_paint_scale_); 115} 116 117gfx::Point ImageView::ComputeImageOrigin(const gfx::Size& image_size) const { 118 gfx::Insets insets = GetInsets(); 119 120 int x; 121 // In order to properly handle alignment of images in RTL locales, we need 122 // to flip the meaning of trailing and leading. For example, if the 123 // horizontal alignment is set to trailing, then we'll use left alignment for 124 // the image instead of right alignment if the UI layout is RTL. 125 Alignment actual_horiz_alignment = horiz_alignment_; 126 if (base::i18n::IsRTL() && (horiz_alignment_ != CENTER)) 127 actual_horiz_alignment = (horiz_alignment_ == LEADING) ? TRAILING : LEADING; 128 switch (actual_horiz_alignment) { 129 case LEADING: x = insets.left(); break; 130 case TRAILING: x = width() - insets.right() - image_size.width(); break; 131 case CENTER: x = (width() - image_size.width()) / 2; break; 132 default: NOTREACHED(); x = 0; break; 133 } 134 135 int y; 136 switch (vert_alignment_) { 137 case LEADING: y = insets.top(); break; 138 case TRAILING: y = height() - insets.bottom() - image_size.height(); break; 139 case CENTER: y = (height() - image_size.height()) / 2; break; 140 default: NOTREACHED(); y = 0; break; 141 } 142 143 return gfx::Point(x, y); 144} 145 146void ImageView::OnFocus() { 147 View::OnFocus(); 148 if (focus_painter_.get()) 149 SchedulePaint(); 150} 151 152void ImageView::OnBlur() { 153 View::OnBlur(); 154 if (focus_painter_.get()) 155 SchedulePaint(); 156} 157 158void ImageView::OnPaint(gfx::Canvas* canvas) { 159 View::OnPaint(canvas); 160 OnPaintImage(canvas); 161 Painter::PaintFocusPainter(this, canvas, focus_painter_.get()); 162} 163 164void ImageView::GetAccessibleState(ui::AXViewState* state) { 165 state->role = ui::AX_ROLE_IMAGE; 166 state->name = tooltip_text_; 167} 168 169void ImageView::SetHorizontalAlignment(Alignment ha) { 170 if (ha != horiz_alignment_) { 171 horiz_alignment_ = ha; 172 SchedulePaint(); 173 } 174} 175 176ImageView::Alignment ImageView::GetHorizontalAlignment() const { 177 return horiz_alignment_; 178} 179 180void ImageView::SetVerticalAlignment(Alignment va) { 181 if (va != vert_alignment_) { 182 vert_alignment_ = va; 183 SchedulePaint(); 184 } 185} 186 187ImageView::Alignment ImageView::GetVerticalAlignment() const { 188 return vert_alignment_; 189} 190 191void ImageView::SetTooltipText(const base::string16& tooltip) { 192 tooltip_text_ = tooltip; 193} 194 195base::string16 ImageView::GetTooltipText() const { 196 return tooltip_text_; 197} 198 199bool ImageView::GetTooltipText(const gfx::Point& p, 200 base::string16* tooltip) const { 201 if (tooltip_text_.empty()) 202 return false; 203 204 *tooltip = GetTooltipText(); 205 return true; 206} 207 208bool ImageView::CanProcessEventsWithinSubtree() const { 209 return interactive_; 210} 211 212void ImageView::OnPaintImage(gfx::Canvas* canvas) { 213 last_paint_scale_ = canvas->image_scale(); 214 last_painted_bitmap_pixels_ = NULL; 215 216 if (image_.isNull()) 217 return; 218 219 gfx::Rect image_bounds(GetImageBounds()); 220 if (image_bounds.IsEmpty()) 221 return; 222 223 if (image_bounds.size() != gfx::Size(image_.width(), image_.height())) { 224 // Resize case 225 SkPaint paint; 226 paint.setFilterLevel(SkPaint::kLow_FilterLevel); 227 canvas->DrawImageInt(image_, 0, 0, image_.width(), image_.height(), 228 image_bounds.x(), image_bounds.y(), image_bounds.width(), 229 image_bounds.height(), true, paint); 230 } else { 231 canvas->DrawImageInt(image_, image_bounds.x(), image_bounds.y()); 232 } 233 last_painted_bitmap_pixels_ = GetBitmapPixels(image_, last_paint_scale_); 234} 235 236} // namespace views 237