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
139
140
141
142
143
144
145
146
147
|
// Copyright 2014 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.
#include "ui/base/cursor/cursor_util.h"
#include "base/logging.h"
#include "skia/ext/image_operations.h"
#include "ui/base/resource/resource_bundle.h"
#include "ui/gfx/geometry/point_conversions.h"
#include "ui/gfx/geometry/size_conversions.h"
#include "ui/gfx/image/image_skia.h"
#include "ui/gfx/skbitmap_operations.h"
#include "ui/gfx/skia_util.h"
namespace ui {
namespace {
// Converts the SkBitmap to use a different alpha type. Returns true if bitmap
// was modified, otherwise returns false.
bool ConvertSkBitmapAlphaType(SkBitmap* bitmap, SkAlphaType alpha_type) {
if (bitmap->info().alphaType() == alpha_type) {
return false;
}
// Copy the bitmap into a temporary buffer. This will convert alpha type.
SkImageInfo image_info =
SkImageInfo::MakeN32(bitmap->width(), bitmap->height(), alpha_type);
std::vector<char> buffer(bitmap->getSize());
bitmap->readPixels(image_info, &buffer[0], image_info.minRowBytes(), 0, 0);
// Read the temporary buffer back into the original bitmap.
bitmap->reset();
bitmap->allocPixels(image_info);
memcpy(bitmap->getPixels(), &buffer[0], buffer.size());
return true;
}
} // namespace
void ScaleAndRotateCursorBitmapAndHotpoint(float scale,
gfx::Display::Rotation rotation,
SkBitmap* bitmap,
gfx::Point* hotpoint) {
// SkBitmapOperations::Rotate() needs the bitmap to have premultiplied alpha,
// so convert bitmap alpha type if we are going to rotate.
bool was_converted = false;
if (rotation != gfx::Display::ROTATE_0 &&
bitmap->info().alphaType() == kUnpremul_SkAlphaType) {
ConvertSkBitmapAlphaType(bitmap, kPremul_SkAlphaType);
was_converted = true;
}
switch (rotation) {
case gfx::Display::ROTATE_0:
break;
case gfx::Display::ROTATE_90:
hotpoint->SetPoint(bitmap->height() - hotpoint->y(), hotpoint->x());
*bitmap = SkBitmapOperations::Rotate(
*bitmap, SkBitmapOperations::ROTATION_90_CW);
break;
case gfx::Display::ROTATE_180:
hotpoint->SetPoint(
bitmap->width() - hotpoint->x(), bitmap->height() - hotpoint->y());
*bitmap = SkBitmapOperations::Rotate(
*bitmap, SkBitmapOperations::ROTATION_180_CW);
break;
case gfx::Display::ROTATE_270:
hotpoint->SetPoint(hotpoint->y(), bitmap->width() - hotpoint->x());
*bitmap = SkBitmapOperations::Rotate(
*bitmap, SkBitmapOperations::ROTATION_270_CW);
break;
}
if (was_converted) {
ConvertSkBitmapAlphaType(bitmap, kUnpremul_SkAlphaType);
}
if (scale < FLT_EPSILON) {
NOTREACHED() << "Scale must be larger than 0.";
scale = 1.0f;
}
if (scale == 1.0f)
return;
gfx::Size scaled_size = gfx::ScaleToFlooredSize(
gfx::Size(bitmap->width(), bitmap->height()), scale);
*bitmap = skia::ImageOperations::Resize(
*bitmap,
skia::ImageOperations::RESIZE_BETTER,
scaled_size.width(),
scaled_size.height());
*hotpoint = gfx::ScaleToFlooredPoint(*hotpoint, scale);
}
void GetImageCursorBitmap(int resource_id,
float scale,
gfx::Display::Rotation rotation,
gfx::Point* hotspot,
SkBitmap* bitmap) {
const gfx::ImageSkia* image =
ResourceBundle::GetSharedInstance().GetImageSkiaNamed(resource_id);
const gfx::ImageSkiaRep& image_rep = image->GetRepresentation(scale);
// TODO(oshima): The cursor should use resource scale factor when
// fractional scale factor is enabled. crbug.com/372212
(*bitmap) = image_rep.sk_bitmap();
ScaleAndRotateCursorBitmapAndHotpoint(
scale / image_rep.scale(), rotation, bitmap, hotspot);
// |image_rep| is owned by the resource bundle. So we do not need to free it.
}
void GetAnimatedCursorBitmaps(int resource_id,
float scale,
gfx::Display::Rotation rotation,
gfx::Point* hotspot,
std::vector<SkBitmap>* bitmaps) {
// TODO(oshima|tdanderson): Support rotation and fractional scale factor.
const gfx::ImageSkia* image =
ResourceBundle::GetSharedInstance().GetImageSkiaNamed(resource_id);
const gfx::ImageSkiaRep& image_rep = image->GetRepresentation(scale);
SkBitmap bitmap = image_rep.sk_bitmap();
int frame_width = bitmap.height();
int frame_height = frame_width;
int total_width = bitmap.width();
DCHECK_EQ(total_width % frame_width, 0);
int frame_count = total_width / frame_width;
DCHECK_GT(frame_count, 0);
bitmaps->resize(frame_count);
for (int frame = 0; frame < frame_count; ++frame) {
int x_offset = frame_width * frame;
DCHECK_LE(x_offset + frame_width, total_width);
SkBitmap cropped = SkBitmapOperations::CreateTiledBitmap(
bitmap, x_offset, 0, frame_width, frame_height);
DCHECK_EQ(frame_width, cropped.width());
DCHECK_EQ(frame_height, cropped.height());
(*bitmaps)[frame] = cropped;
}
}
} // namespace ui
|
