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 "webkit/common/cursors/webcursor.h" 6 7 #include "base/logging.h" 8 #include "base/pickle.h" 9 #include "third_party/WebKit/public/platform/WebImage.h" 10 11 using WebKit::WebCursorInfo; 12 13 static const int kMaxCursorDimension = 1024; 14 15 WebCursor::WebCursor() 16 : type_(WebCursorInfo::TypePointer), 17 custom_scale_(1) { 18 #if defined(OS_WIN) 19 external_cursor_ = NULL; 20 #endif 21 InitPlatformData(); 22 } 23 24 WebCursor::WebCursor(const CursorInfo& cursor_info) 25 : type_(WebCursorInfo::TypePointer) { 26 #if defined(OS_WIN) 27 external_cursor_ = NULL; 28 #endif 29 InitPlatformData(); 30 InitFromCursorInfo(cursor_info); 31 } 32 33 WebCursor::~WebCursor() { 34 Clear(); 35 } 36 37 WebCursor::WebCursor(const WebCursor& other) { 38 InitPlatformData(); 39 Copy(other); 40 } 41 42 const WebCursor& WebCursor::operator=(const WebCursor& other) { 43 if (this == &other) 44 return *this; 45 46 Clear(); 47 Copy(other); 48 return *this; 49 } 50 51 void WebCursor::InitFromCursorInfo(const CursorInfo& cursor_info) { 52 Clear(); 53 54 #if defined(OS_WIN) 55 if (cursor_info.external_handle) { 56 InitFromExternalCursor(cursor_info.external_handle); 57 return; 58 } 59 #endif 60 61 type_ = cursor_info.type; 62 hotspot_ = cursor_info.hotspot; 63 if (IsCustom()) 64 SetCustomData(cursor_info.custom_image); 65 custom_scale_ = cursor_info.image_scale_factor; 66 CHECK(custom_scale_ > 0); 67 ClampHotspot(); 68 } 69 70 void WebCursor::GetCursorInfo(CursorInfo* cursor_info) const { 71 cursor_info->type = static_cast<WebCursorInfo::Type>(type_); 72 cursor_info->hotspot = hotspot_; 73 ImageFromCustomData(&cursor_info->custom_image); 74 cursor_info->image_scale_factor = custom_scale_; 75 76 #if defined(OS_WIN) 77 cursor_info->external_handle = external_cursor_; 78 #endif 79 } 80 81 bool WebCursor::Deserialize(PickleIterator* iter) { 82 int type, hotspot_x, hotspot_y, size_x, size_y, data_len; 83 float scale; 84 const char* data; 85 86 // Leave |this| unmodified unless we are going to return success. 87 if (!iter->ReadInt(&type) || 88 !iter->ReadInt(&hotspot_x) || 89 !iter->ReadInt(&hotspot_y) || 90 !iter->ReadLength(&size_x) || 91 !iter->ReadLength(&size_y) || 92 !iter->ReadFloat(&scale) || 93 !iter->ReadData(&data, &data_len)) 94 return false; 95 96 // Ensure the size is sane, and there is enough data. 97 if (size_x > kMaxCursorDimension || 98 size_y > kMaxCursorDimension) 99 return false; 100 101 // Ensure scale isn't ridiculous, and the scaled image size is still sane. 102 if (scale < 0.01 || scale > 100 || 103 size_x / scale > kMaxCursorDimension || 104 size_y / scale > kMaxCursorDimension) 105 return false; 106 107 type_ = type; 108 109 if (type == WebCursorInfo::TypeCustom) { 110 if (size_x > 0 && size_y > 0) { 111 // The * 4 is because the expected format is an array of RGBA pixel 112 // values. 113 if (size_x * size_y * 4 > data_len) 114 return false; 115 116 hotspot_.set_x(hotspot_x); 117 hotspot_.set_y(hotspot_y); 118 custom_size_.set_width(size_x); 119 custom_size_.set_height(size_y); 120 custom_scale_ = scale; 121 ClampHotspot(); 122 123 custom_data_.clear(); 124 if (data_len > 0) { 125 custom_data_.resize(data_len); 126 memcpy(&custom_data_[0], data, data_len); 127 } 128 } 129 } 130 return DeserializePlatformData(iter); 131 } 132 133 bool WebCursor::Serialize(Pickle* pickle) const { 134 if (!pickle->WriteInt(type_) || 135 !pickle->WriteInt(hotspot_.x()) || 136 !pickle->WriteInt(hotspot_.y()) || 137 !pickle->WriteInt(custom_size_.width()) || 138 !pickle->WriteInt(custom_size_.height()) || 139 !pickle->WriteFloat(custom_scale_)) 140 return false; 141 142 const char* data = NULL; 143 if (!custom_data_.empty()) 144 data = &custom_data_[0]; 145 if (!pickle->WriteData(data, custom_data_.size())) 146 return false; 147 148 return SerializePlatformData(pickle); 149 } 150 151 bool WebCursor::IsCustom() const { 152 return type_ == WebCursorInfo::TypeCustom; 153 } 154 155 bool WebCursor::IsEqual(const WebCursor& other) const { 156 if (type_ != other.type_) 157 return false; 158 159 if (!IsPlatformDataEqual(other)) 160 return false; 161 162 return hotspot_ == other.hotspot_ && 163 custom_size_ == other.custom_size_ && 164 custom_scale_ == other.custom_scale_ && 165 custom_data_ == other.custom_data_; 166 } 167 168 #if defined(OS_WIN) 169 170 static WebCursorInfo::Type ToCursorType(HCURSOR cursor) { 171 static struct { 172 HCURSOR cursor; 173 WebCursorInfo::Type type; 174 } kStandardCursors[] = { 175 { LoadCursor(NULL, IDC_ARROW), WebCursorInfo::TypePointer }, 176 { LoadCursor(NULL, IDC_CROSS), WebCursorInfo::TypeCross }, 177 { LoadCursor(NULL, IDC_HAND), WebCursorInfo::TypeHand }, 178 { LoadCursor(NULL, IDC_IBEAM), WebCursorInfo::TypeIBeam }, 179 { LoadCursor(NULL, IDC_WAIT), WebCursorInfo::TypeWait }, 180 { LoadCursor(NULL, IDC_HELP), WebCursorInfo::TypeHelp }, 181 { LoadCursor(NULL, IDC_SIZENESW), WebCursorInfo::TypeNorthEastResize }, 182 { LoadCursor(NULL, IDC_SIZENWSE), WebCursorInfo::TypeNorthWestResize }, 183 { LoadCursor(NULL, IDC_SIZENS), WebCursorInfo::TypeNorthSouthResize }, 184 { LoadCursor(NULL, IDC_SIZEWE), WebCursorInfo::TypeEastWestResize }, 185 { LoadCursor(NULL, IDC_SIZEALL), WebCursorInfo::TypeMove }, 186 { LoadCursor(NULL, IDC_APPSTARTING), WebCursorInfo::TypeProgress }, 187 { LoadCursor(NULL, IDC_NO), WebCursorInfo::TypeNotAllowed }, 188 }; 189 for (int i = 0; i < arraysize(kStandardCursors); ++i) { 190 if (cursor == kStandardCursors[i].cursor) 191 return kStandardCursors[i].type; 192 } 193 return WebCursorInfo::TypeCustom; 194 } 195 196 void WebCursor::InitFromExternalCursor(HCURSOR cursor) { 197 WebCursorInfo::Type cursor_type = ToCursorType(cursor); 198 199 InitFromCursorInfo(CursorInfo(cursor_type)); 200 201 if (cursor_type == WebCursorInfo::TypeCustom) 202 external_cursor_ = cursor; 203 } 204 205 #endif // defined(OS_WIN) 206 207 void WebCursor::Clear() { 208 type_ = WebCursorInfo::TypePointer; 209 hotspot_.set_x(0); 210 hotspot_.set_y(0); 211 custom_size_.set_width(0); 212 custom_size_.set_height(0); 213 custom_scale_ = 1; 214 custom_data_.clear(); 215 CleanupPlatformData(); 216 } 217 218 void WebCursor::Copy(const WebCursor& other) { 219 type_ = other.type_; 220 hotspot_ = other.hotspot_; 221 custom_size_ = other.custom_size_; 222 custom_scale_ = other.custom_scale_; 223 custom_data_ = other.custom_data_; 224 CopyPlatformData(other); 225 } 226 227 void WebCursor::SetCustomData(const SkBitmap& bitmap) { 228 if (bitmap.empty()) 229 return; 230 231 // Fill custom_data_ directly with the NativeImage pixels. 232 SkAutoLockPixels bitmap_lock(bitmap); 233 custom_data_.resize(bitmap.getSize()); 234 if (!custom_data_.empty()) 235 memcpy(&custom_data_[0], bitmap.getPixels(), bitmap.getSize()); 236 custom_size_.set_width(bitmap.width()); 237 custom_size_.set_height(bitmap.height()); 238 } 239 240 void WebCursor::ImageFromCustomData(SkBitmap* image) const { 241 if (custom_data_.empty()) 242 return; 243 244 image->setConfig(SkBitmap::kARGB_8888_Config, 245 custom_size_.width(), 246 custom_size_.height()); 247 if (!image->allocPixels()) 248 return; 249 memcpy(image->getPixels(), &custom_data_[0], custom_data_.size()); 250 } 251 252 void WebCursor::ClampHotspot() { 253 if (!IsCustom()) 254 return; 255 256 // Clamp the hotspot to the custom image's dimensions. 257 hotspot_.set_x(std::max(0, 258 std::min(custom_size_.width() - 1, hotspot_.x()))); 259 hotspot_.set_y(std::max(0, 260 std::min(custom_size_.height() - 1, hotspot_.y()))); 261 } 262
